@pixerate/editor 0.54.0 → 0.55.0

package/dist/{chunk-YNSK4MGT.cjs → chunk-O2UH7LZE.cjs}

@@ -1,772 +1,283 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4;// 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;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// 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);
 }
-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 };
+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 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 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 pointInMultiPolygon(point, multi) {
-  return multi.some((polygon) => pointInRings(point, polygon, "evenodd"));
+function cubicPointAt(c, t) {
+  return evalCubic(c, t);
 }
-function cleanRing(ring) {
+function dedup(points) {
   const out = [];
-  for (const p of ring) {
+  for (const p of points) {
     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;
+    if (out.length === 0 || dist(out[out.length - 1], p) > 1e-12) out.push(p);
   }
   return out;
 }
-function isOperand(input) {
-  return !Array.isArray(input) && typeof input === "object" && input !== null && Array.isArray(input.rings);
+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 normalizeInput(input) {
-  if (isOperand(input)) {
-    return {
-      rings: input.rings.map(cleanRing).filter((r) => r.length >= 3),
-      fillRule: _nullishCoalesce(input.fillRule, () => ( "nonzero"))
-    };
+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 rings = [];
-  for (const polygon of _nullishCoalesce(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());
-    });
+  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;
   }
-  return { rings, fillRule: "nonzero" };
-}
-var PointPool = (_class = class {
-  constructor(eps) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
-    this.eps = eps;
+  if (!Number.isFinite(al) || !Number.isFinite(ar) || al < eps || ar < eps) {
+    al = seg / 3;
+    ar = seg / 3;
   }
-  
-  __init() {this.vertices = []}
-  __init2() {this.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;
-          }
-        }
-      }
+  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;
     }
-    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;
   }
-}, _class);
-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) };
+  return [e, idx];
 }
-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 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 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);
-    }
+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;
   }
-  let changed = false;
+  return [best, bestErr, bestSplit];
+}
+function fitCubicWithTangents(points, params, t0, t1) {
+  const [curve, error] = fitSingleFrom(points.slice(), params.slice(), [t0[0], t0[1]], [t1[0], t1[1]]);
+  return { curve, error };
+}
+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 = _nullishCoalesce(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 = [];
-  for (const { segment, points } of splits) {
-    if (points.size === 0) {
-      out.push(segment);
-      continue;
+  if (pts.length < 2) return out;
+  const n = pts.length;
+  const start = _nullishCoalesce(_nullishCoalesce((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 = _nullishCoalesce((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;
     }
-    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;
+    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 (prev.id !== segment.b.id) out.push({ a: prev, b: segment.b, operand: segment.operand });
+    if (sharpest) corners.push(i);
   }
-  return { segments: out, changed };
+  return corners;
 }
-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;
+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 Math.max(1e-9, max * 1e-9);
+  return out;
 }
-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 });
-      }
+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 = _nullishCoalesce(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));
     }
-  });
-  for (let pass = 0; pass < 8; pass++) {
-    const result = splitPass(segments, pool, eps);
-    segments = result.segments;
-    if (!result.changed) break;
+    if (closed && n === 2) out2.push(...fitCubicRun([pts[1], pts[0]], tol));
+    return out2;
   }
-  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 corners = findCorners(pts, true, cornerAngle, span);
+  if (corners.length === 0) {
+    const ring = [...pts, pts[0]];
+    const t = _nullishCoalesce(unit(sub(pts[1], pts[n - 1])), () => ( [1, 0]));
+    return fitCubicRun(densify(ring), tol, t, t);
   }
-  const edges = [...byKey.values()].filter((e) => e.mult.some((m) => m !== 0));
-  const right = [];
-  const left = [];
-  const bandCount = Math.max(1, Math.min(4096, Math.ceil(Math.sqrt(edges.length))));
-  const bandIndex = (horizontal) => {
-    const lo = (e) => horizontal ? Math.min(-e.a.x, -e.b.x) : Math.min(e.a.y, e.b.y);
-    const hi = (e) => horizontal ? Math.max(-e.a.x, -e.b.x) : Math.max(e.a.y, e.b.y);
-    let min = Infinity;
-    let max = -Infinity;
-    for (const e of edges) {
-      min = Math.min(min, lo(e));
-      max = Math.max(max, hi(e));
-    }
-    const size = max > min ? (max - min) / bandCount : 1;
-    const band = (v) => Math.min(bandCount - 1, Math.max(0, Math.floor((v - min) / size)));
-    const bands = Array.from({ length: bandCount }, () => []);
-    edges.forEach((e, j) => {
-      for (let k = band(lo(e)); k <= band(hi(e)); k++) bands[k].push(j);
-    });
-    return (v) => bands[band(v)];
-  };
-  const bandsFor = /* @__PURE__ */ new Map();
-  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);
-    if (!bandsFor.has(horizontal)) bandsFor.set(horizontal, bandIndex(horizontal));
-    for (const j of bandsFor.get(horizontal)(my)) {
-      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 fitCubicWithTangents(points, params, t0, t1) {
-  const [curve, error] = fitSingleFrom(points.slice(), params.slice(), [t0[0], t0[1]], [t1[0], t1[1]]);
-  return { curve, error };
-}
-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 = _nullishCoalesce(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 = _nullishCoalesce(_nullishCoalesce((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 = _nullishCoalesce((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, span2) {
-  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]) >= span2) 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]) >= span2) 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 = _nullishCoalesce(options.cornerAngleDeg, () => ( 30));
-  const n = pts.length;
-  const span2 = 4 * tol;
-  if (!closed || n < 3) {
-    const corners2 = [0, ...n > 2 ? findCorners(pts, false, cornerAngle, span2) : [], 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, span2);
-  if (corners.length === 0) {
-    const ring = [...pts, pts[0]];
-    const t = _nullishCoalesce(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;
+  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));
   }
@@ -1077,12 +588,12 @@ function isShapeDescription(value) {
   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 = (_class2 = class {
-  constructor(text) {;_class2.prototype.__init3.call(this);
+var PathScanner = (_class = class {
+  constructor(text) {;_class.prototype.__init.call(this);
     this.text = text;
   }
   
-  __init3() {this.pos = 0}
+  __init() {this.pos = 0}
   skip() {
     while (this.pos < this.text.length && /[\s,]/.test(this.text[this.pos])) this.pos++;
   }
@@ -1117,7 +628,7 @@ var PathScanner = (_class2 = class {
     }
     return null;
   }
-}, _class2);
+}, _class);
 function parseSvgPath(d) {
   const scanner = new PathScanner(_nullishCoalesce(d, () => ( "")));
   const commands = [];
@@ -1509,914 +1020,1403 @@ function getShapeRenderData(shape, size = {}, options = {}) {
   } 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: _nullishCoalesce(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;
+  const data = {
+    viewBox: `0 0 ${formatNumber2(width, 3)} ${formatNumber2(height, 3)}`,
+    width,
+    height,
+    d: svg.d,
+    fillRule: svg.fillRule,
+    fill: fillStr,
+    stroke: strokeStr,
+    strokeWidth: _nullishCoalesce(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 = _nullishCoalesce(shape.fillRule, () => ( "nonzero"));
+    const vb = validViewBox(shape.viewBox);
+    if (vb) {
+      const sx = w / vb[2];
+      const sy = h / vb[3];
+      const tolerance = (_nullishCoalesce(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 = _nullishCoalesce(options.precision, () => ( 3));
+  const f = (n) => formatNumber2(n, precision);
+  const dx = _nullishCoalesce(_optionalChain([options, 'access', _14 => _14.offset, 'optionalAccess', _15 => _15.x]), () => ( 0));
+  const dy = _nullishCoalesce(_optionalChain([options, 'access', _16 => _16.offset, 'optionalAccess', _17 => _17.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: _nullishCoalesce(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 _nullishCoalesce(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 clampRatio(value) {
-  if (value === void 0 || !Number.isFinite(value)) return 0.5;
-  return Math.min(1, Math.max(0.01, value));
+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 validViewBox(vb) {
-  if (!vb || vb.length !== 4 || !vb.every(Number.isFinite) || vb[2] <= 0 || vb[3] <= 0) return null;
-  return vb;
+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 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 = _nullishCoalesce(shape.fillRule, () => ( "nonzero"));
-    const vb = validViewBox(shape.viewBox);
-    if (vb) {
-      const sx = w / vb[2];
-      const sy = h / vb[3];
-      const tolerance = (_nullishCoalesce(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);
+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;
     }
-  } else {
-    const { d } = getShapeSvg({ ...shape, rotation: 0 }, size);
-    rings = flattenSvgPath(d, options);
+    if (Math.abs(cross(chord, v)) / len > tol) return false;
+    const along = dot2(chord, v) / len;
+    if (along < -tol || along > len + tol) return false;
   }
-  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);
+  return true;
 }
-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";
+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;
   }
-  return d;
+  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 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 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 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;
+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]);
       }
     }
-    if (index !== -1 && maxDist > tolerance) {
-      keep[index] = 1;
-      stack.push([s, index], [index, e]);
-    }
   }
-  return points.filter((_, i) => keep[i]);
+  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 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;
-    }
+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;
   }
-  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 : [];
+  return t;
 }
-function polygonToSvgPath(input, options = {}) {
-  const precision = _nullishCoalesce(options.precision, () => ( 3));
-  const f = (n) => formatNumber2(n, precision);
-  const dx = _nullishCoalesce(_optionalChain([options, 'access', _14 => _14.offset, 'optionalAccess', _15 => _15.x]), () => ( 0));
-  const dy = _nullishCoalesce(_optionalChain([options, 'access', _16 => _16.offset, 'optionalAccess', _17 => _17.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: _nullishCoalesce(options.curveTolerance, () => ( 0.25)),
-          cornerAngleDeg: options.cornerAngleDeg,
-          precision,
-          offset: { x: dx, y: dy }
-        });
-        continue;
+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;
       }
-      rings.push(dx || dy ? r.map(([x, y]) => [x + dx, y + dy]) : r);
+      t = next;
     }
+    const d = dist2(p, segmentPoint(seg, t));
+    if (d < best.distance) best = { t, distance: d };
   }
-  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;
+  return best;
 }
-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]];
+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 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]
-  ];
+  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 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])];
+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;
+    }
   }
