flo-mat 3.0.6 → 3.0.9

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

@@ -9,6 +9,7 @@ import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
 import { Circle } from '../geometry/circle.js';
 import { isPosCorner } from '../point-on-shape/is-pos-corner.js';
 import { getPosCorner } from '../point-on-shape/get-pos-corner.js';
+import { MatMeta } from '../index.js';
 
 
 /** @internal */
@@ -17,10 +18,13 @@ function getInitialBezierPieces(
         isHoleClosing: boolean,
         loop: Loop,
         loops: Loop[],
-        cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        meta: MatMeta,
         y: PointOnShape,
         circle: Circle): CurvePiece[] {
 
+    const { cpTrees } = meta;
+
     if (isHoleClosing) {
         return loops
         .filter(_loop => _loop !== loop)

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

@@ -8,6 +8,7 @@ import { Circle } from '../geometry/circle.js';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { addToCpGraph } from '../mat/add-to-cp-graph.js';
 import { isAnotherCpCloseby } from '../mat/is-another-cp-closeby.js';
+import { MatMeta } from '../mat/mat-meta.js';
 
 
 /**
@@ -24,86 +25,88 @@ import { isAnotherCpCloseby } from '../mat/is-another-cp-closeby.js';
  * @param threeProng 
  */
 function add3Prong(
-		cpTrees: Map<Loop,LlRbTree<CpNode>>,
-		orders: number[],
-		threeProng: { 
-    		circle: Circle, 
-			ps: PointOnShape[],
-			δ3s: CpNode[][]
-		}): CpNode[] {
-	
-	const { circle, ps: poss, δ3s } = threeProng;
+        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        meta: MatMeta,
+        orders: number[],
+        threeProng: { 
+            circle: Circle, 
+            ps: PointOnShape[],
+            δ3s: CpNode[][]
+        }): CpNode[] {
+    
+    const { cpTrees } = meta;
+    const { circle, ps: poss, δ3s } = threeProng;
 
-	// Keep for possible future debugging.	
+    // Keep for possible future debugging.    
 
-	/*
-	let ii = -1;
-	if (typeof _debug_ !== 'undefined') {
-		for (let i=0; i<3; i++) {
-			const cpBef = threeProng.δ3s[i][0].cp;
-			const cpAft = threeProng.δ3s[i][1].cp;
+    /*
+    let ii = -1;
+    if (typeof _debug_ !== 'undefined') {
+        for (let i=0; i<3; i++) {
+            const cpBef = threeProng.δ3s[i][0].cp;
+            const cpAft = threeProng.δ3s[i][1].cp;
 
-			//let cmpBef = PointOnShape.compareInclOrder(cpBef.pointOnShape, poss[i], cpBef.order, orders[i]);
-			//let cmpAft = PointOnShape.compareInclOrder(cpAft.pointOnShape, poss[i], cpAft.order, orders[i]); 
-			const cmpBef = compareCps(cpBef, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
-			const cmpAft = compareCps(cpAft, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
+            //let cmpBef = PointOnShape.compareInclOrder(cpBef.pointOnShape, poss[i], cpBef.order, orders[i]);
+            //let cmpAft = PointOnShape.compareInclOrder(cpAft.pointOnShape, poss[i], cpAft.order, orders[i]); 
+            const cmpBef = compareCps(cpBef, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
+            const cmpAft = compareCps(cpAft, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
 
-			// const cmpBef = comparePoss(cpBef.pointOnShape, poss[i]);
-			// const cmpAft = comparePoss(cpAft.pointOnShape, poss[i]); 
+            // const cmpBef = comparePoss(cpBef.pointOnShape, poss[i]);
+            // const cmpAft = comparePoss(cpAft.pointOnShape, poss[i]); 
 
-			// len is used by debug functions to reference a particular 
-			// three-prong.
-			const len = _debug_.generated.elems.threeProng.length-1; 
-			if (cmpBef > 0) {
-				console.log('----------------------------------------');
-				console.log(`3-prong order is wrong (bef) : i: ${i} - cmp: ${cmpBef} - n: ${len}`);
-				console.log(threeProng);
-				console.log(cpBef);
-				console.log(cpAft);
-				console.log(poss[i]);
-				ii = i;
-			}
-			if (cmpAft < 0) {
-				console.log('----------------------------------------');
-				console.log(`3-prong order is wrong (aft) : i: ${i} - cmp: ${cmpAft} - n: ${len}`);
-				console.log(threeProng);
-				console.log(cpBef);
-				console.log(cpAft);
-				console.log(poss[i]);
-			}
-		}
-	}
-	*/
+            // len is used by debug functions to reference a particular 
+            // three-prong.
+            const len = _debug_.generated.elems.threeProng.length-1; 
+            if (cmpBef > 0) {
+                console.log('----------------------------------------');
+                console.log(`3-prong order is wrong (bef) : i: ${i} - cmp: ${cmpBef} - n: ${len}`);
+                console.log(threeProng);
+                console.log(cpBef);
+                console.log(cpAft);
+                console.log(poss[i]);
+                ii = i;
+            }
+            if (cmpAft < 0) {
+                console.log('----------------------------------------');
+                console.log(`3-prong order is wrong (aft) : i: ${i} - cmp: ${cmpAft} - n: ${len}`);
+                console.log(threeProng);
+                console.log(cpBef);
+                console.log(cpAft);
+                console.log(poss[i]);
+            }
+        }
+    }
+    */
 
-	// TODO - replace 1000 below with correct value
-	const c1 = isAnotherCpCloseby(cpTrees, poss[0], circle, orders[0], 0, 1000);
-	const c2 = isAnotherCpCloseby(cpTrees, poss[1], circle, orders[1], 0, 1000);
-	const c3 = isAnotherCpCloseby(cpTrees, poss[2], circle, orders[2], 0, 1000);
+    // TODO - replace 1000 below with correct value
+    const c1 = isAnotherCpCloseby(cpTrees, poss[0], circle, orders[0], 0, 1000);
+    const c2 = isAnotherCpCloseby(cpTrees, poss[1], circle, orders[1], 0, 1000);
+    const c3 = isAnotherCpCloseby(cpTrees, poss[2], circle, orders[2], 0, 1000);
 
-	// for (let pos of poss) {
-	// 	if (pos.t === 0.9978869234519733) {
-	// 		console.log(pos)
-	// 	}
-	// }
-	
+    // for (let pos of poss) {
+    //     if (pos.t === 0.9978869234519733) {
+    //         console.log(pos)
+    //     }
+    // }
+    
 
-	// if (!!c1) {
-	// 	console.log(getRealProngCount(c1));
-	// }
-	// if (!!c2) {
-	// 	console.log(getRealProngCount(c2));
-	// }
-	// if (!!c3) {
-	// 	console.log(getRealProngCount(c3));
-	// }
+    // if (!!c1) {
+    //     console.log(getRealProngCount(c1));
+    // }
+    // if (!!c2) {
+    //     console.log(getRealProngCount(c2));
+    // }
+    // if (!!c3) {
+    //     console.log(getRealProngCount(c3));
+    // }
 
-	// if (!!c1) { return [c1]; }
-	// if (!!c2) { return [c2]; }
-	// if (!!c3) { return [c3]; }
+    // if (!!c1) { return [c1]; }
+    // if (!!c2) { return [c2]; }
+    // if (!!c3) { return [c3]; }
 
-	const cps = addToCpGraph(circle, orders, cpTrees, poss, δ3s); 
-	
-	return cps;
+    const cps = addToCpGraph(circle, orders, cpTrees, poss, δ3s); 
+    
+    return cps;
 }
 
 

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

