flo-mat 2.0.2 → 2.0.3

package/node/mat/find-mat/add-debug-info.js

@@ -1,68 +1,68 @@
-import { getBoundingHull, getBoundingBoxTight } from 'flo-bezier3';
-import { getCornerAtEnd } from '../../curve.js';
-import { getBoundingBox_ } from '../../get-bounding-box-.js';
-let timingStart;
-/** @hidden */
-function addDebugInfo1(loops) {
-    if (typeof _debug_ === 'undefined') {
-        return;
-    }
-    timingStart = performance.now();
-    for (const loop of loops) {
-        _debug_.fs.nameObj(loop, 'l|');
-    }
-    const generated = _debug_.generated;
-    //generated.elems.loop.push(...loops);
-    //generated.elems.loops.push(loops);
-    for (const loop of loops) {
-        let i = 0;
-        loop.curves.forEach(function (curve) {
-            const ps = curve.ps;
-            const hull = getBoundingHull(ps);
-            generated.elems.boundingHull.push(hull);
-            const looseBoundingBox = getBoundingBox_(ps);
-            generated.elems.looseBoundingBox.push(looseBoundingBox);
-            const tightBoundingBox = getBoundingBoxTight(ps);
-            generated.elems.tightBoundingBox.push(tightBoundingBox);
-            const corner = getCornerAtEnd(curve);
-            if (corner.isSharp) {
-                generated.elems.sharpCorner.push(curve);
-            }
-            else if (corner.isDull) {
-                generated.elems.dullCorner.push(curve);
-            }
-            i++;
-        });
-    }
-}
-/** @hidden */
-function addDebugInfo2() {
-    if (typeof _debug_ === 'undefined') {
-        return;
-    }
-    const timing = _debug_.generated.timing;
-    const now = performance.now();
-    timing.holeClosers += now - timingStart;
-    timingStart = now;
-}
-function addDebugInfo3() {
-    if (typeof _debug_ === 'undefined') {
-        return;
-    }
-    const generated = _debug_.generated;
-    const timing = generated.timing;
-    const now = performance.now();
-    timing.oneAnd2Prongs += now - timingStart;
-    timingStart = now;
-}
-function addDebugInfo4(mat) {
-    if (typeof _debug_ === 'undefined') {
-        return;
-    }
-    const generated = _debug_.generated;
-    const timing = generated.timing;
-    generated.elems.mat.push(mat);
-    timing.threeProngs += performance.now() - timingStart;
-}
-export { addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 };
+import { getBoundingHull, getBoundingBoxTight } from 'flo-bezier3';
+import { getCornerAtEnd } from '../../curve.js';
+import { getBoundingBox_ } from '../../get-bounding-box-.js';
+let timingStart;
+/** @hidden */
+function addDebugInfo1(loops) {
+    if (typeof _debug_ === 'undefined') {
+        return;
+    }
+    timingStart = performance.now();
+    for (const loop of loops) {
+        _debug_.fs.nameObj(loop, 'l|');
+    }
+    const generated = _debug_.generated;
+    //generated.elems.loop.push(...loops);
+    //generated.elems.loops.push(loops);
+    for (const loop of loops) {
+        let i = 0;
+        loop.curves.forEach(function (curve) {
+            const ps = curve.ps;
+            const hull = getBoundingHull(ps);
+            generated.elems.boundingHull.push(hull);
+            const looseBoundingBox = getBoundingBox_(ps);
+            generated.elems.looseBoundingBox.push(looseBoundingBox);
+            const tightBoundingBox = getBoundingBoxTight(ps);
+            generated.elems.tightBoundingBox.push(tightBoundingBox);
+            const corner = getCornerAtEnd(curve);
+            if (corner.isSharp) {
+                generated.elems.sharpCorner.push(curve);
+            }
+            else if (corner.isDull) {
+                generated.elems.dullCorner.push(curve);
+            }
+            i++;
+        });
+    }
+}
+/** @hidden */
+function addDebugInfo2() {
+    if (typeof _debug_ === 'undefined') {
+        return;
+    }
+    const timing = _debug_.generated.timing;
+    const now = performance.now();
+    timing.holeClosers += now - timingStart;
+    timingStart = now;
+}
+function addDebugInfo3() {
+    if (typeof _debug_ === 'undefined') {
+        return;
+    }
+    const generated = _debug_.generated;
+    const timing = generated.timing;
+    const now = performance.now();
+    timing.oneAnd2Prongs += now - timingStart;
+    timingStart = now;
+}
+function addDebugInfo4(mat) {
+    if (typeof _debug_ === 'undefined') {
+        return;
+    }
+    const generated = _debug_.generated;
+    const timing = generated.timing;
+    generated.elems.mat.push(mat);
+    timing.threeProngs += performance.now() - timingStart;
+}
+export { addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 };
 //# sourceMappingURL=add-debug-info.js.map

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

