@pixodesk/svg-animator-core 1.0.39 → 1.0.41

package/dist/internal.cjs

@@ -0,0 +1,3513 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  PX_ANIM_ATTR_NAME: () => PX_ANIM_ATTR_NAME,
+  PX_ANIM_SRC_ATTR_NAME: () => PX_ANIM_SRC_ATTR_NAME,
+  PX_COLOR_ATTR_NAMES: () => PX_COLOR_ATTR_NAMES,
+  PX_CSS_ONLY_STYLE_PROPS: () => PX_CSS_ONLY_STYLE_PROPS,
+  PX_DEFAULT_DURATION_MS: () => PX_DEFAULT_DURATION_MS,
+  PX_DISALLOWED_SVG_TAGS_LOWER: () => PX_DISALLOWED_SVG_TAGS_LOWER,
+  PX_LOOP_JUMP_SHIFT_MS: () => PX_LOOP_JUMP_SHIFT_MS,
+  PX_PCT_BASED_ATTR_NAMES: () => PX_PCT_BASED_ATTR_NAMES,
+  PX_STYLE_ATTR_NAMES: () => PX_STYLE_ATTR_NAMES,
+  PX_TEXT_CONTENT_ATTR: () => PX_TEXT_CONTENT_ATTR,
+  PX_TRANSFORM_FN_NAMES: () => PX_TRANSFORM_FN_NAMES,
+  PX_UNKNOWN_KEY_ERROR: () => PX_UNKNOWN_KEY_ERROR,
+  bezierToSvgPath: () => bezierToSvgPath,
+  camelCaseToKebabWordIfNeeded: () => camelCaseToKebabWordIfNeeded,
+  clamp: () => clamp,
+  composeTransformParts: () => composeTransformParts,
+  createDiagnostics: () => createDiagnostics,
+  createPathSampler: () => createPathSampler,
+  cubicBezier: () => cubicBezier,
+  deepClone: () => deepClone,
+  diffFieldUniverse: () => diffFieldUniverse,
+  diffInEffect: () => diffInEffect,
+  extendedPathForBrowser: () => extendedPathForBrowser,
+  generateUniqueId: () => generateUniqueId,
+  interpolateValue: () => interpolateValue,
+  isScrollTimeline: () => isScrollTimeline,
+  kebabToCamelCaseWord: () => kebabToCamelCaseWord,
+  keyframeEasing: () => keyframeEasing,
+  keyframeValue: () => keyframeValue,
+  layoutGlyphTextChars: () => layoutGlyphTextChars,
+  materializeGlyphText: () => materializeGlyphText,
+  materializeGlyphTextAlongPath: () => materializeGlyphTextAlongPath,
+  materializeMotionPathInPropAnim: () => materializeMotionPathInPropAnim,
+  mergeStaticTransformIntoAnimDef: () => mergeStaticTransformIntoAnimDef,
+  planSchemaRelease: () => planSchemaRelease,
+  releaseLogProblems: () => releaseLogProblems,
+  reportDocumentDiagnostics: () => reportDocumentDiagnostics,
+  reverseEasing: () => reverseEasing,
+  sanitizeAttributeValue: () => sanitizeAttributeValue,
+  schemaFieldUniverse: () => schemaFieldUniverse,
+  scrollOffsetProgress: () => scrollOffsetProgress,
+  scrollPhaseInterval: () => scrollPhaseInterval,
+  scrollResolveAxis: () => scrollResolveAxis,
+  scrollTotalDurationMs: () => scrollTotalDurationMs,
+  scrollViewProgress: () => scrollViewProgress,
+  splitEasing: () => splitEasing,
+  subdivideCubicBezier: () => subdivideCubicBezier,
+  toRGBA: () => toRGBA
+});
+module.exports = __toCommonJS(internal_exports);
+
+// 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 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/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"
+});
+var PX_TRIGGER_DEFAULTS = {
+  startOn: "load",
+  outAction: "continue",
+  scrollIntoViewThreshold: 0
+};
+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 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 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;
+}
+
+// src/version/PxSchemaVersion.ts
+var PX_WIRE_SCHEMA_VERSION = "1.1";
+
+// src/version/PxWireVersion.ts
+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]) };
+}
+var _a;
+var PX_WIRE_VERSION = (_a = parseWireVersion(PX_WIRE_SCHEMA_VERSION)) != null ? _a : { a: 1, b: 1, c: 0 };
+
+// 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()
+}));
+
+// 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 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 + ")";
+}
+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;
+}
+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/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;
+}
+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);
+}
+
+// src/animation/PxDefinitions.ts
+var PX_LOOP_JUMP_SHIFT_MS = 1;
+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 mergeStaticTransformIntoAnimDef(animDef, staticTransform) {
+  if (!animDef) return animDef;
+  const staticParts = staticTransform && typeof staticTransform === "object" && !Array.isArray(staticTransform) ? staticTransform : parseTransformParts(staticTransform);
+  if (!staticParts || !Object.keys(staticParts).length) return animDef;
+  const mergeKfValue = (v) => v && typeof v === "object" && !Array.isArray(v) ? __spreadValues(__spreadValues({}, staticParts), v) : v;
+  const transformAnim = animDef[TRANSFORM_ATTR];
+  if (transformAnim && typeof transformAnim === "object") {
+    const anim = transformAnim;
+    if (Array.isArray(anim.keyframes)) {
+      const out = __spreadProps(__spreadValues({}, anim), {
+        keyframes: anim.keyframes.map((kf) => __spreadProps(__spreadValues({}, kf), { value: mergeKfValue(kf.value) }))
+      });
+      if (out.value !== void 0) out.value = mergeKfValue(out.value);
+      return __spreadProps(__spreadValues({}, animDef), { transform: out });
+    }
+    return animDef;
+  }
+  const channels = Object.keys(animDef).filter((k) => PX_TRANSFORM_FN_NAMES.has(k));
+  if (channels.length !== 1) return animDef;
+  const ch = channels[0];
+  const chAnim = animDef[ch];
+  if (!chAnim || typeof chAnim !== "object" || !Array.isArray(chAnim.keyframes)) return animDef;
+  const lifted = __spreadProps(__spreadValues({}, chAnim), {
+    keyframes: chAnim.keyframes.map((kf) => __spreadProps(__spreadValues({}, kf), { value: __spreadProps(__spreadValues({}, staticParts), { [ch]: kf.value }) }))
+  });
+  if (lifted.value !== void 0) lifted.value = __spreadProps(__spreadValues({}, staticParts), { [ch]: lifted.value });
+  const rest = __spreadValues({}, animDef);
+  delete rest[ch];
+  return __spreadProps(__spreadValues({}, rest), { transform: lifted });
+}
+
+// src/effects/PlayerEffectsUtil.visualModel.ts
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+function mul(m, n) {
+  return [
+    m[0] * n[0] + m[2] * n[1],
+    m[1] * n[0] + m[3] * n[1],
+    m[0] * n[2] + m[2] * n[3],
+    m[1] * n[2] + m[3] * n[3],
+    m[0] * n[4] + m[2] * n[5] + m[4],
+    m[1] * n[4] + m[3] * n[5] + m[5]
+  ];
+}
+var translateM = (x, y) => [1, 0, 0, 1, x, y];
+var scaleM = (sx, sy) => [sx, 0, 0, sy, 0, 0];
+function rotateM(deg) {
+  const r = deg * Math.PI / 180;
+  return [Math.cos(r), Math.sin(r), -Math.sin(r), Math.cos(r), 0, 0];
+}
+var skewXM = (deg) => [1, 0, Math.tan(deg * Math.PI / 180), 1, 0, 0];
+var skewYM = (deg) => [1, Math.tan(deg * Math.PI / 180), 0, 1, 0, 0];
+function parseTransformString(s) {
+  let m = IDENTITY;
+  const re = /(translate|rotate|scale|matrix|skewX|skewY)\(([^)]*)\)/g;
+  let hit;
+  while (hit = re.exec(s)) {
+    const fn = hit[1];
+    const a = hit[2].split(/[\s,]+/).filter(Boolean).map(Number);
+    if (fn === "translate") m = mul(m, translateM(a[0] || 0, a[1] || 0));
+    else if (fn === "scale") m = mul(m, scaleM(a[0], a.length > 1 ? a[1] : a[0]));
+    else if (fn === "rotate") m = mul(m, rotateM(a[0]));
+    else if (fn === "skewX") m = mul(m, skewXM(a[0]));
+    else if (fn === "skewY") m = mul(m, skewYM(a[0]));
+    else if (fn === "matrix") m = mul(m, [a[0], a[1], a[2], a[3], a[4], a[5]]);
+  }
+  return m;
+}
+function partsToMatrix(p) {
+  let m = IDENTITY;
+  if (p.translate) m = mul(m, translateM(p.translate[0], p.translate[1]));
+  const pivot = p.origin && (p.rotate !== void 0 || p.scale);
+  if (pivot) m = mul(m, translateM(p.origin[0], p.origin[1]));
+  if (p.rotate !== void 0) m = mul(m, rotateM(p.rotate));
+  if (p.scale) m = mul(m, scaleM(p.scale[0], p.scale[1]));
+  if (pivot) m = mul(m, translateM(-p.origin[0], -p.origin[1]));
+  return m;
+}
+function lerp(a, b, f) {
+  return a + (b - a) * f;
+}
+function interpParts(kfs, t) {
+  var _a2, _b, _c, _d, _e, _f, _g;
+  if (!kfs.length) return {};
+  if (t <= ((_a2 = kfs[0].time) != null ? _a2 : 0)) return kfs[0].value || {};
+  if (t >= ((_b = kfs[kfs.length - 1].time) != null ? _b : 0)) return kfs[kfs.length - 1].value || {};
+  let i = 0;
+  while (i < kfs.length - 1 && ((_c = kfs[i + 1].time) != null ? _c : 0) < t) i++;
+  const a = kfs[i], b = kfs[i + 1];
+  const f = (t - ((_d = a.time) != null ? _d : 0)) / (((_e = b.time) != null ? _e : 0) - ((_f = a.time) != null ? _f : 0) || 1);
+  const va = a.value || {}, vb = b.value || {};
+  const out = {};
+  if (va.translate && vb.translate) out.translate = [lerp(va.translate[0], vb.translate[0], f), lerp(va.translate[1], vb.translate[1], f)];
+  else out.translate = va.translate || vb.translate;
+  if (va.rotate !== void 0 && vb.rotate !== void 0) out.rotate = lerp(va.rotate, vb.rotate, f);
+  else out.rotate = (_g = va.rotate) != null ? _g : vb.rotate;
+  if (va.scale && vb.scale) out.scale = [lerp(va.scale[0], vb.scale[0], f), lerp(va.scale[1], vb.scale[1], f)];
+  else out.scale = va.scale || vb.scale;
+  out.origin = va.origin || vb.origin;
+  return out;
+}
+function evalTransformValue(v, t) {
+  if (v === void 0 || v === null) return IDENTITY;
+  if (typeof v === "string") return parseTransformString(v);
+  if (v.keyframes) return partsToMatrix(interpParts(v.keyframes, t));
+  if (v.value) return partsToMatrix(v.value);
+  if (typeof v === "object" && !Array.isArray(v)) return partsToMatrix(v);
+  return IDENTITY;
+}
+function nodeMatrix(node, t) {
+  if (node.animate && node.animate.transform) return evalTransformValue(node.animate.transform, t);
+  if (node.transform !== void 0) return evalTransformValue(node.transform, t);
+  return IDENTITY;
+}
+function evalScalar(animated, staticVal, fallback, t) {
+  var _a2, _b, _c, _d, _e, _f;
+  if (animated && animated.keyframes && animated.keyframes.length) {
+    const kfs = animated.keyframes;
+    if (t <= ((_a2 = kfs[0].time) != null ? _a2 : 0)) return kfs[0].value;
+    if (t >= ((_b = kfs[kfs.length - 1].time) != null ? _b : 0)) return kfs[kfs.length - 1].value;
+    let i = 0;
+    while (i < kfs.length - 1 && ((_c = kfs[i + 1].time) != null ? _c : 0) < t) i++;
+    const a = kfs[i], b = kfs[i + 1];
+    const f = (t - ((_d = a.time) != null ? _d : 0)) / (((_e = b.time) != null ? _e : 0) - ((_f = a.time) != null ? _f : 0) || 1);
+    return lerp(a.value, b.value, f);
+  }
+  return staticVal !== void 0 ? Number(staticVal) : fallback;
+}
+var CONTAINER_TYPES = /* @__PURE__ */ new Set(["svg", "g", "symbol"]);
+var SKIP_TYPES = /* @__PURE__ */ new Set(["defs", "mask", "clipPath", "title"]);
+function buildIdMap(node, map) {
+  var _a2;
+  if (typeof node.id === "string") map.set(node.id, node);
+  (_a2 = node.children) == null ? void 0 : _a2.forEach((c) => buildIdMap(c, map));
+}
+function num(v) {
+  return v === void 0 || v === null ? 0 : Number(v);
+}
+function round(n) {
+  return Math.round(n * 100) / 100 + 0;
+}
+function geomKey(node) {
+  var _a2;
+  switch (node.type) {
+    case "rect":
+      return num(node.width) + "," + num(node.height) + "," + num(node.x) + "," + num(node.y);
+    case "ellipse":
+      return num(node.rx) + "," + num(node.ry) + "," + num(node.cx) + "," + num(node.cy);
+    case "circle":
+      return num(node.r) + "," + num(node.cx) + "," + num(node.cy);
+    case "path":
+      return String((_a2 = node.d) != null ? _a2 : "");
+    default:
+      return "";
+  }
+}
+function describePrimitive(node, m, t) {
+  var _a2, _b, _c, _d, _e;
+  const fill = (_a2 = node.fill) != null ? _a2 : "";
+  const stroke = (_b = node.stroke) != null ? _b : "";
+  const sw = (_d = (_c = node["stroke-width"]) != null ? _c : node.strokeWidth) != null ? _d : "";
+  const opacity = round(evalScalar((_e = node.animate) == null ? void 0 : _e.opacity, node.opacity, 1, t));
+  const masked = node.mask ? 1 : 0;
+  const mat = m.map(round).join(",");
+  return node.type + "|" + geomKey(node) + "|[" + mat + "]|f:" + fill + "|s:" + stroke + "|sw:" + (num(sw) || "") + "|o:" + opacity + "|m:" + masked;
+}
+function flatten(node, parent, t, idMap, out) {
+  var _a2;
+  const type = node.type || "";
+  if (SKIP_TYPES.has(type)) return;
+  const m = mul(parent, nodeMatrix(node, t));
+  if (type === "use") {
+    const targetId = typeof node.href === "string" ? node.href.replace(/^#/, "") : "";
+    const target = idMap.get(targetId);
+    const useM = mul(m, translateM(num(node.x), num(node.y)));
+    if (target) flatten(target, useM, t, idMap, out);
+    else out.push("UNRESOLVED_USE:#" + targetId);
+    return;
+  }
+  if (CONTAINER_TYPES.has(type)) {
+    (_a2 = node.children) == null ? void 0 : _a2.forEach((c) => flatten(c, m, t, idMap, out));
+    return;
+  }
+  out.push(describePrimitive(node, m, t));
+}
+function collectSampleTimes(node, into) {
+  var _a2;
+  into.add(0);
+  const scanAnim = (anim) => {
+    var _a3;
+    if (!anim || typeof anim !== "object") return;
+    for (const key of Object.keys(anim)) {
+      const kfs = (_a3 = anim[key]) == null ? void 0 : _a3.keyframes;
+      if (Array.isArray(kfs)) kfs.forEach((kf) => {
+        var _a4;
+        return into.add((_a4 = kf.time) != null ? _a4 : 0);
+      });
+    }
+  };
+  scanAnim(node.animate);
+  if (node.transform && typeof node.transform === "object" && node.transform.keyframes) {
+    node.transform.keyframes.forEach((kf) => {
+      var _a3;
+      return into.add((_a3 = kf.time) != null ? _a3 : 0);
+    });
+  }
+  (_a2 = node.children) == null ? void 0 : _a2.forEach((c) => collectSampleTimes(c, into));
+}
+function visualModelAt(root, t) {
+  const idMap = /* @__PURE__ */ new Map();
+  buildIdMap(root, idMap);
+  const out = [];
+  flatten(root, IDENTITY, t, idMap, out);
+  return out.sort();
+}
+function diffInEffect(a, b) {
+  const times = /* @__PURE__ */ new Set();
+  collectSampleTimes(a, times);
+  collectSampleTimes(b, times);
+  const diffs = [];
+  for (const t of Array.from(times).sort((x, y) => x - y)) {
+    const ma = visualModelAt(a, t);
+    const mb = visualModelAt(b, t);
+    const onlyInA = subtractMultiset(ma, mb);
+    const onlyInB = subtractMultiset(mb, ma);
+    if (onlyInA.length || onlyInB.length) diffs.push({ time: t, onlyInA, onlyInB });
+  }
+  return diffs;
+}
+function subtractMultiset(a, b) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const x of b) counts.set(x, (counts.get(x) || 0) + 1);
+  const extra = [];
+  for (const x of a) {
+    const c = counts.get(x) || 0;
+    if (c > 0) counts.set(x, c - 1);
+    else extra.push(x);
+  }
+  return extra;
+}
+
+// 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 num2 = () => 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 = num2() + (rel ? cx : 0), y = num2() + (rel ? cy : 0);
+      cx = x;
+      cy = y;
+      sx = x;
+      sy = y;
+      prevCmd = cmd;
+      continue;
+    }
+    if (U === "L") {
+      pushLine(num2() + (rel ? cx : 0), num2() + (rel ? cy : 0));
+    } else if (U === "H") {
+      pushLine(num2() + (rel ? cx : 0), cy);
+    } else if (U === "V") {
+      pushLine(cx, num2() + (rel ? cy : 0));
+    } else if (U === "C") {
+      const p1 = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+      const p2 = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+      const p3 = [num2() + (rel ? cx : 0), num2() + (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 = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+      const p3 = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+      pcx = p2[0];
+      pcy = p2[1];
+      push(p1, p2, p3);
+    } else if (U === "Q") {
+      const qc = [num2() + (rel ? cx : 0), num2() + (rel ? cy : 0)];
+      const p3 = [num2() + (rel ? cx : 0), num2() + (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 = [num2() + (rel ? cx : 0), num2() + (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(num2() + (rel ? cx : 0), num2() + (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/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 num2 = () => parseFloat(tokens[i++]);
+  while (i < tokens.length) {
+    const cmd = tokens[i++];
+    if (cmd === "M" || cmd === "L") {
+      const [x, y] = apply(m, num2(), num2());
+      out += cmd + pack([x, y], decimals);
+    } else if (cmd === "C") {
+      const [x1, y1] = apply(m, num2(), num2());
+      const [x2, y2] = apply(m, num2(), num2());
+      const [x, y] = apply(m, num2(), num2());
+      out += "C" + pack([x1, y1, x2, y2, x, y], decimals);
+    } else if (cmd === "Q") {
+      const [x1, y1] = apply(m, num2(), num2());
+      const [x, y] = apply(m, num2(), num2());
+      out += "Q" + pack([x1, y1, x, y], decimals);
+    } else if (cmd === "Z" || cmd === "z") {
+      out += "Z";
+    }
+  }
+  return out;
+}
+
+// src/effects/shared/transformParts.ts
+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 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;
+}
+
+// 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);
+}
+
+// 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 };
+}
+var r3 = (n) => Math.round(n * 1e3) / 1e3;
+function extendedPathForBrowser(pathD, opts) {
+  var _a2;
+  if (opts.pathOverflow === "clip") return { d: pathD, startShift: 0 };
+  const sampler = createPathSampler(pathD);
+  if (!sampler || sampler.closed || sampler.totalLength <= 0) return { d: pathD, startShift: 0 };
+  const L = sampler.totalLength;
+  const margin = EXTEND_MARGIN_FRAC * L;
+  const so = numRange(opts.startOffset);
+  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 };
+}
+
+// src/format/PxDocumentDiagnostic.ts
+var MAX_REPORTED = 6;
+function diagnoseDocument(doc) {
+  try {
+    return { problems: validateDocument(doc) };
+  } catch (e) {
+    return { problems: [] };
+  }
+}
+function reportDocumentDiagnostics(doc, where) {
+  const { problems } = diagnoseDocument(doc);
+  if (!problems.length) return;
+  const shown = problems.slice(0, MAX_REPORTED);
+  const more = problems.length - shown.length;
+  console.warn(
+    where + ": this document does not match the animation schema in " + problems.length + " place" + (problems.length === 1 ? "" : "s") + ".\n" + shown.map((p) => "  - " + p).join("\n") + (more > 0 ? "\n  \u2026 and " + more + " more" : "") + "\n\nIf you did not author these keys, the usual cause is a build that MANGLES PROPERTY NAMES. An animation document is data loaded at runtime, so renaming the property reads inside the player stops them matching the keys in the JSON, and the animation silently does nothing. Feed the published reserved-name list to your minifier \u2014 @pixodesk/svg-animator-web/mangle-reserved.json \u2014 see docs/library/minification.md."
+  );
+}
+
+// src/playback/PxDiagnostics.ts
+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/playback/PxScrollMath.ts
+function isScrollTimeline(config) {
+  return (config == null ? void 0 : config.timelineSource) === "scroll";
+}
+function scrollTotalDurationMs(config) {
+  const duration = typeof (config == null ? void 0 : config.duration) === "number" && config.duration > 0 ? config.duration : PX_DEFAULT_DURATION_MS;
+  const iterations = typeof (config == null ? void 0 : config.iterations) === "number" && config.iterations > 0 ? config.iterations : 1;
+  return duration * iterations;
+}
+function scrollPhaseInterval(phase, subjectSize, scrollportSize) {
+  const s = subjectSize, vp = scrollportSize;
+  switch (phase) {
+    case "cover":
+      return [0, s + vp];
+    case "entry":
+      return [0, Math.min(s, vp)];
+    case "contain":
+      return [Math.min(s, vp), Math.max(s, vp)];
+    case "exit":
+      return [Math.max(s, vp), s + vp];
+    case "entry-crossing":
+      return [0, s];
+    case "exit-crossing":
+      return [vp, s + vp];
+  }
+}
+var DEFAULT_PHASE = "cover";
+function resolveRangePointU(point, defaultFraction, subjectSize, scrollportSize) {
+  var _a2;
+  const [u0, u1] = scrollPhaseInterval((_a2 = point == null ? void 0 : point.phase) != null ? _a2 : DEFAULT_PHASE, subjectSize, scrollportSize);
+  const fraction = typeof (point == null ? void 0 : point.fraction) === "number" ? point.fraction : defaultFraction;
+  return u0 + fraction * (u1 - u0);
+}
+function scrollViewProgress(subjectStart, subjectSize, scrollportSize, range) {
+  const u = scrollportSize - subjectStart;
+  const uStart = resolveRangePointU(range == null ? void 0 : range.start, 0, subjectSize, scrollportSize);
+  const uEnd = resolveRangePointU(range == null ? void 0 : range.end, 1, subjectSize, scrollportSize);
+  if (uEnd <= uStart) return u >= uEnd ? 1 : 0;
+  return clamp((u - uStart) / (uEnd - uStart), 0, 1);
+}
+function scrollOffsetProgress(offset, maxOffset, range) {
+  var _a2, _b;
+  const raw = maxOffset > 0 ? clamp(offset / maxOffset, 0, 1) : 1;
+  const start = typeof ((_a2 = range == null ? void 0 : range.start) == null ? void 0 : _a2.fraction) === "number" ? range.start.fraction : 0;
+  const end = typeof ((_b = range == null ? void 0 : range.end) == null ? void 0 : _b.fraction) === "number" ? range.end.fraction : 1;
+  if (end <= start) return raw >= end ? 1 : 0;
+  return clamp((raw - start) / (end - start), 0, 1);
+}
+function scrollResolveAxis(axis, writingMode) {
+  const a = axis != null ? axis : "block";
+  if (a === "x" || a === "y") return a;
+  const vertical = !!writingMode && writingMode.startsWith("vertical");
+  if (a === "inline") return vertical ? "y" : "x";
+  return vertical ? "x" : "y";
+}
+
+// src/util/PxIdUtil.ts
+var _idCounter = 0;
+function generateUniqueId() {
+  const timestamp = Date.now().toString(36);
+  const counter = (++_idCounter).toString(36);
+  const random = Math.random().toString(36).substring(2, 6);
+  return "_px_" + timestamp + counter + random;
+}
+function deepClone(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((item) => deepClone(item));
+  const obj = value;
+  const cloned = {};
+  for (const key of Object.keys(obj)) {
+    cloned[key] = deepClone(obj[key]);
+  }
+  return cloned;
+}
+
+// src/util/PxNodeProps.ts
+var PX_DISALLOWED_SVG_TAGS_LOWER = /* @__PURE__ */ new Set([
+  "script",
+  "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;
+}
+
+// src/version/PxSchemaFieldUniverse.ts
+function schemaFieldUniverse(root) {
+  const fields = /* @__PURE__ */ new Set();
+  const enumerated = /* @__PURE__ */ new Set();
+  const queue = [{ schema: root, path: "" }];
+  while (queue.length) {
+    const { schema, path } = queue.shift();
+    const d = describeSchema(schema);
+    switch (d.kind) {
+      case "shape": {
+        if (enumerated.has(schema)) break;
+        enumerated.add(schema);
+        for (const key of Object.keys(d.shape)) {
+          const id = path ? path + "." + key : key;
+          fields.add(id);
+          queue.push({ schema: d.shape[key], path: id });
+        }
+        if (d.openValue) queue.push({ schema: d.openValue, path: path + "{*}" });
+        break;
+      }
+      case "optional":
+        queue.push({ schema: d.inner, path });
+        break;
+      case "array":
+        queue.push({ schema: d.item, path: path + "[]" });
+        break;
+      case "lazy":
+        queue.push({ schema: d.resolved, path });
+        break;
+      case "record":
+        queue.push({ schema: d.value, path: path + "{*}" });
+        break;
+      case "union":
+        d.members.forEach((member, i) => queue.push({ schema: member, path: path + "|" + i }));
+        break;
+      case "discriminatedUnion":
+        for (const member of d.members) queue.push({ schema: member, path: path + "|" + discriminantOf(member, d.key) });
+        break;
+      default:
+        break;
+    }
+  }
+  return [...fields].sort();
+}
+function discriminantOf(member, key) {
+  const d = describeSchema(member);
+  if (d.kind !== "shape") return "?";
+  const keySchema = d.shape[key];
+  if (keySchema === void 0) return "?";
+  const kd = describeSchema(keySchema);
+  return String((kd.kind === "optional" ? kd.inner : keySchema)._default);
+}
+
+// src/version/PxSchemaRelease.ts
+function diffFieldUniverse(previous, current) {
+  const prev = new Set(previous);
+  const cur = new Set(current);
+  return {
+    added: current.filter((k) => !prev.has(k)).sort(),
+    removed: previous.filter((k) => !cur.has(k)).sort()
+  };
+}
+function planSchemaRelease(p) {
+  const changed = p.added.length > 0 || p.removed.length > 0;
+  const last = parseWireVersion(p.lastReleased);
+  const declared = parseWireVersion(p.declared);
+  if (!last || !declared) return { changed, refuse: "Unparseable version: " + p.lastReleased + " / " + p.declared + "." };
+  const requiredVersion = last.a + "." + (last.b + 1);
+  if (!changed) {
+    if (declared.b === last.b && declared.a === last.a) return { changed };
+    const step2 = p.steps.find((s) => s.to === p.declared);
+    return step2 ? { changed, requiredVersion: p.declared } : { changed, refuse: "The version moved to " + p.declared + " with no key change and no step explaining it." };
+  }
+  const requiredKind = p.removed.length ? "converted" /* converted */ : "additive" /* additive */;
+  const summary = p.added.length + " key(s) added, " + p.removed.length + " removed";
+  if (declared.a !== last.a || declared.b !== last.b + 1) {
+    return {
+      changed,
+      requiredKind,
+      requiredVersion,
+      refuse: "The player schema changed (" + summary + ") but PX_WIRE_SCHEMA_VERSION is " + p.declared + ". Set it to " + requiredVersion + " and add the PX_WIRE_STEPS entry."
+    };
+  }
+  const step = p.steps.find((s) => s.to === p.declared);
+  if (!step) {
+    return { changed, requiredKind, requiredVersion, refuse: "No PX_WIRE_STEPS entry reaches " + p.declared + "." };
+  }
+  if (requiredKind === "converted" /* converted */ && step.kind !== "converted" /* converted */) {
+    return {
+      changed,
+      requiredKind,
+      requiredVersion,
+      refuse: "Keys were REMOVED (" + p.removed.join(", ") + "), which is never additive \u2014 the " + p.declared + " step must be `converted`, with an up()."
+    };
+  }
+  return { changed, requiredKind, requiredVersion };
+}
+function releaseLogProblems(releases, steps, declared, baseline) {
+  const problems = [];
+  if (!releases.length) return ["The release log is empty."];
+  if (!releases[0].baseline || releases[0].version !== baseline) {
+    problems.push("The first release must be the baseline " + baseline + ".");
+  }
+  for (let i = 1; i < releases.length; i++) {
+    const prev = parseWireVersion(releases[i - 1].version);
+    const cur = parseWireVersion(releases[i].version);
+    if (!prev || !cur || cur.a !== prev.a || cur.b !== prev.b + 1) {
+      problems.push("Release " + releases[i].version + " does not follow " + releases[i - 1].version + " by one `b` step.");
+    }
+    if (releases[i].date < releases[i - 1].date) problems.push("Release " + releases[i].version + " is dated before its predecessor.");
+    const step = steps.find((s) => s.to === releases[i].version);
+    if (!step) problems.push("Release " + releases[i].version + " has no PX_WIRE_STEPS entry.");
+    else if (releases[i].removed.length && step.kind !== "converted" /* converted */) {
+      problems.push("Release " + releases[i].version + " removed keys, but its step is not `converted`.");
+    }
+  }
+  const latest = releases[releases.length - 1].version;
+  if (latest !== declared) {
+    problems.push("PX_WIRE_SCHEMA_VERSION is " + declared + " but the last release record is " + latest + " \u2014 a bump needs its changelog entry (run scripts/schema-release.mjs --apply).");
+  }
+  return problems;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PX_ANIM_ATTR_NAME,
+  PX_ANIM_SRC_ATTR_NAME,
+  PX_COLOR_ATTR_NAMES,
+  PX_CSS_ONLY_STYLE_PROPS,
+  PX_DEFAULT_DURATION_MS,
+  PX_DISALLOWED_SVG_TAGS_LOWER,
+  PX_LOOP_JUMP_SHIFT_MS,
+  PX_PCT_BASED_ATTR_NAMES,
+  PX_STYLE_ATTR_NAMES,
+  PX_TEXT_CONTENT_ATTR,
+  PX_TRANSFORM_FN_NAMES,
+  PX_UNKNOWN_KEY_ERROR,
+  bezierToSvgPath,
+  camelCaseToKebabWordIfNeeded,
+  clamp,
+  composeTransformParts,
+  createDiagnostics,
+  createPathSampler,
+  cubicBezier,
+  deepClone,
+  diffFieldUniverse,
+  diffInEffect,
+  extendedPathForBrowser,
+  generateUniqueId,
+  interpolateValue,
+  isScrollTimeline,
+  kebabToCamelCaseWord,
+  keyframeEasing,
+  keyframeValue,
+  layoutGlyphTextChars,
+  materializeGlyphText,
+  materializeGlyphTextAlongPath,
+  materializeMotionPathInPropAnim,
+  mergeStaticTransformIntoAnimDef,
+  planSchemaRelease,
+  releaseLogProblems,
+  reportDocumentDiagnostics,
+  reverseEasing,
+  sanitizeAttributeValue,
+  schemaFieldUniverse,
+  scrollOffsetProgress,
+  scrollPhaseInterval,
+  scrollResolveAxis,
+  scrollTotalDurationMs,
+  scrollViewProgress,
+  splitEasing,
+  subdivideCubicBezier,
+  toRGBA
+});
+//# sourceMappingURL=internal.cjs.map