flo-mat 2.0.1 → 2.0.3

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

@@ -1,5 +1,5 @@
-/** @hidden */
-declare var _debug_: Debug; 
+/** @internal */
+declare const _debug_: Debug; 
 
 import { fromTo } from 'flo-bezier3';
 import { Debug } from '../../../debug/debug.js';
@@ -19,18 +19,18 @@ import { getBoundaryPieceBeziers } from '../../get-boundary-piece-beziers.js';
  * tolerances.
  */ 
 function find3Prong(δs: CpNode[][], extreme: number) {
-	let bezierPiecess = δs.map(getBoundaryPieceBeziers);
+	const bezierPiecess = δs.map(getBoundaryPieceBeziers);
 
 	if (typeof _debug_ !== 'undefined') { 
-		let threeProngs = _debug_.generated.elems.threeProng;
+		const threeProngs = _debug_.generated.elems.threeProng;
 		threeProngs.push(createEmptyThreeProngForDebugging());
 
-		let d = threeProngs[threeProngs.length-1];
+		const d = threeProngs[threeProngs.length-1];
 		d.boundaries = [];
-		for (let bezierPieces of bezierPiecess) {
-			let boundary: number[][][] = [];
+		for (const bezierPieces of bezierPiecess) {
+			const boundary: number[][][] = [];
 			d.boundaries.push(boundary);
-			for (let bezierPiece of bezierPieces) {
+			for (const bezierPiece of bezierPieces) {
 				/* qqq
 				let bezier = fromTo(bezierPiece.curve.ps)(
 					bezierPiece.ts[0], bezierPiece.ts[1]
@@ -46,7 +46,7 @@ function find3Prong(δs: CpNode[][], extreme: number) {
 		d.traces = [];
 	}
 
-	let candidateThreeProngs = [];
+	const candidateThreeProngs = [];
 
 	// The best candidate amongst the different 'permutations' of the given δs.
 	let threeProng: { 
@@ -59,17 +59,17 @@ function find3Prong(δs: CpNode[][], extreme: number) {
 	for (let i=1; i<δs.length-1; i++) {
 		for (let k=0; k<3; k++) {
 			if (typeof _debug_ !== 'undefined') { 
-				let threeProngs = _debug_.generated.elems.threeProng;
-				let d = threeProngs[threeProngs.length-1];
-				let trace: number[][] = [];
+				const threeProngs = _debug_.generated.elems.threeProng;
+				const d = threeProngs[threeProngs.length-1];
+				const trace: number[][] = [];
 				d.traces.push(trace);
 			}
 
-			let threeProngInfo = 
+			const threeProngInfo = 
 				find3ProngForDelta3s(δs, i, k, bezierPiecess, extreme);
 			if (!threeProngInfo) { continue; }
 
-			let { circle, ps, error, δ3s } = threeProngInfo;
+			const { circle, ps, error, δ3s } = threeProngInfo;
 			
 			if (typeof _debug_ !== 'undefined') { 
 				candidateThreeProngs.push({ circle, ps });
@@ -87,8 +87,8 @@ function find3Prong(δs: CpNode[][], extreme: number) {
 	//threeProng.δ3s = [δs[0], δs[bestIndx+1], δs[δs.length-1]];
 
 	if (typeof _debug_ !== 'undefined') { 
-		let threeProngs = _debug_.generated.elems.threeProng;
-		let d = threeProngs[threeProngs.length-1];
+		const threeProngs = _debug_.generated.elems.threeProng;
+		const d = threeProngs[threeProngs.length-1];
 
 		d.generated = _debug_.generated;
 		d.circle = threeProng.circle;

package/src/mat/find-mat/find-3-prong/get-closest-points.ts

@@ -13,7 +13,7 @@ function getClosestPoints(
         bezierPiece3s: BezierPiece[][]) {
 
     return bezierPiece3s.map(bezierPieces => {
-        let posInfo = getClosestBoundaryPoint(
+        const posInfo = getClosestBoundaryPoint(
                 bezierPieces,
                 x, 
                 undefined, // curve

package/src/mat/find-mat/find-and-add-2-prongs-on-all-paths.ts

@@ -23,8 +23,8 @@ function findAndAdd2ProngsOnAllPaths(
     let cpNode;
 
     for (let k=0; k<for2Prongss.length; k++) {
-        let for2Prongs = for2Prongss[k];
-        let _cpNode = findAndAdd2Prongs(loops, cpGraphs, k, for2Prongs, extreme);
+        const for2Prongs = for2Prongss[k];
+        const _cpNode = findAndAdd2Prongs(loops, cpGraphs, k, for2Prongs, extreme);
         cpNode = cpNode || _cpNode;
     }
 

package/src/mat/find-mat/find-and-add-2-prongs.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';
@@ -29,28 +29,26 @@ function findAndAdd2Prongs(
         for2Prongs: IPointOnShape[],
         extreme: number) {
 
-    let len = for2Prongs.length;
-    let index = indexLinear(len); 
-    //let index = indexInterlaced(len); // Keep for possible future use.
+    const len = for2Prongs.length;
+    const index = indexLinear(len); 
+    //const index = indexInterlaced(len); // Keep for possible future use.
     let cpNode_;
 
-    let bounds = getShapeBounds(loops);
-    let squaredDiagonalLength = 
+    const bounds = getShapeBounds(loops);
+    const squaredDiagonalLength = 
         (bounds.maxX.p[0] - bounds.minX.p[0])**2 +
         (bounds.maxY.p[1] - bounds.minY.p[1])**2;
 
     for (let i=0; i<len; i++) {
-        let pos = for2Prongs[index[i]];
+        const pos = for2Prongs[index[i]];
 
-        let twoProngInfo: { circle: Circle,	zs: { pos: IPointOnShape, d: number }[] };
-
-        twoProngInfo = find2Prong(
+        const twoProngInfo: { circle: Circle,	zs: { pos: IPointOnShape, d: number }[] } = find2Prong(
             loops, extreme, squaredDiagonalLength, cpGraphs, pos, false, k
         );
 
         if (twoProngInfo) {
-            let { circle, zs } = twoProngInfo;
-            let cpNode = add2Prong(cpGraphs, circle, pos, zs, false, extreme);
+            const { circle, zs } = twoProngInfo;
+            const cpNode = add2Prong(cpGraphs, circle, pos, zs, false, extreme);
             cpNode_ = cpNode_ || cpNode;
         }
 
@@ -71,7 +69,7 @@ function findAndAdd2Prongs(
  * @param n
  */
 function indexLinear(n: number) {
-	let arr = [];
+	const arr = [];
 	for (let i=0; i<n; i++) {
 		arr.push(i);
 	}
@@ -86,8 +84,8 @@ function indexLinear(n: number) {
  * @param n
 */
 function indexInterlaced(n: number) {
-	let source: { [index:number]: boolean } = {};
-	let arr = [];
+	const source: { [index:number]: boolean } = {};
+	const arr = [];
 	// l is the lowest power of 2 so that 2^l > n
 	let l = Math.pow(2, Math.floor(Math.log2(n)));
 	

package/src/mat/find-mat/find-and-add-3-prongs.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';
@@ -27,22 +27,22 @@ function findAndAddAll3Prongs(
 	// Don't change this function to be recursive, the call stack may overflow 
 	// if there are too many two-prongs.
 
-	let visitedEdges = new Map<CpNode, Set<CpNode>>();
+	const visitedEdges = new Map<CpNode, Set<CpNode>>();
 
-	let edgesToCheck = [{ fromCpNode: undefined as CpNode, cpStart }];
+	const edgesToCheck = [{ fromCpNode: undefined as CpNode, cpStart }];
 
 	while (edgesToCheck.length) {
-		let { fromCpNode, cpStart } = edgesToCheck.shift();
+		const { fromCpNode, cpStart } = edgesToCheck.shift();
 
 		markEdgeAsTaken(visitedEdges, fromCpNode, cpStart);
 		
-		for (let cpNode of cpStart.getCpNodesOnCircle()) {
+		for (const cpNode of cpStart.getCpNodesOnCircle()) {
 
 			//if (!PointOnShape.isSharpCorner(cpNode.cp.pointOnShape)) {
 			if (!isPosSharpCorner(cpNode.cp.pointOnShape)) {
 				if (findAndAdd3Prongs(cpGraphs, cpNode, extreme) === undefined) {
 					return; // only for debugging purposes
-				};
+				}
 			}
 
 			if (hasEdgeBeenTaken(visitedEdges, cpNode, cpNode.next)) {
@@ -89,10 +89,10 @@ function hasEdgeBeenTaken(
 	let cps: Set<CpNode>;
 
 	cps = visitedEdges.get(cp1);
-	let takenForward   = cps && cps.has(cp2); 
+	const takenForward   = cps && cps.has(cp2); 
 
 	cps = visitedEdges.get(cp2);
-	let takenBackwards = cps && cps.has(cp1); 
+	const takenBackwards = cps && cps.has(cp1); 
 
 	return takenForward || takenBackwards;
 }
@@ -112,11 +112,11 @@ function traverseShape(cpStart: CpNode) {
 		return [cpNode];
 	}
 
-	let visitedCps = [];
+	const visitedCps = [];
 	do {
 		visitedCps.push(cpNode);
 	
-		let next = cpNode.next.prevOnCircle;
+		const next = cpNode.next.prevOnCircle;
 		cpNode = cpNode === next
 				? cpNode = cpNode.next.next // Terminal vertex
 				: cpNode = next         // Take last exit
@@ -179,14 +179,14 @@ function findAndAdd3Prong(
 		visitedCps : CpNode[],
 		extreme    : number) {
 	
-	let δs = [];
-	for (let visitedCp of visitedCps) {
+	const δs = [];
+	for (const visitedCp of visitedCps) {
 		δs.push([visitedCp, visitedCp.next]);
 	}
 	
-	let threeProng = find3Prong(δs, extreme);
+	const threeProng = find3Prong(δs, extreme);
 	
-	let orders = [];
+	const orders = [];
 	for (let i=0; i<3; i++) {
 		orders.push(
 			//PointOnShape.calcOrder(threeProng.circle, threeProng.ps[i])
@@ -194,7 +194,7 @@ function findAndAdd3Prong(
 		);
 	}
 	
-	let circle = add3Prong(cpGraphs, orders, threeProng);
+	const circle = add3Prong(cpGraphs, orders, threeProng);
 
 	if (typeof _debug_ !== 'undefined') { 
 		add3ProngDebugInfo(circle, visitedCps);
@@ -207,9 +207,9 @@ function add3ProngDebugInfo(
 		circle: Circle, 
 		visitedCps: CpNode[]) {
 
-	let threeProngs = _debug_.generated.elems.threeProng;
-	let len = threeProngs.length;
-	let data = threeProngs[len-1];
+	const threeProngs = _debug_.generated.elems.threeProng;
+	const len = threeProngs.length;
+	const data = threeProngs[len-1];
 	data.visitedCps = visitedCps;
 	data.circle     = circle;
 }

package/src/mat/find-mat/find-and-add-hole-closing-2-prongs.ts

@@ -21,19 +21,19 @@ function findAndAddHoleClosing2Prongs(
         cpTrees: Map<Loop,LlRbTree<CpNode>>,
         extreme: number) {
 
-    let bounds = getShapeBounds(loops);
-    let squaredDiagonalLength = 
+    const bounds = getShapeBounds(loops);
+    const squaredDiagonalLength = 
         (bounds.maxX.p[0] - bounds.minX.p[0])**2 +
         (bounds.maxY.p[1] - bounds.minY.p[1])**2;
 
     // Find the topmost points on each loop.
-    let minYs = loops.map(getMinYPos);
+    const minYs = loops.map(getMinYPos);
 
     // We start at 1 since 0 is the outer (root) loop
     for (let k=1; k<minYs.length; k++) {
-        let posSource = minYs[k];
+        const posSource = minYs[k];
         
-        let holeClosingTwoProng = find2Prong(
+        const holeClosingTwoProng = find2Prong(
             loops, extreme, squaredDiagonalLength, cpTrees, posSource, true, k
         );
 
@@ -43,7 +43,7 @@ function findAndAddHoleClosing2Prongs(
 
         // TODO important - handle case of n-prong, i.e. more than one antipode
         // - currently we only handle case of single antipode (the general case)
-        let { circle, zs: posAntipodes } = holeClosingTwoProng;
+        const { circle, zs: posAntipodes } = holeClosingTwoProng;
 
         add2Prong(cpTrees, circle, posSource, [posAntipodes[0]], true, extreme);
     }	

package/src/mat/find-mat/get-potential-2-prongs.ts

@@ -3,12 +3,12 @@ import { IPointOnShape, isPosQuiteSharpCorner } from '../../point-on-shape.js';
 
 /** @hidden */
 function getPotential2Prongs(possPerLoop: IPointOnShape[][]) {
-    let for2ProngsArray = []; 
+    const for2ProngsArray = []; 
     
-    for (let poss of possPerLoop) {
-        let for2Prongs = [];
+    for (const poss of possPerLoop) {
+        const for2Prongs = [];
         
-        for (let pos of poss) {
+        for (const pos of poss) {
             if (!isPosQuiteSharpCorner(pos)) {
                 for2Prongs.push(pos);
             } 

package/src/mat/find-mat/get-sharp-corners.ts

@@ -3,12 +3,12 @@ import { IPointOnShape, isPosQuiteSharpCorner } from '../../point-on-shape.js';
 
 /** @hidden */
 function getSharpCorners(possPerLoop: IPointOnShape[][]) {
-    let sharpCornersPerLoop = [];
+    const sharpCornersPerLoop = [];
     
-    for (let poss of possPerLoop) {
-        let sharpCorners = [];
+    for (const poss of possPerLoop) {
+        const sharpCorners = [];
         
-        for (let pos of poss) {
+        for (const pos of poss) {
             //if (PointOnShape.isQuiteSharpCorner(pos)) {
             if (isPosQuiteSharpCorner(pos)) {
                 sharpCorners.push(pos);

package/src/mat/find-mat/get-total-abs-curvature.ts

@@ -6,7 +6,7 @@ import { getTotalBy } from './get-total-by.js';
 /**
  * @hidden
  */
-let getTotalAbsoluteCurvature = getTotalBy(
+const getTotalAbsoluteCurvature = getTotalBy(
     curve => (
         totalAbsoluteCurvature(curve.ps, [0,1]) + 
         Math.abs(getCurvatureAtInterface(curve))

package/src/mat/geometry/get-closest-squared-distance-to-rotated-rect.ts

@@ -7,14 +7,14 @@ import {
  * @hidden
  */
 function getClosestSquaredDistanceToRotatedRect(ps: number[][], p: number[]) {
-	let ds = [0,1,2,3].map(i => squaredDistanceBetweenPointAndLineSegment(
+	const ds = [0,1,2,3].map(i => squaredDistanceBetweenPointAndLineSegment(
 			p, 
 			[ps[i], ps[(i+1) % 4]]
 		)				
 	);
 	
-	let width  = squaredDistanceBetween(ps[0], ps[1]);
-	let height = squaredDistanceBetween(ps[0], ps[3]);
+	const width  = squaredDistanceBetween(ps[0], ps[1]);
+	const height = squaredDistanceBetween(ps[0], ps[3]);
 
 	if (ds[0] <= height && ds[2] <= height && 
 		ds[1] <= width  && ds[3] <= width) {

package/src/mat/get-boundary-piece-beziers.ts

@@ -14,9 +14,9 @@ import { compareCps } from '../contact-point.js';
  */
 function getBoundaryPieceBeziers(cpNodes: CpNode[]): BezierPiece[] {
     let cpThis = cpNodes[0]; 
-    let cpEnd  = cpNodes[1];
+    const cpEnd  = cpNodes[1];
     
-    let bezierPieces = [];
+    const bezierPieces = [];
 
     // As opposed to going around the circle and taking the last exit
     let goStraight = true; 
@@ -29,8 +29,8 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): BezierPiece[] {
 
         goStraight = false;
         
-        let posThis = cpThis     .cp.pointOnShape;
-        let posNext = cpThis.next.cp.pointOnShape;
+        const posThis = cpThis     .cp.pointOnShape;
+        const posNext = cpThis.next.cp.pointOnShape;
 
         if (posNext.curve === posThis.curve && 
             //PointOnShape.isQuiteSharpCorner(posThis) && 
@@ -81,7 +81,7 @@ function addSkippedBeziers(
     let curveThis = curveStart;
     do {
         curveThis = curveThis.next;
-        let tEnd = curveThis === curveEnd ? t1 : 1;
+        const tEnd = curveThis === curveEnd ? t1 : 1;
         bezierPieces.push({ curve: curveThis, ts: [0, tEnd] });
     } while (curveThis !== curveEnd);
 }

package/src/mat/get-contact-circles-at-interface.ts

@@ -8,7 +8,7 @@ import { IPointOnShape } from '../point-on-shape.js';
  * @param curve 
  */
 function getContactCirclesAtInterface(curve: Curve): IPointOnShape[] {
-	let { isQuiteSharp, isQuiteDull } = getCornerAtEnd(curve);
+	const { isQuiteSharp, isQuiteDull } = getCornerAtEnd(curve);
 
 	if (isQuiteSharp) {  
 		return [new PointOnShape(curve, 1)]; 

package/src/mat/get-edges-as-array.ts

@@ -2,9 +2,9 @@ import { CpNode } from '../cp-node.js';
 import { traverseEdges } from '../traverse-edges.js';
 
 
-/** @hidden */
+/** @internal */
 function getEdgesAsArray(cpNode: CpNode) {	
-	let cpNodes: CpNode[] = [];
+	const cpNodes: CpNode[] = [];
 	
 	traverseEdges(
 		cpNode, 

package/src/mat/get-leaves.ts

@@ -3,9 +3,9 @@ import { CpNode } from '../cp-node.js';
 
 /** @hidden */
 function getLeaves(cpNode: CpNode) {
-    let leaves: CpNode[] = [];
+    const leaves: CpNode[] = [];
 
-    let cps = cpNode.getAllOnLoop();
+    const cps = cpNode.getAllOnLoop();
     cps.forEach(function(cp) {
         if (cp.isTerminating()) { 
             leaves.push(cp);

package/src/mat/get-neighboring-cps.ts

@@ -18,7 +18,7 @@ function getNeighbouringPoints(
         order: number,
         order2: number) {
 
-    let cps = cpTree.findBounds(
+    const cps = cpTree.findBounds(
         new CpNode({ pointOnShape: pos, circle: undefined, order, order2 }, false, false)
     );
 

package/src/mat/is-another-cp-closeby.ts

@@ -48,28 +48,28 @@ function isAnotherCpCloseby(
     // It seems this can be zero else the ordering should be correct
     //const DISTANCE_THRESHOLD = 0;
 
-    let cpTree = cpTrees.get(pos.curve.loop);
-    let cpNodes = getNeighbouringPoints(cpTree, pos, order, order2);
+    const cpTree = cpTrees.get(pos.curve.loop);
+    const cpNodes = getNeighbouringPoints(cpTree, pos, order, order2);
     if (!cpNodes[0]) { return false }
 
-    for (let cpNode of cpNodes) {
-        let pos2 = cpNode.cp.pointOnShape;
-        let p1 = pos.p;
-        let p2 = pos2.p;
+    for (const cpNode of cpNodes) {
+        const pos2 = cpNode.cp.pointOnShape;
+        const p1 = pos.p;
+        const p2 = pos2.p;
         
         if (distanceBetween(p1,p2) > DISTANCE_THRESHOLD) {
             continue;
         }
 
-        let v1 = toUnitVector(fromTo(
+        const v1 = toUnitVector(fromTo(
             cpNode.cp.pointOnShape.p, 
             cpNode.cp.circle.center
         ));
-        let v2 = toUnitVector(fromTo(
+        const v2 = toUnitVector(fromTo(
             p1,
             circle.center
         ));
-        let cosTheta = dot(v1,v2);
+        const cosTheta = dot(v1,v2);
                             
         if (cosTheta > ANGLE_THRESHOLD) {
             //console.log(`%c${cosTheta} - ${distanceBetween(p1,p2)}`, `color: ${color}`);

package/src/mat/simplify-mat-map-only.ts

@@ -25,29 +25,29 @@ function simplifyMatMapOnly(
         hausdorffTolerance = 1e-1,
         hausdorffSpacing = 1e0) {
 
-    let simpleMap: Map<CpNode, { ps: number[][], ts: number[] }> = new Map();
+    const simpleMap: Map<CpNode, { ps: number[][], ts: number[] }> = new Map();
 
     // Start from a leaf
     while (!cpNode.isTerminating()) {
         cpNode = cpNode.next;
     }
 
-    let branches = getBranches(cpNode, anlgeTolerance);
+    const branches = getBranches(cpNode, anlgeTolerance);
 
-    let canDeletes: CpNode[] = [];
+    const canDeletes: CpNode[] = [];
     for (let k=0; k<branches.length; k++) {
-        let branch = branches[k];
+        const branch = branches[k];
 
         // Try to remove some
         let j = 0;
         while (j < branch.length) {
-            let i = j;
+            const i = j;
             while (true) {
                 j++;
 
                 if (j === branch.length) { break; }
 
-                let hd = getTotalHausdorffDistance(i, j, branch, hausdorffSpacing);
+                const hd = getTotalHausdorffDistance(i, j, branch, hausdorffSpacing);
 
                 if (hd > hausdorffTolerance) {
                     break;
@@ -59,17 +59,17 @@ function simplifyMatMapOnly(
             if (i+1 === j) { 
                 // no simplification occured
             } else {
-                let branStart = branch[i];
-                let branEnd = branch[j-1];
+                const branStart = branch[i];
+                const branEnd = branch[j-1];
 
-                let medial = toCubic(getCurveBetween(branStart, branEnd.next));
-                let rev = medial.slice().reverse();
+                const medial = toCubic(getCurveBetween(branStart, branEnd.next));
+                const rev = medial.slice().reverse();
                 let curCpNode = branStart;
                 let prevT = 0;
                 while (curCpNode !== branEnd) {
-                    let t = closestPointOnBezier(medial, curCpNode.next.cp.circle.center).t;
+                    const t = closestPointOnBezier(medial, curCpNode.next.cp.circle.center).t;
                     simpleMap.set(curCpNode, { ps: medial, ts: [prevT, t] });
-                    let oppositeCpNode = curCpNode.nextOnCircle.prev;
+                    const oppositeCpNode = curCpNode.nextOnCircle.prev;
                     simpleMap.set(oppositeCpNode, { ps: rev, ts: [1-t, 1-prevT] });
 
                     prevT = t;
@@ -77,7 +77,7 @@ function simplifyMatMapOnly(
                 }
                 simpleMap.set(curCpNode, { ps: medial, ts: [prevT, 1] });
 
-                let oppositeCpNode = curCpNode.nextOnCircle.prev;
+                const oppositeCpNode = curCpNode.nextOnCircle.prev;
                 simpleMap.set(oppositeCpNode, { ps: rev, ts: [0, 1-prevT] });
             }
         }
@@ -93,8 +93,8 @@ function getTotalHausdorffDistance(
         branch: CpNode[],
         hausdorffSpacing: number) {
 
-    let hds: number[] = [];
-    let longCurve = getCurveBetween(branch[i], branch[j].next);
+    const hds: number[] = [];
+    const longCurve = getCurveBetween(branch[i], branch[j].next);
     for (let m=i; m<j+1; m++) {
         hds.push(hausdorffDistance(
             getCurveToNext(branch[m]), 

package/src/mat/to-scale-axis/add-debug-info.ts

@@ -1,4 +1,4 @@
-declare var _debug_: Debug; 
+declare const _debug_: Debug; 
 
 import { Debug } from '../../debug/debug.js';
 import { Mat } from '../../mat.js';
@@ -8,12 +8,15 @@ import { Mat } from '../../mat.js';
  * @hidden
  * @param sat 
  */
-function addDebugInfo(sat: Mat, timingStart: number) {
+function addDebugInfo(
+		sat: Mat,
+		timingStart: number) {
+
 	if (typeof _debug_ === 'undefined') { return; }
 
 	_debug_.generated.elems.sat.push(sat);
 
-	let timing = _debug_.generated.timing;
+	const timing = _debug_.generated.timing;
 	timing.sats = performance.now() - timingStart;
 }
 

package/src/mat/to-scale-axis/add-to-tree.ts

@@ -25,7 +25,7 @@ function addToTree(
     circle: Circle,
     depth: number) {
 
-    let { groups, newLimits } = calcGroups(
+    const { groups, newLimits } = calcGroups(
         s,
         coordinate, 
         limits, 
@@ -34,15 +34,15 @@ function addToTree(
 
     // Create new edge if it does not exist yet.
     if (groups.length === 1 && depth !== DEPTH_LIMIT) {
-        let group = groups[0]; 
+        const group = groups[0]; 
         
-        if (!tree.trees.get(group)) { 
-            tree.trees.set(group, { trees: new Map(), circles: new Set() } ); 
+        if (!tree.trees!.get(group)) { 
+            tree.trees!.set(group, { trees: new Map(), circles: new Set() } ); 
         }	
-        let t = tree.trees.get(group);
+        const t = tree.trees!.get(group)!;
         
         // Flip coordinates
-        let newCoordinate = coordinate ? 0 : 1; 
+        const newCoordinate = coordinate ? 0 : 1; 
         addToTree(
             s,
             t, 
@@ -55,11 +55,11 @@ function addToTree(
         return;
     }
 
-    if (!tree.trees.get(5)) { 
-        tree.trees.set(5, { trees: new Map(), circles: new Set() } );
+    if (!tree.trees!.get(5)) { 
+        tree.trees!.set(5, { trees: new Map(), circles: new Set() } );
     }
-    let vertices = tree.trees.get(5).circles;
-    vertices.add(circle);
+    const vertices = tree.trees!.get(5)!.circles;
+    vertices!.add(circle);
 }