@hyperframes/parsers 0.7.15

package/dist/gsapWriterAcorn.js

@@ -0,0 +1,2369 @@
+// src/gsapWriterAcorn.ts
+import MagicString from "magic-string";
+
+// src/gsapConstants.ts
+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;
+}
+
+// src/gsapSerialize.ts
+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 };
+}
+var CSS_IDENTITY = {
+  opacity: 1,
+  autoAlpha: 1,
+  scale: 1,
+  scaleX: 1,
+  scaleY: 1
+};
+function cssIdentityValue(prop) {
+  return CSS_IDENTITY[prop] ?? 0;
+}
+function buildIdentityMap(props) {
+  const identity = {};
+  for (const [key, val] of Object.entries(props)) {
+    if (val != null) identity[key] = typeof val === "number" ? cssIdentityValue(key) : val;
+  }
+  return identity;
+}
+function resolveConversionProps(anim, resolvedFromValues) {
+  if (anim.method === "set") {
+    return { fromProps: { ...anim.properties }, toProps: { ...anim.properties } };
+  }
+  if (anim.method === "to") {
+    const identity = buildIdentityMap(anim.properties);
+    const fromProps = resolvedFromValues ? { ...identity, ...resolvedFromValues } : identity;
+    return { fromProps, toProps: { ...anim.properties } };
+  }
+  if (anim.method === "from") {
+    const identity = buildIdentityMap(anim.properties);
+    const toProps2 = resolvedFromValues ? { ...identity, ...resolvedFromValues } : identity;
+    return { fromProps: { ...anim.properties }, toProps: toProps2 };
+  }
+  const toProps = resolvedFromValues ? { ...anim.properties, ...resolvedFromValues } : { ...anim.properties };
+  return { fromProps: { ...anim.fromProperties ?? {} }, toProps };
+}
+function numericXY(props) {
+  const vx = props.x;
+  const vy = props.y;
+  return typeof vx === "number" && typeof vy === "number" ? { x: vx, y: vy } : null;
+}
+function extractArcWaypoints(anim) {
+  const keyframeWps = (anim.keyframes?.keyframes ?? []).map((kf) => numericXY(kf.properties)).filter((pt) => pt !== null);
+  if (keyframeWps.length >= 2) return keyframeWps;
+  const propX = anim.properties.x;
+  const propY = anim.properties.y;
+  if (typeof propX !== "number" && typeof propY !== "number") return keyframeWps;
+  const destX = typeof propX === "number" ? propX : 0;
+  const destY = typeof propY === "number" ? propY : 0;
+  return [
+    { x: 0, y: 0 },
+    { x: destX, y: destY }
+  ];
+}
+function autoRotateSuffix(autoRotate) {
+  if (autoRotate === true) return ", autoRotate: true";
+  if (typeof autoRotate === "number") return `, autoRotate: ${autoRotate}`;
+  return "";
+}
+function cubicControlPoints(seg, wp, nextWp) {
+  if (seg.cp1 && seg.cp2) {
+    return [`{x: ${seg.cp1.x}, y: ${seg.cp1.y}}`, `{x: ${seg.cp2.x}, y: ${seg.cp2.y}}`];
+  }
+  const dx = nextWp.x - wp.x;
+  const dy = nextWp.y - wp.y;
+  const c = seg.curviness ?? 1;
+  return [
+    `{x: ${wp.x + dx * 0.33}, y: ${wp.y + dy * 0.33 - c * Math.abs(dx) * 0.25}}`,
+    `{x: ${wp.x + dx * 0.66}, y: ${wp.y + dy * 0.66 - c * Math.abs(dx) * 0.25}}`
+  ];
+}
+function buildCubicPathEntries(waypoints, segments) {
+  const first = waypoints[0];
+  if (!first) return [];
+  const entries = [`{x: ${first.x}, y: ${first.y}}`];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const wp = waypoints[i];
+    const nextWp = waypoints[i + 1];
+    if (!seg || !wp || !nextWp) continue;
+    entries.push(...cubicControlPoints(seg, wp, nextWp));
+    entries.push(`{x: ${nextWp.x}, y: ${nextWp.y}}`);
+  }
+  return entries;
+}
+function buildMotionPathObjectCode(config) {
+  const { waypoints, segments, autoRotate } = config;
+  const arSuffix = autoRotateSuffix(autoRotate);
+  const hasExplicitCp = segments.some((s) => s.cp1 && s.cp2);
+  const curvinessVaries = segments.some(
+    (s) => (s.curviness ?? 1) !== (segments[0]?.curviness ?? 1)
+  );
+  if ((hasExplicitCp || curvinessVaries) && waypoints.length >= 2) {
+    const pathStr = buildCubicPathEntries(waypoints, segments).join(", ");
+    return `{ path: [${pathStr}], type: "cubic"${arSuffix} }`;
+  }
+  const pathEntries = waypoints.map((wp) => `{x: ${wp.x}, y: ${wp.y}}`);
+  const curviness = segments[0]?.curviness ?? 1;
+  const curvPart = curviness !== 1 ? `, curviness: ${curviness}` : "";
+  return `{ path: [${pathEntries.join(", ")}]${curvPart}${arSuffix} }`;
+}
+
+// src/gsapParserAcorn.ts
+import * as acorn from "acorn";
+import * as acornWalk from "acorn-walk";
+
+// src/gsapInline.ts
+function readProvenance(node) {
+  return node?.__hfProvenance;
+}
+
+// src/gsapParserAcorn.ts
+var GSAP_METHODS = /* @__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 isFunctionNode(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" && isFunctionNode(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_METHODS.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;
+  }
+}
+
+// src/gsapWriterAcorn.ts
+import * as acornWalk2 from "acorn-walk";
+function valueToCode(value) {
+  if (typeof value === "string" && value.startsWith("__raw:")) return value.slice(6);
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number") return Number.isNaN(value) ? "0" : String(value);
+  if (typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+function safeKey(key) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function buildTweenStatementCode(timelineVar, anim) {
+  const selector = JSON.stringify(anim.targetSelector);
+  const props = { ...anim.properties };
+  if (anim.method !== "set" && anim.duration !== void 0) props.duration = anim.duration;
+  if (anim.ease) props.ease = anim.ease;
+  const entries = Object.entries(props).map(([k, v]) => `${safeKey(k)}: ${valueToCode(v)}`);
+  if (anim.extras) {
+    for (const [k, v] of Object.entries(anim.extras)) {
+      entries.push(`${safeKey(k)}: ${valueToCode(v)}`);
+    }
+  }
+  const objCode = `{ ${entries.join(", ")} }`;
+  const posCode = valueToCode(
+    typeof anim.position === "number" ? anim.position : anim.position ?? 0
+  );
+  if (anim.method === "fromTo") {
+    const fromEntries = Object.entries(anim.fromProperties ?? {}).map(
+      ([k, v]) => `${safeKey(k)}: ${valueToCode(v)}`
+    );
+    return `${timelineVar}.fromTo(${selector}, { ${fromEntries.join(", ")} }, ${objCode}, ${posCode});`;
+  }
+  if (anim.method === "set" && anim.global) {
+    return `gsap.set(${selector}, ${objCode});`;
+  }
+  return `${timelineVar}.${anim.method}(${selector}, ${objCode}, ${posCode});`;
+}
+function isObjectProperty2(prop) {
+  return prop?.type === "ObjectProperty" || prop?.type === "Property";
+}
+function propKeyName2(prop) {
+  return prop?.key?.name ?? prop?.key?.value;
+}
+function findPropertyNode2(varsArgNode, key) {
+  if (varsArgNode?.type !== "ObjectExpression") return void 0;
+  for (const prop of varsArgNode.properties ?? []) {
+    if (!isObjectProperty2(prop)) continue;
+    if (propKeyName2(prop) === key) return prop;
+  }
+  return void 0;
+}
+function keyframesObjectNode(varsNode) {
+  const kfProp = findPropertyNode2(varsNode, "keyframes");
+  return kfProp?.value?.type === "ObjectExpression" ? kfProp.value : null;
+}
+function findEnclosingExpressionStatement(ancestors) {
+  for (let i = ancestors.length - 2; i >= 0; i--) {
+    if (ancestors[i]?.type === "ExpressionStatement") return ancestors[i];
+  }
+  return null;
+}
+function findTimelineDeclarationStatement(ast, timelineVar) {
+  let found = null;
+  acornWalk2.simple(ast, {
+    // fallow-ignore-next-line complexity
+    VariableDeclaration(node) {
+      if (found) return;
+      for (const decl of node.declarations ?? []) {
+        if (decl.id?.name === timelineVar && decl.init?.type === "CallExpression" && decl.init.callee?.type === "MemberExpression" && decl.init.callee.object?.name === "gsap" && decl.init.callee.property?.name === "timeline") {
+          found = node;
+        }
+      }
+    }
+  });
+  return found;
+}
+function removeProp(ms, propNode, editableProps) {
+  const idx = editableProps.indexOf(propNode);
+  if (idx === -1) return;
+  if (editableProps.length === 1) {
+    ms.remove(propNode.start, propNode.end);
+  } else if (idx === 0) {
+    ms.remove(editableProps[0].start, editableProps[1].start);
+  } else {
+    ms.remove(editableProps[idx - 1].end, propNode.end);
+  }
+}
+function buildVarsObjectCode(record) {
+  const entries = Object.entries(record).map(([k, v]) => `${safeKey(k)}: ${valueToCode(v)}`);
+  return entries.length > 0 ? `{ ${entries.join(", ")} }` : "{}";
+}
+function overwriteVarsArg(ms, call, objCode) {
+  if (!call.varsArg) return;
+  ms.overwrite(call.varsArg.start, call.varsArg.end, objCode);
+}
+function upsertProp(ms, objNode, key, value) {
+  if (objNode?.type !== "ObjectExpression") return;
+  const existing = findPropertyNode2(objNode, key);
+  if (existing) {
+    ms.overwrite(existing.value.start, existing.value.end, valueToCode(value));
+  } else {
+    const sep = objNode.properties.length > 0 ? ", " : "";
+    ms.appendLeft(objNode.end - 1, `${sep}${safeKey(key)}: ${valueToCode(value)}`);
+  }
+}
+var NON_EDITABLE_PROP_KEYS = /* @__PURE__ */ new Set([
+  "duration",
+  "ease",
+  "delay",
+  "onComplete",
+  "onStart",
+  "onUpdate",
+  "onRepeat",
+  "stagger",
+  "yoyo",
+  "repeat",
+  "repeatDelay",
+  "snap",
+  "overwrite",
+  "immediateRender"
+]);
+function isEditableVarKey(key) {
+  return !NON_EDITABLE_PROP_KEYS.has(key);
+}
+function preservedEntries(objNode, source, drop, overrides) {
+  const entries = [];
+  const keys = /* @__PURE__ */ new Set();
+  for (const prop of objNode.properties ?? []) {
+    if (!isObjectProperty2(prop)) continue;
+    const key = propKeyName2(prop);
+    if (typeof key !== "string" || drop(key)) continue;
+    keys.add(key);
+    const code = key in overrides ? valueToCode(overrides[key]) : source.slice(prop.value.start, prop.value.end);
+    entries.push(`${safeKey(key)}: ${code}`);
+  }
+  return { entries, keys };
+}
+function reconcileEditableProps(ms, objNode, source, newProps, nonEditableOverrides) {
+  if (objNode?.type !== "ObjectExpression") return;
+  const overrides = nonEditableOverrides ?? {};
+  const { entries, keys } = preservedEntries(objNode, source, isEditableVarKey, overrides);
+  for (const [key, value] of Object.entries(overrides)) {
+    if (!keys.has(key)) entries.push(`${safeKey(key)}: ${valueToCode(value)}`);
+  }
+  for (const [key, value] of Object.entries(newProps)) {
+    entries.push(`${safeKey(key)}: ${valueToCode(value)}`);
+  }
+  ms.overwrite(objNode.start, objNode.end, `{ ${entries.join(", ")} }`);
+}
+function isTimelineRooted(node, timelineVar) {
+  if (node?.type === "Identifier") return node.name === timelineVar;
+  if (node?.type === "CallExpression") return isTimelineRooted(node.callee?.object, timelineVar);
+  return false;
+}
+function findInsertionPoint(parsed) {
+  const lastLocated = parsed.located[parsed.located.length - 1];
+  if (lastLocated) {
+    const lastCall = lastLocated.call;
+    const exprStmt = findEnclosingExpressionStatement(lastCall.ancestors);
+    return exprStmt?.end ?? lastCall.node.end;
+  }
+  if (!parsed.hasTimeline) return null;
+  const tlDecl = findTimelineDeclarationStatement(parsed.ast, parsed.timelineVar);
+  return tlDecl?.end ?? parsed.ast.end;
+}
+function updateAnimationInScript(script, animationId, updates) {
+  if (!Object.keys(updates).length) return script;
+  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 { call } = target;
+  if (updates.properties) {
+    const overrides = {};
+    if (updates.duration !== void 0) overrides.duration = updates.duration;
+    if (updates.ease !== void 0) overrides.ease = updates.ease;
+    if (updates.extras) Object.assign(overrides, updates.extras);
+    reconcileEditableProps(ms, call.varsArg, script, updates.properties, overrides);
+  } else {
+    if (updates.duration !== void 0) {
+      upsertProp(ms, call.varsArg, "duration", updates.duration);
+    }
+    const easeValue = updates.easeEach ?? updates.ease;
+    if (easeValue !== void 0) {
+      const kfNode = keyframesObjectNode(call.varsArg);
+      if (kfNode) {
+        upsertProp(ms, kfNode, "easeEach", easeValue);
+        if (updates.resetKeyframeEases) {
+          for (const kfEntry of kfNode.properties ?? []) {
+            if (!isObjectProperty2(kfEntry)) continue;
+            const val = kfEntry.value;
+            if (val?.type !== "ObjectExpression") continue;
+            const easeNode = findPropertyNode2(val, "ease");
+            if (easeNode) removeProp(ms, easeNode, val.properties);
+          }
+        }
+      } else {
+        upsertProp(ms, call.varsArg, "ease", easeValue);
+      }
+    }
+    if (updates.extras) {
+      for (const [key, value] of Object.entries(updates.extras)) {
+        upsertProp(ms, call.varsArg, key, value);
+      }
+    }
+  }
+  if (updates.fromProperties && call.method === "fromTo" && call.fromArg) {
+    reconcileEditableProps(ms, call.fromArg, script, updates.fromProperties);
+  }
+  if (updates.position !== void 0) {
+    overwritePosition(ms, call, updates.position);
+  }
+  return ms.toString();
+}
+function overwritePosition(ms, call, position) {
+  if (call.positionArg) {
+    ms.overwrite(call.positionArg.start, call.positionArg.end, valueToCode(position));
+  } else {
+    ms.appendLeft(call.node.end - 1, `, ${valueToCode(position)}`);
+  }
+}
+function shiftPositionsInScript(script, targetSelector, delta) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const ms = new MagicString(script);
+  let changed = false;
+  for (const entry of parsed.located) {
+    if (entry.animation.targetSelector !== targetSelector) continue;
+    if (typeof entry.animation.position !== "number") continue;
+    const newPos = Math.max(0, Math.round((entry.animation.position + delta) * 1e3) / 1e3);
+    overwritePosition(ms, entry.call, newPos);
+    changed = true;
+  }
+  return changed ? ms.toString() : script;
+}
+function scalePositionsInScript(script, targetSelector, oldStart, oldDuration, newStart, newDuration) {
+  if (oldDuration <= 0 || newDuration <= 0) return script;
+  const ratio = newDuration / oldDuration;
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const ms = new MagicString(script);
+  let changed = false;
+  for (const entry of parsed.located) {
+    if (entry.animation.targetSelector !== targetSelector) continue;
+    if (typeof entry.animation.position !== "number") continue;
+    const newPos = Math.max(
+      0,
+      Math.round((newStart + (entry.animation.position - oldStart) * ratio) * 1e3) / 1e3
+    );
+    overwritePosition(ms, entry.call, newPos);
+    if (typeof entry.animation.duration === "number" && entry.animation.duration > 0) {
+      const newDur = Math.max(1e-3, Math.round(entry.animation.duration * ratio * 1e3) / 1e3);
+      upsertProp(ms, entry.call.varsArg, "duration", newDur);
+    }
+    changed = true;
+  }
+  return changed ? ms.toString() : script;
+}
+function addAnimationToScript(script, animation) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return { script, id: "" };
+  const insertionPoint = findInsertionPoint(parsed);
+  if (insertionPoint === null) return { script, id: "" };
+  const ms = new MagicString(script);
+  const statementCode = buildTweenStatementCode(parsed.timelineVar, animation);
+  ms.appendLeft(insertionPoint, "\n" + statementCode);
+  const result = ms.toString();
+  const reParsed = parseGsapScriptAcornForWrite(result);
+  const newId = reParsed?.located[reParsed.located.length - 1]?.id ?? "";
+  return { script: result, id: newId };
+}
+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();
+}
+var CSS_IDENTITY2 = {
+  opacity: 1,
+  autoAlpha: 1,
+  scale: 1,
+  scaleX: 1,
+  scaleY: 1
+};
+function cssIdentityValue2(prop) {
+  return CSS_IDENTITY2[prop] ?? 0;
+}
+var NON_EDITABLE_VAR_KEYS = /* @__PURE__ */ new Set([
+  "duration",
+  "delay",
+  "onComplete",
+  "onStart",
+  "onUpdate",
+  "onRepeat",
+  "stagger",
+  "yoyo",
+  "repeat",
+  "repeatDelay",
+  "snap",
+  "overwrite",
+  "immediateRender"
+]);
+function identityProps(properties) {
+  const identity = {};
+  for (const [k, v] of Object.entries(properties)) {
+    if (v != null) identity[k] = typeof v === "number" ? cssIdentityValue2(k) : v;
+  }
+  return identity;
+}
+function conversionEndpoints(animation) {
+  if (animation.method === "from") {
+    return { fromProps: { ...animation.properties }, toProps: identityProps(animation.properties) };
+  }
+  if (animation.method === "fromTo") {
+    return {
+      fromProps: { ...animation.fromProperties ?? {} },
+      toProps: { ...animation.properties }
+    };
+  }
+  return { fromProps: identityProps(animation.properties), toProps: { ...animation.properties } };
+}
+function preservedVarsEntries(varsNode, source) {
+  const entries = [];
+  if (varsNode?.type !== "ObjectExpression") return entries;
+  for (const prop of varsNode.properties ?? []) {
+    if (!isObjectProperty2(prop)) continue;
+    const key = propKeyName2(prop);
+    if (typeof key !== "string" || !NON_EDITABLE_VAR_KEYS.has(key)) continue;
+    entries.push(`${safeKey(key)}: ${source.slice(prop.value.start, prop.value.end)}`);
+  }
+  return entries;
+}
+function buildConvertedVarsCode(animation, varsNode, source) {
+  const { fromProps, toProps } = conversionEndpoints(animation);
+  const easeEach = animation.ease;
+  const easeEachEntry = easeEach ? `, easeEach: ${JSON.stringify(easeEach)}` : "";
+  const kfCode = `{ "0%": ${recordToCode(fromProps)}, "100%": ${recordToCode(toProps)}${easeEachEntry} }`;
+  const entries = [`keyframes: ${kfCode}`, ...preservedVarsEntries(varsNode, source)];
+  if (easeEach) entries.push(`ease: "none"`);
+  return `{ ${entries.join(", ")} }`;
+}
+function convertMethodToTo(ms, animation, call, varsNode) {
+  if (animation.method !== "from" && animation.method !== "fromTo") return;
+  const calleeProp = call.node.callee?.property;
+  if (calleeProp) ms.overwrite(calleeProp.start, calleeProp.end, "to");
+  if (animation.method === "fromTo" && call.fromArg) ms.remove(call.fromArg.start, varsNode.start);
+}
+function convertFlatTweenToKeyframes(script, target) {
+  const animation = target.animation;
+  if (animation.keyframes || animation.method === "set") return script;
+  const call = target.call;
+  const varsNode = call.varsArg;
+  if (varsNode?.type !== "ObjectExpression") return script;
+  const ms = new MagicString(script);
+  ms.overwrite(varsNode.start, varsNode.end, buildConvertedVarsCode(animation, varsNode, script));
+  convertMethodToTo(ms, animation, call, varsNode);
+  return ms.toString();
+}
+var PERCENTAGE_KEY_RE2 = /^(\d+(?:\.\d+)?)%$/;
+var PCT_TOLERANCE = 2;
+function percentageFromKey(key) {
+  const m = PERCENTAGE_KEY_RE2.exec(key);
+  return m ? Number.parseFloat(m[1] ?? "0") : Number.NaN;
+}
+function recordToCode(record) {
+  const entries = Object.entries(record).map(([k, v]) => `${safeKey(k)}: ${valueToCode(v)}`);
+  return `{ ${entries.join(", ")} }`;
+}
+function percentagePropsOf(kfNode) {
+  return (kfNode.properties ?? []).filter((p) => {
+    if (!isObjectProperty2(p)) return false;
+    const key = propKeyName2(p);
+    return typeof key === "string" && PERCENTAGE_KEY_RE2.test(key);
+  });
+}
+var LITERAL_NODE_TYPES = /* @__PURE__ */ new Set(["Literal", "NumericLiteral", "StringLiteral"]);
+function readValueNode(v, source) {
+  if (LITERAL_NODE_TYPES.has(v?.type) && (typeof v.value === "number" || typeof v.value === "string")) {
+    return v.value;
+  }
+  if (v?.type === "UnaryExpression" && v.operator === "-" && typeof v.argument?.value === "number") {
+    return -v.argument.value;
+  }
+  return `__raw:${source.slice(v.start, v.end)}`;
+}
+function valueNodeToRecord(valueNode, source) {
+  const record = {};
+  if (valueNode?.type !== "ObjectExpression") return record;
+  for (const prop of valueNode.properties ?? []) {
+    if (!isObjectProperty2(prop)) continue;
+    const key = propKeyName2(prop);
+    if (typeof key !== "string") continue;
+    record[key] = readValueNode(prop.value, source);
+  }
+  return record;
+}
+function recordHasAuto(record) {
+  return "_auto" in record;
+}
+function autoEndpointOverwrites(kfNode, source, percentage, properties) {
+  const result = /* @__PURE__ */ new Map();
+  if (percentage <= 0 || percentage >= 100) return result;
+  const pctProps = percentagePropsOf(kfNode);
+  const allPcts = pctProps.map((p) => percentageFromKey(propKeyName2(p) ?? "")).filter((n) => !Number.isNaN(n) && n !== percentage).sort((a, b) => a - b);
+  const leftNeighbor = allPcts.filter((p) => p < percentage).pop();
+  const rightNeighbor = allPcts.find((p) => p > percentage);
+  for (const endPct of [0, 100]) {
+    const isNeighbor = endPct === 0 ? leftNeighbor === 0 : rightNeighbor === 100;
+    if (!isNeighbor) continue;
+    const endProp = pctProps.find((p) => percentageFromKey(propKeyName2(p) ?? "") === endPct);
+    if (!endProp) continue;
+    const rec = valueNodeToRecord(endProp.value, source);
+    if (!recordHasAuto(rec)) continue;
+    result.set(endProp, { ...properties, _auto: 1 });
+  }
+  return result;
+}
+function findKfPropByPct(kfNode, percentage) {
+  const props = kfNode.properties ?? [];
+  let best = null;
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < props.length; i++) {
+    const prop = props[i];
+    if (!isObjectProperty2(prop)) continue;
+    const key = propKeyName2(prop);
+    if (typeof key !== "string") continue;
+    const dist = Math.abs(percentageFromKey(key) - percentage);
+    if (dist <= PCT_TOLERANCE && dist < bestDist) {
+      best = { prop, idx: i };
+      bestDist = dist;
+    }
+  }
+  return best;
+}
+function updateKeyframeInScript(script, animationId, percentage, properties, ease) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  const kfPropNode = findPropertyNode2(target.call.varsArg, "keyframes");
+  if (!kfPropNode) return script;
+  if (kfPropNode.value?.type === "ArrayExpression") {
+    return updateArrayKeyframeByPct(script, kfPropNode.value, percentage, properties, ease);
+  }
+  if (kfPropNode.value?.type !== "ObjectExpression") return script;
+  const match = findKfPropByPct(kfPropNode.value, percentage);
+  if (!match) return script;
+  const record = { ...properties };
+  if (ease) record.ease = ease;
+  const ms = new MagicString(script);
+  ms.overwrite(match.prop.value.start, match.prop.value.end, recordToCode(record));
+  return ms.toString();
+}
+function updateArrayKeyframeByPct(script, arrayNode, percentage, properties, ease) {
+  const elements = (arrayNode.elements ?? []).filter(
+    (el2) => !!el2 && el2.type === "ObjectExpression"
+  );
+  const n = elements.length;
+  if (n === 0) return script;
+  const idx = n > 1 ? Math.round(percentage / 100 * (n - 1)) : 0;
+  const el = elements[Math.max(0, Math.min(n - 1, idx))];
+  if (!el) return script;
+  const merged = {
+    ...valueNodeToRecord(el, script),
+    ...properties
+  };
+  if (ease) merged.ease = ease;
+  const ms = new MagicString(script);
+  ms.overwrite(el.start, el.end, recordToCode(merged));
+  return ms.toString();
+}
+function buildTargetRecord(existing, source, properties, ease) {
+  if (!existing || existing.prop.value?.type !== "ObjectExpression") {
+    const record = { ...properties };
+    if (ease) record.ease = ease;
+    return record;
+  }
+  const existingRecord = valueNodeToRecord(existing.prop.value, source);
+  const existingEase = typeof existingRecord.ease === "string" ? existingRecord.ease : void 0;
+  const merged = { ...existingRecord };
+  for (const [k, v] of Object.entries(properties)) merged[k] = v;
+  const finalEase = ease ?? existingEase;
+  if (finalEase) merged.ease = finalEase;
+  else delete merged.ease;
+  return merged;
+}
+function backfilledSiblingRecord(valueNode, source, newPropKeys, backfillDefaults) {
+  if (valueNode?.type !== "ObjectExpression") return null;
+  const record = valueNodeToRecord(valueNode, source);
+  let changed = false;
+  for (const pk of newPropKeys) {
+    const defaultVal = backfillDefaults[pk];
+    if (pk in record || defaultVal == null) continue;
+    record[pk] = defaultVal;
+    changed = true;
+  }
+  return changed ? record : null;
+}
+function locateWithKeyframes(script, animationId) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return null;
+  const convertedId = animationId.replace(/-from-|-fromTo-/, "-to-");
+  const target = parsed.located.find((l) => l.id === animationId) ?? parsed.located.find((l) => l.id === convertedId);
+  if (!target) return null;
+  const kfPropNode = findPropertyNode2(target.call.varsArg, "keyframes");
+  if (!kfPropNode || kfPropNode.value?.type !== "ObjectExpression") return null;
+  return { script, parsed, target, kfNode: kfPropNode.value };
+}
+function convertArrayKeyframesToObject(script, target) {
+  const kfPropNode = findPropertyNode2(target.call.varsArg, "keyframes");
+  if (!kfPropNode || kfPropNode.value?.type !== "ArrayExpression") return script;
+  const els = (kfPropNode.value.elements ?? []).filter(
+    (el) => !!el && el.type === "ObjectExpression"
+  );
+  const n = els.length;
+  if (n === 0) return script;
+  const entries = els.map((el, i) => {
+    const pct = n > 1 ? Math.round(i / (n - 1) * 1e3) / 10 : 0;
+    return `${JSON.stringify(`${pct}%`)}: ${script.slice(el.start, el.end)}`;
+  });
+  const ms = new MagicString(script);
+  ms.overwrite(kfPropNode.value.start, kfPropNode.value.end, `{ ${entries.join(", ")} }`);
+  return ms.toString();
+}
+function ensureKeyframesNode(script, animationId) {
+  const direct = locateWithKeyframes(script, animationId);
+  if (direct) return direct;
+  const parsed = parseGsapScriptAcornForWrite(script);
+  const target = parsed?.located.find((l) => l.id === animationId);
+  if (!target) return null;
+  const kfProp = findPropertyNode2(target.call.varsArg, "keyframes");
+  if (kfProp?.value?.type === "ArrayExpression") {
+    const normalized = convertArrayKeyframesToObject(script, target);
+    if (normalized !== script) return locateWithKeyframes(normalized, animationId);
+    return null;
+  }
+  const converted = convertFlatTweenToKeyframes(script, target);
+  if (converted === script) return null;
+  return locateWithKeyframes(converted, animationId);
+}
+function collectBackfillOverwrites(kfNode, src, properties, backfillDefaults, skip) {
+  const result = /* @__PURE__ */ new Map();
+  if (!backfillDefaults) return result;
+  const newPropKeys = Object.keys(properties);
+  for (const prop of percentagePropsOf(kfNode)) {
+    if (prop === skip.existingProp || skip.endpoints.has(prop)) continue;
+    const rec = backfilledSiblingRecord(prop.value, src, newPropKeys, backfillDefaults);
+    if (rec) result.set(prop, rec);
+  }
+  return result;
+}
+function addKeyframeToScript(script, animationId, percentage, properties, ease, backfillDefaults) {
+  const located = ensureKeyframesNode(script, animationId);
+  if (!located) return script;
+  const { script: src, kfNode } = located;
+  const existing = findKfPropByPct(kfNode, percentage);
+  const targetRecord = buildTargetRecord(existing, src, properties, ease);
+  const endpointOverwrites = existing ? /* @__PURE__ */ new Map() : autoEndpointOverwrites(kfNode, src, percentage, properties);
+  const backfillOverwrites = collectBackfillOverwrites(kfNode, src, properties, backfillDefaults, {
+    existingProp: existing?.prop,
+    endpoints: endpointOverwrites
+  });
+  const ms = new MagicString(src);
+  if (existing) {
+    if (existing.prop.value?.type === "ObjectExpression") {
+      for (const [k, v] of Object.entries(properties)) {
+        upsertProp(ms, existing.prop.value, k, v);
+      }
+      if (ease !== void 0) upsertProp(ms, existing.prop.value, "ease", ease);
+    } else {
+      ms.overwrite(existing.prop.value.start, existing.prop.value.end, recordToCode(targetRecord));
+    }
+  } else {
+    insertNewKeyframe(ms, kfNode, percentage, `${percentage}%`, recordToCode(targetRecord));
+  }
+  for (const [prop, rec] of [...endpointOverwrites, ...backfillOverwrites]) {
+    ms.overwrite(prop.value.start, prop.value.end, recordToCode(rec));
+  }
+  return ms.toString();
+}
+function insertNewKeyframe(ms, kfNode, percentage, pctKey, valueCode) {
+  const allProps = (kfNode.properties ?? []).filter((p) => isObjectProperty2(p));
+  let insertBeforeProp = null;
+  for (const prop of allProps) {
+    const key = propKeyName2(prop);
+    if (typeof key === "string" && percentageFromKey(key) > percentage) {
+      insertBeforeProp = prop;
+      break;
+    }
+  }
+  if (insertBeforeProp) {
+    ms.appendLeft(insertBeforeProp.start, `${JSON.stringify(pctKey)}: ${valueCode}, `);
+  } else {
+    const sep = allProps.length > 0 ? ", " : "";
+    ms.appendLeft(kfNode.end - 1, `${sep}${JSON.stringify(pctKey)}: ${valueCode}`);
+  }
+}
+function collapseKeyframesToFlat(ms, varsNode, source, remainingRecord) {
+  if (varsNode?.type !== "ObjectExpression") return;
+  const dropKeyframeKeys = (key) => key === "keyframes" || key === "easeEach";
+  const { entries } = preservedEntries(varsNode, source, dropKeyframeKeys, {});
+  for (const [k, v] of Object.entries(remainingRecord)) {
+    if (k !== "ease") entries.push(`${safeKey(k)}: ${valueToCode(v)}`);
+  }
+  ms.overwrite(varsNode.start, varsNode.end, `{ ${entries.join(", ")} }`);
+}
+function arrayKeyframePct(i, n) {
+  return n > 1 ? i / (n - 1) * 100 : 0;
+}
+function removeArrayKeyframe(ms, varsArg, arrNode, script, percentage) {
+  const elements = (arrNode.elements ?? []).filter(
+    (e) => !!e && e.type === "ObjectExpression"
+  );
+  const n = elements.length;
+  if (n === 0) return false;
+  let matchIdx = -1;
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < n; i++) {
+    const dist = Math.abs(arrayKeyframePct(i, n) - percentage);
+    if (dist <= PCT_TOLERANCE && dist < bestDist) {
+      matchIdx = i;
+      bestDist = dist;
+    }
+  }
+  if (matchIdx === -1) return false;
+  const remaining = elements.filter((_, i) => i !== matchIdx);
+  if (remaining.length < 2) {
+    const sole = remaining[0];
+    const record = sole ? valueNodeToRecord(sole, script) : {};
+    collapseKeyframesToFlat(ms, varsArg, script, record);
+    return true;
+  }
+  removeProp(ms, elements[matchIdx], elements);
+  return true;
+}
+function removeKeyframeFromScript(script, animationId, percentage) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  const kfPropNode = findPropertyNode2(target.call.varsArg, "keyframes");
+  if (!kfPropNode) return script;
+  if (kfPropNode.value?.type === "ArrayExpression") {
+    const ms2 = new MagicString(script);
+    return removeArrayKeyframe(ms2, target.call.varsArg, kfPropNode.value, script, percentage) ? ms2.toString() : script;
+  }
+  if (kfPropNode.value?.type !== "ObjectExpression") return script;
+  const kfNode = kfPropNode.value;
+  const match = findKfPropByPct(kfNode, percentage);
+  if (!match) return script;
+  const ms = new MagicString(script);
+  const remaining = percentagePropsOf(kfNode).filter((p) => p !== match.prop);
+  if (remaining.length < 2) {
+    const sole = remaining[0];
+    const record = sole ? valueNodeToRecord(sole.value, script) : {};
+    collapseKeyframesToFlat(ms, target.call.varsArg, script, record);
+    return ms.toString();
+  }
+  const allProps = (kfNode.properties ?? []).filter((p) => isObjectProperty2(p));
+  removeProp(ms, match.prop, allProps);
+  return ms.toString();
+}
+function removePropertyFromAnimation(script, animationId, property, from = false) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  const { call } = target;
+  const objNode = from ? call.method === "fromTo" ? call.fromArg : null : call.varsArg;
+  if (!objNode) return script;
+  const propNode = findPropertyNode2(objNode, property);
+  if (!propNode) return script;
+  const allProps = (objNode.properties ?? []).filter((p) => isObjectProperty2(p));
+  const ms = new MagicString(script);
+  removeProp(ms, propNode, allProps);
+  return ms.toString();
+}
+function removeAllKeyframesFromScript(script, animationId) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  const kfs = target.animation.keyframes?.keyframes;
+  if (!kfs || kfs.length === 0) return script;
+  const sorted = [...kfs].sort((a, b) => a.percentage - b.percentage);
+  const collapse = target.call.method === "from" ? sorted[0] : sorted[sorted.length - 1];
+  if (!collapse) return script;
+  const ms = new MagicString(script);
+  overwriteVarsArg(
+    ms,
+    target.call,
+    buildVarsObjectCode(buildCollapsedFlatVars(target.animation, collapse))
+  );
+  return ms.toString();
+}
+function buildCollapsedFlatVars(animation, collapse) {
+  const flat = { ...animation.properties };
+  for (const [k, v] of Object.entries(collapse.properties)) {
+    if (k !== "ease") flat[k] = v;
+  }
+  if (animation.duration !== void 0) flat.duration = animation.duration;
+  if (animation.ease) flat.ease = animation.ease;
+  for (const [k, v] of Object.entries(animation.extras ?? {})) {
+    if (typeof v === "number" || typeof v === "string") flat[k] = v;
+  }
+  return flat;
+}
+function buildKeyframesVarsCode(animation, fromProps, toProps, varsNode, source, setDuration) {
+  const fromEntries = Object.entries(fromProps).map(([k, v]) => `${safeKey(k)}: ${valueToCode(v)}`);
+  const toEntries = Object.entries(toProps).map(([k, v]) => `${safeKey(k)}: ${valueToCode(v)}`);
+  const easeEntry = animation.ease ? `, easeEach: ${JSON.stringify(animation.ease)}` : "";
+  const kfCode = `{ "0%": { ${fromEntries.join(", ")} }, "100%": { ${toEntries.join(", ")} }${easeEntry} }`;
+  let preserved = preservedVarsEntries(varsNode, source);
+  if (setDuration !== void 0) {
+    preserved = preserved.filter((e) => !/^\s*(immediateRender|data|duration)\s*:/.test(e));
+  }
+  const parts = [`keyframes: ${kfCode}`, ...preserved];
+  if (setDuration !== void 0) parts.push(`duration: ${Math.max(1e-3, setDuration)}`);
+  if (animation.ease) parts.push(`ease: "none"`);
+  return `{ ${parts.join(", ")} }`;
+}
+function convertToKeyframesFromScript(script, animationId, resolvedFromValues, setDuration = 1) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  const { animation, call } = target;
+  if (animation.keyframes) return script;
+  const isSet = call.method === "set";
+  const { fromProps, toProps } = resolveConversionProps(animation, resolvedFromValues);
+  const ms = new MagicString(script);
+  if (isSet && animation.global) {
+    const calleeObj = call.node.callee.object;
+    if (calleeObj?.type === "Identifier") {
+      ms.overwrite(calleeObj.start, calleeObj.end, parsed.timelineVar);
+    }
+    const args = call.node.arguments;
+    if (args.length > 0 && args.length < 3) {
+      ms.appendLeft(args[args.length - 1].end, ", 0");
+    }
+  }
+  if (call.method === "from" || call.method === "fromTo" || isSet) {
+    ms.overwrite(call.node.callee.property.start, call.node.callee.property.end, "to");
+  }
+  if (call.method === "fromTo" && call.fromArg) {
+    ms.remove(call.fromArg.start, call.varsArg.start);
+  }
+  overwriteVarsArg(
+    ms,
+    call,
+    buildKeyframesVarsCode(
+      animation,
+      fromProps,
+      toProps,
+      call.varsArg,
+      script,
+      isSet ? setDuration : void 0
+    )
+  );
+  return ms.toString();
+}
+function buildKeyframeObjectCode(keyframes, easeEach) {
+  const entries = keyframes.map((kf) => {
+    const props = Object.entries(kf.properties).map(([k, v]) => `${safeKey(k)}: ${valueToCode(v)}`);
+    if (kf.ease) props.push(`ease: ${JSON.stringify(kf.ease)}`);
+    if (kf.auto) props.push(`_auto: 1`);
+    return `${JSON.stringify(`${kf.percentage}%`)}: { ${props.join(", ")} }`;
+  });
+  if (easeEach) entries.push(`easeEach: ${JSON.stringify(easeEach)}`);
+  return `{ ${entries.join(", ")} }`;
+}
+function materializeKeyframesFromScript(script, animationId, keyframes, easeEach, resolvedSelector) {
+  if (keyframes.length === 0) return script;
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  const { call } = target;
+  const sorted = [...keyframes].sort((a, b) => a.percentage - b.percentage);
+  const kfObjCode = buildKeyframeObjectCode(sorted, easeEach);
+  const ms = new MagicString(script);
+  if (resolvedSelector) {
+    const selectorArg = call.node.arguments[0];
+    if (selectorArg)
+      ms.overwrite(selectorArg.start, selectorArg.end, JSON.stringify(resolvedSelector));
+  }
+  const kfProp = findPropertyNode2(call.varsArg, "keyframes");
+  if (kfProp) {
+    ms.overwrite(kfProp.value.start, kfProp.value.end, kfObjCode);
+  } else if (call.varsArg?.type === "ObjectExpression") {
+    const vars = call.varsArg;
+    if (vars.properties.length > 0) {
+      ms.prependLeft(vars.properties[0].start, `keyframes: ${kfObjCode}, `);
+    } else {
+      ms.appendLeft(vars.end - 1, `keyframes: ${kfObjCode}`);
+    }
+  }
+  const eachProp = findPropertyNode2(call.varsArg, "easeEach");
+  if (eachProp) {
+    const allProps = (call.varsArg.properties ?? []).filter((p) => isObjectProperty2(p));
+    removeProp(ms, eachProp, allProps);
+  }
+  return ms.toString();
+}
+function addAnimationWithKeyframesToScript(script, targetSelector, position, duration, keyframes, ease, easeEach) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return { script, id: "" };
+  const insertionPoint = findInsertionPoint(parsed);
+  if (insertionPoint === null) return { script, id: "" };
+  const sorted = [...keyframes].sort((a, b) => a.percentage - b.percentage);
+  const kfObjCode = buildKeyframeObjectCode(sorted, easeEach);
+  const varParts = [`keyframes: ${kfObjCode}`, `duration: ${valueToCode(duration)}`];
+  if (ease) varParts.push(`ease: ${JSON.stringify(ease)}`);
+  const stmtCode = `${parsed.timelineVar}.to(${JSON.stringify(targetSelector)}, { ${varParts.join(", ")} }, ${valueToCode(position)});`;
+  const ms = new MagicString(script);
+  ms.appendLeft(insertionPoint, "\n" + stmtCode);
+  const result = ms.toString();
+  const reParsed = parseGsapScriptAcornForWrite(result);
+  const newId = reParsed?.located[reParsed.located.length - 1]?.id ?? "";
+  return { script: result, id: newId };
+}
+function collectPropertyKeys(anim) {
+  const keys = /* @__PURE__ */ new Set();
+  if (anim.keyframes) {
+    for (const kf of anim.keyframes.keyframes) {
+      for (const k of Object.keys(kf.properties)) keys.add(k);
+    }
+  } else {
+    for (const k of Object.keys(anim.properties)) keys.add(k);
+  }
+  return keys;
+}
+function partitionPropertyGroups(keys) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    if (key === "transformOrigin") continue;
+    const group = classifyPropertyGroup(key);
+    let arr = groups.get(group);
+    if (!arr) {
+      arr = [];
+      groups.set(group, arr);
+    }
+    arr.push(key);
+  }
+  return groups;
+}
+function assignTransformOrigin(groupProps) {
+  let largestGroup;
+  let largestCount = 0;
+  for (const [group, props] of groupProps) {
+    if (props.length > largestCount) {
+      largestCount = props.length;
+      largestGroup = group;
+    }
+  }
+  const largest = largestGroup ? groupProps.get(largestGroup) : void 0;
+  if (largest) largest.push("transformOrigin");
+}
+function filterGroupKeyframes(kfs, propSet) {
+  const result = [];
+  for (const kf of kfs) {
+    const filtered = {};
+    for (const [k, v] of Object.entries(kf.properties)) {
+      if (propSet.has(k)) filtered[k] = v;
+    }
+    if (Object.keys(filtered).length > 0) {
+      result.push({
+        percentage: kf.percentage,
+        properties: filtered,
+        ...kf.ease ? { ease: kf.ease } : {}
+      });
+    }
+  }
+  return result;
+}
+function filterGroupProperties(properties, propSet) {
+  const result = {};
+  for (const [k, v] of Object.entries(properties)) {
+    if (propSet.has(k)) result[k] = v;
+  }
+  return result;
+}
+function addGroupAnimToScript(script, anim, propSet) {
+  if (anim.keyframes) {
+    const groupKeyframes = filterGroupKeyframes(anim.keyframes.keyframes, propSet);
+    if (groupKeyframes.length === 0) return { script, id: "" };
+    const pos = typeof anim.position === "number" ? anim.position : 0;
+    return addAnimationWithKeyframesToScript(
+      script,
+      anim.targetSelector,
+      pos,
+      anim.duration ?? 0.5,
+      groupKeyframes,
+      anim.keyframes.easeEach ?? anim.ease
+    );
+  }
+  const groupProperties = filterGroupProperties(anim.properties, propSet);
+  if (Object.keys(groupProperties).length === 0) return { script, id: "" };
+  const fromProperties = anim.method === "fromTo" && anim.fromProperties ? filterGroupProperties(anim.fromProperties, propSet) : void 0;
+  return addAnimationToScript(script, {
+    targetSelector: anim.targetSelector,
+    method: anim.method,
+    position: anim.position,
+    duration: anim.duration,
+    ease: anim.ease,
+    properties: groupProperties,
+    fromProperties,
+    extras: anim.extras
+  });
+}
+function splitIntoPropertyGroupsFromScript(script, animationId) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return { script, ids: [animationId] };
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return { script, ids: [animationId] };
+  const { animation } = target;
+  const allPropKeys = collectPropertyKeys(animation);
+  const groupProps = partitionPropertyGroups(allPropKeys);
+  if (groupProps.size <= 1) return { script, ids: [animationId] };
+  if (allPropKeys.has("transformOrigin")) assignTransformOrigin(groupProps);
+  let result = removeAnimationFromScript(script, animationId);
+  for (const [, props] of groupProps) {
+    const { script: next, id } = addGroupAnimToScript(result, animation, new Set(props));
+    if (id) result = next;
+  }
+  const reParsed = parseGsapScriptAcornForWrite(result);
+  const newIds = (reParsed?.located ?? []).filter((l) => l.animation.targetSelector === animation.targetSelector).map((l) => l.id);
+  return { script: result, ids: newIds };
+}
+function isTimelineMethodCall(expr, timelineVar, method) {
+  return expr?.type === "CallExpression" && expr.callee?.type === "MemberExpression" && isTimelineRooted(expr.callee.object, timelineVar) && expr.callee.property?.name === method;
+}
+function isAddLabelCall(expr, timelineVar, name) {
+  const firstArg = expr?.arguments?.[0];
+  return isTimelineMethodCall(expr, timelineVar, "addLabel") && firstArg?.type === "Literal" && firstArg.value === name;
+}
+function findLabelStatements(parsed, name) {
+  const targets = [];
+  acornWalk2.simple(parsed.ast, {
+    ExpressionStatement(node) {
+      if (isAddLabelCall(node.expression, parsed.timelineVar, name)) targets.push(node);
+    }
+  });
+  return targets;
+}
+function addLabelToScript(script, name, position) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const existing = findLabelStatements(parsed, name)[0];
+  if (existing) {
+    const ms2 = new MagicString(script);
+    const posArg = existing.expression.arguments?.[1];
+    if (posArg) ms2.overwrite(posArg.start, posArg.end, valueToCode(position));
+    else ms2.appendLeft(existing.expression.end - 1, `, ${valueToCode(position)}`);
+    return ms2.toString();
+  }
+  const insertionPoint = findInsertionPoint(parsed);
+  if (insertionPoint === null) return script;
+  const ms = new MagicString(script);
+  const labelCode = `${parsed.timelineVar}.addLabel(${JSON.stringify(name)}, ${valueToCode(position)});`;
+  ms.appendLeft(insertionPoint, "\n" + labelCode);
+  return ms.toString();
+}
+function removeLabelFromScript(script, name) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const targets = findLabelStatements(parsed, name);
+  if (!targets.length) return script;
+  const ms = new MagicString(script);
+  for (const target of targets) {
+    const end = target.end < script.length && script[target.end] === "\n" ? target.end + 1 : target.end;
+    ms.remove(target.start, end);
+  }
+  return ms.toString();
+}
+function removePropsByKey(ms, objNode, keys) {
+  if (objNode?.type !== "ObjectExpression") return;
+  const allProps = (objNode.properties ?? []).filter(isObjectProperty2);
+  const marked = allProps.map((p) => keys.has(propKeyName2(p) ?? ""));
+  let i = 0;
+  while (i < allProps.length) {
+    if (!marked[i]) {
+      i++;
+      continue;
+    }
+    const blockStart = i;
+    while (i < allProps.length && marked[i]) i++;
+    ms.remove(...blockRemoveRange(allProps, blockStart, i));
+  }
+}
+function blockRemoveRange(allProps, blockStart, blockEnd) {
+  if (blockStart === 0 && blockEnd === allProps.length)
+    return [allProps[0].start, allProps[allProps.length - 1].end];
+  if (blockStart === 0) return [allProps[0].start, allProps[blockEnd].start];
+  return [allProps[blockStart - 1].end, allProps[blockEnd - 1].end];
+}
+function readLastWaypointXY(mpVal) {
+  if (mpVal?.type !== "ObjectExpression") return { x: null, y: null };
+  const pathProp = findPropertyNode2(mpVal, "path");
+  if (pathProp?.value?.type !== "ArrayExpression") return { x: null, y: null };
+  const elems = pathProp.value.elements ?? [];
+  const last = elems[elems.length - 1];
+  if (last?.type !== "ObjectExpression") return { x: null, y: null };
+  return {
+    x: readNumericLiteralNode(findPropertyNode2(last, "x")?.value),
+    y: readNumericLiteralNode(findPropertyNode2(last, "y")?.value)
+  };
+}
+function readNumericLiteralNode(v) {
+  if (LITERAL_NODE_TYPES.has(v?.type) && typeof v.value === "number") return v.value;
+  if (v?.type === "UnaryExpression" && v.operator === "-" && typeof v.argument?.value === "number") {
+    return -v.argument.value;
+  }
+  return null;
+}
+function disableArcPath(ms, call) {
+  const mpProp = findPropertyNode2(call.varsArg, "motionPath");
+  if (!mpProp) return false;
+  const { x, y } = readLastWaypointXY(mpProp.value);
+  if (x === null && y === null) {
+    const allProps = (call.varsArg.properties ?? []).filter(isObjectProperty2);
+    removeProp(ms, mpProp, allProps);
+    return true;
+  }
+  const parts = [];
+  if (x !== null) parts.push(`x: ${x}`);
+  if (y !== null) parts.push(`y: ${y}`);
+  ms.overwrite(mpProp.start, mpProp.end, parts.join(", "));
+  return true;
+}
+function stripXYFromKeyframes(ms, kfPropNode) {
+  if (kfPropNode?.value?.type !== "ObjectExpression") return;
+  const xyKeys = /* @__PURE__ */ new Set(["x", "y"]);
+  for (const pctProp of (kfPropNode.value.properties ?? []).filter(isObjectProperty2)) {
+    const k = propKeyName2(pctProp);
+    if (typeof k === "string" && k.endsWith("%") && pctProp.value?.type === "ObjectExpression") {
+      removePropsByKey(ms, pctProp.value, xyKeys);
+    }
+  }
+}
+function enableArcPath(ms, call, animation, config) {
+  const waypoints = extractArcWaypoints(animation);
+  if (waypoints.length < 2) return false;
+  const segments = config.segments.length === waypoints.length - 1 ? config.segments : Array.from({ length: waypoints.length - 1 }, () => ({ curviness: 1 }));
+  const motionPathCode = buildMotionPathObjectCode({
+    waypoints,
+    segments,
+    autoRotate: config.autoRotate
+  });
+  const vars = call.varsArg;
+  if (vars?.type !== "ObjectExpression") return false;
+  const editable = (vars.properties ?? []).filter(isObjectProperty2);
+  const survivesRemoval = editable.some((p) => {
+    const k = propKeyName2(p);
+    return k !== "x" && k !== "y";
+  });
+  const sep = survivesRemoval ? ", " : "";
+  ms.appendRight(vars.start + 1, ` motionPath: ${motionPathCode}${sep}`);
+  stripXYFromKeyframes(ms, findPropertyNode2(call.varsArg, "keyframes"));
+  removePropsByKey(ms, call.varsArg, /* @__PURE__ */ new Set(["x", "y"]));
+  return true;
+}
+function setArcPathInScript(script, animationId, config) {
+  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 handled = config.enabled ? enableArcPath(ms, target.call, target.animation, config) : disableArcPath(ms, target.call);
+  return handled ? ms.toString() : script;
+}
+function updateArcSegmentInScript(script, animationId, segmentIndex, update) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  const { call, animation } = target;
+  if (!animation.arcPath?.enabled) return script;
+  const segments = [...animation.arcPath.segments];
+  const existingSeg = segments[segmentIndex];
+  if (segmentIndex < 0 || segmentIndex >= segments.length || !existingSeg) return script;
+  segments[segmentIndex] = { ...existingSeg, ...update };
+  const waypoints = extractArcWaypoints(animation);
+  if (waypoints.length < 2) return script;
+  const motionPathCode = buildMotionPathObjectCode({
+    waypoints,
+    segments,
+    autoRotate: animation.arcPath.autoRotate
+  });
+  const mpProp = findPropertyNode2(call.varsArg, "motionPath");
+  if (!mpProp) return script;
+  const ms = new MagicString(script);
+  ms.overwrite(mpProp.value.start, mpProp.value.end, motionPathCode);
+  return ms.toString();
+}
+function removeArcPathFromScript(script, animationId) {
+  return setArcPathInScript(script, animationId, {
+    enabled: false,
+    autoRotate: false,
+    segments: []
+  });
+}
+function updateAnimationSelectorInScript(script, animationId, newSelector) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const target = parsed.located.find((l) => l.id === animationId);
+  if (!target) return script;
+  const selectorArg = target.call.node.arguments?.[0];
+  if (!selectorArg) return script;
+  const ms = new MagicString(script);
+  ms.overwrite(selectorArg.start, selectorArg.end, JSON.stringify(newSelector));
+  return ms.toString();
+}
+function insertInheritedStateSetInScript(script, selector, position, properties) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return script;
+  const props = Object.entries(properties).map(([k, v]) => `${safeKey(k)}: ${valueToCode(v)}`).join(", ");
+  const code = `${parsed.timelineVar}.set(${JSON.stringify(selector)}, { ${props} }, ${position});`;
+  const ms = new MagicString(script);
+  const tlDecl = findTimelineDeclarationStatement(parsed.ast, parsed.timelineVar);
+  const firstLocated = parsed.located[0];
+  if (tlDecl) {
+    ms.appendLeft(tlDecl.end, "\n" + code);
+  } else if (firstLocated) {
+    const firstCall = firstLocated.call;
+    const exprStmt = findEnclosingExpressionStatement(firstCall.ancestors);
+    const insertAt = exprStmt?.start ?? firstCall.node.start;
+    ms.prependLeft(insertAt, code + "\n");
+  } else {
+    ms.append("\n" + code);
+  }
+  return ms.toString();
+}
+function computeForwardBaselines(matching, splitTime) {
+  const before = [];
+  const acc = {};
+  for (const anim of matching) {
+    before.push({ ...acc });
+    const pos = typeof anim.position === "number" ? anim.position : 0;
+    const dur = anim.duration ?? 0;
+    const animEnd = pos + dur;
+    if (anim.keyframes) {
+      const kfs = anim.keyframes.keyframes;
+      if (pos >= splitTime) {
+      } else if (animEnd > splitTime) {
+        for (const kf of kfs) {
+          const kfTime = pos + kf.percentage / 100 * dur;
+          if (kfTime <= splitTime) {
+            for (const [k, v] of Object.entries(kf.properties)) acc[k] = v;
+          }
+        }
+      } else {
+        const lastKf = kfs[kfs.length - 1];
+        if (lastKf) {
+          for (const [k, v] of Object.entries(lastKf.properties)) acc[k] = v;
+        }
+      }
+      continue;
+    }
+    if (animEnd <= splitTime) {
+      for (const [k, v] of Object.entries(anim.properties)) acc[k] = v;
+      continue;
+    }
+    if (pos >= splitTime) continue;
+    const progress = dur > 0 ? (splitTime - pos) / dur : 0;
+    const fromSource = anim.fromProperties ?? acc;
+    for (const [k, v] of Object.entries(anim.properties)) {
+      if (typeof v !== "number") {
+        acc[k] = v;
+        continue;
+      }
+      const fromVal = typeof fromSource[k] === "number" ? fromSource[k] : 0;
+      acc[k] = fromVal + (v - fromVal) * progress;
+    }
+  }
+  return { before, final: { ...acc } };
+}
+function buildSpanningSplit(result, anim, pos, dur, fromSource, ctx) {
+  const progress = dur > 0 ? (ctx.splitTime - pos) / dur : 0;
+  const midProps = {};
+  for (const [k, v] of Object.entries(anim.properties)) {
+    if (typeof v !== "number") {
+      midProps[k] = v;
+      continue;
+    }
+    const fromVal = typeof fromSource[k] === "number" ? fromSource[k] : 0;
+    midProps[k] = fromVal + (v - fromVal) * progress;
+  }
+  const trimmed = updateAnimationInScript(result, anim.id, {
+    duration: ctx.splitTime - pos,
+    properties: midProps
+  });
+  return addAnimationToScript(trimmed, {
+    targetSelector: ctx.newSelector,
+    method: "fromTo",
+    position: ctx.newElementStart,
+    duration: pos + dur - ctx.splitTime,
+    properties: { ...anim.properties },
+    fromProperties: { ...midProps },
+    ease: anim.ease,
+    extras: anim.extras
+  }).script;
+}
+function applyTweenSplit(result, anim, baselineBefore, ctx, skippedSelectors) {
+  const pos = typeof anim.position === "number" ? anim.position : 0;
+  const dur = anim.duration ?? 0;
+  const animEnd = pos + dur;
+  if (anim.keyframes) {
+    if (pos >= ctx.splitTime)
+      return updateAnimationSelectorInScript(result, anim.id, ctx.newSelector);
+    if (animEnd > ctx.splitTime) {
+      skippedSelectors.push(`${ctx.originalSelector} (keyframes spanning split)`);
+    }
+    return result;
+  }
+  if (animEnd <= ctx.splitTime) return result;
+  if (pos >= ctx.splitTime)
+    return updateAnimationSelectorInScript(result, anim.id, ctx.newSelector);
+  const fromSource = anim.fromProperties ?? baselineBefore;
+  return buildSpanningSplit(result, anim, pos, dur, fromSource, ctx);
+}
+function splitAnimationsInScript(script, opts) {
+  const parsed = parseGsapScriptAcornForWrite(script);
+  if (!parsed) return { script, skippedSelectors: [] };
+  const originalSelector = `#${opts.originalId}`;
+  const newSelector = `#${opts.newId}`;
+  const animations = parsed.located.map((l) => l.animation);
+  const skippedSelectors = [];
+  for (const a of animations) {
+    if (a.targetSelector !== originalSelector && a.targetSelector.includes(opts.originalId)) {
+      skippedSelectors.push(a.targetSelector);
+    }
+  }
+  const matching = animations.filter((a) => a.targetSelector === originalSelector);
+  if (matching.length === 0) return { script, skippedSelectors };
+  let result = script;
+  const newElementStart = opts.splitTime;
+  const { before: baselineBefore, final: finalInheritedProps } = computeForwardBaselines(
+    matching,
+    opts.splitTime
+  );
+  const ctx = { splitTime: opts.splitTime, originalSelector, newSelector, newElementStart };
+  for (let i = matching.length - 1; i >= 0; i--) {
+    const anim = matching[i];
+    if (!anim) continue;
+    result = applyTweenSplit(result, anim, baselineBefore[i] ?? {}, ctx, skippedSelectors);
+  }
+  if (Object.keys(finalInheritedProps).length > 0) {
+    result = insertInheritedStateSetInScript(
+      result,
+      newSelector,
+      newElementStart,
+      finalInheritedProps
+    );
+  }
+  return { script: result, skippedSelectors };
+}
+function isLoopNode(node) {
+  const t = node?.type;
+  return t === "ForStatement" || t === "ForInStatement" || t === "ForOfStatement" || t === "WhileStatement";
+}
+function isForEachStatement(node) {
+  return node?.type === "ExpressionStatement" && node.expression?.type === "CallExpression" && node.expression.callee?.property?.name === "forEach";
+}
+function findEnclosingLoopNode(ancestors) {
+  for (let i = ancestors.length - 2; i >= 0; i--) {
+    const node = ancestors[i];
+    if (isLoopNode(node) || isForEachStatement(node)) return node;
+  }
+  return null;
+}
+function loopBodyStatements(loopNode) {
+  let body;
+  if (loopNode?.type === "ExpressionStatement") {
+    const cb = loopNode.expression?.arguments?.[0];
+    body = cb?.body;
+  } else {
+    body = loopNode?.body;
+  }
+  if (body?.type !== "BlockStatement") return null;
+  return (body.body ?? []).filter((s) => s?.type === "ExpressionStatement");
+}
+function loopIndexVarName(loopNode) {
+  if (loopNode?.type === "ForStatement") {
+    const decl = loopNode.init?.declarations?.[0];
+    return typeof decl?.id?.name === "string" ? decl.id.name : null;
+  }
+  return null;
+}
+function isIndexBindingPosition(node, parent) {
+  if (parent?.type === "MemberExpression") return parent.property === node && !parent.computed;
+  if (parent?.type === "Property" || parent?.type === "ObjectProperty") {
+    return parent.key === node && !parent.computed;
+  }
+  return false;
+}
+function substituteLoopIndex(stmt, indexVar, idx, script) {
+  const base = stmt.start;
+  const src = script.slice(base, stmt.end);
+  const ranges = [];
+  acornWalk2.ancestor(stmt, {
+    Identifier(node, _state, ancestors) {
+      if (node.name !== indexVar) return;
+      if (isIndexBindingPosition(node, ancestors[ancestors.length - 2])) return;
+      ranges.push([node.start - base, node.end - base]);
+    }
+  });
+  if (ranges.length === 0) return src;
+  ranges.sort((a, b) => b[0] - a[0]);
+  let out = src;
+  for (const [s, e] of ranges) out = out.slice(0, s) + String(idx) + out.slice(e);
+  return out;
+}
+function buildUnrollReplacement(timelineVar, animation, elements) {
+  const duration = typeof animation.duration === "number" ? animation.duration : 8;
+  const ease = typeof animation.ease === "string" ? animation.ease : "none";
+  const pos = animation.position ?? 0;
+  const posCode = typeof pos === "number" ? String(pos) : JSON.stringify(pos);
+  const calls = elements.map((el) => {
+    const sorted = [...el.keyframes].sort((a, b) => a.percentage - b.percentage);
+    const kfCode = buildKeyframeObjectCode(sorted, el.easeEach);
+    return `${timelineVar}.to(${JSON.stringify(el.selector)}, { keyframes: ${kfCode}, duration: ${duration}, ease: ${JSON.stringify(ease)} }, ${posCode});`;
+  });
+  return calls.join("\n  ");
+}
+function buildUnrollCallForElement(timelineVar, animation, el) {
+  const duration = typeof animation.duration === "number" ? animation.duration : 8;
+  const ease = typeof animation.ease === "string" ? animation.ease : "none";
+  const pos = animation.position ?? 0;
+  const posCode = typeof pos === "number" ? String(pos) : JSON.stringify(pos);
+  const sorted = [...el.keyframes].sort((a, b) => a.percentage - b.percentage);
+  const kfCode = buildKeyframeObjectCode(sorted, el.easeEach);
+  return `${timelineVar}.to(${JSON.stringify(el.selector)}, { keyframes: ${kfCode}, duration: ${duration}, ease: ${JSON.stringify(ease)} }, ${posCode});`;
+}
+var REFUSE_UNROLL = /* @__PURE__ */ Symbol("refuse-unroll");
+function loopBodyRawStatements(loopNode) {
+  const body = loopNode?.type === "ExpressionStatement" ? loopNode.expression?.arguments?.[0]?.body : loopNode?.body;
+  return body?.type === "BlockStatement" ? body.body ?? [] : [];
+}
+function rebindsIndex(node, indexVar) {
+  if (node.type === "VariableDeclarator") return node.id?.name === indexVar;
+  if (node.type === "FunctionExpression" || node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression") {
+    return (node.params ?? []).some((p) => p?.name === indexVar);
+  }
+  return false;
+}
+function isShorthandIndexUse(node, indexVar) {
+  return (node.type === "Property" || node.type === "ObjectProperty") && node.shorthand === true && propKeyName2(node) === indexVar;
+}
+function hasUnsafeLoopIndexUse(stmt, indexVar) {
+  let unsafe = false;
+  acornWalk2.full(stmt, (node) => {
+    if (!unsafe && (isShorthandIndexUse(node, indexVar) || rebindsIndex(node, indexVar))) {
+      unsafe = true;
+    }
+  });
+  return unsafe;
+}
+function unrollSiblingStrategy(loopNode, targetStmt, stmts, indexVar) {
+  const siblings = stmts.filter((s) => s !== targetStmt);
+  const hasUnmodeledSibling = loopBodyRawStatements(loopNode).some(
+    (s) => s !== targetStmt && !stmts.includes(s)
+  );
+  if (siblings.length === 0 && !hasUnmodeledSibling) return "blanket";
+  if (hasUnmodeledSibling || !indexVar) return "refuse";
+  return siblings.some((s) => hasUnsafeLoopIndexUse(s, indexVar)) ? "refuse" : "preserve";
+}
+function emitUnrolledLines(stmts, targetStmt, elements, timelineVar, animation, indexVar, script) {
+  const lines = [];
+  for (let idx = 0; idx < elements.length; idx++) {
+    const el = elements[idx];
+    if (!el) continue;
+    for (const stmt of stmts) {
+      lines.push(
+        stmt === targetStmt ? buildUnrollCallForElement(timelineVar, animation, el) : substituteLoopIndex(stmt, indexVar, idx, script)
+      );
+    }
+  }
+  return lines.join("\n  ");
+}
+function buildLoopUnrollPreserving(script, timelineVar, animation, elements, loopNode, targetStmt) {
+  const stmts = loopBodyStatements(loopNode);
+  if (!stmts || !stmts.includes(targetStmt)) return null;
+  const indexVar = loopIndexVarName(loopNode);
+  const strategy = unrollSiblingStrategy(loopNode, targetStmt, stmts, indexVar);
+  if (strategy === "blanket") return null;
+  if (strategy === "refuse" || !indexVar) return REFUSE_UNROLL;
+  return emitUnrolledLines(stmts, targetStmt, elements, timelineVar, animation, indexVar, script);
+}
+function unrollDynamicAnimations(script, animationId, elements) {
+  if (elements.length === 0) return script;
+  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 loopNode = findEnclosingLoopNode(target.call.ancestors);
+  if (loopNode) {
+    const targetStmt = findEnclosingExpressionStatement(target.call.ancestors);
+    const preserving = targetStmt ? buildLoopUnrollPreserving(
+      script,
+      parsed.timelineVar,
+      target.animation,
+      elements,
+      loopNode,
+      targetStmt
+    ) : null;
+    if (preserving === REFUSE_UNROLL) return script;
+    const replacement = preserving ?? buildUnrollReplacement(parsed.timelineVar, target.animation, elements);
+    ms.overwrite(loopNode.start, loopNode.end, replacement);
+  } else {
+    const stmt = findEnclosingExpressionStatement(target.call.ancestors);
+    if (!stmt) return script;
+    const replacement = buildUnrollReplacement(parsed.timelineVar, target.animation, elements);
+    ms.overwrite(stmt.start, stmt.end, replacement);
+  }
+  return ms.toString();
+}
+export {
+  addAnimationToScript,
+  addAnimationWithKeyframesToScript,
+  addKeyframeToScript,
+  addLabelToScript,
+  convertToKeyframesFromScript,
+  materializeKeyframesFromScript,
+  removeAllKeyframesFromScript,
+  removeAnimationFromScript,
+  removeArcPathFromScript,
+  removeKeyframeFromScript,
+  removeLabelFromScript,
+  removePropertyFromAnimation,
+  scalePositionsInScript,
+  setArcPathInScript,
+  shiftPositionsInScript,
+  splitAnimationsInScript,
+  splitIntoPropertyGroupsFromScript,
+  unrollDynamicAnimations,
+  updateAnimationInScript,
+  updateArcSegmentInScript,
+  updateKeyframeInScript
+};
+//# sourceMappingURL=gsapWriterAcorn.js.map