From cbd481161f7342c8238e2147f45e6048ad32ff4b Mon Sep 17 00:00:00 2001
From: clover caruso <git@paperclover.net>
Date: Sun, 15 Feb 2026 22:02:48 -0800
Subject: [PATCH] chore: don't be stupid regarding marko tags

---
 examples/marko-run/src/md/example.mdo        |   1 -
 examples/marko-run/src/tags/photo-grid.marko |   2 +-
 src/lib.rs                                   | 128 +--
 src/marko.rs                                 | 963 +++++++------------
 src/marko_ast.rs                             | 230 +++++
 src/plugin/mod.rs                            |   2 +-
 src/plugin/statement.rs                      |  13 +-
 src/plugin/tags.rs                           | 109 +--
 src/plugin/toc.rs                            |   6 +-
 src/typescript.rs                            | 136 ++-
 tests/fixtures/23-outline-extracting.marko   |   3 +
 11 files changed, 735 insertions(+), 858 deletions(-)
 create mode 100644 src/marko_ast.rs

diff --git a/examples/marko-run/src/md/example.mdo b/examples/marko-run/src/md/example.mdo
index d7b658e89cfa8848ab3f7fbebf4937e80b8b97c7..52c8c2af67656b0afc78d7114d784a8ac81cfa96 100644
--- a/examples/marko-run/src/md/example.mdo
+++ b/examples/marko-run/src/md/example.mdo
@@ -28,7 +28,6 @@ a lot less brace hell for non-string attributes, and more treats!
   <@img src="IMG_4838.jpeg" w=2 />
   <@img src="IMG_4839.jpeg" w=2 align="top" />
   <@img src="IMG_4833.jpeg" h=2 />
-  <@img src="IMG_4832.jpeg" w=2 />
 </>
 
 ## in conclusion
diff --git a/examples/marko-run/src/tags/photo-grid.marko b/examples/marko-run/src/tags/photo-grid.marko
index 7d92d6c4cc66896ce88ec8db7d93eef068b6136c..fdbab98b76e27e3e2770e7db4dd8c276b98049df 100644
--- a/examples/marko-run/src/tags/photo-grid.marko
+++ b/examples/marko-run/src/tags/photo-grid.marko
@@ -46,7 +46,7 @@ export interface Input {
     "grid-template-rows": input.rows.map(row => `${row}px`).join(" "),
 }>
     <for|pos| of=computedPositions>
-        <const/itemStyle = `grid-column: ${pos.x + 1} / ${pos.x + 1 + pos.w}; grid-row: ${pos.y + 1} / ${pos.y + 1 + pos.h}; align-self: ${pos.align === "top" ? "start" : pos.align === "bottom" ? "end" : "center"};` />
+        <const/itemStyle = `grid-column: ${pos.x + 1} / ${pos.x + 1 + pos.w}; grid-row: ${pos.y + 1} / ${pos.y + 1 + pos.h};` />
         <const/hue = (pos.x + pos.y) * 37 % 360 />
         <const/bgColor = `hsl(${hue}, 65%, 75%)` />
         <div class="photo-grid-item" style=`${itemStyle} background: ${bgColor};` /> 
diff --git a/src/lib.rs b/src/lib.rs
index 0a8838413757c36cdf212fc1742b34630ec4bfdc..b9f2e4d4d3da77da648eccbbeec4ac0328543e2c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,10 +1,11 @@
 pub mod marko;
+pub mod marko_ast;
 pub mod plugin;
 pub mod typescript;
-
 pub mod wasm;
 
 use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
+use oxc_span::Span;
 use plugin::tags::{MarkoClose, MarkoOpen};
 use serde::Serialize;
 use serde_json;
@@ -94,7 +95,7 @@ pub fn transform(
     };
 
     // Extract statements before rendering - they need to be hoisted above Layout
-    let extracted_statements = extract_statements(&mut ast);
+    let extracted_statements = hoist_statements(&mut ast);
 
     let mut text = ast.render();
 
@@ -177,9 +178,9 @@ pub fn adjust_err(mut err: OxcDiagnostic, offset: isize) -> OxcDiagnostic {
     err
 }
 
