@hyperframes/parsers 0.7.15

package/dist/gsapParserAcorn.js

@@ -0,0 +1,1294 @@
+// src/gsapParserAcorn.ts
+import * as acorn from "acorn";
+import * as acornWalk from "acorn-walk";
+
+// 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 editabilityForProvenance(provenance) {
+  if (!provenance || provenance.kind === "literal") return "direct";
+  if (provenance.kind === "runtime-dynamic") return "source";
+  return "unroll";
+}
+function buildArcPath(coords, curviness, autoRotate, isCubic) {
+  const first = coords[0];
+  if (coords.length < 2 || !first) return void 0;
+  const segments = [];
+  let waypoints;
+  if (isCubic && coords.length >= 4) {
+    waypoints = [first];
+    for (let i = 1; i + 2 < coords.length; i += 3) {
+      const cp1 = coords[i];
+      const cp2 = coords[i + 1];
+      const anchor = coords[i + 2];
+      if (!cp1 || !cp2 || !anchor) continue;
+      waypoints.push(anchor);
+      segments.push({ curviness, cp1, cp2 });
+    }
+  } else {
+    waypoints = coords;
+    for (let i = 0; i < waypoints.length - 1; i++) segments.push({ curviness });
+  }
+  return { arcPath: { enabled: true, autoRotate, segments }, waypoints };
+}
+
+// src/gsapInline.ts
+var SKIP_KEYS = /* @__PURE__ */ new Set(["type", "start", "end", "loc", "range", "__hfProvenance", "__hfOrder"]);
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "FunctionDeclaration"
+]);
+var GSAP_METHODS = /* @__PURE__ */ new Set(["set", "to", "from", "fromTo"]);
+var MAX_DEPTH = 8;
+var MAX_ITERS = 512;
+function isFunctionNode(node) {
+  return !!node && FUNCTION_TYPES.has(node.type);
+}
+function isNode(x) {
+  return !!x && typeof x === "object" && typeof x.type === "string";
+}
+function transformChildren(node, fn) {
+  for (const key of Object.keys(node)) {
+    if (SKIP_KEYS.has(key) || isNonValueIdentifierSlot(node, key)) continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (let i = 0; i < child.length; i++) child[i] = fn(child[i]);
+    } else {
+      node[key] = fn(child);
+    }
+  }
+}
+function cloneNode(node) {
+  return structuredClone(node);
+}
+function collectPatternNames(pattern, out) {
+  if (pattern?.type === "Identifier") out.add(pattern.name);
+  else if (pattern?.type === "AssignmentPattern") collectPatternNames(pattern.left, out);
+  else if (pattern?.type === "RestElement") collectPatternNames(pattern.argument, out);
+}
+function collectBoundNames(root) {
+  const names = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (!isNode(node)) return node;
+    if (isFunctionNode(node)) for (const p of node.params ?? []) collectPatternNames(p, names);
+    else if (node.type === "VariableDeclarator") collectPatternNames(node.id, names);
+    else if (node.type === "CatchClause") collectPatternNames(node.param, names);
+    transformChildren(node, visit);
+    return node;
+  };
+  visit(root);
+  return names;
+}
+function isNonValueIdentifierSlot(node, key) {
+  if (node.computed) return false;
+  return node.type === "MemberExpression" && key === "property" || node.type === "Property" && key === "key";
+}
+function substituteParams(node, bindings) {
+  const shadowed = collectBoundNames(node);
+  let effective = bindings;
+  if (shadowed.size > 0) {
+    effective = new Map(bindings);
+    for (const name of shadowed) effective.delete(name);
+  }
+  if (effective.size === 0) return node;
+  return replace(node, effective);
+}
+function replace(node, bindings) {
+  if (!isNode(node)) return node;
+  if (node.type === "Identifier" && bindings.has(node.name)) {
+    return cloneNode(bindings.get(node.name));
+  }
+  transformChildren(node, (child) => replace(child, bindings));
+  return node;
+}
+function tagProvenance(node, provenance) {
+  if (node && typeof node === "object") node.__hfProvenance = provenance;
+  return node;
+}
+function readProvenance(node) {
+  return node?.__hfProvenance;
+}
+function numericLiteral(value) {
+  return { type: "Literal", value, raw: String(value) };
+}
+function walkNodes(node, fn) {
+  if (!isNode(node)) return;
+  fn(node);
+  for (const key of Object.keys(node)) {
+    if (SKIP_KEYS.has(key)) continue;
+    const child = node[key];
+    if (Array.isArray(child)) for (const c of child) walkNodes(c, fn);
+    else walkNodes(child, fn);
+  }
+}
+function timelineRootName(call) {
+  let obj = call.callee?.object;
+  while (obj?.type === "CallExpression") obj = obj.callee?.object;
+  return obj?.type === "Identifier" ? obj.name : null;
+}
+function isTimelineRooted(call, timelineVar) {
+  if (timelineRootName(call) !== timelineVar) return false;
+  return call.callee?.property?.type === "Identifier" && GSAP_METHODS.has(call.callee.property.name);
+}
+function containsTimelineCall(node, timelineVar) {
+  let found = false;
+  walkNodes(node, (n) => {
+    if (n.type === "CallExpression" && isTimelineRooted(n, timelineVar)) found = true;
+  });
+  return found;
+}
+function rangeOf(node) {
+  return typeof node.start === "number" && typeof node.end === "number" ? [node.start, node.end] : void 0;
+}
+function isShapeEligible(fn) {
+  return isFunctionNode(fn) && fn.body?.type === "BlockStatement" && !(fn.params ?? []).some((p) => p.type !== "Identifier");
+}
+function callsAny(node, names) {
+  let hit = false;
+  walkNodes(node, (n) => {
+    if (n.type === "CallExpression" && n.callee?.type === "Identifier" && names.has(n.callee.name)) {
+      hit = true;
+    }
+  });
+  return hit;
+}
+function varDeclHelper(stmt) {
+  if (stmt.declarations?.length !== 1) return null;
+  const d = stmt.declarations[0];
+  return d.id?.type === "Identifier" && isShapeEligible(d.init) ? [d.id.name, d.init] : null;
+}
+function helperFromStatement(stmt) {
+  if (stmt.type === "FunctionDeclaration") {
+    return stmt.id && isShapeEligible(stmt) ? [stmt.id.name, stmt] : null;
+  }
+  if (stmt.type === "VariableDeclaration") return varDeclHelper(stmt);
+  return null;
+}
+function gatherHelperCandidates(program) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const stmt of program.body ?? []) {
+    const helper = helperFromStatement(stmt);
+    if (helper) candidates.set(helper[0], helper[1]);
+  }
+  return candidates;
+}
+function timelineBuildingNames(candidates, timelineVar) {
+  const building = /* @__PURE__ */ new Set();
+  for (const [name, fn] of candidates) {
+    if (containsTimelineCall(fn.body, timelineVar)) building.add(name);
+  }
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const [name, fn] of candidates) {
+      if (!building.has(name) && callsAny(fn.body, building)) {
+        building.add(name);
+        changed = true;
+      }
+    }
+  }
+  return building;
+}
+function bump(counts, key) {
+  counts.set(key, (counts.get(key) ?? 0) + 1);
+}
+function safelyDroppable(program, candidates) {
+  const names = new Set(candidates.keys());
+  const totalIds = /* @__PURE__ */ new Map();
+  const stmtCalls = /* @__PURE__ */ new Map();
+  walkNodes(program, (n) => {
+    if (n.type === "Identifier" && names.has(n.name)) bump(totalIds, n.name);
+    const e = n.type === "ExpressionStatement" ? n.expression : void 0;
+    if (e?.type === "CallExpression" && e.callee?.type === "Identifier" && names.has(e.callee.name)) {
+      bump(stmtCalls, e.callee.name);
+    }
+  });
+  const safe = /* @__PURE__ */ new Map();
+  for (const [name, fn] of candidates) {
+    if ((totalIds.get(name) ?? 0) === 1 + (stmtCalls.get(name) ?? 0)) safe.set(name, fn);
+  }
+  return safe;
+}
+function collectInlinableHelpers(program, timelineVar) {
+  const candidates = gatherHelperCandidates(program);
+  if (candidates.size === 0) return candidates;
+  const building = timelineBuildingNames(candidates, timelineVar);
+  for (const name of [...candidates.keys()]) if (!building.has(name)) candidates.delete(name);
+  if (candidates.size === 0) return candidates;
+  return safelyDroppable(program, candidates);
+}
+function isHelperDecl(stmt, helpers) {
+  if (stmt.type === "FunctionDeclaration") return !!stmt.id && helpers.get(stmt.id.name) === stmt;
+  if (stmt.type === "VariableDeclaration" && stmt.declarations?.length === 1) {
+    const d = stmt.declarations[0];
+    return d.id?.type === "Identifier" && helpers.get(d.id.name) === d.init;
+  }
+  return false;
+}
+function bodyStatements(node) {
+  if (node?.type === "BlockStatement") return node.body ?? [];
+  return node ? [{ type: "ExpressionStatement", expression: node }] : [];
+}
+function tagTimelineCalls(stmts, prov, ctx) {
+  for (const stmt of stmts) {
+    walkNodes(stmt, (n) => {
+      if (n.type === "CallExpression" && isTimelineRooted(n, ctx.timelineVar)) {
+        tagProvenance(n, { ...prov });
+        n.__hfOrder = ctx.order.n++;
+      }
+    });
+  }
+}
+function expandBody(bodyStmts, bindings, prov, ctx) {
+  const block = substituteParams(cloneNode({ type: "BlockStatement", body: bodyStmts }), bindings);
+  tagTimelineCalls(block.body, prov, ctx);
+  return expandStatements(block.body, { ...ctx, depth: ctx.depth + 1 });
+}
+function inlineHelper(call, ctx) {
+  const fn = ctx.helpers.get(call.callee.name);
+  const bindings = /* @__PURE__ */ new Map();
+  (fn.params ?? []).forEach((p, i) => {
+    const arg = call.arguments?.[i];
+    if (arg) bindings.set(p.name, arg);
+  });
+  const prov = {
+    kind: "helper",
+    fn: call.callee.name,
+    callSite: ++ctx.site.n,
+    sourceRange: rangeOf(call)
+  };
+  return expandBody(fn.body.body, bindings, prov, ctx);
+}
+function assignStep(update, resolve) {
+  if (update.operator === "+=") return asNum(resolve(update.right));
+  if (update.operator === "-=") {
+    const s = asNum(resolve(update.right));
+    return s === void 0 ? void 0 : -s;
+  }
+  if (update.operator === "=" && update.right?.type === "BinaryExpression") {
+    return asNum(resolve(update.right.right));
+  }
+  return void 0;
+}
+function updatedVarName(update) {
+  if (update?.type === "UpdateExpression") return update.argument?.name ?? null;
+  if (update?.type === "AssignmentExpression") return update.left?.name ?? null;
+  return null;
+}
+function loopStep(update, varName, resolve) {
+  if (updatedVarName(update) !== varName) return void 0;
+  if (update.type === "UpdateExpression") return update.operator === "++" ? 1 : -1;
+  return assignStep(update, resolve);
+}
+function asNum(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function loopSatisfied(op, x, end) {
+  if (op === "<") return x < end;
+  if (op === "<=") return x <= end;
+  if (op === ">") return x > end;
+  if (op === ">=") return x >= end;
+  return false;
+}
+function forInitVar(init) {
+  if (init?.type !== "VariableDeclaration" || init.declarations?.length !== 1) return null;
+  const d = init.declarations[0];
+  return d.id?.type === "Identifier" ? { name: d.id.name, initExpr: d.init } : null;
+}
+function parseForHeader(stmt, resolve) {
+  const iv = forInitVar(stmt.init);
+  const test = stmt.test;
+  if (!iv || test?.type !== "BinaryExpression" || test.left?.name !== iv.name) return null;
+  const start = asNum(resolve(iv.initExpr));
+  const end = asNum(resolve(test.right));
+  const step = loopStep(stmt.update, iv.name, resolve);
+  if (start === void 0 || end === void 0 || !step) return null;
+  return { v: iv.name, start, end, op: test.operator, step };
+}
+function unrollFor(stmt, ctx) {
+  const h = parseForHeader(stmt, ctx.resolve);
+  if (!h) return null;
+  const body = bodyStatements(stmt.body);
+  const out = [];
+  const site = ++ctx.site.n;
+  let iteration = 0;
+  for (let x = h.start; loopSatisfied(h.op, x, h.end); x += h.step) {
+    if (iteration >= MAX_ITERS) return null;
+    const prov = {
+      kind: "loop",
+      callSite: site,
+      iteration,
+      sourceRange: rangeOf(stmt)
+    };
+    out.push(...expandBody(body, /* @__PURE__ */ new Map([[h.v, numericLiteral(x)]]), prov, ctx));
+    iteration++;
+  }
+  return out;
+}
+function forOfVarName(left) {
+  if (left?.type === "VariableDeclaration") {
+    const id = left.declarations?.[0]?.id;
+    return id?.type === "Identifier" ? id.name : null;
+  }
+  return left?.type === "Identifier" ? left.name : null;
+}
+function unrollOverArray(elements, body, elName, idxName, range, ctx) {
+  const out = [];
+  const site = ++ctx.site.n;
+  elements.forEach((el, i) => {
+    if (!el) return;
+    const bindings = /* @__PURE__ */ new Map();
+    if (elName) bindings.set(elName, el);
+    if (idxName) bindings.set(idxName, numericLiteral(i));
+    const prov = { kind: "loop", callSite: site, iteration: i, sourceRange: range };
+    out.push(...expandBody(body, bindings, prov, ctx));
+  });
+  return out;
+}
+function unrollForOf(stmt, ctx) {
+  if (stmt.right?.type !== "ArrayExpression") return null;
+  const elName = forOfVarName(stmt.left);
+  if (!elName) return null;
+  return unrollOverArray(
+    stmt.right.elements ?? [],
+    bodyStatements(stmt.body),
+    elName,
+    null,
+    rangeOf(stmt),
+    ctx
+  );
+}
+function callbackParamNames(cb) {
+  const names = [];
+  for (const p of [cb.params?.[0], cb.params?.[1]]) {
+    if (!p) names.push(null);
+    else if (p.type !== "Identifier") return null;
+    else names.push(p.name);
+  }
+  return { el: names[0], idx: names[1] };
+}
+function isForEachCall(callee) {
+  return callee?.type === "MemberExpression" && callee.property?.name === "forEach" && callee.object?.type === "ArrayExpression";
+}
+function forEachTarget(call) {
+  if (!isForEachCall(call.callee)) return null;
+  const cb = call.arguments?.[0];
+  return isFunctionNode(cb) ? { elements: call.callee.object.elements ?? [], cb } : null;
+}
+function unrollForEach(call, ctx) {
+  const target = forEachTarget(call);
+  if (!target) return null;
+  const params = callbackParamNames(target.cb);
+  if (!params) return null;
+  return unrollOverArray(
+    target.elements,
+    bodyStatements(target.cb.body),
+    params.el,
+    params.idx,
+    rangeOf(call),
+    ctx
+  );
+}
+function expandCall(call, ctx) {
+  if (call.callee?.type === "Identifier" && ctx.helpers.has(call.callee.name)) {
+    return inlineHelper(call, ctx);
+  }
+  return unrollForEach(call, ctx);
+}
+function expandStatement(stmt, ctx) {
+  if (ctx.depth >= MAX_DEPTH) return null;
+  if (stmt.type === "ForStatement") return unrollFor(stmt, ctx);
+  if (stmt.type === "ForOfStatement") return unrollForOf(stmt, ctx);
+  if (stmt.type === "ExpressionStatement" && stmt.expression?.type === "CallExpression") {
+    return expandCall(stmt.expression, ctx);
+  }
+  return null;
+}
+function expandStatements(stmts, ctx) {
+  const out = [];
+  for (const stmt of stmts) {
+    const expanded = expandStatement(stmt, ctx);
+    if (expanded) out.push(...expanded);
+    else out.push(stmt);
+  }
+  return out;
+}
+function inlineComputedTimelines(ast, timelineVar, resolve) {
+  const helpers = collectInlinableHelpers(ast, timelineVar);
+  const ctx = {
+    helpers,
+    timelineVar,
+    resolve,
+    depth: 0,
+    site: { n: 0 },
+    order: { n: 0 }
+  };
+  const body = (ast.body ?? []).filter((stmt) => !isHelperDecl(stmt, helpers));
+  ast.body = expandStatements(body, ctx);
+}
+
+// src/gsapParserAcorn.ts
+var GSAP_METHODS2 = /* @__PURE__ */ new Set(["set", "to", "from", "fromTo"]);
+var QUERY_METHODS = /* @__PURE__ */ new Set(["querySelector", "querySelectorAll"]);
+var ITERATION_METHODS = /* @__PURE__ */ new Set(["forEach", "map"]);
+var SCOPE_NODE_TYPES = /* @__PURE__ */ new Set([
+  "Program",
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ArrowFunctionExpression"
+]);
+function resolveNode(node, scope) {
+  if (!node) return void 0;
+  if (node.type === "NumericLiteral" || node.type === "Literal" && typeof node.value === "number")
+    return node.value;
+  if (node.type === "StringLiteral" || node.type === "Literal" && typeof node.value === "string")
+    return node.value;
+  if (node.type === "BooleanLiteral" || node.type === "Literal" && typeof node.value === "boolean")
+    return node.value;
+  if (node.type === "UnaryExpression" && node.operator === "-" && node.argument) {
+    const val = resolveNode(node.argument, scope);
+    return typeof val === "number" ? -val : void 0;
+  }
+  if (node.type === "BinaryExpression") {
+    const left = resolveNode(node.left, scope);
+    const right = resolveNode(node.right, scope);
+    if (typeof left === "number" && typeof right === "number") {
+      switch (node.operator) {
+        case "+":
+          return left + right;
+        case "-":
+          return left - right;
+        case "*":
+          return left * right;
+        case "/":
+          return right !== 0 ? left / right : void 0;
+      }
+    }
+    if (typeof left === "string" && node.operator === "+") return left + String(right ?? "");
+    if (typeof right === "string" && node.operator === "+") return String(left ?? "") + right;
+  }
+  if (node.type === "Identifier" && scope.has(node.name)) {
+    return scope.get(node.name);
+  }
+  if (node.type === "TemplateLiteral" && node.expressions?.length === 0) {
+    return node.quasis?.[0]?.value?.cooked ?? void 0;
+  }
+  return void 0;
+}
+function extractLiteralValue(node, scope) {
+  return resolveNode(node, scope);
+}
+function selectorFromQueryCall(node, scope) {
+  if (node?.type !== "CallExpression") return null;
+  const callee = node.callee;
+  if (callee?.type !== "MemberExpression" || callee.property?.type !== "Identifier") return null;
+  const method = callee.property.name;
+  const argValue = resolveNode(node.arguments?.[0], scope);
+  if (typeof argValue !== "string" || argValue.length === 0) return null;
+  if (QUERY_METHODS.has(method) || method === "toArray") return argValue;
+  if (method === "getElementById") return `#${argValue}`;
+  return null;
+}
+function enclosingScopeNodeFromAncestors(ancestors) {
+  for (let i = ancestors.length - 2; i >= 0; i--) {
+    const node = ancestors[i];
+    if (node && SCOPE_NODE_TYPES.has(node.type)) return node;
+  }
+  return null;
+}
+function scopeChainFromAncestors(ancestors) {
+  const chain = [];
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const node = ancestors[i];
+    if (node && SCOPE_NODE_TYPES.has(node.type)) chain.push(node);
+  }
+  return chain;
+}
+function addBinding(bindings, scopeNode, name, selector) {
+  let scoped = bindings.get(scopeNode);
+  if (!scoped) {
+    scoped = /* @__PURE__ */ new Map();
+    bindings.set(scopeNode, scoped);
+  }
+  if (!scoped.has(name)) scoped.set(name, selector);
+}
+function lookupBindingFromAncestors(name, ancestors, bindings) {
+  for (const scopeNode of scopeChainFromAncestors(ancestors)) {
+    const selector = bindings.get(scopeNode)?.get(name);
+    if (selector !== void 0) return selector;
+  }
+  return bindings.get(null)?.get(name) ?? null;
+}
+function isFunctionNode2(node) {
+  return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression" || node?.type === "FunctionDeclaration";
+}
+function resolveCollectionSelector(node, ancestors, scope, bindings) {
+  if (node?.type === "Identifier")
+    return lookupBindingFromAncestors(node.name, ancestors, bindings);
+  if (node?.type === "CallExpression") return selectorFromQueryCall(node, scope);
+  return null;
+}
+function collectScopeBindings(ast) {
+  const bindings = /* @__PURE__ */ new Map();
+  acornWalk.simple(ast, {
+    VariableDeclarator(node) {
+      const name = node.id?.name;
+      const init = node.init;
+      if (name && init) {
+        const val = resolveNode(init, bindings);
+        if (val !== void 0) bindings.set(name, val);
+      }
+    }
+  });
+  return bindings;
+}
+function collectTargetBindings(ast, scope) {
+  const bindings = /* @__PURE__ */ new Map();
+  acornWalk.ancestor(ast, {
+    VariableDeclarator(node, _, ancestors) {
+      const name = node.id?.name;
+      const selector = selectorFromQueryCall(node.init, scope);
+      if (name && selector !== null) {
+        addBinding(bindings, enclosingScopeNodeFromAncestors(ancestors), name, selector);
+      }
+    },
+    AssignmentExpression(node, _, ancestors) {
+      const left = node.left;
+      const selector = selectorFromQueryCall(node.right, scope);
+      if (left?.type === "Identifier" && selector !== null) {
+        addBinding(bindings, enclosingScopeNodeFromAncestors(ancestors), left.name, selector);
+      }
+    }
+  });
+  acornWalk.ancestor(ast, {
+    // fallow-ignore-next-line complexity
+    CallExpression(node, _, ancestors) {
+      const callee = node.callee;
+      if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier" && ITERATION_METHODS.has(callee.property.name)) {
+        const collectionSelector = resolveCollectionSelector(
+          callee.object,
+          ancestors,
+          scope,
+          bindings
+        );
+        const fn = node.arguments?.[0];
+        const param = fn?.params?.[0];
+        if (collectionSelector && param?.type === "Identifier" && isFunctionNode2(fn)) {
+          addBinding(bindings, fn, param.name, collectionSelector);
+        }
+      }
+    }
+  });
+  return bindings;
+}
+function resolveTargetSelector(node, ancestors, scope, bindings) {
+  if (!node) return null;
+  if (node.type === "StringLiteral" || node.type === "Literal") {
+    return typeof node.value === "string" ? node.value : null;
+  }
+  if (node.type === "Identifier") {
+    return lookupBindingFromAncestors(node.name, ancestors, bindings);
+  }
+  if (node.type === "CallExpression") {
+    return selectorFromQueryCall(node, scope);
+  }
+  if (node.type === "ArrayExpression") {
+    const parts = node.elements.map((el) => resolveTargetSelector(el, ancestors, scope, bindings)).filter((s) => typeof s === "string" && s.length > 0);
+    return parts.length > 0 ? parts.join(", ") : null;
+  }
+  if (node.type === "MemberExpression" && node.object?.type === "Identifier") {
+    return lookupBindingFromAncestors(node.object.name, ancestors, bindings);
+  }
+  return null;
+}
+function isObjectProperty(prop) {
+  return prop?.type === "ObjectProperty" || prop?.type === "Property";
+}
+function propKeyName(prop) {
+  return prop?.key?.name ?? prop?.key?.value;
+}
+function findPropertyNode(varsArgNode, key) {
+  if (varsArgNode?.type !== "ObjectExpression") return void 0;
+  for (const prop of varsArgNode.properties ?? []) {
+    if (!isObjectProperty(prop)) continue;
+    if (propKeyName(prop) === key) return prop.value;
+  }
+  return void 0;
+}
+function extractRawPropertySource(varsArgNode, key, source) {
+  const node = findPropertyNode(varsArgNode, key);
+  return node ? source.slice(node.start, node.end) : void 0;
+}
+function objectExpressionToRecord(node, scope, source) {
+  const result = {};
+  if (node?.type !== "ObjectExpression") return result;
+  for (const prop of node.properties ?? []) {
+    if (!isObjectProperty(prop)) continue;
+    const key = prop.key?.name ?? prop.key?.value;
+    if (!key) continue;
+    const resolved = resolveNode(prop.value, scope);
+    if (resolved !== void 0) {
+      result[key] = resolved;
+    } else {
+      result[key] = `__raw:${source.slice(prop.value.start, prop.value.end)}`;
+    }
+  }
+  return result;
+}
+function isGsapTimelineCall(node) {
+  return node?.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.name === "gsap" && node.callee.property?.name === "timeline";
+}
+function extractTimelineDefaults(callNode, scope) {
+  const arg = callNode.arguments?.[0];
+  if (!arg || arg.type !== "ObjectExpression") return void 0;
+  const defaultsProp = arg.properties?.find(
+    (p) => isObjectProperty(p) && propKeyName(p) === "defaults"
+  );
+  if (!defaultsProp?.value || defaultsProp.value.type !== "ObjectExpression") return void 0;
+  const result = {};
+  for (const prop of defaultsProp.value.properties ?? []) {
+    if (!isObjectProperty(prop)) continue;
+    const key = propKeyName(prop);
+    const val = resolveNode(prop.value, scope);
+    if (key === "ease" && typeof val === "string") result.ease = val;
+    if (key === "duration" && typeof val === "number") result.duration = val;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function findTimelineVar(ast, scope) {
+  let timelineVar = null;
+  let timelineCount = 0;
+  let defaults;
+  const emptyScope = scope ?? /* @__PURE__ */ new Map();
+  acornWalk.simple(ast, {
+    VariableDeclarator(node) {
+      if (isGsapTimelineCall(node.init)) {
+        timelineCount += 1;
+        if (!timelineVar) {
+          timelineVar = node.id?.name ?? null;
+          defaults = extractTimelineDefaults(node.init, emptyScope);
+        }
+      }
+    },
+    AssignmentExpression(node) {
+      if (isGsapTimelineCall(node.right)) {
+        timelineCount += 1;
+        if (!timelineVar) {
+          const left = node.left;
+          if (left?.type === "Identifier") timelineVar = left.name;
+          defaults = extractTimelineDefaults(node.right, emptyScope);
+        }
+      }
+    }
+  });
+  return { timelineVar, timelineCount, defaults };
+}
+var BUILTIN_VAR_KEYS = /* @__PURE__ */ new Set(["duration", "ease", "delay"]);
+var DROPPED_VAR_KEYS = /* @__PURE__ */ new Set(["onComplete", "onStart", "onUpdate", "onRepeat"]);
+var EXTRAS_KEYS = /* @__PURE__ */ new Set([
+  "stagger",
+  "yoyo",
+  "repeat",
+  "repeatDelay",
+  "snap",
+  "overwrite",
+  "immediateRender"
+]);
+function isTimelineRootedCall(callNode, timelineVar) {
+  let obj = callNode.callee?.object;
+  while (obj?.type === "CallExpression") {
+    obj = obj.callee?.object;
+  }
+  return obj?.type === "Identifier" && obj.name === timelineVar;
+}
+function findAllTweenCalls(ast, timelineVar, scope, targetBindings) {
+  const results = [];
+  function visit(node, ancestors) {
+    if (!node || typeof node !== "object") return;
+    const nodeAncestors = [...ancestors, node];
+    if (node.type === "CallExpression") {
+      const callee = node.callee;
+      const gsapSetArg = node.arguments?.[0];
+      const isGlobalSet = callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.name === "gsap" && callee.property?.type === "Identifier" && callee.property.name === "set" && (gsapSetArg?.type === "StringLiteral" || gsapSetArg?.type === "Literal" && typeof gsapSetArg.value === "string");
+      if (callee?.type === "MemberExpression" && callee.property?.type === "Identifier" && (isTimelineRootedCall(node, timelineVar) || isGlobalSet) && GSAP_METHODS2.has(callee.property.name)) {
+        const method = callee.property.name;
+        const args = node.arguments;
+        const selectorValue = args.length >= 1 ? resolveTargetSelector(args[0], nodeAncestors, scope, targetBindings) ?? "__unresolved__" : "__unresolved__";
+        if (method === "fromTo" && args.length >= 3) {
+          results.push({
+            node,
+            ancestors: nodeAncestors,
+            method: "fromTo",
+            selector: selectorValue,
+            fromArg: args[1],
+            varsArg: args[2],
+            positionArg: args[3]
+          });
+        } else if (method !== "fromTo" && args.length >= 2) {
+          results.push({
+            node,
+            ancestors: nodeAncestors,
+            method,
+            selector: selectorValue,
+            varsArg: args[1],
+            positionArg: args[2],
+            ...isGlobalSet ? { global: true } : {}
+          });
+        }
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "type" || key === "start" || key === "end" || key === "loc") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && item.type) visit(item, nodeAncestors);
+        }
+      } else if (child && typeof child === "object" && child.type) {
+        visit(child, nodeAncestors);
+      }
+    }
+  }
+  visit(ast, []);
+  return results;
+}
+var PERCENTAGE_KEY_RE = /^(\d+(?:\.\d+)?)%$/;
+function tryResolveStringProp(propValue, scope) {
+  const val = resolveNode(propValue, scope);
+  return typeof val === "string" ? val : void 0;
+}
+function parsePercentageKeyframes(node, scope, source) {
+  const keyframes = [];
+  let ease;
+  let easeEach;
+  for (const prop of node.properties ?? []) {
+    if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+    const key = prop.key?.value ?? prop.key?.name;
+    if (typeof key !== "string") continue;
+    const pctMatch = PERCENTAGE_KEY_RE.exec(key);
+    if (pctMatch) {
+      const percentage = Number.parseFloat(pctMatch[1] ?? "0");
+      const record = objectExpressionToRecord(prop.value, scope, source);
+      const properties = {};
+      let kfEase;
+      for (const [k, v] of Object.entries(record)) {
+        if (k === "ease" && typeof v === "string") {
+          kfEase = v;
+        } else if (typeof v === "number" || typeof v === "string") {
+          properties[k] = v;
+        }
+      }
+      keyframes.push({ percentage, properties, ...kfEase ? { ease: kfEase } : {} });
+    } else if (key === "ease") {
+      ease = tryResolveStringProp(prop.value, scope) ?? ease;
+    } else if (key === "easeEach") {
+      easeEach = tryResolveStringProp(prop.value, scope) ?? easeEach;
+    }
+  }
+  keyframes.sort((a, b) => a.percentage - b.percentage);
+  return {
+    format: "percentage",
+    keyframes,
+    ...ease ? { ease } : {},
+    ...easeEach ? { easeEach } : {}
+  };
+}
+function computeKeyframesTotalDuration(varsNode, scope, source) {
+  const kfNode = (varsNode.properties ?? []).find(
+    (p) => (p.key?.name ?? p.key?.value) === "keyframes"
+  )?.value;
+  if (!kfNode || kfNode.type !== "ArrayExpression") return void 0;
+  let total = 0;
+  for (const el of kfNode.elements ?? []) {
+    if (!el || el.type !== "ObjectExpression") continue;
+    const r = objectExpressionToRecord(el, scope, source);
+    if (typeof r.duration === "number") total += r.duration;
+  }
+  return total > 0 ? total : void 0;
+}
+function parseObjectArrayKeyframes(node, scope, source) {
+  const elements = node.elements ?? [];
+  const raw = [];
+  for (const el of elements) {
+    if (!el || el.type !== "ObjectExpression") continue;
+    const record = objectExpressionToRecord(el, scope, source);
+    const properties = {};
+    let duration;
+    let ease;
+    for (const [k, v] of Object.entries(record)) {
+      if (k === "duration" && typeof v === "number") {
+        duration = v;
+      } else if (k === "ease" && typeof v === "string") {
+        ease = v;
+      } else if (typeof v === "number" || typeof v === "string") {
+        properties[k] = v;
+      }
+    }
+    raw.push({ properties, duration, ease });
+  }
+  const totalDuration = raw.reduce((sum, r) => sum + (r.duration ?? 0), 0);
+  const keyframes = [];
+  if (totalDuration > 0) {
+    let cumulative = 0;
+    for (const entry of raw) {
+      cumulative += entry.duration ?? 0;
+      const percentage = Math.round(cumulative / totalDuration * 100);
+      keyframes.push({
+        percentage,
+        properties: entry.properties,
+        ...entry.ease ? { ease: entry.ease } : {}
+      });
+    }
+  } else {
+    for (let i = 0; i < raw.length; i++) {
+      const entry = raw[i];
+      if (!entry) continue;
+      const percentage = raw.length > 1 ? Math.round(i / (raw.length - 1) * 100) : 0;
+      keyframes.push({
+        percentage,
+        properties: entry.properties,
+        ...entry.ease ? { ease: entry.ease } : {}
+      });
+    }
+  }
+  return { format: "object-array", keyframes };
+}
+function parseSimpleArrayKeyframes(node, scope) {
+  const arrayProps = /* @__PURE__ */ new Map();
+  let ease;
+  let easeEach;
+  for (const prop of node.properties ?? []) {
+    if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+    const key = prop.key?.name ?? prop.key?.value;
+    if (typeof key !== "string") continue;
+    if (prop.value?.type === "ArrayExpression") {
+      const values = [];
+      for (const el of prop.value.elements ?? []) {
+        const val = resolveNode(el, scope);
+        if (typeof val === "number" || typeof val === "string") {
+          values.push(val);
+        }
+      }
+      if (values.length > 0) arrayProps.set(key, values);
+    } else if (key === "ease") {
+      ease = tryResolveStringProp(prop.value, scope) ?? ease;
+    } else if (key === "easeEach") {
+      easeEach = tryResolveStringProp(prop.value, scope) ?? easeEach;
+    }
+  }
+  const maxLen = Math.max(...[...arrayProps.values()].map((a) => a.length), 0);
+  const keyframes = [];
+  for (let i = 0; i < maxLen; i++) {
+    const percentage = maxLen > 1 ? Math.round(i / (maxLen - 1) * 100) : 0;
+    const properties = {};
+    for (const [key, values] of arrayProps) {
+      if (i < values.length) properties[key] = values[i];
+    }
+    keyframes.push({ percentage, properties });
+  }
+  return {
+    format: "simple-array",
+    keyframes,
+    ...ease ? { ease } : {},
+    ...easeEach ? { easeEach } : {}
+  };
+}
+function parseKeyframesNode(node, scope, source) {
+  if (!node) return void 0;
+  if (node.type === "ArrayExpression") {
+    return parseObjectArrayKeyframes(node, scope, source);
+  }
+  if (node.type !== "ObjectExpression") return void 0;
+  const props = node.properties ?? [];
+  let hasPercentageKey = false;
+  let hasArrayValue = false;
+  for (const prop of props) {
+    if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+    const key = prop.key?.value ?? prop.key?.name;
+    if (typeof key === "string" && PERCENTAGE_KEY_RE.test(key)) {
+      hasPercentageKey = true;
+      break;
+    }
+    if (prop.value?.type === "ArrayExpression") {
+      hasArrayValue = true;
+    }
+  }
+  if (hasPercentageKey) return parsePercentageKeyframes(node, scope, source);
+  if (hasArrayValue) return parseSimpleArrayKeyframes(node, scope);
+  return void 0;
+}
+function parseMotionPathNode(node, scope, source) {
+  if (!node) return void 0;
+  let pathNode;
+  let autoRotate = false;
+  let curviness = 1;
+  let isCubic = false;
+  if (node.type === "ObjectExpression") {
+    for (const prop of node.properties ?? []) {
+      if (!isObjectProperty(prop)) continue;
+      const key = propKeyName(prop);
+      if (key === "path") pathNode = prop.value;
+      else if (key === "autoRotate") {
+        const val = resolveNode(prop.value, scope);
+        autoRotate = typeof val === "number" ? val : val === true;
+      } else if (key === "curviness") {
+        const val = resolveNode(prop.value, scope);
+        if (typeof val === "number") curviness = val;
+      } else if (key === "type") {
+        const val = resolveNode(prop.value, scope);
+        if (val === "cubic") isCubic = true;
+      }
+    }
+  } else if (node.type === "ArrayExpression") {
+    pathNode = node;
+  }
+  if (!pathNode || pathNode.type !== "ArrayExpression") return void 0;
+  const elements = pathNode.elements ?? [];
+  const coords = [];
+  for (const elem of elements) {
+    if (!elem || elem.type !== "ObjectExpression") continue;
+    const rec = objectExpressionToRecord(elem, scope, source);
+    const x = typeof rec.x === "number" ? rec.x : void 0;
+    const y = typeof rec.y === "number" ? rec.y : void 0;
+    if (x !== void 0 && y !== void 0) coords.push({ x, y });
+  }
+  return buildArcPath(coords, curviness, autoRotate, isCubic);
+}
+function tweenCallToAnimation(call, scope, source) {
+  const vars = objectExpressionToRecord(call.varsArg, scope, source);
+  const properties = {};
+  const extras = {};
+  let keyframesData;
+  let hasUnresolvedKeyframes = false;
+  let motionPathResult;
+  for (const [key, val] of Object.entries(vars)) {
+    if (BUILTIN_VAR_KEYS.has(key)) continue;
+    if (DROPPED_VAR_KEYS.has(key)) continue;
+    if (key === "keyframes") {
+      const kfNode = findPropertyNode(call.varsArg, "keyframes");
+      keyframesData = parseKeyframesNode(kfNode, scope, source);
+      if (!keyframesData && kfNode) hasUnresolvedKeyframes = true;
+      continue;
+    }
+    if (key === "motionPath") {
+      const mpNode = findPropertyNode(call.varsArg, "motionPath");
+      motionPathResult = parseMotionPathNode(mpNode, scope, source);
+      continue;
+    }
+    if (key === "easeEach") continue;
+    if (EXTRAS_KEYS.has(key)) {
+      const rawSource = extractRawPropertySource(call.varsArg, key, source);
+      if (rawSource !== void 0) {
+        extras[key] = `__raw:${rawSource}`;
+      } else if (val !== void 0) {
+        extras[key] = val;
+      }
+      continue;
+    }
+    if (typeof val === "number" || typeof val === "string") {
+      properties[key] = val;
+    }
+  }
+  if (keyframesData && typeof vars.easeEach === "string") {
+    keyframesData.easeEach = vars.easeEach;
+  }
+  if (motionPathResult) {
+    const { waypoints } = motionPathResult;
+    if (!keyframesData) {
+      const kf = waypoints.map((wp, i) => ({
+        percentage: waypoints.length > 1 ? Math.round(i / (waypoints.length - 1) * 100) : 0,
+        properties: { x: wp.x, y: wp.y }
+      }));
+      keyframesData = { format: "percentage", keyframes: kf };
+    } else {
+      const kfs = keyframesData.keyframes;
+      if (kfs.length === waypoints.length) {
+        for (let i = 0; i < kfs.length; i++) {
+          const kf = kfs[i];
+          const wp = waypoints[i];
+          if (kf && wp) {
+            kf.properties.x = wp.x;
+            kf.properties.y = wp.y;
+          }
+        }
+      }
+    }
+  }
+  let fromProperties;
+  if (call.method === "fromTo" && call.fromArg) {
+    fromProperties = {};
+    const fromVars = objectExpressionToRecord(call.fromArg, scope, source);
+    for (const [key, val] of Object.entries(fromVars)) {
+      if (typeof val === "number" || typeof val === "string") {
+        fromProperties[key] = val;
+      }
+    }
+  }
+  const hasPositionArg = !!call.positionArg;
+  const posVal = hasPositionArg ? extractLiteralValue(call.positionArg, scope) : 0;
+  const position = typeof posVal === "number" ? posVal : typeof posVal === "string" ? posVal : 0;
+  let duration = typeof vars.duration === "number" ? vars.duration : void 0;
+  const ease = typeof vars.ease === "string" ? vars.ease : void 0;
+  if (duration === void 0 && keyframesData) {
+    duration = computeKeyframesTotalDuration(call.varsArg, scope, source);
+  }
+  const anim = {
+    targetSelector: call.selector,
+    method: call.method,
+    position,
+    properties,
+    fromProperties,
+    duration,
+    ease
+  };
+  if (!hasPositionArg) anim.implicitPosition = true;
+  let group = classifyTweenPropertyGroup(properties);
+  if (!group && keyframesData) {
+    const kfProps = {};
+    for (const kf of keyframesData.keyframes) {
+      for (const k of Object.keys(kf.properties)) kfProps[k] = true;
+    }
+    group = classifyTweenPropertyGroup(kfProps);
+  }
+  if (group) anim.propertyGroup = group;
+  if (call.global) anim.global = true;
+  if (Object.keys(extras).length > 0) anim.extras = extras;
+  if (keyframesData) anim.keyframes = keyframesData;
+  if (motionPathResult) anim.arcPath = motionPathResult.arcPath;
+  if (hasUnresolvedKeyframes) anim.hasUnresolvedKeyframes = true;
+  if (call.selector === "__unresolved__") anim.hasUnresolvedSelector = true;
+  const provenance = readProvenance(call.node);
+  if (provenance) anim.provenance = provenance;
+  return anim;
+}
+var GSAP_DEFAULT_DURATION = 0.5;
+function resolvePositionString(pos, cursor, prevStart) {
+  const trimmed = pos.trim();
+  if (trimmed === "") return cursor;
+  if (trimmed.startsWith("+=")) {
+    const n2 = Number.parseFloat(trimmed.slice(2));
+    return Number.isFinite(n2) ? cursor + n2 : null;
+  }
+  if (trimmed.startsWith("-=")) {
+    const n2 = Number.parseFloat(trimmed.slice(2));
+    return Number.isFinite(n2) ? cursor - n2 : null;
+  }
+  if (trimmed === "<") return prevStart;
+  if (trimmed === ">") return cursor;
+  if (trimmed.startsWith("<")) {
+    const n2 = Number.parseFloat(trimmed.slice(1));
+    return Number.isFinite(n2) ? prevStart + n2 : null;
+  }
+  if (trimmed.startsWith(">")) {
+    const n2 = Number.parseFloat(trimmed.slice(1));
+    return Number.isFinite(n2) ? cursor + n2 : null;
+  }
+  const n = Number.parseFloat(trimmed);
+  return Number.isFinite(n) ? n : null;
+}
+function applyTimelineDefaults(anims, defaults) {
+  if (!defaults) return;
+  for (const anim of anims) {
+    if (anim.method === "set") continue;
+    if (anim.duration === void 0 && defaults.duration !== void 0) {
+      anim.duration = defaults.duration;
+    }
+    if (anim.ease === void 0 && defaults.ease !== void 0) {
+      anim.ease = defaults.ease;
+    }
+  }
+}
+function resolveTimelinePositions(anims) {
+  let cursor = 0;
+  let prevStart = 0;
+  for (const anim of anims) {
+    if (anim.method === "set" && anim.global) {
+      anim.resolvedStart = 0;
+      continue;
+    }
+    const duration = anim.method === "set" ? 0 : anim.duration ?? GSAP_DEFAULT_DURATION;
+    let start;
+    if (anim.implicitPosition) {
+      start = cursor;
+    } else if (typeof anim.position === "number") {
+      start = anim.position;
+    } else if (typeof anim.position === "string") {
+      start = resolvePositionString(anim.position, cursor, prevStart);
+    } else {
+      start = cursor;
+    }
+    if (start != null) {
+      anim.resolvedStart = Math.max(0, start);
+      prevStart = anim.resolvedStart;
+      cursor = Math.max(cursor, anim.resolvedStart + duration);
+    }
+  }
+}
+function compareByLoc(a, b) {
+  const aLoc = a.node.callee?.property?.loc?.start;
+  const bLoc = b.node.callee?.property?.loc?.start;
+  if (!aLoc || !bLoc) return 0;
+  return aLoc.line - bLoc.line || aLoc.column - bLoc.column;
+}
+function compareCallOrder(a, b) {
+  const ao = a.node.__hfOrder;
+  const bo = b.node.__hfOrder;
+  if (ao === void 0 && bo === void 0) return compareByLoc(a, b);
+  if (ao === void 0) return -1;
+  if (bo === void 0) return 1;
+  return ao - bo;
+}
+function sortBySourcePosition(calls) {
+  calls.sort(compareCallOrder);
+}
+function assignStableIds(anims) {
+  const counts = /* @__PURE__ */ new Map();
+  return anims.map((anim) => {
+    const posKey = typeof anim.position === "number" ? String(Math.round(anim.position * 1e3)) : String(anim.position);
+    const groupSuffix = anim.propertyGroup ? `-${anim.propertyGroup}` : "";
+    const base = `${anim.targetSelector}-${anim.method}-${posKey}${groupSuffix}`;
+    const count = (counts.get(base) ?? 0) + 1;
+    counts.set(base, count);
+    const id = count === 1 ? base : `${base}-${count}`;
+    return { ...anim, id };
+  });
+}
+function parseGsapScriptAcornForWrite(script) {
+  try {
+    const ast = acorn.parse(script, {
+      ecmaVersion: "latest",
+      sourceType: "script",
+      locations: true
+    });
+    const scope = collectScopeBindings(ast);
+    const targetBindings = collectTargetBindings(ast, scope);
+    const detection = findTimelineVar(ast, scope);
+    const timelineVar = detection.timelineVar ?? "tl";
+    const calls = findAllTweenCalls(ast, timelineVar, scope, targetBindings);
+    sortBySourcePosition(calls);
+    const rawAnims = calls.map((call) => tweenCallToAnimation(call, scope, script));
+    applyTimelineDefaults(rawAnims, detection.defaults);
+    resolveTimelinePositions(rawAnims);
+    const animations = assignStableIds(rawAnims);
+    const located = calls.map((call, i) => ({
+      id: animations[i].id,
+      call,
+      animation: animations[i]
+    }));
+    return { ast, timelineVar, hasTimeline: detection.timelineVar !== null, located };
+  } catch {
+    return null;
+  }
+}
+function parseGsapScriptAcorn(script) {
+  try {
+    const ast = acorn.parse(script, {
+      ecmaVersion: "latest",
+      sourceType: "script",
+      locations: true
+    });
+    const scope = collectScopeBindings(ast);
+    const detection = findTimelineVar(ast, scope);
+    const timelineVar = detection.timelineVar ?? "tl";
+    try {
+      inlineComputedTimelines(ast, timelineVar, (node) => resolveNode(node, scope));
+    } catch {
+    }
+    const targetBindings = collectTargetBindings(ast, scope);
+    const calls = findAllTweenCalls(ast, timelineVar, scope, targetBindings);
+    sortBySourcePosition(calls);
+    const rawAnims = calls.map((call) => tweenCallToAnimation(call, scope, script));
+    applyTimelineDefaults(rawAnims, detection.defaults);
+    resolveTimelinePositions(rawAnims);
+    const animations = assignStableIds(rawAnims);
+    const timelineMatch = script.match(
+      new RegExp(
+        `^[\\s\\S]*?(?:const|let|var)\\s+${timelineVar}\\s*=\\s*gsap\\.timeline\\s*\\([^)]*\\)\\s*;?`
+      )
+    );
+    const preamble = timelineMatch?.[0] ?? `const ${timelineVar} = gsap.timeline({ paused: true });`;
+    const lastCallIdx = script.lastIndexOf(`${timelineVar}.`);
+    let postamble = "";
+    if (lastCallIdx !== -1) {
+      const afterLast = script.slice(lastCallIdx);
+      const endOfCall = afterLast.indexOf(";");
+      if (endOfCall !== -1) {
+        postamble = script.slice(lastCallIdx + endOfCall + 1).trim();
+      }
+    }
+    const result = { animations, timelineVar, preamble, postamble };
+    if (detection.timelineCount > 1) result.multipleTimelines = true;
+    if (detection.timelineCount > 0 && detection.timelineVar === null)
+      result.unsupportedTimelinePattern = true;
+    return result;
+  } catch {
+    return { animations: [], timelineVar: "tl", preamble: "", postamble: "" };
+  }
+}
+function extractGsapLabels(script) {
+  try {
+    const ast = acorn.parse(script, {
+      ecmaVersion: "latest",
+      sourceType: "script",
+      locations: true
+    });
+    const scope = collectScopeBindings(ast);
+    const detection = findTimelineVar(ast, scope);
+    const timelineVar = detection.timelineVar ?? "tl";
+    const labels = [];
+    acornWalk.simple(ast, {
+      // fallow-ignore-next-line complexity
+      ExpressionStatement(node) {
+        const expr = node.expression;
+        if (!expr || expr.type !== "CallExpression") return;
+        const callee = expr.callee;
+        if (callee?.type !== "MemberExpression" || callee.object?.name !== timelineVar || callee.property?.name !== "addLabel")
+          return;
+        const args = expr.arguments ?? [];
+        const nameNode = args[0];
+        const posNode = args[1];
+        if (nameNode?.type !== "Literal" || typeof nameNode.value !== "string") return;
+        if (!posNode) return;
+        const pos = resolveNode(posNode, scope);
+        if (typeof pos !== "number" || !Number.isFinite(pos)) return;
+        labels.push({ name: nameNode.value, position: pos });
+      }
+    });
+    return labels;
+  } catch {
+    return [];
+  }
+}
+export {
+  buildArcPath,
+  editabilityForProvenance,
+  extractGsapLabels,
+  parseGsapScriptAcorn,
+  parseGsapScriptAcornForWrite
+};
+//# sourceMappingURL=gsapParserAcorn.js.map