flo-mat 4.1.3 → 4.1.5

package/src/add-n-prong.ts/join-spokes.ts

@@ -2,6 +2,8 @@ import type { CpNode } from "../cp-node/cp-node.js";
 import type { Circle } from "../geometry/circle.js";
 import type { Mutable } from "../utils/mutable.js";
 
+const { atan2 } = Math;
+
 
 function joinSpokes(
         circle: Circle,
@@ -30,8 +32,8 @@ function byAngle(circle: Circle) {
         a = [a[0] - c[0], a[1] - c[1]];
         b = [b[0] - c[0], b[1] - c[1]];
 
-        const a_ = Math.atan2(a[1], a[0]);
-        const b_ = Math.atan2(b[1], b[0]);
+        const a_ = atan2(a[1], a[0]);
+        const b_ = atan2(b[1], b[0]);
 
         return b_ - a_;
     }

package/src/cp-node/fs/get-angle-between-mat-curves.ts

@@ -1,8 +1,10 @@
+import type { CpNode } from "../cp-node.js";
 import { tangent } from "flo-bezier3";
 import { cross, toUnitVector } from "flo-vector2d";
-import { CpNode } from "../cp-node.js";
 import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
 
+const { abs, asin, PI: π } = Math;
+
 
 /**
  * 
@@ -24,7 +26,7 @@ function getInitialDegAngleBetweenMatCurves(
     ));
 
     const cross_ = cross(tan1, tan2);
-    const angle = Math.abs(Math.asin( cross_ ) * (180/Math.PI));
+    const angle = abs(asin( cross_ ) * (180/π));
 
     return angle;
 }

package/src/cp-node/fs/get-edge-direction.ts

@@ -4,6 +4,8 @@ import { toUnitVector, fromTo, rotate, translate, rotate90Degrees, reverse as re
 import { tangent } from 'flo-bezier3';
 import { isPosSharpCorner } from '../../point-on-shape/is-pos-sharp-corner.js';
 
+const { sqrt } = Math;
+
 
 /**
  * Returns a line segment of unit length starting in the given Vertex center and
@@ -54,8 +56,8 @@ function getEdgeDirection(
         // Recall the identities sin(acos(x)) = sqrt(1-x^2), etc. Also 
         // recall the half angle formulas. Then the rotation matrix, R, can 
         // be calculated.
-        const cosθ = Math.sqrt((1 + x)/2);
-        const sinθ = Math.sqrt((1 - x)/2);
+        const cosθ = sqrt((1 + x)/2);
+        const sinθ = sqrt((1 - x)/2);
         
         vDir = rotate(sinθ, cosθ, tan2);
     }

package/src/cp-node/fs/get-implied-boundary-bezier-between.ts

@@ -1,8 +1,8 @@
+import type { CpNode } from '../cp-node.js';
 import { tangent } from 'flo-bezier3';
-import { 
-    fromTo, dot, cross, translate, lineLineIntersection, toUnitVector
-} from 'flo-vector2d';
-import { CpNode } from '../cp-node.js';
+import { fromTo, dot, cross, translate, lineLineIntersection, toUnitVector } from 'flo-vector2d';
+
+const { abs } = Math;
 
 
 /** @internal */
@@ -56,8 +56,8 @@ function getImpliedBoundaryBezierBetween(
     const w1 = fromTo(lA[0], lA[1]);  // This is a unit vector
     const w2 = fromTo(lB[0], lB[1]);  // This is a unit vector
 
-    const d1 = Math.abs(cross(c, w1)) / (3*3); 
-    const d2 = Math.abs(cross(c, w2)) / (3*3); 
+    const d1 = abs(cross(c, w1)) / (3*3); 
+    const d2 = abs(cross(c, w2)) / (3*3); 
 
     if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
         // not within tolerance

package/src/cp-node/fs/get-mat-curve-between.ts

@@ -17,6 +17,7 @@ const TOLERANCE_USE_LINE = 0.0001; // else cubic
 /**
  * Returns the bezier curve from the maximal disk of one `CpNode` to another
  * `CpNode`'s maximal disk.
+ * 
  * @param cpNodeFrom 
  * @param cpNodeTo 
  */

package/src/cp-node/fs/insert-cp-node.ts

@@ -5,19 +5,34 @@ import { RbTree } from "flo-ll-rb-tree";
 import { isOrderCorrect } from "./is-order-correct.js";
 
 
+/**
+ * 
+ * @param insertIfOrderWrong order cannot be checked for hole-closers since they're on different loops
+ * @param isHoleClosing 
+ * @param isIntersection 
+ * @param cpTree 
+ * @param pos 
+ * @param pred predecessor (to `pos`) on sampe loop (found via `cpTree`)
+ * @param succ successor (to `pos`) on sampe loop (found via `cpTree`)
+ * @param lastInsertId 
+ */
 function insertCpNode(
         insertIfOrderWrong: boolean,
         isHoleClosing: boolean,
         isIntersection: boolean,
         cpTree: RbTree<CpNode>,
         pos: PointOnShape,
-        _prev: CpNode | undefined,
+        pred: CpNode | undefined,
+        succ: CpNode | undefined,
         lastInsertId: { id: number }): CpNode | undefined {
 
-    if (_prev !== undefined &&
-        !isOrderCorrect(cpTree, pos, _prev.next)) {
-
-        if (!insertIfOrderWrong) {
+    if (pred !== undefined && succ !== undefined) {
+        // !isOrderCorrect(cpTree, pos, pred.next, false)) {
+        const orderCorrect = isOrderCorrect(cpTree, pred, pos, succ, false);
+        // if (!orderCorrect) {
+        //     console.log('aaaaa');
+        // }
+        if (!insertIfOrderWrong && !orderCorrect) {
             return undefined;
         }
     }
@@ -34,8 +49,8 @@ function insertCpNode(
     };
     lastInsertId.id++;
 
-    const prev = _prev === undefined ? cpNode : _prev;
-    const next = _prev === undefined ? cpNode : prev.next;
+    const prev = pred === undefined ? cpNode : pred;
+    const next = pred === undefined ? cpNode : prev.next;
 
     (next as Mutable<CpNode>).prev = cpNode;
     (prev as Mutable<CpNode>).next = cpNode;

package/src/cp-node/fs/is-fully-terminating.ts

@@ -5,13 +5,10 @@ import { isTrivial } from "./is-trivial.js";
 
 
 /**
- * Like isTerminating() but only returns true if all cpNodes on the circle
+ * Like `isTerminating` but only returns true if all `CpNode`s on the circle
  * (except this.prevOnCircle) is terminating.
  */
 function isFullyTerminating(cpNode: CpNode) {
-    // const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
-
-    // return otherOnCircle.every(isTerminating);
     if (!isTerminating(cpNode)) {
         return false;
     }
@@ -24,9 +21,8 @@ function isFullyTerminating(cpNode: CpNode) {
         cpNode = cpNode.prev;
     }
 
-    const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
-
-    return otherOnCircle.every(isTerminating);
+    return getAllOnCircle(cpNode.prevOnCircle, true)
+        .every(isTerminating);
 }
 
 

package/src/cp-node/fs/is-on-same-circle.ts

@@ -1,11 +1,13 @@
 import { CpNode } from "../cp-node.js";
-import { getAllOnCircle } from "./get-all-on-circle.js";
 
 
 /**
- * Returns true if the 2 given `CpNode`s are on the same maximal disk 
+ * Returns true if the 2 given `CpNode`s are on the same maximal disk
  * circle.
- * 
+ *
+ * * O(1): all `CpNode`s on the same on-circle ring share the same `Circle`
+ *   object, and no other ring does (see `PointOnShape.circle`)
+ *
  * @param cpNode1 A `CpNode`.
  * @param cpNode2 Another `CpNode`
  */
@@ -13,10 +15,7 @@ function isOnSameCircle(
         cpNode1: CpNode,
         cpNode2: CpNode) {
 
-    // const cpNodes = getAllOnCircle(cpNode1, true);
-    const cpNodes = getAllOnCircle(cpNode1);
-
-    return cpNodes.indexOf(cpNode2) >= 0;
+    return cpNode1.pointOnShape.circle === cpNode2.pointOnShape.circle;
 }
 
 

package/src/cp-node/fs/is-order-correct copy.ts

@@ -0,0 +1,60 @@
+import type { CpNode } from "../cp-node.js";
+import { RbTree } from "flo-ll-rb-tree";
+import { PointOnShape } from "../../point-on-shape/point-on-shape.js";
+import { comparePoss } from "../../point-on-shape/compare-poss.js";
+
+
+/**
+ * 
+ * @param cpTree 
+ * @param pos 
+ * @param succ 
+ * @param alreadyInserted set to `true` if the given `pos` has already been
+ * inserted, `false` otherwise.
+ */
+function isOrderCorrect(
+        cpTree: RbTree<CpNode>,
+        pred: CpNode,
+        pos: PointOnShape,
+        succ: CpNode,
+        alreadyInserted: boolean): boolean {
+
+    if (cpTree.size <= (alreadyInserted ? 2 : 1)) {
+        return true;
+    }
+
+    const c = comparePoss(pos, succ.pointOnShape);
+
+
+    if (c < 0) { return true; }
+    if (c === 0) { return false; }
+
+    const minNode = cpTree.getMinNode()!.datum;
+    const maxNode = cpTree.getMaxNode()!.datum;
+
+    // larger than all -> crossing zero on loop
+    const largerThanAll = comparePoss(pos, maxNode.pointOnShape!) >= 0;
+    const r = 
+        largerThanAll &&
+        minNode === succ;
+
+
+    // const r = (pos === max.pointOnShape) && (next === min);
+
+    if (!r) {
+        console.log(c);
+        console.log(cpTree.toArr().map(v => {
+            return {
+                curveIdx: v.pointOnShape.curve.idx,
+                t: v.pointOnShape.t,
+                order: v.pointOnShape.order,
+                order2: v.pointOnShape.order2
+            }
+        }));
+    }
+
+    return r;
+}
+
+
+export { isOrderCorrect }

package/src/cp-node/fs/is-order-correct.ts

@@ -4,27 +4,75 @@ import { PointOnShape } from "../../point-on-shape/point-on-shape.js";
 import { comparePoss } from "../../point-on-shape/compare-poss.js";
 
 
+/**
+ * 
+ * @param cpTree 
+ * @param pos 
+ * @param succ 
+ * @param alreadyInserted set to `true` if the given `pos` has already been
+ * inserted, `false` otherwise.
+ */
 function isOrderCorrect(
         cpTree: RbTree<CpNode>,
+        pred: CpNode,
         pos: PointOnShape,
-        next: CpNode): boolean {
+        succ: CpNode,
+        alreadyInserted: boolean): boolean {
 
-    const c = comparePoss(pos, next.pointOnShape);
-    if (c < 0) { return true; }
-    if (c === 0) {
-        return false;
-    }
-
-    const minNode = cpTree.getMinNode();
-    if (minNode === undefined) {  // if tree not empty
+    if (cpTree.size <= (alreadyInserted ? 2 : 1)) {
         return true;
     }
 
-    const min = minNode.datum;
-    const max = cpTree.getMaxNode()!.datum;
+    const a = pred.pointOnShape;
+    const b = pos;
+    const c = succ.pointOnShape;
+
+    // Let a = pred, b = pos, and c = succ.
+    // For a cyclic order we need:
+    // `(a < b && b < c)` || `(b < c && c < a)` || `(c < a && a < b)`
+    // Let `X = a < b, Y = b < c, Z = c < a` then
+    // `(X && Y)` || `(Y && Z)` || `(Z && X)`
+
+    const _X = comparePoss(a, b);
+    if (_X === 0) {  // two points must have different order
+        // console.log('aaa');
+        // throw 'a';
+        return false;
+    }  
+    const _Y = comparePoss(b, c);
+    if (_Y === 0) {  // two points must have different order
+        // console.log('bbb');
+        // throw 'b';
+        return false;
+    }  
+    const _Z = comparePoss(c, a);
+    if (_Z === 0) {
+        // console.log('bbb');
+        // throw 'c';
+        return false;
+    }  // impossible anyway at this point
+
+    // Now neither `_X` nor `_Y` nor `_Z` === `0`
+    const X = _X < 0;
+    const Y = _Y < 0;
+    const Z = _Z < 0;
+
+    // Cyclic order condition
+    if ((X && Y) || (Y && Z) || (Z && X)) { return true; }
+
+    // throw 'd';
+
+    // console.log(_X, _Y, _Z);
+    // console.log(cpTree.toArr().map(v => {
+    //     return {
+    //         curveIdx: v.pointOnShape.curve.idx,
+    //         t: v.pointOnShape.t,
+    //         order: v.pointOnShape.order,
+    //         order2: v.pointOnShape.order2
+    //     }
+    // }));
 
-    // larger than all -> crossing zero on loop
-    return (comparePoss(max.pointOnShape!, pos) < 0 && min === next);
+    return false;
 }
 
 

package/src/cp-node/fs/remove-cp-node.ts

@@ -15,7 +15,7 @@ function removeCpNode(
     (next as Mutable<CpNode>).prev = prev;
 
     const cpTree = cpTrees.get(cpNode.pointOnShape.curve.loop)!;
-    cpTree.remove(cpNode, false); 
+    cpTree.remove(cpNode); 
 }
 
 

package/src/cp-node/stringification/from-stringifyable.ts

@@ -1,7 +1,9 @@
 import type { PointOnShape } from "../../point-on-shape/point-on-shape.js";
 import type { CpNode } from "../cp-node";
 import type { CpNodeStringifyable } from "./cp-node-stringifyable";
+import type { Mutable } from "../../utils/mutable.js";
 import { EDGES } from "./cp-node-stringifyable";
+import { getAllOnCircle } from "../fs/get-all-on-circle.js";
 import { loopFromStringifyable } from './loop-from-stringifyable.js';
 
 
@@ -51,6 +53,21 @@ function fromStringifyable(
         }
     }
 
+    //--------------------------------------------------------------------------
+    // Third pass: one shared `Circle` object per on-circle ring, as when the
+    // MAT was built (the JSON gave every contact point its own copy).
+    //--------------------------------------------------------------------------
+    const done = new Set<CpNode>();
+    for (const cpNode of cpNodes) {
+        if (done.has(cpNode)) { continue; }
+
+        const { circle } = cpNode.pointOnShape;
+        for (const cp of getAllOnCircle(cpNode)) {
+            done.add(cp);
+            (cp.pointOnShape as Mutable<PointOnShape>).circle = circle;
+        }
+    }
+
     return cpNodes[0];
 }
 

package/src/debug/functions/check-ordering.ts

@@ -4,7 +4,18 @@ import { CpNode } from "../../cp-node/cp-node.js";
 import { getAllOnLoop } from "../../cp-node/fs/get-all-on-loop.js";
 import { getProngCount } from "../../cp-node/fs/get-prong-count.js";
 import { isOrderCorrect } from "../../cp-node/fs/is-order-correct.js";
-import { comparePoss } from "../../point-on-shape/compare-poss.js";
+
+
+interface Order {
+    prongCount: number;
+    cpNode: CpNode;
+    p: number[];
+    /** From highest to lowest significance */
+    curveIdx: number;
+    t: number;
+    order: number;
+    order2: number;
+}
 
 
 function checkOrdering(
@@ -16,81 +27,53 @@ function checkOrdering(
     const cpNodes = getAllOnLoop(cpStart);
 
     const wrongsPerLoop: Map<Loop,[Order,Order][]> = new Map();
-    for (const cpNodeA of cpNodes) {
-        const cpNodeB = cpNodeA.next;
-
-        const posA = cpNodeA.pointOnShape;
-        const idxA = posA.curve.idx;
-        const pA = posA.p;
-        const loopA = posA.curve.loop;
-        const cpTreeA = cpTrees.get(loopA)!;
-
-        const posB = cpNodeB.pointOnShape;
-        const idxB = posB.curve.idx;
-        const pB = posB.p;
-        // const loopB = posB.curve.loop;
-        // const cpTreeB = cpTrees.get(loopB)!;
-        
+    for (const cpNode of cpNodes) {
+        const pos = cpNode.pointOnShape;
+        const loop = pos.curve.loop;
+
+        if (loop !== cpNode.prev.pointOnShape.curve.loop ||
+            loop !== cpNode.next.pointOnShape.curve.loop) {
+
+            continue;
+        }
+
+        const cpTree = cpTrees.get(loop)!;
+
         const orderCorrect = isOrderCorrect(
-            cpTreeA, posA, cpNodeB
-        )
+            cpTree, cpNode.prev, cpNode.pointOnShape, cpNode.next, true
+        );
         if (!orderCorrect) {
-            const A: Order = {
-                prongCount: getProngCount(cpNodeA),
-                p: pA,
-                cpNode: cpNodeA,
-                curveIdx: idxA,
-                t: posA.t,
-                order: posA.order,
-                order2: posA.order2
-            }
-            const B: Order = {
-                prongCount: getProngCount(cpNodeB),
-                p: pB,
-                cpNode: cpNodeB,
-                curveIdx: idxB,
-                t: posB.t,
-                order: posB.order,
-                order2: posB.order2
-            }
-            const loopA = A.cpNode.pointOnShape.curve.loop;
-            let wrongs = wrongsPerLoop.get(loopA);
-            if (wrongs === undefined) {
-                wrongs = [];
-                wrongsPerLoop.set(loopA, wrongs);
-            }
+            const A = toOrder(cpNode);
+            const B = toOrder(cpNode.next);
+
+            let wrongs = wrongsPerLoop.getOrInsert(loop, []);
             wrongs.push([A,B]);
         }
     }
 
     for (const [loop,wrongs] of wrongsPerLoop) {
-        let maxOrder = -Infinity;
-        let max: Order | undefined = undefined;
         for (const wrong of wrongs) {
             const A = wrong[0];
             const B = wrong[1];
-            const c = comparePoss(A.cpNode.pointOnShape, B.cpNode.pointOnShape);
-            if (c > maxOrder) { 
-                
-            }
-            // console.log(wrong[0]);
-            // console.log(wrong[1]);
-            // console.log('---------');
+            // const c = comparePoss(A.cpNode.pointOnShape, B.cpNode.pointOnShape);
+
+            console.log(A);
+            console.log(B);
+            console.log('---------');
         }
     }
-    // }
 }
 
 
-interface Order {
-    prongCount: number;
-    cpNode: CpNode;
-    p: number[];
-    /** From highest to lowest significance */
-    curveIdx: number;
-    t: number;
-    order: number;
-    order2: number;
+function toOrder(
+        cpNode: CpNode): Order {
+
+    const prongCount = getProngCount(cpNode);
+    const { pointOnShape } = cpNode;
+    const { p, t, order, order2, curve } = pointOnShape;
+    const curveIdx = curve.idx;
+
+    return { cpNode, prongCount, p, curveIdx, t, order, order2 };
 }
 
 

package/src/find-2-prong/add-2-prong.ts

@@ -83,13 +83,19 @@ function closeHole(
 
     const [cpNodeSource, cpNodeAntipode] = cpNodes as Mutable<CpNode>[];
 
+    // The twins form their own on-circle ring (a separate MAT vertex - that
+    // is what cuts the hole), so they get their own (equal) `Circle` object:
+    // one `Circle` object per ring.
+    const twinCircle: Circle = { ...cpNodeSource.pointOnShape.circle };
+
     // Antipode - create and insert twin
     const posAntipode = cpNodeAntipode.pointOnShape;
     const cpNodeAntipodeTwin = insertCpNode(
         true, true, false,
         cpTrees.get(posAntipode.curve.loop)!,
-        { ...posAntipode, order2: +1 },
+        { ...posAntipode, circle: twinCircle, order2: +1 },
         cpNodeAntipode,
+        undefined,  // unused
         meta.lastInsertId
     )! as Mutable<CpNode>;
     cpNodeAntipodeTwin.holeCloserTwin = cpNodeAntipode;
@@ -100,8 +106,9 @@ function closeHole(
     const cpNodeSourceTwin = insertCpNode(
         true, true, false,
         cpTrees.get(posSource.curve.loop)!,
-        { ...cpNodeSource.pointOnShape!, order2: -1 },
+        { ...posSource!, circle: twinCircle, order2: -1 },
         cpNodeSource.prev,
+        undefined,  // unused
         meta.lastInsertId
     )! as Mutable<CpNode>;
     cpNodeSourceTwin.holeCloserTwin = cpNodeSource;

package/src/find-2-prong/calc-seperation-tolerance.ts

@@ -89,10 +89,10 @@ export { calcSeperationTolerance }
 
 
 // function degToRad(degrees: number) {
-//     return degrees/360*2*Math.PI;
+//     return degrees/360*2*PI;
 // }
 // function radToDeg(rad: number) {
-//     return rad*360/2/Math.PI;
+//     return rad*360/2/PI;
 // }
 
 

package/src/find-2-prong/find-and-add-2-prongs.ts

@@ -37,7 +37,7 @@ function findAndAdd2Prongs(
     for (let i=0; i<for2Prongs.length; i++) {
         const pos = for2Prongs[i];
 
-        const angles = getValidAngles(angleIncrement_, pos);
+        const angles = for1Prong ? [0] : getValidAngles(angleIncrement_, pos);
 
         for (const angle of angles) {
             const twoProngInfo = find2Prong_(

package/src/find-2-prong/get-initial-bezier-pieces.ts

@@ -2,7 +2,7 @@ import type { Loop } from 'flo-boolean';
 import type { CurvePiece  } from '../mat/curve-piece.js';
 import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import type { MatMeta } from '../mat/mat-meta.js';
-import { getCpNodeToLeftOrSame } from '../mat/get-cp-node-to-left-or-same.js';
+import { getCpNodeNeighbors } from '../mat/get-cp-node-neighbors.js';
 import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
 import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
 import { isPosCorner } from '../point-on-shape/is-pos-corner.js';
@@ -38,7 +38,7 @@ function getInitialCurvePieces(
                 : calcPosOrder(xO, yPos)
             : 0;
 
-    const cpNode = getCpNodeToLeftOrSame(cpTrees.get(loop)!, yPos, order, 0);
+    const cpNode = getCpNodeNeighbors(cpTrees.get(loop)!, yPos, order, 0)?.[0];
     if (!cpNode || 
         // The special case if there is only a single sharp corner or 
         // two-way terminating 2-prong currently in the MAT. Don't remove!

package/src/find-3-prong/find-3-prong-for-delta3s.ts

@@ -28,7 +28,7 @@ const { min, abs, asin } = Math;
  * @internal
  */
 function find3ProngForDelta3s(
-        δs: CpNode[][], 
+        δs: [CpNode, CpNode][], 
         idx: number, 
         k: number,
         curvePiecess: CurvePiece[][],
@@ -37,25 +37,33 @@ function find3ProngForDelta3s(
     const TOLERANCE = 2**(maxCoordPowerOf2 - 32);
     const MAX_ITERATIONS = 10;
 
-    const δs_ = [
+    const δs_: [[CpNode,CpNode], [CpNode,CpNode], [CpNode,CpNode]] = [
         δs[0],
         δs[idx], 
         δs[δs.length-1]
     ];
 
-    const curvePieces_ = [
+    const curvePieces_: [CurvePiece[], CurvePiece[], CurvePiece[]] = [
         curvePiecess[0], 
         curvePiecess[idx], 
-        curvePiecess[δs.length-1]
+        curvePiecess[δs.length - 1]
     ];
 
-    const δ3ss = [
+    const δ3ss: [
+        [[CpNode, CpNode], [CpNode, CpNode], [CpNode, CpNode]],
+        [[CpNode, CpNode], [CpNode, CpNode], [CpNode, CpNode]],
+        [[CpNode, CpNode], [CpNode, CpNode], [CpNode, CpNode]]
+    ] = [
         [δs_[0], δs_[1], δs_[2]],
         [δs_[1], δs_[2], δs_[0]],
         [δs_[2], δs_[0], δs_[1]],
     ];
 
-    const curvePiecess_ = [
+    const curvePiecess_: [
+        [CurvePiece[], CurvePiece[], CurvePiece[]],
+        [CurvePiece[], CurvePiece[], CurvePiece[]],
+        [CurvePiece[], CurvePiece[], CurvePiece[]]
+    ] = [
         [curvePieces_[0], curvePieces_[1], curvePieces_[2]],
         [curvePieces_[1], curvePieces_[2], curvePieces_[0]],
         [curvePieces_[2], curvePieces_[0], curvePieces_[1]],
@@ -166,7 +174,7 @@ function find3ProngForDelta3s(
             const v2 = toUnitVector( tangent(pos.curve.ps, pos.t) );
             
             // Cross is more numerically stable than Vector.dot at angles a
-            // multiple of `Math.PI` **and** is close to the actual angle value
+            // multiple of π **and** is close to the actual angle value
             // and can thus just be added to cone method of looking at 
             // tolerance.
             

package/src/find-3-prong/find-3-prong.ts

@@ -14,7 +14,7 @@ import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
  * @internal
  */ 
 function find3Prong(
-        δs: CpNode[][],
+        δs: [CpNode, CpNode][],
         maxCoordPowerOf2: number): ThreeProngInfo {
 
     // FUTURE if `δs.length > (some threshold (say 4 or 5))` then add two-prongs