three-text 0.4.10 → 0.4.11

package/dist/index.js

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.4.10
+ * three-text v0.4.11
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -3127,117 +3127,33 @@ class BoundaryClusterer {
     }
 }
 
-class MinHeap {
-    constructor(compare) {
-        this.heap = [];
-        this.itemIndex = new Map();
-        this.compare = compare;
-    }
-    insert(value) {
-        const existingIndex = this.itemIndex.get(value);
-        if (existingIndex !== undefined) {
-            // Already exists - update in place
-            this.siftUp(existingIndex);
-            this.siftDown(existingIndex);
-            return;
-        }
-        const index = this.heap.length;
-        this.heap.push(value);
-        this.itemIndex.set(value, index);
-        this.siftUp(index);
-    }
-    extractMin() {
-        const heapLength = this.heap.length;
-        if (!heapLength)
-            return undefined;
-        if (heapLength === 1) {
-            const min = this.heap.pop();
-            this.itemIndex.clear();
-            return min;
-        }
-        const min = this.heap[0];
-        const last = this.heap.pop();
-        this.heap[0] = last;
-        this.itemIndex.delete(min);
-        this.itemIndex.set(last, 0);
-        this.siftDown(0);
-        return min;
-    }
-    update(value) {
-        const index = this.itemIndex.get(value);
-        if (index === undefined) {
-            this.insert(value);
-            return;
-        }
-        // Percolate in both directions - one will terminate immediately
-        this.siftUp(index);
-        this.siftDown(index);
-    }
-    isEmpty() {
-        return !this.heap.length;
-    }
-    swap(i, j) {
-        const itemI = this.heap[i];
-        const itemJ = this.heap[j];
-        this.heap[i] = itemJ;
-        this.heap[j] = itemI;
-        this.itemIndex.set(itemI, j);
-        this.itemIndex.set(itemJ, i);
-    }
-    siftUp(i) {
-        const item = this.heap[i];
-        while (i > 0) {
-            const parentIndex = (i - 1) >> 1; // Bit shift for fast division by 2
-            const parent = this.heap[parentIndex];
-            // Early exit if heap property satisfied
-            if (this.compare(item, parent) >= 0)
-                break;
-            // Move parent down
-            this.heap[i] = parent;
-            this.itemIndex.set(parent, i);
-            i = parentIndex;
-        }
-        this.heap[i] = item;
-        this.itemIndex.set(item, i);
-    }
-    siftDown(i) {
-        const item = this.heap[i];
-        const heapLength = this.heap.length;
-        const halfLength = heapLength >> 1; // Only nodes in first half can have children
-        while (i < halfLength) {
-            const leftIndex = (i << 1) + 1; // Bit shift for fast multiplication by 2
-            const rightIndex = leftIndex + 1;
-            let smallestIndex = i;
-            let smallest = item;
-            const left = this.heap[leftIndex];
-            if (this.compare(left, smallest) < 0) {
-                smallestIndex = leftIndex;
-                smallest = left;
-            }
-            if (rightIndex < heapLength) {
-                const right = this.heap[rightIndex];
-                if (this.compare(right, smallest) < 0) {
-                    smallestIndex = rightIndex;
-                    smallest = right;
-                }
-            }
-            // Early exit if heap property satisfied
-            if (smallestIndex === i)
-                break;
-            // Move smallest child up
-            this.heap[i] = smallest;
-            this.itemIndex.set(smallest, i);
-            i = smallestIndex;
-        }
-        this.heap[i] = item;
-        this.itemIndex.set(item, i);
-    }
-}
-
 const DEFAULT_OPTIMIZATION_CONFIG = {
     enabled: true,
-    areaThreshold: 1.0 // Remove triangles smaller than 1 square font unit
+    areaThreshold: 1.0
 };
