@weasel-js/geom 1.10.1 → 1.11.1

package/dist/chunk-4Y67BZL5.js

@@ -0,0 +1,573 @@
+import { nearestOnLine, nearestOnCubic } from './chunk-CE7IY7TB.js';
+import { cornerCuts, decodeContours, fillsOpenSubpaths, resolveCorners, segmentsCross, pointInPolygon } from './chunk-EAKE3N7W.js';
+import { EPS } from './chunk-755Y4YZS.js';
+import { withoutCorners, compactCorners, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z, forEachSegment, pathCommandCoordCount, PathBuilder, splitQuadraticAt, splitCubicAt } from './chunk-B53BERKG.js';
+
+// src/paths/cornerCarry.ts
+var flatCache = /* @__PURE__ */ new WeakMap();
+function flatAnchorIndices(path) {
+  const hit = flatCache.get(path);
+  if (hit) return hit;
+  const { commands, coords } = path;
+  const out = [];
+  let flat = 0, first = 0, count = 0;
+  let sx = 0, sy = 0, ex = 0, ey = 0, curve = false;
+  forEachSegment(commands, coords, (cmd, ci) => {
+    if (cmd === PATH_Z) {
+      if (count > 1 && curve && ex === sx && ey === sy) {
+        out[out.length - 1] = first;
+        flat--;
+      }
+      count = 0;
+      return;
+    }
+    const n = pathCommandCoordCount(cmd);
+    ex = coords[ci + n - 2];
+    ey = coords[ci + n - 1];
+    curve = cmd === PATH_C || cmd === PATH_Q;
+    if (cmd === PATH_M || count === 0) {
+      first = flat;
+      sx = ex;
+      sy = ey;
+      count = 0;
+    }
+    count++;
+    out.push(flat++);
+  });
+  const result = Int32Array.from(out);
+  flatCache.set(path, result);
+  return result;
+}
+function carryCorners(from, to, sources) {
+  const bare = withoutCorners(to);
+  const specs = from.corners;
+  if (!specs) return bare;
+  const fromFlat = flatAnchorIndices(from);
+  const toFlat = flatAnchorIndices(to);
+  const placed = /* @__PURE__ */ new Set();
+  const next = [];
+  for (let k = 0; k < toFlat.length; k++) {
+    const s = sources[k];
+    if (s === void 0 || s < 0 || s >= fromFlat.length) continue;
+    const f = fromFlat[s];
+    const spec = specs[f];
+    if (!spec || placed.has(f)) continue;
+    placed.add(f);
+    while (next.length < toFlat[k]) next.push(null);
+    next[toFlat[k]] = spec;
+  }
+  const corners = compactCorners(next);
+  return corners ? { ...bare, corners } : bare;
+}
+function anchorRange(start, count) {
+  const out = new Int32Array(count);
+  for (let i = 0; i < count; i++) out[i] = start + i;
+  return out;
+}
+
+// src/paths/cornerRestore.ts
+var CORNER_RESTORE_TOLERANCE = 1e-3;
+function cornerTraces(path) {
+  if (path.kind !== "polygon") return [];
+  return cornerCuts(path).map(({ anchor, spec, start, end, pieces }) => ({ anchor, spec, start, end, pieces }));
+}
+function keepCorners(sources, result, tolerance = CORNER_RESTORE_TOLERANCE) {
+  const traces = sources.flatMap(cornerTraces);
+  return traces.length === 0 ? result : restoreCorners(result, traces, tolerance);
+}
+var dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+function onTrace(p, t, tol) {
+  let from = t.start;
+  for (const piece of t.pieces) {
+    const d = piece.kind === "line" ? nearestOnLine(p.x, p.y, from.x, from.y, piece.to.x, piece.to.y).dist : nearestOnCubic(p.x, p.y, from.x, from.y, piece.c1.x, piece.c1.y, piece.c2.x, piece.c2.y, piece.to.x, piece.to.y).dist;
+    if (d <= tol) return true;
+    from = piece.to;
+  }
+  return false;
+}
+function blossom(s, u, v, w) {
+  const lerp = (a2, b2, t) => ({ x: a2.x + (b2.x - a2.x) * t, y: a2.y + (b2.y - a2.y) * t });
+  const a = lerp(s.p0, s.c1, u), b = lerp(s.c1, s.c2, u), c = lerp(s.c2, s.p3, u);
+  const d = lerp(a, b, v), e = lerp(b, c, v);
+  return lerp(d, e, w);
+}
+function extendTo(s, target, from, tol) {
+  const at = (u2) => blossom(s, u2, u2, u2);
+  const d1 = (u2) => {
+    const a = blossom(s, u2, u2, 0), b = blossom(s, u2, u2, 1);
+    return { x: 3 * (b.x - a.x), y: 3 * (b.y - a.y) };
+  };
+  const speed = Math.hypot(d1(from).x, d1(from).y);
+  if (speed === 0) return null;
+  let u = from + (from === 1 ? 1 : -1) * dist(at(from), target) / speed;
+  for (let i = 0; i < 30; i++) {
+    const p = at(u), d = d1(u);
+    const dd = d.x * d.x + d.y * d.y;
+    if (dd === 0) break;
+    u -= ((p.x - target.x) * d.x + (p.y - target.y) * d.y) / dd;
+  }
+  return dist(at(u), target) <= tol ? u : null;
+}
+function reachSeg(s, start, end, tol) {
+  const p0 = start ?? s.p0, p3 = end ?? s.p3;
+  if (s.line) return { line: true, p0, c1: p0, c2: p3, p3 };
+  const u0 = start ? extendTo(s, start, 0, tol) : 0;
+  const u1 = end ? extendTo(s, end, 1, tol) : 1;
+  if (u0 === null || u1 === null) return null;
+  return { line: false, p0, c1: blossom(s, u0, u0, u1), c2: blossom(s, u0, u1, u1), p3 };
+}
+function endsCut(a, edge, p, t, tol) {
+  if (dist(a, p) <= tol) return true;
+  return edge.line && onTrace(a, t, tol) && nearestOnLine(p.x, p.y, edge.p0.x, edge.p0.y, edge.p3.x, edge.p3.y).dist <= tol;
+}
+function findRun(c, t, tol) {
+  const n = c.anchors.length;
+  for (let i = c.closed ? 0 : 1; i < n; i++) {
+    for (const [first, last] of [[t.start, t.end], [t.end, t.start]]) {
+      if (!endsCut(c.anchors[i], c.segs[(i - 1 + n) % n], first, t, tol)) continue;
+      for (let j = i + 1, steps = 1; steps < c.segs.length; j++, steps++) {
+        if (!c.closed && j >= n - 1) break;
+        const a = c.anchors[j % n];
+        const seg = c.segs[(j - 1) % n];
+        if (!seg.line && !onTrace(blossom(seg, 0.5, 0.5, 0.5), t, tol)) break;
+        if (endsCut(a, c.segs[j % n], last, t, tol)) return { from: i, to: j % n, trace: t };
+        if (!onTrace(a, t, tol)) break;
+      }
+    }
+  }
+  return null;
+}
+function covered(run, n) {
+  const out = [];
+  for (let k = run.from; ; k = (k + 1) % n) {
+    out.push(k);
+    if (k === run.to) return out;
+  }
+}
+function foldContour(c, runs, specs, tol) {
+  const n = c.anchors.length;
+  const runAt = /* @__PURE__ */ new Map();
+  const inside = /* @__PURE__ */ new Set();
+  for (const run of runs) {
+    runAt.set(run.from, run);
+    for (const k of covered(run, n)) inside.add(k);
+  }
+  let begin = 0;
+  if (c.closed) {
+    const free = c.anchors.findIndex((_a, k) => !inside.has(k));
+    begin = free >= 0 ? free : runs[0].from;
+  }
+  const nodes = [];
+  const exits = [];
+  for (let step = 0, k = begin; step < n; ) {
+    const run = runAt.get(k);
+    if (run) {
+      nodes.push({ at: run.trace.anchor, spec: run.trace.spec });
+      exits.push(run.to);
+      const span = covered(run, n).length;
+      step += span;
+      k = (run.to + 1) % n;
+    } else {
+      nodes.push({ at: c.anchors[k], spec: specs[k] ?? null });
+      exits.push(k);
+      step++;
+      k = (k + 1) % n;
+    }
+  }
+  const runEnds = new Set(runs.map((r) => r.to));
+  const segs = [];
+  const count = c.closed ? nodes.length : nodes.length - 1;
+  for (let m = 0; m < count; m++) {
+    const exit = exits[m];
+    const moveStart = runEnds.has(exit) ? nodes[m].at : void 0;
+    const moveEnd = runAt.has((exit + 1) % n) ? nodes[(m + 1) % nodes.length].at : void 0;
+    const reached = reachSeg(c.segs[exit], moveStart, moveEnd, tol);
+    if (!reached) return null;
+    segs.push(reached);
+  }
+  return { nodes, segs, closed: c.closed, folded: [...runs] };
+}
+function write(contours, result) {
+  const b = new PathBuilder();
+  const specs = [];
+  for (const { nodes, segs, closed } of contours) {
+    b.moveTo(nodes[0].at.x, nodes[0].at.y);
+    specs.push(nodes[0].spec);
+    segs.forEach((s, m) => {
+      const to = nodes[(m + 1) % nodes.length];
+      const closing = closed && m === segs.length - 1;
+      if (closing && s.line) return;
+      if (s.line) b.lineTo(to.at.x, to.at.y);
+      else b.curveTo(s.c1.x, s.c1.y, s.c2.x, s.c2.y, to.at.x, to.at.y);
+      specs.push(to.spec);
+    });
+    if (closed) b.close();
+  }
+  const { commands, coords } = b.build();
+  const built = { ...withoutCorners(result), commands, coords };
+  const flat = flatAnchorIndices(built);
+  const corners = [];
+  specs.forEach((spec, k) => {
+    if (!spec) return;
+    while (corners.length < flat[k]) corners.push(null);
+    corners[flat[k]] = spec;
+  });
+  const compact = compactCorners(corners);
+  return compact ? { ...built, corners: compact } : built;
+}
+function failedTraces(path, tol, folded) {
+  const bad = new Set(folded.map((r) => r.trace));
+  for (const cut of cornerCuts(path)) {
+    for (const t of bad) {
+      if (dist(cut.anchor, t.anchor) > tol) continue;
+      const same = dist(cut.start, t.start) <= tol && dist(cut.end, t.end) <= tol || dist(cut.start, t.end) <= tol && dist(cut.end, t.start) <= tol;
+      if (same) bad.delete(t);
+    }
+  }
+  return bad;
+}
+function restoreCorners(result, traces, tolerance = CORNER_RESTORE_TOLERANCE) {
+  const contours = decodeContours(result);
+  if (!contours || traces.length === 0) return result;
+  const rejected = /* @__PURE__ */ new Set();
+  for (let attempt = 0; attempt <= traces.length; attempt++) {
+    const rebuilt = [];
+    for (const c of contours) {
+      const runs = [];
+      const used = /* @__PURE__ */ new Set();
+      for (const t of traces) {
+        if (rejected.has(t)) continue;
+        const run = findRun(c, t, tolerance);
+        if (!run) continue;
+        const span = covered(run, c.anchors.length);
+        if (span.some((k) => used.has(k))) continue;
+        span.forEach((k) => used.add(k));
+        runs.push(run);
+      }
+      const specs = c.anchors.map((_a, k) => result.corners?.[c.first + k] ?? null);
+      const folded2 = runs.length > 0 ? foldContour(c, runs, specs, tolerance) : null;
+      if (runs.length > 0 && !folded2) {
+        runs.forEach((r) => rejected.add(r.trace));
+        rebuilt.length = 0;
+        break;
+      }
+      rebuilt.push(folded2 ?? { nodes: c.anchors.map((at, k) => ({ at, spec: specs[k] })), segs: c.segs, closed: c.closed, folded: [] });
+    }
+    if (rebuilt.length !== contours.length) continue;
+    const folded = rebuilt.flatMap((r) => r.folded);
+    if (folded.length === 0) return result;
+    const out = write(rebuilt, result);
+    const bad = failedTraces(out, tolerance, folded);
+    if (bad.size === 0) return out;
+    bad.forEach((t) => rejected.add(t));
+  }
+  return result;
+}
+
+// src/booleans/contourSegments.ts
+function evalSeg(s, t) {
+  const u = 1 - t;
+  if (s.length === 2) return { x: u * s[0].x + t * s[1].x, y: u * s[0].y + t * s[1].y };
+  if (s.length === 3) {
+    const a2 = u * u, b2 = 2 * u * t, c2 = t * t;
+    return { x: a2 * s[0].x + b2 * s[1].x + c2 * s[2].x, y: a2 * s[0].y + b2 * s[1].y + c2 * s[2].y };
+  }
+  const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
+  return {
+    x: a * s[0].x + b * s[1].x + c * s[2].x + d * s[3].x,
+    y: a * s[0].y + b * s[1].y + c * s[2].y + d * s[3].y
+  };
+}
+function derivSeg(s, t) {
+  const n = s.length - 1;
+  const d = [];
+  for (let i = 0; i < n; i++) d.push({ x: n * (s[i + 1].x - s[i].x), y: n * (s[i + 1].y - s[i].y) });
+  return d.length === 1 ? d[0] : evalSeg(d, t);
+}
+function splitSeg(s, t) {
+  const pts = (c) => {
+    const out = [];
+    for (let i = 0; i < c.length; i += 2) out.push({ x: c[i], y: c[i + 1] });
+    return out;
+  };
+  if (s.length === 2) {
+    const m = evalSeg(s, t);
+    return [[s[0], m], [m, s[1]]];
+  }
+  if (s.length === 3) {
+    const [l2, r2] = splitQuadraticAt(s[0].x, s[0].y, s[1].x, s[1].y, s[2].x, s[2].y, t);
+    return [pts(l2), pts(r2)];
+  }
+  const [l, r] = splitCubicAt(s[0].x, s[0].y, s[1].x, s[1].y, s[2].x, s[2].y, s[3].x, s[3].y, t);
+  return [pts(l), pts(r)];
+}
+function subSeg(s, t0, t1, p0, p1) {
+  if (t1 - t0 <= 0) return null;
+  let out = s;
+  if (t0 > 0) out = splitSeg(out, t0)[1];
+  const u = (t1 - t0) / (1 - t0);
+  if (u < 1) out = splitSeg(out, u)[0];
+  out = out.slice();
+  out[0] = p0;
+  out[out.length - 1] = p1;
+  return out;
+}
+var reverseContour = (c) => c.map((s) => s.slice().reverse()).reverse();
+function sampleContour(c) {
+  const out = [];
+  for (const s of c) {
+    const n = s.length === 2 ? 1 : 16;
+    for (let i = 0; i < n; i++) {
+      const p = evalSeg(s, i / n);
+      out.push(p.x, p.y);
+    }
+  }
+  return out;
+}
+function signedArea(c) {
+  const pts = sampleContour(c);
+  let a = 0;
+  for (let i = 0; i < pts.length; i += 2) {
+    const j = (i + 2) % pts.length;
+    a += pts[i] * pts[j + 1] - pts[j] * pts[i + 1];
+  }
+  return a / 2;
+}
+function sideCoeffs(s, o, d) {
+  return s.map((p) => d.x * (p.y - o.y) - d.y * (p.x - o.x));
+}
+function bernstein(f, t) {
+  const u = 1 - t;
+  if (f.length === 2) return u * f[0] + t * f[1];
+  if (f.length === 3) return u * u * f[0] + 2 * u * t * f[1] + t * t * f[2];
+  return u * u * u * f[0] + 3 * u * u * t * f[1] + 3 * u * t * t * f[2] + t * t * t * f[3];
+}
+function signChanges(f, zeroIsPositive) {
+  const sgn = (v) => v > 0 ? 1 : v < 0 ? -1 : zeroIsPositive ? 1 : 0;
+  const cuts = [0, ...criticalPoints(f), 1];
+  const out = [];
+  for (let i = 0; i + 1 < cuts.length; i++) {
+    let lo = cuts[i], hi = cuts[i + 1];
+    const slo = sgn(bernstein(f, lo)), shi = sgn(bernstein(f, hi));
+    if (slo === 0 && i > 0) {
+      const before = sgn(bernstein(f, lo - 1e-7)), after = sgn(bernstein(f, lo + 1e-7));
+      if (before * after < 0) out.push({ t: lo, before, after });
+    }
+    if (slo * shi >= 0) continue;
+    for (let it = 0; it < 64; it++) {
+      const mid = (lo + hi) / 2;
+      if (sgn(bernstein(f, mid)) === slo) lo = mid;
+      else hi = mid;
+    }
+    out.push({ t: (lo + hi) / 2, before: slo, after: shi });
+  }
+  return out;
+}
+function criticalPoints(f) {
+  if (f.length < 3) return [];
+  const n = f.length - 1;
+  const d = f.slice(1).map((v, i) => n * (v - f[i]));
+  let A = 0, B, C;
+  if (d.length === 2) {
+    B = d[1] - d[0];
+    C = d[0];
+  } else {
+    A = d[0] - 2 * d[1] + d[2];
+    B = 2 * (d[1] - d[0]);
+    C = d[0];
+  }
+  const out = [];
+  const scale = Math.max(Math.abs(A), Math.abs(B), Math.abs(C)) || 1;
+  if (Math.abs(A) / scale < 1e-12) {
+    if (Math.abs(B) / scale > 1e-12) out.push(-C / B);
+  } else {
+    const disc = B * B - 4 * A * C;
+    if (disc >= 0) {
+      const q = -0.5 * (B + Math.sign(B || 1) * Math.sqrt(disc));
+      out.push(q / A);
+      if (q !== 0) out.push(C / q);
+    }
+  }
+  return out.filter((t) => t > 0 && t < 1).sort((x, y) => x - y);
+}
+function endSide(f, fromStart) {
+  const n = f.length;
+  for (let i = 1; i < n; i++) {
+    const v = fromStart ? f[i] : f[n - 1 - i];
+    if (v !== 0) return Math.sign(v);
+  }
+  return 0;
+}
+
+// src/booleans/contours.ts
+function parseContours(path) {
+  const fillsOpen = path.kind === "rect" || fillsOpenSubpaths(path);
+  return parseSubpaths(path).filter((s) => s.closed || fillsOpen).map((s) => s.segs);
+}
+function parseSubpaths(given, implicitClose = true) {
+  const path = resolveCorners(given);
+  if (path.kind === "rect") {
+    const { x, y, width: w, height: h } = path;
+    const p = [{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }];
+    return [{ segs: p.map((q, i) => [q, p[(i + 1) % 4]]), closed: true }];
+  }
+  const out = [];
+  let cur = [];
+  let start = { x: 0, y: 0 };
+  let pen = start;
+  const finish = (closed) => {
+    if (cur.length > 0 && (closed || implicitClose) && (pen.x !== start.x || pen.y !== start.y)) {
+      cur.push([pen, start]);
+    }
+    if (cur.length > 0) out.push({ segs: cur, closed });
+    cur = [];
+    pen = start;
+  };
+  const c = path.coords;
+  let k = 0;
+  for (const cmd of path.commands) {
+    if (cmd === PATH_M) {
+      finish(false);
+      start = pen = { x: c[k], y: c[k + 1] };
+      k += 2;
+    } else if (cmd === PATH_L) {
+      const e = { x: c[k], y: c[k + 1] };
+      if (e.x !== pen.x || e.y !== pen.y) cur.push([pen, e]);
+      pen = e;
+      k += 2;
+    } else if (cmd === PATH_Q) {
+      const e = { x: c[k + 2], y: c[k + 3] };
+      cur.push([pen, { x: c[k], y: c[k + 1] }, e]);
+      pen = e;
+      k += 4;
+    } else if (cmd === PATH_C) {
+      const e = { x: c[k + 4], y: c[k + 5] };
+      cur.push([pen, { x: c[k], y: c[k + 1] }, { x: c[k + 2], y: c[k + 3] }, e]);
+      pen = e;
+      k += 6;
+    } else if (cmd === PATH_Z) {
+      finish(true);
+    }
+  }
+  finish(false);
+  return out;
+}
+function contoursIntersect(contours, tol) {
+  const edges = [];
+  contours.forEach((contour, ci) => {
+    const pts = [];
+    for (const s of contour) {
+      let n = 1;
+      if (s.length > 2) {
+        let len = 0;
+        for (let i = 0; i + 1 < s.length; i++) len += Math.hypot(s[i + 1].x - s[i].x, s[i + 1].y - s[i].y);
+        n = Math.min(64, Math.max(2, Math.ceil(Math.sqrt(len / Math.max(tol, 1e-3)))));
+      }
+      for (let i = 0; i < n; i++) pts.push(evalSeg(s, i / n));
+    }
+    for (let i = 0; i < pts.length; i++) {
+      const p = pts[i], q = pts[(i + 1) % pts.length];
+      edges.push({ x0: p.x, y0: p.y, x1: q.x, y1: q.y, c: ci, i, n: pts.length });
+    }
+  });
+  for (let i = 0; i < edges.length; i++) {
+    const e = edges[i];
+    for (let j = i + 1; j < edges.length; j++) {
+      const f = edges[j];
+      if (e.c === f.c && (j - i === 1 || i === 0 && f.i === f.n - 1)) continue;
+      if (Math.max(e.x0, e.x1) < Math.min(f.x0, f.x1) || Math.max(f.x0, f.x1) < Math.min(e.x0, e.x1)) continue;
+      if (Math.max(e.y0, e.y1) < Math.min(f.y0, f.y1) || Math.max(f.y0, f.y1) < Math.min(e.y0, e.y1)) continue;
+      if (segmentsCross(e.x0, e.y0, e.x1, e.y1, f.x0, f.y0, f.x1, f.y1)) return true;
+    }
+  }
+  return false;
+}
+function windingAt(q, contours) {
+  const dir = { x: 1, y: 0 };
+  let w = 0;
+  for (const contour of contours) {
+    for (const s of contour) {
+      for (const c of signChanges(sideCoeffs(s, q, dir), true)) {
+        if (evalSeg(s, c.t).x > q.x) w += c.after > 0 ? 1 : -1;
+      }
+    }
+  }
+  return w;
+}
+function extentOf(contours) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const c of contours) for (const s of c) for (const p of s) {
+    minX = Math.min(minX, p.x);
+    maxX = Math.max(maxX, p.x);
+    minY = Math.min(minY, p.y);
+    maxY = Math.max(maxY, p.y);
+  }
+  return Math.hypot(maxX - minX, maxY - minY);
+}
+function negligibleArea(contours) {
+  const extent = extentOf(contours);
+  return extent * extent * EPS * EPS;
+}
+function orientBoundaries(contours, fillRule) {
+  const filled = (q) => {
+    const w = windingAt(q, contours);
+    return fillRule === "evenodd" ? (w & 1) !== 0 : w !== 0;
+  };
+  const eps = Math.max(extentOf(contours) * 1e-6, 1e-9);
+  const out = [];
+  for (const contour of contours) {
+    let probe = contour[0];
+    let best = -1;
+    for (const s of contour) {
+      const len = Math.hypot(s[s.length - 1].x - s[0].x, s[s.length - 1].y - s[0].y);
+      if (len > best) {
+        best = len;
+        probe = s;
+      }
+    }
+    const p = evalSeg(probe, 0.5);
+    let tan = derivSeg(probe, 0.5);
+    const tl = Math.hypot(tan.x, tan.y);
+    if (tl === 0) continue;
+    tan = { x: tan.x / tl, y: tan.y / tl };
+    const left = filled({ x: p.x - tan.y * eps, y: p.y + tan.x * eps });
+    const right = filled({ x: p.x + tan.y * eps, y: p.y - tan.x * eps });
+    if (left && !right) out.push(contour);
+    else if (right && !left) out.push(reverseContour(contour));
+  }
+  return out;
+}
+
+// src/booleans/cutRegions.ts
+function assembleRegions(outers, holes) {
+  const regions = outers.map((o) => ({ loops: [o], ring: sampleContour(o), area: signedArea(o) }));
+  for (const h of holes) {
+    const hp = evalSeg(h[0], 0.5);
+    let best = null;
+    for (const r of regions) {
+      if (pointInPolygon(r.ring, hp.x, hp.y) && (!best || r.area < best.area)) best = r;
+    }
+    best?.loops.push(h);
+  }
+  return regions.map((r) => r.loops);
+}
+var regionArea = (r) => r.reduce((s, c) => s + signedArea(c), 0);
+var toPath = (loops, fillRule) => writePath(loops.map((segs) => ({ segs, closed: true })), fillRule);
+function writePath(subpaths, fillRule) {
+  const cmds = [];
+  const xs = [];
+  for (const { segs, closed } of subpaths) {
+    cmds.push(PATH_M);
+    xs.push(segs[0][0].x, segs[0][0].y);
+    for (const s of segs) {
+      cmds.push(s.length === 2 ? PATH_L : s.length === 3 ? PATH_Q : PATH_C);
+      for (let i = 1; i < s.length; i++) xs.push(s[i].x, s[i].y);
+    }
+    if (closed) cmds.push(PATH_Z);
+  }
+  return { kind: "polygon", commands: new Uint8Array(cmds), coords: new Float32Array(xs), fillRule };
+}
+
+export { CORNER_RESTORE_TOLERANCE, anchorRange, assembleRegions, carryCorners, contoursIntersect, cornerTraces, derivSeg, endSide, evalSeg, extentOf, keepCorners, negligibleArea, orientBoundaries, parseContours, parseSubpaths, regionArea, restoreCorners, reverseContour, sampleContour, sideCoeffs, signChanges, signedArea, subSeg, toPath, windingAt, writePath };
+//# sourceMappingURL=chunk-4Y67BZL5.js.map
+//# sourceMappingURL=chunk-4Y67BZL5.js.map