flo-mat 2.0.1 → 2.0.3

package/src/compare-curvatures-at-interface.ts

@@ -24,14 +24,14 @@ function compareCurvaturesAtInterface(
         psO: number[][]) {
 
     // Get x' and y' for incoming curve evaluated at 0
-    let [dxI, dyI] = tangentAt0(psI); // max bitlength increase / max shift === 3
+    const [dxI, dyI] = tangentAt0(psI); // max bitlength increase / max shift === 3
     // Get x'' and y'' for incoming curve evaluated at 0
-    let [ddxI, ddyI] = evaluate2ndDerivativeAt0(psI); // max bitlength increase / max shift === 5
+    const [ddxI, ddyI] = evaluate2ndDerivativeAt0(psI); // max bitlength increase / max shift === 5
 
     // Get x' and y' for outgoing curve evaluated at 0
-    let [dxO, dyO] = tangentAt0(psO); // max bitlength increase / max shift === 3
+    const [dxO, dyO] = tangentAt0(psO); // max bitlength increase / max shift === 3
     // Get x'' and y'' for outgoing curve evaluated at 0
-    let [ddxO, ddyO] = evaluate2ndDerivativeAt0(psO); // max bitlength increase / max shift === 5
+    const [ddxO, ddyO] = evaluate2ndDerivativeAt0(psO); // max bitlength increase / max shift === 5
 
     //console.log('κI: ', κ(psI, 0));
     //console.log('κO: ', κ(psO, 0));
@@ -59,40 +59,40 @@ function compareCurvaturesAtInterface(
     //let d = (dxI*dxI  + dyI*dyI )**3;
 
     // We need to resort to exact floating point arithmetic at this point
-    let a = eDiff(
+    const a = eDiff(
         twoProduct(dxI, ddyI), 
         twoProduct(dyI, ddxI)
     );
-    let c = eDiff(
+    const c = eDiff(
         twoProduct(dxO, ddyO),
         twoProduct(dyO, ddxO)
     );
 
-    let signA = eSign(a);
-    let signC = eSign(c);
+    const signA = eSign(a);
+    const signC = eSign(c);
     if (signA !== signC) {
         //console.log('branch 3');
         return signA - signC;
     }
 
-    let b = fastExpansionSum(
+    const b = fastExpansionSum(
         twoProduct(dxO, dxO),
         twoProduct(dyO, dyO)
     );
-    let d = fastExpansionSum(
+    const d = fastExpansionSum(
         twoProduct(dxI, dxI),
         twoProduct(dyI, dyI)
     );
 
-    let b2 = expansionProduct(b, b);
-    let b3 = expansionProduct(b2, b);
-    let d2 = expansionProduct(d, d);
-    let d3 = expansionProduct(d2, d);
+    const b2 = expansionProduct(b, b);
+    const b3 = expansionProduct(b2, b);
+    const d2 = expansionProduct(d, d);
+    const d3 = expansionProduct(d2, d);
 
     if (signA !== 0 || signC !== 0) {
         //console.log('branch 4');
-        let a2 = expansionProduct(a, a);
-        let c2 = expansionProduct(c, c);
+        const a2 = expansionProduct(a, a);
+        const c2 = expansionProduct(c, c);
 
         // max aggregate bitlength increase (let original bitlength === p):
         // κ -> (2 x ((p+3)+(p+5) + 1)) + (3 x ((p+3) + 1)) === 7p + 30
@@ -101,9 +101,9 @@ function compareCurvaturesAtInterface(
         // results without resorting to infinite precision) we get 51 bits.
 
         
-        let κI = expansionProduct(a2,b3);
-        let κO = expansionProduct(c2,d3);
-        let δκ = eSign(eDiff(κI, κO));
+        const κI = expansionProduct(a2,b3);
+        const κO = expansionProduct(c2,d3);
+        const δκ = eSign(eDiff(κI, κO));
 
         if (δκ !== 0) {
             //console.log('branch 5');
@@ -125,32 +125,32 @@ function compareCurvaturesAtInterface(
     // <=> i²b⁵ > j²d⁵
 
     // Get x′′′ and y′′′ for incoming curve evaluated at 1
-    let [dddxI, dddyI] = toPowerBasis_3rdDerivative(psI); // max bitlength increase === max shift === 6
-    let [dddxO, dddyO] = toPowerBasis_3rdDerivative(psO); // max bitlength increase === max shift === 6
+    const [dddxI, dddyI] = toPowerBasis_3rdDerivative(psI); // max bitlength increase === max shift === 6
+    const [dddxO, dddyO] = toPowerBasis_3rdDerivative(psO); // max bitlength increase === max shift === 6
 
-    let e = eDiff(
+    const e = eDiff(
         twoProduct(dxI, dddyI),
         twoProduct(dyI, dddxI)
     );
 
-    let f = fastExpansionSum(
+    const f = fastExpansionSum(
         twoProduct(dxI, ddxI),
         twoProduct(dyI, ddyI)
     );
 
-    let g = eDiff(
+    const g = eDiff(
         twoProduct(dxO, dddyO),
         twoProduct(dyO, dddxO)
     );
 
-    let h = fastExpansionSum(
+    const h = fastExpansionSum(
         twoProduct(dxO, ddxO),
         twoProduct(dyO, ddyO)
     );
 
     // (de - 3af)²b⁵ > (bg - 3ch)²d⁵
     // i²b⁵ > j²d⁵
-    let i = eDiff(
+    const i = eDiff(
         expansionProduct(d, e),
         scaleExpansion(
             expansionProduct(a, f),
@@ -158,7 +158,7 @@ function compareCurvaturesAtInterface(
         )
     );
 
-    let j = eDiff(
+    const j = eDiff(
         expansionProduct(b, g),
         scaleExpansion(
             expansionProduct(c, h),
@@ -166,8 +166,8 @@ function compareCurvaturesAtInterface(
         )
     );
 
-    let signI = eSign(i);
-    let signJ = eSign(j);
+    const signI = eSign(i);
+    const signJ = eSign(j);
     if (signA !== signC) {
         return signI - signJ;
     }
@@ -177,15 +177,15 @@ function compareCurvaturesAtInterface(
         return 0;
     }
 
-    let i2 = expansionProduct(i,i);
-    let b5 = expansionProduct(b2,b3);
-    let j2 = expansionProduct(j,j);
-    let d5 = expansionProduct(d2,d3);
+    const i2 = expansionProduct(i,i);
+    const b5 = expansionProduct(b2,b3);
+    const j2 = expansionProduct(j,j);
+    const d5 = expansionProduct(d2,d3);
 
-    let dκI = expansionProduct(i2,b5);
-    let dκO = expansionProduct(j2,d5);
+    const dκI = expansionProduct(i2,b5);
+    const dκO = expansionProduct(j2,d5);
 
-    let sgn = eSign(eDiff(dκI, dκO));
+    const sgn = eSign(eDiff(dκI, dκO));
 
     return signI > 0 ? sgn : -sgn;
 

package/src/cp-node/clone.ts

@@ -21,18 +21,18 @@ function clone(cpNode: CpNode): CpNode {
     // Don't change this function to be recursive, the call stack may 
     // overflow if there are too many CpNodes.
 
-    let nodeMap: Map<CpNode, CpNode> = new Map();
+    const nodeMap: Map<CpNode, CpNode> = new Map();
 
-    let newCpNode = new CpNode(cpNode.cp, cpNode.isHoleClosing, cpNode.isIntersection);
+    const newCpNode = new CpNode(cpNode.cp, cpNode.isHoleClosing, cpNode.isIntersection);
 
     nodeMap.set(cpNode, newCpNode);
-    let cpStack = [{ cpNode, newCpNode }];
+    const cpStack = [{ cpNode, newCpNode }];
 
     while (cpStack.length) {
-        let { cpNode, newCpNode } = cpStack.pop();
+        const { cpNode, newCpNode } = cpStack.pop();
 
-        for (let edge of EDGES) {
-            let node = cpNode[edge];
+        for (const edge of EDGES) {
+            const node = cpNode[edge];
             let newNode = nodeMap.get(node);
             if (!newNode) {	
                 newNode = new CpNode(node.cp, node.isHoleClosing, node.isIntersection);

package/src/cp-node/remove.ts

@@ -8,13 +8,13 @@ import { CpNode } from "../cp-node.js";
  * @param cpNode The [[CpNode]] to remove.
  */
 function removeCpNode(cpNode: CpNode, cpTree?: LlRbTree<CpNode>): void {
-    let prev = cpNode.prev;
-    let next = cpNode.next;
+    const prev = cpNode.prev;
+    const next = cpNode.next;
     prev.next = next;
     next.prev = prev;
 
-    let nextOpposite = next.prevOnCircle;
-    let prevOpposite = prev.nextOnCircle;
+    const nextOpposite = next.prevOnCircle;
+    const prevOpposite = prev.nextOnCircle;
     nextOpposite.next = prevOpposite;
     prevOpposite.prev = nextOpposite;
     

package/src/cp-node.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';
@@ -115,9 +115,9 @@ class CpNode {
 	 * edges.
 	 */
 	getChildren() {
-		let children: CpNode[] = [];
+		const children: CpNode[] = [];
 
-		let cp = this.next;
+		const cp = this.next;
 		let cp_ = cp;
 		do {
 			children.push(cp_); 
@@ -141,8 +141,8 @@ class CpNode {
 	get vertexChildren() {
 		if (this.isTerminating()) { return []; }
 
-		let cp: CpNode = this;
-		let children: CpNode[] = [];
+		const cp: CpNode = this;
+		const children: CpNode[] = [];
 
 		let cp_ = cp;
 		while (cp_ !== cp.prevOnCircle) {
@@ -159,8 +159,8 @@ class CpNode {
 	 * starting from the current one and going anti-clockwise around the shape.
 	 */
 	public getAllOnLoop() {
-		let cpStart: CpNode = this;
-		let cps: CpNode[] = [cpStart];
+		const cpStart: CpNode = this;
+		const cps: CpNode[] = [cpStart];
 		let cp: CpNode = this.next;
 
 		while (cp !== cpStart) {
@@ -193,7 +193,7 @@ class CpNode {
 			cp: ContactPoint, 
 			prev_: CpNode) {
 	
-		let cpNode = new CpNode(cp, isHoleClosing, isIntersection);
+		const cpNode = new CpNode(cp, isHoleClosing, isIntersection);
 		if (typeof _debug_ !== 'undefined') {
 			_debug_.generated.elems.cpNode.push({
 				generated: _debug_.generated,
@@ -231,10 +231,10 @@ class CpNode {
 	 * [[CpNode]].
 	 */
 	public getCpNodesOnCircle(exclThis = false) {
-		let startCp = this as CpNode;
+		const startCp = this as CpNode;
 		let cp = startCp;
 		
-		let cps: CpNode[] = [];
+		const cps: CpNode[] = [];
 		do {
 			if (exclThis) {
 				exclThis = false;
@@ -255,7 +255,7 @@ class CpNode {
 	 * @param cpNode2 Another [[CpNode]]
 	 */
 	static isOnSameCircle(cpNode1: CpNode, cpNode2: CpNode) {
-		let cpNodes = cpNode1.getCpNodesOnCircle(true);
+		const cpNodes = cpNode1.getCpNodesOnCircle(true);
 
 		return cpNodes.indexOf(cpNode2) >= 0;
 	}
@@ -284,8 +284,8 @@ class CpNode {
 	 * (except this.prevOnCircle) is terminating.
 	 */
 	public isFullyTerminating() {
-		let otherOnCircle = this.prevOnCircle.getCpNodesOnCircle(true);
-		let isFullyTerminating = otherOnCircle.every(cpNode => cpNode.isTerminating());
+		const otherOnCircle = this.prevOnCircle.getCpNodesOnCircle(true);
+		const isFullyTerminating = otherOnCircle.every(cpNode => cpNode.isTerminating());
 
 		return isFullyTerminating;
 	}
@@ -296,7 +296,7 @@ class CpNode {
 	 * .nextOnCircle) that exits the circle.
 	 */
 	public getFirstExit() {
-		let startNode = this as CpNode;
+		const startNode = this as CpNode;
 		let cpNode = startNode;
 
 		while (cpNode.next === cpNode.prevOnCircle) {
@@ -333,16 +333,16 @@ class CpNode {
 	 * preserve symmetry - see [[isTerminating]] for more details.
 	 */
 	public isOneProng() {
-		let cp1 = this;
+		const cp1 = this;
 
 		if (cp1.cp.circle.radius === 0) {
 			return true;
 		}
 
-		let cp2 = cp1.nextOnCircle;
+		const cp2 = cp1.nextOnCircle;
 
-		let p1 = cp1.cp.pointOnShape.p;
-		let p2 = cp2.cp.pointOnShape.p;
+		const p1 = cp1.cp.pointOnShape.p;
+		const p2 = cp2.cp.pointOnShape.p;
 
 		return (p1[0] === p2[0] && p1[1] === p2[1]);
 	}
@@ -357,7 +357,7 @@ class CpNode {
 	 * [[getRealProngCount]] instead which will return 1 in these cases.
 	 */
 	public getProngCount() {
-		let startCp = this as CpNode;
+		const startCp = this as CpNode;
 		let cp = startCp;
 
 		let i = 0;

package/src/curve.ts

@@ -66,37 +66,37 @@ const DEGREE_LIMIT = DEGREES[4];
 function getCorner(psI: number[][], psO: number[][]): Corner {
 	// getInterfaceCcw must return a number !== 0 if psI and psO are not the
 	// same as seen as a curve extension with t ∈ [-∞,+∞]
-	let ccw = getInterfaceCcw(psI, psO);
-	let isSharp = ccw < 0;
-	let isDull  = ccw > 0;
+	const ccw = getInterfaceCcw(psI, psO);
+	const isSharp = ccw < 0;
+	const isDull  = ccw > 0;
 
 	// Find (non-normalized) tangent of curve.ps at t === 1
-	let p0E = psI[psI.length-2];
-	let p1E = psI[psI.length-1];
-	let xE = p1E[0] - p0E[0];
-	let yE = p1E[1] - p0E[1];
-	let tangentAtEnd = [xE,yE];
+	const p0E = psI[psI.length-2];
+	const p1E = psI[psI.length-1];
+	const xE = p1E[0] - p0E[0];
+	const yE = p1E[1] - p0E[1];
+	const tangentAtEnd = [xE,yE];
 
 	// Find (non-normalized) tangent of curve.next.ps at t === 0
-	let p0S = psO[0];
-	let p1S = psO[1];
-	let xS = p1S[0] - p0S[0];
-	let yS = p1S[1] - p0S[1];
-	let tangentAtStart = [xS,yS];
+	const p0S = psO[0];
+	const p1S = psO[1];
+	const xS = p1S[0] - p0S[0];
+	const yS = p1S[1] - p0S[1];
+	const tangentAtStart = [xS,yS];
 
 	// These use square root and are thus not exact
-	let tangents_ = [
+	const tangents_ = [
 		toUnitVector(tangentAtEnd), 
 		toUnitVector(tangentAtStart), 
 	];
 
 	// The cross calculated below should be exact due to beziers having been
 	// normalized!
-	let crossTangents = cross(tangents_[0], tangents_[1]);
+	const crossTangents = cross(tangents_[0], tangents_[1]);
 
 	let isQuiteSharp: boolean; 
 	let isQuiteDull: boolean; 
-	let dotTangents = dot(tangentAtEnd, tangentAtStart);
+	const dotTangents = dot(tangentAtEnd, tangentAtStart);
 	if (dotTangents > 0) {
 		// Curves go in same direction
 		isQuiteSharp = crossTangents < -DEGREE_LIMIT;
@@ -122,9 +122,9 @@ function getCorner(psI: number[][], psO: number[][]): Corner {
  * Returns information about the corner created at the end of this curve 
  * (at t === 1) and the start of the next curve (at t === 0).
  */
-let getCornerAtEnd = memoize(function(curve: Curve) {
-	let psE = curve.ps;
-	let psS = curve.next.ps;
+const getCornerAtEnd = memoize(function(curve: Curve) {
+	const psE = curve.ps;
+	const psS = curve.next.ps;
 
 	return getCorner(psE, psS);
 });

package/src/debug/functions/draw-elem/bounding-hull.ts

@@ -5,9 +5,9 @@ import { drawFs } from 'flo-draw';
 function boundingHull(
         g: SVGGElement,
         hull: number[][], 
-        style: string = 'thin5 black nofill') {
+        style = 'thin5 black nofill') {
             
-	let $polygon = drawFs.polygon(g, hull, style);
+	const $polygon = drawFs.polygon(g, hull, style);
 
 	return $polygon;
 }

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

@@ -6,15 +6,15 @@ import { getCurveToNext } from '../../../get-curve-to-next.js';
 /** @hidden */
 function drawBranch(g: SVGGElement, branch: CpNode[], delay?: number) {
 
-    let classes = 'thin5 purple nofill';
+    const classes = 'thin5 purple nofill';
 
-    let $svgs: SVGElement[] = [];
+    const $svgs: SVGElement[] = [];
     let i = 0;
 
-    for (let cpNode of branch) {
+    for (const cpNode of branch) {
         if (cpNode.isTerminating()) { continue; }
         //let bezier = cpNode.matCurveToNextVertex;
-        let bezier = getCurveToNext(cpNode);
+        const bezier = getCurveToNext(cpNode);
         if (!bezier) { continue; }
         i++;
         $svgs.push( ...drawFs.bezier(g, bezier, classes, delay));

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

@@ -3,10 +3,10 @@ import { Circle } from '../../../circle.js';
 
 /** @hidden */
 function culls(g: SVGGElement, culls: Circle[]) {	
-    let $elems: SVGElement[] = [];
+    const $elems: SVGElement[] = [];
 
-    for (let circle of culls) {
-        let p = circle.center;
+    for (const circle of culls) {
+        const p = circle.center;
 
         $elems.push(drawCircle(g, p, 0.4, 'cyan thin5 nofill'));
     }
@@ -24,7 +24,7 @@ function drawCircle(
 
     const XMLNS = 'http://www.w3.org/2000/svg';            
 
-    let $circle = document.createElementNS(XMLNS, 'circle');
+    const $circle = document.createElementNS(XMLNS, 'circle');
     $circle.setAttributeNS(null, "cx", center[0].toString());
     $circle.setAttributeNS(null, "cy", center[1].toString());
     $circle.setAttributeNS(null, "r", radiusPercent.toString() + '%');

package/src/debug/functions/draw-elem/draw-circle-percent.ts

@@ -6,9 +6,9 @@ function drawCirclePercent(
         radiusPercent: number, 
         classes: string) {
 
-    const XMLNS = 'http://www.w3.org/2000/svg';            
+    const XMLNS = 'http://www.w3.org/2000/svg';
 
-    let $circle = document.createElementNS(XMLNS, 'circle');
+    const $circle = document.createElementNS(XMLNS, 'circle');
     $circle.setAttributeNS(null, "cx", center[0].toString());
     $circle.setAttributeNS(null, "cy", center[1].toString());
     $circle.setAttributeNS(null, "r", radiusPercent.toString() + '%');

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

@@ -30,7 +30,7 @@ function notImplementedYet<T extends IDebugElems[keyof IDebugElems]> (g: SVGElem
 
 
 /** @hidden */
-let drawElemFunctions: TDrawElemFunctions = {
+const drawElemFunctions: TDrawElemFunctions = {
 	oneProng: drawOneProng,
 	oneProngAtDullCorner,
 	

package/src/debug/functions/draw-elem/dull-corner.ts

@@ -6,9 +6,9 @@ import { Curve } from '../../../curve.js';
 function dullCorner(g: SVGGElement, curve: Curve) {
 	const scaleFactor = 1;
 		
-	let ps = curve.ps; 
-	let p = curve.ps[ps.length-1];
-	let $pos = drawFs.dot(g, p, 0.5*scaleFactor, 'orange');
+	const ps = curve.ps; 
+	const p = curve.ps[ps.length-1];
+	const $pos = drawFs.dot(g, p, 0.5*scaleFactor, 'orange');
 	
 	return $pos;
 }

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

@@ -4,11 +4,11 @@ import { drawCirclePercent } from './draw-circle-percent.js';
 
 /** @hidden */
 function leaves(g: SVGGElement, leaves: CpNode[]) {	
-    let $elems: SVGElement[] = [];
+    const $elems: SVGElement[] = [];
 
-    for (let cpNode of leaves) {
-        let cp = cpNode.cp;
-        let p = cp.circle.center;
+    for (const cpNode of leaves) {
+        const cp = cpNode.cp;
+        const p = cp.circle.center;
 
         $elems.push(drawCirclePercent(g, p, 0.5, 'pinker thin5 nofill'));
     }

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

@@ -4,10 +4,10 @@ import { drawFs } from "flo-draw";
 /** @hidden */
 function looseBoundingBox(g: SVGGElement, box: number[][]) {
 
-	let [[x0, y0],[x1, y1]] = box;
+	const [[x0, y0],[x1, y1]] = box;
 	box = [[x0, y0],[x1, y0],[x1,y1],[x0,y1]];
 
-	let $box = drawFs.polygon(g, box, 'thin5 brown nofill');
+	const $box = drawFs.polygon(g, box, 'thin5 brown nofill');
 	
 	return $box;
 }

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

@@ -7,22 +7,22 @@ import { getCurveToNext } from '../../../get-curve-to-next.js';
 /** @hidden */
 function drawMat(type: 'mat' | 'sat') {
 
-    let classes: string = type === 'mat'
+    const classes: string = type === 'mat'
         ? 'thin5 purple nofill'
         : 'thin10 red nofill';
 
     return (g: SVGGElement, mat: Mat) => {
-        let cpNode = mat.cpNode;
+        const cpNode = mat.cpNode;
         
         if (!cpNode) { return undefined; }
 
-        let $svgs: SVGElement[] = [];
+        const $svgs: SVGElement[] = [];
         let i = 0;
 
         traverseEdges(cpNode, cpNode => {
             if (cpNode.isTerminating()) { return; }
     
-            let bezier = getCurveToNext(cpNode);
+            const bezier = getCurveToNext(cpNode);
 
             if (!bezier) { return; }
 

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

@@ -4,9 +4,9 @@ import { CpNode } from '../../../cp-node.js';
 
 /** @hidden */
 function maxVertex(g: SVGGElement, cpNode: CpNode) {	
-    let circle = cpNode.cp.circle;
+    const circle = cpNode.cp.circle;
 
-    let $elems = drawFs.circle(g, circle, 'brown thin10 nofill');
+    const $elems = drawFs.circle(g, circle, 'brown thin10 nofill');
         
 	return $elems;
 }

package/src/debug/functions/draw-elem/min-y.ts

@@ -5,14 +5,14 @@ import { IPointOnShape } from '../../../point-on-shape.js';
 
 /** @hidden */
 function minY(g: SVGGElement, pos: IPointOnShape) {	
-    let p = evalDeCasteljau(pos.curve.ps, pos.t) ;
+    const p = evalDeCasteljau(pos.curve.ps, pos.t) ;
 
-    let ps = toCubic(pos.curve.ps);
+    const ps = toCubic(pos.curve.ps);
     //console.log('x: ', getX(ps));
     //console.log('y: ', getY(ps));
     //console.log('t: ', pos.t);
 
-    let $elems = drawFs.crossHair( 
+    const $elems = drawFs.crossHair( 
             g, p, 'red thin10 nofill'
 	);  
 	

package/src/debug/functions/draw-elem/one-prong-at-dull-corner.ts

@@ -5,11 +5,11 @@ import { getOsculatingCircle, IPointOnShape } from '../../../point-on-shape.js';
 /** @hidden */
 function oneProngAtDullCorner(g: SVGGElement, pos: IPointOnShape) {
     //let oCircle = PointOnShape.getOsculatingCircle(Number.POSITIVE_INFINITY, pos);
-    let oCircle = getOsculatingCircle(Number.POSITIVE_INFINITY, pos);
+    const oCircle = getOsculatingCircle(Number.POSITIVE_INFINITY, pos);
 
-    let $center = drawFs.dot(g, pos.p, 0.1, 'orange');
-    let $circle = drawFs.dot(g, oCircle.center, 0.25, 'orange');
-    let $pos    = drawFs.circle(g, oCircle, 'orange thin10 nofill');
+    const $center = drawFs.dot(g, pos.p, 0.1, 'orange');
+    const $circle = drawFs.dot(g, oCircle.center, 0.25, 'orange');
+    const $pos    = drawFs.circle(g, oCircle, 'orange thin10 nofill');
         
 	return [...$center, ...$circle, ...$pos];
 }

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

@@ -9,15 +9,15 @@ const scaleFactor = 0.5;
 
 /** @hidden */
 function drawOneProng(g: SVGGElement, pos: IPointOnShape, classes: string, delay = 0) {
-    let circle = scaleCircle(
+    const circle = scaleCircle(
         //PointOnShape.getOsculatingCircle(Number.POSITIVE_INFINITY, pos),
         getOsculatingCircle(Number.POSITIVE_INFINITY, pos),
         1
     );
 
-    let $center = drawFs.dot(g, pos.p, 0.1*scaleFactor, 'gray', delay);
-    let $circle = drawFs.dot(g, circle.center, 0.25*scaleFactor, 'gray', delay);
-    let $pos    = drawFs.circle(g, circle, 'gray thin10 nofill', delay);
+    const $center = drawFs.dot(g, pos.p, 0.1*scaleFactor, 'gray', delay);
+    const $circle = drawFs.dot(g, circle.center, 0.25*scaleFactor, 'gray', delay);
+    const $pos    = drawFs.circle(g, circle, 'gray thin10 nofill', delay);
         
 	return [...$center, ...$circle, ...$pos];
 }

package/src/debug/functions/draw-elem/sharp-corner.ts

@@ -6,8 +6,8 @@ import { Curve } from '../../../curve.js';
 function sharpCorner(g: SVGGElement, curve: Curve) {
 	const scaleFactor = 1;
 		
-	let p = curve.ps[curve.ps.length-1];
-	let $pos = drawFs.dot(g, p, 0.6*scaleFactor, 'green');
+	const p = curve.ps[curve.ps.length-1];
+	const $pos = drawFs.dot(g, p, 0.6*scaleFactor, 'green');
 		
 	return $pos;
 }

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

@@ -9,17 +9,17 @@ const scaleFactor = 0.3;
 
 /** @hidden */
 function threeProng(g: SVGGElement, threeProng: ThreeProngForDebugging) {
-	let circle = scaleCircle(
+	const circle = scaleCircle(
 		threeProng.circle,
 		1
 	);
-	let poss = threeProng.poss;
+	const poss = threeProng.poss;
 		
-	let $cp1 = drawFs.dot(g, poss[0].p, 0.1*1*scaleFactor, 'blue');
-	let $cp2 = drawFs.dot(g, poss[1].p, 0.1*2*scaleFactor, 'blue');
-	let $cp3 = drawFs.dot(g, poss[2].p, 0.1*3*scaleFactor, 'blue');
-	let $center = drawFs.dot(g, circle.center, 0.3*scaleFactor, 'blue');
-	let $circle = drawFs.circle(g, circle, 'blue thin2 nofill');
+	const $cp1 = drawFs.dot(g, poss[0].p, 0.1*1*scaleFactor, 'blue');
+	const $cp2 = drawFs.dot(g, poss[1].p, 0.1*2*scaleFactor, 'blue');
+	const $cp3 = drawFs.dot(g, poss[2].p, 0.1*3*scaleFactor, 'blue');
+	const $center = drawFs.dot(g, circle.center, 0.3*scaleFactor, 'blue');
+	const $circle = drawFs.circle(g, circle, 'blue thin2 nofill');
 		
 	return [...$center, ...$cp1, ...$cp2, ...$cp3, ...$circle];
 }