hyperframes 0.8.193 → 0.8.195

package/dist/{chunk-2VXY3PEF.js → chunk-2TU4OKIR.js}

@@ -3714,7 +3714,9 @@ var require_dist = __commonJS({
 import { parse } from "acorn";
 var import_postcss_selector_parser = __toESM(require_dist(), 1);
 import postcss from "postcss";
-import { parse as parse2 } from "acorn";
+import { parse as parse2, parseExpressionAt } from "acorn";
+import { parse as parse3 } from "acorn";
+var import_postcss_selector_parser2 = __toESM(require_dist(), 1);
 import postcss2 from "postcss";
 import postcss3 from "postcss";
 
@@ -3753,7 +3755,6 @@ function trackKindOf(node) {
 }
 
 // ../lint/dist/index.js
-import { parse as parse3, parseExpressionAt } from "acorn";
 import { createHash } from "crypto";
 import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
 import { dirname as dirname2, extname, join as join3, relative as relative2, resolve } from "path";
@@ -3833,7 +3834,18 @@ function parseStartExpression(raw) {
     offset: reference.operator === "-" ? -reference.magnitude : reference.magnitude
   };
 }
-function findReferenceTargetEl(doc, refId) {
+function compositionScopeOf(el) {
+  return (el.getAttribute("data-composition-id") !== null ? el.parentElement : el)?.closest?.(
+    "[data-composition-id]"
+  ) ?? null;
+}
+function findReferenceTargetEl(doc, refId, from) {
+  const scope = compositionScopeOf(from);
+  if (scope) {
+    for (const candidate of scope.querySelectorAll?.(`[id="${refId}"]`) ?? []) {
+      if (compositionScopeOf(candidate) === scope) return candidate;
+    }
+  }
   return doc.getElementById(refId) ?? doc.querySelector(`[data-composition-id="${refId}"]`);
 }
 function resolveReferencedStart(doc, el, startCache, visiting) {
@@ -3852,7 +3864,7 @@ function resolveReferencedStart(doc, el, startCache, visiting) {
       startCache.set(el, value);
       return value;
     }
-    const target = findReferenceTargetEl(doc, expression.refId);
+    const target = findReferenceTargetEl(doc, expression.refId, el);
     if (!target) {
       startCache.set(el, 0);
       return 0;
@@ -4690,11 +4702,96 @@ function buildLintContext(html, options = {}) {
     options
   };
 }
+var GLSL_SCRIPT_TYPES = /* @__PURE__ */ new Set(["x-shader/x-fragment", "x-shader/x-vertex", "text/glsl"]);
+function withoutComments(source) {
+  return source.replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*/g, (text) => text.replace(/[^\r\n]/g, " "));
+}
+function staticShaders(source) {
+  const shaders = [];
+  try {
+    const ast = parse2(source, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      allowReturnOutsideFunction: true
+    });
+    simple(ast, {
+      Literal(node) {
+        if (typeof node.value !== "string") return;
+        shaders.push({
+          text: node.value,
+          start: node.start + 1,
+          exactOffsets: source.slice(node.start + 1, node.end - 1) === node.value
+        });
+      },
+      TemplateLiteral(node) {
+        if (node.expressions.length !== 0) return;
+        const value = node.quasis[0]?.value;
+        if (value?.cooked == null) return;
+        shaders.push({
+          text: value.cooked,
+          start: node.start + 1,
+          exactOffsets: source.slice(node.start + 1, node.end - 1) === value.cooked
+        });
+      }
+    });
+  } catch {
+  }
+  return shaders.filter(({ text }) => /\bvoid\s+main\s*\(/.test(withoutComments(text)));
+}
+function isNumber(node, value) {
+  return node?.type === "Literal" && node.value === value;
+}
+function isCall(node, name) {
+  return node?.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === name;
+}
+function unboundedCosine(node) {
+  if (node.type !== "CallExpression") return false;
+  if (isCall(node, "dot")) return node.arguments.length === 2;
+  if (!isCall(node, "max") || node.arguments.length !== 2) return false;
+  const a = argumentAt(node, 0);
+  const b = argumentAt(node, 1);
+  return zeroFlooredDot(a, b) || zeroFlooredDot(b, a);
+}
+function argumentAt(call, index) {
+  const node = call.arguments[index];
+  return node?.type === "SpreadElement" ? void 0 : node;
+}
+function zeroFlooredDot(a, b) {
+  return isCall(a, "dot") && isNumber(b, 0);
+}
+function unsafeCosinePower(call) {
+  if (call.arguments.length !== 2) return false;
+  const [base2] = call.arguments;
+  return base2?.type === "BinaryExpression" && base2.operator === "-" && base2.left.type !== "PrivateIdentifier" && isNumber(base2.left, 1) && unboundedCosine(base2.right);
+}
+function unsafePowOffsets(source) {
+  const offsets = [];
+  const masked = withoutComments(source);
+  for (const match of masked.matchAll(/\bpow\s*\(/g)) {
+    try {
+      const expression = parseExpressionAt(masked, match.index, { ecmaVersion: "latest" });
+      simple(expression, {
+        CallExpression(node) {
+          if (node.start === match.index && unsafeCosinePower(node)) offsets.push(node.start);
+        }
+      });
+    } catch {
+    }
+  }
+  return offsets;
+}
+function shaderDomainOffsets(source, glsl = false) {
+  const shaders = glsl ? [{ text: source, start: 0, exactOffsets: true }] : staticShaders(source);
+  return shaders.flatMap(
+    ({ text, start, exactOffsets }) => unsafePowOffsets(text).map((offset) => exactOffsets ? start + offset : void 0)
+  );
+}
 var SCRIPT_SYNTAX_EXEMPT_TYPES = /* @__PURE__ */ new Set([
   "application/json",
   "application/hyperframes-slideshow+json",
   "importmap",
-  "module"
+  "module",
+  ...GLSL_SCRIPT_TYPES
 ]);
 function repeatedDescendantId(selector) {
   let repeated = null;
@@ -5493,7 +5590,7 @@ function driftingFields(members) {
     return values.some((value) => Math.abs(value - first) > SYNC_TOLERANCE_S);
   }).map(({ field }) => field);
 }
-function compositionScopeOf(tag, compositions) {
+function compositionScopeOf2(tag, compositions) {
   let scope = -1;
   for (const composition of compositions) {
     const end = composition.endIndex ?? composition.closeIndex ?? Number.POSITIVE_INFINITY;
@@ -5512,7 +5609,7 @@ function groupByLink(tags) {
   for (const tag of tags) {
     const link = readAttr(tag.raw, "data-link");
     if (!link) continue;
-    const key = `${compositionScopeOf(tag, compositions)}\0${link}`;
+    const key = `${compositionScopeOf2(tag, compositions)}\0${link}`;
     const group = groups.get(key) ?? { link, members: [] };
     group.members.push(tag);
     groups.set(key, group);
@@ -6442,7 +6539,7 @@ function callsFor(script) {
   if (cached) return cached;
   const calls = [];
   try {
-    const ast = parse2(script.content, {
+    const ast = parse3(script.content, {
       ecmaVersion: "latest",
       sourceType: "script",
       allowReturnOutsideFunction: true
@@ -6627,12 +6724,154 @@ function firstRescalingZoom(css) {
   }
   return null;
 }
-function targetsCanvasRoot(selector, rootId, rootClasses) {
+function canvasScopeCandidate(selector, root) {
   const leftmost = selector.trim().split(/[\s>+~]+/)[0] ?? "";
-  const bare = leftmost.toLowerCase();
-  if (bare === "html" || bare === "body" || bare === ":root" || bare === "*") return true;
-  if (rootId && leftmostCompoundId(selector) === rootId) return true;
-  return leftmostCompoundClasses(selector).some((cls) => rootClasses.includes(cls));
+  if (["html", "body", ":root", "*"].includes(leftmost.toLowerCase())) return true;
+  if (root.id && leftmostCompoundId(selector) === root.id) return true;
+  return leftmostCompoundClasses(selector).some((name) => root.classes.includes(name));
+}
+function canvasIdentity(tag) {
+  return {
+    name: tag.name,
+    raw: tag.raw,
+    id: readDecodedAttr(tag.raw, "id"),
+    classes: (readDecodedAttr(tag.raw, "class") ?? "").split(/[\t\n\f\r ]+/)
+  };
+}
+function anyCanvasMatch(matches) {
+  if (matches.includes(true)) return true;
+  return matches.includes(void 0) ? void 0 : false;
+}
+function allCanvasMatch(matches) {
+  if (matches.includes(false)) return false;
+  return matches.includes(void 0) ? void 0 : true;
+}
+function canvasTokenMatch(tokens, value) {
+  if (tokens.includes(value)) return true;
+  const fold = (token) => token.replace(/[A-Z]/g, (char) => char.toLowerCase());
+  return tokens.some((token) => fold(token) === fold(value)) ? void 0 : false;
+}
+function canvasPseudoMatch(node, element, hasIdentity) {
+  const name = node.value.toLowerCase();
+  if (name.startsWith("::") || [":before", ":after", ":first-letter", ":first-line"].includes(name))
+    return { match: false, hasIdentity: false };
+  if ([":is", ":where"].includes(name)) {
+    const branches = node.nodes.map(
+      (branch) => canvasPathMatch(branch.nodes, element, hasIdentity)
+    );
+    const match = anyCanvasMatch(branches.map((branch) => branch.match));
+    return { match, hasIdentity: match === true || branches.some((branch) => branch.hasIdentity) };
+  }
+  if (name === ":root") {
+    const match = element.name === "html";
+    return { match, hasIdentity: match };
+  }
+  if (name === ":nth-child" && element.name === "body") {
+    const argument = node.nodes.map((branch) => branch.toString()).join(",").trim();
+    if (/^[1-9]\d*$/.test(argument)) {
+      const match = Number(argument) === 2;
+      return { match, hasIdentity: match };
+    }
+  }
+  return { match: void 0, hasIdentity: false };
+}
+function canvasTagMatch(node, element) {
+  if (node.namespace !== void 0) return { match: void 0, hasIdentity: false };
+  if (node.value.toLowerCase() !== element.name.toLowerCase())
+    return { match: false, hasIdentity: false };
+  return { match: ["html", "body"].includes(element.name) ? true : void 0, hasIdentity: true };
+}
+function canvasAttributeMatch(node, element) {
+  if (node.namespace === void 0 && node.operator === void 0 && /^data-[a-z0-9_-]+$/.test(node.attribute))
+    return readDecodedAttr(element.raw, node.attribute) !== null;
+  return void 0;
+}
+function canvasNodeMatch(node, element, hasIdentity) {
+  switch (node.type) {
+    case "id": {
+      const match = canvasTokenMatch(element.id === null ? [] : [element.id], node.value);
+      return { match, hasIdentity: match === true };
+    }
+    case "class": {
+      const match = canvasTokenMatch(element.classes, node.value);
+      return { match, hasIdentity: match === true };
+    }
+    case "tag":
+      return canvasTagMatch(node, element);
+    case "universal":
+      return { match: node.toString().trim() === "*" ? true : void 0, hasIdentity: false };
+    case "attribute":
+      return { match: canvasAttributeMatch(node, element), hasIdentity: false };
+    case "pseudo":
+      return canvasPseudoMatch(node, element, hasIdentity);
+    default:
+      return { match: void 0, hasIdentity: false };
+  }
+}
+function canvasAncestorMatch(nodes, relation, element) {
+  if (!["", ">"].includes(relation)) return void 0;
+  const matches = [];
+  let parent = element.parent;
+  while (parent) {
+    matches.push(canvasPathMatch(nodes, parent).match);
+    if (relation === ">") break;
+    parent = parent.parent;
+  }
+  if (parent === void 0) matches.push(void 0);
+  return anyCanvasMatch(matches);
+}
+function canvasPathMatch(nodes, element, inheritedIdentity = false) {
+  let split = -1;
+  let relation = "";
+  for (const [index, node] of nodes.entries()) {
+    if (node.type === "combinator") {
+      split = index;
+      relation = node.value.trim();
+    }
+  }
+  const subjectNodes = nodes.slice(split + 1);
+  if (subjectNodes.length === 0) return { match: void 0, hasIdentity: false };
+  const matches = subjectNodes.map((node) => canvasNodeMatch(node, element, inheritedIdentity));
+  const hasIdentity = inheritedIdentity || matches.some((result) => result.hasIdentity);
+  const subject = allCanvasMatch(
+    subjectNodes.map((node, index) => {
+      const match2 = matches[index]?.match;
+      if (!hasIdentity || match2 !== false) return match2;
+      if (["id", "class", "attribute"].includes(node.type)) return void 0;
+      if (node.type === "pseudo" && !inheritedIdentity)
+        return canvasNodeMatch(node, element, true).match;
+      return match2;
+    })
+  );
+  const match = subject === false || split === -1 ? subject : allCanvasMatch([subject, canvasAncestorMatch(nodes.slice(0, split), relation, element)]);
+  return { match, hasIdentity: match !== false && hasIdentity };
+}
+function canvasElements(rootTag, tags) {
+  const root = canvasIdentity(rootTag);
+  const html = {
+    ...root.name === "html" ? root : canvasIdentity(findHtmlTag(tags) ?? { name: "html", raw: "<html>" }),
+    parent: null
+  };
+  const body = {
+    ...root.name === "body" ? root : canvasIdentity(tags.find((tag) => tag.name === "body") ?? { name: "body", raw: "<body>" }),
+    parent: html
+  };
+  const elements = [html, body];
+  if (!["html", "body"].includes(root.name))
+    elements.push({ ...root, parent: ["head", "template"].includes(root.name) ? void 0 : body });
+  return { root, elements };
+}
+function canvasSelectorMatcher(rootTag, tags) {
+  let canvas;
+  return (selector, allowNewHits) => {
+    const { root, elements } = canvas ??= canvasElements(rootTag, tags);
+    const match = anyCanvasMatch(
+      elements.map((element) => canvasPathMatch(selector.nodes, element).match)
+    );
+    if (match === false) return false;
+    if (match === true && allowNewHits) return true;
+    return selector.toString().split(",").some((part) => canvasScopeCandidate(part, root));
+  };
 }
 function inlineCanvasZoomHits(rootTag, tags) {
   const hits = [];
@@ -6650,19 +6889,23 @@ function inlineCanvasZoomHits(rootTag, tags) {
   }
   return hits;
 }
-function firstCanvasSelector(header, rootId, rootClasses) {
-  for (const selector of header.split(",")) {
-    const trimmed = selector.trim();
-    if (trimmed && targetsCanvasRoot(trimmed, rootId, rootClasses)) return trimmed;
+function firstCanvasSelector(header, matchesCanvas) {
+  try {
+    for (const selector of (0, import_postcss_selector_parser2.default)().astSync(header).nodes) {
+      const trimmed = selector.toString().trim();
+      if (matchesCanvas(selector)) return trimmed;
+    }
+  } catch {
+    return null;
   }
   return null;
 }
-function canvasZoomInRule(header, body, rootId, rootClasses) {
+function canvasZoomInRule(header, body, matchesCanvas) {
   const trimmedHeader = header.trim();
   if (!trimmedHeader || trimmedHeader.startsWith("@")) return null;
   const value = firstRescalingZoom(body);
   if (!value) return null;
-  const selector = firstCanvasSelector(trimmedHeader, rootId, rootClasses);
+  const selector = firstCanvasSelector(trimmedHeader, matchesCanvas);
   if (!selector) return null;
   return {
     where: `\`${selector}\``,
@@ -6670,23 +6913,28 @@ function canvasZoomInRule(header, body, rootId, rootClasses) {
     snippet: truncateSnippet(`${selector} { zoom: ${value} }`)
   };
 }
-function stylesheetCanvasZoomHits(styles, rootId, rootClasses) {
+function stylesheetCanvasZoomHits(styles, matchesCanvas) {
   const hits = [];
   for (const style of styles) {
     const ruleWithBody = /([^{}]+)\{([^{}]*)\}/g;
     const content = stripCssComments(style.content);
+    const allowNewHits = style.attrs.trim() === "" && !content.includes("@");
     let match;
     while ((match = ruleWithBody.exec(content)) !== null) {
-      const hit = canvasZoomInRule(match[1] ?? "", match[2] ?? "", rootId, rootClasses);
+      const hit = canvasZoomInRule(
+        match[1] ?? "",
+        match[2] ?? "",
+        (selector) => matchesCanvas(selector, allowNewHits)
+      );
       if (hit) hits.push(hit);
     }
   }
   return hits;
 }
-function canvasZoomHits(rootTag, tags, styles, rootId, rootClasses) {
+function canvasZoomHits(rootTag, tags, styles) {
   return [
     ...inlineCanvasZoomHits(rootTag, tags),
-    ...stylesheetCanvasZoomHits(styles, rootId, rootClasses)
+    ...stylesheetCanvasZoomHits(styles, canvasSelectorMatcher(rootTag, tags))
   ];
 }
 function collectDeclaredVariableIds(htmlTagRaw) {
@@ -7584,9 +7832,7 @@ ${allInlineStyles}`.replace(/\/\*[\s\S]*?\*\//g, "");
   // fired on every `zoom` would be flagging correct authoring.
   ({ rootTag, tags, styles }) => {
     if (!rootTag) return [];
-    const rootId = readAttr(rootTag.raw, "id");
-    const rootClasses = (readAttr(rootTag.raw, "class") || "").split(/\s+/).filter(Boolean);
-    const hits = canvasZoomHits(rootTag, tags, styles, rootId, rootClasses);
+    const hits = canvasZoomHits(rootTag, tags, styles);
     const hit = hits[0];
     if (!hit) return [];
     const enlarging = !hit.value.startsWith("-") && parseFloat(hit.value) > (hit.value.includes("%") ? 100 : 1);
@@ -7676,11 +7922,11 @@ function deriveDurationFromClips(tags, rootTag) {
   return resolveCompositionDuration({ authoredDurationSeconds: null, clipEndsSeconds: clipEnds });
 }
 async function loadParseGsapScript() {
-  const mod = await import("./gsapParserAcorn-OOTY2MVN.js");
+  const mod = await import("./gsapParserAcorn-LZJKCFQI.js");
   return mod.parseGsapScriptAcorn;
 }
 async function loadGsapScriptMotionPathFirstUseIndex() {
-  const mod = await import("./gsapParserAcorn-OOTY2MVN.js");
+  const mod = await import("./gsapParserAcorn-LZJKCFQI.js");
   return mod.gsapScriptMotionPathFirstUseIndex;
 }
 var SCENE_BOUNDARY_EPSILON_SECONDS = 0.05;
@@ -8632,9 +8878,12 @@ ${right.raw}`)
     const usesGsap = allScriptTexts.some(
       (t) => /gsap\.(to|from|fromTo|timeline|set|registerPlugin)\b/.test(t)
     );
-    const hasGsapScript = allScriptSrcs.some((src) => /gsap/i.test(src));
+    const isGsapCoreSrc = (src) => /(^|\/)gsap(-\d+(\.\d+)*)?(\.min)?\.js$/i.test(src.split(/[?#]/)[0] ?? "");
+    const hasGsapScript = allScriptSrcs.some(isGsapCoreSrc);
     const hasInlineGsap = allScriptTexts.some(
-      (t) => /\/\*\s*inlined:.*gsap/i.test(t) || /\b_gsScope\b/.test(t) || /\bGreenSock\b/.test(t) || /\bgsap\.(config|defaults|version)\b/.test(t) || t.length > 5e3 && /\bgsap\b/i.test(t)
+      (t) => [...t.matchAll(/\/\*\s*inlined:\s*(\S+)\s*\*\//gi)].some(
+        (m) => isGsapCoreSrc(m[1] ?? "")
+      ) || /\/\*!\s*\*\s*GSAP\s+\d/.test(t) || /Missing plugin\? gsap\.registerPlugin\(\)/.test(t) || /\b_gsScope\b/.test(t)
     );
     if (!usesGsap || hasGsapScript || hasInlineGsap || canInheritGsapFromHost) return [];
     return [
@@ -10311,89 +10560,6 @@ var structureRules = [
     return topLevelElements(root).filter((row) => !isSubCompositionHost(row)).flatMap((row) => neverVisibleNestedFindings(row, severity));
   }
 ];
-function withoutComments(source) {
-  return source.replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*/g, (text) => text.replace(/[^\r\n]/g, " "));
-}
-function staticShaders(source) {
-  const shaders = [];
-  try {
-    const ast = parse3(source, {
-      ecmaVersion: "latest",
-      sourceType: "module",
-      allowReturnOutsideFunction: true
-    });
-    simple(ast, {
-      Literal(node) {
-        if (typeof node.value !== "string") return;
-        shaders.push({
-          text: node.value,
-          start: node.start + 1,
-          exactOffsets: source.slice(node.start + 1, node.end - 1) === node.value
-        });
-      },
-      TemplateLiteral(node) {
-        if (node.expressions.length !== 0) return;
-        const value = node.quasis[0]?.value;
-        if (value?.cooked == null) return;
-        shaders.push({
-          text: value.cooked,
-          start: node.start + 1,
-          exactOffsets: source.slice(node.start + 1, node.end - 1) === value.cooked
-        });
-      }
-    });
-  } catch {
-  }
-  return shaders.filter(({ text }) => /\bvoid\s+main\s*\(/.test(withoutComments(text)));
-}
-function isNumber(node, value) {
-  return node?.type === "Literal" && node.value === value;
-}
-function isCall(node, name) {
-  return node?.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === name;
-}
-function unboundedCosine(node) {
-  if (node.type !== "CallExpression") return false;
-  if (isCall(node, "dot")) return node.arguments.length === 2;
-  if (!isCall(node, "max") || node.arguments.length !== 2) return false;
-  const a = argumentAt(node, 0);
-  const b = argumentAt(node, 1);
-  return zeroFlooredDot(a, b) || zeroFlooredDot(b, a);
-}
-function argumentAt(call, index) {
-  const node = call.arguments[index];
-  return node?.type === "SpreadElement" ? void 0 : node;
-}
-function zeroFlooredDot(a, b) {
-  return isCall(a, "dot") && isNumber(b, 0);
-}
-function unsafeCosinePower(call) {
-  if (call.arguments.length !== 2) return false;
-  const [base2] = call.arguments;
-  return base2?.type === "BinaryExpression" && base2.operator === "-" && base2.left.type !== "PrivateIdentifier" && isNumber(base2.left, 1) && unboundedCosine(base2.right);
-}
-function unsafePowOffsets(source) {
-  const offsets = [];
-  const masked = withoutComments(source);
-  for (const match of masked.matchAll(/\bpow\s*\(/g)) {
-    try {
-      const expression = parseExpressionAt(masked, match.index, { ecmaVersion: "latest" });
-      simple(expression, {
-        CallExpression(node) {
-          if (node.start === match.index && unsafeCosinePower(node)) offsets.push(node.start);
-        }
-      });
-    } catch {
-    }
-  }
-  return offsets;
-}
-function shaderDomainOffsets(source, glsl = false) {
-  const shaders = glsl ? [{ text: source, start: 0, exactOffsets: true }] : staticShaders(source);
-  return shaders.flatMap(
-    ({ text, start, exactOffsets }) => unsafePowOffsets(text).map((offset) => exactOffsets ? start + offset : void 0)
-  );
-}
 function shaderDomainWarning() {
   return {
     code: "shader_unbounded_cosine_pow",
@@ -10407,7 +10573,7 @@ var shaderRules = [
     const tag = `<script ${script.attrs}>`;
     if (readAttr(tag, "src") !== null) return [];
     const type = readAttr(tag, "type") ?? "";
-    const glsl = /^(?:x-shader\/x-(?:fragment|vertex)|text\/glsl)$/i.test(type);
+    const glsl = GLSL_SCRIPT_TYPES.has(type.toLowerCase());
     if (type && !glsl && !/^(?:module|(?:text|application)\/javascript)$/i.test(type)) return [];
     return shaderDomainOffsets(script.content, glsl).map((offset) => ({
       ...shaderDomainWarning(),

package/dist/{chunk-4PPWAQYV.js → chunk-3OAFRLD3.js}

@@ -7,29 +7,29 @@ var __dirname = __hf_dirname(__filename);
 import {
   RegistryCompatibilityError,
   gateRegistryItemsCompatibility
-} from "./chunk-ZT45TCY3.js";
+} from "./chunk-3PYIQLPL.js";
 import {
   DEFAULT_PROJECT_CONFIG,
   createProjectConfig,
   loadProjectConfig,
   projectConfigPath,
   recordProjectRegistryItems
-} from "./chunk-6XUJVEY2.js";
+} from "./chunk-RAACYYWX.js";
 import {
   resolveItemWithDependencies,
   resolveItemsByTag
-} from "./chunk-X5CECNCK.js";
+} from "./chunk-D6XDOYMB.js";
 import {
   InvalidVariableValuesError,
   prepareItem,
   publishItem
-} from "./chunk-QKX7ITER.js";
+} from "./chunk-W4SSWOOD.js";
 import {
   DEFAULT_REGISTRY_URL
-} from "./chunk-7QNIXBQD.js";
+} from "./chunk-HT33OHQL.js";
 import {
   trackRegistryItemAdded
-} from "./chunk-RTLPWOO6.js";
+} from "./chunk-ZL6ZCLY6.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -41,7 +41,7 @@ import {
 } from "./chunk-ZTZA4UWZ.js";
 import {
   ITEM_TYPE_DIRS
-} from "./chunk-7HTH5PFK.js";
+} from "./chunk-E74JMKSK.js";
 import {
   isProjectRootMissing,
   realpath

package/dist/{chunk-ZT45TCY3.js → chunk-3PYIQLPL.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   VERSION
-} from "./chunk-LFUVTS6V.js";
+} from "./chunk-66Q27H72.js";
 
 // src/registry/compatibility.ts
 import { compareVersions } from "compare-versions";

package/dist/{chunk-DYNHVCBF.js → chunk-4R2NWLQL.js}

@@ -6,10 +6,10 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   detectGpuEncoder
-} from "./chunk-L4JB7LI4.js";
+} from "./chunk-HJINEUHY.js";
 import {
   runCancellableProcess
-} from "./chunk-RWGASWT7.js";
+} from "./chunk-BL4U6U52.js";
 import {
   findFfBinary
 } from "./chunk-VAS6HQX3.js";

package/dist/{chunk-SOY2FPOR.js → chunk-636WBDXB.js}

@@ -6,26 +6,26 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   parakeetRunner
-} from "./chunk-OFV3WSOE.js";
+} from "./chunk-TE6VGYHQ.js";
 import {
   DecodeCancelled,
   prepareSherpaWav,
   sherpaUnsupportedReason,
   transcribeWithSherpa
-} from "./chunk-MFUNDJEV.js";
+} from "./chunk-6ORTRIDW.js";
 import {
   initialModelForLanguage,
   transcribe
-} from "./chunk-M3KZBDPB.js";
+} from "./chunk-2HSRLKZR.js";
 import {
   createRenderCancellationScope,
   stoppedByCancelSignal
-} from "./chunk-BP4EMEGH.js";
+} from "./chunk-P5X5URNQ.js";
 import {
   DEFAULT_MODEL,
   findWhisper,
   isWhisperUnavailable
-} from "./chunk-VLLFORE2.js";
+} from "./chunk-F4T7XYMF.js";
 import {
   formatSrt,
   formatVtt,

package/dist/{chunk-LFUVTS6V.js → chunk-66Q27H72.js}

@@ -6,8 +6,8 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 
 // src/version.ts
-var VERSION = true ? "0.8.193" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.193" : "0.0.0-dev";
+var VERSION = true ? "0.8.195" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.195" : "0.0.0-dev";
 
 export {
   VERSION,

package/dist/{chunk-MFUNDJEV.js → chunk-6ORTRIDW.js}

@@ -21,13 +21,13 @@ import {
   emitWords,
   getPreparedWavDurationSeconds,
   prepareWav
-} from "./chunk-M3KZBDPB.js";
+} from "./chunk-2HSRLKZR.js";
 import {
   stoppedByCancelSignal
-} from "./chunk-BP4EMEGH.js";
+} from "./chunk-P5X5URNQ.js";
 import {
   verifies
-} from "./chunk-VLLFORE2.js";
+} from "./chunk-F4T7XYMF.js";
 import {
   PARAKEET_MODEL_LABEL,
   SHERPA_ERROR_PREFIX,