-/// Extract all StatementBlock content from the AST and clear them.
-/// Returns the collected statement content as a single string.
-fn extract_statements(node: &mut markdown_it::Node) -> String {
+/// Extract `StatementBlock` contents from the AST, replacing them with an empty
+/// string so they render as nothing. Returns the statements hoisted.
+fn hoist_statements(node: &mut markdown_it::Node) -> String {
     let mut statements = String::new();
 
     fn walk(node: &mut markdown_it::Node, statements: &mut String) {
@@ -198,33 +199,15 @@ fn extract_statements(node: &mut markdown_it::Node) -> String {
 
 /// Check if the AST contains any Marko-specific features
 fn has_marko_features(node: &markdown_it::Node) -> bool {
-    // Check if this node is a RawBlock or StatementBlock
-    if node.cast::<plugin::RawBlock>().is_some() {
-        return true;
-    }
-    if node.cast::<plugin::StatementBlock>().is_some() {
-        return true;
-    }
-
-    // Check for Marko tags
-    if node.cast::<MarkoOpen>().is_some()
+    node.cast::<plugin::RawBlock>().is_some()
+        || node.cast::<plugin::StatementBlock>().is_some()
+        || node.cast::<MarkoOpen>().is_some()
         || node.cast::<MarkoClose>().is_some()
         || node.cast::<plugin::tags::MarkoSelfClosing>().is_some()
         || node.cast::<plugin::tags::MarkoOpenWithText>().is_some()
         || node.cast::<plugin::tags::MarkoInlineTag>().is_some()
         || node.cast::<plugin::tags::MarkoBlockComplete>().is_some()
-    {
-        return true;
-    }
-
-    // Recursively check children
-    for child in &node.children {
-        if has_marko_features(child) {
-            return true;
-        }
-    }
-
-    false
+        || node.children.iter().any(|child| has_marko_features(child))
 }
 
 /// Validate that Marko open/close tags are properly matched
@@ -233,68 +216,57 @@ fn validate_marko_tags(
     errors: &mut Vec<OxcDiagnostic>,
     preamble_offset: usize,
 ) {
-    #[derive(Debug)]
-    struct OpenTag {
-        name: String,
-        /// Byte offset of the tag name in the source (after '<')
-        name_start: usize,
-        /// Length of the tag name
-        name_len: usize,
-    }
-
-    let mut stack: Vec<OpenTag> = vec![];
+    // Stack of (tag_name, absolute_span_of_name)
+    let mut stack: Vec<(String, Span)> = vec![];
 
     fn walk(
         node: &markdown_it::Node,
-        stack: &mut Vec<OpenTag>,
+        stack: &mut Vec<(String, Span)>,
         errors: &mut Vec<OxcDiagnostic>,
-        offset: usize,
+        offset: u32,
     ) {
         if let Some(open) = node.cast::<MarkoOpen>() {
             let (start, _) = node.srcmap.unwrap().get_byte_offsets();
-            stack.push(OpenTag {
-                name: open.tag_name.clone(),
-                name_start: start + offset + 1, // +1 to skip '<'
-                name_len: open.tag_name_len,
-            });
+            let rel_span = open.open.as_ref().tag_name_span();
+            let abs_span = Span::new(
+                start as u32 + offset + rel_span.start,
+                start as u32 + offset + rel_span.end,
+            );
+            stack.push((open.open.as_ref().tag_name().to_owned(), abs_span));
         } else if let Some(open) = node.cast::<plugin::tags::MarkoOpenWithText>() {
             let (start, _) = node.srcmap.unwrap().get_byte_offsets();
-            stack.push(OpenTag {
-                name: open.tag_name.clone(),
-                name_start: start + offset + 1, // +1 to skip '<'
-                name_len: open.tag_name_len,
-            });
+            let rel_span = open.open.as_ref().tag_name_span();
+            let abs_span = Span::new(
+                start as u32 + offset + rel_span.start,
+                start as u32 + offset + rel_span.end,
+            );
+            stack.push((open.open.as_ref().tag_name().to_owned(), abs_span));
         } else if let Some(close) = node.cast::<MarkoClose>() {
             let (close_start, _) = node.srcmap.unwrap().get_byte_offsets();
+            let close_start = close_start as u32 + offset;
             // Close tag name starts after '</' (offset +2)
-            let close_name_start = close_start + offset + 2;
-            let close_name_len = close.tag_name_len.unwrap_or(0);
+            let close_span = close
+                .tag_name
+                .as_ref()
+                .map(|name| Span::new(close_start + 2, close_start + 2 + name.len() as u32));
 
             match (close.tag_name.as_ref(), stack.pop()) {
+                (Some(name), Some((top_name, _))) if name == &top_name => {
+                    // valid
+                }
                 (None, Some(_)) => {
                     // </> closes anything - valid
                 }
-                (Some(name), Some(top)) if name == &top.name => {
-                    // Exact match - valid
-                }
-                (Some(name), Some(top)) => {
-                    // Mismatched: expected </top.name>, got </name>
+                (Some(name), Some((top_name, top_span))) => {
+                    // Mismatched: expected </top_name>, got </name>
                     errors.push(
                         OxcDiagnostic::error(format!(
                             "Mismatched closing tag: expected </{}>, found </{}>",
-                            top.name, name
+                            top_name, name
                         ))
                         .with_labels(vec![
-                            LabeledSpan::new(
-                                Some("opened here".into()),
-                                top.name_start,
-                                top.name_len,
-                            ),
-                            LabeledSpan::new(
-                                Some("closed here".into()),
-                                close_name_start,
-                                close_name_len,
-                            ),
+                            top_span.label("opened here"),
+                            close_span.unwrap().label("closed here"),
                         ]),
                     );
                 }
@@ -304,18 +276,14 @@ fn validate_marko_tags(
                         OxcDiagnostic::error(format!(
                             "Closing tag </{name}> without matching open"
                         ))
-                        .with_label(LabeledSpan::new(
-                            None,
-                            close_name_start,
-                            close_name_len,
-                        )),
+                        .with_label(close_span.unwrap()),
                     );
                 }
                 (None, None) => {
                     // </> without any open tag - highlight the whole </>
                     errors.push(
                         OxcDiagnostic::error("Closing tag </> without matching open")
-                            .with_label(LabeledSpan::new(None, close_start + offset, 3)),
+                            .with_label(Span::new(close_start, close_start + 3)),
                     );
                 }
             }
@@ -327,18 +295,14 @@ fn validate_marko_tags(
         }
     }
 
-    walk(node, &mut stack, errors, preamble_offset);
+    walk(node, &mut stack, errors, preamble_offset as u32);
 
     // Check for unclosed tags
-    for unclosed in stack {
-        errors.push(
-            OxcDiagnostic::error(format!("Unclosed tag <{}>", unclosed.name)).with_label(
-                LabeledSpan::new(None, unclosed.name_start, unclosed.name_len),
-            ),
-        );
+    for (name, span) in stack {
+        errors.push(OxcDiagnostic::error(format!("Unclosed tag <{}>", name)).with_label(span));
     }
 }
 
-pub fn err<T: Into<Cow<'static, str>>>(str: T, offset: usize, length: usize) -> OxcDiagnostic {
-    OxcDiagnostic::error(str).and_label(LabeledSpan::new(None, offset, length))
+pub fn err<T: Into<Cow<'static, str>>>(str: T, offset: u32, length: usize) -> OxcDiagnostic {
+    OxcDiagnostic::error(str).and_label(LabeledSpan::new(None, offset as usize, length))
 }
diff --git a/src/marko.rs b/src/marko.rs
index 02e0dc3bc92ab37bd2cee78f657faf938898e7e7..c6cbfce2a2df80a84b0910d1d15c43295b6e2d16 100644
--- a/src/marko.rs
+++ b/src/marko.rs
@@ -1,74 +1,16 @@
-use std::{borrow::Cow, iter::Map};
-
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_span::Span;
+use serde_yml::libyml::tag;
 
 use crate::{
     err,
+    marko_ast::*,
     typescript::{
         parse_call_arguments, parse_expr, parse_expr_without_gt, parse_fn_params_and_body,
         parse_var_binding,
     },
 };
 
-#[derive(Debug, Clone, PartialEq)]
-pub struct Open<'a> {
-    pub tag_name: &'a str,
-    pub content: &'a str,
-    pub self_closing: bool,
-}
-
-impl<'a> Open<'a> {
-    /// Returns the span of the tag name relative to the start of the tag.
-    pub fn tag_name_span(&self) -> Span {
-        // fast case, when a literal tag name is passed
-        if !self.tag_name.is_empty() {
-            Span::new(1, 1 + (self.tag_name.len() as u32))
-        } else {
-            // slow path, re-parse the js expression. not that deep because you
-            // only do this in the error case. TODO: actually store `Open` in
-            // the md tree, the lifetimes are complicated rn
-            let mut l = LexState::new(self.content);
-            l.advance(3);
-            parse_expr(&mut l).expect("validated text should pass");
-            Span::new(3, l.offset() as u32)
-        }
-    }
-
-    pub fn id_attr(&self) -> Option<&'a str> {
-        todo!();
-    }
-
-    pub fn set_id_attr(&mut self, str: &'a str) {
-        todo!();
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Close<'a> {
-    pub tag_name: Option<&'a str>,
-    pub length: usize,
-}
-
-impl Close<'_> {
-    /// Returns the span of the tag name relative to the start of the tag.
-    /// For `</div>`, returns Span(2, 5) pointing to "div".
-    /// For `</>`, returns None.
-    pub fn tag_name_span(&self) -> Option<Span> {
-        self.tag_name.map(|name| {
-            // Close tag starts with '</', so tag name starts at offset 2
-            let start = 2u32;
-            let end = start + (name.len() as u32);
-            Span::new(start, end)
-        })
-    }
-}
-
-pub enum OpenOrClose<'a> {
-    Open(Open<'a>),
-    Close(Close<'a>),
-}
-
 pub fn parse_tag(src: &str) -> Result<OpenOrClose, OxcDiagnostic> {
     assert_eq!(src.as_bytes()[0], b'<');
     if src.starts_with("</") {
@@ -78,66 +20,6 @@ pub fn parse_tag(src: &str) -> Result<OpenOrClose, OxcDiagnostic> {
     }
 }
 
-pub struct LexState<'a> {
-    pub src: &'a str,
-    pub offset: usize,
-}
-
-impl<'a> LexState<'a> {
-    pub fn new(src: &'a str) -> LexState<'a> {
-        LexState { src, offset: 0 }
-    }
-
-    pub fn offset(&self) -> usize {
-        self.offset
-    }
-
-    pub fn advance(&mut self, n: usize) {
-        self.offset += n;
-    }
-
-    pub fn restore(&mut self, n: usize) {
-        self.offset = n;
-    }
-
-    pub fn peek_byte(&self) -> Option<u8> {
-        self.src.as_bytes().get(self.offset).copied()
-    }
-
-    pub fn peek_rest(&self) -> &'a str {
-        &self.src[self.offset..]
-    }
-
-    pub fn expect_byte(&mut self) -> Result<u8, OxcDiagnostic> {
-        if let Some(b) = self.peek_byte() {
-            self.offset += 1;
-            return Ok(b);
-        }
-        Err(err("Unexpected end of file", self.offset, 1))
-    }
-
-    pub fn expect(&mut self, expected: &str) -> Result<(), OxcDiagnostic> {
-        if self.src[self.offset..].starts_with(expected) {
-            self.offset += expected.len();
-            Ok(())
-        } else {
-            Err(err(format!("Expected {expected}"), self.offset, 1))
-        }
-    }
-
-    pub fn skip_whitespace(&mut self) {
-        loop {
-            match self.peek_byte() {
-                Some(byte) => match byte {
-                    b' ' | b'\n' | b'\t' | b'\r' => self.offset += 1,
-                    _ => break,
-                },
-                None => break,
-            }
-        }
-    }
-}
-
 pub fn parse_open(src: &str) -> Result<Open, OxcDiagnostic> {
     assert!(src.starts_with("<"));
     let mut l = LexState { src, offset: 1 };
@@ -145,21 +27,33 @@ pub fn parse_open(src: &str) -> Result<Open, OxcDiagnostic> {
     let is_attribute_tag = tag_name.starts_with('@');
 
     // class and id shorthand
-    let mut has_id = false;
+    let mut id_attr = AttributeValue::None;
     while let Some(byte @ b'#' | byte @ b'.') = l.peek_byte() {
-        let offset = l.offset;
+        let id_start = l.offset;
         l.advance(1);
         let name = parse_class_name_shorthand(&mut l, byte == b'#')?;
-        _ = name;
+        let id_end = l.offset;
 
         if byte == b'#' {
-            if has_id {
-                return Err(err("Cannot specify two ID shorthands", offset, name.len()));
+            if !matches!(id_attr, AttributeValue::None) {
+                return Err(err("Cannot specify two IDs", id_start, name.len()));
+            }
+
+            // Check if the shorthand contains ${} (dynamic)
+            if name.contains("${") {
+                id_attr = AttributeValue::Dynamic;
+            } else {
+                id_attr = AttributeValue::Static {
+                    span: Span::new(id_start + 1, id_end),
+                    is_quoted: false,
+                };
             }
-            has_id = true;
         }
     }
 
+    // Track where shorthands end (for inserting new #id if needed)
+    let shorthand_end = l.offset;
+
     // in any order: parameters, arguments, variable
     let mut has_js_arguments = false;
     let mut has_js_params = false;
@@ -239,14 +133,14 @@ pub fn parse_open(src: &str) -> Result<Open, OxcDiagnostic> {
             return Err(err(
                 "Attribute tags do not support variables",
                 offset,
-                l.offset - offset,
+                (l.offset - offset) as usize,
             ));
         }
         if is_attribute_tag && byte == b'(' {
             return Err(err(
                 "Attribute tags do not support arguments",
                 offset,
-                l.offset - offset,
+                (l.offset - offset) as usize,
             ));
         }
     }
@@ -274,8 +168,36 @@ pub fn parse_open(src: &str) -> Result<Open, OxcDiagnostic> {
                         self_closing = true;
                         break;
                     }
-                    parse_attribute(&mut l)?;
-                    l.skip_whitespace();
+                    // Check for id= attribute (only if we don't already have an id)
+                    if l.peek_rest().starts_with("id=") {
+                        if !matches!(id_attr, AttributeValue::None) {
+                            return Err(err(
+                                "Cannot combine the 'id' attribute with ID shorthand",
+                                l.offset(),
+                                3,
+                            ));
+                        }
+
+                        l.advance(3); // skip "id="
+                        l.skip_whitespace();
+                        let value_start = l.offset;
+                        let first_byte = l.peek_byte();
+                        parse_expr_without_gt(&mut l)?;
+                        let value_end = l.offset;
+                        l.skip_whitespace();
+
+                        if first_byte == Some(b'"') || first_byte == Some(b'\'') {
+                            id_attr = AttributeValue::Static {
+                                span: Span::new(value_start, value_end),
+                                is_quoted: true,
+                            };
+                        } else {
+                            id_attr = AttributeValue::Dynamic;
+                        }
+                    } else {
+                        parse_attribute(&mut l)?;
+                        l.skip_whitespace();
+                    }
                 }
             }
         }
@@ -287,11 +209,13 @@ pub fn parse_open(src: &str) -> Result<Open, OxcDiagnostic> {
         }
     }
 
-    Ok(Open {
-        tag_name,
-        content: &src[0..l.offset],
+    Ok(Open::new(
+        &src[0..l.offset as usize],
+        Span::new(1, (tag_name.len() + 1) as u32),
         self_closing,
-    })
+        shorthand_end,
+        id_attr,
+    ))
 }
 
 pub fn parse_close(src: &str) -> Result<Close, OxcDiagnostic> {
@@ -329,7 +253,7 @@ fn parse_tag_name<'a>(l: &mut LexState<'a>) -> Result<&'a str, OxcDiagnostic> {
             _ => break,
         }
     }
-    let tag_name = &l.src[start..l.offset];
+    let tag_name = &l.src[start as usize..l.offset as usize];
     if !tag_name.is_empty() {
         Ok(tag_name)
     } else {
@@ -345,7 +269,7 @@ fn parse_attr_name<'a>(l: &mut LexState<'a>) -> Result<&'a str, OxcDiagnostic> {
             _ => break,
         }
     }
-    let tag_name = &l.src[start..l.offset];
+    let tag_name = &l.src[start as usize..l.offset as usize];
     if !tag_name.is_empty() {
         Ok(tag_name)
     } else {
@@ -408,7 +332,7 @@ fn parse_class_name_shorthand<'a>(
             _ => l.offset += 1,
         }
     }
