flo-mat 2.0.2 → 2.0.3

package/node/mat/find-mat/find-and-add-2-prongs.d.ts

@@ -1,16 +1,16 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from '../../loop.js';
-import { CpNode } from '../../cp-node.js';
-import { IPointOnShape } from '../../point-on-shape.js';
-/**
- * @hidden
- * Find and add two-prongs.
- * @param loops
- * @param cpGraphs
- * @param k
- * @param for2Prongs
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-declare function findAndAdd2Prongs(loops: Loop[], cpGraphs: Map<Loop, LlRbTree<CpNode>>, k: number, for2Prongs: IPointOnShape[], extreme: number): CpNode;
-export { findAndAdd2Prongs };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Loop } from '../../loop.js';
+import { CpNode } from '../../cp-node.js';
+import { IPointOnShape } from '../../point-on-shape.js';
+/**
+ * @hidden
+ * Find and add two-prongs.
+ * @param loops
+ * @param cpGraphs
+ * @param k
+ * @param for2Prongs
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+declare function findAndAdd2Prongs(loops: Loop[], cpGraphs: Map<Loop, LlRbTree<CpNode>>, k: number, for2Prongs: IPointOnShape[], extreme: number): CpNode;
+export { findAndAdd2Prongs };

package/node/mat/find-mat/find-and-add-2-prongs.js

@@ -1,74 +1,74 @@
-import { getShapeBounds } from '../../svg/get-shape-bounds.js';
-import { find2Prong } from './find-2-prong/find-2-prong.js';
-import { add2Prong } from './add-2-prong.js';
-/**
- * @hidden
- * Find and add two-prongs.
- * @param loops
- * @param cpGraphs
- * @param k
- * @param for2Prongs
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-function findAndAdd2Prongs(loops, cpGraphs, k, for2Prongs, extreme) {
-    const len = for2Prongs.length;
-    const index = indexLinear(len);
-    //const index = indexInterlaced(len); // Keep for possible future use.
-    let cpNode_;
-    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++) {
-        const pos = for2Prongs[index[i]];
-        const twoProngInfo = find2Prong(loops, extreme, squaredDiagonalLength, cpGraphs, pos, false, k);
-        if (twoProngInfo) {
-            const { circle, zs } = twoProngInfo;
-            const cpNode = add2Prong(cpGraphs, circle, pos, zs, false, extreme);
-            cpNode_ = cpNode_ || cpNode;
-        }
-        if (typeof _debug_ !== 'undefined') {
-            if (i + 1 === _debug_.directives.stopAfterTwoProngsNum) {
-                return undefined;
-            }
-        }
-    }
-    return cpNode_;
-}
-/**
- * @hidden
- * Simple linear array indexing.
- * @param n
- */
-function indexLinear(n) {
-    const arr = [];
-    for (let i = 0; i < n; i++) {
-        arr.push(i);
-    }
-    return arr;
-}
-/**
- * @hidden
- * Creates a kind of interlaced index vector.
- * @param n
-*/
-function indexInterlaced(n) {
-    const source = {};
-    const arr = [];
-    // l is the lowest power of 2 so that 2^l > n
-    let l = Math.pow(2, Math.floor(Math.log2(n)));
-    while (l >= 1) {
-        let k = 0;
-        while (k < n) {
-            if (!source[k]) {
-                arr.push(k);
-                source[k] = true;
-            }
-            k = k + l;
-        }
-        l = l / 2;
-    }
-    return arr;
-}
-export { findAndAdd2Prongs };
+import { getShapeBounds } from '../../svg/get-shape-bounds.js';
+import { find2Prong } from './find-2-prong/find-2-prong.js';
+import { add2Prong } from './add-2-prong.js';
+/**
+ * @hidden
+ * Find and add two-prongs.
+ * @param loops
+ * @param cpGraphs
+ * @param k
+ * @param for2Prongs
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+function findAndAdd2Prongs(loops, cpGraphs, k, for2Prongs, extreme) {
+    const len = for2Prongs.length;
+    const index = indexLinear(len);
+    //const index = indexInterlaced(len); // Keep for possible future use.
+    let cpNode_;
+    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++) {
+        const pos = for2Prongs[index[i]];
+        const twoProngInfo = find2Prong(loops, extreme, squaredDiagonalLength, cpGraphs, pos, false, k);
+        if (twoProngInfo) {
+            const { circle, zs } = twoProngInfo;
+            const cpNode = add2Prong(cpGraphs, circle, pos, zs, false, extreme);
+            cpNode_ = cpNode_ || cpNode;
+        }
+        if (typeof _debug_ !== 'undefined') {
+            if (i + 1 === _debug_.directives.stopAfterTwoProngsNum) {
+                return undefined;
+            }
+        }
+    }
+    return cpNode_;
+}
+/**
+ * @hidden
+ * Simple linear array indexing.
+ * @param n
+ */
+function indexLinear(n) {
+    const arr = [];
+    for (let i = 0; i < n; i++) {
+        arr.push(i);
+    }
+    return arr;
+}
+/**
+ * @hidden
+ * Creates a kind of interlaced index vector.
+ * @param n
+*/
+function indexInterlaced(n) {
+    const source = {};
+    const arr = [];
+    // l is the lowest power of 2 so that 2^l > n
+    let l = Math.pow(2, Math.floor(Math.log2(n)));
+    while (l >= 1) {
+        let k = 0;
+        while (k < n) {
+            if (!source[k]) {
+                arr.push(k);
+                source[k] = true;
+            }
+            k = k + l;
+        }
+        l = l / 2;
+    }
+    return arr;
+}
+export { findAndAdd2Prongs };
 //# sourceMappingURL=find-and-add-2-prongs.js.map

