flo-mat 2.0.0 → 2.0.2

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

@@ -1,5 +1,5 @@
-/** @hidden */
-declare var _debug_: Debug;
+/** @internal */
+declare const _debug_: Debug;
 
 import { LlRbTree } from 'flo-ll-rb-tree';
 import { exponent } from 'big-float-ts';
@@ -34,8 +34,8 @@ function add2Prong(
 		extreme       : number): CpNode {
 
 	//let orderSource   = PointOnShape.calcOrder(circle, posSource);
-	let orderSource   = calcPosOrder(circle, posSource);
-	let orderAntipodes = posAntipodes.map(
+	const orderSource   = calcPosOrder(circle, posSource);
+	const orderAntipodes = posAntipodes.map(
 		posAntipode => {
 			//console.log(circle.center)
 			//return PointOnShape.calcOrder(circle, posAntipode.pos);
@@ -58,8 +58,8 @@ function add2Prong(
 
 	let isCloseByAntipodes = false;
 	for (let i=0; i<posAntipodes.length; i++) {
-		let posAntipode = posAntipodes[i];
-		let orderAntipode = orderAntipodes[i];
+		const posAntipode = posAntipodes[i];
+		const orderAntipode = orderAntipodes[i];
 
 		if (isAnotherCpCloseby(cpGraphs, posAntipode.pos, circle, orderAntipode, 0, extreme, 'red')) {
 			isCloseByAntipodes = true;
@@ -80,22 +80,22 @@ function add2Prong(
 	}
 
 	// Antipode
-	let newCpAntipodes: CpNode[] = [];
-	let cpAntipodes: ContactPoint[] = [];
-	let cpTreeAntipodes: LlRbTree<CpNode>[] = [];
-	let deltaAntipodes: CpNode[][] = [];
-	let loopAntipodes: Loop[] = [];
+	const newCpAntipodes: CpNode[] = [];
+	const cpAntipodes: ContactPoint[] = [];
+	const cpTreeAntipodes: LlRbTree<CpNode>[] = [];
+	const deltaAntipodes: CpNode[][] = [];
+	const loopAntipodes: Loop[] = [];
 	for (let i=0; i<posAntipodes.length; i++) {
-		let posAntipode = posAntipodes[i];
-		let orderAntipode = orderAntipodes[i];
+		const posAntipode = posAntipodes[i];
+		const orderAntipode = orderAntipodes[i];
 
-		let cpAntipode: ContactPoint = { pointOnShape: posAntipode.pos, circle, order: orderAntipode, order2: 0 };
+		const cpAntipode: ContactPoint = { pointOnShape: posAntipode.pos, circle, order: orderAntipode, order2: 0 };
 		cpAntipodes.push(cpAntipode);
-		let loopAntipode = posAntipode.pos.curve.loop;
+		const loopAntipode = posAntipode.pos.curve.loop;
 		loopAntipodes.push(loopAntipode);
-		let cpTreeAntipode = cpGraphs.get(loopAntipode);
+		const cpTreeAntipode = cpGraphs.get(loopAntipode);
 		cpTreeAntipodes.push(cpTreeAntipode);
-		let deltaAntipode = getNeighbouringPoints(
+		const deltaAntipode = getNeighbouringPoints(
 			cpTreeAntipode, posAntipode.pos, orderAntipode, 0
 		);	
 		deltaAntipodes.push(deltaAntipode);
@@ -111,13 +111,13 @@ function add2Prong(
 	
 	
 	// Source
-	let cpSource: ContactPoint = { pointOnShape: posSource, circle, order: orderSource, order2: 0 };
-	let loopSource = posSource.curve.loop;
-	let cpTreeSource = cpGraphs.get(loopSource);
-	let deltaSource = getNeighbouringPoints(
+	const cpSource: ContactPoint = { pointOnShape: posSource, circle, order: orderSource, order2: 0 };
+	const loopSource = posSource.curve.loop;
+	const cpTreeSource = cpGraphs.get(loopSource);
+	const deltaSource = getNeighbouringPoints(
 		cpTreeSource, posSource, orderSource, 0
 	);
-	let newCpSource = CpNode.insert(
+	const newCpSource = CpNode.insert(
 		holeClosing,
 		false,
 		cpTreeSource,
@@ -134,19 +134,19 @@ function add2Prong(
 		newCpAntipodes[0].prevOnCircle = newCpSource;
 		newCpAntipodes[0].nextOnCircle = newCpSource;
 	} else {
-		let cpNodes = newCpAntipodes.slice();
+		const cpNodes = newCpAntipodes.slice();
 		cpNodes.push(newCpSource);
 
 		// Order points according to their angle with the x-axis
 		cpNodes.sort(byAngle(circle));
 
 		for (let i=0; i<cpNodes.length; i++) {
-			let iNext = (i+1 === cpNodes.length) ? 0 : i+1;
-			let iPrev = (i === 0) ? cpNodes.length-1 : i-1;
+			const iNext = (i+1 === cpNodes.length) ? 0 : i+1;
+			const iPrev = (i === 0) ? cpNodes.length-1 : i-1;
 
-			let cpNodeCurr = cpNodes[i];
-			let cpNodeNext = cpNodes[iNext];
-			let cpNodePrev = cpNodes[iPrev];
+			const cpNodeCurr = cpNodes[i];
+			const cpNodeNext = cpNodes[iNext];
+			const cpNodePrev = cpNodes[iPrev];
 
 			cpNodeCurr.nextOnCircle = cpNodeNext;
 			cpNodeCurr.prevOnCircle = cpNodePrev;
@@ -157,11 +157,11 @@ function add2Prong(
 	if (holeClosing) { 
 		// TODO - important - take care of case where there are more than 1 antipode
 		// Duplicate ContactPoints
-		let cpB2: ContactPoint = { pointOnShape: posAntipodes[0].pos, circle, order: cpAntipodes[0].order, order2: +1 };
-		let newCpB2Node = CpNode.insert(true, false, cpTreeAntipodes[0], cpB2, newCpAntipodes[0]);
+		const cpB2: ContactPoint = { pointOnShape: posAntipodes[0].pos, circle, order: cpAntipodes[0].order, order2: +1 };
+		const newCpB2Node = CpNode.insert(true, false, cpTreeAntipodes[0], cpB2, newCpAntipodes[0]);
 		
-		let cpB1: ContactPoint = { pointOnShape: posSource, circle, order: cpSource.order, order2: -1 };
-		let newCpB1Node = CpNode.insert(true, false, cpTreeSource, cpB1, newCpSource.prev);
+		const cpB1: ContactPoint = { pointOnShape: posSource, circle, order: cpSource.order, order2: -1 };
+		const newCpB1Node = CpNode.insert(true, false, cpTreeSource, cpB1, newCpSource.prev);
 		
 		// Connect graph
 		newCpB1Node.prevOnCircle = newCpB2Node;
@@ -185,7 +185,7 @@ function add2Prong(
 			elems = _debug_.generated.elems['twoProng_regular'];
 		}
 
-		let elem = elems[elems.length-1];
+		const elem = elems[elems.length-1];
 
 		if (!newCpSource) { console.log('asas')}
 		elem.cpNode = newCpSource;
@@ -230,10 +230,10 @@ function getSize(x: number, y: number) {
 
 /** @hidden */
 function byAngle(circle: Circle) {
-	let c = circle.center;
-	let r = circle.radius;
+	const c = circle.center;
+	const r = circle.radius;
 
-	let exp = exponent(r);
+	const exp = exponent(r);
 
 	return function(_a: CpNode, _b: CpNode) {
 		let a = _a.cp.pointOnShape.p;
@@ -244,14 +244,14 @@ function byAngle(circle: Circle) {
 		b = [b[0]-c[0], b[1]-c[1]];
 
 		// Scale
-		let ax = scale(a[0], exp);
-		let ay = scale(a[1], exp);
-		let bx = scale(b[0], exp);
-		let by = scale(b[1], exp);
+		const ax = scale(a[0], exp);
+		const ay = scale(a[1], exp);
+		const bx = scale(b[0], exp);
+		const by = scale(b[1], exp);
 
 		// Get 'size'
-		let sa = getSize(ax, ay);
-		let sb = getSize(bx, by);
+		const sa = getSize(ax, ay);
+		const sb = getSize(bx, by);
 
 		return sb - sa;
 	}

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

@@ -24,7 +24,7 @@ function add3Prong(
 			δ3s: CpNode[][]
 		}) {
 	
-	let { circle, ps: poss, δ3s } = threeProng;
+	const { circle, ps: poss, δ3s } = threeProng;
 
 	// Keep for possible future debugging.	
 	/*

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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