-    let tag_name = &l.src[start..l.offset];
+    let tag_name = &l.src[start as usize..l.offset as usize];
     if !tag_name.is_empty() {
         Ok(tag_name)
     } else {
@@ -428,133 +352,73 @@ fn parse_class_name_shorthand<'a>(
 mod tests {
     use super::*;
 
+    /// Helper to check basic Open properties without worrying about id_info/shorthand_end
+    fn check_open(src: &str, tag_name: &str, content: &str, self_closing: bool) {
+        let open = parse_open(src).unwrap();
+        assert_eq!(open.tag_name(), tag_name, "tag_name mismatch for {src}");
+        assert_eq!(open.src, content, "content mismatch for {src}");
+        assert_eq!(
+            open.self_closing, self_closing,
+            "self_closing mismatch for {src}"
+        );
+    }
+
     #[test]
     fn test_open_basic() {
-        assert_eq!(
-            parse_open("<div>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div>",
-                self_closing: false,
-            })
+        check_open("<div>", "div", "<div>", false);
+        check_open(
+            "<footer#id.class meow=purr yolo=4.2 /> etfdas",
+            "footer",
+            "<footer#id.class meow=purr yolo=4.2 />",
+            true,
         );
-        assert_eq!(
-            parse_open("<footer#id.class meow=purr yolo=4.2 /> etfdas"),
-            Ok(Open {
-                tag_name: "footer",
-                content: "<footer#id.class meow=purr yolo=4.2 />",
-                self_closing: true,
-            })
-        );
-        assert_eq!(
-            parse_open("<movie value=x > 4 /> etfdas"),
-            Ok(Open {
-                tag_name: "movie",
-                content: "<movie value=x >",
-                self_closing: false,
-            })
+        check_open(
+            "<movie value=x > 4 /> etfdas",
+            "movie",
+            "<movie value=x >",
+            false,
         );
     }
 
     #[test]
     fn test_open_id() {
-        assert_eq!(
-            parse_open("<h2#technical-review>A Technical Review"),
-            Ok(Open {
-                tag_name: "h2",
-                content: "<h2#technical-review>",
-                self_closing: false,
-            })
+        check_open(
+            "<h2#technical-review>A Technical Review",
+            "h2",
+            "<h2#technical-review>",
+            false,
         );
-        assert_eq!(
-            parse_open("<footer#id.class meow=purr yolo=4.2 /> etfdas"),
-            Ok(Open {
-                tag_name: "footer",
-                content: "<footer#id.class meow=purr yolo=4.2 />",
-                self_closing: true,
-            })
+        check_open(
+            "<footer#id.class meow=purr yolo=4.2 /> etfdas",
+            "footer",
+            "<footer#id.class meow=purr yolo=4.2 />",
+            true,
         );
-        assert_eq!(
-            parse_open("<movie value=x > 4 /> etfdas"),
-            Ok(Open {
-                tag_name: "movie",
-                content: "<movie value=x >",
-                self_closing: false,
-            })
+        check_open(
+            "<movie value=x > 4 /> etfdas",
+            "movie",
+            "<movie value=x >",
+            false,
         );
     }
 
     #[test]
     fn test_open_self_closing_with_space() {
-        // Self-closing with space before /> works
-        assert_eq!(
-            parse_open("<input />"),
-            Ok(Open {
-                tag_name: "input",
-                content: "<input />",
-                self_closing: true,
-            })
-        );
+        check_open("<input />", "input", "<input />", true);
     }
 
     #[test]
     fn test_open_self_closing_no_space() {
-        assert_eq!(
-            parse_open("<br/>"),
-            Ok(Open {
-                tag_name: "br",
-                content: "<br/>",
-                self_closing: true,
-            })
-        );
-        assert_eq!(
-            parse_open("<my-component/>"),
-            Ok(Open {
-                tag_name: "my-component",
-                content: "<my-component/>",
-                self_closing: true,
-            })
-        );
+        check_open("<br/>", "br", "<br/>", true);
+        check_open("<my-component/>", "my-component", "<my-component/>", true);
     }
 
     #[test]
     fn test_open_tag_names() {
-        // kebab-case
-        assert_eq!(
-            parse_open("<my-custom-tag>"),
-            Ok(Open {
-                tag_name: "my-custom-tag",
-                content: "<my-custom-tag>",
-                self_closing: false,
-            })
-        );
-        // PascalCase (for custom tags referencing imports)
-        assert_eq!(
-            parse_open("<MyComponent>"),
-            Ok(Open {
-                tag_name: "MyComponent",
-                content: "<MyComponent>",
-                self_closing: false,
-            })
-        );
-        // with underscore
-        assert_eq!(
-            parse_open("<my_tag>"),
-            Ok(Open {
-                tag_name: "my_tag",
-                content: "<my_tag>",
-                self_closing: false,
-            })
-        );
-        // with $ (valid in Marko)
-        assert_eq!(
-            parse_open("<$tag>"),
-            Ok(Open {
-                tag_name: "$tag",
-                content: "<$tag>",
-                self_closing: false,
-            })
-        );
+        check_open("<my-custom-tag>", "my-custom-tag", "<my-custom-tag>", false);
+        check_open("<MyComponent>", "MyComponent", "<MyComponent>", false);
+        check_open("<my_tag>", "my_tag", "<my_tag>", false);
+        check_open("<$tag>", "$tag", "<$tag>", false);
     }
 
     #[test]
@@ -602,53 +466,32 @@ mod tests {
 
     #[test]
     fn test_attribute_tag_basic_open() {
-        // @attr tag without self-closing works
-        assert_eq!(
-            parse_open("<@header>"),
-            Ok(Open {
-                tag_name: "@header",
-                content: "<@header>",
-                self_closing: false,
-            })
-        );
+        check_open("<@header>", "@header", "<@header>", false);
     }
 
     #[test]
     fn test_attribute_tag_self_closing() {
-        assert_eq!(
-            parse_open("<@item/>"),
-            Ok(Open {
-                tag_name: "@item",
-                content: "<@item/>",
-                self_closing: true,
-            })
-        );
+        check_open("<@item/>", "@item", "<@item/>", true);
     }
 
     #[test]
     fn test_attribute_tag_with_string_attr() {
-        assert_eq!(
-            parse_open("<@option value=\"foo\">"),
-            Ok(Open {
-                tag_name: "@option",
-                content: "<@option value=\"foo\">",
-                self_closing: false,
-            })
+        check_open(
+            "<@option value=\"foo\">",
+            "@option",
+            "<@option value=\"foo\">",
+            false,
         );
     }
 
     #[test]
     fn test_attribute_tag_no_variable() {
-        // Attribute tags do not support tag variables - correctly errors
-        let result = parse_open("<@header/myVar>");
-        assert!(result.is_err());
+        assert!(parse_open("<@header/myVar>").is_err());
     }
 
     #[test]
     fn test_attribute_tag_no_arguments() {
-        // Attribute tags do not support tag arguments - correctly errors
-        let result = parse_open("<@header(arg)>");
-        assert!(result.is_err());
+        assert!(parse_open("<@header(arg)>").is_err());
     }
 
     // ===========================================
@@ -657,97 +500,47 @@ mod tests {
 
     #[test]
     fn test_shorthand_id() {
-        assert_eq!(
-            parse_open("<div#myId>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div#myId>",
-                self_closing: false,
-            })
-        );
+        check_open("<div#myId>", "div", "<div#myId>", false);
     }
 
     #[test]
     fn test_shorthand_class() {
-        assert_eq!(
-            parse_open("<div.myClass>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div.myClass>",
-                self_closing: false,
-            })
-        );
+        check_open("<div.myClass>", "div", "<div.myClass>", false);
     }
 
     #[test]
     fn test_shorthand_multiple_classes() {
-        assert_eq!(
-            parse_open("<div.cls1.cls2.cls3>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div.cls1.cls2.cls3>",
-                self_closing: false,
-            })
-        );
+        check_open("<div.cls1.cls2.cls3>", "div", "<div.cls1.cls2.cls3>", false);
     }
 
     #[test]
     fn test_shorthand_id_and_classes() {
-        assert_eq!(
-            parse_open("<div#myId.cls1.cls2>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div#myId.cls1.cls2>",
-                self_closing: false,
-            })
-        );
+        check_open("<div#myId.cls1.cls2>", "div", "<div#myId.cls1.cls2>", false);
     }
 
     #[test]
     fn test_shorthand_classes_then_id() {
-        // Order shouldn't matter
-        assert_eq!(
-            parse_open("<div.cls1#myId.cls2>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div.cls1#myId.cls2>",
-                self_closing: false,
-            })
-        );
+        check_open("<div.cls1#myId.cls2>", "div", "<div.cls1#myId.cls2>", false);
     }
 
     #[test]
     fn test_shorthand_duplicate_id_error() {
-        // Cannot have two ID shorthands - correctly errors
-        let result = parse_open("<div#id1#id2>");
-        assert!(result.is_err());
+        assert!(parse_open("<div#id1#id2>").is_err());
     }
 
     #[test]
     fn test_shorthand_with_hyphen() {
-        // Classes/IDs can contain hyphens
-        assert_eq!(
-            parse_open("<div.my-class#my-id>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div.my-class#my-id>",
-                self_closing: false,
-            })
-        );
+        check_open("<div.my-class#my-id>", "div", "<div.my-class#my-id>", false);
     }
 
     #[test]
     fn test_shorthand_empty_class_error() {
-        // Empty class correctly errors
-        let result = parse_open("<div.>");
-        assert!(result.is_err());
+        assert!(parse_open("<div.>").is_err());
     }
 
     #[test]
     fn test_shorthand_empty_id_error() {
-        // Empty id correctly errors
-        let result = parse_open("<div#>");
-        assert!(result.is_err());
+        assert!(parse_open("<div#>").is_err());
     }
 
     // ===========================================
@@ -756,475 +549,309 @@ mod tests {
 
     #[test]
     fn test_tag_variable_simple() {
-        assert_eq!(
-            parse_open("<my-tag/foo>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag/foo>",
-                self_closing: false,
-            })
-        );
+        check_open("<my-tag/foo>", "my-tag", "<my-tag/foo>", false);
     }
 
-    // BUG: Variable binding followed by /> fails
     #[test]
     fn test_tag_variable_self_closing() {
-        assert_eq!(
-            parse_open("<input/myInput/>"),
-            Ok(Open {
-                tag_name: "input",
-                content: "<input/myInput/>",
-                self_closing: true,
-            })
-        );
+        check_open("<input/myInput/>", "input", "<input/myInput/>", true);
     }
 
     #[test]
     fn test_tag_variable_destructure_object() {
-        assert_eq!(
-            parse_open("<my-tag/{ a, b }>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag/{ a, b }>",
-                self_closing: false,
-            })
-        );
+        check_open("<my-tag/{ a, b }>", "my-tag", "<my-tag/{ a, b }>", false);
     }
 
     #[test]
     fn test_tag_variable_destructure_array() {
-        assert_eq!(
-            parse_open("<my-tag/[x, y]>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag/[x, y]>",
-                self_closing: false,
-            })
-        );
+        check_open("<my-tag/[x, y]>", "my-tag", "<my-tag/[x, y]>", false);
     }
 
     #[test]
     fn test_tag_variable_with_type() {
-        assert_eq!(
-            parse_open("<const/items: Item[]>"),
-            Ok(Open {
-                tag_name: "const",
-                content: "<const/items: Item[]>",
-                self_closing: false,
-            })
+        check_open(
+            "<const/items: Item[]>",
+            "const",
+            "<const/items: Item[]>",
+            false,
         );
     }
 
     #[test]
     fn test_tag_variable_with_attrs() {
-        assert_eq!(
-            parse_open("<my-tag/result value=42>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag/result value=42>",
-                self_closing: false,
-            })
+        check_open(
+            "<my-tag/result value=42>",
+            "my-tag",
+            "<my-tag/result value=42>",
+            false,
         );
     }
 
     // ===========================================
     // Tag arguments (args)
-    // BUG: Tag arguments without whitespace before ( fail
-    // The parser only enters argument parsing after skip_whitespace,
-    // but <tag()> has no whitespace before (
     // ===========================================
 
     #[test]
     fn test_tag_arguments_empty() {
-        assert_eq!(
-            parse_open("<my-tag()>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag()>",
-                self_closing: false,
-            })
-        );
+        check_open("<my-tag()>", "my-tag", "<my-tag()>", false);
     }
 
     #[test]
     fn test_tag_arguments_simple() {
-        assert_eq!(
-            parse_open("<my-tag(1, 2, 3)>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag(1, 2, 3)>",
-                self_closing: false,
-            })
-        );
+        check_open("<my-tag(1, 2, 3)>", "my-tag", "<my-tag(1, 2, 3)>", false);
     }
 
     #[test]
     fn test_tag_arguments_expressions() {
-        assert_eq!(
-            parse_open("<my-tag(a + b, fn())>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag(a + b, fn())>",
-                self_closing: false,
-            })
+        check_open(
+            "<my-tag(a + b, fn())>",
+            "my-tag",
+            "<my-tag(a + b, fn())>",
+            false,
         );
     }
 
     #[test]
     fn test_tag_arguments_spread() {
-        assert_eq!(
-            parse_open("<my-tag(...args)>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag(...args)>",
-                self_closing: false,
-            })
-        );
+        check_open("<my-tag(...args)>", "my-tag", "<my-tag(...args)>", false);
     }
 
     #[test]
     fn test_tag_arguments_object() {
-        assert_eq!(
-            parse_open("<my-tag({ a: 1, b: 2 })>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag({ a: 1, b: 2 })>",
-                self_closing: false,
-            })
+        check_open(
+            "<my-tag({ a: 1, b: 2 })>",
+            "my-tag",
+            "<my-tag({ a: 1, b: 2 })>",
+            false,
         );
     }
 
