@weasel-js/geom 1.10.0 → 1.11.0

package/dist/chunk-6XSJY3TC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tessellate/polyline.ts"],"names":[],"mappings":"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","file":"chunk-6XSJY3TC.js","sourcesContent":["import { forEachSegment, PATH_M, PATH_L, PATH_Z, PATH_C, PATH_Q } from '../commands';\nimport { resolveCorners } from '../paths/corners';\nimport { rectToContour } from '../box';\nimport { DEFAULT_FLATTEN_TOLERANCE, flattenCubicWithArcLen, flattenQuadraticWithArcLen } from '../flatten';\nimport type { Path, PolygonPath, RectPath } from '../path';\n\n/** One contour of a path, flattened to straight segments. */\nexport interface Polyline {\n  /** Interleaved x,y vertices (length = 2 × point count). */\n  points: number[];\n  /** Whether the contour was closed (ends with Z, or is a RectPath). */\n  closed: boolean;\n  /** For each point, the previous anchor index. Anchor-aligned points set A === B. */\n  anchorA?: Uint32Array;\n  /** For each point, the next anchor index. */\n  anchorB?: Uint32Array;\n  /** For each point, the arc-length fraction along (A, B). 0 at anchor A; for anchor-aligned, set to 0. */\n  anchorT?: Float32Array;\n  /** Per-point stroke width, populated by the tessellator when the Stroke\n   *  carries `vertexWidths`. Undefined means uniform `Stroke.width`. */\n  widths?: Float32Array;\n  /** Per-point distance the ribbon's middle sits off the path toward the\n   *  normal `(−dy, dx)` of the direction of travel: half the right edge's\n   *  distance less the left's. Set alongside `widths` only when the two sides\n   *  differ somewhere; undefined means centered. */\n  offsets?: Float32Array;\n}\n\n/** Options for `extractPolylines`. */\nexport interface ExtractOptions {\n  flattenTolerance?: number;\n  /** Most a curve may turn, in radians, between two flattened vertices.\n   *  Unbounded when unset. */\n  maxTurn?: number;\n}\n\n/** Flatten each contour of a path to a straight-segment polyline, carrying the\n *  anchor parameterization per point. A rect yields one closed contour. */\nexport function extractPolylines(path: Path, opts: ExtractOptions = {}): Polyline[] {\n  if (path.kind === 'rect') return [extractRect(path)];\n  return extractPolygon(resolveCorners(path), opts);\n}\n\nfunction extractRect(p: RectPath): Polyline {\n  const { x, y, width: w, height: h } = p;\n  return {\n    points: Array.from(rectToContour(x, y, w, h)),\n    closed: true,\n    anchorA: new Uint32Array([0, 1, 2, 3]),\n    anchorB: new Uint32Array([0, 1, 2, 3]),\n    anchorT: new Float32Array([0, 0, 0, 0]),\n  };\n}\n\nfunction extractPolygon(p: PolygonPath, opts: ExtractOptions): Polyline[] {\n  const tolerance = opts.flattenTolerance ?? DEFAULT_FLATTEN_TOLERANCE;\n  const { commands, coords } = p;\n  const out: Polyline[] = [];\n  // Anchors are numbered globally (across all contours) in command-stream order.\n  let anchorCounter = 0;\n\n  // Builders for the current polyline.\n  let pts: number[] | null = null;\n  let aA: number[] | null = null;\n  let aB: number[] | null = null;\n  let aT: number[] | null = null;\n  let current: Polyline | null = null;\n\n  let prevAnchor = -1;\n  // The anchor a subpath opened by a bare drawing command starts from.\n  let startAnchor = 0;\n\n  const beginContour = (): Polyline => {\n    pts = [];\n    aA = [];\n    aB = [];\n    aT = [];\n    const next: Polyline = { points: pts, closed: false };\n    out.push(next);\n    return next;\n  };\n\n  /**\n   * A closed contour's last point repeating its first leaves a zero-length\n   * closing segment, which the stroker discards along with the wrap-around\n   * join it should have carried, notching the ribbon at the contour's start.\n   * Every font outline serialized by opentype.js is written this way. Exact\n   * equality is the right test: the duplicate is a re-emission of the same\n   * number, and a near-miss is a genuine (if tiny) segment the author asked for.\n   */\n  const dropDuplicateClosingPoint = (): void => {\n    if (!pts || !aA || !aB || !aT) return;\n    const n = pts.length / 2;\n    if (n < 2) return;\n    if (pts[0] !== pts[(n - 1) * 2] || pts[1] !== pts[(n - 1) * 2 + 1]) return;\n    pts.length -= 2;\n    aA.length -= 1;\n    aB.length -= 1;\n    aT.length -= 1;\n  };\n\n  const commit = (target: Polyline): void => {\n    if (!pts || !aA || !aB || !aT) return;\n    target.anchorA = new Uint32Array(aA);\n    target.anchorB = new Uint32Array(aB);\n    target.anchorT = new Float32Array(aT);\n  };\n\n  // Fill anchorA/B/T for each point a curve just appended: interior points\n  // interpolate (prevAnchor → target), and the final point is pinned to the\n  // target so the draw-time lerp returns anchor B's color exactly.\n  const pushCurveAnchors = (segStart: number, arcAccum: number[], total: number, target: number): void => {\n    for (let k = 0; k < arcAccum.length; k++) {\n      aA!.push(prevAnchor);\n      aB!.push(target);\n      aT!.push(total > 0 ? arcAccum[k] / total : 0);\n    }\n    const lastIdx = (segStart + arcAccum.length) - 1;\n    aA![lastIdx] = target;\n    aB![lastIdx] = target;\n    aT![lastIdx] = 0;\n  };\n\n  forEachSegment(commands, coords, (cmd, coordIdx, prevX, prevY, _i, opensSubpath) => {\n    if (opensSubpath) {\n      if (current) commit(current);\n      current = beginContour();\n      pts!.push(prevX, prevY);\n      aA!.push(startAnchor);\n      aB!.push(startAnchor);\n      aT!.push(0);\n      prevAnchor = startAnchor;\n    }\n    switch (cmd) {\n      case PATH_M:\n      case PATH_L: {\n        if (cmd === PATH_M) {\n          if (current) commit(current);\n          current = beginContour();\n          startAnchor = anchorCounter;\n        }\n        pts!.push(coords[coordIdx], coords[coordIdx + 1]);\n        aA!.push(anchorCounter);\n        aB!.push(anchorCounter);\n        aT!.push(0);\n        prevAnchor = anchorCounter;\n        anchorCounter++;\n        break;\n      }\n      case PATH_Q: {\n        const target = anchorCounter;\n        const segStart = pts!.length / 2;\n        const arcAccum: number[] = [];\n        const total = flattenQuadraticWithArcLen(\n          prevX, prevY,\n          coords[coordIdx], coords[coordIdx + 1],\n          coords[coordIdx + 2], coords[coordIdx + 3],\n          tolerance, pts!, arcAccum, opts.maxTurn,\n        );\n        pushCurveAnchors(segStart, arcAccum, total, target);\n        prevAnchor = target;\n        anchorCounter++;\n        break;\n      }\n      case PATH_C: {\n        const target = anchorCounter;\n        const segStart = pts!.length / 2;\n        const arcAccum: number[] = [];\n        const total = flattenCubicWithArcLen(\n          prevX, prevY,\n          coords[coordIdx], coords[coordIdx + 1],\n          coords[coordIdx + 2], coords[coordIdx + 3],\n          coords[coordIdx + 4], coords[coordIdx + 5],\n          tolerance, pts!, arcAccum, opts.maxTurn,\n        );\n        pushCurveAnchors(segStart, arcAccum, total, target);\n        prevAnchor = target;\n        anchorCounter++;\n        break;\n      }\n      case PATH_Z: {\n        if (current) {\n          current.closed = true;\n          dropDuplicateClosingPoint();\n        }\n        break;\n      }\n      default:\n        throw new Error(`extractPolylines: unknown command code ${cmd}`);\n    }\n  });\n\n  if (current) commit(current);\n  return out;\n}\n"]}

package/dist/chunk-7KLJZFBY.js

@@ -0,0 +1,573 @@
+import { nearestOnLine, nearestOnCubic } from './chunk-CE7IY7TB.js';
+import { cornerCuts, decodeContours, fillsOpenSubpaths, resolveCorners, segmentsCross, pointInPolygon } from './chunk-J2O2B54M.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-7KLJZFBY.js.map
+//# sourceMappingURL=chunk-7KLJZFBY.js.map