package/node/mat/find-mat/find-and-add-3-prongs.d.ts

@@ -1,13 +1,13 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from '../../cp-node.js';
-import { Loop } from '../../loop.js';
-/**
- * @hidden
- * Finds and adds all 3-prongs.
- * @param cpGraphs
- * @param cpStart The CpNode to start traversing from.
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-declare function findAndAddAll3Prongs(cpGraphs: Map<Loop, LlRbTree<CpNode>>, cpStart: CpNode, extreme: number): void;
-export { findAndAddAll3Prongs };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { CpNode } from '../../cp-node.js';
+import { Loop } from '../../loop.js';
+/**
+ * @hidden
+ * Finds and adds all 3-prongs.
+ * @param cpGraphs
+ * @param cpStart The CpNode to start traversing from.
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+declare function findAndAddAll3Prongs(cpGraphs: Map<Loop, LlRbTree<CpNode>>, cpStart: CpNode, extreme: number): void;
+export { findAndAddAll3Prongs };

package/node/mat/find-mat/find-and-add-3-prongs.js

@@ -1,147 +1,147 @@
-import { calcPosOrder, isPosSharpCorner } from '../../point-on-shape.js';
-import { find3Prong } from './find-3-prong/find-3-prong.js';
-import { add3Prong } from '../find-mat/add-3-prong.js';
-/**
- * @hidden
- * Finds and adds all 3-prongs.
- * @param cpGraphs
- * @param cpStart The CpNode to start traversing from.
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-function findAndAddAll3Prongs(cpGraphs, cpStart, extreme) {
-    // Don't change this function to be recursive, the call stack may overflow 
-    // if there are too many two-prongs.
-    const visitedEdges = new Map();
-    const edgesToCheck = [{ fromCpNode: undefined, cpStart }];
-    while (edgesToCheck.length) {
-        const { fromCpNode, cpStart } = edgesToCheck.shift();
-        markEdgeAsTaken(visitedEdges, fromCpNode, cpStart);
-        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)) {
-                continue; // We already visited this edge
-            }
-            edgesToCheck.push({ fromCpNode: cpStart, cpStart: cpNode.next });
-        }
-    }
-}
-/**
- * @hidden
- * Marks the given edge as already taken.
- */
-function markEdgeAsTaken(visitedEdges, cp1, cp2) {
-    if (cp1 === undefined) {
-        return;
-    }
-    f(cp1, cp2);
-    f(cp2, cp1);
-    function f(cp1, cp2) {
-        let visited = visitedEdges.get(cp1);
-        if (!visited) {
-            visited = new Set();
-            visitedEdges.set(cp1, visited);
-        }
-        visited.add(cp2);
-    }
-}
-/** @hidden */
-function hasEdgeBeenTaken(visitedEdges, cp1, cp2) {
-    let cps;
-    cps = visitedEdges.get(cp1);
-    const takenForward = cps && cps.has(cp2);
-    cps = visitedEdges.get(cp2);
-    const takenBackwards = cps && cps.has(cp1);
-    return takenForward || takenBackwards;
-}
-/**
- * @hidden
- * Traverses the shape from the given ContactPoint going around contact circles
- * so that only a piece of the shape is traversed and returns the visited
- * CpNodes (starting from the given CpNode).
- * @param cpStart The ContactPoint from where to start the traversal.
- */
-function traverseShape(cpStart) {
-    let cpNode = cpStart;
-    if (cpNode === cpNode.next.prevOnCircle) {
-        return [cpNode];
-    }
-    const visitedCps = [];
-    do {
-        visitedCps.push(cpNode);
-        const next = cpNode.next.prevOnCircle;
-        cpNode = cpNode === next
-            ? cpNode = cpNode.next.next // Terminal vertex
-            : cpNode = next; // Take last exit
-    } while (cpNode !== cpStart);
-    return visitedCps;
-}
-/**
- * @hidden
- * Starting from some ContactPoint, traverses the shape going around Vertices
- * and if more than two Vertices have been visited in total then recursively
- * adds 3-prongs until only one or two Vertices have been visited.
- *
- * This process further subdivides the shape.
- * @param cpGraphs
- * @param cpStart The ContactPoint from where to start the process.
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-let ii = 0;
-function findAndAdd3Prongs(cpGraphs, cpStart, extreme) {
-    let visitedCps;
-    do {
-        visitedCps = traverseShape(cpStart);
-        if (visitedCps.length > 2) {
-            findAndAdd3Prong(cpGraphs, visitedCps, extreme);
-            ii++;
-        }
-        if (typeof _debug_ !== 'undefined') {
-            if (ii === _debug_.directives.stopAfterThreeProngsNum) {
-                return undefined;
-            }
-        }
-    } while (visitedCps.length > 2);
-    return visitedCps;
-}
-/**
- * @hidden
- * Finds and add a 3-prong MAT circle to the given shape.
- * @param cpGraphs
- * @param visitedCps
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-function findAndAdd3Prong(cpGraphs, visitedCps, extreme) {
-    const δs = [];
-    for (const visitedCp of visitedCps) {
-        δs.push([visitedCp, visitedCp.next]);
-    }
-    const threeProng = find3Prong(δs, extreme);
-    const orders = [];
-    for (let i = 0; i < 3; i++) {
-        orders.push(
-        //PointOnShape.calcOrder(threeProng.circle, threeProng.ps[i])
-        calcPosOrder(threeProng.circle, threeProng.ps[i]));
-    }
-    const circle = add3Prong(cpGraphs, orders, threeProng);
-    if (typeof _debug_ !== 'undefined') {
-        add3ProngDebugInfo(circle, visitedCps);
-    }
-}
-/** @hidden */
-function add3ProngDebugInfo(circle, visitedCps) {
-    const threeProngs = _debug_.generated.elems.threeProng;
-    const len = threeProngs.length;
-    const data = threeProngs[len - 1];
-    data.visitedCps = visitedCps;
-    data.circle = circle;
-}
-export { findAndAddAll3Prongs };
+import { calcPosOrder, isPosSharpCorner } from '../../point-on-shape.js';
+import { find3Prong } from './find-3-prong/find-3-prong.js';
+import { add3Prong } from '../find-mat/add-3-prong.js';
+/**
+ * @hidden
+ * Finds and adds all 3-prongs.
+ * @param cpGraphs
+ * @param cpStart The CpNode to start traversing from.
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+function findAndAddAll3Prongs(cpGraphs, cpStart, extreme) {
+    // Don't change this function to be recursive, the call stack may overflow 
+    // if there are too many two-prongs.
+    const visitedEdges = new Map();
+    const edgesToCheck = [{ fromCpNode: undefined, cpStart }];
+    while (edgesToCheck.length) {
+        const { fromCpNode, cpStart } = edgesToCheck.shift();
+        markEdgeAsTaken(visitedEdges, fromCpNode, cpStart);
+        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)) {
+                continue; // We already visited this edge
+            }
+            edgesToCheck.push({ fromCpNode: cpStart, cpStart: cpNode.next });
+        }
+    }
+}
+/**
+ * @hidden
+ * Marks the given edge as already taken.
+ */
+function markEdgeAsTaken(visitedEdges, cp1, cp2) {
+    if (cp1 === undefined) {
+        return;
+    }
+    f(cp1, cp2);
+    f(cp2, cp1);
+    function f(cp1, cp2) {
+        let visited = visitedEdges.get(cp1);
+        if (!visited) {
+            visited = new Set();
+            visitedEdges.set(cp1, visited);
+        }
+        visited.add(cp2);
+    }
+}
+/** @hidden */
+function hasEdgeBeenTaken(visitedEdges, cp1, cp2) {
+    let cps;
+    cps = visitedEdges.get(cp1);
+    const takenForward = cps && cps.has(cp2);
+    cps = visitedEdges.get(cp2);
+    const takenBackwards = cps && cps.has(cp1);
+    return takenForward || takenBackwards;
+}
+/**
+ * @hidden
+ * Traverses the shape from the given ContactPoint going around contact circles
+ * so that only a piece of the shape is traversed and returns the visited
+ * CpNodes (starting from the given CpNode).
+ * @param cpStart The ContactPoint from where to start the traversal.
+ */
+function traverseShape(cpStart) {
+    let cpNode = cpStart;
+    if (cpNode === cpNode.next.prevOnCircle) {
+        return [cpNode];
+    }
+    const visitedCps = [];
+    do {
+        visitedCps.push(cpNode);
+        const next = cpNode.next.prevOnCircle;
+        cpNode = cpNode === next
+            ? cpNode = cpNode.next.next // Terminal vertex
+            : cpNode = next; // Take last exit
+    } while (cpNode !== cpStart);
+    return visitedCps;
+}
+/**
+ * @hidden
+ * Starting from some ContactPoint, traverses the shape going around Vertices
+ * and if more than two Vertices have been visited in total then recursively
+ * adds 3-prongs until only one or two Vertices have been visited.
+ *
+ * This process further subdivides the shape.
+ * @param cpGraphs
+ * @param cpStart The ContactPoint from where to start the process.
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+let ii = 0;
+function findAndAdd3Prongs(cpGraphs, cpStart, extreme) {
+    let visitedCps;
+    do {
+        visitedCps = traverseShape(cpStart);
+        if (visitedCps.length > 2) {
+            findAndAdd3Prong(cpGraphs, visitedCps, extreme);
+            ii++;
+        }
+        if (typeof _debug_ !== 'undefined') {
+            if (ii === _debug_.directives.stopAfterThreeProngsNum) {
+                return undefined;
+            }
+        }
+    } while (visitedCps.length > 2);
+    return visitedCps;
+}
+/**
+ * @hidden
+ * Finds and add a 3-prong MAT circle to the given shape.
+ * @param cpGraphs
+ * @param visitedCps
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+function findAndAdd3Prong(cpGraphs, visitedCps, extreme) {
+    const δs = [];
+    for (const visitedCp of visitedCps) {
+        δs.push([visitedCp, visitedCp.next]);
+    }
+    const threeProng = find3Prong(δs, extreme);
+    const orders = [];
+    for (let i = 0; i < 3; i++) {
+        orders.push(
+        //PointOnShape.calcOrder(threeProng.circle, threeProng.ps[i])
+        calcPosOrder(threeProng.circle, threeProng.ps[i]));
+    }
+    const circle = add3Prong(cpGraphs, orders, threeProng);
+    if (typeof _debug_ !== 'undefined') {
+        add3ProngDebugInfo(circle, visitedCps);
+    }
+}
+/** @hidden */
+function add3ProngDebugInfo(circle, visitedCps) {
+    const threeProngs = _debug_.generated.elems.threeProng;
+    const len = threeProngs.length;
+    const data = threeProngs[len - 1];
+    data.visitedCps = visitedCps;
+    data.circle = circle;
+}
+export { findAndAddAll3Prongs };
 //# sourceMappingURL=find-and-add-3-prongs.js.map

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

