@pixerate/editor 0.37.0 → 0.38.0

package/dist/{chunk-HPEKB352.js → chunk-ZCCU3VNI.js}

@@ -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 = 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;
+    options.onFallback?.(reason);
+    const tolerance = 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;
@@ -3731,6 +3795,567 @@ 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(path[0][0]?.[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 > (best?.width ?? 0))) continue;
+      const m = [(xs[i] + xs[i + 1]) / 2, y];
+      if (windingNumber(chains, m) !== 0) best = { width, p: m };
+    }
+  }
+  return best?.p ?? null;
+}
+var PlanarMap = class _PlanarMap {
+  constructor(vertices, edges, sources, eps, inputCount, inputs) {
+    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: 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));
+  }
+  vertices;
+  edges;
+  sources;
+  eps;
+  inputCount;
+  around;
+  slot;
+  component;
+  cyclesCache = null;
+  sourcesCache = [];
+  fills;
+  /**
+   * 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 > (options.maxSegments ?? 4096)) return null;
+    let split;
+    try {
+      split = planarSplit(chains, options);
+    } catch {
+      return null;
+    }
+    const edges = split.edges.filter((e) => e.a !== e.b).map((e) => ({ ...e, source: e.operands[e.operands.length - 1] ?? -1 }));
+    if (!edges.length) return null;
+    const gap = 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;
+  }
+};
+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);
+  }
+}
+
+// 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: 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) => 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 })));
+}
+
 export {
   ringSignedArea,
   polygonArea,
@@ -3807,9 +4432,15 @@ export {
   dividePaths,
   normalizeBezierPath,
   bezierPathArea,
+  planarSplit,
+  pathBooleanSelect,
   dashContours,
   strokeOutlineRings,
   outlineStroke,
-  offsetPath
+  offsetPath,
+  interiorPoint,
+  PlanarMap,
+  PATHFINDER_OPERATIONS,
+  pathfinder
 };
-//# sourceMappingURL=chunk-HPEKB352.js.map
+//# sourceMappingURL=chunk-ZCCU3VNI.js.map