@eventra_dev/eventra-cli 0.1.22 → 0.1.23

package/dist/engine/functionAnalyzer.js

@@ -15,8 +15,20 @@ function findTrackParamIndex(fn) {
     let result = null;
     function visit(node) {
         if (typescript_1.default.isCallExpression(node)) {
-            const name = getCallName(node.expression);
-            if (/(track|event|capture|send)/i.test(name)) {
+            let isTrackCall = false;
+            if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
+                const method = node.expression.name.text;
+                if (method === "track") {
+                    isTrackCall = true;
+                }
+            }
+            // fallback
+            if (typescript_1.default.isIdentifier(node.expression)) {
+                if (node.expression.text === "track") {
+                    isTrackCall = true;
+                }
+            }
+            if (isTrackCall) {
                 for (const arg of node.arguments) {
                     if (typescript_1.default.isIdentifier(arg)) {
                         const idx = paramIndex.get(arg.text);
@@ -25,6 +37,10 @@ function findTrackParamIndex(fn) {
                             return;
                         }
                     }
+                    if (typescript_1.default.isStringLiteral(arg)) {
+                        result = 0;
+                        return;
+                    }
                 }
             }
         }
@@ -35,11 +51,3 @@ function findTrackParamIndex(fn) {
     }
     return result;
 }
-function getCallName(expr) {
-    if (typescript_1.default.isIdentifier(expr))
-        return expr.text;
-    if (typescript_1.default.isPropertyAccessExpression(expr)) {
-        return expr.name.text;
-    }
-    return "";
-}

package/dist/engine/resolver.js

@@ -11,42 +11,60 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
         return { values: [], dynamic: true };
     }
     seen.add(node);
+    // param mapping
     if (typescript_1.default.isIdentifier(node) && paramMap?.has(node.text)) {
         return resolveNodeValue(paramMap.get(node.text), checker, paramMap, seen);
     }
+    // STRING
     if (typescript_1.default.isStringLiteral(node)) {
         return { values: [node.text], dynamic: false };
     }
+    // ARRAY
+    if (typescript_1.default.isArrayLiteralExpression(node)) {
+        const values = [];
+        for (const el of node.elements) {
+            const res = resolveNodeValue(el, checker, paramMap, seen);
+            if (res.values.length) {
+                values.push(...res.values);
+            }
+        }
+        return { values, dynamic: true };
+    }
+    // TEMPLATE
     if (typescript_1.default.isTemplateExpression(node)) {
-        let result = node.head.text;
+        let results = [node.head.text];
         for (const span of node.templateSpans) {
-            result += "*";
-            result += span.literal.text;
+            const res = resolveNodeValue(span.expression, checker, paramMap, seen);
+            if (res.values.length) {
+                results = results.flatMap(r => res.values.map(v => r + v));
+            }
+            else {
+                results = results.map(r => r + "*");
+            }
+            results = results.map(r => r + span.literal.text);
         }
-        return { values: [result], dynamic: true };
+        return { values: results, dynamic: true };
     }
+    // CONDITIONAL
     if (typescript_1.default.isConditionalExpression(node)) {
         const a = resolveNodeValue(node.whenTrue, checker, paramMap, seen);
         const b = resolveNodeValue(node.whenFalse, checker, paramMap, seen);
         return {
-            values: [...new Set([...(a.values ?? []), ...(b.values ?? [])])],
+            values: [...new Set([...a.values, ...b.values])],
             dynamic: true,
         };
     }
+    // IDENTIFIER
     if (typescript_1.default.isIdentifier(node)) {
         let symbol = checker.getSymbolAtLocation(node);
         if (!symbol)
             return { values: [], dynamic: true };
-        for (const decl of symbol.getDeclarations() ?? []) {
-            if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
-                return resolveNodeValue(decl.initializer, checker, paramMap, seen);
-            }
-        }
-        const original = symbol;
+        // unwrap export
         symbol = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
-        if (symbol !== original && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
+        if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
             symbol = checker.getAliasedSymbol(symbol);
         }