+// Scratch buffers reused across calls. Grown on demand, never shrunk
+let _cap = 1024;
+let _px = new Float64Array(_cap);
+let _py = new Float64Array(_cap);
+let _area = new Float64Array(_cap);
+let _prev = new Int32Array(_cap);
+let _next = new Int32Array(_cap);
+let _heap = new Int32Array(_cap);
+let _hpos = new Int32Array(_cap);
+function ensureCap(n) {
+    if (n <= _cap)
+        return;
+    _cap = 1;
+    while (_cap < n)
+        _cap <<= 1;
+    _px = new Float64Array(_cap);
+    _py = new Float64Array(_cap);
+    _area = new Float64Array(_cap);
+    _prev = new Int32Array(_cap);
+    _next = new Int32Array(_cap);
+    _heap = new Int32Array(_cap);
+    _hpos = new Int32Array(_cap);
+}
 class PathOptimizer {
     constructor(config) {
         this.stats = {
@@ -3250,85 +3166,26 @@ class PathOptimizer {
         this.config = config;
     }
     optimizePath(path) {
-        if (path.points.length <= 2) {
-            return path;
-        }
-        if (!this.config.enabled) {
-            return path;
-        }
-        this.stats.originalPointCount += path.points.length;
-        // Most paths are already immutable after collection; avoid copying large point arrays
-        // The optimizers below never mutate the input `points` array
         const points = path.points;
-        if (points.length < 5) {
+        const n = points.length;
+        if (n < 5 || !this.config.enabled) {
+            if (this.config.enabled)
+                this.stats.originalPointCount += n;
             return path;
         }
-        let optimized = points;
-        // Visvalingam-Whyatt simplification
-        optimized = this.simplifyPathVW(optimized, this.config.areaThreshold);
-        if (optimized.length < 3) {
+        this.stats.originalPointCount += n;
+        const removed = simplifyVW(points, n, this.config.areaThreshold);
+        if (removed === 0)
             return path;
+        this.stats.pointsRemovedByVisvalingam += removed;
+        const result = new Array(n - removed);
+        let idx = 0;
+        let out = 0;
+        while (idx >= 0) {
+            result[out++] = points[idx];
+            idx = _next[idx];
         }
-        return {
-            ...path,
-            points: optimized
-        };
-    }
-    // Visvalingam-Whyatt algorithm
-    simplifyPathVW(points, areaThreshold) {
-        if (points.length <= 3)
-            return points;
-        const originalLength = points.length;
-        const minPoints = 3;
-        const pointList = points.map((p, i) => ({
-            index: i,
-            area: Infinity,
-            prev: null,
-            next: null
-        }));
-        for (let i = 0; i < pointList.length; i++) {
-            pointList[i].prev = pointList[i - 1] || null;
-            pointList[i].next = pointList[i + 1] || null;
-        }
-        const heap = new MinHeap((a, b) => a.area - b.area);
-        for (let i = 1; i < pointList.length - 1; i++) {
-            const p = pointList[i];
-            p.area = this.calculateTriangleArea(points[p.prev.index], points[p.index], points[p.next.index]);
-            heap.insert(p);
-        }
-        let remainingPoints = originalLength;
-        while (!heap.isEmpty() && remainingPoints > minPoints) {
-            const p = heap.extractMin();
-            if (!p || p.area > areaThreshold) {
-                break;
-            }
-            if (p.prev)
-                p.prev.next = p.next;
-            if (p.next)
-                p.next.prev = p.prev;
-            remainingPoints--;
-            if (p.prev && p.prev.prev) {
-                p.prev.area = this.calculateTriangleArea(points[p.prev.prev.index], points[p.prev.index], points[p.next.index]);
-                heap.update(p.prev);
-            }
-            if (p.next && p.next.next) {
-                p.next.area = this.calculateTriangleArea(points[p.prev.index], points[p.next.index], points[p.next.next.index]);
-                heap.update(p.next);
-            }
-        }
-        const simplifiedPoints = [];
-        let current = pointList[0];
-        while (current) {
-            simplifiedPoints.push(points[current.index]);
-            current = current.next;
-        }
-        const pointsRemoved = originalLength - simplifiedPoints.length;
-        this.stats.pointsRemovedByVisvalingam += pointsRemoved;
-        return simplifiedPoints;
-    }
-    // Shoelace formula
-    calculateTriangleArea(p1, p2, p3) {
-        return Math.abs((p1.x * (p2.y - p3.y) + p2.x * (p3.y - p1.y) + p3.x * (p1.y - p2.y)) / 2);
+        return { ...path, points: result };
     }
     getStats() {
         return { ...this.stats };
@@ -3340,6 +3197,158 @@ class PathOptimizer {
         };
     }
 }
+// Visvalingam-Whyatt simplification. Iteratively removes the point
+// whose removal causes the smallest change in contour area (measured
+// as the triangle formed with its two neighbors) until all remaining
+// triangles exceed areaThreshold
+//
+// Uses parallel typed arrays for the linked list and a binary min-heap
+// with an index-based position map for O(log n) extract and update.
+// Coordinates are flattened into Float64Array to keep area computation
+// on contiguous memory. Areas are stored as 2x actual (skipping the
+// shoelace /2) and the threshold is doubled to match
+//
+// Returns the number of points removed. The caller reads _next[] to
+// walk the surviving linked list
+function simplifyVW(points, n, areaThreshold) {
+    if (n <= 3)
+        return 0;
+    ensureCap(n);
+    const px = _px;
+    const py = _py;
+    const area = _area;
+    const prev = _prev;
+    const next = _next;
+    const heap = _heap;
+    const hpos = _hpos;
+    // Flatten coordinates and initialize doubly-linked list
+    for (let i = 0; i < n; i++) {
+        const p = points[i];
+        px[i] = p.x;
+        py[i] = p.y;
+        prev[i] = i - 1;
+        next[i] = i + 1;
+    }
+    next[n - 1] = -1;
+    // Compute triangle areas for interior points and seed the heap
+    const heapLen0 = n - 2;
+    area[0] = Infinity;
+    area[n - 1] = Infinity;
+    for (let i = 1; i < n - 1; i++) {
+        area[i] = area2x(px, py, i - 1, i, i + 1);
+        heap[i - 1] = i;
+        hpos[i] = i - 1;
+    }
+    hpos[0] = -1;
+    hpos[n - 1] = -1;
+    // Bottom-up heapify, O(n)
+    let heapLen = heapLen0;
+    for (let i = (heapLen >> 1) - 1; i >= 0; i--) {
+        siftDown(heap, hpos, area, i, heapLen);
+    }
+    const threshold2x = areaThreshold * 2;
+    const maxRemovals = n - 3;
+    let removed = 0;
+    while (heapLen > 0 && removed < maxRemovals) {
+        const minIdx = heap[0];
+        if (area[minIdx] > threshold2x)
+            break;
+        // Extract min
+        heapLen--;
+        if (heapLen > 0) {
+            const last = heap[heapLen];
+            heap[0] = last;
+            hpos[last] = 0;
+            siftDown(heap, hpos, area, 0, heapLen);
+        }
+        hpos[minIdx] = -1;
+        // Unlink
+        const pi = prev[minIdx];
+        const ni = next[minIdx];
+        if (pi >= 0)
+            next[pi] = ni;
+        if (ni >= 0)
+            prev[ni] = pi;
+        removed++;
+        // Recompute prev neighbor's area and update heap position
+        if (pi >= 0 && prev[pi] >= 0) {
+            const oldArea = area[pi];
+            const newArea = area2x(px, py, prev[pi], pi, ni);
+            area[pi] = newArea;
+            const pos = hpos[pi];
+            if (pos >= 0) {
+                if (newArea < oldArea)
+                    siftUp(heap, hpos, area, pos);
+                else if (newArea > oldArea)
+                    siftDown(heap, hpos, area, pos, heapLen);
+            }
+        }
+        // Same for next neighbor
+        if (ni >= 0 && next[ni] >= 0) {
+            const oldArea = area[ni];
+            const newArea = area2x(px, py, pi, ni, next[ni]);
+            area[ni] = newArea;
+            const pos = hpos[ni];
+            if (pos >= 0) {
+                if (newArea < oldArea)
+                    siftUp(heap, hpos, area, pos);
+                else if (newArea > oldArea)
+                    siftDown(heap, hpos, area, pos, heapLen);
+            }
+        }
+    }
+    return removed;
+}
+function siftUp(heap, hpos, area, i) {
+    const idx = heap[i];
+    const val = area[idx];
+    while (i > 0) {
+        const parent = (i - 1) >> 1;
+        const pidx = heap[parent];
+        if (area[pidx] <= val)
+            break;
+        heap[i] = pidx;
+        hpos[pidx] = i;
+        i = parent;
+    }
+    heap[i] = idx;
+    hpos[idx] = i;
+}
+function siftDown(heap, hpos, area, i, len) {
+    const idx = heap[i];
+    const val = area[idx];
+    const half = len >> 1;
+    while (i < half) {
+        let child = (i << 1) + 1;
+        let childIdx = heap[child];
+        let childVal = area[childIdx];
+        const right = child + 1;
+        if (right < len) {
+            const rIdx = heap[right];
+            const rVal = area[rIdx];
+            if (rVal < childVal) {
+                child = right;
+                childIdx = rIdx;
+                childVal = rVal;
+            }
+        }
+        if (childVal >= val)
+            break;
+        heap[i] = childIdx;
+        hpos[childIdx] = i;
+        i = child;
+    }
+    heap[i] = idx;
+    hpos[idx] = i;
+}
+// Doubled triangle area via the shoelace formula. Skipping the /2
+// means callers compare against a doubled threshold instead
+function area2x(px, py, i1, i2, i3) {
+    const v = px[i1] * (py[i2] - py[i3]) +
+        px[i2] * (py[i3] - py[i1]) +
+        px[i3] * (py[i1] - py[i2]);
+    return v < 0 ? -v : v;
+}
 
 /**
  * @license
@@ -3380,23 +3389,314 @@ class PathOptimizer {
  */
 const DEFAULT_CURVE_FIDELITY = {
     distanceTolerance: 0.5,
-    angleTolerance: 0.2 // ~11.5 degrees
+    angleTolerance: 0.2,
+    cuspLimit: 0,
+    collinearityEpsilon: 1e-6,
+    recursionLimit: 16
 };
-const COLLINEARITY_EPSILON = 1e-6;
-const RECURSION_LIMIT = 16;
+const COLLINEARITY_EPSILON = DEFAULT_CURVE_FIDELITY.collinearityEpsilon;
+// Module-level state for the recursive subdivision functions,
+// set from instance config before each polygonize call
+// Output array, reset before each polygonize call
+let _out;
+// Cached tolerance state
+let _distTolSq = 0;
+let _colEps = 0;
+let _maxLvl = 0;
+let _angleTol = 0;
+let _tanAngSq = 0;
+let _cuspLim = 0;
+let _tanCuspSq = 0;
+// Collinearity checks in the recursive core prevent near-duplicate points
+function emit(x, y) {
+    _out.push(new Vec2(x, y));
+}
+// Quadratic recursive subdivision (AGG curve3_div)
+function quadRec(x1, y1, x2, y2, x3, y3, level) {
+    if (level > _maxLvl)
+        return;
+    const x12 = (x1 + x2) * 0.5;
+    const y12 = (y1 + y2) * 0.5;
+    const x23 = (x2 + x3) * 0.5;
+    const y23 = (y2 + y3) * 0.5;
+    const x123 = (x12 + x23) * 0.5;
+    const y123 = (y12 + y23) * 0.5;
+    const dx = x3 - x1;
+    const dy = y3 - y1;
+    let d = Math.abs((x2 - x3) * dy - (y2 - y3) * dx);
+    if (d > _colEps) {
+        if (d * d <= _distTolSq * (dx * dx + dy * dy)) {
+            if (_angleTol > 0) {
+                const v1x = x2 - x1;
+                const v1y = y2 - y1;
+                const v2x = x3 - x2;
+                const v2y = y3 - y2;
+                const cross = v1x * v2y - v1y * v2x;
+                const dot = v1x * v2x + v1y * v2y;
+                if (dot > 0 && cross * cross < _tanAngSq * dot * dot) {
+                    emit(x123, y123);
+                    return;
+                }
+            }
+            else {
+                emit(x123, y123);
+                return;
+            }
+        }
+    }
+    else {
+        let da = dx * dx + dy * dy;
+        if (da === 0) {
+            d = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+        }
+        else {
+            d = ((x2 - x1) * dx + (y2 - y1) * dy) / da;
+            if (d > 0 && d < 1)
+                return;
+            if (d <= 0)
+                d = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+            else if (d >= 1)
+                d = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3);
+            else {
+                const px = x1 + d * dx;
+                const py = y1 + d * dy;
+                d = (x2 - px) * (x2 - px) + (y2 - py) * (y2 - py);
+            }
+        }
+        if (d < _distTolSq) {
+            emit(x2, y2);
+            return;
+        }
+    }
+    const nl = level + 1;
+    quadRec(x1, y1, x12, y12, x123, y123, nl);
+    quadRec(x123, y123, x23, y23, x3, y3, nl);
+}
+// Cubic recursive subdivision (AGG curve4_div)
+// cubicBegin handles level 0, which always subdivides
+function cubicBegin(x1, y1, x2, y2, x3, y3, x4, y4) {
+    const x12 = (x1 + x2) * 0.5;
+    const y12 = (y1 + y2) * 0.5;
+    const x23 = (x2 + x3) * 0.5;
+    const y23 = (y2 + y3) * 0.5;
+    const x34 = (x3 + x4) * 0.5;
+    const y34 = (y3 + y4) * 0.5;
+    const x123 = (x12 + x23) * 0.5;
+    const y123 = (y12 + y23) * 0.5;
+    const x234 = (x23 + x34) * 0.5;
+    const y234 = (y23 + y34) * 0.5;
+    const x1234 = (x123 + x234) * 0.5;
+    const y1234 = (y123 + y234) * 0.5;
+    cubicRec(x1, y1, x12, y12, x123, y123, x1234, y1234, 1);
+    cubicRec(x1234, y1234, x234, y234, x34, y34, x4, y4, 1);
+}
+function cubicRec(x1, y1, x2, y2, x3, y3, x4, y4, level) {
+    if (level > _maxLvl)
+        return;
+    const x12 = (x1 + x2) * 0.5;
+    const y12 = (y1 + y2) * 0.5;
+    const x23 = (x2 + x3) * 0.5;
+    const y23 = (y2 + y3) * 0.5;
+    const x34 = (x3 + x4) * 0.5;
+    const y34 = (y3 + y4) * 0.5;
+    const x123 = (x12 + x23) * 0.5;
+    const y123 = (y12 + y23) * 0.5;
+    const x234 = (x23 + x34) * 0.5;
+    const y234 = (y23 + y34) * 0.5;
+    const x1234 = (x123 + x234) * 0.5;
+    const y1234 = (y123 + y234) * 0.5;
+    const dx = x4 - x1;
+    const dy = y4 - y1;
+    let d2 = Math.abs((x2 - x4) * dy - (y2 - y4) * dx);
+    let d3 = Math.abs((x3 - x4) * dy - (y3 - y4) * dx);
+    const sc = (d2 > _colEps ? 2 : 0) + (d3 > _colEps ? 1 : 0);
+    switch (sc) {
+        case 0: {
+            let k = dx * dx + dy * dy;
+            if (k === 0) {
+                d2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+                d3 = (x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1);
+            }
+            else {
+                k = 1 / k;
+                let t1 = x2 - x1;
+                let t2 = y2 - y1;
+                d2 = k * (t1 * dx + t2 * dy);
+                t1 = x3 - x1;
+                t2 = y3 - y1;
+                d3 = k * (t1 * dx + t2 * dy);
+                if (d2 > 0 && d2 < 1 && d3 > 0 && d3 < 1)
+                    return;
+                if (d2 <= 0)
+                    d2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+                else if (d2 >= 1)
+                    d2 = (x2 - x4) * (x2 - x4) + (y2 - y4) * (y2 - y4);
+                else {
+                    const px = x1 + d2 * dx, py = y1 + d2 * dy;
+                    d2 = (x2 - px) * (x2 - px) + (y2 - py) * (y2 - py);
+                }
+                if (d3 <= 0)
+                    d3 = (x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1);
+                else if (d3 >= 1)
+                    d3 = (x3 - x4) * (x3 - x4) + (y3 - y4) * (y3 - y4);
+                else {
+                    const px = x1 + d3 * dx, py = y1 + d3 * dy;
+                    d3 = (x3 - px) * (x3 - px) + (y3 - py) * (y3 - py);
+                }
+            }
+            if (d2 > d3) {
+                if (d2 < _distTolSq) {
+                    emit(x2, y2);
+                    return;
+                }
+            }
+            else {
+                if (d3 < _distTolSq) {
+                    emit(x3, y3);
+                    return;
+                }
+            }
+            break;
+        }
+        case 1:
+            if (d3 * d3 <= _distTolSq * (dx * dx + dy * dy)) {
+                if (_angleTol > 0) {
+                    const v1x = x3 - x2, v1y = y3 - y2;
+                    const v2x = x4 - x3, v2y = y4 - y3;
+                    const cross = v1x * v2y - v1y * v2x;
+                    const dot = v1x * v2x + v1y * v2y;
+                    if (dot > 0 && cross * cross < _tanAngSq * dot * dot) {
+                        emit(x2, y2);
+                        emit(x3, y3);
+                        return;
+                    }
+                    if (_cuspLim > 0 &&
+                        (dot <= 0 || cross * cross > _tanCuspSq * dot * dot)) {
+                        emit(x3, y3);
+                        return;
+                    }
+                }
+                else {
+                    emit(x23, y23);
+                    return;
+                }
+            }
+            break;
+        case 2:
+            if (d2 * d2 <= _distTolSq * (dx * dx + dy * dy)) {
+                if (_angleTol > 0) {
+                    const v1x = x2 - x1, v1y = y2 - y1;
+                    const v2x = x3 - x2, v2y = y3 - y2;
+                    const cross = v1x * v2y - v1y * v2x;
+                    const dot = v1x * v2x + v1y * v2y;
+                    if (dot > 0 && cross * cross < _tanAngSq * dot * dot) {
+                        emit(x2, y2);
+                        emit(x3, y3);
+                        return;
+                    }
+                    if (_cuspLim > 0 &&
+                        (dot <= 0 || cross * cross > _tanCuspSq * dot * dot)) {
+                        emit(x2, y2);
+                        return;
+                    }
+                }
+                else {
+                    emit(x23, y23);
+                    return;
+                }
+            }
+            break;
+        case 3: {
+            if ((d2 + d3) * (d2 + d3) <= _distTolSq * (dx * dx + dy * dy)) {
+                if (_angleTol > 0) {
+                    const a1x = x2 - x1, a1y = y2 - y1;
+                    const a2x = x3 - x2, a2y = y3 - y2;
+                    const c1 = a1x * a2y - a1y * a2x;
+                    const dot1 = a1x * a2x + a1y * a2y;
+                    const b2x = x4 - x3, b2y = y4 - y3;
+                    const c2 = a2x * b2y - a2y * b2x;
+                    const dot2 = a2x * b2x + a2y * b2y;
+                    // Sum of unsigned angles via tangent addition identity
+                    if (dot1 > 0 && dot2 > 0) {
+                        const ac1 = c1 < 0 ? -c1 : c1;
+                        const ac2 = c2 < 0 ? -c2 : c2;
+                        const cc = ac1 * dot2 + ac2 * dot1;
+                        const cd = dot1 * dot2 - ac1 * ac2;
+                        if (cd > 0 && cc * cc < _tanAngSq * cd * cd) {
+                            emit(x23, y23);
+                            return;
+                        }
+                    }
+                    if (_cuspLim > 0) {
+                        if (dot1 <= 0 || c1 * c1 > _tanCuspSq * dot1 * dot1) {
+                            emit(x2, y2);
+                            return;
+                        }
+                        if (dot2 <= 0 || c2 * c2 > _tanCuspSq * dot2 * dot2) {
+                            emit(x3, y3);
+                            return;
+                        }
+                    }
+                }
+                else {
+                    emit(x23, y23);
+                    return;
+                }
+            }
+            break;
+        }
+    }
+    const nl = level + 1;
+    cubicRec(x1, y1, x12, y12, x123, y123, x1234, y1234, nl);
+    cubicRec(x1234, y1234, x234, y234, x34, y34, x4, y4, nl);
+}
 class Polygonizer {
     constructor(curveFidelityConfig) {
         this.curveSteps = null;
+        // Precomputed tolerances
+        this._distTolSq = 0;
+        this._angleTol = 0;
+        this._tanAngSq = 0;
+        this._cuspLim = 0;
+        this._tanCuspSq = 0;
+        this._colEps = 0;
+        this._maxLvl = 0;
         this.curveFidelityConfig = {
             ...DEFAULT_CURVE_FIDELITY,
             ...curveFidelityConfig
         };
+        this.precompute();
     }
     setCurveFidelityConfig(curveFidelityConfig) {
         this.curveFidelityConfig = {
             ...DEFAULT_CURVE_FIDELITY,
             ...curveFidelityConfig
         };
+        this.precompute();
+    }
+    precompute() {
+        const c = this.curveFidelityConfig;
+        const dt = c.distanceTolerance ?? DEFAULT_CURVE_FIDELITY.distanceTolerance;
+        this._distTolSq = dt * dt;
+        this._angleTol = c.angleTolerance ?? DEFAULT_CURVE_FIDELITY.angleTolerance;
+        this._tanAngSq = this._angleTol > 0
+            ? Math.tan(this._angleTol) ** 2 : 0;
+        this._cuspLim = c.cuspLimit ?? 0;
+        this._tanCuspSq = this._cuspLim > 0
+            ? Math.tan(this._cuspLim) ** 2 : 0;
+        this._colEps = c.collinearityEpsilon ?? DEFAULT_CURVE_FIDELITY.collinearityEpsilon;
+        this._maxLvl = c.recursionLimit ?? DEFAULT_CURVE_FIDELITY.recursionLimit;
+    }
+    // Set module-level state from instance tolerances
+    activate() {
+        _distTolSq = this._distTolSq;
+        _angleTol = this._angleTol;
+        _tanAngSq = this._tanAngSq;
+        _cuspLim = this._cuspLim;
+        _tanCuspSq = this._tanCuspSq;
+        _colEps = this._colEps;
+        _maxLvl = this._maxLvl;
+        _out = [];
     }
     // Fixed-step subdivision; overrides adaptive curveFidelity when set
     setCurveSteps(curveSteps) {
@@ -3415,280 +3715,49 @@ class Polygonizer {
         if (this.curveSteps !== null) {
             return this.polygonizeQuadraticFixedSteps(start, control, end, this.curveSteps);
         }
-        const points = [];
-        this.recursiveQuadratic(start.x, start.y, control.x, control.y, end.x, end.y, points);
-        this.addPoint(end.x, end.y, points);
-        return points;
+        this.activate();
+        quadRec(start.x, start.y, control.x, control.y, end.x, end.y, 0);
+        emit(end.x, end.y);
+        return _out;
     }
     polygonizeCubic(start, control1, control2, end) {
         if (this.curveSteps !== null) {
             return this.polygonizeCubicFixedSteps(start, control1, control2, end, this.curveSteps);
         }
-        const points = [];
-        this.recursiveCubic(start.x, start.y, control1.x, control1.y, control2.x, control2.y, end.x, end.y, points);
-        this.addPoint(end.x, end.y, points);
-        return points;
-    }
-    lerp(a, b, t) {
-        return a + (b - a) * t;
+        this.activate();
+        cubicBegin(start.x, start.y, control1.x, control1.y, control2.x, control2.y, end.x, end.y);
+        emit(end.x, end.y);
+        return _out;
     }
     polygonizeQuadraticFixedSteps(start, control, end, steps) {
-        const points = [];
-        // Emit intermediate points; caller already has start
+        this.activate();
         for (let i = 1; i <= steps; i++) {
             const t = i / steps;
-            const x12 = this.lerp(start.x, control.x, t);
-            const y12 = this.lerp(start.y, control.y, t);
-            const x23 = this.lerp(control.x, end.x, t);
-            const y23 = this.lerp(control.y, end.y, t);
-            const x = this.lerp(x12, x23, t);
-            const y = this.lerp(y12, y23, t);
-            this.addPoint(x, y, points);
+            const x12 = start.x + (control.x - start.x) * t;
+            const y12 = start.y + (control.y - start.y) * t;
+            const x23 = control.x + (end.x - control.x) * t;
+            const y23 = control.y + (end.y - control.y) * t;
+            emit(x12 + (x23 - x12) * t, y12 + (y23 - y12) * t);
         }
-        return points;
+        return _out;
     }
     polygonizeCubicFixedSteps(start, control1, control2, end, steps) {
-        const points = [];
-        // Emit intermediate points; caller already has start
+        this.activate();
         for (let i = 1; i <= steps; i++) {
             const t = i / steps;
-            // De Casteljau
-            const x12 = this.lerp(start.x, control1.x, t);
-            const y12 = this.lerp(start.y, control1.y, t);
-            const x23 = this.lerp(control1.x, control2.x, t);
-            const y23 = this.lerp(control1.y, control2.y, t);
-            const x34 = this.lerp(control2.x, end.x, t);
-            const y34 = this.lerp(control2.y, end.y, t);
-            const x123 = this.lerp(x12, x23, t);
-            const y123 = this.lerp(y12, y23, t);
-            const x234 = this.lerp(x23, x34, t);
-            const y234 = this.lerp(y23, y34, t);
-            const x = this.lerp(x123, x234, t);
-            const y = this.lerp(y123, y234, t);
-            this.addPoint(x, y, points);
-        }
-        return points;
-    }
-    recursiveQuadratic(x1, y1, x2, y2, x3, y3, points, level = 0) {
-        if (level > RECURSION_LIMIT)
-            return;
-        // De Casteljau subdivision: split the curve at t=0.5
-        // First calculate midpoints of the two line segments
-        const x12 = (x1 + x2) / 2;
-        const y12 = (y1 + y2) / 2;
-        const x23 = (x2 + x3) / 2;
-        const y23 = (y2 + y3) / 2;
-        // Then find the midpoint of those midpoints - this is the curve point at t=0.5
-        const x123 = (x12 + x23) / 2;
-        const y123 = (y12 + y23) / 2;
-        const dx = x3 - x1;
-        const dy = y3 - y1;
-        const d = Math.abs((x2 - x3) * dy - (y2 - y3) * dx);
-        const baseTolerance = this.curveFidelityConfig.distanceTolerance ??
-            DEFAULT_CURVE_FIDELITY.distanceTolerance;
-        const distanceTolerance = baseTolerance * baseTolerance;
-        if (d > COLLINEARITY_EPSILON) {
-            // Regular case
-            // Recursion terminates when the curve is flat enough (deviation from straight line is within tolerance)
-            if (d * d <= distanceTolerance * (dx * dx + dy * dy)) {
-                // Angle check
-                const angleTolerance = this.curveFidelityConfig.angleTolerance ??
-                    DEFAULT_CURVE_FIDELITY.angleTolerance;
-                if (angleTolerance > 0) {
-                    // Angle between segments (p1->p2) and (p2->p3)
-                    // atan2(cross, dot) avoids computing 2 separate atan2() values
-                    const v1x = x2 - x1;
-                    const v1y = y2 - y1;
-                    const v2x = x3 - x2;
-                    const v2y = y3 - y2;
-                    const da = Math.abs(Math.atan2(v1x * v2y - v1y * v2x, v1x * v2x + v1y * v2y));
-                    if (da < angleTolerance) {
-                        this.addPoint(x2, y2, points);
-                        return;
-                    }
-                }
-                else {
-                    this.addPoint(x2, y2, points);
-                    return;
-                }
-            }
-        }
-        else {
-            // Collinear case
-            const da = dx * dx + dy * dy;
-            if (da === 0) {
-                const d2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
-                if (d2 <= distanceTolerance) {
-                    this.addPoint(x2, y2, points);
-                    return;
-                }
-            }
-            else {
-                const d2 = ((x2 - x1) * dx + (y2 - y1) * dy) / da;
-                if (d2 > 0 && d2 < 1 && d * d <= distanceTolerance * da) {
-                    this.addPoint(x2, y2, points);
-                    return;
-                }
-            }
-        }
-        // Continue subdividing
-        this.recursiveQuadratic(x1, y1, x12, y12, x123, y123, points, level + 1);
-        this.recursiveQuadratic(x123, y123, x23, y23, x3, y3, points, level + 1);
-    }
-    recursiveCubic(x1, y1, x2, y2, x3, y3, x4, y4, points, level = 0) {
-        if (level > RECURSION_LIMIT)
-            return;
-        // De Casteljau subdivision for cubic curves
-        const x12 = (x1 + x2) / 2;
-        const y12 = (y1 + y2) / 2;
-        const x23 = (x2 + x3) / 2;
-        const y23 = (y2 + y3) / 2;
-        const x34 = (x3 + x4) / 2;
-        const y34 = (y3 + y4) / 2;
-        const x123 = (x12 + x23) / 2;
-        const y123 = (y12 + y23) / 2;
-        const x234 = (x23 + x34) / 2;
-        const y234 = (y23 + y34) / 2;
-        const x1234 = (x123 + x234) / 2;
-        const y1234 = (y123 + y234) / 2;
-        const dx = x4 - x1;
-        const dy = y4 - y1;
-        const d2 = Math.abs((x2 - x4) * dy - (y2 - y4) * dx);
-        const d3 = Math.abs((x3 - x4) * dy - (y3 - y4) * dx);
-        const baseTolerance = this.curveFidelityConfig.distanceTolerance ??
-            DEFAULT_CURVE_FIDELITY.distanceTolerance;
-        const distanceTolerance = baseTolerance * baseTolerance;
-        let switchCondition = 0;
-        if (d2 > COLLINEARITY_EPSILON)
-            switchCondition |= 1;
-        if (d3 > COLLINEARITY_EPSILON)
-            switchCondition |= 2;
-        switch (switchCondition) {
-            case 0:
-                // All collinear OR p1==p4
-                const k = dx * dx + dy * dy;
-                if (k === 0) {
-                    const d2_sq = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
-                    const d3_sq = (x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1);
-                    if (d2_sq <= distanceTolerance && d3_sq <= distanceTolerance) {
-                        this.addPoint(x2, y2, points);
-                        this.addPoint(x3, y3, points);
-                        return;
-                    }
-                }
-                else {
-                    const da1 = ((x2 - x1) * dx + (y2 - y1) * dy) / k;
-                    const da2 = ((x3 - x1) * dx + (y3 - y1) * dy) / k;
-                    if (da1 > 0 &&
-                        da1 < 1 &&
-                        da2 > 0 &&
-                        da2 < 1 &&
-                        (d2 + d3) * (d2 + d3) <= distanceTolerance * k) {
-                        this.addPoint(x2, y2, points);
-                        this.addPoint(x3, y3, points);
-                        return;
-                    }
-                }
-                break;
-            case 1:
-                // p1,p2,p4 are collinear, p3 is not
-                if (d3 * d3 <= distanceTolerance * (dx * dx + dy * dy)) {
-                    const angleTolerance = this.curveFidelityConfig.angleTolerance ??
-                        DEFAULT_CURVE_FIDELITY.angleTolerance;
-                    if (angleTolerance > 0) {
-                        // Angle between segments (p2->p3) and (p3->p4)
-                        const v1x = x3 - x2;
-                        const v1y = y3 - y2;
-                        const v2x = x4 - x3;
-                        const v2y = y4 - y3;
-                        const da1 = Math.abs(Math.atan2(v1x * v2y - v1y * v2x, v1x * v2x + v1y * v2y));
-                        if (da1 < angleTolerance) {
-                            this.addPoint(x2, y2, points);
-                            this.addPoint(x3, y3, points);
-                            return;
-                        }
-                    }
-                    else {
-                        this.addPoint(x2, y2, points);
-                        this.addPoint(x3, y3, points);
-                        return;
-                    }
-                }
-                break;
-            case 2:
-                // p1,p3,p4 are collinear, p2 is not
-                if (d2 * d2 <= distanceTolerance * (dx * dx + dy * dy)) {
-                    const angleTolerance = this.curveFidelityConfig.angleTolerance ??
-                        DEFAULT_CURVE_FIDELITY.angleTolerance;
-                    if (angleTolerance > 0) {
-                        // Angle between segments (p1->p2) and (p2->p3)
-                        const v1x = x2 - x1;
-                        const v1y = y2 - y1;
-                        const v2x = x3 - x2;
-                        const v2y = y3 - y2;
-                        const da1 = Math.abs(Math.atan2(v1x * v2y - v1y * v2x, v1x * v2x + v1y * v2y));
-                        if (da1 < angleTolerance) {
-                            this.addPoint(x2, y2, points);
-                            this.addPoint(x3, y3, points);
-                            return;
-                        }
-                    }
-                    else {
-                        this.addPoint(x2, y2, points);
-                        this.addPoint(x3, y3, points);
-                        return;
-                    }
-                }
-                break;
-            case 3:
-                // Regular case
-                if ((d2 + d3) * (d2 + d3) <= distanceTolerance * (dx * dx + dy * dy)) {
-                    const angleTolerance = this.curveFidelityConfig.angleTolerance ??
-                        DEFAULT_CURVE_FIDELITY.angleTolerance;
-                    if (angleTolerance > 0) {
-                        // da1: angle between (p1->p2) and (p2->p3)
-                        const a1x = x2 - x1;
-                        const a1y = y2 - y1;
-                        const a2x = x3 - x2;
-                        const a2y = y3 - y2;
-                        const da1 = Math.abs(Math.atan2(a1x * a2y - a1y * a2x, a1x * a2x + a1y * a2y));
-                        // da2: angle between (p2->p3) and (p3->p4)
-                        const b1x = a2x;
-                        const b1y = a2y;
-                        const b2x = x4 - x3;
-                        const b2y = y4 - y3;
-                        const da2 = Math.abs(Math.atan2(b1x * b2y - b1y * b2x, b1x * b2x + b1y * b2y));
-                        if (da1 + da2 < angleTolerance) {
-                            this.addPoint(x2, y2, points);
-                            this.addPoint(x3, y3, points);
-                            return;
-                        }
-                    }
-                    else {
-                        this.addPoint(x2, y2, points);
-                        this.addPoint(x3, y3, points);
-                        return;
-                    }
-                }
-                break;
-        }
-        // Continue subdividing
-        this.recursiveCubic(x1, y1, x12, y12, x123, y123, x1234, y1234, points, level + 1);
-        this.recursiveCubic(x1234, y1234, x234, y234, x34, y34, x4, y4, points, level + 1);
-    }
-    addPoint(x, y, points) {
-        const newPoint = new Vec2(x, y);
-        if (points.length === 0) {
-            points.push(newPoint);
-            return;
-        }
-        const lastPoint = points[points.length - 1];
-        const dx = newPoint.x - lastPoint.x;
-        const dy = newPoint.y - lastPoint.y;
-        const distanceSquared = dx * dx + dy * dy;
-        if (distanceSquared > COLLINEARITY_EPSILON * COLLINEARITY_EPSILON) {
-            points.push(newPoint);
-        }
+            const x12 = start.x + (control1.x - start.x) * t;
+            const y12 = start.y + (control1.y - start.y) * t;
+            const x23 = control1.x + (control2.x - control1.x) * t;
+            const y23 = control1.y + (control2.y - control1.y) * t;
+            const x34 = control2.x + (end.x - control2.x) * t;
+            const y34 = control2.y + (end.y - control2.y) * t;
+            const x123 = x12 + (x23 - x12) * t;
+            const y123 = y12 + (y23 - y12) * t;
+            const x234 = x23 + (x34 - x23) * t;
+            const y234 = y23 + (y34 - y23) * t;
+            emit(x123 + (x234 - x123) * t, y123 + (y234 - y123) * t);
+        }
+        return _out;
     }
 }