flo-mat 2.0.1 → 2.0.3

package/src/mat/find-mat/add-debug-info.ts

@@ -6,13 +6,11 @@ import { Mat } from '../../mat.js';
 import { getBoundingBox_ } from '../../get-bounding-box-.js';
 
 
-/** @hidden */
-declare var _debug_: Debug; 
+/** @internal */
+declare const _debug_: Debug; 
 
 
-if (typeof _debug_ !== 'undefined') { 
-    var timingStart: number;
-}
+let timingStart: number;
 
 
 /** @hidden */
@@ -21,30 +19,30 @@ function addDebugInfo1(loops: Loop[]) {
     
     timingStart = performance.now();
 
-    for (let loop of loops) {
+    for (const loop of loops) {
         _debug_.fs.nameObj(loop,'l|');
     }
 
-    let generated = _debug_.generated;
+    const generated = _debug_.generated;
 
     //generated.elems.loop.push(...loops);
     //generated.elems.loops.push(loops);
 
-    for (let loop of loops) {
+    for (const loop of loops) {
         let i = 0;
         loop.curves.forEach(function(curve: Curve) {
-            let ps = curve.ps;
-            let hull = getBoundingHull(ps); 
+            const ps = curve.ps;
+            const hull = getBoundingHull(ps); 
 
             generated.elems.boundingHull.push(hull);
 
-            let looseBoundingBox = getBoundingBox_(ps);
+            const looseBoundingBox = getBoundingBox_(ps);
             generated.elems.looseBoundingBox.push(looseBoundingBox);
 
-            let tightBoundingBox = getBoundingBoxTight(ps);
+            const tightBoundingBox = getBoundingBoxTight(ps);
             generated.elems.tightBoundingBox.push(tightBoundingBox);
 
-            let corner = getCornerAtEnd(curve);
+            const corner = getCornerAtEnd(curve);
             if (corner.isSharp) {
                 generated.elems.sharpCorner.push(curve);
             } else if (corner.isDull) {
@@ -61,8 +59,8 @@ function addDebugInfo1(loops: Loop[]) {
 function addDebugInfo2() {
     if (typeof _debug_ === 'undefined') { return; }
 
-    let timing = _debug_.generated.timing;
-    let now = performance.now();
+    const timing = _debug_.generated.timing;
+    const now = performance.now();
     timing.holeClosers += now - timingStart;
     timingStart = now;
 }
@@ -71,9 +69,9 @@ function addDebugInfo2() {
 function addDebugInfo3() {
     if (typeof _debug_ === 'undefined') { return; }
 
-    let generated = _debug_.generated;
-    let timing = generated.timing;
-    let now = performance.now();
+    const generated = _debug_.generated;
+    const timing = generated.timing;
+    const now = performance.now();
 
     timing.oneAnd2Prongs += now - timingStart;
     timingStart = now;
@@ -83,8 +81,8 @@ function addDebugInfo3() {
 function addDebugInfo4(mat: Mat) {
     if (typeof _debug_ === 'undefined') { return; }
 
-    let generated = _debug_.generated;
-    let timing = generated.timing;
+    const generated = _debug_.generated;
+    const timing = generated.timing;
 
     generated.elems.mat.push(mat);
 

package/src/mat/find-mat/create-get-interesting-points-on-loop.ts

@@ -17,10 +17,10 @@ function getInterestingPointsOnLoop(
         maxLength: number) {
 
     return function(loop: Loop) {
-        let allPoints: IPointOnShape[] = [];
+        const allPoints: IPointOnShape[] = [];
 
         for (let i=0; i<loop.curves.length; i++) {
-            let curve = loop.curves[i];
+            const curve = loop.curves[i];
 
             // qqq if (lengthSquaredUpperBound(curve.ps) < minBezLength) {
             if (controlPointLinesLength(curve.ps) < minBezLength) {
@@ -43,10 +43,10 @@ function getInterestingPointsOnLoop(
 
             // let { maxima } = getCurvatureExtrema(curve.ps);
             // qqq let { maxCurvatureTs, maxNegativeCurvatureTs } = getCurvatureExtrema(curve.ps);
-            let { maxima } = getCurvatureExtrema(curve.ps);
+            const { maxima } = getCurvatureExtrema(curve.ps);
             // let maxAbsCurvatures = maxima.map(t => new PointOnShape(curve, t));
             // qqq let maxAbsCurvatures = [...maxCurvatureTs, ...maxNegativeCurvatureTs].map(t => new PointOnShape(curve, t));
-            let maxAbsCurvatures = [...maxima].map(t => new PointOnShape(curve, t));
+            const maxAbsCurvatures = [...maxima].map(t => new PointOnShape(curve, t));
 
             allPoints.push(
                 ...getContactCirclesAtInterface(curve), 

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

@@ -20,22 +20,22 @@ function createInitialCpGraph(
     let cpNode;
 
     for (let k=0; k<sharpCornerss.length; k++) {
-        let sharpCorners = sharpCornerss[k];
+        const sharpCorners = sharpCornerss[k];
 
-        // qqq let cpTree = new LlRbTree(CpNode.comparator, [], true);
-        let cpTree = new LlRbTree(CpNode.comparator, false);
+        // qqq const cpTree = new LlRbTree(CpNode.comparator, [], true);
+        const cpTree = new LlRbTree(CpNode.comparator, false);
         
         let cpNode1 = undefined;
         let cpNode2 = undefined;
-        for (let pos of sharpCorners) {
-            let ps = pos.curve.next.ps;
-            //let x = xMap.get(ps);
-            //let isIntersection = !!x;
+        for (const pos of sharpCorners) {
+            const ps = pos.curve.next.ps;
+            //const x = xMap.get(ps);
+            //const isIntersection = !!x;
             
-            let circle = { center: pos.p, radius: 0 };
+            const circle = { center: pos.p, radius: 0 };
 
-            let cp1: ContactPoint = { pointOnShape: pos, circle, order: -1, order2: 0 };
-            let cp2: ContactPoint = { pointOnShape: pos, circle, order: +1, order2: 0 };
+            const cp1: ContactPoint = { pointOnShape: pos, circle, order: -1, order2: 0 };
+            const cp2: ContactPoint = { pointOnShape: pos, circle, order: +1, order2: 0 };
 
             cpNode1 = CpNode.insert(false, /*isIntersection*/ false, cpTree, cp1, cpNode2);
             cpNode2 = CpNode.insert(false, /*isIntersection*/ false, cpTree, cp2, cpNode1);
@@ -49,7 +49,7 @@ function createInitialCpGraph(
 
         if (!cpNode) { cpNode = cpNode1; }
 
-        let loop = loops[k];
+        const loop = loops[k];
         cpTrees.set(loop, cpTree);
     }
 

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

@@ -1,5 +1,5 @@
-/** @hidden */
-declare var _debug_: Debug; 
+/** @internal */
+declare const _debug_: Debug; 
 
 import { Debug } from '../../../debug/debug.js';
 import { IPointOnShape } from '../../../point-on-shape.js';
@@ -23,7 +23,7 @@ function addDebugInfo(
         xs: TXForDebugging[], 
         holeClosing: boolean) {
 
-    let twoProng: TwoProngForDebugging = {
+    const twoProng: TwoProngForDebugging = {
             generated: _debug_.generated,
             bezierPieces,
             pos,
@@ -38,7 +38,7 @@ function addDebugInfo(
             cpNode: undefined
     };
 
-    let twoProngType = getTwoProngType(twoProng) as ElemType_TwoProng;
+    const twoProngType = getTwoProngType(twoProng) as ElemType_TwoProng;
     _debug_.generated.elems[twoProngType].push(twoProng);
 }
 

package/src/mat/find-mat/find-2-prong/cull-bezier-pieces.ts

@@ -25,12 +25,12 @@ function cullBezierPieces(
     }
 
 
-    let newPieces = [];
-    for (let bezierPiece of bezierPieces) {
-        let ps = bezierPiece.curve.ps;
+    const newPieces = [];
+    for (const bezierPiece of bezierPieces) {
+        const ps = bezierPiece.curve.ps;
         
-        let rect = getBoundingBox_(ps);
-        let bd = getClosestSquareDistanceToRect(rect, p);
+        const rect = getBoundingBox_(ps);
+        const bd = getClosestSquareDistanceToRect(rect, p);
         if (bd <= rSquared * TOLERANCE) {
             newPieces.push(bezierPiece);
         } 

package/src/mat/find-mat/find-2-prong/find-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 { lineLineIntersection, distanceBetween, squaredDistanceBetween, interpolate, dot } from 'flo-vector2d';
@@ -67,7 +67,7 @@ function find2Prong(
 
 	// The boundary piece that should contain the other point of 
 	// the 2-prong circle. (Defined by start and end points).
-	let { bezierPieces, δ } = getInitialBezierPieces(
+	const { bezierPieces, δ } = getInitialBezierPieces(
 		isHoleClosing, k, loops, cpTrees, y
 	);
 	//console.log(bezierPieces.length)
@@ -88,14 +88,14 @@ function find2Prong(
 	}
 
 	// The lines below is an optimization.
-	let r_ = reduceRadius(extreme, bezierPieces, p, x);
+	const r_ = reduceRadius(extreme, bezierPieces, p, x);
 	if (r > r_) {
 		x = interpolate(p, x, Math.sqrt(r_/r));
 	}
 
 	
 	/** Trace the convergence (for debugging). */
-	let xs: TXForDebugging[] = []; 
+	const xs: TXForDebugging[] = []; 
 	/** The antipode of the two-prong (successively refined) */
 	let z: { pos: IPointOnShape; d: number }; 
 	let i = 0;
@@ -107,7 +107,7 @@ function find2Prong(
 		i++
 
 		/** squared distance between source boundary point and circle center */
-		let r = squaredDistanceBetween(x, y.p);
+		const r = squaredDistanceBetween(x, y.p);
 
 		bezierPieces_ = cullBezierPieces(bezierPieces_, x, r);
 
@@ -120,11 +120,11 @@ function find2Prong(
 
 		if (z === undefined) {
 			if (typeof _debug_ !== 'undefined') {
-				let elems = _debug_.generated.elems;
-				let elem = isHoleClosing 
+				const elems = _debug_.generated.elems;
+				const elem = isHoleClosing 
 					? elems.twoProng_holeClosing
 					: elems.twoProng_regular
-				let elemStr = isHoleClosing
+				const elemStr = isHoleClosing
 					? 'hole-closing: ' + elem.length
 					: 'regular: ' + elem.length;
 				console.log(
@@ -140,7 +140,7 @@ function find2Prong(
 		}
 		
 		/** squared distance between anti-pode boundary point and circle center */
-		let d = squaredDistanceBetween(x, z.pos.p);
+		const d = squaredDistanceBetween(x, z.pos.p);
 		//if (i === 1 && d*oneProngTolerance >= r) {
 		if (i === 1 && r < d+oneProngTolerance) {
 			// It is a 1-prong.
@@ -174,9 +174,9 @@ function find2Prong(
 
 		// Find the point on the line connecting y with x that is  
 		// equidistant from y and z. This will be our next x.
-		let nextX = findEquidistantPointOnLine(x, y.p, z.pos.p);
+		const nextX = findEquidistantPointOnLine(x, y.p, z.pos.p);
 		
-		let squaredError = squaredDistanceBetween(x, nextX);
+		const squaredError = squaredDistanceBetween(x, nextX);
 		
 		x = nextX;
 
@@ -235,28 +235,28 @@ function reduceRadius(
 	let prevP = undefined;
 	let minRadius = 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]);
+		const p1 = evalDeCasteljau(ps, bezierPiece.ts[0]);
 		let r1 = Number.POSITIVE_INFINITY;
 
 		// Prevent evaluating the same points twice
 		if (!prevP || prevP[0] !== p1[0] || prevP[1] !== p1[1]) {
-			let cc1 = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p1);
+			const cc1 = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p1);
 			if (cc1) { r1 = squaredDistanceBetween(p, cc1);	}
 		}
 		
 		let r2 = Number.POSITIVE_INFINITY;
-		let p2 = evalDeCasteljau(ps, bezierPiece.ts[1]);
+		const p2 = evalDeCasteljau(ps, bezierPiece.ts[1]);
 
-		let cc2 = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p2);
+		const cc2 = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p2);
 		if (cc2) { r2 = squaredDistanceBetween(p, cc2);	}
 		
 		prevP = p2;
 		
-		let d = Math.min(r1, r2); 
+		const d = Math.min(r1, r2); 
 		
 		if (d < minRadius) {
 			minRadius = d;  
@@ -283,7 +283,7 @@ function getCircleCenterFrom2PointsAndNormal(
 		p1: number[]) {
 
 	// TODO - remove delta
-	let TOLERANCE = (1e-4 * extreme)**2;
+	const TOLERANCE = (1e-4 * extreme)**2;
 
 	// Ignore if p and p1 are too close together
 	if (squaredDistanceBetween(p,p1) < TOLERANCE) {
@@ -291,20 +291,20 @@ function getCircleCenterFrom2PointsAndNormal(
 	}
 
 	/** The perpindicular bisector between the two given points on the circle */
-	let pb = [
+	const pb = [
 		(p[0] + p1[0]) / 2,
 		(p[1] + p1[1]) / 2,
 	];
-	let tan = [p1[0] - p[0], p1[1] - p[1]];
-	let norm  = [-tan[1], tan[0]]; // Rotate by 90 degrees
-	let pb2 = [pb[0] + norm[0], pb[1] + norm[1]];
+	const tan = [p1[0] - p[0], p1[1] - p[1]];
+	const norm  = [-tan[1], tan[0]]; // Rotate by 90 degrees
+	const pb2 = [pb[0] + norm[0], pb[1] + norm[1]];
 
-	let res = lineLineIntersection([p,x], [pb, pb2]);
+	const res = lineLineIntersection([p,x], [pb, pb2]);
 
 	if (!res) { return undefined; }
 
-	let resO = [res[0] - p[0], res[1] - p[1]];
-	let xO = [x[0] - p[0], x[1] - p[1]];
+	const resO = [res[0] - p[0], res[1] - p[1]];
+	const xO = [x[0] - p[0], x[1] - p[1]];
 	if (dot(resO, xO) < 0) {
 		return undefined;
 	}

package/src/mat/find-mat/find-2-prong/find-equidistant-point-on-line.ts

@@ -10,7 +10,7 @@ function findEquidistantPointOnLine(x: number[], y: number[], z: number[]) {
 	// Some basic algebra (not shown) finds the required point.
 	
 	// Swap axes if x and y are more aligned to y-axis than to x-axis.
-	let swapAxes = Math.abs((x[1] - y[1]) / (x[0] - y[0])) > 1;
+	const swapAxes = Math.abs((x[1] - y[1]) / (x[0] - y[0])) > 1;
 	
 	// Cache
 	let x1, x2, y1, y2, z1, z2;
@@ -26,12 +26,12 @@ function findEquidistantPointOnLine(x: number[], y: number[], z: number[]) {
 	}
 	
 	// a <= 1 (due to swapped axes)
-	let a = (x2 - y2) / (x1 - y1); 
-	let b = y2 - a*y1;
-	let c = (y1*y1 + y2*y2 - z1*z1 - z2*z2) + 2*b*(z2 - y2);
-	let d = y1 - z1 + a*(y2 - z2);
-	let t1 = c/(2*d);
-	let t2 = a*t1 + b;
+	const a = (x2 - y2) / (x1 - y1); 
+	const b = y2 - a*y1;
+	const c = (y1*y1 + y2*y2 - z1*z1 - z2*z2) + 2*b*(z2 - y2);
+	const d = y1 - z1 + a*(y2 - z2);
+	const t1 = c/(2*d);
+	const t2 = a*t1 + b;
 	
 	return swapAxes ? [t2,t1] : [t1,t2];
 }

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

@@ -21,17 +21,17 @@ function getInitialBezierPieces(
     if (isHoleClosing) {
         bezierPieces = [];
         for (let k2=0; k2<k; k2++) {
-            let pieces: BezierPiece[] = loops[k2].curves
+            const pieces: BezierPiece[] = loops[k2].curves
                 .map(curve => ({ curve, ts: [0,1] }))
             bezierPieces.push(...pieces);
         }
     } else {
         //let order = PointOnShape.isDullCorner(y)
-        let order = isPosDullCorner(y)
+        const order = isPosDullCorner(y)
                 ? y.t === 1 ? -1 : +1
                 : 0;
-        let loop = loops[k];
-        let cpNode = getNeighbouringPoints(cpTrees.get(loop), y, order, 0)[0];
+        const loop = loops[k];
+        const cpNode = getNeighbouringPoints(cpTrees.get(loop), y, order, 0)[0];
         δ = [cpNode, cpNode];
         if (!cpNode || 
             // The special case if there is only a single sharp corner or 

package/src/mat/find-mat/find-3-prong/calc-better-x.ts

@@ -20,7 +20,7 @@ function calcBetterX(
         x: number[], 
         vectorToZeroV: number[]) {
 
-    let V = len(vectorToZeroV);
+    const V = len(vectorToZeroV);
 
     let nu = 1;
     let better;
@@ -29,15 +29,15 @@ function calcBetterX(
     let newV;
     let i = 0; // Safeguard
     do { 
-        let shift = scale(vectorToZeroV, nu);
+        const shift = scale(vectorToZeroV, nu);
         newX = translate(shift, x); 
         
         
         newPs = getClosestPoints(newX, bezierPiece3s);
                     
         // Point of zero V
-        let newCircleCenter = circumCenter(newPs.map(pos => pos.p)); 
-        let newVectorToZeroV = fromTo(newX, newCircleCenter);
+        const newCircleCenter = circumCenter(newPs.map(pos => pos.p)); 
+        const newVectorToZeroV = fromTo(newX, newCircleCenter);
         newV = len(newVectorToZeroV);
         
         better = newV < V;

package/src/mat/find-mat/find-3-prong/calc-initial-3-prong-center.ts

@@ -18,16 +18,16 @@ function calcInitial3ProngCenter(
         δ3s: CpNode[][], 
         bezierPiece3s: BezierPiece[][]) {
 
-    let twoProngCircleCenter = δ3s[0][0].cp.circle.center;
+    const twoProngCircleCenter = δ3s[0][0].cp.circle.center;
 
-    let posInfo = getClosestBoundaryPoint(
+    const posInfo = getClosestBoundaryPoint(
             bezierPiece3s[1],
             twoProngCircleCenter, 
             undefined, // curve
             undefined  // t
     );
 
-    let meanPoints = [
+    const meanPoints = [
         δ3s[0][0].cp.pointOnShape.p, 
         posInfo.pos.p,
         δ3s[2][1].cp.pointOnShape.p,

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

@@ -1,5 +1,5 @@
-/** @hidden */
-declare var _debug_: Debug;
+/** @internal */
+declare const _debug_: Debug;
 
 import { 
     fromTo, circumCenter, len, distanceBetween, toUnitVector, rotate90Degrees,
@@ -40,33 +40,33 @@ function find3ProngForDelta3s(
     const TOLERANCE = extreme * 1e-10;
     const MAX_ITERATIONS = 10;
 
-    let δs_ = [
+    const δs_ = [
         δs[0], 
         δs[idx], 
         δs[δs.length-1]
     ];
 
-    let bezierPieces_ = [
+    const bezierPieces_ = [
         bezierPiecess[0], 
         bezierPiecess[idx], 
         bezierPiecess[δs.length-1]
     ];
 
-    let δ3ss = [
+    const δ3ss = [
         [δs_[0], δs_[1], δs_[2]],
         [δs_[1], δs_[2], δs_[0]],
         [δs_[2], δs_[0], δs_[1]],
     ];
 
-    let bezierPiecess_ = [
+    const bezierPiecess_ = [
         [bezierPieces_[0], bezierPieces_[1], bezierPieces_[2]],
         [bezierPieces_[1], bezierPieces_[2], bezierPieces_[0]],
         [bezierPieces_[2], bezierPieces_[0], bezierPieces_[1]],
     ]
 
 
-    let δ3s = δ3ss[k];
-    let bezierPiece3s = bezierPiecess_[k];
+    const δ3s = δ3ss[k];
+    const bezierPiece3s = bezierPiecess_[k];
 
     if (δ3s[0][0].isSharp()) { return undefined; }
 
@@ -77,9 +77,9 @@ function find3ProngForDelta3s(
     let x = calcInitial3ProngCenter(δ3s, bezierPiece3s);
 
     if (typeof _debug_ !== 'undefined') { 
-        let threeProngs = _debug_.generated.elems.threeProng;
-        let d = threeProngs[threeProngs.length-1];
-        let trace = d.traces[d.traces.length-1];
+        const threeProngs = _debug_.generated.elems.threeProng;
+        const d = threeProngs[threeProngs.length-1];
+        const trace = d.traces[d.traces.length-1];
         trace.push(x);
     }
 
@@ -99,7 +99,7 @@ function find3ProngForDelta3s(
 
         circumCenter_ = circumCenter(ps.map(x => x.p));
 
-        let vectorToZeroV = calcVectorToZeroV_StraightToIt(x, circumCenter_);
+        const vectorToZeroV = calcVectorToZeroV_StraightToIt(x, circumCenter_);
 
         if (!Number.isFinite(vectorToZeroV[0]) || !Number.isFinite(vectorToZeroV[1])) {
 
@@ -109,27 +109,27 @@ function find3ProngForDelta3s(
             // loop. This check, for instance, would be eliminated completely.
             return undefined;
         }
-        let upds = calcBetterX(bezierPiece3s, x, vectorToZeroV);
+        const upds = calcBetterX(bezierPiece3s, x, vectorToZeroV);
         x = upds.newX;
         ps = upds.newPs;
 
         if (typeof _debug_ !== 'undefined') { 
-            let threeProngs = _debug_.generated.elems.threeProng;
-            let d = threeProngs[threeProngs.length-1];
-            let trace = d.traces[d.traces.length-1];
+            const threeProngs = _debug_.generated.elems.threeProng;
+            const d = threeProngs[threeProngs.length-1];
+            const trace = d.traces[d.traces.length-1];
             trace.push(x);
         }
 
-        let V = len(vectorToZeroV); // The 'potential'
+        const V = len(vectorToZeroV); // The 'potential'
         
         tolerance = Math.abs(V - upds.newV);
     }
 
-    let radius = (distanceBetween(x, ps[0].p) + 
+    const radius = (distanceBetween(x, ps[0].p) + 
                 distanceBetween(x, ps[1].p) + 
                 distanceBetween(x, ps[2].p)) / 3;
 
-    let circle = { center: x, radius };
+    const circle = { center: x, radius };
 
     //-------------------------------------------------------------------------
     // Calculate the unit tangent vector at 3-prong circle points - they should 
@@ -138,12 +138,12 @@ function find3ProngForDelta3s(
     //-------------------------------------------------------------------------
     let totalAngleError = 0;
     for (let i=0; i<3; i++) {
-        let p = ps[i];
+        const p = ps[i];
         //----------------------------
         // Tangent of circle at point
         //----------------------------
-        let v = toUnitVector(fromTo(p.p, x));
-        let v1 = rotate90Degrees(v);
+        const v = toUnitVector(fromTo(p.p, x));
+        const v1 = rotate90Degrees(v);
         
         
         //-----------------------------------
@@ -151,13 +151,13 @@ function find3ProngForDelta3s(
         //-----------------------------------
         //if (PointOnShape.isDullCorner(p)) {
         if (isPosDullCorner(p)) {
-            //let corner = Curve.getCornerAtEnd(p.curve);
-            let corner = getCornerAtEnd(p.curve);
-            let tans = corner.tangents;
-            let perps = tans.map( rotate90Degrees );
+            //const corner = Curve.getCornerAtEnd(p.curve);
+            const corner = getCornerAtEnd(p.curve);
+            const tans = corner.tangents;
+            const perps = tans.map( rotate90Degrees );
                 
-            let angleError1 = Math.asin( cross( perps[0], v ) );
-            let angleError2 = Math.asin( cross( v, perps[1] ) );
+            const angleError1 = Math.asin( cross( perps[0], v ) );
+            const angleError2 = Math.asin( cross( v, perps[1] ) );
             
             let angleError = 0;
             if (angleError1 > 0) { angleError += angleError1; }
@@ -168,7 +168,7 @@ function find3ProngForDelta3s(
             //---------------------------
             // Tangent of curve at point
             //---------------------------
-            let v2 = toUnitVector( tangent(p.curve.ps, p.t) );
+            const v2 = toUnitVector( tangent(p.curve.ps, p.t) );
             
             // Cross is more numerically stable than Vector.dot at angles a
             // multiple of Math.PI **and** is close to the actual angle value
@@ -176,7 +176,7 @@ function find3ProngForDelta3s(
             // tolerance.
             
             // Should be close to zero and is close to the actual angle.
-            let cross_ = Math.abs( Math.asin( cross(v1, v2) ) );
+            const cross_ = Math.abs( Math.asin( cross(v1, v2) ) );
             
             totalAngleError += cross_;
         }		
@@ -187,21 +187,21 @@ function find3ProngForDelta3s(
     // point to the 3-prong. It should be around 0. If not, this is not a good 
     // candidate for the 3-prong.
     //-------------------------------------------------------------------------
-    let closestDs = [];
+    const closestDs = [];
     for (let i=0; i<bezierPiecess.length; i++) {
-        let p = getClosestBoundaryPoint(
+        const p = getClosestBoundaryPoint(
             bezierPiecess[i], x, undefined, undefined
         );
         
         closestDs.push( distanceBetween(p.pos.p, x) );
     }
-    let closestD = Math.min(...closestDs);
-    let radiusDelta = Math.abs(radius - closestD);
+    const closestD = Math.min(...closestDs);
+    const radiusDelta = Math.abs(radius - closestD);
 
     // Weights below still need to be optimized.
-    let W1 = 1;
-    let W2 = 1;
-    let error = W1*radiusDelta + W2*totalAngleError;
+    const W1 = 1;
+    const W2 = 1;
+    const error = W1*radiusDelta + W2*totalAngleError;
 
     return { ps, circle, error, δ3s };
 }