@pixodesk/svg-animator-web 1.0.30 → 1.0.35

package/dist/index.prerendered-waapi.umd.js

@@ -21,6 +21,18 @@ var PixodeskAnimator = (() => {
     return a;
   };
   var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+  var __objRest = (source, exclude) => {
+    var target = {};
+    for (var prop in source)
+      if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+        target[prop] = source[prop];
+    if (source != null && __getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(source)) {
+        if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+          target[prop] = source[prop];
+      }
+    return target;
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -43,7 +55,7 @@ var PixodeskAnimator = (() => {
     setupAnimationTriggers: () => setupAnimationTriggers
   });
 
-  // ../svg-animator-core/src/PxAnimatorUtil.ts
+  // ../svg-animator-core/src/util/PxAnimatorUtil.ts
   function bezierToSvgPath(path, forceCurves = false) {
     var _a, _b, _c, _d;
     const v = path.v;
@@ -291,6 +303,38 @@ var PixodeskAnimator = (() => {
     if (o) segs.push("translate(" + -o[0] + tu + "," + -o[1] + tu + ")");
     return segs.join("");
   }
+  function parseTransformParts(str) {
+    var _a, _b;
+    if (!str || typeof str !== "string") return void 0;
+    const out = {};
+    const re = /([a-zA-Z]+)\s*\(([^)]*)\)/g;
+    const order = ["translate", "rotate", "skewX", "scale"];
+    let lastIdx = -1;
+    let m;
+    while ((m = re.exec(str)) !== null) {
+      const fn = m[1];
+      const idx = order.indexOf(fn);
+      if (idx < 0 || idx <= lastIdx) return void 0;
+      lastIdx = idx;
+      const nums = m[2].split(/[\s,]+/).filter(Boolean).map(Number);
+      if (nums.some((n) => Number.isNaN(n))) return void 0;
+      if (fn === "translate") {
+        if (nums.length < 1 || nums.length > 2) return void 0;
+        out.translate = [nums[0], (_a = nums[1]) != null ? _a : 0];
+      } else if (fn === "rotate") {
+        if (nums.length !== 1) return void 0;
+        out.rotate = nums[0];
+      } else if (fn === "skewX") {
+        if (nums.length !== 1) return void 0;
+        out.skew = nums[0];
+      } else {
+        if (nums.length < 1 || nums.length > 2) return void 0;
+        out.scale = [nums[0], (_b = nums[1]) != null ? _b : nums[0]];
+      }
+    }
+    if (str.replace(/([a-zA-Z]+)\s*\(([^)]*)\)/g, "").replace(/[\s,]/g, "").length) return void 0;
+    return Object.keys(out).length ? out : void 0;
+  }
   function kebabToCamelCaseWord(kebab) {
     return kebab.includes("-") ? kebab.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()) : kebab;
   }
@@ -434,27 +478,612 @@ var PixodeskAnimator = (() => {
     return cubicBezier(flipped);
   }
 
-  // ../svg-animator-core/src/PxAnimatorConstants.ts
-  var PxAnimatorMode = {
+  // ../svg-animator-core/src/schema/PxSchema.ts
+  var PX_UNKNOWN_KEY_ERROR = "unexpected extra key";
+  function pathStr(path) {
+    if (!path.length) return ".";
+    let result = "";
+    for (const seg of path) {
+      if (seg.startsWith("[")) result += seg;
+      else result += (result ? "." : "") + seg;
+    }
+    return result;
+  }
+  var Base = class {
+    _canSanitize(raw) {
+      return this.isValid(raw);
+    }
+    optional() {
+      return new Optional(this);
+    }
+  };
+  var Optional = class extends Base {
+    constructor(inner) {
+      super();
+      this.inner = inner;
+      this._default = void 0;
+    }
+    sanitize(raw) {
+      if (raw === void 0 || raw === null) return void 0;
+      return this.inner._canSanitize(raw) ? this.inner.sanitize(raw) : void 0;
+    }
+    isValid(raw, ctx, path) {
+      if (raw === void 0 || raw === null) return true;
+      return this.inner.isValid(raw, ctx, path);
+    }
+    _canSanitize(raw) {
+      return raw === void 0 || raw === null || this.inner._canSanitize(raw);
+    }
+  };
+  var Str = class extends Base {
+    constructor(_default = "") {
+      super();
+      this._default = _default;
+    }
+    sanitize(raw) {
+      return typeof raw === "string" ? raw : this._default;
+    }
+    isValid(raw, ctx, path) {
+      if (typeof raw === "string") return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected string, got " + typeof raw);
+      return false;
+    }
+  };
+  var Num = class extends Base {
+    constructor(_default = 0) {
+      super();
+      this._default = _default;
+    }
+    sanitize(raw) {
+      return typeof raw === "number" && isFinite(raw) ? raw : this._default;
+    }
+    isValid(raw, ctx, path) {
+      if (typeof raw === "number" && isFinite(raw)) return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected finite number, got " + JSON.stringify(raw));
+      return false;
+    }
+  };
+  var Bool = class extends Base {
+    constructor(_default = false) {
+      super();
+      this._default = _default;
+    }
+    sanitize(raw) {
+      return typeof raw === "boolean" ? raw : this._default;
+    }
+    isValid(raw, ctx, path) {
+      if (typeof raw === "boolean") return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected boolean, got " + typeof raw);
+      return false;
+    }
+  };
+  var Literal = class extends Base {
+    constructor(value) {
+      super();
+      this.value = value;
+      this._default = value;
+    }
+    sanitize(raw) {
+      return raw === this.value ? this.value : this._default;
+    }
+    isValid(raw, ctx, path) {
+      if (raw === this.value) return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected " + JSON.stringify(this.value) + ", got " + JSON.stringify(raw));
+      return false;
+    }
+  };
+  var Enum = class extends Base {
+    constructor(values, defaultVal) {
+      super();
+      this.values = values;
+      this._default = defaultVal != null ? defaultVal : values[0];
+    }
+    sanitize(raw) {
+      return this.values.includes(raw) ? raw : this._default;
+    }
+    isValid(raw, ctx, path) {
+      if (this.values.includes(raw)) return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected one of " + this.values.map((v) => JSON.stringify(v)).join(" | ") + ", got " + JSON.stringify(raw));
+      return false;
+    }
+  };
+  var Union = class extends Base {
+    constructor(schemas, defaultVal) {
+      super();
+      this.schemas = schemas;
+      /** Structural tag read by {@link describeSchema} — `schemas` alone cannot tell Union from Tuple. */
+      this._kind = "union";
+      this._default = defaultVal != null ? defaultVal : schemas[0]._default;
+    }
+    sanitize(raw) {
+      for (const s of this.schemas) {
+        if (s.isValid(raw)) return s.sanitize(raw);
+      }
+      return this._default;
+    }
+    isValid(raw, ctx, path) {
+      var _a;
+      const probe = ctx && { errors: [], warnings: [], strict: ctx.strict };
+      if (this.schemas.some((s) => s.isValid(raw, probe, path ? [...path] : void 0))) return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": no union member matched for value " + ((_a = JSON.stringify(raw)) != null ? _a : "").slice(0, 240));
+      return false;
+    }
+    _canSanitize(raw) {
+      return this.schemas.some((s) => s._canSanitize(raw));
+    }
+  };
+  var DiscriminatedUnion = class extends Base {
+    constructor(_key, _schemas, defaultVal) {
+      var _a;
+      super();
+      this._key = _key;
+      this._schemas = _schemas;
+      /** Structural tag read by {@link describeSchema}. */
+      this._kind = "discriminatedUnion";
+      this._default = defaultVal != null ? defaultVal : _schemas[0]._default;
+      this._map = /* @__PURE__ */ new Map();
+      for (const s of _schemas) {
+        const keySchema = s._shape[_key];
+        if (!keySchema) continue;
+        const literal = (_a = keySchema.inner) != null ? _a : keySchema;
+        this._map.set(literal._default, s);
+        if (keySchema.inner) this._absentMember = s;
+      }
+    }
+    _findSchema(raw) {
+      if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+      const val = raw[this._key];
+      if (val === void 0 || val === null) return this._absentMember;
+      return this._map.get(val);
+    }
+    sanitize(raw) {
+      var _a;
+      return ((_a = this._findSchema(raw)) != null ? _a : this._schemas[0]).sanitize(raw);
+    }
+    isValid(raw, ctx, path) {
+      const schema = this._findSchema(raw);
+      if (!schema) {
+        const val = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw[this._key] : void 0;
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": no discriminated union member matched " + this._key + "=" + JSON.stringify(val));
+        return false;
+      }
+      return schema.isValid(raw, ctx, path);
+    }
+    _canSanitize(raw) {
+      if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return false;
+      const schema = this._findSchema(raw);
+      return schema ? schema._canSanitize(raw) : this._schemas[0]._canSanitize(raw);
+    }
+  };
+  var Obj = class extends Base {
+    constructor(_shape) {
+      super();
+      this._shape = _shape;
+      const d = {};
+      for (const key of Object.keys(_shape)) d[key] = _shape[key]._default;
+      this._default = d;
+    }
+    sanitize(raw) {
+      const src = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+      const out = {};
+      for (const key of Object.keys(this._shape)) {
+        const v = this._shape[key].sanitize(src[key]);
+        if (v !== void 0) out[key] = v;
+      }
+      return out;
+    }
+    isValid(raw, ctx, path) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected object, got " + (Array.isArray(raw) ? "array" : typeof raw));
+        return false;
+      }
+      const obj = raw;
+      const p = path != null ? path : [];
+      let ok = true;
+      for (const key of Object.keys(this._shape)) {
+        p.push(key);
+        if (!this._shape[key].isValid(obj[key], ctx, p)) ok = false;
+        p.pop();
+      }
+      if (ctx == null ? void 0 : ctx.strict) {
+        for (const key of Object.keys(obj)) {
+          if (key in this._shape) continue;
+          if (obj[key] === void 0) continue;
+          p.push(key);
+          ctx.errors.push(pathStr(p) + ": " + PX_UNKNOWN_KEY_ERROR);
+          p.pop();
+          ok = false;
+        }
+      }
+      return ok;
+    }
+    _canSanitize(raw) {
+      return !!raw && typeof raw === "object" && !Array.isArray(raw);
+    }
+  };
+  var OpenObj = class extends Base {
+    constructor(_shape, _openSchema) {
+      super();
+      this._shape = _shape;
+      this._openSchema = _openSchema;
+      const d = {};
+      for (const key of Object.keys(_shape)) d[key] = _shape[key]._default;
+      this._default = d;
+    }
+    sanitize(raw) {
+      const src = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+      const out = __spreadValues({}, src);
+      for (const key of Object.keys(this._shape)) {
+        const v = this._shape[key].sanitize(src[key]);
+        if (v !== void 0) out[key] = v;
+      }
+      if (this._openSchema) {
+        for (const key of Object.keys(src)) {
+          if (!(key in this._shape)) out[key] = this._openSchema.sanitize(src[key]);
+        }
+      }
+      return out;
+    }
+    isValid(raw, ctx, path) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected object, got " + (Array.isArray(raw) ? "array" : typeof raw));
+        return false;
+      }
+      const obj = raw;
+      const p = path != null ? path : [];
+      let ok = true;
+      for (const key of Object.keys(this._shape)) {
+        p.push(key);
+        if (!this._shape[key].isValid(obj[key], ctx, p)) ok = false;
+        p.pop();
+      }
+      if (this._openSchema) {
+        for (const key of Object.keys(obj)) {
+          if (key in this._shape) continue;
+          p.push(key);
+          if (!this._openSchema.isValid(obj[key], ctx, p)) ok = false;
+          p.pop();
+        }
+      }
+      return ok;
+    }
+    _canSanitize(raw) {
+      return !!raw && typeof raw === "object" && !Array.isArray(raw);
+    }
+  };
+  var Arr = class extends Base {
+    constructor(item) {
+      super();
+      this.item = item;
+      this._default = [];
+    }
+    sanitize(raw) {
+      if (!Array.isArray(raw)) return [];
+      const out = [];
+      for (const el of raw) {
+        if (this.item._canSanitize(el)) out.push(this.item.sanitize(el));
+      }
+      return out;
+    }
+    isValid(raw, ctx, path) {
+      if (!Array.isArray(raw)) {
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected array, got " + typeof raw);
+        return false;
+      }
+      const p = path != null ? path : [];
+      let ok = true;
+      for (let i = 0; i < raw.length; i++) {
+        p.push("[" + i + "]");
+        if (!this.item.isValid(raw[i], ctx, p)) ok = false;
+        p.pop();
+      }
+      return ok;
+    }
+    _canSanitize(raw) {
+      return Array.isArray(raw);
+    }
+  };
+  var Rec = class extends Base {
+    constructor(value) {
+      super();
+      this.value = value;
+      /** Structural tag read by {@link describeSchema}. */
+      this._kind = "record";
+      this._default = {};
+    }
+    sanitize(raw) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+      const out = {};
+      for (const [k, v] of Object.entries(raw)) {
+        if (this.value._canSanitize(v)) out[k] = this.value.sanitize(v);
+      }
+      return out;
+    }
+    isValid(raw, ctx, path) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected object/record, got " + (Array.isArray(raw) ? "array" : typeof raw));
+        return false;
+      }
+      const p = path != null ? path : [];
+      let ok = true;
+      for (const [k, v] of Object.entries(raw)) {
+        p.push(k);
+        if (!this.value.isValid(v, ctx, p)) ok = false;
+        p.pop();
+      }
+      return ok;
+    }
+    _canSanitize(raw) {
+      return !!raw && typeof raw === "object" && !Array.isArray(raw);
+    }
+  };
+  var Any = class extends Base {
+    constructor() {
+      super(...arguments);
+      this._default = void 0;
+    }
+    sanitize(raw) {
+      return raw;
+    }
+    isValid(_raw, _ctx, _path) {
+      return true;
+    }
+    _canSanitize(_raw) {
+      return true;
+    }
+  };
+  var Defined = class extends Base {
+    constructor() {
+      super(...arguments);
+      this._default = void 0;
+    }
+    sanitize(raw) {
+      return raw;
+    }
+    isValid(raw, ctx, path) {
+      if (raw !== void 0) return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": required value is missing");
+      return false;
+    }
+    _canSanitize(raw) {
+      return raw !== void 0;
+    }
+  };
+  var Lazy = class extends Base {
+    constructor(fn, _default) {
+      super();
+      this.fn = fn;
+      this._default = _default;
+      this.resolved = null;
+    }
+    get schema() {
+      var _a;
+      return (_a = this.resolved) != null ? _a : this.resolved = this.fn();
+    }
+    sanitize(raw) {
+      return this.schema.sanitize(raw);
+    }
+    isValid(raw, ctx, path) {
+      return this.schema.isValid(raw, ctx, path);
+    }
+    _canSanitize(raw) {
+      return this.schema._canSanitize(raw);
+    }
+  };
+  var Tuple = class extends Base {
+    constructor(schemas) {
+      super();
+      this.schemas = schemas;
+      /** Structural tag read by {@link describeSchema} — `schemas` alone cannot tell Tuple from Union. */
+      this._kind = "tuple";
+      this._default = schemas.map((s) => s._default);
+    }
+    sanitize(raw) {
+      if (!Array.isArray(raw) || raw.length !== this.schemas.length) return this._default;
+      return this.schemas.map((s, i) => s.sanitize(raw[i]));
+    }
+    isValid(raw, ctx, path) {
+      if (!Array.isArray(raw) || raw.length !== this.schemas.length) {
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected tuple of length " + this.schemas.length + ", got " + (Array.isArray(raw) ? "array[" + raw.length + "]" : typeof raw));
+        return false;
+      }
+      const p = path != null ? path : [];
+      let ok = true;
+      for (let i = 0; i < this.schemas.length; i++) {
+        p.push("[" + i + "]");
+        if (!this.schemas[i].isValid(raw[i], ctx, p)) ok = false;
+        p.pop();
+      }
+      return ok;
+    }
+    // Require exact length so wrong-length arrays are dropped rather than repaired to default.
+    _canSanitize(raw) {
+      return Array.isArray(raw) && raw.length === this.schemas.length;
+    }
+  };
+  function implementsInterface() {
+    return (schema) => schema;
+  }
+  var px = {
+    /** Matches a string. Default: '' or provided value. */
+    string: (defaultVal = "") => new Str(defaultVal),
+    /** Matches a finite number. Default: 0 or provided value. */
+    number: (defaultVal = 0) => new Num(defaultVal),
+    /** Matches a boolean. Default: false or provided value. */
+    boolean: (defaultVal = false) => new Bool(defaultVal),
+    /** Matches one exact primitive value; its default is the value itself. */
+    literal: (value) => new Literal(value),
+    /** Matches one of a fixed set of string/number values. Default: first value. */
+    enum: (values, defaultVal) => new Enum(values, defaultVal),
+    /**
+     * Returns the first schema whose isValid passes.
+     * TypeScript infers the union of all member types automatically.
+     */
+    union: (schemas, defaultVal) => new Union(schemas, defaultVal),
+    /**
+     * Discriminated union — reads `raw[key]`, finds the member schema whose
+     * literal at `key` matches, then delegates sanitize/isValid to that member.
+     * Each member must be an object schema with a `px.literal(...)` at `key`.
+     * TypeScript infers the union of all member types automatically.
+     */
+    discriminatedUnion: (key, schemas) => new DiscriminatedUnion(key, schemas),
+    /** Typed object — unknown keys are stripped. Required fields fall back to their default. */
+    object: (shape) => new Obj(shape),
+    /**
+     * Open object — validates known keys; passes unknown keys through as-is,
+     * or validates/sanitizes them against `openSchema` when provided.
+     */
+    openObject: (shape, openSchema) => new OpenObj(shape, openSchema),
+    /**
+     * Creates a new closed object schema by merging a base schema's shape with additional fields.
+     * The base can be the result of px.object() or px.openObject() — anything with a _shape property.
+     *
+     * @example
+     * const PxSvgNodeSchema = px.extendedObject(PxNodeBase, { width: px.number().optional() });
+     */
+    extendedObject: (base, extra) => new Obj(__spreadValues(__spreadValues({}, base._shape), extra)),
+    /** Array whose unrecoverable items are filtered out. Default: []. */
+    array: (item) => new Arr(item),
+    /** String-keyed record whose unrecoverable values are dropped. Default: {}. */
+    record: (value) => new Rec(value),
+    /** Passes anything through unchanged — always valid. */
+    any: () => new Any(),
+    /** Anything EXCEPT `undefined` — an open type whose presence is required (V6). */
+    defined: () => new Defined(),
+    /** Fixed-length tuple — validates element count and each position individually. */
+    tuple: (schemas) => new Tuple(schemas),
+    /** Defers schema creation — required for recursive types. Must supply a default value. */
+    lazy: (fn, defaultVal) => new Lazy(fn, defaultVal)
+  };
+
+  // ../svg-animator-core/src/format/PxAnimatorConstants.ts
+  var PxTimelineEngine = {
+    native: "native",
+    js: "js"
+  };
+  var PxTimelineEngineExtra = __spreadProps(__spreadValues({}, PxTimelineEngine), {
+    auto: "auto"
+  });
+  var PxLoopRepeatAt = {
+    /** Segment from the START; the repetition runs BEFORE the first keyframe
+     *  (intro loops that play until the main timeline begins). */
+    start: "start",
+    /** DEFAULT — segment from the END; the repetition runs AFTER the last keyframe
+     *  (idle/outro loops that continue once the main timeline has finished). */
+    end: "end"
+  };
+  var PxLoopDirection = {
+    /** DEFAULT — cycle: every repetition replays the segment the same way round. */
+    normal: "normal",
+    /** Ping-pong: repetitions alternate forward / backward. */
+    alternate: "alternate"
+  };
+  var PxMaskType = {
+    luminance: "luminance",
+    alpha: "alpha"
+  };
+  var PxUnits = {
+    userSpaceOnUse: "userSpaceOnUse",
+    objectBoundingBox: "objectBoundingBox"
+  };
+  var PxCloneWithout = {
+    translate: "translate"
+    // transform: 'transform',   // future: drop rotate/scale too (content only)
+  };
+  var PxPathOverflow = {
+    clip: "clip",
+    extend: "extend"
+  };
+  var PxLengthAdjust = {
+    spacing: "spacing",
+    spacingAndGlyphs: "spacingAndGlyphs"
+  };
+  var PxTextPathMethod = {
+    align: "align",
+    stretch: "stretch"
+  };
+  var PxTextPathSpacing = {
     auto: "auto",
-    waapi: "waapi",
-    frames: "frames"
+    exact: "exact"
+  };
+  var PxStrokeTrimSubPaths = {
+    separate: "separate",
+    combined: "combined"
+  };
+  var TRANSFORM_ATTR = "transform";
+  var TRANSFORM_PART = {
+    translate: "translate",
+    rotate: "rotate",
+    scale: "scale",
+    origin: "origin"
+  };
+  var PX_TRANSFORM_PART_KEYS = [
+    TRANSFORM_PART.translate,
+    TRANSFORM_PART.rotate,
+    TRANSFORM_PART.scale,
+    TRANSFORM_PART.origin
+  ];
+  var PxGradientUnits = {
+    userSpaceOnUse: "userSpaceOnUse",
+    objectBoundingBox: "objectBoundingBox"
   };
