@popcraft/kit 0.26.0 → 0.26.1

package/dist/chunks/chunk-QLADEGBH.js

@@ -1,1417 +0,0 @@
-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-D2UCKTWZ.js";
-import {
-  fittedRadii,
-  vectorCmds
-} from "./chunk-4CKI3O4M.js";
-import {
-  strToU8,
-  zipSync
-} from "./chunk-M7RQFLBQ.js";
-import {
-  bytesToBase64,
-  encodePng
-} from "./chunk-YJB7BGFC.js";
-import {
-  samplePose
-} from "./chunk-4RFGUSNI.js";
-import {
-  machineOf
-} from "./chunk-WGWAUMXY.js";
-import {
-  LINEAR_CP,
-  lottieEase,
-  segmentEase
-} from "./chunk-J4QYIKWI.js";
-import {
-  resolvedFills,
-  resolvedStrokes
-} from "./chunk-P2LIBAGF.js";
-import {
-  frameTimeline,
-  timelineDuration
-} from "./chunk-KJQMMKPO.js";
-import {
-  TRANSLATE,
-  XY,
-  sampleTrack
-} from "./chunk-STB3GK3P.js";
-import {
-  getWorldMatrix,
-  getWorldRenderBounds,
-  getWorldTransform,
-  init_scene_graph,
-  uprightBounds
-} from "./chunk-PLZOQXMQ.js";
-import {
-  init_properties,
-  propertyFor
-} from "./chunk-62AVP6QT.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
-};