@@ -1,11 +1,11 @@
-import { Loop } from '../../loop.js';
-import { IPointOnShape } from '../../point-on-shape.js';
-/**
- * @hidden
- * Get useful points on the shape - these incude points of maximum curvature and
- * points at the bezier-bezier interfaces.
- * @param loop
- * @param additionalPointCount
- */
-declare function getInterestingPointsOnLoop(minBezLength: number, maxCurviness: number, maxLength: number): (loop: Loop) => IPointOnShape[];
-export { getInterestingPointsOnLoop };
+import { Loop } from '../../loop.js';
+import { IPointOnShape } from '../../point-on-shape.js';
+/**
+ * @hidden
+ * Get useful points on the shape - these incude points of maximum curvature and
+ * points at the bezier-bezier interfaces.
+ * @param loop
+ * @param additionalPointCount
+ */
+declare function getInterestingPointsOnLoop(minBezLength: number, maxCurviness: number, maxLength: number): (loop: Loop) => IPointOnShape[];
+export { getInterestingPointsOnLoop };

package/node/mat/find-mat/create-get-interesting-points-on-loop.js

@@ -1,52 +1,52 @@
-import { getCurvatureExtrema, splitByCurvatureAndLength, controlPointLinesLength } from 'flo-bezier3';
-import { getContactCirclesAtInterface } from '../get-contact-circles-at-interface.js';
-import { PointOnShape, comparePoss } from '../../point-on-shape.js';
-/**
- * @hidden
- * Get useful points on the shape - these incude points of maximum curvature and
- * points at the bezier-bezier interfaces.
- * @param loop
- * @param additionalPointCount
- */
-function getInterestingPointsOnLoop(minBezLength, maxCurviness, maxLength) {
-    return function (loop) {
-        const allPoints = [];
-        for (let i = 0; i < loop.curves.length; i++) {
-            const curve = loop.curves[i];
-            // qqq if (lengthSquaredUpperBound(curve.ps) < minBezLength) {
-            if (controlPointLinesLength(curve.ps) < minBezLength) {
-                continue;
-            }
-            /*
-            let { maxCurvatureTs, maxNegativeCurvatureTs } =
-                getCurvatureExtrema(curve.ps);
-            let maxCurvatures = maxCurvatureTs.map(t => new PointOnShape(curve, t));
-            let maxNegativeCurvatures = maxNegativeCurvatureTs.map(t => new PointOnShape(curve, t));
-
-            allPoints.push(
-                ...getContactCirclesAtInterface(curve),
-                ...maxCurvatures,
-                ...maxNegativeCurvatures
-            );
-            */
-            // let { maxima } = getCurvatureExtrema(curve.ps);
-            // qqq let { maxCurvatureTs, maxNegativeCurvatureTs } = 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));
-            const maxAbsCurvatures = [...maxima].map(t => new PointOnShape(curve, t));
-            allPoints.push(...getContactCirclesAtInterface(curve), ...maxAbsCurvatures);
-            let ts = splitByCurvatureAndLength(curve.ps, maxCurviness, maxLength);
-            if (ts.length === 2) {
-                ts = [0, 0.5, 1];
-            }
-            for (let i = 1; i < ts.length - 1; i++) {
-                allPoints.push(new PointOnShape(curve, ts[i]));
-            }
-        }
-        allPoints.sort(comparePoss);
-        return allPoints;
-    };
-}
-export { getInterestingPointsOnLoop };
+import { getCurvatureExtrema, splitByCurvatureAndLength, controlPointLinesLength } from 'flo-bezier3';
+import { getContactCirclesAtInterface } from '../get-contact-circles-at-interface.js';
+import { PointOnShape, comparePoss } from '../../point-on-shape.js';
+/**
+ * @hidden
+ * Get useful points on the shape - these incude points of maximum curvature and
+ * points at the bezier-bezier interfaces.
+ * @param loop
+ * @param additionalPointCount
+ */
+function getInterestingPointsOnLoop(minBezLength, maxCurviness, maxLength) {
+    return function (loop) {
+        const allPoints = [];
+        for (let i = 0; i < loop.curves.length; i++) {
+            const curve = loop.curves[i];
+            // qqq if (lengthSquaredUpperBound(curve.ps) < minBezLength) {
+            if (controlPointLinesLength(curve.ps) < minBezLength) {
+                continue;
+            }
+            /*
+            let { maxCurvatureTs, maxNegativeCurvatureTs } =
+                getCurvatureExtrema(curve.ps);
+            let maxCurvatures = maxCurvatureTs.map(t => new PointOnShape(curve, t));
+            let maxNegativeCurvatures = maxNegativeCurvatureTs.map(t => new PointOnShape(curve, t));
+
+            allPoints.push(
+                ...getContactCirclesAtInterface(curve),
+                ...maxCurvatures,
+                ...maxNegativeCurvatures
+            );
+            */
+            // let { maxima } = getCurvatureExtrema(curve.ps);
+            // qqq let { maxCurvatureTs, maxNegativeCurvatureTs } = 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));
+            const maxAbsCurvatures = [...maxima].map(t => new PointOnShape(curve, t));
+            allPoints.push(...getContactCirclesAtInterface(curve), ...maxAbsCurvatures);
+            let ts = splitByCurvatureAndLength(curve.ps, maxCurviness, maxLength);
+            if (ts.length === 2) {
+                ts = [0, 0.5, 1];
+            }
+            for (let i = 1; i < ts.length - 1; i++) {
+                allPoints.push(new PointOnShape(curve, ts[i]));
+            }
+        }
+        allPoints.sort(comparePoss);
+        return allPoints;
+    };
+}
+export { getInterestingPointsOnLoop };
 //# sourceMappingURL=create-get-interesting-points-on-loop.js.map