-  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 _nullishCoalesce(unit2(sub2(seg[seg.length - 1], seg[0])), () => ( [1, 0]));
+  return out;
 }
-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);
+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;
+    }
   }
-  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);
+  return contours;
 }
-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]]
-    ];
+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" });
   }
-  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]]
-    ];
+  return out;
+}
+function bezierPathToSvg(input, options = {}) {
+  const path = toBezierPath(input);
+  const precision = _nullishCoalesce(options.precision, () => ( 3));
+  const dx = _nullishCoalesce(_optionalChain([options, 'access', _18 => _18.offset, 'optionalAccess', _19 => _19.x]), () => ( 0));
+  const dy = _nullishCoalesce(_optionalChain([options, 'access', _20 => _20.offset, 'optionalAccess', _21 => _21.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;
+    }
   }
-  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]]
-  ];
+  return d;
 }
-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 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 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;
+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++;
     }
-    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;
+  return out;
 }
-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 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 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);
+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);
     }
-  } 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]);
-      }
+  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, 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;
+  return minX === Infinity ? null : { minX, minY, maxX, maxY };
 }
-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];
+function bezierPathSignedArea(input) {
   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;
+  for (const contour of pathToContours(input)) sum += contourSignedArea(closeContour(contour, true));
+  return sum;
 }
-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;
+function contourSignedArea(segs) {
   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;
+  for (const s of segs) sum += segmentAreaTerm(s);
+  return sum;
 }
-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 bezierPathLength(input) {
+  let total = 0;
+  for (const contour of pathToContours(input)) for (const s of closeContour(contour)) total += segmentLength(s);
+  return total;
 }
-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 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 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;
+function trimSegments(segs, from, to, lengths) {
+  const lens = _nullishCoalesce(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 = 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;
+  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);
-    const speed = Math.hypot(d[0], d[1]);
-    let next = speed > 0 ? t - err / speed : (lo + hi) / 2;
+    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 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)) };
+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;
+    }
   }
-  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;
+  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;
+    }
   }
-  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;
+  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]);
       }
-      t = next;
+      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);
     }
-    const d = dist2(p, segmentPoint(seg, t));
-    if (d < best.distance) best = { t, distance: d };
+    if (contour.segments.length === 0) continue;
   }
   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];
-  };
+function flattenChain(segs, tolerance) {
   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;
+  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;
 }
-function isBezierCommandList(input) {
-  return Array.isArray(input) && !input.some((c) => c && c.type === "A");
+
+// 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 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;
+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 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] });
+  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: _nullishCoalesce(input.fillRule, () => ( "nonzero"))
+    };
+  }
+  const rings = [];
+  for (const polygon of _nullishCoalesce(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 = (_class2 = class {
+  constructor(eps) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);
+    this.eps = eps;
+  }
+  
+  __init2() {this.vertices = []}
+  __init3() {this.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;
+          }
         }
-        current = [cmd.x, cmd.y];
-        break;
       }
-      case "Z":
-        if (open) out.push({ type: "Z" });
-        open = false;
-        current = start;
-        break;
     }
+    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;
   }
-  return out;
+}, _class2);
+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 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;
+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);
     }
   }
-  return contours;
-}
-function contoursToPath(contours) {
+  let changed = false;
   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 (const { segment, points } of splits) {
+    if (points.size === 0) {
+      out.push(segment);
+      continue;
     }
-    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] });
+    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 (contour.closed) out.push({ type: "Z" });
+    if (prev.id !== segment.b.id) out.push({ a: prev, b: segment.b, operand: segment.operand });
   }
-  return out;
+  return { segments: out, changed };
 }
-function bezierPathToSvg(input, options = {}) {
-  const path = toBezierPath(input);
-  const precision = _nullishCoalesce(options.precision, () => ( 3));
-  const dx = _nullishCoalesce(_optionalChain([options, 'access', _18 => _18.offset, 'optionalAccess', _19 => _19.x]), () => ( 0));
-  const dy = _nullishCoalesce(_optionalChain([options, 'access', _20 => _20.offset, 'optionalAccess', _21 => _21.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;
+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 d;
+  return Math.max(1e-9, max * 1e-9);
 }
-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 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 });
+      }
     }
   });
-}
-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++;
-    }
+  for (let pass = 0; pass < 8; pass++) {
+    const result = splitPass(segments, pool, eps);
+    segments = result.segments;
+    if (!result.changed) break;
   }
