@flighthq/path-boolean 0.5.1-next.3302.76ece6b → 0.5.1-next.4304.322dc96

package/dist/martinezKernel.js

@@ -1,330 +1,778 @@
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
-export function createMartinezPathBooleanKernel() {
-    const out = allocateEntity();
-    initializeMartinezPathBooleanKernel(out);
-    return finishEntity(out);
-}
-// The Martinez–Rueda–Feito kernel: a from-scratch, floating-point sweep-line over caller-owned contours.
-//
-//
-// The pipeline runs in two stages, deliberately separated so the correctness-critical classification
-// never races the arrangement construction:
-//
-//   1. Arrangement (the sweep). An event priority queue holds the left/right endpoint events of every
-//      input edge. Sweeping left-to-right maintains a status of the active segments ordered by their y
-//      at the sweep; each segment is only ever tested for intersection against its immediate status
-//      neighbors. A proper crossing splits both segments at the crossing point; a collinear overlap
-//      splits each at the other's interior endpoints so the shared span becomes geometrically identical
-//      sub-segments. When a segment's right endpoint is reached it is final and recorded.
-//   2. Classification + assembly (a static pass over the final segments). Coincident sub-segments are
-//      merged by geometry, summing each operand's winding contribution. Every unique segment is then
-//      classified by the winding number just below vs just above it (a downward ray from its midpoint),
-//      under the fill rule, for the operation — the boundary test. In-result segments are oriented so
-//      the kept region lies on their left and traced into closed rings.
-//
-// Handling coincidence in the static pass rather than mid-sweep is the key robustness decision: winding
-// deltas are all final before any membership is computed, so both fill rules and both same/opposite
-// edge orientations fall out of the same arithmetic with no field-staleness. It trades the classic
-// algorithm's O(n log n) inline classification for an O(n²) post-pass, which is the right call for a
-// correctness-first kernel on the modest polygon sizes booleans see.
-export function initializeMartinezPathBooleanKernel(out) {
-    out.computePathBoolean = (subject, clip, operation, fillRule) => {
-        return computeMartinezBoolean(subject, clip, operation, fillRule);
-    };
-}
-// The kernel the boolean operations use unless the caller passes another one. A stateless value, so it is
-// one shared instance rather than a per-call construction: a second instance would be indistinguishable
-// and would only break the identity a caller may use to recognise the stock kernel. Annotated with its
-// concrete type because an exported const whose type is inferred lowers to an anonymous struct of
-// type-erased closures in the C++ emitter; see agents/portability.md.
-export const martinezPathBooleanKernel = createMartinezPathBooleanKernel();
-// Relative factor for the vertex-merge grid: two vertices collapse to one when they fall in the same
-// cell of a grid this fraction of the input's coordinate extent. Large enough to catch the last-bit
-// numerical twins a crossing computation produces (a few ulps of the extent), far below any real
-// feature separation, so it only ever fuses points that were meant to be identical. Made relative to
-// the coordinate magnitude (rather than a fixed absolute) so the same topology resolves whether the
-// polygon is expressed in pixels, metres, or micrometres.
+// Generated from crates/flight-path-boolean/src/martinez_kernel.rs by flight-compiler.
+// Rust is authoritative; run `npm run generate` after changing it.
+import { allocateEntity } from '@flighthq/entity/contract';
+/**
+ * Relative factor for the vertex-merge grid: two vertices collapse to one when
+ * they fall in the same cell of a grid this fraction of the input's coordinate
+ * extent.
+ */
 const VERTEX_SNAP_RELATIVE = 1e-9;
-// Fallback absolute snap for degenerate all-coincident input where the extent is zero; no segments
-// survive such input, so the exact value only guards the division in `snap`.
+/**
+ * Fallback absolute snap for degenerate all-coincident input where the extent is
+ * zero.
+ */
 const VERTEX_SNAP_FALLBACK = 1e-9;
-// Relative tolerance for the intersection orientation tests, scaled by squared edge lengths in each
-// comparison so it already behaves consistently across coordinate magnitudes.
+/**
+ * Relative tolerance for the intersection orientation tests, scaled by squared
+ * edge lengths in each comparison.
+ */
 const INTERSECTION_EPS = 1e-12;
