flo-mat 2.0.1 → 2.0.3

package/src/mat/to-scale-axis/calc-groups.ts

@@ -29,47 +29,47 @@ function calcGroups(
         limits: number[][], 
         circle: Circle) {
 
-    let limit = limits[coordinate];
-    let l1 = limit[0];
-    let l2 = limit[1];
+    const limit = limits[coordinate];
+    const l1 = limit[0];
+    const l2 = limit[1];
 
     // Relevant cut-off lines.
-    let q = (l2 - l1) / 4;
-    let w = q+q;
+    const q = (l2 - l1) / 4;
+    const w = q+q;
 
     // Shift origin
-    let r = circle.radius;
-    let x = circle.center[coordinate] - l1;
-    let x0 = x - (r * s);
-    let x1 = x + (r * s); 
+    const r = circle.radius;
+    const x = circle.center[coordinate] - l1;
+    const x0 = x - (r * s);
+    const x1 = x + (r * s); 
 
-    let newLimit: number[] = [,];
-    let groups = []; // Group to which circle belongs;
+    let newLimit: (number | undefined)[] = [,];
+    const groups: number[] = []; // Group to which circle belongs;
 
-    let qStart = Math.floor(x0/q);
-    let qEnd   = Math.floor(x1/q) + 1;
-    let qDiff  = qEnd - qStart; 
+    const qStart = Math.floor(x0/q);
+    const qEnd   = Math.floor(x1/q) + 1;
+    const qDiff  = qEnd - qStart; 
 
-    let group;
+    let group: number;
     if (qDiff === 1) {
         // If contained in sliver.
         group = (2 * Math.floor(qStart/2)) + 1;
         groups.push(group);
         
-        let lowerLimit = l1 + q*(group-1); 
+        const lowerLimit = l1 + q*(group-1); 
         newLimit = [lowerLimit, lowerLimit + w];			
         
     } else if (qDiff === 2) {
         group = qStart + 1;
         groups.push(group);
         
-        let lowerLimit = l1 + q*(group-1); 
+        const lowerLimit = l1 + q*(group-1); 
         newLimit = [lowerLimit, lowerLimit + w];
     }
 
-    let newLimits: number[][] = [,];
+    const newLimits: ((number | undefined)[] | undefined)[] = [,];
     if (groups.length === 1) {
-        let otherCoordinate = coordinate ? 0 : 1; 
+        const otherCoordinate = coordinate ? 0 : 1; 
         
         newLimits[otherCoordinate] = limits[otherCoordinate];
         newLimits[coordinate] = newLimit;

package/src/mat/to-scale-axis/create-spacial-tree.ts

@@ -18,12 +18,12 @@ function createSpacialTree(
         s: number, 
         circles: Circle[]) {
 
-    let coordinate = 0;
-    let limits = [[0, width], [0, height]];
+    const coordinate = 0;
+    const limits = [[0, width], [0, height]];
 
-    let tree: TTree = { trees: new Map(), circles: new Set() };
+    const tree: TTree = { trees: new Map(), circles: new Set() };
 
-    for (let circle of circles) {
+    for (const circle of circles) {
         addToTree(
                 s, 
                 tree, 

package/src/mat/to-scale-axis/cull-non-cycles.ts

@@ -12,11 +12,11 @@ function cullNonCycles(cpStart: CpNode) {
 
     let cpNodeKept = cpStart;
 
-    let leaves = getLeaves(cpStart);
+    const leaves = getLeaves(cpStart);
 
     
     while (leaves.length) {
-        let leaf = leaves.pop();
+        const leaf = leaves.pop();
 
         // Preserve topology - keep cycles.
         if (leaf.isHoleClosing || leaf.isIntersection) { continue; }
@@ -26,11 +26,11 @@ function cullNonCycles(cpStart: CpNode) {
         while (true) {
             cpNode = cpNode.next;
             let cut = false;
-            let cp1 = cpNode.prevOnCircle;
+            const cp1 = cpNode.prevOnCircle;
 
             if (cpNode.getProngCount() > 2) {
-                //let cp2 = cp1.prevOnCircle;
-                let cp2 = cpNode.nextOnCircle;
+                //const cp2 = cp1.prevOnCircle;
+                const cp2 = cpNode.nextOnCircle;
 
                 //if (cpStart === cpNode || cpStart === cp1 || cpStart === cp2) {
                 if (CpNode.isOnSameCircle(cpNode, cpStart)) {

package/src/mat/to-scale-axis/cull.ts

@@ -15,12 +15,12 @@ function cull(
         culls: Set<Circle>, 
         maxCpNode: CpNode) {
 
-    let leaves = getLeaves(maxCpNode);
+    const leaves = getLeaves(maxCpNode);
 
     function getNonTrivialEdges(cpStart: CpNode) {
 		let cp = cpStart;
 		
-        let cps: CpNode[] = [];
+        const cps: CpNode[] = [];
 		do {
             if (cp.next !== cp.nextOnCircle) {
                 cps.push(cp);
@@ -32,7 +32,7 @@ function cull(
     }
 
     while (leaves.length) {
-        let leaf = leaves.pop();
+        const leaf = leaves.pop();
 
         // Preserve topology.
         if (leaf.isHoleClosing || leaf.isIntersection) { continue; }
@@ -46,7 +46,7 @@ function cull(
         while (true) {
             cpNode = cpNode.next;
             let cut = false;
-            let cp1 = cpNode.prevOnCircle;
+            const cp1 = cpNode.prevOnCircle;
 
             if (!culls.has(cpNode.cp.circle)) {
                 // Cut off the edge once a non-cull has been reached.
@@ -54,7 +54,7 @@ function cull(
             } else if (CpNode.isOnSameCircle(cpNode, maxCpNode)) {
                 cut = true; // We are at the max disk - cut whole edge
             } else {
-                let cps = getNonTrivialEdges(cpNode);
+                const cps = getNonTrivialEdges(cpNode);
 
                 if (cps.length === 1) { 
                     cpNode = cps[0];

package/src/mat/to-scale-axis/get-engulfed-vertices.ts

@@ -22,24 +22,24 @@ function getEngulfedVertices(
         tree: TTree, 
         circle: Circle) {
 
-    let c1 = scaleCircle(circle, s);
+    const c1 = scaleCircle(circle, s);
 
-    let cullNodes: Set<Circle> = new Set();
+    const cullNodes: Set<Circle> = new Set();
 
-    let limits = [[0, width], [0, height]];
+    const limits = [[0, width], [0, height]];
     f(tree, 0, limits, 0);
 
     return cullNodes;
 
 
     function cullBranch5(tree: TTree) {
-        let t = tree.trees.get(5);
+        const t = tree.trees!.get(5);
         if (!t) { return; }
 
-        let circles = t.circles;
+        const circles = t.circles!;
         
         circles.forEach(function(circle, key) {
-            let c2 = scaleCircle(circle, s);
+            const c2 = scaleCircle(circle, s);
             if (engulfsCircle(c1, c2)) {
                 cullNodes.add(circle);
                 circles.delete(key);
@@ -51,7 +51,7 @@ function getEngulfedVertices(
     function f(
             tree: TTree, 
             coordinate: number, 
-            limits: number[][], 
+            limits: number[][] | null, 
             depth: number) {
         
         if (limits === null) {
@@ -60,7 +60,7 @@ function getEngulfedVertices(
             cullBranch5(tree);
             
             for (let i=0; i<=4; i++) {
-                let t = tree.trees.get(i);
+                const t = tree.trees!.get(i);
                 if (t) {
                     f(t, 0, null, depth+1);
                 }
@@ -69,7 +69,7 @@ function getEngulfedVertices(
             return;
         }
         
-        let { groups, newLimits } = calcGroups(
+        const { groups, newLimits } = calcGroups(
                 s, 
                 coordinate, 
                 limits, 
@@ -79,13 +79,13 @@ function getEngulfedVertices(
         if (groups.length === 1) {
             cullBranch5(tree);
             
-            let group = groups[0];
-            let newCoordinate = coordinate ? 0 : 1;
+            const group = groups[0];
+            const newCoordinate = coordinate ? 0 : 1;
             
             if (group === 1 || group === 3) {
                 // One of the higher priority left/top or 
                 // right/bottom half groups.
-                let t = tree.trees.get(group);
+                const t = tree.trees!.get(group);
                 
                 if (t) {
                     f(
@@ -98,12 +98,12 @@ function getEngulfedVertices(
             } else {
                 // One of the lower priority even groups (0,2 or 4).
                 
-                let branches = [];
-                branches.push(tree.trees.get(group));
-                if (group > 0) { branches.push(tree.trees.get(group-1)); }
-                if (group < 4) { branches.push(tree.trees.get(group+1)); }
+                const branches: TTree[] = [];
+                branches.push(tree.trees!.get(group)!);
+                if (group > 0) { branches.push(tree.trees!.get(group-1)!); }
+                if (group < 4) { branches.push(tree.trees!.get(group+1)!); }
                 
-                for (let branch of branches) {
+                for (const branch of branches) {
                     if (branch) {
                         f(
                                 branch, 
@@ -123,7 +123,7 @@ function getEngulfedVertices(
         // Circle spans multiple groups at this level of the tree. Check all 
         // circles in all branches.
         for (let i=0; i<=4; i++) {
-            let t = tree.trees.get(i);
+            const t = tree.trees!.get(i);
             if (!t) { continue; }
             
             f(t, 0, null, depth+1);

package/src/mat/trim-mat.ts

@@ -10,7 +10,7 @@ import { clone } from '../cp-node/clone.js';
  * @param mat The MAT to trim.
  */
 function trimMat(mat: Mat): Mat {
-	let cpNode = cullNonCycles(clone(mat.cpNode));
+	const cpNode = cullNonCycles(clone(mat.cpNode));
 
     if (!cpNode) { return undefined; }
 

package/src/point-on-shape.ts

@@ -65,7 +65,7 @@ function getPosCorner(pos: IPointOnShape) {
 /**
  * @hidden
  */
-let isPosSharpCorner = memoize((pos: IPointOnShape) => {
+const isPosSharpCorner = memoize((pos: IPointOnShape) => {
     if (!isPosCorner(pos)) { return false; }
 
     return getPosCorner(pos).isSharp;
@@ -75,7 +75,7 @@ let isPosSharpCorner = memoize((pos: IPointOnShape) => {
 /**
  * @hidden
  */
-let isPosDullCorner = memoize((pos: IPointOnShape) => {
+const isPosDullCorner = memoize((pos: IPointOnShape) => {
     if (!isPosCorner(pos)) { return false; }
 
     return getPosCorner(pos).isDull;
@@ -85,7 +85,7 @@ let isPosDullCorner = memoize((pos: IPointOnShape) => {
 /**
  * @hidden
  */
-let isPosQuiteSharpCorner = memoize((pos: IPointOnShape) => {
+const isPosQuiteSharpCorner = memoize((pos: IPointOnShape) => {
     if (!isPosCorner(pos)) { return false; }
 
     return getPosCorner(pos).isQuiteSharp;
@@ -95,7 +95,7 @@ let isPosQuiteSharpCorner = memoize((pos: IPointOnShape) => {
 /**
  * @hidden
  */
-let isPosQuiteDullCorner = memoize((pos: IPointOnShape) => {
+const isPosQuiteDullCorner = memoize((pos: IPointOnShape) => {
     if (!isPosCorner(pos)) { return false; }
 
     return getPosCorner(pos).isQuiteDull;
@@ -128,10 +128,10 @@ function calcPosOrder(
     if (!isPosDullCorner(pos)) { return 0; }
     //if (!isPosDullCorner(pos)) { return 0; }
 
-    let corner = getPosCorner(pos);
+    const corner = getPosCorner(pos);
 
-    let n = rotateNeg90Degrees(corner.tangents[0]);
-    let v = toUnitVector( fromTo(pos.p, circle.center) );
+    const n = rotateNeg90Degrees(corner.tangents[0]);
+    const v = toUnitVector( fromTo(pos.p, circle.center) );
 
     return -dot(n, v);
 }
@@ -168,11 +168,11 @@ function comparePoss(a: IPointOnShape, b: IPointOnShape) {
  * @param t
  * @hidden
  */
-let calcOsculatingCircleRadius = memoize((pos: IPointOnShape) => {
-    let ps = pos.curve.ps;
-    let t  = pos.t;
+const calcOsculatingCircleRadius = memoize((pos: IPointOnShape) => {
+    const ps = pos.curve.ps;
+    const t  = pos.t;
 
-    let c = -curvature(ps, t); 
+    const c = -curvature(ps, t); 
 
     // c > 0 => bending inwards
 
@@ -202,13 +202,13 @@ function getOsculatingCircle(
         maxOsculatingCircleRadius
     );
 
-    let ps = pos.curve.ps;
-    let t  = pos.t;
+    const ps = pos.curve.ps;
+    const t  = pos.t;
     
     const tangent_ = tangent(ps,t);
-    let normal_ = toUnitVector([-tangent_[1],tangent_[0]]);
-    let p = evalDeCasteljau(ps,t);
-    let circleCenter = [
+    const normal_ = toUnitVector([-tangent_[1],tangent_[0]]);
+    const p = evalDeCasteljau(ps,t);
+    const circleCenter = [
         p[0] - normal_[0]*radius,
         p[1] - normal_[1]*radius
     ];

package/src/simplify-mat.ts

@@ -30,22 +30,22 @@ function simplifyMat(
     // 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, maxIterations);
+                const hd = getTotalHausdorffDistance(i, j, branch, maxIterations);
 
                 if (hd > hausdorffTolerance) {
                     break;
@@ -61,9 +61,9 @@ function simplifyMat(
         }
     }
 
-    for (let cpNode of canDeletes) {
-        let isTerminating = cpNode.isTerminating();
-        let onCircleCount = cpNode.getCpNodesOnCircle().length;
+    for (const cpNode of canDeletes) {
+        const isTerminating = cpNode.isTerminating();
+        const onCircleCount = cpNode.getCpNodesOnCircle().length;
         if (isTerminating || onCircleCount !== 2) { 
             continue; 
         }
@@ -82,8 +82,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 (; i<j+1; i++) {
         hds.push(hausdorffDistance(
             getCurveToNext(branch[i]),

package/src/svg/get-curvature-at-interface.ts

@@ -11,24 +11,22 @@ import { Curve } from '../curve.js';
  * @param curve
  */
 function getCurvatureAtInterface(curve: Curve) {	
-	const ts = [1,0];
-	
-	let pss = [
+	const pss = [
 		curve.ps,
 		curve.next.ps
 	];
 	
-	let tans = [ 
+	const tans = [ 
 		toUnitVector(tangent(pss[0], 1)), 
 		toUnitVector(tangent(pss[0], 0))
 	];
 	
 	// The integral of a kind of Dirac Delta function.
-	let cosθ = dot  (tans[0], tans[1]);
-	let sinθ = cross(tans[0], tans[1]);
-	let θ = acos(cosθ);
+	const cosθ = dot  (tans[0], tans[1]);
+	const sinθ = cross(tans[0], tans[1]);
+	const θ = acos(cosθ);
 	
-	let result = sinθ >= 0 ? θ : -θ;
+	const result = sinθ >= 0 ? θ : -θ;
 	
 	return result;
 }

package/src/svg/get-extreme.ts

@@ -9,7 +9,7 @@ import { getShapeBounds } from './get-shape-bounds.js';
  * @param loops 
  */
 function getExtreme(loops: Loop[]) {
-	let bounds = getShapeBounds(loops);
+	const bounds = getShapeBounds(loops);
 	
 	return Math.max(  
 			Math.abs(bounds.minX.p[0]),

package/src/svg/get-loop-bounds.ts

@@ -12,13 +12,13 @@ const INF = Number.POSITIVE_INFINITY;
 /** 
  * @hidden 
  */
-let getLoopBounds = memoize(function(loop: Loop): {
+const getLoopBounds = memoize(function(loop: Loop): {
 		minX: IPointOnShape;
 		minY: IPointOnShape;
 		maxX: IPointOnShape;
 		maxY: IPointOnShape } {	
 
-	let extremes: { 
+	const extremes: { 
 		bezier: Curve, 
 		t: number, 
 		val: number 
@@ -34,15 +34,15 @@ let getLoopBounds = memoize(function(loop: Loop): {
 	];
 	
 	loop.curves.forEach(function(curve: Curve): void {			
-		let ps = curve.ps; 
-		// let bounds = getBounds_(ps);
-		let bounds = getBounds(ps);
+		const ps = curve.ps; 
+		// const bounds = getBounds_(ps);
+		const bounds = getBounds(ps);
 		
 		
 		{	
 			{
-				let v = bounds.box[0][0];
-				let x = extremes[0][0].val;
+				const v = bounds.box[0][0];
+				const x = extremes[0][0].val;
 				if (v < x || (v === x && bounds.ts[0][0] > extremes[0][0].t)) { 
 					extremes[0][0] = { 
 						bezier : curve, 
@@ -53,8 +53,8 @@ let getLoopBounds = memoize(function(loop: Loop): {
 			}
 
 			{
-				let v = bounds.box[0][1];
-				let x = extremes[0][1].val;
+				const v = bounds.box[0][1];
+				const x = extremes[0][1].val;
 				if (v < x || (v === x && bounds.ts[0][1] > extremes[0][1].t)) { 
 					extremes[0][1] = { 
 						bezier : curve, 
@@ -67,8 +67,8 @@ let getLoopBounds = memoize(function(loop: Loop): {
 
 		{	
 			{
-				let v = bounds.box[1][0];
-				let x = extremes[1][0].val;
+				const v = bounds.box[1][0];
+				const x = extremes[1][0].val;
 				if (v > x || (v === x && bounds.ts[1][0] > extremes[1][0].t)) { 
 					extremes[1][0] = { 
 						bezier : curve, 
@@ -79,8 +79,8 @@ let getLoopBounds = memoize(function(loop: Loop): {
 			}
 
 			{
-				let v = bounds.box[1][1];
-				let x = extremes[1][1].val;
+				const v = bounds.box[1][1];
+				const x = extremes[1][1].val;
 				if (v > x || (v === x && bounds.ts[1][1] > extremes[1][1].t)) { 
 					extremes[1][1] = { 
 						bezier : curve, 

package/src/svg/get-shape-bounds.ts

@@ -6,8 +6,8 @@ import { getLoopBounds } from './get-loop-bounds.js';
 // TODO - move to another library
 
 
-/** @hidden */
-let getShapeBounds = memoize(function(loops: Loop[]) {
+/** @internal */
+const getShapeBounds = memoize(function(loops: Loop[]) {
     let minX_ = Number.POSITIVE_INFINITY;
     let maxX_ = Number.NEGATIVE_INFINITY;
     let minY_ = Number.POSITIVE_INFINITY;
@@ -18,8 +18,8 @@ let getShapeBounds = memoize(function(loops: Loop[]) {
     let minY;
     let maxY;
 
-    for (let loop of loops) {
-        let bounds = getLoopBounds(loop);
+    for (const loop of loops) {
+        const bounds = getLoopBounds(loop);
         if (bounds.minX.p[0] < minX_) {
             minX = bounds.minX;
             minX_ = bounds.minX.p[0];

package/src/sweep-line/are-boxes-intersecting.ts

@@ -15,10 +15,10 @@ function areBoxesIntersecting(closed: boolean) {
         let [[bx0, by0],[bx1, by1]] = b;
 
         // Swap so smaller coordinate comes first
-        if (ay0 > ay1) { [ay0,ay1] = [ay1,ay0] };
-        if (by0 > by1) { [by0,by1] = [by1,by0] };
-        if (ax0 > ax1) { [ax0,ax1] = [ax1,ax0] };
-        if (bx0 > bx1) { [bx0,bx1] = [bx1,bx0] };
+        if (ay0 > ay1) { [ay0,ay1] = [ay1,ay0] }
+        if (by0 > by1) { [by0,by1] = [by1,by0] }
+        if (ax0 > ax1) { [ax0,ax1] = [ax1,ax0] }
+        if (bx0 > bx1) { [bx0,bx1] = [bx1,bx0] }
 
         return closed
             ? (

package/src/sweep-line/sweep-line.ts

@@ -32,8 +32,8 @@ function sweepLine<T>(
         predicate: (item1: T, item2: T) => boolean): [T,T][] {
 
     // Initialize event queue to contain all endpoints.
-    let events: IEvent<T>[] = [];
-	for (let item of items) {
+    const events: IEvent<T>[] = [];
+	for (const item of items) {
 		events.push({ 
             type: EVENT_LEFT, 
             item, 
@@ -48,15 +48,15 @@ function sweepLine<T>(
 
 	events.sort(compare);
 	
-	let activeItems = new Set<T>();
+	const activeItems = new Set<T>();
     
     /** A list of pairs of items that passed the predicate */
-	let pairedItems: [T,T][] = [];
-	for (let event of events) {
-    	let { item } = event;
+	const pairedItems: [T,T][] = [];
+	for (const event of events) {
+    	const { item } = event;
     	
    		if (event.type === EVENT_LEFT) {
-   			for (let activeItem of activeItems.values()) {
+   			for (const activeItem of activeItems.values()) {
    				if (predicate(item, activeItem)) { 
                     pairedItems.push([item, activeItem]);
    				}
@@ -93,7 +93,7 @@ interface IEvent<T> {
  * @param b Another event
  */
 function compare<T>(a: IEvent<T>, b: IEvent<T>) {
-    let res = a.x - b.x;
+    const res = a.x - b.x;
 
     if (res !== 0) { return res; }
 

package/src/to-scale-axis.ts

@@ -1,5 +1,5 @@
-/** @hidden */
-declare var _debug_: Debug;
+/** @internal */
+declare const _debug_: Debug;
 
 import { length } from 'flo-bezier3';
 import { Debug } from './debug/debug.js';
@@ -45,21 +45,22 @@ function toScaleAxis(
 		s: number, 
 		f: (s: number) => (r: number) => number = linearScale): Mat {
 
+	let timingStart = 0;
 	if (typeof _debug_ !== 'undefined') {
-		var timingStart = performance.now();
-		let leaves = getLeaves(mat.cpNode);
+		timingStart = performance.now();
+		const leaves = getLeaves(mat.cpNode);
 		_debug_.generated.elems.leaves.push(leaves);
 	}
 
 	/** The largest vertex (as measured by its inscribed disk) */
-	let cpNodes: CpNode[] = [];
+	const cpNodes: CpNode[] = [];
 	traverseVertices(
 		clone(mat.cpNode), 
 		cpNode => { cpNodes.push(cpNode); }
 	);
 
-	let cpNode = getLargestVertex(cpNodes);
-	let f_ = f(s);
+	const cpNode = getLargestVertex(cpNodes);
+	const f_ = f(s);
 
 	if (typeof _debug_ !== 'undefined') {
 		_debug_.generated.elems.maxVertex.push(cpNode);
@@ -69,22 +70,22 @@ function toScaleAxis(
 	 * All vertices that are set to be culled initially. This may change later 
 	 * in order to preserve topology. 
 	 */
-	let culls: Set<Circle> = new Set();
+	const culls: Set<Circle> = new Set();
 
-	let rMap: Map<CpNode,number> = new Map();
+	const rMap: Map<CpNode,number> = new Map();
 
 	traverseEdges(cpNode, function(cpNode) {
 		/** The occulating radius stored with this vertex. */
-		let R = rMap.get(cpNode) || f_(cpNode.cp.circle.radius);
+		const R = rMap.get(cpNode) || f_(cpNode.cp.circle.radius);
 
-		let cpNode_ = cpNode.next;
+		const cpNode_ = cpNode.next;
 
-		let l = length([0,1], getCurveToNext(cpNode));
+		const l = length([0,1], getCurveToNext(cpNode));
 
-		let r = cpNode_.cp.circle.radius;
-		let r_ = f_(r);
+		const r = cpNode_.cp.circle.radius;
+		const r_ = f_(r);
 		if (R - l > r_) {
-			for (let cpNode of cpNode_.getCpNodesOnCircle()) {
+			for (const cpNode of cpNode_.getCpNodesOnCircle()) {
 				rMap.set(cpNode, R - l); // Update osculating radii
 			}
 			culls.add(cpNode_.cp.circle);
@@ -98,8 +99,8 @@ function toScaleAxis(
 	}
 	 
 	// TODO - put line below back - goes into infinite loop
-	//let sat: Mat = { cpNode, cpTrees: createNewCpTree(cpNode) };
-	let sat: Mat = { cpNode, cpTrees: undefined };
+	//const sat: Mat = { cpNode, cpTrees: createNewCpTree(cpNode) };
+	const sat: Mat = { cpNode, cpTrees: undefined };
 
 	addDebugInfo(sat, timingStart);