@popcraft/kit 0.32.0 → 0.33.0

package/dist/chunks/chunk-MQ66HDKC.js

@@ -1,2662 +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 {
-  init_palettes,
-  presetPalette
-} from "./chunk-N7XUSTLZ.js";
-import {
-  init_page_presets,
-  kindForCategory,
-  presetById,
-  presetPx
-} from "./chunk-XBVMM6ZD.js";
-import {
-  encodeCels,
-  init_cells
-} from "./chunk-2LYY4KTS.js";
-import {
-  init_instance_layout,
-  instanceChildBox,
-  setSceneApi
-} from "./chunk-SMR77HUB.js";
-import {
-  effectiveComponentProperties,
-  init_instances,
-  withPropertyPaths
-} from "./chunk-2YBOCBPA.js";
-import {
-  init_variables,
-  resolveNodeVariables
-} from "./chunk-FREAHUVP.js";
-import {
-  blursOf,
-  init_effects,
-  shadowsOf
-} from "./chunk-4VICNBUI.js";
-import {
-  init_layout_access,
-  readCachedTextLayout
-} from "./chunk-IPETYEVH.js";
-import {
-  init_scene3d,
-  scene3dOf,
-  sceneLayers,
-  setVirtualResolver
-} from "./chunk-NMFXCSU4.js";
-import {
-  fromAffine,
-  init_transform3d,
-  mul4,
-  projectRect,
-  sceneFrame
-} from "./chunk-CK43FENV.js";
-import {
-  IDENTITY,
-  aabbOf,
-  apply,
-  decompose,
-  determinant,
-  init_transform,
-  invert,
-  lengthScale,
-  localCentre,
-  localMatrix,
-  multiply,
-  nearestAngle,
-  nodeFlips,
-  restValue,
-  withoutFlips
-} from "./chunk-X53QDCNX.js";
-import {
-  init_dist_node,
-  v4_default
-} from "./chunk-VBAS5IB5.js";
-import {
-  createColor,
-  createDefaultSceneNodeProps,
-  createSolidPaint,
-  init_types
-} from "./chunk-CZXJDKOJ.js";
-import {
-  init_define_POPCRAFT_COMPONENT_IDS
-} from "./chunk-FFS4SO7R.js";
-import {
-  __esm,
-  __export,
-  __toCommonJS
-} from "./chunk-LJSVREWM.js";
-
-// lib/engine/routing.ts
-function calculateOrthogonalPath(options) {
-  const { startPos, endPos, startDir, endDir, minSegmentLength = 20, obstacles, obstaclePadding = 14 } = options;
-  if (obstacles && obstacles.length > 0) {
-    const routed = routeAroundObstacles(startPos, endPos, startDir, endDir, obstacles, obstaclePadding, minSegmentLength);
-    if (routed) return routed;
-  }
-  const p1 = getPointAtDistance(startPos, startDir, minSegmentLength);
-  const p2 = getPointAtDistance(endPos, endDir, minSegmentLength);
-  const pts = [startPos, p1];
-  const isHoriz = (dir) => dir === "LEFT" || dir === "RIGHT" || dir === "CENTER";
-  if (isHoriz(startDir) && isHoriz(endDir)) {
-    const midX = (p1.x + p2.x) / 2;
-    pts.push({ x: midX, y: p1.y });
-    pts.push({ x: midX, y: p2.y });
-  } else if (!isHoriz(startDir) && !isHoriz(endDir)) {
-    const midY = (p1.y + p2.y) / 2;
-    pts.push({ x: p1.x, y: midY });
-    pts.push({ x: p2.x, y: midY });
-  } else if (isHoriz(startDir) && !isHoriz(endDir)) {
-    pts.push({ x: p2.x, y: p1.y });
-  } else {
-    pts.push({ x: p1.x, y: p2.y });
-  }
-  pts.push(p2);
-  pts.push(endPos);
-  return dedupe(pts);
-}
-function getPointAtDistance(pos, dir, dist) {
-  switch (dir) {
-    case "TOP":
-      return { x: pos.x, y: pos.y - dist };
-    case "BOTTOM":
-      return { x: pos.x, y: pos.y + dist };
-    case "LEFT":
-      return { x: pos.x - dist, y: pos.y };
-    case "RIGHT":
-      return { x: pos.x + dist, y: pos.y };
-    case "CENTER":
-      return { ...pos };
-  }
-}
-function dedupe(pts) {
-  const out = [];
-  for (let i = 0; i < pts.length; i++) {
-    if (i === 0 || Math.abs(pts[i].x - pts[i - 1].x) > 0.1 || Math.abs(pts[i].y - pts[i - 1].y) > 0.1) {
-      out.push(pts[i]);
-    }
-  }
-  return out;
-}
-function inflate(r, p) {
-  return { x: r.x - p, y: r.y - p, w: r.w + 2 * p, h: r.h + 2 * p };
-}
-function segmentBlocked(ax, ay, bx, by, rects) {
-  const EPS = 0.01;
-  if (Math.abs(ay - by) < EPS) {
-    const y = ay;
-    const lo = Math.min(ax, bx), hi = Math.max(ax, bx);
-    for (const r of rects) {
-      const top = r.y, bot = r.y + r.h, left = r.x, right = r.x + r.w;
-      if (y > top + EPS && y < bot - EPS && hi > left + EPS && lo < right - EPS) return true;
-    }
-  } else {
-    const x = ax;
-    const lo = Math.min(ay, by), hi = Math.max(ay, by);
-    for (const r of rects) {
-      const top = r.y, bot = r.y + r.h, left = r.x, right = r.x + r.w;
-      if (x > left + EPS && x < right - EPS && hi > top + EPS && lo < bot - EPS) return true;
-    }
-  }
-  return false;
-}
-function pointInsideAny(x, y, rects) {
-  const EPS = 0.01;
-  for (const r of rects) {
-    if (x > r.x + EPS && x < r.x + r.w - EPS && y > r.y + EPS && y < r.y + r.h - EPS) return true;
-  }
-  return false;
-}
-function uniqSorted(vals) {
-  const s = vals.slice().sort((a, b) => a - b);
-  const out = [];
-  for (const v of s) if (out.length === 0 || Math.abs(v - out[out.length - 1]) > 0.5) out.push(v);
-  return out;
-}
-function routeAroundObstacles(start, end, startDir, endDir, obstacles, padding, stub) {
-  const infl = obstacles.map((o) => inflate(o, padding));
-  const s1 = getPointAtDistance(start, startDir, stub);
-  const e1 = getPointAtDistance(end, endDir, stub);
-  let minX = Math.min(s1.x, e1.x), maxX = Math.max(s1.x, e1.x);
-  let minY = Math.min(s1.y, e1.y), maxY = Math.max(s1.y, e1.y);
-  for (const r of infl) {
-    minX = Math.min(minX, r.x);
-    maxX = Math.max(maxX, r.x + r.w);
-    minY = Math.min(minY, r.y);
-    maxY = Math.max(maxY, r.y + r.h);
-  }
-  const ring = padding + stub;
-  const xsRaw = [s1.x, e1.x, minX - ring, maxX + ring];
-  const ysRaw = [s1.y, e1.y, minY - ring, maxY + ring];
-  for (const r of infl) {
-    xsRaw.push(r.x, r.x + r.w);
-    ysRaw.push(r.y, r.y + r.h);
-  }
-  const X = uniqSorted(xsRaw);
-  const Y = uniqSorted(ysRaw);
-  if (X.length * Y.length > 4e3) return null;
-  const ix = (v) => X.findIndex((x) => Math.abs(x - v) < 0.5);
-  const iy = (v) => Y.findIndex((y) => Math.abs(y - v) < 0.5);
-  const si = ix(s1.x), sj = iy(s1.y), ti = ix(e1.x), tj = iy(e1.y);
-  if (si < 0 || sj < 0 || ti < 0 || tj < 0) return null;
-  if (pointInsideAny(s1.x, s1.y, infl) || pointInsideAny(e1.x, e1.y, infl)) return null;
-  const W = X.length, H = Y.length;
-  const cell = (i, j) => j * W + i;
-  const N = W * H;
-  const TURN = stub * 1.5;
-  const startAxis = startDir === "CENTER" ? 0 : HORIZ(startDir) ? 1 : 2;
-  const g = new Float64Array(N * 3).fill(Infinity);
-  const cameFrom = new Int32Array(N * 3).fill(-1);
-  const heurTarget = { x: X[ti], y: Y[tj] };
-  const h = (i, j) => Math.abs(X[i] - heurTarget.x) + Math.abs(Y[j] - heurTarget.y);
-  const heap = [];
-  const fscore = [];
-  const push = (id, f) => {
-    heap.push(id);
-    fscore.push(f);
-    let c = heap.length - 1;
-    while (c > 0) {
-      const p = c - 1 >> 1;
-      if (fscore[p] <= fscore[c]) break;
-      [heap[p], heap[c]] = [heap[c], heap[p]];
-      [fscore[p], fscore[c]] = [fscore[c], fscore[p]];
-      c = p;
-    }
-  };
-  const pop = () => {
-    const top = heap[0];
-    const lastId = heap.pop();
-    const lastF = fscore.pop();
-    if (heap.length > 0) {
-      heap[0] = lastId;
-      fscore[0] = lastF;
-      let c = 0;
-      for (; ; ) {
-        const l = 2 * c + 1, r = 2 * c + 2;
-        let m = c;
-        if (l < heap.length && fscore[l] < fscore[m]) m = l;
-        if (r < heap.length && fscore[r] < fscore[m]) m = r;
-        if (m === c) break;
-        [heap[m], heap[c]] = [heap[c], heap[m]];
-        [fscore[m], fscore[c]] = [fscore[c], fscore[m]];
-        c = m;
-      }
-    }
-    return top;
-  };
-  const startState = cell(si, sj) * 3 + startAxis;
-  g[startState] = 0;
-  push(startState, h(si, sj));
-  const targetCell = cell(ti, tj);
-  let endState = -1;
-  while (heap.length > 0) {
-    const state = pop();
-    const c = Math.floor(state / 3);
-    const axis = state % 3;
-    if (c === targetCell) {
-      endState = state;
-      break;
-    }
-    const i = c % W, j = Math.floor(c / W);
-    const gc = g[state];
-    const moves = [
-      { ni: i - 1, nj: j, ax: 1 },
-      { ni: i + 1, nj: j, ax: 1 },
-      { ni: i, nj: j - 1, ax: 2 },
-      { ni: i, nj: j + 1, ax: 2 }
-    ];
-    for (const mv of moves) {
-      if (mv.ni < 0 || mv.ni >= W || mv.nj < 0 || mv.nj >= H) continue;
-      if (segmentBlocked(X[i], Y[j], X[mv.ni], Y[mv.nj], infl)) continue;
-      const len = Math.abs(X[mv.ni] - X[i]) + Math.abs(Y[mv.nj] - Y[j]);
-      const turn = axis !== 0 && axis !== mv.ax ? TURN : 0;
-      const ns = cell(mv.ni, mv.nj) * 3 + mv.ax;
-      const ng = gc + len + turn;
-      if (ng < g[ns]) {
-        g[ns] = ng;
-        cameFrom[ns] = state;
-        push(ns, ng + h(mv.ni, mv.nj));
-      }
-    }
-  }
-  if (endState < 0) return null;
-  const way = [];
-  let s = endState;
-  while (s >= 0) {
-    const c = Math.floor(s / 3);
-    way.push({ x: X[c % W], y: Y[Math.floor(c / W)] });
-    s = cameFrom[s];
-  }
-  way.reverse();
-  return dedupe([start, ...way, end]);
-}
-function trimPolyline(pts, startTrim, endTrim) {
-  if (pts.length < 2) return null;
-  if (startTrim <= 0 && endTrim <= 0) return pts;
-  const n = pts.length;
-  const cum = new Array(n);
-  cum[0] = 0;
-  for (let i = 1; i < n; i++) {
-    cum[i] = cum[i - 1] + Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y);
-  }
-  const total = cum[n - 1];
-  const s0 = Math.max(0, startTrim);
-  const s1 = total - Math.max(0, endTrim);
-  const EPS = 1e-3;
-  if (s1 - s0 < EPS) return null;
-  const pointAt = (s) => {
-    let i = 1;
-    while (i < n - 1 && cum[i] <= s) i++;
-    const segLen = cum[i] - cum[i - 1];
-    const t = segLen > 1e-6 ? (s - cum[i - 1]) / segLen : 0;
-    return {
-      x: pts[i - 1].x + (pts[i].x - pts[i - 1].x) * t,
-      y: pts[i - 1].y + (pts[i].y - pts[i - 1].y) * t
-    };
-  };
-  const out = [pointAt(s0)];
-  for (let i = 1; i < n - 1; i++) {
-    if (cum[i] > s0 + EPS && cum[i] < s1 - EPS) out.push(pts[i]);
-  }
-  out.push(pointAt(s1));
-  return out;
-}
-function calculateBezierPath(options, steps = 30) {
-  const { startPos, endPos, startDir, endDir } = options;
-  const dx = endPos.x - startPos.x;
-  const dy = endPos.y - startPos.y;
-  const dist = Math.max(Math.hypot(dx, dy) * 0.4, 40);
-  const actualDist = Math.hypot(dx, dy);
-  const numSteps = Math.max(30, Math.min(150, Math.floor(actualDist / 3)));
-  let cp1 = getPointAtDistance(startPos, startDir, dist);
-  let cp2 = getPointAtDistance(endPos, endDir, dist);
-  if (startDir === "CENTER") cp1 = { x: startPos.x + dx * 0.25, y: startPos.y + dy * 0.25 };
-  if (endDir === "CENTER") cp2 = { x: endPos.x - dx * 0.25, y: endPos.y - dy * 0.25 };
-  const pts = [];
-  for (let i = 0; i <= numSteps; i++) {
-    const t = i / numSteps;
-    const u = 1 - t;
-    const tt = t * t;
-    const uu = u * u;
-    const uuu = uu * u;
-    const ttt = tt * t;
-    const pX = uuu * startPos.x + 3 * uu * t * cp1.x + 3 * u * tt * cp2.x + ttt * endPos.x;
-    const pY = uuu * startPos.y + 3 * uu * t * cp1.y + 3 * u * tt * cp2.y + ttt * endPos.y;
-    pts.push({ x: pX, y: pY });
-  }
-  return dedupe(pts);
-}
-var HORIZ;
-var init_routing = __esm({
-  "lib/engine/routing.ts"() {
-    "use strict";
-    init_define_POPCRAFT_COMPONENT_IDS();
-    HORIZ = (d) => d === "LEFT" || d === "RIGHT" || d === "CENTER";
-  }
-});
-
-// lib/engine/geometry/flatten.ts
-function flattenQuadratic(x1, y1, cx, cy, x2, y2, points, tolerance) {
-  const dx = x2 - x1;
-  const dy = y2 - y1;
-  const d = Math.abs(dy * cx - dx * cy + x2 * y1 - y2 * x1);
-  const len = Math.sqrt(dx * dx + dy * dy);
-  if (len > 0 && d / len <= tolerance) {
-    points.push(x2, y2);
-    return;
-  }
-  const x12 = (x1 + cx) / 2;
-  const y12 = (y1 + cy) / 2;
-  const x23 = (cx + x2) / 2;
-  const y23 = (cy + y2) / 2;
-  const x123 = (x12 + x23) / 2;
-  const y123 = (y12 + y23) / 2;
-  flattenQuadratic(x1, y1, x12, y12, x123, y123, points, tolerance);
-  flattenQuadratic(x123, y123, x23, y23, x2, y2, points, tolerance);
-}
-function flattenCubic(x1, y1, c1x, c1y, c2x, c2y, x2, y2, points, tolerance) {
-  const dx = x2 - x1;
-  const dy = y2 - y1;
-  const d1 = Math.abs(dy * c1x - dx * c1y + x2 * y1 - y2 * x1);
-  const d2 = Math.abs(dy * c2x - dx * c2y + x2 * y1 - y2 * x1);
-  const len = Math.sqrt(dx * dx + dy * dy);
-  if (len > 0 && (d1 + d2) / len <= tolerance) {
-    points.push(x2, y2);
-    return;
-  }
-  const x12 = (x1 + c1x) / 2;
-  const y12 = (y1 + c1y) / 2;
-  const x23 = (c1x + c2x) / 2;
-  const y23 = (c1y + c2y) / 2;
-  const x34 = (c2x + x2) / 2;
-  const y34 = (c2y + y2) / 2;
-  const x123 = (x12 + x23) / 2;
-  const y123 = (y12 + y23) / 2;
-  const x234 = (x23 + x34) / 2;
-  const y234 = (y23 + y34) / 2;
-  const x1234 = (x123 + x234) / 2;
-  const y1234 = (y123 + y234) / 2;
-  flattenCubic(x1, y1, x12, y12, x123, y123, x1234, y1234, points, tolerance);
-  flattenCubic(x1234, y1234, x234, y234, x34, y34, x2, y2, points, tolerance);
-}
-function flattenPaths(paths, tolerance = DEFAULT_TOLERANCE) {
-  const result = [];
-  for (const path of paths) {
-    if (!path.points || path.points.length === 0) continue;
-    const flatPoints = [];
-    flatPoints.push(path.points[0].x, path.points[0].y);
-    for (let i = 1; i < path.points.length; i++) {
-      const prev = path.points[i - 1];
-      const curr = path.points[i];
-      if (prev.handleOut && curr.handleIn) {
-        flattenCubic(
-          prev.x,
-          prev.y,
-          prev.handleOut.x,
-          prev.handleOut.y,
-          curr.handleIn.x,
-          curr.handleIn.y,
-          curr.x,
-          curr.y,
-          flatPoints,
-          tolerance
-        );
-      } else if (prev.handleOut) {
-        flattenQuadratic(
-          prev.x,
-          prev.y,
-          prev.handleOut.x,
-          prev.handleOut.y,
-          curr.x,
-          curr.y,
-          flatPoints,
-          tolerance
-        );
-      } else if (curr.handleIn) {
-        flattenQuadratic(
-          prev.x,
-          prev.y,
-          curr.handleIn.x,
-          curr.handleIn.y,
-          curr.x,
-          curr.y,
-          flatPoints,
-          tolerance
-        );
-      } else {
-        flatPoints.push(curr.x, curr.y);
-      }
-    }
-    if (path.closed && path.points.length > 1) {
-      const curr = path.points[0];
-      const prev = path.points[path.points.length - 1];
-      if (prev.handleOut && curr.handleIn) {
-        flattenCubic(
-          prev.x,
-          prev.y,
-          prev.handleOut.x,
-          prev.handleOut.y,
-          curr.handleIn.x,
-          curr.handleIn.y,
-          curr.x,
-          curr.y,
-          flatPoints,
-          tolerance
-        );
-      } else if (prev.handleOut) {
-        flattenQuadratic(
-          prev.x,
-          prev.y,
-          prev.handleOut.x,
-          prev.handleOut.y,
-          curr.x,
-          curr.y,
-          flatPoints,
-          tolerance
-        );
-      } else if (curr.handleIn) {
-        flattenQuadratic(
-          prev.x,
-          prev.y,
-          curr.handleIn.x,
-          curr.handleIn.y,
-          curr.x,
-          curr.y,
-          flatPoints,
-          tolerance
-        );
-      } else {
-        flatPoints.push(curr.x, curr.y);
-      }
-    }
-    result.push(flatPoints);
-  }
-  return result;
-}
-var DEFAULT_TOLERANCE;
-var init_flatten = __esm({
-  "lib/engine/geometry/flatten.ts"() {
-    "use strict";
-    init_define_POPCRAFT_COMPONENT_IDS();
-    DEFAULT_TOLERANCE = 0.25;
-  }
-});
-
-// lib/engine/text/glyph-linear.ts
-function glyphLinear(g) {
-  if (g.xform) return g.xform;
-  if (!g.angle) return null;
-  const c = Math.cos(g.angle), s = Math.sin(g.angle);
-  return [c, s, -s, c];
-}
-var init_glyph_linear = __esm({
-  "lib/engine/text/glyph-linear.ts"() {
-    "use strict";
-    init_define_POPCRAFT_COMPONENT_IDS();
-  }
-});
-
-// lib/engine/text/outline-sdf.ts
-function flattenPath(commands, t, line, tolerance = FLATTEN_TOLERANCE) {
-  const X = (x) => t.sx * x + t.tx;
-  const Y = (y) => t.sy * y + t.ty;
-  let sx = 0, sy = 0, cx = 0, cy = 0, open = false;
-  const close = () => {
-    if (open && (cx !== sx || cy !== sy)) line(cx, cy, sx, sy);
-    cx = sx;
-    cy = sy;
-    open = false;
-  };
-  for (const c of commands) {
-    const a = c.args;
-    switch (c.command) {
-      case "moveTo":
-        close();
-        sx = cx = X(a[0]);
-        sy = cy = Y(a[1]);
-        break;
-      case "lineTo": {
-        const x = X(a[0]), y = Y(a[1]);
-        line(cx, cy, x, y);
-        cx = x;
-        cy = y;
-        open = true;
-        break;
-      }
-      case "quadraticCurveTo": {
-        const x1 = X(a[0]), y1 = Y(a[1]), x2 = X(a[2]), y2 = Y(a[3]);
-        const dd = Math.hypot(cx - 2 * x1 + x2, cy - 2 * y1 + y2);
-        const n = Math.min(256, Math.max(1, Math.ceil(Math.sqrt(dd / (4 * tolerance)))));
-        let px = cx, py = cy;
-        for (let i = 1; i <= n; i++) {
-          const u = i / n, v = 1 - u;
-          const x = v * v * cx + 2 * u * v * x1 + u * u * x2;
-          const y = v * v * cy + 2 * u * v * y1 + u * u * y2;
-          line(px, py, x, y);
-          px = x;
-          py = y;
-        }
-        cx = x2;
-        cy = y2;
-        open = true;
-        break;
-      }
-      case "bezierCurveTo": {
-        const x1 = X(a[0]), y1 = Y(a[1]), x2 = X(a[2]), y2 = Y(a[3]), x3 = X(a[4]), y3 = Y(a[5]);
-        const dd = Math.max(Math.hypot(cx - 2 * x1 + x2, cy - 2 * y1 + y2), Math.hypot(x1 - 2 * x2 + x3, y1 - 2 * y2 + y3));
-        const n = Math.min(256, Math.max(1, Math.ceil(Math.sqrt(0.75 * dd / tolerance))));
-        let px = cx, py = cy;
-        for (let i = 1; i <= n; i++) {
-          const u = i / n, v = 1 - u;
-          const b0 = v * v * v, b1 = 3 * u * v * v, b2 = 3 * u * u * v, b3 = u * u * u;
-          const x = b0 * cx + b1 * x1 + b2 * x2 + b3 * x3;
-          const y = b0 * cy + b1 * y1 + b2 * y2 + b3 * y3;
-          line(px, py, x, y);
-          px = x;
-          py = y;
-        }
-        cx = x3;
-        cy = y3;
-        open = true;
-        break;
-      }
-      case "closePath":
-        close();
-        break;
-    }
-  }
-  close();
-}
-var FLATTEN_TOLERANCE;
-var init_outline_sdf = __esm({
-  "lib/engine/text/outline-sdf.ts"() {
-    "use strict";
-    init_define_POPCRAFT_COMPONENT_IDS();
-    FLATTEN_TOLERANCE = 5e-3;
-  }
-});
-
-// lib/engine/text/text-rings.ts
-function glyphTransform(g) {
-  const s = g.unitScale ?? 0;
-  return { sx: s, sy: -s, tx: g.penX ?? g.x, ty: g.baseline ?? g.y };
-}
-function glyphOutline(g) {
-  if (g.gid === void 0 || !g.font || !g.unitScale) return null;
-  let glyph;
-  try {
-    glyph = g.font.getGlyph(g.gid);
-  } catch {
-    return null;
-  }
-  const commands = glyph?.path?.commands;
-  if (!commands?.length) return null;
-  const t = glyphTransform(g);
-  const turn = glyphTurn(g);
-  return { commands, place: (x, y) => turn(t.sx * x + t.tx, t.sy * y + t.ty) };
-}
-function glyphTurn(g) {
-  const t = glyphTransform(g);
-  const m = glyphLinear(g);
-  return (x, y) => m ? [t.tx + (x - t.tx) * m[0] + (y - t.ty) * m[2], t.ty + (x - t.tx) * m[1] + (y - t.ty) * m[3]] : [x, y];
-}
-function glyphInstancesToRings(instances) {
-  const rings = [];
-  for (const g of instances) {
-    if (g.gid === void 0 || !g.font || !g.unitScale) continue;
-    let glyph;
-    try {
-      glyph = g.font.getGlyph(g.gid);
-    } catch {
-      continue;
-    }
-    const commands = glyph?.path?.commands;
-    if (!commands?.length) continue;
-    let current = [];
-    const push = () => {
-      if (current.length >= 3) rings.push(closeRing(current));
-      current = [];
-    };
-    const t = glyphTransform(g);
-    const turn = glyphTurn(g);
-    flattenPath(commands, t, (x0, y0, x1, y1) => {
-      const [ax, ay] = turn(x0, y0), [bx, by] = turn(x1, y1);
-      const last = current[current.length - 1];
-      if (!last || last[0] !== ax || last[1] !== ay) {
-        push();
-        current.push([ax, ay]);
-      }
-      current.push([bx, by]);
-    });
-    push();
-  }
-  return rings;
-}
-function closeRing(r) {
-  const a = r[0];
-  const b = r[r.length - 1];
-  return a[0] === b[0] && a[1] === b[1] ? r : [...r, [a[0], a[1]]];
-}
-var init_text_rings = __esm({
-  "lib/engine/text/text-rings.ts"() {
-    "use strict";
-    init_define_POPCRAFT_COMPONENT_IDS();
-    init_glyph_linear();
-    init_outline_sdf();
-  }
-});
-
-// lib/engine/geometry/shape-outline.ts
-function shapeToRings(node, ox, oy) {
-  const w = node.width;
-  const h = node.height;
-  const cx = ox + w / 2;
-  const cy = oy + h / 2;
-  const rot = (node.rotation || 0) * Math.PI / 180;
-  const cosR = Math.cos(rot);
-  const sinR = Math.sin(rot);
-  const place2 = (lx, ly) => {
-    const dx = ox + lx - cx;
-    const dy = oy + ly - cy;
-    return [cx + dx * cosR - dy * sinR, cy + dx * sinR + dy * cosR];
-  };
-  const closeRing2 = (r) => {
-    if (r.length && (r[0][0] !== r[r.length - 1][0] || r[0][1] !== r[r.length - 1][1])) r.push([r[0][0], r[0][1]]);
-    return r;
-  };
-  switch (node.type) {
-    case "ELLIPSE": {
-      const rx = w / 2, ry = h / 2;
-      const ring = [];
-      for (let i = 0; i < ELLIPSE_SEGMENTS; i++) {
-        const a = i / ELLIPSE_SEGMENTS * Math.PI * 2;
-        ring.push(place2(w / 2 + rx * Math.cos(a), h / 2 + ry * Math.sin(a)));
-      }
-      return [closeRing2(ring)];
-    }
-    case "POLYGON": {
-      const n = Math.max(3, node.pointCount || 3);
-      const rx = w / 2, ry = h / 2;
-      const ring = [];
-      for (let i = 0; i < n; i++) {
-        const a = -Math.PI / 2 + i / n * Math.PI * 2;
-        ring.push(place2(w / 2 + rx * Math.cos(a), h / 2 + ry * Math.sin(a)));
-      }
-      return [closeRing2(ring)];
-    }
-    case "STAR": {
-      const n = Math.max(3, node.pointCount || 5);
-      const inner = node.innerRadius ?? 0.4;
-      const rx = w / 2, ry = h / 2;
-      const ring = [];
-      for (let i = 0; i < n * 2; i++) {
-        const a = -Math.PI / 2 + i / (n * 2) * Math.PI * 2;
-        const f = i % 2 === 0 ? 1 : inner;
-        ring.push(place2(w / 2 + rx * f * Math.cos(a), h / 2 + ry * f * Math.sin(a)));
-      }
-      return [closeRing2(ring)];
-    }
-    case "VECTOR": {
-      const paths = node.paths;
-      if (!paths || paths.length === 0) return [];
-      const flat = flattenPaths(paths);
-      return flat.filter((p) => p.length >= 6).map((p) => {
-        const ring = [];
-        for (let i = 0; i < p.length; i += 2) ring.push(place2(p[i], p[i + 1]));
-        return closeRing2(ring);
-      });
-    }
-    case "TEXT": {
-      const layout = readCachedTextLayout(node.id);
-      if (!layout) return [];
-      return glyphInstancesToRings(layout.instances).map((ring) => ring.map(([lx, ly]) => place2(lx, ly)));
-    }
-    case "LINE":
-    case "ARROW":
-      return [];
-    // no fillable area
-    default: {
-      return [closeRing2([place2(0, 0), place2(w, 0), place2(w, h), place2(0, h)])];
-    }
-  }
-}
-function tableCellGeom(table) {
-  const colCount = table.colCount || 5, rowCount = table.rowCount || 5;
-  const colWidths = table.colWidths && table.colWidths.length ? table.colWidths : Array(colCount).fill(140);
-  const rowHeights = table.rowHeights && table.rowHeights.length ? table.rowHeights : Array(rowCount).fill(32);
-  return { colWidths, rowHeights };
-}
-function tableCellRect(table, r, c) {
-  const { colWidths, rowHeights } = tableCellGeom(table);
-  let x = 0;
-  for (let i = 0; i < c; i++) x += colWidths[i] || 140;
-  let y = 0;
-  for (let i = 0; i < r; i++) y += rowHeights[i] || 32;
-  return { x, y, w: colWidths[c] || 140, h: rowHeights[r] || 32 };
-}
-function tableCellAnchor(table, r, c, edge) {
-  const rc = tableCellRect(table, r, c);
-  switch (edge) {
-    case "TOP":
-      return { x: rc.x + rc.w / 2, y: rc.y };
-    case "BOTTOM":
-      return { x: rc.x + rc.w / 2, y: rc.y + rc.h };
-    case "LEFT":
-      return { x: rc.x, y: rc.y + rc.h / 2 };
-    case "RIGHT":
-      return { x: rc.x + rc.w, y: rc.y + rc.h / 2 };
-    default:
-      return { x: rc.x + rc.w / 2, y: rc.y + rc.h / 2 };
-  }
-}
-function getConnectorAnchorLocal(node, position) {
-  const w = node.width || 1;
-  const h = node.height || 1;
-  if (node.type === "TABLE") {
-    const m = /^(\d+),(\d+):(TOP|BOTTOM|LEFT|RIGHT)$/.exec(position);
-    if (m) return tableCellAnchor(node, +m[1], +m[2], m[3]);
-  }
-  const bbox = {
-    TOP: { x: w / 2, y: 0 },
-    BOTTOM: { x: w / 2, y: h },
-    LEFT: { x: 0, y: h / 2 },
-    RIGHT: { x: w, y: h / 2 },
-    CENTER: { x: w / 2, y: h / 2 }
-  };
-  const pos = position in bbox ? position : "CENTER";
-  if (pos === "CENTER") return bbox.CENTER;
-  const boxy = /* @__PURE__ */ new Set([
-    "RECTANGLE",
-    "FRAME",
-    "IMAGE",
-    "TEXT",
-    "STICKY",
-    "GROUP",
-    "SECTION",
-    "COMPONENT",
-    "COMPONENT_SET",
-    "INSTANCE",
-    "TABLE",
-    "SLICE"
-  ]);
-  if (boxy.has(node.type)) return bbox[pos];
-  const key = `${node.id}:${Math.round(w)}x${Math.round(h)}:${node.type}`;
-  let anchors = _anchorCache.get(key);
-  if (!anchors) {
-    anchors = { ...bbox };
-    let rings = [];
-    try {
-      rings = shapeToRings({ ...node, rotation: 0 }, 0, 0);
-    } catch {
-      rings = [];
-    }
-    if (rings.length) {
-      const yc = h / 2;
-      let minX = Infinity, maxX = -Infinity;
-      const xc = w / 2;
-      let minY = Infinity, maxY = -Infinity;
-      for (const ring of rings) {
-        for (let i = 1; i < ring.length; i++) {
-          const [x1, y1] = ring[i - 1], [x2, y2] = ring[i];
-          if (y1 <= yc && y2 >= yc || y2 <= yc && y1 >= yc) {
-            if (y1 !== y2) {
-              const t = (yc - y1) / (y2 - y1);
-              const x = x1 + t * (x2 - x1);
-              if (x < minX) minX = x;
-              if (x > maxX) maxX = x;
-            }
-          }
-          if (x1 <= xc && x2 >= xc || x2 <= xc && x1 >= xc) {
-            if (x1 !== x2) {
-              const t = (xc - x1) / (x2 - x1);
-              const y = y1 + t * (y2 - y1);
-              if (y < minY) minY = y;
-              if (y > maxY) maxY = y;
-            }
-          }
-        }
-      }
-      if (minX !== Infinity) {
-        anchors.LEFT = { x: minX, y: yc };
-        anchors.RIGHT = { x: maxX, y: yc };
-      }
-      if (minY !== Infinity) {
-        anchors.TOP = { x: xc, y: minY };
-        anchors.BOTTOM = { x: xc, y: maxY };
-      }
-    }
-    if (_anchorCache.size > 512) _anchorCache.clear();
-    _anchorCache.set(key, anchors);
-  }
-  return anchors[pos];
-}
-function connectorPositionDir(position) {
-  const m = /(TOP|BOTTOM|LEFT|RIGHT|CENTER)$/.exec(position || "");
-  return m ? m[1] : "CENTER";
-}
-var ELLIPSE_SEGMENTS, _anchorCache;
-var init_shape_outline = __esm({
-  "lib/engine/geometry/shape-outline.ts"() {
-    "use strict";
-    init_define_POPCRAFT_COMPONENT_IDS();
-    init_flatten();
-    init_layout_access();
-    init_text_rings();
-    ELLIPSE_SEGMENTS = 64;
-    _anchorCache = /* @__PURE__ */ new Map();
-  }
-});
-
-// lib/document/scene-graph.ts
-function virtualRootOf(host, doc) {
-  if (!host) return void 0;
-  if (host.type === "INSTANCE") return host.mainComponentId || void 0;
-  if (host.type === "FRAME") {
-    const frame = host;
-    if (doc) {
-      const { effectiveMasterId: effectiveMasterId2 } = (init_print_pages(), __toCommonJS(print_pages_exports));
-      return effectiveMasterId2(doc, frame);
-    }
-    return frame.print?.masterId;
-  }
-  return void 0;
-}
-function virtualChildId(parent, childId) {
-  if (parent.type === "INSTANCE" || parent.type === "FRAME" && parent.print?.masterId && !parent.id.includes("::")) return `${parent.id}::${childId}`;
-  if (parent.id.includes("::")) return `${parent.id.split("::").slice(0, -1).join("::")}::${childId}`;
-  return childId;
-}
-function chainOverrides(nodes, parts) {
-  let merged = {};
-  for (let k = 0; k < parts.length - 1; k++) {
-    const raw = nodes[parts[k]];
-    if (!raw) break;
-    const node = k === 0 ? raw : { ...raw, ...merged[raw.id] };
-    if (node.type === "INSTANCE") merged = { ...node.overrides || {}, ...merged };
-  }
-  return merged;
-}
-function resolveVirtualNode(nodes, id, opts) {
-  if (!id) return null;
-  if (!id.includes("::")) return nodes[id] || null;
-  const posed = nodes[id];
-  if (posed) return posed;
-  const parts = id.split("::");
-  const instanceId = parts[0];
-  const targetId = parts[parts.length - 1];
-  const instance = nodes[instanceId];
-  const target = nodes[targetId];
-  const rootId = virtualRootOf(instance);
-  if (!instance || !rootId || !target) return null;
-  const overrides = instance.type === "INSTANCE" ? chainOverrides(nodes, parts)[targetId] || {} : {};
-  let parentId;
-  if (parts.length === 2) {
-    parentId = target.parentId === rootId ? instanceId : `${instanceId}::${target.parentId}`;
-  } else {
-    const ownerId = parts.slice(0, -1).join("::");
-    const owner = resolveVirtualNode(nodes, ownerId, opts);
-    const ownerRoot = virtualRootOf(owner ?? void 0);
-    parentId = target.parentId === ownerRoot ? ownerId : `${ownerId}::${target.parentId}`;
-  }
-  const resolved = { ...target, ...overrides, id, parentId };
-  const refs = resolved.componentPropertyReferences;
-  let props = null;
-  if (refs?.characters || refs?.visible) {
-    props = effectiveComponentProperties(nodes, parts);
-    if (refs.characters && typeof props[refs.characters] === "string") resolved.characters = props[refs.characters];
-    if (refs.visible && typeof props[refs.visible] === "boolean") resolved.visible = props[refs.visible];
-  }
-  if (resolved.componentPropertyPaths || resolved.motion?.tracks) {
-    const shown = withPropertyPaths(resolved, props ?? effectiveComponentProperties(nodes, parts));
-    if (shown !== resolved) Object.assign(resolved, shown);
-  }
-  if (resolved.type === "INSTANCE" && instance.type === "INSTANCE") {
-    const ref = resolved.componentPropertyReferences?.mainComponent;
-    const v = ref ? instance.componentProperties?.[ref] : void 0;
-    if (typeof v === "string" && nodes[v]) resolved.mainComponentId = v;
-  }
-  if (opts?.layout !== false) {
-    const box = instanceChildBox(nodes, id);
-    if (box) {
-      resolved.x = box.x;
-      resolved.y = box.y;
-      resolved.width = box.width;
-      resolved.height = box.height;
-    }
-  }
-  return resolved;
-}
-function createDocument(name = "Untitled", settings) {
-  const pageId = v4_default();
-  const page = {
-    id: pageId,
-    name: "Page 1",
-    type: "PAGE",
-    x: 0,
-    y: 0,
-    width: 0,
-    height: 0,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    backgroundColor: createColor(0.12, 0.12, 0.13)
-  };
-  return {
-    id: v4_default(),
-    name,
-    pages: [pageId],
-    nodes: {
-      [pageId]: page
-    },
-    ...settings ? { settings } : {}
-  };
-}
-function createPage(name = "New Page") {
-  return {
-    id: v4_default(),
-    name,
-    type: "PAGE",
-    x: 0,
-    y: 0,
-    width: 0,
-    height: 0,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    backgroundColor: createColor(0.12, 0.12, 0.13)
-  };
-}
-function createRectangle(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Rectangle",
-    type: "RECTANGLE",
-    x: 0,
-    y: 0,
-    width: 100,
-    height: 100,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    ...props
-  };
-}
-function createEllipse(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Ellipse",
-    type: "ELLIPSE",
-    x: 0,
-    y: 0,
-    width: 100,
-    height: 100,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    ...props
-  };
-}
-function createSticky(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Sticky Note",
-    type: "STICKY",
-    x: 0,
-    y: 0,
-    width: 200,
-    height: 200,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    text: "",
-    authorName: "Unknown",
-    ...createDefaultSceneNodeProps(),
-    fills: [createSolidPaint(createColor(1, 0.9, 0.4, 1))],
-    // Default yellow sticky color
-    ...props
-  };
-}
-function createLine(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Line",
-    type: "LINE",
-    x: 0,
-    y: 0,
-    width: 100,
-    height: 0,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    fills: [],
-    // Lines typically have no fill
-    strokes: [{
-      color: createColor(0, 0, 0),
-      width: 2,
-      alignment: "CENTER",
-      cap: "ROUND",
-      join: "ROUND",
-      dashPattern: []
-    }],
-    startPoint: { x: 0, y: 0 },
-    endPoint: { x: 100, y: 0 },
-    ...props
-  };
-}
-function createArrow(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Arrow",
-    type: "ARROW",
-    x: 0,
-    y: 0,
-    width: 100,
-    height: 0,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    fills: [],
-    strokes: [{
-      color: createColor(0, 0, 0),
-      width: 2,
-      alignment: "CENTER",
-      cap: "ROUND",
-      join: "ROUND",
-      dashPattern: []
-    }],
-    startPoint: { x: 0, y: 0 },
-    endPoint: { x: 100, y: 0 },
-    startArrowhead: "NONE",
-    endArrowhead: "ARROW",
-    ...props
-  };
-}
-function createPolygon(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Polygon",
-    type: "POLYGON",
-    x: 0,
-    y: 0,
-    width: 100,
-    height: 100,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    pointCount: 3,
-    // triangle by default
-    ...props
-  };
-}
-function createStar(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Star",
-    type: "STAR",
-    x: 0,
-    y: 0,
-    width: 100,
-    height: 100,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    pointCount: 5,
-    innerRadius: 0.4,
-    ...props
-  };
-}
-function createSection(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Section",
-    type: "SECTION",
-    x: 0,
-    y: 0,
-    width: 400,
-    height: 300,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    backgroundColor: createColor(0.2, 0.2, 0.22),
-    ...props
-  };
-}
-function createSlice(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Slice",
-    type: "SLICE",
-    x: 0,
-    y: 0,
-    width: 100,
-    height: 100,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    exportSettings: [{
-      format: "PNG",
-      suffix: "",
-      scale: 1,
-      constraint: { type: "SCALE", value: 1 }
-    }],
-    ...props
-  };
-}
-function createFrame(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Frame",
-    type: "FRAME",
-    x: 0,
-    y: 0,
-    width: 375,
-    height: 667,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    fills: [createSolidPaint(createColor(1, 1, 1))],
-    clipsContent: true,
-    backgroundColor: createColor(1, 1, 1),
-    layoutMode: "NONE",
-    primaryAxisAlignItems: "MIN",
-    counterAxisAlignItems: "MIN",
-    padding: { top: 0, right: 0, bottom: 0, left: 0 },
-    itemSpacing: 0,
-    interactions: [],
-    overflowScrolling: "NONE",
-    isFlowStartingPoint: false,
-    ...props
-  };
-}
-function createText(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Text",
-    type: "TEXT",
-    x: 0,
-    y: 0,
-    width: 200,
-    height: 48,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    fills: [createSolidPaint(createColor(0, 0, 0))],
-    characters: "",
-    // New text starts at 40 (its box: one auto line, ~1.2× the size).
-    fontSize: 40,
-    fontFamily: "Inter",
-    fontWeight: 400,
-    fontStyle: "normal",
-    textAlign: "LEFT",
-    verticalAlign: "TOP",
-    lineHeight: "AUTO",
-    letterSpacing: 0,
-    paragraphSpacing: 0,
-    paragraphIndent: 0,
-    textDecoration: "NONE",
-    textCase: "ORIGINAL",
-    textAutoResize: "WIDTH_AND_HEIGHT",
-    interactions: [],
-    ...props
-  };
-}
-function createGroup(childIds = []) {
-  return {
-    id: v4_default(),
-    name: "Group",
-    type: "GROUP",
-    x: 0,
-    y: 0,
-    width: 0,
-    height: 0,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds
-  };
-}
-function createVector(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Vector",
-    type: "VECTOR",
-    x: 0,
-    y: 0,
-    width: 100,
-    height: 100,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    paths: [],
-    fillRule: "NONZERO",
-    ...props
-  };
-}
-function createBoolean(operation, childIds = [], props = {}) {
-  return {
-    id: v4_default(),
-    name: `Boolean (${operation.toLowerCase()})`,
-    type: "BOOLEAN",
-    x: 0,
-    y: 0,
-    width: 100,
-    height: 100,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds,
-    ...createDefaultSceneNodeProps(),
-    booleanOperation: operation,
-    // Children are stored relative to this node, like a group's. The marker exists so the one-time
-    // migration in the store can tell an already-converted boolean from one written before the change.
-    booleanChildSpace: "LOCAL",
-    paths: [],
-    fillRule: "NONZERO",
-    ...props
-  };
-}
-function createPixelGrid(props = {}) {
-  const cell = props.cellSize ?? 10;
-  const pw = Math.max(1, Math.min(2048, Math.round(props.pixelWidth ?? (props.width ? props.width / cell : 32))));
-  const ph = Math.max(1, Math.min(2048, Math.round(props.pixelHeight ?? (props.height ? props.height / cell : 32))));
-  const { cellSize: _c, width: _w, height: _h, ...rest } = props;
-  return {
-    id: v4_default(),
-    name: "Pixel canvas",
-    type: "PIXEL_GRID",
-    x: 0,
-    y: 0,
-    width: pw * cell,
-    height: ph * cell,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    fills: [],
-    strokes: [],
-    pixelWidth: pw,
-    pixelHeight: ph,
-    colorMode: "RGBA",
-    palette: presetPalette("PICO-8"),
-    transparentIndex: 0,
-    frames: [{ id: v4_default(), cels: encodeCels(new Uint32Array(pw * ph)), duration: 100 }],
-    activeFrame: 0,
-    tags: [],
-    onionSkin: { enabled: false, prev: 1, next: 1, opacity: 0.35 },
-    tiledMode: "NONE",
-    ...rest
-  };
-}
-function createImage(imageUrl, props = {}) {
-  return {
-    id: v4_default(),
-    name: "Image",
-    type: "IMAGE",
-    x: 0,
-    y: 0,
-    width: 200,
-    height: 200,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    // Image nodes draw their imageUrl; a (default grey) fill would be drawn over it instead.
-    fills: [],
-    imageUrl,
-    scaleMode: "FILL",
-    ...props
-  };
-}
-function createRaster(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Paint layer",
-    type: "RASTER",
-    x: 0,
-    y: 0,
-    width: 1024,
-    height: 768,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    fills: [],
-    strokes: [],
-    pixelWidth: 1024,
-    pixelHeight: 768,
-    rasterTiles: {},
-    ...props
-  };
-}
-function createComponent(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Component",
-    type: "COMPONENT",
-    x: 0,
-    y: 0,
-    width: 100,
-    height: 100,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    componentPropertyDefinitions: {},
-    ...createDefaultSceneNodeProps(),
-    ...props
-  };
-}
-function createComponentSet(props = {}) {
-  return {
-    id: v4_default(),
-    name: "Component Set",
-    type: "COMPONENT_SET",
-    x: 0,
-    y: 0,
-    width: 200,
-    height: 200,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    componentPropertyDefinitions: {},
-    ...createDefaultSceneNodeProps(),
-    ...props
-  };
-}
-function createInstance(mainComponentId, props = {}) {
-  return {
-    id: v4_default(),
-    name: "Instance",
-    type: "INSTANCE",
-    x: 0,
-    y: 0,
-    width: 100,
-    height: 100,
-    rotation: 0,
-    opacity: 1,
-    visible: true,
-    locked: false,
-    parentId: null,
-    childIds: [],
-    ...createDefaultSceneNodeProps(),
-    mainComponentId,
-    overrides: {},
-    componentProperties: {},
-    ...props
-  };
-}
-function createInstanceOf(main, props = {}) {
-  const m = main;
-  return createInstance(main.id, {
-    name: main.name,
-    width: main.width,
-    height: main.height,
-    fills: m.fills ?? [],
-    strokes: m.strokes ?? [],
-    effects: m.effects ?? [],
-    cornerRadius: m.cornerRadius ?? 0,
-    ...props
-  });
-}
-function addNode(document, node, parentId) {
-  const parent = document.nodes[parentId];
-  if (!parent) {
-    console.error("Parent node not found:", parentId);
-    return document;
-  }
-  const updatedParent = {
-    ...parent,
-    childIds: [...parent.childIds, node.id]
-  };
-  const updatedNode = {
-    ...node,
-    parentId
-  };
-  return {
-    ...document,
-    nodes: {
-      ...document.nodes,
-      [parentId]: updatedParent,
-      [node.id]: updatedNode
-    }
-  };
-}
-function removeNode(document, nodeId) {
-  const node = document.nodes[nodeId];
-  if (!node) return document;
-  const newNodes = { ...document.nodes };
-  if (node.parentId) {
-    const parent = newNodes[node.parentId];
-    if (parent) {
-      newNodes[node.parentId] = {
-        ...parent,
-        childIds: parent.childIds.filter((id) => id !== nodeId)
-      };
-    }
-  }
-  function removeRecursive(id) {
-    const n = newNodes[id];
-    if (n && n.childIds) {
-      n.childIds.forEach(removeRecursive);
-    }
-    delete newNodes[id];
-  }
-  removeRecursive(nodeId);
-  return {
-    ...document,
-    nodes: newNodes
-  };
-}
-function updateNode(document, nodeId, updates) {
-  const node = document.nodes[nodeId];
-  if (!node) return document;
-  return {
-    ...document,
-    nodes: {
-      ...document.nodes,
-      [nodeId]: { ...node, ...updates }
-    }
-  };
-}
-function getDescendants(document, nodeId) {
-  const result = [];
-  const node = document.nodes[nodeId];
-  if (!node) return result;
-  function collectChildren(id) {
-    const n = document.nodes[id];
-    if (n) {
-      result.push(n);
-      n.childIds.forEach(collectChildren);
-    }
-  }
-  node.childIds.forEach(collectChildren);
-  return result;
-}
-function getAncestors(document, nodeId) {
-  const ancestors = [];
-  const node = document.nodes[nodeId];
-  if (!node) return ancestors;
-  let current = node;
-  while (current.parentId) {
-    const parent = document.nodes[current.parentId];
-    if (parent) {
-      ancestors.push(parent);
-      current = parent;
-    } else {
-      break;
-    }
-  }
-  return ancestors;
-}
-function applyConstraints(document, parentId, oldW, oldH, newW, newH) {
-  const parent = document.nodes[parentId];
-  if (!parent || !parent.childIds || parent.childIds.length === 0) return document;
-  if (oldW === 0 || oldH === 0) return document;
-  if (oldW === newW && oldH === newH) return document;
-  if (parent.layoutMode && parent.layoutMode !== "NONE") {
-    return document;
-  }
-  let newDoc = { ...document, nodes: { ...document.nodes } };
-  const deltaW = newW - oldW;
-  const deltaH = newH - oldH;
-  const scaleX = newW / oldW;
-  const scaleY = newH / oldH;
-  for (const childId of parent.childIds) {
-    const child = newDoc.nodes[childId];
-    if (!child) continue;
-    const hConstraint = child.constraints?.horizontal || "MIN";
-    const vConstraint = child.constraints?.vertical || "MIN";
-    let newX = child.x;
-    let newChildW = child.width;
-    let newY = child.y;
-    let newChildH = child.height;
-    switch (hConstraint) {
-      case "MIN":
-        break;
-      case "MAX":
-        newX += deltaW;
-        break;
-      case "CENTER":
-        newX += deltaW / 2;
-        break;
-      case "STRETCH":
-        newChildW = Math.max(1, newChildW + deltaW);
-        break;
-      case "SCALE":
-        newX *= scaleX;
-        newChildW = Math.max(1, newChildW * scaleX);
-        break;
-    }
-    switch (vConstraint) {
-      case "MIN":
-        break;
-      case "MAX":
-        newY += deltaH;
-        break;
-      case "CENTER":
-        newY += deltaH / 2;
-        break;
-      case "STRETCH":
-        newChildH = Math.max(1, newChildH + deltaH);
-        break;
-      case "SCALE":
-        newY *= scaleY;
-        newChildH = Math.max(1, newChildH * scaleY);
-        break;
-    }
-    if (newX !== child.x || newY !== child.y || newChildW !== child.width || newChildH !== child.height) {
-      newDoc.nodes[childId] = {
-        ...child,
-        x: newX,
-        y: newY,
-        width: newChildW,
-        height: newChildH
-      };
-      if (newChildW !== child.width || newChildH !== child.height) {
-        if ("childIds" in child && child.childIds && child.childIds.length > 0) {
-          newDoc = applyConstraints(newDoc, childId, child.width, child.height, newChildW, newChildH);
-        }
-      }
-    }
-  }
-  return newDoc;
-}
-function getRenderableNodes(document, pageId) {
-  const result = [];
-  function collectNodes(nodeId) {
-    const node = document.nodes[nodeId];
-    if (!node || !node.visible) return;
-    if (node.type !== "PAGE") {
-      result.push(node);
-    }
-    if (node.type === "PAGE") {
-      node.childIds.forEach(collectNodes);
-    }
-  }
-  collectNodes(pageId);
-  return result;
-}
-function moveNodeInZOrder(document, nodeId, direction) {
-  const node = document.nodes[nodeId];
-  if (!node || !node.parentId) return document;
-  const parent = document.nodes[node.parentId];
-  if (!parent) return document;
-  const siblings = [...parent.childIds];
-  const currentIndex = siblings.indexOf(nodeId);
-  if (currentIndex === -1) return document;
-  siblings.splice(currentIndex, 1);
-  let newIndex;
-  switch (direction) {
-    case "up":
-      newIndex = Math.min(currentIndex + 1, siblings.length);
-      break;
-    case "down":
-      newIndex = Math.max(currentIndex - 1, 0);
-      break;
-    case "top":
-      newIndex = siblings.length;
-      break;
-    case "bottom":
-      newIndex = 0;
-      break;
-  }
-  siblings.splice(newIndex, 0, nodeId);
-  return {
-    ...document,
-    nodes: {
-      ...document.nodes,
-      [node.parentId]: { ...parent, childIds: siblings }
-    }
-  };
-}
-function uprightBounds(t, width, height) {
-  const hw = width / 2 * t.scaleX, hh = height / 2 * t.scaleY;
-  return { minX: t.cx - hw, minY: t.cy - hh, maxX: t.cx + hw, maxY: t.cy + hh };
-}
-function unmirroredMatrix(t, width, height) {
-  return withoutFlips(t.matrix, t.flipX, t.flipY, width, height);
-}
-function lineShaftEnds(t, width) {
-  const hw = width / 2 * t.scaleX;
-  const cos = Math.cos(t.rotationRad), sin = Math.sin(t.rotationRad);
-  return [{ x: t.cx - hw * cos, y: t.cy - hw * sin }, { x: t.cx + hw * cos, y: t.cy + hw * sin }];
-}
-function place(outer, node, scroll) {
-  const local = localMatrix(node, false, scroll?.x ?? 0, scroll?.y ?? 0);
-  const flips = nodeFlips(node);
-  return {
-    m: outer === ROOT ? local : multiply(outer.m, local),
-    flipX: outer.flipX !== flips.flipX,
-    flipY: outer.flipY !== flips.flipY,
-    angle: outer.sense * ((node.rotation || 0) * Math.PI / 180) + outer.angle,
-    sense: flips.flipX === flips.flipY ? outer.sense : -outer.sense,
-    conformal: outer.conformal && Math.abs(restValue(node, "scaleX")) === Math.abs(restValue(node, "scaleY"))
-  };
-}
-function decomposed(outer, node, p) {
-  const [lx, ly] = localCentre(node);
-  const [cx, cy] = outer === ROOT ? [lx, ly] : apply(outer.m, lx, ly);
-  const q = decompose(withoutFlips(p.m, p.flipX, p.flipY, node.width, node.height));
-  return { cx, cy, rotationRad: p.conformal ? p.angle : q.rotation, flipX: p.flipX, flipY: p.flipY, scaleX: q.scaleX, scaleY: q.scaleY, matrix: p.m };
-}
-function detachedTransform(node) {
-  return decomposed(ROOT, node, place(ROOT, node));
-}
-function rootPlacement(m, outer) {
-  const mirrored = determinant(m) < 0;
-  const q = decompose(m);
-  const uniform = Math.abs(Math.abs(q.scaleX) - Math.abs(q.scaleY)) < 1e-9 && Math.abs(q.skew) < 1e-9;
-  return {
-    m: outer === ROOT ? m : multiply(m, outer.m),
-    flipX: outer.flipX !== mirrored,
-    flipY: outer.flipY,
-    angle: outer.angle + q.rotation,
-    sense: mirrored ? -outer.sense : outer.sense,
-    conformal: outer.conformal && uniform
-  };
-}
-function createResolver(nodes, scrollState, roots) {
-  const placed = /* @__PURE__ */ new Map();
-  const frames = /* @__PURE__ */ new Map();
-  const transforms = /* @__PURE__ */ new Map();
-  const rootFrames = /* @__PURE__ */ new Map();
-  const outerOf = (node) => {
-    const m = roots?.get(node.id);
-    if (!m) return frameOf(node.parentId);
-    let p = rootFrames.get(node.id);
-    if (!p) {
-      p = rootPlacement(m, frameOf(node.parentId));
-      rootFrames.set(node.id, p);
-    }
-    return p;
-  };
-  const placementOf = (id) => {
-    const cached = placed.get(id);
-    if (cached !== void 0) return cached;
-    const node = resolveVirtualNode(nodes, id);
-    const hit = node ? { node, p: place(outerOf(node), node) } : null;
-    placed.set(id, hit);
-    return hit;
-  };
-  function frameOf(containerId) {
-    if (!containerId) return ROOT;
-    const cached = frames.get(containerId);
-    if (cached) return cached;
-    const c = placementOf(containerId);
-    let frame = ROOT;
-    if (c && c.node.type !== "PAGE") {
-      const scroll = scrollState?.[c.node.id];
-      frame = scroll ? place(outerOf(c.node), c.node, scroll) : c.p;
-    }
-    frames.set(containerId, frame);
-    return frame;
-  }
-  return {
-    matrixOf: (id) => placementOf(id)?.p.m ?? IDENTITY,
-    transformOf: (id) => {
-      const cached = transforms.get(id);
-      if (cached) return cached;
-      const hit = placementOf(id);
-      if (!hit) return ZERO_TRANSFORM;
-      const t = decomposed(outerOf(hit.node), hit.node, hit.p);
-      transforms.set(id, t);
-      return t;
-    }
-  };
-}
-function createWorldMatrixResolver(nodes, scrollState) {
-  return createResolver(nodes, scrollState).matrixOf;
-}
-function createWorldTransformResolver(nodes, scrollState, roots) {
-  return createResolver(nodes, scrollState, roots).transformOf;
-}
-function cachedResolver(nodes) {
-  let r = resolverCache.get(nodes);
-  if (!r) {
-    r = createResolver(nodes);
-    resolverCache.set(nodes, r);
-  }
-  return r;
-}
-function getWorldTransform(document, nodeId, scrollState) {
-  return (scrollState ? createResolver(document.nodes, scrollState) : cachedResolver(document.nodes)).transformOf(nodeId);
-}
-function getWorldMatrix(document, nodeId, scrollState) {
-  return (scrollState ? createResolver(document.nodes, scrollState) : cachedResolver(document.nodes)).matrixOf(nodeId);
-}
-function placementUnder(document, nodeId, newParentId) {
-  const node = resolveVirtualNode(document.nodes, nodeId);
-  if (!node) return null;
-  const parent = resolveVirtualNode(document.nodes, newParentId);
-  const inv = !parent || parent.type === "PAGE" ? IDENTITY : invert(getWorldMatrix(document, newParentId));
-  if (!inv) return null;
-  const local = multiply(inv, getWorldMatrix(document, nodeId));
-  let flipH = !!node.flipHorizontal;
-  const flipV = !!node.flipVertical;
-  let m = withoutFlips(local, flipH, flipV, 0, 0);
-  if (determinant(m) < 0) {
-    flipH = !flipH;
-    m = withoutFlips(m, true, false, 0, 0);
-  }
-  const q = decompose(m);
-  const w = node.width, h = node.height;
-  const ax = restValue(node, "anchorX"), ay = restValue(node, "anchorY");
-  const [px, py] = apply(local, ax * w, ay * h);
-  const scale = (key, v) => {
-    const next = Math.abs(v - 1) < 1e-9 ? void 0 : v;
-    return next === void 0 && node[key] === void 0 ? {} : { [key]: next };
-  };
-  return {
-    x: px - ax * w - restValue(node, "translateX"),
-    y: py - ay * h - restValue(node, "translateY"),
-    rotation: nearestAngle(q.rotation * 180 / Math.PI, node.rotation || 0),
-    ...scale("scaleX", q.scaleX),
-    ...scale("scaleY", q.scaleY),
-    ...flipH !== !!node.flipHorizontal ? { flipHorizontal: flipH } : {}
-  };
-}
-function componentsDrawnBy(document, rootId) {
-  const out = /* @__PURE__ */ new Set();
-  const stack = [rootId];
-  const seen = /* @__PURE__ */ new Set();
-  while (stack.length) {
-    const id = stack.pop();
-    if (seen.has(id)) continue;
-    seen.add(id);
-    const n = document.nodes[id];
-    if (!n) continue;
-    if (n.type === "INSTANCE" && n.mainComponentId) {
-      const main = n.mainComponentId;
-      out.add(main);
-      stack.push(main);
-    }
-    if ("childIds" in n && n.childIds) for (const c of n.childIds) stack.push(c);
-  }
-  return out;
-}
-function wouldCreateCycle(document, nodeId, newParentId) {
-  if (nodeId === newParentId) return true;
-  const chain = [document.nodes[newParentId], ...getAncestors(document, newParentId)].filter(Boolean);
-  if (chain.some((a) => a.id === nodeId)) return true;
-  const drawn = componentsDrawnBy(document, nodeId);
-  if (!drawn.size) return false;
-  const enclosing = new Set(chain.filter((a) => a.type === "COMPONENT" || a.type === "COMPONENT_SET").map((a) => a.id));
-  for (const c of drawn) if (enclosing.has(c)) return true;
-  for (const c of drawn) {
-    const comp = document.nodes[c];
-    if (!comp) continue;
-    for (const a of [comp, ...getAncestors(document, c)]) if (enclosing.has(a.id)) return true;
-  }
-  return false;
-}
-function wrapInComponent(document, ids, fallbackParentId, name = "Component") {
-  const nodes = ids.map((id) => resolveVirtualNode(document.nodes, id)).filter(Boolean);
-  if (!nodes.length) return null;
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const n of nodes) {
-    const b = uprightBounds(getWorldTransform(document, n.id), n.width, n.height);
-    minX = Math.min(minX, b.minX);
-    minY = Math.min(minY, b.minY);
-    maxX = Math.max(maxX, b.maxX);
-    maxY = Math.max(maxY, b.maxY);
-  }
-  const top = nodes.filter((n) => !n.parentId || !ids.includes(n.parentId));
-  const parentId = (top[0] || nodes[0]).parentId ?? fallbackParentId;
-  const parentNode = document.nodes[parentId];
-  let x = minX, y = minY;
-  if (parentNode && parentNode.type !== "PAGE") {
-    const pw = getWorldTransform(document, parentId);
-    x = minX - (pw.cx - parentNode.width / 2);
-    y = minY - (pw.cy - parentNode.height / 2);
-  }
-  const component = createComponent({ x, y, width: maxX - minX, height: maxY - minY, name, fills: [], componentPropertyDefinitions: {} });
-  let doc = addNode(document, component, parentId);
-  for (const id of ids) {
-    if (!doc.nodes[id]) continue;
-    const placed = placementUnder(doc, id, component.id);
-    if (placed) doc = updateNode(doc, id, placed);
-    doc = reparentNode(doc, id, component.id);
-  }
-  return { document: doc, componentId: component.id };
-}
-function reparentNode(document, nodeId, newParentId, index) {
-  const node = document.nodes[nodeId];
-  if (!node) return document;
-  const newParent = document.nodes[newParentId];
-  if (!newParent) return document;
-  if (wouldCreateCycle(document, nodeId, newParentId)) return document;
-  const newNodes = { ...document.nodes };
-  const updatedOldParentChildIds = node.parentId && newNodes[node.parentId] ? newNodes[node.parentId].childIds.filter((id) => id !== nodeId) : [];
-  if (node.parentId && newNodes[node.parentId]) {
-    newNodes[node.parentId] = {
-      ...newNodes[node.parentId],
-      childIds: updatedOldParentChildIds
-    };
-  }
-  const targetParentChildIds = node.parentId === newParentId ? updatedOldParentChildIds : [...newParent.childIds];
-  if (index !== void 0) {
-    targetParentChildIds.splice(index, 0, nodeId);
-  } else {
-    targetParentChildIds.push(nodeId);
-  }
-  newNodes[newParentId] = {
-    ...newNodes[newParentId],
-    childIds: targetParentChildIds
-  };
-  newNodes[nodeId] = {
-    ...node,
-    parentId: newParentId
-  };
-  return {
-    ...document,
-    nodes: newNodes
-  };
-}
-function duplicateNode(document, nodeId, offset = { x: 10, y: 10 }) {
-  const node = document.nodes[nodeId];
-  if (!node || !node.parentId) {
-    return { document, newNodeId: "" };
-  }
-  function cloneNode(n) {
-    const newNode2 = {
-      ...n,
-      id: v4_default(),
-      name: `${n.name} Copy`,
-      x: n.x + offset.x,
-      y: n.y + offset.y,
-      childIds: []
-    };
-    const anyNode = newNode2;
-    if (Array.isArray(anyNode.cells)) anyNode.cells = anyNode.cells.map((row) => row.map((c) => ({ ...c })));
-    if (Array.isArray(anyNode.colWidths)) anyNode.colWidths = [...anyNode.colWidths];
-    if (Array.isArray(anyNode.rowHeights)) anyNode.rowHeights = [...anyNode.rowHeights];
-    return newNode2;
-  }
-  const newNode = cloneNode(node);
-  let doc = addNode(document, newNode, node.parentId);
-  function cloneChildren(originalId, newParentId) {
-    const original = document.nodes[originalId];
-    if (!original) return;
-    original.childIds.forEach((childId) => {
-      const child = document.nodes[childId];
-      if (child) {
-        const newChild = cloneNode(child);
-        newChild.x = child.x;
-        newChild.y = child.y;
-        doc = addNode(doc, newChild, newParentId);
-        cloneChildren(childId, newChild.id);
-      }
-    });
-  }
-  cloneChildren(nodeId, newNode.id);
-  return { document: doc, newNodeId: newNode.id };
-}
-function getNodeBounds(document, nodeId) {
-  const node = document.nodes[nodeId];
-  if (!node) return null;
-  if (node.childIds.length === 0) {
-    return {
-      x: node.x,
-      y: node.y,
-      width: node.width,
-      height: node.height
-    };
-  }
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  function updateBounds(n) {
-    minX = Math.min(minX, n.x);
-    minY = Math.min(minY, n.y);
-    maxX = Math.max(maxX, n.x + n.width);
-    maxY = Math.max(maxY, n.y + n.height);
-  }
-  if (node.type !== "PAGE" && node.type !== "GROUP") {
-    updateBounds(node);
-  }
-  const descendants = getDescendants(document, nodeId);
-  descendants.forEach(updateBounds);
-  if (minX === Infinity) return null;
-  return {
-    x: minX,
-    y: minY,
-    width: maxX - minX,
-    height: maxY - minY
-  };
-}
-function getWorldRenderBounds(document, nodeId) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  function bleedFor(node) {
-    const scene = node;
-    let bleed = 0;
-    let maxStrokeW = 0;
-    for (const s of scene.strokes ?? []) {
-      const w = Array.isArray(s.width) ? Math.max(...s.width) : s.width;
-      maxStrokeW = Math.max(maxStrokeW, w || 0);
-      if (s.alignment === "OUTSIDE") bleed = Math.max(bleed, w);
-      else if (s.alignment === "CENTER") bleed = Math.max(bleed, w / 2);
-    }
-    if (node.type === "LINE" || node.type === "ARROW") {
-      if (node.type === "ARROW" && maxStrokeW === 0) maxStrokeW = 2;
-      bleed = Math.max(bleed, maxStrokeW / 2);
-      if (scene.startArrowhead && scene.startArrowhead !== "NONE" || scene.endArrowhead && scene.endArrowhead !== "NONE") {
-        bleed = Math.max(bleed, Math.max(8, maxStrokeW * 4));
-      }
-    }
-    for (const sh of shadowsOf(scene, document.styles)) {
-      if (sh.type !== "DROP_SHADOW") continue;
-      const reach = Math.max(Math.abs(sh.offset.x), Math.abs(sh.offset.y)) + sh.blur + sh.spread;
-      bleed = Math.max(bleed, reach);
-    }
-    for (const bl of blursOf(scene, document.styles)) {
-      if (bl.type === "LAYER") bleed = Math.max(bleed, bl.radius);
-    }
-    return bleed;
-  }
-  const world = cachedResolver(document.nodes);
-  function visit(id) {
-    const raw = document.nodes[id];
-    if (!raw || !raw.visible) return;
-    const node = resolveNodeVariables(raw, document.variables, document.variableCollections, document.activeVariableModes);
-    const m = world.matrixOf(id);
-    const b = aabbOf(m, node.width, node.height, bleedFor(node) * lengthScale(m));
-    minX = Math.min(minX, b.minX);
-    minY = Math.min(minY, b.minY);
-    maxX = Math.max(maxX, b.maxX);
-    maxY = Math.max(maxY, b.maxY);
-    const clips = "clipsContent" in node && node.clipsContent;
-    if (clips || node.type === "BOOLEAN") return;
-    const scene = scene3dOf(node);
-    if (scene) {
-      const frame = sceneFrame(scene, node.width, node.height);
-      const toWorld = mul4(mul4(fromAffine(m), frame.projection), frame.view);
-      for (const card of sceneLayers(document.nodes, id)) {
-        const pad = bleedFor(card.node);
-        for (const [x, y] of projectRect(mul4(toWorld, card.model), -pad, -pad, card.node.width + pad, card.node.height + pad)) {
-          minX = Math.min(minX, x);
-          minY = Math.min(minY, y);
-          maxX = Math.max(maxX, x);
-          maxY = Math.max(maxY, y);
-        }
-      }
-      return;
-    }
-    node.childIds.forEach(visit);
-  }
-  visit(nodeId);
-  if (minX === Infinity) return null;
-  return { minX, minY, maxX, maxY };
-}
-function gatherLineObstacles(document, line, startAbs, endAbs) {
-  const excluded = /* @__PURE__ */ new Set([line.id]);
-  for (const att of [line.connectorStart, line.connectorEnd]) {
-    if (att && att.nodeId && document.nodes[att.nodeId]) {
-      excluded.add(att.nodeId);
-      for (const a of getAncestors(document, att.nodeId)) excluded.add(a.id);
-      for (const d of getDescendants(document, att.nodeId)) excluded.add(d.id);
-    }
-  }
-  const margin = 160;
-  const rMinX = Math.min(startAbs.x, endAbs.x) - margin;
-  const rMaxX = Math.max(startAbs.x, endAbs.x) + margin;
-  const rMinY = Math.min(startAbs.y, endAbs.y) - margin;
-  const rMaxY = Math.max(startAbs.y, endAbs.y) + margin;
-  const rects = [];
-  for (const n of Object.values(document.nodes)) {
-    if (excluded.has(n.id) || n.visible === false || !OBSTACLE_TYPES.has(n.type)) continue;
-    const { minX: ax, minY: ay, maxX: bx, maxY: by } = aabbOf(getWorldMatrix(document, n.id), n.width, n.height);
-    if (bx < rMinX || ax > rMaxX || by < rMinY || ay > rMaxY) continue;
-    rects.push({ x: ax, y: ay, w: bx - ax, h: by - ay });
-    if (rects.length >= 40) break;
-  }
-  return rects;
-}
-function connectorIdsOf(nodes) {
-  let ids = connectorIdCache.get(nodes);
-  if (!ids) {
-    ids = [];
-    for (const id in nodes) {
-      const t = nodes[id].type;
-      if (t === "LINE" || t === "ARROW") ids.push(id);
-    }
-    connectorIdCache.set(nodes, ids);
-  }
-  return ids;
-}
-function carryConnectorIds(from, to) {
-  if (from === to) return;
-  const ids = connectorIdCache.get(from);
-  if (ids && !connectorIdCache.has(to)) connectorIdCache.set(to, ids);
-}
-function updateConnectors(document, movedNodeIds) {
-  const movedSet = new Set(movedNodeIds);
-  const stack = [...movedNodeIds];
-  while (stack.length) {
-    const n = document.nodes[stack.pop()];
-    if (n && Array.isArray(n.childIds)) {
-      for (const cid of n.childIds) if (!movedSet.has(cid)) {
-        movedSet.add(cid);
-        stack.push(cid);
-      }
-    }
-  }
-  const ids = connectorIdsOf(document.nodes);
-  if (ids.length === 0) return document;
-  const connectors = [];
-  for (const id of ids) {
-    const node = document.nodes[id];
-    if (node) connectors.push(node);
-  }
-  const affectedLineIds = /* @__PURE__ */ new Set();
-  for (const node of connectors) {
-    {
-      const line = node;
-      if (movedSet.has(line.id) || line.connectorStart && movedSet.has(line.connectorStart.nodeId) || line.connectorEnd && movedSet.has(line.connectorEnd.nodeId)) {
-        affectedLineIds.add(line.id);
-      }
-    }
-  }
-  const movedBoxes = [];
-  for (const id of movedSet) {
-    const n = document.nodes[id];
-    if (!n || n.type === "LINE" || n.type === "ARROW") continue;
-    const b = uprightBounds(getWorldTransform(document, id), n.width, n.height);
-    movedBoxes.push({ x0: b.minX, y0: b.minY, x1: b.maxX, y1: b.maxY });
-  }
-  if (movedBoxes.length) {
-    const M = 48;
-    for (const node of connectors) {
-      if (node.routingMode !== "ORTHOGONAL") continue;
-      if (affectedLineIds.has(node.id)) continue;
-      const rp = node.routingPoints;
-      if (!Array.isArray(rp) || rp.length === 0) continue;
-      let lx0 = Infinity, ly0 = Infinity, lx1 = -Infinity, ly1 = -Infinity;
-      for (const p of rp) {
-        lx0 = Math.min(lx0, p.x);
-        ly0 = Math.min(ly0, p.y);
-        lx1 = Math.max(lx1, p.x);
-        ly1 = Math.max(ly1, p.y);
-      }
-      for (const b of movedBoxes) {
-        if (lx1 >= b.x0 - M && lx0 <= b.x1 + M && ly1 >= b.y0 - M && ly0 <= b.y1 + M) {
-          affectedLineIds.add(node.id);
-          break;
-        }
-      }
-    }
-  }
-  if (affectedLineIds.size === 0) return document;
-  const newDoc = { ...document, nodes: { ...document.nodes } };
-  for (const lineId of affectedLineIds) {
-    const line = newDoc.nodes[lineId];
-    const [shaftA, shaftB] = lineShaftEnds(getWorldTransform(document, line.id), line.width);
-    const routed = (line.routingMode === "ORTHOGONAL" || line.routingMode === "BEZIER") && Array.isArray(line.routingPoints) && line.routingPoints.length >= 2;
-    let absA = routed ? { x: line.routingPoints[0].x, y: line.routingPoints[0].y } : shaftA;
-    let absB = routed ? { x: line.routingPoints[line.routingPoints.length - 1].x, y: line.routingPoints[line.routingPoints.length - 1].y } : shaftB;
-    const getTargetAbs = (attachment) => {
-      if (!attachment) return null;
-      const targetNode = newDoc.nodes[attachment.nodeId];
-      if (!targetNode) return null;
-      const a = getConnectorAnchorLocal(targetNode, attachment.position);
-      const [x, y] = apply(unmirroredMatrix(getWorldTransform(document, targetNode.id), targetNode.width, targetNode.height), a.x, a.y);
-      return { x, y };
-    };
-    const newA = getTargetAbs(line.connectorStart);
-    const newB = getTargetAbs(line.connectorEnd);
-    if (newA) absA = newA;
-    if (newB) absB = newB;
-    if (!newA && !newB) continue;
-    const inverseTransformPoint = (worldPt, parentId) => {
-      const parentNode = newDoc.nodes[parentId];
-      if (!parentNode || parentNode.type === "PAGE") return worldPt;
-      const inv = invert(getWorldMatrix(document, parentId));
-      if (!inv) return worldPt;
-      const [x, y] = apply(inv, worldPt.x, worldPt.y);
-      return { x, y };
-    };
-    let parentA = absA;
-    let parentB = absB;
-    if (line.parentId) {
-      parentA = inverseTransformPoint(absA, line.parentId);
-      parentB = inverseTransformPoint(absB, line.parentId);
-    }
-    const dx = parentB.x - parentA.x;
-    const dy = parentB.y - parentA.y;
-    const newWidth = Math.hypot(dx, dy);
-    const newRotation = Math.atan2(dy, dx) * 180 / Math.PI;
-    const updatedLine = {
-      ...line,
-      width: newWidth,
-      rotation: newRotation,
-      x: (parentA.x + parentB.x) / 2 - newWidth / 2,
-      y: (parentA.y + parentB.y) / 2 - Math.max(line.strokeWeight || 1, 2) / 2,
-      height: Math.max(line.strokeWeight || 1, 2)
-    };
-    if (line.routingMode === "ORTHOGONAL" || line.routingMode === "BEZIER") {
-      const getDir = (attach, defaultDir) => {
-        if (!attach) return defaultDir;
-        return connectorPositionDir(attach.position);
-      };
-      const sDir = getDir(line.connectorStart, "CENTER");
-      const eDir = getDir(line.connectorEnd, "CENTER");
-      const routeOpts = {
-        startPos: absA,
-        endPos: absB,
-        startDir: sDir,
-        endDir: eDir
-      };
-      if (line.routingMode === "ORTHOGONAL") {
-        routeOpts.obstacles = gatherLineObstacles(newDoc, line, absA, absB);
-      }
-      const pts = line.routingMode === "BEZIER" ? calculateBezierPath(routeOpts) : calculateOrthogonalPath(routeOpts);
-      updatedLine.routingPoints = pts;
-      if (pts.length > 0) {
-        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-        for (const p of pts) {
-          minX = Math.min(minX, p.x);
-          minY = Math.min(minY, p.y);
-          maxX = Math.max(maxX, p.x);
-          maxY = Math.max(maxY, p.y);
-        }
-        const originLocal = line.parentId ? inverseTransformPoint({ x: minX, y: minY }, line.parentId) : { x: minX, y: minY };
-        updatedLine.width = Math.max(1, maxX - minX);
-        updatedLine.height = Math.max(1, maxY - minY);
-        updatedLine.x = originLocal.x;
-        updatedLine.y = originLocal.y;
-        updatedLine.rotation = 0;
-      }
-    } else {
-      updatedLine.routingPoints = void 0;
-    }
-    newDoc.nodes[lineId] = updatedLine;
-  }
-  carryConnectorIds(document.nodes, newDoc.nodes);
-  return newDoc;
-}
-var ZERO_TRANSFORM, ROOT, resolverCache, OBSTACLE_TYPES, connectorIdCache;
-var init_scene_graph = __esm({
-  "lib/document/scene-graph.ts"() {
-    init_define_POPCRAFT_COMPONENT_IDS();
-    init_dist_node();
-    init_effects();
-    init_variables();
-    init_instances();
-    init_instance_layout();
-    init_cells();
-    init_palettes();
-    init_transform();
-    init_types();
-    init_scene3d();
-    init_transform3d();
-    init_routing();
-    init_shape_outline();
-    ZERO_TRANSFORM = { cx: 0, cy: 0, rotationRad: 0, flipX: false, flipY: false, scaleX: 1, scaleY: 1, matrix: IDENTITY };
-    ROOT = { m: IDENTITY, flipX: false, flipY: false, angle: 0, sense: 1, conformal: true };
-    resolverCache = /* @__PURE__ */ new WeakMap();
-    setVirtualResolver(resolveVirtualNode);
-    OBSTACLE_TYPES = /* @__PURE__ */ new Set([
-      "FRAME",
-      "RECTANGLE",
-      "ELLIPSE",
-      "POLYGON",
-      "STAR",
-      "TEXT",
-      "VECTOR",
-      "BOOLEAN",
-      "TABLE",
-      "COMPONENT",
-      "COMPONENT_SET",
-      "INSTANCE",
-      "STICKY",
-      "IMAGE"
-    ]);
-    connectorIdCache = /* @__PURE__ */ new WeakMap();
-    setSceneApi({ resolve: resolveVirtualNode, childId: virtualChildId, rootOf: virtualRootOf });
-  }
-});
-
-// lib/document/print-pages.ts
-var print_pages_exports = {};
-__export(print_pages_exports, {
-  addHeaderFooterToMaster: () => addHeaderFooterToMaster,
-  assignMaster: () => assignMaster,
-  createMasterPage: () => createMasterPage,
-  createPrintPage: () => createPrintPage,
-  currentPrintPage: () => currentPrintPage,
-  documentFromPreset: () => documentFromPreset,
-  effectiveMasterId: () => effectiveMasterId,
-  foldGuides: () => foldGuides,
-  foldGuidesAt: () => foldGuidesAt,
-  foldsOn: () => foldsOn,
-  isFixedPageKind: () => isFixedPageKind,
-  isMasterPage: () => isMasterPage,
-  isPrintPage: () => isPrintPage,
-  jobPageSize: () => jobPageSize,
-  listMasterPages: () => listMasterPages,
-  listPrintPages: () => listPrintPages,
-  pagePosition: () => pagePosition,
-  placePrintPages: () => placePrintPages,
-  printPageOf: () => printPageOf,
-  reorderPrintPages: () => reorderPrintPages,
-  settingsFromPreset: () => settingsFromPreset
-});
-function listPrintPages(doc, pageId) {
-  const page = doc.nodes[pageId];
-  if (!page) return [];
-  return ordered(page.childIds.map((id) => doc.nodes[id]).filter(isPrintPage));
-}
-function listMasterPages(doc, pageId) {
-  const page = doc.nodes[pageId];
-  if (!page) return [];
-  return ordered(page.childIds.map((id) => doc.nodes[id]).filter(isMasterPage));
-}
-function printPageOf(nodes, nodeId) {
-  let cur = nodes[nodeId.includes("::") ? nodeId.split("::")[0] : nodeId];
-  while (cur && cur.type !== "PAGE") {
-    if (cur.type === "FRAME" && cur.print?.isPrintPage) return cur;
-    cur = cur.parentId ? nodes[cur.parentId] : void 0;
-  }
-  return null;
-}
-function currentPrintPage(doc, pageId, o = {}) {
-  const pages = listPrintPages(doc, pageId);
-  if (!pages.length) return null;
-  for (const id of o.selection ?? []) {
-    const owner = printPageOf(doc.nodes, id);
-    if (owner && pages.some((p) => p.id === owner.id)) return owner;
-  }
-  const c = o.centre;
-  if (c) {
-    const inside = pages.find((p) => c.x >= p.x && c.x <= p.x + p.width && c.y >= p.y && c.y <= p.y + p.height);
-    if (inside) return inside;
-    let best = pages[0], bestD = Infinity;
-    for (const p of pages) {
-      const dx = Math.max(p.x - c.x, 0, c.x - (p.x + p.width));
-      const dy = Math.max(p.y - c.y, 0, c.y - (p.y + p.height));
-      const d = dx * dx + dy * dy;
-      if (d < bestD) {
-        bestD = d;
-        best = p;
-      }
-    }
-    return best;
-  }
-  return pages[0];
-}
-function jobPageSize(doc) {
-  const size = doc.settings?.pageSize;
-  if (!size) return void 0;
-  const preset = presetById(size.presetId);
-  const of = preset?.sheetOf ? presetById(preset.sheetOf.presetId) : void 0;
-  if (of) {
-    const px = presetPx(of);
-    return { width: px.width, height: px.height };
-  }
-  return { width: size.width, height: size.height };
-}
-function settingsFromPreset(preset) {
-  const px = presetPx(preset);
-  const s = {
-    kind: kindForCategory(preset.category),
-    pageSize: { width: px.width, height: px.height, presetId: preset.id }
-  };
-  if (preset.unit !== "px") s.units = preset.unit;
-  if (preset.dpi) s.dpi = preset.dpi;
-  if (px.bleed) s.bleed = edges(px.bleed);
-  if (px.margin) s.margins = edges(px.margin);
-  return s;
-}
-function pagePosition(index, size, facing) {
-  if (!facing) return { x: index * (size.width + gutter(size.width)), y: 0 };
-  const spread = Math.ceil(index / 2);
-  const right = index % 2 === 0;
-  return { x: right ? size.width : 0, y: spread * (size.height + gutter(size.width)) };
-}
-function placePrintPages(doc, pageId) {
-  const patches = {};
-  const facing = doc.settings?.facingPages;
-  const place2 = (frames, at) => frames.forEach((f, i) => {
-    const p = at(i, f);
-    if (f.x !== p.x || f.y !== p.y) patches[f.id] = { ...patches[f.id] ?? {}, ...p };
-  });
-  place2(listPrintPages(doc, pageId), (i, f) => pagePosition(i, f, facing));
-  place2(listMasterPages(doc, pageId), (i, f) => masterPosition(i, f));
-  return patches;
-}
-function foldGuides(preset, width, height) {
-  if (!preset.folds) return [];
-  const span = preset.folds.axis === "X" ? width : height;
-  return preset.folds.at.map((t) => ({ id: v4_default(), axis: preset.folds.axis, pos: Math.round(t * span), kind: "FOLD" }));
-}
-function foldGuidesAt(preset, frame) {
-  if (!preset?.folds) return [];
-  return foldGuides(preset, frame.width, frame.height).map((g) => ({ ...g, pos: g.pos + (g.axis === "X" ? frame.x : frame.y) }));
-}
-function createPrintPage(doc, pageId, opts = {}) {
-  const existing = listPrintPages(doc, pageId);
-  const preset = opts.preset ?? presetById(doc.settings?.pageSize?.presetId);
-  const size = preset ? presetPx(preset) : { width: doc.settings?.pageSize?.width ?? 816, height: doc.settings?.pageSize?.height ?? 1056 };
-  const index = existing.length;
-  const last = existing[existing.length - 1];
-  const frame = createFrame({
-    name: opts.name ?? `Page ${index + 1}`,
-    ...pagePosition(index, size, doc.settings?.facingPages),
-    width: size.width,
-    height: size.height,
-    fills: [{ type: "SOLID", color: createColor(1, 1, 1), opacity: 1, visible: true }],
-    clipsContent: true,
-    print: { isPrintPage: true, index, ...last?.print?.masterId ? { masterId: last.print.masterId } : {} }
-  });
-  frame.parentId = pageId;
-  return frame;
-}
-function createMasterPage(doc, pageId, opts = {}) {
-  const masters = listMasterPages(doc, pageId);
-  const preset = presetById(doc.settings?.pageSize?.presetId);
-  const size = preset ? presetPx(preset) : { width: doc.settings?.pageSize?.width ?? 816, height: doc.settings?.pageSize?.height ?? 1056 };
-  const index = masters.length;
-  const frame = createFrame({
-    name: opts.name ?? `${MASTER_NAMES[index % MASTER_NAMES.length]}-Master`,
-    ...masterPosition(index, size),
-    width: size.width,
-    height: size.height,
-    fills: [{ type: "SOLID", color: createColor(1, 1, 1), opacity: 1, visible: true }],
-    clipsContent: true,
-    print: { isPrintPage: true, isMaster: true, index }
-  });
-  frame.parentId = pageId;
-  return frame;
-}
-function assignMaster(doc, pageIds, masterId) {
-  const patches = {};
-  if (masterId && !isMasterPage(doc.nodes[masterId])) return patches;
-  for (const id of pageIds) {
-    const f = doc.nodes[id];
-    if (!isPrintPage(f) || (f.print.masterId ?? void 0) === masterId) continue;
-    const { masterId: _drop, ...rest } = f.print;
-    patches[id] = { print: masterId ? { ...rest, masterId } : rest };
-  }
-  return patches;
-}
-function effectiveMasterId(doc, frame) {
-  const print = frame.print;
-  if (!print || print.isMaster || !frame.parentId) return void 0;
-  const pages = listPrintPages(doc, frame.parentId);
-  const index = pages.findIndex((p) => p.id === frame.id);
-  if (index < 0) return print.masterId;
-  if (index === 0 && print.masterIdFirst && isMasterPage(doc.nodes[print.masterIdFirst])) return print.masterIdFirst;
-  if (doc.settings?.facingPages && index >= 0) {
-    const isRight = (index + 1) % 2 === 1;
-    if (!isRight && print.masterIdLeft && isMasterPage(doc.nodes[print.masterIdLeft])) return print.masterIdLeft;
-    if (isRight && print.masterIdRight && isMasterPage(doc.nodes[print.masterIdRight])) return print.masterIdRight;
-  }
-  return print.masterId;
-}
-function addHeaderFooterToMaster(doc, masterId, kind) {
-  const master = doc.nodes[masterId];
-  if (!isMasterPage(master)) return null;
-  const margin = 36;
-  const height = 24;
-  const y = kind === "header" ? margin : Math.max(margin, master.height - margin - height);
-  const text = createText({
-    name: kind === "header" ? "Header" : "Footer",
-    x: margin,
-    y,
-    width: Math.max(40, master.width - margin * 2),
-    height,
-    characters: kind === "footer" ? "{{page}}" : "Header",
-    fontSize: 10,
-    textAlign: kind === "footer" ? "CENTER" : "LEFT"
-  });
-  const next = addNode(doc, text, masterId);
-  const band = kind === "header" ? { headerHeight: margin + height + 8 } : { footerHeight: margin + height + 8 };
-  const updated = {
-    ...next,
-    nodes: {
-      ...next.nodes,
-      [masterId]: {
-        ...next.nodes[masterId],
-        print: { ...next.nodes[masterId].print, ...band }
-      }
-    }
-  };
-  return { doc: updated, textId: text.id };
-}
-function reorderPrintPages(doc, pageId, orderedIds) {
-  const current = listPrintPages(doc, pageId);
-  const rest = current.map((f) => f.id).filter((id) => !orderedIds.includes(id));
-  const patches = {};
-  [...orderedIds, ...rest].forEach((id, index) => {
-    const f = doc.nodes[id];
-    if (isPrintPage(f) && f.print.index !== index) patches[id] = { print: { ...f.print, index } };
-  });
-  const renumbered = { ...doc, nodes: { ...doc.nodes } };
-  for (const id in patches) renumbered.nodes[id] = { ...doc.nodes[id], ...patches[id] };
-  const placed = placePrintPages(renumbered, pageId);
-  for (const id in placed) patches[id] = { ...patches[id] ?? {}, ...placed[id] };
-  return patches;
-}
-function documentFromPreset(name, preset) {
-  const doc = createDocument(name, settingsFromPreset(preset));
-  const pageId = doc.pages[0];
-  const first = createPrintPage(doc, pageId, { preset, name: isFixedPageKind(doc.settings?.kind) ? "Page 1" : preset.name });
-  if (!isFixedPageKind(doc.settings?.kind)) delete first.print;
-  const page = doc.nodes[pageId];
-  doc.nodes[first.id] = first;
-  doc.nodes[pageId] = { ...page, childIds: [...page.childIds, first.id] };
-  const guides = foldGuides(preset, first.width, first.height).map((g) => ({ ...g, pos: g.pos + (g.axis === "X" ? first.x : first.y) }));
-  if (guides.length) doc.nodes[pageId].guides = guides;
-  return doc;
-}
-var isFixedPageKind, isPrintPage, isMasterPage, ordered, edges, gutter, masterPosition, foldsOn, MASTER_NAMES;
-var init_print_pages = __esm({
-  "lib/document/print-pages.ts"() {
-    init_define_POPCRAFT_COMPONENT_IDS();
-    init_dist_node();
-    init_scene_graph();
-    init_types();
-    init_page_presets();
-    isFixedPageKind = (kind) => kind === "PRINT" || kind === "SOCIAL" || kind === "PRESENTATION" || kind === "EMAIL";
-    isPrintPage = (n) => !!n && n.type === "FRAME" && !!n.print?.isPrintPage && !n.print?.isMaster;
-    isMasterPage = (n) => !!n && n.type === "FRAME" && !!n.print?.isMaster;
-    ordered = (frames) => frames.map((f, i) => ({ f, i })).sort((a, b) => (a.f.print.index ?? Infinity) - (b.f.print.index ?? Infinity) || a.f.y - b.f.y || a.f.x - b.f.x || a.i - b.i).map((x) => x.f);
-    edges = (v) => ({ top: v, right: v, bottom: v, left: v });
-    gutter = (w) => Math.round(w * 0.15);
-    masterPosition = (index, size) => ({
-      x: index * (size.width + gutter(size.width)),
-      y: -(size.height + 2 * gutter(size.width))
-    });
-    foldsOn = (guides, frame) => (guides ?? []).filter((g) => g.kind === "FOLD" && (g.axis === "X" ? g.pos >= frame.x && g.pos <= frame.x + frame.width : g.pos >= frame.y && g.pos <= frame.y + frame.height));
-    MASTER_NAMES = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  }
-});
-
-export {
-  calculateOrthogonalPath,
-  trimPolyline,
-  calculateBezierPath,
-  init_routing,
-  flattenPaths,
-  init_flatten,
-  glyphLinear,
-  init_glyph_linear,
-  glyphOutline,
-  glyphInstancesToRings,
-  init_text_rings,
-  shapeToRings,
-  init_shape_outline,
-  isFixedPageKind,
-  isPrintPage,
-  isMasterPage,
-  listPrintPages,
-  listMasterPages,
-  printPageOf,
-  currentPrintPage,
-  jobPageSize,
-  settingsFromPreset,
-  pagePosition,
-  placePrintPages,
-  foldGuides,
-  foldGuidesAt,
-  foldsOn,
-  createPrintPage,
-  createMasterPage,
-  assignMaster,
-  effectiveMasterId,
-  addHeaderFooterToMaster,
-  reorderPrintPages,
-  documentFromPreset,
-  init_print_pages,
-  virtualRootOf,
-  virtualChildId,
-  chainOverrides,
-  resolveVirtualNode,
-  createDocument,
-  createPage,
-  createRectangle,
-  createEllipse,
-  createSticky,
-  createLine,
-  createArrow,
-  createPolygon,
-  createStar,
-  createSection,
-  createSlice,
-  createFrame,
-  createText,
-  createGroup,
-  createVector,
-  createBoolean,
-  createPixelGrid,
-  createImage,
-  createRaster,
-  createComponent,
-  createComponentSet,
-  createInstance,
-  createInstanceOf,
-  addNode,
-  removeNode,
-  updateNode,
-  getDescendants,
-  getAncestors,
-  applyConstraints,
-  getRenderableNodes,
-  moveNodeInZOrder,
-  uprightBounds,
-  unmirroredMatrix,
-  lineShaftEnds,
-  detachedTransform,
-  createWorldMatrixResolver,
-  createWorldTransformResolver,
-  getWorldTransform,
-  getWorldMatrix,
-  placementUnder,
-  componentsDrawnBy,
-  wouldCreateCycle,
-  wrapInComponent,
-  reparentNode,
-  duplicateNode,
-  getNodeBounds,
-  getWorldRenderBounds,
-  gatherLineObstacles,
-  connectorIdsOf,
-  carryConnectorIds,
-  updateConnectors,
-  init_scene_graph
-};