@hyperframes/parsers 0.7.90 → 0.7.93

package/dist/assets.d.ts

@@ -35,16 +35,37 @@ declare function isPathInside(childPath: string, parentPath: string): boolean;
  * Used by both the core bundler (preview) and the producer compiler (render)
  * to ensure consistent behavior.
  */
+/**
+ * Probe for "does this project-root-relative path exist?", supplied by callers
+ * that can see the filesystem (the studio preview builder, the bundler, the
+ * producer). Keeps this module free of `node:fs` so it stays browser-safe.
+ *
+ * It disambiguates the two conventions for a plain relative path authored in a
+ * sub-composition that lives in a subdirectory:
+ *
+ *   1. A SIBLING file — `<link href="_shared.css">` next to the composition.
+ *      This is what a browser resolves when the file is opened directly, and
+ *      what an author means. Once the content moves into the project-root
+ *      document it must become `design/styleframes/_shared.css` or it 404s.
+ *   2. A PROJECT-ROOT asset — registry blocks are installed into a
+ *      subdirectory but reference `assets/logo.png` at the root. Already
+ *      correct in the root document; rewriting would break it.
+ *
+ * A sibling that exists on disk means (1); anything else is left as authored.
+ * Without a probe the behavior is unchanged — plain relative paths pass through.
+ */
+type AssetExists = (projectRelativePath: string) => boolean;
 /**
  * Rewrite a single relative path from a sub-composition's context to the
  * project root context.
  *
  * @param compSrcPath - The `data-composition-src` value (e.g. "compositions/scene.html")
  * @param relativePath - The asset path to rewrite (e.g. "../icon.svg")
+ * @param assetExists - Optional filesystem probe; see `AssetExists`.
  * @returns The rewritten path relative to project root (e.g. "icon.svg"), or
  *          the original path if no rewriting is needed.
  */
-declare function rewriteAssetPath(compSrcPath: string, relativePath: string): string;
+declare function rewriteAssetPath(compSrcPath: string, relativePath: string, assetExists?: AssetExists): string;
 /**
  * Rewrite all relative `src` and `href` attributes on elements within a
  * DOM tree, adjusting paths from the sub-composition's directory context
@@ -55,15 +76,15 @@ declare function rewriteAssetPath(compSrcPath: string, relativePath: string): st
  * @param getAttr - Function to read an attribute from an element
  * @param setAttr - Function to set an attribute on an element
  */
-declare function rewriteAssetPaths<T>(elements: Iterable<T>, compSrcPath: string, getAttr: (el: T, attr: string) => string | null | undefined, setAttr: (el: T, attr: string, value: string) => void): void;
+declare function rewriteAssetPaths<T>(elements: Iterable<T>, compSrcPath: string, getAttr: (el: T, attr: string) => string | null | undefined, setAttr: (el: T, attr: string, value: string) => void, assetExists?: AssetExists): void;
 /**
  * Rewrite CSS url(...) references inside inline style attributes.
  */
-declare function rewriteInlineStyleAssetUrls<T>(elements: Iterable<T>, compSrcPath: string, getStyle: (el: T) => string | null | undefined, setStyle: (el: T, value: string) => void): void;
+declare function rewriteInlineStyleAssetUrls<T>(elements: Iterable<T>, compSrcPath: string, getStyle: (el: T) => string | null | undefined, setStyle: (el: T, value: string) => void, assetExists?: AssetExists): void;
 /**
  * Rewrite CSS url(...) references in a sub-composition's inline styles so
  * ../foo.woff2 remains valid after the CSS is hoisted into the root document.
  */
-declare function rewriteCssAssetUrls(cssText: string, compSrcPath: string): string;
+declare function rewriteCssAssetUrls(cssText: string, compSrcPath: string, assetExists?: AssetExists): string;
 
-export { CSS_URL_RE, PATH_ATTRS, isNonRelativeUrl, isPathInside, rewriteAssetPath, rewriteAssetPaths, rewriteCssAssetUrls, rewriteInlineStyleAssetUrls };
+export { type AssetExists, CSS_URL_RE, PATH_ATTRS, isNonRelativeUrl, isPathInside, rewriteAssetPath, rewriteAssetPaths, rewriteCssAssetUrls, rewriteInlineStyleAssetUrls };

package/dist/assets.js

@@ -20,43 +20,53 @@ var isAbsoluteOrSpecial = isNonRelativeUrl;
 function needsRewrite(val) {
   return val.startsWith("../") || val === "..";
 }