package/node/mat/find-mat/create-initial-cp-graph.d.ts

@@ -1,12 +1,12 @@
-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
- * Creates the initial ContactPoint loops from the given sharp corners.
- * @param shape
- * @param sharpCornerss
- */
-declare function createInitialCpGraph(loops: Loop[], cpTrees: Map<Loop, LlRbTree<CpNode>>, sharpCornerss: IPointOnShape[][]): CpNode;
-export { createInitialCpGraph };
+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
+ * Creates the initial ContactPoint loops from the given sharp corners.
+ * @param shape
+ * @param sharpCornerss
+ */
+declare function createInitialCpGraph(loops: Loop[], cpTrees: Map<Loop, LlRbTree<CpNode>>, sharpCornerss: IPointOnShape[][]): CpNode;
+export { createInitialCpGraph };

package/node/mat/find-mat/create-initial-cp-graph.js

@@ -1,41 +1,41 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from '../../cp-node.js';
-/**
- * @hidden
- * Creates the initial ContactPoint loops from the given sharp corners.
- * @param shape
- * @param sharpCornerss
- */
-function createInitialCpGraph(loops, cpTrees, sharpCornerss /*,
-xMap: Map<number[][],{ ps: number[][] }>*/) {
-    let cpNode;
-    for (let k = 0; k < sharpCornerss.length; k++) {
-        const sharpCorners = sharpCornerss[k];
-        // qqq const cpTree = new LlRbTree(CpNode.comparator, [], true);
-        const cpTree = new LlRbTree(CpNode.comparator, false);
-        let cpNode1 = undefined;
-        let cpNode2 = undefined;
-        for (const pos of sharpCorners) {
-            const ps = pos.curve.next.ps;
-            //const x = xMap.get(ps);
-            //const isIntersection = !!x;
-            const circle = { center: pos.p, radius: 0 };
-            const cp1 = { pointOnShape: pos, circle, order: -1, order2: 0 };
-            const cp2 = { 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);
-            cpNode1.prevOnCircle = cpNode2;
-            cpNode2.prevOnCircle = cpNode1;
-            cpNode1.nextOnCircle = cpNode2;
-            cpNode2.nextOnCircle = cpNode1;
-        }
-        if (!cpNode) {
-            cpNode = cpNode1;
-        }
-        const loop = loops[k];
-        cpTrees.set(loop, cpTree);
-    }
-    return cpNode;
-}
-export { createInitialCpGraph };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { CpNode } from '../../cp-node.js';
+/**
+ * @hidden
+ * Creates the initial ContactPoint loops from the given sharp corners.
+ * @param shape
+ * @param sharpCornerss
+ */
+function createInitialCpGraph(loops, cpTrees, sharpCornerss /*,
+xMap: Map<number[][],{ ps: number[][] }>*/) {
+    let cpNode;
+    for (let k = 0; k < sharpCornerss.length; k++) {
+        const sharpCorners = sharpCornerss[k];
+        // qqq const cpTree = new LlRbTree(CpNode.comparator, [], true);
+        const cpTree = new LlRbTree(CpNode.comparator, false);
+        let cpNode1 = undefined;
+        let cpNode2 = undefined;
+        for (const pos of sharpCorners) {
+            const ps = pos.curve.next.ps;
+            //const x = xMap.get(ps);
+            //const isIntersection = !!x;
+            const circle = { center: pos.p, radius: 0 };
+            const cp1 = { pointOnShape: pos, circle, order: -1, order2: 0 };
+            const cp2 = { 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);
+            cpNode1.prevOnCircle = cpNode2;
+            cpNode2.prevOnCircle = cpNode1;
+            cpNode1.nextOnCircle = cpNode2;
+            cpNode2.nextOnCircle = cpNode1;
+        }
+        if (!cpNode) {
+            cpNode = cpNode1;
+        }
+        const loop = loops[k];
+        cpTrees.set(loop, cpTree);
+    }
+    return cpNode;
+}
+export { createInitialCpGraph };
 //# sourceMappingURL=create-initial-cp-graph.js.map

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

