fix(mustache): do not render mustaches ahead of child processing

@mizu/mustache/README.md

@@ -20,5 +20,5 @@ Enable content interpolation within « mustaches » ( `{{` and `}}`) from [`Text
 > [!NOTE]
 > HTML content is automatically escaped.
 
-> [!WARNING]
+> [!NOTE]
 > There is currently no distinction between double mustaches ( `{{` and `}}`) and triple mustaches ( `{{{` and `}}}`), but future versions may introduce specific behavior for these.

@mizu/mustache/mod.ts

@@ -10,33 +10,42 @@ export const _mustache = {
   init(renderer) {
     renderer.cache<Cache<typeof _mustache>>(this.name, new WeakMap())
   },
+  setup(renderer, _, { state }) {
+    if (state[renderer.internal("mustaching")]) {
+      return { execute: true }
+    }
+  },
   async execute(renderer, element, { cache, ...options }) {
     if (!renderer.isHtmlElement(element)) {
       return
     }
-    const filter = renderer.window.NodeFilter.SHOW_TEXT
-    const walker = renderer.document.createTreeWalker(element, filter, { acceptNode: () => renderer.window.NodeFilter.FILTER_ACCEPT })
-    while (walker.nextNode()) {
-      const node = walker.currentNode as Text
-      if (!cache.has(node)) {
-        cache.set(node, node.textContent!)
-      }
-      try {
-        const template = cache.get(node)!
-        let templated = template
-        let offset = 0
-        let captured = null as ReturnType<typeof capture>
-        // deno-lint-ignore no-cond-assign
-        while (captured = capture(template, offset)) {
-          const { b, match, captured: expression } = captured
-          templated = templated.replace(match, `${await renderer.evaluate(element, expression, options).catch((error) => (renderer.warn(error, element), null)) ?? ""}`)
-          offset = b
+    await Promise.allSettled(
+      Array.from(element.childNodes).map(async (node) => {
+        if (node.nodeType !== renderer.window.Node.TEXT_NODE) {
+          return
         }
-        node.textContent = templated
-      } catch (error) {
-        renderer.warn(`${error}`.split("\n")[0], element)
-      }
-    }
+        const text = node as Text
+        if (!cache.has(text)) {
+          cache.set(text, text.textContent!)
+        }
+        try {
+          const template = cache.get(text)!
+          let templated = template
+          let offset = 0
+          let captured = null as ReturnType<typeof capture>
+          // deno-lint-ignore no-cond-assign
+          while (captured = capture(template, offset)) {
+            const { b, match, captured: expression } = captured
+            templated = templated.replace(match, `${await renderer.evaluate(element, expression, options).catch((error) => (renderer.warn(error, element), null)) ?? ""}`)
+            offset = b
+          }
+          text.textContent = templated
+        } catch (error) {
+          renderer.warn(`${error}`.split("\n")[0], element)
+        }
+      }),
+    )
+    return { state: { [renderer.internal("mustaching")]: true } }
   },
 } as Directive<WeakMap<Text, string>> & { default: NonNullable<Directive["default"]> }
 

@mizu/mustache/mod_test.html

@@ -50,6 +50,31 @@
   </expect>
 </test>
 
+<test name="[*mustache] templates children delimiters">
+  <script>
+    context.foo = "bar"
+  </script>
+  <render>
+    <p *mustache>
+      <span>foo {{ foo }} foo</span>
+    </p>
+  </render>
+  <expect>
+    <p>
+      <span>foo bar foo</span>
+    </p>
+  </expect>
+  <script>
+    context.foo = "baz"
+  </script>
+  <render></render>
+  <expect>
+    <p>
+      <span>foo baz foo</span>
+    </p>
+  </expect>
+</test>
+
 <test name="[*mustache] defaults to empty string on nullish values">
   <render>
     <p *mustache>