@pixerate/editor 0.25.0 → 0.26.1

package/dist/canvas/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10;
 
 
 var _chunk26BVFKHUcjs = require('../chunk-26BVFKHU.cjs');
@@ -8,6 +8,9 @@ var _chunk26BVFKHUcjs = require('../chunk-26BVFKHU.cjs');
 
 
 
+
+
+
 var _chunk4BVP64JJcjs = require('../chunk-4BVP64JJ.cjs');
 
 
@@ -2264,17 +2267,17 @@ function newton(c, p, t) {
     6 * (s * (c.p2[1] - 2 * c.p1[1] + c.p0[1]) + t * (c.p3[1] - 2 * c.p2[1] + c.p1[1]))
   ];
   const diff = [q[0] - p[0], q[1] - p[1]];
-  const num = dot(diff, d1);
+  const num2 = dot(diff, d1);
   const den = dot(d1, d1) + dot(diff, d2);
   if (Math.abs(den) < 1e-12) return t;
-  const nt = t - num / den;
+  const nt = t - num2 / den;
   return Number.isFinite(nt) ? Math.min(1, Math.max(0, nt)) : t;
 }
 function fitSingleFrom(pts, u, t0, t1) {
   let best = generate(pts, u, t0, t1);
   let [bestErr, bestSplit] = maxError(pts, best, u);
   const params = u.slice();
-  for (let round = 0; round < MAX_REPARAM; round++) {
+  for (let round3 = 0; round3 < MAX_REPARAM; round3++) {
     for (let i = 0; i < params.length; i++) params[i] = newton(best, pts[i], params[i]);
     const c = generate(pts, params, t0, t1);
     const [e, s] = maxError(pts, c, params);
@@ -2729,9 +2732,9 @@ function flattenArc(out, p0, cmd, tolerance, max) {
     rx *= s;
     ry *= s;
   }
-  const num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+  const num2 = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
   const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
-  let coef = den === 0 ? 0 : Math.sqrt(Math.max(0, num / den));
+  let coef = den === 0 ? 0 : Math.sqrt(Math.max(0, num2 / den));
   if (cmd.largeArc === cmd.sweep) coef = -coef;
   const cxp = coef * rx * y1p / ry;
   const cyp = -coef * ry * x1p / rx;
@@ -3382,9 +3385,9 @@ function arcToCubics(from, cmd) {
     rx *= s;
     ry *= s;
   }
-  const num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+  const num2 = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
   const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
-  let coef = den === 0 ? 0 : Math.sqrt(Math.max(0, num / den));
+  let coef = den === 0 ? 0 : Math.sqrt(Math.max(0, num2 / den));
   if (cmd.largeArc === cmd.sweep) coef = -coef;
   const cxp = coef * rx * y1p / ry;
   const cyp = -coef * ry * x1p / rx;
@@ -5262,15 +5265,15 @@ function combineShapeNodes(nodes, ids, operation, options = {}) {
     }
   }
   if (created.length === 0) return { ok: false, operation, reason: "empty" };
-  const done = {
+  const done2 = {
     ok: true,
     operation,
     removeIds: ordered.map((n) => n.id),
     nodes: created,
     engine: report.engine
   };
-  if (report.fallbackReason) done.fallbackReason = report.fallbackReason;
-  return done;
+  if (report.fallbackReason) done2.fallbackReason = report.fallbackReason;
+  return done2;
 }
 function buildPathNode(path, source, id, options) {
   const bounds = bezierPathBounds(path);
@@ -5956,7 +5959,7 @@ function layoutFrameInner(s, frame) {
   const alignMain = _nullishCoalesce(al.alignMain, () => ( "start"));
   const autoGap = alignMain === "space-between" || alignMain === "space-around" || alignMain === "space-evenly";
   const wraps = !!al.wrap && !hugMain;
-  const sizeOf = (id) => {
+  const sizeOf2 = (id) => {
     const b = s.boxes.get(id);
     return horizontal ? [b.w, b.h] : [b.h, b.w];
   };
@@ -5965,7 +5968,7 @@ function layoutFrameInner(s, frame) {
     for (const it of items) {
       if (!it.fillCross || it.fillMain) continue;
       resize(it, it.main, clampLayoutSize(innerCrossFixed, it.minCross, it.maxCross));
-      it.main = sizeOf(it.id)[0];
+      it.main = sizeOf2(it.id)[0];
     }
   }
   const lines = [];
@@ -5998,7 +6001,7 @@ function layoutFrameInner(s, frame) {
     if (!it.fillMain) continue;
     const cross2 = it.fillCross && !wraps ? clampLayoutSize(innerCrossFixed, it.minCross, it.maxCross) : it.cross;
     resize(it, it.main, cross2);
-    it.cross = sizeOf(it.id)[1];
+    it.cross = sizeOf2(it.id)[1];
   }
   if (baseline) {
     for (const it of items) if (!it.fillCross) it.baseline = itemBaseline(s, it.id, 0);
@@ -6542,11 +6545,11 @@ function moveLayoutChild(nodes, childId, index) {
 function parentsFirst(nodes) {
   const ids = new Set(nodes.map((n) => n.id));
   const pending = /* @__PURE__ */ new Map();
-  const done = /* @__PURE__ */ new Set();
+  const done2 = /* @__PURE__ */ new Set();
   const out = [];
   const emit = (n) => {
     out.push(n);
-    done.add(n.id);
+    done2.add(n.id);
     const waiting = pending.get(n.id);
     if (waiting) {
       pending.delete(n.id);
@@ -6554,12 +6557,12 @@ function parentsFirst(nodes) {
     }
   };
   for (const n of nodes) {
-    if (n.parentId && ids.has(n.parentId) && !done.has(n.parentId) && n.parentId !== n.id) {
+    if (n.parentId && ids.has(n.parentId) && !done2.has(n.parentId) && n.parentId !== n.id) {
       if (!pending.has(n.parentId)) pending.set(n.parentId, []);
       pending.get(n.parentId).push(n);
     } else emit(n);
   }
-  for (const waiting of pending.values()) for (const n of waiting) if (!done.has(n.id)) emit(n);
+  for (const waiting of pending.values()) for (const n of waiting) if (!done2.has(n.id)) emit(n);
   return out;
 }
 
@@ -7431,6 +7434,9 @@ function parseDeclarations(style) {
   }
   return out;
 }
+function parseNodeStyleDeclarations(style) {
+  return parseDeclarations(style);
+}
 function readNodeStyleProperty(style, prop) {
   if (!style) return void 0;
   if (typeof style === "object") return style[prop];
@@ -7837,6 +7843,3898 @@ function pruneCanvasTokenModes(nodes, state) {
   return changed ? out : nodes;
 }
 
+// src/canvas/animation/easing.ts
+var ANIMATION_EASING_PRESETS = [
+  "linear",
+  "ease",
+  "ease-in",
+  "ease-out",
+  "ease-in-out",
+  "ease-in-back",
+  "ease-out-back",
+  "spring",
+  "hold"
+];
+var ANIMATION_EASING_LABELS = {
+  linear: "Linear",
+  hold: "Hold",
+  ease: "Ease",
+  "ease-in": "Ease in",
+  "ease-out": "Ease out",
+  "ease-in-out": "Ease in-out",
+  "ease-in-back": "Back in",
+  "ease-out-back": "Back out",
+  spring: "Spring"
+};
+var CUBIC_BEZIER_PRESETS = {
+  linear: [0, 0, 1, 1],
+  ease: [0.25, 0.1, 0.25, 1],
+  "ease-in": [0.42, 0, 1, 1],
+  "ease-out": [0, 0, 0.58, 1],
+  "ease-in-out": [0.42, 0, 0.58, 1],
+  "ease-in-back": [0.36, 0, 0.66, -0.56],
+  "ease-out-back": [0.34, 1.56, 0.64, 1]
+};
+var DEFAULT_SPRING = { stiffness: 170, damping: 26, mass: 1, velocity: 0 };
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+var finite2 = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+function cubicBezierAt(x1, y1, x2, y2, x) {
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+  x1 = clamp(x1, 0, 1);
+  x2 = clamp(x2, 0, 1);
+  const bx = (s2) => 3 * (1 - s2) * (1 - s2) * s2 * x1 + 3 * (1 - s2) * s2 * s2 * x2 + s2 * s2 * s2;
+  const by = (s2) => 3 * (1 - s2) * (1 - s2) * s2 * y1 + 3 * (1 - s2) * s2 * s2 * y2 + s2 * s2 * s2;
+  const dbx = (s2) => 3 * (1 - s2) * (1 - s2) * x1 + 6 * (1 - s2) * s2 * (x2 - x1) + 3 * s2 * s2 * (1 - x2);
+  let s = x;
+  for (let i = 0; i < 8; i++) {
+    const d = dbx(s);
+    if (Math.abs(d) < 1e-9) break;
+    const next = s - (bx(s) - x) / d;
+    if (!(next >= 0 && next <= 1)) break;
+    s = next;
+  }
+  if (Math.abs(bx(s) - x) > 1e-7) {
+    let lo = 0;
+    let hi = 1;
+    for (let i = 0; i < 60; i++) {
+      s = (lo + hi) / 2;
+      if (bx(s) < x) lo = s;
+      else hi = s;
+    }
+  }
+  return by(s);
+}
+function springAt(spring, seconds) {
+  const stiffness = Math.max(1e-6, finite2(spring.stiffness, DEFAULT_SPRING.stiffness));
+  const damping = Math.max(0, finite2(spring.damping, DEFAULT_SPRING.damping));
+  const mass = Math.max(1e-6, finite2(spring.mass, DEFAULT_SPRING.mass));
+  const v0 = -finite2(spring.velocity, DEFAULT_SPRING.velocity);
+  const t = Math.max(0, seconds);
+  const w0 = Math.sqrt(stiffness / mass);
+  const zeta = damping / (2 * Math.sqrt(stiffness * mass));
+  let x;
+  if (zeta < 1 - 1e-6) {
+    const wd = w0 * Math.sqrt(1 - zeta * zeta);
+    x = Math.exp(-zeta * w0 * t) * (Math.cos(wd * t) + (zeta * w0 + v0) / wd * Math.sin(wd * t));
+  } else if (zeta <= 1 + 1e-6) {
+    x = Math.exp(-w0 * t) * (1 + (w0 + v0) * t);
+  } else {
+    const r = Math.sqrt(zeta * zeta - 1);
+    const s1 = -w0 * (zeta - r);
+    const s2 = -w0 * (zeta + r);
+    const c2 = (v0 - s1) / (s2 - s1);
+    const c1 = 1 - c2;
+    x = c1 * Math.exp(s1 * t) + c2 * Math.exp(s2 * t);
+  }
+  return 1 - x;
+}
+function resolveEasing(easing) {
+  if (easing === "hold") return "hold";
+  if (easing === "spring") return { type: "spring", ...DEFAULT_SPRING };
+  if (typeof easing === "string") {
+    const preset = CUBIC_BEZIER_PRESETS[easing];
+    if (preset) return { type: "cubic-bezier", x1: preset[0], y1: preset[1], x2: preset[2], y2: preset[3] };
+    const parsed = parseCssEasing(easing);
+    return parsed ? resolveEasing(parsed) : { type: "cubic-bezier", x1: 0, y1: 0, x2: 1, y2: 1 };
+  }
+  if (easing && typeof easing === "object") {
+    if (easing.type === "spring") {
+      return {
+        type: "spring",
+        stiffness: finite2(easing.stiffness, DEFAULT_SPRING.stiffness),
+        damping: finite2(easing.damping, DEFAULT_SPRING.damping),
+        mass: finite2(easing.mass, DEFAULT_SPRING.mass),
+        velocity: finite2(easing.velocity, DEFAULT_SPRING.velocity)
+      };
+    }
+    if (easing.type === "cubic-bezier") {
+      return {
+        type: "cubic-bezier",
+        x1: clamp(finite2(easing.x1, 0), 0, 1),
+        y1: finite2(easing.y1, 0),
+        x2: clamp(finite2(easing.x2, 1), 0, 1),
+        y2: finite2(easing.y2, 1)
+      };
+    }
+  }
+  return { type: "cubic-bezier", x1: 0, y1: 0, x2: 1, y2: 1 };
+}
+function evaluateEasing(easing, u, durationMs = 1e3) {
+  if (!(u > 0)) return 0;
+  if (u >= 1) return 1;
+  const resolved = resolveEasing(easing);
+  if (resolved === "hold") return 0;
+  if (resolved.type === "spring") return springAt(resolved, u * Math.max(0, durationMs) / 1e3);
+  const { x1, y1, x2, y2 } = resolved;
+  if (x1 === y1 && x2 === y2) return u;
+  return cubicBezierAt(x1, y1, x2, y2, u);
+}
+function easingFromInfluence(outInfluence = 1 / 3, inInfluence = 1 / 3) {
+  return {
+    type: "cubic-bezier",
+    x1: clamp(outInfluence, 0.01, 1),
+    y1: 0,
+    x2: 1 - clamp(inInfluence, 0.01, 1),
+    y2: 1
+  };
+}
+var NUMBER = String.raw`\s*(-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)\s*`;
+var CUBIC_RE = new RegExp(`^cubic-bezier\\(${NUMBER},${NUMBER},${NUMBER},${NUMBER}\\)$`, "i");
+function parseCssEasing(text) {
+  const value = text.trim().toLowerCase();
+  if (value.length > 200) return null;
+  if (ANIMATION_EASING_PRESETS.includes(value)) return value;
+  if (value === "step-end" || /^steps\(\s*1\s*(,\s*(end|jump-end)\s*)?\)$/.test(value)) return "hold";
+  const m = CUBIC_RE.exec(value);
+  if (!m) return null;
+  const [x1, y1, x2, y2] = m.slice(1).map(Number);
+  if (![x1, y1, x2, y2].every(Number.isFinite) || x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) return null;
+  return { type: "cubic-bezier", x1, y1, x2, y2 };
+}
+function isAnimationEasing(value) {
+  if (typeof value === "string") return parseCssEasing(value) !== null;
+  if (typeof value !== "object" || value === null) return false;
+  const e = value;
+  if (e.type === "spring") return true;
+  return e.type === "cubic-bezier" && [e.x1, e.y1, e.x2, e.y2].every((v) => typeof v === "number" && Number.isFinite(v));
+}
+var round = (v, digits = 4) => {
+  const p = 10 ** digits;
+  return Math.round(v * p) / p;
+};
+function easingToCss(easing, durationMs = 1e3, samples = 24) {
+  const resolved = resolveEasing(easing);
+  if (resolved === "hold") return "steps(1, end)";
+  if (resolved.type === "spring") {
+    const n = Math.max(2, Math.floor(samples));
+    const points = [];
+    for (let i = 0; i <= n; i++) points.push(String(round(i === n ? 1 : springAt(resolved, i / n * durationMs / 1e3))));
+    return `linear(${points.join(", ")})`;
+  }
+  const { x1, y1, x2, y2 } = resolved;
+  for (const [name, p] of Object.entries(CUBIC_BEZIER_PRESETS)) {
+    if (["linear", "ease", "ease-in", "ease-out", "ease-in-out"].includes(name) && p[0] === x1 && p[1] === y1 && p[2] === x2 && p[3] === y2) {
+      return name;
+    }
+  }
+  return `cubic-bezier(${round(x1)}, ${round(y1)}, ${round(x2)}, ${round(y2)})`;
+}
+function easingLabel(easing) {
+  if (easing === void 0 || easing === null) return ANIMATION_EASING_LABELS.linear;
+  if (typeof easing === "string") return _nullishCoalesce(ANIMATION_EASING_LABELS[easing], () => ( easing));
+  return easing.type === "spring" ? "Spring" : "Custom";
+}
+
+// src/canvas/animation/color.ts
+var toLinear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+var toGamma = (c) => c <= 31308e-7 ? 12.92 * c : 1.055 * Math.sign(c) * Math.abs(c) ** (1 / 2.4) - 0.055;
+function rgbToOklab(r, g, b, alpha = 1) {
+  const lr = toLinear(r);
+  const lg = toLinear(g);
+  const lb = toLinear(b);
+  const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  return {
+    l: 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    a: 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    b: 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+    alpha
+  };
+}
+function oklabToRgb(color) {
+  const l_ = color.l + 0.3963377774 * color.a + 0.2158037573 * color.b;
+  const m_ = color.l - 0.1055613458 * color.a - 0.0638541728 * color.b;
+  const s_ = color.l - 0.0894841775 * color.a - 1.291485548 * color.b;
+  const l = l_ ** 3;
+  const m = m_ ** 3;
+  const s = s_ ** 3;
+  const clamp01 = (v) => Math.min(1, Math.max(0, v));
+  return {
+    r: clamp01(toGamma(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s)),
+    g: clamp01(toGamma(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s)),
+    b: clamp01(toGamma(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s)),
+    a: clamp01(color.alpha)
+  };
+}
+function parseOklab(input) {
+  const hex = _chunk4BVP64JJcjs.normalizeTokenColor.call(void 0, input);
+  if (hex === null) return null;
+  const c = _chunk4BVP64JJcjs.hexToRgba.call(void 0, hex);
+  return rgbToOklab(c.r, c.g, c.b, c.a);
+}
+function formatOklab(color) {
+  const { r, g, b, a } = oklabToRgb(color);
+  return _chunk4BVP64JJcjs.rgbaToHex.call(void 0, r, g, b, a);
+}
+function mixColorsOklab(from, to, t) {
+  const a = parseOklab(from);
+  const b = parseOklab(to);
+  if (!a || !b) return null;
+  const alpha = a.alpha + (b.alpha - a.alpha) * t;
+  const premul = (k) => a[k] * a.alpha + (b[k] * b.alpha - a[k] * a.alpha) * t;
+  if (alpha <= 1e-9) return formatOklab({ l: a.l + (b.l - a.l) * t, a: 0, b: 0, alpha: 0 });
+  return formatOklab({ l: premul("l") / alpha, a: premul("a") / alpha, b: premul("b") / alpha, alpha });
+}
+
+// src/canvas/animation/model.ts
+var ANIMATION_DATA_KEY = "animation";
+var ANIMATION_TIME_EPSILON = 1e-6;
+var num = (value) => {
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (typeof value === "string") {
+    const n = parseFloat(value);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+};
+var tidy = (v) => Math.round(v * 1e4) / 1e4;
+function tokenBacked(key, label, type, extra = {}) {
+  return {
+    key,
+    label,
+    type,
+    ...extra,
+    read: (node) => {
+      const p = getCanvasTokenProperty(key);
+      const v = _optionalChain([p, 'optionalAccess', _200 => _200.appliesTo, 'call', _201 => _201(node)]) ? p.read(node) : void 0;
+      return typeof v === "number" || typeof v === "string" ? v : void 0;
+    },
+    write: (node, value) => {
+      const p = getCanvasTokenProperty(key);
+      return _optionalChain([p, 'optionalAccess', _202 => _202.appliesTo, 'call', _203 => _203(node)]) ? p.write(node, value) : node;
+    }
+  };
+}
+function sizeProperty(key, label) {
+  return {
+    key,
+    label,
+    type: "number",
+    min: 0,
+    unit: "px",
+    read: (node) => _nullishCoalesce(_nullishCoalesce(num(node[key]), () => ( readStyleSize(node.style)[key])), () => ( num(_optionalChain([node, 'access', _204 => _204.measured, 'optionalAccess', _205 => _205[key]])))),
+    write: (node, value) => {
+      const v = tidy(Math.max(0, value));
+      return { ...node, [key]: v, style: withStyleSize(node.style, { [key]: v }) };
+    }
+  };
+}
+function motionPathPoint(node, progress) {
+  const path = _optionalChain([getNodeAnimation, 'call', _206 => _206(node), 'optionalAccess', _207 => _207.motionPath]);
+  if (!path || typeof path.d !== "string") return null;
+  try {
+    const length = bezierPathLength(path.d);
+    return bezierPathPointAtLength(path.d, Math.min(1, Math.max(0, progress)) * length);
+  } catch (e9) {
+    return null;
+  }
+}
+var ANIMATABLE_PROPERTIES = [
+  {
+    key: "x",
+    label: "X",
+    type: "number",
+    unit: "px",
+    read: (node) => num(_optionalChain([node, 'access', _208 => _208.position, 'optionalAccess', _209 => _209.x])),
+    write: (node, value) => ({ ...node, position: { ...node.position, x: tidy(value) } })
+  },
+  {
+    key: "y",
+    label: "Y",
+    type: "number",
+    unit: "px",
+    read: (node) => num(_optionalChain([node, 'access', _210 => _210.position, 'optionalAccess', _211 => _211.y])),
+    write: (node, value) => ({ ...node, position: { ...node.position, y: tidy(value) } })
+  },
+  sizeProperty("width", "Width"),
+  sizeProperty("height", "Height"),
+  {
+    key: "rotation",
+    label: "Rotation",
+    type: "number",
+    unit: "\xB0",
+    read: (node) => _nullishCoalesce(num(readNodeStyleProperty(node.style, "rotate")), () => ( 0)),
+    write: (node, value) => ({
+      ...node,
+      style: writeNodeStyleProperty(node.style, "rotate", `${tidy(value)}deg`)
+    })
+  },
+  {
+    key: "scale",
+    label: "Scale",
+    type: "number",
+    min: 0,
+    read: (node) => _nullishCoalesce(num(readNodeStyleProperty(node.style, "scale")), () => ( 1)),
+    write: (node, value) => ({
+      ...node,
+      style: writeNodeStyleProperty(_nullishCoalesce(node.style, () => ( {})), "scale", tidy(Math.max(0, value)), true)
+    })
+  },
+  {
+    key: "opacity",
+    label: "Opacity",
+    type: "number",
+    min: 0,
+    max: 1,
+    read: (node) => _nullishCoalesce(num(readNodeStyleProperty(node.style, "opacity")), () => ( 1)),
+    write: (node, value) => ({
+      ...node,
+      style: withStyleOpacity(node.style, tidy(Math.min(1, Math.max(0, value))), typeof node.style === "string" ? "string" : "object")
+    })
+  },
+  tokenBacked("fill", "Fill", "color"),
+  tokenBacked("stroke", "Stroke", "color"),
+  tokenBacked("strokeWidth", "Stroke width", "number", { min: 0, unit: "px" }),
+  tokenBacked("cornerRadius", "Corner radius", "number", { min: 0, unit: "px" }),
+  {
+    key: "motionPath",
+    label: "Motion path",
+    type: "number",
+    min: 0,
+    max: 1,
+    read: () => void 0,
+    write: (node, value) => {
+      const at = motionPathPoint(node, value);
+      if (!at) return node;
+      const { width, height } = getNodeSize(node);
+      let next = {
+        ...node,
+        position: { x: tidy(at.point[0] - width / 2), y: tidy(at.point[1] - height / 2) }
+      };
+      if (_optionalChain([getNodeAnimation, 'call', _212 => _212(node), 'optionalAccess', _213 => _213.motionPath, 'optionalAccess', _214 => _214.autoRotate])) {
+        const base = _nullishCoalesce(num(readNodeStyleProperty(node.style, "rotate")), () => ( 0));
+        next = { ...next, style: writeNodeStyleProperty(next.style, "rotate", `${tidy(base + at.angle * 180 / Math.PI)}deg`) };
+      }
+      return next;
+    }
+  }
+];
+function getAnimatableProperty(key, options = {}) {
+  return (_nullishCoalesce(options.properties, () => ( ANIMATABLE_PROPERTIES))).find((p) => p.key === key);
+}
+function clampAnimationValue(property, value) {
+  if (!property || typeof value !== "number") return value;
+  let v = value;
+  if (property.min !== void 0) v = Math.max(property.min, v);
+  if (property.max !== void 0) v = Math.min(property.max, v);
+  return v;
+}
+function isValue(value) {
+  return typeof value === "number" && Number.isFinite(value) || typeof value === "string";
+}
+function isAnimationKeyframe(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const k = value;
+  return typeof k.time === "number" && Number.isFinite(k.time) && isValue(k.value) && (k.easing === void 0 || isAnimationEasing(k.easing));
+}
+var sortedCache = /* @__PURE__ */ new WeakMap();
+function normalizeKeyframes(keyframes) {
+  if (!Array.isArray(keyframes)) return [];
+  const cached = sortedCache.get(keyframes);
+  if (cached && cached.items.length === keyframes.length && cached.items.every((k, i) => k === keyframes[i])) return cached.out;
+  const indexed = keyframes.map((k, i) => ({ k, i })).filter(({ k }) => isAnimationKeyframe(k)).sort((a, b) => a.k.time - b.k.time || a.i - b.i);
+  const out = [];
+  let lastIndex = -1;
+  for (const { k, i } of indexed) {
+    const prev = out[out.length - 1];
+    if (prev && Math.abs(k.time - prev.time) <= ANIMATION_TIME_EPSILON) {
+      if (i > lastIndex) {
+        out[out.length - 1] = k;
+        lastIndex = i;
+      }
+      continue;
+    }
+    out.push(k);
+    lastIndex = i;
+  }
+  sortedCache.set(keyframes, { items: [...keyframes], out });
+  return out;
+}
+function getNodeAnimation(node) {
+  const raw = _optionalChain([node, 'optionalAccess', _215 => _215.data, 'optionalAccess', _216 => _216[ANIMATION_DATA_KEY]]);
+  if (typeof raw !== "object" || raw === null || typeof raw.tracks !== "object" || raw.tracks === null) return null;
+  return raw;
+}
+function getAnimationTrack(node, property) {
+  const track = _optionalChain([getNodeAnimation, 'call', _217 => _217(node), 'optionalAccess', _218 => _218.tracks, 'access', _219 => _219[property]]);
+  return track && Array.isArray(track.keyframes) && normalizeKeyframes(track.keyframes).length > 0 ? track : void 0;
+}
+function isNodeAnimated(node) {
+  const animation = getNodeAnimation(node);
+  if (!animation) return false;
+  return Object.keys(animation.tracks).some((key) => getAnimationTrack(node, key) !== void 0);
+}
+function getAnimatedProperties(node, options = {}) {
+  const animation = getNodeAnimation(node);
+  if (!animation) return [];
+  const keys = Object.keys(animation.tracks).filter((k) => getAnimationTrack(node, k));
+  const order = (_nullishCoalesce(options.properties, () => ( ANIMATABLE_PROPERTIES))).map((p) => p.key);
+  const rank = (k) => order.includes(k) ? order.indexOf(k) : order.length;
+  return keys.sort((a, b) => rank(a) - rank(b) || a.localeCompare(b));
+}
+function withNodeAnimation(node, animation) {
+  const tracks = {};
+  if (animation) {
+    for (const [key, track] of Object.entries(animation.tracks)) {
+      if (track && Array.isArray(track.keyframes) && track.keyframes.length > 0) tracks[key] = track;
+    }
+  }
+  const data = { ..._nullishCoalesce(node.data, () => ( {})) };
+  if (Object.keys(tracks).length === 0 && !_optionalChain([animation, 'optionalAccess', _220 => _220.motionPath])) delete data[ANIMATION_DATA_KEY];
+  else data[ANIMATION_DATA_KEY] = { ...animation, tracks };
+  return { ...node, data };
+}
+
+// src/canvas/animation/evaluate.ts
+var nodesOf = (doc) => Array.isArray(doc) ? doc : doc.nodes;
+function interpolateAnimationValue(from, to, t, type = "number") {
+  if (typeof from === "number" && typeof to === "number") return from + (to - from) * t;
+  if (t <= 0) return from;
+  if (t >= 1) return to;
+  if (type === "color" || typeof from === "string" && typeof to === "string") {
+    const mixed = mixColorsOklab(from, to, t);
+    if (mixed !== null) return mixed;
+  }
+  return from;
+}
+function segmentIndex(keys, time) {
+  let lo = 0;
+  let hi = keys.length - 1;
+  let found = -1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (keys[mid].time <= time) {
+      found = mid;
+      lo = mid + 1;
+    } else hi = mid - 1;
+  }
+  return found;
+}
+function evaluateTrack(track, time, type = "number") {
+  const keyframes = Array.isArray(track) ? track : _optionalChain([track, 'optionalAccess', _221 => _221.keyframes]);
+  const keys = normalizeKeyframes(keyframes);
+  if (keys.length === 0) return void 0;
+  if (!(time > keys[0].time)) return keys[0].value;
+  const last = keys[keys.length - 1];
+  if (time >= last.time) return last.value;
+  const i = segmentIndex(keys, time);
+  const a = keys[i];
+  const b = keys[i + 1];
+  if (time === a.time) return a.value;
+  const span = b.time - a.time;
+  const u = (time - a.time) / span;
+  if (a.easing === "hold") return a.value;
+  return interpolateAnimationValue(a.value, b.value, evaluateEasing(a.easing, u, span), type);
+}
+function getAnimationDuration(doc) {
+  let end = 0;
+  for (const node of nodesOf(doc)) {
+    const animation = getNodeAnimation(node);
+    if (!animation) continue;
+    for (const track of Object.values(animation.tracks)) {
+      if (!track || track.enabled === false) continue;
+      const keys = normalizeKeyframes(track.keyframes);
+      if (keys.length > 0) end = Math.max(end, keys[keys.length - 1].time);
+    }
+  }
+  return end;
+}
+function wrapAnimationTime(time, duration, loop = "none") {
+  if (!Number.isFinite(time)) return 0;
+  if (!(duration > 0)) return 0;
+  if (loop === "loop") return (time % duration + duration) % duration;
+  if (loop === "ping-pong") {
+    const period = duration * 2;
+    const m = (time % period + period) % period;
+    return m <= duration ? m : period - m;
+  }
+  return Math.min(duration, Math.max(0, time));
+}
+function evaluateAnimation(doc, time, options = {}) {
+  const only = options.ids ? new Set(options.ids) : null;
+  const out = {};
+  for (const node of nodesOf(doc)) {
+    if (only && !only.has(node.id)) continue;
+    const animation = getNodeAnimation(node);
+    if (!animation) continue;
+    let values;
+    for (const [key, track] of Object.entries(animation.tracks)) {
+      if (!track || track.enabled === false) continue;
+      const property = (_nullishCoalesce(options.properties, () => ( ANIMATABLE_PROPERTIES))).find((p) => p.key === key);
+      const value = evaluateTrack(track, time, _nullishCoalesce(_optionalChain([property, 'optionalAccess', _222 => _222.type]), () => ( "number")));
+      if (value === void 0) continue;
+      (values ??= {})[key] = clampAnimationValue(property, value);
+    }
+    if (values) out[node.id] = values;
+  }
+  return out;
+}
+function applyAnimationOverrides(nodes, overrides, options = {}) {
+  const properties = _nullishCoalesce(options.properties, () => ( ANIMATABLE_PROPERTIES));
+  let changed = false;
+  const out = nodes.map((node) => {
+    const values = overrides[node.id];
+    if (!values) return node;
+    let next = node;
+    for (const property of properties) {
+      if (!(property.key in values)) continue;
+      next = property.write(next, values[property.key]);
+    }
+    if (next !== node) changed = true;
+    return next;
+  });
+  return changed ? out : nodes;
+}
+function applyAnimation(nodes, time, options = {}) {
+  return applyAnimationOverrides(nodes, evaluateAnimation(nodes, time, options), options);
+}
+
+// src/canvas/animation/edit.ts
+var AnimationEditError = class extends Error {
+  
+  constructor(code, message) {
+    super(message);
+    this.name = "AnimationEditError";
+    this.code = code;
+  }
+};
+var MAX_KEYFRAME_REFS = 4096;
+var sameTime = (a, b) => Math.abs(a - b) <= ANIMATION_TIME_EPSILON;
+var refKey = (r) => `${r.nodeId}\0${r.property}`;
+function snapTimeToFrame(time, fps) {
+  if (!(fps > 0)) return time;
+  const frame = 1e3 / fps;
+  return Math.round(Math.round(time / frame) * frame * 1e3) / 1e3;
+}
+function coerceValue(property, value) {
+  const type = _nullishCoalesce(_optionalChain([property, 'optionalAccess', _223 => _223.type]), () => ( (typeof value === "string" && _chunk4BVP64JJcjs.normalizeTokenColor.call(void 0, value) !== null ? "color" : "number")));
+  if (type === "color") {
+    const color = _chunk4BVP64JJcjs.normalizeTokenColor.call(void 0, value);
+    if (color === null) throw new AnimationEditError("invalid_value", `"${String(value)}" is not a colour.`);
+    return color;
+  }
+  const n = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+  if (typeof n !== "number" || !Number.isFinite(n)) throw new AnimationEditError("invalid_value", `"${String(value)}" is not a number.`);
+  return clampAnimationValue(property, n);
+}
+function coerceEasing(easing) {
+  if (typeof easing === "string") {
+    const parsed = parseCssEasing(easing);
+    if (parsed) return parsed;
+  } else if (isAnimationEasing(easing)) return easing;
+  throw new AnimationEditError("invalid_easing", `Unknown easing ${JSON.stringify(easing)}.`);
+}
+function coerceTime(time) {
+  if (typeof time !== "number" || !Number.isFinite(time)) throw new AnimationEditError("invalid_time", `Invalid time ${String(time)}.`);
+  return Math.max(0, time);
+}
+var Draft = (_class8 = class {
+  constructor(nodes, options = {}) {;_class8.prototype.__init20.call(this);_class8.prototype.__init21.call(this);
+    this.nodes = nodes;
+    this.options = options;
+    this.byId = new Map(nodes.map((n) => [n.id, n]));
+  }
+  
+  
+  
+  __init20() {this.animations = /* @__PURE__ */ new Map()}
+  __init21() {this.nodeWrites = /* @__PURE__ */ new Map()}
+  node(id) {
+    const node = _nullishCoalesce(this.nodeWrites.get(id), () => ( this.byId.get(id)));
+    if (!node) throw new AnimationEditError("unknown_node", `Node "${id}" does not exist.`);
+    return node;
+  }
+  has(id) {
+    return this.byId.has(id);
+  }
+  animation(id) {
+    let animation = this.animations.get(id);
+    if (!animation) {
+      const current = getNodeAnimation(this.node(id));
+      const tracks = {};
+      for (const [key, track] of Object.entries(_nullishCoalesce(_optionalChain([current, 'optionalAccess', _224 => _224.tracks]), () => ( {})))) {
+        if (track) tracks[key] = { ...track, keyframes: normalizeKeyframes(track.keyframes) };
+      }
+      animation = { ..._nullishCoalesce(current, () => ( {})), tracks };
+      this.animations.set(id, animation);
+    }
+    return animation;
+  }
+  keys(id, property) {
+    return _nullishCoalesce(_optionalChain([this, 'access', _225 => _225.animation, 'call', _226 => _226(id), 'access', _227 => _227.tracks, 'access', _228 => _228[property], 'optionalAccess', _229 => _229.keyframes]), () => ( []));
+  }
+  track(id, property) {
+    return this.animation(id).tracks[property];
+  }
+  setKeys(id, property, keyframes) {
+    const animation = this.animation(id);
+    const sorted = [...keyframes].sort((a, b) => a.time - b.time);
+    if (sorted.length === 0) delete animation.tracks[property];
+    else animation.tracks[property] = { ..._nullishCoalesce(animation.tracks[property], () => ( {})), keyframes: sorted };
+  }
+  setMotionPath(id, motionPath) {
+    const animation = this.animation(id);
+    if (motionPath) animation.motionPath = { ...motionPath };
+    else delete animation.motionPath;
+  }
+  writeNode(id, fn) {
+    this.nodeWrites.set(id, fn(this.node(id)));
+  }
+  find(ref) {
+    const keys = this.keys(ref.nodeId, ref.property);
+    return keys.findIndex((k) => sameTime(k.time, ref.time));
+  }
+  property(key) {
+    return getAnimatableProperty(key, this.options);
+  }
+  commit() {
+    if (this.animations.size === 0 && this.nodeWrites.size === 0) return this.nodes;
+    return this.nodes.map((node) => {
+      const written = this.nodeWrites.get(node.id);
+      const animation = this.animations.get(node.id);
+      if (!written && !animation) return node;
+      const base = _nullishCoalesce(written, () => ( node));
+      return animation ? withNodeAnimation(base, animation) : base;
+    });
+  }
+}, _class8);
+function validateRefs(draft, refs, allowEmpty = false) {
+  if (!Array.isArray(refs) || !allowEmpty && refs.length === 0) throw new AnimationEditError("unknown_keyframe", "Name at least one keyframe.");
+  if (refs.length > MAX_KEYFRAME_REFS) throw new AnimationEditError("too_many_keyframes", `At most ${MAX_KEYFRAME_REFS} keyframes per edit.`);
+  const seen = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    if (!ref || typeof ref.nodeId !== "string" || typeof ref.property !== "string" || typeof ref.time !== "number" || !Number.isFinite(ref.time)) {
+      throw new AnimationEditError("unknown_keyframe", "Invalid keyframe reference.");
+    }
+    draft.node(ref.nodeId);
+    if (draft.find(ref) === -1) throw new AnimationEditError("unknown_keyframe", `No ${ref.property} keyframe at ${ref.time}ms on "${ref.nodeId}".`);
+    const times = _nullishCoalesce(seen.get(refKey(ref)), () => ( []));
+    if (times.some((t) => sameTime(t, ref.time))) throw new AnimationEditError("duplicate_keyframe", "A keyframe is named twice.");
+    times.push(ref.time);
+    seen.set(refKey(ref), times);
+  }
+}
+function readAnimatableValue(node, property) {
+  const value = property.read(node);
+  if (value !== void 0) return value;
+  if (property.key === "width" || property.key === "height") return getNodeSize(node)[property.key];
+  return void 0;
+}
+function getAnimatedValue(node, propertyKey, time, options = {}) {
+  const property = getAnimatableProperty(propertyKey, options);
+  const track = getAnimationTrack(node, propertyKey);
+  if (track && track.enabled !== false) return evaluateTrack(track, time, _nullishCoalesce(_optionalChain([property, 'optionalAccess', _230 => _230.type]), () => ( "number")));
+  return property ? readAnimatableValue(node, property) : void 0;
+}
+function putKey(draft, nodeId, property, time, value, easing, inherit = true) {
+  const keys = [...draft.keys(nodeId, property)];
+  const at = keys.findIndex((k) => sameTime(k.time, time));
+  if (at >= 0) {
+    keys[at] = { ...keys[at], value, ...easing !== void 0 ? { easing } : {} };
+  } else {
+    const before = [...keys].reverse().find((k) => k.time < time);
+    const inherited = _nullishCoalesce(easing, () => ( (inherit ? _optionalChain([before, 'optionalAccess', _231 => _231.easing]) : void 0)));
+    keys.push({ time, value, ...inherited !== void 0 ? { easing: inherited } : {} });
+  }
+  draft.setKeys(nodeId, property, keys);
+}
+function setKeyframe(nodes, nodeId, property, time, value, options = {}) {
+  const draft = new Draft(nodes, options);
+  draft.node(nodeId);
+  const p = draft.property(property);
+  if (!p) throw new AnimationEditError("unknown_property", `"${property}" cannot be animated.`);
+  putKey(draft, nodeId, property, coerceTime(time), coerceValue(p, value), options.easing === void 0 ? void 0 : coerceEasing(options.easing));
+  return draft.commit();
+}
+function addKeyframesAtTime(nodes, ids, time, options = {}) {
+  const draft = new Draft(nodes, options);
+  const t = coerceTime(time);
+  const refs = [];
+  for (const id of ids) {
+    const node = draft.node(id);
+    const animated = Object.keys(draft.animation(id).tracks);
+    const keys = _nullishCoalesce(options.keys, () => ( (animated.length > 0 ? animated : ["x", "y"])));
+    for (const key of keys) {
+      const p = draft.property(key);
+      if (!p) throw new AnimationEditError("unknown_property", `"${key}" cannot be animated.`);
+      const value = getAnimatedValue(node, key, t, options);
+      if (value === void 0) continue;
+      putKey(draft, id, key, t, value);
+      refs.push({ nodeId: id, property: key, time: t });
+    }
+  }
+  return { nodes: draft.commit(), refs };
+}
+function updateKeyframe(nodes, ref, patch, options = {}) {
+  const draft = new Draft(nodes, options);
+  validateRefs(draft, [ref]);
+  const keys = [...draft.keys(ref.nodeId, ref.property)];
+  const i = keys.findIndex((k) => sameTime(k.time, ref.time));
+  const next = { ...keys[i] };
+  if (patch.value !== void 0) next.value = coerceValue(draft.property(ref.property), patch.value);
+  if (patch.easing === null) delete next.easing;
+  else if (patch.easing !== void 0) next.easing = coerceEasing(patch.easing);
+  if (patch.time !== void 0) next.time = coerceTime(patch.time);
+  keys.splice(i, 1);
+  const rest = keys.filter((k) => !sameTime(k.time, next.time));
+  draft.setKeys(ref.nodeId, ref.property, [...rest, next]);
+  return draft.commit();
+}
+function setKeyframeEasing(nodes, refs, easing, options = {}) {
+  const draft = new Draft(nodes, options);
+  validateRefs(draft, refs);
+  const value = easing === null ? null : coerceEasing(easing);
+  for (const ref of refs) {
+    const keys = draft.keys(ref.nodeId, ref.property).map((k) => {
+      if (!sameTime(k.time, ref.time)) return k;
+      const { easing: _old, ...rest } = k;
+      return value === null ? rest : { ...rest, easing: value };
+    });
+    draft.setKeys(ref.nodeId, ref.property, keys);
+  }
+  return draft.commit();
+}
+function deleteKeyframes(nodes, refs, options = {}) {
+  const draft = new Draft(nodes, options);
+  validateRefs(draft, refs);
+  const lanes = /* @__PURE__ */ new Map();
+  for (const ref of refs) lanes.set(refKey(ref), [..._nullishCoalesce(lanes.get(refKey(ref)), () => ( [])), ref]);
+  for (const lane of lanes.values()) {
+    const { nodeId, property } = lane[0];
+    const keys = draft.keys(nodeId, property);
+    const left = keys.filter((k) => !lane.some((r) => sameTime(r.time, k.time)));
+    if (left.length === 0) {
+      const p = draft.property(property);
+      const last = _nullishCoalesce(keys.find((k) => sameTime(k.time, lane[lane.length - 1].time)), () => ( keys[keys.length - 1]));
+      if (p && property !== "motionPath") draft.writeNode(nodeId, (n) => p.write(n, last.value));
+    }
+    draft.setKeys(nodeId, property, left);
+  }
+  return draft.commit();
+}
+function setTrackEnabled(nodes, nodeId, property, enabled) {
+  const draft = new Draft(nodes);
+  if (!draft.track(nodeId, property)) throw new AnimationEditError("unknown_property", `"${nodeId}" has no ${property} track.`);
+  const { enabled: _was, ...track } = draft.track(nodeId, property);
+  draft.animation(nodeId).tracks[property] = enabled ? track : { ...track, enabled: false };
+  return draft.commit();
+}
+function removeTrack(nodes, nodeId, property, options = {}) {
+  const draft = new Draft(nodes, options);
+  const track = draft.track(nodeId, property);
+  if (!track) return nodes;
+  const p = draft.property(property);
+  if (options.keepValueAt !== void 0 && p && property !== "motionPath") {
+    const value = evaluateTrack(track, options.keepValueAt, p.type);
+    if (value !== void 0) draft.writeNode(nodeId, (n) => p.write(n, value));
+  }
+  draft.setKeys(nodeId, property, []);
+  if (property === "motionPath") draft.setMotionPath(nodeId, void 0);
+  return draft.commit();
+}
+function setMotionPath(nodes, nodeId, motionPath) {
+  const draft = new Draft(nodes);
+  draft.node(nodeId);
+  if (motionPath && (typeof motionPath.d !== "string" || motionPath.d.trim() === "")) {
+    throw new AnimationEditError("invalid_value", "A motion path needs SVG path data.");
+  }
+  draft.setMotionPath(nodeId, _nullishCoalesce(motionPath, () => ( void 0)));
+  return draft.commit();
+}
+function moveKeyframes(nodes, refs, delta, options = {}) {
+  if (typeof delta !== "number" || Number.isNaN(delta)) throw new AnimationEditError("invalid_time", "The delta must be a number.");
+  const draft = new Draft(nodes);
+  validateRefs(draft, refs);
+  const min = _nullishCoalesce(options.min, () => ( 0));
+  const max = _nullishCoalesce(options.max, () => ( Infinity));
+  let low = -Infinity;
+  let high = Infinity;
+  for (const ref of refs) {
+    const time = draft.keys(ref.nodeId, ref.property)[draft.find(ref)].time;
+    low = Math.max(low, min - time);
+    high = Math.min(high, max - time);
+  }
+  if (low > high + ANIMATION_TIME_EPSILON) throw new AnimationEditError("no_movement_range", "The keyframes have no common movement range.");
+  const applied = Math.min(high, Math.max(low, delta));
+  const moved = refs.map((ref) => ({ ...ref, time: draft.keys(ref.nodeId, ref.property)[draft.find(ref)].time + applied }));
+  if (Math.abs(applied) <= ANIMATION_TIME_EPSILON) return { nodes, delta: 0, refs: refs.map((r) => ({ ...r })) };
+  retime(draft, refs, (time) => time + applied);
+  return { nodes: draft.commit(), delta: applied, refs: moved };
+}
+function retime(draft, refs, map) {
+  const lanes = /* @__PURE__ */ new Map();
+  for (const ref of refs) lanes.set(refKey(ref), [..._nullishCoalesce(lanes.get(refKey(ref)), () => ( [])), ref]);
+  for (const lane of lanes.values()) {
+    const { nodeId, property } = lane[0];
+    const keys = draft.keys(nodeId, property);
+    const picked = keys.filter((k) => lane.some((r) => sameTime(r.time, k.time)));
+    const movedKeys = picked.map((k) => ({ ...k, time: map(k.time) }));
+    const rest = keys.filter((k) => !picked.includes(k) && !movedKeys.some((m) => sameTime(m.time, k.time)));
+    draft.setKeys(nodeId, property, [...rest, ...movedKeys]);
+  }
+}
+function scaleKeyframes(nodes, refs, factor, options = {}) {
+  if (typeof factor !== "number" || !Number.isFinite(factor) || factor <= 0) throw new AnimationEditError("invalid_factor", "The scale factor must be a positive number.");
+  const draft = new Draft(nodes);
+  validateRefs(draft, refs);
+  const times = refs.map((ref) => draft.keys(ref.nodeId, ref.property)[draft.find(ref)].time);
+  const pivot = _nullishCoalesce(options.pivot, () => ( Math.min(...times)));
+  const min = _nullishCoalesce(options.min, () => ( 0));
+  const max = _nullishCoalesce(options.max, () => ( Infinity));
+  let applied = factor;
+  for (const t of times) {
+    if (t > pivot && Number.isFinite(max)) applied = Math.min(applied, (max - pivot) / (t - pivot));
+    if (t < pivot) applied = Math.min(applied, (pivot - min) / (pivot - t));
+  }
+  applied = Math.max(applied, Number.EPSILON);
+  const map = (t) => pivot + (t - pivot) * applied;
+  if (Math.abs(applied - 1) <= 1e-12) return { nodes, factor: 1, refs: refs.map((r) => ({ ...r })) };
+  retime(draft, refs, map);
+  return { nodes: draft.commit(), factor: applied, refs: refs.map((r, i) => ({ ...r, time: map(times[i]) })) };
+}
+function getKeyframeTimes(nodes, options = {}) {
+  const only = options.ids ? new Set(options.ids) : null;
+  const excluded = /* @__PURE__ */ new Map();
+  for (const ref of _nullishCoalesce(options.exclude, () => ( []))) excluded.set(refKey(ref), [..._nullishCoalesce(excluded.get(refKey(ref)), () => ( [])), ref.time]);
+  const times = [];
+  for (const node of nodes) {
+    if (only && !only.has(node.id)) continue;
+    const animation = getNodeAnimation(node);
+    if (!animation) continue;
+    for (const [property, track] of Object.entries(animation.tracks)) {
+      const skip = _nullishCoalesce(excluded.get(refKey({ nodeId: node.id, property })), () => ( []));
+      for (const k of normalizeKeyframes(_optionalChain([track, 'optionalAccess', _232 => _232.keyframes]))) if (!skip.some((t) => sameTime(t, k.time))) times.push(k.time);
+    }
+  }
+  times.sort((a, b) => a - b);
+  return times.filter((t, i) => i === 0 || !sameTime(t, times[i - 1]));
+}
+function snapKeyframeDelta(times, delta, targets, threshold) {
+  const sorted = [...targets].filter(Number.isFinite).sort((a, b) => a - b);
+  let best = null;
+  for (const time of times) {
+    const at = time + delta;
+    let lo = 0;
+    let hi = sorted.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (sorted[mid] < at) lo = mid + 1;
+      else hi = mid;
+    }
+    for (const i of [lo - 1, lo]) {
+      const target = sorted[i];
+      if (target === void 0) continue;
+      const distance = Math.abs(target - at);
+      if (distance <= threshold && (!best || distance < best.distance)) best = { distance, target, delta: delta + (target - at) };
+    }
+  }
+  return best ? { delta: best.delta, target: best.target } : { delta, target: null };
+}
+function copyKeyframes(nodes, refs) {
+  const draft = new Draft(nodes);
+  validateRefs(draft, refs);
+  const found = refs.map((ref) => ({ ref, key: draft.keys(ref.nodeId, ref.property)[draft.find(ref)] }));
+  const start = Math.min(...found.map((f) => f.key.time));
+  return {
+    type: "pixerate/keyframes",
+    version: 1,
+    keyframes: found.map(({ ref, key }) => ({
+      nodeId: ref.nodeId,
+      property: ref.property,
+      offset: key.time - start,
+      value: key.value,
+      ...key.easing !== void 0 ? { easing: key.easing } : {}
+    }))
+  };
+}
+function parseKeyframeClipboard(input) {
+  let value = input;
+  if (typeof input === "string") {
+    if (input.length > 5e6) return null;
+    try {
+      value = JSON.parse(input);
+    } catch (e10) {
+      return null;
+    }
+  }
+  if (typeof value !== "object" || value === null) return null;
+  const clip = value;
+  if (clip.type !== "pixerate/keyframes" || clip.version !== 1 || !Array.isArray(clip.keyframes)) return null;
+  const keyframes = clip.keyframes.filter(
+    (k) => k && typeof k.nodeId === "string" && typeof k.property === "string" && typeof k.offset === "number" && Number.isFinite(k.offset) && (typeof k.value === "number" && Number.isFinite(k.value) || typeof k.value === "string") && (k.easing === void 0 || isAnimationEasing(k.easing))
+  );
+  return keyframes.length > 0 ? { type: "pixerate/keyframes", version: 1, keyframes } : null;
+}
+function pasteKeyframes(nodes, clipboard, time, options = {}) {
+  const draft = new Draft(nodes, options);
+  const t = coerceTime(time);
+  const sources = [...new Set(clipboard.keyframes.map((k) => k.nodeId))];
+  const targetsOf = (source) => {
+    if (!options.nodeIds || options.nodeIds.length === 0) return [source];
+    if (sources.length === 1) return [...options.nodeIds];
+    const i = sources.indexOf(source);
+    return i < options.nodeIds.length ? [options.nodeIds[i]] : [];
+  };
+  const refs = [];
+  for (const k of clipboard.keyframes) {
+    const p = draft.property(k.property);
+    if (!p) continue;
+    for (const target of targetsOf(k.nodeId)) {
+      if (!draft.has(target)) continue;
+      let value;
+      try {
+        value = coerceValue(p, k.value);
+      } catch (e11) {
+        continue;
+      }
+      const at = t + Math.max(0, k.offset);
+      putKey(draft, target, k.property, at, value, k.easing, false);
+      refs.push({ nodeId: target, property: k.property, time: at });
+    }
+  }
+  return { nodes: draft.commit(), refs };
+}
+var sameValue = (a, b) => typeof a === "number" && typeof b === "number" ? Math.abs(a - b) <= 1e-9 : a === b;
+function recordAnimationChanges(base, before, after, time, options = {}) {
+  const properties = (_nullishCoalesce(options.properties, () => ( ANIMATABLE_PROPERTIES))).filter((p) => p.key !== "motionPath");
+  const baseById = new Map(base.map((n) => [n.id, n]));
+  const beforeById = new Map(before.map((n) => [n.id, n]));
+  const t = coerceTime(time);
+  const keyed = [];
+  const out = after.map((next) => {
+    const stored = baseById.get(next.id);
+    const shown = beforeById.get(next.id);
+    if (!stored) return next;
+    if (shown === next) return stored;
+    const animation = getNodeAnimation(stored);
+    let result = next;
+    let tracks = null;
+    const tracksOf = () => tracks ??= { ..._nullishCoalesce(_optionalChain([animation, 'optionalAccess', _233 => _233.tracks]), () => ( {})) };
+    for (const p of properties) {
+      const track = getAnimationTrack(stored, p.key);
+      const animated = !!track && track.enabled !== false;
+      const now = p.read(next);
+      const was = shown ? p.read(shown) : void 0;
+      const changed = !!shown && now !== void 0 && !sameValue(now, was);
+      const restore = () => {
+        const value = p.read(stored);
+        if (value !== void 0) result = p.write(result, value);
+      };
+      if (animated) {
+        if (changed) {
+          const keys = normalizeKeyframes(track.keyframes).filter((k) => !sameTime(k.time, t));
+          const before2 = [...keys].reverse().find((k) => k.time < t);
+          keys.push({ time: t, value: now, ..._optionalChain([before2, 'optionalAccess', _234 => _234.easing]) !== void 0 ? { easing: before2.easing } : {} });
+          tracksOf()[p.key] = { ...track, keyframes: keys.sort((a, b) => a.time - b.time) };
+          keyed.push({ nodeId: next.id, property: p.key, time: t });
+        }
+        restore();
+      } else if (changed && options.recording && !track) {
+        const keys = [];
+        if (t > ANIMATION_TIME_EPSILON && was !== void 0) keys.push({ time: 0, value: was });
+        keys.push({ time: t, value: now });
+        tracksOf()[p.key] = { keyframes: keys };
+        keyed.push({ nodeId: next.id, property: p.key, time: t });
+        restore();
+      }
+    }
+    if (tracks) result = withNodeAnimation(result, { ..._nullishCoalesce(animation, () => ( {})), tracks });
+    return result;
+  });
+  return { nodes: out, keyed };
+}
+function animateNode(nodes, nodeId, options) {
+  const draft = new Draft(nodes, options);
+  const node = draft.node(nodeId);
+  const start = coerceTime(_nullishCoalesce(options.delay, () => ( 0)));
+  const duration = _nullishCoalesce(options.duration, () => ( 1e3));
+  if (typeof duration !== "number" || !Number.isFinite(duration) || duration <= 0) throw new AnimationEditError("invalid_time", "The duration must be positive.");
+  const easing = options.easing === void 0 ? void 0 : coerceEasing(options.easing);
+  const entries = Object.entries(_nullishCoalesce(options.to, () => ( {})));
+  if (entries.length === 0) throw new AnimationEditError("invalid_value", "Name at least one property to animate.");
+  const refs = [];
+  const writes = [];
+  for (const [key, target] of entries) {
+    const p = draft.property(key);
+    if (!p || key === "motionPath" && !_optionalChain([getNodeAnimation, 'call', _235 => _235(node), 'optionalAccess', _236 => _236.motionPath])) {
+      throw new AnimationEditError("unknown_property", `"${key}" cannot be animated${p ? " without a motion path" : ""}.`);
+    }
+    const from = _nullishCoalesce(_optionalChain([options, 'access', _237 => _237.from, 'optionalAccess', _238 => _238[key]]), () => ( (key === "motionPath" ? 0 : getAnimatedValue(node, key, start, options))));
+    if (from === void 0) throw new AnimationEditError("invalid_value", `"${nodeId}" has no ${key} to animate from; pass "from".`);
+    writes.push([key, coerceValue(p, from), coerceValue(p, target)]);
+  }
+  for (const [key, from, to] of writes) {
+    putKey(draft, nodeId, key, start, from, easing);
+    putKey(draft, nodeId, key, start + duration, to, void 0, false);
+    refs.push({ nodeId, property: key, time: start }, { nodeId, property: key, time: start + duration });
+  }
+  return { nodes: draft.commit(), refs };
+}
+
+// src/canvas/animation/player.ts
+var AnimationPlayer = (_class9 = class {
+  
+  
+  
+  
+  
+  __init22() {this.playing = false}
+  __init23() {this.scrubbing = false}
+  __init24() {this.resumeAfterScrub = false}
+  
+  
+  /** Unwrapped time at `anchorAt` (keeps the ping-pong direction across frames). */
+  __init25() {this.anchorRaw = 0}
+  __init26() {this.anchorAt = 0}
+  __init27() {this.generation = 0}
+  
+  __init28() {this.listeners = /* @__PURE__ */ new Set()}
+  constructor(options = {}) {;_class9.prototype.__init22.call(this);_class9.prototype.__init23.call(this);_class9.prototype.__init24.call(this);_class9.prototype.__init25.call(this);_class9.prototype.__init26.call(this);_class9.prototype.__init27.call(this);_class9.prototype.__init28.call(this);
+    this.clock = _nullishCoalesce(options.clock, () => ( realClock));
+    this.durationSource = _nullishCoalesce(options.duration, () => ( 1e3));
+    this.loop = _nullishCoalesce(options.loop, () => ( "none"));
+    this.rate = Number.isFinite(options.playbackRate) && options.playbackRate !== 0 ? options.playbackRate : 1;
+    this.onTime = options.onTime;
+    this.onEnd = options.onEnd;
+    this.time = this.clamp(_nullishCoalesce(options.time, () => ( 0)));
+    this.cached = this.snapshot();
+  }
+  /** Current timeline length (ms). */
+  get duration() {
+    const d = typeof this.durationSource === "function" ? this.durationSource() : this.durationSource;
+    return Number.isFinite(d) && d > 0 ? d : 0;
+  }
+  get currentTime() {
+    return this.time;
+  }
+  get isPlaying() {
+    return this.playing;
+  }
+  getState() {
+    return this.cached;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Replaces the callbacks (hooks keep them current without recreating the player). */
+  setCallbacks(callbacks) {
+    this.onTime = callbacks.onTime;
+    this.onEnd = callbacks.onEnd;
+  }
+  setDuration(duration) {
+    this.durationSource = duration;
+    this.time = this.clamp(this.time);
+    this.emit(false);
+  }
+  setLoop(loop) {
+    if (loop === this.loop) return;
+    this.reanchor();
+    this.loop = loop;
+    this.emit(false);
+  }
+  setPlaybackRate(rate) {
+    if (!Number.isFinite(rate) || rate === 0 || rate === this.rate) return;
+    this.reanchor();
+    this.rate = rate;
+    this.emit(false);
+  }
+  /** Starts playing from the playhead (from the start again when a one-shot play had ended). */
+  play() {
+    if (this.playing) return;
+    const d = this.duration;
+    if (this.loop === "none" && d > 0) {
+      if (this.rate > 0 && this.time >= d) this.time = 0;
+      if (this.rate < 0 && this.time <= 0) this.time = d;
+    }
+    this.playing = true;
+    this.scrubbing = false;
+    this.anchorRaw = this.time;
+    this.anchorAt = this.clock.now();
+    this.emit(false);
+    this.schedule();
+  }
+  pause() {
+    if (!this.playing) return;
+    this.tick(false);
+    this.playing = false;
+    this.generation++;
+    this.emit(true);
+  }
+  toggle() {
+    if (this.playing) this.pause();
+    else this.play();
+  }
+  /** Pauses and returns to the start. */
+  stop() {
+    this.playing = false;
+    this.generation++;
+    this.seek(0);
+  }
+  /** Moves the playhead (clamped to the timeline); playback continues from there. */
+  seek(time) {
+    if (!Number.isFinite(time)) return;
+    this.time = this.clamp(time);
+    this.anchorRaw = this.time;
+    this.anchorAt = this.clock.now();
+    this.emit(true);
+  }
+  /** Seeks while dragging the playhead: playback pauses until `endScrub`. */
+  scrub(time) {
+    if (!this.scrubbing) {
+      this.resumeAfterScrub = this.playing;
+      if (this.playing) {
+        this.playing = false;
+        this.generation++;
+      }
+      this.scrubbing = true;
+    }
+    this.seek(time);
+  }
+  /** Ends a scrub, resuming playback if it was playing when the scrub began. */
+  endScrub() {
+    if (!this.scrubbing) return;
+    this.scrubbing = false;
+    const resume = this.resumeAfterScrub;
+    this.resumeAfterScrub = false;
+    if (resume) this.play();
+    else this.emit(false);
+  }
+  /** Stops scheduling frames and drops listeners. */
+  destroy() {
+    this.playing = false;
+    this.generation++;
+    this.listeners.clear();
+  }
+  clamp(time) {
+    return Math.min(this.duration, Math.max(0, Number.isFinite(time) ? time : 0));
+  }
+  reanchor() {
+    if (!this.playing) return;
+    this.tick(false);
+    this.anchorRaw = this.rawNow();
+    this.anchorAt = this.clock.now();
+  }
+  rawNow() {
+    return this.anchorRaw + (this.clock.now() - this.anchorAt) * this.rate;
+  }
+  schedule() {
+    const generation = this.generation;
+    this.clock.frame().then(() => {
+      if (generation !== this.generation || !this.playing) return;
+      this.tick(true);
+      if (this.playing) this.schedule();
+    });
+  }
+  /** Advances the playhead to the clock's time; `notify` emits the change. */
+  tick(notify) {
+    if (!this.playing) return;
+    const d = this.duration;
+    const raw = this.rawNow();
+    let ended = false;
+    if (this.loop === "none" || d <= 0) {
+      if (this.rate > 0 && raw >= d) {
+        this.time = d;
+        ended = true;
+      } else if (this.rate < 0 && raw <= 0) {
+        this.time = 0;
+        ended = true;
+      } else this.time = this.clamp(raw);
+    } else {
+      this.time = wrapAnimationTime(raw, d, this.loop);
+    }
+    if (ended) {
+      this.playing = false;
+      this.generation++;
+    }
+    if (notify || ended) this.emit(true);
+    if (ended) _optionalChain([this, 'access', _239 => _239.onEnd, 'optionalCall', _240 => _240()]);
+  }
+  snapshot() {
+    return {
+      time: this.time,
+      playing: this.playing,
+      scrubbing: this.scrubbing,
+      loop: this.loop,
+      playbackRate: this.rate,
+      duration: this.duration
+    };
+  }
+  emit(timeChanged) {
+    const next = this.snapshot();
+    const prev = this.cached;
+    if (prev.time === next.time && prev.playing === next.playing && prev.scrubbing === next.scrubbing && prev.loop === next.loop && prev.playbackRate === next.playbackRate && prev.duration === next.duration) {
+      return;
+    }
+    this.cached = next;
+    if (timeChanged && prev.time !== next.time) _optionalChain([this, 'access', _241 => _241.onTime, 'optionalCall', _242 => _242(next.time)]);
+    for (const listener of this.listeners) listener(next);
+  }
+}, _class9);
+function createAnimationPlayer(options) {
+  return new AnimationPlayer(options);
+}
+
+// src/canvas/animation/export.ts
+function sampleAnimationFrames(doc, options = {}) {
+  const fps = _nullishCoalesce(options.fps, () => ( 30));
+  if (!(fps > 0) || !Number.isFinite(fps)) throw new RangeError("fps must be a positive number.");
+  const start = _nullishCoalesce(options.start, () => ( 0));
+  const duration = Math.max(0, _nullishCoalesce(options.duration, () => ( getAnimationDuration(doc) - start)));
+  const step = 1e3 / fps;
+  const count = Math.floor(duration / step + 1e-9) + 1;
+  if (count > (_nullishCoalesce(options.maxFrames, () => ( 1e5)))) throw new RangeError(`Sampling would produce ${count} frames.`);
+  const frames = [];
+  for (let i = 0; i < count; i++) {
+    const time = start + i * step;
+    frames.push({ index: i, time, overrides: evaluateAnimation(doc, time, options) });
+  }
+  return frames;
+}
+var CSS_ANIMATION_PROPERTIES = {
+  x: { css: "translate", camel: "translate" },
+  y: { css: "translate", camel: "translate" },
+  motionPath: { css: "translate", camel: "translate" },
+  rotation: { css: "rotate", camel: "rotate" },
+  scale: { css: "scale", camel: "scale" },
+  opacity: { css: "opacity", camel: "opacity" },
+  fill: { css: "background-color", camel: "backgroundColor" },
+  stroke: { css: "border-color", camel: "borderColor" },
+  strokeWidth: { css: "border-width", camel: "borderWidth" },
+  cornerRadius: { css: "border-radius", camel: "borderRadius" },
+  width: { css: "width", camel: "width" },
+  height: { css: "height", camel: "height" }
+};
+var round2 = (v) => Math.round(v * 1e3) / 1e3;
+function cssValue(source, value, node, partner, partnerSource) {
+  if (source === "x" || source === "y") {
+    const dx = source === "x" ? value - node.position.x : partner !== void 0 ? partner - node.position.x : 0;
+    const dy = source === "y" ? value - node.position.y : partner !== void 0 && partnerSource === "y" ? partner - node.position.y : 0;
+    return `${round2(dx)}px ${round2(dy)}px`;
+  }
+  if (typeof value === "string") return value;
+  switch (source) {
+    case "rotation":
+      return `${round2(value)}deg`;
+    case "scale":
+    case "opacity":
+      return String(round2(value));
+    default:
+      return `${round2(value)}px`;
+  }
+}
+var sameTimes = (a, b) => a.length === b.length && a.every((k, i) => Math.abs(k.time - b[i].time) < 1e-6 && JSON.stringify(_nullishCoalesce(k.easing, () => ( "linear"))) === JSON.stringify(_nullishCoalesce(b[i].easing, () => ( "linear"))));
+function needsOklab(keys) {
+  for (let i = 0; i + 1 < keys.length; i++) {
+    if (keys[i].easing !== "hold" && keys[i].value !== keys[i + 1].value) return true;
+  }
+  return false;
+}
+function exactStops(keys, duration, format) {
+  const stops = [];
+  if (keys[0].time > 0) stops.push({ offset: 0, value: format(keys[0], 0), easing: "linear" });
+  keys.forEach((k, i) => {
+    const next = keys[i + 1];
+    stops.push({
+      offset: Math.min(1, Math.max(0, k.time / duration)),
+      value: format(k, i),
+      ...next ? { easing: easingToCss(k.easing, next.time - k.time) } : {}
+    });
+  });
+  const last = keys[keys.length - 1];
+  if (last.time < duration) stops.push({ offset: 1, value: format(last, keys.length - 1) });
+  return stops;
+}
+function sampledStops(duration, fps, keyTimes, valueAt) {
+  const times = /* @__PURE__ */ new Set([0, duration, ...keyTimes.filter((t) => t >= 0 && t <= duration)]);
+  const step = 1e3 / Math.max(1, fps);
+  for (let t = step; t < duration; t += step) times.add(t);
+  return [...times].sort((a, b) => a - b).map((t) => ({ offset: Math.min(1, t / duration), value: valueAt(t), easing: "linear" }));
+}
+function getCssPropertyAnimations(nodes, nodeId, options = {}) {
+  const node = nodes.find((n) => n.id === nodeId);
+  const animation = getNodeAnimation(node);
+  if (!node || !animation) return [];
+  const duration = _nullishCoalesce(options.duration, () => ( getAnimationDuration([node])));
+  if (!(duration > 0)) return [];
+  const fps = _nullishCoalesce(options.sampleFps, () => ( 30));
+  const map = { ...CSS_ANIMATION_PROPERTIES, ..._nullishCoalesce(options.cssProperties, () => ( {})) };
+  const tracks = /* @__PURE__ */ new Map();
+  for (const [key, track] of Object.entries(animation.tracks)) {
+    if (!track || track.enabled === false || !map[key]) continue;
+    const keys = normalizeKeyframes(track.keyframes);
+    if (keys.length > 0) tracks.set(key, keys);
+  }
+  const typeOf = (key) => _nullishCoalesce(_optionalChain([ANIMATABLE_PROPERTIES, 'access', _243 => _243.find, 'call', _244 => _244((p) => p.key === key), 'optionalAccess', _245 => _245.type]), () => ( "number"));
+  const groups = /* @__PURE__ */ new Map();
+  for (const key of tracks.keys()) {
+    const css = map[key].css;
+    groups.set(css, [..._nullishCoalesce(groups.get(css), () => ( [])), key]);
+  }
+  const out = [];
+  for (const [css, sources] of groups) {
+    const camel2 = map[sources[0]].camel;
+    const keysOf = (k) => tracks.get(k);
+    const evalAt = (k, t) => evaluateTrack(keysOf(k), t, typeOf(k));
+    const allTimes = sources.flatMap((k) => keysOf(k).map((x) => x.time));
+    if (sources.includes("motionPath")) {
+      const position = (t) => {
+        const moved = ANIMATABLE_PROPERTIES.find((p) => p.key === "motionPath").write(node, evalAt("motionPath", t));
+        return `${round2(moved.position.x - node.position.x)}px ${round2(moved.position.y - node.position.y)}px`;
+      };
+      out.push({ property: css, camel: camel2, sources, stops: sampledStops(duration, fps, allTimes, position), exact: false });
+      continue;
+    }
+    if (sources.length === 2 && css === "translate") {
+      const [a, b] = sources[0] === "x" ? sources : [sources[1], sources[0]];
+      if (sameTimes(keysOf(a), keysOf(b))) {
+        const bKeys = keysOf(b);
+        out.push({ property: css, camel: camel2, sources, stops: exactStops(keysOf(a), duration, (k, i) => cssValue(a, k.value, node, bKeys[i].value, b)), exact: true });
+      } else {
+        out.push({
+          property: css,
+          camel: camel2,
+          sources,
+          stops: sampledStops(duration, fps, allTimes, (t) => cssValue(a, evalAt(a, t), node, evalAt(b, t), b)),
+          exact: false
+        });
+      }
+      continue;
+    }
+    const key = sources[sources.length - 1];
+    const keys = keysOf(key);
+    if (typeOf(key) === "color" && needsOklab(keys)) {
+      out.push({ property: css, camel: camel2, sources: [key], stops: sampledStops(duration, fps, allTimes, (t) => cssValue(key, evalAt(key, t), node)), exact: false });
+    } else {
+      out.push({ property: css, camel: camel2, sources: [key], stops: exactStops(keys, duration, (k) => cssValue(key, k.value, node)), exact: true });
+    }
+  }
+  return out;
+}
+function timing(options, duration) {
+  const rate = options.playbackRate && Number.isFinite(options.playbackRate) && options.playbackRate !== 0 ? options.playbackRate : 1;
+  const loop = _nullishCoalesce(options.loop, () => ( "none"));
+  return {
+    duration: round2(duration / Math.abs(rate)),
+    iterations: loop === "none" ? 1 : Infinity,
+    direction: loop === "ping-pong" ? rate < 0 ? "alternate-reverse" : "alternate" : rate < 0 ? "reverse" : "normal"
+  };
+}
+var cssIdent = (text) => text.replace(/[^A-Za-z0-9_-]/g, "-").replace(/^(\d)/, "_$1");
+function exportCssAnimation(nodes, nodeId, options = {}) {
+  const duration = _nullishCoalesce(options.duration, () => ( getAnimationDuration(nodes.filter((n) => n.id === nodeId))));
+  const props = getCssPropertyAnimations(nodes, nodeId, { ...options, duration });
+  const base = cssIdent(_nullishCoalesce(options.name, () => ( `anim-${nodeId}`)));
+  const t = timing(options, duration);
+  const blocks = [];
+  const parts = [];
+  const animations = [];
+  for (const prop of props) {
+    const name = `${base}-${cssIdent(prop.property)}`;
+    const lines = prop.stops.map((s) => {
+      const pct = `${round2(s.offset * 100)}%`;
+      const easing = s.easing ? ` animation-timing-function: ${s.easing};` : "";
+      return `  ${pct} { ${prop.property}: ${s.value};${easing} }`;
+    });
+    blocks.push(`@keyframes ${name} {
+${lines.join("\n")}
+}`);
+    parts.push(`${name} ${t.duration}ms linear 0ms ${t.iterations === Infinity ? "infinite" : 1} ${t.direction} both`);
+    animations.push({ name, property: prop.property, exact: prop.exact });
+  }
+  const animation = parts.join(", ");
+  const selector = _nullishCoalesce(options.selector, () => ( `[data-id="${nodeId.replace(/["\\]/g, "\\$&")}"]`));
+  const css = blocks.length ? `${blocks.join("\n\n")}
+
+${selector} {
+  animation: ${animation};
+}
+` : "";
+  return { css, animation, animations, exact: props.every((p) => p.exact) };
+}
+function toWebAnimations(nodes, nodeId, options = {}) {
+  const duration = _nullishCoalesce(options.duration, () => ( getAnimationDuration(nodes.filter((n) => n.id === nodeId))));
+  const t = timing(options, duration);
+  return getCssPropertyAnimations(nodes, nodeId, { ...options, duration }).map((prop) => ({
+    property: prop.property,
+    keyframes: prop.stops.map((s) => ({ offset: s.offset, [prop.camel]: s.value, ...s.easing ? { easing: s.easing } : {} })),
+    options: { duration: t.duration, iterations: t.iterations, direction: t.direction, fill: "both", easing: "linear" },
+    exact: prop.exact
+  }));
+}
+function playWebAnimations(element, specs) {
+  return specs.map((spec) => element.animate(spec.keyframes, spec.options));
+}
+function isCssExportExact(nodes, nodeId) {
+  return getCssPropertyAnimations(nodes, nodeId).every((p) => p.exact);
+}
+
+// src/canvas/animation/timeline.ts
+function isKeyframeSelected(selection, ref) {
+  return selection.some((s) => s.nodeId === ref.nodeId && s.property === ref.property && Math.abs(s.time - ref.time) <= ANIMATION_TIME_EPSILON);
+}
+var defaultLabel = (node) => typeof _optionalChain([node, 'access', _246 => _246.data, 'optionalAccess', _247 => _247.label]) === "string" && node.data.label.trim() ? node.data.label : node.id;
+function getTimelineRows(nodes, ids, options = {}) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const selection = _nullishCoalesce(options.selection, () => ( []));
+  const labelOf = _nullishCoalesce(options.labelOf, () => ( defaultLabel));
+  const rows = [];
+  for (const id of new Set(ids)) {
+    const node = byId.get(id);
+    if (!node) continue;
+    for (const property of getAnimatedProperties(node, options)) {
+      const track = getAnimationTrack(node, property);
+      const label = _nullishCoalesce(_optionalChain([(_nullishCoalesce(options.properties, () => ( ANIMATABLE_PROPERTIES))), 'access', _248 => _248.find, 'call', _249 => _249((p) => p.key === property), 'optionalAccess', _250 => _250.label]), () => ( property));
+      rows.push({
+        id: `${id}:${property}`,
+        nodeId: id,
+        nodeLabel: labelOf(node),
+        property,
+        label,
+        enabled: track.enabled !== false,
+        keyframes: normalizeKeyframes(track.keyframes).map((k) => {
+          const ref = { nodeId: id, property, time: k.time };
+          const selected = isKeyframeSelected(selection, ref);
+          return {
+            ref,
+            time: selected && options.dragDelta ? k.time + options.dragDelta : k.time,
+            value: k.value,
+            ...k.easing !== void 0 ? { easing: k.easing } : {},
+            selected
+          };
+        })
+      });
+    }
+  }
+  return rows;
+}
+function timeToX(time, duration, width) {
+  return duration > 0 ? time / duration * width : 0;
+}
+function xToTime(x, duration, width) {
+  if (!(width > 0) || !(duration > 0)) return 0;
+  return Math.min(duration, Math.max(0, x / width * duration));
+}
+function formatAnimationTime(ms) {
+  const s = Math.max(0, ms) / 1e3;
+  return `${s.toFixed(s < 10 ? 2 : 1)}s`;
+}
+var STEPS = [10, 20, 50, 100, 200, 250, 500, 1e3, 2e3, 5e3, 1e4, 15e3, 3e4, 6e4, 12e4, 3e5, 6e5];
+function getTimelineTicks(duration, width, minSpacing = 60) {
+  if (!(duration > 0) || !(width > 0)) return [];
+  const step = _nullishCoalesce(STEPS.find((s) => timeToX(s, duration, width) >= minSpacing), () => ( STEPS[STEPS.length - 1]));
+  const ticks = [];
+  for (let t = 0; t <= duration + 1e-6 && ticks.length < 1e3; t += step) {
+    ticks.push({ time: t, x: timeToX(t, duration, width), label: formatAnimationTime(t) });
+  }
+  return ticks;
+}
+
+// src/canvas/animation/controller.ts
+var uniq = (items) => [...new Set(items)];
+function createCanvasAnimationController(options) {
+  let fixedDuration = options.duration !== void 0 && options.duration > 0 ? options.duration : null;
+  let recording = _nullishCoalesce(options.recording, () => ( false));
+  let fps = options.fps && options.fps > 0 ? options.fps : 30;
+  let selection = [];
+  let drag = null;
+  let clipboard = null;
+  const listeners = /* @__PURE__ */ new Set();
+  const propertyOptions = () => options.properties ? { properties: options.properties } : {};
+  const durationOf = (nodes) => _nullishCoalesce(fixedDuration, () => ( Math.max(_nullishCoalesce(options.minDuration, () => ( 1e3)), getAnimationDuration(nodes))));
+  let durationNodes = null;
+  let durationValue = 0;
+  const duration = () => {
+    const nodes = options.getNodes();
+    if (nodes !== durationNodes) {
+      durationNodes = nodes;
+      durationValue = durationOf(nodes);
+    }
+    return _nullishCoalesce(fixedDuration, () => ( durationValue));
+  };
+  const player = new AnimationPlayer({
+    clock: options.clock,
+    duration,
+    loop: options.loop,
+    playbackRate: options.playbackRate,
+    onTime: (time) => _optionalChain([options, 'access', _251 => _251.onTime, 'optionalCall', _252 => _252(time)])
+  });
+  let cached = null;
+  const snapshot = () => ({
+    ...player.getState(),
+    duration: duration(),
+    recording,
+    fps,
+    selection,
+    drag,
+    autoDuration: fixedDuration === null
+  });
+  const getState = () => {
+    const next = snapshot();
+    if (cached && cached.time === next.time && cached.playing === next.playing && cached.scrubbing === next.scrubbing && cached.loop === next.loop && cached.playbackRate === next.playbackRate && cached.duration === next.duration && cached.recording === next.recording && cached.fps === next.fps && cached.selection === next.selection && cached.drag === next.drag && cached.autoDuration === next.autoDuration) {
+      return cached;
+    }
+    cached = next;
+    return cached;
+  };
+  const notify = () => {
+    const state = getState();
+    _optionalChain([options, 'access', _253 => _253.onChange, 'optionalCall', _254 => _254(state)]);
+    for (const listener of listeners) listener(state);
+  };
+  player.subscribe(notify);
+  const selectedIds = () => _nullishCoalesce(_optionalChain([options, 'access', _255 => _255.getSelectedIds, 'optionalCall', _256 => _256()]), () => ( options.getNodes().filter((n) => n.selected).map((n) => n.id)));
+  const KEEP_FIELDS = ["selected", "dragging", "measured"];
+  const replaceNodes = (nodes, replacements, animationOnly = false) => nodes.map((node) => {
+    const replacement = replacements.get(node.id);
+    if (!replacement) return node;
+    if (animationOnly) {
+      const data = { ..._nullishCoalesce(node.data, () => ( {})) };
+      const value = _optionalChain([replacement, 'access', _257 => _257.data, 'optionalAccess', _258 => _258[ANIMATION_DATA_KEY]]);
+      if (value === void 0) delete data[ANIMATION_DATA_KEY];
+      else data[ANIMATION_DATA_KEY] = value;
+      return { ...node, data };
+    }
+    const next = { ...replacement };
+    for (const field of KEEP_FIELDS) {
+      if (field in node) next[field] = node[field];
+      else delete next[field];
+    }
+    return next;
+  });
+  function commit(name, edit, merge) {
+    const before = options.getNodes();
+    const after = edit(before);
+    if (after === before) return false;
+    const beforeById = new Map(before.map((n) => [n.id, n]));
+    const undoMap = /* @__PURE__ */ new Map();
+    const redoMap = /* @__PURE__ */ new Map();
+    for (const node of after) {
+      const old = beforeById.get(node.id);
+      if (old && old !== node) {
+        undoMap.set(node.id, old);
+        redoMap.set(node.id, node);
+      }
+    }
+    if (redoMap.size === 0) return false;
+    const scope = _nullishCoalesce(_optionalChain([merge, 'optionalAccess', _259 => _259.animationOnly]), () => ( false));
+    const execute = () => options.setNodes(replaceNodes(options.getNodes(), redoMap, scope));
+    const undo = () => options.setNodes(replaceNodes(options.getNodes(), undoMap, scope));
+    const command = { name, execute, undo, ...merge ? { tag: merge.tag } : {} };
+    if (!options.history) execute();
+    else if (merge && options.history.executeMerged) options.history.executeMerged(command, { windowMs: _nullishCoalesce(merge.windowMs, () => ( 1e3)) });
+    else options.history.execute(command);
+    return true;
+  }
+  function pruneSelection() {
+    if (selection.length === 0) return;
+    const byId = new Map(options.getNodes().map((n) => [n.id, n]));
+    const kept = selection.filter((ref) => {
+      const track = _optionalChain([getNodeAnimation, 'call', _260 => _260(byId.get(ref.nodeId)), 'optionalAccess', _261 => _261.tracks, 'access', _262 => _262[ref.property]]);
+      return !!track && normalizeKeyframes(track.keyframes).some((k) => Math.abs(k.time - ref.time) <= ANIMATION_TIME_EPSILON);
+    });
+    if (kept.length !== selection.length) selection = kept;
+  }
+  const setSelection = (refs) => {
+    selection = refs.map((r) => ({ nodeId: r.nodeId, property: r.property, time: r.time }));
+  };
+  let displayCache = null;
+  function display(nodes = options.getNodes()) {
+    const time = player.currentTime;
+    if (displayCache && displayCache.nodes === nodes && displayCache.time === time) return displayCache.out;
+    const out = applyAnimation(nodes, time, propertyOptions());
+    displayCache = { nodes, time, out };
+    return out;
+  }
+  const controller = {
+    player,
+    getState,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    /** Re-reads node-derived state (the automatic duration) and notifies when it changed. */
+    refresh() {
+      const prev = cached;
+      if (getState() !== prev) notify();
+    },
+    // ----- playback ---------------------------------------------------------------------
+    get time() {
+      return player.currentTime;
+    },
+    get playing() {
+      return player.isPlaying;
+    },
+    get duration() {
+      return duration();
+    },
+    play: () => player.play(),
+    pause: () => player.pause(),
+    toggle: () => player.toggle(),
+    stop: () => player.stop(),
+    seek: (time) => player.seek(time),
+    scrub: (time) => player.scrub(time),
+    endScrub: () => player.endScrub(),
+    setLoop: (loop) => player.setLoop(loop),
+    setPlaybackRate: (rate) => player.setPlaybackRate(rate),
+    /** Fixed duration in ms, or `null` to follow the last keyframe. */
+    setDuration(ms) {
+      fixedDuration = ms !== null && Number.isFinite(ms) && ms > 0 ? ms : null;
+      durationNodes = null;
+      player.setDuration(duration);
+      notify();
+    },
+    setFps(value) {
+      if (!(value > 0) || value === fps) return;
+      fps = value;
+      notify();
+    },
+    setRecording(on) {
+      if (recording === on) return;
+      recording = on;
+      notify();
+    },
+    toggleRecording() {
+      controller.setRecording(!recording);
+    },
+    /** Seeks to the next keyframe (of the selected nodes, or all) after the playhead. */
+    nextKeyframe(ids = selectedIds()) {
+      const list = [...ids];
+      const times = getKeyframeTimes(options.getNodes(), list.length ? { ids: list } : {});
+      const next = times.find((t) => t > player.currentTime + ANIMATION_TIME_EPSILON);
+      if (next === void 0) return null;
+      player.seek(next);
+      return next;
+    },
+    previousKeyframe(ids = selectedIds()) {
+      const list = [...ids];
+      const times = getKeyframeTimes(options.getNodes(), list.length ? { ids: list } : {});
+      const prev = [...times].reverse().find((t) => t < player.currentTime - ANIMATION_TIME_EPSILON);
+      if (prev === void 0) return null;
+      player.seek(prev);
+      return prev;
+    },
+    // ----- display ----------------------------------------------------------------------
+    /** The nodes evaluated at the playhead (same array when nothing is animated). */
+    display,
+    /**
+     * Applies edits made on the displayed nodes: animated properties (and, in record mode,
+     * any property) are keyed at the playhead; other changes go to the stored nodes.
+     * Keying is one undo step per node set, merged while a drag continues.
+     */
+    applyDisplayChanges(next) {
+      const base = options.getNodes();
+      const shown = display(base);
+      const time = player.currentTime;
+      const { nodes, keyed } = recordAnimationChanges(base, shown, next, time, { recording, ...propertyOptions() });
+      if (keyed.length === 0) {
+        if (nodes !== base) options.setNodes(nodes);
+        return [];
+      }
+      const ids = new Set(keyed.map((k) => k.nodeId));
+      const baseById = new Map(base.map((n) => [n.id, n]));
+      const staticNodes = nodes.map((n) => {
+        if (!ids.has(n.id)) return n;
+        const old = _optionalChain([baseById, 'access', _263 => _263.get, 'call', _264 => _264(n.id), 'optionalAccess', _265 => _265.data, 'optionalAccess', _266 => _266[ANIMATION_DATA_KEY]]);
+        const data = { ..._nullishCoalesce(n.data, () => ( {})) };
+        if (old === void 0) delete data[ANIMATION_DATA_KEY];
+        else data[ANIMATION_DATA_KEY] = old;
+        return { ...n, data };
+      });
+      const animationOf = new Map(nodes.filter((n) => ids.has(n.id)).map((n) => [n.id, _optionalChain([n, 'access', _267 => _267.data, 'optionalAccess', _268 => _268[ANIMATION_DATA_KEY]])]));
+      options.setNodes(staticNodes);
+      const tag = `animation.record:${[...ids].sort().join(",")}`;
+      commit(
+        "Record Keyframe",
+        (current) => current.map((n) => {
+          if (!animationOf.has(n.id)) return n;
+          const data = { ..._nullishCoalesce(n.data, () => ( {})) };
+          const value = animationOf.get(n.id);
+          if (value === void 0) delete data[ANIMATION_DATA_KEY];
+          else data[ANIMATION_DATA_KEY] = value;
+          return { ...n, data };
+        }),
+        { tag, animationOnly: true }
+      );
+      return keyed;
+    },
+    // ----- editing ----------------------------------------------------------------------
+    /** Keys the nodes (default: selected) at the playhead; see `addKeyframesAtTime`. */
+    addKeyframe(ids, keys, time = player.currentTime) {
+      let refs = [];
+      commit("Add Keyframe", (nodes) => {
+        const result = addKeyframesAtTime(nodes, _nullishCoalesce(ids, () => ( selectedIds())), time, { ...propertyOptions(), ...keys ? { keys } : {} });
+        refs = result.refs;
+        return result.nodes;
+      });
+      if (refs.length) setSelection(refs);
+      notify();
+      return refs;
+    },
+    setKeyframe(nodeId, property, value, time = player.currentTime, easing) {
+      commit("Set Keyframe", (nodes) => setKeyframe(nodes, nodeId, property, time, value, { ...propertyOptions(), ...easing !== void 0 ? { easing } : {} }));
+    },
+    updateKeyframe(ref, patch) {
+      commit("Edit Keyframe", (nodes) => updateKeyframe(nodes, ref, patch, propertyOptions()));
+      if (patch.time !== void 0 && isKeyframeSelected(selection, ref)) {
+        setSelection(selection.map((s) => isKeyframeSelected([ref], s) ? { ...s, time: Math.max(0, patch.time) } : s));
+      }
+      pruneSelection();
+      notify();
+    },
+    deleteKeyframes(refs = selection) {
+      if (refs.length === 0) return false;
+      const changed = commit(refs.length === 1 ? "Delete Keyframe" : "Delete Keyframes", (nodes) => deleteKeyframes(nodes, refs, propertyOptions()));
+      pruneSelection();
+      notify();
+      return changed;
+    },
+    setEasing(easing, refs = selection) {
+      if (refs.length === 0) return false;
+      return commit("Set Easing", (nodes) => setKeyframeEasing(nodes, refs, easing, propertyOptions()));
+    },
+    setTrackEnabled(nodeId, property, enabled) {
+      commit(enabled ? "Enable Track" : "Disable Track", (nodes) => setTrackEnabled(nodes, nodeId, property, enabled));
+    },
+    removeTrack(nodeId, property) {
+      commit("Remove Track", (nodes) => removeTrack(nodes, nodeId, property, { ...propertyOptions(), keepValueAt: player.currentTime }));
+      pruneSelection();
+      notify();
+    },
+    setMotionPath(nodeId, motionPath) {
+      commit("Set Motion Path", (nodes) => setMotionPath(nodes, nodeId, motionPath));
+    },
+    /** Animates a node to `to` (from its current values) over `duration`; see `animateNode`. */
+    animateNode(nodeId, opts) {
+      let refs = [];
+      commit("Animate", (nodes) => {
+        const result = animateNode(nodes, nodeId, { ...opts, ...propertyOptions() });
+        refs = result.refs;
+        return result.nodes;
+      });
+      return refs;
+    },
+    /** Moves keyframes (default: selected) by `delta` ms as one step; returns the delta applied. */
+    moveKeyframes(delta, refs = selection) {
+      if (refs.length === 0) return 0;
+      let applied = 0;
+      let moved = [];
+      commit(refs.length === 1 ? "Move Keyframe" : "Move Keyframes", (nodes) => {
+        const result = moveKeyframes(nodes, refs, delta);
+        applied = result.delta;
+        moved = result.refs;
+        return result.nodes;
+      });
+      if (applied !== 0 && refs === selection) setSelection(moved);
+      notify();
+      return applied;
+    },
+    /** Scales keyframe spacing (default: selected) around `pivot`; returns the factor applied. */
+    scaleKeyframes(factor, refs = selection, pivot) {
+      if (refs.length === 0) return 1;
+      let applied = 1;
+      let scaled = [];
+      commit("Scale Keyframes", (nodes) => {
+        const result = scaleKeyframes(nodes, refs, factor, pivot === void 0 ? {} : { pivot });
+        applied = result.factor;
+        scaled = result.refs;
+        return result.nodes;
+      });
+      if (applied !== 1 && refs === selection) setSelection(scaled);
+      notify();
+      return applied;
+    },
+    copyKeyframes(refs = selection) {
+      if (refs.length === 0) return null;
+      clipboard = copyKeyframes(options.getNodes(), refs);
+      return clipboard;
+    },
+    /** Pastes at the playhead onto the selected nodes (or the copied ones). */
+    pasteKeyframes(data = clipboard, nodeIds = selectedIds(), time = player.currentTime) {
+      if (!data) return [];
+      let refs = [];
+      commit("Paste Keyframes", (nodes) => {
+        const result = pasteKeyframes(nodes, data, time, { ...propertyOptions(), nodeIds });
+        refs = result.refs;
+        return result.nodes;
+      });
+      if (refs.length) setSelection(refs);
+      notify();
+      return refs;
+    },
+    get clipboard() {
+      return clipboard;
+    },
+    // ----- selection & drag -------------------------------------------------------------
+    get selection() {
+      return selection;
+    },
+    selectKeyframes(refs, mode = "replace") {
+      if (mode === "replace") setSelection([...refs]);
+      else if (mode === "add") setSelection([...selection, ...refs.filter((r) => !isKeyframeSelected(selection, r))]);
+      else {
+        const removed = selection.filter((s) => !isKeyframeSelected(refs, s));
+        setSelection([...removed, ...refs.filter((r) => !isKeyframeSelected(selection, r))]);
+      }
+      notify();
+    },
+    clearSelection() {
+      if (selection.length === 0) return;
+      selection = [];
+      notify();
+    },
+    /** Starts dragging keyframes (default: the selection; refs not selected become the selection). */
+    beginKeyframeDrag(refs) {
+      if (refs && !refs.every((r) => isKeyframeSelected(selection, r))) setSelection([...refs]);
+      if (selection.length === 0) return;
+      drag = { refs: selection.map((r) => ({ ...r })), delta: 0, target: null };
+      notify();
+    },
+    /**
+     * Previews the drag at `delta` ms. With `snap` (default on) the group snaps to other
+     * keyframes, the playhead, 0 and the end within `thresholdMs`, else to whole frames.
+     */
+    updateKeyframeDrag(delta, opts = {}) {
+      if (!drag) return null;
+      const nodes = options.getNodes();
+      const times = drag.refs.map((r) => r.time);
+      const minTime = Math.min(...times);
+      let d = Math.max(-minTime, Number.isFinite(delta) ? delta : 0);
+      let target = null;
+      if (opts.snap !== false) {
+        const targets = uniq([...getKeyframeTimes(nodes, { exclude: drag.refs }), player.currentTime, 0, duration()]);
+        const snapped = snapKeyframeDelta(times, d, targets, _nullishCoalesce(opts.thresholdMs, () => ( 1e3 / fps / 2)));
+        target = snapped.target;
+        d = snapped.delta;
+        if (target === null) d = snapTimeToFrame(minTime + d, fps) - minTime;
+      }
+      d = Math.max(-minTime, d);
+      if (d !== drag.delta || target !== drag.target) {
+        drag = { ...drag, delta: d, target };
+        notify();
+      }
+      return drag;
+    },
+    /** Commits the drag as one undo step. */
+    endKeyframeDrag() {
+      if (!drag) return 0;
+      const { refs, delta } = drag;
+      drag = null;
+      let applied = 0;
+      if (delta !== 0) {
+        let moved = [];
+        commit(refs.length === 1 ? "Move Keyframe" : "Move Keyframes", (nodes) => {
+          const result = moveKeyframes(nodes, refs, delta);
+          applied = result.delta;
+          moved = result.refs;
+          return result.nodes;
+        });
+        if (applied !== 0) setSelection(moved);
+      }
+      notify();
+      return applied;
+    },
+    /** Cancels the drag preview (Escape); nothing is edited. */
+    cancelKeyframeDrag() {
+      if (!drag) return;
+      drag = null;
+      notify();
+    },
+    // ----- views & export ---------------------------------------------------------------
+    /** Timeline rows for `ids` (default: selected nodes), including the drag preview. */
+    timelineRows(ids = selectedIds(), opts = {}) {
+      return getTimelineRows(options.getNodes(), ids, { ...propertyOptions(), ...opts, selection, dragDelta: _nullishCoalesce(_optionalChain([drag, 'optionalAccess', _269 => _269.delta]), () => ( 0)) });
+    },
+    sampleFrames(opts = {}) {
+      return sampleAnimationFrames(options.getNodes(), { fps, duration: duration(), ...propertyOptions(), ...opts });
+    },
+    exportCss(nodeId, opts = {}) {
+      const state = player.getState();
+      return exportCssAnimation(options.getNodes(), nodeId, { duration: duration(), loop: state.loop, playbackRate: state.playbackRate, ...opts });
+    },
+    toWebAnimations(nodeId, opts = {}) {
+      const state = player.getState();
+      return toWebAnimations(options.getNodes(), nodeId, { duration: duration(), loop: state.loop, playbackRate: state.playbackRate, ...opts });
+    },
+    destroy() {
+      player.destroy();
+      listeners.clear();
+    }
+  };
+  return controller;
+}
+
+// src/canvas/components.ts
+var COMPONENT_DATA_KEY = "component";
+var COMPONENT_SET_DATA_KEY = "componentSet";
+var INSTANCE_DATA_KEY = "instance";
+var COMPONENT_SOURCE_DATA_KEY = "componentSource";
+var COMPONENT_OVERRIDES_DATA_KEY = "componentOverrides";
+var COMPONENT_PROPERTY_REFS_DATA_KEY = "componentPropertyRefs";
+var MAX_DEPTH = 16;
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var dataOf = (node) => isRecord(_optionalChain([node, 'optionalAccess', _270 => _270.data])) ? node.data : {};
+function same(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(b);
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    const other = b;
+    return a.length === other.length && a.every((x, i) => same(x, other[i]));
+  }
+  const ra = a;
+  const rb = b;
+  const ka = Object.keys(ra).filter((k) => ra[k] !== void 0);
+  const kb = Object.keys(rb).filter((k) => rb[k] !== void 0);
+  return ka.length === kb.length && ka.every((k) => same(ra[k], rb[k]));
+}
+function stringRecord2(value) {
+  const out = {};
+  if (isRecord(value)) {
+    for (const [k, v] of Object.entries(value)) if (typeof v === "string") out[k] = v;
+  }
+  return out;
+}
+function isCanvasComponent(node) {
+  return isRecord(dataOf(node)[COMPONENT_DATA_KEY]);
+}
+function isCanvasComponentSet(node) {
+  return isRecord(dataOf(node)[COMPONENT_SET_DATA_KEY]);
+}
+function isCanvasInstance(node) {
+  const inst = dataOf(node)[INSTANCE_DATA_KEY];
+  return isRecord(inst) && typeof inst.componentId === "string";
+}
+function getInstanceData(node) {
+  return isCanvasInstance(node) ? dataOf(node)[INSTANCE_DATA_KEY] : void 0;
+}
+function getComponentData(node) {
+  return isCanvasComponent(node) ? dataOf(node)[COMPONENT_DATA_KEY] : void 0;
+}
+function getComponentSourceId(node) {
+  const s = dataOf(node)[COMPONENT_SOURCE_DATA_KEY];
+  return typeof s === "string" ? s : void 0;
+}
+function getNodeOverrides(node) {
+  const o = dataOf(node)[COMPONENT_OVERRIDES_DATA_KEY];
+  return Array.isArray(o) ? o.filter((g) => typeof g === "string") : [];
+}
+function getComponentPropertyRefs(node) {
+  return stringRecord2(dataOf(node)[COMPONENT_PROPERTY_REFS_DATA_KEY]);
+}
+function getLayerName(node) {
+  const d = dataOf(node);
+  for (const key of ["name", "label", "text"]) if (typeof d[key] === "string" && d[key]) return d[key];
+  return typeof _optionalChain([node, 'optionalAccess', _271 => _271.type]) === "string" ? node.type : "";
+}
+function withData(node, data) {
+  return { ...node, data };
+}
+function setOverrides(node, groups) {
+  const list = [...new Set(groups)].sort();
+  const data = { ...dataOf(node) };
+  if (list.length) data[COMPONENT_OVERRIDES_DATA_KEY] = list;
+  else delete data[COMPONENT_OVERRIDES_DATA_KEY];
+  return same(getNodeOverrides(node), list) ? node : withData(node, data);
+}
+function unlinked(node, keepRefs = false) {
+  const d = dataOf(node);
+  if (!(COMPONENT_SOURCE_DATA_KEY in d) && !(COMPONENT_OVERRIDES_DATA_KEY in d) && (keepRefs || !(COMPONENT_PROPERTY_REFS_DATA_KEY in d))) return node;
+  const data = { ...d };
+  delete data[COMPONENT_SOURCE_DATA_KEY];
+  delete data[COMPONENT_OVERRIDES_DATA_KEY];
+  if (!keepRefs) delete data[COMPONENT_PROPERTY_REFS_DATA_KEY];
+  return withData(node, data);
+}
+var LINK_KEYS = /* @__PURE__ */ new Set([
+  COMPONENT_DATA_KEY,
+  COMPONENT_SET_DATA_KEY,
+  INSTANCE_DATA_KEY,
+  COMPONENT_SOURCE_DATA_KEY,
+  COMPONENT_OVERRIDES_DATA_KEY,
+  COMPONENT_PROPERTY_REFS_DATA_KEY
+]);
+var NESTED_KEYS = { shape: "shape", layout: "layout", tokenBindings: "token", tokenModes: "tokenMode" };
+var NESTED_PREFIX = { shape: "shape", layout: "layout", token: "tokenBindings", tokenMode: "tokenModes" };
+var SKIPPED_NODE_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "parentId",
+  "parentNode",
+  "position",
+  "positionAbsolute",
+  "selected",
+  "dragging",
+  "resizing",
+  "measured",
+  "width",
+  "height",
+  "style",
+  "data",
+  "hidden",
+  "internals",
+  "computed",
+  "handleBounds"
+]);
+var RUNTIME_KEYS = ["selected", "dragging", "resizing"];
+var UNITLESS = /* @__PURE__ */ new Set(["opacity", "zIndex", "fontWeight", "lineHeight", "flex", "flexGrow", "flexShrink", "order", "zoom"]);
+var OWN_ROOT_GROUPS = /* @__PURE__ */ new Set([
+  "position",
+  "hidden",
+  "component",
+  "props",
+  "data.locked",
+  "data.lockedPrevious",
+  "data.childLayout",
+  "node.draggable",
+  "node.selectable",
+  "node.deletable",
+  "node.connectable",
+  "node.zIndex",
+  "node.extent",
+  "node.expandParent"
+]);
+var isOwnRootGroup = (g) => OWN_ROOT_GROUPS.has(g) || g.startsWith("tokenMode.");
+var camel = (name) => name.startsWith("--") ? name : name.trim().toLowerCase().replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+function styleKeys(style) {
+  if (!style) return [];
+  if (typeof style === "object") return Object.keys(style).filter((k) => style[k] !== void 0);
+  return parseNodeStyleDeclarations(style).map(([k]) => camel(k));
+}
+function sizeOf(node) {
+  const s = readStyleSize(node.style);
+  return { width: node.width, height: node.height, styleWidth: s.width, styleHeight: s.height };
+}
+var splitGroup = (group) => {
+  const dot3 = group.indexOf(".");
+  return dot3 < 0 ? [group, ""] : [group.slice(0, dot3), group.slice(dot3 + 1)];
+};
+function readOverrideGroup(node, group) {
+  const data = dataOf(node);
+  switch (group) {
+    case "hidden":
+      return node.hidden === true;
+    case "position":
+      return node.position;
+    case "size":
+      return sizeOf(node);
+    case "component":
+      return _optionalChain([getInstanceData, 'call', _272 => _272(node), 'optionalAccess', _273 => _273.componentId]);
+    case "props":
+      return _nullishCoalesce(_optionalChain([getInstanceData, 'call', _274 => _274(node), 'optionalAccess', _275 => _275.properties]), () => ( {}));
+  }
+  const [kind, key] = splitGroup(group);
+  switch (kind) {
+    case "style":
+      return readNodeStyleProperty(node.style, key);
+    case "data":
+      return data[key];
+    case "node":
+      return node[key];
+  }
+  const holder = NESTED_PREFIX[kind];
+  if (holder) return isRecord(data[holder]) ? data[holder][key] : void 0;
+  return void 0;
+}
+function withSize(node, value) {
+  const v = isRecord(value) ? value : {};
+  const next = { ...node };
+  if (v.width === void 0) delete next.width;
+  else next.width = v.width;
+  if (v.height === void 0) delete next.height;
+  else next.height = v.height;
+  const current = readStyleSize(node.style);
+  let style = node.style;
+  if (v.styleWidth !== current.width) style = writeNodeStyleProperty(style, "width", v.styleWidth);
+  if (v.styleHeight !== current.height) style = writeNodeStyleProperty(style, "height", v.styleHeight);
+  if (style !== node.style) next.style = style;
+  const w = _nullishCoalesce(v.width, () => ( v.styleWidth));
+  const h = _nullishCoalesce(v.height, () => ( v.styleHeight));
+  if (node.measured && (w !== void 0 || h !== void 0)) {
+    next.measured = { ...node.measured, ...w !== void 0 ? { width: w } : {}, ...h !== void 0 ? { height: h } : {} };
+  }
+  return next;
+}
+function writeOverrideGroup(node, group, value) {
+  if (same(readOverrideGroup(node, group), value)) return node;
+  const next = { ...node };
+  const data = { ...dataOf(node) };
+  switch (group) {
+    case "hidden":
+      if (value) next.hidden = true;
+      else delete next.hidden;
+      return next;
+    case "position":
+      if (isRecord(value)) next.position = { x: value.x, y: value.y };
+      return next;
+    case "size":
+      return withSize(node, value);
+    case "component": {
+      const inst = getInstanceData(node);
+      if (!inst || typeof value !== "string") return node;
+      data[INSTANCE_DATA_KEY] = { ...inst, componentId: value };
+      return withData(node, data);
+    }
+    case "props": {
+      const inst = getInstanceData(node);
+      if (!inst) return node;
+      data[INSTANCE_DATA_KEY] = { ...inst, properties: isRecord(value) ? { ...value } : {} };
+      return withData(node, data);
+    }
+  }
+  const [kind, key] = splitGroup(group);
+  if (!key) return node;
+  switch (kind) {
+    case "style": {
+      const unitless = typeof value === "number" && UNITLESS.has(key);
+      next.style = writeNodeStyleProperty(node.style, key, value, unitless);
+      return next;
+    }
+    case "data":
+      if (LINK_KEYS.has(key) || key in NESTED_KEYS) return node;
+      if (value === void 0) delete data[key];
+      else data[key] = value;
+      return withData(node, data);
+    case "node":
+      if (SKIPPED_NODE_KEYS.has(key)) return node;
+      if (value === void 0) delete next[key];
+      else next[key] = value;
+      return next;
+  }
+  const holder = NESTED_PREFIX[kind];
+  if (!holder) return node;
+  const record = isRecord(data[holder]) ? { ...data[holder] } : {};
+  if (value === void 0) delete record[key];
+  else record[key] = value;
+  if (Object.keys(record).length === 0 && (holder === "tokenBindings" || holder === "tokenModes")) delete data[holder];
+  else data[holder] = record;
+  return withData(node, data);
+}
+function listGroups(node, out) {
+  out.add("hidden");
+  out.add("size");
+  out.add("position");
+  for (const k of styleKeys(node.style)) if (k !== "width" && k !== "height") out.add(`style.${k}`);
+  const data = dataOf(node);
+  for (const [k, v] of Object.entries(data)) {
+    if (LINK_KEYS.has(k)) continue;
+    const prefix = NESTED_KEYS[k];
+    if (prefix) {
+      if (isRecord(v)) for (const sub3 of Object.keys(v)) out.add(`${prefix}.${sub3}`);
+      continue;
+    }
+    out.add(`data.${k}`);
+  }
+  if (isCanvasInstance(node)) {
+    out.add("component");
+    out.add("props");
+  }
+  for (const k of Object.keys(node)) if (!SKIPPED_NODE_KEYS.has(k)) out.add(`node.${k}`);
+}
+function diffOverrideGroups(a, b) {
+  const groups = /* @__PURE__ */ new Set();
+  listGroups(a, groups);
+  listGroups(b, groups);
+  return [...groups].filter((g) => !same(readOverrideGroup(a, g), readOverrideGroup(b, g)));
+}
+function copyGroups(from, to, groups) {
+  let next = to;
+  for (const g of groups) next = writeOverrideGroup(next, g, readOverrideGroup(from, g));
+  return next;
+}
+function fieldGroup(field) {
+  return field === "visible" ? "hidden" : field;
+}
+var Graph = (_class10 = class {
+  constructor(nodes) {;_class10.prototype.__init29.call(this);
+    this.nodes = nodes;
+    this.byId = new Map(nodes.map((n) => [n.id, n]));
+    for (const n of nodes) {
+      if (!n.parentId || !this.byId.has(n.parentId)) continue;
+      let list = this.kids.get(n.parentId);
+      if (!list) this.kids.set(n.parentId, list = []);
+      list.push(n.id);
+    }
+  }
+  
+  
+  __init29() {this.kids = /* @__PURE__ */ new Map()}
+  get(id) {
+    return id === void 0 ? void 0 : this.byId.get(id);
+  }
+  children(id) {
+    return _nullishCoalesce(this.kids.get(id), () => ( []));
+  }
+  /** `id` (optionally) and its ancestors, nearest first. */
+  chain(id, self = true) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    let at = this.get(id);
+    if (at && !self) {
+      seen.add(at.id);
+      at = this.get(at.parentId);
+    }
+    while (at && !seen.has(at.id)) {
+      seen.add(at.id);
+      out.push(at);
+      at = this.get(at.parentId);
+    }
+    return out;
+  }
+  /** Whether `a` is a strict ancestor of `b`. */
+  isAncestor(a, b) {
+    return this.chain(b, false).some((n) => n.id === a);
+  }
+  /** `id` and its descendants, pre-order. */
+  subtree(id) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [id];
+    while (stack.length) {
+      const at = stack.pop();
+      if (seen.has(at) || !this.byId.has(at)) continue;
+      seen.add(at);
+      out.push(at);
+      const kids = this.children(at);
+      for (let i = kids.length - 1; i >= 0; i--) stack.push(kids[i]);
+    }
+    return out;
+  }
+}, _class10);
+var owningComponentIn = (g, id) => _optionalChain([g, 'access', _276 => _276.chain, 'call', _277 => _277(id), 'access', _278 => _278.find, 'call', _279 => _279(isCanvasComponent), 'optionalAccess', _280 => _280.id]);
+var owningInstanceIn = (g, id) => _optionalChain([g, 'access', _281 => _281.chain, 'call', _282 => _282(id), 'access', _283 => _283.find, 'call', _284 => _284(isCanvasInstance), 'optionalAccess', _285 => _285.id]);
+var enclosingInstanceIn = (g, id) => _optionalChain([g, 'access', _286 => _286.chain, 'call', _287 => _287(id, false), 'access', _288 => _288.find, 'call', _289 => _289(isCanvasInstance), 'optionalAccess', _290 => _290.id]);
+function rootInstanceIn(g, id) {
+  const list = g.chain(id).filter(isCanvasInstance);
+  return _optionalChain([list, 'access', _291 => _291[list.length - 1], 'optionalAccess', _292 => _292.id]);
+}
+function variantSetIn(g, componentId) {
+  const comp = g.get(componentId);
+  if (!isCanvasComponent(comp)) return void 0;
+  const parent = g.get(comp.parentId);
+  return isCanvasComponentSet(parent) ? parent : void 0;
+}
+function getVariantValues(node) {
+  const explicit = _optionalChain([getComponentData, 'call', _293 => _293(node), 'optionalAccess', _294 => _294.variant]);
+  if (isRecord(explicit) && Object.keys(explicit).length) return stringRecord2(explicit);
+  const name = getLayerName(node);
+  return name.includes("=") ? parseVariantName(name) : {};
+}
+function parseVariantName(name) {
+  const out = {};
+  for (const part of name.split(",")) {
+    const eq = part.indexOf("=");
+    if (eq < 0) continue;
+    const k = part.slice(0, eq).trim();
+    if (k) out[k] = part.slice(eq + 1).trim();
+  }
+  return out;
+}
+function formatVariantName(pairs, order = []) {
+  const keys = order.filter((k) => k in pairs);
+  keys.push(...Object.keys(pairs).filter((k) => !order.includes(k)).sort());
+  return keys.map((k) => `${k}=${pairs[k]}`).join(", ");
+}
+function variantsIn(g, setId) {
+  return g.children(setId).map((id) => g.get(id)).filter(isCanvasComponent);
+}
+function variantOptionsIn(g, setId) {
+  const out = [];
+  for (const v of variantsIn(g, setId)) {
+    for (const [k, value] of Object.entries(getVariantValues(v))) {
+      let entry = out.find((o) => o.name === k);
+      if (!entry) out.push(entry = { name: k, values: [] });
+      if (!entry.values.includes(value)) entry.values.push(value);
+    }
+  }
+  return out;
+}
+function defaultVariantIn(g, setId) {
+  let best;
+  for (const v of variantsIn(g, setId)) {
+    const { x, y } = v.position;
+    const key = [x + y, y, x];
+    if (!best || key[0] < best.key[0] || key[0] === best.key[0] && (key[1] < best.key[1] || key[1] === best.key[1] && key[2] < best.key[2])) {
+      best = { key, id: v.id };
+    }
+  }
+  return _optionalChain([best, 'optionalAccess', _295 => _295.id]);
+}
+function findVariantIn(g, setId, wanted) {
+  const entries = Object.entries(wanted);
+  let best;
+  for (const v of variantsIn(g, setId)) {
+    const values = getVariantValues(v);
+    const score = entries.filter(([k, val]) => values[k] === val).length;
+    if (score === entries.length) return v.id;
+    if (!best || score > best.score) best = { score, id: v.id };
+  }
+  return _optionalChain([best, 'optionalAccess', _296 => _296.id]);
+}
+function mainOfIn(g, id) {
+  const node = g.get(id);
+  if (isCanvasComponent(node)) return id;
+  if (isCanvasComponentSet(node)) return defaultVariantIn(g, id);
+  return void 0;
+}
+var siblingVariants = (g, a, b) => !!a && !!b && a !== b && !!variantSetIn(g, a) && variantSetIn(g, a) === variantSetIn(g, b);
+function propertyDefsIn(g, componentId) {
+  const comp = g.get(componentId);
+  if (!isCanvasComponent(comp)) return {};
+  const set = variantSetIn(g, componentId);
+  const owner = set ? dataOf(set)[COMPONENT_SET_DATA_KEY] : dataOf(comp)[COMPONENT_DATA_KEY];
+  return isRecord(_optionalChain([owner, 'optionalAccess', _297 => _297.properties])) ? owner.properties : {};
+}
+function validValue(def, v) {
+  return def.type === "boolean" ? typeof v === "boolean" : typeof v === "string";
+}
+function effectivePropsIn(g, componentId, values) {
+  const out = {};
+  for (const [k, def] of Object.entries(propertyDefsIn(g, componentId))) {
+    const v = _optionalChain([values, 'optionalAccess', _298 => _298[k]]);
+    out[k] = v !== void 0 && validValue(def, v) ? v : def.default;
+  }
+  return out;
+}
+function componentDepsIn(g, componentId) {
+  const deps = /* @__PURE__ */ new Set();
+  const queue = [componentId];
+  while (queue.length) {
+    const c = queue.pop();
+    for (const id of g.subtree(c)) {
+      const target = _optionalChain([getInstanceData, 'call', _299 => _299(g.get(id)), 'optionalAccess', _300 => _300.componentId]);
+      if (target && !deps.has(target)) {
+        deps.add(target);
+        queue.push(target);
+      }
+    }
+  }
+  return deps;
+}
+function createsCycleIn(g, componentId, parentId) {
+  if (!parentId) return false;
+  const hosts = g.chain(parentId).filter(isCanvasComponent).map((n) => n.id);
+  if (hosts.length === 0) return false;
+  const deps = componentDepsIn(g, componentId);
+  deps.add(componentId);
+  return hosts.some((h) => deps.has(h));
+}
+function wouldCreateComponentCycle(nodes, componentId, parentId) {
+  const g = new Graph(nodes);
+  return createsCycleIn(g, _nullishCoalesce(mainOfIn(g, componentId), () => ( componentId)), parentId);
+}
+function getOwningComponent(nodes, id) {
+  return owningComponentIn(new Graph(nodes), id);
+}
+function getOwningInstance(nodes, id) {
+  return owningInstanceIn(new Graph(nodes), id);
+}
+function getRootInstance(nodes, id) {
+  return rootInstanceIn(new Graph(nodes), id);
+}
+function isInsideInstance(nodes, id) {
+  return enclosingInstanceIn(new Graph(nodes), id) !== void 0;
+}
+function getComponentInstances(nodes, componentId) {
+  return nodes.filter((n) => _optionalChain([getInstanceData, 'call', _301 => _301(n), 'optionalAccess', _302 => _302.componentId]) === componentId).map((n) => n.id);
+}
+function getInstanceStatus(nodes, id) {
+  const g = new Graph(nodes);
+  const inst = getInstanceData(g.get(id));
+  if (!inst) return void 0;
+  return isCanvasComponent(g.get(inst.componentId)) ? "linked" : "missing-main";
+}
+function getVariantSet(nodes, componentId) {
+  return _optionalChain([variantSetIn, 'call', _303 => _303(new Graph(nodes), componentId), 'optionalAccess', _304 => _304.id]);
+}
+function getVariantOptions(nodes, setId) {
+  return variantOptionsIn(new Graph(nodes), setId);
+}
+function findVariant(nodes, setId, wanted) {
+  return findVariantIn(new Graph(nodes), setId, wanted);
+}
+function getDefaultVariant(nodes, setId) {
+  return defaultVariantIn(new Graph(nodes), setId);
+}
+function getVariantConflicts(nodes, setId) {
+  const by = /* @__PURE__ */ new Map();
+  for (const v of variantsIn(new Graph(nodes), setId)) {
+    const key = formatVariantName(getVariantValues(v));
+    by.set(key, [..._nullishCoalesce(by.get(key), () => ( [])), v.id]);
+  }
+  return [...by.values()].filter((ids) => ids.length > 1);
+}
+function getComponentPropertyDefs(nodes, componentId) {
+  return { ...propertyDefsIn(new Graph(nodes), componentId) };
+}
+function getInstanceProperties(nodes, id) {
+  const g = new Graph(nodes);
+  const inst = getInstanceData(g.get(id));
+  return inst ? effectivePropsIn(g, inst.componentId, inst.properties) : {};
+}
+function listCanvasComponents(nodes) {
+  const g = new Graph(nodes);
+  const counts = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const c = _optionalChain([getInstanceData, 'call', _305 => _305(n), 'optionalAccess', _306 => _306.componentId]);
+    if (c) counts.set(c, (_nullishCoalesce(counts.get(c), () => ( 0))) + 1);
+  }
+  const components = [];
+  for (const n of nodes) {
+    if (!isCanvasComponent(n)) continue;
+    const set = variantSetIn(g, n.id);
+    components.push({
+      id: n.id,
+      name: getLayerName(n) || n.id,
+      ...set ? { setId: set.id, variant: getVariantValues(n) } : {},
+      instanceCount: _nullishCoalesce(counts.get(n.id), () => ( 0))
+    });
+  }
+  const sets = nodes.filter(isCanvasComponentSet).map((s) => ({
+    id: s.id,
+    name: getLayerName(s) || s.id,
+    variants: components.filter((c) => c.setId === s.id),
+    options: variantOptionsIn(g, s.id),
+    defaultVariantId: defaultVariantIn(g, s.id)
+  }));
+  return { components, sets };
+}
+function inspectCanvasInstance(nodes, id) {
+  const g = new Graph(nodes);
+  const instId = owningInstanceIn(g, id);
+  if (!instId) return void 0;
+  const inst = g.get(instId);
+  const data = getInstanceData(inst);
+  const comp = g.get(data.componentId);
+  const linked = isCanvasComponent(comp);
+  const set = linked ? variantSetIn(g, data.componentId) : void 0;
+  const defs = propertyDefsIn(g, data.componentId);
+  const values = effectivePropsIn(g, data.componentId, data.properties);
+  const overrides = [];
+  for (const d of g.subtree(instId)) {
+    const groups = getNodeOverrides(g.get(d));
+    if (groups.length) overrides.push({ id: d, name: getLayerName(g.get(d)) || d, groups: [...groups] });
+  }
+  return {
+    id: instId,
+    rootId: _nullishCoalesce(rootInstanceIn(g, instId), () => ( instId)),
+    nested: enclosingInstanceIn(g, instId) !== void 0,
+    componentId: data.componentId,
+    ...linked ? { componentName: getLayerName(comp) || comp.id } : {},
+    status: linked ? "linked" : "missing-main",
+    ...set ? { setId: set.id } : {},
+    variant: linked && set ? getVariantValues(comp) : {},
+    variantOptions: set ? variantOptionsIn(g, set.id) : [],
+    properties: Object.entries(defs).map(([name, def]) => ({
+      name,
+      type: def.type,
+      value: values[name],
+      default: def.default,
+      ...def.type === "instanceSwap" ? { preferred: [..._nullishCoalesce(def.preferred, () => ( []))] } : {}
+    })),
+    overrides
+  };
+}
+function resolveSync(options = {}) {
+  return {
+    idGenerator: _nullishCoalesce(options.idGenerator, () => ( ((inst, src) => `${inst}:${src}`))),
+    textTypes: _nullishCoalesce(options.textTypes, () => ( ["text"])),
+    layout: options.layout === false ? false : options.layout === true || options.layout === void 0 ? {} : options.layout,
+    tokens: options.tokens
+  };
+}
+var stripLook = (data) => {
+  const out = { ...data };
+  for (const k of LINK_KEYS) delete out[k];
+  return out;
+};
+function clearRuntime(node, old) {
+  for (const k of RUNTIME_KEYS) {
+    if (old && old[k] !== void 0) node[k] = old[k];
+    else delete node[k];
+  }
+}
+function tokenDrivenGroups(n, options) {
+  const mine = stringRecord2(dataOf(n).tokenBindings);
+  const out = [];
+  for (const key of Object.keys(mine)) {
+    const property = getCanvasTokenProperty(key, options);
+    if (!property || !property.appliesTo(n)) continue;
+    const current = property.read(n);
+    const probe = typeof current === "number" ? current + 1 : typeof current === "boolean" ? !current : `${_nullishCoalesce(current, () => ( ""))}
`;
+    for (const g of diffOverrideGroups(n, property.write(n, probe))) if (!out.includes(g)) out.push(g);
+  }
+  return out;
+}
+function propertyDrivenGroups(g, src) {
+  const out = [];
+  let at = src;
+  for (let i = 0; at && i <= MAX_DEPTH; i++) {
+    for (const field of Object.keys(getComponentPropertyRefs(at))) out.push(fieldGroup(field));
+    at = g.get(getComponentSourceId(at));
+  }
+  return out;
+}
+function rootReference(g, comp) {
+  const set = variantSetIn(g, comp.id);
+  if (!set) return comp;
+  const label = dataOf(set).label;
+  return "label" in dataOf(comp) && typeof label === "string" ? withData(comp, { ...dataOf(comp), label }) : comp;
+}
+function fixMeasured(node, old) {
+  const measured2 = _nullishCoalesce(_optionalChain([old, 'optionalAccess', _307 => _307.measured]), () => ( node.measured));
+  const size = sizeOf(node);
+  const w = _nullishCoalesce(size.width, () => ( size.styleWidth));
+  const h = _nullishCoalesce(size.height, () => ( size.styleHeight));
+  if (!measured2) {
+    if (node.measured === void 0) return node;
+    const next = { ...node };
+    delete next.measured;
+    return next;
+  }
+  const fixed = { ...measured2, ...w !== void 0 ? { width: w } : {}, ...h !== void 0 ? { height: h } : {} };
+  return same(fixed, node.measured) ? node : { ...node, measured: fixed };
+}
+function applyProp(g, node, field, value) {
+  if (field === "visible") return typeof value === "boolean" ? writeOverrideGroup(node, "hidden", !value) : node;
+  if (field === "component") {
+    if (typeof value !== "string" || !isCanvasInstance(node)) return node;
+    const main = mainOfIn(g, value);
+    return main ? writeOverrideGroup(node, "component", main) : node;
+  }
+  if (field.startsWith("data.")) return writeOverrideGroup(node, field, typeof value === "string" ? value : String(value));
+  return node;
+}
+function buildInstance(g, instId, opts, taken) {
+  const inst = g.get(instId);
+  const instData = getInstanceData(inst);
+  if (!inst || !instData) return void 0;
+  const compId = instData.componentId;
+  const comp = g.get(compId);
+  if (!comp || !isCanvasComponent(comp) || compId === instId || g.isAncestor(instId, compId) || g.isAncestor(compId, instId)) return void 0;
+  const oldIds = [];
+  const foreign = [];
+  const stack = [...g.children(instId)];
+  while (stack.length) {
+    const id = stack.pop();
+    if (getComponentSourceId(g.get(id)) !== void 0) {
+      oldIds.push(id);
+      stack.push(...g.children(id));
+    } else foreign.push(...g.subtree(id));
+  }
+  const old = new Map(oldIds.map((id) => [id, g.get(id)]));
+  const byParentSource = /* @__PURE__ */ new Map();
+  const bySource = /* @__PURE__ */ new Map();
+  for (const id of oldIds) {
+    const n = old.get(id);
+    const s = getComponentSourceId(n);
+    const key = `${n.parentId}\0${s}`;
+    if (!byParentSource.has(key)) byParentSource.set(key, id);
+    bySource.set(s, bySource.has(s) ? null : id);
+  }
+  let byPath;
+  const oldPaths = () => {
+    const out2 = /* @__PURE__ */ new Map();
+    const walk = (parent, prefix) => {
+      const counts = /* @__PURE__ */ new Map();
+      for (const c of g.children(parent)) {
+        const n = g.get(c);
+        const src = getComponentSourceId(n);
+        if (src === void 0) continue;
+        const name = getLayerName(_nullishCoalesce(g.get(src), () => ( n)));
+        const k = _nullishCoalesce(counts.get(name), () => ( 0));
+        counts.set(name, k + 1);
+        const path = `${prefix}/${k === 0 ? name : `${name}#${k}`}`;
+        if (!out2.has(path)) out2.set(path, c);
+        walk(c, path);
+      }
+    };
+    walk(instId, "");
+    return out2;
+  };
+  const used = /* @__PURE__ */ new Set();
+  const fresh = (sourceId) => {
+    const base = opts.idGenerator(instId, sourceId);
+    let id = base;
+    for (let k = 2; taken.has(id); k++) id = `${base}~${k}`;
+    taken.add(id);
+    return id;
+  };
+  const instProps = /* @__PURE__ */ new Map();
+  const out = [];
+  const isText2 = (n) => typeof n.type === "string" && opts.textTypes.includes(n.type);
+  const copyLayer = (s, o, id, parentId) => {
+    const next = { ...s, id, parentId };
+    const data = stripLook(dataOf(s));
+    if (isCanvasInstance(s)) data[INSTANCE_DATA_KEY] = { ...dataOf(s)[INSTANCE_DATA_KEY] };
+    data[COMPONENT_SOURCE_DATA_KEY] = s.id;
+    next.data = data;
+    clearRuntime(next, o);
+    let n = next;
+    if (o) {
+      let groups = [...getNodeOverrides(o)];
+      const from = g.get(getComponentSourceId(o));
+      if (from && from.id !== s.id && groups.length && !isText2(o) && siblingVariants(g, owningComponentIn(g, from.id), owningComponentIn(g, s.id))) {
+        const differs = new Set(diffOverrideGroups(from, s));
+        groups = groups.filter((gr) => !differs.has(gr));
+      }
+      n = copyGroups(o, n, groups);
+      n = keepLaidOut(s, o, n, groups);
+      n = setOverrides(n, groups);
+    }
+    return fixMeasured(n, o);
+  };
+  const keepLaidOut = (s, o, n, groups) => {
+    if (o.parentId !== n.parentId || groups.includes("size") || groups.includes("position")) return n;
+    const flows = !getChildLayout(n).absolute && !!getAutoLayout(g.get(s.parentId));
+    let next = n;
+    if (flows) next = writeOverrideGroup(next, "position", o.position);
+    const derived = (axis) => {
+      const sizing = getLayoutSizing(next, axis);
+      return sizing === "hug" && !!getAutoLayout(next) || sizing === "fill" && flows;
+    };
+    const size = { ...sizeOf(next) };
+    const oldSize = sizeOf(o);
+    if (derived("width")) {
+      size.width = oldSize.width;
+      size.styleWidth = oldSize.styleWidth;
+    }
+    if (derived("height")) {
+      size.height = oldSize.height;
+      size.styleHeight = oldSize.styleHeight;
+    }
+    return writeOverrideGroup(next, "size", size);
+  };
+  const instanceRoot = (look, place2, old2, id, parentId, sourceId, instance, previousComponent, topLevel) => {
+    const reference = rootReference(g, look);
+    const next = { ...reference, id, position: { ...place2.position } };
+    if (parentId === void 0) delete next.parentId;
+    else next.parentId = parentId;
+    const data = stripLook(dataOf(reference));
+    delete data.tokenModes;
+    data[INSTANCE_DATA_KEY] = { ...instance };
+    data[COMPONENT_SOURCE_DATA_KEY] = sourceId;
+    next.data = data;
+    clearRuntime(next, old2);
+    let n = next;
+    const own = /* @__PURE__ */ new Set();
+    listGroups(place2, own);
+    listGroups(n, own);
+    n = copyGroups(place2, n, [...own].filter((gr) => isOwnRootGroup(gr) && gr !== "component" && gr !== "props"));
+    let groups = old2 ? getNodeOverrides(old2).filter((gr) => !topLevel || !isOwnRootGroup(gr)) : [];
+    if (old2 && previousComponent && siblingVariants(g, previousComponent, look.id)) {
+      const differs = new Set(diffOverrideGroups(g.get(previousComponent), look));
+      groups = groups.filter((gr) => gr === "data.label" || gr === "data.name" || !differs.has(gr));
+    }
+    if (old2) n = copyGroups(old2, n, groups.filter((gr) => gr !== "component" && gr !== "props"));
+    return fixMeasured(setOverrides(n, groups), old2);
+  };
+  const applyChainProps = (n, s, enc) => {
+    const chain = [s];
+    while (chain.length < enc.length) {
+      const next2 = g.get(getComponentSourceId(chain[chain.length - 1]));
+      if (!next2) break;
+      chain.push(next2);
+    }
+    let next = n;
+    for (let j = chain.length - 1; j >= 0; j--) {
+      const props = instProps.get(enc[j]);
+      if (!props) continue;
+      for (const [field, prop] of Object.entries(getComponentPropertyRefs(chain[j]))) {
+        const group = fieldGroup(field);
+        if (getNodeOverrides(next).includes(group) || j > 0 && getNodeOverrides(s).includes(group)) continue;
+        if (prop in props) next = applyProp(g, next, field, props[prop]);
+      }
+    }
+    return next;
+  };
+  const copyChildren = (srcParent, newParent, prefix, enc, expanding, depth) => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const sid of g.children(srcParent)) {
+      const s = g.get(sid);
+      const name = getLayerName(s);
+      const k = _nullishCoalesce(counts.get(name), () => ( 0));
+      counts.set(name, k + 1);
+      const path = `${prefix}/${k === 0 ? name : `${name}#${k}`}`;
+      let oid = byParentSource.get(`${newParent}\0${sid}`);
+      if (oid !== void 0 && used.has(oid)) oid = void 0;
+      if (oid === void 0) {
+        const u = bySource.get(sid);
+        if (u && !used.has(u)) oid = u;
+      }
+      if (oid === void 0) {
+        byPath ??= oldPaths();
+        const p = byPath.get(path);
+        if (p && !used.has(p)) oid = p;
+      }
+      if (oid !== void 0) used.add(oid);
+      const o = oid !== void 0 ? old.get(oid) : void 0;
+      const id = _nullishCoalesce(oid, () => ( fresh(sid)));
+      let n = applyChainProps(copyLayer(s, o, id, newParent), s, enc);
+      const nested = getInstanceData(n);
+      if (nested && depth < MAX_DEPTH) {
+        const target = nested.componentId;
+        instProps.set(id, effectivePropsIn(g, target, nested.properties));
+        if (_optionalChain([getInstanceData, 'call', _308 => _308(s), 'optionalAccess', _309 => _309.componentId]) !== target) {
+          const main = g.get(target);
+          if (isCanvasComponent(main) && !expanding.includes(target) && !g.isAncestor(target, instId)) {
+            const previousComponent = o ? _optionalChain([getInstanceData, 'call', _310 => _310(o), 'optionalAccess', _311 => _311.componentId]) : void 0;
+            n = applyChainProps(instanceRoot(main, s, o, id, newParent, sid, nested, previousComponent, false), s, enc);
+            out.push(n);
+            copyChildren(target, id, path, [id], [...expanding, target], depth + 1);
+            continue;
+          }
+        }
+        out.push(n);
+        copyChildren(sid, id, path, [...enc, id], expanding, depth);
+        continue;
+      }
+      out.push(n);
+      copyChildren(sid, id, path, enc, expanding, depth);
+    }
+  };
+  const root = instanceRoot(comp, inst, inst, instId, inst.parentId, compId, instData, getComponentSourceId(inst), true);
+  instProps.set(instId, effectivePropsIn(g, compId, instData.properties));
+  copyChildren(compId, instId, "", [instId], [compId], 0);
+  const placed = /* @__PURE__ */ new Set([instId, ...out.map((n) => n.id)]);
+  const keptForeign = [];
+  for (const id of foreign) {
+    const n = g.get(id);
+    if (n.parentId && placed.has(n.parentId)) {
+      placed.add(id);
+      keptForeign.push(n);
+    }
+  }
+  const removed = /* @__PURE__ */ new Set([instId, ...oldIds, ...foreign]);
+  let block = [root, ...out, ...keptForeign];
+  const compSize = getNodeSize(comp);
+  const rootSize = getNodeSize(root);
+  if (!getAutoLayout(root) && (Math.abs(compSize.width - rootSize.width) > 1e-9 || Math.abs(compSize.height - rootSize.height) > 1e-9)) {
+    const fixed = new Set(out.filter((n) => getNodeOverrides(n).some((gr) => gr === "size" || gr === "position")).map((n) => n.id));
+    const updates = applyConstraints(block, instId, compSize, opts.layout || {}).filter((u) => !fixed.has(u.id));
+    block = applyNodeUpdates(block, updates);
+  }
+  if (opts.layout) {
+    const frames = block.filter((n) => getAutoLayout(n)).map((n) => n.id);
+    if (frames.length) block = applyNodeUpdates(block, layoutUpMany(block, frames, opts.layout));
+  }
+  block = block.map((n) => {
+    const prev = g.get(n.id);
+    return prev && prev !== n && same(prev, n) ? prev : n;
+  });
+  return { block, removed };
+}
+function rebuildBatch(nodes, ids, opts) {
+  const g = new Graph(nodes);
+  const taken = new Set(g.byId.keys());
+  const built = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const root = g.get(id) ? _nullishCoalesce(rootInstanceIn(g, id), () => ( id)) : void 0;
+    if (!root || built.has(root)) continue;
+    const b = buildInstance(g, root, opts, taken);
+    if (b) built.set(root, b);
+  }
+  if (built.size === 0) return nodes;
+  const removed = /* @__PURE__ */ new Set();
+  for (const b of built.values()) for (const id of b.removed) removed.add(id);
+  let result = [];
+  for (const n of nodes) {
+    const b = built.get(n.id);
+    if (b) result.push(...b.block);
+    else if (!removed.has(n.id)) result.push(n);
+  }
+  if (opts.layout) {
+    const lookup = new Map(result.map((n) => [n.id, n]));
+    const inFrames = [...built.keys()].filter((r) => {
+      const parent = lookup.get(_nullishCoalesce(_optionalChain([lookup, 'access', _312 => _312.get, 'call', _313 => _313(r), 'optionalAccess', _314 => _314.parentId]), () => ( "")));
+      return !!getAutoLayout(parent);
+    });
+    if (inFrames.length) result = applyNodeUpdates(result, layoutUpMany(result, inFrames, opts.layout));
+  }
+  return result.length === nodes.length && result.every((n, i) => n === nodes[i]) ? nodes : result;
+}
+function rebuildInstances(nodes, comps, resync, opts) {
+  let current = nodes;
+  if (resync.size) {
+    current = rebuildBatch(current, resync, opts);
+    const after = new Graph(current);
+    for (const r of resync) {
+      const c = after.get(r) ? owningComponentIn(after, r) : void 0;
+      if (c) comps.add(c);
+    }
+  }
+  if (comps.size === 0) return current;
+  const g = new Graph(current);
+  const rootsOf = /* @__PURE__ */ new Map();
+  for (const n of current) {
+    const inst = getInstanceData(n);
+    if (!inst) continue;
+    const root = _nullishCoalesce(rootInstanceIn(g, n.id), () => ( n.id));
+    let set = rootsOf.get(inst.componentId);
+    if (!set) rootsOf.set(inst.componentId, set = /* @__PURE__ */ new Set());
+    set.add(root);
+  }
+  const level = new Map([...comps].map((c) => [c, 0]));
+  const outer = /* @__PURE__ */ new Map();
+  let frontier = [...comps];
+  for (let rounds = 0; frontier.length && rounds < 64; rounds++) {
+    const next = [];
+    for (const c of frontier) {
+      const lc = _nullishCoalesce(level.get(c), () => ( 0));
+      for (const r of _nullishCoalesce(rootsOf.get(c), () => ( []))) {
+        if (!outer.has(r)) outer.set(r, owningComponentIn(g, r));
+        const x = outer.get(r);
+        if (x && x !== c && (_nullishCoalesce(level.get(x), () => ( -1))) < lc + 1) {
+          level.set(x, lc + 1);
+          next.push(x);
+        }
+      }
+    }
+    frontier = next;
+  }
+  const batches = /* @__PURE__ */ new Map();
+  for (const [r, o] of outer) {
+    const l = o !== void 0 ? _nullishCoalesce(level.get(o), () => ( Number.MAX_SAFE_INTEGER)) : Number.MAX_SAFE_INTEGER;
+    batches.set(l, [..._nullishCoalesce(batches.get(l), () => ( [])), r]);
+  }
+  for (const l of [...batches.keys()].sort((a, b) => a - b)) current = rebuildBatch(current, batches.get(l), opts);
+  return current;
+}
+function finish(original, result, opts) {
+  let out = result;
+  if (_optionalChain([opts, 'access', _315 => _315.tokens, 'optionalAccess', _316 => _316.state])) out = resolveCanvasTokens(out, opts.tokens.state, opts.tokens);
+  if (out.length === original.length && out.every((n, i) => n === original[i])) return original;
+  return out;
+}
+function syncCanvasInstance(nodes, instanceId, options = {}) {
+  const opts = resolveSync(options);
+  return finish(nodes, rebuildInstances([...nodes], /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set([instanceId]), opts), opts);
+}
+function syncAllCanvasInstances(nodes, options = {}) {
+  const opts = resolveSync(options);
+  const comps = new Set(nodes.filter(isCanvasComponent).map((n) => n.id));
+  return finish(nodes, rebuildInstances([...nodes], comps, /* @__PURE__ */ new Set(), opts), opts);
+}
+function rebaseInstance(nodes, instId, tokens) {
+  const g = new Graph(nodes);
+  const inst = getInstanceData(g.get(instId));
+  if (!inst) return nodes;
+  const compId = inst.componentId;
+  const comp = g.get(compId);
+  const theirs = /* @__PURE__ */ new Map();
+  const mine = /* @__PURE__ */ new Map();
+  const paths = (root2, viaSource, into, flip) => {
+    const walk = (parent, prefix) => {
+      const counts = /* @__PURE__ */ new Map();
+      for (const c of g.children(parent)) {
+        const n = g.get(c);
+        const name = getLayerName(viaSource && g.get(getComponentSourceId(n)) || n);
+        const k = _nullishCoalesce(counts.get(name), () => ( 0));
+        counts.set(name, k + 1);
+        const path = `${prefix}/${k === 0 ? name : `${name}#${k}`}`;
+        if (flip) {
+          if (!into.has(path)) into.set(path, c);
+        } else into.set(c, path);
+        walk(c, path);
+      }
+    };
+    walk(root2, "");
+  };
+  if (comp) paths(compId, false, theirs, true);
+  paths(instId, true, mine, false);
+  const updates = /* @__PURE__ */ new Map();
+  for (const [id, path] of mine) {
+    const n = g.get(id);
+    let main;
+    let cur = getComponentSourceId(n);
+    for (let i = 0; cur && i < MAX_DEPTH; i++) {
+      if (cur !== compId && g.get(cur) && g.isAncestor(compId, cur)) {
+        main = cur;
+        break;
+      }
+      cur = getComponentSourceId(g.get(cur));
+    }
+    main ??= comp ? theirs.get(path) : void 0;
+    const m = g.get(main);
+    let next = n;
+    if (m) {
+      const bound = /* @__PURE__ */ new Set([...propertyDrivenGroups(g, m), ...tokenDrivenGroups(n, tokens)]);
+      const groups = new Set(getNodeOverrides(n).filter((gr) => gr !== "component" && gr !== "props"));
+      for (const gr of diffOverrideGroups(m, n)) if (gr !== "size" && gr !== "position" && !bound.has(gr)) groups.add(gr);
+      if (isCanvasInstance(m) && isCanvasInstance(n) && getInstanceData(m).componentId !== getInstanceData(n).componentId) groups.add("component");
+      next = setOverrides(withData(n, { ...dataOf(n), [COMPONENT_SOURCE_DATA_KEY]: m.id }), groups);
+    } else next = unlinked(n);
+    if (next !== n) updates.set(id, next);
+  }
+  const root = g.get(instId);
+  let nextRoot = withData(root, { ...dataOf(root), [COMPONENT_SOURCE_DATA_KEY]: compId });
+  if (comp) {
+    const ref = rootReference(g, comp);
+    const driven = new Set(tokenDrivenGroups(root, tokens));
+    const groups = new Set(getNodeOverrides(root).filter((gr) => !isOwnRootGroup(gr)));
+    for (const gr of diffOverrideGroups(ref, root)) if (!isOwnRootGroup(gr) && !driven.has(gr)) groups.add(gr);
+    nextRoot = setOverrides(nextRoot, groups);
+  }
+  updates.set(instId, nextRoot);
+  return nodes.map((n) => _nullishCoalesce(updates.get(n.id), () => ( n)));
+}
+function sizeFromLayout(g, node) {
+  const parentFlows = !!getAutoLayout(g.get(node.parentId)) && !getChildLayout(node).absolute;
+  return ["width", "height"].some((axis) => {
+    const sizing = getLayoutSizing(node, axis);
+    return sizing === "hug" && !!getAutoLayout(node) || sizing === "fill" && parentFlows;
+  });
+}
+function syncCanvasComponents(before, after, options = {}) {
+  if (before === after) return after;
+  const opts = resolveSync(options);
+  const prev = new Graph(before);
+  let nodes = [...after];
+  const resync = /* @__PURE__ */ new Set();
+  const afterIds = new Set(after.map((n) => n.id));
+  const restore = [];
+  for (const b of before) {
+    if (afterIds.has(b.id) || getComponentSourceId(b) === void 0 || isCanvasInstance(b) && !enclosingInstanceIn(prev, b.id)) continue;
+    const root = rootInstanceIn(prev, b.id);
+    if (!root || root === b.id || !afterIds.has(root)) continue;
+    restore.push(b);
+  }
+  if (restore.length) {
+    const restoring = new Set(restore.map((n) => n.id));
+    for (const b of restore) nodes.push(b.parentId && restoring.has(b.parentId) ? b : writeOverrideGroup(b, "hidden", true));
+    for (const b of restore) {
+      const r = rootInstanceIn(prev, b.id);
+      if (r) resync.add(r);
+    }
+  }
+  let g = new Graph(nodes);
+  const added = nodes.filter((n) => !prev.byId.has(n.id));
+  if (added.length) {
+    const addedIds = new Set(added.map((n) => n.id));
+    const moves = /* @__PURE__ */ new Map();
+    for (const n of added) {
+      if (!n.parentId || addedIds.has(n.parentId)) continue;
+      const r = rootInstanceIn(g, n.parentId);
+      if (!r || addedIds.has(r)) continue;
+      const rootNode = g.get(r);
+      const abs = getAbsolutePosition(n, g.byId);
+      const parent = g.get(rootNode.parentId);
+      const base = parent ? getAbsolutePosition(parent, g.byId) : { x: 0, y: 0 };
+      const moved = { ...n, position: { x: abs.x - base.x, y: abs.y - base.y } };
+      if (rootNode.parentId) moved.parentId = rootNode.parentId;
+      else delete moved.parentId;
+      moves.set(n.id, moved);
+    }
+    if (moves.size) {
+      nodes = nodes.map((n) => _nullishCoalesce(moves.get(n.id), () => ( n)));
+      g = new Graph(nodes);
+    }
+    const rebase = [];
+    const strips = /* @__PURE__ */ new Map();
+    for (const n of added) {
+      const cur = g.get(n.id);
+      if (isCanvasInstance(cur)) {
+        if (enclosingInstanceIn(g, n.id) === void 0 && getComponentSourceId(cur) !== getInstanceData(cur).componentId) rebase.push(n.id);
+        continue;
+      }
+      if (getComponentSourceId(cur) === void 0 && getNodeOverrides(cur).length === 0) continue;
+      const r = rootInstanceIn(g, n.id);
+      if (!r || !addedIds.has(r) || moves.has(n.id)) strips.set(n.id, unlinked(cur, true));
+    }
+    if (strips.size) nodes = nodes.map((n) => _nullishCoalesce(strips.get(n.id), () => ( n)));
+    for (const id of rebase) nodes = rebaseInstance(nodes, id, opts.tokens);
+    g = new Graph(nodes);
+  }
+  const overrideUpdates = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const b = prev.get(n.id);
+    if (!b || b === n) continue;
+    const inst = owningInstanceIn(g, n.id);
+    if (!inst || getComponentSourceId(n) === void 0 && inst !== n.id) continue;
+    const topRoot = inst === n.id && enclosingInstanceIn(g, n.id) === void 0;
+    const bi = getInstanceData(b);
+    const ni = getInstanceData(n);
+    const raw = diffOverrideGroups(b, n);
+    if (topRoot) {
+      if (bi && ni && (bi.componentId !== ni.componentId || !same(_nullishCoalesce(bi.properties, () => ( {})), _nullishCoalesce(ni.properties, () => ( {}))))) resync.add(n.id);
+      if (raw.includes("size")) resync.add(n.id);
+    }
+    let groups = raw.filter((gr) => gr !== "position" && (gr !== "size" || topRoot && !sizeFromLayout(g, n)));
+    if (topRoot) groups = groups.filter((gr) => !isOwnRootGroup(gr));
+    let cleared = [];
+    const srcId = topRoot ? _optionalChain([ni, 'optionalAccess', _317 => _317.componentId]) : getComponentSourceId(n);
+    const src = g.get(srcId);
+    if (src) {
+      const reference = topRoot ? rootReference(g, src) : src;
+      const differs = new Set(diffOverrideGroups(reference, n));
+      const driven = new Set(tokenDrivenGroups(n, opts.tokens));
+      groups = groups.filter((gr) => differs.has(gr) && !driven.has(gr));
+      cleared = raw.filter((gr) => gr !== "size" && gr !== "position" && !differs.has(gr) && getNodeOverrides(n).includes(gr));
+      if (topRoot) cleared = cleared.filter((gr) => !isOwnRootGroup(gr));
+    }
+    const lost = getNodeOverrides(b).some((gr) => !getNodeOverrides(n).includes(gr));
+    const nestedSwitch = !topRoot && raw.some((gr) => gr === "component" || gr === "props");
+    if (groups.length || cleared.length) {
+      const set = new Set(getNodeOverrides(n));
+      for (const gr of groups) set.add(gr);
+      for (const gr of cleared) set.delete(gr);
+      const updated = setOverrides(n, set);
+      if (updated !== n) overrideUpdates.set(n.id, updated);
+    }
+    if (lost || nestedSwitch) {
+      const r = rootInstanceIn(g, n.id);
+      if (r) resync.add(r);
+    }
+  }
+  if (overrideUpdates.size) {
+    nodes = nodes.map((n) => _nullishCoalesce(overrideUpdates.get(n.id), () => ( n)));
+    g = new Graph(nodes);
+  }
+  const comps = /* @__PURE__ */ new Set();
+  for (const n of nodes) {
+    const b = prev.get(n.id);
+    if (b === n) continue;
+    const c = owningComponentIn(g, n.id);
+    if (isCanvasComponentSet(n) && (!b || !same(dataOf(b)[COMPONENT_SET_DATA_KEY], dataOf(n)[COMPONENT_SET_DATA_KEY]))) {
+      for (const v of variantsIn(g, n.id)) comps.add(v.id);
+    }
+    if (!c) continue;
+    if (!b) {
+      comps.add(c);
+      continue;
+    }
+    const structural = b.parentId !== n.parentId || !same(dataOf(b)[COMPONENT_DATA_KEY], dataOf(n)[COMPONENT_DATA_KEY]) || !same(getComponentPropertyRefs(b), getComponentPropertyRefs(n)) || getComponentSourceId(b) !== getComponentSourceId(n) || !same(getNodeOverrides(b), getNodeOverrides(n));
+    const diff = diffOverrideGroups(b, n);
+    if (!structural && (diff.length === 0 || n.id === c && diff.every(isOwnRootGroup))) continue;
+    comps.add(c);
+  }
+  for (const b of before) {
+    if (afterIds.has(b.id)) continue;
+    const c = owningComponentIn(prev, b.id);
+    if (c && c !== b.id && g.get(c)) comps.add(c);
+  }
+  {
+    const order = (list) => {
+      const m = /* @__PURE__ */ new Map();
+      for (const n of list) if (n.parentId) m.set(n.parentId, [..._nullishCoalesce(m.get(n.parentId), () => ( [])), n.id]);
+      return m;
+    };
+    const ob = order(before);
+    const oa = order(nodes);
+    for (const [parent, kids] of oa) {
+      if (same(ob.get(parent), kids)) continue;
+      const c = owningComponentIn(g, parent);
+      if (c && !owningInstanceIn(g, parent)) comps.add(c);
+    }
+  }
+  nodes = rebuildInstances(nodes, comps, resync, opts);
+  return finish(after, nodes, opts);
+}
+function fail(nodes, code, reason) {
+  return { ok: false, nodes, code, reason };
+}
+function done(before, after, ids, options) {
+  return { ok: true, nodes: syncCanvasComponents(before, after, options), ids };
+}
+function uniqueId(base, taken) {
+  let id = base;
+  for (let k = 2; taken.has(id); k++) id = `${base}-${k}`;
+  return id;
+}
+function sizedStyle(like, width, height) {
+  return typeof like === "string" ? `width: ${width}px; height: ${height}px` : { width, height };
+}
+function wrapInFrame(nodes, ids, frame) {
+  const g = new Graph(nodes);
+  const roots = ids.map((id) => g.get(id));
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const n of roots) {
+    const { width: width2, height: height2 } = getNodeSize(n);
+    minX = Math.min(minX, n.position.x);
+    minY = Math.min(minY, n.position.y);
+    maxX = Math.max(maxX, n.position.x + width2);
+    maxY = Math.max(maxY, n.position.y + height2);
+  }
+  minX -= frame.padding;
+  minY -= frame.padding;
+  maxX += frame.padding;
+  maxY += frame.padding;
+  const width = maxX - minX;
+  const height = maxY - minY;
+  const parentId = roots[0].parentId;
+  const wrapper = {
+    id: frame.id,
+    type: frame.type,
+    position: { x: minX, y: minY },
+    width,
+    height,
+    style: sizedStyle(roots[0].style, width, height),
+    data: frame.data,
+    ...parentId ? { parentId } : {}
+  };
+  const selected = new Set(ids);
+  const firstIndex = nodes.findIndex((n) => selected.has(n.id));
+  const out = [];
+  nodes.forEach((n, i) => {
+    if (i === firstIndex) out.push(wrapper);
+    out.push(selected.has(n.id) ? { ...n, parentId: frame.id, position: { x: n.position.x - minX, y: n.position.y - minY } } : n);
+  });
+  return out;
+}
+function createCanvasComponent(nodes, ids, options = {}) {
+  const g = new Graph(nodes);
+  const picked = [...new Set(ids)].filter((id2) => g.get(id2));
+  const roots = picked.filter((id2) => !picked.some((o) => o !== id2 && g.isAncestor(o, id2)));
+  if (roots.length === 0) return fail(nodes, "not-found", "Select the layers to make a component.");
+  if (roots.some((id2) => enclosingInstanceIn(g, id2) !== void 0)) {
+    return fail(nodes, "inside-instance", "Layers inside an instance can't become components: detach the instance first.");
+  }
+  if (roots.some((id2) => isCanvasComponent(g.get(id2)) || isCanvasComponentSet(g.get(id2)))) {
+    return fail(nodes, "invalid", "The selection is already a component.");
+  }
+  if (new Set(roots.map((id2) => _nullishCoalesce(g.get(id2).parentId, () => ( "")))).size > 1) return fail(nodes, "invalid", "Select layers that share a parent.");
+  const frameTypes = _nullishCoalesce(options.frameTypes, () => ( ["group", "frame"]));
+  if (roots.length === 1) {
+    const node = g.get(roots[0]);
+    const frameLike = !isCanvasInstance(node) && (g.children(node.id).length > 0 || typeof node.type === "string" && frameTypes.includes(node.type) || !!getAutoLayout(node));
+    if (frameLike) {
+      const after2 = nodes.map((n) => n.id === node.id ? withData(n, { ...dataOf(n), [COMPONENT_DATA_KEY]: {} }) : n);
+      return done(nodes, after2, [node.id], options);
+    }
+  }
+  const id = _nullishCoalesce(options.id, () => ( uniqueId("component", g.byId)));
+  const name = _nullishCoalesce(options.name, () => ( (roots.length === 1 ? getLayerName(g.get(roots[0])) || "Component" : "Component")));
+  const after = wrapInFrame([...nodes], roots, { id, type: _nullishCoalesce(options.frameType, () => ( "group")), data: { label: name, [COMPONENT_DATA_KEY]: {} }, padding: 0 });
+  return done(nodes, after, [id], options);
+}
+function combineCanvasComponentsAsVariants(nodes, ids, options = {}) {
+  const g = new Graph(nodes);
+  const picked = [...new Set(ids)].filter((id2) => g.get(id2));
+  if (picked.length === 0) return fail(nodes, "not-found", "Select components to combine.");
+  if (!picked.every((id2) => isCanvasComponent(g.get(id2)))) return fail(nodes, "invalid", "Select components only.");
+  if (picked.some((id2) => variantSetIn(g, id2))) return fail(nodes, "invalid", "A component is already a variant of a set.");
+  if (picked.some((id2) => owningInstanceIn(g, id2))) return fail(nodes, "inside-instance", "Components inside an instance can't be combined.");
+  if (new Set(picked.map((id2) => _nullishCoalesce(g.get(id2).parentId, () => ( "")))).size > 1) return fail(nodes, "invalid", "Select components that share a parent.");
+  const ordered = nodes.filter((n) => picked.includes(n.id)).map((n) => n.id);
+  const first = g.get(ordered[0]);
+  const firstName = getLayerName(first);
+  const name = _nullishCoalesce(options.name, () => ( (firstName && !firstName.includes("=") ? firstName.split("/")[0].trim() : "Component")));
+  const id = _nullishCoalesce(options.id, () => ( uniqueId("component-set", g.byId)));
+  let after = wrapInFrame([...nodes], ordered, {
+    id,
+    type: _nullishCoalesce(options.frameType, () => ( "group")),
+    data: { label: name, [COMPONENT_SET_DATA_KEY]: {} },
+    padding: _nullishCoalesce(options.padding, () => ( 20))
+  });
+  const order = [];
+  for (const vid of ordered) for (const k of Object.keys(getVariantValues(g.get(vid)))) if (!order.includes(k)) order.push(k);
+  after = after.map((n) => {
+    const k = ordered.indexOf(n.id);
+    if (k < 0) return n;
+    let variant = getVariantValues(n);
+    if (Object.keys(variant).length === 0) variant = { "Property 1": k === 0 ? "Default" : `Variant${k + 1}` };
+    const comp = { ..._nullishCoalesce(getComponentData(n), () => ( {})), variant };
+    return withData(n, { ...dataOf(n), [COMPONENT_DATA_KEY]: comp, label: formatVariantName(variant, order) });
+  });
+  return done(nodes, after, [id], options);
+}
+function createCanvasInstance(nodes, componentId, options = {}) {
+  const g = new Graph(nodes);
+  const main = mainOfIn(g, componentId);
+  if (!main) return fail(nodes, "not-found", "Choose a component or component set.");
+  const parentId = options.parentId;
+  if (parentId !== void 0 && !g.get(parentId)) return fail(nodes, "not-found", `Unknown parent "${parentId}".`);
+  if (createsCycleIn(g, main, parentId)) return fail(nodes, "cycle", "An instance can't be placed inside its own main component.");
+  if (parentId !== void 0 && owningInstanceIn(g, parentId)) return fail(nodes, "inside-instance", "Instances can't gain layers: place it outside the instance.");
+  const comp = g.get(main);
+  const id = _nullishCoalesce(options.id, () => ( uniqueId(`${main}-instance`, g.byId)));
+  if (g.get(id)) return fail(nodes, "invalid", `Id "${id}" is taken.`);
+  let position = options.position;
+  if (!position) {
+    if (parentId !== void 0) position = { x: 0, y: 0 };
+    else {
+      const top = g.chain(main).pop();
+      position = { x: getAbsolutePosition(top, g.byId).x + getNodeSize(top).width + 40, y: getAbsolutePosition(comp, g.byId).y };
+    }
+  }
+  const root = {
+    id,
+    type: comp.type,
+    position: { ...position },
+    data: { [INSTANCE_DATA_KEY]: { componentId: main, properties: effectivePropsIn(g, main, void 0) }, [COMPONENT_SOURCE_DATA_KEY]: main },
+    ...parentId !== void 0 ? { parentId } : {}
+  };
+  const opts = resolveSync(options);
+  let after = rebuildBatch([...nodes, root], [id], opts);
+  if (options.properties && Object.keys(options.properties).length) {
+    const set = setCanvasInstanceProperties(after, [id], options.properties, { ...options, tokens: void 0 });
+    if (!set.ok) return fail(nodes, set.code, set.reason);
+    after = set.nodes;
+  }
+  return { ok: true, nodes: finish(nodes, after, opts), ids: [id] };
+}
+function detachCanvasInstance(nodes, ids, options = {}) {
+  let current = [...nodes];
+  const doneIds = [];
+  for (const id of new Set(ids)) {
+    const g = new Graph(current);
+    if (!isCanvasInstance(g.get(id))) continue;
+    if (enclosingInstanceIn(g, id) !== void 0) {
+      return fail(nodes, "nested-instance", "A nested instance can't be detached on its own: detach the outer instance first.");
+    }
+    const nested = [];
+    const updates = /* @__PURE__ */ new Map();
+    for (const d of g.subtree(id)) {
+      if (d === id || enclosingInstanceIn(g, d) !== id) continue;
+      if (isCanvasInstance(g.get(d))) nested.push(d);
+      else updates.set(d, unlinked(g.get(d)));
+    }
+    const root = g.get(id);
+    const data = { ...dataOf(root) };
+    delete data[INSTANCE_DATA_KEY];
+    delete data[COMPONENT_SOURCE_DATA_KEY];
+    delete data[COMPONENT_OVERRIDES_DATA_KEY];
+    updates.set(id, withData(root, data));
+    current = current.map((n) => _nullishCoalesce(updates.get(n.id), () => ( n)));
+    for (const nn of nested) current = rebaseInstance(current, nn, options.tokens);
+    doneIds.push(id);
+  }
+  if (doneIds.length === 0) return fail(nodes, "invalid", "Select an instance.");
+  return done(nodes, current, doneIds, options);
+}
+function resetCanvasInstanceOverrides(nodes, id, group, options = {}) {
+  const g = new Graph(nodes);
+  const node = g.get(id);
+  const inst = node ? owningInstanceIn(g, id) : void 0;
+  if (!node || !inst) return fail(nodes, "not-found", "Select an instance or a layer inside one.");
+  const top = inst === id && enclosingInstanceIn(g, id) === void 0;
+  const updates = /* @__PURE__ */ new Map();
+  const resetProps = (n) => {
+    const data = getInstanceData(n);
+    const defaults = effectivePropsIn(g, data.componentId, void 0);
+    return same(_nullishCoalesce(data.properties, () => ( {})), defaults) ? n : withData(n, { ...dataOf(n), [INSTANCE_DATA_KEY]: { ...data, properties: defaults } });
+  };
+  if (group !== void 0) {
+    let next = setOverrides(node, getNodeOverrides(node).filter((gr) => gr !== group));
+    if (top && group === "props") next = resetProps(next);
+    updates.set(id, next);
+  } else if (inst === id) {
+    for (const d of g.subtree(id)) {
+      const n = g.get(d);
+      const keep = d === id && top ? getNodeOverrides(n).filter((gr) => gr === "size") : [];
+      updates.set(d, setOverrides(n, keep));
+    }
+    if (top) updates.set(id, resetProps(updates.get(id)));
+  } else updates.set(id, setOverrides(node, []));
+  const after = nodes.map((n) => _nullishCoalesce(updates.get(n.id), () => ( n)));
+  const changed = after.some((n, i) => n !== nodes[i]);
+  if (!changed) return { ok: true, nodes, ids: [] };
+  const synced = syncCanvasComponents(nodes, after, options);
+  return { ok: true, nodes: synced, ids: [inst] };
+}
+function pushCanvasInstanceOverrides(nodes, id, options = {}) {
+  const g = new Graph(nodes);
+  const inst = g.get(id) ? rootInstanceIn(g, id) : void 0;
+  if (!inst) return fail(nodes, "not-found", "Select an instance.");
+  const compId = getInstanceData(g.get(inst)).componentId;
+  if (!isCanvasComponent(g.get(compId))) return fail(nodes, "missing-main", "The main component was deleted: restore it first.");
+  const updates = /* @__PURE__ */ new Map();
+  let pushed = 0;
+  for (const d of g.subtree(inst)) {
+    const n = g.get(d);
+    const overrides = getNodeOverrides(n);
+    if (overrides.length === 0) continue;
+    const src = d === inst ? compId : getComponentSourceId(n);
+    if (!src || !g.get(src) || src !== compId && !g.isAncestor(compId, src)) continue;
+    const groups = overrides.filter(
+      (gr) => gr !== "size" && gr !== "position" && gr !== "component" && gr !== "props" && !(d === inst && (gr === "data.label" || gr === "data.name" || isOwnRootGroup(gr)))
+    );
+    if (groups.length === 0) continue;
+    pushed++;
+    updates.set(src, copyGroups(n, _nullishCoalesce(updates.get(src), () => ( g.get(src))), groups));
+    updates.set(d, setOverrides(n, overrides.filter((gr) => !groups.includes(gr))));
+  }
+  if (pushed === 0) return fail(nodes, "no-overrides", "The instance has no changes to push.");
+  const after = nodes.map((n) => _nullishCoalesce(updates.get(n.id), () => ( n)));
+  return done(nodes, after, [inst], options);
+}
+function swapCanvasInstance(nodes, ids, componentId, options = {}) {
+  const g = new Graph(nodes);
+  const main = mainOfIn(g, componentId);
+  if (!main) return fail(nodes, "not-found", "Choose a component or component set.");
+  const updates = /* @__PURE__ */ new Map();
+  const list = [...new Set(ids)];
+  for (const id of list) {
+    const n = g.get(id);
+    const inst = getInstanceData(n);
+    if (!n || !inst) return fail(nodes, "invalid", `"${id}" is not an instance.`);
+    if (g.isAncestor(main, id) || createsCycleIn(g, main, n.parentId)) return fail(nodes, "cycle", "An instance can't show the component it is inside.");
+    const defaults = effectivePropsIn(g, main, void 0);
+    const properties = {};
+    for (const [k, d] of Object.entries(defaults)) properties[k] = _optionalChain([inst, 'access', _318 => _318.properties, 'optionalAccess', _319 => _319[k]]) !== void 0 && typeof inst.properties[k] === typeof d ? inst.properties[k] : d;
+    updates.set(id, withData(n, { ...dataOf(n), [INSTANCE_DATA_KEY]: { ...inst, componentId: main, properties } }));
+    if (options.keepTextOverridesOnly) {
+      for (const d of g.subtree(id)) {
+        const layer = _nullishCoalesce(updates.get(d), () => ( g.get(d)));
+        const text = typeof layer.type === "string" && (_nullishCoalesce(options.textTypes, () => ( ["text"]))).includes(layer.type);
+        const keep = getNodeOverrides(layer).filter((gr) => text || d === id && gr === "size");
+        updates.set(d, setOverrides(layer, keep));
+      }
+    }
+  }
+  if (list.length === 0) return fail(nodes, "invalid", "Select an instance.");
+  const after = nodes.map((n) => _nullishCoalesce(updates.get(n.id), () => ( n)));
+  return done(nodes, after, list, options);
+}
+function setCanvasInstanceProperties(nodes, ids, properties, options = {}) {
+  const g = new Graph(nodes);
+  const updates = /* @__PURE__ */ new Map();
+  const list = [...new Set(ids)];
+  if (list.length === 0) return fail(nodes, "invalid", "Select an instance.");
+  for (const id of list) {
+    const n = g.get(id);
+    const inst = getInstanceData(n);
+    if (!n || !inst) return fail(nodes, "invalid", `"${id}" is not an instance.`);
+    const set = variantSetIn(g, inst.componentId);
+    const options_ = set ? variantOptionsIn(g, set.id) : [];
+    const wanted = { ...getVariantValues(g.get(inst.componentId)) };
+    const rest = [];
+    for (const [k, v] of Object.entries(properties)) {
+      const option = options_.find((o) => o.name === k);
+      if (option) {
+        const value = typeof v === "string" ? v : String(v);
+        if (!option.values.includes(value)) return fail(nodes, "invalid", `"${k}" must be one of ${option.values.join(", ")}.`);
+        wanted[k] = value;
+      } else rest.push([k, v]);
+    }
+    let target = inst.componentId;
+    if (set && !same(wanted, getVariantValues(g.get(inst.componentId)))) target = _nullishCoalesce(findVariantIn(g, set.id, wanted), () => ( target));
+    const defs = propertyDefsIn(g, target);
+    const values = { ..._nullishCoalesce(inst.properties, () => ( {})) };
+    for (const [k, v] of rest) {
+      const def = defs[k];
+      if (!def) {
+        const known = [...Object.keys(defs), ...options_.map((o) => o.name)];
+        return fail(nodes, "unknown-property", `Unknown property "${k}"${known.length ? ` (known: ${known.join(", ")})` : ""}.`);
+      }
+      if (def.type === "boolean") {
+        const b = typeof v === "boolean" ? v : v === "true" ? true : v === "false" ? false : void 0;
+        if (b === void 0) return fail(nodes, "type-mismatch", `"${k}" takes true or false.`);
+        values[k] = b;
+      } else if (def.type === "text") {
+        if (typeof v !== "string" && typeof v !== "number") return fail(nodes, "type-mismatch", `"${k}" takes text.`);
+        values[k] = String(v);
+      } else {
+        const main = typeof v === "string" ? mainOfIn(g, v) : void 0;
+        if (!main) return fail(nodes, "type-mismatch", `"${k}" takes a component id.`);
+        if (main === target || componentDepsIn(g, main).has(target) || createsCycleIn(g, main, n.parentId)) {
+          return fail(nodes, "cycle", `"${k}" can't show a component that contains this one.`);
+        }
+        values[k] = main;
+      }
+    }
+    const properties2 = effectivePropsIn(g, target, values);
+    updates.set(id, withData(n, { ...dataOf(n), [INSTANCE_DATA_KEY]: { ...inst, componentId: target, properties: properties2 } }));
+  }
+  const after = nodes.map((n) => _nullishCoalesce(updates.get(n.id), () => ( n)));
+  return done(nodes, after, list, options);
+}
+function setCanvasComponentProperty(nodes, componentId, name, def, options = {}) {
+  const g = new Graph(nodes);
+  const target = g.get(componentId);
+  const compId = isCanvasComponentSet(target) ? void 0 : owningComponentIn(g, componentId);
+  const owner = isCanvasComponentSet(target) ? target : compId ? _nullishCoalesce(variantSetIn(g, compId), () => ( g.get(compId))) : void 0;
+  if (!owner) return fail(nodes, "not-found", "Select a component or component set.");
+  const key = isCanvasComponentSet(owner) ? COMPONENT_SET_DATA_KEY : COMPONENT_DATA_KEY;
+  const ownerData = { ..._nullishCoalesce(dataOf(owner)[key], () => ( {})) };
+  const defs = { ..._nullishCoalesce(ownerData.properties, () => ( {})) };
+  const finalName = (_nullishCoalesce(options.newName, () => ( name))).trim();
+  if (!finalName) return fail(nodes, "invalid", "Property names must not be empty.");
+  if (isCanvasComponentSet(owner) && variantOptionsIn(g, owner.id).some((o) => o.name === finalName)) {
+    return fail(nodes, "invalid", `"${finalName}" is a variant property.`);
+  }
+  if (finalName !== name && defs[finalName]) return fail(nodes, "invalid", `"${finalName}" exists already.`);
+  if (def === null) {
+    if (!defs[name]) return fail(nodes, "unknown-property", `Unknown property "${name}".`);
+    delete defs[name];
+  } else {
+    if (def.type === "boolean" && typeof def.default !== "boolean") return fail(nodes, "type-mismatch", "A boolean property needs a boolean default.");
+    if (def.type === "text" && typeof def.default !== "string") return fail(nodes, "type-mismatch", "A text property needs a text default.");
+    if (def.type === "instanceSwap" && !mainOfIn(g, def.default)) return fail(nodes, "type-mismatch", "An instance swap property needs a component as default.");
+    if (finalName !== name) delete defs[name];
+    defs[finalName] = def;
+  }
+  ownerData.properties = defs;
+  const comps = isCanvasComponentSet(owner) ? variantsIn(g, owner.id).map((v) => v.id) : [owner.id];
+  const updates = /* @__PURE__ */ new Map();
+  updates.set(owner.id, withData(owner, { ...dataOf(owner), [key]: ownerData }));
+  const renamed = def === null ? null : finalName;
+  if (renamed !== name) {
+    for (const c of comps) {
+      for (const d of g.subtree(c)) {
+        const n = _nullishCoalesce(updates.get(d), () => ( g.get(d)));
+        const refs = { ...getComponentPropertyRefs(n) };
+        let touched = false;
+        for (const [field, prop] of Object.entries(refs)) {
+          if (prop !== name) continue;
+          touched = true;
+          if (renamed === null) delete refs[field];
+          else refs[field] = renamed;
+        }
+        if (!touched) continue;
+        const data = { ...dataOf(n), [COMPONENT_PROPERTY_REFS_DATA_KEY]: refs };
+        if (Object.keys(refs).length === 0) delete data[COMPONENT_PROPERTY_REFS_DATA_KEY];
+        updates.set(d, withData(n, data));
+      }
+    }
+    for (const n of nodes) {
+      const inst = getInstanceData(n);
+      if (!inst || !comps.includes(inst.componentId) || !inst.properties || !(name in inst.properties)) continue;
+      const props = { ...inst.properties };
+      const v = props[name];
+      delete props[name];
+      if (renamed !== null) props[renamed] = v;
+      const cur = _nullishCoalesce(updates.get(n.id), () => ( n));
+      updates.set(n.id, withData(cur, { ...dataOf(cur), [INSTANCE_DATA_KEY]: { ...inst, properties: props } }));
+    }
+  }
+  const after = nodes.map((n) => _nullishCoalesce(updates.get(n.id), () => ( n)));
+  return done(nodes, after, [owner.id], options);
+}
+function bindCanvasComponentProperty(nodes, layerId, field, name, options = {}) {
+  const g = new Graph(nodes);
+  const layer = g.get(layerId);
+  const compId = layer ? owningComponentIn(g, layerId) : void 0;
+  if (!layer || !compId || compId === layerId) return fail(nodes, "not-found", "Select a layer of a main component.");
+  const inst = enclosingInstanceIn(g, layerId);
+  if (inst && g.isAncestor(compId, inst)) return fail(nodes, "inside-instance", "Layers of a nested instance can't be bound: bind the nested instance's own main.");
+  const refs = { ...getComponentPropertyRefs(layer) };
+  if (name === null) delete refs[field];
+  else {
+    const def = propertyDefsIn(g, compId)[name];
+    if (!def) return fail(nodes, "unknown-property", `Unknown property "${name}".`);
+    const ok = def.type === "boolean" && field === "visible" || def.type === "text" && field.startsWith("data.") || def.type === "instanceSwap" && field === "component" && isCanvasInstance(layer);
+    if (!ok) return fail(nodes, "type-mismatch", `A ${def.type} property can't drive "${field}".`);
+    refs[field] = name;
+  }
+  const data = { ...dataOf(layer) };
+  if (Object.keys(refs).length) data[COMPONENT_PROPERTY_REFS_DATA_KEY] = refs;
+  else delete data[COMPONENT_PROPERTY_REFS_DATA_KEY];
+  const after = nodes.map((n) => n.id === layerId ? withData(n, data) : n);
+  return done(nodes, after, [layerId], options);
+}
+function restoreCanvasMainComponent(nodes, id, options = {}) {
+  const g = new Graph(nodes);
+  const inst = getInstanceData(g.get(id));
+  if (!inst) return fail(nodes, "invalid", "Select an instance.");
+  if (g.get(inst.componentId)) return fail(nodes, "invalid", "The main component still exists.");
+  if (enclosingInstanceIn(g, id) !== void 0) return fail(nodes, "nested-instance", "Select the outer instance.");
+  const compId = inst.componentId;
+  const sub3 = g.subtree(id);
+  const map = /* @__PURE__ */ new Map([[id, compId]]);
+  const taken = new Set(nodes.map((n) => n.id));
+  taken.add(compId);
+  for (const d of sub3) {
+    if (d === id) continue;
+    const src = enclosingInstanceIn(g, d) === id ? getComponentSourceId(g.get(d)) : void 0;
+    if (src && !taken.has(src)) {
+      map.set(d, src);
+      taken.add(src);
+    }
+  }
+  const nested = [];
+  const replaced = /* @__PURE__ */ new Map();
+  for (const d of sub3) {
+    let n = g.get(d);
+    const nid = _nullishCoalesce(map.get(d), () => ( d));
+    const parentId = n.parentId !== void 0 ? _nullishCoalesce(map.get(n.parentId), () => ( n.parentId)) : void 0;
+    n = { ...n, id: nid, ...parentId !== void 0 ? { parentId } : {} };
+    if (d === id) {
+      const defs = {};
+      for (const [k, v] of Object.entries(_nullishCoalesce(inst.properties, () => ( {})))) {
+        if (typeof v === "boolean") defs[k] = { type: "boolean", default: v };
+        else if (typeof v === "string" && isCanvasComponent(g.get(v))) defs[k] = { type: "instanceSwap", default: v };
+        else if (typeof v === "string") defs[k] = { type: "text", default: v };
+      }
+      const data = { ...dataOf(n) };
+      delete data[INSTANCE_DATA_KEY];
+      delete data[COMPONENT_SOURCE_DATA_KEY];
+      delete data[COMPONENT_OVERRIDES_DATA_KEY];
+      data[COMPONENT_DATA_KEY] = Object.keys(defs).length ? { properties: defs } : {};
+      n = withData(n, data);
+    } else if (enclosingInstanceIn(g, d) === id) {
+      if (isCanvasInstance(n)) nested.push(nid);
+      else n = unlinked(n);
+    }
+    replaced.set(d, n);
+  }
+  let after = nodes.map((n) => _nullishCoalesce(replaced.get(n.id), () => ( n)));
+  for (const nn of nested) after = rebaseInstance(after, nn, options.tokens);
+  return done(nodes, after, [compId], options);
+}
+
+// src/canvas/componentsController.ts
+function makePatch(from, to) {
+  const fromIds = new Map(from.map((n) => [n.id, n]));
+  const toIds = new Set(to.map((n) => n.id));
+  const changes = /* @__PURE__ */ new Map();
+  for (const n of to) if (fromIds.get(n.id) !== n) changes.set(n.id, n);
+  for (const n of from) if (!toIds.has(n.id)) changes.set(n.id, null);
+  return { changes, order: to.map((n) => n.id) };
+}
+function applyPatch(current, patch) {
+  const byId = new Map(current.map((n) => [n.id, n]));
+  for (const [id, n] of patch.changes) {
+    if (n) byId.set(id, n);
+    else byId.delete(id);
+  }
+  const out = [];
+  const placed = /* @__PURE__ */ new Set();
+  for (const id of patch.order) {
+    const n = byId.get(id);
+    if (n && !placed.has(id)) {
+      out.push(n);
+      placed.add(id);
+    }
+  }
+  for (const n of current) if (!placed.has(n.id) && byId.has(n.id)) out.push(byId.get(n.id));
+  return out;
+}
+function createCanvasComponentsController(options) {
+  let synced;
+  const syncOptions = () => ({
+    idGenerator: options.idGenerator,
+    textTypes: options.textTypes,
+    layout: options.layout,
+    tokens: options.tokens
+  });
+  const selection = (ids) => ids ? [...ids] : _nullishCoalesce(_optionalChain([options, 'access', _320 => _320.getSelectedIds, 'optionalCall', _321 => _321()]), () => ( options.getNodes().filter((n) => n.selected).map((n) => n.id)));
+  const target = (id) => _nullishCoalesce(id, () => ( selection()[0]));
+  function set(next) {
+    synced = next;
+    options.setNodes(next);
+  }
+  function sync() {
+    const nodes2 = options.getNodes();
+    if (synced === void 0 || nodes2 === synced) {
+      synced = nodes2;
+      return nodes2;
+    }
+    const next = syncCanvasComponents(synced, nodes2, syncOptions());
+    synced = next;
+    if (next !== nodes2) options.setNodes(next);
+    return next;
+  }
+  function run(name, op) {
+    const before = sync();
+    const result = op(before);
+    if (!result.ok || result.nodes === before) return result;
+    const forward = makePatch(before, result.nodes);
+    const backward = makePatch(result.nodes, before);
+    const execute = () => set(applyPatch(options.getNodes(), forward));
+    const undo = () => set(applyPatch(options.getNodes(), backward));
+    if (options.history) options.history.execute({ name, execute, undo });
+    else execute();
+    return result;
+  }
+  const reason = (result) => result.ok ? true : result.reason;
+  const nodes = () => options.getNodes();
+  const controller = {
+    sync,
+    /** Rebuilds every instance from its main (e.g. after loading), not recorded in history. */
+    syncAll() {
+      const next = syncAllCanvasInstances(nodes(), syncOptions());
+      if (next !== nodes()) set(next);
+      else synced = next;
+      return next;
+    },
+    /** Create Component from `ids` (default: the selection). */
+    createComponent(ids, createOptions = {}) {
+      const list = selection(ids);
+      return run("Create Component", (n) => createCanvasComponent(n, list, { ...syncOptions(), ...createOptions }));
+    },
+    canCreateComponent: (ids) => reason(createCanvasComponent(nodes(), selection(ids), { layout: false })),
+    /** Combine as Variants: wraps the selected components in a component set. */
+    combineAsVariants(ids, combineOptions = {}) {
+      const list = selection(ids);
+      return run("Combine as Variants", (n) => combineCanvasComponentsAsVariants(n, list, { ...syncOptions(), ...combineOptions }));
+    },
+    canCombineAsVariants: (ids) => reason(combineCanvasComponentsAsVariants(nodes(), selection(ids), { layout: false })),
+    /** Create Instance of a component or component set. */
+    createInstance(componentId, createOptions = {}) {
+      return run("Create Instance", (n) => createCanvasInstance(n, componentId, { ...syncOptions(), ...createOptions }));
+    },
+    canCreateInstance(componentId, parentId) {
+      const list = nodes();
+      const target2 = componentId ? list.find((n) => n.id === componentId) : void 0;
+      if (!target2 || !isCanvasComponent(target2) && !isCanvasComponentSet(target2)) return "Choose a component or component set.";
+      if (wouldCreateComponentCycle(list, componentId, parentId)) return "An instance can't be placed inside its own main component.";
+      if (parentId && getOwningInstance(list, parentId)) return "Instances can't gain layers: place it outside the instance.";
+      return true;
+    },
+    /** Detach Instance (default: the selected instances). */
+    detachInstance(ids) {
+      const list = selection(ids);
+      return run("Detach Instance", (n) => detachCanvasInstance(n, list, syncOptions()));
+    },
+    canDetachInstance(ids) {
+      const list = nodes();
+      const instances = selection(ids).filter((id) => getInstanceData(list.find((n) => n.id === id)));
+      if (instances.length === 0) return "Select an instance.";
+      if (instances.some((id) => isInsideInstance(list, id))) return "A nested instance can't be detached on its own: detach the outer instance first.";
+      return true;
+    },
+    /** Reset overrides of an instance or layer (default: the first selected); `group` resets one. */
+    resetOverrides(id, group) {
+      const at = target(id);
+      if (!at) return { ok: false, nodes: nodes(), code: "not-found", reason: "Select an instance or a layer inside one." };
+      return run(group ? "Reset Override" : "Reset All Changes", (n) => resetCanvasInstanceOverrides(n, at, group, syncOptions()));
+    },
+    canResetOverrides(id) {
+      const at = target(id);
+      const info = at ? inspectCanvasInstance(nodes(), at) : void 0;
+      if (!info) return "Select an instance or a layer inside one.";
+      const changedProps = !info.nested && info.properties.some((p) => p.value !== p.default);
+      const own = info.id === at ? info.overrides.length > 0 : getNodeOverrides(nodes().find((n) => n.id === at)).length > 0;
+      return own || info.id === at && changedProps ? true : "No overrides to reset.";
+    },
+    /** Push the (outermost) instance's overrides to its main component. */
+    pushOverrides(id) {
+      const at = target(id);
+      if (!at) return { ok: false, nodes: nodes(), code: "not-found", reason: "Select an instance." };
+      return run("Push Changes to Main Component", (n) => pushCanvasInstanceOverrides(n, at, syncOptions()));
+    },
+    canPushOverrides(id) {
+      const at = target(id);
+      return at ? reason(pushCanvasInstanceOverrides(nodes(), at, { layout: false })) : "Select an instance.";
+    },
+    /** Swap the selected instances to another component (or a set's default variant). */
+    swapInstance(componentId, ids, swapOptions = {}) {
+      const list = selection(ids);
+      return run("Swap Instance", (n) => swapCanvasInstance(n, list, componentId, { ...syncOptions(), ...swapOptions }));
+    },
+    canSwapInstance(componentId, ids) {
+      const list = nodes();
+      const instances = selection(ids).filter((id) => getInstanceData(list.find((n) => n.id === id)));
+      if (instances.length === 0) return "Select an instance.";
+      if (componentId === void 0) return true;
+      const main = list.find((n) => n.id === componentId);
+      if (!main || !isCanvasComponent(main) && !isCanvasComponentSet(main)) return "Choose a component or component set.";
+      for (const id of instances) {
+        const node = list.find((n) => n.id === id);
+        if (wouldCreateComponentCycle(list, componentId, node.parentId)) return "An instance can't show the component it is inside.";
+      }
+      return true;
+    },
+    /** Set variant / component property values on the selected instances (one step). */
+    setInstanceProperties(properties, ids) {
+      const list = selection(ids);
+      return run("Set Instance Properties", (n) => setCanvasInstanceProperties(n, list, properties, syncOptions()));
+    },
+    canSetInstanceProperties(ids) {
+      const list = nodes();
+      const sel = selection(ids);
+      return sel.length > 0 && sel.every((id) => getInstanceData(list.find((n) => n.id === id))) ? true : "Select instances.";
+    },
+    /** Restore Main Component from an instance whose main was deleted. */
+    restoreMainComponent(id) {
+      const at = target(id);
+      if (!at) return { ok: false, nodes: nodes(), code: "not-found", reason: "Select an instance." };
+      return run("Restore Main Component", (n) => restoreCanvasMainComponent(n, at, syncOptions()));
+    },
+    canRestoreMainComponent(id) {
+      const at = target(id);
+      return at ? reason(restoreCanvasMainComponent(nodes(), at, { layout: false })) : "Select an instance.";
+    },
+    /** Adds, edits or (with `null`) deletes a component property. */
+    setComponentProperty(componentId, name, def, propertyOptions = {}) {
+      return run(
+        def ? "Edit Component Property" : "Delete Component Property",
+        (n) => setCanvasComponentProperty(n, componentId, name, def, { ...syncOptions(), ...propertyOptions })
+      );
+    },
+    /** Binds (or with `null` unbinds) a main layer's field to a component property. */
+    bindComponentProperty(layerId, field, name) {
+      return run("Bind Component Property", (n) => bindCanvasComponentProperty(n, layerId, field, name, syncOptions()));
+    },
+    /** Selects the main component of an instance (or of the instance a layer is in). */
+    goToMainComponent(id) {
+      const at = target(id);
+      const list = sync();
+      const inst = at ? getOwningInstance(list, at) : void 0;
+      const main = inst ? _optionalChain([getInstanceData, 'call', _322 => _322(list.find((n) => n.id === inst)), 'optionalAccess', _323 => _323.componentId]) : void 0;
+      const node = main ? list.find((n) => n.id === main) : void 0;
+      if (!node) return void 0;
+      const next = list.map((n) => !!n.selected === (n.id === main) ? n : { ...n, selected: n.id === main });
+      set(next);
+      _optionalChain([options, 'access', _324 => _324.onReveal, 'optionalCall', _325 => _325(next.find((n) => n.id === main))]);
+      return main;
+    },
+    canGoToMainComponent(id) {
+      const at = target(id);
+      const list = nodes();
+      const inst = at ? getOwningInstance(list, at) : void 0;
+      if (!inst) return "Select an instance.";
+      const main = getInstanceData(list.find((n) => n.id === inst)).componentId;
+      return list.some((n) => n.id === main) ? true : "The main component was deleted.";
+    },
+    /** Components and component sets, for a components panel. */
+    list: () => listCanvasComponents(nodes()),
+    /** The instance inspector's view of an instance or a layer inside one (default: the selection). */
+    inspect: (id) => {
+      const at = target(id);
+      return at ? inspectCanvasInstance(nodes(), at) : void 0;
+    },
+    /** The outermost instance containing `id`. */
+    rootInstanceOf: (id) => getRootInstance(nodes(), id)
+  };
+  return controller;
+}
+var CANVAS_COMPONENT_DRAG_TYPE = "application/x-pixerate-component";
+function getCanvasComponentDragId(dataTransfer) {
+  const id = _optionalChain([dataTransfer, 'optionalAccess', _326 => _326.getData, 'call', _327 => _327(CANVAS_COMPONENT_DRAG_TYPE)]);
+  return id ? id : void 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -8056,5 +11954,5 @@ function pruneCanvasTokenModes(nodes, state) {
 
 
 
-exports.AUTO_LAYOUT_DATA_KEY = AUTO_LAYOUT_DATA_KEY; exports.CANVAS_TOKEN_PROPERTIES = CANVAS_TOKEN_PROPERTIES; exports.CHILD_LAYOUT_DATA_KEY = CHILD_LAYOUT_DATA_KEY; exports.CONNECTION_LINE_TYPES = CONNECTION_LINE_TYPES; exports.CanvasScenesStore = CanvasScenesStore; exports.DEFAULT_ARRANGE_SHORTCUTS = _chunk26BVFKHUcjs.DEFAULT_ARRANGE_SHORTCUTS; exports.DEFAULT_NODE_HEIGHT = _chunkWADCJ7A7cjs.DEFAULT_NODE_HEIGHT; exports.DEFAULT_NODE_WIDTH = _chunkWADCJ7A7cjs.DEFAULT_NODE_WIDTH; exports.DEFAULT_PLACEMENT_GAP = _chunkWADCJ7A7cjs.DEFAULT_PLACEMENT_GAP; exports.LOCKED_DATA_KEY = LOCKED_DATA_KEY; exports.LOCKED_PREVIOUS_FLAGS_KEY = LOCKED_PREVIOUS_FLAGS_KEY; exports.ManualClock = ManualClock; exports.PathOpsError = PathOpsError; exports.RESIZE_HANDLES = RESIZE_HANDLES; exports.SHAPE_DATA_KEY = SHAPE_DATA_KEY; exports.SHAPE_KINDS = SHAPE_KINDS; exports.SHAPE_NODE_TYPE = SHAPE_NODE_TYPE; exports.SHAPE_OPERATIONS = SHAPE_OPERATIONS; exports.StreamingLayoutManager = StreamingLayoutManager; exports.TOKEN_BINDINGS_DATA_KEY = TOKEN_BINDINGS_DATA_KEY; exports.TOKEN_MODES_DATA_KEY = TOKEN_MODES_DATA_KEY; exports.alignNodes = alignNodes; exports.applyConstraints = applyConstraints; exports.applyNodeUpdates = applyNodeUpdates; exports.applyShapeCombination = applyShapeCombination; exports.applyShapeReplacement = applyShapeReplacement; exports.arcToCubics = arcToCubics; exports.bezierPathArea = bezierPathArea; exports.bezierPathBounds = bezierPathBounds; exports.bezierPathLength = bezierPathLength; exports.bezierPathPointAtLength = bezierPathPointAtLength; exports.bezierPathSignedArea = bezierPathSignedArea; exports.bezierPathToSvg = bezierPathToSvg; exports.bindCanvasToken = bindCanvasToken; exports.blendLayout = blendLayout; exports.boundsOf = _chunkWADCJ7A7cjs.boundsOf; exports.calculateDagreReflowDisplacement = calculateDagreReflowDisplacement; exports.calculateDirectionalDisplacement = calculateDirectionalDisplacement; exports.canCombineShapeNodes = canCombineShapeNodes; exports.canOffsetShapeNodes = canOffsetShapeNodes; exports.canOutlineShapeNodeStrokes = canOutlineShapeNodeStrokes; exports.canvasHeight = canvasHeight; exports.centerNodes = _chunkWADCJ7A7cjs.centerNodes; exports.centre = _chunkWADCJ7A7cjs.centre; exports.clampLayoutSize = clampLayoutSize; exports.closeContour = closeContour; exports.collectDescendantIds = collectDescendantIds; exports.combineShapeNodes = combineShapeNodes; exports.computeNodesBoundingBox = computeNodesBoundingBox; exports.computeSnapGuides = computeSnapGuides; exports.connectedOnly = connectedOnly; exports.contourSignedArea = contourSignedArea; exports.contoursToPath = contoursToPath; exports.countPathSegments = countPathSegments; exports.createBezierTrajectory = createBezierTrajectory; exports.createCanvasArrangeController = createCanvasArrangeController; exports.createCanvasAutoLayoutController = createCanvasAutoLayoutController; exports.createCanvasScenesStore = createCanvasScenesStore; exports.createFanOutTrajectory = createFanOutTrajectory; exports.createGuideIndex = createGuideIndex; exports.createNodeGuideIndex = createNodeGuideIndex; exports.createNodeLookup = createNodeLookup; exports.cubicPointAt = cubicPointAt; exports.cubicsToPathData = cubicsToPathData; exports.dashContours = dashContours; exports.defaultEasing = defaultEasing; exports.detachTokenBindings = detachTokenBindings; exports.distanceToBezierPath = distanceToBezierPath; exports.distributeNodes = distributeNodes; exports.dividePaths = dividePaths; exports.dividePolygons = dividePolygons; exports.ensureLayout = _chunkWADCJ7A7cjs.ensureLayout; exports.estimateCanvasHeight = estimateCanvasHeight; exports.estimateNodeSize = _chunkWADCJ7A7cjs.estimateNodeSize; exports.excludePaths = excludePaths; exports.findConnectorSnap = findConnectorSnap; exports.fitCubicRun = fitCubicRun; exports.fitCubics = fitCubics; exports.fitFreehandPath = fitFreehandPath; exports.fitPathData = fitPathData; exports.fitViewportToNodes = fitViewportToNodes; exports.fitViewportToRect = fitViewportToRect; exports.flattenSvgPath = flattenSvgPath; exports.flowSide = _chunkWADCJ7A7cjs.flowSide; exports.formatNumber = formatNumber2; exports.getAbsolutePosition = getAbsolutePosition; exports.getAutoLayout = getAutoLayout; exports.getAutoLayoutGrid = getAutoLayoutGrid; exports.getAutoLayoutInsertTarget = getAutoLayoutInsertTarget; exports.getBindableTokenProperties = getBindableTokenProperties; exports.getCanvasTokenProperty = getCanvasTokenProperty; exports.getCenteredNodePosition = _chunkWADCJ7A7cjs.getCenteredNodePosition; exports.getChildLayout = getChildLayout; exports.getEffectiveTokenModes = getEffectiveTokenModes; exports.getFlowChildren = getFlowChildren; exports.getLayoutParent = getLayoutParent; exports.getLayoutSizing = getLayoutSizing; exports.getLayoutedNodes = _chunkWADCJ7A7cjs.getLayoutedNodes; exports.getNodeRect = getNodeRect; exports.getNodeShape = getNodeShape; exports.getNodeSize = getNodeSize; exports.getNodeTokenBindings = getNodeTokenBindings; exports.getNodeTokenModes = getNodeTokenModes; exports.getResizingNodeRect = getResizingNodeRect; exports.getShapeRenderData = getShapeRenderData; exports.getShapeSvg = getShapeSvg; exports.getTokenPropertyScope = getTokenPropertyScope; exports.getTokensForProperty = getTokensForProperty; exports.handlePoint = handlePoint; exports.hasVisibleStroke = hasVisibleStroke; exports.inferResizeHandle = inferResizeHandle; exports.inspectNodeTokens = inspectNodeTokens; exports.intersectPaths = intersectPaths; exports.intersectPolygons = intersectPolygons; exports.invertNodeUpdates = invertNodeUpdates; exports.isAutoLayoutFrame = isAutoLayoutFrame; exports.isEventFromTextInput = isEventFromTextInput; exports.isLocked = isLocked; exports.isMeasureModifierHeld = isMeasureModifierHeld; exports.isShapeDescription = isShapeDescription; exports.isShapeNode = isShapeNode; exports.isStraightCubic = isStraightCubic; exports.isValidCanvasEdge = isValidCanvasEdge; exports.isValidCanvasNode = isValidCanvasNode; exports.isValidCanvasScene = isValidCanvasScene; exports.isValidUrl = isValidUrl; exports.layoutAll = layoutAll; exports.layoutBounds = layoutBounds; exports.layoutFrame = layoutFrame; exports.layoutUp = layoutUp; exports.layoutUpMany = layoutUpMany; exports.linearPositionTrajectory = linearPositionTrajectory; exports.linearTrajectory = linearTrajectory; exports.lockNodes = lockNodes; exports.makeSizingCoherent = makeSizingCoherent; exports.matchArrangeShortcut = _chunk26BVFKHUcjs.matchArrangeShortcut; exports.matchSize = matchSize; exports.measureBetween = measureBetween; exports.measureLabel = measureLabel; exports.measureSelection = measureSelection; exports.measureToLine = measureToLine; exports.mergeNodeUpdates = mergeNodeUpdates; exports.moveLayoutChild = moveLayoutChild; exports.multiPolygonArea = multiPolygonArea; exports.multiPolygonBounds = multiPolygonBounds; exports.nearestHandlePositions = nearestHandlePositions; exports.normalizeBezierPath = normalizeBezierPath; exports.offsetPath = offsetPath; exports.offsetShapeNodes = offsetShapeNodes; exports.oppositePosition = oppositePosition; exports.outlineShapeNodeStrokes = outlineShapeNodeStrokes; exports.outlineStroke = outlineStroke; exports.overlaps = _chunkWADCJ7A7cjs.overlaps; exports.pageHidden = pageHidden; exports.parseCanvasClipboardData = parseCanvasClipboardData; exports.parseCanvasScenes = parseCanvasScenes; exports.parseSvgPath = parseSvgPath; exports.pathBoolean = pathBoolean; exports.pathToContours = pathToContours; exports.placeBeside = _chunkWADCJ7A7cjs.placeBeside; exports.pointInBezierPath = pointInBezierPath; exports.pointInMultiPolygon = pointInMultiPolygon; exports.pointInRings = pointInRings; exports.polygonArea = polygonArea; exports.polygonBoolean = polygonBoolean; exports.polygonToSvgPath = polygonToSvgPath; exports.positionToSide = positionToSide; exports.pruneCanvasTokenModes = pruneCanvasTokenModes; exports.readNodeStyleProperty = readNodeStyleProperty; exports.readStyleSize = readStyleSize; exports.realClock = realClock; exports.relayoutUpdates = relayoutUpdates; exports.remapPastedNodes = remapPastedNodes; exports.reorderNodes = reorderNodes; exports.repositionNodesTo = repositionNodesTo; exports.resizeHandleAxes = resizeHandleAxes; exports.resolveCanvasTokens = resolveCanvasTokens; exports.resolvePadding = resolvePadding; exports.revertShapeCombination = revertShapeCombination; exports.ringSignedArea = ringSignedArea; exports.runMultiNodeTransition = runMultiNodeTransition; exports.segmentBounds = segmentBounds; exports.segmentCurvature = segmentCurvature; exports.segmentDerivative = segmentDerivative; exports.segmentExtrema = segmentExtrema; exports.segmentLength = segmentLength; exports.segmentNearest = segmentNearest; exports.segmentParamAtLength = segmentParamAtLength; exports.segmentPoint = segmentPoint; exports.segmentTangent = segmentTangent; exports.serializeCanvasNodes = serializeCanvasNodes; exports.setCanvasTokenMode = setCanvasTokenMode; exports.shapeNodeToBezierPath = shapeNodeToBezierPath; exports.shapeNodeToPolygon = shapeNodeToPolygon; exports.shapeToBezierPath = shapeToBezierPath; exports.shapeToPolygon = shapeToPolygon; exports.sideToPosition = sideToPosition; exports.simplifyRing = simplifyRing; exports.snapNodeDrag = snapNodeDrag; exports.snapNodeResize = snapNodeResize; exports.snapResize = snapResize; exports.snapToGrid = snapToGrid; exports.splitSegment = splitSegment; exports.strokeOutlineRings = strokeOutlineRings; exports.subSegment = subSegment; exports.subtractPaths = subtractPaths; exports.subtractPolygons = subtractPolygons; exports.toBezierPath = toBezierPath; exports.toggleLockNodes = toggleLockNodes; exports.transformBezierPath = transformBezierPath; exports.trimSegments = trimSegments; exports.unionPolygons = unionPolygons; exports.unitePaths = unitePaths; exports.unlockNodes = unlockNodes; exports.windingNumber = windingNumber; exports.withStyleOpacity = withStyleOpacity; exports.withStyleSize = withStyleSize; exports.writeNodeStyleProperty = writeNodeStyleProperty; exports.xorPolygons = xorPolygons;
+exports.ANIMATABLE_PROPERTIES = ANIMATABLE_PROPERTIES; exports.ANIMATION_DATA_KEY = ANIMATION_DATA_KEY; exports.ANIMATION_EASING_LABELS = ANIMATION_EASING_LABELS; exports.ANIMATION_EASING_PRESETS = ANIMATION_EASING_PRESETS; exports.ANIMATION_TIME_EPSILON = ANIMATION_TIME_EPSILON; exports.AUTO_LAYOUT_DATA_KEY = AUTO_LAYOUT_DATA_KEY; exports.AnimationEditError = AnimationEditError; exports.AnimationPlayer = AnimationPlayer; exports.CANVAS_COMPONENT_DRAG_TYPE = CANVAS_COMPONENT_DRAG_TYPE; exports.CANVAS_TOKEN_PROPERTIES = CANVAS_TOKEN_PROPERTIES; exports.CHILD_LAYOUT_DATA_KEY = CHILD_LAYOUT_DATA_KEY; exports.COMPONENT_DATA_KEY = COMPONENT_DATA_KEY; exports.COMPONENT_OVERRIDES_DATA_KEY = COMPONENT_OVERRIDES_DATA_KEY; exports.COMPONENT_PROPERTY_REFS_DATA_KEY = COMPONENT_PROPERTY_REFS_DATA_KEY; exports.COMPONENT_SET_DATA_KEY = COMPONENT_SET_DATA_KEY; exports.COMPONENT_SOURCE_DATA_KEY = COMPONENT_SOURCE_DATA_KEY; exports.CONNECTION_LINE_TYPES = CONNECTION_LINE_TYPES; exports.CSS_ANIMATION_PROPERTIES = CSS_ANIMATION_PROPERTIES; exports.CUBIC_BEZIER_PRESETS = CUBIC_BEZIER_PRESETS; exports.CanvasScenesStore = CanvasScenesStore; exports.DEFAULT_ARRANGE_SHORTCUTS = _chunk26BVFKHUcjs.DEFAULT_ARRANGE_SHORTCUTS; exports.DEFAULT_NODE_HEIGHT = _chunkWADCJ7A7cjs.DEFAULT_NODE_HEIGHT; exports.DEFAULT_NODE_WIDTH = _chunkWADCJ7A7cjs.DEFAULT_NODE_WIDTH; exports.DEFAULT_PLACEMENT_GAP = _chunkWADCJ7A7cjs.DEFAULT_PLACEMENT_GAP; exports.INSTANCE_DATA_KEY = INSTANCE_DATA_KEY; exports.LOCKED_DATA_KEY = LOCKED_DATA_KEY; exports.LOCKED_PREVIOUS_FLAGS_KEY = LOCKED_PREVIOUS_FLAGS_KEY; exports.MAX_KEYFRAME_REFS = MAX_KEYFRAME_REFS; exports.ManualClock = ManualClock; exports.PathOpsError = PathOpsError; exports.RESIZE_HANDLES = RESIZE_HANDLES; exports.SHAPE_DATA_KEY = SHAPE_DATA_KEY; exports.SHAPE_KINDS = SHAPE_KINDS; exports.SHAPE_NODE_TYPE = SHAPE_NODE_TYPE; exports.SHAPE_OPERATIONS = SHAPE_OPERATIONS; exports.StreamingLayoutManager = StreamingLayoutManager; exports.TOKEN_BINDINGS_DATA_KEY = TOKEN_BINDINGS_DATA_KEY; exports.TOKEN_MODES_DATA_KEY = TOKEN_MODES_DATA_KEY; exports.addKeyframesAtTime = addKeyframesAtTime; exports.alignNodes = alignNodes; exports.animateNode = animateNode; exports.applyAnimation = applyAnimation; exports.applyAnimationOverrides = applyAnimationOverrides; exports.applyConstraints = applyConstraints; exports.applyNodeUpdates = applyNodeUpdates; exports.applyShapeCombination = applyShapeCombination; exports.applyShapeReplacement = applyShapeReplacement; exports.arcToCubics = arcToCubics; exports.bezierPathArea = bezierPathArea; exports.bezierPathBounds = bezierPathBounds; exports.bezierPathLength = bezierPathLength; exports.bezierPathPointAtLength = bezierPathPointAtLength; exports.bezierPathSignedArea = bezierPathSignedArea; exports.bezierPathToSvg = bezierPathToSvg; exports.bindCanvasComponentProperty = bindCanvasComponentProperty; exports.bindCanvasToken = bindCanvasToken; exports.blendLayout = blendLayout; exports.boundsOf = _chunkWADCJ7A7cjs.boundsOf; exports.calculateDagreReflowDisplacement = calculateDagreReflowDisplacement; exports.calculateDirectionalDisplacement = calculateDirectionalDisplacement; exports.canCombineShapeNodes = canCombineShapeNodes; exports.canOffsetShapeNodes = canOffsetShapeNodes; exports.canOutlineShapeNodeStrokes = canOutlineShapeNodeStrokes; exports.canvasHeight = canvasHeight; exports.centerNodes = _chunkWADCJ7A7cjs.centerNodes; exports.centre = _chunkWADCJ7A7cjs.centre; exports.clampAnimationValue = clampAnimationValue; exports.clampLayoutSize = clampLayoutSize; exports.closeContour = closeContour; exports.collectDescendantIds = collectDescendantIds; exports.combineCanvasComponentsAsVariants = combineCanvasComponentsAsVariants; exports.combineShapeNodes = combineShapeNodes; exports.computeNodesBoundingBox = computeNodesBoundingBox; exports.computeSnapGuides = computeSnapGuides; exports.connectedOnly = connectedOnly; exports.contourSignedArea = contourSignedArea; exports.contoursToPath = contoursToPath; exports.copyKeyframes = copyKeyframes; exports.countPathSegments = countPathSegments; exports.createAnimationPlayer = createAnimationPlayer; exports.createBezierTrajectory = createBezierTrajectory; exports.createCanvasAnimationController = createCanvasAnimationController; exports.createCanvasArrangeController = createCanvasArrangeController; exports.createCanvasAutoLayoutController = createCanvasAutoLayoutController; exports.createCanvasComponent = createCanvasComponent; exports.createCanvasComponentsController = createCanvasComponentsController; exports.createCanvasInstance = createCanvasInstance; exports.createCanvasScenesStore = createCanvasScenesStore; exports.createFanOutTrajectory = createFanOutTrajectory; exports.createGuideIndex = createGuideIndex; exports.createNodeGuideIndex = createNodeGuideIndex; exports.createNodeLookup = createNodeLookup; exports.cubicBezierAt = cubicBezierAt; exports.cubicPointAt = cubicPointAt; exports.cubicsToPathData = cubicsToPathData; exports.dashContours = dashContours; exports.defaultEasing = defaultEasing; exports.deleteKeyframes = deleteKeyframes; exports.detachCanvasInstance = detachCanvasInstance; exports.detachTokenBindings = detachTokenBindings; exports.diffOverrideGroups = diffOverrideGroups; exports.distanceToBezierPath = distanceToBezierPath; exports.distributeNodes = distributeNodes; exports.dividePaths = dividePaths; exports.dividePolygons = dividePolygons; exports.easingFromInfluence = easingFromInfluence; exports.easingLabel = easingLabel; exports.easingToCss = easingToCss; exports.ensureLayout = _chunkWADCJ7A7cjs.ensureLayout; exports.estimateCanvasHeight = estimateCanvasHeight; exports.estimateNodeSize = _chunkWADCJ7A7cjs.estimateNodeSize; exports.evaluateAnimation = evaluateAnimation; exports.evaluateEasing = evaluateEasing; exports.evaluateTrack = evaluateTrack; exports.excludePaths = excludePaths; exports.exportCssAnimation = exportCssAnimation; exports.findConnectorSnap = findConnectorSnap; exports.findVariant = findVariant; exports.fitCubicRun = fitCubicRun; exports.fitCubics = fitCubics; exports.fitFreehandPath = fitFreehandPath; exports.fitPathData = fitPathData; exports.fitViewportToNodes = fitViewportToNodes; exports.fitViewportToRect = fitViewportToRect; exports.flattenSvgPath = flattenSvgPath; exports.flowSide = _chunkWADCJ7A7cjs.flowSide; exports.formatAnimationTime = formatAnimationTime; exports.formatNumber = formatNumber2; exports.formatOklab = formatOklab; exports.formatVariantName = formatVariantName; exports.getAbsolutePosition = getAbsolutePosition; exports.getAnimatableProperty = getAnimatableProperty; exports.getAnimatedProperties = getAnimatedProperties; exports.getAnimatedValue = getAnimatedValue; exports.getAnimationDuration = getAnimationDuration; exports.getAnimationTrack = getAnimationTrack; exports.getAutoLayout = getAutoLayout; exports.getAutoLayoutGrid = getAutoLayoutGrid; exports.getAutoLayoutInsertTarget = getAutoLayoutInsertTarget; exports.getBindableTokenProperties = getBindableTokenProperties; exports.getCanvasComponentDragId = getCanvasComponentDragId; exports.getCanvasTokenProperty = getCanvasTokenProperty; exports.getCenteredNodePosition = _chunkWADCJ7A7cjs.getCenteredNodePosition; exports.getChildLayout = getChildLayout; exports.getComponentData = getComponentData; exports.getComponentInstances = getComponentInstances; exports.getComponentPropertyDefs = getComponentPropertyDefs; exports.getComponentPropertyRefs = getComponentPropertyRefs; exports.getComponentSourceId = getComponentSourceId; exports.getCssPropertyAnimations = getCssPropertyAnimations; exports.getDefaultVariant = getDefaultVariant; exports.getEffectiveTokenModes = getEffectiveTokenModes; exports.getFlowChildren = getFlowChildren; exports.getInstanceData = getInstanceData; exports.getInstanceProperties = getInstanceProperties; exports.getInstanceStatus = getInstanceStatus; exports.getKeyframeTimes = getKeyframeTimes; exports.getLayerName = getLayerName; exports.getLayoutParent = getLayoutParent; exports.getLayoutSizing = getLayoutSizing; exports.getLayoutedNodes = _chunkWADCJ7A7cjs.getLayoutedNodes; exports.getNodeAnimation = getNodeAnimation; exports.getNodeOverrides = getNodeOverrides; exports.getNodeRect = getNodeRect; exports.getNodeShape = getNodeShape; exports.getNodeSize = getNodeSize; exports.getNodeTokenBindings = getNodeTokenBindings; exports.getNodeTokenModes = getNodeTokenModes; exports.getOwningComponent = getOwningComponent; exports.getOwningInstance = getOwningInstance; exports.getResizingNodeRect = getResizingNodeRect; exports.getRootInstance = getRootInstance; exports.getShapeRenderData = getShapeRenderData; exports.getShapeSvg = getShapeSvg; exports.getTimelineRows = getTimelineRows; exports.getTimelineTicks = getTimelineTicks; exports.getTokenPropertyScope = getTokenPropertyScope; exports.getTokensForProperty = getTokensForProperty; exports.getVariantConflicts = getVariantConflicts; exports.getVariantOptions = getVariantOptions; exports.getVariantSet = getVariantSet; exports.getVariantValues = getVariantValues; exports.handlePoint = handlePoint; exports.hasVisibleStroke = hasVisibleStroke; exports.inferResizeHandle = inferResizeHandle; exports.inspectCanvasInstance = inspectCanvasInstance; exports.inspectNodeTokens = inspectNodeTokens; exports.interpolateAnimationValue = interpolateAnimationValue; exports.intersectPaths = intersectPaths; exports.intersectPolygons = intersectPolygons; exports.invertNodeUpdates = invertNodeUpdates; exports.isAnimationEasing = isAnimationEasing; exports.isAnimationKeyframe = isAnimationKeyframe; exports.isAutoLayoutFrame = isAutoLayoutFrame; exports.isCanvasComponent = isCanvasComponent; exports.isCanvasComponentSet = isCanvasComponentSet; exports.isCanvasInstance = isCanvasInstance; exports.isCssExportExact = isCssExportExact; exports.isEventFromTextInput = isEventFromTextInput; exports.isInsideInstance = isInsideInstance; exports.isKeyframeSelected = isKeyframeSelected; exports.isLocked = isLocked; exports.isMeasureModifierHeld = isMeasureModifierHeld; exports.isNodeAnimated = isNodeAnimated; exports.isShapeDescription = isShapeDescription; exports.isShapeNode = isShapeNode; exports.isStraightCubic = isStraightCubic; exports.isValidCanvasEdge = isValidCanvasEdge; exports.isValidCanvasNode = isValidCanvasNode; exports.isValidCanvasScene = isValidCanvasScene; exports.isValidUrl = isValidUrl; exports.layoutAll = layoutAll; exports.layoutBounds = layoutBounds; exports.layoutFrame = layoutFrame; exports.layoutUp = layoutUp; exports.layoutUpMany = layoutUpMany; exports.linearPositionTrajectory = linearPositionTrajectory; exports.linearTrajectory = linearTrajectory; exports.listCanvasComponents = listCanvasComponents; exports.lockNodes = lockNodes; exports.makeSizingCoherent = makeSizingCoherent; exports.matchArrangeShortcut = _chunk26BVFKHUcjs.matchArrangeShortcut; exports.matchSize = matchSize; exports.measureBetween = measureBetween; exports.measureLabel = measureLabel; exports.measureSelection = measureSelection; exports.measureToLine = measureToLine; exports.mergeNodeUpdates = mergeNodeUpdates; exports.mixColorsOklab = mixColorsOklab; exports.moveKeyframes = moveKeyframes; exports.moveLayoutChild = moveLayoutChild; exports.multiPolygonArea = multiPolygonArea; exports.multiPolygonBounds = multiPolygonBounds; exports.nearestHandlePositions = nearestHandlePositions; exports.normalizeBezierPath = normalizeBezierPath; exports.normalizeKeyframes = normalizeKeyframes; exports.offsetPath = offsetPath; exports.offsetShapeNodes = offsetShapeNodes; exports.oklabToRgb = oklabToRgb; exports.oppositePosition = oppositePosition; exports.outlineShapeNodeStrokes = outlineShapeNodeStrokes; exports.outlineStroke = outlineStroke; exports.overlaps = _chunkWADCJ7A7cjs.overlaps; exports.pageHidden = pageHidden; exports.parseCanvasClipboardData = parseCanvasClipboardData; exports.parseCanvasScenes = parseCanvasScenes; exports.parseCssEasing = parseCssEasing; exports.parseKeyframeClipboard = parseKeyframeClipboard; exports.parseNodeStyleDeclarations = parseNodeStyleDeclarations; exports.parseOklab = parseOklab; exports.parseSvgPath = parseSvgPath; exports.parseVariantName = parseVariantName; exports.pasteKeyframes = pasteKeyframes; exports.pathBoolean = pathBoolean; exports.pathToContours = pathToContours; exports.placeBeside = _chunkWADCJ7A7cjs.placeBeside; exports.playWebAnimations = playWebAnimations; exports.pointInBezierPath = pointInBezierPath; exports.pointInMultiPolygon = pointInMultiPolygon; exports.pointInRings = pointInRings; exports.polygonArea = polygonArea; exports.polygonBoolean = polygonBoolean; exports.polygonToSvgPath = polygonToSvgPath; exports.positionToSide = positionToSide; exports.pruneCanvasTokenModes = pruneCanvasTokenModes; exports.pushCanvasInstanceOverrides = pushCanvasInstanceOverrides; exports.readAnimatableValue = readAnimatableValue; exports.readNodeStyleProperty = readNodeStyleProperty; exports.readOverrideGroup = readOverrideGroup; exports.readStyleSize = readStyleSize; exports.realClock = realClock; exports.recordAnimationChanges = recordAnimationChanges; exports.relayoutUpdates = relayoutUpdates; exports.remapPastedNodes = remapPastedNodes; exports.removeTrack = removeTrack; exports.reorderNodes = reorderNodes; exports.repositionNodesTo = repositionNodesTo; exports.resetCanvasInstanceOverrides = resetCanvasInstanceOverrides; exports.resizeHandleAxes = resizeHandleAxes; exports.resolveCanvasTokens = resolveCanvasTokens; exports.resolveEasing = resolveEasing; exports.resolvePadding = resolvePadding; exports.restoreCanvasMainComponent = restoreCanvasMainComponent; exports.revertShapeCombination = revertShapeCombination; exports.rgbToOklab = rgbToOklab; exports.ringSignedArea = ringSignedArea; exports.runMultiNodeTransition = runMultiNodeTransition; exports.sampleAnimationFrames = sampleAnimationFrames; exports.scaleKeyframes = scaleKeyframes; exports.segmentBounds = segmentBounds; exports.segmentCurvature = segmentCurvature; exports.segmentDerivative = segmentDerivative; exports.segmentExtrema = segmentExtrema; exports.segmentLength = segmentLength; exports.segmentNearest = segmentNearest; exports.segmentParamAtLength = segmentParamAtLength; exports.segmentPoint = segmentPoint; exports.segmentTangent = segmentTangent; exports.serializeCanvasNodes = serializeCanvasNodes; exports.setCanvasComponentProperty = setCanvasComponentProperty; exports.setCanvasInstanceProperties = setCanvasInstanceProperties; exports.setCanvasTokenMode = setCanvasTokenMode; exports.setKeyframe = setKeyframe; exports.setKeyframeEasing = setKeyframeEasing; exports.setMotionPath = setMotionPath; exports.setTrackEnabled = setTrackEnabled; exports.shapeNodeToBezierPath = shapeNodeToBezierPath; exports.shapeNodeToPolygon = shapeNodeToPolygon; exports.shapeToBezierPath = shapeToBezierPath; exports.shapeToPolygon = shapeToPolygon; exports.sideToPosition = sideToPosition; exports.simplifyRing = simplifyRing; exports.snapKeyframeDelta = snapKeyframeDelta; exports.snapNodeDrag = snapNodeDrag; exports.snapNodeResize = snapNodeResize; exports.snapResize = snapResize; exports.snapTimeToFrame = snapTimeToFrame; exports.snapToGrid = snapToGrid; exports.splitSegment = splitSegment; exports.springAt = springAt; exports.strokeOutlineRings = strokeOutlineRings; exports.subSegment = subSegment; exports.subtractPaths = subtractPaths; exports.subtractPolygons = subtractPolygons; exports.swapCanvasInstance = swapCanvasInstance; exports.syncAllCanvasInstances = syncAllCanvasInstances; exports.syncCanvasComponents = syncCanvasComponents; exports.syncCanvasInstance = syncCanvasInstance; exports.timeToX = timeToX; exports.toBezierPath = toBezierPath; exports.toWebAnimations = toWebAnimations; exports.toggleLockNodes = toggleLockNodes; exports.transformBezierPath = transformBezierPath; exports.trimSegments = trimSegments; exports.unionPolygons = unionPolygons; exports.unitePaths = unitePaths; exports.unlockNodes = unlockNodes; exports.updateKeyframe = updateKeyframe; exports.windingNumber = windingNumber; exports.withNodeAnimation = withNodeAnimation; exports.withStyleOpacity = withStyleOpacity; exports.withStyleSize = withStyleSize; exports.wouldCreateComponentCycle = wouldCreateComponentCycle; exports.wrapAnimationTime = wrapAnimationTime; exports.writeNodeStyleProperty = writeNodeStyleProperty; exports.writeOverrideGroup = writeOverrideGroup; exports.xToTime = xToTime; exports.xorPolygons = xorPolygons;
 //# sourceMappingURL=index.cjs.map