@pixodesk/svg-animator-core 1.0.44 → 1.0.45

package/dist/internal.cjs

@@ -85,7 +85,9 @@ __export(internal_exports, {
   materializeMotionPathInPropAnim: () => materializeMotionPathInPropAnim,
   mergeStaticTransformIntoAnimDef: () => mergeStaticTransformIntoAnimDef,
   planSchemaRelease: () => planSchemaRelease,
+  prepareDocumentForRender: () => prepareDocumentForRender,
   releaseLogProblems: () => releaseLogProblems,
+  renderPxTree: () => renderPxTree,
   reportDocumentDiagnostics: () => reportDocumentDiagnostics,
   reverseEasing: () => reverseEasing,
   sanitizeAttributeValue: () => sanitizeAttributeValue,
@@ -711,6 +713,9 @@ var PxTimelineEngine = {
 var PxTimelineEngineSetting = __spreadProps(__spreadValues({}, PxTimelineEngine), {
   auto: "auto"
 });
+function resolveTimelineEngine(engine) {
+  return engine === PxTimelineEngineSetting.js ? PxTimelineEngine.js : PxTimelineEngine.native;
+}
 var PX_TRIGGER_DEFAULTS = {
   start: "load",
   offScreen: "pause",
@@ -767,6 +772,16 @@ var PxStrokeTrimSubPaths = {
 var PX_TEXT_CONTENT_ATTR = "textContent";
 var CLASS_ATTR = "class";
 var TRANSFORM_ATTR = "transform";
+var OFFSET_DISTANCE_ATTR = "offsetDistance";
+var INTERNAL_ATTRS = /* @__PURE__ */ new Set([
+  "type",
+  "children",
+  "animator",
+  "meta",
+  "animate",
+  "effects",
+  PX_TEXT_CONTENT_ATTR
+]);
 var TRANSFORM_PART = {
   translate: "translate",
   rotate: "rotate",
@@ -847,6 +862,16 @@ function flattenAnimatorTimeline(cfg) {
   flattenMemo.set(cfg, flat);
   return flat;
 }
+function getDefinitions(doc) {
+  var _a2;
+  if (!doc) return void 0;
+  return (_a2 = getAnimatorConfig(doc)) == null ? void 0 : _a2.definitions;
+}
+function getBindings(doc) {
+  var _a2;
+  if (!doc) return void 0;
+  return (_a2 = getAnimatorConfig(doc)) == null ? void 0 : _a2.bindings;
+}
 
 // src/version/PxSchemaVersion.ts
 var PX_WIRE_SCHEMA_VERSION = "1.2";
@@ -1407,6 +1432,11 @@ function interpolateBezier(path1, path2, progress) {
   }
   return { v, i: i.length ? i : void 0, o: o.length ? o : void 0, c: (_i = path1.c) != null ? _i : path2.c };
 }
+function remap(value, inMin, inMax, outMin, outMax) {
+  if (inMax === inMin) return outMin;
+  const t = (value - inMin) / (inMax - inMin);
+  return outMin + t * (outMax - outMin);
+}
 function solveCubicBezierX(p1x, p2x, x) {
   if (x <= 0) return 0;
   if (x >= 1) return 1;
@@ -1511,6 +1541,43 @@ function toRGBA(color) {
   const b = Math.round(color[2] * 255);
   return color.length === 4 ? "rgba(" + r + "," + g + "," + b + "," + color[3] + ")" : "rgb(" + r + "," + g + "," + b + ")";
 }
+function parseRgba(s) {
+  var _a2;
+  const inner = (_a2 = s.match(/rgba?\((.*)\)/)) == null ? void 0 : _a2[1];
+  if (!inner) throw new Error("Invalid rgb/rgba format");
+  const parts = inner.split(",").map((v) => +v.trim());
+  return [parts[0] / 255, parts[1] / 255, parts[2] / 255, ...parts[3] !== void 0 ? [parts[3]] : []];
+}
+function parseHex(s) {
+  const hex = s.slice(1);
+  const isShort = hex.length <= 4;
+  const r = isShort ? hex[0] + hex[0] : hex.slice(0, 2);
+  const g = isShort ? hex[1] + hex[1] : hex.slice(2, 4);
+  const b = isShort ? hex[2] + hex[2] : hex.slice(4, 6);
+  const a = hex.length === 4 ? hex[3] + hex[3] : hex.length === 8 ? hex.slice(6, 8) : null;
+  const result = [
+    parseInt(r, 16) / 255,
+    parseInt(g, 16) / 255,
+    parseInt(b, 16) / 255
+  ];
+  if (a !== null) {
+    result.push(parseInt(a, 16) / 255);
+  }
+  return result;
+}
+function parseColor(s) {
+  if (!s) return void 0;
+  if (Array.isArray(s)) return s;
+  if (typeof s !== "string") return void 0;
+  if (s.startsWith("#")) {
+    return parseHex(s);
+  } else if (s.startsWith("rgb")) {
+    return parseRgba(s);
+  } else {
+    console.warn("Unsupported color format: " + s);
+  }
+  return void 0;
+}
 var PX_COLOR_ATTR_NAMES = /* @__PURE__ */ new Set(["color", "fill", "flood-color", "lighting-color", "stop-color", "stroke"]);
 var PX_TRANSFORM_FN_NAMES = /* @__PURE__ */ new Set(["translate", "rotate", "scale", "skew"]);
 var PX_PCT_BASED_ATTR_NAMES = /* @__PURE__ */ new Set(["offset-distance", "offsetDistance"]);
@@ -1571,6 +1638,9 @@ var PX_DEFAULT_DURATION_MS = 1e3;
 function kebabToCamelCaseWord(kebab) {
   return kebab.includes("-") ? kebab.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()) : kebab;
 }
+function isCamelCaseWord(word) {
+  return !word.includes("-") && /[a-z][A-Z]/.test(word);
+}
 var SVG_CAMEL_CASE_ATTRS = /* @__PURE__ */ new Set([
   // Transform/positioning
   "viewBox",
@@ -1726,6 +1796,38 @@ function invertEasing(easing) {
   return cubicBezier(flipped);
 }
 
+// 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);
@@ -1777,6 +1879,33 @@ function getSegmentCache(prevKf, nextKf, prevPos, nextPos) {
   byNext.set(nextKf, entry);
   return entry;
 }
+function evaluateMotionPathSegment(prevKf, nextKf, prevPos, nextPos, localProgress, autoOrient) {
+  const seg = getSegmentCache(prevKf, nextKf, prevPos, nextPos);
+  const t = seg.totalArc === 0 ? localProgress : tFromArcFraction(seg.lut, localProgress);
+  const point = bezier2D_pointAt(seg.P0, seg.P1, seg.P2, seg.P3, t);
+  if (!autoOrient) return { translate: point };
+  const tan = bezier2D_derivativeAt(seg.P0, seg.P1, seg.P2, seg.P3, t);
+  const rotateDeg = Math.atan2(tan[1], tan[0]) * 180 / Math.PI;
+  return { translate: point, rotateDeg };
+}
+function tFromArcFraction(lut, arcFrac) {
+  const total = lut.ds[lut.ds.length - 1];
+  const target = arcFrac * total;
+  const { ts, ds } = lut;
+  const last = ds.length - 1;
+  if (target <= 0) return ts[0];
+  if (target >= ds[last]) return ts[last];
+  let lo = 1, hi = last;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (ds[mid] < target) lo = mid + 1;
+    else hi = mid;
+  }
+  const dPrev = ds[hi - 1];
+  const span = ds[hi] - dPrev;
+  const frac = span > 0 ? (target - dPrev) / span : 0;
+  return ts[hi - 1] + frac * (ts[hi] - ts[hi - 1]);
+}
 var DEFAULT_FLATNESS_TOL = 0.5;
 var DEFAULT_ROTATION_TOL = 5;
 var DEFAULT_MAX_SAMPLES = 32;
@@ -2049,9 +2178,211 @@ function perpDist(q, pA, pB) {
   const cross = (q[0] - pA[0]) * dy - (q[1] - pA[1]) * dx;
   return Math.abs(cross) / Math.sqrt(len2);
 }
+function materializeMotionPathsInTree(root, opts) {
+  const out = walkAndMaterialize(root, opts);
+  return out != null ? out : root;
+}
+function walkAndMaterialize(node, opts) {
+  let newChildren;
+  if (node.children) {
+    for (let i = 0; i < node.children.length; i++) {
+      const ch = node.children[i];
+      const ret = walkAndMaterialize(ch, opts);
+      if (ret !== null) {
+        if (!newChildren) newChildren = node.children.slice();
+        newChildren[i] = ret;
+      }
+    }
+  }
+  let newAnimate;
+  const animBucket = node.animate;
+  if (animBucket && typeof animBucket === "object" && !Array.isArray(animBucket)) {
+    const animDef = mergeStaticTransformIntoAnimDef(animBucket, node.transform);
+    const transformAnim = animDef.transform;
+    if (transformAnim && typeof transformAnim === "object" && propAnimIsMotionPath(transformAnim)) {
+      const materialized = materializeMotionPathInPropAnim(transformAnim, opts);
+      if (materialized !== transformAnim) {
+        newAnimate = __spreadProps(__spreadValues({}, animDef), { transform: materialized });
+      }
+    }
+  }
+  if (!newChildren && !newAnimate) return null;
+  const cloned = __spreadValues({}, node);
+  if (newChildren) cloned.children = newChildren;
+  if (newAnimate) cloned.animate = newAnimate;
+  return cloned;
+}
 
 // src/animation/PxDefinitions.ts
 var PX_LOOP_JUMP_SHIFT_MS = 1;
+function deepEqualValue(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b || a === null || b === null || typeof a !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  return ka.every((k) => deepEqualValue(a[k], b[k]));
+}
+function parsePathCommands(d) {
+  const tokens = d.split(/([MLCZmlcz]|[\s,]+)/).map((t) => t.trim()).filter((t) => t && t !== ",");
+  const commands = [];
+  let currentCommand = null;
+  for (const token of tokens) {
+    if (/[MLCZmlcz]/.test(token)) {
+      currentCommand = { type: token, values: [] };
+      commands.push(currentCommand);
+    } else if (currentCommand) {
+      const value = +token;
+      currentCommand.values.push(Number.isNaN(value) ? 0 : value);
+    }
+  }
+  return commands;
+}
+function parseSvgPathToBezier(d) {
+  const res = [];
+  let currentPath;
+  const commands = parsePathCommands(d);
+  for (const command of commands) {
+    const type = command.type;
+    const values = command.values;
+    if (type === "M" || type === "m") {
+      const x = values[0] || 0;
+      const y = values[1] || 0;
+      currentPath = {
+        v: [[x, y]],
+        i: [[x, y]],
+        o: [[x, y]],
+        c: false
+      };
+      res.push(currentPath);
+      continue;
+    }
+    if (!currentPath) {
+      currentPath = {
+        v: [[0, 0]],
+        i: [[0, 0]],
+        o: [[0, 0]],
+        c: false
+      };
+      res.push(currentPath);
+    }
+    if (type === "L") {
+      const x = values[0] || 0;
+      const y = values[1] || 0;
+      currentPath.v.push([x, y]);
+      currentPath.i.push([x, y]);
+      currentPath.o.push([x, y]);
+    } else if (type === "C") {
+      const outX = values[0] || 0;
+      const outY = values[1] || 0;
+      const inX2 = values[2] || 0;
+      const inY2 = values[3] || 0;
+      const x2 = values[4] || 0;
+      const y2 = values[5] || 0;
+      currentPath.o[currentPath.o.length - 1] = [outX, outY];
+      currentPath.v.push([x2, y2]);
+      currentPath.i.push([inX2, inY2]);
+      currentPath.o.push([x2, y2]);
+    } else if (type === "Z" || type === "z") {
+      currentPath.c = true;
+    } else {
+      console.warn('Unsupported path command "' + type + '"');
+    }
+  }
+  return res;
+}
+function extractPathData(str2) {
+  if (str2.startsWith("path(") && str2.endsWith(")")) {
+    return str2.slice(5, -1);
+  }
+  if (/^[MmZzLlHhVvCcSsQqTtAa]/.test(str2)) {
+    return str2;
+  }
+  return void 0;
+}
+function isPathString(value) {
+  return typeof value === "string" && extractPathData(value) !== void 0;
+}
+function normalizePathValue(value) {
+  if (value && typeof value === "object" && typeof value.pathData === "string") {
+    const d = extractPathData(value.pathData);
+    return d ? { paths: parseSvgPathToBezier(d) } : value;
+  }
+  if (value && typeof value === "object" && "paths" in value) {
+    const pathsArray = value.paths;
+    if (Array.isArray(pathsArray) && pathsArray.length > 0) {
+      if (isPathString(pathsArray[0])) {
+        const paths = [];
+        for (const pathStr2 of pathsArray) {
+          const d = extractPathData(pathStr2);
+          if (d) {
+            paths.push(...parseSvgPathToBezier(d));
+          }
+        }
+        return { paths };
+      }
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (value.length > 0 && isPathString(value[0])) {
+      const paths = [];
+      for (const pathStr2 of value) {
+        const d = extractPathData(pathStr2);
+        if (d) {
+          paths.push(...parseSvgPathToBezier(d));
+        }
+      }
+      return { paths };
+    }
+    return { paths: value };
+  }
+  if (isPathString(value)) {
+    const d = extractPathData(value);
+    return { paths: parseSvgPathToBezier(d) };
+  }
+  return value;
+}
+function resolveEasing(easing, defs) {
+  var _a2;
+  if (!easing) return void 0;
+  if (Array.isArray(easing)) {
+    return easing;
+  }
+  if ((_a2 = defs == null ? void 0 : defs.easings) == null ? void 0 : _a2[easing]) {
+    return defs.easings[easing];
+  }
+  console.warn("Unknown easing name: " + easing);
+  return void 0;
+}
+function resolveAnimation(animRef, defs) {
+  var _a2;
+  if (typeof animRef === "string") {
+    const resolved = (_a2 = defs == null ? void 0 : defs.animations) == null ? void 0 : _a2[animRef];
+    if (!resolved) {
+      console.warn("Unknown animation name: " + animRef);
+    }
+    return resolved;
+  }
+  return animRef;
+}
+function resolveElementAnimation(animate, defs) {
+  if (!animate) return [];
+  const results = [];
+  if (typeof animate === "string") {
+    const resolved = resolveAnimation(animate, defs);
+    if (resolved) results.push(resolved);
+  } else if (Array.isArray(animate)) {
+    for (const item of animate) {
+      const resolved = resolveAnimation(item, defs);
+      if (resolved) results.push(resolved);
+    }
+  } else {
+    results.push(animate);
+  }
+  return results;
+}
 function interpolateValue(propName, a, b, t) {
   var _a2, _b;
   if (propName === "d") {
@@ -2090,35 +2421,498 @@ function interpolateTransformParts(a, b, t) {
   }
   return out;
 }
-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 });
+function expandLoopKeyframes(propName, keyframes, loop, duration) {
+  var _a2, _b, _c, _d, _e;
+  const totalIntervals = keyframes.length - 1;
+  const segCount = clamp((_a2 = loop.segmentCount) != null ? _a2 : totalIntervals, 1, totalIntervals);
+  let segKfs;
+  if (loop.repeatAt === PxLoopRepeatAt.start) {
+    segKfs = keyframes.slice(0, segCount + 1);
+  } else {
+    segKfs = keyframes.slice(totalIntervals - segCount);
+  }
+  const firstT = (_b = keyframes[0].t) != null ? _b : 0;
+  const lastT = (_c = keyframes[keyframes.length - 1].t) != null ? _c : 0;
+  let fillStart, fillEnd;
+  if (loop.repeatAt === PxLoopRepeatAt.start) {
+    fillStart = 0;
+    fillEnd = firstT;
+  } else {
+    fillStart = lastT;
+    fillEnd = duration;
+  }
+  const fillDuration = fillEnd - fillStart;
+  if (fillDuration <= 0) return keyframes;
+  const segStartT = (_d = segKfs[0].t) != null ? _d : 0;
+  const segEndT = (_e = segKfs[segKfs.length - 1].t) != null ? _e : 0;
+  const segDuration = segEndT - segStartT;
+  if (segDuration <= 0) return keyframes;
+  const template = segKfs.map((kf) => ({
+    relT: (kf.t - segStartT) / segDuration,
+    v: kf.v,
+    e: kf.e,
+    tangentIn: keyframeTangentIn(kf),
+    tangentOut: keyframeTangentOut(kf)
+  }));
+  const fullReps = Math.floor(fillDuration / segDuration);
+  const remainder = fillDuration - fullReps * segDuration;
+  const partialFraction = remainder / segDuration;
+  const looped = [];
+  const separateBoundary = loop.repeatAt !== PxLoopRepeatAt.start;
+  const originalTerminalKf = keyframes[keyframes.length - 1];
+  let terminalEasingOverride;
+  let hasTerminalEasingOverride = false;
+  function appendRep(repStart, isReversed, partial) {
+    var _a3;
+    let entries;
+    if (isReversed) {
+      entries = [];
+      for (let i = template.length - 1; i >= 0; i--) {
+        entries.push({
+          relT: 1 - template[i].relT,
+          v: template[i].v,
+          // Easing for reversed transition: use reversed easing from the forward "from" keyframe
+          e: i > 0 ? reverseEasing(template[i - 1].e) : void 0,
+          // Reversed traversal swaps each vertex's in/out spatial tangents
+          // (geometry is identical, walked backwards), so curvature and
+          // auto-orientation survive the reversed rep.
+          tangentIn: template[i].tangentOut,
+          tangentOut: template[i].tangentIn
+        });
+      }
+    } else {
+      entries = template;
+    }
+    const cutRelT = partial !== void 0 ? partial : 1;
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry.relT > cutRelT + 1e-9) {
+        const prev = entries[i - 1];
+        const intervalSpan = entry.relT - prev.relT;
+        const localFrac = (cutRelT - prev.relT) / intervalSpan;
+        const easedFrac = prev.e ? cubicBezier(prev.e)(localFrac) : localFrac;
+        const cutValue = interpolateValue(propName, prev.v, entry.v, easedFrac);
+        const { left: leftEasing } = splitEasing(prev.e, localFrac);
+        if (looped.length > 0 && prev.relT <= cutRelT) {
+          looped[looped.length - 1].e = leftEasing;
+        }
+        looped.push({ t: repStart + cutRelT * segDuration, v: cutValue, e: void 0 });
+        return;
+      }
+      const prevKf = looped.length > 0 ? looped[looped.length - 1] : originalTerminalKf;
+      const isBoundary = separateBoundary && i === 0 && prevKf !== void 0 && Math.abs(((_a3 = prevKf.t) != null ? _a3 : 0) - (repStart + entry.relT * segDuration)) < 1e-9;
+      if (isBoundary) {
+        if (deepEqualValue(prevKf.v, entry.v)) {
+          if (looped.length > 0) {
+            prevKf.e = entry.e;
+            prevKf.tangentOut = entry.tangentOut;
+          } else {
+            terminalEasingOverride = entry.e;
+            hasTerminalEasingOverride = true;
+          }
+          continue;
+        }
+        if (looped.length > 0) {
+          delete prevKf.tangentIn;
+          delete prevKf.tangentOut;
+        }
+      }
+      const pushed = {
+        t: repStart + entry.relT * segDuration + (isBoundary ? PX_LOOP_JUMP_SHIFT_MS : 0),
+        v: entry.v,
+        e: i < entries.length - 1 ? entry.e : void 0
+      };
+      if (entry.tangentIn) pushed.tangentIn = entry.tangentIn;
+      if (entry.tangentOut) pushed.tangentOut = entry.tangentOut;
+      looped.push(pushed);
     }
-    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 }) }))
+  function appendRepTail(repStart, isReversed, tailFraction) {
+    let entries;
+    if (isReversed) {
+      entries = [];
+      for (let i = template.length - 1; i >= 0; i--) {
+        entries.push({
+          relT: 1 - template[i].relT,
+          v: template[i].v,
+          e: i > 0 ? reverseEasing(template[i - 1].e) : void 0,
+          tangentIn: template[i].tangentOut,
+          tangentOut: template[i].tangentIn
+        });
+      }
+    } else {
+      entries = template;
+    }
+    const startRelT = 1 - tailFraction;
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry.relT < startRelT - 1e-9) continue;
+      const prev = entries[i - 1];
+      if (prev && prev.relT < startRelT - 1e-9 && entry.relT > startRelT + 1e-9) {
+        const intervalSpan = entry.relT - prev.relT;
+        const localFrac = (startRelT - prev.relT) / intervalSpan;
+        const easedFrac = prev.e ? cubicBezier(prev.e)(localFrac) : localFrac;
+        const startValue = interpolateValue(propName, prev.v, entry.v, easedFrac);
+        const { right: rightEasing } = splitEasing(prev.e, localFrac);
+        looped.push({ t: repStart, v: startValue, e: rightEasing });
+      }
+      const pushed = {
+        t: repStart + (entry.relT - startRelT) * segDuration,
+        v: entry.v,
+        e: i < entries.length - 1 ? entry.e : void 0
+      };
+      if (entry.tangentIn) pushed.tangentIn = entry.tangentIn;
+      if (entry.tangentOut) pushed.tangentOut = entry.tangentOut;
+      looped.push(pushed);
+    }
+  }
+  if (loop.repeatAt === PxLoopRepeatAt.start) {
+    if (partialFraction > 1e-9) {
+      const isReversed = loop.direction === PxLoopDirection.alternate && fullReps % 2 === 0;
+      appendRepTail(fillStart, isReversed, partialFraction);
+    }
+    for (let rep = 0; rep < fullReps; rep++) {
+      const distFromBoundary = fullReps - 1 - rep;
+      const isReversed = loop.direction === PxLoopDirection.alternate && distFromBoundary % 2 === 0;
+      const repStart = fillStart + remainder + rep * segDuration;
+      appendRep(repStart, isReversed);
+    }
+  } else {
+    for (let rep = 0; rep < fullReps; rep++) {
+      const isReversed = loop.direction === PxLoopDirection.alternate && rep % 2 === 0;
+      const repStart = fillStart + rep * segDuration;
+      appendRep(repStart, isReversed);
+    }
+    if (partialFraction > 1e-9) {
+      const isReversed = loop.direction === PxLoopDirection.alternate && fullReps % 2 === 0;
+      const repStart = fillStart + fullReps * segDuration;
+      appendRep(repStart, isReversed, partialFraction);
+    }
+  }
+  if (loop.repeatAt === PxLoopRepeatAt.start) {
+    return [...looped, ...keyframes];
+  } else {
+    if (hasTerminalEasingOverride && keyframes.length > 0) {
+      const head = keyframes.slice(0, -1);
+      const tail = __spreadProps(__spreadValues({}, keyframes[keyframes.length - 1]), { e: terminalEasingOverride });
+      return [...head, tail, ...looped];
+    }
+    return [...keyframes, ...looped];
+  }
+}
+function normalizeKeyframes(propName, propAnim, duration, defs) {
+  var _a2;
+  const keyframes = propAnim.keyframes || [];
+  const normalized = [];
+  for (const kf of keyframes) {
+    const timePct = keyframeTime(kf);
+    let value = keyframeValue(kf);
+    const easing = keyframeEasing(kf);
+    if (propName === "d") {
+      value = normalizePathValue(value);
+    }
+    const propNameKebab = isCamelCaseWord(propName) ? camelCaseToKebabWordIfNeeded(propName) : propName;
+    if (PX_COLOR_ATTR_NAMES.has(propNameKebab)) {
+      value = (_a2 = parseColor(value)) != null ? _a2 : value;
+    }
+    const normKf = {
+      t: timePct,
+      v: value,
+      e: resolveEasing(easing, defs)
+    };
+    const tIn = keyframeTangentIn(kf);
+    const tOut = keyframeTangentOut(kf);
+    if (tIn) normKf.tangentIn = tIn;
+    if (tOut) normKf.tangentOut = tOut;
+    normalized.push(normKf);
+  }
+  normalized.sort((a, b) => {
+    var _a3, _b;
+    return ((_a3 = a.t) != null ? _a3 : 0) - ((_b = b.t) != null ? _b : 0);
   });
-  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 });
+  const loopRaw = propAnim.loop;
+  const loop = loopRaw === true ? {} : loopRaw || void 0;
+  if (loop && normalized.length >= 2) {
+    return expandLoopKeyframes(propName, normalized, loop, duration);
+  }
+  return normalized;
+}
+function mergeAnimationDefinitions(animations) {
+  const merged = {};
+  for (const anim of animations) {
+    for (const [prop, propAnim] of Object.entries(anim)) {
+      merged[prop] = propAnim;
+    }
+  }
+  return merged;
+}
+function materializeInternalLoopsInPropAnim(propName, propAnim, duration) {
+  const loopRaw = propAnim.loop;
+  if (loopRaw === void 0 || loopRaw === null || loopRaw === false) return propAnim;
+  const loop = loopRaw === true ? {} : loopRaw;
+  const rawKfs = propAnim.keyframes;
+  if (!Array.isArray(rawKfs) || rawKfs.length < 2) return propAnim;
+  const propNameKebab = isCamelCaseWord(propName) ? camelCaseToKebabWordIfNeeded(propName) : propName;
+  const isColor = PX_COLOR_ATTR_NAMES.has(propNameKebab);
+  const kfs = rawKfs.map((kf) => {
+    var _a2;
+    const t = keyframeTime(kf);
+    let v = keyframeValue(kf);
+    if (propName === "d") v = normalizePathValue(v);
+    if (isColor) v = (_a2 = parseColor(v)) != null ? _a2 : v;
+    const e = keyframeEasing(kf);
+    const out2 = { t, v, e };
+    const tIn = keyframeTangentIn(kf);
+    const tOut = keyframeTangentOut(kf);
+    if (tIn) out2.tangentIn = tIn;
+    if (tOut) out2.tangentOut = tOut;
+    return out2;
+  });
+  const expanded = expandLoopKeyframes(propName, kfs, loop, duration);
+  const out = { keyframes: expanded };
+  if (propAnim.autoOrient !== void 0) out.autoOrient = propAnim.autoOrient;
+  return out;
+}
+function materializeInternalLoopsInTree(root, duration) {
+  const ret = walkAndMaterializeLoops(root, duration);
+  return ret != null ? ret : root;
+}
+function walkAndMaterializeLoops(node, duration) {
+  let newChildren;
+  if (node.children) {
+    for (let i = 0; i < node.children.length; i++) {
+      const ret = walkAndMaterializeLoops(node.children[i], duration);
+      if (ret !== null) {
+        if (!newChildren) newChildren = node.children.slice();
+        newChildren[i] = ret;
+      }
+    }
+  }
+  let newAnimate;
+  const animBucket = node.animate;
+  if (animBucket && typeof animBucket === "object" && !Array.isArray(animBucket)) {
+    const animDef = animBucket;
+    for (const propName of Object.keys(animDef)) {
+      const propAnim = animDef[propName];
+      const materialized = materializeInternalLoopsInPropAnim(propName, propAnim, duration);
+      if (materialized !== propAnim) {
+        if (!newAnimate) newAnimate = __spreadValues({}, animDef);
+        newAnimate[propName] = materialized;
+      }
+    }
+  }
+  if (!newChildren && !newAnimate) return null;
+  const cloned = __spreadValues({}, node);
+  if (newChildren) cloned.children = newChildren;
+  if (newAnimate) cloned.animate = newAnimate;
+  return cloned;
+}
+var _elementIdCounter = 0;
+function generateElementId() {
+  return "_px_el_" + ++_elementIdCounter;
+}
+function normalizeAnimationDefinition(animDef, duration, defs, engine = PxTimelineEngine.native) {
+  const normalized = {};
+  for (const [propName, propAnim] of Object.entries(animDef)) {
+    if (propName === "transform" && propAnim.alongPathMode === "offsetPath" && animDef["offsetDistance"] !== void 0) {
+      continue;
+    }
+    const normalizedKfs = normalizeKeyframes(propName, propAnim, duration, defs);
+    if (normalizedKfs.length > 0) {
+      const out = { keyframes: normalizedKfs };
+      if (propAnim.autoOrient !== void 0) out.autoOrient = propAnim.autoOrient;
+      if (propAnim.loop !== void 0) out.loop = propAnim.loop;
+      normalized[propName] = engine === PxTimelineEngine.native && propName === "transform" ? materializeMotionPathInPropAnim(out) : out;
+    }
+  }
+  return normalized;
+}
+function normalizeBindings(doc, engine = PxTimelineEngine.native) {
+  const animatorConfig = getAnimatorConfig(doc) || {};
+  const defs = getDefinitions(doc);
+  const duration = animatorConfig.duration || 1e3;
+  const bindings = [];
+  const processAnimation = (id, animDefs, staticTransform) => {
+    if (animDefs.length === 0) return null;
+    const merged = mergeStaticTransformIntoAnimDef(mergeAnimationDefinitions(animDefs), staticTransform);
+    const normalizedAnim = normalizeAnimationDefinition(merged, duration, defs, engine);
+    if (Object.keys(normalizedAnim).length === 0) return null;
+    return {
+      id,
+      animate: normalizedAnim
+    };
+  };
+  const docBindings = getBindings(doc);
+  if (docBindings) {
+    for (const binding of docBindings) {
+      const id = binding.target.startsWith("#") ? binding.target.slice(1) : binding.target;
+      const animDefs = binding.animateWith.map((name) => resolveAnimation(name, defs)).filter((d) => !!d);
+      const normalized = processAnimation(id, animDefs);
+      if (normalized) bindings.push(normalized);
+    }
+  }
+  const processNode = (node) => {
+    const inlineAnim = node.animate;
+    if (inlineAnim && Object.keys(inlineAnim).length > 0) {
+      const nodeId = node.id || generateElementId();
+      node.id = nodeId;
+      const normalized = processAnimation(nodeId, resolveElementAnimation(inlineAnim, defs), node.transform);
+      if (normalized) bindings.push(normalized);
+    }
+    if (node.children) {
+      for (let i = 0; i < node.children.length; i++) {
+        processNode(node.children[i]);
+      }
+    }
+  };
+  if (doc.children) {
+    for (let i = 0; i < doc.children.length; i++) {
+      processNode(doc.children[i]);
+    }
+  }
+  return bindings;
+}
+function getKeyframesPair(keyframes, progress) {
+  var _a2, _b;
+  const last = keyframes.length - 1;
+  let prevKf = keyframes[0];
+  let nextKf = keyframes[last > 0 ? 1 : 0];
+  for (let j = 0; j < last; j++) {
+    const aOff = (_a2 = keyframes[j].t) != null ? _a2 : 0;
+    const bOff = (_b = keyframes[j + 1].t) != null ? _b : 0;
+    if (aOff <= progress && progress <= bOff) {
+      prevKf = keyframes[j];
+      nextKf = keyframes[j + 1];
+      break;
+    }
+    if (progress > bOff && j === last - 1) {
+      prevKf = keyframes[last > 0 ? last - 1 : 0];
+      nextKf = keyframes[last];
+    }
+  }
+  return { prevKf, nextKf };
+}
+function calcPropertyValue(propName, propAnim, progress) {
+  var _a2, _b, _c, _d, _e;
+  const keyframes = propAnim.keyframes || [];
+  if (keyframes.length === 0) return null;
+  const { prevKf, nextKf } = getKeyframesPair(keyframes, progress);
+  let localProgress = prevKf === nextKf ? 0 : remap(progress, (_a2 = prevKf.t) != null ? _a2 : 0, (_b = nextKf.t) != null ? _b : 0, 0, 1);
+  localProgress = clamp(localProgress, 0, 1);
+  const easing = keyframeEasing(prevKf);
+  if (easing && Array.isArray(easing)) {
+    try {
+      localProgress = cubicBezier(easing)(localProgress);
+    } catch (e) {
+    }
+  }
+  let cssAttrName = isCamelCaseWord(propName) ? camelCaseToKebabWordIfNeeded(propName) : propName;
+  let cssValue = null;
+  const prevV = prevKf == null ? void 0 : prevKf.v;
+  const nextV = nextKf == null ? void 0 : nextKf.v;
+  if (cssAttrName === "d") {
+    const prevPaths = (_c = prevV == null ? void 0 : prevV.paths) != null ? _c : Array.isArray(prevV) ? prevV : [];
+    const nextPaths = (_d = nextV == null ? void 0 : nextV.paths) != null ? _d : Array.isArray(nextV) ? nextV : [];
+    cssValue = interpolateBeziers(
+      prevPaths,
+      nextPaths,
+      localProgress
+    ).map((bz) => bezierToSvgPath(bz)).join("");
+  } else if (PX_COLOR_ATTR_NAMES.has(cssAttrName)) {
+    cssValue = toRGBA(interpolateColor(
+      prevV || [0, 0, 0, 1],
+      nextV || [0, 0, 0, 1],
+      localProgress
+    ));
+    cssAttrName = propName;
+  } else if (cssAttrName === "stroke-dasharray") {
+    cssValue = interpolateVec(
+      prevV || [],
+      nextV || [],
+      localProgress
+    ).join(" ");
+    cssAttrName = propName;
+  } else if (cssAttrName === "transform" && prevV !== null && typeof prevV === "object" && !Array.isArray(prevV)) {
+    const partKeys = /* @__PURE__ */ new Set([
+      ...prevV ? Object.keys(prevV) : [],
+      ...nextV ? Object.keys(nextV) : []
+    ]);
+    const partsResult = {};
+    for (const partKey of partKeys) {
+      const prevPart = prevV == null ? void 0 : prevV[partKey];
+      const nextPart = nextV == null ? void 0 : nextV[partKey];
+      if (partKey === "rotate" || partKey === "skew") {
+        partsResult[partKey] = interpolateNum(+(prevPart != null ? prevPart : 0), +(nextPart != null ? nextPart : 0), localProgress);
+      } else if (partKey === "translate" || partKey === "scale" || partKey === "origin") {
+        const fallback = partKey === "scale" ? [1, 1] : [0, 0];
+        const interp = interpolateVec(prevPart || fallback, nextPart || fallback, localProgress);
+        partsResult[partKey] = interp;
+      }
+    }
+    if (propAnimIsMotionPath(propAnim)) {
+      const prevTr = prevV.translate;
+      const nextTr = nextV.translate;
+      if (Array.isArray(prevTr) && Array.isArray(nextTr)) {
+        const sample = evaluateMotionPathSegment(
+          prevKf,
+          nextKf,
+          [+prevTr[0], +prevTr[1]],
+          [+nextTr[0], +nextTr[1]],
+          localProgress,
+          !!propAnim.autoOrient
+        );
+        partsResult.translate = [sample.translate[0], sample.translate[1]];
+        if (sample.rotateDeg !== void 0) partsResult.rotate = sample.rotateDeg + ((_e = partsResult.rotate) != null ? _e : 0);
+      }
+    }
+    cssValue = composeTransformParts(partsResult, { withUnits: false });
+    cssAttrName = "transform";
+  } else if (cssAttrName === "translate") {
+    const v = interpolateVec(
+      prevV || [0, 0],
+      nextV || [0, 0],
+      localProgress
+    );
+    cssValue = "translate(" + v.join(",") + ")";
+    cssAttrName = "transform";
+  } else if (cssAttrName === "rotate") {
+    const v = interpolateNum(
+      +(prevV || 0),
+      +(nextV || 0),
+      localProgress
+    );
+    cssValue = "rotate(" + v + ")";
+    cssAttrName = "transform";
+  } else if (cssAttrName === "scale") {
+    const v = interpolateVec(
+      prevV || [1, 1],
+      nextV || [1, 1],
+      localProgress
+    );
+    cssValue = "scale(" + v.join(",") + ")";
+    cssAttrName = "transform";
+  } else {
+    const num2 = interpolateNum(
+      +(prevV || 0),
+      +(nextV || 0),
+      localProgress
+    );
+    cssValue = num2;
+  }
+  if (PX_PCT_BASED_ATTR_NAMES.has(cssAttrName) && typeof cssValue === "number") {
+    cssValue = cssValue * 100 + "%";
+  }
+  return { k: cssAttrName, v: cssValue === null ? "" : "" + cssValue };
+}
+function calcAnimationValues(animDef, progress) {
+  const result = {};
+  for (const [propName, propAnim] of Object.entries(animDef)) {
+    const computed = calcPropertyValue(propName, propAnim, progress);
+    if (computed) {
+      result[computed.k] = computed.v;
+    }
+  }
+  return result;
 }
 
 // src/effects/PlayerEffectsUtil.visualModel.ts