-    // Test that tag arguments WITH whitespace work
     #[test]
     fn test_tag_arguments_with_space() {
-        assert_eq!(
-            parse_open("<my-tag (1, 2, 3)>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag (1, 2, 3)>",
-                self_closing: false,
-            })
-        );
+        check_open("<my-tag (1, 2, 3)>", "my-tag", "<my-tag (1, 2, 3)>", false);
     }
 
     // ===========================================
     // Attributes
     // ===========================================
 
-    // BUG: String literals fail - expression parser doesn't terminate at > after string
     #[test]
     fn test_attr_simple_string() {
-        assert_eq!(
-            parse_open("<div class=\"foo\">"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div class=\"foo\">",
-                self_closing: false,
-            })
-        );
+        check_open("<div class=\"foo\">", "div", "<div class=\"foo\">", false);
     }
 
     #[test]
     fn test_attr_expression() {
-        // Identifier expressions work
-        assert_eq!(
-            parse_open("<div count=1 + 1>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div count=1 + 1>",
-                self_closing: false,
-            })
-        );
+        check_open("<div count=1 + 1>", "div", "<div count=1 + 1>", false);
     }
 
-    // BUG: Template literals fail
     #[test]
     fn test_attr_template_literal() {
-        assert_eq!(
-            parse_open("<div class=`hello ${name}`>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div class=`hello ${name}`>",
-                self_closing: false,
-            })
+        check_open(
+            "<div class=`hello ${name}`>",
+            "div",
+            "<div class=`hello ${name}`>",
+            false,
         );
     }
 
     #[test]
     fn test_attr_spread() {
-        assert_eq!(
-            parse_open("<div ...props>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div ...props>",
-                self_closing: false,
-            })
-        );
+        check_open("<div ...props>", "div", "<div ...props>", false);
     }
 
-    // BUG: Object literals with > in them fail
     #[test]
     fn test_attr_spread_object() {
-        assert_eq!(
-            parse_open("<div ...{ a: 1, b: 2 }>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div ...{ a: 1, b: 2 }>",
-                self_closing: false,
-            })
+        check_open(
+            "<div ...{ a: 1, b: 2 }>",
+            "div",
+            "<div ...{ a: 1, b: 2 }>",
+            false,
         );
     }
 