@@ -1,14 +1,14 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from '../../loop.js';
-import { CpNode } from '../../cp-node.js';
-/**
- * @hidden
- * Find and add two-prongs that remove any holes in the shape.
- * @param loops The loops (that as a precondition must be ordered from
- * highest (i.e. smallest y-value) topmost point loops to lowest)
- * @param cpTrees
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-declare function findAndAddHoleClosing2Prongs(loops: Loop[], cpTrees: Map<Loop, LlRbTree<CpNode>>, extreme: number): void;
-export { findAndAddHoleClosing2Prongs };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Loop } from '../../loop.js';
+import { CpNode } from '../../cp-node.js';
+/**
+ * @hidden
+ * Find and add two-prongs that remove any holes in the shape.
+ * @param loops The loops (that as a precondition must be ordered from
+ * highest (i.e. smallest y-value) topmost point loops to lowest)
+ * @param cpTrees
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+declare function findAndAddHoleClosing2Prongs(loops: Loop[], cpTrees: Map<Loop, LlRbTree<CpNode>>, extreme: number): void;
+export { findAndAddHoleClosing2Prongs };

package/node/mat/find-mat/find-and-add-hole-closing-2-prongs.js

@@ -1,34 +1,34 @@
-import { getShapeBounds } from '../../svg/get-shape-bounds.js';
-import { getMinYPos } from '../../svg/get-min-y-pos.js';
-import { find2Prong } from './find-2-prong/find-2-prong.js';
-import { add2Prong } from './add-2-prong.js';
-/**
- * @hidden
- * Find and add two-prongs that remove any holes in the shape.
- * @param loops The loops (that as a precondition must be ordered from
- * highest (i.e. smallest y-value) topmost point loops to lowest)
- * @param cpTrees
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-function findAndAddHoleClosing2Prongs(loops, cpTrees, extreme) {
-    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.
-    const minYs = loops.map(getMinYPos);
-    // We start at 1 since 0 is the outer (root) loop
-    for (let k = 1; k < minYs.length; k++) {
-        const posSource = minYs[k];
-        const holeClosingTwoProng = find2Prong(loops, extreme, squaredDiagonalLength, cpTrees, posSource, true, k);
-        if (!holeClosingTwoProng) {
-            throw new Error(`Unable to find hole-closing 2-prong`);
-        }
-        // TODO important - handle case of n-prong, i.e. more than one antipode
-        // - currently we only handle case of single antipode (the general case)
-        const { circle, zs: posAntipodes } = holeClosingTwoProng;
-        add2Prong(cpTrees, circle, posSource, [posAntipodes[0]], true, extreme);
-    }
-}
-export { findAndAddHoleClosing2Prongs };
+import { getShapeBounds } from '../../svg/get-shape-bounds.js';
+import { getMinYPos } from '../../svg/get-min-y-pos.js';
+import { find2Prong } from './find-2-prong/find-2-prong.js';
+import { add2Prong } from './add-2-prong.js';
+/**
+ * @hidden
+ * Find and add two-prongs that remove any holes in the shape.
+ * @param loops The loops (that as a precondition must be ordered from
+ * highest (i.e. smallest y-value) topmost point loops to lowest)
+ * @param cpTrees
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+function findAndAddHoleClosing2Prongs(loops, cpTrees, extreme) {
+    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.
+    const minYs = loops.map(getMinYPos);
+    // We start at 1 since 0 is the outer (root) loop
+    for (let k = 1; k < minYs.length; k++) {
+        const posSource = minYs[k];
+        const holeClosingTwoProng = find2Prong(loops, extreme, squaredDiagonalLength, cpTrees, posSource, true, k);
+        if (!holeClosingTwoProng) {
+            throw new Error(`Unable to find hole-closing 2-prong`);
+        }
+        // TODO important - handle case of n-prong, i.e. more than one antipode
+        // - currently we only handle case of single antipode (the general case)
+        const { circle, zs: posAntipodes } = holeClosingTwoProng;
+        add2Prong(cpTrees, circle, posSource, [posAntipodes[0]], true, extreme);
+    }
+}
+export { findAndAddHoleClosing2Prongs };
 //# sourceMappingURL=find-and-add-hole-closing-2-prongs.js.map

package/node/mat/find-mat/get-potential-2-prongs.d.ts

@@ -1,4 +1,4 @@
-import { IPointOnShape } from '../../point-on-shape.js';
-/** @hidden */
-declare function getPotential2Prongs(possPerLoop: IPointOnShape[][]): IPointOnShape[][];
-export { getPotential2Prongs };
+import { IPointOnShape } from '../../point-on-shape.js';
+/** @hidden */
+declare function getPotential2Prongs(possPerLoop: IPointOnShape[][]): IPointOnShape[][];
+export { getPotential2Prongs };