+        // inline variable
         for (const decl of symbol.getDeclarations() ?? []) {
             if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
                 return resolveNodeValue(decl.initializer, checker, paramMap, seen);
@@ -60,12 +78,30 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
+        // UNION TYPES
+        const type = checker.getTypeAtLocation(node);
+        if (type.isUnion()) {
+            const values = [];
+            for (const t of type.types) {
+                if (t.isStringLiteral?.()) {
+                    values.push(t.value);
+                }
+            }
+            if (values.length) {
+                return { values, dynamic: false };
+            }
+        }
+        // TYPE FALLBACK (as const)
+        if (type.isStringLiteral?.()) {
+            return { values: [type.value], dynamic: false };
+        }
         return { values: [], dynamic: true };
     }
+    // PROPERTY ACCESS (obj.a.b)
     if (typescript_1.default.isPropertyAccessExpression(node)) {
         const symbol = checker.getSymbolAtLocation(node);
         if (symbol) {
-            let s = symbol;
+            let s = (0, exportResolver_1.resolveExportedSymbol)(symbol, checker) ?? symbol;
             if (s.flags & typescript_1.default.SymbolFlags.Alias) {
                 s = checker.getAliasedSymbol(s);
             }
@@ -80,6 +116,20 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
                 }
             }
         }
