@pixerate/editor 0.37.0 → 0.39.0

package/dist/{chunk-GVB7ZPLZ.cjs → chunk-VNYRI265.cjs}

@@ -1,4 +1,4 @@
-"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/polygonBoolean.ts
+"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;
@@ -675,14 +675,14 @@ function turnDeg(a, b, c) {
   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) {
+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]) >= span) return j;
+      if (dist(at(j), pts[i]) >= span2) return j;
     }
     return null;
   };
@@ -704,7 +704,7 @@ function findCorners(pts, closed, cornerAngle, span) {
     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 (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);
@@ -742,9 +742,9 @@ function fitCubics(points, tolerance, options = {}) {
   const tol = Math.max(tolerance, 1e-6);
   const cornerAngle = _nullishCoalesce(options.cornerAngleDeg, () => ( 30));
   const n = pts.length;
-  const span = 4 * tol;
+  const span2 = 4 * tol;
   if (!closed || n < 3) {
-    const corners2 = [0, ...n > 2 ? findCorners(pts, false, cornerAngle, span) : [], n - 1];
+    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);
@@ -753,7 +753,7 @@ function fitCubics(points, tolerance, options = {}) {
     if (closed && n === 2) out2.push(...fitCubicRun([pts[1], pts[0]], tol));
     return out2;
   }
-  const corners = findCorners(pts, true, cornerAngle, span);
+  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]));
@@ -2436,10 +2436,10 @@ function normalizeOperand(input) {
   }
   return { chains, fillRule };
 }
