@pixerate/editor 0.30.0 → 0.32.0

package/dist/chunk-GQTXV2EQ.js

@@ -0,0 +1,3335 @@
+// 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 [px, 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) > px) winding++;
+      } else if (by <= py && ay > py) {
+        if (ax + (py - ay) / (by - ay) * (bx - ax) > px) 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 num = dot(diff, d1);
+  const den = dot(d1, d1) + dot(diff, d2);
+  if (Math.abs(den) < 1e-12) return t;
+  const nt = t - num / den;
+  return Number.isFinite(nt) ? Math.min(1, Math.max(0, nt)) : t;
+}
+function fitSingleFrom(pts, u, t0, t1) {
+  let best = generate(pts, u, t0, t1);
+  let [bestErr, bestSplit] = maxError(pts, best, u);
+  const params = u.slice();
+  for (let round = 0; round < MAX_REPARAM; round++) {
+    for (let 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 num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+  const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
+  let coef = den === 0 ? 0 : Math.sqrt(Math.max(0, num / den));
+  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 num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+  const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
+  let coef = den === 0 ? 0 : Math.sqrt(Math.max(0, num / den));
+  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 [px, 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 > px) {
+        winding += dir;
+        continue;
+      }
+      if (maxX <= px) continue;
+      const t = solveMonotone(s, 1, py);
+      if (segmentPoint(s, t)[0] > px) 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);
+}
+
+export {
+  ringSignedArea,
+  polygonArea,
+  multiPolygonArea,
+  multiPolygonBounds,
+  pointInRings,
+  pointInMultiPolygon,
+  polygonBoolean,
+  unionPolygons,
+  intersectPolygons,
+  subtractPolygons,
+  xorPolygons,
+  dividePolygons,
+  cubicPointAt,
+  fitCubicRun,
+  fitCubics,
+  isStraightCubic,
+  cubicsToPathData,
+  fitPathData,
+  fitFreehandPath,
+  CANVAS_GRADIENT_PRESETS,
+  isCanvasGradient,
+  parseCssGradient,
+  resolveCanvasGradient,
+  angleToSvgLinearCoords,
+  gradientToSvgDef,
+  SHAPE_KINDS,
+  isShapeDescription,
+  parseSvgPath,
+  flattenSvgPath,
+  getShapeSvg,
+  getShapeRenderData,
+  shapeToPolygon,
+  formatNumber2 as formatNumber,
+  simplifyRing,
+  polygonToSvgPath,
+  sub2 as sub,
+  add2 as add,
+  scale,
+  dot2 as dot,
+  cross,
+  dist2 as dist,
+  samePoint,
+  segmentPoint,
+  segmentDerivative,
+  segmentTangent,
+  segmentCurvature,
+  splitSegment,
+  subSegment,
+  segmentExtrema,
+  segmentBounds,
+  segmentLength,
+  segmentParamAtLength,
+  segmentNearest,
+  arcToCubics,
+  toBezierPath,
+  pathToContours,
+  contoursToPath,
+  bezierPathToSvg,
+  transformBezierPath,
+  countPathSegments,
+  closeContour,
+  bezierPathBounds,
+  bezierPathSignedArea,
+  contourSignedArea,
+  bezierPathLength,
+  bezierPathPointAtLength,
+  trimSegments,
+  windingNumber,
+  pointInBezierPath,
+  distanceToBezierPath,
+  flattenChain,
+  PathOpsError,
+  pathBoolean,
+  unitePaths,
+  intersectPaths,
+  subtractPaths,
+  excludePaths,
+  dividePaths,
+  normalizeBezierPath,
+  bezierPathArea,
+  pathBooleanRings,
+  nestedRingsToPath
+};
+//# sourceMappingURL=chunk-GQTXV2EQ.js.map