-  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);
+  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;
   }
-  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]);
+  const edges = [...byKey.values()].filter((e) => e.mult.some((m) => m !== 0));
+  const right = [];
+  const left = [];
+  const bandCount = Math.max(1, Math.min(4096, Math.ceil(Math.sqrt(edges.length))));
+  const bandIndex = (horizontal) => {
+    const lo = (e) => horizontal ? Math.min(-e.a.x, -e.b.x) : Math.min(e.a.y, e.b.y);
+    const hi = (e) => horizontal ? Math.max(-e.a.x, -e.b.x) : Math.max(e.a.y, e.b.y);
+    let min = Infinity;
+    let max = -Infinity;
+    for (const e of edges) {
+      min = Math.min(min, lo(e));
+      max = Math.max(max, hi(e));
     }
-  }
-  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 };
+    const size = max > min ? (max - min) / bandCount : 1;
+    const band = (v) => Math.min(bandCount - 1, Math.max(0, Math.floor((v - min) / size)));
+    const bands = Array.from({ length: bandCount }, () => []);
+    edges.forEach((e, j) => {
+      for (let k = band(lo(e)); k <= band(hi(e)); k++) bands[k].push(j);
+    });
+    return (v) => bands[band(v)];
+  };
+  const bandsFor = /* @__PURE__ */ new Map();
+  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);
+    if (!bandsFor.has(horizontal)) bandsFor.set(horizontal, bandIndex(horizontal));
+    for (const j of bandsFor.get(horizontal)(my)) {
+      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];
       }
-      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 };
     }
+    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 last;
+  return { edges, right, left, fillRules: operands.map((o) => o.fillRule), eps };
 }
-function trimSegments(segs, from, to, lengths) {
-  const lens = _nullishCoalesce(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 insideFlags(windings, fillRules) {
+  return windings.map((w, k) => fillRules[k] === "evenodd" ? (w & 1) === 1 : w !== 0);
 }
-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;
+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]);
   }
-  return t;
-}
-function yMonotonePieces(segs) {
-  const out = [];
-  for (const s of segs) {
-    if (s.length === 2) {
-      out.push(s);
-      continue;
+  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;
+      }
     }
-    const ts = segmentExtrema(s, 1);
-    let prev = 0;
-    for (const t of [...ts, 1]) {
-      out.push(subSegment(s, prev, t));
-      prev = t;
+    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 out;
+  return rings;
 }
-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;
+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;
       }
-      if (maxX <= px) continue;
-      const t = solveMonotone(s, 1, py);
-      if (segmentPoint(s, t)[0] > px) winding += dir;
+      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 winding;
+  return polygons;
 }
-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 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 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;
+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;
   }
-  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));
+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) });
   }
-  if (out.length > 1 && samePoint(out[0], out[out.length - 1])) out.pop();
-  return out;
+  return pieces;
 }
 
 // src/canvas/pathops/boolean.ts
@@ -3660,8 +3660,8 @@ function deepPoint(rings) {
     }
     xs.sort((p, q) => p - q);
     for (let i = 0; i + 1 < xs.length; i += 2) {
-      const span2 = xs[i + 1] - xs[i];
-      if (!best || span2 > best.span) best = { span: span2, p: [(xs[i] + xs[i + 1]) / 2, y] };
+      const span = xs[i + 1] - xs[i];
+      if (!best || span > best.span) best = { span, p: [(xs[i] + xs[i + 1]) / 2, y] };
     }
   }
   return _nullishCoalesce(_optionalChain([best, 'optionalAccess', _36 => _36.p]), () => ( null));
@@ -3804,718 +3804,6 @@ function offsetPath(input, distance, options = {}) {
   }
 }
 