@@ -50,7 +50,7 @@ function findAndAdd3Prong(
 
 	const cpNodes = closeBysFor3Prong.length === 0
 		? addToCpTree(
-			true, false, circle, orders, meta.cpTrees, poss, δ3s.map(v => v[0])
+			true, false, circle, orders, meta, poss, δ3s.map(v => v[0])
 		).cpNodes
 		: [];
 

package/src/find-3-prong.ts/find-and-add-3-prongs-on-loop.ts

@@ -1,11 +1,11 @@
-import { CpNode } from '../cp-node/cp-node.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { MatMeta } from '../mat/mat-meta.js';
 import { findAndAdd3Prongs } from './find-and-add-3-prongs.js';
-import { MatMeta } from '../mat/mat-meta.js';
 import { getAllOnLoop } from '../cp-node/fs/get-all-on-loop.js';
 import { removeVertex } from '../vertex/remove-vertex.js';
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { drawFs } from 'flo-draw';
+// import { LlRbTree } from 'flo-ll-rb-tree';
+// import { Loop } from 'flo-boolean';
+// import { drawFs } from 'flo-draw';
 import { getAllOnCircle } from '../cp-node/fs/get-all-on-circle.js';
 
 
@@ -38,7 +38,7 @@ function findAndAdd3ProngsOnLoop(
                 cpNodeGoodSet.add(cpNode);
             } else {
                 reLoop = true;
-                replaceCloseBys(meta.cpTrees, closeBysFor3Prong, cpNodeSet, cpNodeGoodSet);
+                replaceCloseBys(meta, closeBysFor3Prong, cpNodeSet, cpNodeGoodSet);
             }
 
             addedCpNodes.forEach(cpNodes => cpNodes.forEach(cpNode => cpNodeGoodSet.add(cpNode)));
@@ -71,7 +71,8 @@ function getLastItemOfSet<T>(set: Set<T>) {
 
 
 function replaceCloseBys(
-        cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        meta: MatMeta,
         closeBysFor3Prong: CpNode[],
         cpNodeSet: Set<CpNode>,
         cpNodeGoodSet: Set<CpNode>) {
@@ -81,7 +82,7 @@ function replaceCloseBys(
             cpNodeSet.delete(v);
             cpNodeGoodSet.delete(v);
         });
-        removeVertex(closeBy, cpTrees);
+        removeVertex(closeBy, meta);
     }
 }
 

