@ape-egg/vibe-compiler 4.1.2 → 4.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ape-egg/vibe-compiler",
-  "version": "4.1.2",
+  "version": "4.1.4",
   "type": "module",
   "description": "Optional Rust compiler for Vibe — pre-renders, inlines components, and optimizes iterations. The runtime never needs it.",
   "homepage": "https://vibe.korte.kim",

package/src/Cargo.lock

@@ -1599,7 +1599,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "vibe-compiler"
-version = "4.1.1"
+version = "4.1.4"
 dependencies = [
  "clap",
  "colored",

package/src/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vibe-compiler"
-version = "4.1.1"
+version = "4.1.4"
 edition = "2021"
 description = "Vibe framework compiler - compiles Vibe source files into optimized output"
 authors = ["Kim Korte"]

package/src/compiler/name_binding_protect.rs

@@ -18,12 +18,12 @@ pub const NAME_BIND_ATTR: &str = "data-vibe-namebind";
 /// identical behaviour, no expression rewriting. Whitespace-free name-bindings already
 /// survive as-is and are left untouched.
 pub fn protect(html: &str) -> String {
-    // <script>/<style> bodies are raw text — a `<` inside them must not be read as a
-    // tag. Park them behind comment placeholders for the tag scan, restore after.
-    let (masked, raw_blocks) = mask_raw_text(html);
+    crate::inert::protect(html, relocate_bindings)
+}
 
-    let out = tag_open_regex()
-        .replace_all(&masked, |caps: &regex::Captures| {
+fn relocate_bindings(html: &str) -> String {
+    tag_open_regex()
+        .replace_all(html, |caps: &regex::Captures| {
             let name = &caps[1];
             let attrs = &caps[2];
             let (kept, relocated) = relocate_unsafe(attrs);
@@ -41,9 +41,7 @@ pub fn protect(html: &str) -> String {
                 name, body, NAME_BIND_ATTR, relocated, self_close
             )
         })
-        .to_string();
-
-    restore_raw_text(&out, &raw_blocks)
+        .to_string()
 }
 
 /// Matches an opening tag and captures (name, attribute-section). Quoted values may
@@ -124,33 +122,6 @@ fn relocate_unsafe(attrs: &str) -> (String, String) {
     (kept, relocated)
 }
 
-fn raw_text_regex() -> &'static Regex {
-    static RE: OnceLock<Regex> = OnceLock::new();
-    RE.get_or_init(|| Regex::new(r"(?is)<(script|style)\b[^>]*>.*?</(?:script|style)>").unwrap())
-}
-
-fn mask_raw_text(html: &str) -> (String, Vec<String>) {
-    let mut blocks = Vec::new();
-    let mut out = String::with_capacity(html.len());
-    let mut last = 0;
-    for mat in raw_text_regex().find_iter(html) {
-        out.push_str(&html[last..mat.start()]);
-        out.push_str(&format!("<!--VIBE_RAWTEXT_{}-->", blocks.len()));
-        blocks.push(html[mat.start()..mat.end()].to_string());
-        last = mat.end();
-    }
-    out.push_str(&html[last..]);
-    (out, blocks)
-}
-
-fn restore_raw_text(html: &str, blocks: &[String]) -> String {
-    let mut out = html.to_string();
-    for (i, block) in blocks.iter().enumerate() {
-        out = out.replace(&format!("<!--VIBE_RAWTEXT_{}-->", i), block);
-    }
-    out
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

package/src/main.rs

@@ -1,4 +1,5 @@
 mod config;
+mod inert;
 mod parser;
 mod compiler;
 

package/src/parser/html.rs

@@ -4,6 +4,7 @@ use std::collections::{HashMap, HashSet};
 use thiserror::Error;
 
 use super::element::{Element, ElementCache};
+use crate::inert::Inert;
 
 #[derive(Error, Debug)]
 pub enum ParseError {
@@ -178,7 +179,8 @@ impl HtmlParser {
             return content.to_string(); // No custom elements to inline
         }
 
-        let mut result = content.to_string();
+        let mut inert = Inert::new();
+        let mut result = inert.mask(content);
         let mut changed = true;
         let mut iterations = 0;
         const MAX_ITERATIONS: usize = 10; // Reasonable limit for deeply nested custom elements
@@ -244,13 +246,13 @@ impl HtmlParser {
 
                     // 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);
+                    let wrapper = inert.mask(&format!("<component>{}</component>", replacement));
                     result.replace_range(start..end, &wrapper);
                 }
             }
         }
 
-        result
+        inert.restore(&result)
     }
 
     /// Recursively inline all <component> elements with their HTML content
@@ -262,7 +264,7 @@ impl HtmlParser {
     /// 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)> {
+    pub(crate) 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
@@ -324,7 +326,8 @@ impl HtmlParser {
     }
 
     pub fn inline_single_component(&self, content: &str, component_src: &str, component_content: &str) -> String {
-        let mut result = content.to_string();
+        let mut inert = Inert::new();
+        let mut result = inert.mask(content);
 
         // Normalize the src for matching
         let normalized_src = if component_src.starts_with("http://") || component_src.starts_with("https://") {
@@ -373,7 +376,7 @@ impl HtmlParser {
         // 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;
+            return inert.restore(&result);
         }
 
         // Replace from end to start (sorted descending by start position)
@@ -389,15 +392,16 @@ impl HtmlParser {
             replacement = replacement.replace("<slot/>", &slot_wrapped);
             replacement = replacement.replace("<slot />", &slot_wrapped);
 
-            let wrapper = format!("<component>{}</component>", replacement);
+            let wrapper = inert.mask(&format!("<component>{}</component>", replacement));
             result.replace_range(*start..*end, &wrapper);
         }
 
-        result
+        inert.restore(&result)
     }
 
     fn inline_component_elements(&self, content: &str, external_cache: &HashMap<String, String>) -> String {
-        let mut result = content.to_string();
+        let mut inert = Inert::new();
+        let mut result = inert.mask(content);
 
         // Match only the opening component tag — slot content is extracted via depth-counting
         // to correctly handle slot content containing </div> or nested <component> elements.
@@ -471,7 +475,7 @@ impl HtmlParser {
                     replacement = replacement.replace("<slot/>", &slot_wrapped);
                     replacement = replacement.replace("<slot />", &slot_wrapped);
 
-                    let wrapper = format!("<component>{}</component>", replacement);
+                    let wrapper = inert.mask(&format!("<component>{}</component>", replacement));
                     result.replace_range(start..end, &wrapper);
                     applied = true;
                     break;
@@ -483,7 +487,7 @@ impl HtmlParser {
             }
         }
 
-        result
+        inert.restore(&result)
     }
 
     /// Parse component props from attributes string, in source order.
@@ -736,6 +740,10 @@ fn substitute_props(template: &str, props: &[(String, String)]) -> String {
 
 /// Transform custom HTML elements to divs with classes
 fn transform_custom_tags_to_divs(content: &str, reserved_elements: &[String]) -> String {
+    crate::inert::protect(content, |content| transform_custom_tags(content, reserved_elements))
+}
+
+fn transform_custom_tags(content: &str, reserved_elements: &[String]) -> String {
     let mut result = content.to_string();
 
     // Standard HTML5 elements (should not be transformed)
@@ -986,6 +994,116 @@ mod tests {
         );
     }
 
+    #[test]
+    fn component_tag_inside_script_string_is_not_inlined() {
+        let parser = HtmlParser::new(std::path::PathBuf::from("."));
+        let page = concat!(
+            r#"<page><script>const tpl = '<component src="/components/Badge.html"></component>';</script>"#,
+            r#"<component src="/components/Badge.html"></component></page>"#,
+        );
+        let mut cache = HashMap::new();
+        cache.insert("/components/Badge.html".to_string(), "<badge-pill>hi</badge-pill>".to_string());
+
+        let out = parser.inline_component_elements(page, &cache);
+
+        assert!(
+            out.contains(r#"const tpl = '<component src="/components/Badge.html"></component>';"#),
+            "script string literal was rewritten: {out}"
+        );
+        assert!(
+            out.contains("<component><badge-pill>hi</badge-pill></component>"),
+            "the real component was not inlined: {out}"
+        );
+        assert_eq!(out.matches("<badge-pill>").count(), 1, "template leaked into the script: {out}");
+    }
+
+    #[test]
+    fn component_tag_inside_dehydrate_block_is_not_inlined() {
+        let parser = HtmlParser::new(std::path::PathBuf::from("."));
+        let page = concat!(
+            r#"<docs><code vibe-dehydrate><component src="/components/Badge.html"></component></code>"#,
+            r#"<component src="/components/Badge.html"></component></docs>"#,
+        );
+        let mut cache = HashMap::new();
+        cache.insert("/components/Badge.html".to_string(), "<badge-pill>hi</badge-pill>".to_string());
+
+        let out = parser.inline_component_elements(page, &cache);
+
+        assert!(
+            out.contains(r#"<code vibe-dehydrate><component src="/components/Badge.html"></component></code>"#),
+            "dehydrated markup was inlined: {out}"
+        );
+        assert_eq!(out.matches("<badge-pill>").count(), 1, "template leaked into the dehydrate block: {out}");
+    }
+
+    #[test]
+    fn component_tag_inside_pre_is_not_inlined() {
+        let parser = HtmlParser::new(std::path::PathBuf::from("."));
+        let page = concat!(
+            r#"<docs><pre><component src="/components/Badge.html"></component></pre>"#,
+            r#"<component src="/components/Badge.html"></component></docs>"#,
+        );
+        let mut cache = HashMap::new();
+        cache.insert("/components/Badge.html".to_string(), "<badge-pill>hi</badge-pill>".to_string());
+
+        let out = parser.inline_component_elements(page, &cache);
+
+        assert!(
+            out.contains(r#"<pre><component src="/components/Badge.html"></component></pre>"#),
+            "markup inside <pre> was inlined: {out}"
+        );
+        assert_eq!(out.matches("<badge-pill>").count(), 1, "template leaked into the <pre>: {out}");
+    }
+
+    #[test]
+    fn custom_element_inside_script_string_is_not_inlined() {
+        let mut parser = HtmlParser::new(std::path::PathBuf::from("."));
+        parser.cache.insert(
+            "badge".to_string(),
+            Element::new(
+                "badge".to_string(),
+                std::path::PathBuf::from("badge.html"),
+                "<badge-pill>hi</badge-pill>".to_string(),
+            ),
+        );
+
+        let page = concat!(
+            r#"<page><script>el.innerHTML = '<badge></badge>';</script>"#,
+            r#"<badge></badge></page>"#,
+        );
+
+        let out = parser.inline_custom_elements(page);
+
+        assert!(
+            out.contains(r#"el.innerHTML = '<badge></badge>';"#),
+            "script string literal was rewritten: {out}"
+        );
+        assert_eq!(out.matches("<badge-pill>").count(), 1, "template leaked into the script: {out}");
+    }
+
+    #[test]
+    fn custom_element_inside_dehydrate_block_is_not_inlined() {
+        let mut parser = HtmlParser::new(std::path::PathBuf::from("."));
+        parser.cache.insert(
+            "badge".to_string(),
+            Element::new(
+                "badge".to_string(),
+                std::path::PathBuf::from("badge.html"),
+                "<badge-pill>hi</badge-pill>".to_string(),
+            ),
+        );
+
+        let page = r#"<docs><code vibe-dehydrate><badge></badge></code><badge></badge></docs>"#;
+
+        let out = parser.inline_custom_elements(page);
+
+        assert!(
+            out.contains(r#"<code vibe-dehydrate><badge></badge></code>"#),
+            "dehydrated markup was inlined: {out}"
+        );
+        assert_eq!(out.matches("<badge-pill>").count(), 1, "template leaked into the dehydrate block: {out}");
+    }
+
     #[test]
     fn ordinary_component_still_inlines() {
         // Guard: a normal component (root is NOT an array-literal each) must still