-// src/canvas/pathops/planar.ts
-var twin = (h) => h ^ 1;
-function boundsOf(segs) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const s of segs) {
-    for (const [x, y] of s) {
-      if (x < minX) minX = x;
-      if (x > maxX) maxX = x;
-      if (y < minY) minY = y;
-      if (y > maxY) maxY = y;
-    }
-  }
-  return { minX, minY, maxX, maxY };
-}
-var inBounds = (b, p) => p[0] >= b.minX && p[0] <= b.maxX && p[1] >= b.minY && p[1] <= b.maxY;
-function withoutSpurs(cycle) {
-  const out = [];
-  for (const h of cycle) {
-    if (out.length && out[out.length - 1] === twin(h)) out.pop();
-    else out.push(h);
-  }
-  while (out.length >= 2 && twin(out[0]) === out[out.length - 1]) {
-    out.pop();
-    out.shift();
-  }
-  return out;
-}
-function pinEnds(pts, a, b) {
-  const n = pts.length;
-  if (n === 2) return [a, b];
-  const out = pts.map((p) => [p[0], p[1]]);
-  const d0 = [a[0] - pts[0][0], a[1] - pts[0][1]];
-  const d1 = [b[0] - pts[n - 1][0], b[1] - pts[n - 1][1]];
-  out[0] = a;
-  out[n - 1] = b;
-  if (n === 3) {
-    out[1] = [pts[1][0] + (d0[0] + d1[0]) / 2, pts[1][1] + (d0[1] + d1[1]) / 2];
-  } else {
-    out[1] = [pts[1][0] + d0[0], pts[1][1] + d0[1]];
-    out[2] = [pts[2][0] + d1[0], pts[2][1] + d1[1]];
-  }
-  return out;
-}
-function interiorPoint(path) {
-  const chains = Array.isArray(path) && path.length > 0 && Array.isArray(path[0]) && Array.isArray(_optionalChain([path, 'access', _37 => _37[0], 'access', _38 => _38[0], 'optionalAccess', _39 => _39[0]])) ? path : pathToContours(path).map((c) => closeContour(c, true));
-  const b = boundsOf(chains.flat());
-  if (!(b.maxX > b.minX) || !(b.maxY > b.minY)) return null;
-  const tol = Math.max(b.maxX - b.minX, b.maxY - b.minY) * 1e-3;
-  const rings = chains.filter((c) => c.length).map((c) => flattenChain(c, tol));
-  let best = null;
-  for (const f of [0.5, 0.25, 0.75, 0.125, 0.375, 0.625, 0.875, 0.0625, 0.9375]) {
-    const y = b.minY + (b.maxY - b.minY) * (f + 61803e-7);
-    const xs = [];
-    for (const ring of rings) {
-      for (let i = 0; i < ring.length; i++) {
-        const a = ring[i];
-        const c = ring[(i + 1) % ring.length];
-        if (a[1] <= y !== c[1] <= y) xs.push(a[0] + (y - a[1]) / (c[1] - a[1]) * (c[0] - a[0]));
-      }
-    }
-    xs.sort((p, q) => p - q);
-    for (let i = 0; i + 1 < xs.length; i++) {
-      const width = xs[i + 1] - xs[i];
-      if (!(width > (_nullishCoalesce(_optionalChain([best, 'optionalAccess', _40 => _40.width]), () => ( 0))))) continue;
-      const m = [(xs[i] + xs[i + 1]) / 2, y];
-      if (windingNumber(chains, m) !== 0) best = { width, p: m };
-    }
-  }
-  return _nullishCoalesce(_optionalChain([best, 'optionalAccess', _41 => _41.p]), () => ( null));
-}
-var PlanarMap = (_class4 = class _PlanarMap {
-  constructor(vertices, edges, sources, eps, inputCount, inputs) {;_class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);
-    this.vertices = vertices;
-    this.edges = edges;
-    this.sources = sources;
-    this.eps = eps;
-    this.inputCount = inputCount;
-    this.fills = inputs.map((input) => {
-      const chains = input.fills === false ? [] : pathToContours(input.path).filter((c) => c.closed).map((c) => closeContour(c));
-      return { chains, fillRule: _nullishCoalesce(input.fillRule, () => ( "nonzero")), bounds: boundsOf(chains.flat()) };
-    });
-    const nv = vertices.length;
-    this.around = Array.from({ length: nv }, () => []);
-    for (let h = 0; h < edges.length * 2; h++) this.around[this.origin(h)].push(h);
-    this.slot = new Array(edges.length * 2).fill(0);
-    this.around.forEach((list, v) => {
-      if (list.length === 0) return;
-      const at = vertices[v];
-      let r = Infinity;
-      for (const h of list) r = Math.min(r, dist2(at, vertices[this.origin(twin(h))]));
-      r *= 0.5;
-      const keyed = list.map((h) => ({ h, angle: this.leavingAngle(h, at, r) }));
-      keyed.sort((a, b) => a.angle - b.angle);
-      list.length = 0;
-      keyed.forEach(({ h }, k) => {
-        list.push(h);
-        this.slot[h] = k;
-      });
-    });
-    const parent = Array.from({ length: nv }, (_, i) => i);
-    const find = (v) => {
-      while (parent[v] !== v) {
-        parent[v] = parent[parent[v]];
-        v = parent[v];
-      }
-      return v;
-    };
-    for (const e of edges) parent[find(e.a)] = find(e.b);
-    this.component = Array.from({ length: nv }, (_, v) => find(v));
-  }
-  
-  
-  
-  
-  
-  
-  
-  
-  __init6() {this.cyclesCache = null}
-  __init7() {this.sourcesCache = []}
-  
-  /**
-   * Maps `inputs` (their subpaths as given: open ones stay open). Null when they cannot be mapped
-   * (non-finite points, more than `maxSegments` segments or an intersection search that does
-   * not settle) or have no edges.
-   */
-  static build(inputs, options = {}) {
-    const chains = inputs.map((input) => pathToContours(input.path).map((c) => closeContour(c)).filter((c) => c.length));
-    const count = chains.reduce((n, cs) => n + cs.reduce((m, c) => m + c.length, 0), 0);
-    if (count === 0 || count > (_nullishCoalesce(options.maxSegments, () => ( 4096)))) return null;
-    let split;
-    try {
-      split = planarSplit(chains, options);
-    } catch (e6) {
-      return null;
-    }
-    const edges = split.edges.filter((e) => e.a !== e.b).map((e) => ({ ...e, source: _nullishCoalesce(e.operands[e.operands.length - 1], () => ( -1)) }));
-    if (!edges.length) return null;
-    const gap = _nullishCoalesce(options.gap, () => ( 0));
-    if (gap > split.eps) closeGaps(split.vertices, edges, gap);
-    return new _PlanarMap(split.vertices, edges, split.sources, split.eps, inputs.length, inputs);
-  }
-  // -- half-edges ------------------------------------------------------------
-  origin(h) {
-    const e = this.edges[h >> 1];
-    return h & 1 ? e.b : e.a;
-  }
-  halfPts(h) {
-    const pts = this.edges[h >> 1].pts;
-    return h & 1 ? [...pts].reverse() : pts;
-  }
-  /** The half-edge after `h` on the face to its left: the sharpest left turn at its end. */
-  next(h) {
-    const back = twin(h);
-    const list = this.around[this.origin(back)];
-    return list[(this.slot[back] + list.length - 1) % list.length];
-  }
-  /** Direction (angle) in which half-edge `h`, leaving `at`, first gets `r` away from it. */
-  leavingAngle(h, at, r) {
-    const pts = this.halfPts(h);
-    const d = (t2) => dist2(segmentPoint(pts, t2), at);
-    let lo = 0;
-    let hi = 1;
-    const steps = pts.length === 2 ? 1 : 16;
-    for (let k = 1; k <= steps; k++) {
-      if (d(k / steps) >= r) {
-        hi = k / steps;
-        break;
-      }
-      lo = k / steps;
-    }
-    for (let i = 0; i < 40 && hi - lo > 1e-12; i++) {
-      const m = (lo + hi) / 2;
-      if (d(m) >= r) hi = m;
-      else lo = m;
-    }
-    const p = segmentPoint(pts, hi);
-    if (dist2(p, at) > 0) return Math.atan2(p[1] - at[1], p[0] - at[0]);
-    const t = segmentTangent(pts, 0);
-    return Math.atan2(t[1], t[0]);
-  }
-  /** Segments of a run of half-edges (a loop unless `closed` is false), pieces of one input segment joined again. */
-  cycleSegments(halves, closed = true) {
-    const runs = halves.map((h) => {
-      const e = this.edges[h >> 1];
-      return { h, src: e.source < 0 ? -1 : e.src, from: h & 1 ? e.sb : e.sa, to: h & 1 ? e.sa : e.sb };
-    });
-    const joins = (a, b) => a.src >= 0 && a.src === b.src && Math.abs(a.to - b.from) < 1e-9 && a.to - a.from > 0 === b.to - b.from > 0;
-    const n = runs.length;
-    let start = 0;
-    for (let k = 0; closed && k < n; k++) {
-      if (!joins(runs[(k + n - 1) % n], runs[k])) {
-        start = k;
-        break;
-      }
-    }
-    const ordered = [...runs.slice(start), ...runs.slice(0, start)];
-    const out = [];
-    let i = 0;
-    while (i < ordered.length) {
-      let j = i + 1;
-      while (j < ordered.length && joins(ordered[j - 1], ordered[j])) j++;
-      const first = ordered[i];
-      const last = ordered[j - 1];
-      if (j - i === 1) out.push(this.halfPts(first.h));
-      else {
-        const a = this.vertices[this.origin(first.h)];
-        const b = this.vertices[this.origin(twin(last.h))];
-        const seg = this.sources[first.src];
-        out.push(seg.length === 2 ? [a, b] : pinEnds(subSegment(seg, first.from, last.to), a, b));
-      }
-      i = j;
-    }
-    return out;
-  }
-  cycles() {
-    if (this.cyclesCache) return this.cyclesCache;
-    const halves = this.edges.length * 2;
-    const seen = new Uint8Array(halves);
-    const faces = [];
-    const holes = [];
-    const sliver = this.eps * 10;
-    for (let start = 0; start < halves; start++) {
-      if (seen[start]) continue;
-      const walk = [];
-      let h = start;
-      while (!seen[h]) {
-        seen[h] = 1;
-        walk.push(h);
-        h = this.next(h);
-      }
-      const cycle = withoutSpurs(walk);
-      if (!cycle.length) continue;
-      const segments = this.cycleSegments(cycle);
-      const area = contourSignedArea(segments);
-      let perimeter = 0;
-      for (const s of segments) perimeter += s.length === 2 ? dist2(s[0], s[1]) : segmentLength(s, 0, 1, 1e-6);
-      if (!(perimeter > 0)) continue;
-      const entry = { halves: cycle, segments, area, bounds: boundsOf(segments) };
-      if (area > 0 && 2 * area / perimeter >= sliver) faces.push(entry);
-      else if (area < 0 && -2 * area / perimeter >= sliver) holes.push(entry);
-    }
-    const faceHoles = faces.map(() => []);
-    holes.forEach((hole, k) => {
-      const v = this.origin(hole.halves[0]);
-      const p = this.vertices[v];
-      const own = this.component[v];
-      let best = -1;
-      faces.forEach((face, i) => {
-        if (this.component[this.origin(face.halves[0])] === own || !inBounds(face.bounds, p)) return;
-        if (best >= 0 && faces[best].area <= face.area) return;
-        if (windingNumber([face.segments], p) !== 0) best = i;
-      });
-      if (best >= 0) faceHoles[best].push(k);
-    });
-    const faceOf = new Int32Array(halves).fill(-1);
-    faces.forEach((face, i) => {
-      for (const h of face.halves) faceOf[h] = i;
-      for (const k of faceHoles[i]) for (const h of holes[k].halves) faceOf[h] = i;
-    });
-    this.cyclesCache = { faces, holes, faceHoles, faceOf };
-    this.sourcesCache = faces.map(() => null);
-    return this.cyclesCache;
-  }
-  faceChains(i) {
-    const { faces, holes, faceHoles } = this.cycles();
-    return [faces[i].segments, ...faceHoles[i].map((k) => holes[k].segments)];
-  }
-  /** The bounded faces of the map. */
-  get faces() {
-    const { faces, holes, faceHoles } = this.cycles();
-    return faces.map((f, i) => {
-      const chains = this.faceChains(i);
-      const area = f.area + faceHoles[i].reduce((sum, k) => sum + holes[k].area, 0);
-      return { path: contoursToPath(chains.map((segments) => ({ segments, closed: true }))), area, bounds: f.bounds };
-    });
-  }
-  /** The inputs whose fill covers face `i`, ascending (empty for an area only outlines enclose). */
-  faceSources(i) {
-    this.cycles();
-    const cached = this.sourcesCache[i];
-    if (cached) return cached;
-    const p = interiorPoint(this.faceChains(i));
-    const out = [];
-    if (p) {
-      this.fills.forEach((fill, k) => {
-        if (!fill.chains.length || !inBounds(fill.bounds, p)) return;
-        const w = windingNumber(fill.chains, p);
-        if (fill.fillRule === "evenodd" ? (w & 1) === 1 : w !== 0) out.push(k);
-      });
-    }
-    this.sourcesCache[i] = out;
-    return out;
-  }
-  /** A point well inside face `i`. */
-  faceInterior(i) {
-    return interiorPoint(this.faceChains(i));
-  }
-  /** The face under `p` (the smallest one around it), or -1. */
-  faceAt(p) {
-    const { faces } = this.cycles();
-    let best = -1;
-    faces.forEach((face, i) => {
-      if (!inBounds(face.bounds, p) || best >= 0 && faces[best].area <= face.area) return;
-      if (windingNumber(this.faceChains(i), p) !== 0) best = i;
-    });
-    return best;
-  }
-  /**
-   * The union of faces, traced along the map's own edges: those between two merged faces drop
-   * out exactly, so no seam or sliver is left where a boolean union of their outlines could
-   * round shared corners apart. Outer subpaths come out counter-clockwise (y-up), holes clockwise.
-   */
-  merge(faceIndices) {
-    const { faceOf } = this.cycles();
-    const picked = new Set(faceIndices);
-    const merged = (h) => faceOf[h] >= 0 && picked.has(faceOf[h]);
-    const boundary = (h) => merged(h) && !merged(twin(h));
-    const used = new Uint8Array(this.edges.length * 2);
-    const contours = [];
-    for (let start = 0; start < used.length; start++) {
-      if (used[start] || !boundary(start)) continue;
-      const cycle = [];
-      let h = start;
-      let ok = true;
-      while (!used[h]) {
-        used[h] = 1;
-        cycle.push(h);
-        const back = twin(h);
-        const list = this.around[this.origin(back)];
-        const k = this.slot[back];
-        const n = list.length;
-        let found = -1;
-        for (let j = 1; j <= n; j++) {
-          const g = list[(k - j + n * 2) % n];
-          if (boundary(g)) {
-            found = g;
-            break;
-          }
-        }
-        if (found < 0) {
-          ok = false;
-          break;
-        }
-        h = found;
-      }
-      if (!ok || h !== start) continue;
-      contours.push({ segments: this.cycleSegments(cycle), closed: true });
-    }
-    return contoursToPath(contours);
-  }
-  /**
-   * The edges joined into runs between junctions: vertices where other than two edges meet, or
-   * where the two edges lie on different inputs. Each run is keyed by its input.
-   */
-  chains() {
-    const passes = (v) => {
-      const list = this.around[v];
-      if (list.length !== 2) return null;
-      return this.edges[list[0] >> 1].source === this.edges[list[1] >> 1].source ? [list[0], list[1]] : null;
-    };
-    const used = new Uint8Array(this.edges.length);
-    const out = [];
-    const walk = (h0) => {
-      const source = this.edges[h0 >> 1].source;
-      const halves = [];
-      let h = h0;
-      let closed = false;
-      for (; ; ) {
-        if (used[h >> 1]) {
-          closed = true;
-          break;
-        }
-        used[h >> 1] = 1;
-        halves.push(h);
-        const v = this.origin(twin(h));
-        const pass = passes(v);
-        if (!pass) {
-          closed = v === this.origin(h0);
-          break;
-        }
-        h = pass[0] === twin(h) ? pass[1] : pass[0];
-      }
-      if (source < 0) return;
-      const segments = this.cycleSegments(halves, closed);
-      out.push({ segments, closed, source });
-    };
-    this.around.forEach((list, v) => {
-      if (passes(v)) return;
-      for (const h of list) if (!used[h >> 1]) walk(h);
-    });
-    for (let e = 0; e < this.edges.length; e++) if (!used[e]) walk(e * 2);
-    return out;
-  }
-  // -- fill regions (cadcraft `boundary_at_gap`) -------------------------------
-  /**
-   * The region enclosing `p`, traced as cadcraft does it: a ray from `p` towards +x meets the
-   * edges in order; for each, the half-edge with `p` on its left is followed by always taking the
-   * sharpest left turn, until a loop that runs counter-clockwise round `p` comes back. The pieces
-   * of the map nested inside that loop (islands) become its holes. Null when nothing encloses `p`.
-   */
-  regionAt(p) {
-    const { faces, faceOf } = this.cycles();
-    const hits = [];
-    this.edges.forEach((e, i) => {
-      const ay = this.vertices[e.a][1];
-      const by = this.vertices[e.b][1];
-      if (ay > p[1] === by > p[1]) return;
-      const t = solveMonotone(e.pts, 1, p[1]);
-      const x = segmentPoint(e.pts, t)[0];
-      if (x > p[0]) hits.push({ x, e: i });
-    });
-    hits.sort((a, b) => a.x - b.x);
-    for (const { e } of hits.slice(0, 64)) {
-      const ay = this.vertices[this.edges[e].a][1];
-      const by = this.vertices[this.edges[e].b][1];
-      const h = by > ay ? e * 2 : e * 2 + 1;
-      const walk = [];
-      const seen = /* @__PURE__ */ new Set();
-      let g = h;
-      while (!seen.has(g)) {
-        seen.add(g);
-        walk.push(g);
-        g = this.next(g);
-      }
-      if (g !== h) continue;
-      const cycle = withoutSpurs(walk);
-      if (!cycle.length) continue;
-      const segments = this.cycleSegments(cycle);
-      if (!(contourSignedArea(segments) > 0) || windingNumber([segments], p) === 0) continue;
-      const face = faceOf[cycle[0]];
-      if (face >= 0 && faces[face].halves.includes(cycle[0])) {
-        return contoursToPath(this.faceChains(face).map((s) => ({ segments: s, closed: true })));
-      }
-      return contoursToPath([{ segments, closed: true }]);
-    }
-    return null;
-  }
-}, _class4);
-function closeGaps(vertices, edges, gap) {
-  const degree = new Array(vertices.length).fill(0);
-  const linked = /* @__PURE__ */ new Set();
-  for (const e of edges) {
-    degree[e.a]++;
-    degree[e.b]++;
-    linked.add(`${Math.min(e.a, e.b)},${Math.max(e.a, e.b)}`);
-  }
-  const ends = degree.flatMap((d, v) => d === 1 ? [v] : []).sort((a, b) => vertices[a][0] - vertices[b][0]);
-  const joined = /* @__PURE__ */ new Set();
-  let lo = 0;
-  for (let i = 0; i < ends.length; i++) {
-    const u = ends[i];
-    if (joined.has(u)) continue;
-    const pu = vertices[u];
-    while (lo < ends.length && vertices[ends[lo]][0] < pu[0] - gap) lo++;
-    let best = -1;
-    let bestD = Infinity;
-    for (let j = lo; j < ends.length; j++) {
-      const v = ends[j];
-      const pv = vertices[v];
-      if (pv[0] > pu[0] + gap) break;
-      if (v === u || joined.has(v) || linked.has(`${Math.min(u, v)},${Math.max(u, v)}`)) continue;
-      const d = dist2(pu, pv);
-      if (d <= gap && d < bestD) {
-        best = v;
-        bestD = d;
-      }
-    }
-    if (best < 0) continue;
-    const a = Math.min(u, best);
-    const b = Math.max(u, best);
-    edges.push({ a, b, pts: [vertices[a], vertices[b]], operands: [], src: -1, sa: 0, sb: 1, source: -1 });
-    joined.add(u);
-    joined.add(best);
-  }
-}
-function contourEnclosesArea(contour) {
-  const segs = closeContour(contour, true);
-  if (!segs.length) return false;
-  const b = boundsOf(segs);
-  const w = b.maxX - b.minX;
-  const h = b.maxY - b.minY;
-  return Math.abs(contourSignedArea(segs)) > 1e-9 * (w * w + h * h);
-}
-function nearestU(segs, p) {
-  let best = null;
-  segs.forEach((seg, k) => {
-    const n = segmentNearest(seg, p);
-    if (!best || n.distance < best.d) best = { u: k + n.t, d: n.distance };
-  });
-  return best;
-}
-function span(segs, u0, u1) {
-  const n = segs.length;
-  if (!n || !Number.isFinite(u0) || !Number.isFinite(u1)) return [];
-  const first = Math.max(0, Math.floor(u0));
-  const last = Math.min(Math.max(0, Math.ceil(u1)), first + 2 * n);
-  const out = [];
-  for (let k = first; k < last; k++) {
-    const t0 = Math.min(1, Math.max(0, u0 - k));
-    const t1 = Math.min(1, Math.max(0, u1 - k));
-    if (t1 - t0 > 1e-12) out.push(subSegment(segs[k % n], t0, t1));
-  }
-  return out;
-}
-function snapEnds2(segs, to, tol) {
-  if (!segs.length) return segs;
-  const out = segs.map((s) => [...s]);
-  const move = (seg, end, handle) => {
-    const q = to.find((t) => dist2(t, seg[end]) <= tol);
-    if (!q) return;
-    const d = [q[0] - seg[end][0], q[1] - seg[end][1]];
-    seg[end] = q;
-    if (seg.length === 4) seg[handle] = [seg[handle][0] + d[0], seg[handle][1] + d[1]];
-  };
-  move(out[0], 0, 1);
-  const last = out[out.length - 1];
-  move(last, last.length - 1, last.length - 2);
-  return out;
-}
-function cutOutPiece(path, piece, fillCloses, tol) {
-  const segs = piece.segments;
-  if (!segs.length) return null;
-  let mid = null;
-  let longest = -1;
-  let perimeter = 0;
-  for (const seg of segs) {
-    const len2 = segmentLength(seg);
-    perimeter += len2;
-    if (len2 > longest) {
-      longest = len2;
-      mid = segmentPoint(seg, 0.5);
-    }
-  }
-  if (!mid || perimeter <= tol) return null;
-  const a = segs[0][0];
-  const lastSeg = segs[segs.length - 1];
-  const b = lastSeg[lastSeg.length - 1];
-  const whole = !!piece.closed || dist2(a, b) <= tol;
-  const contours = pathToContours(path);
-  let found = null;
-  contours.forEach((c, index2) => {
-    if (!c.segments.length) return;
-    const closed2 = c.closed || fillCloses && contourEnclosesArea(c);
-    const ring2 = closeContour(c, closed2);
-    const n = nearestU(ring2, mid);
-    if (n && n.d <= tol && (!found || n.d < found.d)) found = { index: index2, ring: ring2, closed: closed2, um: n.u, d: n.d };
-  });
-  if (!found) return null;
-  const { index, ring, closed, um } = found;
-  const len = ring.length;
-  const real = closeContour(contours[index]).length;
-  const at = (p) => {
-    const n = nearestU(ring, p);
-    return n && n.d <= tol ? n.u : null;
-  };
-  let keep = [];
-  if (!whole) {
-    const ua = at(a);
-    const ub = at(b);
-    if (ua === null || ub === null) return null;
-    if (closed) {
-      const fwd = (from, to) => ((to - from) % len + len) % len;
-      const [start, end] = fwd(ua, um) <= fwd(ua, ub) ? [ub, ua] : [ua, ub];
-      const rest = fwd(start, end);
-      if (rest > 1e-9 && len - rest > 1e-9) {
-        const parts = real >= len ? [[0, 2 * len]] : [[0, real], [len, len + real]];
-        keep = parts.map(([lo, hi]) => [Math.max(start, lo), Math.min(start + rest, hi)]).filter(([x, y]) => y - x > 1e-9);
-      }
-    } else {
-      const lo = Math.min(ua, ub);
-      const hi = Math.max(ua, ub);
-      if (um < lo - 1e-9 || um > hi + 1e-9) return null;
-      keep = [[0, lo], [hi, len]].filter(([x, y]) => y - x > 1e-9);
-    }
-  }
-  const out = contours.slice(0, index);
-  for (const [u0, u1] of keep) {
-    const run = span(ring, u0, u1);
-    if (run.length) out.push({ segments: snapEnds2(run, [a, b], tol), closed: false });
-  }
-  out.push(...contours.slice(index + 1));
-  return contoursToPath(out);
-}
-
-// src/canvas/pathops/hatch.ts
-function hatchPath(path, options = {}) {
-  const out = [];
-  const b = bezierPathBounds(path);
-  if (!b || b.maxX - b.minX <= 0 || b.maxY - b.minY <= 0) return out;
-  const want = Math.max(_nullishCoalesce(options.gap, () => ( 4)), 1e-3);
-  const s = Math.SQRT1_2;
-  const rot = (p) => [(p[0] + p[1]) * s, (p[1] - p[0]) * s];
-  const unrot = (x, y) => ({ x: (x - y) * s, y: (x + y) * s });
-  const edges = [];
-  for (const contour of pathToContours(path)) {
-    const pts = flattenChain(closeContour(contour, true), want * 0.1).map(rot);
-    for (let i = 0; i < pts.length; i++) {
-      const p = pts[i];
-      const q = pts[(i + 1) % pts.length];
-      if (p[0] !== q[0] || p[1] !== q[1]) edges.push([p, q]);
-    }
-  }
-  let y0 = Infinity;
-  let y1 = -Infinity;
-  for (const [p, q] of edges) {
-    y0 = Math.min(y0, p[1], q[1]);
-    y1 = Math.max(y1, p[1], q[1]);
-  }
-  if (!(y1 > y0)) return out;
-  const gap = Math.max(want, (y1 - y0) / Math.max(1, _nullishCoalesce(options.maxLines, () => ( 400))), 1e-6);
-  const xs = [];
-  for (let y = Math.floor(y0 / gap) * gap + gap / 2; y < y1; y += gap) {
-    xs.length = 0;
-    for (const [p, q] of edges) if (p[1] <= y !== q[1] <= y) xs.push(p[0] + (y - p[1]) / (q[1] - p[1]) * (q[0] - p[0]));
-    xs.sort((m, n) => m - n);
-    for (let i = 0; i + 1 < xs.length; i += 2) {
-      out.push({ type: "M", ...unrot(xs[i], y) }, { type: "L", ...unrot(xs[i + 1], y) });
-    }
-  }
-  return out;
-}
-
-// src/canvas/pathops/pathfinder.ts
-var PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
-var top = (covering) => covering[covering.length - 1];
-function pathfinder(op, shapes, options = {}) {
-  const n = shapes.length;
-  if (n === 0) return { pieces: [], engine: "curve" };
-  const filled = shapes.filter((s) => !s.line);
-  const operands = shapes.map((s) => ({ path: s.path, fillRule: _nullishCoalesce(s.fillRule, () => ( "nonzero")) }));
-  if (op === "outline") {
-    const map = PlanarMap.build(
-      shapes.map((s) => ({ path: s.line ? s.path : closeAll(s.path), fills: false })),
-      options
-    );
-    if (!map) return { pieces: [], engine: "curve", error: "could not map the outlines" };
-    const pieces = map.chains().map((c) => ({ path: contoursToPath([{ segments: c.segments, closed: c.closed }]), source: c.source, open: !c.closed }));
-    return { pieces, engine: "curve" };
-  }
-  if (op === "divide") {
-    if (filled.length !== n) {
-      const map = PlanarMap.build(shapes.map((s) => ({ path: s.line ? s.path : closeAll(s.path), fillRule: s.fillRule, fills: !s.line })), options);
-      if (!map) return { pieces: [], engine: "curve", error: "could not map the shapes" };
-      const pieces = [];
-      map.faces.forEach((face, i) => {
-        const covering = map.faceSources(i);
-        if (covering.length) pieces.push({ path: face.path, source: top(covering) });
-      });
-      return { pieces, engine: "curve" };
-    }
-    const result = dividePaths(operands, options);
-    return { ...report(result), pieces: result.pieces.map((p) => ({ path: p.path, source: top(p.operands) })) };
-  }
-  const index = shapes.flatMap((s, i) => s.line ? [] : [i]);
-  const m = index.length;
-  if (m === 0) return { pieces: [], engine: "curve" };
-  const ops = index.map((i) => operands[i]);
-  const key = (k) => _nullishCoalesce(shapes[index[k]].key, () => ( index[k]));
-  const select = (selectors) => pathBooleanSelect(ops, selectors, options);
-  const joined = (parts) => parts.flat();
-  switch (op) {
-    case "trim": {
-      const result = select(index.map((_, k) => (c) => c.length > 0 && top(c) === k));
-      const pieces = result.parts.flatMap((parts, k) => parts.length ? [{ path: joined(parts), source: index[k] }] : []);
-      return { ...report(result), pieces };
-    }
-    case "merge": {
-      const keys = [];
-      for (let k = 0; k < m; k++) if (!keys.includes(key(k))) keys.push(key(k));
-      const result = select(keys.map((kk) => (c) => c.length > 0 && key(top(c)) === kk));
-      const pieces = [];
-      result.parts.forEach((parts, j) => {
-        let source = 0;
-        for (let k = 0; k < m; k++) if (key(k) === keys[j]) source = index[k];
-        for (const part of parts) pieces.push({ path: part, source });
-      });
-      return { ...report(result), pieces };
-    }
-    case "crop": {
-      if (m < 2) return { pieces: [], engine: "curve" };
-      const front = m - 1;
-      const result = select(
-        index.slice(0, front).map((_, k) => (c) => c.length >= 2 && top(c) === front && c[c.length - 2] === k)
-      );
-      const pieces = result.parts.flatMap((parts, k) => parts.length ? [{ path: joined(parts), source: index[k] }] : []);
-      return { ...report(result), pieces };
-    }
-    case "minusBack": {
-      const front = m - 1;
-      const result = select([(c) => c.length === 1 && c[0] === front]);
-      const parts = result.parts[0];
-      return { ...report(result), pieces: parts.length ? [{ path: joined(parts), source: index[front] }] : [] };
-    }
-  }
-  return { pieces: [], engine: "curve" };
-}
-function report(r) {
-  return { engine: r.engine, ...r.fallbackReason ? { fallbackReason: r.fallbackReason } : {}, ...r.error ? { error: r.error } : {} };
-}
-function closeAll(path) {
-  return contoursToPath(pathToContours(path).map((c) => ({ segments: c.segments, closed: true })));
-}
-
-
-
-
-
-
 
 
 