+        // constant enum / readonly
+        const constantValue = checker.getConstantValue(node);
+        if (typeof constantValue === "string") {
+            return { values: [constantValue], dynamic: false };
+        }
+        // type fallback
+        const type = checker.getTypeAtLocation(node);
+        if (type.isStringLiteral?.()) {
+            return {
+                values: [type.value],
+                dynamic: false,
+            };
+        }
+        // object literal resolve
         if (typescript_1.default.isIdentifier(node.expression)) {
             const objSymbol = checker.getSymbolAtLocation(node.expression);
             if (objSymbol) {
@@ -101,33 +151,59 @@ function resolveNodeValue(node, checker, paramMap, seen = new Set()) {
         }
         return { values: [], dynamic: true };
     }
+    // ARRAY ACCESS (arr[0])
+    if (typescript_1.default.isElementAccessExpression(node)) {
+        const obj = resolveNodeValue(node.expression, checker, paramMap, seen);
+        if (!node.argumentExpression) {
+            return { values: obj.values, dynamic: true };
+        }
+        const index = resolveNodeValue(node.argumentExpression, checker, paramMap, seen);
+        // if index known
+        if (index.values.length === 1) {
+            const i = Number(index.values[0]);
+            if (!Number.isNaN(i) && obj.values[i] !== undefined) {
+                return {
+                    values: [obj.values[i]],
+                    dynamic: false,
+                };
+            }
+        }
+        // fallback → dynamic
+        return obj.values.length
+            ? { values: obj.values, dynamic: true }
+            : { values: [], dynamic: true };
+    }
+    // OBJECT
     if (typescript_1.default.isObjectLiteralExpression(node)) {
         const values = [];
         for (const prop of node.properties) {
             if (!typescript_1.default.isPropertyAssignment(prop))
                 continue;
             const name = prop.name.getText();
-            if (name === "event") {
+            if (["event", "name", "type"].includes(name)) {
                 const res = resolveNodeValue(prop.initializer, checker, paramMap, seen);
                 values.push(...res.values);
             }
         }
         return { values, dynamic: true };
     }
+    // BINARY ("btn_" + name)
     if (typescript_1.default.isBinaryExpression(node)) {
         if (node.operatorToken.kind === typescript_1.default.SyntaxKind.PlusToken) {
             const left = resolveNodeValue(node.left, checker, paramMap, seen);
             const right = resolveNodeValue(node.right, checker, paramMap, seen);
-            if (left && right) {
-                return {
-                    values: left.values.flatMap(l => right.values.length
-                        ? right.values.map(r => l + r)
-                        : [l + "*"]),
-                    dynamic: true,
-                };
+            if (!left.values.length) {
+                return { values: [], dynamic: true };
             }
+            return {
+                values: left.values.flatMap(l => right.values.length
+                    ? right.values.map(r => l + r)
+                    : [l + "*"]),
+                dynamic: true,
+            };
         }
     }
+    // CALL → dynamic
     if (typescript_1.default.isCallExpression(node)) {
         return { values: [], dynamic: true };
     }

package/dist/utils/universal.js

@@ -6,10 +6,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseUniversal = parseUniversal;
 const path_1 = __importDefault(require("path"));
 /**
- * exact JS:
- * - {...}
- * - attr="..."
- * - Vue / Svelte handlers
+ * Strip comments (HTML + JS)
+ */
+function stripComments(input) {
+    return input
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/\/\/.*$/gm, "");
+}
+/**
+ * Extract JS expressions safely
  */
 function extractJS(input) {
     const result = [];
@@ -66,8 +72,13 @@ function extractJS(input) {
             }
             if (depth === 0) {
                 const expr = input.slice(i + 1, j - 1).trim();
-                if (expr)
+                if (expr &&
+                    (expr.includes("(") ||
+                        expr.includes("=") ||
+                        expr.includes(".") ||
+                        expr.includes("track"))) {
                     result.push(expr);
+                }
                 i = j;
                 continue;
             }
@@ -89,8 +100,12 @@ function extractJS(input) {
                 val += c;
                 j++;
             }
-            if (val.trim())
+            if (val.trim() &&
+                (val.includes("(") ||
+                    val.includes("=>") ||
+                    val.includes("track"))) {
                 result.push(val.trim());
+            }
             i = j + 1;
             continue;
         }
@@ -113,6 +128,9 @@ function extractJS(input) {
     }
     return result;
 }
+/**
+ * Extract loose JS but less noisy
+ */
 function extractLooseJS(input) {
     const result = [];
     const lines = input.split("\n");
@@ -122,33 +140,30 @@ function extractLooseJS(input) {
             continue;
         if (l.startsWith("<"))
             continue;
-        if (l.includes("(") ||
-            l.includes("=") ||
+        // strict filter
+        if (l.includes("track") ||
+            l.includes(".track(") ||
             l.includes("=>") ||
-            l.includes("function") ||
-            l.includes("track")) {
+            l.startsWith("function") ||
+            l.includes("(")) {
             result.push(l);
         }
     }
     return result;
 }
 /**
- * Universal:
- * - Astro
- * - Vue
- * - Svelte
- * - React / JSX
- * - Node / backend
+ * Universal parser
  */
 function parseUniversal(content, file) {
     const parts = [];
     const deps = [];
-    //  Astro frontmatter ---
-    const fm = content.match(/^---([\s\S]*?)---/);
+    const clean = stripComments(content);
+    // Astro frontmatter
+    const fm = clean.match(/^---([\s\S]*?)---/);
     if (fm?.[1])
         parts.push(fm[1]);
     // <script src="">
-    const scriptSrc = content.matchAll(/<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g);
+    const scriptSrc = clean.matchAll(/<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g);
     for (const s of scriptSrc) {
         const src = s[1];
         const resolved = src.startsWith("/")
@@ -157,18 +172,23 @@ function parseUniversal(content, file) {
         deps.push(resolved);
     }
     // inline <script>
-    const scripts = content.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script>/g);
+    const scripts = clean.matchAll(/<script\b([^>]*)>([\s\S]*?)<\/script>/g);
     for (const m of scripts) {
-        if (m[1].trim())
-            parts.push(m[1]);
+        const attrs = m[1];
+        // skip JSON / data
+        if (/type=["']application\/json/.test(attrs))
+            continue;
+        if (m[2].trim()) {
+            parts.push(m[2]);
+        }
     }
-    const noScripts = content.replace(/<script[\s\S]*?<\/script>/g, "");
+    // remove scripts
+    const noScripts = clean.replace(/<script[\s\S]*?<\/script>/g, "");
+    // loose JS
     const loose = extractLooseJS(noScripts);
-    for (const l of loose) {
-        parts.push(l);
-    }
+    parts.push(...loose);
     // expressions
-    const extracted = extractJS(content);
+    const extracted = extractJS(clean);
     for (const e of extracted) {
         parts.push(e + ";");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "Eventra CLI",
   "type": "commonjs",
   "bin": {

package/src/engine/functionAnalyzer.ts

@@ -15,9 +15,24 @@ export function findTrackParamIndex(
 
   function visit(node: ts.Node) {
     if (ts.isCallExpression(node)) {
-      const name = getCallName(node.expression);
+      let isTrackCall = false;
 
-      if (/(track|event|capture|send)/i.test(name)) {
+      if (ts.isPropertyAccessExpression(node.expression)) {
+        const method = node.expression.name.text;
+
+        if (method === "track") {
+          isTrackCall = true;
+        }
+      }
+
+      // fallback
+      if (ts.isIdentifier(node.expression)) {
+        if (node.expression.text === "track") {
+          isTrackCall = true;
+        }
+      }
+
+      if (isTrackCall) {
         for (const arg of node.arguments) {
           if (ts.isIdentifier(arg)) {
             const idx = paramIndex.get(arg.text);
@@ -26,6 +41,11 @@ export function findTrackParamIndex(
               return;
             }
           }
+
+          if (ts.isStringLiteral(arg)) {
+            result = 0;
+            return;
+          }
         }
       }
     }
@@ -39,13 +59,3 @@ export function findTrackParamIndex(
 
   return result;
 }
-
-function getCallName(expr: ts.Expression): string {
-  if (ts.isIdentifier(expr)) return expr.text;
-
-  if (ts.isPropertyAccessExpression(expr)) {
-    return expr.name.text;
-  }
-
-  return "";
-}

package/src/engine/resolver.ts

@@ -12,12 +12,12 @@ export function resolveNodeValue(
   paramMap?: Map<string, ts.Expression>,
   seen = new Set<ts.Node>()
 ): ResolveResult {
-
   if (seen.has(node)) {
     return { values: [], dynamic: true };
   }
   seen.add(node);
 
+  // param mapping
   if (ts.isIdentifier(node) && paramMap?.has(node.text)) {
     return resolveNodeValue(
       paramMap.get(node.text)!,
@@ -27,54 +27,70 @@ export function resolveNodeValue(
     );
   }
 
+  // STRING
   if (ts.isStringLiteral(node)) {
     return { values: [node.text], dynamic: false };
   }
 
+  // ARRAY
+  if (ts.isArrayLiteralExpression(node)) {
+    const values: string[] = [];
+
+    for (const el of node.elements) {
+      const res = resolveNodeValue(el, checker, paramMap, seen);
+      if (res.values.length) {
+        values.push(...res.values);
+      }
+    }
+
+    return { values, dynamic: true };
+  }
+
+  // TEMPLATE
   if (ts.isTemplateExpression(node)) {
-    let result = node.head.text;
+    let results = [node.head.text];
 
     for (const span of node.templateSpans) {
-      result += "*";
-      result += span.literal.text;
+      const res = resolveNodeValue(span.expression, checker, paramMap, seen);
+
+      if (res.values.length) {
+        results = results.flatMap(r =>
+          res.values.map(v => r + v)
+        );
+      } else {
+        results = results.map(r => r + "*");
+      }
+
+      results = results.map(r => r + span.literal.text);
     }
 
-    return { values: [result], dynamic: true };
+    return { values: results, dynamic: true };
   }
 
+  // CONDITIONAL
   if (ts.isConditionalExpression(node)) {
     const a = resolveNodeValue(node.whenTrue, checker, paramMap, seen);
     const b = resolveNodeValue(node.whenFalse, checker, paramMap, seen);
 
     return {
-      values: [...new Set([...(a.values ?? []), ...(b.values ?? [])])],
+      values: [...new Set([...a.values, ...b.values])],
       dynamic: true,
     };
   }
 
+  // IDENTIFIER
   if (ts.isIdentifier(node)) {
     let symbol = checker.getSymbolAtLocation(node);
     if (!symbol) return { values: [], dynamic: true };
 
-    for (const decl of symbol.getDeclarations() ?? []) {
-      if (ts.isVariableDeclaration(decl) && decl.initializer) {
-        return resolveNodeValue(
-          decl.initializer,
-          checker,
-          paramMap,
-          seen
-        );
-      }
-    }
-
-    const original = symbol;
-
+    // unwrap export
     symbol = resolveExportedSymbol(symbol, checker) ?? symbol;
 
-    if (symbol !== original && (symbol.flags & ts.SymbolFlags.Alias)) {
+    if (symbol.flags & ts.SymbolFlags.Alias) {
       symbol = checker.getAliasedSymbol(symbol);
     }
 
+    // inline variable
     for (const decl of symbol.getDeclarations() ?? []) {
       if (ts.isVariableDeclaration(decl) && decl.initializer) {
         return resolveNodeValue(
@@ -95,14 +111,38 @@ export function resolveNodeValue(
       }
     }
 
+    // UNION TYPES
+    const type = checker.getTypeAtLocation(node);
+
+    if (type.isUnion()) {
+      const values: string[] = [];
+
+      for (const t of type.types) {
+        if ((t as any).isStringLiteral?.()) {
+          values.push((t as any).value);
+        }
+      }
+
+      if (values.length) {
+        return { values, dynamic: false };
+      }
+    }
+
+    // TYPE FALLBACK (as const)
+    if ((type as any).isStringLiteral?.()) {
+      return { values: [(type as any).value], dynamic: false };
+    }
+
     return { values: [], dynamic: true };
   }
 
+  // PROPERTY ACCESS (obj.a.b)
   if (ts.isPropertyAccessExpression(node)) {
+
     const symbol = checker.getSymbolAtLocation(node);
 
     if (symbol) {
-      let s = symbol;
+      let s = resolveExportedSymbol(symbol, checker) ?? symbol;
 
       if (s.flags & ts.SymbolFlags.Alias) {
         s = checker.getAliasedSymbol(s);
@@ -120,6 +160,23 @@ export function resolveNodeValue(
       }
     }
 
+    // constant enum / readonly
+    const constantValue = checker.getConstantValue(node as any);
+    if (typeof constantValue === "string") {
+      return { values: [constantValue], dynamic: false };
+    }
+
+    // type fallback
+    const type = checker.getTypeAtLocation(node);
+
+    if ((type as any).isStringLiteral?.()) {
+      return {
+        values: [(type as any).value],
+        dynamic: false,
+      };
+    }
+
+    // object literal resolve
     if (ts.isIdentifier(node.expression)) {
       const objSymbol = checker.getSymbolAtLocation(node.expression);
 
@@ -152,6 +209,40 @@ export function resolveNodeValue(
     return { values: [], dynamic: true };
   }
 
+  // ARRAY ACCESS (arr[0])
+  if (ts.isElementAccessExpression(node)) {
+    const obj = resolveNodeValue(node.expression, checker, paramMap, seen);
+
+    if (!node.argumentExpression) {
+      return { values: obj.values, dynamic: true };
+    }
+
+    const index = resolveNodeValue(
+      node.argumentExpression,
+      checker,
+      paramMap,
+      seen
+    );
+
+    // if index known
+    if (index.values.length === 1) {
+      const i = Number(index.values[0]);
+
+      if (!Number.isNaN(i) && obj.values[i] !== undefined) {
+        return {
+          values: [obj.values[i]],
+          dynamic: false,
+        };
+      }
+    }
+
+    // fallback → dynamic
+    return obj.values.length
+      ? { values: obj.values, dynamic: true }
+      : { values: [], dynamic: true };
+  }
+
+  // OBJECT
   if (ts.isObjectLiteralExpression(node)) {
     const values: string[] = [];
 
@@ -160,7 +251,7 @@ export function resolveNodeValue(
 
       const name = prop.name.getText();
 
-      if (name === "event") {
+      if (["event", "name", "type"].includes(name)) {
         const res = resolveNodeValue(prop.initializer, checker, paramMap, seen);
         values.push(...res.values);
       }
@@ -169,24 +260,28 @@ export function resolveNodeValue(
     return { values, dynamic: true };
   }
 
+  // BINARY ("btn_" + name)
   if (ts.isBinaryExpression(node)) {
     if (node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
       const left = resolveNodeValue(node.left, checker, paramMap, seen);
       const right = resolveNodeValue(node.right, checker, paramMap, seen);
 
-      if (left && right) {
-        return {
-          values: left.values.flatMap(l =>
-            right.values.length
-              ? right.values.map(r => l + r)
-              : [l + "*"]
-          ),
-          dynamic: true,
-        };
+      if (!left.values.length) {
+        return { values: [], dynamic: true };
       }
+
+      return {
+        values: left.values.flatMap(l =>
+          right.values.length
+            ? right.values.map(r => l + r)
+            : [l + "*"]
+        ),
+        dynamic: true,
+      };
     }
   }
 
+  // CALL → dynamic
   if (ts.isCallExpression(node)) {
     return { values: [], dynamic: true };
   }

package/src/utils/universal.ts

@@ -2,10 +2,17 @@ import path from "path";
 import { ParseResult } from "../types";
 
 /**
- * exact JS:
- * - {...}
- * - attr="..."
- * - Vue / Svelte handlers
+ * Strip comments (HTML + JS)
+ */
+function stripComments(input: string): string {
+  return input
+    .replace(/<!--[\s\S]*?-->/g, "")
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/\/\/.*$/gm, "");
+}
+
+/**
+ * Extract JS expressions safely
  */
 function extractJS(input: string): string[] {
   const result: string[] = [];
@@ -24,7 +31,6 @@ function extractJS(input: string): string[] {
       if (escape) escape = false;
       else if (ch === "\\") escape = true;
       else if (ch === inString) inString = null;
-
       i++;
       continue;
     }
@@ -68,7 +74,17 @@ function extractJS(input: string): string[] {
 
       if (depth === 0) {
         const expr = input.slice(i + 1, j - 1).trim();
-        if (expr) result.push(expr);
+
+        if (
+          expr &&
+          (expr.includes("(") ||
+            expr.includes("=") ||
+            expr.includes(".") ||
+            expr.includes("track"))
+        ) {
+          result.push(expr);
+        }
+
         i = j;
         continue;
       }
@@ -95,7 +111,14 @@ function extractJS(input: string): string[] {
         j++;
       }
 
-      if (val.trim()) result.push(val.trim());
+      if (
+        val.trim() &&
+        (val.includes("(") ||
+          val.includes("=>") ||
+          val.includes("track"))
+      ) {
+        result.push(val.trim());
+      }
 
       i = j + 1;
       continue;
@@ -123,6 +146,9 @@ function extractJS(input: string): string[] {
   return result;
 }
 
+/**
+ * Extract loose JS but less noisy
+ */
 function extractLooseJS(input: string): string[] {
   const result: string[] = [];
 
@@ -134,12 +160,13 @@ function extractLooseJS(input: string): string[] {
     if (!l) continue;
     if (l.startsWith("<")) continue;
 
+    // strict filter
     if (
-      l.includes("(") ||
-      l.includes("=") ||
+      l.includes("track") ||
+      l.includes(".track(") ||
       l.includes("=>") ||
-      l.includes("function") ||
-      l.includes("track")
+      l.startsWith("function") ||
+      l.includes("(")
     ) {
       result.push(l);
     }
@@ -149,14 +176,8 @@ function extractLooseJS(input: string): string[] {
 }
 
 /**
- * Universal:
- * - Astro
- * - Vue
- * - Svelte
- * - React / JSX
- * - Node / backend
+ * Universal parser
  */
-
 export function parseUniversal(
   content: string,
   file: string
@@ -164,12 +185,14 @@ export function parseUniversal(
   const parts: string[] = [];
   const deps: string[] = [];
 
-  //  Astro frontmatter ---
-  const fm = content.match(/^---([\s\S]*?)---/);
+  const clean = stripComments(content);
+
+  // Astro frontmatter
+  const fm = clean.match(/^---([\s\S]*?)---/);
   if (fm?.[1]) parts.push(fm[1]);
 
   // <script src="">
-  const scriptSrc = content.matchAll(
+  const scriptSrc = clean.matchAll(
     /<script\b[^>]*?\bsrc=["'](.+?)["'][^>]*>/g
   );
 
@@ -184,28 +207,33 @@ export function parseUniversal(
   }
 
   // inline <script>
-  const scripts = content.matchAll(
-    /<script\b[^>]*>([\s\S]*?)<\/script>/g
+  const scripts = clean.matchAll(
+    /<script\b([^>]*)>([\s\S]*?)<\/script>/g
   );
 
   for (const m of scripts) {
-    if (m[1].trim()) parts.push(m[1]);
+    const attrs = m[1];
+
+    // skip JSON / data
+    if (/type=["']application\/json/.test(attrs)) continue;
+
+    if (m[2].trim()) {
+      parts.push(m[2]);
+    }
   }
 
-  const noScripts = content.replace(
+  // remove scripts
+  const noScripts = clean.replace(
     /<script[\s\S]*?<\/script>/g,
     ""
   );
 
+  // loose JS
   const loose = extractLooseJS(noScripts);
-
-  for (const l of loose) {
-    parts.push(l);
-  }
+  parts.push(...loose);
 
   // expressions
-  const extracted = extractJS(content);
-
+  const extracted = extractJS(clean);
   for (const e of extracted) {
     parts.push(e + ";");
   }