-    // BUG: Multiple attributes with string values fail
     #[test]
     fn test_attr_multiple_spreads() {
-        assert_eq!(
-            parse_open("<div ...a ...b foo=\"bar\">"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div ...a ...b foo=\"bar\">",
-                self_closing: false,
-            })
+        check_open(
+            "<div ...a ...b foo=\"bar\">",
+            "div",
+            "<div ...a ...b foo=\"bar\">",
+            false,
         );
     }
 
     #[test]
     fn test_attr_two_way_binding() {
-        assert_eq!(
-            parse_open("<counter value:=count>"),
-            Ok(Open {
-                tag_name: "counter",
-                content: "<counter value:=count>",
-                self_closing: false,
-            })
+        check_open(
+            "<counter value:=count>",
+            "counter",
+            "<counter value:=count>",
+            false,
         );
     }
 
     #[test]
     fn test_attr_two_way_binding_property() {
-        assert_eq!(
-            parse_open("<counter value:=input.count>"),
-            Ok(Open {
-                tag_name: "counter",
-                content: "<counter value:=input.count>",
-                self_closing: false,
-            })
+        check_open(
+            "<counter value:=input.count>",
+            "counter",
+            "<counter value:=input.count>",
+            false,
         );
     }
 
     #[test]
     fn test_attr_method_shorthand() {
-        assert_eq!(
-            parse_open("<button onClick(e) { console.log(e) }>"),
-            Ok(Open {
-                tag_name: "button",
-                content: "<button onClick(e) { console.log(e) }>",
-                self_closing: false,
-            })
+        check_open(
+            "<button onClick(e) { console.log(e) }>",
+            "button",
+            "<button onClick(e) { console.log(e) }>",
+            false,
         );
     }
 
     #[test]
     fn test_attr_method_with_return_type() {
-        assert_eq!(
-            parse_open("<button onClick(e): void { console.log(e) }>"),
-            Ok(Open {
-                tag_name: "button",
-                content: "<button onClick(e): void { console.log(e) }>",
-                self_closing: false,
-            })
+        check_open(
+            "<button onClick(e): void { console.log(e) }>",
+            "button",
+            "<button onClick(e): void { console.log(e) }>",
+            false,
         );
     }
 
     #[test]
     fn test_attr_boolean() {
-        assert_eq!(
-            parse_open("<input type=\"checkbox\" checked>"),
-            Ok(Open {
-                tag_name: "input",
-                content: "<input type=\"checkbox\" checked>",
-                self_closing: false,
-            })
+        check_open(
+            "<input type=\"checkbox\" checked>",
+            "input",
+            "<input type=\"checkbox\" checked>",
+            false,
         );
     }
 
     #[test]
     fn test_attr_boolean_then_attr() {
-        assert_eq!(
-            parse_open("<input checked foo=1>"),
-            Ok(Open {
-                tag_name: "input",
-                content: "<input checked foo=1>",
-                self_closing: false,
-            })
+        check_open(
+            "<input checked foo=1>",
+            "input",
+            "<input checked foo=1>",
+            false,
         );
     }
 
     #[test]
     fn test_attr_with_colon() {
-        assert_eq!(
-            parse_open("<div data:value=\"test\">"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div data:value=\"test\">",
-                self_closing: false,
-            })
+        check_open(
+            "<div data:value=\"test\">",
+            "div",
+            "<div data:value=\"test\">",
+            false,
         );
     }
 
     #[test]
     fn test_shorthand_value() {
-        assert_eq!(
-            parse_open("<my-tag=1>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag=1>",
-                self_closing: false,
-            })
-        );
+        check_open("<my-tag=1>", "my-tag", "<my-tag=1>", false);
     }
 
     #[test]
     fn test_shorthand_value_expression() {
-        assert_eq!(
-            parse_open("<my-tag=a + b>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag=a + b>",
-                self_closing: false,
-            })
-        );
+        check_open("<my-tag=a + b>", "my-tag", "<my-tag=a + b>", false);
     }
 
     #[test]
     fn test_shorthand_value_with_other_attrs() {
-        assert_eq!(
-            parse_open("<my-tag=42 foo=\"bar\">"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag=42 foo=\"bar\">",
-                self_closing: false,
-            })
+        check_open(
+            "<my-tag=42 foo=\"bar\">",
+            "my-tag",
+            "<my-tag=42 foo=\"bar\">",
+            false,
         );
     }
 
     #[test]
     fn test_value_method_shorthand() {
-        assert_eq!(
-            parse_open("<my-tag() { console.log(\"hi\") }>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag() { console.log(\"hi\") }>",
-                self_closing: false,
-            })
+        check_open(
+            "<my-tag() { console.log(\"hi\") }>",
+            "my-tag",
+            "<my-tag() { console.log(\"hi\") }>",
+            false,
         );
     }
 
     #[test]
     fn test_value_method_shorthand_self_closing() {
-        assert_eq!(
-            parse_open("<my-tag() { console.log(\"hi\") }/>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag() { console.log(\"hi\") }/>",
-                self_closing: true,
-            })
+        check_open(
+            "<my-tag() { console.log(\"hi\") }/>",
+            "my-tag",
+            "<my-tag() { console.log(\"hi\") }/>",
+            true,
         );
     }
 
     #[test]
     fn test_value_method_shorthand_with_param() {
-        assert_eq!(
-            parse_open("<my-tag(e) { console.log(e) }>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag(e) { console.log(e) }>",
-                self_closing: false,
-            })
+        check_open(
+            "<my-tag(e) { console.log(e) }>",
+            "my-tag",
+            "<my-tag(e) { console.log(e) }>",
+            false,
         );
     }
 
     #[test]
     fn test_combined_variable_and_args() {
-        assert_eq!(
-            parse_open("<for/item (items)>"),
-            Ok(Open {
-                tag_name: "for",
-                content: "<for/item (items)>",
-                self_closing: false,
-            })
-        );
+        check_open("<for/item (items)>", "for", "<for/item (items)>", false);
     }
 
     #[test]
     fn test_combined_id_class_variable() {
-        assert_eq!(
-            parse_open("<div#myId.cls/ref>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div#myId.cls/ref>",
-                self_closing: false,
-            })
-        );
+        check_open("<div#myId.cls/ref>", "div", "<div#myId.cls/ref>", false);
     }
 
     #[test]
     fn test_combined_complex() {
-        assert_eq!(
-            parse_open("<my-tag#id.cls/result|arg1, arg2| foo=bar ...spread>"),
-            Ok(Open {
-                tag_name: "my-tag",
-                content: "<my-tag#id.cls/result|arg1, arg2| foo=bar ...spread>",
-                self_closing: false,
-            })
+        check_open(
+            "<my-tag#id.cls/result|arg1, arg2| foo=bar ...spread>",
+            "my-tag",
+            "<my-tag#id.cls/result|arg1, arg2| foo=bar ...spread>",
+            false,
         );
     }
 
     #[test]
     fn test_attr_with_gt_in_parens() {
-        assert_eq!(
-            parse_open("<div value=(a > b)>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div value=(a > b)>",
-                self_closing: false,
-            })
-        );
+        check_open("<div value=(a > b)>", "div", "<div value=(a > b)>", false);
     }
 
     #[test]
     fn test_attr_with_gt_in_brackets() {
-        assert_eq!(
-            parse_open("<div value=arr[a > 0]>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div value=arr[a > 0]>",
-                self_closing: false,
-            })
+        check_open(
+            "<div value=arr[a > 0]>",
+            "div",
+            "<div value=arr[a > 0]>",
+            false,
         );
     }
 
     #[test]
     fn test_attr_arrow_function() {
-        assert_eq!(
-            parse_open("<div onClick=() => console.log(1)>"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div onClick=() => console.log(1)>",
-                self_closing: false,
-            })
+        check_open(
+            "<div onClick=() => console.log(1)>",
+            "div",
+            "<div onClick=() => console.log(1)>",
+            false,
         );
     }
 
     #[test]
     fn test_attr_ternary() {
-        assert_eq!(
-            parse_open("<div class=isActive ? a : b> > > > >"),
-            Ok(Open {
-                tag_name: "div",
-                content: "<div class=isActive ? a : b>",
-                self_closing: false,
-            })
+        check_open(
+            "<div class=isActive ? a : b> > > > >",
+            "div",
+            "<div class=isActive ? a : b>",
+            false,
         );
     }
 
@@ -1251,7 +878,7 @@ mod tests {
         let result = parse_tag("<div>").unwrap();
         match result {
             OpenOrClose::Open(open) => {
-                assert_eq!(open.tag_name, "div");
+                assert_eq!(open.tag_name(), "div");
             }
             OpenOrClose::Close(_) => panic!("Expected Open"),
         }
@@ -1360,7 +987,7 @@ mod tests {
         let result = parse_open("<div.color-${iconName}/>");
         assert!(result.is_ok());
         let open = result.unwrap();
-        assert_eq!(open.content, "<div.color-${iconName}/>");
+        assert_eq!(open.src, "<div.color-${iconName}/>");
     }
 
     #[test]
@@ -1368,7 +995,7 @@ mod tests {
         let result = parse_open("<div#${myId}>");
         assert!(result.is_ok());
         let open = result.unwrap();
-        assert_eq!(open.content, "<div#${myId}>");
+        assert_eq!(open.src, "<div#${myId}>");
     }
 
     #[test]
@@ -1376,7 +1003,7 @@ mod tests {
         let result = parse_open("<button.variant-${meow}#${id}>");
         assert!(result.is_ok());
         let open = result.unwrap();
-        assert_eq!(open.content, "<button.variant-${meow}#${id}>");
+        assert_eq!(open.src, "<button.variant-${meow}#${id}>");
     }
 
     #[test]
@@ -1384,7 +1011,7 @@ mod tests {
         let result = parse_open("<div.class1.${dynamic}.class3>");
         assert!(result.is_ok());
         let open = result.unwrap();
-        assert_eq!(open.content, "<div.class1.${dynamic}.class3>");
+        assert_eq!(open.src, "<div.class1.${dynamic}.class3>");
     }
 
     #[test]
@@ -1392,7 +1019,7 @@ mod tests {
         let result = parse_open("<div.class-${a + b}>");
         assert!(result.is_ok());
         let open = result.unwrap();
-        assert_eq!(open.content, "<div.class-${a + b}>");
+        assert_eq!(open.src, "<div.class-${a + b}>");
     }
 
     #[test]
@@ -1400,7 +1027,7 @@ mod tests {
         let result = parse_open("<div.class-$value>");
         assert!(result.is_ok());
         let open = result.unwrap();
-        assert_eq!(open.content, "<div.class-$value>");
+        assert_eq!(open.src, "<div.class-$value>");
     }
 
     #[test]
@@ -1408,4 +1035,82 @@ mod tests {
         let result = parse_open("<${MyComponent}/>");
         assert!(result.is_ok());
     }
+
+    #[test]
+    fn test_id_attr_shorthand_static() {
+        let open = parse_open("<div#myId>").unwrap();
+        assert_eq!(open.id_attr(), Some(("myId", false)));
+        assert!(!open.id_is_dynamic());
+    }
+
+    #[test]
+    fn test_id_attr_shorthand_with_hyphen() {
+        let open = parse_open("<h2#technical-review>").unwrap();
+        assert_eq!(open.id_attr(), Some(("technical-review", false)));
+    }
+
+    #[test]
+    fn test_id_attr_shorthand_dynamic() {
+        let open = parse_open("<div#${myId}>").unwrap();
+        assert_eq!(open.id_attr(), None);
+        assert!(open.id_is_dynamic());
+    }
+
+    #[test]
+    fn test_id_attr_attribute_static() {
+        let open = parse_open("<div id=\"my-id\">").unwrap();
+        assert_eq!(open.id_attr(), Some(("\"my-id\"", true)));
+        assert!(!open.id_is_dynamic());
+    }
+
+    #[test]
+    fn test_id_attr_attribute_single_quotes() {
+        let open = parse_open("<div id='my-id'>").unwrap();
+        assert_eq!(open.id_attr(), Some(("'my-id'", true)));
+    }
+
+    #[test]
+    fn test_id_attr_attribute_dynamic() {
+        let open = parse_open("<div id=myVariable>").unwrap();
+        assert_eq!(open.id_attr(), None);
+        assert!(open.id_is_dynamic());
+    }
+
+    #[test]
+    fn test_id_attr_none() {
+        let open = parse_open("<div class=\"foo\">").unwrap();
+        assert_eq!(open.id_attr(), None);
+        assert!(!open.id_is_dynamic());
+    }
+
+    #[test]
+    fn test_id_attr_shorthand_with_classes() {
+        let open = parse_open("<div.cls1#myId.cls2>").unwrap();
+        assert_eq!(open.id_attr(), Some(("myId", false)));
+    }
+
+    #[test]
+    fn test_set_id_attr_insert_new() {
+        let open = parse_open("<div>").unwrap();
+        let mut owned = open.to_owned();
+        owned.insert_id_attr("new-id");
+        assert_eq!(owned.src, "<div#new-id>");
+        assert_eq!(owned.as_ref().id_attr(), Some(("new-id", false)));
+    }
+
+    #[test]
+    fn test_set_id_attr_insert_with_attrs() {
+        let open = parse_open("<div class=\"foo\">").unwrap();
+        let mut owned = open.to_owned();
+        owned.insert_id_attr("new-id");
+        assert_eq!(owned.src, "<div#new-id class=\"foo\">");
+    }
+
+    #[test]
+    fn test_set_id_attr_self_closing() {
+        let open = parse_open("<input/>").unwrap();
+        let mut owned = open.to_owned();
+        owned.insert_id_attr("my-input");
+        assert_eq!(owned.src, "<input#my-input/>");
+    }
 }
diff --git a/src/marko_ast.rs b/src/marko_ast.rs
new file mode 100644
index 0000000000000000000000000000000000000000..704862db5753ba92c42aeef1d0d7333a281c0f5c
--- /dev/null
+++ b/src/marko_ast.rs
@@ -0,0 +1,230 @@
+use oxc_diagnostics::OxcDiagnostic;
+use oxc_span::Span;
+
+use crate::{err, typescript::parse_expr};
+
+/// Information about the id attribute in a tag.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum AttributeValue {
+    /// No id attribute found
+    None,
+    /// Staticly analyzed string literal (raw source)
+    Static { span: Span, is_quoted: bool },
+    /// Dynamic expression
+    Dynamic,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Open<'a> {
+    pub src: &'a str,
+    /// Only set if the tag name is a static value
+    literal_tag_name: Span,
+    pub self_closing: bool,
+    /// Offset after tag name and class/id shorthands, where new shorthand could be inserted
+    shorthand_end: u32,
+    /// Information about the id attribute
+    pub id: AttributeValue,
+}
+
+impl<'a> Open<'a> {
+    /// Convert to an owned version for storage.
+    pub fn to_owned(&self) -> OpenOwned {
+        OpenOwned {
+            src: self.src.to_string(),
+            literal_tag_name: self.literal_tag_name,
+            self_closing: self.self_closing,
+            shorthand_end: self.shorthand_end,
+            id: self.id,
+        }
+    }
+
+    /// Returns the element tag name. Empty string when dynamic interpolation.
+    pub fn tag_name(&self) -> &'a str {
+        &self.src[self.literal_tag_name]
+    }
+
+    /// Returns the span of the tag's name for errors. Works for dynamic interpolations
+    pub fn tag_name_span(&self) -> Span {
+        // fast case, when a literal tag name is passed
+        if !self.literal_tag_name.is_empty() {
+            self.literal_tag_name.expand_left(1)
+        } else {
+            // slow path, re-parse the js expression
+            let mut l = LexState::new(self.src);
+            l.advance(3);
+            parse_expr(&mut l).expect("validated text should pass");
+            Span::new(3, l.offset() as u32)
+        }
+    }
+
+    /// Returns the id attribute value if it's a static string.
+    /// Returns `None` if no id or if the id is dynamic.
+    pub fn id_attr(&self) -> Option<(&'a str, bool)> {
+        match self.id {
+            AttributeValue::Static { span, is_quoted } => Some((&self.src[span], is_quoted)),
+            AttributeValue::None | AttributeValue::Dynamic => None,
+        }
+    }
+
+    /// Returns whether the id is dynamic (contains ${} or is a non-string expression).
+    pub fn id_is_dynamic(&self) -> bool {
+        matches!(self.id, AttributeValue::Dynamic)
+    }
+
+    pub(crate) fn new(
+        src: &'a str,
+        tag_name: Span,
+        self_closing: bool,
+        shorthand_end: u32,
+        id: AttributeValue,
+    ) -> Self {
+        Self {
+            src,
+            literal_tag_name: tag_name,
+            self_closing,
+            shorthand_end,
+            id,
+        }
+    }
+}
+
+/// Owned version of [Open] for storage in AST nodes, which do not allow specifying a lifetime.
+/// Waste of memory.
+#[derive(Debug, Clone, PartialEq)]
+pub struct OpenOwned {
+    pub src: String,
+    literal_tag_name: Span,
+    pub self_closing: bool,
+    /// Offset after tag name and class/id shorthands, where new shorthand could be inserted
+    shorthand_end: u32,
+    /// Information about the id attribute
+    pub id: AttributeValue,
+}
+
+impl OpenOwned {
+    /// Borrow as an [Open] reference to access methods.
+    pub fn as_ref(&self) -> Open<'_> {
+        Open {
+            src: &self.src,
+            literal_tag_name: self.literal_tag_name,
+            self_closing: self.self_closing,
+            shorthand_end: self.shorthand_end,
+            id: self.id,
+        }
+    }
+
+    /// Set the id attribute to a static string value.
+    /// If an id already exists (shorthand or attribute), it is replaced.
+    /// If no id exists, a shorthand #id is inserted after the tag name/classes.
+    pub fn insert_id_attr(&mut self, new_id: &str) {
+        match self.id {
+            AttributeValue::None => {
+                // Insert new shorthand #id at shorthand_end position
+                let insert_pos = self.shorthand_end;
+                let mut src = String::with_capacity(self.src.len() + 1 + new_id.len());
+                src.push_str(&self.src[..insert_pos as usize]);
+                src.push('#');
+                src.push_str(new_id);
+                src.push_str(&self.src[insert_pos as usize..]);
+
+                let id_start = insert_pos + 1; // after the #
+                let id_end = id_start + new_id.len() as u32;
+
+                self.src = src;
+                self.shorthand_end = id_end;
+                self.id = AttributeValue::Static {
+                    span: Span::new(id_start, id_end),
+                    is_quoted: false,
+                };
+            }
+            AttributeValue::Dynamic | AttributeValue::Static { .. } => {
+                panic!("Cannot replace ID attribute");
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Close<'a> {
+    pub tag_name: Option<&'a str>,
+    pub length: u32,
+}
+
+impl Close<'_> {
+    /// Returns the span of the tag name relative to the start of the tag.
+    /// For `</div>`, returns Span(2, 5) pointing to "div".
+    /// For `</>`, returns None.
+    pub fn tag_name_span(&self) -> Option<Span> {
+        self.tag_name.map(|name| {
+            // Close tag starts with '</', so tag name starts at offset 2
+            let start = 2u32;
+            let end = start + (name.len() as u32);
+            Span::new(start, end)
+        })
+    }
+}
+
+pub enum OpenOrClose<'a> {
+    Open(Open<'a>),
+    Close(Close<'a>),
+}
+
+pub struct LexState<'a> {
+    pub src: &'a str,
+    pub offset: u32,
+}
+
+impl<'a> LexState<'a> {
+    pub fn new(src: &'a str) -> LexState<'a> {
+        LexState { src, offset: 0 }
+    }
+
+    pub fn offset(&self) -> u32 {
+        self.offset
+    }
+
+    pub fn advance(&mut self, n: u32) {
+        self.offset += n;
+    }
+
+    pub fn restore(&mut self, n: u32) {
+        self.offset = n;
+    }
+
+    pub fn peek_byte(&self) -> Option<u8> {
+        self.src.as_bytes().get(self.offset as usize).copied()
+    }
+
+    pub fn peek_rest(&self) -> &'a str {
+        &self.src[self.offset as usize..]
+    }
+
+    pub fn expect_byte(&mut self) -> Result<u8, OxcDiagnostic> {
+        if let Some(b) = self.peek_byte() {
+            self.offset += 1;
+            return Ok(b);
+        }
+        Err(err("Unexpected end of file", self.offset, 1))
+    }
+
+    pub fn expect(&mut self, expected: &str) -> Result<(), OxcDiagnostic> {
+        if self.src[self.offset as usize..].starts_with(expected) {
+            self.offset += expected.len() as u32;
+            Ok(())
+        } else {
+            Err(err(format!("Expected {expected}"), self.offset, 1))
+        }
+    }
+
+    pub fn skip_whitespace(&mut self) {
+        loop {
+            match self.peek_byte() {
+                Some(byte) => match byte {
+                    b' ' | b'\n' | b'\t' | b'\r' => self.offset += 1,
+                    _ => break,
+                },
+                None => break,
+            }
+        }
+    }
+}
diff --git a/src/plugin/mod.rs b/src/plugin/mod.rs
index ba68e6a0ba648eab4c9bd4481a213fdc4483f200..8dee0257d179f2e472908f4315eea094eff810b2 100644
--- a/src/plugin/mod.rs
+++ b/src/plugin/mod.rs
@@ -35,7 +35,7 @@ pub(crate) struct ErrorBlock {
 }
 
 impl NodeValue for ErrorBlock {
-    fn render(&self, _: &Node, _: &mut dyn Renderer) {
+    fn render(&self, _: &Node, r: &mut dyn Renderer) {
         panic!("cannot render ErrorBlock");
     }
 }
diff --git a/src/plugin/statement.rs b/src/plugin/statement.rs
index eb0dbf282687bd4a1840c885625ece60f519f602..bc4c781470f478fda76f9fb2a2dd30cf91b349a4 100644
--- a/src/plugin/statement.rs
+++ b/src/plugin/statement.rs
@@ -36,17 +36,17 @@ impl BlockRule for Rule {
             .iter()
             .find(|k| **k == keyword)
             .map(|k| k.len())
-            .unwrap_or(0);
+            .unwrap_or(0) as u32;
 
         let unbounded_src = &state.src[state.line_offsets[state.line].first_nonspace..];
 
         let statement_end =
-            match scan_first_statement_forbid_trailing(&unbounded_src[keyword_trim..]) {
+            match scan_first_statement_forbid_trailing(&unbounded_src[keyword_trim as usize..]) {
                 Ok(ok) => ok,
                 Err(err) => {
                     return Some((
                         Node::new(ErrorBlock {
-                            errors: vec![adjust_err(err, keyword_trim.cast_signed())],
+                            errors: vec![adjust_err(err, keyword_trim as isize)],
                         }),
                         1,
                     ));
@@ -54,8 +54,11 @@ impl BlockRule for Rule {
             };
 
         let total_end = keyword_trim + statement_end;
-        let content = &unbounded_src[0..unbounded_src.len().min(total_end + 1)];
-        let line_count = 1 + content[..total_end].chars().filter(|&c| c == '\n').count();
+        let content = &unbounded_src[0..unbounded_src.len().min(total_end as usize + 1)];
+        let line_count = 1 + content[..total_end as usize]
+            .chars()
+            .filter(|&c| c == '\n')
+            .count();
 
         let node = Node::new(StatementBlock {
             content: content.into(),
diff --git a/src/plugin/tags.rs b/src/plugin/tags.rs
index 155ec93af4b6062d96b2f605762d60c7c699a11f..d9a3a97660d94876c14ce23cd7b955bcfcbbca00 100644
--- a/src/plugin/tags.rs
+++ b/src/plugin/tags.rs
@@ -2,21 +2,19 @@ use markdown_it::parser::block::{BlockRule, BlockState};
 use markdown_it::parser::inline::{InlineRoot, InlineRule, InlineState};
 use markdown_it::{Node, NodeValue, Renderer};
 
-use crate::marko::{self, OpenOrClose};
+use crate::marko_ast::OpenOrClose;
 use crate::plugin::{get_line_raw, ErrorBlock};
+use crate::{marko, marko_ast};
 
 /// An opening Marko tag: <div>, <if=cond>, <for|item| of=items>, etc.
 #[derive(Debug)]
 pub struct MarkoOpen {
-    pub content: String,
-    pub tag_name: String,
-    /// Length of the tag name (for error span highlighting)
-    pub tag_name_len: usize,
+    pub open: marko_ast::OpenOwned,
 }
 
 impl NodeValue for MarkoOpen {
     fn render(&self, _node: &Node, fmt: &mut dyn Renderer) {
-        fmt.text_raw(&self.content);
+        fmt.text_raw(&self.open.src);
         fmt.text_raw("\n");
     }
 }
@@ -54,15 +52,12 @@ impl NodeValue for MarkoSelfClosing {
 /// The text is parsed as inline markdown (children) but not wrapped in <p>
 #[derive(Debug)]
 pub struct MarkoOpenWithText {
-    pub open_tag: String,
-    pub tag_name: String,
-    /// Length of the tag name (for error span highlighting)
-    pub tag_name_len: usize,
+    pub open: marko_ast::OpenOwned,
 }
 
 impl NodeValue for MarkoOpenWithText {
     fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
-        fmt.text_raw(&self.open_tag);
+        fmt.text_raw(&self.open.src);
         fmt.text_raw("\n");
         fmt.contents(&node.children);
         fmt.text_raw("\n");
@@ -157,37 +152,31 @@ fn find_same_line_close<'a>(content: &'a str, tag_name: &str) -> Option<(&'a str
 
         // Try to parse as a tag
         match marko::parse_tag(&content[lt_pos..]) {
-            Ok(marko::OpenOrClose::Open(open)) => {
+            Ok(OpenOrClose::Open(open)) => {
                 if !open.self_closing {
-                    stack.push(open.tag_name);
+                    stack.push(open.tag_name());
                 }
-                pos = lt_pos + open.content.len();
+                pos = lt_pos + (open.src.len());
             }
-            Ok(marko::OpenOrClose::Close(close)) => {
+            Ok(OpenOrClose::Close(close)) => {
                 if stack.is_empty() {
-                    // No nested tags open - this close tag is for the outer tag
-                    // Check if it matches our tag name or is generic </>
                     if close.tag_name.map(|n| n == tag_name).unwrap_or(true) {
                         let content_before = &content[..lt_pos];
-                        let close_tag = &content[lt_pos..lt_pos + close.length];
+                        let close_tag = &content[lt_pos..lt_pos + close.length as usize];
                         return Some((content_before, close_tag));
                     }
-                    // Named close tag that doesn't match - keep scanning
-                    pos = lt_pos + close.length;
+                    pos = lt_pos + close.length as usize;
                 } else {
-                    // Close tag for a nested open tag - pop the stack
-                    // Generic </> closes the most recent, named must match
                     if close.tag_name.is_none() {
                         stack.pop();
                     } else if stack.last() == close.tag_name.as_ref() {
                         stack.pop();
                     }
-                    // If it doesn't match, we still continue (malformed nesting)
-                    pos = lt_pos + close.length;
+                    pos = lt_pos + close.length as usize;
                 }
             }
             Err(_) => {
-                // Not a valid tag, skip past this '<'
+                // TODO: why no forward
                 pos = lt_pos + 1;
             }
         }
@@ -212,13 +201,13 @@ impl BlockRule for Rule {
         match marko::parse_tag(unbounded_src) {
             Ok(OpenOrClose::Open(open)) => {
                 // Count how many lines this tag spans
-                let lines_consumed = 1 + open.content.chars().filter(|&c| c == '\n').count();
+                let lines_consumed = 1 + open.src.chars().filter(|&c| c == '\n').count();
 
                 if open.self_closing {
                     // <input /> - self-closing tag
                     return Some((
                         Node::new(MarkoSelfClosing {
-                            content: open.content.to_string(),
+                            content: open.src.to_string(),
                         }),
                         lines_consumed,
                     ));
@@ -226,18 +215,19 @@ impl BlockRule for Rule {
 
                 // Check if there's content on the same line after the tag
                 // We need to look at unbounded_src, not trimmed, since tag may span multiple lines
-                let rest_after_tag = &unbounded_src[open.content.len()..];
+                let rest_after_tag = &unbounded_src[open.src.len()..];
                 let rest_of_last_line = rest_after_tag.lines().next().unwrap_or("");
                 if !rest_of_last_line.trim().is_empty() {
                     let text = rest_of_last_line.trim();
 
                     // Check if the same-line content contains a matching close tag
-                    if let Some((content, close_tag)) = find_same_line_close(text, open.tag_name) {
+                    if let Some((content, close_tag)) = find_same_line_close(text, open.tag_name())
+                    {
                         // Complete tag on one line: <tag>content</tag>
                         let content = content.trim();
 
                         // Calculate byte offset for source mapping
-                        let text_start_in_line = open.content.len()
+                        let text_start_in_line = open.src.len()
                             + (rest_of_last_line.len() - rest_of_last_line.trim_start().len());
                         let line_start = state.line_offsets[state.line].first_nonspace;
                         let text_start = line_start + text_start_in_line;
@@ -245,10 +235,10 @@ impl BlockRule for Rule {
                         let mapping = vec![(0, text_start)];
 
                         let mut node = Node::new(MarkoBlockComplete {
-                            open_tag: open.content.to_string(),
+                            open_tag: open.src.to_string(),
                             close_tag: close_tag.to_string(),
-                            tag_name: open.tag_name.to_string(),
-                            tag_name_len: open.tag_name.len(),
+                            tag_name: open.tag_name().to_string(),
+                            tag_name_len: open.tag_name().len(),
                         });
 
                         if !content.is_empty() {
@@ -261,7 +251,7 @@ impl BlockRule for Rule {
 
                     // No close tag - just content after open tag
                     // Parse the text as inline markdown (not wrapped in paragraph)
-                    let text_start_in_line = open.content.len()
+                    let text_start_in_line = open.src.len()
                         + (rest_of_last_line.len() - rest_of_last_line.trim_start().len());
                     let line_start = state.line_offsets[state.line].first_nonspace;
                     let text_start = line_start + text_start_in_line;
@@ -269,9 +259,7 @@ impl BlockRule for Rule {
                     let mapping = vec![(0, text_start)];
 
                     let mut node = Node::new(MarkoOpenWithText {
-                        open_tag: open.content.to_string(),
-                        tag_name: open.tag_name.to_string(),
-                        tag_name_len: open.tag_name.len(),
+                        open: open.to_owned(),
                     });
                     node.children
                         .push(Node::new(InlineRoot::new(text.to_string(), mapping)));
@@ -295,9 +283,7 @@ impl BlockRule for Rule {
                         let mapping = vec![(0, next_line_start)];
 
                         let mut node = Node::new(MarkoOpenWithText {
-                            open_tag: open.content.to_string(),
-                            tag_name: open.tag_name.to_string(),
-                            tag_name_len: open.tag_name.len(),
+                            open: open.to_owned(),
                         });
                         node.children
                             .push(Node::new(InlineRoot::new(text.to_string(), mapping)));
@@ -310,9 +296,7 @@ impl BlockRule for Rule {
                 // Clean case: open tag on its own line(s), followed by blank or another tag
                 Some((
                     Node::new(MarkoOpen {
-                        content: open.content.to_string(),
-                        tag_name: open.tag_name.to_string(),
-                        tag_name_len: open.tag_name.len(),
+                        open: open.to_owned(),
                     }),
                     lines_consumed,
                 ))
@@ -320,15 +304,15 @@ impl BlockRule for Rule {
             Ok(OpenOrClose::Close(close)) => {
                 // Close tags should be single line, but check anyway
                 let lines_consumed = 1 + close.length.saturating_sub(1).min(
-                    unbounded_src[..close.length]
+                    unbounded_src[..close.length as usize]
                         .chars()
                         .filter(|&c| c == '\n')
-                        .count(),
+                        .count() as u32,
                 );
 
                 // Check if there's content on the same line after the close tag
-                let close_text = &unbounded_src[..close.length];
-                let rest_after_tag = &unbounded_src[close.length..];
+                let close_text = &unbounded_src[..close.length as usize];
+                let rest_after_tag = &unbounded_src[close.length as usize..];
                 let rest_of_line = rest_after_tag.lines().next().unwrap_or("");
                 if !rest_of_line.trim().is_empty() {
                     // TODO: content after close tag on same line
@@ -341,7 +325,7 @@ impl BlockRule for Rule {
                         tag_name: close.tag_name.map(|s| s.to_string()),
                         tag_name_len: close.tag_name.map(|s| s.len()),
                     }),
-                    lines_consumed,
+                    lines_consumed as usize,
                 ))
             }
             Err(err) => Some((Node::new(ErrorBlock { errors: vec![err] }), 1)),
@@ -354,50 +338,43 @@ impl InlineRule for Rule {
 
     fn run(state: &mut InlineState) -> Option<(Node, usize)> {
         let input = &state.src[state.pos..state.pos_max];
-
-        // Skip if this doesn't look like a Marko tag
         if !input.starts_with("<") {
             return None;
         }
 
-        // Try to parse as a Marko tag
         match marko::parse_tag(input) {
             Ok(OpenOrClose::Open(open)) => {
                 if open.self_closing {
-                    // Self-closing inline tag like <br/>
                     return Some((
                         Node::new(MarkoSelfClosing {
-                            content: open.content.to_string(),
+                            content: open.src.to_string(),
                         }),
-                        open.content.len(),
+                        open.src.len(),
                     ));
                 }
-                // Emit open marker - will be matched by post-processor
+
                 Some((
                     Node::new(MarkoInlineOpenMarker {
-                        content: open.content.to_string(),
-                        tag_name: open.tag_name.to_string(),
-                        tag_name_len: open.tag_name.len(),
+                        content: open.src.to_string(),
+                        tag_name: open.tag_name().to_owned(),
+                        tag_name_len: open.tag_name().len(),
                     }),
-                    open.content.len(),
+                    open.src.len(),
                 ))
             }
             Ok(OpenOrClose::Close(close)) => {
-                // Emit close marker - will be matched by post-processor
-                let close_text = &input[..close.length];
+                let close_text = &input[..close.length as usize];
                 Some((
                     Node::new(MarkoInlineCloseMarker {
                         content: close_text.to_string(),
                         tag_name: close.tag_name.map(|s| s.to_string()),
                         tag_name_len: close.tag_name.map(|s| s.len()),
                     }),
-                    close.length,
+                    close.length as usize,
                 ))
             }
-            Err(_) => {
-                // Not a valid Marko tag, let other rules handle it
-                None
-            }
+            // TODO: why this no reported
+            Err(_) => None,
         }
     }
 }
diff --git a/src/plugin/toc.rs b/src/plugin/toc.rs
index dd5de9391749d9bf74eb9ed0bb7d531c0bf4f308..48445654752db889e1a1331f0df1fb3e9466897c 100644
--- a/src/plugin/toc.rs
+++ b/src/plugin/toc.rs
@@ -84,14 +84,14 @@ fn collect_headings_recursive(
     }
     // Check for MarkoOpen tags that are h1-h6
     else if let Some(open) = node.cast::<super::tags::MarkoOpen>() {
-        if let Some(level) = parse_heading_level(&open.tag_name) {
+        if let Some(level) = parse_heading_level(&open.open.as_ref().tag_name()) {
             let text = node
                 .children
                 .iter()
                 .map(|c| c.collect_text())
                 .collect::<Vec<_>>()
                 .join("");
-            let id = if let Some(existing) = open.content.strip_prefix('<').and_then(|s| {
+            let id = if let Some(existing) = open.open.src.strip_prefix('<').and_then(|s| {
                 s.find("id=\"")
                     .map(|pos| {
                         let start = pos + 4;
@@ -113,7 +113,7 @@ fn collect_headings_recursive(
     }
     // Check for MarkoOpenWithText tags that are h1-h6
     else if let Some(open) = node.cast::<super::tags::MarkoOpenWithText>() {
-        if let Some(level) = parse_heading_level(open.tag_name.as_str()) {
+        if let Some(level) = parse_heading_level(open.open.as_ref().tag_name()) {
             let text = node
                 .children
                 .iter()
diff --git a/src/typescript.rs b/src/typescript.rs
index 9164fdd1b8020ddbbc936f485998f57c3bcb3d6a..61b9aa61450e15b463be287e02de06355febb61f 100644
--- a/src/typescript.rs
+++ b/src/typescript.rs
@@ -1,23 +1,22 @@
-//! implement ts partial parsing helpers
-use crate::{adjust_err, err, marko::LexState};
+//! implements ts partial parsing helpers
+use crate::{adjust_err, err, marko_ast::LexState};
 
 use oxc_allocator::Allocator;
 use oxc_ast::ast::{Expression, Statement};
 use oxc_diagnostics::{LabeledSpan, OxcDiagnostic};
 use oxc_span::{GetSpan, SourceType};
 
-/// TODO: Replace with oxc parser, but oxc is tough here
-pub fn scan_first_statement_forbid_trailing(source: &str) -> Result<usize, OxcDiagnostic> {
+pub fn scan_first_statement_forbid_trailing(source: &str) -> Result<u32, OxcDiagnostic> {
     let mut allocator = Allocator::new();
     let expr = parse_stmt_extra(source, 0, &mut allocator)?;
     let span = expr.span();
-    let len = (span.end - span.start) as usize;
+    let len = span.end - span.start;
 
     if let Some(trailing) = source[span.end as usize..].lines().next() {
         if trailing.trim().len() > 0 {
             return Err(err(
                 "Trailing content not allowed here",
-                span.end as usize + (trailing.len() - trailing.trim_start().len()),
+                span.end + (trailing.len() - trailing.trim_start().len()) as u32,
                 trailing.trim().len(),
             ));
         }
@@ -33,7 +32,7 @@ fn parse_stmt_extra<'alloc, 'src: 'alloc>(
     if source.is_empty() {
         return Err(err(
             "Expected expression, found end of file",
-            offset.max(0).cast_unsigned(),
+            offset.max(0).cast_unsigned() as u32,
             1,
         ));
     }
@@ -52,7 +51,13 @@ fn parse_stmt_extra<'alloc, 'src: 'alloc>(
         let first_err_offset = first_err
             .labels
             .as_ref()
-            .ok_or_else(|| err("Expected statement", offset.max(0).cast_unsigned(), 1))?
+            .ok_or_else(|| {
+                err(
+                    "Expected statement",
+                    offset.max(0).cast_unsigned() as u32,
+                    1,
+                )
+            })?
             .first()
             .expect("labels, but no labels!")
             .offset();
@@ -82,17 +87,18 @@ fn parse_stmt_extra<'alloc, 'src: 'alloc>(
         assert!(!result.panicked);
     }
 
-    result
-        .program
-        .body
-        .into_iter()
-        .next()
-        .ok_or_else(|| err("Expected statement", offset.max(0).cast_unsigned(), 1))
+    result.program.body.into_iter().next().ok_or_else(|| {
+        err(
+            "Expected statement",
+            offset.max(0).cast_unsigned() as u32,
+            1,
+        )
+    })
 }
 
 fn parse_expr_extra<'alloc, 'src: 'alloc>(
     source: &'src str,
-    offset: isize,
+    offset: i32,
     allocator: &'alloc mut Allocator,
 ) -> Result<Expression<'alloc>, OxcDiagnostic> {
     if source.is_empty() {
@@ -130,7 +136,7 @@ fn parse_expr_extra<'alloc, 'src: 'alloc>(
             let mut whitespace_groups = 0;
             loop {
                 if candidate.is_empty() {
-                    return Err(adjust_err(first_err, offset));
+                    return Err(adjust_err(first_err, offset as isize));
                 }
                 match oxc_parser::Parser::new(allocator, candidate, source_type).parse_expression()
                 {
@@ -141,7 +147,7 @@ fn parse_expr_extra<'alloc, 'src: 'alloc>(
                         if after_trim.len() < before_trim.len() {
                             whitespace_groups += 1;
                             if whitespace_groups > 1 {
-                                return Err(adjust_err(first_err, offset));
+                                return Err(adjust_err(first_err, offset as isize));
                             }
                         }
                         candidate = after_trim;
@@ -164,17 +170,16 @@ fn parse_expr_extra<'alloc, 'src: 'alloc>(
 }
 
 /// parse ts expression, stopping at garbage data / comma
-pub fn parse_expr(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
+pub fn parse_expr(l: &mut LexState) -> Result<u32, OxcDiagnostic> {
     let mut allocator = Allocator::new();
     let expr = parse_expr_extra(l.peek_rest(), l.offset().cast_signed(), &mut allocator)?;
     let span = expr.span();
-    let len = (span.end - span.start) as usize;
-    l.advance(len);
-    Ok(len)
+    l.advance(span.end - span.start);
+    Ok(span.end - span.start)
 }
 
 /// parse ts expression but stop at the first > because of ambiguity with HTML tag end
-pub fn parse_expr_without_gt(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
+pub fn parse_expr_without_gt(l: &mut LexState) -> Result<u32, OxcDiagnostic> {
     use oxc_ast::ast::{BinaryOperator, Expression};
 
     let rest = l.peek_rest();
@@ -196,7 +201,7 @@ pub fn parse_expr_without_gt(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
             }
         }
 
-        let length = e.span().end as usize;
+        let length = e.span().end;
         l.advance(length);
         return Ok(length);
     }
@@ -215,9 +220,9 @@ pub fn parse_expr_without_gt(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
         allocator.reset();
         if let Ok(expr) = parse_expr_extra(candidate, l.offset().cast_signed(), &mut allocator) {
             // Check that the parse consumed most of the candidate (not just a prefix)
-            let length = expr.span().end as usize;
+            let length = expr.span().end;
             // If the expression spans close to the full candidate, use it
-            if length >= pos.saturating_sub(1) {
+            if length >= (pos.saturating_sub(1) as u32) {
                 l.advance(length);
                 return Ok(length);
             }
@@ -227,18 +232,16 @@ pub fn parse_expr_without_gt(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
     // Last resort: return error from the original parse attempt
     allocator.reset();
     let expr = parse_expr_extra(rest, l.offset().cast_signed(), &mut allocator)?;
-    let length = expr.span().end as usize;
+    let length = expr.span().end;
     l.advance(length);
     Ok(length)
 }
 
 /// parse call arguments including the parentheses: `(a, b, ...c)`
-pub fn parse_call_arguments(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
+pub fn parse_call_arguments(l: &mut LexState) -> Result<u32, OxcDiagnostic> {
     let source = l.peek_rest();
     if !source.starts_with("(") {
-        return Err(
-            OxcDiagnostic::error("Expected `(`").and_label(LabeledSpan::new(None, l.offset(), 1)),
-        );
+        return Err(err("Expected `(`", l.offset(), 1));
     }
 
     // Prepend `f` to make it a call expression: "f(a, b, c)"
@@ -248,23 +251,18 @@ pub fn parse_call_arguments(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
     let expr = parse_expr_extra(wrapped.as_str(), l.offset().cast_signed(), &mut allocator)?;
 
     // Walk down the left side of the AST to find the CallExpression
-    let call_span = find_leftmost_call(&expr).ok_or_else(|| {
-        OxcDiagnostic::error("Expected call expression").and_label(LabeledSpan::new(
-            None,
-            l.offset(),
-            1,
-        ))
-    })?;
+    let call_span =
+        find_leftmost_call(&expr).ok_or_else(|| err("Expected call expression", l.offset(), 1))?;
 
     // Subtract the `f` prefix we added
-    let length = call_span.end as usize - 1;
+    let length = call_span.end - 1;
     l.advance(length);
     Ok(length)
 }
 
 /// parse variable binding. identifier or destructuring pattern
 /// also parses optional `: Type`
-pub fn parse_var_binding(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
+pub fn parse_var_binding(l: &mut LexState) -> Result<u32, OxcDiagnostic> {
     // TODO: this approach has bugs
     let offset = l.offset();
     let source = l.peek_rest();
@@ -276,16 +274,16 @@ pub fn parse_var_binding(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
     let end = {
         let expr = parse_expr_extra(source, l.offset().cast_signed(), &mut allocator)?;
         let span = find_leftmost(&expr, LeftmostSearch::Assignment).unwrap();
-        span.end as usize
+        span.end
     };
     allocator.reset();
 
     {
         let prefix = "function f(";
-        let source = format!("{prefix}{}) {{}}", &source[0..end]);
+        let source = format!("{prefix}{}) {{}}", &source[0..end as usize]);
         parse_expr_extra(
             source.as_str(),
-            l.offset().cast_signed() - prefix.len().cast_signed(),
+            l.offset().cast_signed() - (prefix.len().cast_signed() as i32),
             &mut allocator,
         )?;
     }
@@ -305,7 +303,7 @@ pub fn parse_var_binding(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
 }
 
 /// parses a type
-pub fn parse_type(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
+pub fn parse_type(l: &mut LexState) -> Result<u32, OxcDiagnostic> {
     let mut allocator = Allocator::default();
     let source = format!("T as {}", l.peek_rest());
     println!("{{{source}}} HUH");
@@ -319,19 +317,16 @@ pub fn parse_type(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
             expr.span().end as usize,
         )
     })?;
-    let len = (span.end - span.start) as usize;
-
+    let len = span.end - span.start;
     l.advance(len);
     Ok(len)
 }
 
 /// parses `(params): ReturnType { body }`
-pub fn parse_fn_params_and_body(l: &mut LexState) -> Result<usize, OxcDiagnostic> {
+pub fn parse_fn_params_and_body(l: &mut LexState) -> Result<u32, OxcDiagnostic> {
     let source = l.peek_rest();
     if !source.starts_with("(") {
-        return Err(
-            OxcDiagnostic::error("Expected `(`").and_label(LabeledSpan::new(None, l.offset(), 1)),
-        );
+        return Err(err("Expected `(`", l.offset(), 1));
     }
 
     // Prepend `function f` to make it a function expression
@@ -340,19 +335,14 @@ pub fn parse_fn_params_and_body(l: &mut LexState) -> Result<usize, OxcDiagnostic
 
     let mut allocator = Allocator::default();
 
-    let expr = parse_expr_extra(&wrapped, l.offset().cast_signed(), &mut allocator)?;
+    let expr = parse_expr_extra(&wrapped, l.offset() as i32, &mut allocator)?;
 
     // Find the function expression (walk left side of any binary/etc expressions)
-    let func_span = find_leftmost(&expr, LeftmostSearch::Function).ok_or_else(|| {
-        OxcDiagnostic::error("Expected function expression").and_label(LabeledSpan::new(
-            None,
-            l.offset(),
-            1,
-        ))
-    })?;
+    let func_span = find_leftmost(&expr, LeftmostSearch::Function)
+        .ok_or_else(|| err("Expected function expression", l.offset(), 1))?;
 
     // Subtract the prefix we added
-    let length = func_span.end as usize - prefix.len();
+    let length = func_span.end - (prefix.len() as u32);
     l.advance(length);
     Ok(length)
 }
@@ -483,7 +473,7 @@ fn find_leftmost_assign(
 mod tests {
     use super::*;
 
-    fn parse_expr(source: &str) -> Result<usize, OxcDiagnostic> {
+    fn parse_expr(source: &str) -> Result<u32, OxcDiagnostic> {
         let mut l = LexState::new(source);
         super::parse_expr(&mut l)
     }
@@ -568,7 +558,7 @@ mod tests {
         assert!(result.is_err());
     }
 
-    fn parse_expr_no_gt(source: &str) -> Result<usize, OxcDiagnostic> {
+    fn parse_expr_no_gt(source: &str) -> Result<u32, OxcDiagnostic> {
         let mut l = LexState::new(source);
         parse_expr_without_gt(&mut l)
     }
@@ -621,7 +611,7 @@ mod tests {
         assert_eq!(parse_expr_no_gt("x >>> 2"), Ok(1));
     }
 
-    fn parse_call_args(source: &str) -> Result<usize, OxcDiagnostic> {
+    fn parse_call_args(source: &str) -> Result<u32, OxcDiagnostic> {
         let mut l = LexState::new(source);
         parse_call_arguments(&mut l)
     }
@@ -671,7 +661,7 @@ mod tests {
         assert!(result.is_err());
     }
 
-    fn parse_fn_params_body(source: &str) -> Result<usize, OxcDiagnostic> {
+    fn parse_fn_params_body(source: &str) -> Result<u32, OxcDiagnostic> {
         let mut l = LexState::new(source);
         parse_fn_params_and_body(&mut l)
     }
@@ -736,7 +726,7 @@ mod tests {
         assert!(result.is_err());
     }
 
-    fn parse_var_binding(source: &str) -> Result<usize, OxcDiagnostic> {
+    fn parse_var_binding(source: &str) -> Result<u32, OxcDiagnostic> {
         let mut l = LexState::new(source);
         super::parse_var_binding(&mut l)
     }
@@ -816,35 +806,41 @@ mod tests {
     fn test_stmt_function_with_garbage() {
         let source = "function hello() {\n  console.log(1);\n}\n\nrandom markdown garbage";
         let end = scan_first_statement_forbid_trailing(source).unwrap();
-        assert_eq!(&source[..end], "function hello() {\n  console.log(1);\n}");
+        assert_eq!(
+            &source[..end as usize],
+            "function hello() {\n  console.log(1);\n}"
+        );
     }
 
     #[test]
     fn test_stmt_import_with_garbage() {
         let source = "import { foo } from 'bar';\n\n# markdown heading";
         let end = scan_first_statement_forbid_trailing(source).unwrap();
-        assert_eq!(&source[..end], "import { foo } from 'bar';");
+        assert_eq!(&source[..end as usize], "import { foo } from 'bar';");
     }
 
     #[test]
     fn test_stmt_interface_with_garbage() {
         let source = "interface Foo {\n  bar: string;\n}\n\nsome text";
         let end = scan_first_statement_forbid_trailing(source).unwrap();
-        assert_eq!(&source[..end], "interface Foo {\n  bar: string;\n}");
+        assert_eq!(
+            &source[..end as usize],
+            "interface Foo {\n  bar: string;\n}"
+        );
     }
 
     #[test]
     fn test_stmt_const_declaration() {
         let source = "const answer = 42;\n\n# Next section";
         let end = scan_first_statement_forbid_trailing(source).unwrap();
-        assert_eq!(&source[..end], "const answer = 42;");
+        assert_eq!(&source[..end as usize], "const answer = 42;");
     }
 
     #[test]
     fn test_stmt_expression_statement() {
         let source = "console.log('hello');\n\nmore content";
         let end = scan_first_statement_forbid_trailing(source).unwrap();
-        assert_eq!(&source[..end], "console.log('hello');");
+        assert_eq!(&source[..end as usize], "console.log('hello');");
     }
 
     #[test]
@@ -858,8 +854,8 @@ mod tests {
     fn test_stmt_multiline_function() {
         let source = "function sort(items) {\n  while (!isSorted()) {\n    shuffle(items);\n  }\n  return items;\n}\n\n# Heading";
         let end = scan_first_statement_forbid_trailing(source).unwrap();
-        assert!(source[..end].contains("return items;"));
-        assert!(source[..end].contains("}"));
+        assert!(source[..end as usize].contains("return items;"));
+        assert!(source[..end as usize].contains("}"));
     }
 
     #[test]
diff --git a/tests/fixtures/23-outline-extracting.marko b/tests/fixtures/23-outline-extracting.marko
index fbf38d068ae9b24a960651da95fcd01e644962e4..4defab92d3ca6daf4a0423bb6a06d4d07766727c 100644
--- a/tests/fixtures/23-outline-extracting.marko
+++ b/tests/fixtures/23-outline-extracting.marko
@@ -7,6 +7,9 @@ good night
 <define/Header_3__markodown__>
 <strong>snow</strong> time
 </>
+rain <strong>time</strong>
+<define/Header_4__markodown__>
+</>
 <Layout__markodown__ module=self__markodown__ outline=[
   { level: 1, id: 'good-morning', content: Header_1__markodown__ },
   { level: 2, id: 'good-night', content: Header_2__markodown__ },
-- 
2.54.0