@@ -4601,5 +3889,5 @@ function closeAll(path) {
 
 
 
-exports.ringSignedArea = ringSignedArea; exports.polygonArea = polygonArea; exports.multiPolygonArea = multiPolygonArea; exports.multiPolygonBounds = multiPolygonBounds; exports.pointInRings = pointInRings; exports.pointInMultiPolygon = pointInMultiPolygon; exports.polygonBoolean = polygonBoolean; exports.unionPolygons = unionPolygons; exports.intersectPolygons = intersectPolygons; exports.subtractPolygons = subtractPolygons; exports.xorPolygons = xorPolygons; exports.dividePolygons = dividePolygons; exports.cubicPointAt = cubicPointAt; exports.fitCubicWithTangents = fitCubicWithTangents; exports.fitCubicRun = fitCubicRun; exports.fitCubics = fitCubics; exports.isStraightCubic = isStraightCubic; exports.cubicsToPathData = cubicsToPathData; exports.fitPathData = fitPathData; exports.fitFreehandPath = fitFreehandPath; exports.PIXERATE_BRAND_GRADIENT = PIXERATE_BRAND_GRADIENT; exports.CANVAS_GRADIENT_PRESETS = CANVAS_GRADIENT_PRESETS; exports.isCanvasGradient = isCanvasGradient; exports.parseCssGradient = parseCssGradient; exports.resolveCanvasGradient = resolveCanvasGradient; exports.angleToSvgLinearCoords = angleToSvgLinearCoords; exports.gradientToSvgDef = gradientToSvgDef; exports.SHAPE_KINDS = SHAPE_KINDS; exports.isShapeDescription = isShapeDescription; exports.parseSvgPath = parseSvgPath; exports.flattenSvgPath = flattenSvgPath; exports.getShapeSvg = getShapeSvg; exports.getShapeRenderData = getShapeRenderData; exports.shapeToPolygon = shapeToPolygon; exports.formatNumber = formatNumber2; exports.simplifyRing = simplifyRing; exports.polygonToSvgPath = polygonToSvgPath; exports.segmentPoint = segmentPoint; exports.segmentDerivative = segmentDerivative; exports.segmentTangent = segmentTangent; exports.segmentCurvature = segmentCurvature; exports.splitSegment = splitSegment; exports.subSegment = subSegment; exports.segmentExtrema = segmentExtrema; exports.segmentBounds = segmentBounds; exports.segmentLength = segmentLength; exports.segmentParamAtLength = segmentParamAtLength; exports.segmentNearest = segmentNearest; exports.arcToCubics = arcToCubics; exports.toBezierPath = toBezierPath; exports.pathToContours = pathToContours; exports.contoursToPath = contoursToPath; exports.bezierPathToSvg = bezierPathToSvg; exports.transformBezierPath = transformBezierPath; exports.countPathSegments = countPathSegments; exports.closeContour = closeContour; exports.bezierPathBounds = bezierPathBounds; exports.bezierPathSignedArea = bezierPathSignedArea; exports.contourSignedArea = contourSignedArea; exports.bezierPathLength = bezierPathLength; exports.bezierPathPointAtLength = bezierPathPointAtLength; exports.trimSegments = trimSegments; exports.windingNumber = windingNumber; exports.pointInBezierPath = pointInBezierPath; exports.distanceToBezierPath = distanceToBezierPath; exports.flattenChain = flattenChain; exports.PathOpsError = PathOpsError; exports.segmentIntersections = segmentIntersections; exports.pathBoolean = pathBoolean; exports.unitePaths = unitePaths; exports.intersectPaths = intersectPaths; exports.subtractPaths = subtractPaths; exports.excludePaths = excludePaths; exports.dividePaths = dividePaths; exports.normalizeBezierPath = normalizeBezierPath; exports.bezierPathArea = bezierPathArea; exports.planarSplit = planarSplit; exports.pathBooleanSelect = pathBooleanSelect; exports.dashContours = dashContours; exports.strokeOutlineRings = strokeOutlineRings; exports.outlineStroke = outlineStroke; exports.offsetPath = offsetPath; exports.interiorPoint = interiorPoint; exports.PlanarMap = PlanarMap; exports.contourEnclosesArea = contourEnclosesArea; exports.cutOutPiece = cutOutPiece; exports.hatchPath = hatchPath; exports.PATHFINDER_OPERATIONS = PATHFINDER_OPERATIONS; exports.pathfinder = pathfinder;
-//# sourceMappingURL=chunk-YNSK4MGT.cjs.map
+exports.cubicPointAt = cubicPointAt; exports.fitCubicWithTangents = fitCubicWithTangents; exports.fitCubicRun = fitCubicRun; exports.fitCubics = fitCubics; exports.isStraightCubic = isStraightCubic; exports.cubicsToPathData = cubicsToPathData; exports.fitPathData = fitPathData; exports.fitFreehandPath = fitFreehandPath; exports.PIXERATE_BRAND_GRADIENT = PIXERATE_BRAND_GRADIENT; exports.CANVAS_GRADIENT_PRESETS = CANVAS_GRADIENT_PRESETS; exports.isCanvasGradient = isCanvasGradient; exports.parseCssGradient = parseCssGradient; exports.resolveCanvasGradient = resolveCanvasGradient; exports.angleToSvgLinearCoords = angleToSvgLinearCoords; exports.gradientToSvgDef = gradientToSvgDef; exports.SHAPE_KINDS = SHAPE_KINDS; exports.isShapeDescription = isShapeDescription; exports.parseSvgPath = parseSvgPath; exports.flattenSvgPath = flattenSvgPath; exports.getShapeSvg = getShapeSvg; exports.getShapeRenderData = getShapeRenderData; exports.shapeToPolygon = shapeToPolygon; exports.formatNumber = formatNumber2; exports.simplifyRing = simplifyRing; exports.polygonToSvgPath = polygonToSvgPath; exports.dist = dist2; exports.segmentPoint = segmentPoint; exports.segmentDerivative = segmentDerivative; exports.segmentTangent = segmentTangent; exports.segmentCurvature = segmentCurvature; exports.splitSegment = splitSegment; exports.subSegment = subSegment; exports.segmentExtrema = segmentExtrema; exports.segmentBounds = segmentBounds; exports.segmentLength = segmentLength; exports.segmentParamAtLength = segmentParamAtLength; exports.segmentNearest = segmentNearest; exports.arcToCubics = arcToCubics; exports.toBezierPath = toBezierPath; exports.pathToContours = pathToContours; exports.contoursToPath = contoursToPath; exports.bezierPathToSvg = bezierPathToSvg; exports.transformBezierPath = transformBezierPath; exports.countPathSegments = countPathSegments; exports.closeContour = closeContour; exports.bezierPathBounds = bezierPathBounds; exports.bezierPathSignedArea = bezierPathSignedArea; exports.contourSignedArea = contourSignedArea; exports.bezierPathLength = bezierPathLength; exports.bezierPathPointAtLength = bezierPathPointAtLength; exports.trimSegments = trimSegments; exports.solveMonotone = solveMonotone; exports.windingNumber = windingNumber; exports.pointInBezierPath = pointInBezierPath; exports.distanceToBezierPath = distanceToBezierPath; exports.flattenChain = flattenChain; exports.ringSignedArea = ringSignedArea; exports.polygonArea = polygonArea; exports.multiPolygonArea = multiPolygonArea; exports.multiPolygonBounds = multiPolygonBounds; exports.pointInRings = pointInRings; exports.pointInMultiPolygon = pointInMultiPolygon; exports.polygonBoolean = polygonBoolean; exports.unionPolygons = unionPolygons; exports.intersectPolygons = intersectPolygons; exports.subtractPolygons = subtractPolygons; exports.xorPolygons = xorPolygons; exports.dividePolygons = dividePolygons; exports.PathOpsError = PathOpsError; exports.segmentIntersections = segmentIntersections; exports.pathBoolean = pathBoolean; exports.unitePaths = unitePaths; exports.intersectPaths = intersectPaths; exports.subtractPaths = subtractPaths; exports.excludePaths = excludePaths; exports.dividePaths = dividePaths; exports.normalizeBezierPath = normalizeBezierPath; exports.bezierPathArea = bezierPathArea; exports.planarSplit = planarSplit; exports.pathBooleanSelect = pathBooleanSelect; exports.dashContours = dashContours; exports.strokeOutlineRings = strokeOutlineRings; exports.outlineStroke = outlineStroke; exports.offsetPath = offsetPath;
+//# sourceMappingURL=chunk-O2UH7LZE.cjs.map