@@ -2534,6 +3328,15 @@ function transformPathData(d, m, decimals = 2) {
 }
 
 // src/effects/shared/transformParts.ts
+function partsRecord(part, value, origin) {
+  const rec = {};
+  if (part === "translate" /* Translate */) rec.translate = value;
+  else if (part === "rotate" /* Rotate */) rec.rotate = value;
+  else if (part === "skew" /* Skew */) rec.skew = value;
+  else rec.scale = value;
+  if (origin && part !== "translate" /* Translate */) rec.origin = origin;
+  return rec;
+}
 function readAnimatable(raw) {
   var _a2, _b;
   if (raw === void 0) return { kind: "absent" /* Absent */ };
@@ -2552,6 +3355,24 @@ function readAnimatable(raw) {
   }
   return { kind: "static" /* Static */, value: raw };
 }
+function writeAnimatableChannel(node, attrName, read, opts) {
+  var _a2, _b, _c, _d;
+  const toOut = (v) => (opts == null ? void 0 : opts.asString) && v !== void 0 && v !== null ? String(v) : v;
+  if (read.kind === "absent" /* Absent */) return;
+  if (read.kind === "static" /* Static */) {
+    node[attrName] = toOut(read.value);
+    return;
+  }
+  const prevAnimate = node.animate && typeof node.animate === "object" && !Array.isArray(node.animate) ? node.animate : void 0;
+  const animate = __spreadValues({}, prevAnimate || {});
+  const block = { keyframes: read.keyframes };
+  if (read.loop !== void 0) block.loop = read.loop;
+  if (read.autoOrient !== void 0) block.autoOrient = read.autoOrient;
+  animate[attrName] = block;
+  node.animate = animate;
+  const baseline = (_d = (_b = read.base) != null ? _b : (_a2 = read.keyframes[0]) == null ? void 0 : _a2.value) != null ? _d : (_c = read.keyframes[0]) == null ? void 0 : _c.v;
+  if (baseline !== void 0) node[attrName] = toOut(baseline);
+}
 function normalizeKeyframe(kf) {
   if (!kf || typeof kf !== "object") return kf;
   const k = kf;
@@ -2566,6 +3387,22 @@ function normalizeKeyframe(kf) {
   if (out.tangentIn === void 0 && k.ti !== void 0) out.tangentIn = k.ti;
   return out;
 }
+function readStaticOrigin(raw, ctx) {
+  var _a2;
+  const o = readAnimatable(raw);
+  if (o.kind === "absent" /* Absent */) return void 0;
+  if (o.kind === "static" /* Static */) return o.value;
+  ctx.warnings.push("transformBy.origin: animated origin approximated by its first keyframe");
+  return (_a2 = o.keyframes[0]) == null ? void 0 : _a2.value;
+}
+function keyframeWith(kf, value) {
+  const out = { value };
+  if (kf.time !== void 0) out.time = kf.time;
+  if (kf.easing !== void 0) out.easing = kf.easing;
+  if (kf.tangentOut !== void 0) out.tangentOut = kf.tangentOut;
+  if (kf.tangentIn !== void 0) out.tangentIn = kf.tangentIn;
+  return out;
+}
 
 // src/effects/text/textGlyphsEffect.ts
 var DEFAULT_FONT_SIZE = 16;
@@ -3114,27 +3951,154 @@ function materializeGlyphText(node, opts) {
   if (opts.alongPath) return materializeGlyphTextAlongPath(node, opts.alongPath.pathD, opts.alongPath.startOffset, opts, opts.alongPath.textLength, opts.alongPath.pathOverflow);
   return materializeGlyphTextHorizontal(node, opts);
 }
-
-// src/effects/text/textPathEffect.ts
-var EXTEND_MARGIN_FRAC = 0.15;
-function numRange(v) {
-  const read = readAnimatable(v);
-  if (read.kind === "static" /* Static */ && typeof read.value === "number") return { min: read.value, max: read.value };
-  if (read.kind === "animated" /* Animated */ && read.keyframes.length) {
-    const vals = read.keyframes.map((k) => Number(k.value) || 0);
-    return { min: Math.min(...vals), max: Math.max(...vals) };
+function applyTextGlyphsEffect(node, fx, ctx) {
+  if (!(fx == null ? void 0 : fx.useGlyphs)) return node;
+  if (!ctx.glyphs) {
+    ctx.warnings.push("textGlyphs: no definitions.fonts \u2014 left as native <text>");
+    return node;
   }
-  return { min: 0, max: 0 };
+  return materializeGlyphTextHorizontal(node, { glyphs: ctx.glyphs, warnings: ctx.warnings });
 }
-var r3 = (n) => Math.round(n * 1e3) / 1e3;
-function extendedPathForBrowser(pathD, opts) {
-  var _a2;
-  if (opts.pathOverflow === "clip") return { d: pathD, startShift: 0 };
-  const sampler = createPathSampler(pathD);
-  if (!sampler || sampler.closed || sampler.totalLength <= 0) return { d: pathD, startShift: 0 };
-  const L = sampler.totalLength;
-  const margin = EXTEND_MARGIN_FRAC * L;
-  const so = numRange(opts.startOffset);
+function applyTextGlyphsAlongPath(node, ctx, pathD, startOffset, textLength, pathOverflow) {
+  if (!ctx.glyphs) {
+    ctx.warnings.push("textGlyphs: no definitions.fonts");
+    return null;
+  }
+  return materializeGlyphTextAlongPath(node, pathD, startOffset, { glyphs: ctx.glyphs, warnings: ctx.warnings }, textLength, pathOverflow);
+}
+
+// src/util/PxNodeCloneUtil.ts
+function deepClonePxNode(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(deepClonePxNode);
+  const out = {};
+  for (const k of Object.keys(value)) out[k] = deepClonePxNode(value[k]);
+  return out;
+}
+function regenerateIdsAndRewriteRefs(root, genId3) {
+  const oldToNew = /* @__PURE__ */ new Map();
+  const walkAssign = (n) => {
+    var _a2;
+    if (typeof n.id === "string") {
+      const newId = genId3();
+      oldToNew.set(n.id, newId);
+      n.id = newId;
+    }
+    (_a2 = n.children) == null ? void 0 : _a2.forEach(walkAssign);
+  };
+  walkAssign(root);
+  const rewriteUrl = (s) => s.replace(/url\(#([^)]+)\)/g, (m, oldId) => {
+    const newId = oldToNew.get(oldId);
+    return newId ? "url(#" + newId + ")" : m;
+  });
+  const walkRewrite = (n) => {
+    var _a2;
+    if (typeof n.href === "string" && n.href.startsWith("#")) {
+      const newId = oldToNew.get(n.href.slice(1));
+      if (newId) n.href = "#" + newId;
+    }
+    for (const k of Object.keys(n)) {
+      if (k === "children" || k === "effects" || k === "meta" || k === "animate" || k === "href" || k === "id") continue;
+      const v = n[k];
+      if (typeof v === "string" && v.indexOf("url(#") !== -1) {
+        n[k] = rewriteUrl(v);
+      }
+    }
+    (_a2 = n.children) == null ? void 0 : _a2.forEach(walkRewrite);
+  };
+  walkRewrite(root);
+  return oldToNew;
+}
+function toFiniteNum(v) {
+  const n = typeof v === "number" ? v : typeof v === "string" ? parseFloat(v) : NaN;
+  return Number.isFinite(n) ? n : 0;
+}
+function applyUseOffsetToG(gNode) {
+  var _a2;
+  const x = toFiniteNum(gNode.x);
+  const y = toFiniteNum(gNode.y);
+  delete gNode.x;
+  delete gNode.y;
+  if (!x && !y) return gNode;
+  const offset = "translate(" + x + "," + y + ")";
+  const carriesTransform = gNode.transform !== void 0 || gNode.animate !== void 0;
+  if (carriesTransform) {
+    const inner = { type: "g", transform: offset, children: (_a2 = gNode.children) != null ? _a2 : [] };
+    gNode.children = [inner];
+  } else {
+    gNode.transform = offset;
+  }
+  return gNode;
+}
+
+// src/effects/shared/util.ts
+function genId(ctx, prefix) {
+  return "_lw_" + prefix + "_" + ctx.nextId++;
+}
+function stripHash(href) {
+  return typeof href === "string" ? href.replace(/^#/, "") : void 0;
+}
+function indexById(node, map) {
+  var _a2;
+  if (typeof node.id === "string") map.set(node.id, node);
+  (_a2 = node.children) == null ? void 0 : _a2.forEach((child) => indexById(child, map));
+}
+function spliceDefs(root, defs) {
+  if (!defs.length) return;
+  const existing = root.children || (root.children = []);
+  existing.unshift({ type: "defs", children: defs });
+}
+var clone = deepClonePxNode;
+function regenerateIdsInClone(root, ctx) {
+  return regenerateIdsAndRewriteRefs(root, () => genId(ctx, "retimed"));
+}
+
+// src/effects/text/textPathEffect.ts
+var EXTEND_MARGIN_FRAC = 0.15;
+function numRange(v) {
+  const read = readAnimatable(v);
+  if (read.kind === "static" /* Static */ && typeof read.value === "number") return { min: read.value, max: read.value };
+  if (read.kind === "animated" /* Animated */ && read.keyframes.length) {
+    const vals = read.keyframes.map((k) => Number(k.value) || 0);
+    return { min: Math.min(...vals), max: Math.max(...vals) };
+  }
+  return { min: 0, max: 0 };
+}
+function estimateTextAdvance(node) {
+  let chars = 0, maxFont = 16;
+  const walk = (el) => {
+    var _a2;
+    const fs = parseFloat(String((_a2 = el.fontSize) != null ? _a2 : "")) || 0;
+    if (fs) maxFont = Math.max(maxFont, fs);
+    const t = el.textContent;
+    if (typeof t === "string") chars += t.length;
+    if (el.children) for (const c of el.children) walk(c);
+  };
+  walk(node);
+  return chars * maxFont;
+}
+var r3 = (n) => Math.round(n * 1e3) / 1e3;
+function shiftAnimatable(v, by) {
+  if (!by || v === void 0 || v === null) return v;
+  const read = readAnimatable(v);
+  if (read.kind === "absent" /* Absent */) return v;
+  if (read.kind === "static" /* Static */) return typeof v === "number" ? read.value + by : { value: read.value + by };
+  const out = {
+    keyframes: read.keyframes.map((k) => __spreadProps(__spreadValues({}, k), { value: (Number(k.value) || 0) + by }))
+  };
+  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 = read.base + by;
+  return out;
+}
+function extendedPathForBrowser(pathD, opts) {
+  var _a2;
+  if (opts.pathOverflow === "clip") return { d: pathD, startShift: 0 };
+  const sampler = createPathSampler(pathD);
+  if (!sampler || sampler.closed || sampler.totalLength <= 0) return { d: pathD, startShift: 0 };
+  const L = sampler.totalLength;
+  const margin = EXTEND_MARGIN_FRAC * L;
+  const so = numRange(opts.startOffset);
   const runWidth = numRange(opts.textLength).max || ((_a2 = opts.advance) != null ? _a2 : 0);
   const startOverflow = Math.max(0, -so.min);
   const endOverflow = Math.max(0, so.max + runWidth - L);
@@ -3149,33 +4113,2083 @@ function extendedPathForBrowser(pathD, opts) {
     const rest = pathD.replace(/^\s*[Mm]\s*-?[\d.]+[\s,]+-?[\d.]+/, "");
     d = "M" + r3(sx) + "," + r3(sy) + "L" + r3(s.x) + "," + r3(s.y) + rest;
   }
-  if (endExt > 0) {
-    const ex = e.x + Math.cos(e.angle) * endExt, ey = e.y + Math.sin(e.angle) * endExt;
-    d += "L" + r3(ex) + "," + r3(ey);
+  if (endExt > 0) {
+    const ex = e.x + Math.cos(e.angle) * endExt, ey = e.y + Math.sin(e.angle) * endExt;
+    d += "L" + r3(ex) + "," + r3(ey);
+  }
+  return { d, startShift: startExt };
+}
+function applyTextPathEffect(node, fx, ctx) {
+  var _a2;
+  if (!fx || typeof fx.pathData !== "string" || !fx.pathData) return node;
+  const pathId = genId(ctx, "tpath");
+  const { d, startShift } = extendedPathForBrowser(fx.pathData, {
+    pathOverflow: fx.pathOverflow,
+    startOffset: fx.startOffset,
+    textLength: fx.textLength,
+    advance: estimateTextAdvance(node)
+  });
+  ctx.defs.push({ type: "path", id: pathId, d });
+  const textPath = {
+    type: "textPath",
+    href: "#" + pathId,
+    children: (_a2 = node.children) != null ? _a2 : []
+  };
+  if (fx.lengthAdjust !== void 0) textPath.lengthAdjust = fx.lengthAdjust;
+  if (fx.method !== void 0) textPath.method = fx.method;
+  if (fx.spacing !== void 0) textPath.spacing = fx.spacing;
+  applyAnimatableNumber(textPath, "startOffset", shiftAnimatable(fx.startOffset, startShift));
+  applyAnimatableNumber(textPath, "textLength", fx.textLength);
+  node.children = [textPath];
+  return node;
+}
+function applyAnimatableNumber(node, attrName, raw) {
+  if (raw === void 0 || raw === null) return;
+  writeAnimatableChannel(node, attrName, readAnimatable(raw), { asString: true });
+}
+
+// src/format/PxDocumentDiagnostic.ts
+var MAX_REPORTED = 6;
+function diagnoseDocument(doc) {
+  try {
+    return { problems: validateDocument(doc) };
+  } catch (e) {
+    return { problems: [] };
+  }
+}
+function reportDocumentDiagnostics(doc, where) {
+  const { problems } = diagnoseDocument(doc);
+  if (!problems.length) return;
+  const shown = problems.slice(0, MAX_REPORTED);
+  const more = problems.length - shown.length;
+  console.warn(
+    where + ": this document does not match the animation schema in " + problems.length + " place" + (problems.length === 1 ? "" : "s") + ".\n" + shown.map((p) => "  - " + p).join("\n") + (more > 0 ? "\n  \u2026 and " + more + " more" : "") + "\n\nIf you did not author these keys, the usual cause is a build that MANGLES PROPERTY NAMES. An animation document is data loaded at runtime, so renaming the property reads inside the player stops them matching the keys in the JSON, and the animation silently does nothing. Feed the published reserved-name list to your minifier \u2014 @pixodesk/svg-animator-web/mangle-reserved.json \u2014 see docs/library/minification.md."
+  );
+}
+
+// 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 = buildIdMap2(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 buildIdMap2(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);
+    }
   }
-  return { d, startShift: startExt };
+  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/format/PxDocumentDiagnostic.ts
-var MAX_REPORTED = 6;
-function diagnoseDocument(doc) {
-  try {
-    return { problems: validateDocument(doc) };
-  } catch (e) {
-    return { problems: [] };
+// src/util/PxIdUtil.ts
+var _idCounter = 0;
+function generateUniqueId() {
+  const timestamp = Date.now().toString(36);
+  const counter = (++_idCounter).toString(36);
+  const random = Math.random().toString(36).substring(2, 6);
+  return "_px_" + timestamp + counter + random;
+}
+function deepClone(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((item) => deepClone(item));
+  const obj = value;
+  const cloned = {};
+  for (const key of Object.keys(obj)) {
+    cloned[key] = deepClone(obj[key]);
   }
+  return cloned;
 }
-function reportDocumentDiagnostics(doc, where) {
-  const { problems } = diagnoseDocument(doc);
-  if (!problems.length) return;
-  const shown = problems.slice(0, MAX_REPORTED);
-  const more = problems.length - shown.length;
-  console.warn(
-    where + ": this document does not match the animation schema in " + problems.length + " place" + (problems.length === 1 ? "" : "s") + ".\n" + shown.map((p) => "  - " + p).join("\n") + (more > 0 ? "\n  \u2026 and " + more + " more" : "") + "\n\nIf you did not author these keys, the usual cause is a build that MANGLES PROPERTY NAMES. An animation document is data loaded at runtime, so renaming the property reads inside the player stops them matching the keys in the JSON, and the animation silently does nothing. Feed the published reserved-name list to your minifier \u2014 @pixodesk/svg-animator-web/mangle-reserved.json \u2014 see docs/library/minification.md."
-  );
+function generateNewIds(doc) {
+  var _a2;
+  const cloned = deepClone(doc);
+  const idMap = /* @__PURE__ */ new Map();
+  const hashRefAttrs = /* @__PURE__ */ new Set(["href", "xlink:href"]);
+  const urlRefAttrs = /* @__PURE__ */ new Set([
+    "fill",
+    "stroke",
+    "clip-path",
+    "clipPath",
+    "mask",
+    "marker",
+    "marker-start",
+    "marker-mid",
+    "marker-end",
+    "filter",
+    "flood-color",
+    "lighting-color"
+  ]);
+  const directIdRefAttrs = /* @__PURE__ */ new Set(["targetId", "boundElementId"]);
+  const isEffectSourceRef = (key, parentKey) => key === "source" && (parentKey === "maskedBy" || parentKey === "clone");
+  function collectIds(node) {
+    if (!node || typeof node !== "object") return;
+    if (node.id && typeof node.id === "string") {
+      const oldId = node.id;
+      const newId = generateUniqueId();
+      idMap.set(oldId, newId);
+      node.id = newId;
+    } else if (node.animate) {
+      node.id = generateUniqueId();
+    }
+    if (Array.isArray(node.children)) {
+      for (const child of node.children) {
+        collectIds(child);
+      }
+    }
+  }
+  function updateRefs(node, parentKey) {
+    if (!node || typeof node !== "object") return;
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "children") {
+        if (Array.isArray(value)) {
+          for (const child of value) {
+            updateRefs(child);
+          }
+        }
+        continue;
+      }
+      if (typeof value === "string") {
+        if (hashRefAttrs.has(key) && value.startsWith("#")) {
+          const oldId = value.slice(1);
+          const newId = idMap.get(oldId);
+          if (newId) {
+            node[key] = "#" + newId;
+          }
+        } else if (urlRefAttrs.has(key)) {
+          node[key] = replaceUrlRefs(value, idMap);
+        } else if (directIdRefAttrs.has(key) || isEffectSourceRef(key, parentKey)) {
+          const hasHash = value.startsWith("#");
+          const newId = idMap.get(hasHash ? value.slice(1) : value);
+          if (newId) {
+            node[key] = hasHash ? "#" + newId : newId;
+          }
+        } else if (value.includes("url(#")) {
+          node[key] = replaceUrlRefs(value, idMap);
+        }
+      } else if (key === "style" && typeof value === "object" && value !== null) {
+        for (const [styleProp, styleValue] of Object.entries(value)) {
+          if (typeof styleValue === "string") {
+            value[styleProp] = replaceUrlRefs(styleValue, idMap);
+          }
+        }
+      } else if (typeof value === "object" && value !== null) {
+        updateRefs(value, key);
+      }
+    }
+  }
+  collectIds(cloned);
+  updateRefs(cloned);
+  const docBindings = (_a2 = cloned.animator) == null ? void 0 : _a2.bindings;
+  if (Array.isArray(docBindings)) {
+    const updatedBindings = docBindings.map((binding) => {
+      var _a3;
+      const hashed = binding.target.startsWith("#");
+      const id = hashed ? binding.target.slice(1) : binding.target;
+      const newId = (_a3 = idMap.get(id)) != null ? _a3 : id;
+      return __spreadProps(__spreadValues({}, binding), { target: hashed ? "#" + newId : newId });
+    });
+    cloned.animator = __spreadProps(__spreadValues({}, cloned.animator), { bindings: updatedBindings });
+  }
+  return cloned;
+}
+function replaceUrlRefs(value, idMap) {
+  return value.replace(/url\(#([^)]+)\)/g, (match, oldId) => {
+    const newId = idMap.get(oldId);
+    return newId ? "url(#" + newId + ")" : match;
+  });
+}
+
+// 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/PxDiagnostics.ts
+var PxDiagnosticKind = {
+  /** The document is wrong — regenerate or repair the file. */
+  document: "document",
+  /** The page or app cannot provide what the document asks for — fix the mount. */
+  host: "host",
+  /** The platform cannot do it and the player degraded — usually nothing to fix. */
+  platform: "platform",
+  /** The call is wrong or self-contradictory — fix the options or props you passed. */
+  usage: "usage",
+  /** The player failed where it did not expect to — report it to us. */
+  internal: "internal"
+};
 var DOCS_URL = "https://github.com/pixodesk/pixodesk-svg-animator/blob/main/docs/diagnostics.md";
 function codeLine(code) {
   return "PX" + code + " " + DOCS_URL + "#px" + code;
@@ -3208,81 +6222,6 @@ function createDiagnostics(config, prefix) {
   };
 }
 
-// src/playback/PxScrollMath.ts
-function isScrollTimeline(config) {
-  return (config == null ? void 0 : config.timelineSource) === "scroll";
-}
-function scrollTotalDurationMs(config) {
-  const duration = typeof (config == null ? void 0 : config.duration) === "number" && config.duration > 0 ? config.duration : PX_DEFAULT_DURATION_MS;
-  const iterations = typeof (config == null ? void 0 : config.iterations) === "number" && config.iterations > 0 ? config.iterations : 1;
-  return duration * iterations;
-}
-function scrollPhaseInterval(phase, subjectSize, scrollportSize) {
-  const s = subjectSize, vp = scrollportSize;
-  switch (phase) {
-    case "cover":
-      return [0, s + vp];
-    case "entry":
-      return [0, Math.min(s, vp)];
-    case "contain":
-      return [Math.min(s, vp), Math.max(s, vp)];
-    case "exit":
-      return [Math.max(s, vp), s + vp];
-    case "entry-crossing":
-      return [0, s];
-    case "exit-crossing":
-      return [vp, s + vp];
-  }
-}
-var DEFAULT_PHASE = "cover";
-function resolveRangePointU(point, defaultFraction, subjectSize, scrollportSize) {
-  var _a2;
-  const [u0, u1] = scrollPhaseInterval((_a2 = point == null ? void 0 : point.phase) != null ? _a2 : DEFAULT_PHASE, subjectSize, scrollportSize);
-  const fraction = typeof (point == null ? void 0 : point.fraction) === "number" ? point.fraction : defaultFraction;
-  return u0 + fraction * (u1 - u0);
-}
-function scrollViewProgress(subjectStart, subjectSize, scrollportSize, range) {
-  const u = scrollportSize - subjectStart;
-  const uStart = resolveRangePointU(range == null ? void 0 : range.start, 0, subjectSize, scrollportSize);
-  const uEnd = resolveRangePointU(range == null ? void 0 : range.end, 1, subjectSize, scrollportSize);
-  if (uEnd <= uStart) return u >= uEnd ? 1 : 0;
-  return clamp((u - uStart) / (uEnd - uStart), 0, 1);
-}
-function scrollOffsetProgress(offset, maxOffset, range) {
-  var _a2, _b;
-  const raw = maxOffset > 0 ? clamp(offset / maxOffset, 0, 1) : 1;
-  const start = typeof ((_a2 = range == null ? void 0 : range.start) == null ? void 0 : _a2.fraction) === "number" ? range.start.fraction : 0;
-  const end = typeof ((_b = range == null ? void 0 : range.end) == null ? void 0 : _b.fraction) === "number" ? range.end.fraction : 1;
-  if (end <= start) return raw >= end ? 1 : 0;
-  return clamp((raw - start) / (end - start), 0, 1);
-}
-function scrollResolveAxis(axis, writingMode) {
-  const a = axis != null ? axis : "block";
-  if (a === "x" || a === "y") return a;
-  const vertical = !!writingMode && writingMode.startsWith("vertical");
-  if (a === "inline") return vertical ? "y" : "x";
-  return vertical ? "x" : "y";
-}
-
-// src/util/PxIdUtil.ts
-var _idCounter = 0;
-function generateUniqueId() {
-  const timestamp = Date.now().toString(36);
-  const counter = (++_idCounter).toString(36);
-  const random = Math.random().toString(36).substring(2, 6);
-  return "_px_" + timestamp + counter + random;
-}
-function deepClone(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) return value.map((item) => deepClone(item));
-  const obj = value;
-  const cloned = {};
-  for (const key of Object.keys(obj)) {
-    cloned[key] = deepClone(obj[key]);
-  }
-  return cloned;
-}
-
 // src/util/PxNodeProps.ts
 var PX_DISALLOWED_SVG_TAGS_LOWER = /* @__PURE__ */ new Set([
   "script",
@@ -3346,6 +6285,135 @@ function sanitizeAttributeValue(name, value) {
   }
   return value;
 }
+function toDomProps(props) {
+  const propsCopy = {};
+  for (const rawKey of Object.keys(props)) {
+    const key = kebabToCamelCaseWord(rawKey);
+    if (INTERNAL_ATTRS.has(key)) continue;
+    if (key === "style") continue;
+    let value = props[rawKey];
+    if (PX_COLOR_ATTR_NAMES.has(key) && Array.isArray(value)) {
+      propsCopy[key] = toRGBA(value);
+    } else if (key === "transform" && value !== null && typeof value === "object" && !Array.isArray(value) && !value.keyframes) {
+      const parts = value.value && typeof value.value === "object" ? value.value : value;
+      propsCopy[TRANSFORM_ATTR] = composeTransformParts(parts, { withUnits: false });
+    } else if (PX_TRANSFORM_FN_NAMES.has(key)) {
+      if (Array.isArray(value)) {
+        if (key === "translate") value = value.map((v) => v + "px");
+        value = value.join(",");
+      }
+      if (key === "rotate") value = value + "deg";
+      propsCopy[TRANSFORM_ATTR] = key + "(" + value + ")";
+    } else if (Array.isArray(value)) {
+      propsCopy[key] = value.join(",");
+    } else if (value !== void 0 && value !== null) {
+      propsCopy[key] = String(value);
+    }
+  }
+  return propsCopy;
+}
+
+// src/render/PxRenderTree.ts
+var CLASS_NAME_KEY = "className";
+var CLASS_ATTR2 = "class";
+var DOM_TYPE_KEY = "domType";
+var TYPE_ATTR = "type";
+var DEFAULT_TAG = "g";
+function renderPxTree(node, factory, diag) {
+  return node ? renderOne(node, factory, diag, true, 0) : null;
+}
+function renderOne(node, factory, diag, isRoot, index) {
+  const _a2 = node, { type, children, style } = _a2, props = __objRest(_a2, ["type", "children", "style"]);
+  const tag = type || DEFAULT_TAG;
+  if (PX_DISALLOWED_SVG_TAGS_LOWER.has(tag.toLowerCase())) {
+    (diag != null ? diag : createDiagnostics(void 0, "[PxAnimator]")).warn(PxDiagnosticKind.document, 1103 /* blockedTag */, tag);
+    return null;
+  }
+  const domType = props[DOM_TYPE_KEY];
+  if (domType !== void 0) delete props[DOM_TYPE_KEY];
+  const attrs = {};
+  let inlineStyle;
+  const domProps = toDomProps(props);
+  for (const propName of Object.keys(domProps)) {
+    const sanitized = sanitizeAttributeValue(propName, domProps[propName]);
+    if (sanitized === void 0) continue;
+    if (PX_CSS_ONLY_STYLE_PROPS.has(propName)) {
+      (inlineStyle != null ? inlineStyle : inlineStyle = {})[propName] = String(sanitized);
+      continue;
+    }
+    attrs[propName === CLASS_NAME_KEY ? CLASS_ATTR2 : camelCaseToKebabWordIfNeeded(propName)] = sanitized;
+  }
+  if (domType !== void 0) attrs[TYPE_ATTR] = String(domType);
+  if (style) {
+    for (const styleProp of Object.keys(style)) (inlineStyle != null ? inlineStyle : inlineStyle = {})[styleProp] = String(style[styleProp]);
+  }
+  const rendered = [];
+  if (children) {
+    children.forEach((child, i) => {
+      const el = renderOne(child, factory, diag, false, i);
+      if (el !== null) rendered.push(el);
+    });
+  }
+  const ownText = props[PX_TEXT_CONTENT_ATTR];
+  const text = !rendered.length && typeof ownText === "string" && ownText ? ownText : void 0;
+  return factory({ tag, attrs, style: inlineStyle, children: rendered, text, node, isRoot, index });
+}
+
+// src/playback/PxScrollMath.ts
+function isScrollTimeline(config) {
+  return (config == null ? void 0 : config.timelineSource) === "scroll";
+}
+function scrollTotalDurationMs(config) {
+  const duration = typeof (config == null ? void 0 : config.duration) === "number" && config.duration > 0 ? config.duration : PX_DEFAULT_DURATION_MS;
+  const iterations = typeof (config == null ? void 0 : config.iterations) === "number" && config.iterations > 0 ? config.iterations : 1;
+  return duration * iterations;
+}
+function scrollPhaseInterval(phase, subjectSize, scrollportSize) {
+  const s = subjectSize, vp = scrollportSize;
+  switch (phase) {
+    case "cover":
+      return [0, s + vp];
+    case "entry":
+      return [0, Math.min(s, vp)];
+    case "contain":
+      return [Math.min(s, vp), Math.max(s, vp)];
+    case "exit":
+      return [Math.max(s, vp), s + vp];
+    case "entry-crossing":
+      return [0, s];
+    case "exit-crossing":
+      return [vp, s + vp];
+  }
+}
+var DEFAULT_PHASE = "cover";
+function resolveRangePointU(point, defaultFraction, subjectSize, scrollportSize) {
+  var _a2;
+  const [u0, u1] = scrollPhaseInterval((_a2 = point == null ? void 0 : point.phase) != null ? _a2 : DEFAULT_PHASE, subjectSize, scrollportSize);
+  const fraction = typeof (point == null ? void 0 : point.fraction) === "number" ? point.fraction : defaultFraction;
+  return u0 + fraction * (u1 - u0);
+}
+function scrollViewProgress(subjectStart, subjectSize, scrollportSize, range) {
+  const u = scrollportSize - subjectStart;
+  const uStart = resolveRangePointU(range == null ? void 0 : range.start, 0, subjectSize, scrollportSize);
+  const uEnd = resolveRangePointU(range == null ? void 0 : range.end, 1, subjectSize, scrollportSize);
+  if (uEnd <= uStart) return u >= uEnd ? 1 : 0;
+  return clamp((u - uStart) / (uEnd - uStart), 0, 1);
+}
+function scrollOffsetProgress(offset, maxOffset, range) {
+  var _a2, _b;
+  const raw = maxOffset > 0 ? clamp(offset / maxOffset, 0, 1) : 1;
+  const start = typeof ((_a2 = range == null ? void 0 : range.start) == null ? void 0 : _a2.fraction) === "number" ? range.start.fraction : 0;
+  const end = typeof ((_b = range == null ? void 0 : range.end) == null ? void 0 : _b.fraction) === "number" ? range.end.fraction : 1;
+  if (end <= start) return raw >= end ? 1 : 0;
+  return clamp((raw - start) / (end - start), 0, 1);
+}
+function scrollResolveAxis(axis, writingMode) {
+  const a = axis != null ? axis : "block";
+  if (a === "x" || a === "y") return a;
+  const vertical = !!writingMode && writingMode.startsWith("vertical");
+  if (a === "inline") return vertical ? "y" : "x";
+  return vertical ? "x" : "y";
+}
 
 // src/version/PxSchemaFieldUniverse.ts
 function schemaFieldUniverse(root) {
@@ -3506,7 +6574,9 @@ function releaseLogProblems(releases, steps, declared, baseline) {
   materializeMotionPathInPropAnim,
   mergeStaticTransformIntoAnimDef,
   planSchemaRelease,
+  prepareDocumentForRender,
   releaseLogProblems,
+  renderPxTree,
   reportDocumentDiagnostics,
   reverseEasing,
   sanitizeAttributeValue,