@@ -1,8 +1,8 @@
-import { IPointOnShape } from '../../../point-on-shape.js';
-import { Circle } from '../../../circle.js';
-import { CpNode } from '../../../cp-node.js';
-import { BezierPiece } from '../../bezier-piece.js';
-import { TXForDebugging } from './x-for-debugging.js';
-/** @hidden */
-declare function addDebugInfo(bezierPieces: BezierPiece[], failed: boolean, pos: IPointOnShape, circle: Circle, z: IPointOnShape, δ: CpNode[], xs: TXForDebugging[], holeClosing: boolean): void;
-export { addDebugInfo };
+import { IPointOnShape } from '../../../point-on-shape.js';
+import { Circle } from '../../../circle.js';
+import { CpNode } from '../../../cp-node.js';
+import { BezierPiece } from '../../bezier-piece.js';
+import { TXForDebugging } from './x-for-debugging.js';
+/** @hidden */
+declare function addDebugInfo(bezierPieces: BezierPiece[], failed: boolean, pos: IPointOnShape, circle: Circle, z: IPointOnShape, δ: CpNode[], xs: TXForDebugging[], holeClosing: boolean): void;
+export { addDebugInfo };

package/node/mat/find-mat/find-2-prong/add-debug-info.js

@@ -1,22 +1,22 @@
-import { getTwoProngType } from '../../get-two-prong-type.js';
-/** @hidden */
-function addDebugInfo(bezierPieces, failed, pos, circle, z, δ, xs, holeClosing) {
-    const twoProng = {
-        generated: _debug_.generated,
-        bezierPieces,
-        pos,
-        δ,
-        z: z ? z.p : undefined,
-        circle,
-        xs,
-        failed,
-        holeClosing,
-        notAdded: false,
-        deleted: false,
-        cpNode: undefined
-    };
-    const twoProngType = getTwoProngType(twoProng);
-    _debug_.generated.elems[twoProngType].push(twoProng);
-}
-export { addDebugInfo };
+import { getTwoProngType } from '../../get-two-prong-type.js';
+/** @hidden */
+function addDebugInfo(bezierPieces, failed, pos, circle, z, δ, xs, holeClosing) {
+    const twoProng = {
+        generated: _debug_.generated,
+        bezierPieces,
+        pos,
+        δ,
+        z: z ? z.p : undefined,
+        circle,
+        xs,
+        failed,
+        holeClosing,
+        notAdded: false,
+        deleted: false,
+        cpNode: undefined
+    };
+    const twoProngType = getTwoProngType(twoProng);
+    _debug_.generated.elems[twoProngType].push(twoProng);
+}
+export { addDebugInfo };
 //# sourceMappingURL=add-debug-info.js.map

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

