@pixodesk/svg-animator-core 1.0.43 → 1.0.45

package/dist/{chunk-BOTZI36B.js → chunk-YVKMPBHE.js}

@@ -563,7 +563,7 @@ var px = {
 };
 
 // src/version/PxSchemaVersion.ts
-var PX_WIRE_SCHEMA_VERSION = "1.1";
+var PX_WIRE_SCHEMA_VERSION = "1.2";
 
 // src/version/PxWireVersion.ts
 var PX_WIRE_VERSION_KEY = "version";
@@ -632,7 +632,46 @@ var PxWireStepKind = /* @__PURE__ */ ((PxWireStepKind2) => {
   return PxWireStepKind2;
 })(PxWireStepKind || {});
 var PX_WIRE_BASELINE_VERSION = "1.1";
-var PX_WIRE_STEPS = [];
+var PX_WIRE_STEPS = [
+  {
+    from: "1.1",
+    to: "1.2",
+    reason: "The trigger block became two axes: `start` says what STARTS an animation, `offScreen` + `visibilityThreshold` + `visibilityDebounce` say whether it may RUN. `scrollIntoView` is no longer a start value \u2014 it is what `start: 'load'` behind the default gate already means \u2014 and `outAction` split into `offScreen` (scroll) and `mouseOut` (hover), because one field meant three things.",
+    kind: "converted" /* converted */,
+    up: upTriggerTwoAxes
+    // No `down`: 1.2 can express combinations 1.1 could not ("start on click AND pause when
+    // scrolled away"), so the mapping is not invertible.
+  }
+];
+function upTriggerTwoAxes(doc) {
+  const animator = doc["animator"];
+  if (!animator || typeof animator !== "object") return;
+  const timeline = animator["timeline"];
+  const holder = timeline && typeof timeline === "object" ? timeline : animator;
+  const trigger = holder["trigger"];
+  if (!trigger || typeof trigger !== "object") return;
+  const t = trigger;
+  const startOn = t["startOn"];
+  const outAction = t["outAction"];
+  delete t["startOn"];
+  delete t["outAction"];
+  if (startOn === "scrollIntoView") {
+    if (outAction !== void 0) t["offScreen"] = outAction;
+  } else {
+    if (startOn === "programmatic") t["start"] = "none";
+    else if (startOn !== void 0) t["start"] = startOn;
+    if (startOn === "mouseOver" && outAction !== void 0) t["mouseOut"] = outAction;
+    if (t["offScreen"] === void 0) t["offScreen"] = "continue";
+  }
+  if (t["scrollIntoViewThreshold"] !== void 0) {
+    t["visibilityThreshold"] = t["scrollIntoViewThreshold"];
+    delete t["scrollIntoViewThreshold"];
+  }
+  if (t["finishAction"] !== void 0) {
+    t["finish"] = t["finishAction"];
+    delete t["finishAction"];
+  }
+}
 function applyWireSteps(doc, cfg) {
   const from = readWireVersion(doc);
   const relation = compareWireVersion(from, cfg.target, cfg.readerReadsEditorPart);
@@ -757,14 +796,18 @@ var PxPlaybackDirection = {
 };
 var PX_ANIM_SRC_ATTR_NAME = "data-px-animation-src";
 var PX_ANIM_ATTR_NAME = "_px_animator";
-var PxStartOn = {
+var PxTriggerStart = {
   load: "load",
   mouseOver: "mouseOver",
   click: "click",
-  scrollIntoView: "scrollIntoView",
-  programmatic: "programmatic"
+  none: "none"
 };
-var PxOutAction = {
+var PxOffScreenAction = {
+  pause: "pause",
+  continue: "continue",
+  reset: "reset"
+};
+var PxMouseOutAction = {
   continue: "continue",
   pause: "pause",
   reset: "reset",
@@ -832,9 +875,11 @@ function mayUseNativeScrollTimeline(engine) {
   return engine !== PxTimelineEngineSetting.js;
 }
 var PX_TRIGGER_DEFAULTS = {
-  startOn: "load",
-  outAction: "continue",
-  scrollIntoViewThreshold: 0
+  start: "load",
+  offScreen: "pause",
+  mouseOut: "continue",
+  visibilityThreshold: 0.5,
+  visibilityDebounce: 150
 };
 var PxControlMode = {
   /** No control props — the document's trigger decides, and nothing is taken over. */
@@ -868,11 +913,13 @@ function controlModeTakesOverTrigger(mode) {
   return mode !== PxControlMode.autoplay;
 }
 function resolveTrigger(trigger) {
-  var _a2, _b, _c;
+  var _a2, _b, _c, _d, _e;
   return {
-    startOn: (_a2 = trigger == null ? void 0 : trigger.startOn) != null ? _a2 : PX_TRIGGER_DEFAULTS.startOn,
-    outAction: (_b = trigger == null ? void 0 : trigger.outAction) != null ? _b : PX_TRIGGER_DEFAULTS.outAction,
-    scrollIntoViewThreshold: (_c = trigger == null ? void 0 : trigger.scrollIntoViewThreshold) != null ? _c : PX_TRIGGER_DEFAULTS.scrollIntoViewThreshold
+    start: (_a2 = trigger == null ? void 0 : trigger.start) != null ? _a2 : PX_TRIGGER_DEFAULTS.start,
+    offScreen: (_b = trigger == null ? void 0 : trigger.offScreen) != null ? _b : PX_TRIGGER_DEFAULTS.offScreen,
+    mouseOut: (_c = trigger == null ? void 0 : trigger.mouseOut) != null ? _c : PX_TRIGGER_DEFAULTS.mouseOut,
+    visibilityThreshold: (_d = trigger == null ? void 0 : trigger.visibilityThreshold) != null ? _d : PX_TRIGGER_DEFAULTS.visibilityThreshold,
+    visibilityDebounce: (_e = trigger == null ? void 0 : trigger.visibilityDebounce) != null ? _e : PX_TRIGGER_DEFAULTS.visibilityDebounce
   };
 }
 var PxLoopRepeatAt = {
@@ -1008,9 +1055,9 @@ function flattenAnimatorTimeline(cfg) {
   } else {
     if (timeline.duration !== void 0) flat.duration = timeline.duration;
     if (timeline.trigger !== void 0) {
-      const _b = timeline.trigger, { finishAction } = _b, restTrigger = __objRest(_b, ["finishAction"]);
+      const _b = timeline.trigger, { finish } = _b, restTrigger = __objRest(_b, ["finish"]);
       if (Object.keys(restTrigger).length) flat.trigger = restTrigger;
-      if (finishAction !== void 0) flat.resetOnFinish = finishAction === "reset";
+      if (finish !== void 0) flat.resetOnFinish = finish === "reset";
     }
     if (timeline.delay !== void 0) flat.delay = timeline.delay;
     if (timeline.iterations !== void 0) flat.iterations = timeline.iterations;
@@ -1077,7 +1124,7 @@ function nestAnimatorTimeline(cfg) {
   if (duration !== void 0) timeline.duration = duration;
   if (trigger !== void 0 || resetOnFinish) {
     const t = __spreadValues({}, trigger || {});
-    if (resetOnFinish) t.finishAction = "reset";
+    if (resetOnFinish) t.finish = "reset";
     timeline.trigger = t;
   }
   if (delay !== void 0) timeline.delay = delay;
@@ -1180,13 +1227,15 @@ var PxElementAnimationSchema = implementsInterface()(px.union([
   PxAnimationDefinitionSchema
 ]));
 var PxTriggerSchema = implementsInterface()(px.object({
-  startOn: px.enum([PxStartOn.load, PxStartOn.mouseOver, PxStartOn.click, PxStartOn.scrollIntoView, PxStartOn.programmatic], PX_TRIGGER_DEFAULTS.startOn).optional(),
-  outAction: px.enum([PxOutAction.continue, PxOutAction.pause, PxOutAction.reset, PxOutAction.reverse], PX_TRIGGER_DEFAULTS.outAction).optional(),
+  start: px.enum([PxTriggerStart.load, PxTriggerStart.mouseOver, PxTriggerStart.click, PxTriggerStart.none], PX_TRIGGER_DEFAULTS.start).optional(),
+  offScreen: px.enum([PxOffScreenAction.pause, PxOffScreenAction.continue, PxOffScreenAction.reset], PX_TRIGGER_DEFAULTS.offScreen).optional(),
+  mouseOut: px.enum([PxMouseOutAction.continue, PxMouseOutAction.pause, PxMouseOutAction.reset, PxMouseOutAction.reverse], PX_TRIGGER_DEFAULTS.mouseOut).optional(),
   // What happens after a NATURAL finish — `'hold'` (default: keep the end state per
-  // `fill`) or `'reset'` (snap back to the start state). Pairs with `outAction` ("what
-  // happens when the trigger condition ends"); both end-of-life knobs now read alike.
-  finishAction: px.enum([PxFinishAction.hold, PxFinishAction.reset]).optional(),
-  scrollIntoViewThreshold: px.number().optional()
+  // `fill`) or `'reset'` (snap back to the start state). One of four occasion keys
+  // (`start`, `offScreen`, `mouseOut`, `finish`), all named the same way.
+  finish: px.enum([PxFinishAction.hold, PxFinishAction.reset]).optional(),
+  visibilityThreshold: px.number().optional(),
+  visibilityDebounce: px.number().optional()
 }));
 var PxGlyphSchema = implementsInterface()(px.object({
   width: px.number(),
@@ -2219,6 +2268,38 @@ function toDomProps(props) {
   return propsCopy;
 }
 
+// src/animation/PxStaticTransformMerge.ts
+function mergeStaticTransformIntoAnimDef(animDef, staticTransform) {
+  if (!animDef) return animDef;
+  const staticParts = staticTransform && typeof staticTransform === "object" && !Array.isArray(staticTransform) ? staticTransform : parseTransformParts(staticTransform);
+  if (!staticParts || !Object.keys(staticParts).length) return animDef;
+  const mergeKfValue = (v) => v && typeof v === "object" && !Array.isArray(v) ? __spreadValues(__spreadValues({}, staticParts), v) : v;
+  const transformAnim = animDef[TRANSFORM_ATTR];
+  if (transformAnim && typeof transformAnim === "object") {
+    const anim = transformAnim;
+    if (Array.isArray(anim.keyframes)) {
+      const out = __spreadProps(__spreadValues({}, anim), {
+        keyframes: anim.keyframes.map((kf) => __spreadProps(__spreadValues({}, kf), { value: mergeKfValue(kf.value) }))
+      });
+      if (out.value !== void 0) out.value = mergeKfValue(out.value);
+      return __spreadProps(__spreadValues({}, animDef), { transform: out });
+    }
+    return animDef;
+  }
+  const channels = Object.keys(animDef).filter((k) => PX_TRANSFORM_FN_NAMES.has(k));
+  if (channels.length !== 1) return animDef;
+  const ch = channels[0];
+  const chAnim = animDef[ch];
+  if (!chAnim || typeof chAnim !== "object" || !Array.isArray(chAnim.keyframes)) return animDef;
+  const lifted = __spreadProps(__spreadValues({}, chAnim), {
+    keyframes: chAnim.keyframes.map((kf) => __spreadProps(__spreadValues({}, kf), { value: __spreadProps(__spreadValues({}, staticParts), { [ch]: kf.value }) }))
+  });
+  if (lifted.value !== void 0) lifted.value = __spreadProps(__spreadValues({}, staticParts), { [ch]: lifted.value });
+  const rest = __spreadValues({}, animDef);
+  delete rest[ch];
+  return __spreadProps(__spreadValues({}, rest), { transform: lifted });
+}
+
 // src/materialize/PxMotionPath.ts
 function getKfTranslate(kf) {
   const v = keyframeValue(kf);
@@ -2588,7 +2669,7 @@ function walkAndMaterialize(node, opts) {
   let newAnimate;
   const animBucket = node.animate;
   if (animBucket && typeof animBucket === "object" && !Array.isArray(animBucket)) {
-    const animDef = animBucket;
+    const animDef = mergeStaticTransformIntoAnimDef(animBucket, node.transform);
     const transformAnim = animDef.transform;
     if (transformAnim && typeof transformAnim === "object" && propAnimIsMotionPath(transformAnim)) {
       const materialized = materializeMotionPathInPropAnim(transformAnim, opts);
@@ -3102,36 +3183,6 @@ var _elementIdCounter = 0;
 function generateElementId() {
   return "_px_el_" + ++_elementIdCounter;
 }
-function mergeStaticTransformIntoAnimDef(animDef, staticTransform) {
-  if (!animDef) return animDef;
-  const staticParts = staticTransform && typeof staticTransform === "object" && !Array.isArray(staticTransform) ? staticTransform : parseTransformParts(staticTransform);
-  if (!staticParts || !Object.keys(staticParts).length) return animDef;
-  const mergeKfValue = (v) => v && typeof v === "object" && !Array.isArray(v) ? __spreadValues(__spreadValues({}, staticParts), v) : v;
-  const transformAnim = animDef[TRANSFORM_ATTR];
-  if (transformAnim && typeof transformAnim === "object") {
-    const anim = transformAnim;
-    if (Array.isArray(anim.keyframes)) {
-      const out = __spreadProps(__spreadValues({}, anim), {
-        keyframes: anim.keyframes.map((kf) => __spreadProps(__spreadValues({}, kf), { value: mergeKfValue(kf.value) }))
-      });
-      if (out.value !== void 0) out.value = mergeKfValue(out.value);
-      return __spreadProps(__spreadValues({}, animDef), { transform: out });
-    }
-    return animDef;
-  }
-  const channels = Object.keys(animDef).filter((k) => PX_TRANSFORM_FN_NAMES.has(k));
-  if (channels.length !== 1) return animDef;
-  const ch = channels[0];
-  const chAnim = animDef[ch];
-  if (!chAnim || typeof chAnim !== "object" || !Array.isArray(chAnim.keyframes)) return animDef;
-  const lifted = __spreadProps(__spreadValues({}, chAnim), {
-    keyframes: chAnim.keyframes.map((kf) => __spreadProps(__spreadValues({}, kf), { value: __spreadProps(__spreadValues({}, staticParts), { [ch]: kf.value }) }))
-  });
-  if (lifted.value !== void 0) lifted.value = __spreadProps(__spreadValues({}, staticParts), { [ch]: lifted.value });
-  const rest = __spreadValues({}, animDef);
-  delete rest[ch];
-  return __spreadProps(__spreadValues({}, rest), { transform: lifted });
-}
 function normalizeAnimationDefinition(animDef, duration, defs, engine = PxTimelineEngine.native) {
   const normalized = {};
   for (const [propName, propAnim] of Object.entries(animDef)) {
@@ -3214,7 +3265,7 @@ function getKeyframesPair(keyframes, progress) {
   return { prevKf, nextKf };
 }
 function calcPropertyValue(propName, propAnim, progress) {
-  var _a2, _b, _c, _d;
+  var _a2, _b, _c, _d, _e;
   const keyframes = propAnim.keyframes || [];
   if (keyframes.length === 0) return null;
   const { prevKf, nextKf } = getKeyframesPair(keyframes, progress);
@@ -3283,7 +3334,7 @@ function calcPropertyValue(propName, propAnim, progress) {
           !!propAnim.autoOrient
         );
         partsResult.translate = [sample.translate[0], sample.translate[1]];
-        if (sample.rotateDeg !== void 0) partsResult.rotate = sample.rotateDeg;
+        if (sample.rotateDeg !== void 0) partsResult.rotate = sample.rotateDeg + ((_e = partsResult.rotate) != null ? _e : 0);
       }
     }
     cssValue = composeTransformParts(partsResult, { withUnits: false });
@@ -3569,12 +3620,12 @@ function deepClonePxNode(value) {
   for (const k of Object.keys(value)) out[k] = deepClonePxNode(value[k]);
   return out;
 }
-function regenerateIdsAndRewriteRefs(root, genId2) {
+function regenerateIdsAndRewriteRefs(root, genId3) {
   const oldToNew = /* @__PURE__ */ new Map();
   const walkAssign = (n) => {
     var _a2;
     if (typeof n.id === "string") {
-      const newId = genId2();
+      const newId = genId3();
       oldToNew.set(n.id, newId);
       n.id = newId;
     }
@@ -4360,6 +4411,1931 @@ function applyTextGlyphsAlongPath(node, ctx, pathD, startOffset, textLength, pat
   return materializeGlyphTextAlongPath(node, pathD, startOffset, { glyphs: ctx.glyphs, warnings: ctx.warnings }, textLength, pathOverflow);
 }
 
+// src/effects/transform/transformationEffect.ts
+function applyTransformByEffect(node, fx, ctx) {
+  if (!fx) return node;
+  delete node.transform;
+  let n = node;
+  n = wrapOrigin(
+    n,
+    fx.origin,
+    /*invert=*/
+    true
+  );
+  n = wrapTransformPart(n, "scale" /* Scale */, normalizeScale(fx.scale), ctx);
+  n = wrapTransformPart(n, "skew" /* Skew */, fx.skew, ctx);
+  n = wrapTransformPart(n, "rotate" /* Rotate */, fx.rotate, ctx);
+  n = wrapOrigin(
+    n,
+    fx.origin,
+    /*invert=*/
+    false
+  );
+  if (translateHasAutoOrient(fx.translate)) {
+    n = wrapOrigin(
+      n,
+      fx.origin,
+      /*invert=*/
+      true
+    );
+    n = wrapTransformPart(n, "translate" /* Translate */, fx.translate, ctx);
+    n = wrapOrigin(
+      n,
+      fx.origin,
+      /*invert=*/
+      false
+    );
+  } else {
+    n = wrapTransformPart(n, "translate" /* Translate */, fx.translate, ctx);
+  }
+  if (n !== node && node.id) {
+    n.id = node.id;
+    delete node.id;
+  }
+  return n;
+}
+function translateHasAutoOrient(translate) {
+  if (!translate || typeof translate !== "object") return false;
+  const obj = translate;
+  if (obj.autoOrient) return true;
+  return Array.isArray(obj.keyframes) && obj.keyframes.some((kf) => kf.tangentOut || kf.tangentIn);
+}
+function normalizeScale(raw) {
+  return raw;
+}
+function wrapTransformPart(inner, part, raw, ctx) {
+  if (raw === void 0) return inner;
+  const v = readAnimatable(raw);
+  if (v.kind === "static" /* Static */) {
+    return { type: "g", transform: { value: partsRecord(part, v.value, void 0) }, children: [inner] };
+  }
+  if (v.kind === "animated" /* Animated */) {
+    const animTr = { keyframes: v.keyframes.map((kf) => keyframeWith(kf, partsRecord(part, kf.value, void 0))) };
+    if (v.autoOrient) animTr.autoOrient = true;
+    if (v.loop !== void 0) animTr.loop = v.loop;
+    return {
+      type: "g",
+      animate: { transform: animTr },
+      children: [inner]
+    };
+  }
+  return inner;
+}
+function wrapOrigin(inner, raw, invert) {
+  if (raw === void 0) return inner;
+  const v = readAnimatable(raw);
+  const sign = (value) => invert ? [-value[0], -value[1]] : value;
+  if (v.kind === "absent" /* Absent */) return inner;
+  if (v.kind === "static" /* Static */) {
+    if (v.value[0] === 0 && v.value[1] === 0) return inner;
+    return { type: "g", transform: { value: { translate: sign(v.value) } }, children: [inner] };
+  }
+  if (v.kind === "animated" /* Animated */) {
+    const animTr = { keyframes: v.keyframes.map((kf) => keyframeWith(kf, { translate: sign(kf.value) })) };
+    if (v.loop !== void 0) animTr.loop = v.loop;
+    return {
+      type: "g",
+      animate: { transform: animTr },
+      children: [inner]
+    };
+  }
+  return inner;
+}
+
+// src/effects/reference/contentRefSplit.ts
+function identifyContentRefTargets(node, ctx, allocator) {
+  var _a2, _b, _c;
+  if (node.type === "use" && ((_b = (_a2 = node.effects) == null ? void 0 : _a2.clone) == null ? void 0 : _b.without) === "translate") {
+    const sourceId = stripHash(node.effects.clone.source);
+    if (typeof sourceId === "string" && sourceId && !ctx.contentRefInnerIds.has(sourceId)) {
+      ctx.contentRefInnerIds.set(sourceId, allocator(sourceId));
+    }
+  }
+  (_c = node.children) == null ? void 0 : _c.forEach((c) => identifyContentRefTargets(c, ctx, allocator));
+}
+function splitForContentRef(node, transformBy, originalId, innerId, ctx) {
+  const outerBody = liftBodyTranslate(node, transformBy);
+  if (typeof node.id === "string") delete node.id;
+  const { outer: outerTr, inner: innerTr } = splitTransformByEffect(transformBy);
+  let innerNode = node;
+  innerNode = applyTransformByEffect(innerNode, innerTr, ctx);
+  const innerWrapper = { type: "g", id: innerId, children: [innerNode] };
+  let outerWrapper = { type: "g", id: originalId, children: [innerWrapper] };
+  if (outerBody.transform !== void 0) outerWrapper.transform = outerBody.transform;
+  if (outerBody.animate !== void 0) outerWrapper.animate = outerBody.animate;
+  if (outerTr) {
+    delete outerWrapper.id;
+    outerWrapper = applyTransformByEffect(outerWrapper, outerTr, ctx);
+    outerWrapper.id = originalId;
+  }
+  return outerWrapper;
+}
+function liftBodyTranslate(node, transformBy) {
+  var _a2, _b, _c;
+  const out = {};
+  let didLiftAnimate = false;
+  const animTr = (_a2 = node.animate) == null ? void 0 : _a2.transform;
+  if (animTr && typeof animTr === "object" && Array.isArray(animTr.keyframes)) {
+    const kfs = animTr.keyframes;
+    const hasTranslate = kfs.some((kf) => kf.value && kf.value.translate);
+    if (hasTranslate) {
+      const outerHasOrigin = needsOriginOnOuter(animTr);
+      const outerKfs = kfs.map((kf) => {
+        const v = kf.value || {};
+        const newValue = {};
+        if (v.translate !== void 0) newValue.translate = v.translate;
+        if (outerHasOrigin && v.origin !== void 0) newValue.origin = v.origin;
+        const outerKf = { value: newValue };
+        if (kf.time !== void 0) outerKf.time = kf.time;
+        if (kf.easing !== void 0) outerKf.easing = kf.easing;
+        if (kf.tangentOut !== void 0) outerKf.tangentOut = kf.tangentOut;
+        if (kf.tangentIn !== void 0) outerKf.tangentIn = kf.tangentIn;
+        return outerKf;
+      });
+      const outerAnimTr = { keyframes: outerKfs };
+      if (animTr.autoOrient) outerAnimTr.autoOrient = true;
+      const srcLoop = animTr.loop;
+      if (srcLoop !== void 0) outerAnimTr.loop = srcLoop;
+      out.animate = { transform: outerAnimTr };
+      const innerHasPivotedPart = kfs.some((kf) => {
+        const v = kf.value || {};
+        return v.rotate !== void 0 || v.scale !== void 0;
+      });
+      const innerKfs = kfs.map((kf) => {
+        const v = kf.value || {};
+        const newValue = {};
+        if (v.rotate !== void 0) newValue.rotate = v.rotate;
+        if (v.scale !== void 0) newValue.scale = v.scale;
+        if (v.origin !== void 0 && (!outerHasOrigin || innerHasPivotedPart)) newValue.origin = v.origin;
+        const innerKf = { value: newValue };
+        if (kf.time !== void 0) innerKf.time = kf.time;
+        if (kf.easing !== void 0) innerKf.easing = kf.easing;
+        return innerKf;
+      });
+      const allInnerEmpty = innerKfs.every((kf) => Object.keys(kf.value).length === 0);
+      if (allInnerEmpty) {
+        delete node.animate.transform;
+        if (node.animate && Object.keys(node.animate).length === 0) delete node.animate;
+      } else {
+        const innerAnimTr = { keyframes: innerKfs };
+        if (srcLoop !== void 0) innerAnimTr.loop = srcLoop;
+        node.animate.transform = innerAnimTr;
+      }
+      didLiftAnimate = true;
+    }
+  }
+  const transformationHasTranslate = (transformBy == null ? void 0 : transformBy.translate) !== void 0;
+  const stripBodyTranslateOnly = didLiftAnimate || transformationHasTranslate;
+  const liftedAnimateIsAutoOriented = didLiftAnimate && needsOriginOnOuter(((_b = node.animate) == null ? void 0 : _b.transform) || void 0) || didLiftAnimate && needsOriginOnOuter(((_c = out.animate) == null ? void 0 : _c.transform) || void 0);
+  if (typeof node.transform === "string") {
+    const split = splitTransformString(node.transform);
+    if (stripBodyTranslateOnly) {
+      if (split.translate !== void 0) {
+        if (split.rest) node.transform = split.rest;
+        else delete node.transform;
+      } else if (isPureTranslateBody(node.transform)) {
+        delete node.transform;
+      } else if (liftedAnimateIsAutoOriented && isSingleMatrixBody(node.transform)) {
+        delete node.transform;
+      }
+    } else if (split.translate) {
+      out.transform = split.translate;
+      if (split.rest) node.transform = split.rest;
+      else delete node.transform;
+    }
+  } else if (node.transform && typeof node.transform === "object" && !Array.isArray(node.transform) && !node.transform.keyframes) {
+    const wrapped = node.transform.value;
+    const isWrapped = !!(wrapped && typeof wrapped === "object");
+    const value = isWrapped ? wrapped : node.transform;
+    const rewrap = (rec) => isWrapped ? { value: rec } : rec;
+    if (Array.isArray(value.translate)) {
+      const rest = __spreadValues({}, value);
+      delete rest.translate;
+      const hasRest = Object.keys(rest).length > 0;
+      if (stripBodyTranslateOnly) {
+        if (hasRest) node.transform = rewrap(rest);
+        else delete node.transform;
+      } else {
+        out.transform = rewrap({ translate: value.translate });
+        if (hasRest) node.transform = rewrap(rest);
+        else delete node.transform;
+      }
+    }
+  }
+  return out;
+}
+function isSingleMatrixBody(s) {
+  const re = /(translate|rotate|scale|matrix|skewX|skewY)\(([^)]*)\)/g;
+  let count = 0;
+  let isMatrix = false;
+  let m;
+  while (m = re.exec(s)) {
+    count++;
+    if (m[1] === "matrix") isMatrix = true;
+  }
+  return count === 1 && isMatrix;
+}
+function isPureTranslateBody(s) {
+  const re = /(translate|rotate|scale|matrix|skewX|skewY)\(([^)]*)\)/g;
+  const ops = [];
+  let m;
+  while (m = re.exec(s)) ops.push({ name: m[1], full: m[0] });
+  if (ops.length !== 1) return false;
+  if (ops[0].name === "translate") return true;
+  if (ops[0].name !== "matrix") return false;
+  const args = /matrix\(([^)]*)\)/.exec(ops[0].full);
+  if (!args) return false;
+  const nums = args[1].split(/[\s,]+/).filter(Boolean).map(Number);
+  return nums.length >= 4 && nums[0] === 1 && nums[1] === 0 && nums[2] === 0 && nums[3] === 1;
+}
+function splitTransformString(s) {
+  const ops = [];
+  const re = /(translate|rotate|scale|matrix|skewX|skewY)\(([^)]*)\)/g;
+  let m;
+  while (m = re.exec(s)) ops.push({ name: m[1], full: m[0] });
+  if (!ops.length) return { rest: s || void 0 };
+  if (ops.every((o) => o.name === "translate")) {
+    return { translate: ops.map((o) => o.full).join("") };
+  }
+  const leading = ops[0];
+  const trailing = ops[ops.length - 1];
+  if (trailing.name === "translate" && leading.name === "translate") {
+    const trailingVec = parseTranslateArgs(trailing.full);
+    const leadingVec = parseTranslateArgs(leading.full);
+    const ox = -trailingVec[0];
+    const oy = -trailingVec[1];
+    const userTx = leadingVec[0] - ox;
+    const userTy = leadingVec[1] - oy;
+    if (userTx === 0 && userTy === 0) return { rest: s };
+    const middleAndTrailing = "translate(" + ox + "," + oy + ")" + ops.slice(1).map((o) => o.full).join("");
+    return { translate: "translate(" + userTx + "," + userTy + ")", rest: middleAndTrailing };
+  }
+  if (trailing.name === "translate") return { rest: s };
+  const lifted = [];
+  let i = 0;
+  while (i < ops.length && ops[i].name === "translate") {
+    lifted.push(ops[i].full);
+    i++;
+  }
+  if (!lifted.length) return { rest: s };
+  const rest = ops.slice(i).map((o) => o.full).join("");
+  return {
+    translate: lifted.join(""),
+    rest: rest || void 0
+  };
+}
+function parseTranslateArgs(translateOp) {
+  const m = /translate\(([^)]*)\)/.exec(translateOp);
+  if (!m) return [0, 0];
+  const nums = m[1].split(/[\s,]+/).filter(Boolean).map(Number);
+  return [nums[0] || 0, nums[1] || 0];
+}
+function splitTransformByEffect(fx) {
+  if (!fx) return {};
+  const originOnOuter = needsOriginOnOuter(fx.translate);
+  const innerHasPivotedPart = fx.rotate !== void 0 || fx.scale !== void 0;
+  const outer = {};
+  const inner = {};
+  if (fx.translate !== void 0) outer.translate = fx.translate;
+  if (originOnOuter && fx.origin !== void 0) outer.origin = fx.origin;
+  if (fx.rotate !== void 0) inner.rotate = fx.rotate;
+  if (fx.scale !== void 0) inner.scale = fx.scale;
+  if (fx.skew !== void 0) inner.skew = fx.skew;
+  if (fx.origin !== void 0 && (!originOnOuter || innerHasPivotedPart)) inner.origin = fx.origin;
+  return {
+    outer: Object.keys(outer).length ? outer : void 0,
+    inner: Object.keys(inner).length ? inner : void 0
+  };
+}
+function needsOriginOnOuter(translateAnim) {
+  if (!translateAnim || typeof translateAnim !== "object") return false;
+  const obj = translateAnim;
+  if (obj.autoOrient) return true;
+  if (Array.isArray(obj.keyframes)) {
+    return obj.keyframes.some((kf) => kf.tangentOut || kf.tangentIn);
+  }
+  return false;
+}
+
+// src/effects/paint/gradientEffect.ts
+function applyFillGradientEffect(node, fx, ctx) {
+  return applyGradient(node, fx, ctx, "fill");
+}
+function applyStrokeGradientEffect(node, fx, ctx) {
+  return applyGradient(node, fx, ctx, "stroke");
+}
+function applyGradient(node, fx, ctx, attr) {
+  if (!fx) return node;
+  const id = genId(ctx, "grad");
+  const def = synthesiseGradientDef(fx, id, ctx);
+  ctx.defs.push(def);
+  node[attr] = "url(#" + id + ")";
+  return node;
+}
+function synthesiseGradientDef(fx, id, ctx) {
+  const out = {
+    type: fx.type === PxGradientType.radial ? "radialGradient" : "linearGradient",
+    id
+  };
+  if (fx.type === PxGradientType.linear) {
+    applyGeomVec(out, "x1", "y1", fx.start);
+    applyGeomVec(out, "x2", "y2", fx.end);
+  } else {
+    applyGeomVec(out, "cx", "cy", fx.center);
+    applyGeomNumber(out, "r", fx.radius);
+    applyGeomVec(out, "fx", "fy", fx.focal);
+  }
+  if (fx.gradientUnits) out.gradientUnits = fx.gradientUnits;
+  if (fx.spreadMethod) out.spreadMethod = fx.spreadMethod;
+  if (fx.gradientTransform) out.gradientTransform = fx.gradientTransform;
+  out.children = buildStopChildren(fx.stops, ctx);
+  return out;
+}
+function applyGeomVec(out, xAttr, yAttr, raw) {
+  var _a2, _b, _c;
+  const read = readAnimatable(raw);
+  if (read.kind === "absent" /* Absent */) return;
+  if (read.kind === "static" /* Static */) {
+    out[xAttr] = String(read.value[0]);
+    out[yAttr] = String(read.value[1]);
+    return;
+  }
+  const axisChannel = (idx) => {
+    const block = {
+      keyframes: read.keyframes.map((kf) => {
+        const axisKf = { time: kf.time, value: Array.isArray(kf.value) ? kf.value[idx] : void 0 };
+        if (kf.easing !== void 0) axisKf.easing = kf.easing;
+        return axisKf;
+      })
+    };
+    if (read.loop !== void 0) block.loop = read.loop;
+    return block;
+  };
+  const animate = (_a2 = out.animate) != null ? _a2 : {};
+  animate[xAttr] = axisChannel(0);
+  animate[yAttr] = axisChannel(1);
+  out.animate = animate;
+  const baseline = (_c = read.base) != null ? _c : (_b = read.keyframes[0]) == null ? void 0 : _b.value;
+  if (Array.isArray(baseline)) {
+    out[xAttr] = String(baseline[0]);
+    out[yAttr] = String(baseline[1]);
+  }
+}
+function applyGeomNumber(out, attrName, raw) {
+  const read = readAnimatable(raw);
+  if (read.kind === "absent" /* Absent */) return;
+  writeAnimatableChannel(out, attrName, read, { asString: true });
+}
+function buildStopChildren(stops, ctx) {
+  var _a2, _b;
+  if (!stops) return [];
+  const read = readAnimatable(stops);
+  if (read.kind === "absent" /* Absent */) return [];
+  if (read.kind === "static" /* Static */) return Array.isArray(read.value) ? read.value.map(staticStopNode) : [];
+  const kfs = read.keyframes;
+  if (!kfs.length) return [];
+  const loopFromSource = read.loop;
+  let stopCount = 0;
+  for (const kf of kfs) {
+    const v = keyframeValue(kf);
+    if (Array.isArray(v) && v.length > stopCount) stopCount = v.length;
+  }
+  if (!stopCount) return [];
+  const firstKfValue = keyframeValue(kfs[0]);
+  const baselineStops = [];
+  for (let i = 0; i < stopCount; i++) {
+    const s = (_b = (_a2 = firstKfValue == null ? void 0 : firstKfValue[i]) != null ? _a2 : prevDefinedStop(kfs, 0, i)) != null ? _b : { offset: i / Math.max(1, stopCount - 1), color: "#000000" };
+    baselineStops.push({ offset: s.offset, color: s.color });
+  }
+  return baselineStops.map((bs, i) => animatedStopNode(bs, kfs, i, ctx, loopFromSource));
+}
+function staticStopNode(s) {
+  return {
+    type: "stop",
+    offset: formatOffset(s.offset),
+    stopColor: s.color
+  };
+}
+function animatedStopNode(baseline, kfs, stopIdx, _ctx, loop) {
+  var _a2;
+  const colorKfs = [];
+  const offsetKfs = [];
+  let offsetVaries = false;
+  for (const kf of kfs) {
+    const t = keyframeTime(kf);
+    const arr = keyframeValue(kf);
+    const sliced = (_a2 = arr == null ? void 0 : arr[stopIdx]) != null ? _a2 : prevDefinedStop(kfs, kfs.indexOf(kf), stopIdx);
+    if (!sliced) continue;
+    const easing = keyframeEasing(kf);
+    const colorOut = { time: t, value: sliced.color };
+    if (easing !== void 0) colorOut.easing = easing;
+    colorKfs.push(colorOut);
+    const offsetOut = { time: t, value: sliced.offset };
+    if (easing !== void 0) offsetOut.easing = easing;
+    offsetKfs.push(offsetOut);
+    if (sliced.offset !== baseline.offset) offsetVaries = true;
+  }
+  const stop = {
+    type: "stop",
+    offset: formatOffset(baseline.offset),
+    stopColor: baseline.color
+  };
+  const animate = {};
+  if (colorKfs.length) {
+    animate.stopColor = { keyframes: colorKfs };
+    if (loop !== void 0) animate.stopColor.loop = loop;
+  }
+  if (offsetVaries && offsetKfs.length) {
+    animate.offset = { keyframes: offsetKfs };
+    if (loop !== void 0) animate.offset.loop = loop;
+  }
+  if (Object.keys(animate).length) stop.animate = animate;
+  return stop;
+}
+function prevDefinedStop(kfs, fromIdx, stopIdx) {
+  for (let i = fromIdx; i >= 0; i--) {
+    const arr = keyframeValue(kfs[i]);
+    if (arr == null ? void 0 : arr[stopIdx]) return arr[stopIdx];
+  }
+  for (let i = fromIdx + 1; i < kfs.length; i++) {
+    const arr = keyframeValue(kfs[i]);
+    if (arr == null ? void 0 : arr[stopIdx]) return arr[stopIdx];
+  }
+  return void 0;
+}
+function formatOffset(o) {
+  const pct = Math.round(o * 1e3) / 10;
+  return pct + "%";
+}
+
+// src/effects/clipping/clipPathEffect.ts
+function applyClipPathEffect(node, fx, ctx) {
+  if (!(fx == null ? void 0 : fx.pathData)) return node;
+  const clipId = genId(ctx, "clip");
+  const pathChild = { type: "path" };
+  const read = readAnimatable(fx.pathData);
+  if (read.kind !== "absent" /* Absent */) {
+    if (read.kind === "static" /* Static */) {
+      pathChild.d = pathString(read.value);
+    } else {
+      writeAnimatableChannel(pathChild, "d", read);
+      if (pathChild.d !== void 0) pathChild.d = pathString(pathChild.d);
+    }
+  }
+  ctx.defs.push({ type: "clipPath", id: clipId, children: [pathChild] });
+  node.clipPath = "url(#" + clipId + ")";
+  return node;
+}
+function pathString(v) {
+  if (typeof v === "string") return v;
+  if (v && typeof v === "object" && typeof v.pathData === "string") return v.pathData;
+  return void 0;
+}
+
+// src/effects/clipping/maskedByEffect.ts
+function applyMaskedByEffect(node, fx, transformBy, ctx) {
+  if (!fx) return node;
+  const sourceId = stripHash(fx.source);
+  if (!sourceId) {
+    ctx.errors.push("maskedBy.source missing \u2014 cannot build mask");
+    return node;
+  }
+  const maskId = genId(ctx, "mask");
+  let content = { type: "use", href: "#" + sourceId };
+  if (transformBy) {
+    content = wrapInverseTransform(content, transformBy, ctx);
+  } else if (hasAnimateTransform(node)) {
+    content = wrapInverseAnimatedBodyTransform(content, node, ctx);
+  } else {
+    const bodyStatic = readTransformationFromBody(node);
+    if (bodyStatic) content = wrapInverseTransform(content, bodyStatic, ctx);
+  }
+  const includeTargetOwn = transformBy === void 0 && !nodeHasBodyTransform(node);
+  content = wrapAncestorChainCompensation(content, node, sourceId, ctx, includeTargetOwn);
+  const mask = { type: "mask", id: maskId, children: [content] };
+  if (fx.maskType) mask.maskType = fx.maskType;
+  if (fx.maskUnits) mask.maskUnits = fx.maskUnits;
+  if (fx.maskContentUnits) mask.maskContentUnits = fx.maskContentUnits;
+  if (fx.x !== void 0) mask.x = String(fx.x);
+  if (fx.y !== void 0) mask.y = String(fx.y);
+  if (fx.width !== void 0) mask.width = String(fx.width);
+  if (fx.height !== void 0) mask.height = String(fx.height);
+  ctx.defs.push(mask);
+  node.mask = "url(#" + maskId + ")";
+  return node;
+}
+function wrapInverseTransform(inner, fx, ctx) {
+  if (!fx) return inner;
+  const origin = readStaticOrigin(fx.origin, ctx);
+  let n = inner;
+  n = wrapInversePart(n, "translate" /* Translate */, fx.translate, void 0, ctx);
+  n = wrapInversePart(n, "rotate" /* Rotate */, fx.rotate, origin, ctx);
+  n = wrapInversePart(n, "scale" /* Scale */, fx.scale, origin, ctx);
+  return n;
+}
+function wrapInversePart(inner, part, raw, origin, ctx) {
+  if (raw === void 0) return inner;
+  const normalizedRaw = part === "scale" /* Scale */ && Array.isArray(raw) ? [raw[0] / 100, raw[1] / 100] : raw;
+  const v = readAnimatable(normalizedRaw);
+  if (v.kind === "static" /* Static */) {
+    return { type: "g", transform: { value: partsRecord(part, invertPartValue(part, v.value), origin) }, children: [inner] };
+  }
+  if (v.kind === "animated" /* Animated */) {
+    const animTr = { keyframes: v.keyframes.map((kf) => {
+      const out = keyframeWith(kf, partsRecord(part, invertPartValue(part, kf.value), origin));
+      return part === "translate" /* Translate */ ? __spreadValues(__spreadValues({}, out), negatedSpatialTangents(kf)) : out;
+    }) };
+    if (v.loop !== void 0) animTr.loop = v.loop;
+    return {
+      type: "g",
+      animate: { transform: animTr },
+      children: [inner]
+    };
+  }
+  return inner;
+}
+function invertPartValue(part, value) {
+  if (part === "translate" /* Translate */) return [-value[0], -value[1]];
+  if (part === "rotate" /* Rotate */) return -value;
+  return [1 / value[0], 1 / value[1]];
+}
+function negatedSpatialTangents(kf) {
+  var _a2, _b;
+  const out = {};
+  const to = (_a2 = kf.tangentOut) != null ? _a2 : kf.to;
+  const ti = (_b = kf.tangentIn) != null ? _b : kf.ti;
+  if (Array.isArray(to)) out.tangentOut = [-to[0], -to[1]];
+  if (Array.isArray(ti)) out.tangentIn = [-ti[0], -ti[1]];
+  return out;
+}
+function wrapInverseAnimatedBodyTransform(inner, node, _ctx) {
+  var _a2;
+  const animate = node.animate && typeof node.animate === "object" && !Array.isArray(node.animate) ? node.animate : void 0;
+  const animTr = animate == null ? void 0 : animate.transform;
+  const kfs = animTr && typeof animTr === "object" && Array.isArray(animTr.keyframes) ? animTr.keyframes : void 0;
+  if (!kfs || !kfs.length) return inner;
+  const translateKfs = [];
+  const rotateKfs = [];
+  const scaleKfs = [];
+  for (const kf of kfs) {
+    const v = ((_a2 = kf.value) != null ? _a2 : kf.v) || {};
+    const baseKf = keyframeWith(kf, void 0);
+    if (Array.isArray(v.translate)) {
+      translateKfs.push(__spreadProps(__spreadValues(__spreadValues({}, baseKf), negatedSpatialTangents(kf)), { value: { translate: [-v.translate[0], -v.translate[1]] } }));
+    }
+    if (typeof v.rotate === "number") {
+      const rec = { rotate: -v.rotate };
+      if (Array.isArray(v.origin)) rec.origin = [v.origin[0], v.origin[1]];
+      rotateKfs.push(__spreadProps(__spreadValues({}, baseKf), { value: rec }));
+    }
+    if (Array.isArray(v.scale)) {
+      const rec = { scale: [1 / v.scale[0], 1 / v.scale[1]] };
+      if (Array.isArray(v.origin)) rec.origin = [v.origin[0], v.origin[1]];
+      scaleKfs.push(__spreadProps(__spreadValues({}, baseKf), { value: rec }));
+    }
+  }
+  const srcLoop = animTr == null ? void 0 : animTr.loop;
+  const withLoop = (kfs2) => {
+    const block = { keyframes: kfs2 };
+    if (srcLoop !== void 0) block.loop = srcLoop;
+    return block;
+  };
+  let n = inner;
+  if (translateKfs.length) n = { type: "g", animate: { transform: withLoop(translateKfs) }, children: [n] };
+  if (rotateKfs.length) n = { type: "g", animate: { transform: withLoop(rotateKfs) }, children: [n] };
+  if (scaleKfs.length) n = { type: "g", animate: { transform: withLoop(scaleKfs) }, children: [n] };
+  return n;
+}
+function nodeHasBodyTransform(node) {
+  if (typeof node.transform === "string") return true;
+  if (node.transform && typeof node.transform === "object") return true;
+  return hasAnimateTransform(node);
+}
+function hasAnimateTransform(node) {
+  const animate = node.animate && typeof node.animate === "object" && !Array.isArray(node.animate) ? node.animate : void 0;
+  return !!(animate && animate.transform);
+}
+function readTransformationFromBody(node) {
+  if (typeof node.transform === "string") {
+    const parts = parseTransformStringToParts(node.transform);
+    if (!parts) return void 0;
+    const out = {};
+    if (parts.translate) out.translate = parts.translate;
+    if (parts.rotate !== void 0) out.rotate = parts.rotate;
+    if (parts.scale) out.scale = { value: parts.scale };
+    if (parts.origin) out.origin = parts.origin;
+    return Object.keys(out).length ? out : void 0;
+  }
+  if (node.transform && typeof node.transform === "object" && !node.transform.keyframes) {
+    const wrapped = node.transform.value;
+    const value = wrapped && typeof wrapped === "object" ? wrapped : node.transform;
+    if (value && typeof value === "object") {
+      const out = {};
+      if (Array.isArray(value.translate)) out.translate = value.translate;
+      if (typeof value.rotate === "number") out.rotate = value.rotate;
+      if (typeof value.skew === "number") out.skew = value.skew;
+      if (Array.isArray(value.scale)) out.scale = { value: value.scale };
+      if (Array.isArray(value.origin)) out.origin = value.origin;
+      return Object.keys(out).length ? out : void 0;
+    }
+  }
+  return void 0;
+}
+function parseTransformStringToParts(s) {
+  var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const re = /([a-zA-Z]+)\s*\(([^)]*)\)/g;
+  let m;
+  const ops = [];
+  while ((m = re.exec(s)) !== null) {
+    const args = m[2].split(/[\s,]+/).filter((a) => a.length > 0).map(Number);
+    ops.push({ name: m[1], args });
+  }
+  if (!ops.length) return void 0;
+  const last = ops[ops.length - 1];
+  if (last.name === "translate") {
+    for (let j = ops.length - 2; j >= 0; j--) {
+      const cand = ops[j];
+      if (cand.name !== "translate") continue;
+      const ox = (_a2 = cand.args[0]) != null ? _a2 : 0;
+      const oy = (_b = cand.args[1]) != null ? _b : 0;
+      const lx = (_c = last.args[0]) != null ? _c : 0;
+      const ly = (_d = last.args[1]) != null ? _d : 0;
+      if (lx !== -ox || ly !== -oy) continue;
+      const out2 = {};
+      out2.origin = [ox, oy];
+      for (let k = 0; k < j; k++) {
+        if (ops[k].name === "translate") {
+          const tx = (_e = ops[k].args[0]) != null ? _e : 0;
+          const ty = (_f = ops[k].args[1]) != null ? _f : 0;
+          out2.translate = out2.translate ? [out2.translate[0] + tx, out2.translate[1] + ty] : [tx, ty];
+        }
+      }
+      for (let k = j + 1; k < ops.length - 1; k++) {
+        const op = ops[k];
+        if (op.name === "rotate") out2.rotate = ((_g = out2.rotate) != null ? _g : 0) + ((_h = op.args[0]) != null ? _h : 0);
+        else if (op.name === "scale") {
+          const sx = (_i = op.args[0]) != null ? _i : 1;
+          const sy = op.args.length > 1 ? op.args[1] : sx;
+          out2.scale = out2.scale ? [out2.scale[0] * sx, out2.scale[1] * sy] : [sx, sy];
+        }
+      }
+      return out2;
+    }
+  }
+  let translate;
+  let rotate;
+  let scale;
+  for (const op of ops) {
+    if (op.name === "translate") {
+      const dx = (_j = op.args[0]) != null ? _j : 0;
+      const dy = (_k = op.args[1]) != null ? _k : 0;
+      translate = translate ? [translate[0] + dx, translate[1] + dy] : [dx, dy];
+    } else if (op.name === "rotate") {
+      rotate = (rotate != null ? rotate : 0) + ((_l = op.args[0]) != null ? _l : 0);
+    } else if (op.name === "scale") {
+      const sx = (_m = op.args[0]) != null ? _m : 1;
+      const sy = op.args.length > 1 ? op.args[1] : sx;
+      scale = scale ? [scale[0] * sx, scale[1] * sy] : [sx, sy];
+    }
+  }
+  const out = {};
+  if (translate) out.translate = translate;
+  if (rotate !== void 0) out.rotate = rotate;
+  if (scale) out.scale = scale;
+  return Object.keys(out).length ? out : void 0;
+}
+function wrapAncestorChainCompensation(inner, maskedNode, sourceId, ctx, includeTargetOwn) {
+  const sourceNode = ctx.idMap.get(sourceId);
+  const targetAncestors = ctx.maskAncestorChains.get(maskedNode) || [];
+  const targetOwn = includeTargetOwn ? extractTranslateOnly(maskedNode, ctx) : void 0;
+  const targetChain = targetOwn ? [...targetAncestors, targetOwn] : targetAncestors;
+  const sourceChain = sourceNode && ctx.maskAncestorChains.get(sourceNode) || [];
+  if (!targetChain.length && !sourceChain.length) return inner;
+  const times = /* @__PURE__ */ new Set();
+  for (const a of targetChain) if (a.translateKeyframes) for (const kf of a.translateKeyframes) times.add(kf.time);
+  for (const a of sourceChain) if (a.translateKeyframes) for (const kf of a.translateKeyframes) times.add(kf.time);
+  const animated = times.size > 0;
+  if (!animated) {
+    const tgt = sumStaticTranslate(targetChain);
+    const src = sumStaticTranslate(sourceChain);
+    const dx = src[0] - tgt[0];
+    const dy = src[1] - tgt[1];
+    if (dx === 0 && dy === 0) return inner;
+    return { type: "g", transform: "translate(" + dx + "," + dy + ")", children: [inner] };
+  }
+  const sortedTimes = Array.from(times).sort((a, b) => a - b);
+  const keyframes = sortedTimes.map((t) => {
+    const tgt = sumTranslateAt(targetChain, t);
+    const src = sumTranslateAt(sourceChain, t);
+    return { time: t, value: { translate: [src[0] - tgt[0], src[1] - tgt[1]] } };
+  });
+  return { type: "g", animate: { transform: { keyframes } }, children: [inner] };
+}
+function sumStaticTranslate(chain) {
+  let x = 0, y = 0;
+  for (const a of chain) {
+    if (a.translate) {
+      x += a.translate[0];
+      y += a.translate[1];
+    }
+  }
+  return [x, y];
+}
+function sumTranslateAt(chain, t) {
+  let x = 0, y = 0;
+  for (const a of chain) {
+    if (a.translateKeyframes && a.translateKeyframes.length) {
+      const v = interpKfs(a.translateKeyframes, t);
+      x += v[0];
+      y += v[1];
+    } else if (a.translate) {
+      x += a.translate[0];
+      y += a.translate[1];
+    }
+  }
+  return [x, y];
+}
+function interpKfs(kfs, t) {
+  if (t <= kfs[0].time) return kfs[0].value;
+  if (t >= kfs[kfs.length - 1].time) return kfs[kfs.length - 1].value;
+  for (let i = 1; i < kfs.length; i++) {
+    if (t <= kfs[i].time) {
+      const prev = kfs[i - 1];
+      const cur = kfs[i];
+      const a = (t - prev.time) / (cur.time - prev.time);
+      return [prev.value[0] + (cur.value[0] - prev.value[0]) * a, prev.value[1] + (cur.value[1] - prev.value[1]) * a];
+    }
+  }
+  return kfs[kfs.length - 1].value;
+}
+function collectMaskAncestorChains(root, ctx) {
+  const interestingNodes = /* @__PURE__ */ new Set();
+  const collectInterestingNodes = (n) => {
+    var _a2, _b;
+    const maskSourceId = stripHash((_b = (_a2 = n.effects) == null ? void 0 : _a2.maskedBy) == null ? void 0 : _b.source);
+    if (typeof maskSourceId === "string") {
+      interestingNodes.add(n);
+      const sourceNode = ctx.idMap.get(maskSourceId);
+      if (sourceNode) interestingNodes.add(sourceNode);
+    }
+    if (Array.isArray(n.children)) for (const ch of n.children) collectInterestingNodes(ch);
+  };
+  collectInterestingNodes(root);
+  if (interestingNodes.size === 0) return;
+  const walk = (node, chain) => {
+    if (interestingNodes.has(node)) ctx.maskAncestorChains.set(node, chain);
+    if (Array.isArray(node.children)) {
+      const own = extractTranslateOnly(node, ctx);
+      const next = own ? [...chain, own] : chain;
+      for (const ch of node.children) walk(ch, next);
+    }
+  };
+  walk(root, []);
+}
+function extractTranslateOnly(node, ctx) {
+  var _a2, _b, _c;
+  const tr = node.transform;
+  const animateBlock = node.animate && typeof node.animate === "object" && !Array.isArray(node.animate) ? node.animate.transform : void 0;
+  if (tr === void 0 && !animateBlock) return void 0;
+  const out = {};
+  if (typeof tr === "string") {
+    const parts = parseTranslateOnlyFromString(tr, ctx);
+    if (parts) out.translate = parts;
+  } else if (tr && typeof tr === "object" && !tr.keyframes) {
+    const wrapped = tr.value;
+    const value = wrapped && typeof wrapped === "object" ? wrapped : tr;
+    if (value && typeof value === "object" && Array.isArray(value.translate)) {
+      out.translate = [value.translate[0] || 0, value.translate[1] || 0];
+    }
+    if (value && (value.rotate !== void 0 || value.scale !== void 0 || value.skew !== void 0)) {
+      ctx.warnings.push("maskedBy ancestor: non-translate transform parts ignored (rotate/scale not yet supported)");
+    }
+  }
+  if (animateBlock && Array.isArray(animateBlock.keyframes)) {
+    const kfs = animateBlock.keyframes;
+    const translateKfs = [];
+    for (const kf of kfs) {
+      const v = (_a2 = kf.value) != null ? _a2 : kf.v;
+      const t = (_c = (_b = kf.time) != null ? _b : kf.t) != null ? _c : 0;
+      if (v && typeof v === "object" && Array.isArray(v.translate)) {
+        translateKfs.push({ time: t, value: [v.translate[0] || 0, v.translate[1] || 0] });
+        if (v.rotate !== void 0 || v.scale !== void 0 || v.skew !== void 0) {
+          ctx.warnings.push("maskedBy ancestor: animated non-translate parts ignored");
+        }
+      }
+    }
+    if (translateKfs.length) out.translateKeyframes = translateKfs;
+  }
+  return out.translate || out.translateKeyframes ? out : void 0;
+}
+function parseTranslateOnlyFromString(s, ctx) {
+  const re = /([a-zA-Z]+)\s*\(([^)]*)\)/g;
+  let m;
+  let x = 0, y = 0;
+  let seen = false;
+  let droppedNonTranslate = false;
+  while ((m = re.exec(s)) !== null) {
+    const name = m[1];
+    const args = m[2].split(/[\s,]+/).filter((a) => a.length > 0).map(Number);
+    if (name === "translate") {
+      x += args[0] || 0;
+      y += args[1] || 0;
+      seen = true;
+    } else {
+      droppedNonTranslate = true;
+    }
+  }
+  if (droppedNonTranslate) ctx.warnings.push("maskedBy ancestor: non-translate transform in string ignored: " + s);
+  return seen ? [x, y] : void 0;
+}
+
+// src/effects/reference/refEffect.ts
+function applyRefHref(node, clone2, ctx) {
+  if (!clone2) return;
+  const sourceId = stripHash(clone2.source);
+  if (!sourceId) {
+    if (clone2.without === PxCloneWithout.translate) ctx.errors.push("clone: content ref missing `source`");
+    return;
+  }
+  const targetId = clone2.without === PxCloneWithout.translate ? ctx.contentRefInnerIds.get(sourceId) || sourceId : sourceId;
+  node.href = "#" + targetId;
+}
+function applyRefAndTransformationEffect(node, clone2, transformBy, ctx) {
+  applyRefHref(node, clone2, ctx);
+  return applyTransformByEffect(node, transformBy, ctx);
+}
+
+// src/effects/transform/repeaterEffect.ts
+function applyRepeaterEffect(node, fx, ctx) {
+  var _a2, _b;
+  if (!fx) return node;
+  const copies = (_a2 = fx.copies) != null ? _a2 : 1;
+  if (copies < 1) {
+    ctx.errors.push("repeater.copies invalid: " + fx.copies);
+    return node;
+  }
+  const sharedTransform = node.transform;
+  const sharedAnimTransform = (_b = node.animate) == null ? void 0 : _b.transform;
+  const base = clone(node);
+  delete base.transform;
+  if (base.animate) {
+    delete base.animate.transform;
+    if (Object.keys(base.animate).length === 0) delete base.animate;
+  }
+  delete base.id;
+  const children = [base];
+  for (let i = 1; i < copies; i++) {
+    const baseClone = clone(base);
+    const synthFx = synthesisePerCopyFx(fx, i);
+    const wrapped = synthFx ? applyTransformByEffect(baseClone, synthFx, ctx) : baseClone;
+    children.push(wrapped);
+  }
+  const wrapper = { type: "g", children };
+  if (node.id) wrapper.id = node.id;
+  if (sharedTransform !== void 0) wrapper.transform = sharedTransform;
+  if (sharedAnimTransform !== void 0) wrapper.animate = { transform: sharedAnimTransform };
+  return wrapper;
+}
+function synthesisePerCopyFx(fx, i) {
+  const out = {};
+  if (fx.translate !== void 0) {
+    out.translate = mapAnimatable(fx.translate, (v) => [v[0] * i, v[1] * i]);
+  }
+  if (fx.rotate !== void 0) {
+    out.rotate = mapAnimatable(fx.rotate, (v) => v * i);
+  }
+  if (fx.skew !== void 0) {
+    out.skew = mapAnimatable(fx.skew, (v) => v * i);
+  }
+  if (fx.scale !== void 0) {
+    out.scale = synthesiseScale(fx.scale, i);
+  }
+  if (fx.origin !== void 0) {
+    out.origin = fx.origin;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function mapAnimatable(raw, fn, wrapStatic = false) {
+  const read = readAnimatable(raw);
+  if (read.kind === "absent" /* Absent */) return raw;
+  if (read.kind === "static" /* Static */) {
+    const mapped = fn(read.value);
+    const wasRawStatic = typeof raw === "number" || Array.isArray(raw);
+    return wasRawStatic && !wrapStatic ? mapped : { value: mapped };
+  }
+  const out = {
+    keyframes: read.keyframes.map((kf) => kf && kf.value !== void 0 ? __spreadProps(__spreadValues({}, kf), { value: fn(kf.value) }) : kf)
+  };
+  if (read.loop !== void 0) out.loop = read.loop;
+  if (read.autoOrient !== void 0) out.autoOrient = read.autoOrient;
+  if (read.base !== void 0) out.value = fn(read.base);
+  return out;
+}
+function synthesiseScale(raw, i) {
+  const scalePower = (v) => [Math.pow(v[0], i), Math.pow(v[1], i)];
+  return mapAnimatable(raw, scalePower, true);
+}
+
+// src/effects/reference/retimeEffect.ts
+var RETIME_MATERIALIZATION_MODE_INLINE_G = false;
+function asRetime(r) {
+  var _a2, _b;
+  return { start: (_a2 = r.start) != null ? _a2 : 0, stretch: (_b = r.stretch) != null ? _b : 1 };
+}
+var CROP_EDGE_MS = 1;
+function applyTimeCrop(useNode, crop, ctx) {
+  const [start, end] = crop;
+  if (!Number.isFinite(start) || !Number.isFinite(end)) {
+    ctx.warnings.push("retime: timeCrop is not a pair of finite numbers \u2014 ignored");
+    return;
+  }
+  const keyframes = end <= start ? [{ time: 0, value: 0 }] : [
+    ...start > 0 ? [{ time: Math.max(0, start - CROP_EDGE_MS), value: 0 }] : [],
+    { time: Math.max(0, start), value: 1 },
+    { time: end, value: 1 },
+    { time: end + CROP_EDGE_MS, value: 0 }
+  ];
+  const inner = __spreadValues({}, useNode);
+  for (const k of Object.keys(useNode)) delete useNode[k];
+  useNode.type = "g";
+  useNode.children = [inner];
+  useNode.animate = { opacity: { keyframes } };
+}
+function concatRetime(child, parent) {
+  return {
+    start: parent.start + parent.stretch * child.start,
+    stretch: parent.stretch * child.stretch
+  };
+}
+function readCloneRetime(n) {
+  var _a2, _b;
+  return (_b = (_a2 = n.effects) == null ? void 0 : _a2.clone) == null ? void 0 : _b.retime;
+}
+function clearCloneRetime(n) {
+  var _a2;
+  const clone2 = (_a2 = n.effects) == null ? void 0 : _a2.clone;
+  if (!clone2) return;
+  delete clone2.retime;
+  if (Object.keys(clone2).length === 0) delete n.effects.clone;
+  if (n.effects && Object.keys(n.effects).length === 0) delete n.effects;
+}
+function applyAllRetimeEffects(root, ctx) {
+  ctx.idMap.clear();
+  indexById(root, ctx.idMap);
+  const sites = [];
+  const collect = (n) => {
+    var _a2;
+    if (readCloneRetime(n)) sites.push(n);
+    (_a2 = n.children) == null ? void 0 : _a2.forEach(collect);
+  };
+  collect(root);
+  const reachCount = /* @__PURE__ */ new Map();
+  for (const site of sites) {
+    let count = 0;
+    const visited = /* @__PURE__ */ new Set();
+    const walk = (n) => {
+      var _a2;
+      if (!n) return;
+      if (n !== site && readCloneRetime(n)) count++;
+      if (n.type === "use" && n.href) {
+        const id = stripHash(n.href);
+        if (id && !visited.has(id)) {
+          visited.add(id);
+          walk(ctx.idMap.get(id));
+        }
+      }
+      (_a2 = n.children) == null ? void 0 : _a2.forEach(walk);
+    };
+    const rootId = stripHash(site.href);
+    if (rootId) {
+      visited.add(rootId);
+      walk(ctx.idMap.get(rootId));
+    }
+    reachCount.set(site, count);
+  }
+  sites.sort((a, b) => {
+    var _a2, _b;
+    return ((_a2 = reachCount.get(b)) != null ? _a2 : 0) - ((_b = reachCount.get(a)) != null ? _b : 0);
+  });
+  for (const useNode of sites) {
+    const retime = readCloneRetime(useNode);
+    if (!retime) continue;
+    const crop = retime.timeCrop;
+    clearCloneRetime(useNode);
+    materializeRetime(useNode, asRetime(retime), ctx);
+    if (crop) applyTimeCrop(useNode, crop, ctx);
+  }
+}
+function materializeRetime(useNode, retime, ctx) {
+  const targetId = stripHash(useNode.href);
+  if (!targetId) {
+    ctx.errors.push("retime: <use> has no href to follow");
+    return;
+  }
+  const chainRootId = buildChainClone(targetId, retime, ctx, /* @__PURE__ */ new Set());
+  if (!chainRootId) return;
+  if (RETIME_MATERIALIZATION_MODE_INLINE_G) {
+    const cloneNode = ctx.idMap.get(chainRootId);
+    useNode.type = "g";
+    delete useNode.href;
+    useNode.children = [cloneNode];
+    applyUseOffsetToG(useNode);
+    ctx.defs = ctx.defs.filter((d) => d !== cloneNode);
+  } else {
+    useNode.href = "#" + chainRootId;
+  }
+}
+function buildChainClone(targetId, accum, ctx, chain) {
+  if (chain.has(targetId)) {
+    ctx.errors.push('retime: loop via "' + targetId + '"');
+    return void 0;
+  }
+  const target = ctx.idMap.get(targetId);
+  if (!target) {
+    ctx.warnings.push('retime: target "' + targetId + '" not found');
+    return void 0;
+  }
+  const cloneNode = clone(target);
+  regenerateIdsInClone(cloneNode, ctx);
+  if (target.type === "use") {
+    remapKeyframeTimesOnly(cloneNode, accum.start, accum.stretch);
+  } else {
+    remapKeyframeTimes(cloneNode, accum.start, accum.stretch);
+  }
+  clearCloneRetime(cloneNode);
+  if (target.type === "use" && target.href) {
+    const subId = stripHash(target.href);
+    if (subId) {
+      const innerRetime = readCloneRetime(target);
+      const subAccum = innerRetime ? concatRetime(asRetime(innerRetime), accum) : accum;
+      const subChain = new Set(chain);
+      subChain.add(targetId);
+      const subId2 = buildChainClone(subId, subAccum, ctx, subChain);
+      if (subId2) cloneNode.href = "#" + subId2;
+    }
+  } else {
+    materializeNestedRetimeUses(cloneNode, accum, ctx, chain, targetId);
+  }
+  ctx.defs.push(cloneNode);
+  if (typeof cloneNode.id === "string") ctx.idMap.set(cloneNode.id, cloneNode);
+  return typeof cloneNode.id === "string" ? cloneNode.id : void 0;
+}
+function materializeNestedRetimeUses(node, accum, ctx, chain, parentTargetId) {
+  const visit = (n) => {
+    var _a2;
+    const retime = readCloneRetime(n);
+    if (n.type === "use" && retime && n.href) {
+      const subId = stripHash(n.href);
+      if (subId) {
+        const subAccum = concatRetime(asRetime(retime), accum);
+        const subChain = new Set(chain);
+        subChain.add(parentTargetId);
+        const subId2 = buildChainClone(subId, subAccum, ctx, subChain);
+        if (subId2) n.href = "#" + subId2;
+      }
+      clearCloneRetime(n);
+    }
+    (_a2 = n.children) == null ? void 0 : _a2.forEach(visit);
+  };
+  visit(node);
+}
+function remapKeyframeTimes(node, start, stretch) {
+  var _a2;
+  remapKeyframeTimesOnly(node, start, stretch);
+  (_a2 = node.children) == null ? void 0 : _a2.forEach((c) => remapKeyframeTimes(c, start, stretch));
+}
+function remapKeyframeTimesOnly(node, start, stretch) {
+  const remap2 = (kfs) => {
+    for (const kf of kfs) if (typeof kf.time === "number") kf.time = start + kf.time * stretch;
+  };
+  if (node.transform && typeof node.transform === "object" && Array.isArray(node.transform.keyframes)) {
+    remap2(node.transform.keyframes);
+  }
+  if (node.animate && typeof node.animate === "object") {
+    for (const prop of Object.keys(node.animate)) {
+      const anim = node.animate[prop];
+      if (anim && Array.isArray(anim.keyframes)) remap2(anim.keyframes);
+    }
+  }
+}
+
+// src/effects/stroke/strokeTrimEffect.ts
+function applyStrokeTrimEffect(node, strokeTrim, ctx) {
+  if (!strokeTrim) return node;
+  const combined = strokeTrim.subPaths === PxStrokeTrimSubPaths.combined;
+  const leafEntries = [];
+  const measure = (n) => {
+    if (Array.isArray(n.children) && n.children.length > 0) {
+      for (const ch of n.children) measure(ch);
+      return;
+    }
+    const d = typeof n.d === "string" ? n.d : shapeToPathD(n);
+    if (d === void 0) return;
+    const subpaths = parseSvgPathToBezier(d);
+    if (!subpaths.length) return;
+    const entry = { leaf: n, subpaths: [] };
+    for (const sp of subpaths) {
+      const lengthPx = pxBezierPathLength(sp);
+      entry.subpaths.push({ subpath: sp, lengthPx, startOffsetPx: 0 });
+    }
+    leafEntries.push(entry);
+  };
+  measure(node);
+  if (!leafEntries.length) return node;
+  let acc = 0;
+  const iterOrder = combined ? [...leafEntries].reverse() : leafEntries;
+  for (const entry of iterOrder) {
+    for (const sp of entry.subpaths) {
+      if (!combined) acc = 0;
+      sp.startOffsetPx = acc;
+      acc += sp.lengthPx;
+    }
+  }
+  const chainLengthPx = acc;
+  if (combined && chainLengthPx < 1e-3) return node;
+  const offsetReadRaw = readAnimatable(strokeTrim.offset);
+  const offsetRead = offsetReadRaw.kind === "absent" /* Absent */ ? { kind: "static" /* Static */, value: 0 } : offsetReadRaw;
+  const rangeReadRaw = readRangeWithCrossings(strokeTrim.range);
+  const rangeRead = rangeReadRaw.kind === "absent" /* Absent */ ? { kind: "static" /* Static */, value: [0, 1] } : rangeReadRaw;
+  const offsetValues = readScalarValues(offsetRead);
+  const minOffset = offsetValues.length ? Math.min(...offsetValues) : 0;
+  const maxOffset = offsetValues.length ? Math.max(...offsetValues) : 0;
+  const minMaxOffset = [minOffset, maxOffset];
+  if (leafEntries.length === 1 && leafEntries[0].leaf === node && leafEntries[0].subpaths.length === 1) {
+    const entry = leafEntries[0];
+    const sp = entry.subpaths[0];
+    const pathLengthPx = combined ? chainLengthPx : sp.lengthPx;
+    if (pathLengthPx < 1e-3) return node;
+    const startOffsetPct = combined ? sp.startOffsetPx / pathLengthPx : 0;
+    return collapseLeafWithTrim(entry.leaf, pathLengthPx, startOffsetPct, minMaxOffset, offsetRead, rangeRead);
+  }
+  const replacements = /* @__PURE__ */ new Map();
+  for (const entry of leafEntries) {
+    const newChildren = [];
+    for (const sp of entry.subpaths) {
+      const pathLengthPx = combined ? chainLengthPx : sp.lengthPx;
+      if (pathLengthPx < 1e-3) continue;
+      const startOffsetPct = combined ? sp.startOffsetPx / pathLengthPx : 0;
+      newChildren.push(...buildSubpathNodes(entry.leaf, sp.subpath, pathLengthPx, startOffsetPct, minMaxOffset, offsetRead, rangeRead, ctx));
+    }
+    replacements.set(entry.leaf, wrapLeafAsGroup(entry.leaf, newChildren));
+  }
+  const swap = (n) => {
+    const r = replacements.get(n);
+    if (r) return r;
+    if (Array.isArray(n.children) && n.children.length > 0) {
+      return __spreadProps(__spreadValues({}, n), { children: n.children.map(swap) });
+    }
+    return n;
+  };
+  return swap(node);
+}
+function wrapLeafAsGroup(leaf, children) {
+  const wrapper = __spreadProps(__spreadValues({}, leaf), { type: "g", children });
+  delete wrapper.d;
+  delete wrapper.strokeDasharray;
+  delete wrapper.strokeDashoffset;
+  delete wrapper.effects;
+  return wrapper;
+}
+function buildSubpathNodes(leaf, subpath, pathLengthPx, startOffsetPct, minMaxOffset, offsetRead, rangeRead, ctx) {
+  const offsetToDashOffset = makeOffsetToDashOffset(startOffsetPct, pathLengthPx, minMaxOffset);
+  const rangeToDasharray = makeRangeToDasharray(pathLengthPx, minMaxOffset);
+  const dashOffsetAttr = computeAnimAttr(offsetRead, offsetToDashOffset);
+  const dashArrayAttr = computeAnimAttr(rangeRead, rangeToDasharray);
+  const strokeOpacityAttr = computeOpacityFromRange(rangeRead);
+  const dStr = bezierToSvgPath(subpath);
+  const base = makeBareSubpath(dStr);
+  applyAttr(base, "strokeDasharray", dashArrayAttr);
+  applyAttr(base, "strokeDashoffset", dashOffsetAttr);
+  applyAttr(base, "strokeOpacity", strokeOpacityAttr);
+  return [base];
+}
+function collapseLeafWithTrim(leaf, pathLengthPx, startOffsetPct, minMaxOffset, offsetRead, rangeRead) {
+  const offsetToDashOffset = makeOffsetToDashOffset(startOffsetPct, pathLengthPx, minMaxOffset);
+  const rangeToDasharray = makeRangeToDasharray(pathLengthPx, minMaxOffset);
+  const node = __spreadValues({}, leaf);
+  delete node.effects;
+  applyAttr(node, "strokeDasharray", computeAnimAttr(rangeRead, rangeToDasharray));
+  applyAttr(node, "strokeDashoffset", computeAnimAttr(offsetRead, offsetToDashOffset));
+  applyAttr(node, "strokeOpacity", computeOpacityFromRange(rangeRead));
+  return node;
+}
+function makeBareSubpath(dStr) {
+  return { type: "path", d: dStr };
+}
+var SMALL_PADDING_PX = 1;
+function makeOffsetToDashOffset(startOffsetPct, pathLengthPx, minMaxOffset) {
+  const [minIdx] = getOffsetIndexRange(minMaxOffset);
+  return (offsetVal) => pathLengthPx * (-offsetVal - minIdx + startOffsetPct) + SMALL_PADDING_PX;
+}
+function makeRangeToDasharray(pathLengthPx, minMaxOffset) {
+  const [minIdx, maxIdx] = getOffsetIndexRange(minMaxOffset);
+  const repeats = maxIdx - minIdx + 1;
+  return (rangeVal) => {
+    const a = clamp(rangeVal[0], 0, 1);
+    const b = clamp(rangeVal[1], 0, 1);
+    const minR = Math.min(a, b);
+    const maxR = Math.max(a, b);
+    const out = [0];
+    let gap = SMALL_PADDING_PX;
+    for (let i = 0; i < repeats; i++) {
+      out.push(gap + minR * pathLengthPx);
+      out.push((maxR - minR) * pathLengthPx);
+      gap = (1 - maxR) * pathLengthPx;
+    }
+    out.push(gap + SMALL_PADDING_PX);
+    return out;
+  };
+}
+function getOffsetIndexRange(minMaxOffset) {
+  return [
+    Math.floor(Math.min(-minMaxOffset[0], -minMaxOffset[1])),
+    Math.ceil(Math.max(-minMaxOffset[0], -minMaxOffset[1]))
+  ];
+}
+function readScalarValues(r) {
+  if (r.kind === "absent" /* Absent */) return [];
+  if (r.kind === "static" /* Static */) return [r.value];
+  const out = [];
+  for (const kf of r.keyframes) {
+    const v = keyframeValue(kf);
+    if (typeof v === "number") out.push(v);
+  }
+  return out;
+}
+function computeAnimAttr(read, map) {
+  if (read.kind === "absent" /* Absent */) return void 0;
+  if (read.kind === "static" /* Static */) return { kind: "static" /* Static */, value: map(read.value) };
+  return {
+    kind: "animated" /* Animated */,
+    keyframes: read.keyframes.map((kf) => ({
+      time: keyframeTime(kf),
+      value: map(keyframeValue(kf)),
+      easing: keyframeEasing(kf)
+    })),
+    loop: read.loop
+  };
+}
+function applyAttr(node, attrName, attr) {
+  if (!attr) return;
+  writeAnimatableChannel(node, attrName, attr);
+}
+var OPACITY_STEP_MS = 10;
+function computeOpacityFromRange(rangeRead) {
+  const hide = (v) => v[0] === v[1];
+  if (rangeRead.kind === "absent" /* Absent */) return void 0;
+  if (rangeRead.kind === "static" /* Static */) return hide(rangeRead.value) ? { kind: "static" /* Static */, value: 0 } : void 0;
+  const kfs = rangeRead.keyframes;
+  let anyHide = false;
+  let allHide = true;
+  for (const kf of kfs) {
+    if (hide(keyframeValue(kf))) anyHide = true;
+    else allHide = false;
+  }
+  if (!anyHide) return void 0;
+  if (allHide) return { kind: "static" /* Static */, value: 0 };
+  const out = [];
+  for (let i = 0; i < kfs.length; i++) {
+    const kf = kfs[i];
+    const prevKf = i > 0 ? kfs[i - 1] : void 0;
+    const nextKf = i < kfs.length - 1 ? kfs[i + 1] : void 0;
+    const t = keyframeTime(kf);
+    const thisHide = hide(keyframeValue(kf));
+    const prevHide = prevKf ? thisHide && hide(keyframeValue(prevKf)) : thisHide;
+    const nextHide = nextKf ? thisHide && hide(keyframeValue(nextKf)) : thisHide;
+    if (prevHide && !nextHide) {
+      out.push({ time: t, value: 0 });
+      out.push({ time: t + OPACITY_STEP_MS, value: 1 });
+    } else if (!prevHide && nextHide) {
+      out.push({ time: t - OPACITY_STEP_MS, value: 1 });
+      out.push({ time: t, value: 0 });
+    }
+  }
+  if (out.length <= 1) return void 0;
+  return { kind: "animated" /* Animated */, keyframes: out };
+}
+function readRangeWithCrossings(raw) {
+  const r = readAnimatable(raw);
+  if (r.kind !== "animated" /* Animated */) return r;
+  const kfs = r.keyframes.map((kf) => ({
+    time: keyframeTime(kf),
+    value: keyframeValue(kf),
+    easing: keyframeEasing(kf)
+  }));
+  const hasReverse = kfs.some((kf) => kf.value[0] > kf.value[1]);
+  if (!hasReverse) {
+    return {
+      kind: "animated" /* Animated */,
+      keyframes: kfs.map((kf) => ({ time: kf.time, value: kf.value, easing: kf.easing }))
+    };
+  }
+  const crossingTimes = [];
+  for (let i = 1; i < kfs.length; i++) {
+    const prev = kfs[i - 1];
+    const cur = kfs[i];
+    const dPrev = prev.value[1] - prev.value[0];
+    const dCur = cur.value[1] - cur.value[0];
+    if (dPrev * dCur < 0) {
+      const t = bisectionForRangeCrossing(prev, cur);
+      if (t !== null && t > prev.time && t < cur.time) {
+        crossingTimes.push(Math.round(t));
+      }
+    }
+  }
+  const uniqueTs = Array.from(new Set(crossingTimes)).sort((a, b) => a - b);
+  const out = [];
+  let j = 0;
+  for (const kf of kfs) {
+    while (j < uniqueTs.length && uniqueTs[j] < kf.time) {
+      const t = uniqueTs[j++];
+      const v2 = interpolateRangeAt(kfs, t);
+      const m = (v2[0] + v2[1]) / 2;
+      out.push({ time: t, value: [m, m] });
+    }
+    const v = kf.value[0] > kf.value[1] ? [kf.value[1], kf.value[0]] : kf.value;
+    out.push({ time: kf.time, value: v, easing: kf.easing });
+  }
+  while (j < uniqueTs.length) {
+    const t = uniqueTs[j++];
+    const v = interpolateRangeAt(kfs, t);
+    const m = (v[0] + v[1]) / 2;
+    out.push({ time: t, value: [m, m] });
+  }
+  return { kind: "animated" /* Animated */, keyframes: out };
+}
+function bisectionForRangeCrossing(prev, cur) {
+  const f = (t) => {
+    const a = (t - prev.time) / (cur.time - prev.time);
+    const v0 = prev.value[0] + (cur.value[0] - prev.value[0]) * a;
+    const v1 = prev.value[1] + (cur.value[1] - prev.value[1]) * a;
+    return v1 - v0;
+  };
+  let lo = prev.time, hi = cur.time;
+  let fLo = f(lo);
+  if (fLo === 0) return lo;
+  const fHi = f(hi);
+  if (fHi === 0) return hi;
+  if (fLo * fHi > 0) return null;
+  for (let i = 0; i < 100; i++) {
+    const mid = (lo + hi) / 2;
+    const fMid = f(mid);
+    if (fMid === 0 || Math.abs(hi - lo) < 1e-4) return mid;
+    if (fLo * fMid < 0) {
+      hi = mid;
+    } else {
+      lo = mid;
+      fLo = fMid;
+    }
+  }
+  return (lo + hi) / 2;
+}
+function interpolateRangeAt(kfs, t) {
+  if (t <= kfs[0].time) return kfs[0].value;
+  if (t >= kfs[kfs.length - 1].time) return kfs[kfs.length - 1].value;
+  for (let i = 1; i < kfs.length; i++) {
+    if (t <= kfs[i].time) {
+      const prev = kfs[i - 1];
+      const cur = kfs[i];
+      const a = (t - prev.time) / (cur.time - prev.time);
+      return [
+        prev.value[0] + (cur.value[0] - prev.value[0]) * a,
+        prev.value[1] + (cur.value[1] - prev.value[1]) * a
+      ];
+    }
+  }
+  return kfs[kfs.length - 1].value;
+}
+function pxBezierPathLength(path) {
+  const v = path.v;
+  if (!v || v.length < 2) return 0;
+  let total = 0;
+  for (let i = 0; i < v.length - 1; i++) {
+    total += segmentLength(path, i, i + 1);
+  }
+  if (path.c && v.length > 1) {
+    total += segmentLength(path, v.length - 1, 0);
+  }
+  return total;
+}
+function segmentLength(path, from, to) {
+  var _a2, _b, _c, _d;
+  const v = path.v;
+  const p0 = v[from];
+  const p3 = v[to];
+  const p1 = (_b = (_a2 = path.o) == null ? void 0 : _a2[from]) != null ? _b : p0;
+  const p2 = (_d = (_c = path.i) == null ? void 0 : _c[to]) != null ? _d : p3;
+  const lut = bezier2D_arcLengthLUT(p0, p1, p2, p3);
+  return lut.ds[lut.ds.length - 1];
+}
+var ARC_KAPPA = 0.5522847498307936;
+function shapeToPathD(node) {
+  var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (node.type === "rect") {
+    const x = Number((_a2 = node.x) != null ? _a2 : 0), y = Number((_b = node.y) != null ? _b : 0);
+    const w = Number((_c = node.width) != null ? _c : 0), h = Number((_d = node.height) != null ? _d : 0);
+    return "M" + (x + w) + "," + y + "L" + (x + w) + "," + (y + h) + "L" + x + "," + (y + h) + "L" + x + "," + y + "L" + (x + w) + "," + y + "z";
+  }
+  if (node.type === "ellipse" || node.type === "circle") {
+    const cx = Number((_e = node.cx) != null ? _e : 0), cy = Number((_f = node.cy) != null ? _f : 0);
+    const rx = node.type === "circle" ? Number((_g = node.r) != null ? _g : 0) : Number((_h = node.rx) != null ? _h : 0);
+    const ry = node.type === "circle" ? Number((_i = node.r) != null ? _i : 0) : Number((_j = node.ry) != null ? _j : 0);
+    if (!(rx > 0) || !(ry > 0)) return void 0;
+    const kx = rx * ARC_KAPPA, ky = ry * ARC_KAPPA;
+    const c = (x1, y1, x2, y2, x, y) => "C" + x1 + "," + y1 + " " + x2 + "," + y2 + " " + x + "," + y;
+    return "M" + (cx + rx) + "," + cy + c(cx + rx, cy + ky, cx + kx, cy + ry, cx, cy + ry) + c(cx - kx, cy + ry, cx - rx, cy + ky, cx - rx, cy) + c(cx - rx, cy - ky, cx - kx, cy - ry, cx, cy - ry) + c(cx + kx, cy - ry, cx + rx, cy - ky, cx + rx, cy) + "z";
+  }
+  return void 0;
+}
+
+// src/effects/PlayerEffectsUtil.ts
+function materializeNodeEffects(root) {
+  var _a2, _b;
+  const ctx = {
+    defs: [],
+    warnings: [],
+    errors: [],
+    idMap: /* @__PURE__ */ new Map(),
+    nextId: 0,
+    contentRefInnerIds: /* @__PURE__ */ new Map(),
+    maskAncestorChains: /* @__PURE__ */ new Map(),
+    // Resolved engine: `frames` ONLY when explicitly set; auto/waapi/unset →
+    // waapi (we're not 100% sure it's frames, and CSS/WAAPI need the inline form).
+    engine: resolveTimelineEngine((_a2 = getAnimatorConfig(root)) == null ? void 0 : _a2.engine),
+    glyphs: (_b = getDefinitions(root)) == null ? void 0 : _b.fonts
+  };
+  const working = clone(root);
+  indexById(working, ctx.idMap);
+  identifyContentRefTargets(working, ctx, () => genId(ctx, "inner"));
+  collectMaskAncestorChains(working, ctx);
+  const afterPass1 = applyPlayerEffects_exceptRetime(working, ctx);
+  const out = applyPlayerEffects_retime(afterPass1, ctx);
+  spliceDefs(out, ctx.defs);
+  return { root: out, defs: ctx.defs, warnings: ctx.warnings, errors: ctx.errors };
+}
+function applyPlayerEffects_exceptRetime(node, ctx) {
+  if (node.children) node.children = node.children.map((child) => applyPlayerEffects_exceptRetime(child, ctx));
+  const fx = node.effects;
+  const originalId = typeof node.id === "string" ? node.id : void 0;
+  const innerIdForContentRef = originalId ? ctx.contentRefInnerIds.get(originalId) : void 0;
+  if (!fx && !innerIdForContentRef) return node;
+  const { transformBy, repeater, maskedBy, clipPath, strokeTrim, clone: cloneFx, fillGradient, strokeGradient, textPath, text } = fx != null ? fx : {};
+  if (fx) delete node.effects;
+  let n = node;
+  let consumedByGlyphs = false;
+  if (text == null ? void 0 : text.useGlyphs) {
+    if (textPath) {
+      const pathD = typeof textPath.pathData === "string" ? textPath.pathData : void 0;
+      const glyphed = applyTextGlyphsAlongPath(n, ctx, pathD, textPath.startOffset, textPath.textLength, textPath.pathOverflow);
+      if (glyphed) {
+        n = glyphed;
+        consumedByGlyphs = true;
+      }
+    } else {
+      n = applyTextGlyphsEffect(n, text, ctx);
+      consumedByGlyphs = true;
+    }
+  }
+  if (!consumedByGlyphs) n = applyTextPathEffect(n, textPath, ctx);
+  n = applyFillGradientEffect(n, fillGradient, ctx);
+  n = applyStrokeGradientEffect(n, strokeGradient, ctx);
+  n = applyStrokeTrimEffect(n, strokeTrim, ctx);
+  n = applyRepeaterEffect(n, repeater, ctx);
+  n = applyMaskedByEffect(n, maskedBy, transformBy, ctx);
+  n = applyClipPathEffect(n, clipPath, ctx);
+  if (innerIdForContentRef) {
+    applyRefHref(n, cloneFx, ctx);
+    n = splitForContentRef(n, transformBy, originalId, innerIdForContentRef, ctx);
+  } else {
+    n = applyRefAndTransformationEffect(n, cloneFx, transformBy, ctx);
+  }
+  if (cloneFx == null ? void 0 : cloneFx.retime) node.effects = { clone: { retime: cloneFx.retime } };
+  if (originalId) ctx.idMap.set(originalId, n);
+  return n;
+}
+function applyPlayerEffects_retime(node, ctx) {
+  applyAllRetimeEffects(node, ctx);
+  return node;
+}
+
+// src/materialize/PxOffsetPathMaterializer.ts
+function cubicAt(p0, c1, c2, p1, t) {
+  const u = 1 - t;
+  const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
+  return [
+    a * p0[0] + b * c1[0] + c * c2[0] + d * p1[0],
+    a * p0[1] + b * c1[1] + c * c2[1] + d * p1[1]
+  ];
+}
+function cubicLength(p0, c1, c2, p1, steps = 64) {
+  let len = 0;
+  let prev = p0;
+  for (let i = 1; i <= steps; i++) {
+    const pt = cubicAt(p0, c1, c2, p1, i / steps);
+    len += Math.hypot(pt[0] - prev[0], pt[1] - prev[1]);
+    prev = pt;
+  }
+  return len;
+}
+var fmt2 = (n) => {
+  const r = Math.round(n * 1e4) / 1e4;
+  return Object.is(r, -0) ? "0" : String(r);
+};
+function buildOffsetPath(propAnim) {
+  var _a2, _b, _c;
+  if (propAnim.alongPathMode !== "offsetPath") return void 0;
+  const kfs = propAnim.keyframes;
+  if (!kfs || kfs.length < 2) return void 0;
+  const first = keyframeValue(kfs[0]);
+  const anchor = (first == null ? void 0 : first.origin) && first.origin.length >= 2 ? [first.origin[0], first.origin[1]] : [0, 0];
+  const points = [];
+  let keyframesCarryRotate = false;
+  for (const kf of kfs) {
+    const v = keyframeValue(kf);
+    const tr = v == null ? void 0 : v.translate;
+    if (!tr || tr.length < 2) return void 0;
+    const parts = Object.keys(v);
+    if (parts.some((p) => p !== TRANSFORM_PART.translate && p !== TRANSFORM_PART.origin && p !== TRANSFORM_PART.rotate)) return void 0;
+    if ((v == null ? void 0 : v.rotate) !== void 0) {
+      if (v.rotate !== 0) return void 0;
+      keyframesCarryRotate = true;
+    }
+    const o = (_a2 = v == null ? void 0 : v.origin) != null ? _a2 : [0, 0];
+    if (o[0] !== anchor[0] || o[1] !== anchor[1]) return void 0;
+    points.push([tr[0] + anchor[0], tr[1] + anchor[1]]);
+  }
+  if (!kfs.some((kf) => keyframeTangentIn(kf) || keyframeTangentOut(kf))) return void 0;
+  let d = "M" + fmt2(points[0][0]) + "," + fmt2(points[0][1]);
+  const segLens = [];
+  for (let i = 0; i < points.length - 1; i++) {
+    const p0 = points[i], p1 = points[i + 1];
+    const to = (_b = keyframeTangentOut(kfs[i])) != null ? _b : [0, 0];
+    const ti = (_c = keyframeTangentIn(kfs[i + 1])) != null ? _c : [0, 0];
+    const c1 = [p0[0] + to[0], p0[1] + to[1]];
+    const c2 = [p1[0] + ti[0], p1[1] + ti[1]];
+    d += "C" + fmt2(c1[0]) + "," + fmt2(c1[1]) + "," + fmt2(c2[0]) + "," + fmt2(c2[1]) + "," + fmt2(p1[0]) + "," + fmt2(p1[1]);
+    segLens.push(cubicLength(p0, c1, c2, p1));
+  }
+  const total = segLens.reduce((a, b) => a + b, 0);
+  if (!(total > 0)) return void 0;
+  const distanceKfs = [];
+  let cum = 0;
+  for (let i = 0; i < kfs.length; i++) {
+    if (i > 0) cum += segLens[i - 1];
+    const out = { t: keyframeTime(kfs[i]), v: cum / total };
+    const e = keyframeEasing(kfs[i]);
+    if (e !== void 0) out.e = e;
+    distanceKfs.push(out);
+  }
+  return { pathStr: d, distanceKfs, autoOrient: !!propAnim.autoOrient, anchor, keyframesCarryRotate };
+}
+function materializeOffsetPathsInTree(root) {
+  const walk = (node) => {
+    var _a2;
+    let out = node;
+    const anim = node.animate;
+    const transform = anim == null ? void 0 : anim["transform"];
+    if (transform) {
+      const built = buildOffsetPath(transform);
+      if (built) {
+        const newAnimate = __spreadValues({}, anim);
+        delete newAnimate[TRANSFORM_ATTR];
+        const distance = { keyframes: built.distanceKfs };
+        if (transform.loop !== void 0) distance.loop = transform.loop;
+        newAnimate[OFFSET_DISTANCE_ATTR] = distance;
+        const staticTr = node.transform;
+        let newTransform = staticTr;
+        if (staticTr && typeof staticTr === "object") {
+          const t = __spreadValues({}, staticTr);
+          delete t[TRANSFORM_PART.translate];
+          delete t[TRANSFORM_PART.origin];
+          if (built.keyframesCarryRotate) delete t[TRANSFORM_PART.rotate];
+          newTransform = Object.keys(t).length ? t : void 0;
+        }
+        out = __spreadProps(__spreadValues({}, node), {
+          animate: newAnimate,
+          style: __spreadProps(__spreadValues({}, node.style), {
+            offsetPath: "path('" + built.pathStr + "')",
+            offsetAnchor: fmt2(built.anchor[0]) + "px " + fmt2(built.anchor[1]) + "px",
+            offsetRotate: built.autoOrient ? "auto" : "0deg",
+            offsetDistance: "0%"
+          })
+        });
+        if (newTransform !== void 0) out.transform = newTransform;
+        else delete out.transform;
+      }
+    }
+    if ((_a2 = out.children) == null ? void 0 : _a2.length) {
+      const children = out.children.map(walk);
+      if (children.some((c, i) => c !== out.children[i])) out = __spreadProps(__spreadValues({}, out), { children });
+    }
+    return out;
+  };
+  return walk(root);
+}
+
+// src/materialize/PxAnimatorUseMaterializer.ts
+function materializeAnimatedUseInstances(root) {
+  var _a2;
+  const idMap = buildIdMap(root);
+  const animatedIds = computeAnimatedSubtreeIds(root, idMap);
+  if (animatedIds.size === 0) return root;
+  let idCounter = 0;
+  const genId3 = () => "_lw_use_mat_" + ++idCounter;
+  const rootViewport = readRootViewport(root);
+  const defsCollector = [];
+  const walked = walkAndMaterialize2(root, idMap, animatedIds, genId3, defsCollector, rootViewport);
+  if (defsCollector.length === 0) return walked;
+  const defsNode = { type: "defs", children: defsCollector };
+  const newChildren = [...(_a2 = walked.children) != null ? _a2 : [], defsNode];
+  return __spreadProps(__spreadValues({}, walked), { children: newChildren });
+}
+function readRootViewport(root) {
+  const vb = parseViewBox(root.viewBox);
+  if (vb) return [vb[2], vb[3]];
+  const w = numericAttr(root.width);
+  const h = numericAttr(root.height);
+  if (w !== void 0 && h !== void 0) return [w, h];
+  return [1, 1];
+}
+function numericAttr(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    const n = parseFloat(v);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function buildIdMap(root) {
+  const map = /* @__PURE__ */ new Map();
+  const visit = (n) => {
+    var _a2;
+    if (typeof n.id === "string") map.set(n.id, n);
+    (_a2 = n.children) == null ? void 0 : _a2.forEach(visit);
+  };
+  visit(root);
+  return map;
+}
+function computeAnimatedSubtreeIds(root, idMap) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  const result = /* @__PURE__ */ new Set();
+  const hasAnim = (n, visiting) => {
+    const cached = cache.get(n);
+    if (cached !== void 0) return cached;
+    if (visiting.has(n)) return false;
+    visiting.add(n);
+    let r = false;
+    if (n.animate && typeof n.animate === "object" && !Array.isArray(n.animate)) {
+      for (const _ in n.animate) {
+        r = true;
+        break;
+      }
+    }
+    if (!r && n.children) {
+      for (const ch of n.children) {
+        if (hasAnim(ch, visiting)) {
+          r = true;
+          break;
+        }
+      }
+    }
+    if (!r && n.type === "use" && typeof n.href === "string") {
+      const targetId = stripHash2(n.href);
+      const target = targetId ? idMap.get(targetId) : void 0;
+      if (target) r = hasAnim(target, visiting);
+    }
+    visiting.delete(n);
+    cache.set(n, r);
+    return r;
+  };
+  for (const [id, node] of idMap) {
+    if (hasAnim(node, /* @__PURE__ */ new Set())) result.add(id);
+  }
+  return result;
+}
+function stripHash2(href) {
+  if (typeof href !== "string") return void 0;
+  return href.startsWith("#") ? href.slice(1) : href;
+}
+function materializeOneUse(useNode, target, idMap, animatedIds, genId3, defsCollector, rootViewport) {
+  var _a2, _b, _c, _d;
+  const clone2 = deepClonePxNode(target);
+  regenerateIdsAndRewriteRefs(clone2, genId3);
+  const symbolViewBox = clone2.type === "symbol" ? parseViewBox(clone2.viewBox) : void 0;
+  const useW = (_b = (_a2 = numericAttr(useNode.width)) != null ? _a2 : symbolViewBox == null ? void 0 : symbolViewBox[2]) != null ? _b : rootViewport[0];
+  const useH = (_d = (_c = numericAttr(useNode.height)) != null ? _c : symbolViewBox == null ? void 0 : symbolViewBox[3]) != null ? _d : rootViewport[1];
+  const rewrittenClone = clone2.type === "symbol" ? rewriteSymbolRootToGroup(clone2, genId3, defsCollector, useW, useH) : clone2;
+  const materializedClone = walkAndMaterialize2(rewrittenClone, idMap, animatedIds, genId3, defsCollector, rootViewport);
+  const newNode = __spreadProps(__spreadValues({}, useNode), { type: "g", children: [materializedClone] });
+  delete newNode.href;
+  delete newNode.width;
+  delete newNode.height;
+  return applyUseOffsetToG(newNode);
+}
+function rewriteSymbolRootToGroup(symbolNode, genId3, defsCollector, useW, useH) {
+  const viewBox = parseViewBox(symbolNode.viewBox);
+  const g = __spreadProps(__spreadValues({}, symbolNode), { type: "g" });
+  delete g.viewBox;
+  delete g.preserveAspectRatio;
+  delete g.width;
+  delete g.height;
+  if (!viewBox) return g;
+  const [vbX, vbY, vbW, vbH] = viewBox;
+  const scale = vbW > 0 && vbH > 0 ? Math.min(useW / vbW, useH / vbH) : 1;
+  const xOff = (useW - vbW * scale) / 2;
+  const yOff = (useH - vbH * scale) / 2;
+  const parts = [];
+  if (xOff !== 0 || yOff !== 0) parts.push("translate(" + xOff + "," + yOff + ")");
+  if (scale !== 1) parts.push("scale(" + scale + ")");
+  if (vbX !== 0 || vbY !== 0) parts.push("translate(" + -vbX + "," + -vbY + ")");
+  if (parts.length) g.transform = parts.join("");
+  const clipId = genId3();
+  defsCollector.push({
+    type: "clipPath",
+    id: clipId,
+    children: [{ type: "rect", x: vbX, y: vbY, width: vbW, height: vbH }]
+  });
+  g.clipPath = "url(#" + clipId + ")";
+  return g;
+}
+function parseViewBox(v) {
+  if (typeof v !== "string") return void 0;
+  const parts = v.trim().split(/[\s,]+/).map(Number);
+  if (parts.length < 4 || parts.some((n) => !Number.isFinite(n))) return void 0;
+  return [parts[0], parts[1], parts[2], parts[3]];
+}
+function walkAndMaterialize2(node, idMap, animatedIds, genId3, defsCollector, rootViewport) {
+  if (node.type === "use" && typeof node.href === "string") {
+    const targetId = stripHash2(node.href);
+    if (targetId && animatedIds.has(targetId)) {
+      const target = idMap.get(targetId);
+      if (target) return materializeOneUse(node, target, idMap, animatedIds, genId3, defsCollector, rootViewport);
+    }
+  }
+  if (!node.children) return node;
+  let changed = false;
+  const newChildren = node.children.map((ch) => {
+    const m = walkAndMaterialize2(ch, idMap, animatedIds, genId3, defsCollector, rootViewport);
+    if (m !== ch) changed = true;
+    return m;
+  });
+  return changed ? __spreadProps(__spreadValues({}, node), { children: newChildren }) : node;
+}
+
+// src/materialize/PxRestPose.ts
+var TRANSFORM_CHANNEL = "transform";
+var REVERSED_DIRECTIONS = /* @__PURE__ */ new Set(["reverse", "alternate-reverse"]);
+var SCRATCH_ID_PREFIX = "__px_rest_";
+function materializeRestPosesInTree(root, engine) {
+  var _a2;
+  const out = deepClone(root);
+  const config = getAnimatorConfig(out) || {};
+  const duration = +(config.duration || PX_DEFAULT_DURATION_MS);
+  const firstFrameTime = REVERSED_DIRECTIONS.has(String(config.direction)) ? duration : 0;
+  const nodes = animatedNodes(out);
+  if (!nodes.size) return out;
+  const before = bindingsOf(out, engine);
+  const added = /* @__PURE__ */ new Map();
+  for (const [key, animate] of before) {
+    const node = nodes.get(key);
+    if (!node) continue;
+    for (const channel of Object.keys(animate)) {
+      if (!mayCarryRestPose(node, channel)) continue;
+      const value = firstFrameValue(animate, channel, firstFrameTime);
+      if (value === void 0) continue;
+      node[channel] = value;
+      added.set(key, [...(_a2 = added.get(key)) != null ? _a2 : [], channel]);
+    }
+  }
+  if (added.size) {
+    const after = bindingsOf(out, engine);
+    for (const [key, channels] of added) {
+      if (JSON.stringify(after.get(key)) === JSON.stringify(before.get(key))) continue;
+      const node = nodes.get(key);
+      if (node) for (const channel of channels) delete node[channel];
+    }
+  }
+  return out;
+}
+function mayCarryRestPose(node, channel) {
+  if (node[channel] !== void 0) return false;
+  if (PX_TRANSFORM_FN_NAMES.has(channel)) return false;
+  if (channel === TRANSFORM_CHANNEL) {
+    for (const part of PX_TRANSFORM_FN_NAMES) if (node[part] !== void 0) return false;
+  }
+  return true;
+}
+function firstFrameValue(animate, channel, timeMs) {
+  const values = Object.values(calcAnimationValues({ [channel]: animate[channel] }, timeMs));
+  return values.length === 1 && values[0] !== "" ? values[0] : void 0;
+}
+function bindingsOf(tree, engine) {
+  const scratch = deepClone(tree);
+  const keyById = /* @__PURE__ */ new Map();
+  for (const [key, node] of animatedNodes(scratch)) {
+    if (node.id === void 0) node.id = SCRATCH_ID_PREFIX + key;
+    keyById.set(String(node.id), key);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const binding of normalizeBindings(scratch, engine)) {
+    const key = keyById.get(binding.id);
+    if (key !== void 0) out.set(key, binding.animate);
+  }
+  return out;
+}
+function animatedNodes(tree) {
+  const out = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const visit = (node) => {
+    if (node.animate) out.set(String(counter++), node);
+    if (node.children) for (const child of node.children) visit(child);
+  };
+  if (tree.children) for (const child of tree.children) visit(child);
+  return out;
+}
+
+// src/materialize/PxAnimatorMaterializeAll.ts
+function materializeAllInTree(doc, engine, options) {
+  var _a2, _b;
+  let root = materializeNodeEffects(doc).root;
+  root = materializeOffsetPathsInTree(root);
+  const duration = (_b = (_a2 = getAnimatorConfig(root)) == null ? void 0 : _a2.duration) != null ? _b : PX_DEFAULT_DURATION_MS;
+  root = materializeInternalLoopsInTree(root, duration);
+  if (engine === PxTimelineEngine.native) {
+    root = materializeMotionPathsInTree(root, options == null ? void 0 : options.motionPath);
+    root = materializeAnimatedUseInstances(root);
+    root = pruneUnreferencedDefs(root);
+  }
+  root = materializeRestPosesInTree(root, engine);
+  return root;
+}
+function prepareDocumentForRender(doc) {
+  var _a2;
+  const engine = resolveTimelineEngine((_a2 = getAnimatorConfig(doc)) == null ? void 0 : _a2.engine);
+  return generateNewIds(materializeAllInTree(doc, engine));
+}
+function pruneUnreferencedDefs(root) {
+  const stripHash3 = (h) => h.startsWith("#") ? h.slice(1) : h;
+  const walk = (n, fn) => {
+    var _a2;
+    fn(n);
+    (_a2 = n.children) == null ? void 0 : _a2.forEach((c) => walk(c, fn));
+  };
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const referenced = /* @__PURE__ */ new Set();
+    walk(root, (n) => {
+      if (n.type === "use" && typeof n.href === "string") referenced.add(stripHash3(n.href));
+    });
+    walk(root, (n) => {
+      if (!n.children) return;
+      let kept = n.children;
+      if (n.type === "defs") {
+        kept = kept.filter((c) => !((c.type === "g" || c.type === "symbol") && typeof c.id === "string" && !referenced.has(c.id)));
+      }
+      kept = kept.filter((c) => !(c.type === "defs" && (!c.children || c.children.length === 0)));
+      if (kept.length !== n.children.length) {
+        n.children = kept;
+        changed = true;
+      }
+    });
+  }
+  return root;
+}
+
+// src/playback/PxDiagnosticCode.ts
+var PxDiagnosticCode = /* @__PURE__ */ ((PxDiagnosticCode2) => {
+  PxDiagnosticCode2[PxDiagnosticCode2["buildFailed"] = 1001] = "buildFailed";
+  PxDiagnosticCode2[PxDiagnosticCode2["invalidDocumentAtSrc"] = 1002] = "invalidDocumentAtSrc";
+  PxDiagnosticCode2[PxDiagnosticCode2["loadFailed"] = 1003] = "loadFailed";
+  PxDiagnosticCode2[PxDiagnosticCode2["animationBuildFailed"] = 1004] = "animationBuildFailed";
+  PxDiagnosticCode2[PxDiagnosticCode2["effectsShape"] = 1101] = "effectsShape";
+  PxDiagnosticCode2[PxDiagnosticCode2["timelineOverrideIgnored"] = 1102] = "timelineOverrideIgnored";
+  PxDiagnosticCode2[PxDiagnosticCode2["blockedTag"] = 1103] = "blockedTag";
+  PxDiagnosticCode2[PxDiagnosticCode2["unsupportedAnimatedAttrs"] = 1104] = "unsupportedAnimatedAttrs";
+  PxDiagnosticCode2[PxDiagnosticCode2["noBindings"] = 1105] = "noBindings";
+  PxDiagnosticCode2[PxDiagnosticCode2["unresolvedBinding"] = 1106] = "unresolvedBinding";
+  PxDiagnosticCode2[PxDiagnosticCode2["triggersNoRoot"] = 1201] = "triggersNoRoot";
+  PxDiagnosticCode2[PxDiagnosticCode2["noRootForSelector"] = 1202] = "noRootForSelector";
+  PxDiagnosticCode2[PxDiagnosticCode2["noRootElement"] = 1203] = "noRootElement";
+  PxDiagnosticCode2[PxDiagnosticCode2["noElementsForSelector"] = 1206] = "noElementsForSelector";
+  PxDiagnosticCode2[PxDiagnosticCode2["setAttributeNoElement"] = 1207] = "setAttributeNoElement";
+  PxDiagnosticCode2[PxDiagnosticCode2["scrollSmoothingNeedsOwnDriver"] = 1301] = "scrollSmoothingNeedsOwnDriver";
+  PxDiagnosticCode2[PxDiagnosticCode2["scrollNativeUnavailable"] = 1302] = "scrollNativeUnavailable";
+  PxDiagnosticCode2[PxDiagnosticCode2["scrollSubjectInvalid"] = 1303] = "scrollSubjectInvalid";
+  PxDiagnosticCode2[PxDiagnosticCode2["scrollSubjectNoMatch"] = 1304] = "scrollSubjectNoMatch";
+  PxDiagnosticCode2[PxDiagnosticCode2["scrollNoRootToObserve"] = 1305] = "scrollNoRootToObserve";
+  PxDiagnosticCode2[PxDiagnosticCode2["scrollTriggerIgnored"] = 1306] = "scrollTriggerIgnored";
+  PxDiagnosticCode2[PxDiagnosticCode2["rateRejected"] = 1401] = "rateRejected";
+  PxDiagnosticCode2[PxDiagnosticCode2["controlPropsConflict"] = 1501] = "controlPropsConflict";
+  PxDiagnosticCode2[PxDiagnosticCode2["rnCompileFailed"] = 1601] = "rnCompileFailed";
+  PxDiagnosticCode2[PxDiagnosticCode2["rnRenderFailed"] = 1602] = "rnRenderFailed";
+  PxDiagnosticCode2[PxDiagnosticCode2["rnBoundaryCaught"] = 1603] = "rnBoundaryCaught";
+  PxDiagnosticCode2[PxDiagnosticCode2["rnUnsupported"] = 1604] = "rnUnsupported";
+  return PxDiagnosticCode2;
+})(PxDiagnosticCode || {});
+
 // src/playback/PxDiagnostics.ts
 var PxDiagnosticKind = {
   /** The document is wrong — regenerate or repair the file. */
@@ -4427,6 +6403,7 @@ function reportDocumentDiagnostics(doc, where) {
 export {
   __spreadValues,
   __spreadProps,
+  __objRest,
   PX_UNKNOWN_KEY_ERROR,
   schemaKeys,
   describeSchema,
@@ -4450,8 +6427,9 @@ export {
   PxPlaybackDirection,
   PX_ANIM_SRC_ATTR_NAME,
   PX_ANIM_ATTR_NAME,
-  PxStartOn,
-  PxOutAction,
+  PxTriggerStart,
+  PxOffScreenAction,
+  PxMouseOutAction,
   PxFinishAction,
   PxScrollKind,
   PxScrollAxis,
@@ -4482,9 +6460,6 @@ export {
   PxTextPathSpacing,
   PxStrokeTrimSubPaths,
   PX_TEXT_CONTENT_ATTR,
-  TRANSFORM_ATTR,
-  OFFSET_DISTANCE_ATTR,
-  TRANSFORM_PART,
   PX_TRANSFORM_PART_KEYS,
   PxGradientSpreadMethod,
   PxGradientType,
@@ -4497,11 +6472,8 @@ export {
   getChildren,
   PxKeyframeValueSchema,
   PxKeyframeSchema,
-  keyframeTime,
   keyframeValue,
   keyframeEasing,
-  keyframeTangentIn,
-  keyframeTangentOut,
   PxLoopSchema,
   PxPropertyAnimationSchema,
   PxTransformPartsSchema,
@@ -4553,45 +6525,28 @@ export {
   kebabToCamelCaseWord,
   camelCaseToKebabWordIfNeeded,
   clamp,
-  bezier2D_arcLengthLUT,
   PX_DISALLOWED_SVG_TAGS_LOWER,
   PX_CSS_ONLY_STYLE_PROPS,
   sanitizeAttributeValue,
   toDomProps,
+  mergeStaticTransformIntoAnimDef,
   materializeMotionPathInPropAnim,
-  materializeMotionPathsInTree,
   PX_LOOP_JUMP_SHIFT_MS,
-  parseSvgPathToBezier,
   interpolateValue,
-  materializeInternalLoopsInTree,
-  mergeStaticTransformIntoAnimDef,
   normalizeBindings,
   calcAnimationValues,
-  partsRecord,
-  readAnimatable,
-  writeAnimatableChannel,
-  readStaticOrigin,
-  keyframeWith,
-  deepClonePxNode,
-  regenerateIdsAndRewriteRefs,
-  applyUseOffsetToG,
-  genId,
-  stripHash,
-  indexById,
-  spliceDefs,
-  clone,
-  regenerateIdsInClone,
   createPathSampler,
   extendedPathForBrowser,
-  applyTextPathEffect,
   layoutGlyphTextChars,
   materializeGlyphTextAlongPath,
   materializeGlyphText,
-  applyTextGlyphsEffect,
-  applyTextGlyphsAlongPath,
+  materializeNodeEffects,
+  materializeAllInTree,
+  prepareDocumentForRender,
+  PxDiagnosticCode,
   PxDiagnosticKind,
   createDiagnostics,
   diagnoseDocument,
   reportDocumentDiagnostics
 };
-//# sourceMappingURL=chunk-BOTZI36B.js.map
+//# sourceMappingURL=chunk-YVKMPBHE.js.map