flo-mat 2.0.1 → 2.0.3

package/src/get-curve/get-edge-direction.ts

@@ -13,17 +13,16 @@ import { isPosSharpCorner } from '../point-on-shape.js';
  * @param cpNode 
  */
 function getEdgeDirection(cpNode: CpNode) {
+    const circleCenter = cpNode.cp.circle.center;
 
-    let circleCenter = cpNode.cp.circle.center;
+    const cp1 = cpNode;
+    const cp2 = cpNode.nextOnCircle;
 
-    let cp1 = cpNode;
-    let cp2 = cpNode.nextOnCircle;
+    const pos1 = cp1.cp.pointOnShape;
+    const pos2 = cp2.cp.pointOnShape;
 
-    let pos1 = cp1.cp.pointOnShape;
-    let pos2 = cp2.cp.pointOnShape;
-
-    let p1 = pos1.p;
-    let p2 = pos2.p;
+    const p1 = pos1.p;
+    const p2 = pos2.p;
 
     let vDir;
     
@@ -46,20 +45,20 @@ function getEdgeDirection(cpNode: CpNode) {
             curve2 = pos1.curve;
         }
 
-        let tan1 = toUnitVector(tangent(curve1.ps, 0));
-        let tan2 = reverse( toUnitVector(tangent(curve2.ps, 1)) );
+        const tan1 = toUnitVector(tangent(curve1.ps, 0));
+        const tan2 = reverse( toUnitVector(tangent(curve2.ps, 1)) );
         
-        let x = dot(tan1, tan2);
+        const x = dot(tan1, tan2);
         // 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.
-        let cosθ = Math.sqrt((1+x)/2);
-        let sinθ = Math.sqrt((1-x)/2);
+        const cosθ = Math.sqrt((1+x)/2);
+        const sinθ = Math.sqrt((1-x)/2);
         
         vDir = rotate(sinθ, cosθ, tan2);
     }
 
