@pixerate/editor 0.31.0 → 0.33.0

package/dist/canvas/index.js

@@ -1,3 +1,87 @@
+import {
+  CANVAS_GRADIENT_PRESETS,
+  PathOpsError,
+  SHAPE_KINDS,
+  add,
+  angleToSvgLinearCoords,
+  arcToCubics,
+  bezierPathArea,
+  bezierPathBounds,
+  bezierPathLength,
+  bezierPathPointAtLength,
+  bezierPathSignedArea,
+  bezierPathToSvg,
+  closeContour,
+  contourSignedArea,
+  contoursToPath,
+  countPathSegments,
+  cross,
+  cubicPointAt,
+  cubicsToPathData,
+  dist,
+  distanceToBezierPath,
+  dividePaths,
+  dividePolygons,
+  dot,
+  excludePaths,
+  fitCubicRun,
+  fitCubics,
+  fitFreehandPath,
+  fitPathData,
+  flattenChain,
+  flattenSvgPath,
+  formatNumber,
+  getShapeRenderData,
+  getShapeSvg,
+  gradientToSvgDef,
+  intersectPaths,
+  intersectPolygons,
+  isCanvasGradient,
+  isShapeDescription,
+  isStraightCubic,
+  multiPolygonArea,
+  multiPolygonBounds,
+  nestedRingsToPath,
+  normalizeBezierPath,
+  parseCssGradient,
+  parseSvgPath,
+  pathBoolean,
+  pathBooleanRings,
+  pathToContours,
+  pointInBezierPath,
+  pointInMultiPolygon,
+  pointInRings,
+  polygonArea,
+  polygonBoolean,
+  polygonToSvgPath,
+  resolveCanvasGradient,
+  ringSignedArea,
+  samePoint,
+  scale,
+  segmentBounds,
+  segmentCurvature,
+  segmentDerivative,
+  segmentExtrema,
+  segmentLength,
+  segmentNearest,
+  segmentParamAtLength,
+  segmentPoint,
+  segmentTangent,
+  shapeToPolygon,
+  simplifyRing,
+  splitSegment,
+  sub,
+  subSegment,
+  subtractPaths,
+  subtractPolygons,
+  toBezierPath,
+  transformBezierPath,
+  trimSegments,
+  unionPolygons,
+  unitePaths,
+  windingNumber,
+  xorPolygons
+} from "../chunk-GQTXV2EQ.js";
 import {
   DEFAULT_NODE_HEIGHT,
   DEFAULT_NODE_WIDTH,
@@ -1642,3256 +1726,6 @@ function fitViewportToNodes(nodes, size, ids, options = {}) {
   return bounds ? fitViewportToRect(bounds, size, options) : null;
 }
 
-// src/canvas/polygonBoolean.ts
-function ringSignedArea(ring) {
-  let sum = 0;
-  const n = ring.length;
-  for (let i = 0; i < n; i++) {
-    const [x1, y1] = ring[i];
-    const [x2, y2] = ring[(i + 1) % n];
-    sum += x1 * y2 - x2 * y1;
-  }
-  return sum / 2;
-}
-function polygonArea(polygon) {
-  if (polygon.length === 0) return 0;
-  let area = Math.abs(ringSignedArea(polygon[0]));
-  for (let i = 1; i < polygon.length; i++) area -= Math.abs(ringSignedArea(polygon[i]));
-  return area;
-}
-function multiPolygonArea(multi) {
-  let total = 0;
-  for (const polygon of multi) total += polygonArea(polygon);
-  return total;
-}
-function multiPolygonBounds(input) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  const visit = (ring) => {
-    for (const [x, y] of ring) {
-      if (x < minX) minX = x;
-      if (y < minY) minY = y;
-      if (x > maxX) maxX = x;
-      if (y > maxY) maxY = y;
-    }
-  };
-  for (const item of input) {
-    if (item.length > 0 && Array.isArray(item[0]) && Array.isArray(item[0][0])) {
-      for (const ring of item) visit(ring);
-    } else {
-      visit(item);
-    }
-  }
-  return minX === Infinity ? null : { minX, minY, maxX, maxY };
-}
-function pointInRings(point, rings, fillRule = "nonzero") {
-  const [px2, py] = point;
-  let winding = 0;
-  for (const ring of rings) {
-    const n = ring.length;
-    for (let i = 0; i < n; i++) {
-      const [ax, ay] = ring[i];
-      const [bx, by] = ring[(i + 1) % n];
-      if (ay <= py && by > py) {
-        if (ax + (py - ay) / (by - ay) * (bx - ax) > px2) winding++;
-      } else if (by <= py && ay > py) {
-        if (ax + (py - ay) / (by - ay) * (bx - ax) > px2) winding--;
-      }
-    }
-  }
-  return fillRule === "evenodd" ? (winding & 1) === 1 : winding !== 0;
-}
-function pointInMultiPolygon(point, multi) {
-  return multi.some((polygon) => pointInRings(point, polygon, "evenodd"));
-}
-function cleanRing(ring) {
-  const out = [];
-  for (const p of ring) {
-    if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) continue;
-    const last = out[out.length - 1];
-    if (last && last[0] === p[0] && last[1] === p[1]) continue;
-    out.push([p[0], p[1]]);
-  }
-  while (out.length > 1) {
-    const first = out[0];
-    const last = out[out.length - 1];
-    if (first[0] === last[0] && first[1] === last[1]) out.pop();
-    else break;
-  }
-  return out;
-}
-function isOperand(input) {
-  return !Array.isArray(input) && typeof input === "object" && input !== null && Array.isArray(input.rings);
-}
-function normalizeInput(input) {
-  if (isOperand(input)) {
-    return {
-      rings: input.rings.map(cleanRing).filter((r) => r.length >= 3),
-      fillRule: input.fillRule ?? "nonzero"
-    };
-  }
-  const rings = [];
-  for (const polygon of input ?? []) {
-    polygon.forEach((raw, index) => {
-      const ring = cleanRing(raw);
-      if (ring.length < 3) return;
-      const area = ringSignedArea(ring);
-      if (area === 0) return;
-      const wantPositive = index === 0;
-      rings.push(area > 0 === wantPositive ? ring : ring.reverse());
-    });
-  }
-  return { rings, fillRule: "nonzero" };
-}
-var PointPool = class {
-  constructor(eps) {
-    this.eps = eps;
-  }
-  eps;
-  vertices = [];
-  cells = /* @__PURE__ */ new Map();
-  get(x, y) {
-    const cx = Math.floor(x / this.eps);
-    const cy = Math.floor(y / this.eps);
-    let best = null;
-    let bestDist = Infinity;
-    for (let dx = -1; dx <= 1; dx++) {
-      for (let dy = -1; dy <= 1; dy++) {
-        const ids = this.cells.get(`${cx + dx},${cy + dy}`);
-        if (!ids) continue;
-        for (const id of ids) {
-          const v = this.vertices[id];
-          const d = Math.hypot(v.x - x, v.y - y);
-          if (d <= this.eps && d < bestDist) {
-            best = v;
-            bestDist = d;
-          }
-        }
-      }
-    }
-    if (best) return best;
-    const vertex = { id: this.vertices.length, x, y };
-    this.vertices.push(vertex);
-    const key = `${cx},${cy}`;
-    const bucket = this.cells.get(key);
-    if (bucket) bucket.push(vertex.id);
-    else this.cells.set(key, [vertex.id]);
-    return vertex;
-  }
-};
-function project(a, b, p) {
-  const dx = b.x - a.x;
-  const dy = b.y - a.y;
-  const len2 = dx * dx + dy * dy;
-  const t = len2 === 0 ? 0 : ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
-  const cx = a.x + t * dx;
-  const cy = a.y + t * dy;
-  return { t, dist: Math.hypot(p.x - cx, p.y - cy) };
-}
-function addSplit(splits, t, v) {
-  const { a, b } = splits.segment;
-  if (v.id === a.id || v.id === b.id) return;
-  if (!splits.points.has(v.id)) splits.points.set(v.id, { t, v });
-}
-function splitPass(segments, pool, eps) {
-  const order = segments.map((s, i) => ({
-    i,
-    minX: Math.min(s.a.x, s.b.x),
-    maxX: Math.max(s.a.x, s.b.x),
-    minY: Math.min(s.a.y, s.b.y),
-    maxY: Math.max(s.a.y, s.b.y)
-  })).sort((p, q) => p.minX - q.minX);
-  const splits = segments.map((segment) => ({ segment, points: /* @__PURE__ */ new Map() }));
-  for (let oi = 0; oi < order.length; oi++) {
-    const bi = order[oi];
-    const s1 = segments[bi.i];
-    for (let oj = oi + 1; oj < order.length; oj++) {
-      const bj = order[oj];
-      if (bj.minX > bi.maxX + eps) break;
-      if (bj.minY > bi.maxY + eps || bj.maxY < bi.minY - eps) continue;
-      const s2 = segments[bj.i];
-      const sharedA = s1.a.id === s2.a.id || s1.a.id === s2.b.id;
-      const sharedB = s1.b.id === s2.a.id || s1.b.id === s2.b.id;
-      if (sharedA && sharedB) continue;
-      let touched = false;
-      for (const [seg, other, split] of [
-        [s1, s2, splits[bi.i]],
-        [s2, s1, splits[bj.i]]
-      ]) {
-        for (const p of [other.a, other.b]) {
-          if (p.id === seg.a.id || p.id === seg.b.id) continue;
-          const { t: t2, dist: dist3 } = project(seg.a, seg.b, p);
-          const len = Math.hypot(seg.b.x - seg.a.x, seg.b.y - seg.a.y);
-          if (dist3 <= eps && t2 * len > eps && (1 - t2) * len > eps) {
-            addSplit(split, t2, p);
-            touched = true;
-          }
-        }
-      }
-      if (touched) continue;
-      const d1x = s1.b.x - s1.a.x;
-      const d1y = s1.b.y - s1.a.y;
-      const d2x = s2.b.x - s2.a.x;
-      const d2y = s2.b.y - s2.a.y;
-      const denom = d1x * d2y - d1y * d2x;
-      const len1 = Math.hypot(d1x, d1y);
-      const len2 = Math.hypot(d2x, d2y);
-      if (Math.abs(denom) <= 1e-12 * len1 * len2) continue;
-      const ex = s2.a.x - s1.a.x;
-      const ey = s2.a.y - s1.a.y;
-      const t = (ex * d2y - ey * d2x) / denom;
-      const u = (ex * d1y - ey * d1x) / denom;
-      const tolT = eps / len1;
-      const tolU = eps / len2;
-      if (t < -tolT || t > 1 + tolT || u < -tolU || u > 1 + tolU) continue;
-      if (sharedA || sharedB) continue;
-      const v = pool.get(s1.a.x + t * d1x, s1.a.y + t * d1y);
-      addSplit(splits[bi.i], project(s1.a, s1.b, v).t, v);
-      addSplit(splits[bj.i], project(s2.a, s2.b, v).t, v);
-    }
-  }
-  let changed = false;
-  const out = [];
-  for (const { segment, points } of splits) {
-    if (points.size === 0) {
-      out.push(segment);
-      continue;
-    }
-    changed = true;
-    const ordered = [...points.values()].sort((p, q) => p.t - q.t);
-    let prev = segment.a;
-    for (const { v } of ordered) {
-      if (v.id !== prev.id) out.push({ a: prev, b: v, operand: segment.operand });
-      prev = v;
-    }
-    if (prev.id !== segment.b.id) out.push({ a: prev, b: segment.b, operand: segment.operand });
-  }
-  return { segments: out, changed };
-}
-function defaultEpsilon(operands) {
-  let max = 0;
-  for (const op of operands) {
-    for (const ring of op.rings) {
-      for (const [x, y] of ring) {
-        const m = Math.max(Math.abs(x), Math.abs(y));
-        if (m > max) max = m;
-      }
-    }
-  }
-  return Math.max(1e-9, max * 1e-9);
-}
-function buildOverlay(inputs, options) {
-  const operands = inputs.map(normalizeInput);
-  const eps = options.epsilon && options.epsilon > 0 ? options.epsilon : defaultEpsilon(operands);
-  const pool = new PointPool(eps);
-  let segments = [];
-  operands.forEach((op, operand) => {
-    for (const ring of op.rings) {
-      const verts = ring.map(([x, y]) => pool.get(x, y));
-      for (let i = 0; i < verts.length; i++) {
-        const a = verts[i];
-        const b = verts[(i + 1) % verts.length];
-        if (a.id !== b.id) segments.push({ a, b, operand });
-      }
-    }
-  });
-  for (let pass = 0; pass < 8; pass++) {
-    const result = splitPass(segments, pool, eps);
-    segments = result.segments;
-    if (!result.changed) break;
-  }
-  const count = operands.length;
-  const byKey = /* @__PURE__ */ new Map();
-  for (const s of segments) {
-    const forward = s.a.id < s.b.id;
-    const a = forward ? s.a : s.b;
-    const b = forward ? s.b : s.a;
-    const key = `${a.id},${b.id}`;
-    let edge = byKey.get(key);
-    if (!edge) {
-      edge = { a, b, mult: new Array(count).fill(0) };
-      byKey.set(key, edge);
-    }
-    edge.mult[s.operand] += forward ? 1 : -1;
-  }
-  const edges = [...byKey.values()].filter((e) => e.mult.some((m) => m !== 0));
-  const right = [];
-  const left = [];
-  for (let i = 0; i < edges.length; i++) {
-    const edge = edges[i];
-    const horizontal = Math.abs(edge.b.y - edge.a.y) < Math.abs(edge.b.x - edge.a.x);
-    const tx = (v) => horizontal ? v.y : v.x;
-    const ty = (v) => horizontal ? -v.x : v.y;
-    const ax = tx(edge.a);
-    const ay = ty(edge.a);
-    const bx = tx(edge.b);
-    const by = ty(edge.b);
-    const mx = (ax + bx) / 2;
-    const my = (ay + by) / 2;
-    const winding = new Array(count).fill(0);
-    for (let j = 0; j < edges.length; j++) {
-      if (j === i) continue;
-      const other = edges[j];
-      const oax = tx(other.a);
-      const oay = ty(other.a);
-      const obx = tx(other.b);
-      const oby = ty(other.b);
-      let dir = 0;
-      if (oay <= my && oby > my) dir = 1;
-      else if (oby <= my && oay > my) dir = -1;
-      else continue;
-      const x = oax + (my - oay) / (oby - oay) * (obx - oax);
-      if (x <= mx) continue;
-      for (let k = 0; k < count; k++) {
-        if (other.mult[k] !== 0) winding[k] += dir * other.mult[k];
-      }
-    }
-    const sideIsRight = by > ay;
-    const r = sideIsRight ? winding : winding.map((w, k) => w - edge.mult[k]);
-    right.push(r);
-    left.push(r.map((w, k) => w + edge.mult[k]));
-  }
-  return { edges, right, left, fillRules: operands.map((o) => o.fillRule), eps };
-}
-function insideFlags(windings, fillRules) {
-  return windings.map((w, k) => fillRules[k] === "evenodd" ? (w & 1) === 1 : w !== 0);
-}
-function traceRings(directed2) {
-  const outgoing = /* @__PURE__ */ new Map();
-  for (const e of directed2) {
-    const list = outgoing.get(e.from.id);
-    if (list) list.push(e);
-    else outgoing.set(e.from.id, [e]);
-  }
-  const TWO_PI2 = Math.PI * 2;
-  const next = (incoming) => {
-    const candidates = outgoing.get(incoming.to.id);
-    if (!candidates) return void 0;
-    const back = Math.atan2(incoming.from.y - incoming.to.y, incoming.from.x - incoming.to.x);
-    let best;
-    let bestTurn = Infinity;
-    for (const c of candidates) {
-      let turn = back - c.angle;
-      turn -= Math.floor(turn / TWO_PI2) * TWO_PI2;
-      if (turn <= 1e-15) turn = TWO_PI2;
-      if (turn < bestTurn) {
-        bestTurn = turn;
-        best = c;
-      }
-    }
-    return best;
-  };
-  const used = /* @__PURE__ */ new Set();
-  const rings = [];
-  for (const start of directed2) {
-    if (used.has(start)) continue;
-    const ring = [];
-    let edge = start;
-    let guard = directed2.length + 1;
-    while (edge && !used.has(edge) && guard-- > 0) {
-      used.add(edge);
-      ring.push(edge.from);
-      edge = next(edge);
-    }
-    if (ring.length >= 3) rings.push(ring);
-  }
-  return rings;
-}
-function removeCollinear(ring, eps) {
-  let points = ring;
-  let changed = true;
-  while (changed && points.length > 3) {
-    changed = false;
-    const out = [];
-    const n = points.length;
-    for (let i = 0; i < n; i++) {
-      const prev = out.length > 0 ? out[out.length - 1] : points[(i - 1 + n) % n];
-      const cur = points[i];
-      const nxt = points[(i + 1) % n];
-      const dx = nxt[0] - prev[0];
-      const dy = nxt[1] - prev[1];
-      const len = Math.hypot(dx, dy);
-      const cross2 = (cur[0] - prev[0]) * dy - (cur[1] - prev[1]) * dx;
-      const dot3 = (cur[0] - prev[0]) * dx + (cur[1] - prev[1]) * dy;
-      if (len > 0 && Math.abs(cross2) / len <= eps && dot3 > 0 && dot3 < len * len) {
-        changed = true;
-        continue;
-      }
-      out.push(cur);
-    }
-    if (out.length < 3) return out;
-    points = out;
-  }
-  return points;
-}
-function assemble(rings, eps) {
-  const outers = [];
-  const holes = [];
-  const minArea = eps * eps;
-  for (const vertices of rings) {
-    const ring = removeCollinear(
-      vertices.map((v) => [v.x, v.y]),
-      eps
-    );
-    if (ring.length < 3) continue;
-    const area = ringSignedArea(ring);
-    if (Math.abs(area) <= minArea) continue;
-    (area > 0 ? outers : holes).push({ ring, area: Math.abs(area) });
-  }
-  outers.sort((a, b) => b.area - a.area);
-  const polygons = outers.map((o) => [o.ring]);
-  for (const hole of holes) {
-    const [p, q] = [hole.ring[0], hole.ring[1]];
-    const sample = [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2];
-    let owner = -1;
-    for (let i = outers.length - 1; i >= 0; i--) {
-      if (outers[i].area >= hole.area && pointInRings(sample, [outers[i].ring], "evenodd")) {
-        owner = i;
-        break;
-      }
-    }
-    if (owner >= 0) polygons[owner].push(hole.ring);
-  }
-  return polygons;
-}
-function extract(overlay, isInside) {
-  const directed2 = [];
-  overlay.edges.forEach((edge, i) => {
-    const l = isInside(insideFlags(overlay.left[i], overlay.fillRules));
-    const r = isInside(insideFlags(overlay.right[i], overlay.fillRules));
-    if (l === r) return;
-    const [from, to] = l ? [edge.a, edge.b] : [edge.b, edge.a];
-    directed2.push({ from, to, angle: Math.atan2(to.y - from.y, to.x - from.x) });
-  });
-  return assemble(traceRings(directed2), overlay.eps);
-}
-function predicate(operation) {
-  switch (operation) {
-    case "union":
-      return (f) => f.some(Boolean);
-    case "intersection":
-      return (f) => f.length > 0 && f.every(Boolean);
-    case "difference":
-      return (f) => f[0] === true && !f.slice(1).some(Boolean);
-    case "xor":
-      return (f) => f.filter(Boolean).length % 2 === 1;
-  }
-}
-function polygonBoolean(operation, operands, options = {}) {
-  if (operands.length === 0) return [];
-  return extract(buildOverlay(operands, options), predicate(operation));
-}
-var unionPolygons = (a, b, options) => polygonBoolean("union", [a, b], options);
-var intersectPolygons = (a, b, options) => polygonBoolean("intersection", [a, b], options);
-var subtractPolygons = (a, b, options) => polygonBoolean("difference", [a, b], options);
-var xorPolygons = (a, b, options) => polygonBoolean("xor", [a, b], options);
-function dividePolygons(operands, options = {}) {
-  if (operands.length === 0) return [];
-  const overlay = buildOverlay(operands, options);
-  const signatures = /* @__PURE__ */ new Map();
-  const note = (windings) => {
-    const flags = insideFlags(windings, overlay.fillRules);
-    if (!flags.some(Boolean)) return;
-    const key = flags.map((f) => f ? "1" : "0").join("");
-    if (!signatures.has(key)) signatures.set(key, flags.flatMap((f, k) => f ? [k] : []));
-  };
-  overlay.edges.forEach((_, i) => {
-    note(overlay.left[i]);
-    note(overlay.right[i]);
-  });
-  const pieces = [];
-  const keys = [...signatures.keys()].sort();
-  for (const key of keys) {
-    const polygons = extract(overlay, (flags) => flags.map((f) => f ? "1" : "0").join("") === key);
-    polygons.sort((a, b) => polygonArea(b) - polygonArea(a));
-    for (const polygon of polygons) pieces.push({ polygon, operands: signatures.get(key) });
-  }
-  return pieces;
-}
-
-// src/canvas/curveFit.ts
-function formatNumber(value, precision) {
-  const factor = 10 ** precision;
-  const rounded = Math.round(value * factor) / factor;
-  return Object.is(rounded, -0) ? "0" : String(rounded);
-}
-var MAX_REPARAM = 6;
-var sub = (a, b) => [a[0] - b[0], a[1] - b[1]];
-var add = (a, v, s = 1) => [a[0] + v[0] * s, a[1] + v[1] * s];
-var dot = (a, b) => a[0] * b[0] + a[1] * b[1];
-var dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
-function unit(v) {
-  const l = Math.hypot(v[0], v[1]);
-  return l > 1e-12 && Number.isFinite(l) ? [v[0] / l, v[1] / l] : null;
-}
-function evalCubic(c, t) {
-  const s = 1 - t;
-  const b0 = s * s * s;
-  const b1 = 3 * s * s * t;
-  const b2 = 3 * s * t * t;
-  const b3 = t * t * t;
-  return [
-    b0 * c.p0[0] + b1 * c.p1[0] + b2 * c.p2[0] + b3 * c.p3[0],
-    b0 * c.p0[1] + b1 * c.p1[1] + b2 * c.p2[1] + b3 * c.p3[1]
-  ];
-}
-function cubicPointAt(c, t) {
-  return evalCubic(c, t);
-}
-function dedup(points) {
-  const out = [];
-  for (const p of points) {
-    if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) continue;
-    if (out.length === 0 || dist(out[out.length - 1], p) > 1e-12) out.push(p);
-  }
-  return out;
-}
-function chordParams(pts) {
-  const u = [0];
-  let acc = 0;
-  for (let i = 1; i < pts.length; i++) {
-    acc += dist(pts[i - 1], pts[i]);
-    u.push(acc);
-  }
-  return acc > 0 ? u.map((x) => x / acc) : u;
-}
-function generate(pts, u, t0, t1) {
-  const p0 = pts[0];
-  const p3 = pts[pts.length - 1];
-  const dirIn = [-t1[0], -t1[1]];
-  let c00 = 0;
-  let c01 = 0;
-  let c11 = 0;
-  let x0 = 0;
-  let x1 = 0;
-  for (let i = 0; i < pts.length; i++) {
-    const t = u[i];
-    const s = 1 - t;
-    const b0 = s * s * s;
-    const b1 = 3 * s * s * t;
-    const b2 = 3 * s * t * t;
-    const b3 = t * t * t;
-    const a0 = [t0[0] * b1, t0[1] * b1];
-    const a1 = [dirIn[0] * b2, dirIn[1] * b2];
-    c00 += dot(a0, a0);
-    c01 += dot(a0, a1);
-    c11 += dot(a1, a1);
-    const tmp = [
-      pts[i][0] - (p0[0] * (b0 + b1) + p3[0] * (b2 + b3)),
-      pts[i][1] - (p0[1] * (b0 + b1) + p3[1] * (b2 + b3))
-    ];
-    x0 += dot(a0, tmp);
-    x1 += dot(a1, tmp);
-  }
-  const det = c00 * c11 - c01 * c01;
-  const seg = dist(p0, p3);
-  const eps = 1e-6 * seg;
-  let al = seg / 3;
-  let ar = seg / 3;
-  if (Math.abs(det) > 1e-12) {
-    al = (x0 * c11 - x1 * c01) / det;
-    ar = (c00 * x1 - c01 * x0) / det;
-  }
-  if (!Number.isFinite(al) || !Number.isFinite(ar) || al < eps || ar < eps) {
-    al = seg / 3;
-    ar = seg / 3;
-  }
-  const cap = seg * 4 + 1e-9;
-  al = Math.min(al, cap);
-  ar = Math.min(ar, cap);
-  return { p0, p1: add(p0, t0, al), p2: add(p3, dirIn, ar), p3 };
-}
-function maxError(pts, c, u) {
-  let e = 0;
-  let idx = pts.length >> 1;
-  for (let i = 0; i < pts.length; i++) {
-    const d = dist(evalCubic(c, u[i]), pts[i]);
-    if (d > e) {
-      e = d;
-      idx = i;
-    }
-  }
-  return [e, idx];
-}
-function newton(c, p, t) {
-  const s = 1 - t;
-  const q = evalCubic(c, t);
-  const d1 = [
-    3 * (s * s * (c.p1[0] - c.p0[0]) + 2 * s * t * (c.p2[0] - c.p1[0]) + t * t * (c.p3[0] - c.p2[0])),
-    3 * (s * s * (c.p1[1] - c.p0[1]) + 2 * s * t * (c.p2[1] - c.p1[1]) + t * t * (c.p3[1] - c.p2[1]))
-  ];
-  const d2 = [
-    6 * (s * (c.p2[0] - 2 * c.p1[0] + c.p0[0]) + t * (c.p3[0] - 2 * c.p2[0] + c.p1[0])),
-    6 * (s * (c.p2[1] - 2 * c.p1[1] + c.p0[1]) + t * (c.p3[1] - 2 * c.p2[1] + c.p1[1]))
-  ];
-  const diff = [q[0] - p[0], q[1] - p[1]];
-  const num2 = dot(diff, d1);
-  const den = dot(d1, d1) + dot(diff, d2);
-  if (Math.abs(den) < 1e-12) return t;
-  const nt = t - num2 / den;
-  return Number.isFinite(nt) ? Math.min(1, Math.max(0, nt)) : t;
-}
-function fitSingleFrom(pts, u, t0, t1) {
-  let best = generate(pts, u, t0, t1);
-  let [bestErr, bestSplit] = maxError(pts, best, u);
-  const params = u.slice();
-  for (let round2 = 0; round2 < MAX_REPARAM; round2++) {
-    for (let i = 0; i < params.length; i++) params[i] = newton(best, pts[i], params[i]);
-    const c = generate(pts, params, t0, t1);
-    const [e, s] = maxError(pts, c, params);
-    if (e < bestErr) {
-      best = c;
-      bestErr = e;
-      bestSplit = s;
-    } else break;
-  }
-  return [best, bestErr, bestSplit];
-}
-function fitRec(pts, t0, t1, tol, out, depth) {
-  const n = pts.length;
-  if (n === 2) {
-    const d = dist(pts[0], pts[1]) / 3;
-    out.push({ p0: pts[0], p1: add(pts[0], t0, d), p2: add(pts[1], t1, -d), p3: pts[1] });
-    return;
-  }
-  const [c, err, splitAt] = fitSingleFrom(pts, chordParams(pts), t0, t1);
-  if (err <= tol || depth > 40) {
-    out.push(c);
-    return;
-  }
-  const split = Math.min(n - 2, Math.max(1, splitAt));
-  const tc = unit(sub(pts[split + 1], pts[split - 1])) ?? t0;
-  fitRec(pts.slice(0, split + 1), t0, tc, tol, out, depth + 1);
-  fitRec(pts.slice(split), tc, t1, tol, out, depth + 1);
-}
-function tangentFrom(a, b, c) {
-  const chord = unit(sub(b, a));
-  if (!c) return chord;
-  const d1 = dist(a, b);
-  const d2 = dist(b, c);
-  if (!(d1 > 0) || !(d2 > 0)) return chord;
-  const ka = -(2 * d1 + d2) / (d1 * (d1 + d2));
-  const kb = (d1 + d2) / (d1 * d2);
-  const kc = -d1 / (d2 * (d1 + d2));
-  const est = unit([ka * a[0] + kb * b[0] + kc * c[0], ka * a[1] + kb * b[1] + kc * c[1]]);
-  return est && chord && dot(est, chord) > Math.cos(Math.PI / 4) ? est : chord;
-}
-function fitCubicRun(points, tolerance, t0, t1) {
-  const pts = dedup(points);
-  const out = [];
-  if (pts.length < 2) return out;
-  const n = pts.length;
-  const start = (t0 && unit([t0[0], t0[1]])) ?? tangentFrom(pts[0], pts[1], pts[2]) ?? [1, 0];
-  const back = tangentFrom(pts[n - 1], pts[n - 2], pts[n - 3]);
-  const end = (t1 && unit([t1[0], t1[1]])) ?? (back ? [-back[0], -back[1]] : [1, 0]);
-  fitRec(pts, start, end, Math.max(tolerance, 1e-9), out, 0);
-  return out;
-}
-function turnDeg(a, b, c) {
-  const u = unit(sub(b, a));
-  const v = unit(sub(c, b));
-  if (!u || !v) return 0;
-  return Math.acos(Math.min(1, Math.max(-1, dot(u, v)))) * 180 / Math.PI;
-}
-function findCorners(pts, closed, cornerAngle, span) {
-  const n = pts.length;
-  const at = (i) => pts[closed ? (i % n + n) % n : i];
-  const reach = (i, step) => {
-    for (let k = 1; k < (closed ? n : Infinity); k++) {
-      const j = i + step * k;
-      if (!closed && (j < 0 || j >= n)) return k > 1 ? j - step : null;
-      if (dist(at(j), pts[i]) >= span) return j;
-    }
-    return null;
-  };
-  const turns = new Float64Array(n);
-  const windows = [];
-  for (let i = 0; i < n; i++) {
-    windows.push([i, i]);
-    if (!closed && (i === 0 || i === n - 1)) continue;
-    const prev = reach(i, -1);
-    const next = reach(i, 1);
-    if (prev === null || next === null) continue;
-    windows[i] = [prev, next];
-    turns[i] = turnDeg(at(prev), pts[i], at(next));
-  }
-  const corners = [];
-  for (let i = 0; i < n; i++) {
-    if (!(turns[i] > cornerAngle)) continue;
-    const [lo, hi] = windows[i];
-    let sharpest = true;
-    for (let j = lo; j <= hi && sharpest; j++) {
-      const k = closed ? (j % n + n) % n : j;
-      if (k === i || dist(pts[k], pts[i]) >= span) continue;
-      if (turns[k] > turns[i] || turns[k] === turns[i] && k < i) sharpest = false;
-    }
-    if (sharpest) corners.push(i);
-  }
-  return corners;
-}
-function densify(run) {
-  if (run.length < 3) return run;
-  const lengths = [];
-  for (let i = 1; i < run.length; i++) lengths.push(dist(run[i - 1], run[i]));
-  const sorted = [...lengths].sort((a, b) => a - b);
-  const median = sorted[sorted.length >> 1];
-  if (!(median > 0)) return run;
-  const out = [run[0]];
-  for (let i = 1; i < run.length; i++) {
-    const len = lengths[i - 1];
-    if (len > 2 * median) {
-      const steps = Math.min(64, Math.ceil(len / median));
-      const a = run[i - 1];
-      const b = run[i];
-      for (let k = 1; k < steps; k++) {
-        const t = k / steps;
-        out.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
-      }
-    }
-    out.push(run[i]);
-  }
-  return out;
-}
-function fitCubics(points, tolerance, options = {}) {
-  let pts = dedup(points);
-  const closed = options.closed === true;
-  if (closed && pts.length > 1 && dist(pts[0], pts[pts.length - 1]) <= 1e-12) pts = pts.slice(0, -1);
-  if (pts.length < 2) return [];
-  const tol = Math.max(tolerance, 1e-6);
-  const cornerAngle = options.cornerAngleDeg ?? 30;
-  const n = pts.length;
-  const span = 4 * tol;
-  if (!closed || n < 3) {
-    const corners2 = [0, ...n > 2 ? findCorners(pts, false, cornerAngle, span) : [], n - 1];
-    const out2 = [];
-    for (let k = 1; k < corners2.length; k++) {
-      const run = pts.slice(corners2[k - 1], corners2[k] + 1);
-      out2.push(...fitCubicRun(densify(run), tol));
-    }
-    if (closed && n === 2) out2.push(...fitCubicRun([pts[1], pts[0]], tol));
-    return out2;
-  }
-  const corners = findCorners(pts, true, cornerAngle, span);
-  if (corners.length === 0) {
-    const ring = [...pts, pts[0]];
-    const t = unit(sub(pts[1], pts[n - 1])) ?? [1, 0];
-    return fitCubicRun(densify(ring), tol, t, t);
-  }
-  const out = [];
-  for (let k = 0; k < corners.length; k++) {
-    const from = corners[k];
-    const to = corners[(k + 1) % corners.length];
-    const run = [];
-    for (let i = from; ; i = (i + 1) % n) {
-      run.push(pts[i]);
-      if (run.length > 1 && i === to) break;
-    }
-    out.push(...fitCubicRun(densify(run), tol));
-  }
-  return out;
-}
-function isStraightCubic(c, tol) {
-  const chord = sub(c.p3, c.p0);
-  const len = Math.hypot(chord[0], chord[1]);
-  if (len < 1e-12) return dist(c.p1, c.p0) <= tol && dist(c.p2, c.p0) <= tol;
-  const dir = [chord[0] / len, chord[1] / len];
-  return [c.p1, c.p2].every((h) => {
-    const v = sub(h, c.p0);
-    const along = dot(v, dir);
-    const across = Math.abs(v[0] * dir[1] - v[1] * dir[0]);
-    return across <= tol && along >= -tol && along <= len + tol;
-  });
-}
-function cubicsToPathData(segments, options = {}) {
-  if (segments.length === 0) return "";
-  const f = (n) => formatNumber(n, options.precision ?? 3);
-  const dx = options.offset?.x ?? 0;
-  const dy = options.offset?.y ?? 0;
-  const pt = (p) => `${f(p[0] + dx)} ${f(p[1] + dy)}`;
-  const straight = options.straightTolerance ?? 1e-3;
-  let d = `M${pt(segments[0].p0)}`;
-  segments.forEach((c, i) => {
-    const last = options.closed && i === segments.length - 1;
-    if (isStraightCubic(c, straight)) {
-      if (!last) d += `L${pt(c.p3)}`;
-    } else d += `C${pt(c.p1)} ${pt(c.p2)} ${pt(c.p3)}`;
-  });
-  return options.closed ? `${d}Z` : d;
-}
-function polylineToPathData(points, closed, options) {
-  if (points.length < 2) return "";
-  const f = (n) => formatNumber(n, options.precision ?? 3);
-  const dx = options.offset?.x ?? 0;
-  const dy = options.offset?.y ?? 0;
-  let d = `M${f(points[0][0] + dx)} ${f(points[0][1] + dy)}`;
-  for (let i = 1; i < points.length; i++) d += `L${f(points[i][0] + dx)} ${f(points[i][1] + dy)}`;
-  return closed ? `${d}Z` : d;
-}
-function fitPathData(ring, options = {}) {
-  const closed = options.closed ?? true;
-  const tolerance = options.tolerance ?? 0.5;
-  const pts = dedup(ring);
-  const segments = fitCubics(pts, tolerance, { ...options, closed });
-  if (segments.length === 0) return "";
-  const edges = closed ? pts.length : pts.length - 1;
-  if (options.noWorse !== false) {
-    const straight = segments.filter((c) => isStraightCubic(c, tolerance * 0.02)).length;
-    if (segments.length >= edges && straight === segments.length) return polylineToPathData(pts, closed, options);
-    if (segments.length > edges) return polylineToPathData(pts, closed, options);
-  }
-  return cubicsToPathData(segments, {
-    precision: options.precision,
-    offset: options.offset,
-    closed,
-    straightTolerance: tolerance * 0.02
-  });
-}
-function fitFreehandPath(points, options = {}) {
-  return fitPathData(points, { tolerance: 1, ...options, closed: false });
-}
-
-// src/canvas/gradient.ts
-var CANVAS_GRADIENT_PRESETS = {
-  sunset: {
-    type: "linear",
-    angle: 90,
-    stops: [
-      { offset: 0, color: "#f97316" },
-      { offset: 1, color: "#ec4899" }
-    ]
-  },
-  ocean: {
-    type: "linear",
-    angle: 90,
-    stops: [
-      { offset: 0, color: "#06b6d4" },
-      { offset: 1, color: "#3b82f6" }
-    ]
-  },
-  aurora: {
-    type: "linear",
-    angle: 90,
-    stops: [
-      { offset: 0, color: "#10b981" },
-      { offset: 1, color: "#6366f1" }
-    ]
-  },
-  neon: {
-    type: "linear",
-    angle: 90,
-    stops: [
-      { offset: 0, color: "#a855f7" },
-      { offset: 1, color: "#ec4899" }
-    ]
-  },
-  amber: {
-    type: "linear",
-    angle: 90,
-    stops: [
-      { offset: 0, color: "#f59e0b" },
-      { offset: 1, color: "#ef4444" }
-    ]
-  },
-  cosmic: {
-    type: "linear",
-    angle: 90,
-    stops: [
-      { offset: 0, color: "#3b82f6" },
-      { offset: 0.5, color: "#8b5cf6" },
-      { offset: 1, color: "#ec4899" }
-    ]
-  }
-};
-function isCanvasGradient(value) {
-  if (!value || typeof value !== "object") return false;
-  const val = value;
-  if (val.type !== "linear" && val.type !== "radial") return false;
-  if (!Array.isArray(val.stops)) return false;
-  return true;
-}
-function splitCssArgs(str) {
-  const parts = [];
-  let depth = 0;
-  let current = "";
-  for (let i = 0; i < str.length; i++) {
-    const char = str[i];
-    if (char === "(") depth++;
-    else if (char === ")") depth = Math.max(0, depth - 1);
-    if (char === "," && depth === 0) {
-      if (current.trim()) parts.push(current.trim());
-      current = "";
-    } else {
-      current += char;
-    }
-  }
-  if (current.trim()) parts.push(current.trim());
-  return parts;
-}
-function parseCssAngle(val) {
-  const trimmed = val.trim().toLowerCase();
-  if (trimmed.endsWith("deg")) {
-    return parseFloat(trimmed);
-  }
-  if (trimmed.endsWith("turn")) {
-    return parseFloat(trimmed) * 360;
-  }
-  if (trimmed.endsWith("rad")) {
-    return parseFloat(trimmed) * 180 / Math.PI;
-  }
-  if (trimmed.startsWith("to ")) {
-    const dir = trimmed.slice(3).trim();
-    if (dir === "bottom") return 180;
-    if (dir === "top") return 0;
-    if (dir === "right") return 90;
-    if (dir === "left") return 270;
-    if (dir === "bottom right" || dir === "right bottom") return 135;
-    if (dir === "bottom left" || dir === "left bottom") return 225;
-    if (dir === "top right" || dir === "right top") return 45;
-    if (dir === "top left" || dir === "left top") return 315;
-  }
-  const n = parseFloat(trimmed);
-  return Number.isFinite(n) ? n : 180;
-}
-function parseCssGradient(css) {
-  const trimmed = css.trim();
-  const linearMatch = trimmed.match(/^linear-gradient\s*\((.*)\)$/is);
-  if (linearMatch) {
-    const rawArgs = splitCssArgs(linearMatch[1]);
-    if (rawArgs.length === 0) return null;
-    let angle = 180;
-    let stopStartIndex = 0;
-    const first = rawArgs[0].trim().toLowerCase();
-    if (first.endsWith("deg") || first.endsWith("turn") || first.endsWith("rad") || first.startsWith("to ")) {
-      angle = parseCssAngle(first);
-      stopStartIndex = 1;
-    }
-    const stopStrings = rawArgs.slice(stopStartIndex);
-    if (stopStrings.length === 0) return null;
-    const stops = parseStopStrings(stopStrings);
-    if (stops.length === 0) return null;
-    return {
-      type: "linear",
-      angle,
-      stops
-    };
-  }
-  const radialMatch = trimmed.match(/^radial-gradient\s*\((.*)\)$/is);
-  if (radialMatch) {
-    const rawArgs = splitCssArgs(radialMatch[1]);
-    if (rawArgs.length === 0) return null;
-    let stopStartIndex = 0;
-    const first = rawArgs[0].trim().toLowerCase();
-    if (first.startsWith("circle") || first.startsWith("ellipse") || first.includes("at ")) {
-      stopStartIndex = 1;
-    }
-    const stopStrings = rawArgs.slice(stopStartIndex);
-    if (stopStrings.length === 0) return null;
-    const stops = parseStopStrings(stopStrings);
-    if (stops.length === 0) return null;
-    return {
-      type: "radial",
-      cx: 0.5,
-      cy: 0.5,
-      r: 0.5,
-      stops
-    };
-  }
-  return null;
-}
-function parseStopStrings(stopStrings) {
-  const count = stopStrings.length;
-  return stopStrings.map((str, idx) => {
-    const parts = str.trim().split(/\s+(?=[0-9%])/);
-    const color = parts[0];
-    let offset = count === 1 ? 0 : idx / (count - 1);
-    if (parts.length > 1) {
-      const posStr = parts[1].trim();
-      if (posStr.endsWith("%")) {
-        offset = parseFloat(posStr) / 100;
-      } else {
-        const val = parseFloat(posStr);
-        if (Number.isFinite(val)) offset = val;
-      }
-    }
-    return {
-      offset: Math.min(1, Math.max(0, offset)),
-      color
-    };
-  });
-}
-function resolveCanvasGradient(value) {
-  if (!value) return null;
-  if (isCanvasGradient(value)) return value;
-  if (typeof value === "string") {
-    const lower = value.trim().toLowerCase();
-    if (CANVAS_GRADIENT_PRESETS[lower]) {
-      return CANVAS_GRADIENT_PRESETS[lower];
-    }
-    if (lower.startsWith("linear-gradient") || lower.startsWith("radial-gradient")) {
-      return parseCssGradient(value);
-    }
-  }
-  return null;
-}
-function angleToSvgLinearCoords(angleDeg = 180) {
-  const rad = (90 - angleDeg) * Math.PI / 180;
-  const dx = Math.cos(rad);
-  const dy = -Math.sin(rad);
-  const half = 0.5;
-  return {
-    x1: Math.round((half - dx * half) * 1e3) / 1e3,
-    y1: Math.round((half - dy * half) * 1e3) / 1e3,
-    x2: Math.round((half + dx * half) * 1e3) / 1e3,
-    y2: Math.round((half + dy * half) * 1e3) / 1e3
-  };
-}
-function gradientToSvgDef(gradient, id) {
-  const stops = (gradient.stops ?? []).map((s) => ({
-    offset: `${Math.round(s.offset * 1e3) / 10}%`,
-    stopColor: s.color,
-    stopOpacity: s.opacity
-  }));
-  if (gradient.type === "radial") {
-    return {
-      id,
-      type: "radial",
-      attrs: {
-        cx: gradient.cx !== void 0 ? `${gradient.cx * 100}%` : "50%",
-        cy: gradient.cy !== void 0 ? `${gradient.cy * 100}%` : "50%",
-        r: gradient.r !== void 0 ? `${gradient.r * 100}%` : "50%"
-      },
-      stops
-    };
-  }
-  const coords = angleToSvgLinearCoords(gradient.angle ?? 180);
-  return {
-    id,
-    type: "linear",
-    attrs: {
-      x1: `${coords.x1 * 100}%`,
-      y1: `${coords.y1 * 100}%`,
-      x2: `${coords.x2 * 100}%`,
-      y2: `${coords.y2 * 100}%`
-    },
-    stops
-  };
-}
-
-// src/canvas/shapeGeometry.ts
-var SHAPE_KINDS = ["rect", "ellipse", "polygon", "star", "path"];
-function isShapeDescription(value) {
-  if (!value || typeof value !== "object") return false;
-  const kind = value.kind;
-  if (!SHAPE_KINDS.includes(kind)) return false;
-  return kind !== "path" || typeof value.d === "string";
-}
-var PARAM_COUNTS = { m: 2, l: 2, h: 1, v: 1, c: 6, s: 4, q: 4, t: 2, a: 7, z: 0 };
-var PathScanner = class {
-  constructor(text) {
-    this.text = text;
-  }
-  text;
-  pos = 0;
-  skip() {
-    while (this.pos < this.text.length && /[\s,]/.test(this.text[this.pos])) this.pos++;
-  }
-  /** The next command letter, or `null` when a number (or the end) follows. */
-  command() {
-    this.skip();
-    const ch = this.text[this.pos];
-    if (ch && /[MmLlHhVvCcSsQqTtAaZz]/.test(ch)) {
-      this.pos++;
-      return ch;
-    }
-    return null;
-  }
-  done() {
-    this.skip();
-    return this.pos >= this.text.length;
-  }
-  number() {
-    this.skip();
-    const match = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/.exec(this.text.slice(this.pos, this.pos + 64));
-    if (!match) return null;
-    this.pos += match[0].length;
-    const value = Number(match[0]);
-    return Number.isFinite(value) ? value : null;
-  }
-  flag() {
-    this.skip();
-    const ch = this.text[this.pos];
-    if (ch === "0" || ch === "1") {
-      this.pos++;
-      return ch === "1" ? 1 : 0;
-    }
-    return null;
-  }
-};
-function parseSvgPath(d) {
-  const scanner = new PathScanner(d ?? "");
-  const commands = [];
-  let cx = 0;
-  let cy = 0;
-  let startX = 0;
-  let startY = 0;
-  let lastControl = null;
-  let command = "";
-  while (!scanner.done()) {
-    const letter = scanner.command();
-    if (letter) {
-      command = letter;
-      if (command === "z" || command === "Z") {
-        commands.push({ type: "Z" });
-        cx = startX;
-        cy = startY;
-        lastControl = null;
-        continue;
-      }
-    } else if (!command || command === "z" || command === "Z") {
-      break;
-    }
-    const lower = command.toLowerCase();
-    const count = PARAM_COUNTS[lower];
-    const args = [];
-    for (let k = 0; k < count; k++) {
-      const value = lower === "a" && (k === 3 || k === 4) ? scanner.flag() : scanner.number();
-      if (value === null) return commands;
-      args.push(value);
-    }
-    const rel = command !== command.toUpperCase();
-    const ox = rel ? cx : 0;
-    const oy = rel ? cy : 0;
-    switch (lower) {
-      case "m": {
-        cx = args[0] + ox;
-        cy = args[1] + oy;
-        startX = cx;
-        startY = cy;
-        commands.push({ type: "M", x: cx, y: cy });
-        lastControl = null;
-        command = rel ? "l" : "L";
-        break;
-      }
-      case "l":
-        cx = args[0] + ox;
-        cy = args[1] + oy;
-        commands.push({ type: "L", x: cx, y: cy });
-        lastControl = null;
-        break;
-      case "h":
-        cx = args[0] + (rel ? cx : 0);
-        commands.push({ type: "L", x: cx, y: cy });
-        lastControl = null;
-        break;
-      case "v":
-        cy = args[0] + (rel ? cy : 0);
-        commands.push({ type: "L", x: cx, y: cy });
-        lastControl = null;
-        break;
-      case "c": {
-        const c = {
-          type: "C",
-          x1: args[0] + ox,
-          y1: args[1] + oy,
-          x2: args[2] + ox,
-          y2: args[3] + oy,
-          x: args[4] + ox,
-          y: args[5] + oy
-        };
-        commands.push(c);
-        lastControl = { x: c.x2, y: c.y2, type: "C" };
-        cx = c.x;
-        cy = c.y;
-        break;
-      }
-      case "s": {
-        const x1 = lastControl?.type === "C" ? 2 * cx - lastControl.x : cx;
-        const y1 = lastControl?.type === "C" ? 2 * cy - lastControl.y : cy;
-        const c = {
-          type: "C",
-          x1,
-          y1,
-          x2: args[0] + ox,
-          y2: args[1] + oy,
-          x: args[2] + ox,
-          y: args[3] + oy
-        };
-        commands.push(c);
-        lastControl = { x: c.x2, y: c.y2, type: "C" };
-        cx = c.x;
-        cy = c.y;
-        break;
-      }
-      case "q": {
-        const c = { type: "Q", x1: args[0] + ox, y1: args[1] + oy, x: args[2] + ox, y: args[3] + oy };
-        commands.push(c);
-        lastControl = { x: c.x1, y: c.y1, type: "Q" };
-        cx = c.x;
-        cy = c.y;
-        break;
-      }
-      case "t": {
-        const x1 = lastControl?.type === "Q" ? 2 * cx - lastControl.x : cx;
-        const y1 = lastControl?.type === "Q" ? 2 * cy - lastControl.y : cy;
-        const c = { type: "Q", x1, y1, x: args[0] + ox, y: args[1] + oy };
-        commands.push(c);
-        lastControl = { x: x1, y: y1, type: "Q" };
-        cx = c.x;
-        cy = c.y;
-        break;
-      }
-      case "a": {
-        const c = {
-          type: "A",
-          rx: Math.abs(args[0]),
-          ry: Math.abs(args[1]),
-          rotation: args[2],
-          largeArc: args[3] !== 0,
-          sweep: args[4] !== 0,
-          x: args[5] + ox,
-          y: args[6] + oy
-        };
-        commands.push(c);
-        lastControl = null;
-        cx = c.x;
-        cy = c.y;
-        break;
-      }
-    }
-  }
-  return commands;
-}
-function segmentCount(curvature, tolerance, max) {
-  if (!(curvature > 0)) return 1;
-  return Math.max(1, Math.min(max, Math.ceil(Math.sqrt(curvature / tolerance))));
-}
-function flattenCubic(out, p0, x1, y1, x2, y2, x, y, tolerance, max) {
-  const dd = Math.max(
-    Math.hypot(p0[0] - 2 * x1 + x2, p0[1] - 2 * y1 + y2),
-    Math.hypot(x1 - 2 * x2 + x, y1 - 2 * y2 + y)
-  );
-  const n = segmentCount(6 * dd / 8, tolerance, max);
-  for (let k = 1; k <= n; k++) {
-    const t = k / n;
-    const mt = 1 - t;
-    const a = mt * mt * mt;
-    const b = 3 * mt * mt * t;
-    const c = 3 * mt * t * t;
-    const e = t * t * t;
-    out.push([a * p0[0] + b * x1 + c * x2 + e * x, a * p0[1] + b * y1 + c * y2 + e * y]);
-  }
-}
-function flattenQuadratic(out, p0, x1, y1, x, y, tolerance, max) {
-  const dd = Math.hypot(p0[0] - 2 * x1 + x, p0[1] - 2 * y1 + y);
-  const n = segmentCount(2 * dd / 8, tolerance, max);
-  for (let k = 1; k <= n; k++) {
-    const t = k / n;
-    const mt = 1 - t;
-    out.push([mt * mt * p0[0] + 2 * mt * t * x1 + t * t * x, mt * mt * p0[1] + 2 * mt * t * y1 + t * t * y]);
-  }
-}
-function arcSteps(radius, sweep, tolerance, max) {
-  if (radius <= tolerance) return Math.max(1, Math.ceil(Math.abs(sweep) / (Math.PI / 2)));
-  const step = 2 * Math.acos(1 - tolerance / radius);
-  return Math.max(1, Math.min(max, Math.ceil(Math.abs(sweep) / step)));
-}
-function flattenArc(out, p0, cmd, tolerance, max) {
-  const [x0, y0] = p0;
-  let { rx, ry } = cmd;
-  const { x, y } = cmd;
-  if (x0 === x && y0 === y) return;
-  if (rx === 0 || ry === 0) {
-    out.push([x, y]);
-    return;
-  }
-  const phi = cmd.rotation * Math.PI / 180;
-  const cos = Math.cos(phi);
-  const sin = Math.sin(phi);
-  const dx = (x0 - x) / 2;
-  const dy = (y0 - y) / 2;
-  const x1p = cos * dx + sin * dy;
-  const y1p = -sin * dx + cos * dy;
-  const lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
-  if (lambda > 1) {
-    const s = Math.sqrt(lambda);
-    rx *= s;
-    ry *= s;
-  }
-  const num2 = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
-  const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
-  let coef = den === 0 ? 0 : Math.sqrt(Math.max(0, num2 / den));
-  if (cmd.largeArc === cmd.sweep) coef = -coef;
-  const cxp = coef * rx * y1p / ry;
-  const cyp = -coef * ry * x1p / rx;
-  const cx = cos * cxp - sin * cyp + (x0 + x) / 2;
-  const cy = sin * cxp + cos * cyp + (y0 + y) / 2;
-  const angle = (ux, uy, vx, vy) => {
-    const a = Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
-    return a;
-  };
-  const theta1 = angle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);
-  let delta = angle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry);
-  if (!cmd.sweep && delta > 0) delta -= 2 * Math.PI;
-  else if (cmd.sweep && delta < 0) delta += 2 * Math.PI;
-  const n = arcSteps(Math.max(rx, ry), delta, tolerance, max);
-  for (let k = 1; k < n; k++) {
-    const t = theta1 + delta * k / n;
-    const ex = rx * Math.cos(t);
-    const ey = ry * Math.sin(t);
-    out.push([cos * ex - sin * ey + cx, sin * ex + cos * ey + cy]);
-  }
-  out.push([x, y]);
-}
-function flattenSvgPath(d, options = {}) {
-  const tolerance = options.tolerance && options.tolerance > 0 ? options.tolerance : 0.25;
-  const max = options.maxSegments ?? 512;
-  const commands = typeof d === "string" ? parseSvgPath(d) : d;
-  const rings = [];
-  let current = [];
-  let start = [0, 0];
-  const flush = () => {
-    if (current.length >= 3) rings.push(current);
-    current = [];
-  };
-  const last = () => current[current.length - 1] ?? start;
-  for (const cmd of commands) {
-    switch (cmd.type) {
-      case "M":
-        flush();
-        start = [cmd.x, cmd.y];
-        current = [start];
-        break;
-      case "L":
-        if (current.length === 0) current = [start];
-        current.push([cmd.x, cmd.y]);
-        break;
-      case "C":
-        if (current.length === 0) current = [start];
-        flattenCubic(current, last(), cmd.x1, cmd.y1, cmd.x2, cmd.y2, cmd.x, cmd.y, tolerance, max);
-        break;
-      case "Q":
-        if (current.length === 0) current = [start];
-        flattenQuadratic(current, last(), cmd.x1, cmd.y1, cmd.x, cmd.y, tolerance, max);
-        break;
-      case "A":
-        if (current.length === 0) current = [start];
-        flattenArc(current, last(), cmd, tolerance, max);
-        break;
-      case "Z":
-        flush();
-        break;
-    }
-  }
-  flush();
-  return rings.map(dedupeRing).filter((r) => r.length >= 3);
-}
-function dedupeRing(ring) {
-  const out = [];
-  for (const p of ring) {
-    const prev = out[out.length - 1];
-    if (!prev || prev[0] !== p[0] || prev[1] !== p[1]) out.push(p);
-  }
-  while (out.length > 1 && out[0][0] === out[out.length - 1][0] && out[0][1] === out[out.length - 1][1]) out.pop();
-  return out;
-}
-function cornerRadii(shape, width, height) {
-  const raw = shape.cornerRadius ?? 0;
-  let radii = (typeof raw === "number" ? [raw, raw, raw, raw] : [...raw]).map(
-    (r) => Number.isFinite(r) && r > 0 ? r : 0
-  );
-  const factor = Math.min(
-    1,
-    width / Math.max(radii[0] + radii[1], 1e-12),
-    height / Math.max(radii[1] + radii[2], 1e-12),
-    width / Math.max(radii[2] + radii[3], 1e-12),
-    height / Math.max(radii[3] + radii[0], 1e-12)
-  );
-  if (factor < 1) radii = radii.map((r) => r * factor);
-  return radii;
-}
-function polygonVertices(count, inner, width, height) {
-  const raw = [];
-  const total = inner === null ? count : count * 2;
-  for (let k = 0; k < total; k++) {
-    const angle = -Math.PI / 2 + k * 2 * Math.PI / total;
-    const r = inner !== null && k % 2 === 1 ? inner : 1;
-    raw.push([r * Math.cos(angle), r * Math.sin(angle)]);
-  }
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const [x, y] of raw) {
-    minX = Math.min(minX, x);
-    minY = Math.min(minY, y);
-    maxX = Math.max(maxX, x);
-    maxY = Math.max(maxY, y);
-  }
-  const sx = width / (maxX - minX || 1);
-  const sy = height / (maxY - minY || 1);
-  return raw.map(([x, y]) => [(x - minX) * sx, (y - minY) * sy]);
-}
-function rotationTransform(shape, size) {
-  const deg = shape.rotation ?? 0;
-  if (!deg || !Number.isFinite(deg)) return null;
-  const rad = deg * Math.PI / 180;
-  const cos = Math.cos(rad);
-  const sin = Math.sin(rad);
-  const cx = size.width / 2;
-  const cy = size.height / 2;
-  return ([x, y]) => [cx + (x - cx) * cos - (y - cy) * sin, cy + (x - cx) * sin + (y - cy) * cos];
-}
-function getShapeSvg(shape, size) {
-  const { width: w, height: h } = size;
-  const f = (n) => formatNumber2(n, 3);
-  const transforms = [];
-  if (shape.rotation) transforms.push(`rotate(${f(shape.rotation)} ${f(w / 2)} ${f(h / 2)})`);
-  let d = "";
-  let fillRule = "nonzero";
-  switch (shape.kind) {
-    case "rect": {
-      const [tl, tr, br, bl] = cornerRadii(shape, w, h);
-      if (tl + tr + br + bl === 0) {
-        d = `M0 0H${f(w)}V${f(h)}H0Z`;
-      } else {
-        const arc = (r, x, y) => r > 0 ? `A${f(r)} ${f(r)} 0 0 1 ${f(x)} ${f(y)}` : "";
-        d = `M${f(tl)} 0H${f(w - tr)}${arc(tr, w, tr)}V${f(h - br)}${arc(br, w - br, h)}H${f(bl)}${arc(bl, 0, h - bl)}V${f(tl)}${arc(tl, tl, 0)}Z`;
-      }
-      break;
-    }
-    case "ellipse": {
-      const rx = w / 2;
-      const ry = h / 2;
-      d = `M0 ${f(ry)}A${f(rx)} ${f(ry)} 0 1 1 ${f(w)} ${f(ry)}A${f(rx)} ${f(ry)} 0 1 1 0 ${f(ry)}Z`;
-      break;
-    }
-    case "polygon":
-    case "star": {
-      const points = shape.kind === "polygon" ? polygonVertices(Math.max(3, Math.floor(shape.sides ?? 6)), null, w, h) : polygonVertices(Math.max(3, Math.floor(shape.points ?? 5)), clampRatio(shape.innerRadius), w, h);
-      d = ringsToPath([points], f);
-      break;
-    }
-    case "path": {
-      d = shape.d;
-      fillRule = shape.fillRule ?? "nonzero";
-      const vb = validViewBox(shape.viewBox);
-      if (vb) {
-        transforms.push(
-          `scale(${f(w / vb[2])} ${f(h / vb[3])})`,
-          `translate(${f(-vb[0])} ${f(-vb[1])})`
-        );
-      }
-      break;
-    }
-  }
-  return transforms.length > 0 ? { d, transform: transforms.join(" "), fillRule } : { d, fillRule };
-}
-function getShapeRenderData(shape, size = {}, options = {}) {
-  const vb = shape.kind === "path" ? validViewBox(shape.viewBox) : null;
-  const width = size.width && size.width > 0 ? size.width : vb ? vb[2] : 100;
-  const height = size.height && size.height > 0 ? size.height : vb ? vb[3] : 100;
-  const svg = getShapeSvg(shape, { width, height });
-  const baseId = options.id || Math.random().toString(36).slice(2, 9);
-  let fillStr = "currentColor";
-  let fillGradientDef;
-  const rawFill = shape.fillGradient ?? shape.fill;
-  const resolvedFillGradient = resolveCanvasGradient(rawFill);
-  if (resolvedFillGradient) {
-    const gradId = `shape-fill-${baseId}`;
-    fillGradientDef = gradientToSvgDef(resolvedFillGradient, gradId);
-    fillStr = `url(#${gradId})`;
-  } else if (typeof shape.fill === "string") {
-    fillStr = shape.fill;
-  } else if (shape.fill === void 0) {
-    fillStr = "currentColor";
-  }
-  let strokeStr = "none";
-  let strokeGradientDef;
-  const rawStroke = shape.strokeGradient ?? shape.stroke;
-  const resolvedStrokeGradient = resolveCanvasGradient(rawStroke);
-  if (resolvedStrokeGradient) {
-    const gradId = `shape-stroke-${baseId}`;
-    strokeGradientDef = gradientToSvgDef(resolvedStrokeGradient, gradId);
-    strokeStr = `url(#${gradId})`;
-  } else if (typeof shape.stroke === "string") {
-    strokeStr = shape.stroke;
-  } else if (shape.stroke === void 0) {
-    strokeStr = "none";
-  }
-  const data = {
-    viewBox: `0 0 ${formatNumber2(width, 3)} ${formatNumber2(height, 3)}`,
-    width,
-    height,
-    d: svg.d,
-    fillRule: svg.fillRule,
-    fill: fillStr,
-    stroke: strokeStr,
-    strokeWidth: shape.strokeWidth ?? 1
-  };
-  if (svg.transform) data.transform = svg.transform;
-  if (shape.opacity !== void 0) data.opacity = shape.opacity;
-  if (shape.strokeLinecap) data.strokeLinecap = shape.strokeLinecap;
-  if (shape.strokeLinejoin) data.strokeLinejoin = shape.strokeLinejoin;
-  if (fillGradientDef) data.fillGradient = fillGradientDef;
-  if (strokeGradientDef) data.strokeGradient = strokeGradientDef;
-  return data;
-}
-function clampRatio(value) {
-  if (value === void 0 || !Number.isFinite(value)) return 0.5;
-  return Math.min(1, Math.max(0.01, value));
-}
-function validViewBox(vb) {
-  if (!vb || vb.length !== 4 || !vb.every(Number.isFinite) || vb[2] <= 0 || vb[3] <= 0) return null;
-  return vb;
-}
-function shapeToPolygon(shape, size, options = {}) {
-  const { width: w, height: h } = size;
-  if (!(w > 0) || !(h > 0)) return { rings: [], fillRule: "nonzero" };
-  let rings;
-  let fillRule = "nonzero";
-  if (shape.kind === "path") {
-    fillRule = shape.fillRule ?? "nonzero";
-    const vb = validViewBox(shape.viewBox);
-    if (vb) {
-      const sx = w / vb[2];
-      const sy = h / vb[3];
-      const tolerance = (options.tolerance ?? 0.25) / Math.max(sx, sy);
-      rings = flattenSvgPath(shape.d, { ...options, tolerance }).map(
-        (ring) => ring.map(([x, y]) => [(x - vb[0]) * sx, (y - vb[1]) * sy])
-      );
-    } else {
-      rings = flattenSvgPath(shape.d, options);
-    }
-  } else {
-    const { d } = getShapeSvg({ ...shape, rotation: 0 }, size);
-    rings = flattenSvgPath(d, options);
-  }
-  const rotate = rotationTransform(shape, size);
-  if (rotate) rings = rings.map((ring) => ring.map(rotate));
-  return { rings, fillRule };
-}
-function formatNumber2(value, precision = 3) {
-  const factor = 10 ** precision;
-  const rounded = Math.round(value * factor) / factor;
-  return Object.is(rounded, -0) ? "0" : String(rounded);
-}
-function ringsToPath(rings, f) {
-  let d = "";
-  for (const ring of rings) {
-    if (ring.length < 2) continue;
-    d += `M${f(ring[0][0])} ${f(ring[0][1])}`;
-    for (let i = 1; i < ring.length; i++) d += `L${f(ring[i][0])} ${f(ring[i][1])}`;
-    d += "Z";
-  }
-  return d;
-}
-function segmentDistance(p, a, b) {
-  const dx = b[0] - a[0];
-  const dy = b[1] - a[1];
-  const len2 = dx * dx + dy * dy;
-  if (len2 === 0) return Math.hypot(p[0] - a[0], p[1] - a[1]);
-  const t = Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2));
-  return Math.hypot(p[0] - (a[0] + t * dx), p[1] - (a[1] + t * dy));
-}
-function rdp(points, tolerance) {
-  if (points.length <= 2) return points;
-  const keep = new Uint8Array(points.length);
-  keep[0] = 1;
-  keep[points.length - 1] = 1;
-  const stack = [[0, points.length - 1]];
-  while (stack.length) {
-    const [s, e] = stack.pop();
-    let maxDist = -1;
-    let index = -1;
-    for (let i = s + 1; i < e; i++) {
-      const dist3 = segmentDistance(points[i], points[s], points[e]);
-      if (dist3 > maxDist) {
-        maxDist = dist3;
-        index = i;
-      }
-    }
-    if (index !== -1 && maxDist > tolerance) {
-      keep[index] = 1;
-      stack.push([s, index], [index, e]);
-    }
-  }
-  return points.filter((_, i) => keep[i]);
-}
-function simplifyRing(ring, tolerance) {
-  if (ring.length <= 3 || !(tolerance > 0)) return [...ring];
-  let far = 0;
-  let farDist = -1;
-  for (let i = 1; i < ring.length; i++) {
-    const dist3 = Math.hypot(ring[i][0] - ring[0][0], ring[i][1] - ring[0][1]);
-    if (dist3 > farDist) {
-      farDist = dist3;
-      far = i;
-    }
-  }
-  const first = rdp(ring.slice(0, far + 1), tolerance);
-  const second = rdp([...ring.slice(far), ring[0]], tolerance);
-  const out = [...first.slice(0, -1), ...second.slice(0, -1)];
-  return out.length >= 3 ? out : [];
-}
-function polygonToSvgPath(input, options = {}) {
-  const precision = options.precision ?? 3;
-  const f = (n) => formatNumber2(n, precision);
-  const dx = options.offset?.x ?? 0;
-  const dy = options.offset?.y ?? 0;
-  const rings = [];
-  const fit = options.curves === "fit";
-  let fitted = "";
-  for (const item of input) {
-    const list = item.length > 0 && Array.isArray(item[0]) && Array.isArray(item[0][0]) ? item : [item];
-    for (const ring of list) {
-      let r = ring;
-      if (options.simplify && options.simplify > 0) r = simplifyRing(r, options.simplify);
-      if (r.length < 3) continue;
-      if (fit) {
-        fitted += fitPathData(r, {
-          tolerance: options.curveTolerance ?? 0.25,
-          cornerAngleDeg: options.cornerAngleDeg,
-          precision,
-          offset: { x: dx, y: dy }
-        });
-        continue;
-      }
-      rings.push(dx || dy ? r.map(([x, y]) => [x + dx, y + dy]) : r);
-    }
-  }
-  return fit ? fitted : ringsToPath(rings, f);
-}
-
-// src/canvas/pathops/bezier.ts
-var sub2 = (a, b) => [a[0] - b[0], a[1] - b[1]];
-var add2 = (a, b) => [a[0] + b[0], a[1] + b[1]];
-var scale = (a, s) => [a[0] * s, a[1] * s];
-var dot2 = (a, b) => a[0] * b[0] + a[1] * b[1];
-var cross = (a, b) => a[0] * b[1] - a[1] * b[0];
-var dist2 = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
-var lerp = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
-var samePoint = (a, b) => a[0] === b[0] && a[1] === b[1];
-function unit2(v) {
-  const l = Math.hypot(v[0], v[1]);
-  return l > 0 && Number.isFinite(l) ? [v[0] / l, v[1] / l] : null;
-}
-function segmentPoint(seg, t) {
-  const n = seg.length;
-  if (n === 2) return lerp(seg[0], seg[1], t);
-  const mt = 1 - t;
-  if (n === 3) {
-    const a2 = mt * mt;
-    const b2 = 2 * mt * t;
-    const c2 = t * t;
-    return [a2 * seg[0][0] + b2 * seg[1][0] + c2 * seg[2][0], a2 * seg[0][1] + b2 * seg[1][1] + c2 * seg[2][1]];
-  }
-  const a = mt * mt * mt;
-  const b = 3 * mt * mt * t;
-  const c = 3 * mt * t * t;
-  const d = t * t * t;
-  return [
-    a * seg[0][0] + b * seg[1][0] + c * seg[2][0] + d * seg[3][0],
-    a * seg[0][1] + b * seg[1][1] + c * seg[2][1] + d * seg[3][1]
-  ];
-}
-function segmentDerivative(seg, t) {
-  const n = seg.length;
-  if (n === 2) return sub2(seg[1], seg[0]);
-  if (n === 3) {
-    const a2 = sub2(seg[1], seg[0]);
-    const b2 = sub2(seg[2], seg[1]);
-    return [2 * ((1 - t) * a2[0] + t * b2[0]), 2 * ((1 - t) * a2[1] + t * b2[1])];
-  }
-  const a = sub2(seg[1], seg[0]);
-  const b = sub2(seg[2], seg[1]);
-  const c = sub2(seg[3], seg[2]);
-  const mt = 1 - t;
-  return [
-    3 * (mt * mt * a[0] + 2 * mt * t * b[0] + t * t * c[0]),
-    3 * (mt * mt * a[1] + 2 * mt * t * b[1] + t * t * c[1])
-  ];
-}
-function segmentSecondDerivative(seg, t) {
-  const n = seg.length;
-  if (n === 2) return [0, 0];
-  if (n === 3) return [2 * (seg[2][0] - 2 * seg[1][0] + seg[0][0]), 2 * (seg[2][1] - 2 * seg[1][1] + seg[0][1])];
-  const a = [seg[2][0] - 2 * seg[1][0] + seg[0][0], seg[2][1] - 2 * seg[1][1] + seg[0][1]];
-  const b = [seg[3][0] - 2 * seg[2][0] + seg[1][0], seg[3][1] - 2 * seg[2][1] + seg[1][1]];
-  return [6 * ((1 - t) * a[0] + t * b[0]), 6 * ((1 - t) * a[1] + t * b[1])];
-}
-function segmentTangent(seg, t) {
-  const d = unit2(segmentDerivative(seg, t));
-  if (d) return d;
-  const h = t < 0.5 ? Math.min(1, t + 1e-6) : Math.max(0, t - 1e-6);
-  const e = unit2(segmentDerivative(seg, h));
-  if (e) return e;
-  return unit2(sub2(seg[seg.length - 1], seg[0])) ?? [1, 0];
-}
-function segmentCurvature(seg, t) {
-  if (seg.length === 2) return 0;
-  let d = segmentDerivative(seg, t);
-  let tt = t;
-  if (Math.hypot(d[0], d[1]) < 1e-12) {
-    tt = t < 0.5 ? Math.min(1, t + 1e-6) : Math.max(0, t - 1e-6);
-    d = segmentDerivative(seg, tt);
-  }
-  const dd = segmentSecondDerivative(seg, tt);
-  const len = Math.hypot(d[0], d[1]);
-  if (!(len > 0)) return 0;
-  return cross(d, dd) / (len * len * len);
-}
-function splitSegment(seg, t) {
-  const n = seg.length;
-  if (n === 2) {
-    const m2 = lerp(seg[0], seg[1], t);
-    return [
-      [seg[0], m2],
-      [m2, seg[1]]
-    ];
-  }
-  if (n === 3) {
-    const a2 = lerp(seg[0], seg[1], t);
-    const b2 = lerp(seg[1], seg[2], t);
-    const m2 = lerp(a2, b2, t);
-    return [
-      [seg[0], a2, m2],
-      [m2, b2, seg[2]]
-    ];
-  }
-  const a = lerp(seg[0], seg[1], t);
-  const b = lerp(seg[1], seg[2], t);
-  const c = lerp(seg[2], seg[3], t);
-  const ab = lerp(a, b, t);
-  const bc = lerp(b, c, t);
-  const m = lerp(ab, bc, t);
-  return [
-    [seg[0], a, ab, m],
-    [m, bc, c, seg[3]]
-  ];
-}
-function subSegment(seg, t0, t1) {
-  if (t1 < t0) return subSegment(seg, t1, t0).reverse();
-  if (t0 <= 0 && t1 >= 1) return [...seg];
-  let s = [...seg];
-  if (t1 < 1) s = splitSegment(s, t1)[0];
-  if (t0 > 0) s = splitSegment(s, t1 > 0 ? t0 / t1 : 0)[1];
-  return s;
-}
-function isStraightSegment(seg, tol) {
-  if (seg.length === 2) return true;
-  const a = seg[0];
-  const b = seg[seg.length - 1];
-  const chord = sub2(b, a);
-  const len = Math.hypot(chord[0], chord[1]);
-  for (let i = 1; i < seg.length - 1; i++) {
-    const v = sub2(seg[i], a);
-    if (len === 0) {
-      if (Math.hypot(v[0], v[1]) > tol) return false;
-      continue;
-    }
-    if (Math.abs(cross(chord, v)) / len > tol) return false;
-    const along = dot2(chord, v) / len;
-    if (along < -tol || along > len + tol) return false;
-  }
-  return true;
-}
-function quadraticRoots(a, b, c, out) {
-  const push = (t) => {
-    if (t > 1e-12 && t < 1 - 1e-12) out.push(t);
-  };
-  const scaleAbs = Math.max(Math.abs(a), Math.abs(b), Math.abs(c));
-  if (scaleAbs === 0) return;
-  if (Math.abs(a) <= 1e-12 * scaleAbs) {
-    if (b !== 0) push(-c / b);
-    return;
-  }
-  const disc = b * b - 4 * a * c;
-  if (disc < 0) return;
-  const sq = Math.sqrt(disc);
-  const q = -0.5 * (b + (b >= 0 ? sq : -sq));
-  push(q / a);
-  if (q !== 0) push(c / q);
-}
-function segmentExtrema(seg, axis) {
-  const out = [];
-  if (seg.length === 3) {
-    const d = seg[0][axis] - 2 * seg[1][axis] + seg[2][axis];
-    if (d !== 0) {
-      const t = (seg[0][axis] - seg[1][axis]) / d;
-      if (t > 1e-12 && t < 1 - 1e-12) out.push(t);
-    }
-  } else if (seg.length === 4) {
-    const p0 = seg[0][axis];
-    const p1 = seg[1][axis];
-    const p2 = seg[2][axis];
-    const p3 = seg[3][axis];
-    const a = -p0 + 3 * p1 - 3 * p2 + p3;
-    const b = 2 * (p0 - 2 * p1 + p2);
-    const c = p1 - p0;
-    quadraticRoots(a, b, c, out);
-  }
-  return out.sort((x, y) => x - y);
-}
-function segmentBounds(seg) {
-  const a = seg[0];
-  const b = seg[seg.length - 1];
-  let minX = Math.min(a[0], b[0]);
-  let maxX = Math.max(a[0], b[0]);
-  let minY = Math.min(a[1], b[1]);
-  let maxY = Math.max(a[1], b[1]);
-  for (const axis of [0, 1]) {
-    for (const t of segmentExtrema(seg, axis)) {
-      const p = segmentPoint(seg, t);
-      if (axis === 0) {
-        minX = Math.min(minX, p[0]);
-        maxX = Math.max(maxX, p[0]);
-      } else {
-        minY = Math.min(minY, p[1]);
-        maxY = Math.max(maxY, p[1]);
-      }
-    }
-  }
-  return { minX, minY, maxX, maxY };
-}
-function monotoneParams(seg) {
-  if (seg.length === 2) return [];
-  const ts = [...segmentExtrema(seg, 0), ...segmentExtrema(seg, 1)].sort((a, b) => a - b);
-  const out = [];
-  for (const t of ts) if (out.length === 0 || t - out[out.length - 1] > 1e-9) out.push(t);
-  return out;
-}
-function segmentAreaTerm(seg) {
-  if (seg.length === 2) return (seg[0][0] * seg[1][1] - seg[1][0] * seg[0][1]) / 2;
-  const nodes = [-Math.sqrt(3 / 5), 0, Math.sqrt(3 / 5)];
-  const weights = [5 / 9, 8 / 9, 5 / 9];
-  let sum = 0;
-  for (let i = 0; i < 3; i++) {
-    const t = (nodes[i] + 1) / 2;
-    const p = segmentPoint(seg, t);
-    const d = segmentDerivative(seg, t);
-    sum += weights[i] * (p[0] * d[1] - p[1] * d[0]);
-  }
-  return sum / 4;
-}
-var GL_X = [
-  -0.9602898564975363,
-  -0.7966664774136267,
-  -0.525532409916329,
-  -0.1834346424956498,
-  0.1834346424956498,
-  0.525532409916329,
-  0.7966664774136267,
-  0.9602898564975363
-];
-var GL_W = [
-  0.1012285362903763,
-  0.2223810344533745,
-  0.3137066458778873,
-  0.362683783378362,
-  0.362683783378362,
-  0.3137066458778873,
-  0.2223810344533745,
-  0.1012285362903763
-];
-function glLength(seg, t0, t1) {
-  const half = (t1 - t0) / 2;
-  const mid = (t0 + t1) / 2;
-  let sum = 0;
-  for (let i = 0; i < GL_X.length; i++) {
-    const d = segmentDerivative(seg, mid + half * GL_X[i]);
-    sum += GL_W[i] * Math.hypot(d[0], d[1]);
-  }
-  return sum * half;
-}
-function adaptiveLength(seg, t0, t1, whole, tol, depth) {
-  const m = (t0 + t1) / 2;
-  const left = glLength(seg, t0, m);
-  const right = glLength(seg, m, t1);
-  if (depth >= 18 || Math.abs(left + right - whole) <= tol) return left + right;
-  return adaptiveLength(seg, t0, m, left, tol / 2, depth + 1) + adaptiveLength(seg, m, t1, right, tol / 2, depth + 1);
-}
-function segmentLength(seg, t0 = 0, t1 = 1, tolerance = 1e-9) {
-  if (t1 < t0) return segmentLength(seg, t1, t0, tolerance);
-  if (seg.length === 2) return dist2(seg[0], seg[1]) * (t1 - t0);
-  const whole = glLength(seg, t0, t1);
-  return adaptiveLength(seg, t0, t1, whole, Math.max(tolerance, whole * 1e-12), 0);
-}
-function segmentParamAtLength(seg, length, total = segmentLength(seg)) {
-  if (!(total > 0) || length <= 0) return 0;
-  if (length >= total) return 1;
-  if (seg.length === 2) return length / total;
-  let lo = 0;
-  let hi = 1;
-  let t = length / total;
-  for (let i = 0; i < 40; i++) {
-    const err = segmentLength(seg, 0, t) - length;
-    if (Math.abs(err) <= 1e-10 * Math.max(1, total)) break;
-    if (err > 0) hi = t;
-    else lo = t;
-    const d = segmentDerivative(seg, t);
-    const speed = Math.hypot(d[0], d[1]);
-    let next = speed > 0 ? t - err / speed : (lo + hi) / 2;
-    if (!(next > lo && next < hi)) next = (lo + hi) / 2;
-    t = next;
-  }
-  return t;
-}
-function segmentNearest(seg, p) {
-  if (seg.length === 2) {
-    const d = sub2(seg[1], seg[0]);
-    const len2 = dot2(d, d);
-    const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, dot2(sub2(p, seg[0]), d) / len2));
-    return { t, distance: dist2(p, segmentPoint(seg, t)) };
-  }
-  const samples = 16;
-  let best = { t: 0, distance: dist2(p, seg[0]) };
-  const candidates = [];
-  let prev = Infinity;
-  let prevT = 0;
-  let descending = false;
-  for (let i = 0; i <= samples; i++) {
-    const t = i / samples;
-    const d = dist2(p, segmentPoint(seg, t));
-    if (d < best.distance) best = { t, distance: d };
-    if (i > 0 && d > prev && descending) candidates.push(prevT);
-    descending = d < prev;
-    prev = d;
-    prevT = t;
-  }
-  candidates.push(best.t, 1);
-  for (const start of candidates) {
-    let t = start;
-    for (let k = 0; k < 12; k++) {
-      const q = segmentPoint(seg, t);
-      const d1 = segmentDerivative(seg, t);
-      const d2 = segmentSecondDerivative(seg, t);
-      const diff = sub2(q, p);
-      const f = dot2(diff, d1);
-      const fp = dot2(d1, d1) + dot2(diff, d2);
-      if (!(Math.abs(fp) > 1e-300)) break;
-      const next = Math.max(0, Math.min(1, t - f / fp));
-      if (Math.abs(next - t) < 1e-14) {
-        t = next;
-        break;
-      }
-      t = next;
-    }
-    const d = dist2(p, segmentPoint(seg, t));
-    if (d < best.distance) best = { t, distance: d };
-  }
-  return best;
-}
-function arcToCubics(from, cmd) {
-  const [x0, y0] = from;
-  const { x, y } = cmd;
-  if (x0 === x && y0 === y) return [];
-  let rx = Math.abs(cmd.rx);
-  let ry = Math.abs(cmd.ry);
-  if (rx === 0 || ry === 0) return [[from, [x, y]]];
-  const phi = cmd.rotation * Math.PI / 180;
-  const cos = Math.cos(phi);
-  const sin = Math.sin(phi);
-  const dx = (x0 - x) / 2;
-  const dy = (y0 - y) / 2;
-  const x1p = cos * dx + sin * dy;
-  const y1p = -sin * dx + cos * dy;
-  const lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
-  if (lambda > 1) {
-    const s = Math.sqrt(lambda);
-    rx *= s;
-    ry *= s;
-  }
-  const num2 = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
-  const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
-  let coef = den === 0 ? 0 : Math.sqrt(Math.max(0, num2 / den));
-  if (cmd.largeArc === cmd.sweep) coef = -coef;
-  const cxp = coef * rx * y1p / ry;
-  const cyp = -coef * ry * x1p / rx;
-  const cx = cos * cxp - sin * cyp + (x0 + x) / 2;
-  const cy = sin * cxp + cos * cyp + (y0 + y) / 2;
-  const angle = (ux, uy, vx, vy) => Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
-  const theta1 = angle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);
-  let delta = angle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry);
-  if (!cmd.sweep && delta > 0) delta -= 2 * Math.PI;
-  else if (cmd.sweep && delta < 0) delta += 2 * Math.PI;
-  const n = Math.max(1, Math.ceil(Math.abs(delta) / (Math.PI / 2) - 1e-9));
-  const step = delta / n;
-  const k = 4 / 3 * Math.tan(step / 4);
-  const map = (ux, uy) => {
-    const ex = rx * ux;
-    const ey = ry * uy;
-    return [cos * ex - sin * ey + cx, sin * ex + cos * ey + cy];
-  };
-  const out = [];
-  let prev = from;
-  for (let i = 0; i < n; i++) {
-    const a0 = theta1 + step * i;
-    const a1 = a0 + step;
-    const c0 = Math.cos(a0);
-    const s0 = Math.sin(a0);
-    const c1 = Math.cos(a1);
-    const s1 = Math.sin(a1);
-    const end = i === n - 1 ? [x, y] : map(c1, s1);
-    out.push([prev, map(c0 - k * s0, s0 + k * c0), map(c1 + k * s1, s1 - k * c1), end]);
-    prev = end;
-  }
-  return out;
-}
-function isBezierCommandList(input) {
-  return Array.isArray(input) && !input.some((c) => c && c.type === "A");
-}
-function toBezierPath(input) {
-  const commands = typeof input === "string" ? parseSvgPath(input) : isBezierCommandList(input) ? input : input;
-  const out = [];
-  let current = [0, 0];
-  let start = [0, 0];
-  let open = false;
-  const ensureMove = () => {
-    if (!open) {
-      out.push({ type: "M", x: start[0], y: start[1] });
-      current = start;
-      open = true;
-    }
-  };
-  for (const cmd of commands) {
-    switch (cmd.type) {
-      case "M":
-        start = [cmd.x, cmd.y];
-        current = start;
-        out.push({ type: "M", x: cmd.x, y: cmd.y });
-        open = true;
-        break;
-      case "L":
-        ensureMove();
-        out.push({ type: "L", x: cmd.x, y: cmd.y });
-        current = [cmd.x, cmd.y];
-        break;
-      case "Q":
-        ensureMove();
-        out.push({ type: "Q", x1: cmd.x1, y1: cmd.y1, x: cmd.x, y: cmd.y });
-        current = [cmd.x, cmd.y];
-        break;
-      case "C":
-        ensureMove();
-        out.push({ type: "C", x1: cmd.x1, y1: cmd.y1, x2: cmd.x2, y2: cmd.y2, x: cmd.x, y: cmd.y });
-        current = [cmd.x, cmd.y];
-        break;
-      case "A": {
-        ensureMove();
-        for (const c of arcToCubics(current, cmd)) {
-          if (c.length === 2) out.push({ type: "L", x: c[1][0], y: c[1][1] });
-          else out.push({ type: "C", x1: c[1][0], y1: c[1][1], x2: c[2][0], y2: c[2][1], x: c[3][0], y: c[3][1] });
-        }
-        current = [cmd.x, cmd.y];
-        break;
-      }
-      case "Z":
-        if (open) out.push({ type: "Z" });
-        open = false;
-        current = start;
-        break;
-    }
-  }
-  return out;
-}
-function pathToContours(input) {
-  const path = toBezierPath(input);
-  const contours = [];
-  let current = null;
-  let pen = [0, 0];
-  let start = [0, 0];
-  const push = (seg) => {
-    if (!current) {
-      current = { segments: [], closed: false };
-      contours.push(current);
-    }
-    if (seg.every((p) => samePoint(p, seg[0]))) return;
-    current.segments.push(seg);
-  };
-  for (const cmd of path) {
-    switch (cmd.type) {
-      case "M":
-        start = [cmd.x, cmd.y];
-        pen = start;
-        current = { segments: [], closed: false };
-        contours.push(current);
-        break;
-      case "L":
-        push([pen, [cmd.x, cmd.y]]);
-        pen = [cmd.x, cmd.y];
-        break;
-      case "Q":
-        push([pen, [cmd.x1, cmd.y1], [cmd.x, cmd.y]]);
-        pen = [cmd.x, cmd.y];
-        break;
-      case "C":
-        push([pen, [cmd.x1, cmd.y1], [cmd.x2, cmd.y2], [cmd.x, cmd.y]]);
-        pen = [cmd.x, cmd.y];
-        break;
-      case "Z":
-        if (current) current.closed = true;
-        current = null;
-        pen = start;
-        break;
-    }
-  }
-  return contours;
-}
-function contoursToPath(contours) {
-  const out = [];
-  for (const contour of contours) {
-    const segs = contour.segments;
-    if (segs.length === 0) continue;
-    out.push({ type: "M", x: segs[0][0][0], y: segs[0][0][1] });
-    let count = segs.length;
-    if (contour.closed && count > 1) {
-      const last = segs[count - 1];
-      if (last.length === 2 && samePoint(last[1], segs[0][0])) count--;
-    }
-    for (let i = 0; i < count; i++) {
-      const s = segs[i];
-      const end = s[s.length - 1];
-      if (s.length === 2) out.push({ type: "L", x: end[0], y: end[1] });
-      else if (s.length === 3) out.push({ type: "Q", x1: s[1][0], y1: s[1][1], x: end[0], y: end[1] });
-      else out.push({ type: "C", x1: s[1][0], y1: s[1][1], x2: s[2][0], y2: s[2][1], x: end[0], y: end[1] });
-    }
-    if (contour.closed) out.push({ type: "Z" });
-  }
-  return out;
-}
-function bezierPathToSvg(input, options = {}) {
-  const path = toBezierPath(input);
-  const precision = options.precision ?? 3;
-  const dx = options.offset?.x ?? 0;
-  const dy = options.offset?.y ?? 0;
-  const fx = (n) => formatNumber2(n + dx, precision);
-  const fy = (n) => formatNumber2(n + dy, precision);
-  let d = "";
-  for (const c of path) {
-    switch (c.type) {
-      case "M":
-        d += `M${fx(c.x)} ${fy(c.y)}`;
-        break;
-      case "L":
-        d += `L${fx(c.x)} ${fy(c.y)}`;
-        break;
-      case "Q":
-        d += `Q${fx(c.x1)} ${fy(c.y1)} ${fx(c.x)} ${fy(c.y)}`;
-        break;
-      case "C":
-        d += `C${fx(c.x1)} ${fy(c.y1)} ${fx(c.x2)} ${fy(c.y2)} ${fx(c.x)} ${fy(c.y)}`;
-        break;
-      case "Z":
-        d += "Z";
-        break;
-    }
-  }
-  return d;
-}
-function transformBezierPath(input, m) {
-  const [a, b, c, d, e, f] = m;
-  const X = (x, y) => a * x + c * y + e;
-  const Y = (x, y) => b * x + d * y + f;
-  return toBezierPath(input).map((cmd) => {
-    switch (cmd.type) {
-      case "M":
-      case "L":
-        return { type: cmd.type, x: X(cmd.x, cmd.y), y: Y(cmd.x, cmd.y) };
-      case "Q":
-        return { type: "Q", x1: X(cmd.x1, cmd.y1), y1: Y(cmd.x1, cmd.y1), x: X(cmd.x, cmd.y), y: Y(cmd.x, cmd.y) };
-      case "C":
-        return {
-          type: "C",
-          x1: X(cmd.x1, cmd.y1),
-          y1: Y(cmd.x1, cmd.y1),
-          x2: X(cmd.x2, cmd.y2),
-          y2: Y(cmd.x2, cmd.y2),
-          x: X(cmd.x, cmd.y),
-          y: Y(cmd.x, cmd.y)
-        };
-      case "Z":
-        return cmd;
-    }
-  });
-}
-function countPathSegments(input) {
-  const out = { lines: 0, quads: 0, cubics: 0 };
-  for (const contour of pathToContours(input)) {
-    const segs = closeContour(contour);
-    for (const s of segs) {
-      if (s.length === 2) out.lines++;
-      else if (s.length === 3) out.quads++;
-      else out.cubics++;
-    }
-  }
-  return out;
-}
-function closeContour(contour, force = false) {
-  const segs = contour.segments;
-  if (segs.length === 0) return [];
-  if (!contour.closed && !force) return segs;
-  const first = segs[0][0];
-  const lastSeg = segs[segs.length - 1];
-  const last = lastSeg[lastSeg.length - 1];
-  return samePoint(first, last) ? segs : [...segs, [last, first]];
-}
-function bezierPathBounds(input) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  const path = toBezierPath(input);
-  let pen = null;
-  for (const contour of pathToContours(path)) {
-    for (const s of contour.segments) {
-      const b = segmentBounds(s);
-      minX = Math.min(minX, b.minX);
-      minY = Math.min(minY, b.minY);
-      maxX = Math.max(maxX, b.maxX);
-      maxY = Math.max(maxY, b.maxY);
-    }
-  }
-  for (const c of path) {
-    if (c.type === "M") pen = [c.x, c.y];
-    if (pen) {
-      minX = Math.min(minX, pen[0]);
-      minY = Math.min(minY, pen[1]);
-      maxX = Math.max(maxX, pen[0]);
-      maxY = Math.max(maxY, pen[1]);
-    }
-  }
-  return minX === Infinity ? null : { minX, minY, maxX, maxY };
-}
-function bezierPathSignedArea(input) {
-  let sum = 0;
-  for (const contour of pathToContours(input)) sum += contourSignedArea(closeContour(contour, true));
-  return sum;
-}
-function contourSignedArea(segs) {
-  let sum = 0;
-  for (const s of segs) sum += segmentAreaTerm(s);
-  return sum;
-}
-function bezierPathLength(input) {
-  let total = 0;
-  for (const contour of pathToContours(input)) for (const s of closeContour(contour)) total += segmentLength(s);
-  return total;
-}
-function bezierPathPointAtLength(input, length) {
-  const contours = pathToContours(input);
-  let remaining = Math.max(0, length);
-  let last = null;
-  for (let ci = 0; ci < contours.length; ci++) {
-    const segs = closeContour(contours[ci]);
-    for (let si = 0; si < segs.length; si++) {
-      const s = segs[si];
-      const len = segmentLength(s);
-      if (remaining <= len) {
-        const t = segmentParamAtLength(s, remaining, len);
-        const tangent2 = segmentTangent(s, t);
-        return { point: segmentPoint(s, t), tangent: tangent2, angle: Math.atan2(tangent2[1], tangent2[0]), contour: ci, segment: si, t };
-      }
-      remaining -= len;
-      const tangent = segmentTangent(s, 1);
-      last = { point: s[s.length - 1], tangent, angle: Math.atan2(tangent[1], tangent[0]), contour: ci, segment: si, t: 1 };
-    }
-  }
-  return last;
-}
-function trimSegments(segs, from, to, lengths) {
-  const lens = lengths ?? segs.map((s) => segmentLength(s));
-  const out = [];
-  let at = 0;
-  for (let i = 0; i < segs.length; i++) {
-    const len = lens[i];
-    const s0 = at;
-    const s1 = at + len;
-    at = s1;
-    if (s1 <= from || s0 >= to || len <= 0) continue;
-    const t0 = from > s0 ? segmentParamAtLength(segs[i], from - s0, len) : 0;
-    const t1 = to < s1 ? segmentParamAtLength(segs[i], to - s0, len) : 1;
-    if (t1 > t0) out.push(subSegment(segs[i], t0, t1));
-  }
-  return out;
-}
-function solveMonotone(seg, axis, value) {
-  const a = seg[0][axis];
-  const b = seg[seg.length - 1][axis];
-  if (seg.length === 2) return b === a ? 0 : (value - a) / (b - a);
-  const increasing = b > a;
-  let lo = 0;
-  let hi = 1;
-  let t = b === a ? 0.5 : Math.max(0, Math.min(1, (value - a) / (b - a)));
-  for (let i = 0; i < 60; i++) {
-    const v = segmentPoint(seg, t)[axis] - value;
-    if (v === 0) return t;
-    if (v > 0 === increasing) hi = t;
-    else lo = t;
-    const d = segmentDerivative(seg, t)[axis];
-    let next = d !== 0 ? t - v / d : (lo + hi) / 2;
-    if (!(next > lo && next < hi)) next = (lo + hi) / 2;
-    if (Math.abs(next - t) < 1e-15) return next;
-    t = next;
-  }
-  return t;
-}
-function yMonotonePieces(segs) {
-  const out = [];
-  for (const s of segs) {
-    if (s.length === 2) {
-      out.push(s);
-      continue;
-    }
-    const ts = segmentExtrema(s, 1);
-    let prev = 0;
-    for (const t of [...ts, 1]) {
-      out.push(subSegment(s, prev, t));
-      prev = t;
-    }
-  }
-  return out;
-}
-function windingNumber(chains, point) {
-  const [px2, py] = point;
-  let winding = 0;
-  for (const chain of chains) {
-    for (const s of yMonotonePieces(chain)) {
-      const ay = s[0][1];
-      const by = s[s.length - 1][1];
-      let dir = 0;
-      if (ay <= py && by > py) dir = 1;
-      else if (by <= py && ay > py) dir = -1;
-      else continue;
-      let minX = Infinity;
-      let maxX = -Infinity;
-      for (const p of s) {
-        if (p[0] < minX) minX = p[0];
-        if (p[0] > maxX) maxX = p[0];
-      }
-      if (minX > px2) {
-        winding += dir;
-        continue;
-      }
-      if (maxX <= px2) continue;
-      const t = solveMonotone(s, 1, py);
-      if (segmentPoint(s, t)[0] > px2) winding += dir;
-    }
-  }
-  return winding;
-}
-function pointInBezierPath(input, point, fillRule = "nonzero") {
-  const chains = pathToContours(input).map((c) => closeContour(c, true));
-  const w = windingNumber(chains, point);
-  return fillRule === "evenodd" ? (w & 1) === 1 : w !== 0;
-}
-function distanceToBezierPath(input, point) {
-  const contours = Array.isArray(input) && input.length > 0 && input[0].segments ? input : pathToContours(input);
-  let best = Infinity;
-  for (const contour of contours) {
-    for (const s of closeContour(contour)) {
-      let minX = Infinity;
-      let minY = Infinity;
-      let maxX = -Infinity;
-      let maxY = -Infinity;
-      for (const p of s) {
-        minX = Math.min(minX, p[0]);
-        minY = Math.min(minY, p[1]);
-        maxX = Math.max(maxX, p[0]);
-        maxY = Math.max(maxY, p[1]);
-      }
-      const dx = Math.max(minX - point[0], 0, point[0] - maxX);
-      const dy = Math.max(minY - point[1], 0, point[1] - maxY);
-      if (Math.hypot(dx, dy) >= best) continue;
-      best = Math.min(best, segmentNearest(s, point).distance);
-    }
-    if (contour.segments.length === 0) continue;
-  }
-  return best;
-}
-function flattenChain(segs, tolerance) {
-  const out = [];
-  for (const s of segs) {
-    if (out.length === 0) out.push(s[0]);
-    if (s.length === 2) {
-      out.push(s[1]);
-      continue;
-    }
-    let dd = 0;
-    for (let i = 0; i + 2 < s.length; i++) {
-      dd = Math.max(dd, Math.hypot(s[i][0] - 2 * s[i + 1][0] + s[i + 2][0], s[i][1] - 2 * s[i + 1][1] + s[i + 2][1]));
-    }
-    const deg = s.length - 1;
-    const n = Math.max(1, Math.min(256, Math.ceil(Math.sqrt(deg * (deg - 1) * dd / (8 * tolerance)))));
-    for (let k = 1; k <= n; k++) out.push(segmentPoint(s, k / n));
-  }
-  if (out.length > 1 && samePoint(out[0], out[out.length - 1])) out.pop();
-  return out;
-}
-
-// src/canvas/pathops/boolean.ts
-var PathOpsError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "PathOpsError";
-  }
-};
-function isOperandObject(input) {
-  return !!input && typeof input === "object" && !Array.isArray(input) && "path" in input;
-}
-function normalizeOperand(input) {
-  const path = isOperandObject(input) ? input.path : input;
-  const fillRule = isOperandObject(input) ? input.fillRule ?? "nonzero" : "nonzero";
-  const chains = [];
-  for (const contour of pathToContours(path ?? "")) {
-    const chain = closeContour(contour, true);
-    if (chain.length === 0) continue;
-    for (const seg of chain) {
-      for (const p of seg) {
-        if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) throw new PathOpsError(NON_FINITE);
-      }
-    }
-    chains.push(chain);
-  }
-  return { chains, fillRule };
-}
-function scaleOf(operands) {
-  let max = 0;
-  for (const op of operands) {
-    for (const chain of op.chains) {
-      for (const seg of chain) {
-        for (const [x, y] of seg) max = Math.max(max, Math.abs(x), Math.abs(y));
-      }
-    }
-  }
-  return Math.max(1, max);
-}
-var VertexPool = class {
-  constructor(eps) {
-    this.eps = eps;
-  }
-  eps;
-  vertices = [];
-  cells = /* @__PURE__ */ new Map();
-  get(x, y) {
-    const cx = Math.floor(x / this.eps);
-    const cy = Math.floor(y / this.eps);
-    let best = null;
-    let bestDist = Infinity;
-    for (let dx = -1; dx <= 1; dx++) {
-      for (let dy = -1; dy <= 1; dy++) {
-        const ids = this.cells.get(`${cx + dx},${cy + dy}`);
-        if (!ids) continue;
-        for (const id of ids) {
-          const v = this.vertices[id];
-          const d = Math.hypot(v.x - x, v.y - y);
-          if (d <= this.eps && d < bestDist) {
-            best = v;
-            bestDist = d;
-          }
-        }
-      }
-    }
-    if (best) return best;
-    const vertex = { id: this.vertices.length, x, y, p: [x, y] };
-    this.vertices.push(vertex);
-    const key = `${cx},${cy}`;
-    const bucket = this.cells.get(key);
-    if (bucket) bucket.push(vertex.id);
-    else this.cells.set(key, [vertex.id]);
-    return vertex;
-  }
-};
-function hull(pts) {
-  let minX = Infinity;
-  let maxX = -Infinity;
-  let minY = Infinity;
-  let maxY = -Infinity;
-  for (const [x, y] of pts) {
-    if (x < minX) minX = x;
-    if (x > maxX) maxX = x;
-    if (y < minY) minY = y;
-    if (y > maxY) maxY = y;
-  }
-  return { minX, maxX, minY, maxY };
-}
-function snapEnds(pts, a, b) {
-  const n = pts.length;
-  if (n === 2) return [a, b];
-  const d0 = sub2(a, pts[0]);
-  const d1 = sub2(b, pts[n - 1]);
-  if (n === 3) {
-    return [a, [pts[1][0] + (d0[0] + d1[0]) / 2, pts[1][1] + (d0[1] + d1[1]) / 2], b];
-  }
-  return [a, [pts[1][0] + d0[0], pts[1][1] + d0[1]], [pts[2][0] + d1[0], pts[2][1] + d1[1]], b];
-}
-function makePiece(pts, a, b, operand, src, s0, s1) {
-  const snapped = snapEnds(pts, a.p, b.p);
-  return { pts: snapped, a, b, operand, src, s0, s1, dirty: true, ...hull(snapped) };
-}
-var NON_FINITE = "non-finite coordinates";
-function flatness(pts) {
-  if (pts.length === 2) return 0;
-  const a = pts[0];
-  const b = pts[pts.length - 1];
-  const chord = sub2(b, a);
-  const len = Math.hypot(chord[0], chord[1]);
-  let worst = 0;
-  for (let i = 1; i < pts.length - 1; i++) {
-    const v = sub2(pts[i], a);
-    const d = len > 0 ? Math.abs(cross(chord, v)) / len : Math.hypot(v[0], v[1]);
-    const along = len > 0 ? dot2(chord, v) / len : 0;
-    const over = Math.max(0, -along, along - len);
-    worst = Math.max(worst, d, over);
-  }
-  return worst;
-}
-function split2(pts) {
-  const n = pts.length;
-  const mid = (p, q) => [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2];
-  if (n === 2) {
-    const m2 = mid(pts[0], pts[1]);
-    return [
-      [pts[0], m2],
-      [m2, pts[1]]
-    ];
-  }
-  if (n === 3) {
-    const a2 = mid(pts[0], pts[1]);
-    const b2 = mid(pts[1], pts[2]);
-    const m2 = mid(a2, b2);
-    return [
-      [pts[0], a2, m2],
-      [m2, b2, pts[2]]
-    ];
-  }
-  const a = mid(pts[0], pts[1]);
-  const b = mid(pts[1], pts[2]);
-  const c = mid(pts[2], pts[3]);
-  const ab = mid(a, b);
-  const bc = mid(b, c);
-  const m = mid(ab, bc);
-  return [
-    [pts[0], a, ab, m],
-    [m, bc, c, pts[3]]
-  ];
-}
-function closestSegmentPoints(a0, a1, b0, b1) {
-  const d1 = sub2(a1, a0);
-  const d2 = sub2(b1, b0);
-  const r = sub2(a0, b0);
-  const a = dot2(d1, d1);
-  const e = dot2(d2, d2);
-  const f = dot2(d2, r);
-  let s = 0;
-  let u = 0;
-  if (a <= 1e-300 && e <= 1e-300) return { s: 0, u: 0, d: dist2(a0, b0) };
-  if (a <= 1e-300) {
-    u = Math.max(0, Math.min(1, f / e));
-  } else {
-    const c = dot2(d1, r);
-    if (e <= 1e-300) {
-      s = Math.max(0, Math.min(1, -c / a));
-    } else {
-      const b = dot2(d1, d2);
-      const denom = a * e - b * b;
-      s = denom > 0 ? Math.max(0, Math.min(1, (b * f - c * e) / denom)) : 0;
-      u = (b * s + f) / e;
-      if (u < 0) {
-        u = 0;
-        s = Math.max(0, Math.min(1, -c / a));
-      } else if (u > 1) {
-        u = 1;
-        s = Math.max(0, Math.min(1, (b - c) / a));
-      }
-    }
-  }
-  const pa = [a0[0] + d1[0] * s, a0[1] + d1[1] * s];
-  const pb = [b0[0] + d2[0] * u, b0[1] + d2[1] * u];
-  return { s, u, d: dist2(pa, pb) };
-}
-function polish(P, Q, s, u) {
-  let best = { s, u, d: dist2(segmentPoint(P, s), segmentPoint(Q, u)) };
-  for (let i = 0; i < 10 && best.d > 0; i++) {
-    const f = sub2(segmentPoint(P, s), segmentPoint(Q, u));
-    const dp = segmentDerivative(P, s);
-    const dq = segmentDerivative(Q, u);
-    const det = cross(dp, [-dq[0], -dq[1]]);
-    if (!(Math.abs(det) > 1e-300)) break;
-    const ds = cross([-f[0], -f[1]], [-dq[0], -dq[1]]) / det;
-    const du = cross(dp, [-f[0], -f[1]]) / det;
-    s = Math.max(0, Math.min(1, s + ds));
-    u = Math.max(0, Math.min(1, u + du));
-    const d = dist2(segmentPoint(P, s), segmentPoint(Q, u));
-    if (d < best.d) best = { s, u, d };
-    else break;
-  }
-  return best;
-}
-function intersectSubdivided(P, p0, p1, Q, q0, q1, fullP, fullQ, ctx, out, depth) {
-  const hp = hull(P);
-  const hq = hull(Q);
-  const e = ctx.eps;
-  if (hp.minX > hq.maxX + e || hq.minX > hp.maxX + e || hp.minY > hq.maxY + e || hq.minY > hp.maxY + e) return;
-  const fp = flatness(P);
-  const fq = flatness(Q);
-  const flatTol = e * 0.5;
-  if (fp <= flatTol && fq <= flatTol || depth >= 52) {
-    if (++ctx.leaves > ctx.budget) throw new PathOpsError("curve intersection did not converge");
-    const a0 = P[0];
-    const a1 = P[P.length - 1];
-    const b0 = Q[0];
-    const b1 = Q[Q.length - 1];
-    const d1 = sub2(a1, a0);
-    const d2 = sub2(b1, b0);
-    const denom = cross(d1, d2);
-    let s = 0;
-    let u = 0;
-    let hit = false;
-    const l1 = Math.hypot(d1[0], d1[1]);
-    const l2 = Math.hypot(d2[0], d2[1]);
-    if (Math.abs(denom) > 1e-12 * l1 * l2) {
-      const r = sub2(b0, a0);
-      s = cross(r, d2) / denom;
-      u = cross(r, d1) / denom;
-      const ts = l1 > 0 ? e / l1 : 1;
-      const tu = l2 > 0 ? e / l2 : 1;
-      hit = s >= -ts && s <= 1 + ts && u >= -tu && u <= 1 + tu;
-    }
-    if (!hit) {
-      const c = closestSegmentPoints(a0, a1, b0, b1);
-      if (c.d > e) return;
-      s = c.s;
-      u = c.u;
-    }
-    s = Math.max(0, Math.min(1, s));
-    u = Math.max(0, Math.min(1, u));
-    const best = polish(fullP, fullQ, p0 + (p1 - p0) * s, q0 + (q1 - q0) * u);
-    if (best.d > e * 2) return;
-    const a = segmentPoint(fullP, best.s);
-    const b = segmentPoint(fullQ, best.u);
-    out.push({ tp: best.s, tq: best.u, point: [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2] });
-    return;
-  }
-  const splitP = fp > flatTol;
-  const splitQ = fq > flatTol;
-  const pm = (p0 + p1) / 2;
-  const qm = (q0 + q1) / 2;
-  if (splitP && splitQ) {
-    const [pa, pb] = split2(P);
-    const [qa, qb] = split2(Q);
-    intersectSubdivided(pa, p0, pm, qa, q0, qm, fullP, fullQ, ctx, out, depth + 1);
-    intersectSubdivided(pa, p0, pm, qb, qm, q1, fullP, fullQ, ctx, out, depth + 1);
-    intersectSubdivided(pb, pm, p1, qa, q0, qm, fullP, fullQ, ctx, out, depth + 1);
-    intersectSubdivided(pb, pm, p1, qb, qm, q1, fullP, fullQ, ctx, out, depth + 1);
-  } else if (splitP) {
-    const [pa, pb] = split2(P);
-    intersectSubdivided(pa, p0, pm, Q, q0, q1, fullP, fullQ, ctx, out, depth + 1);
-    intersectSubdivided(pb, pm, p1, Q, q0, q1, fullP, fullQ, ctx, out, depth + 1);
-  } else {
-    const [qa, qb] = split2(Q);
-    intersectSubdivided(P, p0, p1, qa, q0, qm, fullP, fullQ, ctx, out, depth + 1);
-    intersectSubdivided(P, p0, p1, qb, qm, q1, fullP, fullQ, ctx, out, depth + 1);
-  }
-}
-function nearestOn(piece, p, eps) {
-  if (p[0] < piece.minX - eps || p[0] > piece.maxX + eps || p[1] < piece.minY - eps || p[1] > piece.maxY + eps) return null;
-  return segmentNearest(piece.pts, p);
-}
-function staysClose(P, Q, e1, e2, tol) {
-  for (const f of [0.25, 0.5, 0.75]) {
-    const tp = e1.tp + (e2.tp - e1.tp) * f;
-    const q = segmentNearest(Q.pts, segmentPoint(P.pts, tp));
-    if (q.distance > tol) return false;
-  }
-  return true;
-}
-function pairEvents(P, Q, ctx) {
-  const eps = ctx.eps;
-  const anchors = [];
-  for (const [va, tp] of [
-    [P.a, 0],
-    [P.b, 1]
-  ]) {
-    if (va === Q.a) anchors.push({ tp, tq: 0, point: va.p, anchor: true, shared: true });
-    else if (va === Q.b) anchors.push({ tp, tq: 1, point: va.p, anchor: true, shared: true });
-  }
-  for (const [v, tq] of [
-    [Q.a, 0],
-    [Q.b, 1]
-  ]) {
-    if (v === P.a || v === P.b) continue;
-    const near = nearestOn(P, v.p, eps);
-    if (near && near.distance <= eps) anchors.push({ tp: near.t, tq, point: v.p, anchor: true });
-  }
-  for (const [v, tp] of [
-    [P.a, 0],
-    [P.b, 1]
-  ]) {
-    if (v === Q.a || v === Q.b) continue;
-    const near = nearestOn(Q, v.p, eps);
-    if (near && near.distance <= eps) anchors.push({ tp, tq: near.t, point: v.p, anchor: true });
-  }
-  if (anchors.length >= 2) {
-    const sorted = [...anchors].sort((x, y) => x.tp - y.tp);
-    const first = sorted[0];
-    const last = sorted[sorted.length - 1];
-    if (dist2(first.point, last.point) > eps && staysClose(P, Q, first, last, eps * 4)) {
-      return anchors.filter((a) => !a.shared);
-    }
-  }
-  const found = [];
-  if (P.pts.length === 2 && Q.pts.length === 2) {
-    const a0 = P.pts[0];
-    const d1 = sub2(P.pts[1], a0);
-    const b0 = Q.pts[0];
-    const d2 = sub2(Q.pts[1], b0);
-    const denom = cross(d1, d2);
-    const l1 = Math.hypot(d1[0], d1[1]);
-    const l2 = Math.hypot(d2[0], d2[1]);
-    if (Math.abs(denom) > 1e-12 * l1 * l2) {
-      const r = sub2(b0, a0);
-      const s = cross(r, d2) / denom;
-      const u = cross(r, d1) / denom;
-      const ts = eps / l1;
-      const tu = eps / l2;
-      if (s >= -ts && s <= 1 + ts && u >= -tu && u <= 1 + tu) {
-        const sc = Math.max(0, Math.min(1, s));
-        const uc = Math.max(0, Math.min(1, u));
-        found.push({ tp: sc, tq: uc, point: [a0[0] + d1[0] * sc, a0[1] + d1[1] * sc] });
-      }
-    }
-  } else {
-    ctx.leaves = 0;
-    intersectSubdivided(P.pts, 0, 1, Q.pts, 0, 1, P.pts, Q.pts, ctx, found, 0);
-  }
-  if (found.length === 0) return anchors.filter((a) => !a.shared);
-  const all = [...anchors, ...found].sort((x, y) => x.tp - y.tp || x.tq - y.tq);
-  const clusters = [];
-  for (const ev of all) {
-    const cluster = clusters[clusters.length - 1];
-    const prev = cluster?.[cluster.length - 1];
-    if (prev && (dist2(prev.point, ev.point) <= eps * 2 || staysClose(P, Q, prev, ev, eps * 2))) cluster.push(ev);
-    else clusters.push([ev]);
-  }
-  const out = [];
-  for (const cluster of clusters) {
-    const shared = cluster.find((e) => e.shared);
-    if (shared) continue;
-    const anchor = cluster.find((e) => e.anchor);
-    out.push(anchor ?? cluster[Math.floor(cluster.length / 2)]);
-  }
-  return out;
-}
-function addSplit2(map, piece, t, v) {
-  if (v === piece.a || v === piece.b) return;
-  const list = map.get(piece);
-  if (list) list.push({ t, v });
-  else map.set(piece, [{ t, v }]);
-}
-function eventVertex(P, Q, ev, pool, eps) {
-  for (const v of [P.a, P.b, Q.a, Q.b]) if (dist2(v.p, ev.point) <= eps) return v;
-  return pool.get(ev.point[0], ev.point[1]);
-}
-function splitPass2(pieces, pool, ctx) {
-  const eps = ctx.eps;
-  const order = pieces.map((_, i) => i).sort((i, j) => pieces[i].minX - pieces[j].minX);
-  const splits = /* @__PURE__ */ new Map();
-  for (let oi = 0; oi < order.length; oi++) {
-    const P = pieces[order[oi]];
-    for (let oj = oi + 1; oj < order.length; oj++) {
-      const Q = pieces[order[oj]];
-      if (Q.minX > P.maxX + eps) break;
-      if (!P.dirty && !Q.dirty) continue;
-      if (Q.minY > P.maxY + eps || Q.maxY < P.minY - eps) continue;
-      if (P.a === Q.a && P.b === Q.b && P.pts.length === 2 && Q.pts.length === 2) continue;
-      if (P.a === Q.b && P.b === Q.a && P.pts.length === 2 && Q.pts.length === 2) continue;
-      for (const ev of pairEvents(P, Q, ctx)) {
-        const v = eventVertex(P, Q, ev, pool, eps);
-        addSplit2(splits, P, ev.tp, v);
-        addSplit2(splits, Q, ev.tq, v);
-      }
-    }
-  }
-  for (const p of pieces) p.dirty = false;
-  if (splits.size === 0) return { pieces, changed: false };
-  const out = [];
-  for (const piece of pieces) {
-    const list = splits.get(piece);
-    if (!list) {
-      out.push(piece);
-      continue;
-    }
-    list.sort((x, y) => x.t - y.t);
-    let prevT = 0;
-    let prevV = piece.a;
-    const range = piece.s1 - piece.s0;
-    const emit = (t, v) => {
-      if (v === prevV || t <= prevT) return;
-      const pts = subSegment(piece.pts, prevT, t);
-      out.push(makePiece(pts, prevV, v, piece.operand, piece.src, piece.s0 + range * prevT, piece.s0 + range * t));
-      prevT = t;
-      prevV = v;
-    };
-    const seen = /* @__PURE__ */ new Set();
-    for (const { t, v } of list) {
-      if (seen.has(v) || t <= 0 || t >= 1) continue;
-      seen.add(v);
-      emit(t, v);
-    }
-    if (prevV !== piece.b) {
-      const pts = subSegment(piece.pts, prevT, 1);
-      out.push(makePiece(pts, prevV, piece.b, piece.operand, piece.src, piece.s0 + range * prevT, piece.s1));
-    }
-  }
-  return { pieces: out, changed: true };
-}
-function buildArrangement(inputs, options) {
-  const operands = inputs.map(normalizeOperand);
-  const scale2 = scaleOf(operands);
-  const eps = options.epsilon && options.epsilon > 0 ? options.epsilon : 1e-9 * scale2;
-  const pool = new VertexPool(eps);
-  const sources = [];
-  let pieces = [];
-  operands.forEach((op, operand) => {
-    for (const chain of op.chains) {
-      for (const raw of chain) {
-        const straight = raw.length > 2 && isStraightSegment(raw, eps * 0.01);
-        const seg = straight ? [raw[0], raw[raw.length - 1]] : raw;
-        const src = sources.length;
-        sources.push({ seg, line: seg.length === 2 });
-        const ts = [0, ...monotoneParams(seg), 1];
-        for (let i = 0; i + 1 < ts.length; i++) {
-          const pts = subSegment(seg, ts[i], ts[i + 1]);
-          const a = pool.get(pts[0][0], pts[0][1]);
-          const b = pool.get(pts[pts.length - 1][0], pts[pts.length - 1][1]);
-          if (a === b) continue;
-          pieces.push(makePiece(pts, a, b, operand, src, ts[i], ts[i + 1]));
-        }
-      }
-    }
-  });
-  const ctx = { eps, leaves: 0, budget: options.subdivisionBudget ?? 2e4 };
-  let settled = false;
-  for (let pass = 0; pass < 6; pass++) {
-    const result = splitPass2(pieces, pool, ctx);
-    pieces = result.pieces;
-    if (!result.changed) {
-      settled = true;
-      break;
-    }
-  }
-  if (!settled) throw new PathOpsError("intersections did not settle");
-  const count = operands.length;
-  const groups = /* @__PURE__ */ new Map();
-  const edges = [];
-  for (const piece of pieces) {
-    const forward = piece.a.id < piece.b.id;
-    const a = forward ? piece.a : piece.b;
-    const b = forward ? piece.b : piece.a;
-    const pts = forward ? piece.pts : [...piece.pts].reverse();
-    const key = `${a.id},${b.id}`;
-    const group = groups.get(key) ?? [];
-    if (!groups.has(key)) groups.set(key, group);
-    const mid = segmentPoint(pts, 0.5);
-    let edge = group.find((e) => {
-      if (e.pts.length === 2 && pts.length === 2) return true;
-      return segmentNearest(e.pts, mid).distance <= eps * 4 && segmentNearest(pts, segmentPoint(e.pts, 0.5)).distance <= eps * 4;
-    });
-    if (!edge) {
-      edge = {
-        a,
-        b,
-        pts,
-        mult: new Array(count).fill(0),
-        src: piece.src,
-        sa: forward ? piece.s0 : piece.s1,
-        sb: forward ? piece.s1 : piece.s0,
-        ...hull(pts)
-      };
-      group.push(edge);
-      edges.push(edge);
-    }
-    edge.mult[piece.operand] += forward ? 1 : -1;
-  }
-  const live = edges.filter((e) => e.mult.some((m) => m !== 0));
-  const byY = new BandIndex(live, (e) => e.minY, (e) => e.maxY);
-  const byX = new BandIndex(live, (e) => e.minX, (e) => e.maxX);
-  const right = [];
-  const left = [];
-  for (let i = 0; i < live.length; i++) {
-    const edge = live[i];
-    const mid = segmentPoint(edge.pts, 0.5);
-    const tan = segmentTangent(edge.pts, 0.5);
-    const horizontal = Math.abs(tan[1]) < Math.abs(tan[0]);
-    const winding = new Array(count).fill(0);
-    const [mx, my] = mid;
-    for (const j of horizontal ? byX.at(mx) : byY.at(my)) {
-      if (j === i) continue;
-      const o = live[j];
-      let dir = 0;
-      if (!horizontal) {
-        if (o.maxX <= mx) continue;
-        const ay = o.a.y;
-        const by = o.b.y;
-        if (ay <= my && by > my) dir = 1;
-        else if (by <= my && ay > my) dir = -1;
-        else continue;
-        if (o.minX <= mx) {
-          const t = solveMonotone(o.pts, 1, my);
-          if (!(segmentPoint(o.pts, t)[0] > mx)) continue;
-        }
-      } else {
-        if (o.maxY <= my) continue;
-        const ax = o.a.x;
-        const bx = o.b.x;
-        if (bx < mx && mx <= ax) dir = 1;
-        else if (ax < mx && mx <= bx) dir = -1;
-        else continue;
-        if (o.minY <= my) {
-          const t = solveMonotone(o.pts, 0, mx);
-          if (!(segmentPoint(o.pts, t)[1] > my)) continue;
-        }
-      }
-      for (let k = 0; k < count; k++) if (o.mult[k] !== 0) winding[k] += dir * o.mult[k];
-    }
-    const sideIsRight = horizontal ? edge.b.x < edge.a.x : edge.b.y > edge.a.y;
-    const r = sideIsRight ? winding : winding.map((w, k) => w - edge.mult[k]);
-    right.push(r);
-    left.push(r.map((w, k) => w + edge.mult[k]));
-  }
-  return { edges: live, left, right, fillRules: operands.map((o) => o.fillRule), sources, eps, scale: scale2 };
-}
-var BandIndex = class {
-  bands;
-  min;
-  size;
-  constructor(edges, lo, hi) {
-    let min = Infinity;
-    let max = -Infinity;
-    for (const e of edges) {
-      min = Math.min(min, lo(e));
-      max = Math.max(max, hi(e));
-    }
-    const count = Math.max(1, Math.min(4096, Math.ceil(Math.sqrt(edges.length) * 2)));
-    this.min = min;
-    this.size = max > min ? (max - min) / count : 1;
-    this.bands = Array.from({ length: count }, () => []);
-    edges.forEach((e, i) => {
-      const from = this.index(lo(e));
-      const to = this.index(hi(e));
-      for (let b = from; b <= to; b++) this.bands[b].push(i);
-    });
-  }
-  index(v) {
-    const k = Math.floor((v - this.min) / this.size);
-    return Math.max(0, Math.min(this.bands.length - 1, Number.isFinite(k) ? k : 0));
-  }
-  at(v) {
-    return this.bands[this.index(v)] ?? [];
-  }
-};
-function insideFlags2(windings, fillRules) {
-  return windings.map((w, k) => fillRules[k] === "evenodd" ? (w & 1) === 1 : w !== 0);
-}
-var TWO_PI = Math.PI * 2;
-var TIE = 1e-3;
-function directed(edge, forward) {
-  const pts = forward ? edge.pts : [...edge.pts].reverse();
-  const out = segmentTangent(pts, 0);
-  const end = segmentTangent(pts, 1);
-  return {
-    from: forward ? edge.a : edge.b,
-    to: forward ? edge.b : edge.a,
-    pts,
-    src: edge.src,
-    sFrom: forward ? edge.sa : edge.sb,
-    sTo: forward ? edge.sb : edge.sa,
-    outAngle: Math.atan2(out[1], out[0]),
-    backAngle: Math.atan2(-end[1], -end[0]),
-    length: dist2(pts[0], pts[pts.length - 1]) + (pts.length > 2 ? flatness(pts) : 0)
-  };
-}
-function chordAngle(pts, t) {
-  const p = segmentPoint(pts, t);
-  return Math.atan2(p[1] - pts[0][1], p[0] - pts[0][0]);
-}
-function mod2pi(a) {
-  const r = a - Math.floor(a / TWO_PI) * TWO_PI;
-  return r >= TWO_PI ? 0 : r;
-}
-function traceRings2(edges, scale2) {
-  const outgoing = /* @__PURE__ */ new Map();
-  for (const e of edges) {
-    const list = outgoing.get(e.from.id);
-    if (list) list.push(e);
-    else outgoing.set(e.from.id, [e]);
-  }
-  const next = (incoming) => {
-    const candidates = outgoing.get(incoming.to.id)?.filter((c) => !used.has(c) || c === start);
-    if (!candidates || candidates.length === 0) return void 0;
-    if (candidates.length === 1) return candidates[0];
-    const turns = candidates.map((c) => mod2pi(incoming.backAngle - c.outAngle));
-    const tied = (x) => x < TIE || x > TWO_PI - TIE;
-    let ambiguous = turns.some(tied);
-    if (!ambiguous) {
-      const sorted = [...turns].sort((a, b) => a - b);
-      for (let i = 1; i < sorted.length; i++) if (sorted[i] - sorted[i - 1] < TIE) ambiguous = true;
-    }
-    if (ambiguous) {
-      const back = [...incoming.pts].reverse();
-      let delta = Math.min(incoming.length, ...candidates.map((c) => c.length));
-      delta = Math.min(delta * 0.25, scale2 * 0.02);
-      const frac = (e) => Math.min(1, Math.max(1e-6, delta / Math.max(e.length, 1e-300)));
-      const backChord = chordAngle(back, frac(incoming));
-      for (let i = 0; i < candidates.length; i++) {
-        turns[i] = mod2pi(backChord - chordAngle(candidates[i].pts, frac(candidates[i])));
-        if (turns[i] < 1e-12) turns[i] = TWO_PI;
-      }
-    } else {
-      for (let i = 0; i < turns.length; i++) if (turns[i] < 1e-15) turns[i] = TWO_PI;
-    }
-    let best = 0;
-    for (let i = 1; i < candidates.length; i++) if (turns[i] < turns[best]) best = i;
-    return candidates[best];
-  };
-  const used = /* @__PURE__ */ new Set();
-  const rings = [];
-  let start = null;
-  for (const first of edges) {
-    if (used.has(first)) continue;
-    start = first;
-    const ring = [];
-    let edge = first;
-    let guard = edges.length + 1;
-    let closed = false;
-    while (edge && guard-- > 0) {
-      used.add(edge);
-      ring.push(edge);
-      edge = next(edge);
-      if (edge === first) {
-        closed = true;
-        break;
-      }
-    }
-    if (!closed) throw new PathOpsError("result outline does not close");
-    rings.push(ring);
-  }
-  return rings;
-}
-function mergeable(a, b, sources, eps) {
-  if (a.src === b.src && Math.abs(a.sTo - b.sFrom) < 1e-9 && a.sTo - a.sFrom > 0 === b.sTo - b.sFrom > 0) return true;
-  if (a.pts.length === 2 && b.pts.length === 2) {
-    const p = a.pts[0];
-    const q = b.pts[1];
-    const m = a.pts[1];
-    const chord = sub2(q, p);
-    const len = Math.hypot(chord[0], chord[1]);
-    if (len === 0) return false;
-    const off = Math.abs(cross(chord, sub2(m, p))) / len;
-    const along = dot2(chord, sub2(m, p));
-    return off <= eps && along > 0 && along < len * len;
-  }
-  void sources;
-  return false;
-}
-function rebuildRing(ring, sources, eps) {
-  const n = ring.length;
-  let startIndex = 0;
-  for (let k = 0; k < n; k++) {
-    if (!mergeable(ring[(k + n - 1) % n], ring[k], sources, eps)) {
-      startIndex = k;
-      break;
-    }
-  }
-  const ordered = [...ring.slice(startIndex), ...ring.slice(0, startIndex)];
-  const out = [];
-  let i = 0;
-  while (i < ordered.length) {
-    const first = ordered[i];
-    let j = i + 1;
-    while (j < ordered.length && mergeable(ordered[j - 1], ordered[j], sources, eps)) j++;
-    const last = ordered[j - 1];
-    if (j - i === 1) {
-      out.push(first.pts);
-    } else if (first.pts.length === 2 && ordered.slice(i, j).every((e) => e.pts.length === 2)) {
-      out.push([first.from.p, last.to.p]);
-    } else {
-      const source = sources[first.src];
-      out.push(snapEnds(subSegment(source.seg, first.sFrom, last.sTo), first.from.p, last.to.p));
-    }
-    i = j;
-  }
-  return out;
-}
-function extractRings(arr, isInside) {
-  const kept = [];
-  arr.edges.forEach((edge, i) => {
-    const l = isInside(insideFlags2(arr.left[i], arr.fillRules));
-    const r = isInside(insideFlags2(arr.right[i], arr.fillRules));
-    if (l === r) return;
-    kept.push(directed(edge, l));
-  });
-  const rings = [];
-  const sliver = Math.max(arr.eps * 10, 1e-7 * arr.scale);
-  for (const ring of traceRings2(kept, arr.scale)) {
-    const segs = rebuildRing(ring, arr.sources, arr.eps);
-    const area = contourSignedArea(segs);
-    let perimeter = 0;
-    for (const s of segs) perimeter += s.length === 2 ? dist2(s[0], s[1]) : segmentLength(s, 0, 1, 1e-6);
-    if (!(perimeter > 0) || 2 * Math.abs(area) / perimeter < sliver) continue;
-    rings.push({ segs, area });
-  }
-  return rings;
-}
-function ringSample(ring) {
-  let best = ring.segs[0];
-  let bestLen = -1;
-  for (const s of ring.segs) {
-    const l = dist2(s[0], s[s.length - 1]);
-    if (l > bestLen) {
-      best = s;
-      bestLen = l;
-    }
-  }
-  return segmentPoint(best, 0.5);
-}
-function groupRings(rings) {
-  const outers = rings.filter((r) => r.area > 0).sort((a, b) => b.area - a.area);
-  const holes = rings.filter((r) => r.area < 0);
-  const groups = outers.map((o) => [o]);
-  for (const hole of holes) {
-    const sample = ringSample(hole);
-    for (let i = outers.length - 1; i >= 0; i--) {
-      if (outers[i].area >= -hole.area && windingNumber([outers[i].segs], sample) !== 0) {
-        groups[i].push(hole);
-        break;
-      }
-    }
-  }
-  return groups;
-}
-function ringsToPath2(rings) {
-  return contoursToPath(rings.map((r) => ({ segments: r.segs, closed: true })));
-}
-function predicate2(operation) {
-  switch (operation) {
-    case "union":
-      return (f) => f.some(Boolean);
-    case "intersection":
-      return (f) => f.length > 0 && f.every(Boolean);
-    case "difference":
-      return (f) => f[0] === true && !f.slice(1).some(Boolean);
-    case "xor":
-      return (f) => f.filter(Boolean).length % 2 === 1;
-  }
-}
-function flattenOperand(input, tolerance) {
-  const path = isOperandObject(input) ? input.path : input;
-  const fillRule = isOperandObject(input) ? input.fillRule ?? "nonzero" : "nonzero";
-  const rings = pathToContours(path ?? "").map((c) => flattenChain(closeContour(c, true), tolerance)).filter((r) => r.length >= 3 && r.every((p) => Number.isFinite(p[0]) && Number.isFinite(p[1])));
-  return { rings, fillRule };
-}
-function multiToPath(multi, tolerance) {
-  if (multi.length === 0) return [];
-  return toBezierPath(polygonToSvgPath(multi, { curves: "fit", curveTolerance: tolerance, precision: 9 }));
-}
-function reasonOf(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function pathBoolean(operation, operands, options = {}) {
-  if (operands.length === 0) return { path: [], engine: "curve" };
-  try {
-    const arr = buildArrangement(operands, options);
-    return { path: ringsToPath2(extractRings(arr, predicate2(operation))), engine: "curve" };
-  } catch (error) {
-    const reason = reasonOf(error);
-    if (reason === NON_FINITE) return { path: [], engine: "curve", error: reason };
-    if (options.fallback === false) throw error;
-    options.onFallback?.(reason);
-    const tolerance = options.fallbackTolerance ?? 0.05;
-    const multi = polygonBoolean(
-      operation,
-      operands.map((o) => flattenOperand(o, tolerance)),
-      { epsilon: options.epsilon }
-    );
-    return { path: multiToPath(multi, tolerance), engine: "polygon", fallbackReason: reason };
-  }
-}
-var unitePaths = (a, b, options) => pathBoolean("union", [a, b], options).path;
-var intersectPaths = (a, b, options) => pathBoolean("intersection", [a, b], options).path;
-var subtractPaths = (a, b, options) => pathBoolean("difference", [a, b], options).path;
-var excludePaths = (a, b, options) => pathBoolean("xor", [a, b], options).path;
-function dividePaths(operands, options = {}) {
-  if (operands.length === 0) return { pieces: [], engine: "curve" };
-  try {
-    const arr = buildArrangement(operands, options);
-    const signatures = /* @__PURE__ */ new Map();
-    const note = (windings) => {
-      const flags = insideFlags2(windings, arr.fillRules);
-      if (!flags.some(Boolean)) return;
-      const key = flags.map((f) => f ? "1" : "0").join("");
-      if (!signatures.has(key)) signatures.set(key, flags.flatMap((f, k) => f ? [k] : []));
-    };
-    arr.edges.forEach((_, i) => {
-      note(arr.left[i]);
-      note(arr.right[i]);
-    });
-    const pieces = [];
-    for (const key of [...signatures.keys()].sort()) {
-      const rings = extractRings(arr, (flags) => flags.map((f) => f ? "1" : "0").join("") === key);
-      const groups = groupRings(rings).sort((a, b) => b[0].area - a[0].area);
-      for (const group of groups) pieces.push({ path: ringsToPath2(group), operands: signatures.get(key) });
-    }
-    return { pieces, engine: "curve" };
-  } catch (error) {
-    const reason = reasonOf(error);
-    if (reason === NON_FINITE) return { pieces: [], engine: "curve", error: reason };
-    if (options.fallback === false) throw error;
-    options.onFallback?.(reason);
-    const tolerance = options.fallbackTolerance ?? 0.05;
-    const pieces = dividePolygons(
-      operands.map((o) => flattenOperand(o, tolerance)),
-      { epsilon: options.epsilon }
-    ).map((p) => ({ path: multiToPath([p.polygon], tolerance), operands: p.operands }));
-    return { pieces, engine: "polygon", fallbackReason: reason };
-  }
-}
-function normalizeBezierPath(path, fillRule = "nonzero", options = {}) {
-  return pathBoolean("union", [{ path, fillRule }], options).path;
-}
-function bezierPathArea(path, fillRule = "nonzero", options = {}) {
-  const normalized = normalizeBezierPath(path, fillRule, options);
-  let sum = 0;
-  for (const contour of pathToContours(normalized)) sum += contourSignedArea(closeContour(contour, true));
-  return Math.abs(sum);
-}
-function pathBooleanRings(operation, operands, options = {}) {
-  const arr = buildArrangement(operands, options);
-  const rings = extractRings(arr, typeof operation === "function" ? operation : predicate2(operation));
-  const order = rings.map((_, i) => i).sort((a, b) => Math.abs(rings[a].area) - Math.abs(rings[b].area));
-  return rings.map((ring, i) => {
-    const sample = ringSample(ring);
-    let parent = -1;
-    for (const j of order) {
-      if (j === i || Math.abs(rings[j].area) <= Math.abs(ring.area)) continue;
-      if (windingNumber([rings[j].segs], sample) !== 0) {
-        parent = j;
-        break;
-      }
-    }
-    return { segments: ring.segs, area: ring.area, parent };
-  });
-}
-function nestedRingsToPath(rings, keep = () => true) {
-  const contours = [];
-  rings.forEach((r, i) => {
-    if (keep(i)) contours.push({ segments: r.segments, closed: true });
-  });
-  return contoursToPath(contours);
-}
-
 // src/canvas/pathops/stroke.ts
 var DEFAULT_TOLERANCE = 0.01;
 var normal = (t) => [-t[1], t[0]];
@@ -4901,30 +1735,30 @@ function raise(seg) {
   return [p0, [p0[0] + 2 / 3 * (p1[0] - p0[0]), p0[1] + 2 / 3 * (p1[1] - p0[1])], [p2[0] + 2 / 3 * (p1[0] - p2[0]), p2[1] + 2 / 3 * (p1[1] - p2[1])], p2];
 }
 function isDegenerate(seg, tol) {
-  return seg.every((p) => dist2(p, seg[0]) <= tol);
+  return seg.every((p) => dist(p, seg[0]) <= tol);
 }
 function offsetSegment(seg, d, tol, out, depth = 0) {
   if (seg.length === 2) {
     const n = normal(segmentTangent(seg, 0));
-    out.push([add2(seg[0], scale(n, d)), add2(seg[1], scale(n, d))]);
+    out.push([add(seg[0], scale(n, d)), add(seg[1], scale(n, d))]);
     return;
   }
   const c = raise(seg);
   const t0 = segmentTangent(c, 0);
   const t1 = segmentTangent(c, 1);
-  const q0 = add2(c[0], scale(normal(t0), d));
-  const q3 = add2(c[3], scale(normal(t1), d));
+  const q0 = add(c[0], scale(normal(t0), d));
+  const q3 = add(c[3], scale(normal(t1), d));
   const k0 = segmentCurvature(c, 0);
   const k1 = segmentCurvature(c, 1);
   const f0 = Number.isFinite(k0) ? 1 - d * k0 : 1;
   const f1 = Number.isFinite(k1) ? 1 - d * k1 : 1;
-  const q1 = add2(q0, scale(sub2(c[1], c[0]), f0));
-  const q2 = add2(q3, scale(sub2(c[2], c[3]), f1));
+  const q1 = add(q0, scale(sub(c[1], c[0]), f0));
+  const q2 = add(q3, scale(sub(c[2], c[3]), f1));
   const approx = [q0, q1, q2, q3];
   if (depth < 10) {
     let err = 0;
     for (const t of [0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875]) {
-      const target = add2(segmentPoint(c, t), scale(normal(segmentTangent(c, t)), d));
+      const target = add(segmentPoint(c, t), scale(normal(segmentTangent(c, t)), d));
       err = Math.max(err, segmentNearest(approx, target).distance);
       if (err > tol) break;
     }
@@ -4968,10 +1802,10 @@ function lineTo(out, from, to) {
   if (!samePoint(from, to)) out.push([from, to]);
 }
 function addJoin(out, p, tin, tout, d, style) {
-  const from = add2(p, scale(normal(tin), d));
-  const to = add2(p, scale(normal(tout), d));
+  const from = add(p, scale(normal(tin), d));
+  const to = add(p, scale(normal(tout), d));
   const turn = cross(tin, tout);
-  const cos = dot2(tin, tout);
+  const cos = dot(tin, tout);
   if (Math.abs(turn) < 1e-9 && cos > 0) {
     lineTo(out, from, to);
     return;
@@ -4985,7 +1819,7 @@ function addJoin(out, p, tin, tout, d, style) {
   }
   const theta = reversal ? d > 0 ? -Math.PI : Math.PI : Math.atan2(turn, cos);
   if (style.join === "round") {
-    const v = sub2(from, p);
+    const v = sub(from, p);
     pushArc(out, p, Math.abs(d), Math.atan2(v[1], v[0]), theta, from, to);
     return;
   }
@@ -4995,8 +1829,8 @@ function addJoin(out, p, tin, tout, d, style) {
     if (ratio <= style.miterLimit) {
       const nin = normal(tin);
       const nout = normal(tout);
-      const s = d / (1 + dot2(nin, nout));
-      const miter = add2(p, scale(add2(nin, nout), s));
+      const s = d / (1 + dot(nin, nout));
+      const miter = add(p, scale(add(nin, nout), s));
       lineTo(out, from, miter);
       lineTo(out, miter, to);
       return;
@@ -5030,13 +1864,13 @@ function reverseChain(chain) {
 }
 function addCap(out, p, t, h, cap) {
   const n = normal(t);
-  const from = add2(p, scale(n, h));
-  const to = add2(p, scale(n, -h));
+  const from = add(p, scale(n, h));
+  const to = add(p, scale(n, -h));
   if (cap === "round") {
     pushArc(out, p, h, Math.atan2(n[1], n[0]), -Math.PI, from, to);
   } else if (cap === "square") {
-    const a = add2(from, scale(t, h));
-    const b = add2(to, scale(t, h));
+    const a = add(from, scale(t, h));
+    const b = add(to, scale(t, h));
     lineTo(out, from, a);
     lineTo(out, a, b);
     lineTo(out, b, to);
@@ -5081,7 +1915,7 @@ function strokeContour(contour, h, style, tol) {
   if (ring.length > 0) joinTo(ring[0][0]);
   return [ring];
 }
-function ringsToPath3(rings) {
+function ringsToPath(rings) {
   return contoursToPath(rings.filter((r) => r.length > 0).map((segments) => ({ segments, closed: true })));
 }
 var MAX_DASHES = 2e5;
@@ -5216,7 +2050,7 @@ function mergeSmoothRuns(path, tolerance) {
       if (a.length !== 4 || b.length !== 4) return false;
       const ta = segmentTangent(a, 1);
       const tb = segmentTangent(b, 0);
-      return dot2(ta, tb) > 0.9998 && Math.abs(cross(ta, tb)) < 0.02;
+      return dot(ta, tb) > 0.9998 && Math.abs(cross(ta, tb)) < 0.02;
     };
     let start = 0;
     for (let k = 0; k < n; k++) {
@@ -5267,11 +2101,11 @@ function strokeOutlineRings(input, options) {
     const dashed = dashContours(contours, options.dash, options.dashOffset ?? 0);
     if (dashed) {
       contours = dashed.contours;
-      for (const dot3 of dashed.dots) rings.push(...dotRings(dot3.point, dot3.tangent, h, style.cap));
+      for (const dot2 of dashed.dots) rings.push(...dotRings(dot2.point, dot2.tangent, h, style.cap));
     }
   }
   for (const contour of contours) rings.push(...strokeContour(contour, h, style, tol));
-  return ringsToPath3(rings);
+  return ringsToPath(rings);
 }
 function outlineStroke(input, options) {
   const h = options.width / 2;
@@ -5821,8 +2655,8 @@ function snapResize(rect, handle, targets, options = {}) {
   const ratio = rect.height > 0 ? rect.width / rect.height : 0;
   if (options.keepAspectRatio && ratio > 0 && (hitX || hitY)) {
     if (axes.x !== 0 && axes.y !== 0) {
-      const dist3 = (h, horizontal) => h ? Math.abs(h.value - (horizontal ? axes.x < 0 ? x0 : x1 : axes.y < 0 ? y0 : y1)) : Infinity;
-      const useX = dist3(hitX, true) <= dist3(hitY, false);
+      const dist2 = (h, horizontal) => h ? Math.abs(h.value - (horizontal ? axes.x < 0 ? x0 : x1 : axes.y < 0 ? y0 : y1)) : Infinity;
+      const useX = dist2(hitX, true) <= dist2(hitY, false);
       if (useX && hitX) {
         setEdge(true, hitX.value);
         const height = (nx1 - nx0) / ratio;
@@ -6201,13 +3035,13 @@ function layoutFrameInner(s, frame) {
     let used = 0;
     items.forEach((it, i) => {
       const sz = it.fillMain ? it.minMain ?? 0 : it.main;
-      const add3 = cur.length === 0 ? sz : Math.max(gap, 0) + sz;
-      if (cur.length > 0 && used + add3 > innerMainFixed + 1e-6) {
+      const add2 = cur.length === 0 ? sz : Math.max(gap, 0) + sz;
+      if (cur.length > 0 && used + add2 > innerMainFixed + 1e-6) {
         lines.push(cur);
         cur = [];
         used = sz;
       } else {
-        used += add3;
+        used += add2;
       }
       cur.push(i);
     });
@@ -6425,11 +3259,11 @@ function resolveTracks(tracks, content, avail) {
   let used = out.reduce((sum, v, i) => trackSpec(tracks, i).sizing === "fill" ? sum : sum + v, 0);
   while (flex.length > 0) {
     const total = flex.reduce((sum, i) => sum + fr(i), 0);
-    const unit3 = total > 1e-12 ? Math.max(avail - used, 0) / total : 0;
-    const open = flex.filter((i) => unit3 * fr(i) >= out[i]);
-    const frozen = flex.filter((i) => unit3 * fr(i) < out[i]);
+    const unit = total > 1e-12 ? Math.max(avail - used, 0) / total : 0;
+    const open = flex.filter((i) => unit * fr(i) >= out[i]);
+    const frozen = flex.filter((i) => unit * fr(i) < out[i]);
     if (frozen.length === 0) {
-      for (const i of open) out[i] = unit3 * fr(i);
+      for (const i of open) out[i] = unit * fr(i);
       break;
     }
     used += frozen.reduce((sum, i) => sum + out[i], 0);
@@ -9614,8 +6448,8 @@ function sizeOf(node) {
   return { width: node.width, height: node.height, styleWidth: s.width, styleHeight: s.height };
 }
 var splitGroup = (group) => {
-  const dot3 = group.indexOf(".");
-  return dot3 < 0 ? [group, ""] : [group.slice(0, dot3), group.slice(dot3 + 1)];
+  const dot2 = group.indexOf(".");
+  return dot2 < 0 ? [group, ""] : [group.slice(0, dot2), group.slice(dot2 + 1)];
 };
 function readOverrideGroup(node, group) {
   const data = dataOf(node);
@@ -9728,7 +6562,7 @@ function listGroups(node, out) {
     if (LINK_KEYS.has(k)) continue;
     const prefix = NESTED_KEYS[k];
     if (prefix) {
-      if (isRecord(v)) for (const sub3 of Object.keys(v)) out.add(`${prefix}.${sub3}`);
+      if (isRecord(v)) for (const sub2 of Object.keys(v)) out.add(`${prefix}.${sub2}`);
       continue;
     }
     out.add(`data.${k}`);
@@ -11041,11 +7875,11 @@ function restoreCanvasMainComponent(nodes, id, options = {}) {
   if (g.get(inst.componentId)) return fail(nodes, "invalid", "The main component still exists.");
   if (enclosingInstanceIn(g, id) !== void 0) return fail(nodes, "nested-instance", "Select the outer instance.");
   const compId = inst.componentId;
-  const sub3 = g.subtree(id);
+  const sub2 = g.subtree(id);
   const map = /* @__PURE__ */ new Map([[id, compId]]);
   const taken = new Set(nodes.map((n) => n.id));
   taken.add(compId);
-  for (const d of sub3) {
+  for (const d of sub2) {
     if (d === id) continue;
     const src = enclosingInstanceIn(g, d) === id ? getComponentSourceId(g.get(d)) : void 0;
     if (src && !taken.has(src)) {
@@ -11055,7 +7889,7 @@ function restoreCanvasMainComponent(nodes, id, options = {}) {
   }
   const nested = [];
   const replaced = /* @__PURE__ */ new Map();
-  for (const d of sub3) {
+  for (const d of sub2) {
     let n = g.get(d);
     const nid = map.get(d) ?? d;
     const parentId = n.parentId !== void 0 ? map.get(n.parentId) ?? n.parentId : void 0;
@@ -11222,15 +8056,15 @@ function addCanvasVariant(nodes, setId, options = {}) {
   const taken = new Set(g.byId.keys());
   taken.add(id);
   const map = /* @__PURE__ */ new Map([[fromId, id]]);
-  const sub3 = g.subtree(fromId);
-  for (const d of sub3) {
+  const sub2 = g.subtree(fromId);
+  for (const d of sub2) {
     if (d === fromId) continue;
     const nid = uniqueId(`${id}-${d}`, taken);
     taken.add(nid);
     map.set(d, nid);
   }
   const order = variantOrder([...edit.variants.map((v) => v.id), id], edit.values);
-  const subSet = new Set(sub3);
+  const subSet = new Set(sub2);
   const copies = nodes.filter((n) => subSet.has(n.id)).map((n) => {
     const next = { ...n, id: map.get(n.id) };
     if (n.parentId !== void 0 && n.id !== fromId) next.parentId = map.get(n.parentId) ?? n.parentId;
@@ -11789,8 +8623,8 @@ function findStrokesAtPoint(point, nodes, radius = 12) {
     }
     const localPoint = [point[0] - rect.x, point[1] - rect.y];
     try {
-      const dist3 = distanceToBezierPath(shape.d, localPoint);
-      if (dist3 <= effectiveRadius) {
+      const dist2 = distanceToBezierPath(shape.d, localPoint);
+      if (dist2 <= effectiveRadius) {
         matches2.push(node);
       }
     } catch {
@@ -12103,7 +8937,7 @@ export {
   flattenSvgPath,
   flowSide,
   formatAnimationTime,
-  formatNumber2 as formatNumber,
+  formatNumber,
   formatOklab,
   formatVariantName,
   getAbsolutePosition,