@hyperframes/parsers 0.7.92 → 0.7.93

package/dist/gsapParserExports.js

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