-  var PxAnimatorEngine = {
-    waapi: PxAnimatorMode.waapi,
-    frames: PxAnimatorMode.frames
+  var PxGradientSpreadMethod = {
+    pad: "pad",
+    reflect: "reflect",
+    repeat: "repeat"
   };
-  var PxLoopExtend = {
-    /** Segment from the START; the animation is extended BEFORE the first keyframe
-     *  (intro loops that run before the main timeline begins). */
-    before: "before",
-    /** DEFAULT — segment from the END; extended AFTER the last keyframe (idle/outro
-     *  loops that continue once the main timeline has finished). */
-    after: "after"
+  var PxGradientType = {
+    linear: "linear",
+    radial: "radial"
   };
   function getAnimatorConfig(doc) {
     var _a;
-    return (doc == null ? void 0 : doc.animator) || ((_a = doc == null ? void 0 : doc.meta) == null ? void 0 : _a.animator);
+    const cfg = (doc == null ? void 0 : doc.animator) || ((_a = doc == null ? void 0 : doc.meta) == null ? void 0 : _a.animator);
+    return cfg ? flattenAnimatorTimeline(cfg) : void 0;
+  }
+  var flattenMemo = /* @__PURE__ */ new WeakMap();
+  function flattenAnimatorTimeline(cfg) {
+    const timeline = cfg.timeline;
+    if (timeline === void 0 || timeline === null || typeof timeline !== "object") return cfg;
+    const memoised = flattenMemo.get(cfg);
+    if (memoised) return memoised;
+    const _a = cfg, { timeline: _dropped } = _a, flat = __objRest(_a, ["timeline"]);
+    if (timeline.engine !== void 0) flat.engine = timeline.engine;
+    if (timeline.frameRate !== void 0) flat.frameRate = timeline.frameRate;
+    if (timeline.type === "scroll" || timeline.type === "view") {
+      flat.timelineSource = "scroll";
+      if (timeline.duration !== void 0) flat.duration = timeline.duration;
+      if (timeline.iterations !== void 0) flat.iterations = timeline.iterations;
+      const scroll = __spreadValues({}, flat.scroll || {});
+      scroll.kind = timeline.type;
+      if (timeline.axis !== void 0) scroll.axis = timeline.axis;
+      if (timeline.source !== void 0) scroll.source = timeline.source;
+      if (timeline.subject !== void 0) scroll.subject = timeline.subject;
+      if (timeline.smoothing !== void 0) scroll.smoothing = timeline.smoothing;
+      if (timeline.range !== void 0) scroll.range = timeline.range;
+      const pin = timeline.pin;
+      if (typeof pin === "boolean") scroll.pin = pin;
+      else if (pin && typeof pin === "object") {
+        scroll.pin = true;
+        if (pin.align !== void 0) scroll.pinAlign = pin.align;
+        if (pin.top !== void 0) scroll.pinTop = pin.top;
+        if (pin.distance !== void 0) scroll.pinDistance = pin.distance;
+      }
+      flat.scroll = scroll;
+    } else {
+      if (timeline.duration !== void 0) flat.duration = timeline.duration;
+      if (timeline.trigger !== void 0) {
+        const _b = timeline.trigger, { finishAction } = _b, restTrigger = __objRest(_b, ["finishAction"]);
+        if (Object.keys(restTrigger).length) flat.trigger = restTrigger;
+        if (finishAction !== void 0) flat.resetOnFinish = finishAction === "reset";
+      }
+      if (timeline.delay !== void 0) flat.delay = timeline.delay;
+      if (timeline.iterations !== void 0) flat.iterations = timeline.iterations;
+      if (timeline.direction !== void 0) flat.direction = timeline.direction;
+      if (timeline.fillMode !== void 0) flat.fill = timeline.fillMode;
+    }
+    flattenMemo.set(cfg, flat);
+    return flat;
   }
   function getDefs(doc) {
     var _a;
@@ -466,13 +1095,379 @@ var PixodeskAnimator = (() => {
     if (!doc) return void 0;
     const animateById = (_a = getAnimatorConfig(doc)) == null ? void 0 : _a.animateById;
     if (!animateById) return void 0;
-    return Object.entries(animateById).map(([id, anim]) => ({ id, animate: anim }));
+    return Object.entries(animateById).map(([id, anim]) => ({ id: id.startsWith("#") ? id.slice(1) : id, animate: anim }));
   }
 
-  // ../svg-animator-core/src/PxMotionPath.ts
-  function getKfTranslate(kf) {
+  // ../svg-animator-core/src/format/PxAnimatorTypes.ts
+  var PxEasingOrRefSchema = px.union([
+    px.string(),
+    px.tuple([px.number(), px.number(), px.number(), px.number()])
+  ]);
+  var PxKeyframeValueSchema = implementsInterface()(px.union([
+    px.string(),
+    // e.g. for colors
+    px.number(),
+    px.array(px.number()),
+    // ORDER LAW: the key-discriminated object shapes (`{path}`, `{paths}`) come BEFORE the
+    // all-optional transform-parts record. In default (non-strict) mode that record accepts
+    // ANY object (every key optional, unknown keys ignored), so listing it earlier made
+    // Union.sanitize route `{path}`/`{paths}` values into it and strip them to `{}` —
+    // silent morph-data loss (repro: the editor's keyframeValueSanitize spec). Validity is
+    // order-independent (`some()`); only sanitize routing depends on this order.
+    px.object({ path: px.string() }),
+    px.lazy(() => px.object({ paths: px.array(PxBezierPathSchema) }), { paths: [] }),
+    // Gradient `stops` timeline — each kf value is the full stops-array snapshot.
+    px.lazy(() => px.array(PxGradientStopSchema), []),
+    px.lazy(() => PxTransformPartsSchema, {})
+  ]));
+  var PxKeyframeSchema = implementsInterface()(px.object({
+    time: px.number().optional(),
+    value: PxKeyframeValueSchema.optional(),
+    easing: PxEasingOrRefSchema.optional(),
+    tangentOut: px.tuple([px.number(), px.number()]).optional(),
+    tangentIn: px.tuple([px.number(), px.number()]).optional()
+    // (`selected` — editor timeline-selection UI state — was REMOVED from the wire
+    // (review §1.3): editor data lives under `meta`. The editor still carries it on
+    // its internal COPY-PASTE payload, which never validates against this schema.)
+  }));
+  var anyKf = (kf) => kf;
+  var kfTime = (kf) => {
+    var _a, _b;
+    return (_b = (_a = anyKf(kf).time) != null ? _a : anyKf(kf).t) != null ? _b : 0;
+  };
+  var kfValue = (kf) => {
     var _a;
-    const v = (_a = kf.value) != null ? _a : kf.v;
+    return (_a = anyKf(kf).value) != null ? _a : anyKf(kf).v;
+  };
+  var kfEasing = (kf) => {
+    var _a;
+    return (_a = anyKf(kf).easing) != null ? _a : anyKf(kf).e;
+  };
+  var kfTangentIn = (kf) => anyKf(kf).tangentIn;
+  var kfTangentOut = (kf) => anyKf(kf).tangentOut;
+  var PxLoopSchema = implementsInterface()(px.object({
+    segmentCount: px.number().optional(),
+    repeatAt: px.enum([PxLoopRepeatAt.start, PxLoopRepeatAt.end]).optional(),
+    direction: px.enum([PxLoopDirection.normal, PxLoopDirection.alternate]).optional()
+  }));
+  var PxPropertyAnimationSchema = implementsInterface()(px.object({
+    value: PxKeyframeValueSchema.optional(),
+    keyframes: px.array(PxKeyframeSchema).optional(),
+    loop: px.union([PxLoopSchema, px.boolean()]).optional(),
+    autoOrient: px.boolean().optional(),
+    alongPathMode: px.enum(["sampled", "offsetPath"]).optional()
+  }));
+  var PxTransformPartsSchema = implementsInterface()(px.object({
+    translate: px.tuple([px.number(), px.number()]).optional(),
+    rotate: px.number().optional(),
+    skew: px.number().optional(),
+    scale: px.tuple([px.number(), px.number()]).optional(),
+    origin: px.tuple([px.number(), px.number()]).optional()
+  }));
+  var PxTransformValueSchema = px.union([
+    px.string(),
+    PxTransformPartsSchema,
+    px.object({ value: PxTransformPartsSchema }),
+    PxPropertyAnimationSchema
+  ]);
+  var PxAnimationDefinitionSchema = implementsInterface()(
+    px.record(PxPropertyAnimationSchema)
+  );
+  var PxElementAnimationSchema = implementsInterface()(px.union([
+    px.string(),
+    px.array(px.union([px.string(), PxAnimationDefinitionSchema])),
+    PxAnimationDefinitionSchema
+  ]));
+  var PxTriggerSchema = implementsInterface()(px.object({
+    startOn: px.enum(["load", "mouseOver", "click", "scrollIntoView", "programmatic"]).optional(),
+    outAction: px.enum(["continue", "pause", "reset", "reverse"]).optional(),
+    // What happens after a NATURAL finish — `'hold'` (default: keep the end state per
+    // `fill`) or `'reset'` (snap back to the start state). Pairs with `outAction` ("what
+    // happens when the trigger condition ends"); both end-of-life knobs now read alike.
+    finishAction: px.enum(["hold", "reset"]).optional(),
+    scrollIntoViewThreshold: px.number().optional()
+  }));
+  var PxGlyphSchema = implementsInterface()(px.object({
+    width: px.number(),
+    d: px.string()
+  }));
+  var PxGlyphFontSchema = implementsInterface()(px.object({
+    fontFamily: px.string(),
+    fontStyle: px.string(),
+    ascent: px.number(),
+    unitsPerEm: px.number(),
+    glyphs: px.record(PxGlyphSchema)
+  }));
+  var PxDefsSchema = implementsInterface()(px.object({
+    easings: px.record(px.tuple([px.number(), px.number(), px.number(), px.number()])).optional(),
+    animations: px.record(PxAnimationDefinitionSchema).optional(),
+    // Review §2.6: the schema now matches the declared type — a style preset is a flat
+    // record of string|number attribute values, nothing nested.
+    styles: px.record(px.record(px.union([px.string(), px.number()]))).optional(),
+    fonts: px.record(PxGlyphFontSchema).optional()
+  }));
+  var PX_SCROLL_PHASES = ["cover", "contain", "entry", "exit", "entry-crossing", "exit-crossing"];
+  var PxScrollRangePointSchema = implementsInterface()(px.object({
+    phase: px.enum(PX_SCROLL_PHASES).optional(),
+    fraction: px.number().optional()
+  }));
+  var PxScrollRangeSchema = px.object({
+    start: PxScrollRangePointSchema.optional(),
+    end: PxScrollRangePointSchema.optional()
+  });
+  var PxScrollSchema = implementsInterface()(px.object({
+    kind: px.enum(["view", "scroll"]).optional(),
+    axis: px.enum(["block", "inline", "x", "y"]).optional(),
+    source: px.enum(["nearest", "root"]).optional(),
+    // Free-form: the two keywords `parent`/`scroller` plus any CSS selector.
+    subject: px.string().optional(),
+    smoothing: px.number().optional(),
+    pin: px.boolean().optional(),
+    pinAlign: px.enum(["top", "center", "bottom"]).optional(),
+    pinTop: px.number().optional(),
+    pinDistance: px.number().optional(),
+    range: PxScrollRangeSchema.optional()
+  }));
+  var PxTimelinePinSchema = implementsInterface()(px.object({
+    align: px.enum(["top", "center", "bottom"]).optional(),
+    top: px.number().optional(),
+    distance: px.number().optional()
+  }));
+  var PxTimelineEngineSchema = px.enum([PxTimelineEngineExtra.auto, PxTimelineEngineExtra.native, PxTimelineEngineExtra.js]).optional();
+  var PxTimeTimelineSchema = implementsInterface()(px.object({
+    type: px.literal("time").optional(),
+    engine: PxTimelineEngineSchema,
+    frameRate: px.number().optional(),
+    // §2.8: duration is a property of the TIMELINE — how long one pass takes.
+    duration: px.number().optional(),
+    trigger: PxTriggerSchema.optional(),
+    delay: px.number().optional(),
+    iterations: px.union([px.number(), px.literal("infinite")]).optional(),
+    // `fillMode` on the wire (CSS `animation-fill-mode`; the runtime view calls it `fill`)
+    // — never `fill`, which is paint everywhere else in the format.
+    fillMode: px.enum(["forwards", "backwards", "both", "none"]).optional(),
+    direction: px.enum(["normal", "reverse", "alternate", "alternate-reverse"]).optional()
+  }));
+  var scrollishTimelineShape = {
+    // §2.8: duration is a property of the TIMELINE — under scrubbing it is the keyframe
+    // span the scroll range maps onto.
+    duration: px.number().optional(),
+    // Finite repeat count IS meaningful when scrubbing — the scroll range maps onto
+    // duration × iterations (rule D4; `'infinite'` cannot map to a range, so no literal here).
+    iterations: px.number().optional(),
+    engine: PxTimelineEngineSchema,
+    frameRate: px.number().optional(),
+    axis: px.enum(["block", "inline", "x", "y"]).optional(),
+    source: px.enum(["nearest", "root"]).optional(),
+    subject: px.string().optional(),
+    // 'parent' | 'scroller' | any CSS selector
+    smoothing: px.number().optional(),
+    // ms
+    pin: px.union([px.boolean(), PxTimelinePinSchema]).optional(),
+    range: PxScrollRangeSchema.optional()
+  };
+  var PxScrollTimelineSchema = implementsInterface()(
+    px.object(__spreadValues({ type: px.literal("scroll") }, scrollishTimelineShape))
+  );
+  var PxViewTimelineSchema = implementsInterface()(
+    px.object(__spreadValues({ type: px.literal("view") }, scrollishTimelineShape))
+  );
+  var PxTimelineSchema = px.discriminatedUnion("type", [
+    PxTimeTimelineSchema,
+    // first = the member an absent `type` selects
+    PxScrollTimelineSchema,
+    PxViewTimelineSchema
+  ]);
+  var PxAnimatorConfigSchema = implementsInterface()(px.object({
+    // (`mode`, `duration` and `frameRate` live INSIDE `timeline` on the wire — §2.8; they exist
+    // at this level only on the runtime view, like the rest of the playback dynamics.)
+    // THE spelling of "what advances progress" — clock / scroll / view (review §2.1).
+    timeline: PxTimelineSchema.optional(),
+    definitions: PxDefsSchema.optional(),
+    animateById: px.record(PxElementAnimationSchema).optional(),
+    debugGlobalName: px.string().optional(),
+    // Declared HERE because this is a closed object: an undeclared key would be stripped by
+    // `sanitize` and flagged by strict validation on our own files.
+    version: px.string().optional()
+  }));
+  var PxBindingSchema = implementsInterface()(px.object({
+    id: px.string(),
+    animate: PxElementAnimationSchema
+  }));
+  var PxAttrValueSchema = px.union([
+    px.string(),
+    px.number(),
+    px.array(px.number()),
+    // Structured static — `{value: …}` (read-accepted transitional spelling, S1).
+    // `defined`, not `any`: the KEY's presence is what identifies this branch (V6).
+    px.object({ value: px.defined() }),
+    // Bare transform parts record — the canonical static `transform` on the wire (T2).
+    PxTransformPartsSchema
+  ]);
+  var PxAnimatableNumberSchema = px.union([
+    px.number(),
+    PxPropertyAnimationSchema,
+    px.object({ value: px.number() })
+  ]);
+  var PxAnimatableVec2Schema = px.union([
+    px.tuple([px.number(), px.number()]),
+    PxPropertyAnimationSchema,
+    px.object({ value: px.tuple([px.number(), px.number()]) })
+  ]);
+  var PxAnimatableStringSchema = px.union([
+    px.string(),
+    PxPropertyAnimationSchema,
+    px.object({ value: px.string() })
+  ]);
+  var PxTransformByEffectSchema = implementsInterface()(px.object({
+    translate: PxAnimatableVec2Schema.optional(),
+    rotate: PxAnimatableNumberSchema.optional(),
+    scale: PxAnimatableVec2Schema.optional(),
+    skew: PxAnimatableNumberSchema.optional(),
+    origin: PxAnimatableVec2Schema.optional()
+  }));
+  var PxRepeaterEffectSchema = implementsInterface()(px.object({
+    // STATIC config, not a channel (V2/SCHEMA-DESIGN R5): the copy COUNT is read
+    // once at expansion time and never sampled — plain number, no `keyframes`.
+    copies: px.number().optional(),
+    translate: PxAnimatableVec2Schema.optional(),
+    rotate: PxAnimatableNumberSchema.optional(),
+    skew: PxAnimatableNumberSchema.optional(),
+    scale: PxAnimatableVec2Schema.optional(),
+    origin: PxAnimatableVec2Schema.optional()
+  }));
+  var PxMaskedByEffectSchema = implementsInterface()(px.object({
+    source: px.string().optional(),
+    maskType: px.enum([PxMaskType.luminance, PxMaskType.alpha]).optional(),
+    maskUnits: px.enum([PxUnits.userSpaceOnUse, PxUnits.objectBoundingBox]).optional(),
+    maskContentUnits: px.enum([PxUnits.userSpaceOnUse, PxUnits.objectBoundingBox]).optional(),
+    x: px.number().optional(),
+    y: px.number().optional(),
+    width: px.number().optional(),
+    height: px.number().optional()
+  }));
+  var PxClipPathEffectSchema = implementsInterface()(px.object({
+    d: PxAnimatableStringSchema.optional()
+  }));
+  var PxStrokeTrimEffectSchema = implementsInterface()(px.object({
+    offset: PxAnimatableNumberSchema.optional(),
+    range: PxAnimatableVec2Schema.optional(),
+    subPaths: px.enum([PxStrokeTrimSubPaths.separate, PxStrokeTrimSubPaths.combined]).optional()
+  }));
+  var PxRetimeEffectSchema = implementsInterface()(px.object({
+    start: px.number().optional(),
+    stretch: px.number().optional(),
+    timeCrop: px.tuple([px.number(), px.number()]).optional()
+  }));
+  var PxCloneEffectSchema = implementsInterface()(px.object({
+    // Subtractive on purpose: the `<use>` can only point at one wrapper layer of the
+    // source, so the choices form a ladder — 'translate' now, maybe 'transform' later.
+    without: px.enum([PxCloneWithout.translate]).optional(),
+    source: px.string().optional(),
+    retime: PxRetimeEffectSchema.optional()
+  }));
+  var PxGradientStopSchema = implementsInterface()(px.object({
+    offset: px.number(),
+    color: px.string()
+  }));
+  var PxAnimatableGradientStopsSchema = px.union([
+    px.array(PxGradientStopSchema),
+    px.object({ value: px.array(PxGradientStopSchema) }),
+    PxPropertyAnimationSchema
+  ]);
+  var PxFillGradientEffectSchema = implementsInterface()(px.object({
+    // Contextual kind — the `type` convention, see `PxNodeBase.type`.
+    type: px.enum([PxGradientType.linear, PxGradientType.radial]),
+    start: PxAnimatableVec2Schema.optional(),
+    end: PxAnimatableVec2Schema.optional(),
+    center: PxAnimatableVec2Schema.optional(),
+    radius: PxAnimatableNumberSchema.optional(),
+    focal: PxAnimatableVec2Schema.optional(),
+    stops: PxAnimatableGradientStopsSchema.optional(),
+    gradientUnits: px.enum([PxGradientUnits.userSpaceOnUse, PxGradientUnits.objectBoundingBox]).optional(),
+    spreadMethod: px.enum([PxGradientSpreadMethod.pad, PxGradientSpreadMethod.reflect, PxGradientSpreadMethod.repeat]).optional(),
+    gradientTransform: px.string().optional()
+  }));
+  var PxStrokeGradientEffectSchema = PxFillGradientEffectSchema;
+  var PxTextPathEffectSchema = implementsInterface()(px.object({
+    pathData: px.string(),
+    pathOverflow: px.enum([PxPathOverflow.clip, PxPathOverflow.extend]).optional(),
+    lengthAdjust: px.enum([PxLengthAdjust.spacing, PxLengthAdjust.spacingAndGlyphs]).optional(),
+    method: px.enum([PxTextPathMethod.align, PxTextPathMethod.stretch]).optional(),
+    spacing: px.enum([PxTextPathSpacing.auto, PxTextPathSpacing.exact]).optional(),
+    startOffset: PxAnimatableNumberSchema.optional(),
+    textLength: PxAnimatableNumberSchema.optional()
+  }));
+  var PxTextEffectSchema = implementsInterface()(px.object({
+    useGlyphs: px.boolean().optional()
+  }));
+  var PxEffectsSchema = implementsInterface()(px.object({
+    transformBy: PxTransformByEffectSchema.optional(),
+    repeater: PxRepeaterEffectSchema.optional(),
+    maskedBy: PxMaskedByEffectSchema.optional(),
+    clipPath: PxClipPathEffectSchema.optional(),
+    strokeTrim: PxStrokeTrimEffectSchema.optional(),
+    clone: PxCloneEffectSchema.optional(),
+    fillGradient: PxFillGradientEffectSchema.optional(),
+    strokeGradient: PxStrokeGradientEffectSchema.optional(),
+    textPath: PxTextPathEffectSchema.optional(),
+    text: PxTextEffectSchema.optional()
+  }));
+  var PxNodeBase = px.openObject({
+    // CONVENTION (SCHEMA-DESIGN R1 / issues N4): `type` is the ONE word for "what
+    // kind of thing is this", discriminated by its CARRIER — here the node TAG
+    // (`rect`, `text`), and inside a sub-object that object's kind (`fillGradient.type`,
+    // `fillGradient.type`, editor `preset.type`). Each sits in its own object, so
+    // the carrier disambiguates completely; synonyms (`cloneKind`, `presetShape`)
+    // would add words that all mean "type" and still need the carrier to read.
+    // Guarding a `type` SLOT against a wrong VALUE is the job of strict enums
+    // (issues V3), never of distinct key names.
+    type: px.string(),
+    // The escape hatch for elements that carry a REAL `type` attribute — `<feTurbulence
+    // type="fractalNoise">`, `<feFuncR type="table">`, `<feColorMatrix type="saturate">`.
+    // `type` is taken by the tag name, so the attribute travels here and the renderer puts
+    // it back (`PxAnimatorDOM.renderNode`, `PxRnRender`). Declared here — not merely
+    // documented — because a wire key that is not in a schema is invisible to the
+    // minifier's reserve list and gets renamed (MINIFICATION-BOUNDARY-PLAN.md §1.1).
+    domType: px.string().optional(),
+    id: px.string().optional(),
+    meta: px.any().optional(),
+    // Player-effects bucket emitted by the Editor's lightweight design format.
+    // Consumed and removed by `applyPlayerEffects` before any other normalisation
+    // (see `createAnimatorImpl`), so downstream code never sees it.
+    effects: PxEffectsSchema.optional(),
+    // `PxElementAnimation` (not just `PxAnimationDefinition`) — accepts
+    // string ref / array of refs / inline definition / mixed array; mirrors
+    // `animator.animateById` map values and what `processNode` resolves at runtime.
+    animate: PxElementAnimationSchema.optional(),
+    style: px.union([px.string(), px.record(px.union([px.string(), px.number()]))]).optional()
+  }, PxAttrValueSchema);
+  var PxNodeSchema = px.openObject(__spreadProps(__spreadValues({}, PxNodeBase._shape), {
+    children: px.lazy(() => px.array(PxNodeSchema), []).optional()
+  }), PxAttrValueSchema);
+  var PxSvgNodeExtra = px.object({
+    // `"100%"` and other SVG length strings are legal here — a number-only slot rejected
+    // real documents (e.g. apple-store-look-14-main.json) at the root <svg>.
+    width: px.union([px.number(), px.string()]).optional(),
+    height: px.union([px.number(), px.string()]).optional(),
+    viewBox: px.string().optional(),
+    animator: PxAnimatorConfigSchema.optional()
+  });
+  var PxAnimatedSvgDocumentSchema = px.openObject(__spreadProps(__spreadValues(__spreadValues({}, PxNodeBase._shape), PxSvgNodeExtra._shape), {
+    type: px.literal("svg"),
+    // override string → literal to require 'svg'
+    children: px.array(PxNodeSchema).optional()
+  }), PxAttrValueSchema);
+  var PxBezierPathSchema = implementsInterface()(px.object({
+    v: px.array(px.array(px.number())),
+    i: px.array(px.array(px.number())).optional(),
+    o: px.array(px.array(px.number())).optional(),
+    c: px.boolean().optional()
+  }));
+
+  // ../svg-animator-core/src/materialise/PxMotionPath.ts
+  function getKfTranslate(kf) {
+    const v = kfValue(kf);
     if (!v) return void 0;
     if (Array.isArray(v) && v.length >= 2 && typeof v[0] === "number" && typeof v[1] === "number") {
       return [v[0], v[1]];
@@ -482,31 +1477,27 @@ var PixodeskAnimator = (() => {
     return void 0;
   }
   function getKfTime(kf) {
-    var _a, _b;
-    return (_b = (_a = kf.time) != null ? _a : kf.t) != null ? _b : 0;
+    return kfTime(kf);
   }
   function getKfEasing(kf) {
-    var _a;
-    return (_a = kf.easing) != null ? _a : kf.e;
+    return kfEasing(kf);
   }
   function propAnimIsMotionPath(anim) {
-    var _a, _b, _c;
-    const kfs = (_a = anim.keyframes) != null ? _a : anim.kfs;
+    const kfs = anim.keyframes;
     if (!Array.isArray(kfs)) return false;
     if (anim.autoOrient) return true;
     for (const kf of kfs) {
-      if (((_b = kf.tangentIn) != null ? _b : kf.ti) || ((_c = kf.tangentOut) != null ? _c : kf.to)) return true;
+      if (kfTangentIn(kf) || kfTangentOut(kf)) return true;
     }
     return false;
   }
   var _segmentCache = /* @__PURE__ */ new WeakMap();
   function getSegmentCache(prevKf, nextKf, prevPos, nextPos) {
-    var _a, _b;
     let byNext = _segmentCache.get(prevKf);
     const existing = byNext == null ? void 0 : byNext.get(nextKf);
     if (existing) return existing;
-    const to = (_a = prevKf.tangentOut) != null ? _a : prevKf.to;
-    const ti = (_b = nextKf.tangentIn) != null ? _b : nextKf.ti;
+    const to = kfTangentOut(prevKf);
+    const ti = kfTangentIn(nextKf);
     const P1 = [prevPos[0] + (to ? to[0] : 0), prevPos[1] + (to ? to[1] : 0)];
     const P2 = [nextPos[0] + (ti ? ti[0] : 0), nextPos[1] + (ti ? ti[1] : 0)];
     const lut = bezier2D_arcLengthLUT(prevPos, P1, P2, nextPos);
@@ -529,14 +1520,14 @@ var PixodeskAnimator = (() => {
   var DEFAULT_ROTATION_TOL = 5;
   var DEFAULT_MAX_SAMPLES = 32;
   function materialiseMotionPathInPropAnim(anim, opts) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     if (!propAnimIsMotionPath(anim)) return anim;
-    const kfs = (_a = anim.keyframes) != null ? _a : anim.kfs;
+    const kfs = anim.keyframes;
     if (!Array.isArray(kfs) || kfs.length < 2) return anim;
     const autoOrient = !!anim.autoOrient;
-    const flatnessTol = (_b = opts == null ? void 0 : opts.flatnessTolerance) != null ? _b : DEFAULT_FLATNESS_TOL;
-    const rotationTol = (_c = opts == null ? void 0 : opts.rotationTolerance) != null ? _c : DEFAULT_ROTATION_TOL;
-    const maxSamples = (_d = opts == null ? void 0 : opts.maxSamplesPerSegment) != null ? _d : DEFAULT_MAX_SAMPLES;
+    const flatnessTol = (_a = opts == null ? void 0 : opts.flatnessTolerance) != null ? _a : DEFAULT_FLATNESS_TOL;
+    const rotationTol = (_b = opts == null ? void 0 : opts.rotationTolerance) != null ? _b : DEFAULT_ROTATION_TOL;
+    const maxSamples = (_c = opts == null ? void 0 : opts.maxSamplesPerSegment) != null ? _c : DEFAULT_MAX_SAMPLES;
     const out = [];
     const firstPos = getKfTranslate(kfs[0]);
     if (!firstPos) return anim;
@@ -565,15 +1556,14 @@ var PixodeskAnimator = (() => {
     const lastInE = getKfEasing(kfs[kfs.length - 1]);
     if (lastInE) out[out.length - 1].e = lastInE;
     if (autoOrient) unwrapAutoOrientRotations(out);
-    const result = { kfs: out };
+    const result = { keyframes: out };
     if (anim.loop !== void 0) result.loop = anim.loop;
     return result;
   }
   function unwrapAutoOrientRotations(kfs) {
-    var _a;
     let prev;
     for (const kf of kfs) {
-      const v = (_a = kf.v) != null ? _a : kf.value;
+      const v = kfValue(kf);
       if (!v || typeof v.rotate !== "number") continue;
       if (prev === void 0) {
         prev = v.rotate;
@@ -590,8 +1580,7 @@ var PixodeskAnimator = (() => {
     return { t: time, v: value };
   }
   function getKfValueParts(kf) {
-    var _a;
-    const v = (_a = kf.value) != null ? _a : kf.v;
+    const v = kfValue(kf);
     if (!v || typeof v !== "object" || Array.isArray(v)) return void 0;
     return v;
   }
@@ -652,9 +1641,8 @@ var PixodeskAnimator = (() => {
     return d;
   }
   function insertSharpCornerStepKfIfNeeded(out, prevKf, nextKf, prevPos, nextPos, rotationTol) {
-    var _a;
     const lastKf = out[out.length - 1];
-    const lastV = (_a = lastKf.v) != null ? _a : lastKf.value;
+    const lastV = kfValue(lastKf);
     const prevExit = lastV == null ? void 0 : lastV.rotate;
     if (typeof prevExit !== "number") return;
     const boundaryV = getKfValueParts(prevKf);
@@ -801,7 +1789,7 @@ var PixodeskAnimator = (() => {
     return Math.abs(cross) / Math.sqrt(len2);
   }
 
-  // ../svg-animator-core/src/PxDefinitions.ts
+  // ../svg-animator-core/src/animation/PxDefinitions.ts
   var LOOP_JUMP_SHIFT_MS = 1;
   function deepEqualValue(a, b) {
     if (a === b) return true;
@@ -902,8 +1890,8 @@ var PixodeskAnimator = (() => {
       if (Array.isArray(pathsArray) && pathsArray.length > 0) {
         if (isPathString(pathsArray[0])) {
           const paths = [];
-          for (const pathStr of pathsArray) {
-            const d = extractPathData(pathStr);
+          for (const pathStr2 of pathsArray) {
+            const d = extractPathData(pathStr2);
             if (d) {
               paths.push(...parseSvgPathToBezier(d));
             }
@@ -916,8 +1904,8 @@ var PixodeskAnimator = (() => {
     if (Array.isArray(value)) {
       if (value.length > 0 && isPathString(value[0])) {
         const paths = [];
-        for (const pathStr of value) {
-          const d = extractPathData(pathStr);
+        for (const pathStr2 of value) {
+          const d = extractPathData(pathStr2);
           if (d) {
             paths.push(...parseSvgPathToBezier(d));
           }
@@ -1014,7 +2002,7 @@ var PixodeskAnimator = (() => {
     const totalIntervals = keyframes.length - 1;
     const segCount = clamp((_a = loop.segmentCount) != null ? _a : totalIntervals, 1, totalIntervals);
     let segKfs;
-    if (loop.extend === PxLoopExtend.before) {
+    if (loop.repeatAt === PxLoopRepeatAt.start) {
       segKfs = keyframes.slice(0, segCount + 1);
     } else {
       segKfs = keyframes.slice(totalIntervals - segCount);
@@ -1022,7 +2010,7 @@ var PixodeskAnimator = (() => {
     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.extend === PxLoopExtend.before) {
+    if (loop.repeatAt === PxLoopRepeatAt.start) {
       fillStart = 0;
       fillEnd = firstT;
     } else {
@@ -1035,21 +2023,18 @@ var PixodeskAnimator = (() => {
     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) => {
-      var _a2, _b2;
-      return {
-        relT: (kf.t - segStartT) / segDuration,
-        v: kf.v,
-        e: kf.e,
-        tangentIn: (_a2 = kf.tangentIn) != null ? _a2 : kf.ti,
-        tangentOut: (_b2 = kf.tangentOut) != null ? _b2 : kf.to
-      };
-    });
+    const template = segKfs.map((kf) => ({
+      relT: (kf.t - segStartT) / segDuration,
+      v: kf.v,
+      e: kf.e,
+      tangentIn: kfTangentIn(kf),
+      tangentOut: kfTangentOut(kf)
+    }));
     const fullReps = Math.floor(fillDuration / segDuration);
     const remainder = fillDuration - fullReps * segDuration;
     const partialFraction = remainder / segDuration;
     const looped = [];
-    const separateBoundary = loop.extend !== PxLoopExtend.before;
+    const separateBoundary = loop.repeatAt !== PxLoopRepeatAt.start;
     const originalTerminalKf = keyframes[keyframes.length - 1];
     let terminalEasingOverride;
     let hasTerminalEasingOverride = false;
@@ -1157,30 +2142,30 @@ var PixodeskAnimator = (() => {
         looped.push(pushed);
       }
     }
-    if (loop.extend === PxLoopExtend.before) {
+    if (loop.repeatAt === PxLoopRepeatAt.start) {
       if (partialFraction > 1e-9) {
-        const isReversed = !!loop.alternate && fullReps % 2 === 0;
+        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.alternate && distFromBoundary % 2 === 0;
+        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.alternate && rep % 2 === 0;
+        const isReversed = loop.direction === PxLoopDirection.alternate && rep % 2 === 0;
         const repStart = fillStart + rep * segDuration;
         appendRep(repStart, isReversed);
       }
       if (partialFraction > 1e-9) {
-        const isReversed = !!loop.alternate && fullReps % 2 === 0;
+        const isReversed = loop.direction === PxLoopDirection.alternate && fullReps % 2 === 0;
         const repStart = fillStart + fullReps * segDuration;
         appendRep(repStart, isReversed, partialFraction);
       }
     }
-    if (loop.extend === PxLoopExtend.before) {
+    if (loop.repeatAt === PxLoopRepeatAt.start) {
       return [...looped, ...keyframes];
     } else {
       if (hasTerminalEasingOverride && keyframes.length > 0) {
@@ -1192,34 +2177,34 @@ var PixodeskAnimator = (() => {
     }
   }
   function normalizeKeyframes(propName, propAnim, duration, defs) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const keyframes = propAnim.keyframes || propAnim.kfs || [];
+    var _a;
+    const keyframes = propAnim.keyframes || [];
     const normalized = [];
     for (const kf of keyframes) {
-      const timePct = (_b = (_a = kf.time) != null ? _a : kf.t) != null ? _b : 0;
-      let value = (_c = kf.value) != null ? _c : kf.v;
-      const easing = (_d = kf.easing) != null ? _d : kf.e;
+      const timePct = kfTime(kf);
+      let value = kfValue(kf);
+      const easing = kfEasing(kf);
       if (propName === "d") {
         value = normalizePathValue(value);
       }
       const propNameKebab = isCamelCaseWord(propName) ? camelCaseToKebabWordIfNeeded(propName) : propName;
       if (COLOUR_ATTR_NAMES.has(propNameKebab)) {
-        value = (_e = parseColor(value)) != null ? _e : value;
+        value = (_a = parseColor(value)) != null ? _a : value;
       }
       const normKf = {
         t: timePct,
         v: value,
         e: resolveEasing(easing, defs)
       };
-      const tIn = (_f = kf.tangentIn) != null ? _f : kf.ti;
-      const tOut = (_g = kf.tangentOut) != null ? _g : kf.to;
+      const tIn = kfTangentIn(kf);
+      const tOut = kfTangentOut(kf);
       if (tIn) normKf.tangentIn = tIn;
       if (tOut) normKf.tangentOut = tOut;
       normalized.push(normKf);
     }
     normalized.sort((a, b) => {
-      var _a2, _b2;
-      return ((_a2 = a.t) != null ? _a2 : 0) - ((_b2 = b.t) != null ? _b2 : 0);
+      var _a2, _b;
+      return ((_a2 = a.t) != null ? _a2 : 0) - ((_b = b.t) != null ? _b : 0);
     });
     const loopRaw = propAnim.loop;
     const loop = loopRaw === true ? {} : loopRaw || void 0;
@@ -1241,7 +2226,37 @@ var PixodeskAnimator = (() => {
   function generateElementId() {
     return "_px_el_" + ++_elementIdCounter;
   }
-  function normalizeAnimationDefinition(animDef, duration, defs, engine = PxAnimatorEngine.waapi) {
+  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) => TRANSFORM_FN_NAMES.has(k));
+    if (channels.length !== 1) return animDef;
+    const ch = channels[0];
+    const chAnim = animDef[ch];
+    if (!chAnim || typeof chAnim !== "object" || !Array.isArray(chAnim.keyframes)) return animDef;
+    const lifted = __spreadProps(__spreadValues({}, chAnim), {
+      keyframes: chAnim.keyframes.map((kf) => __spreadProps(__spreadValues({}, kf), { value: __spreadProps(__spreadValues({}, staticParts), { [ch]: kf.value }) }))
+    });
+    if (lifted.value !== void 0) lifted.value = __spreadProps(__spreadValues({}, staticParts), { [ch]: lifted.value });
+    const rest = __spreadValues({}, animDef);
+    delete rest[ch];
+    return __spreadProps(__spreadValues({}, rest), { transform: lifted });
+  }
+  function normalizeAnimationDefinition(animDef, duration, defs, engine = PxTimelineEngine.native) {
     const normalized = {};
     for (const [propName, propAnim] of Object.entries(animDef)) {
       if (propName === "transform" && propAnim.alongPathMode === "offsetPath" && animDef["offsetDistance"] !== void 0) {
@@ -1249,24 +2264,24 @@ var PixodeskAnimator = (() => {
       }
       const normalizedKfs = normalizeKeyframes(propName, propAnim, duration, defs);
       if (normalizedKfs.length > 0) {
-        const out = { kfs: normalizedKfs };
+        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 === PxAnimatorEngine.waapi && propName === "transform" ? materialiseMotionPathInPropAnim(out) : out;
+        normalized[propName] = engine === PxTimelineEngine.native && propName === "transform" ? materialiseMotionPathInPropAnim(out) : out;
       }
     }
     return normalized;
   }
-  function getNormalisedBindings(doc, engine = PxAnimatorEngine.waapi) {
+  function getNormalisedBindings(doc, engine = PxTimelineEngine.native) {
     const animatorConfig = getAnimatorConfig(doc) || {};
     const defs = getDefs(doc);
     const duration = animatorConfig.duration || 1e3;
     const bindings = [];
-    const processAnimation = (id, animate) => {
+    const processAnimation = (id, animate, staticTransform) => {
       if (!animate) return null;
       const animDefs = resolveElementAnimation(animate, defs);
       if (animDefs.length === 0) return null;
-      const merged = mergeAnimationDefinitions(animDefs);
+      const merged = mergeStaticTransformIntoAnimDef(mergeAnimationDefinitions(animDefs), staticTransform);
       const normalizedAnim = normalizeAnimationDefinition(merged, duration, defs, engine);
       if (Object.keys(normalizedAnim).length === 0) return null;
       return {
@@ -1286,7 +2301,7 @@ var PixodeskAnimator = (() => {
       if (inlineAnim && Object.keys(inlineAnim).length > 0) {
         const nodeId = node.id || generateElementId();
         node.id = nodeId;
-        const normalized = processAnimation(nodeId, inlineAnim);
+        const normalized = processAnimation(nodeId, inlineAnim, node.transform);
         if (normalized) bindings.push(normalized);
       }
       if (node.children) {
@@ -1303,7 +2318,7 @@ var PixodeskAnimator = (() => {
     return bindings;
   }
 
-  // src/PxAnimatorTriggers.ts
+  // src/triggers/PxAnimatorTriggers.ts
   function setupAnimationTriggers(api, config) {
     const { startOn, outAction = "continue", scrollIntoViewThreshold = 0 } = config;
     const root = api.getRootElement();
@@ -1408,16 +2423,15 @@ var PixodeskAnimator = (() => {
     return api;
   }
 
-  // src/PxAnimatorFrameLoop.ts
+  // src/engines/PxAnimatorFrameLoop.ts
   function getSelector(id) {
     return "#" + id;
   }
 
-  // src/PxAnimatorWebApi.ts
+  // src/engines/PxAnimatorWebApi.ts
   function createCssKf(kf, t, propName, unsupportedSet) {
-    var _a, _b;
-    let value = (_a = kf.v) != null ? _a : kf.value;
-    const e = (_b = kf.e) != null ? _b : kf.easing;
+    let value = kfValue(kf);
+    const e = kfEasing(kf);
     const cssKf = {
       offset: t,
       easing: e && Array.isArray(e) ? "cubic-bezier(" + e.join(",") + ")" : void 0
@@ -1488,7 +2502,7 @@ var PixodeskAnimator = (() => {
     const result = /* @__PURE__ */ new Map();
     for (const [propName, propAnim] of Object.entries(animDef)) {
       const duration = config.duration || 1;
-      const clippedKeyframes = clipKeyframesToDuration(propName, propAnim.kfs || propAnim.keyframes || [], duration);
+      const clippedKeyframes = clipKeyframesToDuration(propName, propAnim.keyframes || [], duration);
       const cssKeyframes = [];
       for (let i = 0; i < clippedKeyframes.length; i++) {
         const kf = clippedKeyframes[i];
@@ -1522,7 +2536,7 @@ var PixodeskAnimator = (() => {
         console.warn("createFrameLoopAnimator: No root element provided");
       }
     }
-    const bindings = getNormalisedBindings(doc, PxAnimatorEngine.waapi);
+    const bindings = getNormalisedBindings(doc, PxTimelineEngine.native);
     const animations = [];
     const _iterations = config.iterations;
     let iterations;
@@ -1680,7 +2694,7 @@ var PixodeskAnimator = (() => {
     return api;
   }
 
-  // src/PxAnimatorBind.ts
+  // src/engines/PxAnimatorBind.ts
   function finaliseAnimator(animatorConfig, callbacks, make) {
     let apiRef;
     let effectiveCallbacks = callbacks;
@@ -1695,8 +2709,8 @@ var PixodeskAnimator = (() => {
     }
     const res = make(effectiveCallbacks);
     apiRef = res;
-    if (animatorConfig.debugInstName) {
-      window[animatorConfig.debugInstName] = res;
+    if (animatorConfig.debugGlobalName) {
+      window[animatorConfig.debugGlobalName] = res;
     }
     return res;
   }
@@ -1714,7 +2728,7 @@ var PixodeskAnimator = (() => {
     );
   }
 
-  // src/PxAnimatorKeys.ts
+  // src/shared/PxAnimatorKeys.ts
   var PX_ANIMATOR_DATA_KEY = "data";
   return __toCommonJS(index_prerendered_waapi_exports);
 })();