flo-mat 2.0.1 → 2.0.3

package/src/debug/functions/draw-elem/tight-bounding-box.ts

@@ -3,7 +3,7 @@ import { drawFs } from 'flo-draw';
 
 /** @hidden */
 function tightBoundingBox(g: SVGGElement, box: number[][]) {
-	let $box = drawFs.polygon(g, box, 'thin5 pinker nofill');
+	const $box = drawFs.polygon(g, box, 'thin5 pinker nofill');
 
 	return $box;
 }

package/src/debug/functions/draw-elem/two-prong.ts

@@ -5,7 +5,7 @@ import { getTwoProngType } from '../../../mat/get-two-prong-type.js';
 
 /** @hidden */
 function twoProng(g: SVGGElement, twoProng: TwoProngForDebugging) {
-	let scaleFactor = 0.3;
+	const scaleFactor = 0.3;
 
 	let $failedDot : SVGElement[] = [];
 	let $center    : SVGElement[] = [];

package/src/debug/functions/draw-elem/vertex.ts

@@ -3,36 +3,42 @@ import { CpNode } from '../../../cp-node.js';
 
 
 /** @hidden */
-function vertex(g: SVGGElement, cpNode: CpNode, classes?: string , delay?: number, visible: boolean = true) {
-	let visibleClass = visible ? '' : ' invisible';
+function vertex(
+		g: SVGGElement,
+		cpNode: CpNode,
+		classes?: string,
+		delay?: number,
+		visible = true) {
 
-	let circle = cpNode.cp.circle;
+	const visibleClass = visible ? '' : ' invisible';
+
+	const circle = cpNode.cp.circle;
 
 	const THIN = 'thin20';
 
-	let cps = cpNode.getCpNodesOnCircle();
+	const cps = cpNode.getCpNodesOnCircle();
 	console.log(cps)
 
 	let $svgs: SVGElement[] = [];
 
-	let $circle = drawFs.circle(g, circle, 'red ' + THIN + ' nofill ' + visibleClass, delay);
-	let $crossHair = drawFs.crossHair(g, circle.center, 'red ' + THIN + ' nofill ' + visibleClass, 3, delay);
+	const $circle = drawFs.circle(g, circle, 'red ' + THIN + ' nofill ' + visibleClass, delay);
+	const $crossHair = drawFs.crossHair(g, circle.center, 'red ' + THIN + ' nofill ' + visibleClass, 3, delay);
 
 	$svgs = [...$circle, ...$crossHair];
 
 	for (let i=0; i<cps.length; i++) {
-		let cp = cps[i];
-		let edgeCircle = cp.next.cp.circle;
+		const cp = cps[i];
+		const edgeCircle = cp.next.cp.circle;
 
-		let $circle = drawFs.circle(g, edgeCircle, 'pink ' + THIN + ' nofill ' + visibleClass, delay);
-		let $crossHair = drawFs.crossHair(g, edgeCircle.center, 'pink ' + THIN + ' nofill ' + visibleClass, 3, delay);
+		const $circle = drawFs.circle(g, edgeCircle, 'pink ' + THIN + ' nofill ' + visibleClass, delay);
+		const $crossHair = drawFs.crossHair(g, edgeCircle.center, 'pink ' + THIN + ' nofill ' + visibleClass, 3, delay);
 
 		$svgs.push(...$circle, ...$crossHair)
 
-		let p1 = circle.center;
-		let p2 = edgeCircle.center;
-		let thin = i === 0 ? 'thin10' : (i === 1 ? 'thin20' : 'thin35');
-		let $line = drawFs.line(g, [p1, p2], 'yellow ' + thin  + ' nofill ' + visibleClass, delay);
+		const p1 = circle.center;
+		const p2 = edgeCircle.center;
+		const thin = i === 0 ? 'thin10' : (i === 1 ? 'thin20' : 'thin35');
+		const $line = drawFs.line(g, [p1, p2], 'yellow ' + thin  + ' nofill ' + visibleClass, delay);
 
 		$svgs.push(...$line);
 	}

package/src/debug/functions/general.ts

@@ -18,7 +18,7 @@ let i = 0;
  * @hidden
  * Name the given object - for debugging purposes only 
  */
-function nameObj(o: any, pre: string = '') {
+function nameObj(o: any, pre = '') {
 	o.name = '' + pre + i++;
 }
 
@@ -61,13 +61,13 @@ function pointsToStr(ps: number[][], decimalPlaces = 3) {
  * @param p The point
  * @param decimalPlaces number of decimal places
  */
-function pointToStr(p: number[], decimalPlaces: number = 3) {
+function pointToStr(p: number[], decimalPlaces = 3) {
 	return p[0].toFixed(decimalPlaces) + ', ' + p[1].toFixed(decimalPlaces); 
 }
 
 
 /** @hidden */
-let generalDebugFunctions/*: IGeneralDebugFunctions*/ = {
+const generalDebugFunctions/*: IGeneralDebugFunctions*/ = {
 	δToString,
 	δsToString,
 	pointToStr,

package/src/debug/functions/three-prong.ts

@@ -27,10 +27,10 @@ export interface IThreeProngDebugFunctions {
  * @param n - The 3-prong's zero-based index. 
  */
 function drawSpokes(g: SVGGElement, n: number): void {
-	let threeProng = _debug_.generated.elems.threeProng[n]; 
-	//let g = threeProng.generated.g;
-	let cc = threeProng.circle.center;
-	let poss = threeProng.poss;
+	const threeProng = _debug_.generated.elems.threeProng[n]; 
+	//const g = threeProng.generated.g;
+	const cc = threeProng.circle.center;
+	const poss = threeProng.poss;
 
 	//_debug_.fs.draw.line(g, [poss[0].p, cc], 'thin5 red');
 	//_debug_.fs.draw.line(g, [poss[1].p, cc], 'thin5 red');
@@ -62,12 +62,12 @@ function traceConvergence(g: SVGGElement, n_: number, idx: number): void {
 	
 	for (let n=sIndx; n<eIndx; n++) {
 
-		let forDebugging = _debug_.generated.elems.threeProng[n];
-		//let g = forDebugging.generated.g;
+		const forDebugging = _debug_.generated.elems.threeProng[n];
+		//const g = forDebugging.generated.g;
 		
 		console.log(forDebugging);
 		
-		let candidateThreeProngs = forDebugging.candidateThreeProngs;
+		const candidateThreeProngs = forDebugging.candidateThreeProngs;
 		
 		//-----------------------------
 		//---- Get start and end index
@@ -91,7 +91,7 @@ function traceConvergence(g: SVGGElement, n_: number, idx: number): void {
 		//---- Draw candidate three-prongs
 		//---------------------------------
 		for (let i=startIndx; i<endIndx; i++) {
-			let circle = candidateThreeProngs[i].circle;
+			const circle = candidateThreeProngs[i].circle;
 			if (forDebugging.bestIndx === i) {
 				drawFs.dot(g, circle.center, 0.2, 'green');
 				drawFs.circle(g, circle, 'black thin10 nofill');	
@@ -112,16 +112,16 @@ function traceConvergence(g: SVGGElement, n_: number, idx: number): void {
  * show all.
  */
 function showBoundary(g: SVGGElement, n: number, idx: number): void {
-	let debugInfo = _debug_.generated.elems.threeProng[n];
-	//let g = debugInfo.generated.g;
+	const debugInfo = _debug_.generated.elems.threeProng[n];
+	//const g = debugInfo.generated.g;
 	
-	let candidateThreeProngs = debugInfo.candidateThreeProngs;
+	const candidateThreeProngs = debugInfo.candidateThreeProngs;
 	
-	let startIndx = idx === undefined ? 0 : idx;
-	let endIndx   = idx === undefined ? candidateThreeProngs.length : idx;
+	const startIndx = idx === undefined ? 0 : idx;
+	const endIndx   = idx === undefined ? candidateThreeProngs.length : idx;
 	
 	// Draw relevant δs
-	let cpss = debugInfo.cpss;
+	const cpss = debugInfo.cpss;
 	let j = 0;
 	// For each iteration of δ3s (indexed by j)
 	for (let idx=1; idx<cpss.length-1; idx++) {
@@ -131,7 +131,7 @@ function showBoundary(g: SVGGElement, n: number, idx: number): void {
 			continue; 
 		}
 		
-		let δ3s = [
+		const δ3s = [
 			cpss[0], 
 			cpss[idx], 
 			cpss[cpss.length-1]
@@ -140,17 +140,17 @@ function showBoundary(g: SVGGElement, n: number, idx: number): void {
 		
 		// For each of the 3 δs
 		for (let i=0; i<3; i++) {
-			let δ = δ3s[i];
-			let δS = δ[0]; // Delta Start
-			let δE = δ[1]; // Delta End
+			const δ = δ3s[i];
+			const δS = δ[0]; // Delta Start
+			const δE = δ[1]; // Delta End
 			
-			let posS = δS.cp.pointOnShape;
-			let posE = δE.cp.pointOnShape;
+			const posS = δS.cp.pointOnShape;
+			const posE = δE.cp.pointOnShape;
 			
-			let pS = posS.p;
-			let pE = posE.p;
+			const pS = posS.p;
+			const pE = posE.p;
 			
-			let r = 1 + (i*0.5);
+			const r = 1 + (i*0.5);
 			
 			if (equal(pS, pE)) {
 				drawFs.crossHair(g, pS, 'red thin10 nofill', r); 
@@ -170,7 +170,7 @@ function showBoundary(g: SVGGElement, n: number, idx: number): void {
  * @param n The 3-prong's zero-based index. 
  */
 function logδs(n: number): void {
-	let threeProng = _debug_.generated.elems.threeProng[n];
+	const threeProng = _debug_.generated.elems.threeProng[n];
 	
 	console.log(threeProng.cpss);		
 }
@@ -186,26 +186,26 @@ function logNearest(
 		showBoundaries = true) {
 
 	return function(g: SVGGElement, p: number[], showDelay = 1000) {
-		let generated = _debug_.generated;
+		const generated = _debug_.generated;
 
-		let threeProng = getObjClosestTo<ThreeProngForDebugging>(
+		const threeProng = getObjClosestTo<ThreeProngForDebugging>(
 			p, 
 			generated.elems.threeProng, 
 			threeProng => threeProng.circle ? threeProng.circle.center : [0,0]
 		);
 
 
-		let circle = threeProng.circle;
-		//let g = threeProng.generated.g;
+		const circle = threeProng.circle;
+		//const g = threeProng.generated.g;
 		
 		console.log(threeProng);
 
-		let circle2 = {
+		const circle2 = {
 			center: circle.center,
 			radius: circle.radius || 1
 		};
 
-		//let draw = _debug_.fs.draw;
+		//const draw = _debug_.fs.draw;
 
 		drawFs.circle(g, circle2, 'blue thin10 nofill', showDelay);
 		drawFs.crossHair(g, circle.center, 'red thin2 nofill', 2, showDelay);
@@ -218,21 +218,21 @@ function logNearest(
 
 
 		if (showBoundaries) {
-			let boundaries = threeProng.boundaries;
-			let boundaryS = boundaries[0];
-			let boundaryE = boundaries[boundaries.length-1];
+			const boundaries = threeProng.boundaries;
+			const boundaryS = boundaries[0];
+			const boundaryE = boundaries[boundaries.length-1];
 
 			drawFs.beziers(g, boundaryS, 'red thin20 nofill', showDelay);
 			for (let i=1; i<boundaries.length-1; i++) {
-				let boundary = boundaries[i];
+				const boundary = boundaries[i];
 				drawFs.beziers(g, boundary, 'green thin20 nofill', showDelay);
 			}
 			drawFs.beziers(g, boundaryE, 'blue thin20 nofill', showDelay);
 		}
 
 		if (showTrace) {
-			let traces = threeProng.traces;
-			for (let trace of traces) {
+			const traces = threeProng.traces;
+			for (const trace of traces) {
 				drawFs.polyline(g, trace, 'red thin5 nofill', showDelay)
 			}
 		}
@@ -241,7 +241,7 @@ function logNearest(
 
 
 /** @hidden */
-let threeProngDebugFunctions: IThreeProngDebugFunctions = {
+const threeProngDebugFunctions: IThreeProngDebugFunctions = {
 	drawSpokes,
 	traceConvergence,
 	showBoundary,

package/src/debug/functions/two-prong.ts

@@ -25,7 +25,7 @@ interface ITwoProngDebugFunctions {
  * @hidden
  */
 function logδ(n: number, type: ElemType_TwoProng = 'twoProng_regular') {
-	let δ =_debug_.generated.elems[type][n].δ;
+	const δ =_debug_.generated.elems[type][n].δ;
 	
 	console.log(δ);
 }
@@ -35,7 +35,7 @@ function logδ(n: number, type: ElemType_TwoProng = 'twoProng_regular') {
  * @hidden
  */
 function log(n: number, type: ElemType_TwoProng = 'twoProng_regular') {
-	let twoProng = _debug_.generated.elems[type][n];
+	const twoProng = _debug_.generated.elems[type][n];
 	console.log(twoProng);
 }
 
@@ -49,7 +49,7 @@ function drawNormal(
 		showDelay = 1000, 
 		type: ElemType_TwoProng = 'twoProng_regular') {
 
-	let twoProngs = _debug_.generated.elems[type];
+	const twoProngs = _debug_.generated.elems[type];
 	
 	// If not specified which, draw all
 	if (n === undefined) {
@@ -58,7 +58,7 @@ function drawNormal(
 		}
 	}
 	
-	let twoProng = twoProngs[n];
+	const twoProng = twoProngs[n];
 
 	//let g = twoProng.generated.g;
 	
@@ -77,10 +77,10 @@ function logδBasic(
 		n: number, 
 		type: ElemType_TwoProng = 'twoProng_regular') {
 
-	let delta = _debug_.generated.elems[type][n].δ;
+	const delta = _debug_.generated.elems[type][n].δ;
 
 	function f(x: CpNode) {
-		let pos = x.cp.pointOnShape;
+		const pos = x.cp.pointOnShape;
 		return {
 			bez: pos.curve.ps,
 			t: pos.t
@@ -96,10 +96,10 @@ function logδBasic(
  * @hidden
  */
 function logNearest(g: SVGGElement, p: number[], showDelay = 1000, type: ElemType_TwoProng = 'twoProng_regular') {
-	let closestPerLoops: TwoProngForDebugging[] = [];
+	const closestPerLoops: TwoProngForDebugging[] = [];
 
-	let generated = _debug_.generated;
-	let twoProng = getObjClosestTo<TwoProngForDebugging>(
+	const generated = _debug_.generated;
+	const twoProng = getObjClosestTo<TwoProngForDebugging>(
 		p, 
 		generated.elems[type], 
 		twoProng => twoProng.circle.center
@@ -110,7 +110,7 @@ function logNearest(g: SVGGElement, p: number[], showDelay = 1000, type: ElemTyp
 	
 	let n;
 	for (let i=0; i<_debug_.generated.elems[type].length; i++) {
-		let twoProng_ = _debug_.generated.elems[type][i];
+		const twoProng_ = _debug_.generated.elems[type][i];
 		if (twoProng_ === twoProng) {
 			n = i;
 			break;
@@ -136,8 +136,8 @@ function traceConvergence(
 
 	if (n === undefined) { return; }
 
-	let twoProngInfo = _debug_.generated.elems[type][n];
-	let xs = twoProngInfo.xs;
+	const twoProngInfo = _debug_.generated.elems[type][n];
+	const xs = twoProngInfo.xs;
 	//let g = twoProngInfo.generated.g;
 
 	console.log(twoProngInfo);
@@ -160,9 +160,9 @@ function traceConvergence(
 			continue;
 		}
 
-		let x = twoProngInfo.xs[i];
+		const x = twoProngInfo.xs[i];
 
-		let circle = { center: x.x, radius: distanceBetween(x.x, x.y.p) };
+		const circle = { center: x.x, radius: distanceBetween(x.x, x.y.p) };
 		drawFs.crossHair(g, x.x, 'red thin10 nofill', undefined, showDelay);
 		drawFs.circle(g, circle, 'blue thin10 nofill', showDelay);
 		if (x.z !== undefined) {
@@ -177,7 +177,7 @@ function traceConvergence(
 
 
 /** @hidden */
-let twoProngDebugFunctions: ITwoProngDebugFunctions = {
+const twoProngDebugFunctions: ITwoProngDebugFunctions = {
 	logδ,
 	log,
 	drawNormal,

package/src/find-mats.ts

@@ -1,5 +1,5 @@
-/** @hidden */
-declare var _debug_: Debug; 
+/** @internal */
+declare const _debug_: Debug; 
 
 import { LlRbTree } from 'flo-ll-rb-tree';
 import { simplifyPaths } from 'flo-boolean';
@@ -8,7 +8,7 @@ import { CpNode } from './cp-node.js';
 import { Loop } from './loop.js';
 import { Mat } from './mat.js';
 import { findAndAddAll3Prongs } from './mat/find-mat/find-and-add-3-prongs.js';
-import { createInitialCpGraph } from './mat/find-mat/create-initial-cp-graph.js';;
+import { createInitialCpGraph } from './mat/find-mat/create-initial-cp-graph.js';
 import { addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './mat/find-mat/add-debug-info.js';
 import { getPotential2Prongs } from './mat/find-mat/get-potential-2-prongs.js';
 import { getSharpCorners } from './mat/find-mat/get-sharp-corners.js';
@@ -46,18 +46,18 @@ function findMats(
 		maxCurviness = 0.4,
         maxLength = 4): Mat[] {
 
-	if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
+	// if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
 
 	let maxCoordinate: number;
 	let minBezLength: number;
 	({ maxCurviness, maxLength, maxCoordinate, minBezLength } = 
 		getSizeParams(bezierLoops, maxCurviness, maxLength));
 
-	let loopss = simplifyPaths(bezierLoops, maxCoordinate);
+	const loopss = simplifyPaths(bezierLoops, maxCoordinate);
 
-	let mats: Mat[] = [];
-	for (let loops of loopss) {
-		let mat = findMat(
+	const mats: Mat[] = [];
+	for (const loops of loopss) {
+		const mat = findMat(
 			loops, 
 			minBezLength, 
 			maxCurviness, 
@@ -77,14 +77,14 @@ function getSizeParams(
         maxLength: number) {
 
 	// Gather some shape metrics
-	let { maxCoordinate, maxRadius } = getLoopsMetrics(bezierLoops);
-	let expMax = Math.ceil(Math.log2(maxCoordinate));
-	let minBezLengthSigBits = 14;
+	const { maxCoordinate, maxRadius } = getLoopsMetrics(bezierLoops);
+	const expMax = Math.ceil(Math.log2(maxCoordinate));
+	const minBezLengthSigBits = 14;
 	/** 
 	 * If a curve is shorter than this value then no points on it will be 
 	 * selected for the purpose of finding the MAT.
 	 */
-	let minBezLength = 2**expMax * 2**(-minBezLengthSigBits);
+	const minBezLength = 2**expMax * 2**(-minBezLengthSigBits);
 
 	// Limit the tolerance to a reasonable level
 	if (maxCurviness < 0.05) { maxCurviness = 0.05; }
@@ -93,8 +93,8 @@ function getSizeParams(
 	if (maxLength < 0.1) { maxLength = 0.1; }
 	if (maxLength > 100) { maxLength = 100; }
 	// Adjust length tolerance according to a reference max coordinate
-	let expMaxRadius = Math.ceil(Math.log2(maxRadius));
-	let maxLengthSigBits = 10;  // 1024 x 1024
+	const expMaxRadius = Math.ceil(Math.log2(maxRadius));
+	const maxLengthSigBits = 10;  // 1024 x 1024
 	maxLength = maxLength * (2**expMaxRadius * 2**(-maxLengthSigBits));
 
 	return { maxCurviness, maxLength, maxCoordinate, minBezLength };
@@ -118,14 +118,14 @@ function findMat(
 		
 	// Gets interesting points on the shape, i.e. those that makes sense to use 
 	// for the 2-prong procedure.
-	let pointsPerLoop = loops.map(
+	const pointsPerLoop = loops.map(
 		getInterestingPointsOnLoop(minBezLength, maxCurviness, maxLength)
 	);
 
-	let for2ProngsPerLoop = getPotential2Prongs(pointsPerLoop);
-	let sharpCornersPerLoop = getSharpCorners(pointsPerLoop);
+	const for2ProngsPerLoop = getPotential2Prongs(pointsPerLoop);
+	const sharpCornersPerLoop = getSharpCorners(pointsPerLoop);
 
-	let cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
+	const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
 	let cpNode = createInitialCpGraph(loops, cpTrees, sharpCornersPerLoop);
 	
 	findAndAddHoleClosing2Prongs(loops, cpTrees, maxCoordinate);
@@ -160,7 +160,7 @@ function findMat(
 		}
 	}
 
-	let mat = { cpNode, cpTrees };
+	const mat = { cpNode, cpTrees };
 
 	addDebugInfo4(mat);
 	

package/src/get-boundary-bezier-parts-to-next.ts

@@ -9,14 +9,14 @@ import { Curve  } from './curve.js';
  * @param cpNode
  */
 function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[] {
-    let cpThis = cpNode; 
-    let cpNext = cpNode.next;
+    const cpThis = cpNode; 
+    const cpNext = cpNode.next;
 
-    let posThis = cpThis.cp.pointOnShape;
-    let posNext = cpNext.cp.pointOnShape;
+    const posThis = cpThis.cp.pointOnShape;
+    const posNext = cpNext.cp.pointOnShape;
 
-    let curveThis = posThis.curve;
-    let curveNext = posNext.curve;
+    const curveThis = posThis.curve;
+    const curveNext = posNext.curve;
 
     if (curveThis.loop !== curveNext.loop) {
         // It is a hole-closer going over to the other loop - a kind of terminal
@@ -24,7 +24,7 @@ function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[] {
         return undefined;
     }
     
-    let bezierParts: BezierPiece[] = [];
+    const bezierParts: BezierPiece[] = [];
 
     if (curveNext === curveThis) {
         bezierParts.push(
@@ -60,7 +60,7 @@ function addSkippedBeziers(
     let curveThis = curveStart;
     do {
         curveThis = curveThis.next;
-        let bezierPart = curveThis === curveEnd 
+        const bezierPart = curveThis === curveEnd 
             ? { ps: curveThis.ps, ts: [0, t1] }
             : { ps: curveThis.ps, ts: [0, 1] }
 

package/src/get-boundary-beziers-to-next.ts

@@ -10,14 +10,14 @@ import { Curve  } from './curve.js';
  * @param cpNode
  */
 function getBoundaryBeziersToNext(cpNode: CpNode) {
-    let cpThis = cpNode; 
-    let cpNext = cpNode.next;
+    const cpThis = cpNode; 
+    const cpNext = cpNode.next;
 
-    let posThis = cpThis.cp.pointOnShape;
-    let posNext = cpNext.cp.pointOnShape;
+    const posThis = cpThis.cp.pointOnShape;
+    const posNext = cpNext.cp.pointOnShape;
 
-    let curveThis = posThis.curve;
-    let curveNext = posNext.curve;
+    const curveThis = posThis.curve;
+    const curveNext = posNext.curve;
 
     if (curveThis.loop !== curveNext.loop) {
         // It is a hole-closer going over to the other loop - a kind of terminal
@@ -25,7 +25,7 @@ function getBoundaryBeziersToNext(cpNode: CpNode) {
         return undefined;
     }
     
-    let beziers = [];
+    const beziers = [];
 
     if (curveNext === curveThis) {
         beziers.push(
@@ -61,7 +61,7 @@ function addSkippedBeziers(
     let curveThis = curveStart;
     do {
         curveThis = curveThis.next;
-        let tEnd = curveThis === curveEnd ? t1 : 1;
+        const tEnd = curveThis === curveEnd ? t1 : 1;
         beziers.push( 
             // qqq from0ToT(curveThis.ps, tEnd) 
             fromTo(curveThis.ps, 0, tEnd)

package/src/get-branches.ts

@@ -26,15 +26,15 @@ function getBranches(
 		cpNode = cpNode.next;
 	}
 
-	let branches: CpNode[][] = [];
+	const branches: CpNode[][] = [];
 
 	// Since the tree is unrooted we must iterate in all directions from the
 	// given vertex.
-	let cps = [cpNode.prevOnCircle];
+	const cps = [cpNode.prevOnCircle];
 
 	let branchCpNodes: CpNode[] = [];
 	while (cps.length) {
-		let cp = cps.pop();
+		const cp = cps.pop();
 		branchCpNodes.push(cp);
 
 		let children = cp.getChildren();
@@ -68,17 +68,17 @@ function getBranches(
 			continue;
 		}
 
-		let backPointingTan = toUnitVector(tangent(
+		const backPointingTan = toUnitVector(tangent(
 			getCurveToNext(cp.next.prevOnCircle), 
 			0
 		));
-		let forwardPointingTan = toUnitVector(tangent(
+		const forwardPointingTan = toUnitVector(tangent(
 			getCurveToNext(children[0]), 
 			0
 		));
 
-		let cross_ = cross(backPointingTan, forwardPointingTan);
-		let angle = Math.abs(Math.asin( cross_ ) * (180/Math.PI));
+		const cross_ = cross(backPointingTan, forwardPointingTan);
+		const angle = Math.abs(Math.asin( cross_ ) * (180/Math.PI));
 
 		if (angle > tolerance) {
 			branches.push(branchCpNodes);

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

@@ -22,22 +22,22 @@ function getCurveBetween(
         cpNodeFrom: CpNode, 
         cpNodeTo: CpNode) {
 
-    let fromCc = cpNodeFrom.cp.circle.center;
-    let fromL = getEdgeDirection(cpNodeFrom);
+    const fromCc = cpNodeFrom.cp.circle.center;
+    const fromL = getEdgeDirection(cpNodeFrom);
 
-    let toCc = cpNodeTo.cp.circle.center;
-    let toL = getEdgeDirection(cpNodeTo.prevOnCircle);
+    const toCc = cpNodeTo.cp.circle.center;
+    const toL = getEdgeDirection(cpNodeTo.prevOnCircle);
 
-    let mid = lineLineIntersection(fromL, toL);
+    const mid = lineLineIntersection(fromL, toL);
 
-    let c = fromTo(fromCc,toCc);
+    const c = fromTo(fromCc,toCc);
 
     let twisted: boolean;
     if (!mid) {
         twisted = true;
     } else {
-        let a = fromTo(fromCc, mid);
-        let b = fromTo(toCc,   mid);
+        const a = fromTo(fromCc, mid);
+        const b = fromTo(toCc,   mid);
         
         twisted = dot(a,c) < 0 || dot(b,c) > 0;			
     }
@@ -46,12 +46,12 @@ function getCurveBetween(
         return [fromCc, mid, toCc];
     } 
         
-    let r = rotate90Degrees(c);
-    let w1 = fromTo(fromL[0], fromL[1]); // This is a unit vector
-    let w2 = fromTo(toL[0],  toL[1]);  // This is a unit vector
+    const r = rotate90Degrees(c);
+    const w1 = fromTo(fromL[0], fromL[1]); // This is a unit vector
+    const w2 = fromTo(toL[0],  toL[1]);  // This is a unit vector
 
-    let d1 = Math.abs(cross(c, w1)) / (3*3); 
-    let d2 = Math.abs(cross(c, w2)) / (3*3); 
+    const d1 = Math.abs(cross(c, w1)) / (3*3); 
+    const d2 = Math.abs(cross(c, w2)) / (3*3); 
 
     if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
         // TODO - not within tolerance - must add additional 2-prong
@@ -60,14 +60,14 @@ function getCurveBetween(
 
     if (d1 > TOLERANCE_USE_LINE || d2 > TOLERANCE_USE_LINE) {
         // approximate with cubic bezier
-        let m1 = interpolate(fromCc,toCc,1/3);
-        let m2 = interpolate(fromCc,toCc,2/3);
-        let v1 = translate(r, m1);
-        let v2 = translate(r, m2);
-        let l1 = [m1,v1];
-        let l2 = [m2,v2];
-        let mid1 = lineLineIntersection(fromL, l1);
-        let mid2 = lineLineIntersection(toL,   l2);
+        const m1 = interpolate(fromCc,toCc,1/3);
+        const m2 = interpolate(fromCc,toCc,2/3);
+        const v1 = translate(r, m1);
+        const v2 = translate(r, m2);
+        const l1 = [m1,v1];
+        const l2 = [m2,v2];
+        const mid1 = lineLineIntersection(fromL, l1);
+        const mid2 = lineLineIntersection(toL,   l2);
 
         return [fromCc, mid1, mid2, toCc];
     }