@popcraft/kit 0.27.0 → 0.28.0

package/dist/chunks/chunk-ZT6M4M4U.js

@@ -0,0 +1,1417 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  dotLottieStateMachine,
+  lottieMarkers
+} from "./chunk-JODDNZDL.js";
+import {
+  walkNode
+} from "./chunk-DZGHE43A.js";
+import {
+  fittedRadii,
+  vectorCmds
+} from "./chunk-RG42FB7R.js";
+import {
+  strToU8,
+  zipSync
+} from "./chunk-M7RQFLBQ.js";
+import {
+  bytesToBase64,
+  encodePng
+} from "./chunk-YJB7BGFC.js";
+import {
+  samplePose
+} from "./chunk-5FHTPPGJ.js";
+import {
+  machineOf
+} from "./chunk-WGWAUMXY.js";
+import {
+  LINEAR_CP,
+  lottieEase,
+  segmentEase
+} from "./chunk-HEUBQUFW.js";
+import {
+  resolvedFills,
+  resolvedStrokes
+} from "./chunk-P2LIBAGF.js";
+import {
+  frameTimeline,
+  timelineDuration
+} from "./chunk-K5H4DH3X.js";
+import {
+  TRANSLATE,
+  XY,
+  sampleTrack
+} from "./chunk-YHLIOY2L.js";
+import {
+  getWorldMatrix,
+  getWorldRenderBounds,
+  getWorldTransform,
+  init_scene_graph,
+  uprightBounds
+} from "./chunk-F6JQTMKE.js";
+import {
+  init_properties,
+  propertyFor
+} from "./chunk-QU6I6MIF.js";
+import {
+  init_time,
+  timeShift
+} from "./chunk-AYZ32MGJ.js";
+import {
+  init_morph,
+  isPathValue,
+  morphPair
+} from "./chunk-POXV7LS3.js";
+import {
+  IDENTITY,
+  decompose,
+  init_transform,
+  invert,
+  multiply
+} from "./chunk-PSVLITJE.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-6VMOKHMF.js";
+
+// lib/io/lottie/index.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_scene_graph();
+
+// lib/io/lottie/build.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_transform();
+init_scene_graph();
+init_properties();
+init_morph();
+init_time();
+
+// lib/io/lottie/channels.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/io/lottie/evaluate.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var bez = (a, b, u) => 3 * (1 - u) * (1 - u) * u * a + 3 * (1 - u) * u * u * b + u * u * u;
+var bezSlope = (a, b, u) => 3 * (1 - u) * (1 - u) * a + 6 * (1 - u) * u * (b - a) + 3 * u * u * (1 - b);
+function bezierEase(x1, y1, x2, y2, x) {
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+  if (x1 === y1 && x2 === y2) return x;
+  let u = x;
+  for (let i = 0; i < 8; i++) {
+    const err = bez(x1, x2, u) - x;
+    if (Math.abs(err) < 1e-9) break;
+    const d = bezSlope(x1, x2, u);
+    if (Math.abs(d) < 1e-9) break;
+    u -= err / d;
+  }
+  if (!(u >= 0 && u <= 1) || Math.abs(bez(x1, x2, u) - x) > 1e-7) {
+    let lo = 0, hi = 1;
+    u = x;
+    for (let i = 0; i < 60; i++) {
+      if (bez(x1, x2, u) < x) lo = u;
+      else hi = u;
+      u = (lo + hi) / 2;
+    }
+  }
+  return bez(y1, y2, u);
+}
+var pick = (arr, i, fallback) => {
+  if (typeof arr === "number") return arr;
+  if (!arr?.length) return fallback;
+  return arr[i] ?? arr[0];
+};
+var LUT = 128;
+function spatialPoint(p0, to, ti, p3, e) {
+  const c1 = [p0[0] + to[0], p0[1] + to[1]], c2 = [p3[0] + ti[0], p3[1] + ti[1]];
+  const at = (u2) => {
+    const v = 1 - u2;
+    return [0, 1].map((k) => v * v * v * p0[k] + 3 * v * v * u2 * c1[k] + 3 * v * u2 * u2 * c2[k] + u2 * u2 * u2 * p3[k]);
+  };
+  if (e <= 0 || e >= 1) return at(e);
+  const lens = [0];
+  let prev = at(0);
+  for (let i2 = 1; i2 <= LUT; i2++) {
+    const q = at(i2 / LUT);
+    lens.push(lens[i2 - 1] + Math.hypot(q[0] - prev[0], q[1] - prev[1]));
+    prev = q;
+  }
+  const target = e * lens[LUT];
+  let i = 1;
+  while (i < LUT && lens[i] < target) i++;
+  const span2 = lens[i] - lens[i - 1];
+  const u = (i - 1 + (span2 > 0 ? (target - lens[i - 1]) / span2 : 0)) / LUT;
+  return at(u);
+}
+function evalKeys(keys, f) {
+  if (!keys.length) return [];
+  if (f <= keys[0].t) return keys[0].s;
+  const last = keys[keys.length - 1];
+  if (f >= last.t) return last.s;
+  let k = 0;
+  while (k + 1 < keys.length && keys[k + 1].t <= f) k++;
+  const a = keys[k], b = keys[k + 1];
+  if (a.h === 1) return a.s;
+  const p = (f - a.t) / (b.t - a.t);
+  const ease = (d) => a.o && b && a.i ? bezierEase(pick(a.o.x, d, 0), pick(a.o.y, d, 0), pick(a.i.x, d, 1), pick(a.i.y, d, 1), p) : p;
+  if (a.to && a.ti && a.s.length >= 2 && (a.to.some((v) => v !== 0) || a.ti.some((v) => v !== 0))) return spatialPoint(a.s, a.to, a.ti, b.s, ease(0));
+  return a.s.map((v, d) => v + ((b.s[d] ?? v) - v) * ease(d));
+}
+
+// lib/io/lottie/channels.ts
+var frameMs = (g, i) => g.startMs + i * 1e3 / g.fps;
+var msFrame = (g, ms) => (ms - g.startMs) * g.fps / 1e3;
+var sameVec = (a, b, eps) => a.length === b.length && a.every((v, i) => Math.abs(v - b[i]) <= eps);
+function filled(samples) {
+  const first = samples.findIndex((s) => !!s);
+  if (first < 0) return null;
+  const out = [];
+  let last = samples[first];
+  for (let i = 0; i < samples.length; i++) {
+    const s = samples[i];
+    if (s) last = s;
+    out.push(last);
+  }
+  return out;
+}
+function constantOf(ch) {
+  const eps = ch.eps ?? 1e-4;
+  let v = null;
+  for (const s of ch.samples) {
+    if (!s) continue;
+    if (!v) v = s;
+    else if (!sameVec(v, s, eps)) return null;
+  }
+  return v;
+}
+var staticProp = (v, scalar) => ({ a: 0, k: scalar ? v[0] : v });
+function bakedKeys(samples, eps, hold = false) {
+  const n = samples.length;
+  const dims = samples[0].length;
+  const lin = lottieEase(LINEAR_CP, dims);
+  if (hold) {
+    const out = [];
+    for (let i = 0; i < n; i++) if (i === 0 || !sameVec(samples[i], samples[i - 1], eps)) out.push({ t: i, s: samples[i], h: 1 });
+    return out;
+  }
+  const keep = [0];
+  let a = 0;
+  while (a < n - 1) {
+    let b = a + 1;
+    for (let c = a + 2; c < n; c++) {
+      let ok = true;
+      for (let j = a + 1; j < c && ok; j++) {
+        const u = (j - a) / (c - a);
+        for (let d = 0; d < dims; d++) if (Math.abs(samples[a][d] + (samples[c][d] - samples[a][d]) * u - samples[j][d]) > eps) {
+          ok = false;
+          break;
+        }
+      }
+      if (!ok) break;
+      b = c;
+    }
+    keep.push(b);
+    a = b;
+  }
+  return keep.map((i, j) => j === keep.length - 1 ? { t: i, s: samples[i] } : { t: i, s: samples[i], ...lin });
+}
+function fit(xs, ys) {
+  const n = xs.length;
+  let mx = 0, my = 0;
+  for (let i = 0; i < n; i++) {
+    mx += xs[i];
+    my += ys[i];
+  }
+  mx /= n;
+  my /= n;
+  let sxx = 0, sxy = 0;
+  for (let i = 0; i < n; i++) {
+    sxx += (xs[i] - mx) ** 2;
+    sxy += (xs[i] - mx) * (ys[i] - my);
+  }
+  if (sxx < 1e-12) return { k: 1, c: my - mx };
+  const k = sxy / sxx;
+  return { k, c: my - k * mx };
+}
+var numberAt = (d, localMs) => {
+  const v = sampleTrack(d.track, d.prop, d.rest, localMs);
+  return v === void 0 ? void 0 : d.pick(v);
+};
+function exactKeys(src, grid, samples, present2) {
+  const moving = src.dims.map((d, i) => d ? i : -1).filter((i) => i >= 0);
+  if (!moving.length) return null;
+  const lead = src.dims[moving[0]];
+  const keys = lead.track.keys;
+  if (keys.length < 2) return null;
+  for (const i of moving) {
+    const d = src.dims[i];
+    if (d.track.muted || d.track.modifiers?.length || d.track.keys.some((k) => k.bind)) return null;
+    if (d.track.keys.length !== keys.length || d.track.keys.some((k, j) => Math.abs(k.t - keys[j].t) > 0.5)) return null;
+    if (d.prop.interpolation === "discrete") return null;
+  }
+  const dims = src.dims.length;
+  const fits = [];
+  for (let d = 0; d < dims; d++) {
+    const s = src.dims[d];
+    if (!s) {
+      fits.push(null);
+      continue;
+    }
+    const xs = [], ys = [];
+    for (let f = 0; f < samples.length; f++) {
+      if (!present2[f]) continue;
+      const x = numberAt(s, frameMs(grid, f) - src.shift);
+      if (x === void 0) return null;
+      xs.push(x);
+      ys.push(samples[f][d]);
+    }
+    if (!xs.length) return null;
+    fits.push(fit(xs, ys));
+  }
+  const firstPresent = present2.indexOf(true);
+  const valueAt = (localMs) => src.dims.map((s, d) => {
+    if (!s) return samples[firstPresent][d];
+    const f = fits[d];
+    return f.k * (numberAt(s, localMs) ?? 0) + f.c;
+  });
+  const keyValue = (j) => src.dims.map((s, d) => {
+    if (!s) return samples[firstPresent][d];
+    const k = s.track.keys[j];
+    const f = fits[d];
+    return f.k * s.pick(k.v) + f.c;
+  });
+  const frameOf = (localMs) => msFrame(grid, localMs + src.shift);
+  const out = [];
+  const push = (localMs, s, cps) => {
+    const k = { t: frameOf(localMs), s };
+    if (cps === "hold") k.h = 1;
+    else if (cps) {
+      k.o = { x: cps.map((c) => c[0]), y: cps.map((c) => c[1]) };
+      k.i = { x: cps.map((c) => c[2]), y: cps.map((c) => c[3]) };
+    }
+    out.push(k);
+  };
+  const cpOf = (d, j) => segmentEase(src.dims[d]?.track.keys[j]?.out ?? { kind: "linear" });
+  for (let j = 0; j < keys.length; j++) {
+    const a = keys[j];
+    if (j === keys.length - 1) {
+      push(a.t, keyValue(j), null);
+      break;
+    }
+    const b = keys[j + 1];
+    const eases = moving.map((d) => cpOf(d, j));
+    const all = (kind) => eases.every((e) => e.kind === kind);
+    const cps = (sel) => src.dims.map((s, d) => s ? sel(eases[moving.indexOf(d)]) : LINEAR_CP);
+    if (all("hold")) {
+      push(a.t, keyValue(j), "hold");
+      continue;
+    }
+    if (all("curve")) {
+      push(a.t, keyValue(j), cps((e) => e.kind === "curve" ? e.cp : LINEAR_CP));
+      continue;
+    }
+    if (all("halves")) {
+      const va = keyValue(j), vb = keyValue(j + 1);
+      push(a.t, va, cps((e) => e.kind === "halves" ? e.first : LINEAR_CP));
+      push((a.t + b.t) / 2, va.map((v, d) => (v + vb[d]) / 2), cps((e) => e.kind === "halves" ? e.second : LINEAR_CP));
+      continue;
+    }
+    push(a.t, keyValue(j), Array.from({ length: dims }, () => LINEAR_CP));
+    const f0 = Math.floor(frameOf(a.t)) + 1, f1 = Math.ceil(frameOf(b.t)) - 1;
+    for (let f = f0; f <= f1; f++) {
+      const local = frameMs(grid, f) - src.shift;
+      if (local <= a.t || local >= b.t) continue;
+      push(local, valueAt(local), Array.from({ length: dims }, () => LINEAR_CP));
+    }
+  }
+  return out;
+}
+function keysMatch(keys, samples, present2, eps) {
+  for (let f = 0; f < samples.length; f++) {
+    if (!present2[f]) continue;
+    const v = evalKeys(keys, f);
+    if (!sameVec(v, samples[f], eps)) return false;
+  }
+  return true;
+}
+function emitChannel(ch, grid, scalar = false, stats) {
+  const eps = ch.eps ?? 1e-3;
+  const fill = filled(ch.samples);
+  if (!fill) return staticProp([0], scalar);
+  const still = constantOf({ ...ch, eps: ch.eps ?? 1e-4 });
+  if (still) {
+    if (stats) stats.still++;
+    return staticProp(still, scalar);
+  }
+  const present2 = ch.samples.map((s) => !!s);
+  if (ch.exact && !ch.hold) {
+    const keys = exactKeys(ch.exact, grid, fill, present2);
+    if (keys && keysMatch(keys, fill, present2, Math.max(eps * 5, 1e-3))) {
+      if (stats) stats.exact++;
+      return { a: 1, k: keys };
+    }
+  }
+  if (stats) stats.baked++;
+  return { a: 1, k: bakedKeys(fill, eps, ch.hold) };
+}
+function unwrapDegrees(samples) {
+  let prev;
+  return samples.map((s) => {
+    if (!s) return s;
+    let v = s[0];
+    if (prev !== void 0) {
+      while (v - prev > 180) v -= 360;
+      while (v - prev < -180) v += 360;
+    }
+    prev = v;
+    return [v];
+  });
+}
+
+// lib/io/lottie/shapes.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var EPS = 1e-6;
+function cmdsToBeziers(cmds) {
+  const out = [];
+  let cur = null;
+  let px = 0, py = 0;
+  const finish2 = (closed) => {
+    if (!cur) return;
+    cur.c = closed;
+    const n = cur.v.length;
+    if (closed && n > 1 && Math.abs(cur.v[n - 1][0] - cur.v[0][0]) < EPS && Math.abs(cur.v[n - 1][1] - cur.v[0][1]) < EPS) {
+      cur.i[0] = cur.i[n - 1];
+      cur.v.pop();
+      cur.i.pop();
+      cur.o.pop();
+    }
+    if (cur.v.length) out.push(cur);
+    cur = null;
+  };
+  for (const c of cmds) {
+    switch (c.op) {
+      case "M":
+        finish2(false);
+        cur = { c: false, v: [[c.x, c.y]], i: [[0, 0]], o: [[0, 0]] };
+        px = c.x;
+        py = c.y;
+        break;
+      case "L":
+        if (!cur) cur = { c: false, v: [[px, py]], i: [[0, 0]], o: [[0, 0]] };
+        cur.v.push([c.x, c.y]);
+        cur.i.push([0, 0]);
+        cur.o.push([0, 0]);
+        px = c.x;
+        py = c.y;
+        break;
+      case "Q": {
+        if (!cur) cur = { c: false, v: [[px, py]], i: [[0, 0]], o: [[0, 0]] };
+        const c1x = px + 2 / 3 * (c.x1 - px), c1y = py + 2 / 3 * (c.y1 - py);
+        const c2x = c.x + 2 / 3 * (c.x1 - c.x), c2y = c.y + 2 / 3 * (c.y1 - c.y);
+        cur.o[cur.o.length - 1] = [c1x - px, c1y - py];
+        cur.v.push([c.x, c.y]);
+        cur.i.push([c2x - c.x, c2y - c.y]);
+        cur.o.push([0, 0]);
+        px = c.x;
+        py = c.y;
+        break;
+      }
+      case "C":
+        if (!cur) cur = { c: false, v: [[px, py]], i: [[0, 0]], o: [[0, 0]] };
+        cur.o[cur.o.length - 1] = [c.x1 - px, c.y1 - py];
+        cur.v.push([c.x, c.y]);
+        cur.i.push([c.x2 - c.x, c.y2 - c.y]);
+        cur.o.push([0, 0]);
+        px = c.x;
+        py = c.y;
+        break;
+      case "Z":
+        if (cur) {
+          px = cur.v[0][0];
+          py = cur.v[0][1];
+        }
+        finish2(true);
+        break;
+    }
+  }
+  finish2(false);
+  return out;
+}
+function roundBezier(b) {
+  const r = (v) => Math.round(v * 1e3) / 1e3;
+  const rp = (p) => p.map(([x, y]) => [r(x), r(y)]);
+  return { c: b.c, v: rp(b.v), i: rp(b.i), o: rp(b.o) };
+}
+function rectBezier(x, y, w, h) {
+  const z = [[0, 0], [0, 0], [0, 0], [0, 0]];
+  return { c: true, v: [[x, y], [x + w, y], [x + w, y + h], [x, y + h]], i: z.map((p) => [...p]), o: z.map((p) => [...p]) };
+}
+var K = 0.5522847498;
+function roundedRectBezier(x, y, w, h, radii) {
+  const [tl, tr, br, bl] = fittedRadii(w, h, radii);
+  return {
+    c: true,
+    v: [[x + tl, y], [x + w - tr, y], [x + w, y + tr], [x + w, y + h - br], [x + w - br, y + h], [x + bl, y + h], [x, y + h - bl], [x, y + tl]],
+    i: [[-tl * K, 0], [0, 0], [0, -tr * K], [0, 0], [br * K, 0], [0, 0], [0, bl * K], [0, 0]],
+    o: [[0, 0], [tr * K, 0], [0, 0], [0, br * K], [0, 0], [-bl * K, 0], [0, 0], [0, -tl * K]]
+  };
+}
+function circleBezier(cx, cy, r) {
+  const k = r * K;
+  return {
+    c: true,
+    v: [[cx, cy - r], [cx + r, cy], [cx, cy + r], [cx - r, cy]],
+    i: [[-k, 0], [0, -k], [k, 0], [0, k]],
+    o: [[k, 0], [0, k], [-k, 0], [0, -k]]
+  };
+}
+
+// lib/io/lottie/build.ts
+function sampleFrames(doc, target, range, opts) {
+  const frames = [], docs = [];
+  let stage = { width: 0, height: 0 };
+  const leafCache = /* @__PURE__ */ new WeakMap();
+  const irOf = (posed, id) => {
+    const node = posed.nodes[id];
+    if (!node) return null;
+    const ctx = { renderer: opts.renderer, doc: posed, styles: opts.styles, textAs: "OUTLINE", textCurves: true, glyphGroups: true, leafCache };
+    const ir = walkNode({ ...node, effects: [] }, ctx, IDENTITY, true);
+    return ir?.t === "group" ? ir : null;
+  };
+  for (let i = 0; i < range.count; i++) {
+    const pose = samplePose(doc, target, range, i);
+    const posed = { ...doc, nodes: pose.nodes };
+    docs.push(posed);
+    const roots = [];
+    if (target.kind === "frame") {
+      const root = posed.nodes[target.frameId];
+      if (i === 0 && root) stage = { width: root.width, height: root.height };
+      const ir = irOf(posed, target.frameId);
+      if (ir) roots.push({ key: target.frameId, ir, place: IDENTITY, opacity: 1, doc: posed });
+    } else {
+      const r = pose.stage?.rect;
+      if (i === 0 && r) stage = { width: r.width, height: r.height, background: pose.stage?.background };
+      for (const rr of pose.roots ?? []) {
+        const ir = irOf(posed, rr.rootId);
+        if (!ir || !r) continue;
+        const world = getWorldMatrix(posed, rr.rootId);
+        const place = multiply([1, 0, 0, 1, -r.x, -r.y], multiply(rr.matrix, world));
+        const clip = rr.clip ? { ...rr.clip, cx: rr.clip.cx - r.x, cy: rr.clip.cy - r.y } : void 0;
+        roots.push({ key: rr.rootId, ir, place, opacity: rr.opacity, clip, doc: posed });
+      }
+    }
+    frames.push(roots);
+  }
+  return { frames, docs, stage };
+}
+function zipItem(key, items) {
+  const first = items.find(Boolean);
+  if (!first) return null;
+  if (first.t === "path") return { kind: "path", key, frames: items.map((i) => i?.t === "path" ? i : void 0) };
+  if (first.t === "raster") return { kind: "raster", key, frames: items.map((i) => i?.t === "raster" ? i : void 0) };
+  if (first.t !== "group") return null;
+  const groups = items.map((i) => i?.t === "group" ? i : void 0);
+  if (first.mask) return { kind: "mask", key, frames: groups, content: zipItem(`${key}:matte`, groups.map((g) => g?.mask?.content)), children: zipChildren(groups) };
+  return { kind: "group", key, frames: groups, children: zipChildren(groups) };
+}
+function zipChildren(parents) {
+  const order = [];
+  const byKey = /* @__PURE__ */ new Map();
+  parents.forEach((g, f) => {
+    if (!g) return;
+    let pi = 0, mi = 0, ui = 0;
+    let prev = null;
+    for (const c of g.children) {
+      let key;
+      if (c.t === "path") key = `p${pi++}`;
+      else if (c.t === "raster") key = `r:${c.node.id}`;
+      else if (c.t === "group") key = c.mask ? `m${mi++}` : c.key ?? `u${ui++}`;
+      else continue;
+      let list = byKey.get(key);
+      if (!list) {
+        list = Array.from({ length: parents.length }, () => void 0);
+        byKey.set(key, list);
+        order.splice(prev === null ? 0 : order.indexOf(prev) + 1, 0, key);
+      }
+      list[f] = c;
+      prev = key;
+    }
+  });
+  return order.map((k) => zipItem(k, byKey.get(k))).filter((z) => !!z);
+}
+var BLEND = {
+  NORMAL: 0,
+  MULTIPLY: 1,
+  SCREEN: 2,
+  OVERLAY: 3,
+  DARKEN: 4,
+  LIGHTEN: 5,
+  COLOR_DODGE: 6,
+  COLOR_BURN: 7,
+  HARD_LIGHT: 8,
+  SOFT_LIGHT: 9,
+  DIFFERENCE: 10,
+  EXCLUSION: 11,
+  HUE: 12,
+  SATURATION: 13,
+  COLOR: 14,
+  LUMINOSITY: 15
+};
+var RECT_TYPES = /* @__PURE__ */ new Set(["RECTANGLE", "FRAME", "COMPONENT", "COMPONENT_SET", "INSTANCE", "IMAGE"]);
+var num = (v, d = 0) => typeof v === "number" && Number.isFinite(v) ? v : d;
+var r3 = (v) => Math.round(v * 1e3) / 1e3;
+var present = (frames) => frames.map((f) => !!f);
+var span = (frames) => {
+  const a = frames.findIndex(Boolean);
+  let b = frames.length - 1;
+  while (b > a && !frames[b]) b--;
+  return [Math.max(0, a), b + 1];
+};
+var Writer = class {
+  constructor(grid, base, docs, rootId, opts, size) {
+    this.grid = grid;
+    this.base = base;
+    this.docs = docs;
+    this.rootId = rootId;
+    this.opts = opts;
+    this.assets = [];
+    this.notes = /* @__PURE__ */ new Set();
+    this.stats = { exact: 0, baked: 0, still: 0 };
+    this.comps = 0;
+    this.images = /* @__PURE__ */ new Map();
+    /** The picture's size (precomps that are not a node's are padded around it). */
+    this.size = { width: 1, height: 1 };
+    // ── Rasters (async, before writing) ────────────────────────────────────────────────────────────
+    this.rasterPlacement = /* @__PURE__ */ new Map();
+    this.pad = Math.ceil(Math.max(size.width, size.height) * 2);
+  }
+  // ── Channels ───────────────────────────────────────────────────────────────────────────────────
+  prop(samples, exact = null, scalar = false, eps, hold = false) {
+    return emitChannel({ samples, exact, eps, hold }, this.grid, scalar, this.stats);
+  }
+  /** The rest node a real (non-virtual) layer of a frame timeline samples, or null: exact keys come only from those. */
+  restNode(id) {
+    if (!id || !this.rootId || id.includes("::")) return null;
+    return this.base.nodes[id] ?? null;
+  }
+  dim(id, path, pick2 = (v) => typeof v === "number" ? v : NaN) {
+    const node = this.restNode(id);
+    const track = node?.motion?.tracks[path];
+    const prop = propertyFor(path);
+    if (!node || !track || track.keys.length < 2 || !prop) return null;
+    return { track, prop, rest: prop.read(node, path), pick: pick2 };
+  }
+  exact(id, dims) {
+    if (!dims.some(Boolean) || !id || !this.rootId) return null;
+    return { dims, shift: timeShift(this.base.nodes, id, this.rootId) };
+  }
+  // ── Transforms ─────────────────────────────────────────────────────────────────────────────────
+  /** A node layer's transform from its fields at each frame (localMatrix, lib/document/transform.ts), or from `place`. */
+  nodeKs(frames, offset, anchorPad, place) {
+    const A = [], R = [], S = [];
+    const px = [], py = [];
+    let id;
+    frames.forEach((g, f) => {
+      const m = place?.[f];
+      if (m) {
+        const d = decompose(m);
+        if (Math.abs(d.skew) > 1e-4) this.notes.add("A skewed placement was written without its skew.");
+        A[f] = [anchorPad, anchorPad];
+        px[f] = [m[4] + offset[0]];
+        py[f] = [m[5] + offset[1]];
+        R[f] = [d.rotation * 180 / Math.PI];
+        S[f] = [d.scaleX * 100, d.scaleY * 100];
+        return;
+      }
+      const n = g?.node;
+      if (!n) return;
+      id ??= n.id;
+      const text = n.type === "TEXT";
+      const ax = num(n.anchorX, 0.5), ay = num(n.anchorY, 0.5);
+      const fx = !text && n.flipHorizontal ? -1 : 1, fy = !text && n.flipVertical ? -1 : 1;
+      A[f] = [ax * n.width + anchorPad, ay * n.height + anchorPad];
+      px[f] = [n.x + ax * n.width + num(n.translateX) + offset[0]];
+      py[f] = [n.y + ay * n.height + num(n.translateY) + offset[1]];
+      R[f] = [num(n.rotation)];
+      S[f] = [num(n.scaleX, 1) * 100 * fx, num(n.scaleY, 1) * 100 * fy];
+    });
+    const a0 = A.find(Boolean);
+    const tracks = id ? this.restNode(id)?.motion?.tracks : void 0;
+    const morphing = !!tracks?.["paths"] && !tracks["width"] && !tracks["height"];
+    if (!place && morphing && a0 && A.some((a) => a && (a[0] !== a0[0] || a[1] !== a0[1])) && R.every((r) => !r || r[0] === 0) && S.every((s) => !s || s[0] === 100 && s[1] === 100)) {
+      A.forEach((a, f) => {
+        if (!a) return;
+        px[f] = [px[f][0] - a[0] + a0[0]];
+        py[f] = [py[f][0] - a[1] + a0[1]];
+        A[f] = a0;
+      });
+    }
+    const pos = this.position(id, px, py, !!place);
+    return {
+      a: this.prop(A, null, false, 1e-3),
+      p: pos,
+      s: this.prop(S, place ? null : this.exact(id, [this.dim(id, "scaleX"), this.dim(id, "scaleY")]), false, 1e-3),
+      r: this.prop(place ? unwrapDegrees(R) : R, place ? null : this.exact(id, [this.dim(id, "rotation")]), true, 1e-3),
+      o: { a: 0, k: 100 }
+    };
+  }
+  /** Position: one spatial property when the layer's path curves (spatial tangents), else x and y on their own. */
+  position(id, px, py, placed) {
+    if (!placed && id) {
+      const spatial = this.spatialPosition(id, px, py);
+      if (spatial) return spatial;
+    }
+    const one = (samples, a, b) => {
+      if (placed) return this.prop(samples, null, true, 1e-3);
+      const da = this.dim(id, a), db = this.dim(id, b);
+      return this.prop(samples, da && db ? null : this.exact(id, [da ?? db]), true, 1e-3);
+    };
+    const x = one(px, "x", "translateX"), y = one(py, "y", "translateY");
+    if (x.a === 0 && y.a === 0) return { a: 0, k: [x.k, y.k] };
+    return { s: true, x, y };
+  }
+  /** A position pair whose x keys carry spatial tangents, as one Lottie position with `to` / `ti`, when it plays back exactly. */
+  spatialPosition(id, px, py) {
+    const node = this.restNode(id);
+    if (!node) return null;
+    for (const pair of [XY, TRANSLATE]) {
+      const tx = node.motion?.tracks[pair[0]], ty = node.motion?.tracks[pair[1]];
+      if (!tx || !ty || tx.keys.length < 2 || !tx.keys.some((k) => k.spatial?.in || k.spatial?.out)) continue;
+      if (ty.keys.length !== tx.keys.length || ty.keys.some((k, j) => Math.abs(k.t - tx.keys[j].t) > 1) || tx.modifiers?.length || ty.modifiers?.length) return null;
+      const shift = timeShift(this.base.nodes, id, this.rootId);
+      const f0 = px.findIndex(Boolean);
+      if (f0 < 0) return null;
+      const at = (tr, path) => {
+        const prop = propertyFor(path);
+        return num(sampleTrack(tr, prop, prop.read(node, path), frameMs(this.grid, f0) - shift));
+      };
+      const x0 = at(tx, pair[0]), y0 = at(ty, pair[1]);
+      const cx = px[f0][0] - x0, cy = py[f0][0] - y0;
+      const keys = [];
+      for (let j = 0; j < tx.keys.length; j++) {
+        const a = tx.keys[j], b = tx.keys[j + 1];
+        const k = { t: msFrame(this.grid, a.t + shift), s: [num(a.v) + cx, num(ty.keys[j].v) + cy] };
+        if (b) {
+          const e = segmentEase(a.out);
+          if (e.kind === "hold") k.h = 1;
+          else if (e.kind === "curve") {
+            k.o = { x: [e.cp[0]], y: [e.cp[1]] };
+            k.i = { x: [e.cp[2]], y: [e.cp[3]] };
+          } else return null;
+          k.to = a.spatial?.out ? [...a.spatial.out] : [0, 0];
+          k.ti = b.spatial?.in ? [...b.spatial.in] : [0, 0];
+        }
+        keys.push(k);
+      }
+      const samples = px.map((x, f) => x && py[f] ? [x[0], py[f][0]] : void 0);
+      const fill = samples.map((s, f) => s ?? samples.slice(0, f).reverse().find(Boolean) ?? samples.find(Boolean));
+      if (keysMatch(keys, fill, present(samples), 0.75)) {
+        this.stats.exact++;
+        return { a: 1, k: keys };
+      }
+      this.notes.add("A curved motion path was baked frame by frame (its timing does not follow the path exactly).");
+      return null;
+    }
+    return null;
+  }
+  /** A shape group's transform from an affine (a glyph posed by text animators), per frame. */
+  affineTr(frames) {
+    const P = [], R = [], S = [], O = [];
+    frames.forEach((g, f) => {
+      if (!g) return;
+      const d = decompose(g.local);
+      if (Math.abs(d.skew) > 1e-4) this.notes.add("A skewed glyph was written without its skew.");
+      P[f] = [d.tx, d.ty];
+      R[f] = [d.rotation * 180 / Math.PI];
+      S[f] = [d.scaleX * 100, d.scaleY * 100];
+      O[f] = [g.opacity * 100];
+    });
+    const o = frames.map((g, f) => g ? O[f] : [0]);
+    return { ty: "tr", a: { a: 0, k: [0, 0] }, p: this.prop(P, null, false, 1e-3), s: this.prop(S, null, false, 1e-3), r: this.prop(unwrapDegrees(R), null, true, 1e-3), o: this.prop(o, null, true, 0.01) };
+  }
+  // ── Layers ─────────────────────────────────────────────────────────────────────────────────────
+  base5(nm, ks, frames) {
+    const [ip, op] = span(frames);
+    return { ind: 0, nm, ip, op, st: 0, sr: 1, ks, ao: 0, ddd: 0 };
+  }
+  /** A layer's opacity: its chain times its own opacity at each frame (0 where it is not drawn). */
+  opacity(chain, own, keyed) {
+    const samples = chain.map((c, f) => own[f] === void 0 ? void 0 : [c * own[f] * 100]);
+    const exact = keyed.length === 1 ? this.exact(keyed[0], [this.dim(keyed[0], "opacity")]) : null;
+    return this.prop(samples, exact, true, 0.01);
+  }
+  keyedOpacity(frames) {
+    const id = frames.find(Boolean)?.node?.id;
+    return !!this.dim(id, "opacity");
+  }
+  /** Children of a comp as layers, top first. Own paths (a frame's background) become shape layers where they fall. */
+  items(children, ctx, owner) {
+    const out = [];
+    let run = [];
+    const flush = () => {
+      if (!run.length) return;
+      out.push(this.pathsLayer(run, ctx, owner));
+      run = [];
+    };
+    for (let i = children.length - 1; i >= 0; i--) {
+      const z = children[i];
+      if (z.kind === "path") {
+        run.unshift(z);
+        continue;
+      }
+      flush();
+      if (z.kind === "group") out.push(...this.groupLayers(z, ctx));
+      else if (z.kind === "raster") out.push(...this.rasterLayers(z, ctx));
+      else out.push(...this.maskLayers(z, ctx));
+    }
+    flush();
+    return out;
+  }
+  /** A container's own paths (its fill and stroke), in its own space. */
+  pathsLayer(run, ctx, owner) {
+    const own = run[0].frames.map((_, f) => run.find((z) => z.frames[f])?.frames[f]);
+    const ks = { a: { a: 0, k: [0, 0] }, p: { a: 0, k: [...ctx.offset] }, s: { a: 0, k: [100, 100] }, r: { a: 0, k: 0 }, o: { a: 0, k: 100 } };
+    ks.o = this.opacity(ctx.chain, own.map((p) => p ? 1 : void 0), ctx.chainKeyed);
+    const shapes = run.slice().reverse().map((z, i) => this.pathGroup(z, owner, run.length - 1 - i));
+    const name = owner?.frames.find(Boolean)?.name ?? "Shapes";
+    return { ...this.base5(`${name} \xB7 fill`, ks, own), ty: 4, shapes };
+  }
+  /** A node group: a shape layer when it draws only paths (and posed glyphs), else a precomp of its children. */
+  groupLayers(z, ctx, place) {
+    const g0 = z.frames.find(Boolean);
+    const node = g0.node;
+    const own = z.frames.map((g, f) => g ? g.opacity * (place?.opacity[f] ?? 1) : void 0);
+    const keyed = this.keyedOpacity(z.frames) && node ? [...ctx.chainKeyed, node.id] : ctx.chainKeyed;
+    const name = g0.name || node?.type || "Layer";
+    const blend = BLEND[g0.blend] ?? 0;
+    if (g0.blend !== "NORMAL" && BLEND[g0.blend] === void 0) this.notes.add(`Blend mode ${g0.blend.toLowerCase().replace(/_/g, " ")} has no Lottie equivalent: drawn normally.`);
+    const shapeOnly = !place && z.children.every((c) => c.kind === "path" || c.kind === "group" && !c.frames.find(Boolean)?.node && c.children.every((cc) => cc.kind === "path")) && !z.frames.some((g) => g?.clip);
+    if (shapeOnly) {
+      const ks2 = this.nodeKs(z.frames, ctx.offset, 0);
+      ks2.o = this.opacity(ctx.chain, own, keyed);
+      const shapes = [];
+      let pi = z.children.filter((c) => c.kind === "path").length;
+      for (let i = z.children.length - 1; i >= 0; i--) {
+        const c = z.children[i];
+        if (c.kind === "path") shapes.push(this.pathGroup(c, z, --pi));
+        else if (c.kind === "group") {
+          const inner = c.children.slice().reverse().map((cc) => cc.kind === "path" ? this.pathGroup(cc, null, -1) : null).filter((s) => !!s);
+          shapes.push({ ty: "gr", nm: c.frames.find(Boolean)?.name || "glyph", it: [...inner, this.affineTr(c.frames)] });
+        }
+      }
+      const layer2 = { ...this.base5(name, ks2, z.frames), ty: 4, shapes, ...blend ? { bm: blend } : {} };
+      layer2.ln = node?.id;
+      return [layer2];
+    }
+    const P = this.pad;
+    const chain = ctx.chain.map((c, f) => own[f] === void 0 ? 0 : c * own[f]);
+    const layers = this.items(z.children, { chain, chainKeyed: keyed, offset: [P, P] }, z);
+    const maxW = Math.max(...z.frames.map((g) => g?.node?.width ?? 0), 1), maxH = Math.max(...z.frames.map((g) => g?.node?.height ?? 0), 1);
+    const id = this.comp(layers, maxW + 2 * P, maxH + 2 * P, name);
+    const ks = place ? this.nodeKs(z.frames, ctx.offset, P, place.matrix) : this.nodeKs(z.frames, ctx.offset, P);
+    const layer = { ...this.base5(name, ks, z.frames), ty: 0, refId: id, w: Math.ceil(maxW + 2 * P), h: Math.ceil(maxH + 2 * P), ...blend ? { bm: blend } : {} };
+    layer.ln = node?.id;
+    const masks = [];
+    if (z.frames.some((g) => g?.clip)) {
+      const everRounded = z.frames.some((g) => g?.clip?.radii);
+      const pts = z.frames.map((g) => {
+        if (!g) return void 0;
+        const w = g.clip?.width ?? g.node?.width ?? 0, h = g.clip?.height ?? g.node?.height ?? 0;
+        return everRounded ? roundedRectBezier(P, P, w, h, g.clip?.radii ?? [0, 0, 0, 0]) : rectBezier(P, P, w, h);
+      });
+      masks.push({ mode: "a", nm: "Clip", inv: false, pt: this.shapeProp(pts), o: { a: 0, k: 100 }, x: { a: 0, k: 0 } });
+    }
+    if (place?.clip?.some(Boolean)) {
+      const pts = z.frames.map((_, f) => {
+        const c = place.clip[f], m = place.matrix[f];
+        const inv = m ? invert(m) : null;
+        if (!c || !inv) return rectBezier(0, 0, maxW + 2 * P, maxH + 2 * P);
+        const s = Math.hypot(inv[0], inv[1]);
+        return circleBezier(inv[0] * c.cx + inv[2] * c.cy + inv[4] + P, inv[1] * c.cx + inv[3] * c.cy + inv[5] + P, c.r * s);
+      });
+      masks.push({ mode: "i", nm: "Wipe", inv: false, pt: this.shapeProp(pts, true), o: { a: 0, k: 100 }, x: { a: 0, k: 0 } });
+      this.notes.add("A circle wipe was written as a mask baked frame by frame.");
+    }
+    if (masks.length) {
+      layer.hasMask = true;
+      layer.masksProperties = masks;
+    }
+    return [layer];
+  }
+  /** A node the GPU draws alone: an image asset on a null that carries the node's transform. */
+  rasterLayers(z, ctx) {
+    const f0 = z.frames.findIndex(Boolean);
+    const item = z.frames[f0];
+    const img = this.images.get(z.key);
+    const placed = this.rasterPlacement.get(z.key);
+    if (!img || !placed) {
+      this.notes.add(`\u201C${item.node.name || item.node.type}\u201D is drawn only by the GPU and could not be rendered here: left out.`);
+      return [];
+    }
+    const nul = { ...this.base5(`${item.node.name} \xB7 transform`, this.nodeKs(z.frames, ctx.offset, 0), z.frames), ty: 3 };
+    const d = decompose(placed.matrix);
+    const ks = {
+      a: { a: 0, k: [0, 0] },
+      p: { a: 0, k: [r3(d.tx), r3(d.ty)] },
+      s: { a: 0, k: [d.scaleX * 100, d.scaleY * 100] },
+      r: { a: 0, k: d.rotation * 180 / Math.PI },
+      o: this.opacity(ctx.chain, z.frames.map((r) => r ? num(r.node.opacity, 1) : void 0), this.dim(item.node.id, "opacity") ? [...ctx.chainKeyed, item.node.id] : ctx.chainKeyed)
+    };
+    const image = { ...this.base5(item.node.name || "Image", ks, z.frames), ty: 2, refId: img, __parent: nul };
+    image.ln = item.node.id;
+    return [image, nul];
+  }
+  /** Siblings under a mask child: a matte layer (the mask's own drawing) over a precomp of what it masks. */
+  maskLayers(z, ctx) {
+    if (!z.content) return this.items(z.children, ctx, null);
+    const g0 = z.frames.find(Boolean);
+    const ones = ctx.chain.map(() => 1);
+    let matte = this.items([z.content], { chain: ones, chainKeyed: [], offset: ctx.offset }, null);
+    if (matte.length !== 1) {
+      const P2 = this.pad;
+      const inner = this.items([z.content], { chain: ones, chainKeyed: [], offset: [P2, P2] }, null);
+      const id2 = this.comp(inner, this.size.width + 2 * P2, this.size.height + 2 * P2, "Matte");
+      matte = [{ ...this.base5("Matte", this.padKs(ctx.offset), z.frames), ty: 0, refId: id2, w: Math.ceil(this.size.width + 2 * P2), h: Math.ceil(this.size.height + 2 * P2) }];
+    }
+    matte[0].td = 1;
+    const P = this.pad;
+    const layers = this.items(z.children, { chain: ctx.chain, chainKeyed: ctx.chainKeyed, offset: [P, P] }, null);
+    const id = this.comp(layers, this.size.width + 2 * P, this.size.height + 2 * P, "Masked");
+    const type = g0.mask?.type;
+    const masked = { ...this.base5("Masked", this.padKs(ctx.offset), z.frames), ty: 0, refId: id, w: Math.ceil(this.size.width + 2 * P), h: Math.ceil(this.size.height + 2 * P), tt: type === "LUMINANCE" ? 3 : 1 };
+    return [matte[0], masked];
+  }
+  /** A padded precomp placed so its origin lands on the parent's. */
+  padKs(offset) {
+    return { a: { a: 0, k: [this.pad, this.pad] }, p: { a: 0, k: [...offset] }, s: { a: 0, k: [100, 100] }, r: { a: 0, k: 0 }, o: { a: 0, k: 100 } };
+  }
+  comp(layers, w, h, nm) {
+    const id = `comp_${this.comps++}`;
+    this.assets.push({ id, nm, layers: finish(layers), w: Math.ceil(w), h: Math.ceil(h) });
+    return id;
+  }
+  // ── Shapes ─────────────────────────────────────────────────────────────────────────────────────
+  shapeProp(frames, forceHold = false) {
+    const f0 = frames.findIndex(Boolean);
+    const rounded = frames.map((b, f) => b ?? frames.slice(0, f).reverse().find(Boolean) ?? frames[f0]).map(roundBezier);
+    const sig = (b) => JSON.stringify(b);
+    const first = sig(rounded[0]);
+    if (rounded.every((b) => sig(b) === first)) return { a: 0, k: rounded[0] };
+    const topo = (b) => `${b.c}:${b.v.length}`;
+    const hold = forceHold || !rounded.every((b) => topo(b) === topo(rounded[0]));
+    const filledFrames = hold ? padVertices(rounded) : rounded;
+    const keys = [];
+    for (let f = 0; f < filledFrames.length; f++) {
+      const same = f > 0 && sig(filledFrames[f]) === sig(filledFrames[f - 1]);
+      const nextSame = f + 1 < filledFrames.length && sig(filledFrames[f]) === sig(filledFrames[f + 1]);
+      if (same && nextSame) continue;
+      if (hold && same) continue;
+      const k = { t: f, s: [filledFrames[f]] };
+      if (f < filledFrames.length - 1) {
+        if (hold) k.h = 1;
+        else {
+          k.o = { x: [0], y: [0] };
+          k.i = { x: [1], y: [1] };
+        }
+      }
+      keys.push(k);
+    }
+    this.stats.baked++;
+    return { a: 1, k: keys };
+  }
+  /**
+   * A vector's keyed outline (its `paths` track) as shape keys at the track's own times and curves, one property per
+   * contour, or null when the drawn frames are not that track alone. Each pair of keys is written as the matched pair
+   * `morphPaths` blends (lib/motion/morph.ts), so a player interpolating them draws what we draw; every key is padded
+   * to the most vertices any has. Where one pair's end and the next pair's start are the same outline matched two ways,
+   * the end is held for a sliver of a frame and the next pair starts from its own match.
+   */
+  morphShapes(id, contours) {
+    const d = this.dim(id, "paths", () => NaN);
+    const src = this.exact(id, [d]);
+    if (!d || !src || d.track.muted || d.track.modifiers?.length || d.track.keys.some((k) => k.bind)) return null;
+    const keys = d.track.keys;
+    if (!keys.every((k) => isPathValue(k.v))) return null;
+    const toBeziers = (paths) => cmdsToBeziers(vectorCmds({ paths }));
+    const sig = (bs) => JSON.stringify(bs.map(roundBezier));
+    for (let f = 0; f < contours.length; f++) {
+      const drawn = contours[f];
+      if (!drawn) continue;
+      const v = sampleTrack(d.track, d.prop, d.rest, frameMs(this.grid, f) - src.shift);
+      if (!isPathValue(v) || sig(toBeziers(v)) !== sig(drawn)) return null;
+    }
+    const frameOf = (localMs) => msFrame(this.grid, localMs + src.shift);
+    const lerpB = (a, b, e) => {
+      const l = (p, q) => p.map((u, j) => [u[0] + (q[j][0] - u[0]) * e, u[1] + (q[j][1] - u[1]) * e]);
+      return { c: a.c, v: l(a.v, b.v), i: l(a.i, b.i), o: l(a.o, b.o) };
+    };
+    const out = [];
+    let end = null;
+    for (let j = 0; j < keys.length - 1; j++) {
+      const a = keys[j], b = keys[j + 1];
+      const [ma, mb] = morphPair(a.v, b.v);
+      const A = toBeziers(ma), B = toBeziers(mb);
+      if (A.length !== B.length) return null;
+      let t = frameOf(a.t);
+      if (end && sig(end) !== sig(A)) {
+        out.push({ t, s: end, ease: "hold" });
+        t += 1e-3;
+      }
+      const ease = segmentEase(a.out);
+      if (ease.kind === "hold") {
+        out.push({ t, s: A, ease: "hold" });
+        end = null;
+        continue;
+      }
+      if (ease.kind === "curve") out.push({ t, s: A, ease: ease.cp });
+      else if (ease.kind === "halves") {
+        out.push({ t, s: A, ease: ease.first });
+        out.push({ t: frameOf((a.t + b.t) / 2), s: A.map((c, k) => lerpB(c, B[k], 0.5)), ease: ease.second });
+      } else {
+        const unit = { keys: [{ id: "a", t: a.t, v: 0, out: a.out }, { id: "b", t: b.t, v: 1, out: { kind: "linear" } }] };
+        out.push({ t, s: A, linear: true });
+        for (let f = Math.floor(frameOf(a.t)) + 1; f < frameOf(b.t); f++) {
+          const local = frameMs(this.grid, f) - src.shift;
+          const e = sampleTrack(unit, { valueType: "number", interpolation: "continuous" }, 0, local);
+          if (typeof e === "number") out.push({ t: f, s: A.map((c, k) => lerpB(c, B[k], e)), linear: true });
+        }
+      }
+      end = B;
+    }
+    out.push({ t: frameOf(keys[keys.length - 1].t), s: end ?? toBeziers(keys[keys.length - 1].v) });
+    const count = Math.max(...out.map((k) => k.s.length));
+    const empty = { c: false, v: [], i: [], o: [] };
+    const props = [];
+    for (let c = 0; c < count; c++) {
+      const padded = padVertices(out.map((k) => roundBezier(k.s[c] ?? empty)));
+      props.push({
+        a: 1,
+        k: out.map((k, j) => {
+          const key = { t: k.t, s: [padded[j]] };
+          if (j === out.length - 1) return key;
+          if (k.ease === "hold") key.h = 1;
+          else {
+            const cp = k.linear ? LINEAR_CP : k.ease ?? LINEAR_CP;
+            key.o = { x: [cp[0]], y: [cp[1]] };
+            key.i = { x: [cp[2]], y: [cp[3]] };
+          }
+          return key;
+        })
+      });
+    }
+    this.stats.exact++;
+    return props;
+  }
+  /** One IR path across frames: its geometry, then its strokes and fills (front first), then an identity transform. */
+  pathGroup(z, owner, index) {
+    const frames = z.frames;
+    const p0 = frames.find(Boolean);
+    const ownerNodes = owner ? owner.frames.map((g) => g?.node) : frames.map(() => void 0);
+    const node0 = ownerNodes.find(Boolean);
+    const it = [];
+    const uniform = (n) => {
+      const cr = n?.cornerRadius;
+      return !Array.isArray(cr) || cr.every((v) => v === cr[0]);
+    };
+    const rectLike = index === 0 && !!node0 && RECT_TYPES.has(node0.type) && frames.every((p, f) => !p || !!p.box && uniform(ownerNodes[f]));
+    const ellipse = index === 0 && node0?.type === "ELLIPSE" && !node0.arcData;
+    const nodeId = node0?.id;
+    const geometry = [];
+    if (rectLike) {
+      const rad = (n) => {
+        const cr = n?.cornerRadius;
+        return Array.isArray(cr) ? num(cr[0]) : num(cr);
+      };
+      geometry.push({
+        ty: "rc",
+        nm: "Rectangle",
+        d: 1,
+        p: this.prop(frames.map((p, f) => p ? [ownerNodes[f].width / 2, ownerNodes[f].height / 2] : void 0), null, false, 1e-3),
+        s: this.prop(frames.map((p, f) => p ? [ownerNodes[f].width, ownerNodes[f].height] : void 0), null, false, 1e-3),
+        r: this.prop(frames.map((p, f) => p ? [rad(ownerNodes[f])] : void 0), this.exact(nodeId, [this.dim(nodeId, "cornerRadius")]), true, 1e-3)
+      });
+    } else if (ellipse) {
+      geometry.push({
+        ty: "el",
+        nm: "Ellipse",
+        d: 1,
+        p: this.prop(frames.map((p, f) => p ? [ownerNodes[f].width / 2, ownerNodes[f].height / 2] : void 0), null, false, 1e-3),
+        s: this.prop(frames.map((p, f) => p ? [ownerNodes[f].width, ownerNodes[f].height] : void 0), null, false, 1e-3)
+      });
+    } else {
+      const contours = frames.map((p) => p ? cmdsToBeziers(p.cmds) : void 0);
+      const morph = index === 0 ? this.morphShapes(nodeId, contours) : null;
+      if (morph) geometry.push(...morph.map((ks, c) => ({ ty: "sh", nm: `Path ${c + 1}`, ks })));
+      const count = morph ? 0 : Math.max(...contours.map((c) => c?.length ?? 0));
+      const varies = contours.some((c) => c && c.length !== count);
+      for (let c = 0; c < count; c++) {
+        const empty = { c: false, v: [], i: [], o: [] };
+        geometry.push({ ty: "sh", nm: `Path ${c + 1}`, ks: this.shapeProp(contours.map((cs) => cs ? cs[c] ?? empty : void 0), varies) });
+      }
+    }
+    it.push(...geometry);
+    if (p0.trim) {
+      const trimProp = (field) => {
+        const scale = field === "offset" ? 1 : 100;
+        const pick2 = (v) => typeof v === "number" ? v * scale : NaN;
+        return this.prop(frames.map((p) => p?.trim ? [num(p.trim[field], field === "end" ? 1 : 0) * scale] : void 0), this.exact(nodeId, [this.dim(nodeId, `trim.${field}`, pick2)]), true, 0.01);
+      };
+      it.push({ ty: "tm", nm: "Trim paths", s: trimProp("start"), e: trimProp("end"), o: trimProp("offset"), m: p0.trim.mode === "SEQUENTIAL" ? 2 : 1 });
+    }
+    const box = (p, f) => p.box ?? (ownerNodes[f] ? { width: ownerNodes[f].width, height: ownerNodes[f].height } : { width: 1, height: 1 });
+    const strokeCount = Math.max(...frames.map((p) => p?.strokes.length ?? 0));
+    const fillCount = Math.max(...frames.map((p) => p?.fills.length ?? 0));
+    const single = (list) => {
+      if (!node0 || index !== 0 && !p0.trim) return null;
+      const items = list === "fills" ? resolvedFills(node0, this.opts.styles).filter((f) => f.visible !== false) : resolvedStrokes(node0, this.opts.styles);
+      return items.length === 1 ? items[0] : null;
+    };
+    const insetStrokes = [];
+    const strokesAt = it.length;
+    for (let j = strokeCount - 1; j >= 0; j--) {
+      const s0 = frames.find((p) => p?.strokes[j]).strokes[j];
+      const one = single("strokes");
+      const colorPath = one?.id ? `strokes[@${one.id}].color` : null;
+      const widthPath = one?.id ? `strokes[@${one.id}].width` : null;
+      const st = this.stroke(frames.map((p) => p?.strokes[j]), s0, colorPath, widthPath, nodeId);
+      if (s0.alignment !== "CENTER" && (rectLike || ellipse)) {
+        const sign = s0.alignment === "INSIDE" ? -1 : 1;
+        const inset = (_f, p) => (p ? p.strokes[j]?.width ?? s0.width : s0.width) * sign;
+        const geo = rectLike ? {
+          ty: "rc",
+          d: 1,
+          p: this.prop(frames.map((p, f) => p ? [ownerNodes[f].width / 2, ownerNodes[f].height / 2] : void 0), null, false, 1e-3),
+          s: this.prop(frames.map((p, f) => p ? [Math.max(0, ownerNodes[f].width + inset(f, p)), Math.max(0, ownerNodes[f].height + inset(f, p))] : void 0), null, false, 1e-3),
+          r: this.prop(frames.map((p, f) => {
+            if (!p) return void 0;
+            const cr = ownerNodes[f].cornerRadius;
+            const r0 = Array.isArray(cr) ? num(cr[0]) : num(cr);
+            return [r0 > 0 ? Math.max(0, r0 + inset(f, p) / 2) : 0];
+          }), null, true, 1e-3)
+        } : {
+          ty: "el",
+          d: 1,
+          p: this.prop(frames.map((p, f) => p ? [ownerNodes[f].width / 2, ownerNodes[f].height / 2] : void 0), null, false, 1e-3),
+          s: this.prop(frames.map((p, f) => p ? [Math.max(0, ownerNodes[f].width + inset(f, p)), Math.max(0, ownerNodes[f].height + inset(f, p))] : void 0), null, false, 1e-3)
+        };
+        insetStrokes.push({ ty: "gr", nm: "Stroke", it: [geo, st, identityTr()] });
+        continue;
+      }
+      if (s0.alignment !== "CENTER") this.notes.add("Inside and outside strokes on paths are drawn centred (Lottie strokes only straddle the path).");
+      it.push(st);
+    }
+    for (let j = fillCount - 1; j >= 0; j--) {
+      const f0 = frames.find((p) => p?.fills[j]).fills[j];
+      const one = single("fills");
+      const colorPath = one?.id && one.type === "SOLID" ? `fills[@${one.id}].color` : null;
+      it.push(this.fill(frames.map((p) => p?.fills[j]), f0, z.frames.map((p, f) => p ? box(p, f) : void 0), p0.fillRule, colorPath, nodeId));
+    }
+    if (p0.strokesFirst) {
+      const fillsFrom = it.length - fillCount;
+      const strokes = it.splice(strokesAt, fillsFrom - strokesAt);
+      it.push(...strokes);
+    }
+    it.push(identityTr());
+    const name = node0?.name || "Path";
+    if (!insetStrokes.length) return { ty: "gr", nm: name, it };
+    return { ty: "gr", nm: name, it: [...insetStrokes, { ty: "gr", nm: "Shape", it }, identityTr()] };
+  }
+  colorExact(id, path) {
+    if (!path || !id) return null;
+    const pick2 = (k) => (v) => typeof v === "object" && v ? v[k] : NaN;
+    return this.exact(id, [this.dim(id, path, pick2("r")), this.dim(id, path, pick2("g")), this.dim(id, path, pick2("b"))]);
+  }
+  fill(frames, f0, boxes, rule, colorPath, id) {
+    const r = rule === "evenodd" ? 2 : 1;
+    if (f0.kind === "solid") {
+      const c = frames.map((f) => f?.kind === "solid" ? [f.color.r, f.color.g, f.color.b] : void 0);
+      const o = frames.map((f) => f ? [(f.kind === "solid" ? f.alpha : 0) * 100] : void 0);
+      return { ty: "fl", nm: "Fill", c: this.prop(c, this.colorExact(id, colorPath), false, 5e-4), o: this.prop(o, null, true, 0.01), r };
+    }
+    const grad = this.gradient(frames, f0, boxes);
+    return { ty: "gf", nm: "Gradient fill", t: f0.kind === "linear" ? 1 : 2, ...grad, r };
+  }
+  gradient(frames, f0, boxes) {
+    const stops = f0.kind === "solid" ? 2 : f0.stops.length;
+    const S = [], E = [], G = [], O = [];
+    let alphaStops = false;
+    frames.forEach((f) => {
+      if (f && f.kind !== "solid" && f.stops.some((s) => (s.color.a ?? 1) < 1)) alphaStops = true;
+    });
+    frames.forEach((f, i) => {
+      const b = boxes[i];
+      if (!f || f.kind === "solid" || !b) return;
+      if (f.kind === "linear") {
+        S[i] = [f.from.x * b.width, f.from.y * b.height];
+        E[i] = [f.to.x * b.width, f.to.y * b.height];
+      } else {
+        S[i] = [f.center.x * b.width, f.center.y * b.height];
+        E[i] = [(f.center.x + f.radius) * b.width, f.center.y * b.height];
+      }
+      const list = f.stops.length === stops ? f.stops : f0.kind !== "solid" ? f0.stops : [];
+      const g = [];
+      for (const s of list) g.push(s.position, s.color.r, s.color.g, s.color.b);
+      if (alphaStops) for (const s of list) g.push(s.position, s.color.a ?? 1);
+      G[i] = g;
+      O[i] = [f.alpha * 100];
+    });
+    if (f0.kind === "radial") {
+      const b = boxes.find(Boolean);
+      if (b && Math.abs(b.width - b.height) > 0.5) this.notes.add("An elliptical radial gradient was written circular (Lottie radial gradients are round).");
+    }
+    return { s: this.prop(S, null, false, 1e-3), e: this.prop(E, null, false, 1e-3), g: { p: stops, k: this.prop(G, null, false, 5e-4) }, o: this.prop(O, null, true, 0.01) };
+  }
+  stroke(frames, s0, colorPath, widthPath, id) {
+    const c = frames.map((s) => s ? [s.color.r, s.color.g, s.color.b] : void 0);
+    const o = frames.map((s) => s ? [s.alpha * 100] : void 0);
+    const w = frames.map((s) => s ? [s.width] : void 0);
+    const lc = s0.cap === "ROUND" ? 2 : s0.cap === "SQUARE" ? 3 : 1;
+    const lj = s0.join === "ROUND" ? 2 : s0.join === "BEVEL" ? 3 : 1;
+    const st = {
+      ty: "st",
+      nm: "Stroke",
+      c: this.prop(c, this.colorExact(id, colorPath), false, 5e-4),
+      o: this.prop(o, null, true, 0.01),
+      w: this.prop(w, widthPath ? this.exact(id, [this.dim(id, widthPath)]) : null, true, 1e-3),
+      lc,
+      lj,
+      ml: 4
+    };
+    if (s0.dash) st.d = [{ n: "d", nm: "dash", v: { a: 0, k: s0.dash[0] } }, { n: "g", nm: "gap", v: { a: 0, k: s0.dash[1] } }, { n: "o", nm: "offset", v: { a: 0, k: 0 } }];
+    return st;
+  }
+  /** Render every raster fallback once (at its first drawn frame) into an image asset. */
+  async prepareRasters(roots) {
+    const walk = (z) => {
+      if (!z) return [];
+      const out = [];
+      if (z.kind === "raster") out.push(z);
+      if (z.kind === "group" || z.kind === "mask") for (const c of z.children) out.push(...walk(c));
+      if (z.kind === "mask") out.push(...walk(z.content));
+      return out;
+    };
+    const rasters = roots.flatMap(walk);
+    const render = this.opts.rasterize;
+    for (const z of rasters) {
+      if (this.images.has(z.key)) continue;
+      const f0 = z.frames.findIndex(Boolean);
+      const item = z.frames[f0];
+      if (!render) continue;
+      const last = z.frames.length - 1 - [...z.frames].reverse().findIndex(Boolean);
+      const doc = this.base.nodes[item.node.id] || this.base.nodes[item.node.id.split("::").pop()] ? this.base : this.docs[last];
+      const attempt = async (id2, node) => {
+        const unfaded = { ...doc, nodes: { ...doc.nodes, [id2]: { ...node, opacity: 1 } } };
+        const img2 = await render({ node: unfaded.nodes[id2], doc: unfaded }).catch(() => null);
+        if (!img2) return null;
+        try {
+          return { img: img2, world: getWorldMatrix(unfaded, id2) };
+        } catch {
+          return null;
+        }
+      };
+      const realId = item.node.id.split("::").pop();
+      const got = (doc.nodes[item.node.id] ? await attempt(item.node.id, doc.nodes[item.node.id]) : null) ?? (doc.nodes[realId] ? await attempt(realId, doc.nodes[realId]) : null);
+      if (!got) continue;
+      const { img, world } = got;
+      const inv = invert(world);
+      if (!inv) continue;
+      const b = img.bounds;
+      const toWorld = [(b.maxX - b.minX) / img.width, 0, 0, (b.maxY - b.minY) / img.height, b.minX, b.minY];
+      const id = `image_${this.images.size}`;
+      this.assets.push({ id, w: img.width, h: img.height, u: "", p: img.dataUrl, e: 1 });
+      this.images.set(z.key, id);
+      this.rasterPlacement.set(z.key, { matrix: multiply(inv, toWorld) });
+      if (z.frames.some((r, f) => r && f !== f0 && r.node !== item.node && !sameLook(r.node, item.node))) {
+        this.notes.add(`\u201C${item.node.name || item.node.type}\u201D is drawn by the GPU only: written as a still image that moves, so what changes inside it does not play.`);
+      }
+    }
+    if (rasters.length && !render) this.notes.add("Some layers are drawn only by the GPU (images, GPU-only paints, shadows) and need the canvas renderer to export.");
+  }
+};
+function sameLook(a, b) {
+  const skip = /* @__PURE__ */ new Set(["x", "y", "rotation", "scaleX", "scaleY", "translateX", "translateY", "anchorX", "anchorY", "opacity", "motion"]);
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const k of keys) if (!skip.has(k) && a[k] !== b[k]) return false;
+  return true;
+}
+function padVertices(frames) {
+  const n = Math.max(...frames.map((b) => b.v.length));
+  const anchor = frames.find((b) => b.v.length)?.v[0] ?? [0, 0];
+  const zero = [0, 0];
+  return frames.map((b) => {
+    if (b.v.length === n) return b;
+    const k = b.v.length - 1;
+    const last = b.v[k] ?? anchor;
+    const extra = n - b.v.length;
+    const o = b.o.map((p, j) => j === k ? [...zero] : p);
+    const pads = Array.from({ length: extra }, (_, j) => j === extra - 1 && k >= 0 ? [...b.o[k]] : [...zero]);
+    return {
+      c: b.v.length ? b.c : true,
+      v: [...b.v, ...Array.from({ length: extra }, () => [last[0], last[1]])],
+      i: [...b.i, ...Array.from({ length: extra }, () => [...zero])],
+      o: [...o, ...pads]
+    };
+  });
+}
+var identityTr = () => ({ ty: "tr", a: { a: 0, k: [0, 0] }, p: { a: 0, k: [0, 0] }, s: { a: 0, k: [100, 100] }, r: { a: 0, k: 0 }, o: { a: 0, k: 100 } });
+function finish(layers) {
+  layers.forEach((l, i) => {
+    l.ind = i + 1;
+  });
+  for (const l of layers) {
+    if (l.__parent) l.parent = l.__parent.ind;
+    delete l.__parent;
+  }
+  return layers;
+}
+async function buildLottie(doc, target, range, opts) {
+  const atlas = opts.renderer.getTextAtlas();
+  const budget = atlas?.glyphBudgetMs;
+  if (atlas) atlas.glyphBudgetMs = Infinity;
+  let sampled;
+  try {
+    sampled = sampleFrames(doc, target, range, opts);
+  } finally {
+    if (atlas && budget !== void 0) atlas.glyphBudgetMs = budget;
+  }
+  const { frames, docs, stage } = sampled;
+  const grid = { startMs: range.start, fps: range.fps, count: range.count };
+  const w = new Writer(grid, doc, docs, target.kind === "frame" ? target.frameId : null, opts, stage);
+  w.size = { width: stage.width, height: stage.height };
+  const rootKeys = [];
+  for (const roots of frames) for (const r of roots) if (!rootKeys.includes(r.key)) rootKeys.push(r.key);
+  const zRoots = rootKeys.map((key) => {
+    const at = frames.map((roots) => roots.find((r) => r.key === key));
+    return { key, at, z: zipItem(key, at.map((r) => r?.ir)) };
+  });
+  await w.prepareRasters(zRoots.map((r) => r.z).filter((z) => !!z));
+  const layers = [];
+  for (const r of zRoots.slice().reverse()) {
+    if (!r.z) continue;
+    layers.push(...w.groupLayers(r.z, { chain: r.at.map(() => 1), chainKeyed: [], offset: [0, 0] }, {
+      matrix: r.at.map((x) => x?.place),
+      opacity: r.at.map((x) => x?.opacity),
+      clip: r.at.map((x) => x?.clip)
+    }));
+  }
+  if (target.kind === "composition" && stage.background) {
+    const bg = stage.background;
+    layers.push({
+      ind: 0,
+      nm: "Stage",
+      ty: 4,
+      ip: 0,
+      op: range.count,
+      st: 0,
+      sr: 1,
+      ao: 0,
+      ddd: 0,
+      ks: { a: { a: 0, k: [0, 0] }, p: { a: 0, k: [0, 0] }, s: { a: 0, k: [100, 100] }, r: { a: 0, k: 0 }, o: { a: 0, k: 100 } },
+      shapes: [{ ty: "gr", nm: "Stage", it: [{ ty: "rc", d: 1, p: { a: 0, k: [stage.width / 2, stage.height / 2] }, s: { a: 0, k: [stage.width, stage.height] }, r: { a: 0, k: 0 } }, { ty: "fl", c: { a: 0, k: [bg.r, bg.g, bg.b] }, o: { a: 0, k: (bg.a ?? 1) * 100 }, r: 1 }, identityTr()] }]
+    });
+  }
+  const name = opts.name ?? (target.kind === "frame" ? doc.nodes[target.frameId]?.name : doc.compositions?.[target.compositionId]?.name) ?? "Animation";
+  const { markers } = target.kind === "frame" ? lottieMarkers(frameTimeline(doc.nodes, target.frameId), range) : { markers: [] };
+  const animation = {
+    v: "5.12.0",
+    nm: name,
+    fr: range.fps,
+    ip: 0,
+    op: range.count,
+    w: Math.round(stage.width),
+    h: Math.round(stage.height),
+    ddd: 0,
+    assets: w.assets,
+    layers: finish(layers),
+    meta: { g: "PopCraft" },
+    ...markers.length ? { markers } : {}
+  };
+  return { animation, notes: [...w.notes], stats: w.stats };
+}
+
+// lib/io/lottie/index.ts
+var RASTER_SCALE = 2;
+var MAX_RASTER_PIXELS = 4e6;
+function rendererRasterizer(renderer, styles) {
+  return async ({ node, doc }) => {
+    const b = getWorldRenderBounds(doc, node.id) ?? uprightBounds(getWorldTransform(doc, node.id), node.width, node.height);
+    const w = Math.max(1, b.maxX - b.minX), h = Math.max(1, b.maxY - b.minY);
+    const scale = Math.min(RASTER_SCALE, Math.sqrt(MAX_RASTER_PIXELS / (w * h)));
+    const img = await renderer.exportNode(node, scale, doc, styles);
+    if (!img) return null;
+    const png = await encodePng(img.width, img.height, img.data);
+    return { dataUrl: `data:image/png;base64,${bytesToBase64(png)}`, width: img.width, height: img.height, bounds: { minX: b.minX, minY: b.minY, maxX: b.minX + img.width / scale, maxY: b.minY + img.height / scale } };
+  };
+}
+function compactNumbers(value) {
+  const walk = (v) => {
+    if (typeof v === "number") {
+      const r = Math.round(v * 1e4) / 1e4;
+      return Object.is(r, -0) ? 0 : r;
+    }
+    if (Array.isArray(v)) return v.map(walk);
+    if (v && typeof v === "object") {
+      const o = {};
+      for (const k in v) o[k] = walk(v[k]);
+      return o;
+    }
+    return v;
+  };
+  return walk(value);
+}
+function dotLottie(animation, id = "animation", stateMachines = []) {
+  const manifest = {
+    version: "2",
+    generator: "PopCraft",
+    animations: [{ id }],
+    ...stateMachines.length ? { stateMachines: stateMachines.map((s) => ({ id: s.id, ...s.name ? { name: s.name } : {} })) } : {}
+  };
+  const files = {
+    "manifest.json": strToU8(JSON.stringify(manifest)),
+    [`a/${id}.json`]: strToU8(JSON.stringify(animation))
+  };
+  for (const s of stateMachines) files[`s/${s.id}.json`] = strToU8(JSON.stringify(s.machine));
+  return zipSync(files, { level: 6, mtime: new Date(1980, 0, 1) });
+}
+async function exportLottie(renderer, doc, spec, name, opts = {}) {
+  const styles = doc.styles;
+  const build = await buildLottie(doc, spec.target, spec.range, { renderer, styles, rasterize: rendererRasterizer(renderer, styles), name });
+  let animation = build.animation;
+  const notes = [...build.notes];
+  const machines = [];
+  const sm = spec.target.kind === "frame" ? machineOf(doc.nodes[spec.target.frameId]) : void 0;
+  if (sm && spec.target.kind === "frame" && opts.stateMachine !== false) {
+    if (spec.format !== "dotlottie") notes.push("The state machine is not in a bodymovin .json: export a .lottie to carry it.");
+    else {
+      const id = "animation";
+      const frameId = spec.target.frameId;
+      const out = dotLottieStateMachine({
+        machine: sm,
+        timeline: frameTimeline(doc.nodes, frameId),
+        duration: timelineDuration(doc.nodes, frameId),
+        range: spec.range,
+        animation,
+        animationId: id,
+        nodes: doc.nodes
+      });
+      animation = { ...animation, ...out.markers.length ? { markers: out.markers } : {} };
+      machines.push({ id: sm.id, name: sm.name, machine: out.machine });
+      notes.push(...out.notes);
+    }
+  }
+  animation = compactNumbers(animation);
+  const bytes = spec.format === "dotlottie" ? dotLottie(animation, "animation", machines) : strToU8(JSON.stringify(animation));
+  return { ...build, animation, notes: [...new Set(notes)], bytes };
+}
+
+export {
+  buildLottie,
+  rendererRasterizer,
+  compactNumbers,
+  dotLottie,
+  exportLottie
+};