@@ -1,11 +1,11 @@
-import { BezierPiece } from '../../bezier-piece.js';
-/**
- * @hidden
- * Cull all bezierPieces not within given radius of a given point.
- * @param extreme
- * @param bezierPieces
- * @param p
- * @param rSquared
- */
-declare function cullBezierPieces(bezierPieces: BezierPiece[], p: number[], rSquared: number): BezierPiece[];
-export { cullBezierPieces };
+import { BezierPiece } from '../../bezier-piece.js';
+/**
+ * @hidden
+ * Cull all bezierPieces not within given radius of a given point.
+ * @param extreme
+ * @param bezierPieces
+ * @param p
+ * @param rSquared
+ */
+declare function cullBezierPieces(bezierPieces: BezierPiece[], p: number[], rSquared: number): BezierPiece[];
+export { cullBezierPieces };

package/node/mat/find-mat/find-2-prong/cull-bezier-pieces.js

@@ -1,30 +1,30 @@
-import { getClosestSquareDistanceToRect } from '../../geometry/get-closest-square-distance-to-rect.js';
-import { getBoundingBox_ } from '../../../get-bounding-box-.js';
-/**
- * @hidden
- * Cull all bezierPieces not within given radius of a given point.
- * @param extreme
- * @param bezierPieces
- * @param p
- * @param rSquared
- */
-function cullBezierPieces(bezierPieces, p, rSquared) {
-    const CULL_THRESHOLD = 5;
-    // TODO - base delta on theory
-    const TOLERANCE = 1 + 1e-3;
-    if (bezierPieces.length <= CULL_THRESHOLD) {
-        return bezierPieces;
-    }
-    const newPieces = [];
-    for (const bezierPiece of bezierPieces) {
-        const ps = bezierPiece.curve.ps;
-        const rect = getBoundingBox_(ps);
-        const bd = getClosestSquareDistanceToRect(rect, p);
-        if (bd <= rSquared * TOLERANCE) {
-            newPieces.push(bezierPiece);
-        }
-    }
-    return newPieces;
-}
-export { cullBezierPieces };
+import { getClosestSquareDistanceToRect } from '../../geometry/get-closest-square-distance-to-rect.js';
+import { getBoundingBox_ } from '../../../get-bounding-box-.js';
+/**
+ * @hidden
+ * Cull all bezierPieces not within given radius of a given point.
+ * @param extreme
+ * @param bezierPieces
+ * @param p
+ * @param rSquared
+ */
+function cullBezierPieces(bezierPieces, p, rSquared) {
+    const CULL_THRESHOLD = 5;
+    // TODO - base delta on theory
+    const TOLERANCE = 1 + 1e-3;
+    if (bezierPieces.length <= CULL_THRESHOLD) {
+        return bezierPieces;
+    }
+    const newPieces = [];
+    for (const bezierPiece of bezierPieces) {
+        const ps = bezierPiece.curve.ps;
+        const rect = getBoundingBox_(ps);
+        const bd = getClosestSquareDistanceToRect(rect, p);
+        if (bd <= rSquared * TOLERANCE) {
+            newPieces.push(bezierPiece);
+        }
+    }
+    return newPieces;
+}
+export { cullBezierPieces };
 //# sourceMappingURL=cull-bezier-pieces.js.map