-    let v = translate(
+    const v = translate(
         toUnitVector(vDir),
         circleCenter 
     );

package/src/get-interface-ccw.ts

@@ -27,14 +27,14 @@ import { compareCurvaturesAtInterface } from "./compare-curvatures-at-interface.
  */
 // TODO - improve and make at least 46-bitlength precondition
 function getInterfaceCcw(psI: number[][], psO: number[][]) {
-    let lenI = psI.length;
+    const lenI = psI.length;
 
     // second last control point of incoming curve
-    let p0 = psI[lenI-2];  
+    const p0 = psI[lenI-2];  
     // last control point of incoming curve / first control point of outgoing
-    let p1 = psO[0];
+    const p1 = psO[0];
     // second control point of outgoing curve
-    let p2 = psO[1];
+    const p2 = psO[1];
 
     /*
     if (typeof _bez_debug_ !== 'undefined') {
@@ -63,18 +63,18 @@ function getInterfaceCcw(psI: number[][], psO: number[][]) {
     */
 
     // Max one bit can be added in the calculations below due to bit-alignment
-    let xE = p1[0] - p0[0];  // tangent x-coordinate
-	let yE = p1[1] - p0[1];  // tangent y-coordinate
-	let xS = p2[0] - p1[0];  // tangent x-coordinate
-    let yS = p2[1] - p1[1];  // tangent y-coordinate
+    const xE = p1[0] - p0[0];  // tangent x-coordinate
+	const yE = p1[1] - p0[1];  // tangent y-coordinate
+	const xS = p2[0] - p1[0];  // tangent x-coordinate
+    const yS = p2[1] - p1[1];  // tangent y-coordinate
     
 	// If the tangent is to be found at t === 0 or t === 1 then using a basic 
     // property of bezier curves we can find the tangents easily as below
     
     // (non-normalized) tangent of incoming curve at t === 1
-    let tangentAtEnd = [xE,yE];
+    const tangentAtEnd = [xE,yE];
     // (non-normalized) tangent of outgoing curve at t === 0
-	let tangentAtStart = [xS,yS];
+	const tangentAtStart = [xS,yS];
 
     // The cross calculated below will have a max bitlength of 
     // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
@@ -82,7 +82,7 @@ function getInterfaceCcw(psI: number[][], psO: number[][]) {
     //let crossTangents = cross(tangentAtEnd, tangentAtStart);
     
     // The cross below is exact by adaptive infinite precision
-    let crossTangents = orient2d(p0, p1, p2);
+    const crossTangents = orient2d(p0, p1, p2);
 
 	if (crossTangents !== 0) {
 		return crossTangents;
@@ -91,7 +91,7 @@ function getInterfaceCcw(psI: number[][], psO: number[][]) {
     // The dot calculated below will have a max bitlength of 
     // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
     // If the preconditions are met it is exact
-    let dotTangents = dot(tangentAtEnd, tangentAtStart);
+    const dotTangents = dot(tangentAtEnd, tangentAtStart);
     if (dotTangents > 0) {
         // Curves go in same direction at interface - neither clock or 
         // anti-clockwise.

package/src/loop/get-max-coordinate.ts

@@ -17,10 +17,10 @@ function getLoopsMetrics(loops: number[][][][]): {
     let minY = Number.POSITIVE_INFINITY;
     let maxY = Number.NEGATIVE_INFINITY;
 
-    for (let loop of loops) { for (let ps of loop) { for (let p of ps) {
-        let x = p[0];
-        let y = p[1];
-        let c = max(abs(x), abs(y));
+    for (const loop of loops) { for (const ps of loop) { for (const p of ps) {
+        const x = p[0];
+        const y = p[1];
+        const c = max(abs(x), abs(y));
         if (c > maxCoordinate) { maxCoordinate = c; }
         if (x < minX) { minX = x; }
         if (x > maxX) { maxX = x; }
@@ -28,9 +28,9 @@ function getLoopsMetrics(loops: number[][][][]): {
         if (y > maxY) { maxY = y; }
     } } }
 
-    let width  = maxX - minX;
-    let height = maxY - minY;
-    let maxRadius = max(width, height);
+    const width  = maxX - minX;
+    const height = maxY - minY;
+    const maxRadius = max(width, height);
 
     return { maxCoordinate, maxRadius };
 }

package/src/loop.ts

@@ -17,9 +17,9 @@ interface Loop {
  * @param beziers A pre-ordered array of bezier curves to add initially.
  */
 function loopFromBeziers(beziers: number[][][] = []) {
-    let curves: Curve[] = [];
+    const curves: Curve[] = [];
 
-    let loop: Loop = {
+    const loop: Loop = {
         beziers,
         curves
     };
@@ -30,7 +30,7 @@ function loopFromBeziers(beziers: number[][][] = []) {
     
     for (let i=0; i<beziers.length; i++) {
 
-        let curve: Curve = {
+        const curve: Curve = {
             loop,
             ps: beziers[i],
             prev,
@@ -45,7 +45,7 @@ function loopFromBeziers(beziers: number[][][] = []) {
     }
 
     // close loop
-    let lastCurve = curves[curves.length-1];
+    const lastCurve = curves[curves.length-1];
     curves[0].prev = lastCurve;
     lastCurve.next = curves[0];
 

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

@@ -23,16 +23,16 @@ function addToCpGraph(
         poss    : IPointOnShape[],
         neighbors? : CpNode[][]) {
 
-    let newCps = poss.map((pos, i) => {
-        let cpTree = cpTrees.get(pos.curve.loop);
+    const newCps = poss.map((pos, i) => {
+        const cpTree = cpTrees.get(pos.curve.loop);
 
-        let newCp_: ContactPoint = { pointOnShape: pos, circle, order: orders[i], order2: 0 };
+        const newCp_: ContactPoint = { pointOnShape: pos, circle, order: orders[i], order2: 0 };
 
-        let neighboringCp = neighbors 
+        const neighboringCp = neighbors 
             ? neighbors[i]
             : getNeighbouringPoints(cpTree, pos, orders[i], 0);
 
-        let newCp = CpNode.insert(
+        const newCp = CpNode.insert(
                 false,
                 false,
                 cpTree,
@@ -43,10 +43,10 @@ function addToCpGraph(
         return newCp;
     });
 
-    let len = poss.length;
+    const len = poss.length;
     for (let i=0; i<len; i++) {
-        let indxPrev = i === 0     ? len-1 : i-1;
-        let indxNext = i === len-1 ? 0     : i+1;
+        const indxPrev = i === 0     ? len-1 : i-1;
+        const indxNext = i === len-1 ? 0     : i+1;
 
         newCps[i].prevOnCircle = newCps[indxPrev];
         newCps[i].nextOnCircle = newCps[indxNext];

package/src/mat/closest-boundary-point/closest-points-on-curve.ts

@@ -33,8 +33,7 @@ function closestPointsOnCurve(
         : _poly;
 
     // let roots: Omit<RootInterval,'multiplicity'>[] = allRootsMultiWithErrBounds(
-    let roots: Omit<RootInterval,'multiplicity'>[];
-    roots = allRootsCertified(poly, tS, tE);
+    const roots: Omit<RootInterval,'multiplicity'>[] = allRootsCertified(poly, tS, tE);
 
     // Also test the endpoints
     let push0 = true;
@@ -64,12 +63,12 @@ function closestPointsOnCurve(
         roots.push({ tS: tE, tE: tE });
     }
 
-    let ps = roots.map(
+    const ps = roots.map(
         root => { 
-            let tS = root.tS;
-            let tE = root.tE;
+            const tS = root.tS;
+            const tE = root.tE;
             // TODO - tS, tE should always stay within [0,1] - modify findRootsMulti
-            let t = tS < 0 
+            const t = tS < 0 
                 ? 0
                 : tE > 1 ? 1 : (tS + tE)/2;
             // TODO - why does evalDeCasteljau not work here?

package/src/mat/closest-boundary-point/cull-bezier-pieces.ts

@@ -17,7 +17,7 @@ function cullBezierPieces(
     const CULL_THRESHOLD = 0;
 
     if (bezierPieces.length > CULL_THRESHOLD) {
-        let bestSquaredDistance = getBestDistanceSquared(
+        const bestSquaredDistance = getBestDistanceSquared(
             bezierPieces, p
         );
         bezierPieces = cullByLooseBoundingBox(

package/src/mat/closest-boundary-point/cull-by-loose-bounding-box.ts

@@ -16,15 +16,15 @@ function cullByLooseBoundingBox(
         p: number[],
         dSquared: number) {
 
-    let candidateBezierPieces = [];
+    const candidateBezierPieces = [];
 
     for (let i=0; i<bezierPieces.length; i++) {
-        let bezierPiece = bezierPieces[i];
-        let ps = bezierPiece.curve.ps;
+        const bezierPiece = bezierPieces[i];
+        const ps = bezierPiece.curve.ps;
         
-        let boundingBox = getBoundingBox_(ps);
+        const boundingBox = getBoundingBox_(ps);
         
-        let d = getClosestSquareDistanceToRect(
+        const d = getClosestSquareDistanceToRect(
             boundingBox,
             p
         );

package/src/mat/closest-boundary-point/cull-by-tight-boundary-box.ts

@@ -20,14 +20,14 @@ function cullByTightBoundingBox(
         p: number[],
         bestSquaredDistance: number) {
 
-    let candidateBezierPieces = []; 
+    const candidateBezierPieces = [];
 
     for (let i=0; i<bezierPieces.length; i++) {
-        let bezierPiece = bezierPieces[i];
-        let ps = bezierPiece.curve.ps;
+        const bezierPiece = bezierPieces[i];
+        const ps = bezierPiece.curve.ps;
         
-        let tightBoundingBox = getBoundingBoxTight_(ps);
-        let d = getClosestSquaredDistanceToRotatedRect(
+        const tightBoundingBox = getBoundingBoxTight_(ps);
+        const d = getClosestSquaredDistanceToRotatedRect(
                 tightBoundingBox,
                 p
         );

package/src/mat/closest-boundary-point/get-best-distance-squared.ts

@@ -14,14 +14,14 @@ function getBestDistanceSquared(
 
     let bestSquaredDistance = Number.POSITIVE_INFINITY;
     for (let i=0; i<bezierPieces.length; i++) {
-        let bezierPiece = bezierPieces[i];
+        const bezierPiece = bezierPieces[i];
 
-        let ps = bezierPiece.curve.ps;
+        const ps = bezierPiece.curve.ps;
         
-        let p1 = evalDeCasteljau(ps, bezierPiece.ts[0]);
-        let p2 = evalDeCasteljau(ps, bezierPiece.ts[1]);
+        const p1 = evalDeCasteljau(ps, bezierPiece.ts[0]);
+        const p2 = evalDeCasteljau(ps, bezierPiece.ts[1]);
         
-        let d = Math.min(
+        const d = Math.min(
             squaredDistanceBetween(p, p1),
             squaredDistanceBetween(p, p2)
         ); 

package/src/mat/closest-boundary-point/get-close-boundary-points.ts

@@ -21,20 +21,20 @@ function getCloseBoundaryPoints(
 		y: IPointOnShape,
 		distance: number) {
 	
-	let touchedCurve = y.curve;
-	let t = y.t;
-	let p_ = y.p;
+	const touchedCurve = y.curve;
+	const t = y.t;
+	const p_ = y.p;
 
 	bezierPieces = cullBezierPieces(bezierPieces, point);
  
 	// TODO - integrate with is-another-cp-closeby - we MUST check angle too!
-	let DISTANCE_TOLERANCE = 1e-9;
-	let posInfos: { pos: IPointOnShape; d: number }[] = [];
+	const DISTANCE_TOLERANCE = 1e-9;
+	const posInfos: { pos: IPointOnShape; d: number }[] = [];
 	for (let i=0; i<bezierPieces.length; i++) {
-		let bezierPiece = bezierPieces[i];
+		const bezierPiece = bezierPieces[i];
 
 		// TOOD - important - should be able to return multiple points
-		let ps = closestPointsOnCurve(
+		const ps = closestPointsOnCurve(
 				bezierPiece.curve, 
 				point, 
 				bezierPiece.ts, 
@@ -45,8 +45,8 @@ function getCloseBoundaryPoints(
 		//if (ps === undefined) { continue; }
 
 		for (let j=0; j<ps.length; j++) {
-			let p = ps[j];
-			let d = distanceBetween(p.p, point);
+			const p = ps[j];
+			const d = distanceBetween(p.p, point);
 
 			let curve = bezierPiece.curve;
 			let t_= p.t;
@@ -67,23 +67,23 @@ function getCloseBoundaryPoints(
 		// TODO - in future remove all these checks and join n-prongs when they
 		// are being added - much simpler and more symmetric. Remeber order when
 		// comparing closeness!
-		let indexesToCheck: number[] = [];
+		const indexesToCheck: number[] = [];
 		for (let i=0; i<posInfos.length; i++) {
-			let pi = posInfos[i];
+			const pi = posInfos[i];
 			// Only check if they are close to the edges. Why??
 			//if (pi.pos.t < 1e-2 || 1-pi.pos.t < 1e-2) {
 				indexesToCheck.push(i);
 			//}
 		}
-		let indexesToRemove: number[] = [];
+		const indexesToRemove: number[] = [];
 		for (let i=0; i<indexesToCheck.length; i++) {
 			for (let j=i+1; j<indexesToCheck.length; j++) {
 				if (i === j) { continue; }
-				let p1 = posInfos[indexesToCheck[i]].pos.p;
-				let p2 = posInfos[indexesToCheck[j]].pos.p;
+				const p1 = posInfos[indexesToCheck[i]].pos.p;
+				const p2 = posInfos[indexesToCheck[j]].pos.p;
 				// Below checks for source point too - similar to 
 				// isAnotherCpCloseBy
-				let p3 = p_;
+				const p3 = p_;
 				if ((Math.abs(p1[0] - p2[0]) < 1e-6 && 
 					 Math.abs(p1[1] - p2[1]) < 1e-6) ||
 					

package/src/mat/closest-boundary-point/get-closest-boundary-point.ts

@@ -27,9 +27,9 @@ function getClosestBoundaryPoint(
 	let bestDistance = Number.POSITIVE_INFINITY;
 	let posInfo: { pos: IPointOnShape; d: number };
 	for (let i=0; i<bezierPieces.length; i++) {
-		let bezierPiece = bezierPieces[i];
+		const bezierPiece = bezierPieces[i];
 
-		let ps = closestPointsOnCurve(
+		const ps = closestPointsOnCurve(
 				bezierPiece.curve, 
 				point, 
 				bezierPiece.ts, 
@@ -37,11 +37,11 @@ function getClosestBoundaryPoint(
 				t
 		);
 
-		let p = getObjClosestTo(point, ps, p => p.p)
+		const p = getObjClosestTo(point, ps, p => p.p)
 
 		if (p === undefined) { continue; }
 
-		let d = distanceBetween(p.p, point);
+		const d = distanceBetween(p.p, point);
 
 		let curve = bezierPiece.curve;
 		let t_= p.t;

package/src/mat/cmp-cp-on-delta.ts

@@ -20,12 +20,12 @@ function cmpCpOnδ(
         return 1;
     }
 
-    let cpBef = δ[0].cp;
-    let cpAft = δ[1].cp;
+    const cpBef = δ[0].cp;
+    const cpAft = δ[1].cp;
 
-    let cmp     = compareCps(cpBef, cpAft); 
-    let cmpPrev = compareCps(cpBef, cp);
-    let cmpNext = compareCps(cp,    cpAft);
+    const cmp     = compareCps(cpBef, cpAft); 
+    const cmpPrev = compareCps(cpBef, cp);
+    const cmpNext = compareCps(cp,    cpAft);
     
     if (cmp < 0) {
         if (cmpPrev > 0 || cmpNext > 0) {

package/src/mat/create-new-cp-tree.ts

@@ -8,14 +8,14 @@ import { Loop } from '../loop.js';
  * @param cpNode 
  */
 function createNewCpTree(cpNode: CpNode) {
-	let newCpTrees: Map<Loop,LlRbTree<CpNode>> = new Map();
+	const newCpTrees: Map<Loop,LlRbTree<CpNode>> = new Map();
 
-	let cps = cpNode.getAllOnLoop();
+	const cps = cpNode.getAllOnLoop();
 
 	cps.forEach(f);
 
 	function f(cpNode: CpNode) {
-		let loop = cpNode.cp.pointOnShape.curve.loop;
+		const loop = cpNode.cp.pointOnShape.curve.loop;
 		let cpTree = newCpTrees.get(loop);
 		if (!cpTree) { 
 			// qqq cpTree = new LlRbTree(CpNode.comparator, [], true); 

package/src/mat/find-mat/add-1-prong.ts

@@ -1,5 +1,5 @@
-/** @hidden */
-declare var _debug_: Debug; 
+/** @internal */
+declare const _debug_: Debug; 
 
 import { LlRbTree } from 'flo-ll-rb-tree';
 import { Debug }   from '../../debug/debug.js';
@@ -44,10 +44,10 @@ function add1Prong(
 	}
 	
 	//let circle = PointOnShape.getOsculatingCircle(maxOsculatingCircleRadius, pos);
-	let circle = getOsculatingCircle(maxOsculatingCircleRadius, pos);
+	const circle = getOsculatingCircle(maxOsculatingCircleRadius, pos);
 	
-	//let order = PointOnShape.calcOrder(circle, pos);
-	let order = calcPosOrder(circle, pos);
+	//const order = PointOnShape.calcOrder(circle, pos);
+	const order = calcPosOrder(circle, pos);
 	// Make sure there isn't already a ContactPoint close by - it can cause
 	// floating point stability issues.
 	if (isAnotherCpCloseby(cpGraphs, pos, circle, order, 0, 1000, 'magenta')) {

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

@@ -1,5 +1,5 @@
-/** @hidden */
-declare var _debug_: Debug;
+/** @internal */
+declare const _debug_: Debug;
 
 import { LlRbTree } from 'flo-ll-rb-tree';
 import { exponent } from 'big-float-ts';
@@ -34,8 +34,8 @@ function add2Prong(
 		extreme       : number): CpNode {
 
 	//let orderSource   = PointOnShape.calcOrder(circle, posSource);
-	let orderSource   = calcPosOrder(circle, posSource);
-	let orderAntipodes = posAntipodes.map(
+	const orderSource   = calcPosOrder(circle, posSource);
+	const orderAntipodes = posAntipodes.map(
 		posAntipode => {
 			//console.log(circle.center)
 			//return PointOnShape.calcOrder(circle, posAntipode.pos);
@@ -58,8 +58,8 @@ function add2Prong(
 
 	let isCloseByAntipodes = false;
 	for (let i=0; i<posAntipodes.length; i++) {
-		let posAntipode = posAntipodes[i];
-		let orderAntipode = orderAntipodes[i];
+		const posAntipode = posAntipodes[i];
+		const orderAntipode = orderAntipodes[i];
 
 		if (isAnotherCpCloseby(cpGraphs, posAntipode.pos, circle, orderAntipode, 0, extreme, 'red')) {
 			isCloseByAntipodes = true;
@@ -80,22 +80,22 @@ function add2Prong(
 	}
 
 	// Antipode
-	let newCpAntipodes: CpNode[] = [];
-	let cpAntipodes: ContactPoint[] = [];
-	let cpTreeAntipodes: LlRbTree<CpNode>[] = [];
-	let deltaAntipodes: CpNode[][] = [];
-	let loopAntipodes: Loop[] = [];
+	const newCpAntipodes: CpNode[] = [];
+	const cpAntipodes: ContactPoint[] = [];
+	const cpTreeAntipodes: LlRbTree<CpNode>[] = [];
+	const deltaAntipodes: CpNode[][] = [];
+	const loopAntipodes: Loop[] = [];
 	for (let i=0; i<posAntipodes.length; i++) {
-		let posAntipode = posAntipodes[i];
-		let orderAntipode = orderAntipodes[i];
+		const posAntipode = posAntipodes[i];
+		const orderAntipode = orderAntipodes[i];
 
-		let cpAntipode: ContactPoint = { pointOnShape: posAntipode.pos, circle, order: orderAntipode, order2: 0 };
+		const cpAntipode: ContactPoint = { pointOnShape: posAntipode.pos, circle, order: orderAntipode, order2: 0 };
 		cpAntipodes.push(cpAntipode);
-		let loopAntipode = posAntipode.pos.curve.loop;
+		const loopAntipode = posAntipode.pos.curve.loop;
 		loopAntipodes.push(loopAntipode);
-		let cpTreeAntipode = cpGraphs.get(loopAntipode);
+		const cpTreeAntipode = cpGraphs.get(loopAntipode);
 		cpTreeAntipodes.push(cpTreeAntipode);
-		let deltaAntipode = getNeighbouringPoints(
+		const deltaAntipode = getNeighbouringPoints(
 			cpTreeAntipode, posAntipode.pos, orderAntipode, 0
 		);	
 		deltaAntipodes.push(deltaAntipode);
@@ -111,13 +111,13 @@ function add2Prong(
 	
 	
 	// Source
-	let cpSource: ContactPoint = { pointOnShape: posSource, circle, order: orderSource, order2: 0 };
-	let loopSource = posSource.curve.loop;
-	let cpTreeSource = cpGraphs.get(loopSource);
-	let deltaSource = getNeighbouringPoints(
+	const cpSource: ContactPoint = { pointOnShape: posSource, circle, order: orderSource, order2: 0 };
+	const loopSource = posSource.curve.loop;
+	const cpTreeSource = cpGraphs.get(loopSource);
+	const deltaSource = getNeighbouringPoints(
 		cpTreeSource, posSource, orderSource, 0
 	);
-	let newCpSource = CpNode.insert(
+	const newCpSource = CpNode.insert(
 		holeClosing,
 		false,
 		cpTreeSource,
@@ -134,19 +134,19 @@ function add2Prong(
 		newCpAntipodes[0].prevOnCircle = newCpSource;
 		newCpAntipodes[0].nextOnCircle = newCpSource;
 	} else {
-		let cpNodes = newCpAntipodes.slice();
+		const cpNodes = newCpAntipodes.slice();
 		cpNodes.push(newCpSource);
 
 		// Order points according to their angle with the x-axis
 		cpNodes.sort(byAngle(circle));
 
 		for (let i=0; i<cpNodes.length; i++) {
-			let iNext = (i+1 === cpNodes.length) ? 0 : i+1;
-			let iPrev = (i === 0) ? cpNodes.length-1 : i-1;
+			const iNext = (i+1 === cpNodes.length) ? 0 : i+1;
+			const iPrev = (i === 0) ? cpNodes.length-1 : i-1;
 
-			let cpNodeCurr = cpNodes[i];
-			let cpNodeNext = cpNodes[iNext];
-			let cpNodePrev = cpNodes[iPrev];
+			const cpNodeCurr = cpNodes[i];
+			const cpNodeNext = cpNodes[iNext];
+			const cpNodePrev = cpNodes[iPrev];
 
 			cpNodeCurr.nextOnCircle = cpNodeNext;
 			cpNodeCurr.prevOnCircle = cpNodePrev;
@@ -157,11 +157,11 @@ function add2Prong(
 	if (holeClosing) { 
 		// TODO - important - take care of case where there are more than 1 antipode
 		// Duplicate ContactPoints
-		let cpB2: ContactPoint = { pointOnShape: posAntipodes[0].pos, circle, order: cpAntipodes[0].order, order2: +1 };
-		let newCpB2Node = CpNode.insert(true, false, cpTreeAntipodes[0], cpB2, newCpAntipodes[0]);
+		const cpB2: ContactPoint = { pointOnShape: posAntipodes[0].pos, circle, order: cpAntipodes[0].order, order2: +1 };
+		const newCpB2Node = CpNode.insert(true, false, cpTreeAntipodes[0], cpB2, newCpAntipodes[0]);
 		
-		let cpB1: ContactPoint = { pointOnShape: posSource, circle, order: cpSource.order, order2: -1 };
-		let newCpB1Node = CpNode.insert(true, false, cpTreeSource, cpB1, newCpSource.prev);
+		const cpB1: ContactPoint = { pointOnShape: posSource, circle, order: cpSource.order, order2: -1 };
+		const newCpB1Node = CpNode.insert(true, false, cpTreeSource, cpB1, newCpSource.prev);
 		
 		// Connect graph
 		newCpB1Node.prevOnCircle = newCpB2Node;
@@ -185,7 +185,7 @@ function add2Prong(
 			elems = _debug_.generated.elems['twoProng_regular'];
 		}
 
-		let elem = elems[elems.length-1];
+		const elem = elems[elems.length-1];
 
 		if (!newCpSource) { console.log('asas')}
 		elem.cpNode = newCpSource;
@@ -230,10 +230,10 @@ function getSize(x: number, y: number) {
 
 /** @hidden */
 function byAngle(circle: Circle) {
-	let c = circle.center;
-	let r = circle.radius;
+	const c = circle.center;
+	const r = circle.radius;
 
-	let exp = exponent(r);
+	const exp = exponent(r);
 
 	return function(_a: CpNode, _b: CpNode) {
 		let a = _a.cp.pointOnShape.p;
@@ -244,14 +244,14 @@ function byAngle(circle: Circle) {
 		b = [b[0]-c[0], b[1]-c[1]];
 
 		// Scale
-		let ax = scale(a[0], exp);
-		let ay = scale(a[1], exp);
-		let bx = scale(b[0], exp);
-		let by = scale(b[1], exp);
+		const ax = scale(a[0], exp);
+		const ay = scale(a[1], exp);
+		const bx = scale(b[0], exp);
+		const by = scale(b[1], exp);
 
 		// Get 'size'
-		let sa = getSize(ax, ay);
-		let sb = getSize(bx, by);
+		const sa = getSize(ax, ay);
+		const sb = getSize(bx, by);
 
 		return sb - sa;
 	}

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

@@ -24,7 +24,7 @@ function add3Prong(
 			δ3s: CpNode[][]
 		}) {
 	
-	let { circle, ps: poss, δ3s } = threeProng;
+	const { circle, ps: poss, δ3s } = threeProng;
 
 	// Keep for possible future debugging.	
 	/*