-function scaleOf(operands) {
+function scaleOf(operandChains) {
   let max = 0;
-  for (const op of operands) {
-    for (const chain of op.chains) {
+  for (const chains of operandChains) {
+    for (const chain of chains) {
       for (const seg of chain) {
         for (const [x, y] of seg) max = Math.max(max, Math.abs(x), Math.abs(y));
       }
@@ -2845,15 +2845,14 @@ function splitPass2(pieces, pool, ctx) {
   }
   return { pieces: out, changed: true };
 }
-function buildArrangement(inputs, options) {
-  const operands = inputs.map(normalizeOperand);
-  const scale2 = scaleOf(operands);
+function splitChains(operandChains, options) {
+  const scale2 = scaleOf(operandChains);
   const eps = options.epsilon && options.epsilon > 0 ? options.epsilon : 1e-9 * scale2;
   const pool = new VertexPool(eps);
   const sources = [];
   let pieces = [];
-  operands.forEach((op, operand) => {
-    for (const chain of op.chains) {
+  operandChains.forEach((chains, operand) => {
+    for (const chain of chains) {
       for (const raw of chain) {
         const straight = raw.length > 2 && isStraightSegment(raw, eps * 0.01);
         const seg = straight ? [raw[0], raw[raw.length - 1]] : raw;
@@ -2881,6 +2880,18 @@ function buildArrangement(inputs, options) {
     }
   }
   if (!settled) throw new PathOpsError("intersections did not settle");
+  return { pieces, pool, sources, eps, scale: scale2 };
+}
+function samePiece(e, pts, eps) {
+  if (e.length === 2 && pts.length === 2) return true;
+  return segmentNearest(e, segmentPoint(pts, 0.5)).distance <= eps * 4 && segmentNearest(pts, segmentPoint(e, 0.5)).distance <= eps * 4;
+}
+function buildArrangement(inputs, options) {
+  const operands = inputs.map(normalizeOperand);
+  const { pieces, sources, eps, scale: scale2 } = splitChains(
+    operands.map((o) => o.chains),
+    options
+  );
   const count = operands.length;
   const groups = /* @__PURE__ */ new Map();
   const edges = [];
@@ -2892,11 +2903,7 @@ function buildArrangement(inputs, options) {
     const key = `${a.id},${b.id}`;
     const group = _nullishCoalesce(groups.get(key), () => ( []));
     if (!groups.has(key)) groups.set(key, group);
-    const mid = segmentPoint(pts, 0.5);
-    let edge = group.find((e) => {
-      if (e.pts.length === 2 && pts.length === 2) return true;
-      return segmentNearest(e.pts, mid).distance <= eps * 4 && segmentNearest(pts, segmentPoint(e.pts, 0.5)).distance <= eps * 4;
-    });
+    let edge = group.find((e) => samePiece(e.pts, pts, eps));
     if (!edge) {
       edge = {
         a,
@@ -3289,6 +3296,63 @@ function nestedRingsToPath(rings, keep = () => true) {
   });
   return contoursToPath(contours);
 }
+function planarSplit(inputs, options = {}) {
+  for (const chains of inputs) {
+    for (const chain of chains) {
+      for (const seg of chain) for (const p of seg) if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) throw new PathOpsError(NON_FINITE);
+    }
+  }
+  const { pieces, pool, sources, eps, scale: scale2 } = splitChains(inputs, options);
+  const groups = /* @__PURE__ */ new Map();
+  const edges = [];
+  for (const piece of pieces) {
+    const forward = piece.a.id < piece.b.id;
+    const a = forward ? piece.a : piece.b;
+    const b = forward ? piece.b : piece.a;
+    const pts = forward ? piece.pts : [...piece.pts].reverse();
+    const key = `${a.id},${b.id}`;
+    let group = groups.get(key);
+    if (!group) groups.set(key, group = []);
+    const edge = group.find((e) => samePiece(e.pts, pts, eps));
+    if (edge) {
+      if (!edge.operands.includes(piece.operand)) edge.operands = [...edge.operands, piece.operand].sort((x, y) => x - y);
+      continue;
+    }
+    const created = { a: a.id, b: b.id, pts, operands: [piece.operand], src: piece.src, sa: forward ? piece.s0 : piece.s1, sb: forward ? piece.s1 : piece.s0 };
+    group.push(created);
+    edges.push(created);
+  }
+  return { vertices: pool.vertices.map((v) => v.p), edges, sources: sources.map((s) => s.seg), eps, scale: scale2 };
+}
+function pathBooleanSelect(operands, selectors, options = {}) {
+  if (operands.length === 0) return { parts: selectors.map(() => []), engine: "curve" };
+  const covering = (flags) => flags.flatMap((f, k) => f ? [k] : []);
+  try {
+    const arr = buildArrangement(operands, options);
+    const parts = selectors.map((select) => {
+      const rings = extractRings(arr, (flags) => select(covering(flags)));
+      return groupRings(rings).sort((a, b) => b[0].area - a[0].area).map(ringsToPath2);
+    });
+    return { parts, engine: "curve" };
+  } catch (error) {
+    const reason = reasonOf(error);
+    if (reason === NON_FINITE) return { parts: selectors.map(() => []), engine: "curve", error: reason };
+    if (options.fallback === false) throw error;
+    _optionalChain([options, 'access', _31 => _31.onFallback, 'optionalCall', _32 => _32(reason)]);
+    const tolerance = _nullishCoalesce(options.fallbackTolerance, () => ( 0.05));
+    const pieces = dividePolygons(
+      operands.map((o) => flattenOperand(o, tolerance)),
+      { epsilon: options.epsilon }
+    );
+    const parts = selectors.map((select) => {
+      const picked = pieces.filter((p) => select(p.operands));
+      if (!picked.length) return [];
+      const multi = polygonBoolean("union", [picked.map((p) => p.polygon)], { epsilon: options.epsilon });
+      return multi.map((polygon) => multiToPath([polygon], tolerance));
+    });
+    return { parts, engine: "polygon", fallbackReason: reason };
+  }
+}
 
 // src/canvas/pathops/stroke.ts
 var DEFAULT_TOLERANCE = 0.01;
@@ -3454,7 +3518,7 @@ function strokeContour(contour, h, style, tol) {
   const all = contour.closed ? closeContour(contour) : contour.segments;
   const segs = all.filter((s) => !isDegenerate(s, tiny));
   if (segs.length === 0) {
-    const p = _optionalChain([contour, 'access', _31 => _31.segments, 'access', _32 => _32[0], 'optionalAccess', _33 => _33[0]]);
+    const p = _optionalChain([contour, 'access', _33 => _33.segments, 'access', _34 => _34[0], 'optionalAccess', _35 => _35[0]]);
     return p ? dotRings(p, [1, 0], h, style.cap) : [];
   }
   if (contour.closed) {
@@ -3587,11 +3651,11 @@ function deepPoint(rings) {
     }
     xs.sort((p, q) => p - q);
     for (let i = 0; i + 1 < xs.length; i += 2) {
-      const span = xs[i + 1] - xs[i];
-      if (!best || span > best.span) best = { span, p: [(xs[i] + xs[i + 1]) / 2, y] };
+      const span2 = xs[i + 1] - xs[i];
+      if (!best || span2 > best.span) best = { span: span2, p: [(xs[i] + xs[i + 1]) / 2, y] };
     }
   }
-  return _nullishCoalesce(_optionalChain([best, 'optionalAccess', _34 => _34.p]), () => ( null));
+  return _nullishCoalesce(_optionalChain([best, 'optionalAccess', _36 => _36.p]), () => ( null));
 }
 function dropSpurious(rings, spurious) {
   const children = rings.map(() => []);
@@ -3731,6 +3795,722 @@ 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 })));
+}
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -3811,5 +4591,5 @@ function offsetPath(input, distance, options = {}) {
 
 
 
-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.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.dashContours = dashContours; exports.strokeOutlineRings = strokeOutlineRings; exports.outlineStroke = outlineStroke; exports.offsetPath = offsetPath;
-//# sourceMappingURL=chunk-GVB7ZPLZ.cjs.map
+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.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-VNYRI265.cjs.map