@ape-egg/vibe 2.3.0 → 3.0.1

package/compiler/src/parser/html.rs

@@ -1,1004 +0,0 @@
-use std::fs;
-use std::path::Path;
-use std::collections::{HashMap, HashSet};
-use thiserror::Error;
-
-use super::element::{Element, ElementCache};
-
-#[derive(Error, Debug)]
-pub enum ParseError {
-    #[error("Failed to read file {path}: {source}")]
-    ReadError {
-        path: String,
-        #[source]
-        source: std::io::Error,
-    },
-    #[error("Element not found: {0}")]
-    #[allow(dead_code)]
-    ElementNotFound(String),
-}
-
-pub struct HtmlParser {
-    components_dir: std::path::PathBuf,
-    cache: ElementCache,
-}
-
-impl HtmlParser {
-    pub fn new(components_dir: std::path::PathBuf) -> Self {
-        Self {
-            components_dir,
-            cache: ElementCache::new(),
-        }
-    }
-
-    /// Load all elements from the elements directory
-    pub fn load_elements(&mut self) -> Result<(), ParseError> {
-        if !self.components_dir.exists() {
-            return Ok(()); // No elements directory is fine
-        }
-
-        self.load_elements_recursive(&self.components_dir.clone())
-    }
-
-    fn load_elements_recursive(&mut self, dir: &Path) -> Result<(), ParseError> {
-        let entries = fs::read_dir(dir).map_err(|e| ParseError::ReadError {
-            path: dir.display().to_string(),
-            source: e,
-        })?;
-
-        for entry in entries.flatten() {
-            let path = entry.path();
-
-            if path.is_dir() {
-                self.load_elements_recursive(&path)?;
-            } else if path.extension().map_or(false, |ext| ext == "html") {
-                let tag_name = path
-                    .file_stem()
-                    .and_then(|s| s.to_str())
-                    .unwrap_or("")
-                    .to_string();
-
-                let content = fs::read_to_string(&path).map_err(|e| ParseError::ReadError {
-                    path: path.display().to_string(),
-                    source: e,
-                })?;
-
-                let element = Element::new(tag_name.clone(), path.clone(), content);
-                self.cache.insert(tag_name, element);
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Reload a single element from disk (when the file changes in watch mode)
-    pub fn reload_element(&mut self, path: &Path) -> Result<(), ParseError> {
-        if path.extension().map_or(false, |ext| ext == "html") {
-            if let Some(tag_name) = path.file_stem().and_then(|s| s.to_str()) {
-                let content = fs::read_to_string(path).map_err(|e| ParseError::ReadError {
-                    path: path.display().to_string(),
-                    source: e,
-                })?;
-                let element = Element::new(tag_name.to_string(), path.to_path_buf(), content);
-                self.cache.insert(tag_name.to_string(), element);
-            }
-        }
-        Ok(())
-    }
-
-    /// Get an element by tag name
-    pub fn _get_element(&self, tag_name: &str) -> Option<&Element> {
-        self.cache.get(tag_name)
-    }
-
-    /// Get all loaded elements
-    #[allow(dead_code)]
-    pub fn elements(&self) -> &ElementCache {
-        &self.cache
-    }
-
-    /// Process HTML content: transform custom tags to <component>, optionally inline, transform custom elements
-    pub fn process_html(
-        &self,
-        content: &str,
-        elements_as_is: bool,
-        reserved_elements: &[String],
-        components_as_is: bool,
-        components_dir: &str,
-    ) -> String {
-        self.process_html_with_cache(content, elements_as_is, reserved_elements, components_as_is, components_dir, &HashMap::new())
-    }
-
-    pub fn process_html_with_cache(
-        &self,
-        content: &str,
-        elements_as_is: bool,
-        reserved_elements: &[String],
-        components_as_is: bool,
-        _components_dir: &str,
-        external_cache: &HashMap<String, String>,
-    ) -> String {
-        // Extract and preserve DOCTYPE declaration if present
-        let doctype_re = regex::Regex::new(r"(?i)^\s*<!DOCTYPE[^>]*>\s*").unwrap();
-        let doctype = doctype_re.find(content).map(|m| m.as_str().to_string());
-
-        let mut result = content.to_string();
-
-        // Step 1: Inline custom elements directly (ALWAYS, even with components_as_is)
-        // Custom elements like <card> are always inlined because runtime doesn't know about /components directory
-        result = self.inline_custom_elements(&result);
-
-        // Step 2: Handle explicit <component src="..."> elements
-        // If components_as_is is false, recursively inline all <component> elements
-        // Keep running until no more components are found (handles nested components in slots)
-        if !components_as_is {
-            let mut iterations = 0;
-            let max_iterations = 50; // Prevent infinite loops
-            loop {
-                let before = result.clone();
-                result = self.inline_component_elements(&result, external_cache);
-                iterations += 1;
-
-                // Stop if no changes or max iterations reached
-                if result == before || iterations >= max_iterations {
-                    break;
-                }
-            }
-
-            // NOTE: Don't run inline_custom_elements again here - it causes infinite recursion
-            // Custom elements inside components are already processed when the component was cached
-        }
-
-        // Step 3: Transform custom elements to divs if elements_as_is is false (accessible by default)
-        if !elements_as_is {
-            result = transform_custom_tags_to_divs(&result, reserved_elements);
-        }
-
-        // Step 4: Restore cyclic `<component src>` references that were
-        // escaped during cache build (see compile.rs::escape_recursive_src).
-        // These are runtime-handled component references that the inliner
-        // had to skip; the runtime needs them as real `src=` attributes.
-        result = result.replace("data-vibe-recursive-src=", "src=");
-
-        // Step 5: Restore DOCTYPE if it was present
-        if let Some(dt) = doctype {
-            // Remove any existing DOCTYPE that might have been left behind
-            result = doctype_re.replace(&result, "").to_string();
-            // Prepend the original DOCTYPE
-            result = format!("{}{}", dt, result);
-        }
-
-        result
-    }
-
-    /// Inline custom elements directly with their HTML content (ALWAYS, even with components_as_is)
-    /// Custom elements like <card> are always inlined because runtime doesn't know about /components directory
-    fn inline_custom_elements(&self, content: &str) -> String {
-        if self.cache.is_empty() {
-            return content.to_string(); // No custom elements to inline
-        }
-
-        let mut result = content.to_string();
-        let mut changed = true;
-        let mut iterations = 0;
-        const MAX_ITERATIONS: usize = 10; // Reasonable limit for deeply nested custom elements
-
-        while changed && iterations < MAX_ITERATIONS {
-            changed = false;
-            iterations += 1;
-
-            // Find all tags that match loaded elements
-            for (tag_name, element) in &self.cache {
-                // Match opening and closing tags with any attributes and children
-                let tag_pattern = format!(r"<{}(\s{})?>", regex::escape(tag_name), ATTR_RUN);
-                let tag_re = regex::Regex::new(&tag_pattern).unwrap();
-                let closing_pattern = format!(r"</{}>", regex::escape(tag_name));
-
-                // Find all occurrences
-                let mut matches: Vec<(usize, usize, String, Vec<(String, String)>)> = Vec::new();
-
-                // Find opening tags
-                for cap in tag_re.find_iter(&result) {
-                    let start = cap.start();
-                    let tag_with_attrs = cap.as_str();
-
-                    // Extract attributes and parse as props
-                    let attrs_str = if tag_with_attrs.ends_with('>') {
-                        let inner = &tag_with_attrs[tag_name.len() + 1..tag_with_attrs.len() - 1];
-                        inner.to_string()
-                    } else {
-                        String::new()
-                    };
-                    let props = Self::parse_props(&attrs_str);
-
-                    // Find corresponding closing tag
-                    if let Some(closing_pos) = result[cap.end()..].find(&closing_pattern) {
-                        let closing_start = cap.end() + closing_pos;
-                        let closing_end = closing_start + closing_pattern.len();
-                        let slot_content = result[cap.end()..closing_start].to_string();
-
-                        matches.push((start, closing_end, slot_content, props));
-                    }
-                }
-
-                if !matches.is_empty() {
-                    changed = true;
-                }
-
-                // Replace from end to start to maintain indices
-                matches.reverse();
-                for (start, end, slot_content, props) in matches {
-                    // Substitute props with full runtime parity (bindings,
-                    // expressions, directive comments, event handlers)
-                    let mut replacement = substitute_props(&element.content, &props);
-
-                    // Replace <slot> tags — wrap children in <slot> boundary, or remove if empty
-                    let slot_wrapped = if slot_content.trim().is_empty() {
-                        String::new()
-                    } else {
-                        format!("<slot>{}</slot>", slot_content)
-                    };
-                    replacement = replacement.replace("<slot></slot>", &slot_wrapped);
-                    replacement = replacement.replace("<slot/>", &slot_wrapped);
-                    replacement = replacement.replace("<slot />", &slot_wrapped);
-
-                    // Keep the wrapper for consistency with runtime (using generic <component> wrapper)
-                    // No src attribute = wrapper won't be re-processed
-                    let wrapper = format!("<component>{}</component>", replacement);
-                    result.replace_range(start..end, &wrapper);
-                }
-            }
-        }
-
-        result
-    }
-
-    /// Recursively inline all <component> elements with their HTML content
-    /// Inline a single component (one pass, no looping)
-    /// Used during recursive component fetching to resolve nested components
-    /// Find the start position of the matching close tag, handling nesting of the same tag.
-    /// `after_open`: byte position immediately after the `>` of the opening tag.
-    /// Returns `(start, end)` byte offsets of the matching close tag: `start` is
-    /// the `<` of `</tag…>` (the slot-content boundary), `end` is just past its
-    /// `>`. Because the end tag may carry whitespace before `>` (`</tag\n>`), the
-    /// caller must use this `end` rather than assuming a `</tag>`-length tag.
-    fn find_matching_close(content: &str, after_open: usize, tag_name: &str) -> Option<(usize, usize)> {
-        // (?:\s|>) ensures <component> matches but not <component-foo> (hyphen is not \s or >)
-        let open_re = regex::Regex::new(&format!(r"<{}(?:\s|>|/>)", regex::escape(tag_name))).unwrap();
-        // `\s*>` tolerates whitespace before the `>` of an end tag — HTML allows
-        // it, and whitespace-controlled markup splits end tags across lines
-        // (`</component\n>`). `\s*` can't bridge into `</component-foo>` (the `-`
-        // is neither whitespace nor `>`), so this stays exact on the tag name.
-        let close_re = regex::Regex::new(&format!(r"</{}\s*>", regex::escape(tag_name))).unwrap();
-
-        let mut depth = 1i32;
-        let mut cursor = after_open;
-
-        while cursor < content.len() {
-            let slice = &content[cursor..];
-            let next_open = open_re.find(slice).map(|m| (m.start(), m.end()));
-            let next_close = close_re.find(slice).map(|m| (m.start(), m.end()));
-
-            match (next_open, next_close) {
-                (None, None) => return None,
-                (None, Some((cs, ce))) => {
-                    depth -= 1;
-                    if depth == 0 { return Some((cursor + cs, cursor + ce)); }
-                    cursor += ce;
-                }
-                (Some((os, oe)), None) => {
-                    // Check if self-closing by finding the end of this tag
-                    if let Some(end) = slice[os..].find('>') {
-                        if slice[os..os + end + 1].ends_with("/>") {
-                            cursor += os + end + 1;
-                        } else {
-                            depth += 1;
-                            cursor += oe;
-                        }
-                    } else {
-                        return None;
-                    }
-                }
-                (Some((os, oe)), Some((cs, ce))) => {
-                    if os < cs {
-                        if let Some(end) = slice[os..].find('>') {
-                            if slice[os..os + end + 1].ends_with("/>") {
-                                cursor += os + end + 1;
-                            } else {
-                                depth += 1;
-                                cursor += oe;
-                            }
-                        } else {
-                            return None;
-                        }
-                    } else {
-                        depth -= 1;
-                        if depth == 0 { return Some((cursor + cs, cursor + ce)); }
-                        cursor += ce;
-                    }
-                }
-            }
-        }
-
-        None
-    }
-
-    pub fn inline_single_component(&self, content: &str, component_src: &str, component_content: &str) -> String {
-        let mut result = content.to_string();
-
-        // Normalize the src for matching
-        let normalized_src = if component_src.starts_with("http://") || component_src.starts_with("https://") {
-            component_src.to_string()
-        } else {
-            let without_prefix = component_src.trim_start_matches("./");
-            if without_prefix.starts_with('/') {
-                without_prefix.to_string()
-            } else {
-                format!("/{}", without_prefix)
-            }
-        };
-
-        // Match only the opening tag — slot content is extracted via depth-counting close search
-        // to correctly handle slot content that contains </div> or nested <component> elements.
-        let pattern = format!(r#"<(component|div)\s+({attr})\bsrc="{src}"\s*({attr})>"#, attr = ATTR_RUN, src = regex::escape(&normalized_src));
-        let open_re = regex::Regex::new(&pattern).unwrap();
-
-        let matches: Vec<_> = open_re.captures_iter(&result).filter_map(|cap| {
-            let open_tag = cap.get(0).unwrap();
-            let tag_name = cap.get(1).unwrap().as_str();
-            let attrs_before = cap.get(2).map(|m| m.as_str()).unwrap_or("");
-            let attrs_after = cap.get(3).map(|m| m.as_str()).unwrap_or("");
-
-            // For <div>, verify it has class="component"
-            if tag_name == "div" {
-                let combined_attrs = format!("{} {}", attrs_before, attrs_after);
-                if !combined_attrs.contains("class=") || !combined_attrs.contains("component") {
-                    return None;
-                }
-            }
-
-            let open_end = open_tag.end();
-            let (close_start, close_end) = Self::find_matching_close(&result, open_end, tag_name)?;
-            let slot_content = result[open_end..close_start].to_string();
-
-            let attrs_str = format!("{} {}", attrs_before, attrs_after);
-            let props: Vec<(String, String)> = Self::parse_props(&attrs_str)
-                .into_iter()
-                .filter(|(n, _)| n != "src" && n != "class")
-                .collect();
-
-            Some((open_tag.start(), close_end, props, slot_content))
-        }).collect();
-
-        // Iter-prop components stay as runtime `<component src>` tags (see
-        // is_iter_prop_root). The content is the same for every match, so skip all.
-        if is_iter_prop_root(component_content) {
-            return result;
-        }
-
-        // Replace from end to start (sorted descending by start position)
-        let mut sorted = matches;
-        sorted.sort_by(|a, b| b.0.cmp(&a.0));
-
-        for (start, end, props, slot_content) in &sorted {
-            let mut replacement = substitute_props(component_content, props);
-            replacement = neuter_component_scripts(&replacement);
-
-            let slot_wrapped = if slot_content.trim().is_empty() { String::new() } else { format!("<slot>{}</slot>", slot_content) };
-            replacement = replacement.replace("<slot></slot>", &slot_wrapped);
-            replacement = replacement.replace("<slot/>", &slot_wrapped);
-            replacement = replacement.replace("<slot />", &slot_wrapped);
-
-            let wrapper = format!("<component>{}</component>", replacement);
-            result.replace_range(*start..*end, &wrapper);
-        }
-
-        result
-    }
-
-    fn inline_component_elements(&self, content: &str, external_cache: &HashMap<String, String>) -> String {
-        let mut result = content.to_string();
-
-        // Match only the opening component tag — slot content is extracted via depth-counting
-        // to correctly handle slot content containing </div> or nested <component> elements.
-        let open_re = regex::Regex::new(
-            &format!(r#"<(component|div)\s+({attr})\bsrc="([^"]+)"({attr})>"#, attr = ATTR_RUN)
-        ).unwrap();
-
-        // Process one match at a time with re-scanning after each replacement.
-        // This is required for nested components (e.g. Layout.html wrapping inner components):
-        // collecting all byte positions at once and applying them in reverse fails because
-        // replacing an inner component changes the string length, invalidating the outer
-        // component's end byte position and causing a char boundary panic.
-        loop {
-            let matches: Vec<_> = open_re.captures_iter(&result).filter_map(|cap| {
-                let open_tag = cap.get(0).unwrap();
-                let tag_name = cap.get(1).unwrap().as_str();
-                let attrs_before = cap.get(2).map(|m| m.as_str()).unwrap_or("");
-                let src = cap.get(3).unwrap().as_str();
-                let attrs_after = cap.get(4).map(|m| m.as_str()).unwrap_or("");
-
-                // For <div>, verify it has class="component"
-                if tag_name == "div" {
-                    let combined_attrs = format!("{} {}", attrs_before, attrs_after);
-                    if !combined_attrs.contains("class=") || !combined_attrs.contains("component") {
-                        return None;
-                    }
-                }
-
-                let open_end = open_tag.end();
-                let (close_start, close_end) = Self::find_matching_close(&result, open_end, tag_name)?;
-                let slot_content = result[open_end..close_start].to_string();
-
-                let attrs_str = format!("{} {}", attrs_before, attrs_after);
-                let props: Vec<(String, String)> = Self::parse_props(&attrs_str)
-                    .into_iter()
-                    .filter(|(n, _)| n != "src" && n != "class")
-                    .collect();
-
-                Some((open_tag.start(), close_end, src.to_string(), props, slot_content))
-            }).collect();
-
-            // Pick the rightmost match that has a cached component and apply it, then re-scan.
-            let mut sorted = matches;
-            sorted.sort_by(|a, b| b.0.cmp(&a.0));
-
-            let mut applied = false;
-            for (start, end, src, props, slot_content) in sorted {
-                let normalized_src = if src.starts_with("http://") || src.starts_with("https://") {
-                    src.to_string()
-                } else {
-                    let without_prefix = src.trim_start_matches("./");
-                    if without_prefix.starts_with('/') {
-                        without_prefix.to_string()
-                    } else {
-                        format!("/{}", without_prefix)
-                    }
-                };
-
-                if let Some(template) = external_cache.get(&normalized_src) {
-                    // Iter-prop components stay as runtime `<component src>` tags so the
-                    // runtime renders them via its __vibeiterprops path — inlining
-                    // breaks the enclosing loop's scope (see is_iter_prop_root).
-                    if is_iter_prop_root(template) {
-                        continue;
-                    }
-                    let mut replacement = substitute_props(template, &props);
-                    replacement = neuter_component_scripts(&replacement);
-
-                    let slot_wrapped = if slot_content.trim().is_empty() { String::new() } else { format!("<slot>{}</slot>", slot_content) };
-                    replacement = replacement.replace("<slot></slot>", &slot_wrapped);
-                    replacement = replacement.replace("<slot/>", &slot_wrapped);
-                    replacement = replacement.replace("<slot />", &slot_wrapped);
-
-                    let wrapper = format!("<component>{}</component>", replacement);
-                    result.replace_range(start..end, &wrapper);
-                    applied = true;
-                    break;
-                }
-            }
-
-            if !applied {
-                break;
-            }
-        }
-
-        result
-    }
-
-    /// Parse component props from attributes string, in source order.
-    /// Supports valued (`headline="@[pageTitle]"`) and bare boolean
-    /// (`dndDisabled`) attributes — the runtime receives bare attributes from
-    /// the DOM with an empty-string value, so they're captured the same here.
-    fn parse_props(attrs_str: &str) -> Vec<(String, String)> {
-        let mut props = Vec::new();
-
-        let attr_re = regex::Regex::new(r#"([\w-]+)(?:="([^"]*)")?"#).unwrap();
-
-        for cap in attr_re.captures_iter(attrs_str) {
-            let name = cap.get(1).unwrap().as_str().to_string();
-            let value = cap.get(2).map(|m| m.as_str().to_string()).unwrap_or_default();
-            props.push((name, value));
-        }
-
-        props
-    }
-}
-
-/// Neuter component scripts inlined from `<component src>` templates:
-/// `<script type="module">` becomes `<script type="vibe-module">` so the
-/// browser does NOT execute it as a native page module (wrong timing —
-/// pre-boot, placeholder `$`, no live state merge). The runtime executes
-/// vibe-module scripts through the same injected-component() path it uses
-/// for fetched component scripts, giving compiled and runtime pages one
-/// script-execution pipeline with identical semantics. Runs before slot
-/// inlining so caller-authored slot scripts stay native.
-fn neuter_component_scripts(html: &str) -> String {
-    html.replace("<script type=\"module\"", "<script type=\"vibe-module\"")
-}
-
-/// A run of HTML attributes where `>` is permitted only inside a quoted value.
-/// Mirrors a real HTML tokenizer: a tag ends on an *unquoted* `>` only. Without
-/// this, a binding prop like `flipped="@[a >= b]"` truncates the open tag at the
-/// `>` inside its value, so the trailing attributes get mis-parsed (empty
-/// boolean props → literal `true`) and corrupt the inlined template.
-const ATTR_RUN: &str = r#"(?:"[^"]*"|'[^']*'|[^>"'])*"#;
-
-fn is_ident_byte(b: u8) -> bool {
-    b.is_ascii_alphanumeric() || b == b'_' || b == b'$'
-}
-
-/// Case-insensitive free-identifier substitution, mirroring the runtime's
-/// renderPropsAndSlot idRegex: the name must not be preceded by an identifier
-/// character or `.` (property access) and not followed by an identifier
-/// character. Case-insensitive because HTML lowercases attribute names while
-/// component templates reference the author's camelCase identifiers.
-fn substitute_identifier(expr: &str, name: &str, replacement: &str) -> String {
-    let bytes = expr.as_bytes();
-    let nb = name.as_bytes();
-    let nlen = nb.len();
-    if nlen == 0 {
-        return expr.to_string();
-    }
-    let mut out: Vec<u8> = Vec::with_capacity(bytes.len());
-    let mut i = 0;
-    // Delimiter of the string literal we're currently inside, or 0 when in code.
-    // A prop identifier that appears inside a quoted string (e.g. the selector in
-    // `closest('brawler-slot')`) must be left intact, mirroring the runtime's
-    // substituteInExpr. Template `${…}` counts as part of the literal here.
-    let mut quote: u8 = 0;
-    while i < bytes.len() {
-        let b = bytes[i];
-        if quote != 0 {
-            out.push(b);
-            if b == b'\\' && i + 1 < bytes.len() {
-                out.push(bytes[i + 1]);
-                i += 2;
-                continue;
-            }
-            if b == quote {
-                quote = 0;
-            }
-            i += 1;
-            continue;
-        }
-        if b == b'\'' || b == b'"' || b == b'`' {
-            quote = b;
-            out.push(b);
-            i += 1;
-            continue;
-        }
-        if i + nlen <= bytes.len()
-            && bytes[i..i + nlen].eq_ignore_ascii_case(nb)
-            && (i == 0 || (!is_ident_byte(bytes[i - 1]) && bytes[i - 1] != b'.'))
-            && (i + nlen == bytes.len() || !is_ident_byte(bytes[i + nlen]))
-        {
-            out.extend_from_slice(replacement.as_bytes());
-            i += nlen;
-        } else {
-            out.push(b);
-            i += 1;
-        }
-    }
-    String::from_utf8(out).unwrap()
-}
-
-/// `$.propName` rewrites inside event-handler bodies (the runtime's stateRegex
-/// pass): for a binding prop `value="@[email]"`, `$.value = this.value`
-/// becomes `$.email = this.value` — DOM property reads (`this.value`) stay.
-fn substitute_state_ref(body: &str, name: &str, replacement: &str) -> String {
-    let bytes = body.as_bytes();
-    let nb = name.as_bytes();
-    let nlen = nb.len();
-    if nlen == 0 {
-        return body.to_string();
-    }
-    let mut out: Vec<u8> = Vec::with_capacity(bytes.len());
-    let mut i = 0;
-    while i < bytes.len() {
-        if bytes[i] == b'$'
-            && i + 2 + nlen <= bytes.len()
-            && bytes[i + 1] == b'.'
-            && bytes[i + 2..i + 2 + nlen].eq_ignore_ascii_case(nb)
-            && (i + 2 + nlen == bytes.len() || !is_ident_byte(bytes[i + 2 + nlen]))
-        {
-            out.extend_from_slice(b"$.");
-            out.extend_from_slice(replacement.as_bytes());
-            i += 2 + nlen;
-        } else {
-            out.push(bytes[i]);
-            i += 1;
-        }
-    }
-    String::from_utf8(out).unwrap()
-}
-
-/// Substitute component props into a template — the compiled twin of the
-/// runtime's renderPropsAndSlot (runtime/component.js). Both sides must
-/// transform identically:
-///   - exact `@[propName]` bindings (case-insensitive)
-/// Whether a component template's ROOT is an array-literal each
-/// (`<!-- each [expr] as a -->`). Such a component receives its iterable as a prop
-/// and depends on the runtime's `__vibeiterprops` indirection: the runtime
-/// evaluates the prop binding in the *enclosing* loop scope, stores the value in a
-/// global registry slot, and rewrites the each to iterate that slot. Inlining
-/// instead bakes the call-site's parent-loop alias straight into the each
-/// (`[card.signatureAbility]`); the runtime evaluates an array-literal iterable in
-/// GLOBAL scope (that's the registry-slot pattern), where the alias is undefined →
-/// the loop yields zero items (the empty AbilityCell / status-chip bug in compiled
-/// mode). So such components are NOT inlined — they stay as runtime
-/// `<component src>` tags, and the compiler ships their source so the runtime can
-/// fetch and instantiate them exactly as it does in non-compiled mode.
-fn is_iter_prop_root(template: &str) -> bool {
-    let t = template.trim_start();
-    t.strip_prefix("<!--")
-        .map(str::trim_start)
-        .and_then(|r| r.strip_prefix("each"))
-        .map(str::trim_start)
-        .is_some_and(|after| after.starts_with('['))
-}
-
-/// Substitute component props into a template.
-///
-/// Rewrites:
-///   - prop identifiers inside other `@[expr]` bindings
-///   - prop identifiers inside directive comments (`if` / `else if` / `each`)
-///   - `$.propName` references inside event-handler attribute bodies
-/// Binding props (`prop="@[path]"`) rewrite identifiers to the bound path;
-/// literal props inject the value (bare boolean attrs → true, strings
-/// JSON-quoted, numerics raw).
-fn substitute_props(template: &str, props: &[(String, String)]) -> String {
-    let binding_re = regex::Regex::new(r"@\[([^\]]+)\]").unwrap();
-    let directive_re = regex::Regex::new(r"(?s)<!--\s*(if|else if|each)\s+(.*?)\s*-->").unwrap();
-    let event_re = regex::Regex::new(r#"\bon(\w+)="([^"]*)""#).unwrap();
-    let numeric_re = regex::Regex::new(r"(?i)^-?\d+(\.\d+)?(e[+-]?\d+)?$").unwrap();
-
-    let mut html = template.to_string();
-
-    for (prop_name, prop_value) in props {
-        let exact_re =
-            regex::Regex::new(&format!(r"(?i)@\[{}\]", regex::escape(prop_name))).unwrap();
-
-        let binding_path = prop_value
-            .strip_prefix("@[")
-            .and_then(|v| v.strip_suffix(']'));
-
-        let (exact_repl, ident_repl, each_repl, state_repl) = if let Some(path) = binding_path {
-            (
-                format!("@[{}]", path),
-                format!("({})", path),
-                path.to_string(),
-                path.to_string(),
-            )
-        } else {
-            let literal = if prop_value.is_empty() {
-                "true".to_string()
-            } else if numeric_re.is_match(prop_value) {
-                prop_value.clone()
-            } else {
-                serde_json::to_string(prop_value).unwrap()
-            };
-            (prop_value.clone(), literal.clone(), literal.clone(), literal)
-        };
-
-        html = exact_re
-            .replace_all(&html, regex::NoExpand(exact_repl.as_str()))
-            .to_string();
-
-        html = binding_re
-            .replace_all(&html, |c: &regex::Captures| {
-                let expr = c.get(1).unwrap().as_str();
-                let rewritten = substitute_identifier(expr, prop_name, &ident_repl);
-                if rewritten == expr {
-                    c.get(0).unwrap().as_str().to_string()
-                } else {
-                    format!("@[{}]", rewritten)
-                }
-            })
-            .to_string();
-
-        html = directive_re
-            .replace_all(&html, |c: &regex::Captures| {
-                let kw = c.get(1).unwrap().as_str();
-                let expr = c.get(2).unwrap().as_str();
-                let repl = if kw == "each" { each_repl.as_str() } else { ident_repl.as_str() };
-                let rewritten = substitute_identifier(expr, prop_name, repl);
-                if rewritten == expr {
-                    c.get(0).unwrap().as_str().to_string()
-                } else {
-                    format!("<!-- {} {} -->", kw, rewritten)
-                }
-            })
-            .to_string();
-
-        html = event_re
-            .replace_all(&html, |c: &regex::Captures| {
-                let ev = c.get(1).unwrap().as_str();
-                let body = c.get(2).unwrap().as_str();
-                // First the `$.prop` form, then the bare prop identifier — mirroring
-                // the runtime's two-step rewrite so `onclick="pick(item)"` resolves
-                // the live prop instead of throwing ReferenceError in global scope.
-                // The bare pass skips `$.prop` (its `.`-lookbehind guard) so the two
-                // don't collide.
-                let after_state = substitute_state_ref(body, prop_name, &state_repl);
-                let rewritten = substitute_identifier(&after_state, prop_name, &ident_repl);
-                if rewritten == body {
-                    c.get(0).unwrap().as_str().to_string()
-                } else {
-                    format!(r#"on{}="{}""#, ev, rewritten)
-                }
-            })
-            .to_string();
-    }
-
-    html
-}
-
-/// Transform custom HTML elements to divs with classes
-fn transform_custom_tags_to_divs(content: &str, reserved_elements: &[String]) -> String {
-    let mut result = content.to_string();
-
-    // Standard HTML5 elements (should not be transformed)
-    let standard_tags: HashSet<&str> = [
-        "a", "abbr", "address", "area", "article", "aside", "audio",
-        "b", "base", "bdi", "bdo", "blockquote", "body", "br", "button",
-        "canvas", "caption", "cite", "code", "col", "colgroup",
-        "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt",
-        "em", "embed",
-        "fieldset", "figcaption", "figure", "footer", "form",
-        "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html",
-        "i", "iframe", "img", "input", "ins",
-        "kbd",
-        "label", "legend", "li", "link",
-        "main", "map", "mark", "menu", "meta", "meter",
-        "nav", "noscript",
-        "object", "ol", "optgroup", "option", "output",
-        "p", "param", "picture", "pre", "progress",
-        "q",
-        "rp", "rt", "ruby",
-        "s", "samp", "script", "search", "section", "select", "slot", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "svg",
-        "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track",
-        "u", "ul",
-        "var", "video",
-        "wbr",
-    ].into_iter().collect();
-
-    // Find all custom tags and transform them
-    let tag_pattern = regex::Regex::new(r"<([a-z][a-z0-9-]*)([^>]*)>").unwrap();
-    let _closing_pattern = regex::Regex::new(r"</([a-z][a-z0-9-]*)>").unwrap();
-
-    // Collect unique custom tags (excluding standard HTML tags and reserved elements)
-    let mut custom_tags: Vec<String> = Vec::new();
-    for cap in tag_pattern.captures_iter(&result.clone()) {
-        if let Some(m) = cap.get(1) {
-            let tag = m.as_str().to_string();
-            if !standard_tags.contains(tag.as_str())
-                && !reserved_elements.contains(&tag)
-                && !custom_tags.contains(&tag)
-            {
-                custom_tags.push(tag);
-            }
-        }
-    }
-
-    // Sort by descending length so more specific tags (e.g. "accordion-content")
-    // are processed before shorter prefixes (e.g. "accordion"), preventing
-    // partial tag-name matches like <accordion([^>]*)> matching <accordion-content>
-    custom_tags.sort_by(|a, b| b.len().cmp(&a.len()));
-
-    // Pre-compile class attribute regex for merging existing class values
-    let class_attr_re = regex::Regex::new(r#"\bclass="([^"]*)""#).unwrap();
-
-    // Transform each custom tag
-    for tag in &custom_tags {
-        // Opening tag: require whitespace or end-of-tag after the tag name so that
-        // <accordion> does not accidentally match <accordion-content>
-        let open_re = regex::Regex::new(
-            &format!(r"<{}([\s][^>]*|)>", regex::escape(tag))
-        ).unwrap();
-
-        result = open_re.replace_all(&result, |caps: &regex::Captures| -> String {
-            let attrs = caps.get(1).map(|m| m.as_str()).unwrap_or("");
-
-            // If the element already has class="...", merge tag name with existing value
-            if let Some(class_cap) = class_attr_re.captures(attrs) {
-                let existing = class_cap.get(1).unwrap().as_str();
-                let merged = format!("{} {}", tag, existing);
-                let new_attrs = class_attr_re.replace(
-                    attrs,
-                    format!(r#"class="{}""#, merged.trim()).as_str(),
-                );
-                format!("<div{}>", new_attrs)
-            } else {
-                format!("<div class=\"{}\"{}>", tag, attrs)
-            }
-        }).to_string();
-
-        // Closing tag: </custom-tag> -> </div>
-        let close_re = regex::Regex::new(&format!(r"</{}>", regex::escape(tag))).unwrap();
-        result = close_re.replace_all(&result, "</div>").to_string();
-    }
-
-    // Note: <component> tags are NOT transformed - they are a framework element, not a custom element
-    // Only user-defined custom elements are transformed to divs
-
-    result
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn find_matching_close_tolerates_whitespace_in_end_tag() {
-        // Whitespace-controlled markup splits an end tag across lines, e.g.
-        //   <icon-cell
-        //     ><component src="x"></component
-        //   ></icon-cell>
-        // which reaches the inliner as `</component\n>`. HTML permits
-        // whitespace before the `>` of an end tag, so the depth counter must
-        // treat `</component\n>` as the nested close. If it doesn't, the nested
-        // open is counted but never closed and the OUTER close search overshoots,
-        // swallowing every following sibling into the component.
-        let content = "<component><a><component src=\"x\"></component\n></a></component><sibling></sibling>";
-        let after_open = "<component>".len();
-
-        let (close, close_end) = HtmlParser::find_matching_close(content, after_open, "component")
-            .expect("outer </component> must be found");
-
-        // The match must be the OUTER close (immediately before <sibling>), not
-        // an overshoot past it.
-        assert!(content[close..].starts_with("</component>"), "matched wrong close: {:?}", &content[close..close + 14]);
-        assert!(content[close..].contains("<sibling>"), "sibling was swallowed into the component");
-        // The reported end lands just past the close tag's `>`.
-        assert!(content[..close_end].ends_with('>'), "close_end must sit right after the `>`");
-    }
-
-    #[test]
-    fn inline_component_with_split_end_tag_leaves_no_stray_gt() {
-        // Prettier's whitespace-controlled wrapping splits an end tag across
-        // lines (`</component\n>`). find_matching_close tolerates that whitespace
-        // when locating the close, but the caller computed the replacement end as
-        // `close_start + len("</component>")` — too short by the whitespace before
-        // the `>`. The final `>` was therefore left behind as a stray text node
-        // (the literal ">" that leaked next to inlined components in the app).
-        let parser = HtmlParser::new(std::path::PathBuf::from("."));
-        let page = "<wrap><component src=\"/components/Potion.html\"></component\n></wrap>";
-        let template = "<icon potion></icon>";
-        let mut cache = HashMap::new();
-        cache.insert("/components/Potion.html".to_string(), template.to_string());
-
-        let out = parser.inline_component_elements(page, &cache);
-
-        assert_eq!(
-            out, "<wrap><component><icon potion></icon></component></wrap>",
-            "split end tag left a stray `>` (or otherwise mis-sliced the close): {out}"
-        );
-    }
-
-    #[test]
-    fn inline_component_tolerates_gt_in_prop_binding() {
-        // A component prop whose `@[...]` value contains a comparison operator
-        // (`>=`) must not truncate the open tag at the `>` *inside the value*.
-        // The flawed `[^>]*` attribute run cut the tag mid-attribute, so the
-        // trailing identifiers (`selectedBrawlers`, `length`) were mis-parsed as
-        // empty boolean props (→ literal `true`), rewriting the loop expression
-        // to `brawlHandCards(characters, true)` — which throws `true.includes is
-        // not a function` at runtime, so the card discs never render.
-        let parser = HtmlParser::new(std::path::PathBuf::from("."));
-        let page = concat!(
-            r#"<page><component src="/components/remote/CardHand.html" "#,
-            r#"cards="@[brawlHandCards(characters, selectedBrawlers)]" "#,
-            r#"flipped="@[selectedBrawlers.length >= maxBrawlers]" "#,
-            r#"angle="16"></component></page>"#,
-        );
-        let template = concat!(
-            r#"<card-hand flipped="@[flipped]"><card-fan style="--angle: @[angle]deg">"#,
-            r#"<!-- each cards as card (card.id), i --><card-slot data-id="@[card.id]"></card-slot>"#,
-            r#"<!-- /each --></card-fan></card-hand>"#,
-        );
-        let mut cache = HashMap::new();
-        cache.insert("/components/remote/CardHand.html".to_string(), template.to_string());
-
-        let out = parser.inline_component_elements(page, &cache);
-
-        // The loop expression must carry `selectedBrawlers` through untouched.
-        assert!(
-            out.contains("brawlHandCards(characters, selectedBrawlers)"),
-            "loop expression corrupted: {out}"
-        );
-        assert!(
-            !out.contains("brawlHandCards(characters, true)"),
-            "selectedBrawlers wrongly replaced with `true`: {out}"
-        );
-        // The binding prop keeps its full comparison expression.
-        assert!(
-            out.contains(r#"flipped="@[selectedBrawlers.length >= maxBrawlers]""#),
-            "flipped binding lost: {out}"
-        );
-        // A literal prop *after* the `>=` prop must still substitute — proof the
-        // tag was parsed to the real `>`, not the one inside the value.
-        assert!(out.contains("--angle: 16deg"), "angle not substituted: {out}");
-    }
-
-    #[test]
-    fn inline_custom_element_tolerates_gt_in_prop_binding() {
-        // Same defect in the custom-element inliner's `<tag(\s[^>]*)?>` regex.
-        // (Cached element tags are filename-derived single words — see element.rs.)
-        let mut parser = HtmlParser::new(std::path::PathBuf::from("."));
-        parser.cache.insert(
-            "gauge".to_string(),
-            Element::new(
-                "gauge".to_string(),
-                std::path::PathBuf::from("gauge.html"),
-                r#"<gauge-inner show="@[show]" n="@[count]"></gauge-inner>"#.to_string(),
-            ),
-        );
-
-        let page = r#"<page><gauge show="@[items.length >= max]" count="7"></gauge></page>"#;
-        let out = parser.inline_custom_elements(page);
-
-        // The `>=` inside the binding must not have truncated the open tag.
-        assert!(
-            out.contains(r#"show="@[items.length >= max]""#),
-            "show binding lost: {out}"
-        );
-        // A literal prop after the `>=` prop still substitutes → tag parsed fully.
-        assert!(out.contains(r#"n="7""#), "count not substituted: {out}");
-    }
-
-    #[test]
-    fn each_root_component_is_left_for_runtime() {
-        // A component whose ROOT is an array-literal each (`<!-- each [prop] as a -->`)
-        // depends on the runtime's __vibeiterprops indirection (the runtime evaluates
-        // the prop in the enclosing loop scope and stashes it in a global registry
-        // slot the each iterates). Inlining bakes the parent-loop alias into the each
-        // (`[card.signatureAbility]`); the runtime evaluates array-literal iterables
-        // in GLOBAL scope, where that alias is undefined → zero items (the empty
-        // AbilityCell / status-chip bug). So such a component must NOT be inlined:
-        // leave the `<component src=...>` tag for the runtime to fetch and instantiate.
-        let parser = HtmlParser::new(std::path::PathBuf::from("."));
-        let page = concat!(
-            r#"<!-- each cards as card --><card-section>"#,
-            r#"<component src="/components/AbilityCell.html" ability="@[card.signatureAbility]"></component>"#,
-            r#"</card-section><!-- /each -->"#,
-        );
-        // AbilityCell's root is an each over the `[ability]` array-literal prop.
-        let template = r#"<!-- each [ability] as a --><ability-tile><icon @[a.icon]></icon></ability-tile><!-- /each -->"#;
-        let mut cache = HashMap::new();
-        cache.insert("/components/AbilityCell.html".to_string(), template.to_string());
-
-        let out = parser.inline_component_elements(page, &cache);
-
-        // Left un-inlined for the runtime, with its prop binding intact…
-        assert!(
-            out.contains(r#"<component src="/components/AbilityCell.html""#),
-            "each-root component must be left un-inlined for the runtime: {out}"
-        );
-        assert!(
-            out.contains(r#"ability="@[card.signatureAbility]""#),
-            "prop binding lost on un-inlined component: {out}"
-        );
-        // …and the parent-loop alias must NOT have been baked into an each iterable.
-        assert!(
-            !out.contains("each [card.signatureAbility]"),
-            "parent-loop alias was inlined into the component each (the bug): {out}"
-        );
-    }
-
-    #[test]
-    fn ordinary_component_still_inlines() {
-        // Guard: a normal component (root is NOT an array-literal each) must still
-        // inline as before — the skip is scoped to the iter-prop pattern only.
-        let parser = HtmlParser::new(std::path::PathBuf::from("."));
-        let page = r#"<page><component src="/components/Badge.html" label="@[title]"></component></page>"#;
-        let template = r#"<badge-pill>@[label]</badge-pill>"#;
-        let mut cache = HashMap::new();
-        cache.insert("/components/Badge.html".to_string(), template.to_string());
-
-        let out = parser.inline_component_elements(page, &cache);
-
-        assert!(out.contains("<badge-pill>"), "ordinary component should inline: {out}");
-        assert!(!out.contains(r#"src="/components/Badge.html""#), "ordinary component src should be gone: {out}");
-    }
-}