flo-mat 2.0.1 → 2.0.2

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 };
 }

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}`);