@pixerate/editor 0.54.0 → 0.55.0

package/dist/chunk-VWZB6BCY.js

@@ -0,0 +1,737 @@
+import {
+  bezierPathBounds,
+  closeContour,
+  contourSignedArea,
+  contoursToPath,
+  dist,
+  dividePaths,
+  flattenChain,
+  pathBooleanSelect,
+  pathToContours,
+  planarSplit,
+  segmentLength,
+  segmentNearest,
+  segmentPoint,
+  segmentTangent,
+  solveMonotone,
+  subSegment,
+  windingNumber
+} from "./chunk-GTMJ4Y3S.js";
+
+// 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, dist(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) => dist(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 (dist(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 ? dist(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 = dist(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 snapEnds(segs, to, tol) {
+  if (!segs.length) return segs;
+  const out = segs.map((s) => [...s]);
+  const move = (seg, end, handle) => {
+    const q = to.find((t) => dist(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 || dist(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: snapEnds(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(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, 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: 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 {
+  interiorPoint,
+  PlanarMap,
+  contourEnclosesArea,
+  cutOutPiece,
+  hatchPath,
+  PATHFINDER_OPERATIONS,
+  pathfinder
+};
+//# sourceMappingURL=chunk-VWZB6BCY.js.map