-let nextEventId = 0;
-// The active vertex-merge grid cell size for the boolean currently being computed, derived from the
-// input's coordinate extent at the top of `computeMartinezBoolean`. Module-scoped rather than threaded
-// through every `approxEqual`/`snap` call (the computation is synchronous and single-entrant, like
-// `nextEventId`); it is never read at import time, so importing the package stays side-effect-free.
-let vertexSnap = VERTEX_SNAP_FALLBACK;
-function computeMartinezBoolean(subject, clip, operation, fillRule) {
-    nextEventId = 0;
-    vertexSnap = computeVertexSnap(subject, clip);
-    const segments = buildArrangement(subject, clip);
-    if (segments.length === 0)
-        return [];
-    const unique = mergeCoincidentSegments(segments);
-    const kept = classifySegments(unique, operation, fillRule);
-    if (kept.length === 0)
-        return [];
-    return traceRings(kept);
-}
-// Scene2D 1: the sweep. Returns every final (non-crossing, non-overlapping) segment of the combined
-// subject+clip arrangement.
-function buildArrangement(subject, clip) {
-    const heap = new EventHeap();
-    fillQueue(subject, true, heap);
-    fillQueue(clip, false, heap);
-    const status = [];
-    const segments = [];
-    while (!heap.isEmpty()) {
-        const event = heap.pop();
-        if (event.left) {
-            const index = insertStatus(status, event);
-            const prev = index > 0 ? status[index - 1] : null;
-            const next = index < status.length - 1 ? status[index + 1] : null;
-            if (next !== null)
-                possibleIntersection(event, next, heap);
-            if (prev !== null)
-                possibleIntersection(prev, event, heap);
+/**
+ * The kernel the boolean operations use unless the caller passes another one. A stateless value, so
+ * it is one shared instance rather than a per-call construction (TS `martinezPathBooleanKernel`;
+ * entity-valued singleton as `LazyLock`, D12).
+ */
+export const martinezPathBooleanKernel = createMartinezPathBooleanKernel();
+function createEvent(events, x, y, isSubject) {
+    const id = events.length;
+    events.push({ x: x, y: y, left: false, otherEvent: undefined, isSubject: isSubject, id: id, windingDelta: 0 });
+    return id;
+}
+export function createMartinezPathBooleanKernel() {
+    let out = allocateEntity();
+    initializeMartinezPathBooleanKernel(out);
+    return out;
+}
+export function getPathBooleanFillRuleString(value) {
+    return (() => {
+        const matchValue = value;
+        switch (matchValue) {
+            case 'evenOdd':
+                return 'evenOdd';
+            case 'nonZero':
+                return 'nonZero';
+            case 'negative':
+                return 'negative';
+            case 'positive':
+                return 'positive';
+        }
+    })();
+}
+function addEdge(ax, ay, bx, by, isSubject, events, heap) {
+    const a = createEvent(events, ax, ay, isSubject);
+    const b = createEvent(events, bx, by, isSubject);
+    events[a].otherEvent = b;
+    events[b].otherEvent = a;
+    if (pointOrder(ax, ay, bx, by) < 0) {
+        events[a].left = true;
+        events[a].windingDelta = 1;
+    }
+    else {
+        events[b].left = true;
+        events[b].windingDelta = -1;
+    }
+    eventHeapPush(heap, events, a);
+    eventHeapPush(heap, events, b);
+}
+function approxEqual(a, b, vertexSnap) {
+    return Math.abs(a - b) <= vertexSnap;
+}
+function buildArrangement(subject, clip, vertexSnap) {
+    let events = [];
+    let heap = { data: [], length: 0 };
+    fillQueue(subject, true, events, heap, vertexSnap);
+    fillQueue(clip, false, events, heap, vertexSnap);
+    let status = [];
+    let segments = [];
+    while (!eventHeapIsEmpty(heap)) {
+        const event = eventHeapPop(heap, events);
+        if (events[event].left) {
+            const index = insertStatus(status, events, event);
+            const prev = index > 0 ? status[index - 1] : undefined;
+            const next = index < status.length - 1 ? status[index + 1] : undefined;
+            if (next !== undefined) {
+                const nextEv = next;
+                possibleIntersection(events, heap, vertexSnap, event, nextEv);
+            }
+            if (prev !== undefined) {
+                const prevEv = prev;
+                possibleIntersection(events, heap, vertexSnap, prevEv, event);
+            }
         }
         else {
-            const leftEvent = getOtherEvent(event);
+            const leftEvent = getOtherEvent(events, event);
             const index = findStatus(status, leftEvent);
-            if (index !== -1) {
-                const prev = index > 0 ? status[index - 1] : null;
-                const next = index < status.length - 1 ? status[index + 1] : null;
-                status.splice(index, 1);
-                if (prev !== null && next !== null)
-                    possibleIntersection(prev, next, heap);
+            if (index >= 0) {
+                const idx = index >>> 0;
+                const hasNeighbors = idx > 0 && idx + 1 < status.length;
+                const prevEv = idx > 0 ? status[idx - 1] : 0;
+                const nextEv = idx + 1 < status.length ? status[idx + 1] : 0;
+                let kept = [...status.slice(0, idx)];
+                {
+                    const source = status.slice(idx + 1, status.length);
+                    for (let index = 0, count = source.length; index < count; index++) {
+                        kept.push(source[index]);
+                    }
+                }
+                status = kept;
+                if (hasNeighbors) {
+                    possibleIntersection(events, heap, vertexSnap, prevEv, nextEv);
+                }
             }
-            recordSegment(leftEvent, event, segments);
+            recordSegment(events, leftEvent, event, segments, vertexSnap);
         }
     }
     return segments;
 }
-function recordSegment(leftEvent, rightEvent, segments) {
-    if (!leftEvent.left)
-        return;
-    if (approxEqual(leftEvent.x, rightEvent.x) && approxEqual(leftEvent.y, rightEvent.y))
+function classifySegments(unique, operation, fillRule) {
+    let kept = [];
+    for (const seg of unique) {
+        const mx = (seg.ax + seg.bx) / 2.0;
+        const my = (seg.ay + seg.by) / 2.0;
+        const dx = seg.bx - seg.ax;
+        const dy = seg.by - seg.ay;
+        const len = Math.sqrt(dx * dx + dy * dy);
+        if (len === 0.0) {
+            continue;
+        }
+        const eps = len * 1e-4;
+        const nlx = (-dy / len) * eps;
+        const nly = (dx / len) * eps;
+        const leftInSubject = isInside(windingAt(unique, mx + nlx, my + nly, true), fillRule);
+        const leftInClip = isInside(windingAt(unique, mx + nlx, my + nly, false), fillRule);
+        const rightInSubject = isInside(windingAt(unique, mx - nlx, my - nly, true), fillRule);
+        const rightInClip = isInside(windingAt(unique, mx - nlx, my - nly, false), fillRule);
+        const filledLeft = combine(operation, leftInSubject, leftInClip);
+        const filledRight = combine(operation, rightInSubject, rightInClip);
+        if (filledLeft === filledRight) {
+            continue;
+        }
+        if (filledLeft) {
+            kept.push(new Float64Array([seg.ax, seg.ay, seg.bx, seg.by]));
+        }
+        else {
+            kept.push(new Float64Array([seg.bx, seg.by, seg.ax, seg.ay]));
+        }
+    }
+    return kept;
+}
+function combine(operation, inSubject, inClip) {
+    return (() => {
+        const matchValue = operation;
+        switch (matchValue) {
+            case 'union':
+                return inSubject || inClip;
+            case 'intersection':
+                return inSubject && inClip;
+            case 'difference':
+                return inSubject && !inClip;
+            case 'xor':
+                return inSubject !== inClip;
+        }
+    })();
+}
+/**
+ * Priority order of two events.
+ */
+function compareEvents(events, e1, e2) {
+    if (events[e1].x !== events[e2].x) {
+        return events[e1].x < events[e2].x ? -1 : 1;
+    }
+    if (events[e1].y !== events[e2].y) {
+        return events[e1].y < events[e2].y ? -1 : 1;
+    }
+    if (e1 === e2) {
+        return 0;
+    }
+    if (events[e1].left !== events[e2].left) {
+        return events[e1].left ? 1 : -1;
+    }
+    const e1Other = getOtherEvent(events, e1);
+    const e2Other = getOtherEvent(events, e2);
+    const area = signedArea(events[e1].x, events[e1].y, events[e1Other].x, events[e1Other].y, events[e2Other].x, events[e2Other].y);
+    if (area !== 0.0) {
+        return isBelow(events, e1, events[e2Other].x, events[e2Other].y) ? -1 : 1;
+    }
+    if (events[e1].isSubject !== events[e2].isSubject) {
+        return events[e1].isSubject ? -1 : 1;
+    }
+    return events[e1].id < events[e2].id ? -1 : 1;
+}
+/**
+ * Orders two active segments by vertical position at the sweep (Martinez segment
+ * comparator).
+ */
+function compareSegments(events, le1, le2) {
+    if (le1 === le2) {
+        return 0;
+    }
+    const a1x = events[le1].x;
+    const a1y = events[le1].y;
+    const le2Other = getOtherEvent(events, le2);
+    const le1Other = getOtherEvent(events, le1);
+    const a2x = events[le1Other].x;
+    const a2y = events[le1Other].y;
+    const s1 = signedArea(a1x, a1y, a2x, a2y, events[le2].x, events[le2].y);
+    const s2 = signedArea(a1x, a1y, a2x, a2y, events[le2Other].x, events[le2Other].y);
+    if (s1 !== 0.0 || s2 !== 0.0) {
+        if (a1x === events[le2].x && a1y === events[le2].y) {
+            return isBelow(events, le1, events[le2Other].x, events[le2Other].y) ? -1 : 1;
+        }
+        if (a1x === events[le2].x) {
+            return a1y < events[le2].y ? -1 : 1;
+        }
+        if (compareEvents(events, le1, le2) === 1) {
+            return isBelow(events, le2, a1x, a1y) ? 1 : -1;
+        }
+        return isBelow(events, le1, events[le2].x, events[le2].y) ? -1 : 1;
+    }
+    if (events[le1].isSubject !== events[le2].isSubject) {
+        return events[le1].isSubject ? -1 : 1;
+    }
+    if (a1x === events[le2].x && a1y === events[le2].y) {
+        return events[le1].id < events[le2].id ? -1 : 1;
+    }
+    return compareEvents(events, le1, le2) === 1 ? 1 : -1;
+}
+function compareSnappedKeys(keys, stride, a, b) {
+    for (let offset = 0; offset < stride; offset += 1) {
+        const left = keys[a * stride + offset];
+        const right = keys[b * stride + offset];
+        if (left < right) {
+            return -1;
+        }
+        if (left > right) {
+            return 1;
+        }
+    }
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function computeMartinezBoolean(subject, clip, operation, fillRule) {
+    const vertexSnap = computeVertexSnap(subject, clip);
+    const segments = buildArrangement(subject, clip, vertexSnap);
+    if (segments.length === 0) {
+        return [];
+    }
+    const unique = mergeCoincidentSegments(segments, vertexSnap);
+    const kept = classifySegments(unique, operation, fillRule);
+    if (kept.length === 0) {
+        return [];
+    }
+    return traceRings(kept, vertexSnap);
+}
+function computeVertexSnap(subject, clip) {
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const contours of [subject, clip]) {
+        for (const contour of contours) {
+            let i = 0;
+            while (i < contour.length) {
+                const x = contour[i];
+                const y = contour[i + 1];
+                if (x < minX) {
+                    minX = x;
+                }
+                if (x > maxX) {
+                    maxX = x;
+                }
+                if (y < minY) {
+                    minY = y;
+                }
+                if (y > maxY) {
+                    maxY = y;
+                }
+                i += 2;
+            }
+        }
+    }
+    const extent = Math.max(maxX - minX, maxY - minY);
+    return extent > 0.0 ? extent * VERTEX_SNAP_RELATIVE : VERTEX_SNAP_FALLBACK;
+}
+/**
+ * `from` and `to` are snapped-vertex ids in first-occurrence order (see `firstOccurrenceIds`).
+ */
+function directedGraphAddEdge(graph, from, to, edge) {
+    from = directedGraphVertex(graph, from, edge[0], edge[1]);
+    to = directedGraphVertex(graph, to, edge[2], edge[3]);
+    if (from === to) {
         return;
-    segments.push({
-        ax: leftEvent.x,
-        ay: leftEvent.y,
-        bx: rightEvent.x,
-        by: rightEvent.y,
-        isSubject: leftEvent.isSubject,
-        windingDelta: leftEvent.windingDelta,
-    });
+    }
+    const edgeIndex = graph.edgeFrom.length;
+    graph.edgeFrom.push(from);
+    graph.edgeTo.push(to);
+    graph.used.push(false);
+    graph.outgoing[from].push(edgeIndex);
+}
+function directedGraphNew() {
+    return { xs: [], ys: [], outgoing: [], edgeTo: [], edgeFrom: [], used: [] };
+}
+/**
+ * At vertex `at`, arriving from `cameFrom`, pick the unused outgoing edge that
+ * turns most clockwise from the reversed incoming direction.
+ */
+function directedGraphNextEdge(graph, at, cameFrom) {
+    const incomingAngle = Math.atan2(graph.ys[cameFrom] - graph.ys[at], graph.xs[cameFrom] - graph.xs[at]);
+    let best = -1;
+    let bestGap = Number.POSITIVE_INFINITY;
+    const twoPi = Math.PI * 2.0;
+    for (const edge of graph.outgoing[at]) {
+        if (graph.used[edge]) {
+            continue;
+        }
+        const to = graph.edgeTo[edge];
+        const angle = Math.atan2(graph.ys[to] - graph.ys[at], graph.xs[to] - graph.xs[at]);
+        let gap = incomingAngle - angle;
+        while (gap <= 0.0) {
+            gap += twoPi;
+        }
+        while (gap > twoPi) {
+            gap -= twoPi;
+        }
+        if (gap < bestGap) {
+            bestGap = gap;
+            best = edge | 0;
+        }
+    }
+    return best;
+}
+function directedGraphTraceRings(graph) {
+    let rings = [];
+    for (let start = 0; start < graph.edgeFrom.length; start += 1) {
+        if (graph.used[start]) {
+            continue;
+        }
+        const ring = directedGraphWalk(graph, start);
+        if (ring !== undefined) {
+            const r = ring;
+            if (r.length >= 6) {
+                rings.push(r);
+            }
+        }
+    }
+    return rings;
 }
-// Appends every edge of every contour as a left/right event pair. A trailing vertex repeating the first
-// (flattenPath appends one on CLOSE) is dropped; zero-length edges are skipped.
-function fillQueue(contours, isSubject, heap) {
+function directedGraphVertex(graph, id, x, y) {
+    if (id === graph.xs.length) {
+        graph.xs.push(x);
+        graph.ys.push(y);
+        graph.outgoing.push([]);
+    }
+    return id;
+}
+function directedGraphWalk(graph, startEdge) {
+    let ring = [];
+    let edge = startEdge;
+    let guard = 0;
+    const limit = graph.edgeFrom.length + 2;
+    while (guard < limit) {
+        guard += 1;
+        graph.used[edge] = true;
+        const from = graph.edgeFrom[edge];
+        ring.push(graph.xs[from]);
+        ring.push(graph.ys[from]);
+        const to = graph.edgeTo[edge];
+        const next = directedGraphNextEdge(graph, to, from);
+        if (next < 0 || next >>> 0 === startEdge || graph.used[next >>> 0]) {
+            break;
+        }
+        edge = next >>> 0;
+    }
+    return ring;
+}
+function divideIfInterior(events, heap, vertexSnap, le, x, y) {
+    const other = getOtherEvent(events, le);
+    const leX = events[le].x;
+    const leY = events[le].y;
+    const otherX = events[other].x;
+    const otherY = events[other].y;
+    if (pointStrictlyInside(leX, leY, otherX, otherY, x, y, vertexSnap)) {
+        divideSegment(events, heap, le, x, y);
+    }
+}
+/**
+ * Splits `le` at interior point (x, y).
+ */
+function divideSegment(events, heap, le, x, y) {
+    const isSubject = events[le].isSubject;
+    const windingDelta = events[le].windingDelta;
+    const right = getOtherEvent(events, le);
+    const newRight = createEvent(events, x, y, isSubject);
+    const newLeft = createEvent(events, x, y, isSubject);
+    events[newRight].left = false;
+    events[newRight].otherEvent = le;
+    events[newLeft].left = true;
+    events[newLeft].otherEvent = right;
+    events[newLeft].windingDelta = windingDelta;
+    events[le].otherEvent = newRight;
+    events[right].otherEvent = newLeft;
+    eventHeapPush(heap, events, newLeft);
+    eventHeapPush(heap, events, newRight);
+}
+function eventHeapIsEmpty(heap) {
+    return heap.length === 0;
+}
+function eventHeapPop(heap, events) {
+    const top = heap.data[0];
+    heap.length -= 1;
+    const last = heap.data[heap.length];
+    if (heap.length > 0) {
+        heap.data[0] = last;
+        let i = 0;
+        const n = heap.length;
+        for (;;) {
+            const left = i * 2 + 1;
+            const right = left + 1;
+            let smallest = i;
+            if (left < n && compareEvents(events, heap.data[left], heap.data[smallest]) < 0) {
+                smallest = left;
+            }
+            if (right < n && compareEvents(events, heap.data[right], heap.data[smallest]) < 0) {
+                smallest = right;
+            }
+            if (smallest === i) {
+                break;
+            }
+            [heap.data[i], heap.data[smallest]] = [heap.data[smallest], heap.data[i]];
+            i = smallest;
+        }
+    }
+    return top;
+}
+function eventHeapPush(heap, events, event) {
+    if (heap.length < heap.data.length) {
+        heap.data[heap.length] = event;
+    }
+    else {
+        heap.data.push(event);
+    }
+    heap.length += 1;
+    let i = heap.length - 1;
+    while (i > 0) {
+        const parent = (i - 1) >> 1;
+        if (compareEvents(events, heap.data[i], heap.data[parent]) < 0) {
+            [heap.data[i], heap.data[parent]] = [heap.data[parent], heap.data[i]];
+            i = parent;
+        }
+        else {
+            break;
+        }
+    }
+}
+/**
+ * Appends every edge of every contour as a left/right event pair.
+ */
+function fillQueue(contours, isSubject, events, heap, vertexSnap) {
     for (const contour of contours) {
         let count = contour.length >> 1;
-        if (count < 2)
+        if (count < 2) {
             continue;
-        if (approxEqual(contour[0], contour[(count - 1) * 2]) && approxEqual(contour[1], contour[(count - 1) * 2 + 1])) {
+        }
+        if (approxEqual(contour[0], contour[(count - 1) * 2], vertexSnap) &&
+            approxEqual(contour[1], contour[(count - 1) * 2 + 1], vertexSnap)) {
             count -= 1;
         }
-        if (count < 3)
+        if (count < 3) {
             continue;
-        for (let i = 0; i < count; i++) {
+        }
+        for (let i = 0; i < count; i += 1) {
             const ax = contour[i * 2];
             const ay = contour[i * 2 + 1];
             const j = (i + 1) % count;
             const bx = contour[j * 2];
             const by = contour[j * 2 + 1];
-            if (approxEqual(ax, bx) && approxEqual(ay, by))
+            if (approxEqual(ax, bx, vertexSnap) && approxEqual(ay, by, vertexSnap)) {
                 continue;
-            addEdge(ax, ay, bx, by, isSubject, heap);
+            }
+            addEdge(ax, ay, bx, by, isSubject, events, heap);
         }
     }
 }
-function addEdge(ax, ay, bx, by, isSubject, heap) {
-    const a = createEvent(ax, ay, isSubject);
-    const b = createEvent(bx, by, isSubject);
-    a.otherEvent = b;
-    b.otherEvent = a;
-    if (pointOrder(ax, ay, bx, by) < 0) {
-        a.left = true;
-        a.windingDelta = 1;
+function findStatus(status, event) {
+    for (let i = 0; i < status.length; i += 1) {
+        if (status[i] === event) {
+            return i | 0;
+        }
     }
-    else {
-        b.left = true;
-        b.windingDelta = -1;
-    }
-    heap.push(a);
-    heap.push(b);
-}
-function createEvent(x, y, isSubject) {
-    return {
-        x,
-        y,
-        left: false,
-        otherEvent: null,
-        isSubject,
-        id: nextEventId++,
-        windingDelta: 0,
-    };
-}
-// Reshapes the arrangement so two status-neighbor segments only ever meet at shared endpoints.
-function possibleIntersection(le1, le2, heap) {
-    const le1Other = getOtherEvent(le1);
-    const le2Other = getOtherEvent(le2);
-    const inter = segmentIntersection(le1.x, le1.y, le1Other.x, le1Other.y, le2.x, le2.y, le2Other.x, le2Other.y);
-    if (inter === null)
-        return;
-    if (inter.length === 1) {
-        const ix = inter[0][0];
-        const iy = inter[0][1];
-        if (!pointOnEndpoint(le1, ix, iy))
-            divideSegment(le1, ix, iy, heap);
-        if (!pointOnEndpoint(le2, ix, iy))
-            divideSegment(le2, ix, iy, heap);
-        return;
+    return -1;
+}
+function firstOccurrenceIds(keys, stride) {
+    const count = Math.trunc(keys.length / stride);
+    let order = [];
+    for (let position = 0; position < count; position += 1) {
+        order.push(position);
     }
-    // Collinear overlap: split each segment at the other's strictly-interior endpoints. Remaining overlap
-    // on the freshly-created halves is resolved when those halves become status neighbors and are tested.
-    divideIfInterior(le1, le2.x, le2.y, heap);
-    divideIfInterior(le1, le2Other.x, le2Other.y, heap);
-    divideIfInterior(le2, le1.x, le1.y, heap);
-    divideIfInterior(le2, le1Other.x, le1Other.y, heap);
-}
-function divideIfInterior(le, x, y, heap) {
-    const other = getOtherEvent(le);
-    if (pointStrictlyInside(le.x, le.y, other.x, other.y, x, y))
-        divideSegment(le, x, y, heap);
-}
-// Splits `le` at interior point (x, y): the left half keeps `le` as its left endpoint; a fresh left
-// event opens the right half. Both halves inherit the ring orientation, so their winding deltas match.
-function divideSegment(le, x, y, heap) {
-    const right = getOtherEvent(le);
-    const newRight = createEvent(x, y, le.isSubject);
-    const newLeft = createEvent(x, y, le.isSubject);
-    newRight.left = false;
-    newRight.otherEvent = le;
-    newLeft.left = true;
-    newLeft.otherEvent = right;
-    newLeft.windingDelta = le.windingDelta;
-    le.otherEvent = newRight;
-    right.otherEvent = newLeft;
-    heap.push(newLeft);
-    heap.push(newRight);
-}
-function pointOnEndpoint(le, x, y) {
-    const other = getOtherEvent(le);
-    return (approxEqual(le.x, x) && approxEqual(le.y, y)) || (approxEqual(other.x, x) && approxEqual(other.y, y));
-}
-function pointStrictlyInside(lx, ly, rx, ry, x, y) {
-    if ((approxEqual(lx, x) && approxEqual(ly, y)) || (approxEqual(rx, x) && approxEqual(ry, y)))
-        return false;
-    const cross = (rx - lx) * (y - ly) - (ry - ly) * (x - lx);
-    const lenSq = (rx - lx) * (rx - lx) + (ry - ly) * (ry - ly);
-    if (cross * cross > INTERSECTION_EPS * lenSq * lenSq)
-        return false;
-    const dot = (x - lx) * (rx - lx) + (y - ly) * (ry - ly);
-    return dot > 0 && dot < lenSq;
+    order.sort((a, b) => compareSnappedKeys(keys, stride, a, b));
+    let first = new Array(count).fill(0);
+    let groupStart = 0;
+    for (let rank = 0; rank < count; rank += 1) {
+        if (!snappedKeysEqual(keys, stride, order[groupStart], order[rank])) {
+            groupStart = rank;
+        }
+        first[order[rank]] = order[groupStart];
+    }
+    let ids = new Array(count).fill(0);
+    let next = 0;
+    for (let position = 0; position < count; position += 1) {
+        if (first[position] === position) {
+            ids[position] = next;
+            next += 1;
+        }
+        else {
+            ids[position] = ids[first[position]];
+        }
+    }
+    return ids;
+}
+function getOtherEvent(events, event) {
+    return (() => {
+        const matchValue = events[event].otherEvent;
+        if (matchValue !== undefined) {
+            const other = matchValue;
+            return other;
+        }
+        else {
+            return (() => {
+                throw new Error('Sweep event entered the Martinez queue before its endpoint pair was linked');
+            })();
+        }
+    })();
+}
+export function getPathBooleanOperationString(value) {
+    return (() => {
+        const matchValue = value;
+        switch (matchValue) {
+            case 'difference':
+                return 'difference';
+            case 'intersection':
+                return 'intersection';
+            case 'union':
+                return 'union';
+            case 'xor':
+                return 'xor';
+        }
+    })();
+}
+/**
+ * The construction initializer of `createMartinezPathBooleanKernel`.
+ */
+export function initializeMartinezPathBooleanKernel(out) {
+    out.computePathBoolean = computeMartinezBoolean;
 }
-// Sweep-line status: a sorted array. Because segments are subdivided at every crossing they never swap
-// order once inserted, so a plain insertion order stays valid.
-function insertStatus(status, event) {
+function insertStatus(status, events, event) {
     let lo = 0;
     let hi = status.length;
     while (lo < hi) {
         const mid = (lo + hi) >> 1;
-        if (compareSegments(status[mid], event) < 0)
+        if (compareSegments(events, status[mid], event) < 0) {
             lo = mid + 1;
-        else
+        }
+        else {
             hi = mid;
+        }
+    }
+    status.push(event);
+    let shift = status.length - 1;
+    while (shift > lo) {
+        status[shift] = status[shift - 1];
+        shift -= 1;
     }
-    status.splice(lo, 0, event);
+    status[lo] = event;
     return lo;
 }
-function findStatus(status, event) {
-    for (let i = 0; i < status.length; i++)
-        if (status[i] === event)
-            return i;
-    return -1;
+/**
+ * True when segment `le` passes strictly below point (x, y).
+ */
+function isBelow(events, le, x, y) {
+    const other = getOtherEvent(events, le);
+    return events[le].left
+        ? signedArea(events[le].x, events[le].y, events[other].x, events[other].y, x, y) > 0.0
+        : signedArea(events[other].x, events[other].y, events[le].x, events[le].y, x, y) > 0.0;
 }
-// Orders two active segments by vertical position at the sweep (Martinez segment comparator). Uses
-// exact comparisons throughout so the order is a consistent total order — a non-transitive tolerant
-// comparator would corrupt the sorted status.
-function compareSegments(le1, le2) {
-    if (le1 === le2)
-        return 0;
-    const a1x = le1.x;
-    const a1y = le1.y;
-    const le2Other = getOtherEvent(le2);
-    const le1Other = getOtherEvent(le1);
-    const a2x = le1Other.x;
-    const a2y = le1Other.y;
-    const s1 = signedArea(a1x, a1y, a2x, a2y, le2.x, le2.y);
-    const s2 = signedArea(a1x, a1y, a2x, a2y, le2Other.x, le2Other.y);
-    if (s1 !== 0 || s2 !== 0) {
-        if (a1x === le2.x && a1y === le2.y)
-            return isBelow(le1, le2Other.x, le2Other.y) ? -1 : 1;
-        if (a1x === le2.x)
-            return a1y < le2.y ? -1 : 1;
-        if (compareEvents(le1, le2) === 1)
-            return isBelow(le2, a1x, a1y) ? 1 : -1;
-        return isBelow(le1, le2.x, le2.y) ? -1 : 1;
-    }
-    if (le1.isSubject !== le2.isSubject)
-        return le1.isSubject ? -1 : 1;
-    if (a1x === le2.x && a1y === le2.y)
-        return le1.id < le2.id ? -1 : 1;
-    return compareEvents(le1, le2) === 1 ? 1 : -1;
-}
-// True when segment `le` passes strictly below point (x, y).
-function isBelow(le, x, y) {
-    const other = getOtherEvent(le);
-    return le.left
-        ? signedArea(le.x, le.y, other.x, other.y, x, y) > 0
-        : signedArea(other.x, other.y, le.x, le.y, x, y) > 0;
-}
-// Priority order of two events: by x, then y, then right-endpoint-before-left, then by slope, then a
-// stable operand/id tiebreak. Returns -1 when e1 is processed first. Exact comparisons only.
-function compareEvents(e1, e2) {
-    if (e1.x !== e2.x)
-        return e1.x < e2.x ? -1 : 1;
-    if (e1.y !== e2.y)
-        return e1.y < e2.y ? -1 : 1;
-    if (e1 === e2)
-        return 0;
-    if (e1.left !== e2.left)
-        return e1.left ? 1 : -1;
-    const e1Other = getOtherEvent(e1);
-    const e2Other = getOtherEvent(e2);
-    const area = signedArea(e1.x, e1.y, e1Other.x, e1Other.y, e2Other.x, e2Other.y);
-    if (area !== 0)
-        return isBelow(e1, e2Other.x, e2Other.y) ? -1 : 1;
-    if (e1.isSubject !== e2.isSubject)
-        return e1.isSubject ? -1 : 1;
-    return e1.id < e2.id ? -1 : 1;
-}
-function getOtherEvent(event) {
-    if (event.otherEvent === null) {
-        throw new Error('Sweep event entered the Martinez queue before its endpoint pair was linked');
-    }
-    return event.otherEvent;
+function isInside(winding, fillRule) {
+    return (() => {
+        const matchValue = fillRule;
+        switch (matchValue) {
+            case 'evenOdd':
+                return (Math.abs(winding) & 1) === 1;
+            case 'positive':
+                return winding > 0;
+            case 'negative':
+                return winding < 0;
+            case 'nonZero':
+                return winding !== 0;
+        }
+    })();
+}
+function mergeCoincidentSegments(segments, vertexSnap) {
+    let oriented = [];
+    let keys = [];
+    for (const seg of segments) {
+        let ax = seg.ax;
+        let ay = seg.ay;
+        let bx = seg.bx;
+        let by = seg.by;
+        if (pointOrder(ax, ay, bx, by) > 0) {
+            ax = seg.bx;
+            ay = seg.by;
+            bx = seg.ax;
+            by = seg.ay;
+        }
+        oriented.push(ax);
+        oriented.push(ay);
+        oriented.push(bx);
+        oriented.push(by);
+        keys.push(snap(ax, vertexSnap));
+        keys.push(snap(ay, vertexSnap));
+        keys.push(snap(bx, vertexSnap));
+        keys.push(snap(by, vertexSnap));
+    }
+    const ids = firstOccurrenceIds(keys, 4);
+    let unique = [];
+    for (let index = 0; index < segments.length; index += 1) {
+        const seg = segments[index];
+        const idx = ids[index];
+        if (idx < unique.length) {
+            if (seg.isSubject) {
+                unique[idx].subjectDelta += seg.windingDelta;
+            }
+            else {
+                unique[idx].clipDelta += seg.windingDelta;
+            }
+        }
+        else {
+            const ax = oriented[index * 4];
+            const ay = oriented[index * 4 + 1];
+            const bx = oriented[index * 4 + 2];
+            const by = oriented[index * 4 + 3];
+            unique.push({
+                ax: ax,
+                ay: ay,
+                bx: bx,
+                by: by,
+                subjectDelta: seg.isSubject ? seg.windingDelta : 0,
+                clipDelta: seg.isSubject ? 0 : seg.windingDelta,
+            });
+        }
+    }
+    return unique;
+}
+export function parsePathBooleanFillRule(value) {
+    return (() => {
+        const matchValue = value;
+        switch (matchValue) {
+            case 'evenOdd':
+                return 'evenOdd';
+            case 'nonZero':
+                return 'nonZero';
+            case 'negative':
+                return 'negative';
+            case 'positive':
+                return 'positive';
+            default:
+                return undefined;
+        }
+    })();
+}
+export function parsePathBooleanOperation(value) {
+    return (() => {
+        const matchValue = value;
+        switch (matchValue) {
+            case 'difference':
+                return 'difference';
+            case 'intersection':
+                return 'intersection';
+            case 'union':
+                return 'union';
+            case 'xor':
+                return 'xor';
+            default:
+                return undefined;
+        }
+    })();
+}
+function pointOnEndpointCoords(leX, leY, otherX, otherY, x, y, vertexSnap) {
+    return ((approxEqual(leX, x, vertexSnap) && approxEqual(leY, y, vertexSnap)) ||
+        (approxEqual(otherX, x, vertexSnap) && approxEqual(otherY, y, vertexSnap)));
 }
 function pointOrder(ax, ay, bx, by) {
-    if (ax < bx)
+    if (ax < bx) {
         return -1;
-    if (ax > bx)
+    }
+    if (ax > bx) {
         return 1;
-    if (ay < by)
+    }
+    if (ay < by) {
         return -1;
-    if (ay > by)
+    }
+    if (ay > by) {
         return 1;
+    }
     return 0;
 }
-// > 0 when (p0, p1, p2) turn counterclockwise in math (y-up) orientation.
-function signedArea(p0x, p0y, p1x, p1y, p2x, p2y) {
-    return (p0x - p2x) * (p1y - p2y) - (p1x - p2x) * (p0y - p2y);
+function pointStrictlyInside(lx, ly, rx, ry, x, y, vertexSnap) {
+    if ((approxEqual(lx, x, vertexSnap) && approxEqual(ly, y, vertexSnap)) ||
+        (approxEqual(rx, x, vertexSnap) && approxEqual(ry, y, vertexSnap))) {
+        return false;
+    }
+    const cross = (rx - lx) * (y - ly) - (ry - ly) * (x - lx);
+    const lenSq = (rx - lx) * (rx - lx) + (ry - ly) * (ry - ly);
+    if (cross * cross > INTERSECTION_EPS * lenSq * lenSq) {
+        return false;
+    }
+    const dot = (x - lx) * (rx - lx) + (y - ly) * (ry - ly);
+    return dot > 0.0 && dot < lenSq;
+}
+/**
+ * Reshapes the arrangement so two status-neighbor segments only ever meet at
+ * shared endpoints.
+ */
+function possibleIntersection(events, heap, vertexSnap, le1, le2) {
+    const le1Other = getOtherEvent(events, le1);
+    const le2Other = getOtherEvent(events, le2);
+    const le1X = events[le1].x;
+    const le1Y = events[le1].y;
+    const le1OtherX = events[le1Other].x;
+    const le1OtherY = events[le1Other].y;
+    const le2X = events[le2].x;
+    const le2Y = events[le2].y;
+    const le2OtherX = events[le2Other].x;
+    const le2OtherY = events[le2Other].y;
+    let inter = segmentIntersection(le1X, le1Y, le1OtherX, le1OtherY, le2X, le2Y, le2OtherX, le2OtherY);
+    if (inter === undefined) {
+        return;
+    }
+    inter = inter;
+    if (inter.length === 1) {
+        const ix = inter[0][0];
+        const iy = inter[0][1];
+        const on1 = pointOnEndpointCoords(le1X, le1Y, le1OtherX, le1OtherY, ix, iy, vertexSnap);
+        if (!on1) {
+            divideSegment(events, heap, le1, ix, iy);
+        }
+        const on2 = pointOnEndpointCoords(le2X, le2Y, le2OtherX, le2OtherY, ix, iy, vertexSnap);
+        if (!on2) {
+            divideSegment(events, heap, le2, ix, iy);
+        }
+        return;
+    }
+    divideIfInterior(events, heap, vertexSnap, le1, le2X, le2Y);
+    divideIfInterior(events, heap, vertexSnap, le1, le2OtherX, le2OtherY);
+    divideIfInterior(events, heap, vertexSnap, le2, le1X, le1Y);
+    divideIfInterior(events, heap, vertexSnap, le2, le1OtherX, le1OtherY);
+}
+function recordSegment(events, leftEvent, rightEvent, segments, vertexSnap) {
+    if (!events[leftEvent].left) {
+        return;
+    }
+    if (approxEqual(events[leftEvent].x, events[rightEvent].x, vertexSnap) &&
+        approxEqual(events[leftEvent].y, events[rightEvent].y, vertexSnap)) {
+        return;
+    }
+    segments.push({
+        ax: events[leftEvent].x,
+        ay: events[leftEvent].y,
+        bx: events[rightEvent].x,
+        by: events[rightEvent].y,
+        isSubject: events[leftEvent].isSubject,
+        windingDelta: events[leftEvent].windingDelta,
+    });
 }
-// Returns null, a single intersection point, or the two endpoints of a collinear overlap.
+/**
+ * Returns None, a single intersection point, or the two endpoints of a collinear
+ * overlap.
+ */
 function segmentIntersection(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
     const vax = a2x - a1x;
     const vay = a2y - a1y;
@@ -338,313 +786,83 @@ function segmentIntersection(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
     const sqrLenB = vbx * vbx + vby * vby;
     if (sqrKross > INTERSECTION_EPS * sqrLenA * sqrLenB) {
         const s = (ex * vby - ey * vbx) / kross;
-        if (s < 0 || s > 1)
-            return null;
+        if (s < 0.0 || s > 1.0) {
+            return undefined;
+        }
         const t = (ex * vay - ey * vax) / kross;
-        if (t < 0 || t > 1)
-            return null;
+        if (t < 0.0 || t > 1.0) {
+            return undefined;
+        }
         return [[a1x + s * vax, a1y + s * vay]];
     }
     const krossE = ex * vay - ey * vax;
-    if (krossE * krossE > INTERSECTION_EPS * sqrLenA * (ex * ex + ey * ey))
-        return null;
+    if (krossE * krossE > INTERSECTION_EPS * sqrLenA * (ex * ex + ey * ey)) {
+        return undefined;
+    }
     const sa = (ex * vax + ey * vay) / sqrLenA;
     const sb = sa + (vbx * vax + vby * vay) / sqrLenA;
-    const lo = Math.max(0, Math.min(sa, sb));
-    const hi = Math.min(1, Math.max(sa, sb));
-    if (lo > hi + 1e-12)
-        return null;
-    if (Math.abs(lo - hi) <= 1e-12)
+    const lo = Math.max(0.0, Math.min(sa, sb));
+    const hi = Math.min(1.0, Math.max(sa, sb));
+    if (lo > hi + 1e-12) {
+        return undefined;
+    }
+    if (Math.abs(lo - hi) <= 1e-12) {
         return [[a1x + lo * vax, a1y + lo * vay]];
+    }
     return [
         [a1x + lo * vax, a1y + lo * vay],
         [a1x + hi * vax, a1y + hi * vay],
     ];
 }
-// Scene2D 2a: fold coincident final segments into one, summing each operand's winding contribution. The
-// key normalizes endpoints to lexicographic order, matching the way `addEdge` measures windingDelta, so
-// deltas from opposite-direction coincident edges cancel.
-function mergeCoincidentSegments(segments) {
-    const map = new Map();
-    for (const seg of segments) {
-        let ax = seg.ax;
-        let ay = seg.ay;
-        let bx = seg.bx;
-        let by = seg.by;
-        if (pointOrder(ax, ay, bx, by) > 0) {
-            ax = seg.bx;
-            ay = seg.by;
-            bx = seg.ax;
-            by = seg.ay;
+/**
+ * > 0 when (p0, p1, p2) turn counterclockwise.
+ */
+function signedArea(p0x, p0y, p1x, p1y, p2x, p2y) {
+    return (p0x - p2x) * (p1y - p2y) - (p1x - p2x) * (p0y - p2y);
+}
+function snap(v, vertexSnap) {
+    return Math.round(v / vertexSnap);
+}
+function snappedKeysEqual(keys, stride, a, b) {
+    for (let offset = 0; offset < stride; offset += 1) {
+        if (keys[a * stride + offset] !== keys[b * stride + offset]) {
+            return false;
         }
-        const key = `${snap(ax)},${snap(ay)},${snap(bx)},${snap(by)}`;
-        let unique = map.get(key);
-        if (unique === undefined) {
-            unique = { ax, ay, bx, by, subjectDelta: 0, clipDelta: 0 };
-            map.set(key, unique);
-        }
-        if (seg.isSubject)
-            unique.subjectDelta += seg.windingDelta;
-        else
-            unique.clipDelta += seg.windingDelta;
-    }
-    return [...map.values()];
-}
-// Scene2D 2b: classify each unique segment by the boundary test, orienting kept segments so the retained
-// region sits on the segment's left. Returns directed edges [fromX, fromY, toX, toY].
-//
-// Membership is sampled at two points a hair off each side of the segment's midpoint, perpendicular to
-// it, and the winding of each operand at those points is found by a downward ray. Sampling
-// perpendicular to the edge (rather than straight up/down) is what makes vertical and horizontal edges
-// classify correctly — a purely y-based below/above test is degenerate for vertical edges.
-function classifySegments(unique, operation, fillRule) {
-    const kept = [];
-    for (const seg of unique) {
-        const mx = (seg.ax + seg.bx) / 2;
-        const my = (seg.ay + seg.by) / 2;
-        const dx = seg.bx - seg.ax;
-        const dy = seg.by - seg.ay;
-        const len = Math.hypot(dx, dy);
-        if (len === 0)
-            continue;
-        // Left normal of the lex-ordered direction A→B (math y-up: rotate +90°). Offset well inside the
-        // segment's own clear zone — other segments only meet it at its endpoints.
-        const eps = len * 1e-4;
-        const nlx = (-dy / len) * eps;
-        const nly = (dx / len) * eps;
-        const leftInSubject = isInside(windingAt(unique, mx + nlx, my + nly, true), fillRule);
-        const leftInClip = isInside(windingAt(unique, mx + nlx, my + nly, false), fillRule);
-        const rightInSubject = isInside(windingAt(unique, mx - nlx, my - nly, true), fillRule);
-        const rightInClip = isInside(windingAt(unique, mx - nlx, my - nly, false), fillRule);
-        const filledLeft = combine(operation, leftInSubject, leftInClip);
-        const filledRight = combine(operation, rightInSubject, rightInClip);
-        if (filledLeft === filledRight)
-            continue;
-        // Direct the edge so the kept region is on its left.
-        if (filledLeft)
-            kept.push([seg.ax, seg.ay, seg.bx, seg.by]);
-        else
-            kept.push([seg.bx, seg.by, seg.ax, seg.ay]);
     }
-    return kept;
+    return true;
+}
+function traceRings(edges, vertexSnap) {
+    let keys = [];
+    for (const e of edges) {
+        keys.push(snap(e[0], vertexSnap));
+        keys.push(snap(e[1], vertexSnap));
+        keys.push(snap(e[2], vertexSnap));
+        keys.push(snap(e[3], vertexSnap));
+    }
+    const ids = firstOccurrenceIds(keys, 2);
+    let graph = directedGraphNew();
+    for (let index = 0; index < edges.length; index += 1) {
+        directedGraphAddEdge(graph, ids[index * 2], ids[index * 2 + 1], edges[index]);
+    }
+    return directedGraphTraceRings(graph);
 }
-// Winding number of one operand at (px, py): the signed sum of the winding deltas of every segment that
-// the downward vertical ray from the point crosses (a segment strictly spanning px whose y at px lies
-// below py).
+/**
+ * Winding number of one operand at (px, py).
+ */
 function windingAt(unique, px, py, subject) {
     let winding = 0;
     for (const v of unique) {
         const lox = Math.min(v.ax, v.bx);
         const hix = Math.max(v.ax, v.bx);
-        // Half-open x-interval so a ray passing exactly through a shared vertex counts exactly one of the
-        // two edges meeting there (the one that starts at px, not the one that ends at it).
-        if (px < lox || px >= hix)
+        if (px < lox || px >= hix) {
             continue;
+        }
         const t = (px - v.ax) / (v.bx - v.ax);
         const yAt = v.ay + t * (v.by - v.ay);
-        if (yAt < py)
+        if (yAt < py) {
             winding += subject ? v.subjectDelta : v.clipDelta;
-    }
-    return winding;
-}
-function combine(operation, inSubject, inClip) {
-    switch (operation) {
-        case 'union':
-            return inSubject || inClip;
-        case 'intersection':
-            return inSubject && inClip;
-        case 'difference':
-            return inSubject && !inClip;
-        case 'xor':
-            return inSubject !== inClip;
-    }
-}
-function isInside(winding, fillRule) {
-    switch (fillRule) {
-        case 'evenOdd':
-            return (Math.abs(winding) & 1) === 1;
-        case 'positive':
-            return winding > 0;
-        case 'negative':
-            return winding < 0;
-        default:
-            return winding !== 0;
-    }
-}
-// Scene2D 2c: chain the directed, fill-on-left edges into closed rings. At a vertex shared by several
-// rings, the next edge is the one turning most clockwise from the reversed incoming direction, which
-// keeps the retained region continuously on the left.
-function traceRings(edges) {
-    const graph = new DirectedGraph();
-    for (const e of edges)
-        graph.addEdge(e[0], e[1], e[2], e[3]);
-    return graph.traceRings();
-}
-function approxEqual(a, b) {
-    return Math.abs(a - b) <= vertexSnap;
-}
-// Derives the vertex-merge grid size from the largest coordinate span across both operands, so the
-// snap tolerance tracks the input's magnitude. Zero/degenerate extent falls back to a fixed absolute.
-function computeVertexSnap(subject, clip) {
-    let minX = Infinity;
-    let minY = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    for (const contours of [subject, clip]) {
-        for (const contour of contours) {
-            for (let i = 0; i < contour.length; i += 2) {
-                const x = contour[i];
-                const y = contour[i + 1];
-                if (x < minX)
-                    minX = x;
-                if (x > maxX)
-                    maxX = x;
-                if (y < minY)
-                    minY = y;
-                if (y > maxY)
-                    maxY = y;
-            }
-        }
-    }
-    const extent = Math.max(maxX - minX, maxY - minY);
-    return extent > 0 ? extent * VERTEX_SNAP_RELATIVE : VERTEX_SNAP_FALLBACK;
-}
-function snap(v) {
-    return Math.round(v / vertexSnap);
-}
-// Directed graph of the kept boundary edges. Each directed edge is consumed once; ring closure and
-// vertex sharing are handled by angular next-edge selection.
-class DirectedGraph {
-    keys = new Map();
-    xs = [];
-    ys = [];
-    outgoing = [];
-    edgeTo = [];
-    edgeFrom = [];
-    used = [];
-    addEdge(fromX, fromY, toX, toY) {
-        const from = this.vertex(fromX, fromY);
-        const to = this.vertex(toX, toY);
-        if (from === to)
-            return;
-        const edge = this.edgeFrom.length;
-        this.edgeFrom.push(from);
-        this.edgeTo.push(to);
-        this.used.push(false);
-        this.outgoing[from].push(edge);
-    }
-    traceRings() {
-        const rings = [];
-        for (let start = 0; start < this.edgeFrom.length; start++) {
-            if (this.used[start])
-                continue;
-            const ring = this.walk(start);
-            if (ring !== null && ring.length >= 6)
-                rings.push(ring);
-        }
-        return rings;
-    }
-    walk(startEdge) {
-        const ring = [];
-        let edge = startEdge;
-        let guard = 0;
-        const limit = this.edgeFrom.length + 2;
-        while (guard++ < limit) {
-            this.used[edge] = true;
-            const from = this.edgeFrom[edge];
-            ring.push(this.xs[from], this.ys[from]);
-            const to = this.edgeTo[edge];
-            const next = this.nextEdge(to, from);
-            if (next === -1 || next === startEdge || this.used[next])
-                break;
-            edge = next;
-        }
-        return ring;
-    }
-    // At vertex `at`, arriving from `cameFrom`, pick the unused outgoing edge that turns most clockwise
-    // from the reversed incoming direction — the walk that keeps the retained region on the left.
-    nextEdge(at, cameFrom) {
-        const incomingAngle = Math.atan2(this.ys[cameFrom] - this.ys[at], this.xs[cameFrom] - this.xs[at]);
-        let best = -1;
-        let bestGap = Infinity;
-        for (const edge of this.outgoing[at]) {
-            if (this.used[edge])
-                continue;
-            const to = this.edgeTo[edge];
-            const angle = Math.atan2(this.ys[to] - this.ys[at], this.xs[to] - this.xs[at]);
-            let gap = incomingAngle - angle;
-            while (gap <= 0)
-                gap += Math.PI * 2;
-            while (gap > Math.PI * 2)
-                gap -= Math.PI * 2;
-            if (gap < bestGap) {
-                bestGap = gap;
-                best = edge;
-            }
-        }
-        return best;
-    }
-    vertex(x, y) {
-        const key = `${snap(x)},${snap(y)}`;
-        const existing = this.keys.get(key);
-        if (existing !== undefined)
-            return existing;
-        const index = this.xs.length;
-        this.keys.set(key, index);
-        this.xs.push(x);
-        this.ys.push(y);
-        this.outgoing.push([]);
-        return index;
-    }
-}
-// Binary min-heap over sweep events ordered by compareEvents.
-class EventHeap {
-    data = [];
-    isEmpty() {
-        return this.data.length === 0;
-    }
-    push(event) {
-        const data = this.data;
-        data.push(event);
-        let i = data.length - 1;
-        while (i > 0) {
-            const parent = (i - 1) >> 1;
-            if (compareEvents(data[i], data[parent]) < 0) {
-                swap(data, i, parent);
-                i = parent;
-            }
-            else
-                break;
         }
     }
-    pop() {
-        const data = this.data;
-        const top = data[0];
-        const last = data.pop();
-        if (data.length > 0) {
-            data[0] = last;
-            let i = 0;
-            const n = data.length;
-            for (;;) {
-                const left = i * 2 + 1;
-                const right = left + 1;
-                let smallest = i;
-                if (left < n && compareEvents(data[left], data[smallest]) < 0)
-                    smallest = left;
-                if (right < n && compareEvents(data[right], data[smallest]) < 0)
-                    smallest = right;
-                if (smallest === i)
-                    break;
-                swap(data, i, smallest);
-                i = smallest;
-            }
-        }
-        return top;
-    }
-}
-function swap(data, i, j) {
-    const tmp = data[i];
-    data[i] = data[j];
-    data[j] = tmp;
+    return winding;
 }
 //# sourceMappingURL=martinezKernel.js.map