package/src/find-mat/create-initial-cp-tree.ts

@@ -5,6 +5,7 @@ import { CpNodeFs } from '../cp-node/cp-node-fs.js';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { ContactPoint } from '../contact-point/contact-point.js';
 import { insertCpNode } from '../cp-node/fs/insert-cp-node.js';
+import { MatMeta } from '../index.js';
 
 const { cpNodeComparator } = CpNodeFs;
 
@@ -13,17 +14,20 @@ const { cpNodeComparator } = CpNodeFs;
  * @internal
  * Creates the initial ContactPoint loops from the given sharp corners.
  * 
- * * modifies `cpTrees`
+ * * modifies `cpTrees` and `lastInsertId` of `meta`
  * 
- * @param shape
+ * @param loops
+ * @param cpTrees
  * @param sharpCornerss
+ * @param lastInsertId
  */
 function createInitialCpTree(
         loops: Loop[], 
         cpTrees: Map<Loop, LlRbTree<CpNode>>,
-        sharpCornerss: PointOnShape[][]) {
+        sharpCornerss: PointOnShape[][],
+        lastInsertId: { id: number }) {
 
-    let cpNode;
+    let cpNode: CpNode | undefined;
     for (let k=0; k<sharpCornerss.length; k++) {
         const sharpCorners = sharpCornerss[k];
 
@@ -37,8 +41,8 @@ function createInitialCpTree(
             const cp1: ContactPoint = { pointOnShape: pos, circle, order: -1, order2: 0 };
             const cp2: ContactPoint = { pointOnShape: pos, circle, order: +1, order2: 0 };
 
-            cpNode1 = insertCpNode(true, false, false, cpTree, cp1, cpNode2)!;
-            cpNode2 = insertCpNode(true, false, false, cpTree, cp2, cpNode1)!;
+            cpNode1 = insertCpNode(true, false, false, cpTree, cp1, cpNode2, lastInsertId)!;
+            cpNode2 = insertCpNode(true, false, false, cpTree, cp2, cpNode1, lastInsertId)!;
             
             cpNode1.prevOnCircle = cpNode2; 
             cpNode2.prevOnCircle = cpNode1; 

package/src/find-mat/find-mat.ts

@@ -7,7 +7,7 @@ import { CpNode } from '../cp-node/cp-node.js';
 import { Loop } from 'flo-boolean';
 import { findAndAdd3ProngsOnLoop } from '../find-3-prong.ts/find-and-add-3-prongs-on-loop.js';
 import { createInitialCpTree } from './create-initial-cp-tree.js';
-import { getMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
+import { getPointToCpNode, getPartialMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
 import { getSharpCornersOnLoop } from './get-sharp-corners.js';
 import { getDullCornersOnLoop } from './get-dull-corners-on-loop.js';
 import { findAndAdd2ProngsOnAllLoops } from '../find-2-prong/find-and-add-2-prongs-on-all-loops.js';
@@ -16,6 +16,7 @@ import { getFor1ProngsOnLoop } from './get-for-1-prongs-on-loop.js';
 import { findAndAddHoleClosing2Prongs } from '../find-2-prong/find-and-add-hole-closing-2-prongs.js';
 import { getShapeBounds } from '../svg/get-shape-bounds.js';
 import { MatOptions } from './mat-options.js';
+import { MatMeta } from '../mat/mat-meta.js';
 
 
 /**
@@ -38,15 +39,27 @@ function findMat(
 
     const sharpCornersPerLoop = loops.map(getSharpCornersOnLoop_);
 
-    const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
-    createInitialCpTree(loops, cpTrees, sharpCornersPerLoop);
-
     const bounds = getShapeBounds(loops);
     const squaredDiagonalLength = 
         (bounds.maxX.p[0] - bounds.minX.p[0])**2 +
         (bounds.maxY.p[1] - bounds.minY.p[1])**2;
 
-    const meta = getMeta(maxCoordinate, squaredDiagonalLength, loops, cpTrees);
+    const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
+    const lastInsertId = { id: 0 };
+    createInitialCpTree(loops, cpTrees, sharpCornersPerLoop, lastInsertId);
+
+    const _meta = getPartialMeta(loops);
+    const pointToCpNode = getPointToCpNode(loops, cpTrees);
+    const meta: MatMeta = {
+        maxCoordinate, squaredDiagonalLength, loops, cpTrees, pointToCpNode,
+        lastInsertId, ..._meta
+    };
+    // const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
+    // const lastInsertId = { id: 0 };
+    // createInitialCpTree(loops, cpTrees, sharpCornersPerLoop, lastInsertId);
+
+    // const meta = getMeta(maxCoordinate, squaredDiagonalLength, loops, cpTrees, lastInsertId);
+
 
     let cpNode: CpNode | undefined;
 

package/src/find-mat/get-meta.ts

@@ -18,23 +18,14 @@ let timingStart: number;
 
 
 /** @internal */
-function getMeta(
-        maxCoordinate: number,
-        squaredDiagonalLength: number,
+function getPointToCpNode(
         loops: Loop[],
-        cpTrees: Map<Loop, LlRbTree<CpNode>>): MatMeta {
+        cpTrees: Map<Loop, LlRbTree<CpNode>>): TriMap<Loop,number,number,CpNode> {
 
     timingStart = performance.now();
 
     const pointToCpNode: TriMap<Loop,number,number,CpNode> = new Map();
-
-    const looseBoundingBoxes: number[][][] = [];
-    const tightBoundingBoxes: number[][][] = [];
-    const boundingHulls: number[][][] = [];
-    const sharpCorners: Curve[] = [];
-    const dullCorners: Curve[] = [];
-
-    for (const loop of loops) {
+        for (const loop of loops) {
         // Populate `posMap`
         const cpTree = cpTrees.get(loop)!;
         const cpNodes = cpTree.toArrayInOrder();
@@ -42,8 +33,32 @@ function getMeta(
             const { p, t } = cpNode.cp.pointOnShape;
             TriMapFs.set(pointToCpNode,loop,p[0],p[1],cpNode);
         }
+    }
+
+    return pointToCpNode;
+}
 
-        for (let curve of loop.curves) {
+
+/** @internal */
+function getPartialMeta(
+        loops: Loop[]): Omit<
+            MatMeta,
+            | 'cpTrees'
+            | 'pointToCpNode'
+            | 'loops'
+            | 'maxCoordinate'
+            | 'squaredDiagonalLength'
+            | 'lastInsertId'
+        > {
+
+    const looseBoundingBoxes: number[][][] = [];
+    const tightBoundingBoxes: number[][][] = [];
+    const boundingHulls: number[][][] = [];
+    const sharpCorners: Curve[] = [];
+    const dullCorners: Curve[] = [];
+
+    for (const loop of loops) {
+        for (const curve of loop.curves) {
             const ps = curve.ps;
             const hull = getBoundingHull(ps, true)!;
 
@@ -65,16 +80,11 @@ function getMeta(
     }
 
     return {
-        maxCoordinate,
-        squaredDiagonalLength,
         looseBoundingBoxes,
         tightBoundingBoxes,
         boundingHulls,
         sharpCorners,
-        dullCorners,
-        loops,
-        cpTrees,
-        pointToCpNode
+        dullCorners
     }
 }
 
@@ -112,4 +122,10 @@ function addDebugInfo4() {
 }
 
 
-export { getMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 }
+export {
+    getPointToCpNode,
+    getPartialMeta,
+    addDebugInfo2,
+    addDebugInfo3,
+    addDebugInfo4
+}

package/src/get-curve/get-curve-between.ts

@@ -13,8 +13,8 @@ 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.
+ * Returns the bezier curve from the maximal disk of one `CpNode` to another
+ * `CpNode`'s maximal disk.
  * @param cpNodeFrom 
  * @param cpNodeTo 
  */

package/src/index.ts

@@ -49,5 +49,5 @@ export { getSharpCornersOnLoop } from './find-mat/get-sharp-corners.js';
 export { getFor2ProngsOnLoop } from './find-mat/get-for-2-prongs-on-loop.js';
 export { getPotentialClosestPointsOnCurveCertified } from './closest-boundary-point/get-potential-closest-points-on-curve-certified.js';
 export { getCloseBoundaryPointsCertified } from './closest-boundary-point/get-close-boundary-points-certified.js';
-export { getMeta } from './find-mat/get-meta.js';
+export { getPartialMeta, getPointToCpNode } from './find-mat/get-meta.js';
 export { findAndAddHoleClosing2Prongs } from './find-2-prong/find-and-add-hole-closing-2-prongs.js';

package/src/mat/add-to-cp-tree.ts

@@ -1,10 +1,8 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { Circle } from '../geometry/circle.js';
-import { ContactPoint } from '../contact-point/contact-point.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { CpNode } from '../cp-node/cp-node.js';
-import { CpNodeFs } from '../cp-node/cp-node-fs.js';
+import type  { Circle } from '../geometry/circle.js';
+import type  { ContactPoint } from '../contact-point/contact-point.js';
+import type  { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import type  { CpNode } from '../cp-node/cp-node.js';
+import type { MatMeta } from '../index.js';
 import { getCpNodeToLeftOrSame } from './get-cp-node-to-left-or-same.js';
 import { insertCpNode } from '../cp-node/fs/insert-cp-node.js';
 import { joinSpokes } from '../add-n-prong.ts/join-spokes.js';
@@ -24,10 +22,13 @@ function addToCpTree(
         isHoleClosing: boolean,
         circle: Circle, 
         orders: number[],
-        cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        meta: MatMeta,
         poss: PointOnShape[],
         neighbors? : CpNode[]): { anyFailed: boolean, cpNodes: (CpNode | undefined) [] } {
 
+    const { cpTrees } = meta;
+
     let anyFailed = false;
     const cpNodes = poss.map((pos,i) => {
         const order = orders[i];
@@ -38,7 +39,15 @@ function addToCpTree(
             ? getCpNodeToLeftOrSame(cpTree, pos, order, 0)
             : neighbors[i];
 
-        const cpNode = insertCpNode(insertIfOrderIsWrong, isHoleClosing, false, cpTree, cp, pred);
+        const cpNode = insertCpNode(
+            insertIfOrderIsWrong,
+            isHoleClosing,
+            false,
+            cpTree,
+            cp,
+            pred,
+            meta.lastInsertId
+        );
 
         if (cpNode === undefined) { anyFailed = true; }
 

package/src/mat/get-branches.ts

@@ -3,44 +3,51 @@ import { getBranch } from '../cp-node/fs/get-branch.js';
 import { getNonTerminatingOnCircle } from '../cp-node/fs/get-non-terminating-on-circle.js';
 
 
+/**
+ * Returns all branches associated with the give cpNode.
+ * 
+ * * the final `CpNode` of each branch is not returned to improve symmetry
+ * 
+ * @param cpNode `CpNode` representing the start vertex.
+ */
 function getBranches(
-		cpNode: CpNode): CpNode[][] {
+        cpNode: CpNode): CpNode[][] {
 
-	const branches: CpNode[][] = [];
-	const cpNodeStack: CpNode[] = [cpNode];
-	const takenBranches: Set<CpNode> = new Set();
-	while (cpNodeStack.length > 0) {
-		const cpNode = cpNodeStack.pop()!;
-		const branch = getBranch(cpNode);
+    const branches: CpNode[][] = [];
+    const cpNodeStack: CpNode[] = [cpNode];
+    const takenBranches: Set<CpNode> = new Set();
+    while (cpNodeStack.length > 0) {
+        const cpNode = cpNodeStack.pop()!;
+        const branch = getBranch(cpNode);
 
-		if (branch.length === 0) {
-			continue;
-		}
+        if (branch.length === 0) {
+            continue;
+        }
 
-		branches.push(branch);
+        branches.push(branch);
 
-		const cpNodeS = branch[0];
-		const cpNodeE = branch[branch.length-1].next.prevOnCircle;
+        const cpNodeS = branch[0];
+        const cpNodeE = branch[branch.length-1].next.prevOnCircle;
 
-		takenBranches.add(cpNodeS);
-		takenBranches.add(cpNodeE);
+        takenBranches.add(cpNodeS);
+        takenBranches.add(cpNodeE);
 
-		const _cpNodesS = getNonTerminatingOnCircle(cpNodeS, true);
-		const _cpNodesE = getNonTerminatingOnCircle(cpNodeE, true);
-		const cpNodesS = _cpNodesS.filter(cpNode => !takenBranches.has(cpNode));
-		const cpNodesE = _cpNodesE.filter(cpNode => !takenBranches.has(cpNode));
+        const _cpNodesS = getNonTerminatingOnCircle(cpNodeS, true);
+        const _cpNodesE = getNonTerminatingOnCircle(cpNodeE, true);
+        const cpNodesS = _cpNodesS.filter(cpNode => !takenBranches.has(cpNode));
+        const cpNodesE = _cpNodesE.filter(cpNode => !takenBranches.has(cpNode));
 
-		for (const cpNode of cpNodesS) {
-			takenBranches.add(cpNode);
-		}
-		for (const cpNode of cpNodesE) {
-			takenBranches.add(cpNode);
-		}
+        for (const cpNode of cpNodesS) {
+            takenBranches.add(cpNode);
+        }
+        for (const cpNode of cpNodesE) {
+            takenBranches.add(cpNode);
+        }
 
-		cpNodeStack.push(...cpNodesS, ...cpNodesE);
-	}
+        cpNodeStack.push(...cpNodesS, ...cpNodesE);
+    }
 
-	return branches;
+    return branches;
 }
 
 

package/src/mat/mat-meta.ts

@@ -19,12 +19,17 @@ interface MatMeta {
     
     /** 
      * Primarily for internal use. A tree structure storing the
-     * [[CpNode]]s of the MAT by their compare order, i.e. their cyclic order
+     * `CpNode`s of the MAT by their compare order, i.e. their cyclic order
      * around the shape boundary.
      */
     readonly cpTrees: Map<Loop, LlRbTree<CpNode>>;
     /** A map from a bezier and t value to a `PointOnShape` */
     readonly pointToCpNode: TriMap<Loop,number,number,CpNode>;
+    /**
+     * Stores the last insert id so each `CpNode` can have a unique id for
+     * debugging purposes
+     */
+    readonly lastInsertId: { id: number };
 }
 
 

package/src/mat/mat.ts

@@ -5,13 +5,13 @@ import { MatMeta } from './mat-meta.js';
 /**
  * Represents a complete Medial Axis Transform (MAT).
  * 
- * The MAT is fully described through its [[CpNode]] property. The [[cpTrees]]
+ * The MAT is fully described through its `CpNode` property. The `cpTrees`
  * property is only added to facilitate extension of the MAT, e.g. by adding
- * extra maximal disks and is typically not used. See [[CpNode]] for more
+ * extra maximal disks and is typically not used. See `CpNode` for more
  * details.
  */
 interface Mat {
-    /** A complete representation of the MAT. See [[CpNode]]. */
+    /** A complete representation of the MAT. See `CpNode`. */
     cpNode: CpNode;
     /**
      * Stores additional info about the shape that could be useful for various

package/src/mat/simplify-mat.ts

@@ -75,7 +75,7 @@ function simplifyMat(
                 !cpNode.isHoleClosing
             )(cpNode)) {
 
-            removeVertex(cpNode, mat.meta.cpTrees);
+            removeVertex(cpNode, mat.meta);
         }
     }
 

package/src/point-on-shape/compare-poss.ts

@@ -2,10 +2,10 @@ import { PointOnShape } from "./point-on-shape.js";
 
 
 /**
- * Compares two [[PointOnShape]]s according to their cyclic ordering imposed
+ * Compares two `PointOnShape`s according to their cyclic ordering imposed
  * by their relative positions on the shape boundary. 
- * @param a The first [[PointOnShape]].
- * @param b The second [[PointOnShape]].
+ * @param a The first `PointOnShape`.
+ * @param b The second `PointOnShape`.
  * @internal
  */
 function comparePoss(

package/src/point-on-shape/get-osculating-circle.ts

@@ -9,7 +9,7 @@ import { PointOnShape } from './point-on-shape.js';
  * 
  * @param minCurvature If not Number.POSITIVE_INFINITY then the
  * circle radius will be limited to this value.
- * @param pos The [[PointOnShape]] identifying the point.
+ * @param pos The `PointOnShape` identifying the point.
  * @param useMaxRadius
  */
 function getOsculatingCircle(

package/src/point-on-shape/point-on-shape.ts

@@ -2,7 +2,7 @@ import { Curve } from '../curve/curve.js';
 
 
 interface PointOnShape {
-    /** The [[ICurve]] on the shape boundary this points belong to. */
+    /** The `Curve` on the shape boundary this points belong to. */
     curve: Curve;
     /** The bezier parameter value on the curve identifying the point coordinates. */
     t: number;