package/node/mat/find-mat/find-2-prong/find-2-prong.d.ts

@@ -1,37 +1,37 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from '../../../cp-node.js';
-import { Loop } from '../../../loop.js';
-import { Circle } from '../../../circle.js';
-import { IPointOnShape } from '../../../point-on-shape.js';
-/**
- * @hidden
- * Adds a 2-prong to the MAT. The first point on the shape boundary is given and
- * the second one is found by the algorithm.
- *
- * A 2-prong is defined as a MAT circle that touches the shape at exactly 2
- * points.
- *
- * Before any 2-prongs are added the entire shape is our δΩ (1-prongs do not
- * reduce the boundary).
- *
- * As per the paper by Choi, Choi, Moon and Wee:
- *   "The starting point of this algorithm is a choice of a circle Br(x)
- *    centered at an interior point x which contains two boundary portions c and
- *    d of dΩ as in Fig. 19."
- * In fact, we (and they) start by fixing one point on the boundary beforehand.
- * @param loops A shape represented by path loops
- * @param extreme The extreme coordinate value of the shape
- * @param squaredDiagonalLength The squared diagonal length of the shape
- * bounding box.
- * @param y The source point of the 2-prong to be found
- * @param isHoleClosing True if this is a hole-closing two-prong, false otherwise
- * @param k The loop array index
- */
-declare function find2Prong(loops: Loop[], extreme: number, squaredDiagonalLength: number, cpTrees: Map<Loop, LlRbTree<CpNode>>, y: IPointOnShape, isHoleClosing: boolean, k: number): {
-    circle: Circle;
-    zs: {
-        pos: IPointOnShape;
-        d: number;
-    }[];
-};
-export { find2Prong };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { CpNode } from '../../../cp-node.js';
+import { Loop } from '../../../loop.js';
+import { Circle } from '../../../circle.js';
+import { IPointOnShape } from '../../../point-on-shape.js';
+/**
+ * @hidden
+ * Adds a 2-prong to the MAT. The first point on the shape boundary is given and
+ * the second one is found by the algorithm.
+ *
+ * A 2-prong is defined as a MAT circle that touches the shape at exactly 2
+ * points.
+ *
+ * Before any 2-prongs are added the entire shape is our δΩ (1-prongs do not
+ * reduce the boundary).
+ *
+ * As per the paper by Choi, Choi, Moon and Wee:
+ *   "The starting point of this algorithm is a choice of a circle Br(x)
+ *    centered at an interior point x which contains two boundary portions c and
+ *    d of dΩ as in Fig. 19."
+ * In fact, we (and they) start by fixing one point on the boundary beforehand.
+ * @param loops A shape represented by path loops
+ * @param extreme The extreme coordinate value of the shape
+ * @param squaredDiagonalLength The squared diagonal length of the shape
+ * bounding box.
+ * @param y The source point of the 2-prong to be found
+ * @param isHoleClosing True if this is a hole-closing two-prong, false otherwise
+ * @param k The loop array index
+ */
+declare function find2Prong(loops: Loop[], extreme: number, squaredDiagonalLength: number, cpTrees: Map<Loop, LlRbTree<CpNode>>, y: IPointOnShape, isHoleClosing: boolean, k: number): {
+    circle: Circle;
+    zs: {
+        pos: IPointOnShape;
+        d: number;
+    }[];
+};
+export { find2Prong };