@hyperframes/parsers 0.7.15

package/dist/index.js

@@ -0,0 +1,2500 @@
+// src/types.ts
+var CANVAS_DIMENSIONS = {
+  landscape: { width: 1920, height: 1080 },
+  portrait: { width: 1080, height: 1920 },
+  "landscape-4k": { width: 3840, height: 2160 },
+  "portrait-4k": { width: 2160, height: 3840 },
+  square: { width: 1080, height: 1080 },
+  "square-4k": { width: 2160, height: 2160 }
+};
+var VALID_CANVAS_RESOLUTIONS = Object.keys(
+  CANVAS_DIMENSIONS
+);
+var RESOLUTION_ALIASES = {
+  "1080p": "landscape",
+  hd: "landscape",
+  "1080p-portrait": "portrait",
+  "portrait-1080p": "portrait",
+  "4k": "landscape-4k",
+  uhd: "landscape-4k",
+  "4k-portrait": "portrait-4k",
+  "1080p-square": "square",
+  "square-1080p": "square",
+  "4k-square": "square-4k"
+};
+function normalizeResolutionFlag(input) {
+  if (!input) return void 0;
+  const lowered = input.toLowerCase();
+  if (VALID_CANVAS_RESOLUTIONS.includes(lowered)) {
+    return lowered;
+  }
+  return RESOLUTION_ALIASES[lowered];
+}
+var COMPOSITION_VARIABLE_TYPES = [
+  "string",
+  "number",
+  "color",
+  "boolean",
+  "enum",
+  "font",
+  "image"
+];
+function isTextElement(el) {
+  return el.type === "text";
+}
+function isMediaElement(el) {
+  return el.type === "video" || el.type === "image" || el.type === "audio";
+}
+function isCompositionElement(el) {
+  return el.type === "composition";
+}
+var TIMELINE_COLORS = {
+  video: "#ec4899",
+  image: "#3b82f6",
+  text: "#06b6d4",
+  audio: "#10b981",
+  composition: "#f97316"
+};
+var DEFAULT_DURATIONS = {
+  video: 5,
+  image: 5,
+  text: 2,
+  audio: 5,
+  composition: 5
+};
+function getDefaultStageZoom(resolution) {
+  const { width, height } = CANVAS_DIMENSIONS[resolution];
+  return {
+    scale: 1,
+    focusX: width / 2,
+    focusY: height / 2
+  };
+}
+
+// src/gsapConstants.ts
+var SUPPORTED_PROPS = [
+  // 2D Transforms
+  "x",
+  "y",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotation",
+  "skewX",
+  "skewY",
+  // 3D Transforms
+  "z",
+  "rotationX",
+  "rotationY",
+  "rotationZ",
+  "perspective",
+  "transformPerspective",
+  "transformOrigin",
+  // Visibility
+  "opacity",
+  "visibility",
+  "autoAlpha",
+  // Dimensions
+  "width",
+  "height",
+  // Colors
+  "color",
+  "backgroundColor",
+  "borderColor",
+  // Box model
+  "borderRadius",
+  // Typography
+  "fontSize",
+  "letterSpacing",
+  // Filter & Clipping
+  "filter",
+  "clipPath",
+  // DOM content (number counters, text roll-ups)
+  "innerText"
+];
+var PROPERTY_GROUPS = {
+  position: /* @__PURE__ */ new Set(["x", "y", "xPercent", "yPercent"]),
+  scale: /* @__PURE__ */ new Set(["scale", "scaleX", "scaleY"]),
+  size: /* @__PURE__ */ new Set(["width", "height"]),
+  rotation: /* @__PURE__ */ new Set(["rotation", "skewX", "skewY"]),
+  visual: /* @__PURE__ */ new Set(["opacity", "autoAlpha"]),
+  other: /* @__PURE__ */ new Set()
+};
+var PROP_TO_GROUP = /* @__PURE__ */ new Map();
+for (const [group, props] of Object.entries(PROPERTY_GROUPS)) {
+  for (const p of props) PROP_TO_GROUP.set(p, group);
+}
+function classifyPropertyGroup(prop) {
+  return PROP_TO_GROUP.get(prop) ?? "other";
+}
+function classifyTweenPropertyGroup(properties) {
+  const groups = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(properties)) {
+    if (key === "transformOrigin" || key === "_auto" || key === "data") continue;
+    const g = classifyPropertyGroup(key);
+    groups.add(g);
+  }
+  if (groups.size === 1) return groups.values().next().value;
+  return void 0;
+}
+var SUPPORTED_EASES = [
+  "none",
+  "power1.in",
+  "power1.out",
+  "power1.inOut",
+  "power2.in",
+  "power2.out",
+  "power2.inOut",
+  "power3.in",
+  "power3.out",
+  "power3.inOut",
+  "power4.in",
+  "power4.out",
+  "power4.inOut",
+  "back.in",
+  "back.out",
+  "back.inOut",
+  "elastic.in",
+  "elastic.out",
+  "elastic.inOut",
+  "bounce.in",
+  "bounce.out",
+  "bounce.inOut",
+  "expo.in",
+  "expo.out",
+  "expo.inOut",
+  "spring-gentle",
+  "spring-bouncy",
+  "spring-stiff",
+  "spring-wobbly",
+  "spring-heavy",
+  "steps(1)"
+];
+
+// src/gsapSerialize.ts
+function editabilityForProvenance(provenance) {
+  if (!provenance || provenance.kind === "literal") return "direct";
+  if (provenance.kind === "runtime-dynamic") return "source";
+  return "unroll";
+}
+function buildArcPath(coords, curviness, autoRotate, isCubic) {
+  const first = coords[0];
+  if (coords.length < 2 || !first) return void 0;
+  const segments = [];
+  let waypoints;
+  if (isCubic && coords.length >= 4) {
+    waypoints = [first];
+    for (let i = 1; i + 2 < coords.length; i += 3) {
+      const cp1 = coords[i];
+      const cp2 = coords[i + 1];
+      const anchor = coords[i + 2];
+      if (!cp1 || !cp2 || !anchor) continue;
+      waypoints.push(anchor);
+      segments.push({ curviness, cp1, cp2 });
+    }
+  } else {
+    waypoints = coords;
+    for (let i = 0; i < waypoints.length - 1; i++) segments.push({ curviness });
+  }
+  return { arcPath: { enabled: true, autoRotate, segments }, waypoints };
+}
+function serializeGsapAnimations(animations, timelineVar = "tl", options) {
+  const sorted = [...animations].sort((a, b) => {
+    const aNum = a.resolvedStart ?? (typeof a.position === "number" ? a.position : Number.MAX_SAFE_INTEGER);
+    const bNum = b.resolvedStart ?? (typeof b.position === "number" ? b.position : Number.MAX_SAFE_INTEGER);
+    return aNum - bNum;
+  });
+  const lines = sorted.map((anim) => {
+    const selector = `"${anim.targetSelector}"`;
+    const props = { ...anim.properties };
+    if (anim.duration !== void 0) props.duration = anim.duration;
+    if (anim.ease) props.ease = anim.ease;
+    let propsStr = serializeObject(props);
+    if (anim.extras && Object.keys(anim.extras).length > 0) {
+      const extrasStr = serializeExtras(anim.extras);
+      if (Object.keys(props).length === 0) {
+        propsStr = `{ ${extrasStr} }`;
+      } else {
+        propsStr = propsStr.slice(0, -2) + `, ${extrasStr} }`;
+      }
+    }
+    const posStr = typeof anim.position === "string" ? `"${anim.position}"` : anim.position;
+    switch (anim.method) {
+      case "set":
+        return anim.global ? `    gsap.set(${selector}, ${propsStr});` : `    ${timelineVar}.set(${selector}, ${propsStr}, ${posStr});`;
+      case "to":
+        return `    ${timelineVar}.to(${selector}, ${propsStr}, ${posStr});`;
+      case "from":
+        return `    ${timelineVar}.from(${selector}, ${propsStr}, ${posStr});`;
+      case "fromTo": {
+        const fromStr = serializeObject(anim.fromProperties || {});
+        return `    ${timelineVar}.fromTo(${selector}, ${fromStr}, ${propsStr}, ${posStr});`;
+      }
+    }
+  });
+  let mediaSync = "";
+  if (options?.includeMediaSync) {
+    mediaSync = `
+    ${timelineVar}.eventCallback("onUpdate", function() {
+      const time = ${timelineVar}.time();
+      document.querySelectorAll("video[data-start], audio[data-start]").forEach(function(media) {
+        const start = parseFloat(media.dataset.start);
+        const end = parseFloat(media.dataset.end) || Infinity;
+        const mediaTime = time - start;
+        if (time >= start && time < end) {
+          if (Math.abs(media.currentTime - mediaTime) > 0.1) {
+            media.currentTime = mediaTime;
+          }
+          if (media.paused && !${timelineVar}.paused()) {
+            media.play().catch(function() {});
+          }
+        } else if (!media.paused) {
+          media.pause();
+        }
+      });
+    });`;
+  }
+  const preamble = options?.preamble || `const ${timelineVar} = gsap.timeline({ paused: true });`;
+  const postamble = options?.postamble ? `
+    ${options.postamble}` : "";
+  return `
+    ${preamble}
+${lines.join("\n")}${mediaSync}${postamble}
+  `;
+}
+function serializeValue(value) {
+  if (typeof value === "string" && value.startsWith("__raw:")) {
+    return value.slice(6);
+  }
+  if (typeof value === "string") return JSON.stringify(value);
+  return String(value);
+}
+function safeJsKey(key) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function serializeObject(obj) {
+  const entries = Object.entries(obj).map(([key, value]) => {
+    return `${safeJsKey(key)}: ${serializeValue(value)}`;
+  });
+  return `{ ${entries.join(", ")} }`;
+}
+function serializeExtras(extras) {
+  return Object.entries(extras).map(([key, value]) => {
+    return `${safeJsKey(key)}: ${serializeValue(value)}`;
+  }).join(", ");
+}
+function getAnimationsForElementId(animations, elementId) {
+  const selector = `#${elementId}`;
+  return animations.filter((a) => a.targetSelector === selector);
+}
+var FORBIDDEN_GSAP_PATTERNS = [
+  { pattern: /\.call\s*\(/, message: "call() method not allowed" },
+  { pattern: /\.add\s*\(/, message: "add() method not allowed" },
+  { pattern: /\.addPause\s*\(/, message: "addPause() method not allowed" },
+  { pattern: /gsap\.registerEffect\s*\(/, message: "registerEffect() not allowed" },
+  { pattern: /ScrollTrigger/, message: "ScrollTrigger not allowed" },
+  { pattern: /onComplete\s*:/, message: "onComplete callback not allowed" },
+  { pattern: /onUpdate\s*:/, message: "onUpdate callback not allowed" },
+  { pattern: /onStart\s*:/, message: "onStart callback not allowed" },
+  { pattern: /onRepeat\s*:/, message: "onRepeat callback not allowed" },
+  { pattern: /onReverseComplete\s*:/, message: "onReverseComplete callback not allowed" },
+  { pattern: /repeat\s*:\s*-1/, message: "Infinite repeat (repeat: -1) not allowed" },
+  { pattern: /Math\.random\s*\(/, message: "Random values (Math.random) not allowed" },
+  { pattern: /Date\.now\s*\(/, message: "Date-dependent values (Date.now) not allowed" },
+  { pattern: /new\s+Date\s*\(/, message: "Date constructor not allowed" },
+  { pattern: /setTimeout\s*\(/, message: "setTimeout not allowed" },
+  { pattern: /setInterval\s*\(/, message: "setInterval not allowed" },
+  { pattern: /requestAnimationFrame\s*\(/, message: "requestAnimationFrame not allowed" }
+];
+function validateCompositionGsap(script) {
+  const errors = [];
+  const warnings = [];
+  for (const { pattern, message } of FORBIDDEN_GSAP_PATTERNS) {
+    if (pattern.test(script)) errors.push(message);
+  }
+  if (/yoyo\s*:\s*true/.test(script)) {
+    warnings.push("yoyo animations may behave unexpectedly when scrubbing");
+  }
+  if (/stagger\s*:/.test(script)) {
+    warnings.push("stagger animations may not serialize correctly");
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+function keyframesToGsapAnimations(elementId, keyframes, elementStartTime, base) {
+  const sorted = [...keyframes].sort((a, b) => a.time - b.time);
+  const animations = [];
+  const baseX = base?.x ?? 0;
+  const baseY = base?.y ?? 0;
+  const baseScale = base?.scale ?? 1;
+  sorted.forEach((kf, i) => {
+    const absoluteTime = elementStartTime + kf.time;
+    const isFirst = i === 0;
+    const prevKf = i > 0 ? sorted[i - 1] : null;
+    const duration = prevKf ? kf.time - prevKf.time : void 0;
+    const position = prevKf ? elementStartTime + prevKf.time : absoluteTime;
+    const properties = {};
+    for (const [key, value] of Object.entries(kf.properties)) {
+      if (typeof value !== "number") continue;
+      if (key === "x") properties.x = baseX + value;
+      else if (key === "y") properties.y = baseY + value;
+      else if (key === "scale") properties.scale = baseScale * value;
+      else properties[key] = value;
+    }
+    animations.push({
+      id: `${elementId}-kf-${kf.id}`,
+      targetSelector: `#${elementId}`,
+      method: isFirst ? "set" : "to",
+      position,
+      properties,
+      duration: isFirst ? void 0 : duration,
+      ease: kf.ease
+    });
+  });
+  return animations;
+}
+function gsapAnimationsToKeyframes(animations, elementStartTime, options) {
+  const validMethods = ["set", "to", "from", "fromTo"];
+  const baseX = options?.baseX ?? 0;
+  const baseY = options?.baseY ?? 0;
+  const baseScale = options?.baseScale ?? 1;
+  const clampTimeToZero = options?.clampTimeToZero ?? true;
+  const skipBaseSet = options?.skipBaseSet ?? false;
+  const baseTimeEpsilon = 1e-3;
+  const baseValueEpsilon = 1e-5;
+  return animations.filter(
+    (a) => validMethods.includes(a.method) && typeof a.position === "number"
+  ).map((a) => {
+    const relativeTimeRaw = a.position - elementStartTime;
+    const time = clampTimeToZero ? Math.max(0, relativeTimeRaw) : relativeTimeRaw;
+    const properties = {};
+    for (const [key, value] of Object.entries(a.properties)) {
+      if (typeof value !== "number") continue;
+      if (key === "x") properties.x = value - baseX;
+      else if (key === "y") properties.y = value - baseY;
+      else if (key === "scale") {
+        properties.scale = baseScale !== 0 ? value / baseScale : value;
+      } else {
+        properties[key] = value;
+      }
+    }
+    if (skipBaseSet && a.method === "set" && time < baseTimeEpsilon && Object.values(properties).every(
+      (v) => typeof v === "number" && Math.abs(v) < baseValueEpsilon
+    )) {
+      return null;
+    }
+    return {
+      id: a.id.replace(/^.*-kf-/, ""),
+      time,
+      properties,
+      ease: a.ease
+    };
+  }).filter((kf) => kf !== null);
+}
+
+// src/gsapParser.ts
+import * as recast from "recast";
+import { parse as babelParse } from "@babel/parser";
+
+// src/springEase.ts
+var SPRING_PRESETS = [
+  { name: "spring-gentle", label: "Gentle", mass: 1, stiffness: 100, damping: 15 },
+  { name: "spring-bouncy", label: "Bouncy", mass: 1, stiffness: 180, damping: 12 },
+  { name: "spring-stiff", label: "Stiff", mass: 1, stiffness: 300, damping: 20 },
+  { name: "spring-wobbly", label: "Wobbly", mass: 1, stiffness: 120, damping: 8 },
+  { name: "spring-heavy", label: "Heavy", mass: 3, stiffness: 200, damping: 20 }
+];
+function generateSpringEaseData(mass, stiffness, damping, steps = 120) {
+  const w0 = Math.sqrt(stiffness / mass);
+  const zeta = damping / (2 * Math.sqrt(stiffness * mass));
+  let settleDuration;
+  if (zeta < 1) {
+    settleDuration = Math.min(5 / (zeta * w0), 10);
+  } else {
+    const decayRate = zeta * w0 - w0 * Math.sqrt(zeta * zeta - 1);
+    settleDuration = Math.min(4 / Math.max(decayRate, 0.01), 10);
+  }
+  const simDuration = Math.max(settleDuration, 1);
+  const segments = ["M0,0"];
+  for (let i = 1; i <= steps; i++) {
+    const t = i / steps;
+    const simT = t * simDuration;
+    let value;
+    if (zeta < 1) {
+      const wd = w0 * Math.sqrt(1 - zeta * zeta);
+      value = 1 - Math.exp(-zeta * w0 * simT) * (Math.cos(wd * simT) + zeta * w0 / wd * Math.sin(wd * simT));
+    } else if (zeta === 1) {
+      value = 1 - (1 + w0 * simT) * Math.exp(-w0 * simT);
+    } else {
+      const s1 = -w0 * (zeta - Math.sqrt(zeta * zeta - 1));
+      const s2 = -w0 * (zeta + Math.sqrt(zeta * zeta - 1));
+      value = 1 + (s1 * Math.exp(s2 * simT) - s2 * Math.exp(s1 * simT)) / (s2 - s1);
+    }
+    segments.push(`${t.toFixed(4)},${value.toFixed(4)}`);
+  }
+  segments[segments.length - 1] = "1,1";
+  return `${segments[0]} L${segments.slice(1).join(" ")}`;
+}
+
+// src/gsapParser.ts
+var STUDIO_HOLD_MARKER = "hf-hold";
+function isStudioHoldSet(anim) {
+  return anim.method === "set" && anim.properties?.data === STUDIO_HOLD_MARKER;
+}
+
+// src/gsapParserAcorn.ts
+import * as acorn from "acorn";
+import * as acornWalk from "acorn-walk";
+
+// src/gsapInline.ts
+var SKIP_KEYS = /* @__PURE__ */ new Set(["type", "start", "end", "loc", "range", "__hfProvenance", "__hfOrder"]);
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "FunctionDeclaration"
+]);
+var GSAP_METHODS = /* @__PURE__ */ new Set(["set", "to", "from", "fromTo"]);
+var MAX_DEPTH = 8;
+var MAX_ITERS = 512;
+function isFunctionNode(node) {
+  return !!node && FUNCTION_TYPES.has(node.type);
+}
+function isNode(x) {
+  return !!x && typeof x === "object" && typeof x.type === "string";
+}
+function transformChildren(node, fn) {
+  for (const key of Object.keys(node)) {
+    if (SKIP_KEYS.has(key) || isNonValueIdentifierSlot(node, key)) continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (let i = 0; i < child.length; i++) child[i] = fn(child[i]);
+    } else {
+      node[key] = fn(child);
+    }
+  }
+}
+function cloneNode(node) {
+  return structuredClone(node);
+}
+function collectPatternNames(pattern, out) {
+  if (pattern?.type === "Identifier") out.add(pattern.name);
+  else if (pattern?.type === "AssignmentPattern") collectPatternNames(pattern.left, out);
+  else if (pattern?.type === "RestElement") collectPatternNames(pattern.argument, out);
+}
+function collectBoundNames(root) {
+  const names = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (!isNode(node)) return node;
+    if (isFunctionNode(node)) for (const p of node.params ?? []) collectPatternNames(p, names);
+    else if (node.type === "VariableDeclarator") collectPatternNames(node.id, names);
+    else if (node.type === "CatchClause") collectPatternNames(node.param, names);
+    transformChildren(node, visit);
+    return node;
+  };
+  visit(root);
+  return names;
+}
+function isNonValueIdentifierSlot(node, key) {
+  if (node.computed) return false;
+  return node.type === "MemberExpression" && key === "property" || node.type === "Property" && key === "key";
+}
+function substituteParams(node, bindings) {
+  const shadowed = collectBoundNames(node);
+  let effective = bindings;
+  if (shadowed.size > 0) {
+    effective = new Map(bindings);
+    for (const name of shadowed) effective.delete(name);
+  }
+  if (effective.size === 0) return node;
+  return replace(node, effective);
+}
+function replace(node, bindings) {
+  if (!isNode(node)) return node;
+  if (node.type === "Identifier" && bindings.has(node.name)) {
+    return cloneNode(bindings.get(node.name));
+  }
+  transformChildren(node, (child) => replace(child, bindings));
+  return node;
+}
+function tagProvenance(node, provenance) {
+  if (node && typeof node === "object") node.__hfProvenance = provenance;
+  return node;
+}
+function readProvenance(node) {
+  return node?.__hfProvenance;
+}
+function numericLiteral(value) {
+  return { type: "Literal", value, raw: String(value) };
+}
+function walkNodes(node, fn) {
+  if (!isNode(node)) return;
+  fn(node);
+  for (const key of Object.keys(node)) {
+    if (SKIP_KEYS.has(key)) continue;
+    const child = node[key];
+    if (Array.isArray(child)) for (const c of child) walkNodes(c, fn);
+    else walkNodes(child, fn);
+  }
+}
+function timelineRootName(call) {
+  let obj = call.callee?.object;
+  while (obj?.type === "CallExpression") obj = obj.callee?.object;
+  return obj?.type === "Identifier" ? obj.name : null;
+}
+function isTimelineRooted(call, timelineVar) {
+  if (timelineRootName(call) !== timelineVar) return false;
+  return call.callee?.property?.type === "Identifier" && GSAP_METHODS.has(call.callee.property.name);
+}
+function containsTimelineCall(node, timelineVar) {
+  let found = false;
+  walkNodes(node, (n) => {
+    if (n.type === "CallExpression" && isTimelineRooted(n, timelineVar)) found = true;
+  });
+  return found;
+}
+function rangeOf(node) {
+  return typeof node.start === "number" && typeof node.end === "number" ? [node.start, node.end] : void 0;
+}
+function isShapeEligible(fn) {
+  return isFunctionNode(fn) && fn.body?.type === "BlockStatement" && !(fn.params ?? []).some((p) => p.type !== "Identifier");
+}
+function callsAny(node, names) {
+  let hit = false;
+  walkNodes(node, (n) => {
+    if (n.type === "CallExpression" && n.callee?.type === "Identifier" && names.has(n.callee.name)) {
+      hit = true;
+    }
+  });
+  return hit;
+}
+function varDeclHelper(stmt) {
+  if (stmt.declarations?.length !== 1) return null;
+  const d = stmt.declarations[0];
+  return d.id?.type === "Identifier" && isShapeEligible(d.init) ? [d.id.name, d.init] : null;
+}
+function helperFromStatement(stmt) {
+  if (stmt.type === "FunctionDeclaration") {
+    return stmt.id && isShapeEligible(stmt) ? [stmt.id.name, stmt] : null;
+  }
+  if (stmt.type === "VariableDeclaration") return varDeclHelper(stmt);
+  return null;
+}
+function gatherHelperCandidates(program) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const stmt of program.body ?? []) {
+    const helper = helperFromStatement(stmt);
+    if (helper) candidates.set(helper[0], helper[1]);
+  }
+  return candidates;
+}
+function timelineBuildingNames(candidates, timelineVar) {
+  const building = /* @__PURE__ */ new Set();
+  for (const [name, fn] of candidates) {
+    if (containsTimelineCall(fn.body, timelineVar)) building.add(name);
+  }
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const [name, fn] of candidates) {
+      if (!building.has(name) && callsAny(fn.body, building)) {
+        building.add(name);
+        changed = true;
+      }
+    }
+  }
+  return building;
+}
+function bump(counts, key) {
+  counts.set(key, (counts.get(key) ?? 0) + 1);
+}
+function safelyDroppable(program, candidates) {
+  const names = new Set(candidates.keys());
+  const totalIds = /* @__PURE__ */ new Map();
+  const stmtCalls = /* @__PURE__ */ new Map();
+  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 safe = /* @__PURE__ */ new Map();
+  for (const [name, fn] of candidates) {
+    if ((totalIds.get(name) ?? 0) === 1 + (stmtCalls.get(name) ?? 0)) safe.set(name, fn);
+  }
+  return safe;
+}
+function collectInlinableHelpers(program, timelineVar) {
+  const candidates = gatherHelperCandidates(program);
+  if (candidates.size === 0) return candidates;
+  const building = timelineBuildingNames(candidates, timelineVar);
+  for (const name of [...candidates.keys()]) if (!building.has(name)) candidates.delete(name);
+  if (candidates.size === 0) return candidates;
+  return safelyDroppable(program, candidates);
+}
+function isHelperDecl(stmt, helpers) {
+  if (stmt.type === "FunctionDeclaration") return !!stmt.id && helpers.get(stmt.id.name) === stmt;
+  if (stmt.type === "VariableDeclaration" && stmt.declarations?.length === 1) {
+    const d = stmt.declarations[0];
+    return d.id?.type === "Identifier" && helpers.get(d.id.name) === d.init;
+  }
+  return false;
+}
+function bodyStatements(node) {
+  if (node?.type === "BlockStatement") return node.body ?? [];
+  return node ? [{ type: "ExpressionStatement", expression: node }] : [];
+}
+function tagTimelineCalls(stmts, prov, ctx) {
+  for (const stmt of stmts) {
+    walkNodes(stmt, (n) => {
+      if (n.type === "CallExpression" && isTimelineRooted(n, ctx.timelineVar)) {
+        tagProvenance(n, { ...prov });
+        n.__hfOrder = ctx.order.n++;
+      }
+    });
+  }
+}
+function expandBody(bodyStmts, bindings, prov, ctx) {
+  const block = substituteParams(cloneNode({ type: "BlockStatement", body: bodyStmts }), bindings);
+  tagTimelineCalls(block.body, prov, ctx);
+  return expandStatements(block.body, { ...ctx, depth: ctx.depth + 1 });
+}
+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);
+  });
+  const prov = {
+    kind: "helper",
+    fn: call.callee.name,
+    callSite: ++ctx.site.n,
+    sourceRange: rangeOf(call)
+  };
+  return expandBody(fn.body.body, bindings, prov, ctx);
+}
+function assignStep(update, resolve) {
+  if (update.operator === "+=") return asNum(resolve(update.right));
+  if (update.operator === "-=") {
+    const s = asNum(resolve(update.right));
+    return s === void 0 ? void 0 : -s;
+  }
+  if (update.operator === "=" && update.right?.type === "BinaryExpression") {
+    return asNum(resolve(update.right.right));
+  }
+  return void 0;
+}
+function updatedVarName(update) {
+  if (update?.type === "UpdateExpression") return update.argument?.name ?? null;
+  if (update?.type === "AssignmentExpression") return update.left?.name ?? null;
+  return null;
+}
+function loopStep(update, varName, resolve) {
+  if (updatedVarName(update) !== varName) return void 0;
+  if (update.type === "UpdateExpression") return update.operator === "++" ? 1 : -1;
+  return assignStep(update, resolve);
+}
+function asNum(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function loopSatisfied(op, x, end) {
+  if (op === "<") return x < end;
+  if (op === "<=") return x <= end;
+  if (op === ">") return x > end;
+  if (op === ">=") return x >= end;
+  return false;
+}
+function forInitVar(init) {
+  if (init?.type !== "VariableDeclaration" || init.declarations?.length !== 1) return null;
+  const d = init.declarations[0];
+  return d.id?.type === "Identifier" ? { name: d.id.name, initExpr: d.init } : null;
+}
+function parseForHeader(stmt, resolve) {
+  const iv = forInitVar(stmt.init);
+  const test = stmt.test;
+  if (!iv || test?.type !== "BinaryExpression" || test.left?.name !== iv.name) return null;
+  const start = asNum(resolve(iv.initExpr));
+  const end = asNum(resolve(test.right));
+  const step = loopStep(stmt.update, iv.name, resolve);
+  if (start === void 0 || end === void 0 || !step) return null;
+  return { v: iv.name, start, end, op: test.operator, step };
+}
+function unrollFor(stmt, ctx) {
+  const h = parseForHeader(stmt, ctx.resolve);
+  if (!h) return null;
+  const body = bodyStatements(stmt.body);
+  const out = [];
+  const site = ++ctx.site.n;
+  let iteration = 0;
+  for (let x = h.start; loopSatisfied(h.op, x, h.end); x += h.step) {
+    if (iteration >= MAX_ITERS) return null;
+    const prov = {
+      kind: "loop",
+      callSite: site,
+      iteration,
+      sourceRange: rangeOf(stmt)
+    };
+    out.push(...expandBody(body, /* @__PURE__ */ new Map([[h.v, numericLiteral(x)]]), prov, ctx));
+    iteration++;
+  }
+  return out;
+}
+function forOfVarName(left) {
+  if (left?.type === "VariableDeclaration") {
+    const id = left.declarations?.[0]?.id;
+    return id?.type === "Identifier" ? id.name : null;
+  }
+  return left?.type === "Identifier" ? left.name : null;
+}
+function unrollOverArray(elements, body, elName, idxName, range, ctx) {
+  const out = [];
+  const site = ++ctx.site.n;
+  elements.forEach((el, i) => {
+    if (!el) return;
+    const bindings = /* @__PURE__ */ new Map();
+    if (elName) bindings.set(elName, el);
+    if (idxName) bindings.set(idxName, numericLiteral(i));
+    const prov = { kind: "loop", callSite: site, iteration: i, sourceRange: range };
+    out.push(...expandBody(body, bindings, prov, ctx));
+  });
+  return out;
+}
+function unrollForOf(stmt, ctx) {
+  if (stmt.right?.type !== "ArrayExpression") return null;
+  const elName = forOfVarName(stmt.left);
+  if (!elName) return null;
+  return unrollOverArray(
+    stmt.right.elements ?? [],
+    bodyStatements(stmt.body),
+    elName,
+    null,
+    rangeOf(stmt),
+    ctx
+  );
+}
+function callbackParamNames(cb) {
+  const names = [];
+  for (const p of [cb.params?.[0], cb.params?.[1]]) {
+    if (!p) names.push(null);
+    else if (p.type !== "Identifier") return null;
+    else names.push(p.name);
+  }
+  return { el: names[0], idx: names[1] };
+}
+function isForEachCall(callee) {
+  return callee?.type === "MemberExpression" && callee.property?.name === "forEach" && callee.object?.type === "ArrayExpression";
+}
+function forEachTarget(call) {
+  if (!isForEachCall(call.callee)) return null;
+  const cb = call.arguments?.[0];
+  return isFunctionNode(cb) ? { elements: call.callee.object.elements ?? [], cb } : null;
+}
+function unrollForEach(call, ctx) {
+  const target = forEachTarget(call);
+  if (!target) return null;
+  const params = callbackParamNames(target.cb);
+  if (!params) return null;
+  return unrollOverArray(
+    target.elements,
+    bodyStatements(target.cb.body),
+    params.el,
+    params.idx,
+    rangeOf(call),
+    ctx
+  );
+}
+function expandCall(call, ctx) {
+  if (call.callee?.type === "Identifier" && ctx.helpers.has(call.callee.name)) {
+    return inlineHelper(call, ctx);
+  }
+  return unrollForEach(call, ctx);
+}
+function expandStatement(stmt, ctx) {
+  if (ctx.depth >= MAX_DEPTH) return null;
+  if (stmt.type === "ForStatement") return unrollFor(stmt, ctx);
+  if (stmt.type === "ForOfStatement") return unrollForOf(stmt, ctx);
+  if (stmt.type === "ExpressionStatement" && stmt.expression?.type === "CallExpression") {
+    return expandCall(stmt.expression, ctx);
+  }
+  return null;
+}
+function expandStatements(stmts, ctx) {
+  const out = [];
+  for (const stmt of stmts) {
+    const expanded = expandStatement(stmt, ctx);
+    if (expanded) out.push(...expanded);
+    else out.push(stmt);
+  }
+  return out;
+}
+function inlineComputedTimelines(ast, timelineVar, resolve) {
+  const helpers = collectInlinableHelpers(ast, timelineVar);
+  const ctx = {
+    helpers,
+    timelineVar,
+    resolve,
+    depth: 0,
+    site: { n: 0 },
+    order: { n: 0 }
+  };
+  const body = (ast.body ?? []).filter((stmt) => !isHelperDecl(stmt, helpers));
+  ast.body = expandStatements(body, ctx);
+}
+
+// src/gsapParserAcorn.ts
+var GSAP_METHODS2 = /* @__PURE__ */ new Set(["set", "to", "from", "fromTo"]);
+var QUERY_METHODS = /* @__PURE__ */ new Set(["querySelector", "querySelectorAll"]);
+var ITERATION_METHODS = /* @__PURE__ */ new Set(["forEach", "map"]);
+var SCOPE_NODE_TYPES = /* @__PURE__ */ new Set([
+  "Program",
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ArrowFunctionExpression"
+]);
+function resolveNode(node, scope) {
+  if (!node) return void 0;
+  if (node.type === "NumericLiteral" || node.type === "Literal" && typeof node.value === "number")
+    return node.value;
+  if (node.type === "StringLiteral" || node.type === "Literal" && typeof node.value === "string")
+    return node.value;
+  if (node.type === "BooleanLiteral" || node.type === "Literal" && typeof node.value === "boolean")
+    return node.value;
+  if (node.type === "UnaryExpression" && node.operator === "-" && node.argument) {
+    const val = resolveNode(node.argument, scope);
+    return typeof val === "number" ? -val : void 0;
+  }
+  if (node.type === "BinaryExpression") {
+    const left = resolveNode(node.left, scope);
+    const right = resolveNode(node.right, scope);
+    if (typeof left === "number" && typeof right === "number") {
+      switch (node.operator) {
+        case "+":
+          return left + right;
+        case "-":
+          return left - right;
+        case "*":
+          return left * right;
+        case "/":
+          return right !== 0 ? left / right : void 0;
+      }
+    }
+    if (typeof left === "string" && node.operator === "+") return left + String(right ?? "");
+    if (typeof right === "string" && node.operator === "+") return String(left ?? "") + right;
+  }
+  if (node.type === "Identifier" && scope.has(node.name)) {
+    return scope.get(node.name);
+  }
+  if (node.type === "TemplateLiteral" && node.expressions?.length === 0) {
+    return node.quasis?.[0]?.value?.cooked ?? void 0;
+  }
+  return void 0;
+}
+function extractLiteralValue(node, scope) {
+  return resolveNode(node, scope);
+}
+function selectorFromQueryCall(node, scope) {
+  if (node?.type !== "CallExpression") return null;
+  const callee = node.callee;
+  if (callee?.type !== "MemberExpression" || callee.property?.type !== "Identifier") return null;
+  const method = callee.property.name;
+  const argValue = resolveNode(node.arguments?.[0], scope);
+  if (typeof argValue !== "string" || argValue.length === 0) return null;
+  if (QUERY_METHODS.has(method) || method === "toArray") return argValue;
+  if (method === "getElementById") return `#${argValue}`;
+  return null;
+}
+function enclosingScopeNodeFromAncestors(ancestors) {
+  for (let i = ancestors.length - 2; i >= 0; i--) {
+    const node = ancestors[i];
+    if (node && SCOPE_NODE_TYPES.has(node.type)) return node;
+  }
+  return null;
+}
+function scopeChainFromAncestors(ancestors) {
+  const chain = [];
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const node = ancestors[i];
+    if (node && SCOPE_NODE_TYPES.has(node.type)) chain.push(node);
+  }
+  return chain;
+}
+function addBinding(bindings, scopeNode, name, selector) {
+  let scoped = bindings.get(scopeNode);
+  if (!scoped) {
+    scoped = /* @__PURE__ */ new Map();
+    bindings.set(scopeNode, scoped);
+  }
+  if (!scoped.has(name)) scoped.set(name, selector);
+}
+function lookupBindingFromAncestors(name, ancestors, bindings) {
+  for (const scopeNode of scopeChainFromAncestors(ancestors)) {
+    const selector = bindings.get(scopeNode)?.get(name);
+    if (selector !== void 0) return selector;
+  }
+  return bindings.get(null)?.get(name) ?? null;
+}
+function isFunctionNode2(node) {
+  return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression" || node?.type === "FunctionDeclaration";
+}
+function resolveCollectionSelector(node, ancestors, scope, bindings) {
+  if (node?.type === "Identifier")
+    return lookupBindingFromAncestors(node.name, ancestors, bindings);
+  if (node?.type === "CallExpression") return selectorFromQueryCall(node, scope);
+  return null;
+}
+function collectScopeBindings(ast) {
+  const bindings = /* @__PURE__ */ new Map();
+  acornWalk.simple(ast, {
+    VariableDeclarator(node) {
+      const name = node.id?.name;
+      const init = node.init;
+      if (name && init) {
+        const val = resolveNode(init, bindings);
+        if (val !== void 0) bindings.set(name, val);
+      }
+    }
+  });
+  return bindings;
+}
+function collectTargetBindings(ast, scope) {
+  const bindings = /* @__PURE__ */ new Map();
+  acornWalk.ancestor(ast, {
+    VariableDeclarator(node, _, ancestors) {
+      const name = node.id?.name;
+      const selector = selectorFromQueryCall(node.init, scope);
+      if (name && selector !== null) {
+        addBinding(bindings, enclosingScopeNodeFromAncestors(ancestors), name, selector);
+      }
+    },
+    AssignmentExpression(node, _, ancestors) {
+      const left = node.left;
+      const selector = selectorFromQueryCall(node.right, scope);
+      if (left?.type === "Identifier" && selector !== null) {
+        addBinding(bindings, enclosingScopeNodeFromAncestors(ancestors), left.name, selector);
+      }
+    }
+  });
+  acornWalk.ancestor(ast, {
+    // fallow-ignore-next-line complexity
+    CallExpression(node, _, ancestors) {
+      const callee = node.callee;
+      if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier" && ITERATION_METHODS.has(callee.property.name)) {
+        const collectionSelector = resolveCollectionSelector(
+          callee.object,
+          ancestors,
+          scope,
+          bindings
+        );
+        const fn = node.arguments?.[0];
+        const param = fn?.params?.[0];
+        if (collectionSelector && param?.type === "Identifier" && isFunctionNode2(fn)) {
+          addBinding(bindings, fn, param.name, collectionSelector);
+        }
+      }
+    }
+  });
+  return bindings;
+}
+function resolveTargetSelector(node, ancestors, scope, bindings) {
+  if (!node) return null;
+  if (node.type === "StringLiteral" || node.type === "Literal") {
+    return typeof node.value === "string" ? node.value : null;
+  }
+  if (node.type === "Identifier") {
+    return lookupBindingFromAncestors(node.name, ancestors, bindings);
+  }
+  if (node.type === "CallExpression") {
+    return selectorFromQueryCall(node, scope);
+  }
+  if (node.type === "ArrayExpression") {
+    const parts = node.elements.map((el) => resolveTargetSelector(el, ancestors, scope, bindings)).filter((s) => typeof s === "string" && s.length > 0);
+    return parts.length > 0 ? parts.join(", ") : null;
+  }
+  if (node.type === "MemberExpression" && node.object?.type === "Identifier") {
+    return lookupBindingFromAncestors(node.object.name, ancestors, bindings);
+  }
+  return null;
+}
+function isObjectProperty(prop) {
+  return prop?.type === "ObjectProperty" || prop?.type === "Property";
+}
+function propKeyName(prop) {
+  return prop?.key?.name ?? prop?.key?.value;
+}
+function findPropertyNode(varsArgNode, key) {
+  if (varsArgNode?.type !== "ObjectExpression") return void 0;
+  for (const prop of varsArgNode.properties ?? []) {
+    if (!isObjectProperty(prop)) continue;
+    if (propKeyName(prop) === key) return prop.value;
+  }
+  return void 0;
+}
+function extractRawPropertySource(varsArgNode, key, source) {
+  const node = findPropertyNode(varsArgNode, key);
+  return node ? source.slice(node.start, node.end) : void 0;
+}
+function objectExpressionToRecord(node, scope, source) {
+  const result = {};
+  if (node?.type !== "ObjectExpression") return result;
+  for (const prop of node.properties ?? []) {
+    if (!isObjectProperty(prop)) continue;
+    const key = prop.key?.name ?? prop.key?.value;
+    if (!key) continue;
+    const resolved = resolveNode(prop.value, scope);
+    if (resolved !== void 0) {
+      result[key] = resolved;
+    } else {
+      result[key] = `__raw:${source.slice(prop.value.start, prop.value.end)}`;
+    }
+  }
+  return result;
+}
+function isGsapTimelineCall(node) {
+  return node?.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.name === "gsap" && node.callee.property?.name === "timeline";
+}
+function extractTimelineDefaults(callNode, scope) {
+  const arg = callNode.arguments?.[0];
+  if (!arg || arg.type !== "ObjectExpression") return void 0;
+  const defaultsProp = arg.properties?.find(
+    (p) => isObjectProperty(p) && propKeyName(p) === "defaults"
+  );
+  if (!defaultsProp?.value || defaultsProp.value.type !== "ObjectExpression") return void 0;
+  const result = {};
+  for (const prop of defaultsProp.value.properties ?? []) {
+    if (!isObjectProperty(prop)) continue;
+    const key = propKeyName(prop);
+    const val = resolveNode(prop.value, scope);
+    if (key === "ease" && typeof val === "string") result.ease = val;
+    if (key === "duration" && typeof val === "number") result.duration = val;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function findTimelineVar(ast, scope) {
+  let timelineVar = null;
+  let timelineCount = 0;
+  let defaults;
+  const emptyScope = scope ?? /* @__PURE__ */ new Map();
+  acornWalk.simple(ast, {
+    VariableDeclarator(node) {
+      if (isGsapTimelineCall(node.init)) {
+        timelineCount += 1;
+        if (!timelineVar) {
+          timelineVar = node.id?.name ?? null;
+          defaults = extractTimelineDefaults(node.init, emptyScope);
+        }
+      }
+    },
+    AssignmentExpression(node) {
+      if (isGsapTimelineCall(node.right)) {
+        timelineCount += 1;
+        if (!timelineVar) {
+          const left = node.left;
+          if (left?.type === "Identifier") timelineVar = left.name;
+          defaults = extractTimelineDefaults(node.right, emptyScope);
+        }
+      }
+    }
+  });
+  return { timelineVar, timelineCount, defaults };
+}
+var BUILTIN_VAR_KEYS = /* @__PURE__ */ new Set(["duration", "ease", "delay"]);
+var DROPPED_VAR_KEYS = /* @__PURE__ */ new Set(["onComplete", "onStart", "onUpdate", "onRepeat"]);
+var EXTRAS_KEYS = /* @__PURE__ */ new Set([
+  "stagger",
+  "yoyo",
+  "repeat",
+  "repeatDelay",
+  "snap",
+  "overwrite",
+  "immediateRender"
+]);
+function isTimelineRootedCall(callNode, timelineVar) {
+  let obj = callNode.callee?.object;
+  while (obj?.type === "CallExpression") {
+    obj = obj.callee?.object;
+  }
+  return obj?.type === "Identifier" && obj.name === timelineVar;
+}
+function findAllTweenCalls(ast, timelineVar, scope, targetBindings) {
+  const results = [];
+  function visit(node, ancestors) {
+    if (!node || typeof node !== "object") return;
+    const nodeAncestors = [...ancestors, node];
+    if (node.type === "CallExpression") {
+      const callee = node.callee;
+      const gsapSetArg = node.arguments?.[0];
+      const isGlobalSet = callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.name === "gsap" && callee.property?.type === "Identifier" && callee.property.name === "set" && (gsapSetArg?.type === "StringLiteral" || gsapSetArg?.type === "Literal" && typeof gsapSetArg.value === "string");
+      if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier" && (isTimelineRootedCall(node, timelineVar) || isGlobalSet) && GSAP_METHODS2.has(callee.property.name)) {
+        const method = callee.property.name;
+        const args = node.arguments;
+        const selectorValue = args.length >= 1 ? resolveTargetSelector(args[0], nodeAncestors, scope, targetBindings) ?? "__unresolved__" : "__unresolved__";
+        if (method === "fromTo" && args.length >= 3) {
+          results.push({
+            node,
+            ancestors: nodeAncestors,
+            method: "fromTo",
+            selector: selectorValue,
+            fromArg: args[1],
+            varsArg: args[2],
+            positionArg: args[3]
+          });
+        } else if (method !== "fromTo" && args.length >= 2) {
+          results.push({
+            node,
+            ancestors: nodeAncestors,
+            method,
+            selector: selectorValue,
+            varsArg: args[1],
+            positionArg: args[2],
+            ...isGlobalSet ? { global: true } : {}
+          });
+        }
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "type" || key === "start" || key === "end" || key === "loc") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && item.type) visit(item, nodeAncestors);
+        }
+      } else if (child && typeof child === "object" && child.type) {
+        visit(child, nodeAncestors);
+      }
+    }
+  }
+  visit(ast, []);
+  return results;
+}
+var PERCENTAGE_KEY_RE = /^(\d+(?:\.\d+)?)%$/;
+function tryResolveStringProp(propValue, scope) {
+  const val = resolveNode(propValue, scope);
+  return typeof val === "string" ? val : void 0;
+}
+function parsePercentageKeyframes(node, scope, source) {
+  const keyframes = [];
+  let ease;
+  let easeEach;
+  for (const prop of node.properties ?? []) {
+    if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+    const key = prop.key?.value ?? prop.key?.name;
+    if (typeof key !== "string") continue;
+    const pctMatch = PERCENTAGE_KEY_RE.exec(key);
+    if (pctMatch) {
+      const percentage = Number.parseFloat(pctMatch[1] ?? "0");
+      const record = objectExpressionToRecord(prop.value, scope, source);
+      const properties = {};
+      let kfEase;
+      for (const [k, v] of Object.entries(record)) {
+        if (k === "ease" && typeof v === "string") {
+          kfEase = v;
+        } else if (typeof v === "number" || typeof v === "string") {
+          properties[k] = v;
+        }
+      }
+      keyframes.push({ percentage, properties, ...kfEase ? { ease: kfEase } : {} });
+    } else if (key === "ease") {
+      ease = tryResolveStringProp(prop.value, scope) ?? ease;
+    } else if (key === "easeEach") {
+      easeEach = tryResolveStringProp(prop.value, scope) ?? easeEach;
+    }
+  }
+  keyframes.sort((a, b) => a.percentage - b.percentage);
+  return {
+    format: "percentage",
+    keyframes,
+    ...ease ? { ease } : {},
+    ...easeEach ? { easeEach } : {}
+  };
+}
+function computeKeyframesTotalDuration(varsNode, scope, source) {
+  const kfNode = (varsNode.properties ?? []).find(
+    (p) => (p.key?.name ?? p.key?.value) === "keyframes"
+  )?.value;
+  if (!kfNode || kfNode.type !== "ArrayExpression") return void 0;
+  let total = 0;
+  for (const el of kfNode.elements ?? []) {
+    if (!el || el.type !== "ObjectExpression") continue;
+    const r = objectExpressionToRecord(el, scope, source);
+    if (typeof r.duration === "number") total += r.duration;
+  }
+  return total > 0 ? total : void 0;
+}
+function parseObjectArrayKeyframes(node, scope, source) {
+  const elements = node.elements ?? [];
+  const raw = [];
+  for (const el of elements) {
+    if (!el || el.type !== "ObjectExpression") continue;
+    const record = objectExpressionToRecord(el, scope, source);
+    const properties = {};
+    let duration;
+    let ease;
+    for (const [k, v] of Object.entries(record)) {
+      if (k === "duration" && typeof v === "number") {
+        duration = v;
+      } else if (k === "ease" && typeof v === "string") {
+        ease = v;
+      } else if (typeof v === "number" || typeof v === "string") {
+        properties[k] = v;
+      }
+    }
+    raw.push({ properties, duration, ease });
+  }
+  const totalDuration = raw.reduce((sum, r) => sum + (r.duration ?? 0), 0);
+  const keyframes = [];
+  if (totalDuration > 0) {
+    let cumulative = 0;
+    for (const entry of raw) {
+      cumulative += entry.duration ?? 0;
+      const percentage = Math.round(cumulative / totalDuration * 100);
+      keyframes.push({
+        percentage,
+        properties: entry.properties,
+        ...entry.ease ? { ease: entry.ease } : {}
+      });
+    }
+  } else {
+    for (let i = 0; i < raw.length; i++) {
+      const entry = raw[i];
+      if (!entry) continue;
+      const percentage = raw.length > 1 ? Math.round(i / (raw.length - 1) * 100) : 0;
+      keyframes.push({
+        percentage,
+        properties: entry.properties,
+        ...entry.ease ? { ease: entry.ease } : {}
+      });
+    }
+  }
+  return { format: "object-array", keyframes };
+}
+function parseSimpleArrayKeyframes(node, scope) {
+  const arrayProps = /* @__PURE__ */ new Map();
+  let ease;
+  let easeEach;
+  for (const prop of node.properties ?? []) {
+    if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+    const key = prop.key?.name ?? prop.key?.value;
+    if (typeof key !== "string") continue;
+    if (prop.value?.type === "ArrayExpression") {
+      const values = [];
+      for (const el of prop.value.elements ?? []) {
+        const val = resolveNode(el, scope);
+        if (typeof val === "number" || typeof val === "string") {
+          values.push(val);
+        }
+      }
+      if (values.length > 0) arrayProps.set(key, values);
+    } else if (key === "ease") {
+      ease = tryResolveStringProp(prop.value, scope) ?? ease;
+    } else if (key === "easeEach") {
+      easeEach = tryResolveStringProp(prop.value, scope) ?? easeEach;
+    }
+  }
+  const maxLen = Math.max(...[...arrayProps.values()].map((a) => a.length), 0);
+  const keyframes = [];
+  for (let i = 0; i < maxLen; i++) {
+    const percentage = maxLen > 1 ? Math.round(i / (maxLen - 1) * 100) : 0;
+    const properties = {};
+    for (const [key, values] of arrayProps) {
+      if (i < values.length) properties[key] = values[i];
+    }
+    keyframes.push({ percentage, properties });
+  }
+  return {
+    format: "simple-array",
+    keyframes,
+    ...ease ? { ease } : {},
+    ...easeEach ? { easeEach } : {}
+  };
+}
+function parseKeyframesNode(node, scope, source) {
+  if (!node) return void 0;
+  if (node.type === "ArrayExpression") {
+    return parseObjectArrayKeyframes(node, scope, source);
+  }
+  if (node.type !== "ObjectExpression") return void 0;
+  const props = node.properties ?? [];
+  let hasPercentageKey = false;
+  let hasArrayValue = false;
+  for (const prop of props) {
+    if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+    const key = prop.key?.value ?? prop.key?.name;
+    if (typeof key === "string" && PERCENTAGE_KEY_RE.test(key)) {
+      hasPercentageKey = true;
+      break;
+    }
+    if (prop.value?.type === "ArrayExpression") {
+      hasArrayValue = true;
+    }
+  }
+  if (hasPercentageKey) return parsePercentageKeyframes(node, scope, source);
+  if (hasArrayValue) return parseSimpleArrayKeyframes(node, scope);
+  return void 0;
+}
+function parseMotionPathNode(node, scope, source) {
+  if (!node) return void 0;
+  let pathNode;
+  let autoRotate = false;
+  let curviness = 1;
+  let isCubic = false;
+  if (node.type === "ObjectExpression") {
+    for (const prop of node.properties ?? []) {
+      if (!isObjectProperty(prop)) continue;
+      const key = propKeyName(prop);
+      if (key === "path") pathNode = prop.value;
+      else if (key === "autoRotate") {
+        const val = resolveNode(prop.value, scope);
+        autoRotate = typeof val === "number" ? val : val === true;
+      } else if (key === "curviness") {
+        const val = resolveNode(prop.value, scope);
+        if (typeof val === "number") curviness = val;
+      } else if (key === "type") {
+        const val = resolveNode(prop.value, scope);
+        if (val === "cubic") isCubic = true;
+      }
+    }
+  } else if (node.type === "ArrayExpression") {
+    pathNode = node;
+  }
+  if (!pathNode || pathNode.type !== "ArrayExpression") return void 0;
+  const elements = pathNode.elements ?? [];
+  const coords = [];
+  for (const elem of elements) {
+    if (!elem || elem.type !== "ObjectExpression") continue;
+    const rec = objectExpressionToRecord(elem, scope, source);
+    const x = typeof rec.x === "number" ? rec.x : void 0;
+    const y = typeof rec.y === "number" ? rec.y : void 0;
+    if (x !== void 0 && y !== void 0) coords.push({ x, y });
+  }
+  return buildArcPath(coords, curviness, autoRotate, isCubic);
+}
+function tweenCallToAnimation(call, scope, source) {
+  const vars = objectExpressionToRecord(call.varsArg, scope, source);
+  const properties = {};
+  const extras = {};
+  let keyframesData;
+  let hasUnresolvedKeyframes = false;
+  let motionPathResult;
+  for (const [key, val] of Object.entries(vars)) {
+    if (BUILTIN_VAR_KEYS.has(key)) continue;
+    if (DROPPED_VAR_KEYS.has(key)) continue;
+    if (key === "keyframes") {
+      const kfNode = findPropertyNode(call.varsArg, "keyframes");
+      keyframesData = parseKeyframesNode(kfNode, scope, source);
+      if (!keyframesData && kfNode) hasUnresolvedKeyframes = true;
+      continue;
+    }
+    if (key === "motionPath") {
+      const mpNode = findPropertyNode(call.varsArg, "motionPath");
+      motionPathResult = parseMotionPathNode(mpNode, scope, source);
+      continue;
+    }
+    if (key === "easeEach") continue;
+    if (EXTRAS_KEYS.has(key)) {
+      const rawSource = extractRawPropertySource(call.varsArg, key, source);
+      if (rawSource !== void 0) {
+        extras[key] = `__raw:${rawSource}`;
+      } else if (val !== void 0) {
+        extras[key] = val;
+      }
+      continue;
+    }
+    if (typeof val === "number" || typeof val === "string") {
+      properties[key] = val;
+    }
+  }
+  if (keyframesData && typeof vars.easeEach === "string") {
+    keyframesData.easeEach = vars.easeEach;
+  }
+  if (motionPathResult) {
+    const { waypoints } = motionPathResult;
+    if (!keyframesData) {
+      const kf = waypoints.map((wp, i) => ({
+        percentage: waypoints.length > 1 ? Math.round(i / (waypoints.length - 1) * 100) : 0,
+        properties: { x: wp.x, y: wp.y }
+      }));
+      keyframesData = { format: "percentage", keyframes: kf };
+    } else {
+      const kfs = keyframesData.keyframes;
+      if (kfs.length === waypoints.length) {
+        for (let i = 0; i < kfs.length; i++) {
+          const kf = kfs[i];
+          const wp = waypoints[i];
+          if (kf && wp) {
+            kf.properties.x = wp.x;
+            kf.properties.y = wp.y;
+          }
+        }
+      }
+    }
+  }
+  let fromProperties;
+  if (call.method === "fromTo" && call.fromArg) {
+    fromProperties = {};
+    const fromVars = objectExpressionToRecord(call.fromArg, scope, source);
+    for (const [key, val] of Object.entries(fromVars)) {
+      if (typeof val === "number" || typeof val === "string") {
+        fromProperties[key] = val;
+      }
+    }
+  }
+  const hasPositionArg = !!call.positionArg;
+  const posVal = hasPositionArg ? extractLiteralValue(call.positionArg, scope) : 0;
+  const position = typeof posVal === "number" ? posVal : typeof posVal === "string" ? posVal : 0;
+  let duration = typeof vars.duration === "number" ? vars.duration : void 0;
+  const ease = typeof vars.ease === "string" ? vars.ease : void 0;
+  if (duration === void 0 && keyframesData) {
+    duration = computeKeyframesTotalDuration(call.varsArg, scope, source);
+  }
+  const anim = {
+    targetSelector: call.selector,
+    method: call.method,
+    position,
+    properties,
+    fromProperties,
+    duration,
+    ease
+  };
+  if (!hasPositionArg) anim.implicitPosition = true;
+  let group = classifyTweenPropertyGroup(properties);
+  if (!group && keyframesData) {
+    const kfProps = {};
+    for (const kf of keyframesData.keyframes) {
+      for (const k of Object.keys(kf.properties)) kfProps[k] = true;
+    }
+    group = classifyTweenPropertyGroup(kfProps);
+  }
+  if (group) anim.propertyGroup = group;
+  if (call.global) anim.global = true;
+  if (Object.keys(extras).length > 0) anim.extras = extras;
+  if (keyframesData) anim.keyframes = keyframesData;
+  if (motionPathResult) anim.arcPath = motionPathResult.arcPath;
+  if (hasUnresolvedKeyframes) anim.hasUnresolvedKeyframes = true;
+  if (call.selector === "__unresolved__") anim.hasUnresolvedSelector = true;
+  const provenance = readProvenance(call.node);
+  if (provenance) anim.provenance = provenance;
+  return anim;
+}
+var GSAP_DEFAULT_DURATION = 0.5;
+function resolvePositionString(pos, cursor, prevStart) {
+  const trimmed = pos.trim();
+  if (trimmed === "") return cursor;
+  if (trimmed.startsWith("+=")) {
+    const n2 = Number.parseFloat(trimmed.slice(2));
+    return Number.isFinite(n2) ? cursor + n2 : null;
+  }
+  if (trimmed.startsWith("-=")) {
+    const n2 = Number.parseFloat(trimmed.slice(2));
+    return Number.isFinite(n2) ? cursor - n2 : null;
+  }
+  if (trimmed === "<") return prevStart;
+  if (trimmed === ">") return cursor;
+  if (trimmed.startsWith("<")) {
+    const n2 = Number.parseFloat(trimmed.slice(1));
+    return Number.isFinite(n2) ? prevStart + n2 : null;
+  }
+  if (trimmed.startsWith(">")) {
+    const n2 = Number.parseFloat(trimmed.slice(1));
+    return Number.isFinite(n2) ? cursor + n2 : null;
+  }
+  const n = Number.parseFloat(trimmed);
+  return Number.isFinite(n) ? n : null;
+}
+function applyTimelineDefaults(anims, defaults) {
+  if (!defaults) return;
+  for (const anim of anims) {
+    if (anim.method === "set") continue;
+    if (anim.duration === void 0 && defaults.duration !== void 0) {
+      anim.duration = defaults.duration;
+    }
+    if (anim.ease === void 0 && defaults.ease !== void 0) {
+      anim.ease = defaults.ease;
+    }
+  }
+}
+function resolveTimelinePositions(anims) {
+  let cursor = 0;
+  let prevStart = 0;
+  for (const anim of anims) {
+    if (anim.method === "set" && anim.global) {
+      anim.resolvedStart = 0;
+      continue;
+    }
+    const duration = anim.method === "set" ? 0 : anim.duration ?? GSAP_DEFAULT_DURATION;
+    let start;
+    if (anim.implicitPosition) {
+      start = cursor;
+    } else if (typeof anim.position === "number") {
+      start = anim.position;
+    } else if (typeof anim.position === "string") {
+      start = resolvePositionString(anim.position, cursor, prevStart);
+    } else {
+      start = cursor;
+    }
+    if (start != null) {
+      anim.resolvedStart = Math.max(0, start);
+      prevStart = anim.resolvedStart;
+      cursor = Math.max(cursor, anim.resolvedStart + duration);
+    }
+  }
+}
+function compareByLoc(a, b) {
+  const aLoc = a.node.callee?.property?.loc?.start;
+  const bLoc = b.node.callee?.property?.loc?.start;
+  if (!aLoc || !bLoc) return 0;
+  return aLoc.line - bLoc.line || aLoc.column - bLoc.column;
+}
+function compareCallOrder(a, b) {
+  const ao = a.node.__hfOrder;
+  const bo = b.node.__hfOrder;
+  if (ao === void 0 && bo === void 0) return compareByLoc(a, b);
+  if (ao === void 0) return -1;
+  if (bo === void 0) return 1;
+  return ao - bo;
+}
+function sortBySourcePosition(calls) {
+  calls.sort(compareCallOrder);
+}
+function assignStableIds(anims) {
+  const counts = /* @__PURE__ */ new Map();
+  return anims.map((anim) => {
+    const posKey = typeof anim.position === "number" ? String(Math.round(anim.position * 1e3)) : String(anim.position);
+    const groupSuffix = anim.propertyGroup ? `-${anim.propertyGroup}` : "";
+    const base = `${anim.targetSelector}-${anim.method}-${posKey}${groupSuffix}`;
+    const count = (counts.get(base) ?? 0) + 1;
+    counts.set(base, count);
+    const id = count === 1 ? base : `${base}-${count}`;
+    return { ...anim, id };
+  });
+}
+function parseGsapScriptAcornForWrite(script) {
+  try {
+    const ast = acorn.parse(script, {
+      ecmaVersion: "latest",
+      sourceType: "script",
+      locations: true
+    });
+    const scope = collectScopeBindings(ast);
+    const targetBindings = collectTargetBindings(ast, scope);
+    const detection = findTimelineVar(ast, scope);
+    const timelineVar = detection.timelineVar ?? "tl";
+    const calls = findAllTweenCalls(ast, timelineVar, scope, targetBindings);
+    sortBySourcePosition(calls);
+    const rawAnims = calls.map((call) => tweenCallToAnimation(call, scope, script));
+    applyTimelineDefaults(rawAnims, detection.defaults);
+    resolveTimelinePositions(rawAnims);
+    const animations = assignStableIds(rawAnims);
+    const located = calls.map((call, i) => ({
+      id: animations[i].id,
+      call,
+      animation: animations[i]
+    }));
+    return { ast, timelineVar, hasTimeline: detection.timelineVar !== null, located };
+  } catch {
+    return null;
+  }
+}
+function parseGsapScriptAcorn(script) {
+  try {
+    const ast = acorn.parse(script, {
+      ecmaVersion: "latest",
+      sourceType: "script",
+      locations: true
+    });
+    const scope = collectScopeBindings(ast);
+    const detection = findTimelineVar(ast, scope);
+    const timelineVar = detection.timelineVar ?? "tl";
+    try {
+      inlineComputedTimelines(ast, timelineVar, (node) => resolveNode(node, scope));
+    } catch {
+    }
+    const targetBindings = collectTargetBindings(ast, scope);
+    const calls = findAllTweenCalls(ast, timelineVar, scope, targetBindings);
+    sortBySourcePosition(calls);
+    const rawAnims = calls.map((call) => tweenCallToAnimation(call, scope, script));
+    applyTimelineDefaults(rawAnims, detection.defaults);
+    resolveTimelinePositions(rawAnims);
+    const animations = assignStableIds(rawAnims);
+    const timelineMatch = script.match(
+      new RegExp(
+        `^[\\s\\S]*?(?:const|let|var)\\s+${timelineVar}\\s*=\\s*gsap\\.timeline\\s*\\([^)]*\\)\\s*;?`
+      )
+    );
+    const preamble = timelineMatch?.[0] ?? `const ${timelineVar} = gsap.timeline({ paused: true });`;
+    const lastCallIdx = script.lastIndexOf(`${timelineVar}.`);
+    let postamble = "";
+    if (lastCallIdx !== -1) {
+      const afterLast = script.slice(lastCallIdx);
+      const endOfCall = afterLast.indexOf(";");
+      if (endOfCall !== -1) {
+        postamble = script.slice(lastCallIdx + endOfCall + 1).trim();
+      }
+    }
+    const result = { animations, timelineVar, preamble, postamble };
+    if (detection.timelineCount > 1) result.multipleTimelines = true;
+    if (detection.timelineCount > 0 && detection.timelineVar === null)
+      result.unsupportedTimelinePattern = true;
+    return result;
+  } catch {
+    return { animations: [], timelineVar: "tl", preamble: "", postamble: "" };
+  }
+}
+
+// src/hfIds.ts
+import { parseHTML } from "linkedom";
+var EXCLUDED_TAGS = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "template",
+  "meta",
+  "link",
+  "noscript",
+  "base"
+]);
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function toHfId(hash) {
+  const s = (hash >>> 0).toString(36);
+  const four = s.length >= 4 ? s.slice(-4) : s.padStart(4, "0");
+  return `hf-${four}`;
+}
+function ownText(el) {
+  let text = "";
+  el.childNodes.forEach((n) => {
+    if (n.nodeType === 3) text += n.nodeValue ?? "";
+  });
+  return text.trim();
+}
+function contentKey(el) {
+  const attrs = Array.from(el.attributes).filter((a) => !a.name.startsWith("data-hf-")).map((a) => `${a.name}\0${a.value}`).sort().join("
");
+  return `${el.tagName.toLowerCase()}|${attrs}|${ownText(el)}`;
+}
+function mintHfId(el, assigned) {
+  const key = contentKey(el);
+  let id = toHfId(fnv1a(key));
+  let dup = 0;
+  while (assigned.has(id)) {
+    dup += 1;
+    if (dup > 1e4) {
+      id = `hf-${(fnv1a(key) >>> 0).toString(36)}-${dup}`;
+      break;
+    }
+    id = toHfId(fnv1a(`${key}#${dup}`));
+  }
+  assigned.add(id);
+  return id;
+}
+function ensureHfIds(html) {
+  const hasDocumentShell = /<!doctype|<html[\s>]/i.test(html);
+  const wrapped = !hasDocumentShell;
+  const { document } = wrapped ? parseHTML(`<!DOCTYPE html><html><head></head><body>${html}</body></html>`) : parseHTML(html);
+  const body = document.body;
+  if (!body) return html;
+  const assigned = /* @__PURE__ */ new Set();
+  for (const el of Array.from(body.querySelectorAll("[data-hf-id]"))) {
+    const existing = el.getAttribute("data-hf-id");
+    if (existing) assigned.add(existing);
+  }
+  for (const el of Array.from(body.querySelectorAll("*"))) {
+    if (EXCLUDED_TAGS.has(el.tagName.toLowerCase())) continue;
+    if (el.getAttribute("data-hf-id")) continue;
+    el.setAttribute("data-hf-id", mintHfId(el, assigned));
+  }
+  return wrapped ? document.body.innerHTML || "" : document.toString();
+}
+
+// src/utils/cssSelector.ts
+function queryByAttr(root, attr, value, tag) {
+  const selector = tag ? `${tag}[${attr}]` : `[${attr}]`;
+  for (const el of root.querySelectorAll(selector)) {
+    if (el.getAttribute(attr) === value) return el;
+  }
+  return null;
+}
+
+// src/gsapWriterAcorn.ts
+import MagicString from "magic-string";
+import * as acornWalk2 from "acorn-walk";
+function findEnclosingExpressionStatement(ancestors) {
+  for (let i = ancestors.length - 2; i >= 0; i--) {
+    if (ancestors[i]?.type === "ExpressionStatement") return ancestors[i];
+  }
+  return null;
+}
+function removeAnimationFromScript(script, animationId) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  const ms = new MagicString(script);
+  const N = target.call.node;
+  const exprStmt = findEnclosingExpressionStatement(target.call.ancestors);
+  if (N.callee?.object?.type !== "CallExpression" && exprStmt?.expression === N) {
+    const end = exprStmt.end < script.length && script[exprStmt.end] === "\n" ? exprStmt.end + 1 : exprStmt.end;
+    ms.remove(exprStmt.start, end);
+  } else {
+    ms.remove(N.callee.object.end, N.end);
+  }
+  return ms.toString();
+}
+
+// src/htmlParser.ts
+var MEDIA_TYPES = /* @__PURE__ */ new Set(["video", "image", "audio"]);
+function getElementType(el) {
+  const tag = el.tagName.toLowerCase();
+  if (tag === "video") return "video";
+  if (tag === "img") return "image";
+  if (tag === "audio") return "audio";
+  const dataType = el.getAttribute("data-type");
+  if (dataType === "composition") return "composition";
+  if (dataType === "text") return "text";
+  if (tag === "div" || tag === "p" || tag === "h1" || tag === "h2" || tag === "h3" || tag === "span") {
+    return "text";
+  }
+  return null;
+}
+function getElementName(el) {
+  const dataName = el.getAttribute("data-name");
+  if (dataName) return dataName;
+  const type = getElementType(el);
+  if (type === "text") {
+    const text = el.textContent?.trim().slice(0, 30) || "Text";
+    return text.length === 30 ? text + "..." : text;
+  }
+  const src = el.getAttribute("src");
+  if (src) {
+    const filename = src.split("/").pop() || src;
+    return filename.split("?")[0] ?? filename;
+  }
+  return el.id || el.className?.toString().split(" ")[0] || "Element";
+}
+function getZIndex(el) {
+  const dataLayer = el.getAttribute("data-layer");
+  if (dataLayer) return parseInt(dataLayer, 10) || 0;
+  const style = el.style?.zIndex;
+  if (style) return parseInt(style, 10) || 0;
+  return 0;
+}
+function parseResolutionFromCss(doc, cssText) {
+  const stage = doc.getElementById("stage") || doc.querySelector("#stage");
+  if (stage) {
+    const inlineStyle = stage.style;
+    if (inlineStyle?.width && inlineStyle?.height) {
+      const w = parseInt(inlineStyle.width, 10);
+      const h = parseInt(inlineStyle.height, 10);
+      if (w && h) {
+        return resolveResolutionFromDimensions(w, h);
+      }
+    }
+  }
+  if (cssText) {
+    const stageMatch = cssText.match(
+      /#stage\s*\{[^}]*width:\s*(\d+)px[^}]*height:\s*(\d+)px[^}]*\}/
+    );
+    if (stageMatch) {
+      const w = parseInt(stageMatch[1] ?? "", 10);
+      const h = parseInt(stageMatch[2] ?? "", 10);
+      return resolveResolutionFromDimensions(w, h);
+    }
+    const stageMatchReverse = cssText.match(
+      /#stage\s*\{[^}]*height:\s*(\d+)px[^}]*width:\s*(\d+)px[^}]*\}/
+    );
+    if (stageMatchReverse) {
+      const h = parseInt(stageMatchReverse[1] ?? "", 10);
+      const w = parseInt(stageMatchReverse[2] ?? "", 10);
+      return resolveResolutionFromDimensions(w, h);
+    }
+  }
+  return "portrait";
+}
+function parseResolutionFromHtml(doc) {
+  const htmlEl = doc.documentElement;
+  const resolutionAttr = htmlEl.getAttribute("data-resolution");
+  if (resolutionAttr === "landscape" || resolutionAttr === "portrait" || resolutionAttr === "landscape-4k" || resolutionAttr === "portrait-4k" || resolutionAttr === "square" || resolutionAttr === "square-4k") {
+    return resolutionAttr;
+  }
+  const widthAttr = htmlEl.getAttribute("data-composition-width");
+  const heightAttr = htmlEl.getAttribute("data-composition-height");
+  if (widthAttr && heightAttr) {
+    const width = parseInt(widthAttr, 10);
+    const height = parseInt(heightAttr, 10);
+    if (width && height) {
+      return resolveResolutionFromDimensions(width, height);
+    }
+  }
+  return null;
+}
+var UHD_SQUARE_MIN = 2160;
+var UHD_RECT_MIN = 3840;
+function resolveResolutionFromDimensions(width, height) {
+  const longSide = Math.max(width, height);
+  if (width === height) {
+    return longSide >= UHD_SQUARE_MIN ? "square-4k" : "square";
+  }
+  const isLandscape = width > height;
+  const isUhd = longSide >= UHD_RECT_MIN;
+  if (isLandscape) return isUhd ? "landscape-4k" : "landscape";
+  return isUhd ? "portrait-4k" : "portrait";
+}
+function parseHtml(html) {
+  const withIds = ensureHfIds(html);
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(withIds, "text/html");
+  const elements = [];
+  const keyframes = {};
+  let idCounter = 0;
+  const htmlEl = doc.documentElement;
+  const customStylesAttr = htmlEl.getAttribute("data-custom-styles");
+  let customStyles = null;
+  if (customStylesAttr) {
+    try {
+      customStyles = JSON.parse(customStylesAttr);
+    } catch {
+      customStyles = customStylesAttr;
+    }
+  }
+  const timedElements = doc.querySelectorAll("[data-start]");
+  timedElements.forEach((el) => {
+    const type = getElementType(el);
+    if (!type) return;
+    const start = parseFloat(el.getAttribute("data-start") || "0");
+    const dataEnd = el.getAttribute("data-end");
+    let duration;
+    if (dataEnd) {
+      duration = Math.max(0, parseFloat(dataEnd) - start);
+    } else {
+      duration = 5;
+    }
+    const id = el.getAttribute("data-hf-id") || el.id || `element-${++idCounter}`;
+    const name = getElementName(el);
+    const zIndex = getZIndex(el);
+    const keyframesAttr = el.getAttribute("data-keyframes");
+    if (keyframesAttr) {
+      try {
+        const parsedKeyframes = JSON.parse(keyframesAttr);
+        if (Array.isArray(parsedKeyframes) && parsedKeyframes.length > 0) {
+          keyframes[id] = parsedKeyframes;
+        }
+      } catch {
+      }
+    }
+    const xAttr = el.getAttribute("data-x");
+    const yAttr = el.getAttribute("data-y");
+    const scaleAttr = el.getAttribute("data-scale");
+    const opacityAttr = el.getAttribute("data-opacity");
+    const x = xAttr ? parseFloat(xAttr) : void 0;
+    const y = yAttr ? parseFloat(yAttr) : void 0;
+    const scale = scaleAttr ? parseFloat(scaleAttr) : void 0;
+    const opacity = opacityAttr ? parseFloat(opacityAttr) : void 0;
+    if (type === "text") {
+      const textEl = el.firstElementChild;
+      const content = textEl?.textContent || name;
+      const color = el.getAttribute("data-color") || void 0;
+      const fontSizeAttr = el.getAttribute("data-font-size");
+      const fontSize = fontSizeAttr ? parseInt(fontSizeAttr, 10) : void 0;
+      const fontWeightAttr = el.getAttribute("data-font-weight");
+      const fontWeight = fontWeightAttr ? parseInt(fontWeightAttr, 10) : void 0;
+      const fontFamily = el.getAttribute("data-font-family") || void 0;
+      const textShadowAttr = el.getAttribute("data-text-shadow");
+      const textShadow = textShadowAttr === "false" ? false : void 0;
+      const textOutlineAttr = el.getAttribute("data-text-outline");
+      const textOutline = textOutlineAttr === "true" ? true : void 0;
+      const textOutlineColor = el.getAttribute("data-text-outline-color") || void 0;
+      const textOutlineWidthAttr = el.getAttribute("data-text-outline-width");
+      const textOutlineWidth = textOutlineWidthAttr ? parseInt(textOutlineWidthAttr, 10) : void 0;
+      const textHighlightAttr = el.getAttribute("data-text-highlight");
+      const textHighlight = textHighlightAttr === "true" ? true : void 0;
+      const textHighlightColor = el.getAttribute("data-text-highlight-color") || void 0;
+      const textHighlightPaddingAttr = el.getAttribute("data-text-highlight-padding");
+      const textHighlightPadding = textHighlightPaddingAttr ? parseInt(textHighlightPaddingAttr, 10) : void 0;
+      const textHighlightRadiusAttr = el.getAttribute("data-text-highlight-radius");
+      const textHighlightRadius = textHighlightRadiusAttr ? parseInt(textHighlightRadiusAttr, 10) : void 0;
+      const textElement = {
+        id,
+        type: "text",
+        name,
+        content,
+        startTime: start,
+        duration,
+        zIndex,
+        x,
+        y,
+        scale,
+        opacity,
+        color,
+        fontSize,
+        fontWeight,
+        fontFamily,
+        textShadow,
+        textOutline,
+        textOutlineColor,
+        textOutlineWidth,
+        textHighlight,
+        textHighlightColor,
+        textHighlightPadding,
+        textHighlightRadius
+      };
+      elements.push(textElement);
+    } else if (type === "composition") {
+      const iframe = el.querySelector("iframe");
+      const src = iframe?.getAttribute("src") || el.getAttribute("src") || "";
+      const compositionId = el.getAttribute("data-composition-id") || "";
+      const sourceDurationAttr = el.getAttribute("data-source-duration");
+      const sourceDuration = sourceDurationAttr ? parseFloat(sourceDurationAttr) : void 0;
+      const sourceWidthAttr = el.getAttribute("data-source-width");
+      const sourceWidth = sourceWidthAttr ? parseInt(sourceWidthAttr, 10) : void 0;
+      const sourceHeightAttr = el.getAttribute("data-source-height");
+      const sourceHeight = sourceHeightAttr ? parseInt(sourceHeightAttr, 10) : void 0;
+      const variableValuesAttr = el.getAttribute("data-variable-values");
+      let variableValues;
+      if (variableValuesAttr) {
+        try {
+          variableValues = JSON.parse(variableValuesAttr);
+        } catch {
+        }
+      }
+      const compositionElement = {
+        id,
+        type: "composition",
+        name,
+        src,
+        compositionId,
+        startTime: start,
+        duration,
+        zIndex,
+        x,
+        y,
+        scale,
+        opacity,
+        sourceDuration,
+        sourceWidth,
+        sourceHeight,
+        variableValues
+      };
+      elements.push(compositionElement);
+    } else {
+      if (!MEDIA_TYPES.has(type)) return;
+      const src = el.getAttribute("src") || "";
+      const mediaStartTimeAttr = el.getAttribute("data-media-start");
+      const mediaStartTime = mediaStartTimeAttr ? parseFloat(mediaStartTimeAttr) : void 0;
+      const sourceDurationAttr = el.getAttribute("data-source-duration");
+      const sourceDuration = sourceDurationAttr ? parseFloat(sourceDurationAttr) : void 0;
+      const isArollAttr = el.getAttribute("data-aroll");
+      const isAroll = isArollAttr === "true" ? true : void 0;
+      const volumeAttr = el.getAttribute("data-volume");
+      const volume = volumeAttr ? parseFloat(volumeAttr) : void 0;
+      const hasAudioAttr = el.getAttribute("data-has-audio");
+      const hasAudio = hasAudioAttr === "true" ? true : void 0;
+      const mediaElement = {
+        id,
+        type,
+        name,
+        src,
+        startTime: start,
+        duration,
+        zIndex,
+        x,
+        y,
+        scale,
+        opacity,
+        mediaStartTime,
+        sourceDuration,
+        isAroll,
+        volume,
+        hasAudio
+      };
+      elements.push(mediaElement);
+    }
+  });
+  const scriptTags = doc.querySelectorAll("script");
+  let gsapScript = null;
+  for (const script of scriptTags) {
+    const src = script.getAttribute("src");
+    if (src && src.includes("gsap")) continue;
+    const content = script.textContent?.trim();
+    if (content && (content.includes("gsap") || content.includes("timeline"))) {
+      gsapScript = content;
+      break;
+    }
+  }
+  for (const element of elements) {
+    const elementKeyframes = keyframes[element.id];
+    if (!elementKeyframes || elementKeyframes.length === 0) continue;
+    const baseX = element.x ?? 0;
+    const baseY = element.y ?? 0;
+    const baseScale = element.type === "video" || element.type === "image" || element.type === "composition" ? element.scale ?? 1 : 1;
+    keyframes[element.id] = normalizeKeyframes(elementKeyframes, baseX, baseY, baseScale);
+  }
+  const styleTags = doc.querySelectorAll("style");
+  const allStyles = Array.from(styleTags).map((s) => s.textContent?.trim()).filter(Boolean).join("\n\n") || null;
+  const customStyleTags = Array.from(styleTags).filter(
+    (s) => s.getAttribute("data-hf-custom") === "true"
+  );
+  const customStylesFromTags = customStyleTags.map((s) => s.textContent?.trim()).filter(Boolean).join("\n\n") || null;
+  const styles = customStyles ?? customStylesFromTags ?? null;
+  const resolution = parseResolutionFromHtml(doc) ?? parseResolutionFromCss(doc, allStyles);
+  const stageZoomKeyframes = parseStageZoomKeyframes(doc);
+  return {
+    elements,
+    gsapScript,
+    styles,
+    resolution,
+    keyframes,
+    stageZoomKeyframes
+  };
+}
+function parseStageZoomKeyframes(doc) {
+  const zoomContainer = doc.getElementById("stage-zoom-container");
+  if (!zoomContainer) {
+    return [];
+  }
+  const zoomKeyframesAttr = zoomContainer.getAttribute("data-zoom-keyframes");
+  if (!zoomKeyframesAttr) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(zoomKeyframesAttr);
+    if (Array.isArray(parsed)) {
+      return parsed.filter(
+        (kf) => typeof kf === "object" && kf !== null && typeof kf.id === "string" && typeof kf.time === "number" && typeof kf.zoom === "object" && kf.zoom !== null && typeof kf.zoom.scale === "number" && typeof kf.zoom.focusX === "number" && typeof kf.zoom.focusY === "number"
+      );
+    }
+  } catch {
+  }
+  return [];
+}
+function normalizeKeyframes(keyframes, baseX, baseY, baseScale) {
+  const timeEpsilon = 1e-3;
+  const valueEpsilon = 1e-5;
+  const hasBaseCheck = (value, base) => value !== void 0 && Math.abs(value - base) <= valueEpsilon && Math.abs(base) > valueEpsilon;
+  const timeZeroKeyframes = keyframes.filter((kf) => Math.abs(kf.time) <= timeEpsilon);
+  const treatAsAbsolute = timeZeroKeyframes.some((kf) => {
+    const props = kf.properties || {};
+    if (hasBaseCheck(props.x, baseX) || hasBaseCheck(props.y, baseY) || baseScale !== 1 && hasBaseCheck(props.scale, baseScale)) {
+      return true;
+    }
+    return false;
+  });
+  return keyframes.map((kf) => {
+    const normalizedProps = {};
+    for (const [key, value] of Object.entries(kf.properties || {})) {
+      if (typeof value !== "number") continue;
+      if (treatAsAbsolute && key === "x") {
+        normalizedProps.x = value - baseX;
+      } else if (treatAsAbsolute && key === "y") {
+        normalizedProps.y = value - baseY;
+      } else if (treatAsAbsolute && key === "scale") {
+        normalizedProps.scale = baseScale !== 0 ? value / baseScale : value;
+      } else {
+        normalizedProps[key] = value;
+      }
+    }
+    return {
+      ...kf,
+      time: Math.max(0, kf.time),
+      properties: normalizedProps
+    };
+  });
+}
+function updateElementInHtml(html, elementId, updates) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const el = doc.getElementById(elementId) || queryByAttr(doc, "data-name", elementId);
+  if (!el) return html;
+  if (updates.startTime !== void 0) {
+    el.setAttribute("data-start", String(updates.startTime));
+    if (el.hasAttribute("data-end") && updates.duration !== void 0) {
+      el.setAttribute("data-end", String(updates.startTime + updates.duration));
+    }
+  }
+  if (updates.duration !== void 0) {
+    const start = parseFloat(el.getAttribute("data-start") || "0");
+    el.setAttribute("data-end", String(start + updates.duration));
+    el.removeAttribute("data-duration");
+  }
+  if (updates.name !== void 0) {
+    el.setAttribute("data-name", updates.name);
+  }
+  if (updates.zIndex !== void 0) {
+    el.setAttribute("data-layer", String(updates.zIndex));
+  }
+  if ("src" in updates && updates.src !== void 0) {
+    el.setAttribute("src", updates.src);
+  }
+  if ("content" in updates && updates.content !== void 0) {
+    const textEl = el.firstElementChild;
+    if (textEl) {
+      textEl.textContent = updates.content;
+    }
+  }
+  if ("color" in updates && updates.color !== void 0) {
+    el.setAttribute("data-color", updates.color);
+  }
+  if ("fontSize" in updates && updates.fontSize !== void 0) {
+    el.setAttribute("data-font-size", String(updates.fontSize));
+  }
+  if ("textShadow" in updates) {
+    if (updates.textShadow === false) {
+      el.setAttribute("data-text-shadow", "false");
+    } else {
+      el.removeAttribute("data-text-shadow");
+    }
+  }
+  if ("volume" in updates) {
+    if (updates.volume !== void 0 && updates.volume !== 1) {
+      el.setAttribute("data-volume", String(updates.volume));
+    } else {
+      el.removeAttribute("data-volume");
+    }
+  }
+  if ("hasAudio" in updates) {
+    if (updates.hasAudio === true) {
+      el.setAttribute("data-has-audio", "true");
+    } else {
+      el.removeAttribute("data-has-audio");
+    }
+  }
+  return "<!DOCTYPE html>\n" + doc.documentElement.outerHTML;
+}
+function addElementToHtml(html, element) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const container = doc.querySelector("#stage-zoom-container") || doc.querySelector(".container") || doc.querySelector("#stage") || doc.body;
+  const id = element.id || `element-${Date.now()}`;
+  let newEl;
+  function applyMediaAttrs(el, mediaEl) {
+    if (mediaEl.src) el.setAttribute("src", mediaEl.src);
+    if (mediaEl.volume !== void 0 && mediaEl.volume !== 1) {
+      el.setAttribute("data-volume", String(mediaEl.volume));
+    }
+  }
+  switch (element.type) {
+    case "video": {
+      const mediaEl = element;
+      newEl = doc.createElement("video");
+      newEl.setAttribute("muted", "");
+      newEl.setAttribute("playsinline", "");
+      applyMediaAttrs(newEl, mediaEl);
+      if (mediaEl.hasAudio) {
+        newEl.setAttribute("data-has-audio", "true");
+      }
+      break;
+    }
+    case "image": {
+      const mediaEl = element;
+      newEl = doc.createElement("img");
+      if (mediaEl.src) newEl.setAttribute("src", mediaEl.src);
+      newEl.setAttribute("alt", element.name);
+      break;
+    }
+    case "audio": {
+      const mediaEl = element;
+      newEl = doc.createElement("audio");
+      applyMediaAttrs(newEl, mediaEl);
+      break;
+    }
+    case "text":
+    default: {
+      const textEl = element;
+      newEl = doc.createElement("div");
+      const textContent = doc.createElement("div");
+      textContent.textContent = textEl.content || element.name;
+      newEl.appendChild(textContent);
+      if (textEl.color) {
+        newEl.setAttribute("data-color", textEl.color);
+      }
+      if (textEl.fontSize) {
+        newEl.setAttribute("data-font-size", String(textEl.fontSize));
+      }
+      break;
+    }
+  }
+  newEl.id = id;
+  newEl.setAttribute("data-start", String(element.startTime));
+  newEl.setAttribute("data-end", String(element.startTime + element.duration));
+  newEl.setAttribute("data-layer", String(element.zIndex));
+  newEl.setAttribute("data-name", element.name);
+  container.appendChild(newEl);
+  return {
+    html: "<!DOCTYPE html>\n" + doc.documentElement.outerHTML,
+    id
+  };
+}
+function selectorTargetsId(selector, id) {
+  return selector === `#${id}` || selector === `[data-hf-id="${id}"]` || selector === `[data-hf-id='${id}']`;
+}
+function stripGsapForId(script, elementId) {
+  let current = script;
+  for (; ; ) {
+    const parsed = parseGsapScriptAcornForWrite(current);
+    if (!parsed) return current;
+    const match = parsed.located.find(
+      (l) => selectorTargetsId(l.animation.targetSelector, elementId)
+    );
+    if (!match) return current;
+    const updated = removeAnimationFromScript(current, match.id);
+    if (updated === current) return current;
+    current = updated;
+  }
+}
+function cascadeRemoveGsapById(doc, elementId) {
+  for (const script of Array.from(doc.querySelectorAll("script"))) {
+    const text = script.textContent ?? "";
+    if (!text.includes("gsap") && !text.includes("ScrollTrigger")) continue;
+    const updated = stripGsapForId(text, elementId);
+    if (updated !== text) script.textContent = updated;
+  }
+}
+function removeElementFromHtml(html, elementId) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  doc.getElementById(elementId)?.remove();
+  cascadeRemoveGsapById(doc, elementId);
+  return "<!DOCTYPE html>\n" + doc.documentElement.outerHTML;
+}
+function extractCompositionMetadata(html) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const htmlEl = doc.documentElement;
+  const compositionId = htmlEl.getAttribute("data-composition-id");
+  const durationStr = htmlEl.getAttribute("data-composition-duration");
+  const compositionDuration = durationStr ? parseFloat(durationStr) : null;
+  const variables = parseCompositionVariables(htmlEl);
+  return {
+    compositionId,
+    compositionDuration: compositionDuration && isFinite(compositionDuration) ? compositionDuration : null,
+    variables
+  };
+}
+function parseCompositionVariables(htmlEl) {
+  const variablesAttr = htmlEl.getAttribute("data-composition-variables");
+  if (!variablesAttr) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(variablesAttr);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed.filter((v) => {
+      if (typeof v !== "object" || v === null) return false;
+      if (typeof v.id !== "string" || typeof v.label !== "string") return false;
+      if (!["string", "number", "color", "boolean", "enum", "font", "image"].includes(v.type))
+        return false;
+      switch (v.type) {
+        case "string":
+          return typeof v.default === "string";
+        case "number":
+          return typeof v.default === "number";
+        case "color":
+          return typeof v.default === "string";
+        case "boolean":
+          return typeof v.default === "boolean";
+        case "enum":
+          return typeof v.default === "string" && Array.isArray(v.options);
+        case "font":
+          return typeof v.default === "string";
+        case "image":
+          return typeof v.default === "string";
+        default:
+          return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function validateCompositionHtml(html) {
+  const errors = [];
+  const warnings = [];
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const htmlEl = doc.documentElement;
+  const compositionId = htmlEl.getAttribute("data-composition-id");
+  if (!compositionId) {
+    errors.push("Missing data-composition-id attribute on <html> element");
+  }
+  const durationStr = htmlEl.getAttribute("data-composition-duration");
+  if (!durationStr) {
+    errors.push("Missing data-composition-duration attribute on <html> element");
+  } else {
+    const duration = parseFloat(durationStr);
+    if (!isFinite(duration) || duration <= 0) {
+      errors.push("data-composition-duration must be a positive finite number");
+    }
+  }
+  const stage = doc.getElementById("stage");
+  if (!stage) {
+    errors.push("Missing #stage element");
+  }
+  if (/\son\w+\s*=/i.test(html)) {
+    errors.push("Inline event handlers (onclick, onload, etc.) not allowed");
+  }
+  if (/javascript\s*:/i.test(html)) {
+    errors.push("javascript: URLs not allowed");
+  }
+  const scripts = doc.querySelectorAll("script");
+  if (scripts.length > 2) {
+    warnings.push("Multiple script tags detected - only GSAP CDN and main script expected");
+  }
+  const gsapScript = extractGsapScript(doc);
+  if (gsapScript) {
+    const gsapValidation = validateCompositionGsap(gsapScript);
+    errors.push(...gsapValidation.errors);
+    warnings.push(...gsapValidation.warnings);
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function extractGsapScript(doc) {
+  const scripts = doc.querySelectorAll("script");
+  for (const script of scripts) {
+    const content = script.textContent || "";
+    if (content.includes("gsap.timeline") || content.includes(".set(") || content.includes(".to(")) {
+      return content;
+    }
+  }
+  return null;
+}
+
+// src/gsapUnroll.ts
+import * as acorn2 from "acorn";
+import MagicString2 from "magic-string";
+function propEntries(props) {
+  return Object.entries(props).map(([k, v]) => `${safeJsKey(k)}: ${serializeValue(v)}`);
+}
+function motionPathEntry(anim) {
+  const waypoints = (anim.keyframes?.keyframes ?? []).filter((k) => typeof k.properties.x === "number" && typeof k.properties.y === "number").map((k) => `{ x: ${serializeValue(k.properties.x)}, y: ${serializeValue(k.properties.y)} }`);
+  const curviness = anim.arcPath?.segments[0]?.curviness ?? 1;
+  const autoRotate = anim.arcPath?.autoRotate;
+  const extra = autoRotate ? `, autoRotate: ${serializeValue(autoRotate)}` : "";
+  return `motionPath: { path: [${waypoints.join(", ")}], curviness: ${curviness}${extra} }`;
+}
+function keyframesEntry(anim) {
+  const kfs = (anim.keyframes?.keyframes ?? []).map((k) => {
+    const body = propEntries(k.properties);
+    if (k.ease) body.push(`ease: ${serializeValue(k.ease)}`);
+    return `"${k.percentage}%": { ${body.join(", ")} }`;
+  });
+  if (anim.keyframes?.easeEach) kfs.push(`easeEach: ${serializeValue(anim.keyframes.easeEach)}`);
+  return `keyframes: { ${kfs.join(", ")} }`;
+}
+function buildVarsParts(anim) {
+  const parts = [];
+  if (anim.arcPath?.enabled) parts.push(motionPathEntry(anim));
+  else if (anim.keyframes) parts.push(keyframesEntry(anim));
+  parts.push(...propEntries(anim.properties));
+  if (anim.method !== "set" && anim.duration !== void 0) {
+    parts.push(`duration: ${serializeValue(anim.duration)}`);
+  }
+  if (anim.ease) parts.push(`ease: ${serializeValue(anim.ease)}`);
+  for (const [k, v] of Object.entries(anim.extras ?? {})) {
+    parts.push(`${safeJsKey(k)}: ${serializeValue(v)}`);
+  }
+  return parts;
+}
+function serializeTweenStatement(timelineVar, anim) {
+  const obj = `{ ${buildVarsParts(anim).join(", ")} }`;
+  const pos = serializeValue(
+    anim.resolvedStart ?? (typeof anim.position === "number" ? anim.position : 0)
+  );
+  const sel = serializeValue(anim.targetSelector);
+  if (anim.method === "fromTo") {
+    const from = `{ ${propEntries(anim.fromProperties ?? {}).join(", ")} }`;
+    return `${timelineVar}.fromTo(${sel}, ${from}, ${obj}, ${pos});`;
+  }
+  return `${timelineVar}.${anim.method}(${sel}, ${obj}, ${pos});`;
+}
+function isComputed(anim) {
+  return anim.provenance?.kind === "helper" || anim.provenance?.kind === "loop";
+}
+function topLevelStatements(script) {
+  return acorn2.parse(script, { ecmaVersion: "latest", sourceType: "script" }).body ?? [];
+}
+function enclosingTopLevel(statements, start, end) {
+  for (const stmt of statements) {
+    if (stmt.start <= start && stmt.end >= end) return stmt;
+  }
+  return null;
+}
+function isHelperDeclNamed(stmt, names) {
+  if (stmt.type === "FunctionDeclaration") return names.has(stmt.id?.name);
+  if (stmt.type === "VariableDeclaration") {
+    return (stmt.declarations ?? []).some((d) => names.has(d.id?.name));
+  }
+  return false;
+}
+function unrollComputedTimeline(script) {
+  const parsed = parseGsapScriptAcorn(script);
+  const computed = parsed.animations.filter((a) => isComputed(a) && a.provenance?.sourceRange);
+  if (computed.length === 0) return script;
+  const statements = topLevelStatements(script);
+  const byStatement = /* @__PURE__ */ new Map();
+  const helperNames = /* @__PURE__ */ new Set();
+  for (const anim of computed) {
+    if (anim.provenance?.fn) helperNames.add(anim.provenance.fn);
+    const [s, e] = anim.provenance.sourceRange;
+    const stmt = enclosingTopLevel(statements, s, e);
+    if (!stmt) continue;
+    const list = byStatement.get(stmt) ?? [];
+    list.push(anim);
+    byStatement.set(stmt, list);
+  }
+  if (byStatement.size === 0) return script;
+  const ms = new MagicString2(script);
+  for (const [stmt, anims] of byStatement) {
+    const literals = anims.map((a) => serializeTweenStatement(parsed.timelineVar, a)).join("\n");
+    ms.overwrite(stmt.start, stmt.end, literals);
+  }
+  for (const stmt of statements) {
+    if (isHelperDeclNamed(stmt, helperNames)) ms.remove(stmt.start, stmt.end);
+  }
+  return ms.toString();
+}
+export {
+  CANVAS_DIMENSIONS,
+  COMPOSITION_VARIABLE_TYPES,
+  DEFAULT_DURATIONS,
+  EXCLUDED_TAGS,
+  PROPERTY_GROUPS,
+  SPRING_PRESETS,
+  SUPPORTED_EASES,
+  SUPPORTED_PROPS,
+  TIMELINE_COLORS,
+  VALID_CANVAS_RESOLUTIONS,
+  addElementToHtml,
+  classifyPropertyGroup,
+  classifyTweenPropertyGroup,
+  editabilityForProvenance,
+  ensureHfIds,
+  extractCompositionMetadata,
+  generateSpringEaseData,
+  getAnimationsForElementId,
+  getDefaultStageZoom,
+  gsapAnimationsToKeyframes,
+  isCompositionElement,
+  isMediaElement,
+  isStudioHoldSet,
+  isTextElement,
+  keyframesToGsapAnimations,
+  mintHfId,
+  normalizeResolutionFlag,
+  parseGsapScriptAcorn as parseGsapScript,
+  parseHtml,
+  queryByAttr,
+  removeElementFromHtml,
+  serializeGsapAnimations,
+  unrollComputedTimeline,
+  updateElementInHtml,
+  validateCompositionGsap,
+  validateCompositionHtml
+};
+//# sourceMappingURL=index.js.map