@pixodesk/svg-animator-core 1.0.39 → 1.0.41

package/dist/chunk-L6GJ6Y2M.js

@@ -0,0 +1,4595 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  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;
+};
+
+// 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_MEMBER_ERROR_LIMIT = 4;
+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 _a2;
+    const probe = ctx && { errors: [], warnings: [], strict: ctx.strict };
+    if (this.schemas.some((s) => s.isValid(raw, probe, path ? [...path] : void 0))) return true;
+    if (!ctx) return false;
+    const base = pathStr(path != null ? path : []);
+    ctx.errors.push(base + ": no union member matched for value " + ((_a2 = JSON.stringify(raw)) != null ? _a2 : "").slice(0, 240));
+    let best;
+    let bestDepth = -1;
+    const leafExpectations = [];
+    for (const member of this.schemas) {
+      const sink = { errors: [], warnings: [], strict: ctx.strict };
+      member.isValid(raw, sink, path ? [...path] : void 0);
+      if (!sink.errors.length) continue;
+      const depth = Math.max(...sink.errors.map((e) => e.slice(0, e.indexOf(":")).length));
+      if (depth > bestDepth || depth === bestDepth && best && sink.errors.length < best.length) {
+        bestDepth = depth;
+        best = sink.errors;
+      }
+      if (depth <= base.length) {
+        for (const e of sink.errors) {
+          const m = /: expected (.+?), got /.exec(e);
+          if (m && !leafExpectations.includes(m[1])) leafExpectations.push(m[1]);
+        }
+      }
+    }
+    if (best && bestDepth > base.length) {
+      for (const e of best.slice(0, UNION_MEMBER_ERROR_LIMIT)) {
+        if (!ctx.errors.includes(e)) ctx.errors.push(e);
+      }
+    } else if (leafExpectations.length) {
+      ctx.errors.push(base + ": expected " + leafExpectations.join(" | "));
+    }
+    return false;
+  }
+  _canSanitize(raw) {
+    return this.schemas.some((s) => s._canSanitize(raw));
+  }
+};
+var DiscriminatedUnion = class extends Base {
+  constructor(_key, _schemas, defaultVal) {
+    var _a2;
+    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 = (_a2 = keySchema.inner) != null ? _a2 : 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 _a2;
+    return ((_a2 = this._findSchema(raw)) != null ? _a2 : 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 _a2;
+    return (_a2 = this.resolved) != null ? _a2 : 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;
+}
+function schemaKeys(schema) {
+  return Object.fromEntries(
+    Object.keys(schema["_shape"]).map((k) => [k, k])
+  );
+}
+function describeSchema(schema) {
+  var _a2;
+  const s = schema;
+  switch (s._kind) {
+    case "union":
+      return { kind: "union", members: s.schemas };
+    case "discriminatedUnion":
+      return { kind: "discriminatedUnion", key: s._key, members: s._schemas };
+    case "record":
+      return { kind: "record", value: s.value };
+    case "tuple":
+      return { kind: "tuple", items: s.schemas };
+  }
+  if ("_shape" in s) return { kind: "shape", shape: s._shape, openValue: s._openSchema };
+  if ("item" in s) return { kind: "array", item: s.item };
+  if ("inner" in s) return { kind: "optional", inner: s.inner };
+  if ("fn" in s) return { kind: "lazy", resolved: (_a2 = s.resolved) != null ? _a2 : s.resolved = s.fn() };
+  return { kind: "leaf" };
+}
+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(PxNodeBaseSchema, { 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)
+};
+
+// src/version/PxSchemaVersion.ts
+var PX_WIRE_SCHEMA_VERSION = "1.1";
+
+// src/version/PxWireVersion.ts
+var PX_WIRE_VERSION_KEY = "version";
+var ANIMATOR_KEY = "animator";
+var META_KEY = "meta";
+var PxWireVersionRelation = /* @__PURE__ */ ((PxWireVersionRelation2) => {
+  PxWireVersionRelation2["unstamped"] = "unstamped";
+  PxWireVersionRelation2["same"] = "same";
+  PxWireVersionRelation2["older"] = "older";
+  PxWireVersionRelation2["newer"] = "newer";
+  PxWireVersionRelation2["otherGeneration"] = "otherGeneration";
+  return PxWireVersionRelation2;
+})(PxWireVersionRelation || {});
+var VERSION_RE = /^(\d+)\.(\d+)(?:\.(\d+))?$/;
+function parseWireVersion(raw) {
+  if (typeof raw !== "string") return void 0;
+  const m = VERSION_RE.exec(raw.trim());
+  if (!m) return void 0;
+  return { a: Number(m[1]), b: Number(m[2]), c: m[3] === void 0 ? 0 : Number(m[3]) };
+}
+function formatWireVersion(v) {
+  return v.a + "." + v.b + "." + v.c;
+}
+var _a;
+var PX_WIRE_VERSION = (_a = parseWireVersion(PX_WIRE_SCHEMA_VERSION)) != null ? _a : { a: 1, b: 1, c: 0 };
+function getAnimatorBlock(doc) {
+  if (!doc || typeof doc !== "object") return void 0;
+  const atRoot = readObjectProp(doc, ANIMATOR_KEY);
+  if (atRoot) return atRoot;
+  const meta = readObjectProp(doc, META_KEY);
+  return meta ? readObjectProp(meta, ANIMATOR_KEY) : void 0;
+}
+function readObjectProp(obj, key) {
+  const value = obj[key];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readWireVersion(doc) {
+  const animator = getAnimatorBlock(doc);
+  return animator ? parseWireVersion(animator[PX_WIRE_VERSION_KEY]) : void 0;
+}
+function compareWireVersion(file, mine, readerReadsEditorPart) {
+  if (!file) return "unstamped" /* unstamped */;
+  if (file.a !== mine.a) return "otherGeneration" /* otherGeneration */;
+  if (file.b !== mine.b) return file.b > mine.b ? "newer" /* newer */ : "older" /* older */;
+  if (!readerReadsEditorPart || file.c === mine.c) return "same" /* same */;
+  return file.c > mine.c ? "newer" /* newer */ : "older" /* older */;
+}
+function wireVersionAdvice(relation, file, mine, isPlayer) {
+  if (!file) return void 0;
+  const target = isPlayer ? "player" : "editor";
+  const gap = "written for schema " + formatWireVersion(file) + ", this " + target + " reads " + formatWireVersion(mine);
+  switch (relation) {
+    case "newer" /* newer */:
+      return "This file is " + gap + ". Update the " + target + " to open it fully.";
+    case "older" /* older */:
+      return "This file is " + gap + ". Saving it from this " + target + " rewrites it in the current format.";
+    case "otherGeneration" /* otherGeneration */:
+      return "This file is " + gap + " \u2014 a different format generation, which no conversion bridges. Open it in a " + target + " of that generation, or accept this document without the parts named above.";
+    default:
+      return void 0;
+  }
+}
+var PxWireStepKind = /* @__PURE__ */ ((PxWireStepKind2) => {
+  PxWireStepKind2["additive"] = "additive";
+  PxWireStepKind2["converted"] = "converted";
+  return PxWireStepKind2;
+})(PxWireStepKind || {});
+var PX_WIRE_BASELINE_VERSION = "1.1";
+var PX_WIRE_STEPS = [];
+function applyWireSteps(doc, cfg) {
+  const from = readWireVersion(doc);
+  const relation = compareWireVersion(from, cfg.target, cfg.readerReadsEditorPart);
+  if (!from || relation !== "older" /* older */) {
+    return {
+      doc,
+      from,
+      relation,
+      applied: [],
+      advice: wireVersionAdvice(relation, from, cfg.target, !cfg.readerReadsEditorPart)
+    };
+  }
+  const due = [];
+  for (const step of cfg.steps) {
+    const stepTo = parseWireVersion(step.to);
+    if (!stepTo) continue;
+    if (compareWireVersion(from, stepTo, cfg.readerReadsEditorPart) !== "older" /* older */) continue;
+    if (!step.up) continue;
+    due.push(step);
+  }
+  if (!due.length || !doc || typeof doc !== "object") return { doc, from, relation, applied: [] };
+  const target = clonePlain(doc);
+  const applied = [];
+  for (const step of due) {
+    try {
+      step.up(target);
+      applied.push(step);
+    } catch (e) {
+      break;
+    }
+  }
+  if (!applied.length) return { doc, from, relation, applied: [] };
+  stampVersion(target, cfg.target, cfg.readerReadsEditorPart);
+  return { doc: target, from, relation, applied };
+}
+function convertWireDocument(doc) {
+  return applyWireSteps(doc, {
+    steps: PX_WIRE_STEPS,
+    target: PX_WIRE_VERSION,
+    readerReadsEditorPart: false
+  });
+}
+function clonePlain(value) {
+  const structured = globalThis.structuredClone;
+  return structured ? structured(value) : JSON.parse(JSON.stringify(value));
+}
+function stampVersion(doc, target, readerReadsEditorPart) {
+  const animator = getAnimatorBlock(doc);
+  if (!animator) return;
+  const previous = parseWireVersion(animator[PX_WIRE_VERSION_KEY]);
+  animator[PX_WIRE_VERSION_KEY] = formatWireVersion({
+    a: target.a,
+    b: target.b,
+    c: readerReadsEditorPart ? target.c : previous ? previous.c : 0
+  });
+}
+function applyWireStepsDown(doc, cfg) {
+  const from = readWireVersion(doc);
+  if (!from) {
+    return { ok: false, blocking: [], reason: "The document carries no version, so there is nothing to convert down from." };
+  }
+  const relation = compareWireVersion(from, cfg.target, cfg.readerReadsEditorPart);
+  if (relation === "otherGeneration" /* otherGeneration */) {
+    return {
+      ok: false,
+      blocking: [],
+      reason: "Schema " + formatWireVersion(from) + " and " + formatWireVersion(cfg.target) + " are different generations; no conversion bridges them."
+    };
+  }
+  if (relation !== "newer" /* newer */) return { ok: true, doc, applied: [] };
+  const toUndo = [];
+  for (const step of cfg.steps) {
+    const stepTo = parseWireVersion(step.to);
+    if (!stepTo) continue;
+    if (compareWireVersion(stepTo, cfg.target, cfg.readerReadsEditorPart) !== "newer" /* newer */) continue;
+    if (compareWireVersion(stepTo, from, cfg.readerReadsEditorPart) === "newer" /* newer */) continue;
+    toUndo.push(step);
+  }
+  toUndo.reverse();
+  const blocking = toUndo.filter((s) => s.kind === "converted" /* converted */ && !s.down);
+  if (blocking.length) {
+    return {
+      ok: false,
+      blocking,
+      reason: "Cannot convert down to " + formatWireVersion(cfg.target) + ": " + blocking.map((s) => s.from + " \u2192 " + s.to + " (" + s.reason + ")").join("; ") + " cannot be undone."
+    };
+  }
+  const target = clonePlain(doc);
+  const applied = [];
+  for (const step of toUndo) {
+    if (!step.down) continue;
+    try {
+      step.down(target);
+      applied.push(step);
+    } catch (e) {
+      return {
+        ok: false,
+        blocking: [step],
+        reason: "Undoing " + step.from + " \u2192 " + step.to + " failed: " + String(e)
+      };
+    }
+  }
+  stampVersion(target, cfg.target, cfg.readerReadsEditorPart);
+  return { ok: true, doc: target, applied };
+}
+function downgradeWireDocument(doc, target) {
+  return applyWireStepsDown(doc, { steps: PX_WIRE_STEPS, target, readerReadsEditorPart: false });
+}
+
+// src/format/PxAnimatorConstants.ts
+var PxFillMode = {
+  forwards: "forwards",
+  backwards: "backwards",
+  both: "both",
+  none: "none"
+};
+var PxPlaybackDirection = {
+  normal: "normal",
+  reverse: "reverse",
+  alternate: "alternate",
+  alternateReverse: "alternate-reverse"
+};
+var PX_ANIM_SRC_ATTR_NAME = "data-px-animation-src";
+var PX_ANIM_ATTR_NAME = "_px_animator";
+var PxStartOn = {
+  load: "load",
+  mouseOver: "mouseOver",
+  click: "click",
+  scrollIntoView: "scrollIntoView",
+  programmatic: "programmatic"
+};
+var PxOutAction = {
+  continue: "continue",
+  pause: "pause",
+  reset: "reset",
+  reverse: "reverse"
+};
+var PxFinishAction = {
+  hold: "hold",
+  reset: "reset"
+};
+var PxScrollKind = {
+  view: "view",
+  scroll: "scroll"
+};
+var PxScrollAxis = {
+  block: "block",
+  inline: "inline",
+  x: "x",
+  y: "y"
+};
+var PxScrollSource = {
+  nearest: "nearest",
+  root: "root"
+};
+var PxPinAlign = {
+  top: "top",
+  center: "center",
+  bottom: "bottom"
+};
+var PxScrollPhase = {
+  cover: "cover",
+  contain: "contain",
+  entry: "entry",
+  exit: "exit",
+  entryCrossing: "entry-crossing",
+  exitCrossing: "exit-crossing"
+};
+var PxAlongPathMode = {
+  sampled: "sampled",
+  offsetPath: "offsetPath"
+};
+var PX_TIMELINE_SHARED_KEYS = ["duration", "iterations", "engine", "frameRate"];
+var PX_TIME_ONLY_TIMELINE_KEYS = ["trigger", "delay", "fillMode", "direction"];
+var PX_FLAT_RUNTIME_VIEW_KEYS = [
+  ...PX_TIMELINE_SHARED_KEYS,
+  ...PX_TIME_ONLY_TIMELINE_KEYS,
+  "fill",
+  "resetOnFinish",
+  "timelineSource",
+  "scroll"
+];
+var PxTimelineEngine = {
+  native: "native",
+  js: "js"
+};
+var PxTimelineEngineSetting = __spreadProps(__spreadValues({}, PxTimelineEngine), {
+  auto: "auto"
+});
+function resolveTimelineEngine(engine) {
+  return engine === PxTimelineEngineSetting.js ? PxTimelineEngine.js : PxTimelineEngine.native;
+}
+function isNativeForced(engine) {
+  return engine === PxTimelineEngineSetting.native;
+}
+function mayUseNativeScrollTimeline(engine) {
+  return engine !== PxTimelineEngineSetting.js;
+}
+var PX_TRIGGER_DEFAULTS = {
+  startOn: "load",
+  outAction: "continue",
+  scrollIntoViewThreshold: 0
+};
+var PxControlMode = {
+  /** No control props — the document's trigger decides, and nothing is taken over. */
+  static: "static",
+  /** `progress` / `time` — the host scrubs; the component seeks and stays paused. */
+  fixedTime: "fixedTime",
+  /** `play` / `pause` — the host drives playback with booleans. */
+  play: "play",
+  /** `autoplay` — the document's own trigger starts it. */
+  autoplay: "autoplay"
+};
+function resolveControlMode(props) {
+  const hasFixedTime = props.progress !== void 0 || props.time !== void 0;
+  const hasPlayPause = props.play !== void 0 || props.pause !== void 0;
+  const hasAutoplay = !!props.autoplay;
+  const warnings = [];
+  const named = (a, b, winner) => a + " and " + b + " were both set \u2014 " + winner + " wins, " + (winner === a ? b : a) + " is ignored.";
+  if (hasFixedTime) {
+    if (hasPlayPause) warnings.push(named("progress/time", "play/pause", "progress/time"));
+    if (hasAutoplay) warnings.push(named("progress/time", "autoplay", "progress/time"));
+    return { mode: PxControlMode.fixedTime, warnings };
+  }
+  if (hasPlayPause) {
+    if (hasAutoplay) warnings.push(named("play/pause", "autoplay", "play/pause"));
+    return { mode: PxControlMode.play, warnings };
+  }
+  if (hasAutoplay) return { mode: PxControlMode.autoplay, warnings };
+  return { mode: PxControlMode.static, warnings };
+}
+function controlModeTakesOverTrigger(mode) {
+  return mode !== PxControlMode.autoplay;
+}
+function resolveTrigger(trigger) {
+  var _a2, _b, _c;
+  return {
+    startOn: (_a2 = trigger == null ? void 0 : trigger.startOn) != null ? _a2 : PX_TRIGGER_DEFAULTS.startOn,
+    outAction: (_b = trigger == null ? void 0 : trigger.outAction) != null ? _b : PX_TRIGGER_DEFAULTS.outAction,
+    scrollIntoViewThreshold: (_c = trigger == null ? void 0 : trigger.scrollIntoViewThreshold) != null ? _c : PX_TRIGGER_DEFAULTS.scrollIntoViewThreshold
+  };
+}
+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",
+  exact: "exact"
+};
+var PxStrokeTrimSubPaths = {
+  separate: "separate",
+  combined: "combined"
+};
+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",
+  scale: "scale",
+  origin: "origin"
+};
+var PX_TRANSFORM_PART_KEYS = [
+  TRANSFORM_PART.translate,
+  TRANSFORM_PART.rotate,
+  TRANSFORM_PART.scale,
+  TRANSFORM_PART.origin
+];
+var PxGradientSpreadMethod = {
+  pad: "pad",
+  reflect: "reflect",
+  repeat: "repeat"
+};
+var PxGradientType = {
+  linear: "linear",
+  radial: "radial"
+};
+function isPxDocument(doc) {
+  if (!(doc && typeof doc === "object" && !Array.isArray(doc))) {
+    return false;
+  }
+  return doc.type === "svg";
+}
+function getAnimatorConfig(doc) {
+  var _a2;
+  const cfg = (doc == null ? void 0 : doc.animator) || ((_a2 = doc == null ? void 0 : doc.meta) == null ? void 0 : _a2.animator);
+  if (!cfg) return void 0;
+  const memoised = wireViewMemo.get(cfg);
+  if (memoised) return memoised;
+  const wire = cfg;
+  const stray = PX_FLAT_RUNTIME_VIEW_KEYS.filter((k) => wire[k] !== void 0);
+  const source = stray.length ? __spreadValues({}, wire) : cfg;
+  for (const k of stray) delete source[k];
+  const view = flattenAnimatorTimeline(source);
+  wireViewMemo.set(cfg, view);
+  return view;
+}
+var wireViewMemo = /* @__PURE__ */ new WeakMap();
+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 _a2 = cfg, { timeline: _dropped } = _a2, flat = __objRest(_a2, ["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.offset !== void 0) scroll.pinOffset = pin.offset;
+      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 scrollKindOrDefault(kind) {
+  return kind === "scroll" ? "scroll" : "view";
+}
+function nestAnimatorTimeline(cfg) {
+  if (!cfg || cfg.timeline !== void 0) return cfg;
+  const _a2 = cfg, {
+    timelineSource,
+    scroll,
+    trigger,
+    delay,
+    iterations,
+    direction,
+    fill,
+    resetOnFinish,
+    duration,
+    engine,
+    frameRate
+  } = _a2, shared = __objRest(_a2, [
+    "timelineSource",
+    "scroll",
+    "trigger",
+    "delay",
+    "iterations",
+    "direction",
+    "fill",
+    "resetOnFinish",
+    "duration",
+    "engine",
+    "frameRate"
+  ]);
+  if (timelineSource === "scroll") {
+    const timeline2 = { type: scrollKindOrDefault(scroll == null ? void 0 : scroll.kind) };
+    if (engine !== void 0) timeline2.engine = engine;
+    if (frameRate !== void 0) timeline2.frameRate = frameRate;
+    if (duration !== void 0) timeline2.duration = duration;
+    if (typeof iterations === "number") timeline2.iterations = iterations;
+    if (scroll) {
+      if (scroll.axis !== void 0) timeline2.axis = scroll.axis;
+      if (scroll.source !== void 0) timeline2.source = scroll.source;
+      if (scroll.subject !== void 0) timeline2.subject = scroll.subject;
+      if (scroll.smoothing !== void 0) timeline2.smoothing = scroll.smoothing;
+      if (scroll.range !== void 0) timeline2.range = scroll.range;
+      const hasPinParams = scroll.pinAlign !== void 0 || scroll.pinOffset !== void 0 || scroll.pinDistance !== void 0;
+      if (hasPinParams) {
+        timeline2.pin = __spreadValues(__spreadValues(__spreadValues({}, scroll.pinAlign !== void 0 ? { align: scroll.pinAlign } : {}), scroll.pinOffset !== void 0 ? { offset: scroll.pinOffset } : {}), scroll.pinDistance !== void 0 ? { distance: scroll.pinDistance } : {});
+      } else if (scroll.pin !== void 0) {
+        timeline2.pin = scroll.pin;
+      }
+    }
+    return __spreadProps(__spreadValues({}, shared), { timeline: timeline2 });
+  }
+  const timeline = {};
+  if (engine !== void 0) timeline.engine = engine;
+  if (frameRate !== void 0) timeline.frameRate = frameRate;
+  if (duration !== void 0) timeline.duration = duration;
+  if (trigger !== void 0 || resetOnFinish) {
+    const t = __spreadValues({}, trigger || {});
+    if (resetOnFinish) t.finishAction = "reset";
+    timeline.trigger = t;
+  }
+  if (delay !== void 0) timeline.delay = delay;
+  if (iterations !== void 0) timeline.iterations = iterations;
+  if (direction !== void 0) timeline.direction = direction;
+  if (fill !== void 0) timeline.fillMode = fill;
+  return Object.keys(timeline).length > 0 ? __spreadProps(__spreadValues({}, shared), { timeline }) : shared;
+}
+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;
+}
+function getChildren(doc) {
+  return doc == null ? void 0 : doc.children;
+}
+
+// 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 shape (`{pathData}`) comes 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 `{pathData}` 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({ pathData: px.string() }),
+  // 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 keyframeTime = (kf) => {
+  var _a2, _b;
+  return (_b = (_a2 = anyKf(kf).time) != null ? _a2 : anyKf(kf).t) != null ? _b : 0;
+};
+var keyframeValue = (kf) => {
+  var _a2;
+  return (_a2 = anyKf(kf).value) != null ? _a2 : anyKf(kf).v;
+};
+var keyframeEasing = (kf) => {
+  var _a2;
+  return (_a2 = anyKf(kf).easing) != null ? _a2 : anyKf(kf).e;
+};
+var keyframeTangentIn = (kf) => anyKf(kf).tangentIn;
+var keyframeTangentOut = (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([PxAlongPathMode.sampled, PxAlongPathMode.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([PxStartOn.load, PxStartOn.mouseOver, PxStartOn.click, PxStartOn.scrollIntoView, PxStartOn.programmatic], PX_TRIGGER_DEFAULTS.startOn).optional(),
+  outAction: px.enum([PxOutAction.continue, PxOutAction.pause, PxOutAction.reset, PxOutAction.reverse], PX_TRIGGER_DEFAULTS.outAction).optional(),
+  // What happens after a NATURAL finish — `'hold'` (default: keep the end state per
+  // `fill`) or `'reset'` (snap back to the start state). Pairs with `outAction` ("what
+  // happens when the trigger condition ends"); both end-of-life knobs now read alike.
+  finishAction: px.enum([PxFinishAction.hold, PxFinishAction.reset]).optional(),
+  scrollIntoViewThreshold: px.number().optional()
+}));
+var PxGlyphSchema = implementsInterface()(px.object({
+  width: px.number(),
+  pathData: px.string()
+}));
+var PxGlyphFontSchema = implementsInterface()(px.object({
+  fontFamily: px.string(),
+  fontStyle: px.string(),
+  ascent: px.number(),
+  unitsPerEm: px.number(),
+  glyphs: px.record(PxGlyphSchema)
+}));
+var PxDefinitionsSchema = implementsInterface()(px.object({
+  easings: px.record(px.tuple([px.number(), px.number(), px.number(), px.number()])).optional(),
+  animations: px.record(PxAnimationDefinitionSchema).optional(),
+  fonts: px.record(PxGlyphFontSchema).optional()
+}));
+var PxScrollRangePointSchema = implementsInterface()(px.object({
+  phase: px.enum([
+    PxScrollPhase.cover,
+    PxScrollPhase.contain,
+    PxScrollPhase.entry,
+    PxScrollPhase.exit,
+    PxScrollPhase.entryCrossing,
+    PxScrollPhase.exitCrossing
+  ]).optional(),
+  fraction: px.number().optional()
+}));
+var PxScrollRangeSchema = px.object({
+  start: PxScrollRangePointSchema.optional(),
+  end: PxScrollRangePointSchema.optional()
+});
+var PxScrollSchema = implementsInterface()(px.object({
+  kind: px.enum([PxScrollKind.view, PxScrollKind.scroll]).optional(),
+  axis: px.enum([PxScrollAxis.block, PxScrollAxis.inline, PxScrollAxis.x, PxScrollAxis.y]).optional(),
+  source: px.enum([PxScrollSource.nearest, PxScrollSource.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([PxPinAlign.top, PxPinAlign.center, PxPinAlign.bottom]).optional(),
+  pinOffset: px.number().optional(),
+  pinDistance: px.number().optional(),
+  range: PxScrollRangeSchema.optional()
+}));
+var PxTimelinePinSchema = implementsInterface()(px.object({
+  align: px.enum([PxPinAlign.top, PxPinAlign.center, PxPinAlign.bottom]).optional(),
+  offset: px.number().optional(),
+  distance: px.number().optional()
+}));
+var PxTimelineEngineSchema = px.enum([PxTimelineEngineSetting.auto, PxTimelineEngineSetting.native, PxTimelineEngineSetting.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([PxFillMode.forwards, PxFillMode.backwards, PxFillMode.both, PxFillMode.none]).optional(),
+  direction: px.enum([PxPlaybackDirection.normal, PxPlaybackDirection.reverse, PxPlaybackDirection.alternate, PxPlaybackDirection.alternateReverse]).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([PxScrollAxis.block, PxScrollAxis.inline, PxScrollAxis.x, PxScrollAxis.y]).optional(),
+  source: px.enum([PxScrollSource.nearest, PxScrollSource.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 PxBindingSchema = implementsInterface()(px.object({
+  target: px.string(),
+  animateWith: px.array(px.string())
+}));
+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: PxDefinitionsSchema.optional(),
+  bindings: px.array(PxBindingSchema).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 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({
+  pathData: 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 `PxNodeBaseSchema.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([PxUnits.userSpaceOnUse, PxUnits.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()
+}));
+function validateNodeEffects(root, options) {
+  const warnings = [];
+  const walk = (node, path) => {
+    if (node && node.effects) {
+      const ctx = { errors: [], warnings: [], strict: !!(options == null ? void 0 : options.strict) };
+      const ok = PxEffectsSchema.isValid(node.effects, ctx, [path + ".effects"]);
+      if (!ok) {
+        for (const err of ctx.errors) warnings.push(err);
+      }
+    }
+    if (node && Array.isArray(node.children)) {
+      node.children.forEach((c, i) => walk(c, path + ".children[" + i + "]"));
+    }
+  };
+  walk(root, "root");
+  return warnings;
+}
+function validateGlyphFontRefs(root, fonts) {
+  if (!fonts || !Object.keys(fonts).length) return [];
+  const problems = [];
+  const walk = (node, path, inherited, inGlyphText) => {
+    var _a2, _b;
+    if (!node) return;
+    const own = typeof node.fontFamily === "string" ? node.fontFamily : void 0;
+    const family = own != null ? own : inherited;
+    const isGlyphText = inGlyphText || node.type === "text" && !!((_b = (_a2 = node.effects) == null ? void 0 : _a2.text) == null ? void 0 : _b.useGlyphs);
+    if (isGlyphText && own && !Object.prototype.hasOwnProperty.call(fonts, own)) {
+      const problem = path + ': glyph-mode text uses font-family "' + own + '", which has no entry in animator.definitions.fonts';
+      if (!problems.includes(problem)) problems.push(problem);
+    }
+    if (Array.isArray(node.children)) {
+      node.children.forEach((c, i) => walk(c, path + ".children[" + i + "]", family, isGlyphText));
+    }
+  };
+  walk(root, "root", void 0, false);
+  return problems;
+}
+function validateEasingRefs(root, easings) {
+  const problems = [];
+  const walk = (node, path) => {
+    if (Array.isArray(node)) {
+      node.forEach((item, i) => walk(item, path + "[" + i + "]"));
+      return;
+    }
+    if (!node || typeof node !== "object") return;
+    const easing = node.easing;
+    if (typeof easing === "string" && !(easings && Object.prototype.hasOwnProperty.call(easings, easing))) {
+      const problem = path + '.easing: "' + easing + '" names no entry in animator.definitions.easings \u2014 it will play linear';
+      if (!problems.includes(problem)) problems.push(problem);
+    }
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "easing") continue;
+      if (value && typeof value === "object") walk(value, path + "." + key);
+    }
+  };
+  walk(root, "root");
+  return problems;
+}
+function validateVersionStamp(doc) {
+  var _a2;
+  const version = (_a2 = getAnimatorConfig(doc)) == null ? void 0 : _a2.version;
+  if (version === void 0) return [];
+  if (parseWireVersion(version) !== void 0) return [];
+  return ["root.animator.version: " + JSON.stringify(version) + ' is not a version stamp ("a.b" or "a.b.c") \u2014 it reads as unstamped'];
+}
+function validateDocument(doc, options) {
+  var _a2;
+  const strict = (options == null ? void 0 : options.strict) !== false;
+  const ctx = { errors: [], warnings: [], strict };
+  const problems = PxAnimatedSvgDocumentSchema.isValid(doc, ctx, ["root"]) ? [] : [...ctx.errors];
+  if (doc && typeof doc === "object") {
+    for (const w of validateNodeEffects(doc, { strict })) {
+      if (!problems.includes(w)) problems.push(w);
+    }
+    const defs = (_a2 = getAnimatorConfig(doc)) == null ? void 0 : _a2.definitions;
+    for (const w of validateGlyphFontRefs(doc, defs == null ? void 0 : defs.fonts)) {
+      if (!problems.includes(w)) problems.push(w);
+    }
+    for (const w of validateEasingRefs(doc, defs == null ? void 0 : defs.easings)) {
+      if (!problems.includes(w)) problems.push(w);
+    }
+    for (const w of validateVersionStamp(doc)) {
+      if (!problems.includes(w)) problems.push(w);
+    }
+  }
+  return problems;
+}
+var PxNodeBaseSchema = 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 (dev-docs/plans/minification-boundary.md §1.1).
+  domType: px.string().optional(),
+  // Text content of a `<text>` / `<tspan>`. Declared, so a non-string value is a schema error
+  // and the minifier reserves the key; `text` is NOT an alias for it and is not read anywhere.
+  textContent: 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 `materializeNodeEffects` before any other normalization
+  // (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
+  // `node.animate` values and what `processNode` resolves at runtime.
+  animate: PxElementAnimationSchema.optional(),
+  style: px.record(px.union([px.string(), px.number()])).optional()
+}, PxAttrValueSchema);
+var PxNodeSchema = px.openObject(__spreadProps(__spreadValues({}, PxNodeBaseSchema._shape), {
+  children: px.lazy(() => px.array(PxNodeSchema), []).optional()
+}), PxAttrValueSchema);
+var PxSvgNodeRootSchema = 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({}, PxNodeBaseSchema._shape), PxSvgNodeRootSchema._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()
+}));
+function isValidPxDocument(doc) {
+  const errors = validateDocument(doc, { strict: false });
+  return { valid: errors.length === 0, errors };
+}
+
+// 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 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/util/PxAnimatorUtil.ts
+function bezierToSvgPath(path, forceCurves = false) {
+  var _a2, _b, _c, _d;
+  const v = path.v;
+  const i = path.i;
+  const o = path.o;
+  const c = path.c;
+  if (!v.length) return "";
+  const d = [];
+  const len = v.length;
+  d.push("M" + v[0][0] + "," + v[0][1]);
+  for (let idx = 1; idx < len; idx++) {
+    const prevV = v[idx - 1];
+    const prevO = (_a2 = o == null ? void 0 : o[idx - 1]) != null ? _a2 : prevV;
+    const currI = (_b = i == null ? void 0 : i[idx]) != null ? _b : v[idx];
+    const currV = v[idx];
+    const isLine = !forceCurves && (prevO[0] === prevV[0] && prevO[1] === prevV[1]) && (currI[0] === currV[0] && currI[1] === currV[1]);
+    if (isLine) {
+      d.push("L" + currV[0] + "," + currV[1]);
+    } else {
+      d.push("C" + prevO[0] + "," + prevO[1] + "," + currI[0] + "," + currI[1] + "," + currV[0] + "," + currV[1]);
+    }
+  }
+  if (c && len > 0) {
+    const lastV = v[len - 1];
+    const lastO = (_c = o == null ? void 0 : o[len - 1]) != null ? _c : lastV;
+    const firstI = (_d = i == null ? void 0 : i[0]) != null ? _d : v[0];
+    const firstV = v[0];
+    const isLine = !forceCurves && (lastO[0] === lastV[0] && lastO[1] === lastV[1]) && (firstI[0] === firstV[0] && firstI[1] === firstV[1]);
+    if (!isLine) {
+      d.push("C" + lastO[0] + "," + lastO[1] + "," + firstI[0] + "," + firstI[1] + "," + firstV[0] + "," + firstV[1]);
+    }
+    d.push("z");
+  }
+  return d.join("");
+}
+function interpolateNum(a, b, t) {
+  return a + (b - a) * t;
+}
+function interpolateVec(a, b, t) {
+  const res = [];
+  const count = Math.max(a.length, b.length);
+  for (let i = 0; i < count; i++) {
+    res[i] = interpolateNum(a[i] || 0, b[i] || 0, t);
+  }
+  return res;
+}
+function interpolateColor(a, b, t) {
+  return [
+    interpolateNum(a[0] || 0, b[0] || 0, t),
+    interpolateNum(a[1] || 0, b[1] || 0, t),
+    interpolateNum(a[2] || 0, b[2] || 0, t),
+    interpolateNum(a[3] === void 0 ? 1 : a[3], b[3] === void 0 ? 1 : b[3], t)
+  ];
+}
+function interpolateBeziers(paths1, paths2, progress) {
+  const count = Math.max(paths1.length, paths2.length);
+  const res = [];
+  for (let i = 0; i < count; i++) {
+    res.push(interpolateBezier(paths1[i], paths2[i], progress));
+  }
+  return res;
+}
+function interpolateBezier(path1, path2, progress) {
+  var _a2, _b, _c, _d, _e, _f, _g, _h, _i;
+  if (!path1 || !path2) return path1 || path2 || { v: [] };
+  const t = Math.min(Math.max(progress, 0), 1);
+  const len = Math.min(path1.v.length, path2.v.length);
+  const v = [];
+  const i = [];
+  const o = [];
+  for (let idx = 0; idx < len; idx++) {
+    const v1 = path1.v[idx];
+    const v2 = path2.v[idx];
+    v.push(interpolateVec(v1, v2, t));
+    const i1 = (_b = (_a2 = path1.i) == null ? void 0 : _a2[idx]) != null ? _b : v1;
+    const i2 = (_d = (_c = path2.i) == null ? void 0 : _c[idx]) != null ? _d : v2;
+    i.push(interpolateVec(i1, i2, t));
+    const o1 = (_f = (_e = path1.o) == null ? void 0 : _e[idx]) != null ? _f : v1;
+    const o2 = (_h = (_g = path2.o) == null ? void 0 : _g[idx]) != null ? _h : v2;
+    o.push(interpolateVec(o1, o2, t));
+  }
+  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;
+  const cx = 3 * p1x;
+  const bx = 3 * (p2x - p1x) - cx;
+  const ax = 1 - cx - bx;
+  function sampleX(t) {
+    return ((ax * t + bx) * t + cx) * t;
+  }
+  function sampleDX(t) {
+    return (3 * ax * t + 2 * bx) * t + cx;
+  }
+  let t2 = x;
+  let t0 = 0;
+  let t1 = 1;
+  for (let i = 0; i < 8; i++) {
+    const x2 = sampleX(t2) - x;
+    if (Math.abs(x2) < 1e-6) return t2;
+    const d2 = sampleDX(t2);
+    if (Math.abs(d2) < 1e-6) break;
+    t2 -= x2 / d2;
+  }
+  t2 = x;
+  while (t0 < t1) {
+    const x2 = sampleX(t2);
+    if (Math.abs(x2 - x) < 1e-6) return t2;
+    if (x > x2) t0 = t2;
+    else t1 = t2;
+    t2 = (t1 + t0) / 2;
+  }
+  return t2;
+}
+function cubicBezier(easing) {
+  const [p1x, p1y, p2x, p2y] = easing;
+  const cy = 3 * p1y;
+  const by = 3 * (p2y - p1y) - cy;
+  const ay = 1 - cy - by;
+  function sampleCurveY(t) {
+    return ((ay * t + by) * t + cy) * t;
+  }
+  return function(x) {
+    return sampleCurveY(solveCubicBezierX(p1x, p2x, x));
+  };
+}
+function lerp2(a, b, t) {
+  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+}
+function subdivideCubicBezier(p0, p1, p2, p3, t) {
+  const q0 = lerp2(p0, p1, t);
+  const q1 = lerp2(p1, p2, t);
+  const q2 = lerp2(p2, p3, t);
+  const r0 = lerp2(q0, q1, t);
+  const r1 = lerp2(q1, q2, t);
+  const s = lerp2(r0, r1, t);
+  return {
+    left: [p0, q0, r0, s],
+    right: [s, r1, q2, p3]
+  };
+}
+function splitEasing(easing, xFraction) {
+  if (!easing) return { left: void 0, right: void 0 };
+  if (xFraction <= 0) return { left: void 0, right: easing };
+  if (xFraction >= 1) return { left: easing, right: void 0 };
+  const [x1, y1, x2, y2] = easing;
+  const t = solveCubicBezierX(x1, x2, xFraction);
+  const p0 = [0, 0];
+  const p1 = [x1, y1];
+  const p2 = [x2, y2];
+  const p3 = [1, 1];
+  const { left, right } = subdivideCubicBezier(p0, p1, p2, p3, t);
+  const sx = left[3][0];
+  const sy = left[3][1];
+  let leftEasing;
+  if (sx > 1e-9 && Math.abs(sy) > 1e-9) {
+    leftEasing = [
+      left[1][0] / sx,
+      left[1][1] / sy,
+      left[2][0] / sx,
+      left[2][1] / sy
+    ];
+  }
+  let rightEasing;
+  const rx = 1 - sx;
+  const ry = 1 - sy;
+  if (rx > 1e-9 && Math.abs(ry) > 1e-9) {
+    rightEasing = [
+      (right[1][0] - sx) / rx,
+      (right[1][1] - sy) / ry,
+      (right[2][0] - sx) / rx,
+      (right[2][1] - sy) / ry
+    ];
+  }
+  return { left: leftEasing, right: rightEasing };
+}
+function reverseEasing(easing) {
+  if (!easing) return void 0;
+  return [1 - easing[2], 1 - easing[3], 1 - easing[0], 1 - easing[1]];
+}
+function toRGBA(color) {
+  const r = Math.round(color[0] * 255);
+  const g = Math.round(color[1] * 255);
+  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"]);
+function composeTransformParts(parts, opts) {
+  var _a2;
+  if (!parts) return "";
+  const withUnits = (_a2 = opts == null ? void 0 : opts.withUnits) != null ? _a2 : true;
+  const segs = [];
+  const t = parts.translate;
+  const o = parts.origin;
+  const r = parts.rotate;
+  const k = parts.skew;
+  const s = parts.scale;
+  const tu = withUnits ? "px" : "";
+  const ru = withUnits ? "deg" : "";
+  if (t) segs.push("translate(" + t[0] + tu + "," + t[1] + tu + ")");
+  if (o) segs.push("translate(" + o[0] + tu + "," + o[1] + tu + ")");
+  if (r !== void 0 && r !== null) segs.push("rotate(" + r + ru + ")");
+  if (k !== void 0 && k !== null) segs.push("skewX(" + k + ru + ")");
+  if (s) segs.push("scale(" + s[0] + "," + s[1] + ")");
+  if (o) segs.push("translate(" + -o[0] + tu + "," + -o[1] + tu + ")");
+  return segs.join("");
+}
+function parseTransformParts(str2) {
+  var _a2, _b;
+  if (!str2 || typeof str2 !== "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(str2)) !== 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], (_a2 = nums[1]) != null ? _a2 : 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 (str2.replace(/([a-zA-Z]+)\s*\(([^)]*)\)/g, "").replace(/[\s,]/g, "").length) return void 0;
+  return Object.keys(out).length ? out : void 0;
+}
+var PX_STYLE_ATTR_NAMES = /* @__PURE__ */ new Set(["offset-distance", "offsetDistance"]);
+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",
+  "preserveAspectRatio",
+  // Gradient
+  "gradientUnits",
+  "gradientTransform",
+  "spreadMethod",
+  // Pattern
+  "patternUnits",
+  "patternContentUnits",
+  "patternTransform",
+  // Clipping/masking
+  "clipPathUnits",
+  "maskUnits",
+  "maskContentUnits",
+  // Marker  (SVG spec keeps these camelCase, like viewBox)
+  "markerUnits",
+  "markerWidth",
+  "markerHeight",
+  "refX",
+  "refY",
+  // Text
+  "textLength",
+  "lengthAdjust",
+  "startOffset",
+  // Filter
+  "filterUnits",
+  "primitiveUnits",
+  "tableValues",
+  // feFuncR/G/B/A transfer table (type="table")
+  "stdDeviation",
+  "baseFrequency",
+  "numOctaves",
+  "surfaceScale",
+  "diffuseConstant",
+  "specularConstant",
+  "specularExponent",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "edgeMode",
+  "preserveAlpha",
+  "targetX",
+  "targetY"
+  // // Animation
+  // 'attributeName',
+  // 'attributeType',
+  // 'calcMode',
+  // 'keyTimes',
+  // 'keySplines',
+  // 'repeatCount',
+  // 'repeatDur'    
+]);
+function camelCaseToKebabWordIfNeeded(camel) {
+  return SVG_CAMEL_CASE_ATTRS.has(camel) ? camel : camel.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(value, max));
+}
+function bezier2D_pointAt(P0, P1, P2, P3, t) {
+  if (t <= 0) return [P0[0], P0[1]];
+  if (t >= 1) return [P3[0], P3[1]];
+  const u = 1 - t;
+  const u2 = u * u;
+  const u3 = u2 * u;
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const w0 = u3;
+  const w1 = 3 * t * u2;
+  const w2 = 3 * t2 * u;
+  const w3 = t3;
+  return [
+    w0 * P0[0] + w1 * P1[0] + w2 * P2[0] + w3 * P3[0],
+    w0 * P0[1] + w1 * P1[1] + w2 * P2[1] + w3 * P3[1]
+  ];
+}
+var BEZIER_T_NUDGE = 1e-4;
+function bezier2D_derivativeAt(P0, P1, P2, P3, t) {
+  const result = _bezier2D_derivativeAtRaw(P0, P1, P2, P3, t);
+  if (result[0] === 0 && result[1] === 0) {
+    const nudgedT = t < 0.5 ? t + BEZIER_T_NUDGE : t - BEZIER_T_NUDGE;
+    return _bezier2D_derivativeAtRaw(P0, P1, P2, P3, nudgedT);
+  }
+  return result;
+}
+function _bezier2D_derivativeAtRaw(P0, P1, P2, P3, t) {
+  const u = 1 - t;
+  const a = 3 * u * u;
+  const b = 6 * t * u;
+  const c = 3 * t * t;
+  return [
+    a * (P1[0] - P0[0]) + b * (P2[0] - P1[0]) + c * (P3[0] - P2[0]),
+    a * (P1[1] - P0[1]) + b * (P2[1] - P1[1]) + c * (P3[1] - P2[1])
+  ];
+}
+function bezier2D_arcLengthLUT(P0, P1, P2, P3, steps = 100) {
+  const n = steps + 1;
+  const ts = new Float64Array(n);
+  const ds = new Float64Array(n);
+  let prev = bezier2D_pointAt(P0, P1, P2, P3, 0);
+  ts[0] = 0;
+  ds[0] = 0;
+  let cum = 0;
+  for (let i = 1; i < n; i++) {
+    const t = i / steps;
+    const cur = bezier2D_pointAt(P0, P1, P2, P3, t);
+    const dx = cur[0] - prev[0];
+    const dy = cur[1] - prev[1];
+    cum += Math.sqrt(dx * dx + dy * dy);
+    ts[i] = t;
+    ds[i] = cum;
+    prev = cur;
+  }
+  return { ts, ds };
+}
+function bezier2D_tForDistance(lut, distance) {
+  const { ts, ds } = lut;
+  const last = ds.length - 1;
+  if (distance <= 0) return ts[0];
+  if (distance >= ds[last]) return ts[last];
+  let lo = 1;
+  let hi = last;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (ds[mid] < distance) lo = mid + 1;
+    else hi = mid;
+  }
+  const dPrev = ds[hi - 1];
+  const dCur = ds[hi];
+  const span = dCur - dPrev;
+  const frac = span > 0 ? (distance - dPrev) / span : 0;
+  return ts[hi - 1] + frac * (ts[hi] - ts[hi - 1]);
+}
+function bezier2D_arcAtT(lut, t) {
+  const { ts, ds } = lut;
+  const last = ts.length - 1;
+  if (t <= ts[0]) return ds[0];
+  if (t >= ts[last]) return ds[last];
+  let lo = 1, hi = last;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (ts[mid] < t) lo = mid + 1;
+    else hi = mid;
+  }
+  const tPrev = ts[hi - 1];
+  const span = ts[hi] - tPrev;
+  const frac = span > 0 ? (t - tPrev) / span : 0;
+  return ds[hi - 1] + frac * (ds[hi] - ds[hi - 1]);
+}
+function invertEasing(easing) {
+  if (!easing) return (y) => y;
+  const flipped = [easing[1], easing[0], easing[3], easing[2]];
+  return cubicBezier(flipped);
+}
+
+// src/util/PxNodeProps.ts
+var PX_DISALLOWED_SVG_TAGS_LOWER = /* @__PURE__ */ new Set([
+  "script",
+  "foreignobject"
+]);
+var URL_VALUE_ATTRS_LOWER = /* @__PURE__ */ new Set([
+  "href",
+  // <use>, <image>
+  "xlink:href",
+  // legacy <use>
+  "src",
+  // <image>
+  "filter",
+  // url(#filterId)
+  "clippath",
+  // clip-path="url(#…)"
+  "mask",
+  // url(#maskId)
+  "markerstart",
+  // marker-start="url(#…)"
+  "markermid",
+  // marker-mid="url(#…)"
+  "markerend"
+  // marker-end="url(#…)"
+]);
+var IMAGE_REF_ATTRS_LOWER = /* @__PURE__ */ new Set(["href", "xlink:href", "src"]);
+var PX_CSS_ONLY_STYLE_PROPS = /* @__PURE__ */ new Set(["mixBlendMode", "isolation"]);
+var DATA_RASTER_IMAGE_RE = /^data:image\/(?:png|jpe?g|gif|webp|bmp);base64,/i;
+var DATA_SVG_IMAGE_RE = /^data:image\/svg\+xml(?:;[^,]*)?,/i;
+var DATA_IMAGE_BASE64_PAYLOAD_RE = /^data:image\/[^;,]*;base64,([A-Za-z0-9+/]{8})/i;
+var BASE64_RASTER_MAGICS = ["iVBORw0K", "/9j/", "R0lGOD", "UklGR", "Qk"];
+function isContentSniffedRasterImage(str2) {
+  const m = DATA_IMAGE_BASE64_PAYLOAD_RE.exec(str2);
+  return !!m && BASE64_RASTER_MAGICS.some((magic) => m[1].startsWith(magic));
+}
+function isDangerousAttrName(nameLower) {
+  if (nameLower.startsWith("on")) return true;
+  return false;
+}
+function sanitizeAttributeValue(name, value) {
+  const nameLower = name.toLowerCase();
+  if (isDangerousAttrName(nameLower)) {
+    console.warn("Attribute blocked (event handler / dangerous): ", nameLower);
+    return void 0;
+  }
+  if (nameLower === "fill" || nameLower === "stroke" || nameLower === "stopcolor") {
+    const str2 = String(value);
+    if (str2.includes("url(") && !/^url\(#[^)]+\)$/.test(str2)) {
+      console.warn('Attribute "' + nameLower + '" blocked: url() must be internal url(#id), got:', value);
+      return void 0;
+    }
+    return value;
+  }
+  if (URL_VALUE_ATTRS_LOWER.has(nameLower)) {
+    const str2 = String(value);
+    if (str2.startsWith("#")) return value;
+    if (/^url\(#[^)]+\)$/.test(str2)) return value;
+    if (IMAGE_REF_ATTRS_LOWER.has(nameLower) && (DATA_RASTER_IMAGE_RE.test(str2) || DATA_SVG_IMAGE_RE.test(str2) || isContentSniffedRasterImage(str2))) return value;
+    console.warn('Attribute "' + nameLower + '" blocked: must be #id, url(#id), or data:image/\u2026 URI, got:', value);
+    return void 0;
+  }
+  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/materialize/PxMotionPath.ts
+function getKfTranslate(kf) {
+  const v = keyframeValue(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]];
+  }
+  const tr = v.translate;
+  if (Array.isArray(tr) && tr.length >= 2) return [tr[0], tr[1]];
+  return void 0;
+}
+function getKfTime(kf) {
+  return keyframeTime(kf);
+}
+function getKfEasing(kf) {
+  return keyframeEasing(kf);
+}
+function propAnimIsMotionPath(anim) {
+  const kfs = anim.keyframes;
+  if (!Array.isArray(kfs)) return false;
+  if (anim.autoOrient) return true;
+  for (const kf of kfs) {
+    if (keyframeTangentIn(kf) || keyframeTangentOut(kf)) return true;
+  }
+  return false;
+}
+var _segmentCache = /* @__PURE__ */ new WeakMap();
+function getSegmentCache(prevKf, nextKf, prevPos, nextPos) {
+  let byNext = _segmentCache.get(prevKf);
+  const existing = byNext == null ? void 0 : byNext.get(nextKf);
+  if (existing) return existing;
+  const to = keyframeTangentOut(prevKf);
+  const ti = keyframeTangentIn(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);
+  const entry = {
+    P0: prevPos,
+    P1,
+    P2,
+    P3: nextPos,
+    lut,
+    totalArc: lut.ds[lut.ds.length - 1]
+  };
+  if (!byNext) {
+    byNext = /* @__PURE__ */ new WeakMap();
+    _segmentCache.set(prevKf, byNext);
+  }
+  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;
+function materializeMotionPathInPropAnim(anim, opts) {
+  var _a2, _b, _c;
+  if (!propAnimIsMotionPath(anim)) return anim;
+  const kfs = anim.keyframes;
+  if (!Array.isArray(kfs) || kfs.length < 2) return anim;
+  const autoOrient = !!anim.autoOrient;
+  const flatnessTol = (_a2 = opts == null ? void 0 : opts.flatnessTolerance) != null ? _a2 : 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;
+  const firstRotate = autoOrient ? derivAngleForFirstKf(kfs[0], kfs[1]) : void 0;
+  out.push(makeOutKf(
+    getKfTime(kfs[0]),
+    buildOutKfValue(getKfValueParts(kfs[0]), getKfValueParts(kfs[0]), 0, firstPos, firstRotate, autoOrient)
+  ));
+  for (let i = 0; i < kfs.length - 1; i++) {
+    const prevKf = kfs[i];
+    const nextKf = kfs[i + 1];
+    const prevPos = getKfTranslate(prevKf);
+    const nextPos = getKfTranslate(nextKf);
+    if (!prevPos || !nextPos) {
+      out.push(makeOutKf(
+        getKfTime(nextKf),
+        buildOutKfValue(getKfValueParts(nextKf), getKfValueParts(nextKf), 1, nextPos != null ? nextPos : [0, 0], void 0, autoOrient)
+      ));
+      continue;
+    }
+    if (autoOrient && i > 0) {
+      insertSharpCornerStepKfIfNeeded(out, prevKf, nextKf, prevPos, nextPos, rotationTol);
+    }
+    materializeSegment(out, prevKf, nextKf, prevPos, nextPos, autoOrient, flatnessTol, rotationTol, maxSamples);
+  }
+  const lastInE = getKfEasing(kfs[kfs.length - 1]);
+  if (lastInE) out[out.length - 1].e = lastInE;
+  if (autoOrient) unwrapAutoOrientRotations(out);
+  const result = { keyframes: out };
+  if (anim.loop !== void 0) result.loop = anim.loop;
+  return result;
+}
+function unwrapAutoOrientRotations(kfs) {
+  let prev;
+  for (const kf of kfs) {
+    const v = keyframeValue(kf);
+    if (!v || typeof v.rotate !== "number") continue;
+    if (prev === void 0) {
+      prev = v.rotate;
+      continue;
+    }
+    let r = v.rotate;
+    while (r - prev > 180) r -= 360;
+    while (r - prev < -180) r += 360;
+    v.rotate = r;
+    prev = r;
+  }
+}
+function makeOutKf(time, value) {
+  return { t: time, v: value };
+}
+function getKfValueParts(kf) {
+  const v = keyframeValue(kf);
+  if (!v || typeof v !== "object" || Array.isArray(v)) return void 0;
+  return v;
+}
+function interpolatePart(prev, next, p) {
+  if (prev === void 0) return next;
+  if (next === void 0) return prev;
+  if (typeof prev === "number" && typeof next === "number") {
+    return prev + (next - prev) * p;
+  }
+  if (Array.isArray(prev) && Array.isArray(next) && prev.length === next.length) {
+    const out = new Array(prev.length);
+    for (let i = 0; i < prev.length; i++) {
+      const a = typeof prev[i] === "number" ? prev[i] : 0;
+      const b = typeof next[i] === "number" ? next[i] : 0;
+      out[i] = a + (b - a) * p;
+    }
+    return out;
+  }
+  return p < 0.5 ? prev : next;
+}
+function buildOutKfValue(prevV, nextV, p, translate, rotateDegFromAutoOrient, autoOrient) {
+  const value = { translate };
+  const keys = /* @__PURE__ */ new Set();
+  if (prevV) for (const k of Object.keys(prevV)) keys.add(k);
+  if (nextV) for (const k of Object.keys(nextV)) keys.add(k);
+  for (const k of keys) {
+    if (k === "translate") continue;
+    if (k === "rotate" && autoOrient) continue;
+    const pv = prevV == null ? void 0 : prevV[k];
+    const nv = nextV == null ? void 0 : nextV[k];
+    if (pv === void 0 && nv === void 0) continue;
+    value[k] = interpolatePart(pv, nv, p);
+  }
+  if (rotateDegFromAutoOrient !== void 0) {
+    value.rotate = rotateDegFromAutoOrient + explicitRotateAt(prevV, nextV, p);
+  }
+  return value;
+}
+function explicitRotateAt(prevV, nextV, p) {
+  const pv = typeof (prevV == null ? void 0 : prevV.rotate) === "number" ? prevV.rotate : void 0;
+  const nv = typeof (nextV == null ? void 0 : nextV.rotate) === "number" ? nextV.rotate : void 0;
+  if (pv === void 0 && nv === void 0) return 0;
+  const r = interpolatePart(pv, nv, p);
+  return typeof r === "number" ? r : 0;
+}
+function derivAngleForFirstKf(kf0, kf1) {
+  const p0 = getKfTranslate(kf0);
+  const p1 = getKfTranslate(kf1);
+  if (!p0 || !p1) return 0;
+  const seg = getSegmentCache(kf0, kf1, p0, p1);
+  const tan = bezier2D_derivativeAt(seg.P0, seg.P1, seg.P2, seg.P3, 0);
+  return Math.atan2(tan[1], tan[0]) * 180 / Math.PI;
+}
+function wrappedAngleDelta(a, b) {
+  let d = a - b;
+  while (d > 180) d -= 360;
+  while (d < -180) d += 360;
+  return d;
+}
+function insertSharpCornerStepKfIfNeeded(out, prevKf, nextKf, prevPos, nextPos, rotationTol) {
+  const lastKf = out[out.length - 1];
+  const lastV = keyframeValue(lastKf);
+  const prevExit = lastV == null ? void 0 : lastV.rotate;
+  if (typeof prevExit !== "number") return;
+  const boundaryV = getKfValueParts(prevKf);
+  const prevExitTangent = prevExit - explicitRotateAt(boundaryV, boundaryV, 0);
+  const seg = getSegmentCache(prevKf, nextKf, prevPos, nextPos);
+  const tanAtStart = bezier2D_derivativeAt(seg.P0, seg.P1, seg.P2, seg.P3, 0);
+  const nextEntry = Math.atan2(tanAtStart[1], tanAtStart[0]) * 180 / Math.PI;
+  const delta = wrappedAngleDelta(nextEntry, prevExitTangent);
+  if (Math.abs(delta) <= rotationTol) return;
+  const prevTime = getKfTime(prevKf);
+  const stepTime = Math.min(prevTime + CORNER_STEP_AFTER_BOUNDARY_MS, (prevTime + getKfTime(nextKf)) / 2);
+  const dupValue = buildOutKfValue(
+    getKfValueParts(prevKf),
+    getKfValueParts(prevKf),
+    0,
+    prevPos,
+    nextEntry,
+    true
+  );
+  out.push(makeOutKf(stepTime, dupValue));
+}
+var CORNER_STEP_AFTER_BOUNDARY_MS = 0.05;
+function materializeSegment(out, prevKf, nextKf, prevPos, nextPos, autoOrient, flatnessTol, rotationTol, maxSamples) {
+  const seg = getSegmentCache(prevKf, nextKf, prevPos, nextPos);
+  const prevTime = getKfTime(prevKf);
+  const nextTime = getKfTime(nextKf);
+  const prevEasing = getKfEasing(prevKf);
+  const invertFn = invertEasing(prevEasing);
+  const prevV = getKfValueParts(prevKf);
+  const nextV = getKfValueParts(nextKf);
+  const interiorTs = computeSampleTs(seg, autoOrient, flatnessTol, rotationTol, maxSamples);
+  const samples = [];
+  for (const t of interiorTs) {
+    const arc = bezier2D_arcAtT(seg.lut, t);
+    const p = clamp(seg.totalArc > 0 ? arc / seg.totalArc : t, 0, 1);
+    const u = clamp(invertFn(p), 0, 1);
+    const pos = bezier2D_pointAt(seg.P0, seg.P1, seg.P2, seg.P3, t);
+    const sample = { u, p, pos };
+    if (autoOrient) {
+      const tan = bezier2D_derivativeAt(seg.P0, seg.P1, seg.P2, seg.P3, t);
+      sample.rotateDeg = Math.atan2(tan[1], tan[0]) * 180 / Math.PI;
+    }
+    samples.push(sample);
+  }
+  let remaining = prevEasing;
+  let prevU = 0;
+  const startIdx = out.length - 1;
+  for (let i = 0; i < samples.length; i++) {
+    const s = samples[i];
+    const xFrac = prevU < 1 ? clamp((s.u - prevU) / (1 - prevU), 0, 1) : 1;
+    const { left, right } = splitEasing(remaining, xFrac);
+    const ownerIdx = i === 0 ? startIdx : out.length - 1;
+    if (left) out[ownerIdx].e = left;
+    else delete out[ownerIdx].e;
+    const tGlobal = prevTime + s.u * (nextTime - prevTime);
+    const value = buildOutKfValue(prevV, nextV, s.p, s.pos, s.rotateDeg, autoOrient);
+    out.push(makeOutKf(tGlobal, value));
+    remaining = right;
+    prevU = s.u;
+  }
+}
+function computeSampleTs(seg, autoOrient, flatnessTol, rotationTol, maxSamples) {
+  const extremes = [];
+  addAxisExtremes(seg.P0[0], seg.P1[0], seg.P2[0], seg.P3[0], extremes);
+  addAxisExtremes(seg.P0[1], seg.P1[1], seg.P2[1], seg.P3[1], extremes);
+  extremes.sort((a, b) => a - b);
+  const critical = [0];
+  for (const t of extremes) {
+    if (t > critical[critical.length - 1] + 1e-6 && t < 1 - 1e-6) {
+      critical.push(t);
+    }
+  }
+  critical.push(1);
+  const out = [];
+  const budget = { remaining: maxSamples - critical.length };
+  for (let i = 0; i < critical.length - 1; i++) {
+    bisect(critical[i], critical[i + 1], out, seg, autoOrient, flatnessTol, rotationTol, budget);
+  }
+  return out;
+}
+function addAxisExtremes(p0, p1, p2, p3, out) {
+  const a = p1 - p0;
+  const b = p2 - p1;
+  const c = p3 - p2;
+  const A = a - 2 * b + c;
+  const B = 2 * (b - a);
+  const C = a;
+  if (Math.abs(A) < 1e-10) {
+    if (Math.abs(B) > 1e-10) {
+      const t = -C / B;
+      if (t > 1e-6 && t < 1 - 1e-6) out.push(t);
+    }
+    return;
+  }
+  const disc = B * B - 4 * A * C;
+  if (disc < 0) return;
+  const sq = Math.sqrt(disc);
+  const t1 = (-B - sq) / (2 * A);
+  const t2 = (-B + sq) / (2 * A);
+  if (t1 > 1e-6 && t1 < 1 - 1e-6) out.push(t1);
+  if (t2 > 1e-6 && t2 < 1 - 1e-6) out.push(t2);
+}
+function bisect(tA, tB, out, seg, autoOrient, flatnessTol, rotationTol, budget) {
+  const tMid = (tA + tB) / 2;
+  const pA = bezier2D_pointAt(seg.P0, seg.P1, seg.P2, seg.P3, tA);
+  const pB = bezier2D_pointAt(seg.P0, seg.P1, seg.P2, seg.P3, tB);
+  const span = tB - tA;
+  const p25 = bezier2D_pointAt(seg.P0, seg.P1, seg.P2, seg.P3, tA + span * 0.25);
+  const p50 = bezier2D_pointAt(seg.P0, seg.P1, seg.P2, seg.P3, tMid);
+  const p75 = bezier2D_pointAt(seg.P0, seg.P1, seg.P2, seg.P3, tA + span * 0.75);
+  const dev = Math.max(
+    perpDist(p25, pA, pB),
+    perpDist(p50, pA, pB),
+    perpDist(p75, pA, pB)
+  );
+  let rotOk = true;
+  if (autoOrient) {
+    const tanA = bezier2D_derivativeAt(seg.P0, seg.P1, seg.P2, seg.P3, tA);
+    const tanB = bezier2D_derivativeAt(seg.P0, seg.P1, seg.P2, seg.P3, tB);
+    const angA = Math.atan2(tanA[1], tanA[0]) * 180 / Math.PI;
+    const angB = Math.atan2(tanB[1], tanB[0]) * 180 / Math.PI;
+    let delta = Math.abs(angA - angB);
+    if (delta > 180) delta = 360 - delta;
+    if (delta > rotationTol) rotOk = false;
+  }
+  if (dev <= flatnessTol && rotOk || budget.remaining <= 0 || span < 1e-6) {
+    out.push(tB);
+    return;
+  }
+  budget.remaining -= 1;
+  bisect(tA, tMid, out, seg, autoOrient, flatnessTol, rotationTol, budget);
+  bisect(tMid, tB, out, seg, autoOrient, flatnessTol, rotationTol, budget);
+}
+function perpDist(q, pA, pB) {
+  const dx = pB[0] - pA[0];
+  const dy = pB[1] - pA[1];
+  const len2 = dx * dx + dy * dy;
+  if (len2 < 1e-20) {
+    const qdx = q[0] - pA[0];
+    const qdy = q[1] - pA[1];
+    return Math.sqrt(qdx * qdx + qdy * qdy);
+  }
+  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 = animBucket;
+    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") {
+    const aPaths = (_a2 = a == null ? void 0 : a.paths) != null ? _a2 : Array.isArray(a) ? a : [];
+    const bPaths = (_b = b == null ? void 0 : b.paths) != null ? _b : Array.isArray(b) ? b : [];
+    return { paths: interpolateBeziers(aPaths, bPaths, t) };
+  }
+  if (PX_COLOR_ATTR_NAMES.has(propName)) {
+    return interpolateColor(a || [0, 0, 0, 1], b || [0, 0, 0, 1], t);
+  }
+  if (propName === "transform" && typeof a === "object" && a !== null && !Array.isArray(a) && typeof b === "object" && b !== null && !Array.isArray(b)) {
+    return interpolateTransformParts(a, b, t);
+  }
+  if (propName === "rotate" && typeof a === "number" && typeof b === "number") {
+    return interpolateNum(a, b, t);
+  }
+  if (PX_TRANSFORM_FN_NAMES.has(propName) || propName === "stroke-dasharray" || propName === "strokeDasharray") {
+    return interpolateVec(a || [], b || [], t);
+  }
+  return interpolateNum(+(a || 0), +(b || 0), t);
+}
+function interpolateTransformParts(a, b, t) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a != null ? a : {}), ...Object.keys(b != null ? b : {})]);
+  const out = {};
+  for (const k of keys) {
+    const av = a == null ? void 0 : a[k];
+    const bv = b == null ? void 0 : b[k];
+    if (k === "rotate" || k === "skew") {
+      out[k] = interpolateNum(+(av != null ? av : 0), +(bv != null ? bv : 0), t);
+    } else if (k === "translate" || k === "scale" || k === "origin") {
+      const fallback = k === "scale" ? [1, 1] : [0, 0];
+      out[k] = interpolateVec(av || fallback, bv || fallback, t);
+    } else {
+      out[k] = bv != null ? bv : av;
+    }
+  }
+  return 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);
+    }
+  }
+  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);
+  });
+  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 mergeStaticTransformIntoAnimDef(animDef, staticTransform) {
+  if (!animDef) return animDef;
+  const staticParts = staticTransform && typeof staticTransform === "object" && !Array.isArray(staticTransform) ? staticTransform : parseTransformParts(staticTransform);
+  if (!staticParts || !Object.keys(staticParts).length) return animDef;
+  const mergeKfValue = (v) => v && typeof v === "object" && !Array.isArray(v) ? __spreadValues(__spreadValues({}, staticParts), v) : v;
+  const transformAnim = animDef[TRANSFORM_ATTR];
+  if (transformAnim && typeof transformAnim === "object") {
+    const anim = transformAnim;
+    if (Array.isArray(anim.keyframes)) {
+      const out = __spreadProps(__spreadValues({}, anim), {
+        keyframes: anim.keyframes.map((kf) => __spreadProps(__spreadValues({}, kf), { value: mergeKfValue(kf.value) }))
+      });
+      if (out.value !== void 0) out.value = mergeKfValue(out.value);
+      return __spreadProps(__spreadValues({}, animDef), { transform: out });
+    }
+    return animDef;
+  }
+  const channels = Object.keys(animDef).filter((k) => PX_TRANSFORM_FN_NAMES.has(k));
+  if (channels.length !== 1) return animDef;
+  const ch = channels[0];
+  const chAnim = animDef[ch];
+  if (!chAnim || typeof chAnim !== "object" || !Array.isArray(chAnim.keyframes)) return animDef;
+  const lifted = __spreadProps(__spreadValues({}, chAnim), {
+    keyframes: chAnim.keyframes.map((kf) => __spreadProps(__spreadValues({}, kf), { value: __spreadProps(__spreadValues({}, staticParts), { [ch]: kf.value }) }))
+  });
+  if (lifted.value !== void 0) lifted.value = __spreadProps(__spreadValues({}, staticParts), { [ch]: lifted.value });
+  const rest = __spreadValues({}, animDef);
+  delete rest[ch];
+  return __spreadProps(__spreadValues({}, rest), { transform: lifted });
+}
+function normalizeAnimationDefinition(animDef, duration, defs, engine = PxTimelineEngine.native) {
+  const normalized = {};
+  for (const [propName, propAnim] of Object.entries(animDef)) {
+    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;
+  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;
+      }
+    }
+    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 num = interpolateNum(
+      +(prevV || 0),
+      +(nextV || 0),
+      localProgress
+    );
+    cssValue = num;
+  }
+  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/text/pathSampler.ts
+var LUT_STEPS = 48;
+var CMD_RE = /[MmLlHhVvCcSsQqTtAaZz]/;
+function tokenize(d) {
+  const tokens = [];
+  const re = /([MmLlHhVvCcSsQqTtAaZz])|(-?\d*\.?\d+(?:[eE][-+]?\d+)?)/g;
+  let m;
+  while ((m = re.exec(d)) !== null) tokens.push(m[0]);
+  return tokens;
+}
+function quadToCubic(P0, Qc, P3) {
+  return {
+    P1: [P0[0] + 2 / 3 * (Qc[0] - P0[0]), P0[1] + 2 / 3 * (Qc[1] - P0[1])],
+    P2: [P3[0] + 2 / 3 * (Qc[0] - P3[0]), P3[1] + 2 / 3 * (Qc[1] - P3[1])]
+  };
+}
+function parseCubics(d) {
+  const tokens = tokenize(d);
+  const segs = [];
+  let i = 0;
+  let cx = 0, cy = 0;
+  let sx = 0, sy = 0;
+  let pcx = 0, pcy = 0;
+  let pqx = 0, pqy = 0;
+  let prevCmd = "";
+  const num = () => parseFloat(tokens[i++]);
+  const push = (P1, P2, P3) => {
+    const P0 = [cx, cy];
+    const lut = bezier2D_arcLengthLUT(P0, P1, P2, P3, LUT_STEPS);
+    segs.push({ P0, P1, P2, P3, lut, len: lut.ds[lut.ds.length - 1] });
+    cx = P3[0];
+    cy = P3[1];
+  };
+  const pushLine = (x, y) => {
+    push(
+      [cx + (x - cx) / 3, cy + (y - cy) / 3],
+      [cx + 2 * (x - cx) / 3, cy + 2 * (y - cy) / 3],
+      [x, y]
+    );
+  };
+  while (i < tokens.length) {
+    let cmd = tokens[i];
+    if (CMD_RE.test(cmd)) i++;
+    else cmd = prevCmd === "M" ? "L" : prevCmd === "m" ? "l" : prevCmd;
+    const rel = cmd >= "a";
+    const U = cmd.toUpperCase();
+    if (U === "Z") {
+      pushLine(sx, sy);
+      cx = sx;
+      cy = sy;
+      prevCmd = cmd;
+      continue;
+    }
+    if (U === "M") {
+      const x = num() + (rel ? cx : 0), y = num() + (rel ? cy : 0);
+      cx = x;
+      cy = y;
+      sx = x;
+      sy = y;
+      prevCmd = cmd;
+      continue;
+    }
+    if (U === "L") {
+      pushLine(num() + (rel ? cx : 0), num() + (rel ? cy : 0));
+    } else if (U === "H") {
+      pushLine(num() + (rel ? cx : 0), cy);
+    } else if (U === "V") {
+      pushLine(cx, num() + (rel ? cy : 0));
+    } else if (U === "C") {
+      const p1 = [num() + (rel ? cx : 0), num() + (rel ? cy : 0)];
+      const p2 = [num() + (rel ? cx : 0), num() + (rel ? cy : 0)];
+      const p3 = [num() + (rel ? cx : 0), num() + (rel ? cy : 0)];
+      pcx = p2[0];
+      pcy = p2[1];
+      push(p1, p2, p3);
+    } else if (U === "S") {
+      const smooth = prevCmd.toUpperCase() === "C" || prevCmd.toUpperCase() === "S";
+      const p1 = smooth ? [2 * cx - pcx, 2 * cy - pcy] : [cx, cy];
+      const p2 = [num() + (rel ? cx : 0), num() + (rel ? cy : 0)];
+      const p3 = [num() + (rel ? cx : 0), num() + (rel ? cy : 0)];
+      pcx = p2[0];
+      pcy = p2[1];
+      push(p1, p2, p3);
+    } else if (U === "Q") {
+      const qc = [num() + (rel ? cx : 0), num() + (rel ? cy : 0)];
+      const p3 = [num() + (rel ? cx : 0), num() + (rel ? cy : 0)];
+      pqx = qc[0];
+      pqy = qc[1];
+      const { P1, P2 } = quadToCubic([cx, cy], qc, p3);
+      push(P1, P2, p3);
+    } else if (U === "T") {
+      const smooth = prevCmd.toUpperCase() === "Q" || prevCmd.toUpperCase() === "T";
+      const qc = smooth ? [2 * cx - pqx, 2 * cy - pqy] : [cx, cy];
+      const p3 = [num() + (rel ? cx : 0), num() + (rel ? cy : 0)];
+      pqx = qc[0];
+      pqy = qc[1];
+      const { P1, P2 } = quadToCubic([cx, cy], qc, p3);
+      push(P1, P2, p3);
+    } else if (U === "A") {
+      i += 5;
+      pushLine(num() + (rel ? cx : 0), num() + (rel ? cy : 0));
+    } else {
+      i++;
+      continue;
+    }
+    prevCmd = cmd;
+  }
+  return segs.length ? segs : null;
+}
+function clamp2(v, lo, hi) {
+  return v < lo ? lo : v > hi ? hi : v;
+}
+function createPathSampler(d) {
+  const segs = parseCubics(d);
+  if (!segs) return null;
+  const cum = new Float64Array(segs.length + 1);
+  for (let k = 0; k < segs.length; k++) cum[k + 1] = cum[k] + segs[k].len;
+  const totalLength = cum[segs.length];
+  const start = segs[0].P0, end = segs[segs.length - 1].P3;
+  const closed = Math.hypot(end[0] - start[0], end[1] - start[1]) < 1e-3;
+  const sampleOn = (dist) => {
+    let k = 0;
+    while (k < segs.length - 1 && dist > cum[k + 1]) k++;
+    const seg = segs[k];
+    const local = dist - cum[k];
+    const t = seg.len > 0 ? bezier2D_tForDistance(seg.lut, local) : 0;
+    const [x, y] = bezier2D_pointAt(seg.P0, seg.P1, seg.P2, seg.P3, t);
+    const [dx, dy] = bezier2D_derivativeAt(seg.P0, seg.P1, seg.P2, seg.P3, t);
+    return { x, y, angle: Math.atan2(dy, dx) };
+  };
+  return {
+    totalLength,
+    closed,
+    sampleAtDistance(dist) {
+      if (closed && totalLength > 0 && (dist < 0 || dist > totalLength)) {
+        return sampleOn((dist % totalLength + totalLength) % totalLength);
+      }
+      if (!closed && (dist < 0 || dist > totalLength)) {
+        const edge = dist < 0 ? 0 : totalLength;
+        const p = sampleOn(edge);
+        const over = dist - edge;
+        return { x: p.x + Math.cos(p.angle) * over, y: p.y + Math.sin(p.angle) * over, angle: p.angle };
+      }
+      return sampleOn(clamp2(dist, 0, totalLength));
+    }
+  };
+}
+
+// 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 */ };
+  if (Array.isArray(raw)) return { kind: "static" /* Static */, value: raw };
+  if (typeof raw === "object") {
+    const obj = raw;
+    const kfs = obj.keyframes;
+    if (kfs) {
+      const out = { kind: "animated" /* Animated */, keyframes: kfs.map(normalizeKeyframe), autoOrient: obj.autoOrient, loop: obj.loop };
+      const base = (_a2 = obj.value) != null ? _a2 : obj.v;
+      if (base !== void 0 && out.kind === "animated" /* Animated */) out.base = base;
+      return out;
+    }
+    const staticValue = (_b = obj.value) != null ? _b : obj.v;
+    if (staticValue !== void 0) return { kind: "static" /* Static */, value: staticValue };
+  }
+  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;
+  if (k.t === void 0 && k.v === void 0 && k.e === void 0 && k.to === void 0 && k.ti === void 0) {
+    return kf;
+  }
+  const out = __spreadValues({}, k);
+  if (out.time === void 0 && k.t !== void 0) out.time = k.t;
+  if (out.value === void 0 && k.v !== void 0) out.value = k.v;
+  if (out.easing === void 0 && k.e !== void 0) out.easing = k.e;
+  if (out.tangentOut === void 0 && k.to !== void 0) out.tangentOut = k.to;
+  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/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, genId2) {
+  const oldToNew = /* @__PURE__ */ new Map();
+  const walkAssign = (n) => {
+    var _a2;
+    if (typeof n.id === "string") {
+      const newId = genId2();
+      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);
+  const startExt = startOverflow > 0 ? startOverflow + margin : 0;
+  const endExt = endOverflow > 0 ? endOverflow + margin : 0;
+  if (endExt <= 0 && startExt <= 0) return { d: pathD, startShift: 0 };
+  const s = sampler.sampleAtDistance(0);
+  const e = sampler.sampleAtDistance(L);
+  let d = pathD;
+  if (startExt > 0) {
+    const sx = s.x - Math.cos(s.angle) * startExt, sy = s.y - Math.sin(s.angle) * startExt;
+    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);
+  }
+  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/effects/text/elementFactory.ts
+var jsonElementFactory = (type, props, children) => {
+  const node = { type };
+  for (const k in props) if (props[k] !== void 0) node[k] = props[k];
+  const arr = Array.isArray(children) ? children.filter((c) => c != null) : children != null ? [children] : [];
+  if (arr.length) node.children = arr;
+  return node;
+};
+
+// src/effects/text/glyphPathBake.ts
+function fmt(v, decimals) {
+  return Math.round(v) === v ? "" + Math.round(v) : v.toFixed(decimals);
+}
+function pack(nums, decimals) {
+  let s = "";
+  for (let i = 0; i < nums.length; i++) {
+    const str2 = fmt(nums[i], decimals);
+    if (i > 0 && str2.charCodeAt(0) !== 45) s += " ";
+    s += str2;
+  }
+  return s;
+}
+function apply(m, x, y) {
+  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+var TOKEN_RE = /([MLCQZ])|(-?\d*\.?\d+(?:e[-+]?\d+)?)/gi;
+function transformPathData(d, m, decimals = 2) {
+  const tokens = [];
+  let match;
+  TOKEN_RE.lastIndex = 0;
+  while ((match = TOKEN_RE.exec(d)) !== null) tokens.push(match[0]);
+  let out = "";
+  let i = 0;
+  const num = () => parseFloat(tokens[i++]);
+  while (i < tokens.length) {
+    const cmd = tokens[i++];
+    if (cmd === "M" || cmd === "L") {
+      const [x, y] = apply(m, num(), num());
+      out += cmd + pack([x, y], decimals);
+    } else if (cmd === "C") {
+      const [x1, y1] = apply(m, num(), num());
+      const [x2, y2] = apply(m, num(), num());
+      const [x, y] = apply(m, num(), num());
+      out += "C" + pack([x1, y1, x2, y2, x, y], decimals);
+    } else if (cmd === "Q") {
+      const [x1, y1] = apply(m, num(), num());
+      const [x, y] = apply(m, num(), num());
+      out += "Q" + pack([x1, y1, x, y], decimals);
+    } else if (cmd === "Z" || cmd === "z") {
+      out += "Z";
+    }
+  }
+  return out;
+}
+
+// src/effects/text/textGlyphsEffect.ts
+var DEFAULT_FONT_SIZE = 16;
+var TEXT_ATTR_KEYS = [
+  "fontFamily",
+  "fontSize",
+  "fontWeight",
+  "fontStyle",
+  "textAnchor",
+  "letterSpacing",
+  "wordSpacing",
+  "textDecoration",
+  "textTransform",
+  "whiteSpace",
+  "x",
+  "y",
+  "dx",
+  "dy",
+  "lengthAdjust",
+  "fill",
+  "stroke",
+  "strokeWidth",
+  "effects",
+  PX_TEXT_CONTENT_ATTR,
+  "xml:space"
+];
+var PAINT_STATIC_KEYS = [
+  "fillOpacity",
+  "fillRule",
+  "strokeOpacity",
+  "strokeDasharray",
+  "strokeDashoffset",
+  "strokeLinecap",
+  "strokeLinejoin",
+  "strokeMiterlimit",
+  "mixBlendMode",
+  "filter"
+];
+var PAINT_ANIMATE_KEYS = ["fill", "stroke", "strokeWidth", "opacity", "fillOpacity", "strokeOpacity", "strokeDasharray", "strokeDashoffset"];
+function parseLen(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    const n = parseFloat(v);
+    return isNaN(n) ? void 0 : n;
+  }
+  return void 0;
+}
+function str(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function paintAnimateOf(node) {
+  const bag = node.animate;
+  if (!bag || typeof bag !== "object") return void 0;
+  let out;
+  for (const k of PAINT_ANIMATE_KEYS) {
+    if (bag[k] !== void 0) (out != null ? out : out = {})[k] = bag[k];
+  }
+  return out;
+}
+function resolveStyle(node, parent) {
+  var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const isTextRoot = node.type === "text";
+  const nodeStyle = node.style;
+  const own = (key) => {
+    var _a3;
+    return isTextRoot ? void 0 : (_a3 = node[key]) != null ? _a3 : nodeStyle == null ? void 0 : nodeStyle[key];
+  };
+  const res = {
+    fontFamily: (_a2 = str(node.fontFamily)) != null ? _a2 : parent.fontFamily,
+    fontSize: (_b = parseLen(node.fontSize)) != null ? _b : parent.fontSize,
+    fill: (_c = node.fill) != null ? _c : parent.fill,
+    stroke: (_d = node.stroke) != null ? _d : parent.stroke,
+    strokeWidth: (_e = node.strokeWidth) != null ? _e : parent.strokeWidth,
+    letterSpacing: (_f = parseLen(node.letterSpacing)) != null ? _f : parent.letterSpacing,
+    wordSpacing: (_g = parseLen(node.wordSpacing)) != null ? _g : parent.wordSpacing,
+    opacity: (_h = parseLen(own("opacity"))) != null ? _h : parent.opacity,
+    animate: (_i = isTextRoot ? void 0 : paintAnimateOf(node)) != null ? _i : parent.animate
+  };
+  for (const key of PAINT_STATIC_KEYS) {
+    const v = (_j = own(key)) != null ? _j : parent[key];
+    if (v !== void 0) res[key] = v;
+  }
+  return res;
+}
+function rootStyleOf(node) {
+  var _a2, _b, _c;
+  return {
+    fontFamily: str(node.fontFamily),
+    fontSize: (_a2 = parseLen(node.fontSize)) != null ? _a2 : DEFAULT_FONT_SIZE,
+    fill: node.fill,
+    stroke: node.stroke,
+    strokeWidth: node.strokeWidth,
+    letterSpacing: (_b = parseLen(node.letterSpacing)) != null ? _b : 0,
+    wordSpacing: (_c = parseLen(node.wordSpacing)) != null ? _c : 0
+  };
+}
+function paintOf(s) {
+  const p = {};
+  if (s.fill !== void 0) p.fill = s.fill;
+  if (s.stroke !== void 0) p.stroke = s.stroke;
+  if (s.strokeWidth !== void 0) p.strokeWidth = s.strokeWidth;
+  if (s.opacity !== void 0 && s.opacity !== 1) p.opacity = s.opacity;
+  for (const key of PAINT_STATIC_KEYS) {
+    if (s[key] !== void 0) p[key] = s[key];
+  }
+  if (s.animate !== void 0) p.animate = s.animate;
+  return p;
+}
+function glyphFontFor(s, glyphs, soleFont, warnings) {
+  var _a2;
+  const gf = s.fontFamily ? glyphs[s.fontFamily] : soleFont;
+  if (!gf) warnings == null ? void 0 : warnings.push('textGlyphs: no glyphs for font "' + ((_a2 = s.fontFamily) != null ? _a2 : "") + '"');
+  return gf;
+}
+function soleFontOf(glyphs) {
+  const names = Object.keys(glyphs);
+  return names.length === 1 ? glyphs[names[0]] : void 0;
+}
+var MISSING_GLYPH_ADVANCE_EM = 0.6;
+var MISSING_GLYPH_CLASS_NAME = "px-missing-glyph";
+function missingGlyphBoxEm(advanceEm, ascentEm) {
+  if (advanceEm <= 0 || ascentEm <= 0) return "";
+  const inset = 0.08;
+  const x0 = advanceEm * inset, x1 = advanceEm * (1 - inset);
+  const y1 = -ascentEm * (1 - inset);
+  const bw = x1 - x0, bh = -y1;
+  const t = Math.max(1, Math.min(bw, bh) * 0.12);
+  const outer = "M" + x0 + " 0L" + x1 + " 0L" + x1 + " " + y1 + "L" + x0 + " " + y1 + "Z";
+  if (bw <= 2 * t || bh <= 2 * t) return outer;
+  const ix0 = x0 + t, ix1 = x1 - t, iyb = -t, iyt = y1 + t;
+  return outer + "M" + ix0 + " " + iyb + "L" + ix0 + " " + iyt + "L" + ix1 + " " + iyt + "L" + ix1 + " " + iyb + "Z";
+}
+function materializeGlyphTextHorizontal(node, opts) {
+  var _a2, _b, _c;
+  const { glyphs, create = jsonElementFactory, warnings } = opts;
+  const soleFont = soleFontOf(glyphs);
+  const pen = { x: (_a2 = parseLen(node.x)) != null ? _a2 : 0, y: (_b = parseLen(node.y)) != null ? _b : 0 };
+  const placements = [];
+  const lines = [{ start: pen.x, end: pen.x }];
+  let line = 0;
+  const renderChars = (content, s) => {
+    var _a3;
+    const gf = glyphFontFor(s, glyphs, soleFont, warnings);
+    const upm = (gf == null ? void 0 : gf.unitsPerEm) || 1e3;
+    const scale = s.fontSize / upm;
+    const ascentEm = (_a3 = gf == null ? void 0 : gf.ascent) != null ? _a3 : 0.9 * upm;
+    const paint = paintOf(s);
+    for (let i = 0; i < content.length; i++) {
+      const ch = content.charAt(i);
+      const g = gf == null ? void 0 : gf.glyphs[ch];
+      if (g && g.pathData) {
+        placements.push({ glyphD: g.pathData, m: [scale, 0, 0, scale, pen.x, pen.y], paint, line, x: pen.x, y: pen.y, scale });
+        pen.x += g.width * scale;
+      } else if (/\S/.test(ch)) {
+        const advEm = g && g.width > 0 ? g.width : MISSING_GLYPH_ADVANCE_EM * upm;
+        placements.push({ glyphD: missingGlyphBoxEm(advEm, ascentEm), m: [scale, 0, 0, scale, pen.x, pen.y], paint, isMissing: true, line, x: pen.x, y: pen.y, scale });
+        pen.x += advEm * scale;
+      } else {
+        pen.x += (g ? g.width : 0) * scale;
+      }
+      pen.x += s.letterSpacing + (ch === " " ? s.wordSpacing : 0);
+      lines[line].end = pen.x;
+    }
+  };
+  const walk = (el, parentStyle) => {
+    var _a3, _b2, _c2;
+    const s = resolveStyle(el, parentStyle);
+    const x = parseLen(el.x);
+    const y = parseLen(el.y);
+    if (x !== void 0) {
+      pen.x = x;
+      line = lines.length;
+      lines.push({ start: pen.x, end: pen.x });
+    }
+    if (y !== void 0) pen.y = y;
+    pen.x += (_a3 = parseLen(el.dx)) != null ? _a3 : 0;
+    pen.y += (_b2 = parseLen(el.dy)) != null ? _b2 : 0;
+    const content = str(el[PX_TEXT_CONTENT_ATTR]);
+    if (content && !((_c2 = el.children) == null ? void 0 : _c2.length)) renderChars(content, s);
+    if (el.children) for (const ch of el.children) walk(ch, s);
+  };
+  const rootStyle = rootStyleOf(node);
+  if (node.children) for (const ch of node.children) walk(ch, rootStyle);
+  const rootContent = str(node[PX_TEXT_CONTENT_ATTR]);
+  if (rootContent && !((_c = node.children) == null ? void 0 : _c.length)) renderChars(rootContent, rootStyle);
+  const anchor = str(node.textAnchor);
+  if (anchor === "middle" || anchor === "end") {
+    for (const p of placements) {
+      const w = lines[p.line].end - lines[p.line].start;
+      const shift = anchor === "middle" ? -w / 2 : -w;
+      p.m = [p.scale, 0, 0, p.scale, p.x + shift, p.y];
+    }
+  }
+  return toGroup(node, buildPaths(placements, create, warnings), create);
+}
+function layoutGlyphTextChars(node, opts) {
+  var _a2, _b, _c, _d, _e;
+  if ((_a2 = opts.alongPath) == null ? void 0 : _a2.pathD) return layoutGlyphTextCharsAlongPath(node, opts.alongPath.pathD, opts);
+  const { glyphs, warnings } = opts;
+  const soleFont = soleFontOf(glyphs);
+  const pen = { x: (_b = parseLen(node.x)) != null ? _b : 0, y: (_c = parseLen(node.y)) != null ? _c : 0 };
+  const boxes = [];
+  const lines = [{ start: pen.x, end: pen.x }];
+  let line = 0;
+  const renderChars = (content, s) => {
+    var _a3;
+    const gf = glyphFontFor(s, glyphs, soleFont, warnings);
+    const upm = (gf == null ? void 0 : gf.unitsPerEm) || 1e3;
+    const scale = s.fontSize / upm;
+    const ascent = ((_a3 = gf == null ? void 0 : gf.ascent) != null ? _a3 : 0.9 * upm) * scale;
+    for (let i = 0; i < content.length; i++) {
+      const ch = content.charAt(i);
+      const g = gf == null ? void 0 : gf.glyphs[ch];
+      const advance = (g ? g.width : 0) * scale + s.letterSpacing + (ch === " " ? s.wordSpacing : 0);
+      boxes.push({ x: pen.x, y: pen.y, width: advance, ascent, fontSize: s.fontSize, line });
+      pen.x += advance;
+      lines[line].end = pen.x;
+    }
+  };
+  const walk = (el, parentStyle) => {
+    var _a3, _b2, _c2;
+    const s = resolveStyle(el, parentStyle);
+    const x = parseLen(el.x);
+    const y = parseLen(el.y);
+    if (x !== void 0) {
+      pen.x = x;
+      line = lines.length;
+      lines.push({ start: pen.x, end: pen.x });
+    }
+    if (y !== void 0) pen.y = y;
+    pen.x += (_a3 = parseLen(el.dx)) != null ? _a3 : 0;
+    pen.y += (_b2 = parseLen(el.dy)) != null ? _b2 : 0;
+    const content = str(el[PX_TEXT_CONTENT_ATTR]);
+    if (content && !((_c2 = el.children) == null ? void 0 : _c2.length)) renderChars(content, s);
+    if (el.children) for (const ch of el.children) walk(ch, s);
+  };
+  const rootStyle = rootStyleOf(node);
+  if (node.children) for (const ch of node.children) {
+    const before = boxes.length;
+    walk(ch, rootStyle);
+    if (boxes.length === before) {
+      const s = resolveStyle(ch, rootStyle);
+      const gf = glyphFontFor(s, glyphs, soleFont);
+      const upm = (gf == null ? void 0 : gf.unitsPerEm) || 1e3;
+      boxes.push({ x: pen.x, y: pen.y, width: 0, ascent: ((_d = gf == null ? void 0 : gf.ascent) != null ? _d : 0.9 * upm) * (s.fontSize / upm), fontSize: s.fontSize, line });
+    }
+  }
+  const rootContent = str(node[PX_TEXT_CONTENT_ATTR]);
+  if (rootContent && !((_e = node.children) == null ? void 0 : _e.length)) renderChars(rootContent, rootStyle);
+  const anchor = str(node.textAnchor);
+  if (anchor === "middle" || anchor === "end") {
+    for (const b of boxes) {
+      const w = lines[b.line].end - lines[b.line].start;
+      b.x += anchor === "middle" ? -w / 2 : -w;
+    }
+  }
+  return boxes.map((_f) => {
+    var _g = _f, { line: _l } = _g, b = __objRest(_g, ["line"]);
+    return b;
+  });
+}
+function layoutGlyphTextCharsAlongPath(node, pathD, opts) {
+  var _a2, _b;
+  const { glyphs, warnings, alongPath } = opts;
+  const sampler = createPathSampler(pathD);
+  if (!sampler) {
+    warnings == null ? void 0 : warnings.push("textGlyphs: unparsable along-path geometry (caret)");
+    return [];
+  }
+  const soleFont = soleFontOf(glyphs);
+  const chars = [];
+  let adv = 0;
+  const walk = (el, parentStyle) => {
+    var _a3, _b2;
+    const s = resolveStyle(el, parentStyle);
+    const content = str(el[PX_TEXT_CONTENT_ATTR]);
+    if (content && !((_a3 = el.children) == null ? void 0 : _a3.length)) {
+      const gf = glyphFontFor(s, glyphs, soleFont, warnings);
+      const upm = (gf == null ? void 0 : gf.unitsPerEm) || 1e3;
+      const scale = s.fontSize / upm;
+      const ascent = ((_b2 = gf == null ? void 0 : gf.ascent) != null ? _b2 : 0.9 * upm) * scale;
+      for (let i = 0; i < content.length; i++) {
+        const ch = content.charAt(i);
+        const g = gf == null ? void 0 : gf.glyphs[ch];
+        const glyphW = (g ? g.width : 0) * scale;
+        const advance = glyphW + s.letterSpacing + (ch === " " ? s.wordSpacing : 0);
+        chars.push({ advStart: adv, advEnd: adv + advance, glyphW, ascent, fontSize: s.fontSize });
+        adv += advance;
+      }
+    }
+    if (el.children) for (const ch of el.children) walk(ch, s);
+  };
+  walk(node, rootStyleOf(node));
+  const width = adv;
+  const tlr = readAnimatable(alongPath == null ? void 0 : alongPath.textLength);
+  const tlv = tlr.kind === "animated" /* Animated */ ? Number((_a2 = tlr.keyframes[0]) == null ? void 0 : _a2.value) || 0 : tlr.kind === "static" /* Static */ ? Number(tlr.value) || 0 : 0;
+  const k = tlv > 0 && width > 0 ? tlv / width : 1;
+  const so = readAnimatable(alongPath == null ? void 0 : alongPath.startOffset);
+  const { along: alongOffset, perp } = alongPathNodeOffsets(node);
+  const base = alongOffset + (so.kind === "animated" /* Animated */ ? Number((_b = so.keyframes[0]) == null ? void 0 : _b.value) || 0 : so.kind === "static" /* Static */ ? Number(so.value) || 0 : 0);
+  const withPerp = (p) => ({
+    x: p.x - perp * Math.sin(p.angle),
+    y: p.y + perp * Math.cos(p.angle),
+    angle: p.angle
+  });
+  return chars.map((c) => {
+    const dStart = base + c.advStart * k;
+    const dEnd = base + c.advEnd * k;
+    const p0 = withPerp(sampler.sampleAtDistance(dStart));
+    const p1 = withPerp(sampler.sampleAtDistance(dEnd));
+    const glyphMid = sampler.sampleAtDistance(base + (c.advStart + c.glyphW / 2) * k);
+    return {
+      x: p0.x,
+      y: p0.y,
+      width: c.advEnd - c.advStart,
+      ascent: c.ascent,
+      fontSize: c.fontSize,
+      endX: p1.x,
+      endY: p1.y,
+      rotation: glyphMid.angle * 180 / Math.PI
+    };
+  });
+}
+function collectAlongPathCells(node, glyphs, soleFont, warnings) {
+  const cells = [];
+  let adv = 0;
+  const walk = (el, parentStyle) => {
+    var _a2, _b;
+    const s = resolveStyle(el, parentStyle);
+    const content = str(el[PX_TEXT_CONTENT_ATTR]);
+    if (content && !((_a2 = el.children) == null ? void 0 : _a2.length)) {
+      const gf = glyphFontFor(s, glyphs, soleFont, warnings);
+      if (gf) {
+        const scale = s.fontSize / gf.unitsPerEm;
+        const ascentEm = (_b = gf.ascent) != null ? _b : 0.9 * gf.unitsPerEm;
+        const paint = paintOf(s);
+        for (let i = 0; i < content.length; i++) {
+          const ch = content.charAt(i);
+          const g = gf.glyphs[ch];
+          if (g && g.pathData) {
+            const glyphAdv = g.width * scale;
+            cells.push({ glyphD: g.pathData, widthEm: g.width, scale, paint, midBase: adv + glyphAdv / 2 });
+            adv += glyphAdv;
+          } else if (/\S/.test(ch)) {
+            const wEm = g && g.width > 0 ? g.width : MISSING_GLYPH_ADVANCE_EM * gf.unitsPerEm;
+            const boxAdv = wEm * scale;
+            cells.push({ glyphD: missingGlyphBoxEm(wEm, ascentEm), widthEm: wEm, scale, paint, isMissing: true, midBase: adv + boxAdv / 2 });
+            adv += boxAdv;
+          } else {
+            adv += (g ? g.width : 0) * scale;
+          }
+          adv += s.letterSpacing + (ch === " " ? s.wordSpacing : 0);
+        }
+      }
+    }
+    if (el.children) for (const ch of el.children) walk(ch, s);
+  };
+  walk(node, rootStyleOf(node));
+  return { cells, width: adv };
+}
+function alongAffine(sampler, dist, scale, widthEm, perp = 0) {
+  const { x, y, angle } = sampler.sampleAtDistance(dist);
+  const cos = Math.cos(angle), sin = Math.sin(angle), hw = widthEm / 2;
+  return [scale * cos, scale * sin, -scale * sin, scale * cos, x - scale * cos * hw - perp * sin, y - scale * sin * hw + perp * cos];
+}
+function alongPathNodeOffsets(node) {
+  var _a2, _b, _c;
+  return {
+    along: ((_a2 = parseLen(node.x)) != null ? _a2 : 0) + ((_b = parseLen(node.dx)) != null ? _b : 0),
+    perp: (_c = parseLen(node.dy)) != null ? _c : 0
+  };
+}
+function materializeGlyphTextAlongPath(node, pathD, startOffset, opts, textLength, pathOverflow) {
+  const { glyphs, create = jsonElementFactory, warnings } = opts;
+  const sampler = pathD ? createPathSampler(pathD) : null;
+  if (!sampler) {
+    warnings == null ? void 0 : warnings.push("textGlyphs: unparsable along-path geometry");
+    return null;
+  }
+  const soleFont = soleFontOf(glyphs);
+  const { cells, width } = collectAlongPathCells(node, glyphs, soleFont, warnings);
+  if (!cells.length) return toGroup(node, [], create);
+  const { along: alongOffset, perp } = alongPathNodeOffsets(node);
+  const soTrack = numTrackOf(startOffset);
+  const tlTrack = numTrackOf(textLength);
+  const kOf = (tl) => tl > 0 && width > 0 ? tl / width : 1;
+  const isClip = pathOverflow === "clip" && !sampler.closed;
+  if (soTrack.animated || tlTrack.animated) {
+    const times = mergeTrackTimes(soTrack.times, tlTrack.times);
+    const distOf = (c, t) => alongOffset + soTrack.at(t) + kOf(tlTrack.at(t)) * c.midBase;
+    const loop = soTrack.animated ? soTrack.loop : tlTrack.loop;
+    return toGroup(node, buildAnimatedAlongPath(cells, sampler, distOf, times, loop, create, isClip, perp), create);
+  }
+  const k = kOf(tlTrack.at(0));
+  const base = alongOffset + soTrack.at(0);
+  const placeCells = isClip ? cells.filter((c) => {
+    const d = base + c.midBase * k;
+    return d >= 0 && d <= sampler.totalLength;
+  }) : cells;
+  const placements = placeCells.map((c) => ({
+    glyphD: c.glyphD,
+    paint: c.paint,
+    isMissing: c.isMissing,
+    m: alongAffine(sampler, base + c.midBase * k, c.scale, c.widthEm, perp)
+  }));
+  return toGroup(node, buildPaths(placements, create, warnings), create);
+}
+function numTrackOf(raw) {
+  var _a2;
+  const r = readAnimatable(raw);
+  if (r.kind === "animated" /* Animated */ && r.keyframes.length >= 2) {
+    const kfs = [...r.keyframes].sort((k1, k2) => (Number(k1.time) || 0) - (Number(k2.time) || 0));
+    const times = kfs.map((kf) => Number(kf.time) || 0);
+    const vals = kfs.map((kf) => Number(kf.value) || 0);
+    return {
+      animated: true,
+      times,
+      loop: r.loop,
+      at(t) {
+        if (t <= times[0]) return vals[0];
+        for (let i = 1; i < times.length; i++) {
+          if (t <= times[i]) {
+            const span = times[i] - times[i - 1];
+            const f = span > 0 ? (t - times[i - 1]) / span : 1;
+            return vals[i - 1] + f * (vals[i] - vals[i - 1]);
+          }
+        }
+        return vals[vals.length - 1];
+      }
+    };
+  }
+  const v = r.kind === "animated" /* Animated */ ? Number((_a2 = r.keyframes[0]) == null ? void 0 : _a2.value) || 0 : r.kind === "static" /* Static */ ? Number(r.value) || 0 : 0;
+  return { animated: false, times: [], at: () => v };
+}
+function mergeTrackTimes(a, b) {
+  const all = [...a, ...b].sort((t1, t2) => t1 - t2);
+  const out = [];
+  for (const t of all) if (!out.length || t !== out[out.length - 1]) out.push(t);
+  return out;
+}
+var ALONG_PATH_MAX_STEPS = 48;
+var ALONG_PATH_MAX_STEPS_PER_SEGMENT = 64;
+function roundN(v, n) {
+  const f = __pow(10, n);
+  return Math.round(v * f) / f;
+}
+function buildAnimatedAlongPath(cells, sampler, distOf, times, loop, create, isClip, perp = 0) {
+  const step = Math.max(sampler.totalLength / ALONG_PATH_MAX_STEPS, 0.5);
+  const onPath = (dist) => dist >= 0 && dist <= sampler.totalLength;
+  const out = [];
+  for (const c of cells) {
+    const centered = [c.scale, 0, 0, c.scale, -c.scale * (c.widthEm / 2), 0];
+    const d = transformPathData(c.glyphD, centered);
+    const sampleKf = (dist, time) => {
+      const { x, y, angle } = sampler.sampleAtDistance(dist);
+      const cos = Math.cos(angle), sin = Math.sin(angle);
+      return {
+        time,
+        value: {
+          ["translate" /* Translate */]: [roundN(x - perp * sin, 3), roundN(y + perp * cos, 3)],
+          ["rotate" /* Rotate */]: roundN(angle * 180 / Math.PI, 3)
+        }
+      };
+    };
+    const kfs = [];
+    const opKfs = [];
+    const pushKf = (dist, time) => {
+      kfs.push(sampleKf(dist, time));
+      if (isClip) opKfs.push({ time, value: onPath(dist) ? 1 : 0 });
+    };
+    pushKf(distOf(c, times[0]), times[0]);
+    for (let k = 1; k < times.length; k++) {
+      const t0 = times[k - 1], t1 = times[k];
+      const d0 = distOf(c, t0), d1 = distOf(c, t1);
+      const n = Math.min(ALONG_PATH_MAX_STEPS_PER_SEGMENT, Math.max(1, Math.ceil(Math.abs(d1 - d0) / step)));
+      for (let s = 1; s <= n; s++) {
+        const f = s / n;
+        const t = t0 + f * (t1 - t0);
+        pushKf(distOf(c, t), t);
+      }
+    }
+    unwrapAutoOrientRotations(kfs);
+    const transform = { keyframes: kfs };
+    if (loop !== void 0) transform.loop = loop;
+    const animate = { transform };
+    if (c.paint.animate) Object.assign(animate, c.paint.animate);
+    if (isClip && opKfs.some((k) => k.value === 0)) {
+      const op = { keyframes: opKfs };
+      if (loop !== void 0) op.loop = loop;
+      animate.opacity = op;
+    }
+    out.push(create("path", __spreadProps(__spreadValues(__spreadValues({ d }, paintProps(c.paint)), missingGlyphProps(c.isMissing)), { animate }), []));
+  }
+  return out;
+}
+function paintProps(paint) {
+  const p = {};
+  if (paint.fill !== void 0) p.fill = paint.fill;
+  if (paint.stroke !== void 0) p.stroke = paint.stroke;
+  if (paint.strokeWidth !== void 0) p.strokeWidth = paint.strokeWidth;
+  if (paint.opacity !== void 0) p.opacity = paint.opacity;
+  for (const key of PAINT_STATIC_KEYS) {
+    if (paint[key] !== void 0) p[key] = paint[key];
+  }
+  return p;
+}
+function missingGlyphProps(isMissing) {
+  return isMissing ? { [CLASS_ATTR]: MISSING_GLYPH_CLASS_NAME } : {};
+}
+function buildPaths(placements, create, warnings) {
+  if (!placements.length) {
+    warnings == null ? void 0 : warnings.push("textGlyphs: nothing to render");
+    return [];
+  }
+  const byPaint = /* @__PURE__ */ new Map();
+  for (const p of placements) {
+    const key = JSON.stringify([p.paint, !!p.isMissing]);
+    const baked = transformPathData(p.glyphD, p.m);
+    const entry = byPaint.get(key);
+    if (entry) entry.d += baked;
+    else byPaint.set(key, { paint: p.paint, d: baked, isMissing: p.isMissing });
+  }
+  const out = [];
+  for (const { paint, d, isMissing } of byPaint.values()) {
+    out.push(create("path", __spreadValues(__spreadValues(__spreadValues({
+      d
+    }, paintProps(paint)), missingGlyphProps(isMissing)), paint.animate !== void 0 ? { animate: __spreadValues({}, paint.animate) } : {}), []));
+  }
+  return out;
+}
+function toGroup(node, children, create) {
+  const gProps = {};
+  for (const k of Object.keys(node)) {
+    if (k === "type" || k === "children" || TEXT_ATTR_KEYS.indexOf(k) !== -1) continue;
+    gProps[k] = node[k];
+  }
+  if (gProps.style && typeof gProps.style === "object") {
+    const style = __spreadValues({}, gProps.style);
+    delete style["white-space"];
+    if (Object.keys(style).length) gProps.style = style;
+    else delete gProps.style;
+  }
+  return create("g", gProps, children);
+}
+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);
+}
+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 materializeGlyphTextHorizontal(node, { glyphs: ctx.glyphs, warnings: ctx.warnings });
+}
+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/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"
+};
+function asError(error) {
+  return typeof error === "string" ? new Error(error) : error;
+}
+function createDiagnostics(config, prefix) {
+  const tag = prefix ? prefix + " " : "";
+  return {
+    warn: (kind, message, detail) => {
+      if (config == null ? void 0 : config.onWarn) {
+        config.onWarn({ kind, message, detail });
+        return;
+      }
+      if (config == null ? void 0 : config.muteWarn) return;
+      const line = tag + kind + ": " + message;
+      if (detail === void 0) console.warn(line);
+      else console.warn(line, detail);
+    },
+    error: (kind, error, detail) => {
+      const err = asError(error);
+      if (config == null ? void 0 : config.onError) {
+        config.onError({ kind, message: err.message, error: err, detail });
+        return;
+      }
+      if (config == null ? void 0 : config.muteError) return;
+      const line = tag + kind + ": " + err.message;
+      if (detail === void 0) console.error(line);
+      else console.error(line, detail);
+    }
+  };
+}
+
+// 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."
+  );
+}
+
+export {
+  __spreadValues,
+  __spreadProps,
+  PX_UNKNOWN_KEY_ERROR,
+  schemaKeys,
+  describeSchema,
+  px,
+  PX_WIRE_SCHEMA_VERSION,
+  PX_WIRE_VERSION_KEY,
+  PxWireVersionRelation,
+  parseWireVersion,
+  formatWireVersion,
+  PX_WIRE_VERSION,
+  readWireVersion,
+  compareWireVersion,
+  wireVersionAdvice,
+  PxWireStepKind,
+  PX_WIRE_BASELINE_VERSION,
+  PX_WIRE_STEPS,
+  applyWireSteps,
+  convertWireDocument,
+  downgradeWireDocument,
+  PxFillMode,
+  PxPlaybackDirection,
+  PX_ANIM_SRC_ATTR_NAME,
+  PX_ANIM_ATTR_NAME,
+  PxStartOn,
+  PxOutAction,
+  PxFinishAction,
+  PxScrollKind,
+  PxScrollAxis,
+  PxScrollSource,
+  PxPinAlign,
+  PxScrollPhase,
+  PxAlongPathMode,
+  PX_TIMELINE_SHARED_KEYS,
+  PX_TIME_ONLY_TIMELINE_KEYS,
+  PxTimelineEngine,
+  PxTimelineEngineSetting,
+  resolveTimelineEngine,
+  isNativeForced,
+  mayUseNativeScrollTimeline,
+  PX_TRIGGER_DEFAULTS,
+  PxControlMode,
+  resolveControlMode,
+  controlModeTakesOverTrigger,
+  resolveTrigger,
+  PxLoopRepeatAt,
+  PxLoopDirection,
+  PxMaskType,
+  PxUnits,
+  PxCloneWithout,
+  PxPathOverflow,
+  PxLengthAdjust,
+  PxTextPathMethod,
+  PxTextPathSpacing,
+  PxStrokeTrimSubPaths,
+  PX_TEXT_CONTENT_ATTR,
+  TRANSFORM_ATTR,
+  OFFSET_DISTANCE_ATTR,
+  TRANSFORM_PART,
+  PX_TRANSFORM_PART_KEYS,
+  PxGradientSpreadMethod,
+  PxGradientType,
+  isPxDocument,
+  getAnimatorConfig,
+  flattenAnimatorTimeline,
+  nestAnimatorTimeline,
+  getDefinitions,
+  getBindings,
+  getChildren,
+  PxKeyframeValueSchema,
+  PxKeyframeSchema,
+  keyframeTime,
+  keyframeValue,
+  keyframeEasing,
+  keyframeTangentIn,
+  keyframeTangentOut,
+  PxLoopSchema,
+  PxPropertyAnimationSchema,
+  PxTransformPartsSchema,
+  PxTransformValueSchema,
+  PxElementAnimationSchema,
+  PxTriggerSchema,
+  PxDefinitionsSchema,
+  PxScrollRangePointSchema,
+  PxScrollRangeSchema,
+  PxScrollSchema,
+  PxTimelineSchema,
+  PxAnimatorConfigSchema,
+  PxAttrValueSchema,
+  PxTransformByEffectSchema,
+  PxRepeaterEffectSchema,
+  PxMaskedByEffectSchema,
+  PxClipPathEffectSchema,
+  PxStrokeTrimEffectSchema,
+  PxRetimeEffectSchema,
+  PxCloneEffectSchema,
+  PxGradientStopSchema,
+  PxFillGradientEffectSchema,
+  PxTextPathEffectSchema,
+  PxTextEffectSchema,
+  PxEffectsSchema,
+  validateNodeEffects,
+  validateDocument,
+  PxNodeBaseSchema,
+  PxNodeSchema,
+  PxSvgNodeRootSchema,
+  PxAnimatedSvgDocumentSchema,
+  PxBezierPathSchema,
+  isValidPxDocument,
+  generateUniqueId,
+  deepClone,
+  generateNewIds,
+  bezierToSvgPath,
+  cubicBezier,
+  subdivideCubicBezier,
+  splitEasing,
+  reverseEasing,
+  toRGBA,
+  PX_COLOR_ATTR_NAMES,
+  PX_TRANSFORM_FN_NAMES,
+  PX_PCT_BASED_ATTR_NAMES,
+  composeTransformParts,
+  PX_STYLE_ATTR_NAMES,
+  PX_DEFAULT_DURATION_MS,
+  kebabToCamelCaseWord,
+  camelCaseToKebabWordIfNeeded,
+  clamp,
+  bezier2D_arcLengthLUT,
+  PX_DISALLOWED_SVG_TAGS_LOWER,
+  PX_CSS_ONLY_STYLE_PROPS,
+  sanitizeAttributeValue,
+  toDomProps,
+  materializeMotionPathInPropAnim,
+  materializeMotionPathsInTree,
+  PX_LOOP_JUMP_SHIFT_MS,
+  parseSvgPathToBezier,
+  interpolateValue,
+  materializeInternalLoopsInTree,
+  mergeStaticTransformIntoAnimDef,
+  normalizeBindings,
+  calcAnimationValues,
+  partsRecord,
+  readAnimatable,
+  writeAnimatableChannel,
+  readStaticOrigin,
+  keyframeWith,
+  deepClonePxNode,
+  regenerateIdsAndRewriteRefs,
+  applyUseOffsetToG,
+  genId,
+  stripHash,
+  indexById,
+  spliceDefs,
+  clone,
+  regenerateIdsInClone,
+  createPathSampler,
+  extendedPathForBrowser,
+  applyTextPathEffect,
+  layoutGlyphTextChars,
+  materializeGlyphTextAlongPath,
+  materializeGlyphText,
+  applyTextGlyphsEffect,
+  applyTextGlyphsAlongPath,
+  PxDiagnosticKind,
+  createDiagnostics,
+  diagnoseDocument,
+  reportDocumentDiagnostics
+};
+//# sourceMappingURL=chunk-L6GJ6Y2M.js.map