package/node/mat/find-mat/get-potential-2-prongs.js

@@ -1,17 +1,17 @@
-import { isPosQuiteSharpCorner } from '../../point-on-shape.js';
-/** @hidden */
-function getPotential2Prongs(possPerLoop) {
-    const for2ProngsArray = [];
-    for (const poss of possPerLoop) {
-        const for2Prongs = [];
-        for (const pos of poss) {
-            if (!isPosQuiteSharpCorner(pos)) {
-                for2Prongs.push(pos);
-            }
-        }
-        for2ProngsArray.push(for2Prongs);
-    }
-    return for2ProngsArray;
-}
-export { getPotential2Prongs };
+import { isPosQuiteSharpCorner } from '../../point-on-shape.js';
+/** @hidden */
+function getPotential2Prongs(possPerLoop) {
+    const for2ProngsArray = [];
+    for (const poss of possPerLoop) {
+        const for2Prongs = [];
+        for (const pos of poss) {
+            if (!isPosQuiteSharpCorner(pos)) {
+                for2Prongs.push(pos);
+            }
+        }
+        for2ProngsArray.push(for2Prongs);
+    }
+    return for2ProngsArray;
+}
+export { getPotential2Prongs };
 //# sourceMappingURL=get-potential-2-prongs.js.map

package/node/mat/find-mat/get-sharp-corners.d.ts

@@ -1,4 +1,4 @@
-import { IPointOnShape } from '../../point-on-shape.js';
-/** @hidden */
-declare function getSharpCorners(possPerLoop: IPointOnShape[][]): IPointOnShape[][];
-export { getSharpCorners };
+import { IPointOnShape } from '../../point-on-shape.js';
+/** @hidden */
+declare function getSharpCorners(possPerLoop: IPointOnShape[][]): IPointOnShape[][];
+export { getSharpCorners };