-function rewriteAssetPath(compSrcPath, relativePath) {
+function splitPathSuffix(value) {
+  const marker = value.search(/[?#]/);
+  return marker === -1 ? [value, ""] : [value.slice(0, marker), value.slice(marker)];
+}
+function rewriteAssetPath(compSrcPath, relativePath, assetExists) {
   if (isAbsoluteOrSpecial(relativePath)) return relativePath;
-  if (!needsRewrite(relativePath)) return relativePath;
   const compDir = dirname(compSrcPath);
   if (!compDir || compDir === ".") return relativePath;
+  if (!needsRewrite(relativePath)) {
+    if (!assetExists) return relativePath;
+    const [filePart, suffix] = splitPathSuffix(relativePath);
+    if (!filePart) return relativePath;
+    const sibling = resolve2("/", join(compDir, filePart)).slice(1);
+    return assetExists(sibling) ? sibling + suffix : relativePath;
+  }
   const resolved = join(compDir, relativePath);
   const normalized = resolve2("/", resolved).slice(1);
   return normalized;
 }
-function rewriteAssetPaths(elements, compSrcPath, getAttr, setAttr) {
+function rewriteAssetPaths(elements, compSrcPath, getAttr, setAttr, assetExists) {
   for (const el of elements) {
     for (const attr of PATH_ATTRS) {
       const val = (getAttr(el, attr) || "").trim();
-      const rewritten = rewriteAssetPath(compSrcPath, val);
+      const rewritten = rewriteAssetPath(compSrcPath, val, assetExists);
       if (rewritten !== val) {
         setAttr(el, attr, rewritten);
       }
     }
   }
 }
-function rewriteInlineStyleAssetUrls(elements, compSrcPath, getStyle, setStyle) {
+function rewriteInlineStyleAssetUrls(elements, compSrcPath, getStyle, setStyle, assetExists) {
   const compDir = dirname(compSrcPath);
   if (!compDir || compDir === ".") return;
   for (const el of elements) {
     const style = getStyle(el);
     if (!style) continue;
-    const rewritten = rewriteCssAssetUrls(style, compSrcPath);
+    const rewritten = rewriteCssAssetUrls(style, compSrcPath, assetExists);
     if (rewritten !== style) {
       setStyle(el, rewritten);
     }
   }
 }
-function rewriteCssAssetUrls(cssText, compSrcPath) {
+function rewriteCssAssetUrls(cssText, compSrcPath, assetExists) {
   if (!cssText) return cssText;
   return cssText.replace(CSS_URL_RE, (full, quote, rawUrl) => {
     const urlValue = (rawUrl || "").trim();
-    const rewritten = rewriteAssetPath(compSrcPath, urlValue);
+    const rewritten = rewriteAssetPath(compSrcPath, urlValue, assetExists);
     if (rewritten === urlValue) return full;
     return `url(${quote || ""}${rewritten}${quote || ""})`;
   });

package/dist/assets.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/assetPaths.ts","../src/rewriteSubCompPaths.ts"],"sourcesContent":["/**\n * Shared primitives for scanning and rewriting asset paths in HTML/CSS.\n *\n * Used by: rewriteSubCompPaths (core), collectExternalAssets (producer),\n * localizeExternalAssets (CLI publish).\n */\n\nimport { isAbsolute, relative, resolve } from \"node:path\";\n\n/**\n * Regex matching CSS `url(...)` references — captures the quote style and the\n * raw URL. The URL group is anchored to non-whitespace at both ends so the\n * surrounding `\\s*` can never overlap it (avoids polynomial-ReDoS backtracking);\n * the captured value is whitespace-bounded already, matching the old behavior\n * after callers `.trim()` it.\n */\nexport const CSS_URL_RE = /\\burl\\(\\s*([\"']?)([^)\"'\\s](?:[^)\"']*[^)\"'\\s])?)\\1\\s*\\)/g;\n\n/** Attributes that may contain relative asset paths. */\nexport const PATH_ATTRS = [\"src\", \"href\"] as const;\n\n/** Returns true for URLs/prefixes that should never be rewritten. */\nexport function isNonRelativeUrl(val: string): boolean {\n  return (\n    !val ||\n    val.startsWith(\"http://\") ||\n    val.startsWith(\"https://\") ||\n    val.startsWith(\"//\") ||\n    val.startsWith(\"data:\") ||\n    val.startsWith(\"#\") ||\n    val.startsWith(\"/\")\n  );\n}\n\n/**\n * Cross-platform containment check: is `childPath` inside `parentPath`?\n * Equality counts as \"inside\".\n */\nexport function isPathInside(childPath: string, parentPath: string): boolean {\n  const absChild = resolve(childPath);\n  const absParent = resolve(parentPath);\n  if (absChild === absParent) return true;\n  const rel = relative(absParent, absChild);\n  return rel !== \"\" && !rel.startsWith(\"..\") && !isAbsolute(rel);\n}\n","/**\n * Rewrite relative asset paths in sub-composition content so they resolve\n * correctly after the content is inlined into the root document.\n *\n * A sub-composition at \"compositions/scene.html\" referencing \"../icon.svg\"\n * means the project root — but after inlining into root index.html, the\n * \"../\" escapes the project directory and causes 404s. This function\n * resolves each relative path against the sub-composition's directory,\n * then normalizes it to be relative to the project root.\n *\n * Used by both the core bundler (preview) and the producer compiler (render)\n * to ensure consistent behavior.\n */\n\n// URL paths in HTML output are POSIX regardless of host OS — use the `posix`\n// submodule so Windows builds don't emit backslash-separated paths (or worse,\n// drive-letter-prefixed artifacts from `resolve(\"/\", ...)`).\nimport { posix } from \"path\";\nconst { join, resolve, dirname } = posix;\n\nimport { CSS_URL_RE, PATH_ATTRS, isNonRelativeUrl } from \"./assetPaths.js\";\n\nconst isAbsoluteOrSpecial = isNonRelativeUrl;\n\n/**\n * Returns true only for paths that traverse up with `../`.\n * Plain relative paths like `assets/foo.svg` are already correct from the\n * root perspective — the browser resolves them against the served root, which\n * is the project root, so they don't need rewriting.\n */\nfunction needsRewrite(val: string): boolean {\n  return val.startsWith(\"../\") || val === \"..\";\n}\n\n/**\n * Rewrite a single relative path from a sub-composition's context to the\n * project root context.\n *\n * @param compSrcPath - The `data-composition-src` value (e.g. \"compositions/scene.html\")\n * @param relativePath - The asset path to rewrite (e.g. \"../icon.svg\")\n * @returns The rewritten path relative to project root (e.g. \"icon.svg\"), or\n *          the original path if no rewriting is needed.\n */\nexport function rewriteAssetPath(compSrcPath: string, relativePath: string): string {\n  if (isAbsoluteOrSpecial(relativePath)) return relativePath;\n  if (!needsRewrite(relativePath)) return relativePath;\n  const compDir = dirname(compSrcPath);\n  if (!compDir || compDir === \".\") return relativePath;\n  const resolved = join(compDir, relativePath);\n  const normalized = resolve(\"/\", resolved).slice(1);\n  return normalized;\n}\n\n/**\n * Rewrite all relative `src` and `href` attributes on elements within a\n * DOM tree, adjusting paths from the sub-composition's directory context\n * to the project root.\n *\n * @param elements - Iterable of DOM elements to scan (e.g. from querySelectorAll)\n * @param compSrcPath - The `data-composition-src` value\n * @param getAttr - Function to read an attribute from an element\n * @param setAttr - Function to set an attribute on an element\n */\nexport function rewriteAssetPaths<T>(\n  elements: Iterable<T>,\n  compSrcPath: string,\n  getAttr: (el: T, attr: string) => string | null | undefined,\n  setAttr: (el: T, attr: string, value: string) => void,\n): void {\n  for (const el of elements) {\n    for (const attr of PATH_ATTRS) {\n      const val = (getAttr(el, attr) || \"\").trim();\n      const rewritten = rewriteAssetPath(compSrcPath, val);\n      if (rewritten !== val) {\n        setAttr(el, attr, rewritten);\n      }\n    }\n  }\n}\n\n/**\n * Rewrite CSS url(...) references inside inline style attributes.\n */\nexport function rewriteInlineStyleAssetUrls<T>(\n  elements: Iterable<T>,\n  compSrcPath: string,\n  getStyle: (el: T) => string | null | undefined,\n  setStyle: (el: T, value: string) => void,\n): void {\n  const compDir = dirname(compSrcPath);\n  if (!compDir || compDir === \".\") return;\n\n  for (const el of elements) {\n    const style = getStyle(el);\n    if (!style) continue;\n    const rewritten = rewriteCssAssetUrls(style, compSrcPath);\n    if (rewritten !== style) {\n      setStyle(el, rewritten);\n    }\n  }\n}\n\n/**\n * Rewrite CSS url(...) references in a sub-composition's inline styles so\n * ../foo.woff2 remains valid after the CSS is hoisted into the root document.\n */\nexport function rewriteCssAssetUrls(cssText: string, compSrcPath: string): string {\n  if (!cssText) return cssText;\n  return cssText.replace(CSS_URL_RE, (full, quote: string, rawUrl: string) => {\n    const urlValue = (rawUrl || \"\").trim();\n    const rewritten = rewriteAssetPath(compSrcPath, urlValue);\n    if (rewritten === urlValue) return full;\n    return `url(${quote || \"\"}${rewritten}${quote || \"\"})`;\n  });\n}\n"],"mappings":";AAOA,SAAS,YAAY,UAAU,eAAe;AASvC,IAAM,aAAa;AAGnB,IAAM,aAAa,CAAC,OAAO,MAAM;AAGjC,SAAS,iBAAiB,KAAsB;AACrD,SACE,CAAC,OACD,IAAI,WAAW,SAAS,KACxB,IAAI,WAAW,UAAU,KACzB,IAAI,WAAW,IAAI,KACnB,IAAI,WAAW,OAAO,KACtB,IAAI,WAAW,GAAG,KAClB,IAAI,WAAW,GAAG;AAEtB;AAMO,SAAS,aAAa,WAAmB,YAA6B;AAC3E,QAAM,WAAW,QAAQ,SAAS;AAClC,QAAM,YAAY,QAAQ,UAAU;AACpC,MAAI,aAAa,UAAW,QAAO;AACnC,QAAM,MAAM,SAAS,WAAW,QAAQ;AACxC,SAAO,QAAQ,MAAM,CAAC,IAAI,WAAW,IAAI,KAAK,CAAC,WAAW,GAAG;AAC/D;;;AC3BA,SAAS,aAAa;AACtB,IAAM,EAAE,MAAM,SAAAA,UAAS,QAAQ,IAAI;AAInC,IAAM,sBAAsB;AAQ5B,SAAS,aAAa,KAAsB;AAC1C,SAAO,IAAI,WAAW,KAAK,KAAK,QAAQ;AAC1C;AAWO,SAAS,iBAAiB,aAAqB,cAA8B;AAClF,MAAI,oBAAoB,YAAY,EAAG,QAAO;AAC9C,MAAI,CAAC,aAAa,YAAY,EAAG,QAAO;AACxC,QAAM,UAAU,QAAQ,WAAW;AACnC,MAAI,CAAC,WAAW,YAAY,IAAK,QAAO;AACxC,QAAM,WAAW,KAAK,SAAS,YAAY;AAC3C,QAAM,aAAaA,SAAQ,KAAK,QAAQ,EAAE,MAAM,CAAC;AACjD,SAAO;AACT;AAYO,SAAS,kBACd,UACA,aACA,SACA,SACM;AACN,aAAW,MAAM,UAAU;AACzB,eAAW,QAAQ,YAAY;AAC7B,YAAM,OAAO,QAAQ,IAAI,IAAI,KAAK,IAAI,KAAK;AAC3C,YAAM,YAAY,iBAAiB,aAAa,GAAG;AACnD,UAAI,cAAc,KAAK;AACrB,gBAAQ,IAAI,MAAM,SAAS;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AACF;AAKO,SAAS,4BACd,UACA,aACA,UACA,UACM;AACN,QAAM,UAAU,QAAQ,WAAW;AACnC,MAAI,CAAC,WAAW,YAAY,IAAK;AAEjC,aAAW,MAAM,UAAU;AACzB,UAAM,QAAQ,SAAS,EAAE;AACzB,QAAI,CAAC,MAAO;AACZ,UAAM,YAAY,oBAAoB,OAAO,WAAW;AACxD,QAAI,cAAc,OAAO;AACvB,eAAS,IAAI,SAAS;AAAA,IACxB;AAAA,EACF;AACF;AAMO,SAAS,oBAAoB,SAAiB,aAA6B;AAChF,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,QAAQ,YAAY,CAAC,MAAM,OAAe,WAAmB;AAC1E,UAAM,YAAY,UAAU,IAAI,KAAK;AACrC,UAAM,YAAY,iBAAiB,aAAa,QAAQ;AACxD,QAAI,cAAc,SAAU,QAAO;AACnC,WAAO,OAAO,SAAS,EAAE,GAAG,SAAS,GAAG,SAAS,EAAE;AAAA,EACrD,CAAC;AACH;","names":["resolve"]}
+{"version":3,"sources":["../src/assetPaths.ts","../src/rewriteSubCompPaths.ts"],"sourcesContent":["/**\n * Shared primitives for scanning and rewriting asset paths in HTML/CSS.\n *\n * Used by: rewriteSubCompPaths (core), collectExternalAssets (producer),\n * localizeExternalAssets (CLI publish).\n */\n\nimport { isAbsolute, relative, resolve } from \"node:path\";\n\n/**\n * Regex matching CSS `url(...)` references — captures the quote style and the\n * raw URL. The URL group is anchored to non-whitespace at both ends so the\n * surrounding `\\s*` can never overlap it (avoids polynomial-ReDoS backtracking);\n * the captured value is whitespace-bounded already, matching the old behavior\n * after callers `.trim()` it.\n */\nexport const CSS_URL_RE = /\\burl\\(\\s*([\"']?)([^)\"'\\s](?:[^)\"']*[^)\"'\\s])?)\\1\\s*\\)/g;\n\n/** Attributes that may contain relative asset paths. */\nexport const PATH_ATTRS = [\"src\", \"href\"] as const;\n\n/** Returns true for URLs/prefixes that should never be rewritten. */\nexport function isNonRelativeUrl(val: string): boolean {\n  return (\n    !val ||\n    val.startsWith(\"http://\") ||\n    val.startsWith(\"https://\") ||\n    val.startsWith(\"//\") ||\n    val.startsWith(\"data:\") ||\n    val.startsWith(\"#\") ||\n    val.startsWith(\"/\")\n  );\n}\n\n/**\n * Cross-platform containment check: is `childPath` inside `parentPath`?\n * Equality counts as \"inside\".\n */\nexport function isPathInside(childPath: string, parentPath: string): boolean {\n  const absChild = resolve(childPath);\n  const absParent = resolve(parentPath);\n  if (absChild === absParent) return true;\n  const rel = relative(absParent, absChild);\n  return rel !== \"\" && !rel.startsWith(\"..\") && !isAbsolute(rel);\n}\n","/**\n * Rewrite relative asset paths in sub-composition content so they resolve\n * correctly after the content is inlined into the root document.\n *\n * A sub-composition at \"compositions/scene.html\" referencing \"../icon.svg\"\n * means the project root — but after inlining into root index.html, the\n * \"../\" escapes the project directory and causes 404s. This function\n * resolves each relative path against the sub-composition's directory,\n * then normalizes it to be relative to the project root.\n *\n * Used by both the core bundler (preview) and the producer compiler (render)\n * to ensure consistent behavior.\n */\n\n// URL paths in HTML output are POSIX regardless of host OS — use the `posix`\n// submodule so Windows builds don't emit backslash-separated paths (or worse,\n// drive-letter-prefixed artifacts from `resolve(\"/\", ...)`).\nimport { posix } from \"path\";\nconst { join, resolve, dirname } = posix;\n\nimport { CSS_URL_RE, PATH_ATTRS, isNonRelativeUrl } from \"./assetPaths.js\";\n\nconst isAbsoluteOrSpecial = isNonRelativeUrl;\n\n/**\n * Returns true only for paths that traverse up with `../`.\n * Plain relative paths like `assets/foo.svg` are ambiguous: two conventions are\n * in the wild, and only the filesystem can tell them apart — see `AssetExists`.\n */\nfunction needsRewrite(val: string): boolean {\n  return val.startsWith(\"../\") || val === \"..\";\n}\n\n/**\n * Probe for \"does this project-root-relative path exist?\", supplied by callers\n * that can see the filesystem (the studio preview builder, the bundler, the\n * producer). Keeps this module free of `node:fs` so it stays browser-safe.\n *\n * It disambiguates the two conventions for a plain relative path authored in a\n * sub-composition that lives in a subdirectory:\n *\n *   1. A SIBLING file — `<link href=\"_shared.css\">` next to the composition.\n *      This is what a browser resolves when the file is opened directly, and\n *      what an author means. Once the content moves into the project-root\n *      document it must become `design/styleframes/_shared.css` or it 404s.\n *   2. A PROJECT-ROOT asset — registry blocks are installed into a\n *      subdirectory but reference `assets/logo.png` at the root. Already\n *      correct in the root document; rewriting would break it.\n *\n * A sibling that exists on disk means (1); anything else is left as authored.\n * Without a probe the behavior is unchanged — plain relative paths pass through.\n */\nexport type AssetExists = (projectRelativePath: string) => boolean;\n\n/** Split `foo.png?v=2#frag` into its path and its `?`/`#` suffix. */\nfunction splitPathSuffix(value: string): [string, string] {\n  const marker = value.search(/[?#]/);\n  return marker === -1 ? [value, \"\"] : [value.slice(0, marker), value.slice(marker)];\n}\n\n/**\n * Rewrite a single relative path from a sub-composition's context to the\n * project root context.\n *\n * @param compSrcPath - The `data-composition-src` value (e.g. \"compositions/scene.html\")\n * @param relativePath - The asset path to rewrite (e.g. \"../icon.svg\")\n * @param assetExists - Optional filesystem probe; see `AssetExists`.\n * @returns The rewritten path relative to project root (e.g. \"icon.svg\"), or\n *          the original path if no rewriting is needed.\n */\nexport function rewriteAssetPath(\n  compSrcPath: string,\n  relativePath: string,\n  assetExists?: AssetExists,\n): string {\n  if (isAbsoluteOrSpecial(relativePath)) return relativePath;\n  const compDir = dirname(compSrcPath);\n  if (!compDir || compDir === \".\") return relativePath;\n  if (!needsRewrite(relativePath)) {\n    if (!assetExists) return relativePath;\n    const [filePart, suffix] = splitPathSuffix(relativePath);\n    if (!filePart) return relativePath;\n    const sibling = resolve(\"/\", join(compDir, filePart)).slice(1);\n    return assetExists(sibling) ? sibling + suffix : relativePath;\n  }\n  const resolved = join(compDir, relativePath);\n  const normalized = resolve(\"/\", resolved).slice(1);\n  return normalized;\n}\n\n/**\n * Rewrite all relative `src` and `href` attributes on elements within a\n * DOM tree, adjusting paths from the sub-composition's directory context\n * to the project root.\n *\n * @param elements - Iterable of DOM elements to scan (e.g. from querySelectorAll)\n * @param compSrcPath - The `data-composition-src` value\n * @param getAttr - Function to read an attribute from an element\n * @param setAttr - Function to set an attribute on an element\n */\nexport function rewriteAssetPaths<T>(\n  elements: Iterable<T>,\n  compSrcPath: string,\n  getAttr: (el: T, attr: string) => string | null | undefined,\n  setAttr: (el: T, attr: string, value: string) => void,\n  assetExists?: AssetExists,\n): void {\n  for (const el of elements) {\n    for (const attr of PATH_ATTRS) {\n      const val = (getAttr(el, attr) || \"\").trim();\n      const rewritten = rewriteAssetPath(compSrcPath, val, assetExists);\n      if (rewritten !== val) {\n        setAttr(el, attr, rewritten);\n      }\n    }\n  }\n}\n\n/**\n * Rewrite CSS url(...) references inside inline style attributes.\n */\nexport function rewriteInlineStyleAssetUrls<T>(\n  elements: Iterable<T>,\n  compSrcPath: string,\n  getStyle: (el: T) => string | null | undefined,\n  setStyle: (el: T, value: string) => void,\n  assetExists?: AssetExists,\n): void {\n  const compDir = dirname(compSrcPath);\n  if (!compDir || compDir === \".\") return;\n\n  for (const el of elements) {\n    const style = getStyle(el);\n    if (!style) continue;\n    const rewritten = rewriteCssAssetUrls(style, compSrcPath, assetExists);\n    if (rewritten !== style) {\n      setStyle(el, rewritten);\n    }\n  }\n}\n\n/**\n * Rewrite CSS url(...) references in a sub-composition's inline styles so\n * ../foo.woff2 remains valid after the CSS is hoisted into the root document.\n */\nexport function rewriteCssAssetUrls(\n  cssText: string,\n  compSrcPath: string,\n  assetExists?: AssetExists,\n): string {\n  if (!cssText) return cssText;\n  return cssText.replace(CSS_URL_RE, (full, quote: string, rawUrl: string) => {\n    const urlValue = (rawUrl || \"\").trim();\n    const rewritten = rewriteAssetPath(compSrcPath, urlValue, assetExists);\n    if (rewritten === urlValue) return full;\n    return `url(${quote || \"\"}${rewritten}${quote || \"\"})`;\n  });\n}\n"],"mappings":";AAOA,SAAS,YAAY,UAAU,eAAe;AASvC,IAAM,aAAa;AAGnB,IAAM,aAAa,CAAC,OAAO,MAAM;AAGjC,SAAS,iBAAiB,KAAsB;AACrD,SACE,CAAC,OACD,IAAI,WAAW,SAAS,KACxB,IAAI,WAAW,UAAU,KACzB,IAAI,WAAW,IAAI,KACnB,IAAI,WAAW,OAAO,KACtB,IAAI,WAAW,GAAG,KAClB,IAAI,WAAW,GAAG;AAEtB;AAMO,SAAS,aAAa,WAAmB,YAA6B;AAC3E,QAAM,WAAW,QAAQ,SAAS;AAClC,QAAM,YAAY,QAAQ,UAAU;AACpC,MAAI,aAAa,UAAW,QAAO;AACnC,QAAM,MAAM,SAAS,WAAW,QAAQ;AACxC,SAAO,QAAQ,MAAM,CAAC,IAAI,WAAW,IAAI,KAAK,CAAC,WAAW,GAAG;AAC/D;;;AC3BA,SAAS,aAAa;AACtB,IAAM,EAAE,MAAM,SAAAA,UAAS,QAAQ,IAAI;AAInC,IAAM,sBAAsB;AAO5B,SAAS,aAAa,KAAsB;AAC1C,SAAO,IAAI,WAAW,KAAK,KAAK,QAAQ;AAC1C;AAwBA,SAAS,gBAAgB,OAAiC;AACxD,QAAM,SAAS,MAAM,OAAO,MAAM;AAClC,SAAO,WAAW,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,MAAM,GAAG,MAAM,GAAG,MAAM,MAAM,MAAM,CAAC;AACnF;AAYO,SAAS,iBACd,aACA,cACA,aACQ;AACR,MAAI,oBAAoB,YAAY,EAAG,QAAO;AAC9C,QAAM,UAAU,QAAQ,WAAW;AACnC,MAAI,CAAC,WAAW,YAAY,IAAK,QAAO;AACxC,MAAI,CAAC,aAAa,YAAY,GAAG;AAC/B,QAAI,CAAC,YAAa,QAAO;AACzB,UAAM,CAAC,UAAU,MAAM,IAAI,gBAAgB,YAAY;AACvD,QAAI,CAAC,SAAU,QAAO;AACtB,UAAM,UAAUA,SAAQ,KAAK,KAAK,SAAS,QAAQ,CAAC,EAAE,MAAM,CAAC;AAC7D,WAAO,YAAY,OAAO,IAAI,UAAU,SAAS;AAAA,EACnD;AACA,QAAM,WAAW,KAAK,SAAS,YAAY;AAC3C,QAAM,aAAaA,SAAQ,KAAK,QAAQ,EAAE,MAAM,CAAC;AACjD,SAAO;AACT;AAYO,SAAS,kBACd,UACA,aACA,SACA,SACA,aACM;AACN,aAAW,MAAM,UAAU;AACzB,eAAW,QAAQ,YAAY;AAC7B,YAAM,OAAO,QAAQ,IAAI,IAAI,KAAK,IAAI,KAAK;AAC3C,YAAM,YAAY,iBAAiB,aAAa,KAAK,WAAW;AAChE,UAAI,cAAc,KAAK;AACrB,gBAAQ,IAAI,MAAM,SAAS;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AACF;AAKO,SAAS,4BACd,UACA,aACA,UACA,UACA,aACM;AACN,QAAM,UAAU,QAAQ,WAAW;AACnC,MAAI,CAAC,WAAW,YAAY,IAAK;AAEjC,aAAW,MAAM,UAAU;AACzB,UAAM,QAAQ,SAAS,EAAE;AACzB,QAAI,CAAC,MAAO;AACZ,UAAM,YAAY,oBAAoB,OAAO,aAAa,WAAW;AACrE,QAAI,cAAc,OAAO;AACvB,eAAS,IAAI,SAAS;AAAA,IACxB;AAAA,EACF;AACF;AAMO,SAAS,oBACd,SACA,aACA,aACQ;AACR,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,QAAQ,QAAQ,YAAY,CAAC,MAAM,OAAe,WAAmB;AAC1E,UAAM,YAAY,UAAU,IAAI,KAAK;AACrC,UAAM,YAAY,iBAAiB,aAAa,UAAU,WAAW;AACrE,QAAI,cAAc,SAAU,QAAO;AACnC,WAAO,OAAO,SAAS,EAAE,GAAG,SAAS,GAAG,SAAS,EAAE;AAAA,EACrD,CAAC;AACH;","names":["resolve"]}

package/dist/gsapParserAcorn.js

@@ -171,8 +171,79 @@ function containsTimelineCall(node, timelineVar) {
 function rangeOf(node) {
   return typeof node.start === "number" && typeof node.end === "number" ? [node.start, node.end] : void 0;
 }
+var SAFE_DEFAULT_NODES = /* @__PURE__ */ new Set([
+  "ArrayExpression",
+  "BinaryExpression",
+  "ChainExpression",
+  "ConditionalExpression",
+  "Identifier",
+  "Literal",
+  "LogicalExpression",
+  "MemberExpression",
+  "ObjectExpression",
+  "Property",
+  "SpreadElement",
+  "TemplateElement",
+  "TemplateLiteral",
+  "UnaryExpression"
+]);
+function isSafeDefaultExpression(node, earlierParams) {
+  let safe = true;
+  const visit = (current, parent, key) => {
+    if (!isNode(current) || !safe) return;
+    if (!SAFE_DEFAULT_NODES.has(current.type)) {
+      safe = false;
+      return;
+    }
+    if (current.type === "UnaryExpression" && current.operator === "delete") {
+      safe = false;
+      return;
+    }
+    if (current.type === "Identifier") {
+      const nonValue = parent && key ? isNonValueIdentifierSlot(parent, key) : false;
+      if (!nonValue && current.name !== "undefined" && !earlierParams.has(current.name)) {
+        safe = false;
+      }
+      return;
+    }
+    for (const childKey of Object.keys(current)) {
+      if (SKIP_KEYS.has(childKey)) continue;
+      const child = current[childKey];
+      if (Array.isArray(child)) {
+        for (const item of child) visit(item, current, childKey);
+      } else {
+        visit(child, current, childKey);
+      }
+    }
+  };
+  visit(node);
+  return safe;
+}
+var SUPPORTED_PARAMS_CACHE = /* @__PURE__ */ new WeakMap();
+function supportedParam(param, earlier) {
+  if (param.type === "Identifier") return { name: param.name };
+  if (param.type !== "AssignmentPattern" || param.left?.type !== "Identifier") return null;
+  if (!isSafeDefaultExpression(param.right, earlier)) return null;
+  return { name: param.left.name, defaultExpression: param.right };
+}
+function supportedParams(fn) {
+  if (SUPPORTED_PARAMS_CACHE.has(fn)) return SUPPORTED_PARAMS_CACHE.get(fn) ?? null;
+  const params = [];
+  const earlier = /* @__PURE__ */ new Set();
+  for (const param of fn.params ?? []) {
+    const parsed = supportedParam(param, earlier);
+    if (!parsed) {
+      SUPPORTED_PARAMS_CACHE.set(fn, null);
+      return null;
+    }
+    params.push(parsed);
+    earlier.add(parsed.name);
+  }
+  SUPPORTED_PARAMS_CACHE.set(fn, params);
+  return params;
+}
 function isShapeEligible(fn) {
-  return isFunctionNode(fn) && fn.body?.type === "BlockStatement" && !(fn.params ?? []).some((p) => p.type !== "Identifier");
+  return isFunctionNode(fn) && fn.body?.type === "BlockStatement" && supportedParams(fn) !== null;
 }
 function callsAny(node, names) {
   let hit = false;
@@ -222,20 +293,55 @@ function timelineBuildingNames(candidates, timelineVar) {
 function bump(counts, key) {
   counts.set(key, (counts.get(key) ?? 0) + 1);
 }
+function undefinedIdentifier() {
+  return { type: "Identifier", name: "undefined" };
+}
+function isExplicitUndefined(node) {
+  return node?.type === "Identifier" && node.name === "undefined" || node?.type === "UnaryExpression" && node.operator === "void" && node.argument?.type === "Literal" && node.argument.value === 0;
+}
+function resolveHelperBindings(call, params) {
+  if (call.arguments?.some((arg) => arg?.type === "SpreadElement")) return null;
+  const bindings = /* @__PURE__ */ new Map();
+  for (let i = 0; i < params.length; i++) {
+    const param = params[i];
+    const arg = call.arguments?.[i];
+    if (arg && !isExplicitUndefined(arg)) {
+      bindings.set(param.name, arg);
+    } else if (param.defaultExpression) {
+      bindings.set(param.name, substituteParams(cloneNode(param.defaultExpression), bindings));
+    } else {
+      bindings.set(param.name, undefinedIdentifier());
+    }
+  }
+  return bindings;
+}
+function statementHelperCall(node, names) {
+  if (node.type !== "ExpressionStatement") return void 0;
+  const expression = node.expression;
+  if (expression?.type !== "CallExpression" || expression.callee?.type !== "Identifier") {
+    return void 0;
+  }
+  return names.has(expression.callee.name) ? expression : void 0;
+}
 function safelyDroppable(program, candidates) {
   const names = new Set(candidates.keys());
   const totalIds = /* @__PURE__ */ new Map();
   const stmtCalls = /* @__PURE__ */ new Map();
+  const unbindable = /* @__PURE__ */ new Set();
   walkNodes(program, (n) => {
     if (n.type === "Identifier" && names.has(n.name)) bump(totalIds, n.name);
-    const e = n.type === "ExpressionStatement" ? n.expression : void 0;
-    if (e?.type === "CallExpression" && e.callee?.type === "Identifier" && names.has(e.callee.name)) {
-      bump(stmtCalls, e.callee.name);
-    }
+    const call = statementHelperCall(n, names);
+    if (!call) return;
+    bump(stmtCalls, call.callee.name);
+    const fn = candidates.get(call.callee.name);
+    const params = fn && supportedParams(fn);
+    if (!params || !resolveHelperBindings(call, params)) unbindable.add(call.callee.name);
   });
   const safe = /* @__PURE__ */ new Map();
   for (const [name, fn] of candidates) {
-    if ((totalIds.get(name) ?? 0) === 1 + (stmtCalls.get(name) ?? 0)) safe.set(name, fn);
+    if (!unbindable.has(name) && (totalIds.get(name) ?? 0) === 1 + (stmtCalls.get(name) ?? 0)) {
+      safe.set(name, fn);
+    }
   }
   return safe;
 }
@@ -278,11 +384,11 @@ function expandBody(bodyStmts, bindings, prov, ctx) {
 }
 function inlineHelper(call, ctx) {
   const fn = ctx.helpers.get(call.callee.name);
-  const bindings = /* @__PURE__ */ new Map();
-  (fn.params ?? []).forEach((p, i) => {
-    const arg = call.arguments?.[i];
-    if (arg) bindings.set(p.name, arg);
-  });
+  if (!fn) return null;
+  const params = supportedParams(fn);
+  if (!params) return null;
+  const bindings = resolveHelperBindings(call, params);
+  if (!bindings) return null;
   const prov = {
     kind: "helper",
     fn: call.callee.name,