flo-mat 3.0.7 → 3.0.10

package/src/find-2-prong/reduce-radius.ts

@@ -10,22 +10,22 @@ import { CurvePiece } from '../mat/curve-piece.js';
  */
 function reduceRadius(
         extreme: number,
-        bezierPieces: CurvePiece[], 
+        curvePieces: CurvePiece[], 
         p: number[],
         x: number[]) {
 
     const TOLERANCE = 1 + 2**-10;
 
     let minRadius = Number.POSITIVE_INFINITY;
-    for (let i=0; i<bezierPieces.length; i++) {
-        const bezierPiece = bezierPieces[i];
+    for (let i=0; i<curvePieces.length; i++) {
+        const curvePiece = curvePieces[i];
 
-        const ps = bezierPiece.curve.ps;
+        const ps = curvePiece.curve.ps;
 
         // let min = Number.POSITIVE_INFINITY;
         const num = 2;
         for (let j=0; j<(num + 1); j++) {
-            const p_ = evalDeCasteljau(ps, bezierPiece.ts[j/num]);
+            const p_ = evalDeCasteljau(ps, curvePiece.ts[j/num]);
             const cc = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p_);
             if (cc) {
                 let r = squaredDistanceBetween(p, cc);

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

@@ -9,14 +9,14 @@ import { getClosestPoints } from './get-closest-points.js';
  * Find new x and ps that are a better estimate of the 3-prong circle.
  * The potential function, V, is defined as the distance to the actual 3 prong 
  * circle center.
- * @param bezierPiece3s The three boundary pieces, each of which should contain 
+ * @param curvePiece3s The three boundary pieces, each of which should contain 
  * a point of the 3-prong to be found.
  * @param x The currently best guess at the center of the 3-prong circle.
  * @param vectorToZeroV
  * @param extreme
  */
 function calcBetterX(
-        bezierPiece3s: CurvePiece[][], 
+        curvePiece3s: CurvePiece[][], 
         x: number[], 
         vectorToZeroV: number[]) {
 
@@ -33,7 +33,7 @@ function calcBetterX(
         newX = translate(shift, x); 
         
         
-        newPoss = getClosestPoints(newX, bezierPiece3s);
+        newPoss = getClosestPoints(newX, curvePiece3s);
 
         // Point of zero V
         const newCircleCenter = circumCenter(newPoss.map(pos => pos!.p)); 

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

@@ -13,13 +13,13 @@ const { max, ceil, log2 } = Math;
  * must be within the shape. 
  * @param δ3s - The three boundary pieces of which we need to find the three 
  * 3-prong points.
- * @param bezierPiece3s 
+ * @param curvePiece3s 
  * @param extreme 
  */
 function calcInitial3ProngCenter(
         maxCoordinate: number,
         δ3s: CpNode[][], 
-        bezierPiece3s: CurvePiece[][]) {
+        curvePiece3s: CurvePiece[][]) {
 
     const circle = δ3s[0][0].cp.circle;
     const twoProngCircleCenter = circle.center;
@@ -27,7 +27,7 @@ function calcInitial3ProngCenter(
     const pow = max(0,ceil(log2(maxCoordinate/circle.radius))) + 1;  // determines accuracy;
     const pos = getCloseBoundaryPointsCertified(
         pow,
-        bezierPiece3s[1],
+        curvePiece3s[1],
         twoProngCircleCenter
     )[0];
 

package/src/find-3-prong.ts/find-3-prong-for-delta3s.ts

@@ -27,7 +27,7 @@ const calcVectorToZeroV_StraightToIt = fromTo;
  * Finds a 3-prong using only the 3 given δs.
  * @param δs The boundary pieces
  * @param idx δ identifier
- * @param bezierPiecess
+ * @param curvePiecess
  * @param maxCoordinate The maximum coordinate value used to calculate floating point
  * tolerances.
  */
@@ -35,7 +35,7 @@ function find3ProngForDelta3s(
         δs: CpNode[][], 
         idx: number, 
         k: number,
-        bezierPiecess: CurvePiece[][],
+        curvePiecess: CurvePiece[][],
         maxCoordinate: number) {
 
     const TOLERANCE = 2**-32*maxCoordinate;
@@ -47,10 +47,10 @@ function find3ProngForDelta3s(
         δs[δs.length-1]
     ];
 
-    const bezierPieces_ = [
-        bezierPiecess[0], 
-        bezierPiecess[idx], 
-        bezierPiecess[δs.length-1]
+    const curvePieces_ = [
+        curvePiecess[0], 
+        curvePiecess[idx], 
+        curvePiecess[δs.length-1]
     ];
 
     const δ3ss = [
@@ -59,15 +59,15 @@ function find3ProngForDelta3s(
         [δs_[2], δs_[0], δs_[1]],
     ];
 
-    const bezierPiecess_ = [
-        [bezierPieces_[0], bezierPieces_[1], bezierPieces_[2]],
-        [bezierPieces_[1], bezierPieces_[2], bezierPieces_[0]],
-        [bezierPieces_[2], bezierPieces_[0], bezierPieces_[1]],
+    const curvePiecess_ = [
+        [curvePieces_[0], curvePieces_[1], curvePieces_[2]],
+        [curvePieces_[1], curvePieces_[2], curvePieces_[0]],
+        [curvePieces_[2], curvePieces_[0], curvePieces_[1]],
     ]
 
 
     const δ3s = δ3ss[k];
-    const bezierPiece3s = bezierPiecess_[k];
+    const curvePiece3s = curvePiecess_[k];
 
     if (isSharp(δ3s[0][0])) { return undefined; }
 
@@ -75,13 +75,13 @@ function find3ProngForDelta3s(
     let poss: PointOnShape[] = undefined!;
     let circumCenter_;
     let j = 0; // Safeguard for slow convergence
-    let x = calcInitial3ProngCenter(maxCoordinate, δ3s, bezierPiece3s);
+    let x = calcInitial3ProngCenter(maxCoordinate, δ3s, curvePiece3s);
 
     let tolerance = Number.POSITIVE_INFINITY;
     while (tolerance > TOLERANCE && j < MAX_ITERATIONS) { 
         j++;
         
-        poss = getClosestPoints(x, bezierPiece3s);
+        poss = getClosestPoints(x, curvePiece3s);
         if (!Number.isFinite(x[0]) || !Number.isFinite(x[1])) {
 
             // TODO - the code can be cleaned up and sped up a lot if we don't
@@ -103,7 +103,7 @@ function find3ProngForDelta3s(
             // loop. This check, for instance, would be eliminated completely.
             return undefined;
         }
-        const upds = calcBetterX(bezierPiece3s, x, vectorToZeroV);
+        const upds = calcBetterX(curvePiece3s, x, vectorToZeroV);
         x = upds.newX;
         poss = upds.newPoss;
 
@@ -173,10 +173,10 @@ function find3ProngForDelta3s(
     // candidate for the 3-prong.
     //-------------------------------------------------------------------------
     const closestDs = [];
-    for (let i=0; i<bezierPiecess.length; i++) {
+    for (let i=0; i<curvePiecess.length; i++) {
         const p = getCloseBoundaryPointsCertified(
             5,  // TODO - see find-2-prong
-            bezierPiecess[i], x
+            curvePiecess[i], x
         )[0];
 
         closestDs.push( distanceBetween(p.p, x) );

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

@@ -15,7 +15,7 @@ import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
 function find3Prong(
 		δs: CpNode[][], extreme: number) {
 
-	const bezierPiecess = δs.map(getBoundaryPieceBeziers);
+	const curvePiecess = δs.map(getBoundaryPieceBeziers);
 
 	// The best candidate amongst the different 'permutations' of the given δs.
 	let threeProng: { 
@@ -27,7 +27,7 @@ function find3Prong(
 	for (let i=1; i<δs.length-1; i++) {
 		for (let k=0; k<3; k++) {
 			const threeProngInfo = 
-				find3ProngForDelta3s(δs, i, k, bezierPiecess, extreme);
+				find3ProngForDelta3s(δs, i, k, curvePiecess, extreme);
 			if (!threeProngInfo) { continue; }
 
 			const { circle, poss: poss, error, δ3s } = threeProngInfo;

package/src/find-3-prong.ts/get-closest-points.ts

@@ -5,17 +5,17 @@ import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-c
 /**
  * @internal
  * @param x 
- * @param bezierPiece3s 
+ * @param curvePiece3s 
  * @param extreme 
  */
 function getClosestPoints(
         x: number[], 
-        bezierPiece3s: CurvePiece[][]) {
+        curvePiece3s: CurvePiece[][]) {
 
-    return bezierPiece3s.map(bezierPieces => {
+    return curvePiece3s.map(curvePieces => {
         return getCloseBoundaryPointsCertified(
             5,  // TODO - see find-2-prong
-            bezierPieces, x
+            curvePieces, x
         )[0];
     });
 }

package/src/find-mat/add-2-prongs-by-error.ts

@@ -1,18 +1,18 @@
-import { drawFs } from "flo-draw";
+// import { drawFs } from "flo-draw";
 import { closestPointOnBezier } from "flo-bezier3";
 import { CpNode } from "../cp-node/cp-node.js";
 import { findAndAdd2Prong } from "../find-2-prong/find-and-add-2-prong.js";
 import { MatMeta } from "../mat/mat-meta.js";
 import { getHalfAngle } from "./get-half-angles.js";
 import { getMatCurveToNext } from "../cp-node/fs/get-mat-curve-to-next.js";
-import { getAllOnCircle } from "../cp-node/fs/get-all-on-circle.js";
+// import { getAllOnCircle } from "../cp-node/fs/get-all-on-circle.js";
 import { isTerminating } from "../cp-node/fs/is-terminating.js";
-import { findAndAdd3Prongs } from "../find-3-prong.ts/find-and-add-3-prongs.js";
-import { getBoundaryBezierPartsToNext } from "../cp-node/fs/get-boundary-bezier-parts-to-next.js";
-import { drawBezierPieces } from "../debug/functions/draw/draw-bezier-pieces.js";
+// import { findAndAdd3Prongs } from "../find-3-prong.ts/find-and-add-3-prongs.js";
+// import { getBoundaryBezierPartsToNext } from "../cp-node/fs/get-boundary-bezier-parts-to-next.js";
+// import { drawBezierPieces } from "../debug/functions/draw/draw-bezier-pieces.js";
 import { getAllOnLoop } from "../cp-node/fs/get-all-on-loop.js";
-import { PointOnShape } from "../point-on-shape/point-on-shape.js";
-import { getBoundaryBeziersToNext } from "../cp-node/fs/get-boundary-beziers-to-next.js";
+// import { PointOnShape } from "../point-on-shape/point-on-shape.js";
+// import { getBoundaryBeziersToNext } from "../cp-node/fs/get-boundary-beziers-to-next.js";
 import { isPosQuiteDullCorner } from "../point-on-shape/is-pos-quite-dull-corner.js";
 import { MatOptions } from "./mat-options.js";
 

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

@@ -54,6 +54,12 @@ function findMat(
         maxCoordinate, squaredDiagonalLength, loops, cpTrees, pointToCpNode,
         lastInsertId, ..._meta
     };
+    // const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
+    // const lastInsertId = { id: 0 };
+    // createInitialCpTree(loops, cpTrees, sharpCornersPerLoop, lastInsertId);
+
+    // const meta = getMeta(maxCoordinate, squaredDiagonalLength, loops, cpTrees, lastInsertId);
+
 
     let cpNode: CpNode | undefined;
 

package/src/find-mat/get-meta.ts

@@ -122,4 +122,10 @@ function addDebugInfo4() {
 }
 
 
-export { getPointToCpNode, getPartialMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 }
+export {
+    getPointToCpNode,
+    getPartialMeta,
+    addDebugInfo2,
+    addDebugInfo3,
+    addDebugInfo4
+}

package/src/index.ts

@@ -49,5 +49,5 @@ export { getSharpCornersOnLoop } from './find-mat/get-sharp-corners.js';
 export { getFor2ProngsOnLoop } from './find-mat/get-for-2-prongs-on-loop.js';
 export { getPotentialClosestPointsOnCurveCertified } from './closest-boundary-point/get-potential-closest-points-on-curve-certified.js';
 export { getCloseBoundaryPointsCertified } from './closest-boundary-point/get-close-boundary-points-certified.js';
-// export { getMeta } from './find-mat/get-meta.js';
-export { findAndAddHoleClosing2Prongs } from './find-2-prong/find-and-add-hole-closing-2-prongs.js';
+export { getPartialMeta, getPointToCpNode } from './find-mat/get-meta.js';
+export { findAndAddHoleClosing2Prongs } from './find-2-prong/find-and-add-hole-closing-2-prongs.js';

package/src/mat/get-boundary-piece-beziers.ts

@@ -17,7 +17,7 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): CurvePiece[] {
     let cpThis = cpNodes[0]; 
     const cpEnd  = cpNodes[1];
     
-    const bezierPieces: CurvePiece[] = [];
+    const curvePieces: CurvePiece[] = [];
 
     // As opposed to going around the circle and taking the last exit
     let goStraight = true; 
@@ -41,17 +41,17 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): CurvePiece[] {
         } else if (posNext.curve === posThis.curve &&
                    compareCps(cpThis.next.cp, cpThis.cp) > 0) {
                 
-            bezierPieces.push(
+            curvePieces.push(
                 { curve: posThis.curve, ts: [posThis.t, posNext.t] }
             );
         } else {
-            bezierPieces.push(
+            curvePieces.push(
                 { curve: posThis.curve, ts: [posThis.t, 1] }
             );
             
             if (posThis.curve.loop === posNext.curve.loop) {
                 addSkippedBeziers(
-                        bezierPieces, 
+                        curvePieces, 
                         posThis.curve, 
                         posNext.curve,
                         posNext.t
@@ -63,7 +63,7 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): CurvePiece[] {
     } while (cpThis !== cpEnd);
 
 
-    return bezierPieces;
+    return curvePieces;
 }
 
 
@@ -72,7 +72,7 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): CurvePiece[] {
  * Adds pieces of skipped beziers
  */
 function addSkippedBeziers(
-        bezierPieces: CurvePiece[], 
+        curvePieces: CurvePiece[], 
         curveStart: Curve, 
         curveEnd: Curve, 
         t1: number) {
@@ -81,7 +81,7 @@ function addSkippedBeziers(
     do {
         curveThis = curveThis.next;
         const tEnd = curveThis === curveEnd ? t1 : 1;
-        bezierPieces.push({ curve: curveThis, ts: [0, tEnd] });
+        curvePieces.push({ curve: curveThis, ts: [0, tEnd] });
     } while (curveThis !== curveEnd);
 }
 

package/src/mat/get-two-prong-type.ts

@@ -1,13 +1,13 @@
-import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
-import { ElemType_TwoProng } from './elem-type-two-prong.js';
+// import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
+// import { ElemType_TwoProng } from './elem-type-two-prong.js';
 
 
-/** @internal */
-function getTwoProngType(e: TwoProngForDebugging): ElemType_TwoProng {
-	if (e.holeClosing) { return 'twoProng_holeClosing' }
+// /** @internal */
+// function getTwoProngType(e: TwoProngForDebugging): ElemType_TwoProng {
+// 	if (e.holeClosing) { return 'twoProng_holeClosing' }
 	
-	return 'twoProng_regular';
-}
+// 	return 'twoProng_regular';
+// }
 
 
-export { getTwoProngType }
+// export { getTwoProngType }

package/src/sat/cull.ts

@@ -1,16 +1,17 @@
-import { Circle } from '../geometry/circle.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { DualSet } from '../utils/dual-set.js';
 import { getLeaves } from './get-leaves.js';
-import { CpNode } from '../cp-node/cp-node.js';
 import { CpNodeFs } from '../cp-node/cp-node-fs.js';
 import { isTerminating } from '../cp-node/fs/is-terminating.js';
-import { DualSet, DualSetFs } from '../utils/dual-set.js';
+import { DualSetFs } from '../utils/dual-set.js';
 
 const { isOnSameCircle } = CpNodeFs;
 
 
 /**
+ * Returns the set of non-trivial forward edges starting from the given `CpNode`.
  * 
- * @param cpStart 
+ * @param cpStart the start `CpNode`
  */
 function getNonTrivialForwardEdges(cpStart: CpNode) {
     let cpNode = cpStart;
@@ -32,12 +33,14 @@ function getNonTrivialForwardEdges(cpStart: CpNode) {
 
 
 /**
- * @internal
  * Returns the set of Vertices passing the following test: walk the MAT tree and 
  * keep all Vertices not in the current cull set and any Vertices that have a 
  * non-culled node further down the line toward the tree leaves.
- * @param culls The CpNodes (referred to by circles) that should be culled.
- * @param maxCpNode The start CpNode which must reprsesent the maximal vertex.
+ * 
+ * @param culls the `CpNode`s (referred to by circles) that should be culled
+ * @param maxCpNode the start `CpNode` which must represent the maximal vertex
+ * 
+ * @internal
  */
 function cull(
         culls: DualSet<number, number>,

package/src/sat/to-scale-axis.ts

@@ -12,43 +12,44 @@ import { getSatCulls } from './get-sat-culls.js';
 
 
 /**
- * Apply and returns an enhanced version of the Scale Axis Transform (SAT) to 
- * the given MAT. The returned SAT is guaranteed to be a subset of the MAT and 
+ * Apply and returns an enhanced version of the Scale Axis Transform (SAT) to
+ * the given MAT. The returned SAT is guaranteed to be a subset of the MAT and
  * preserves topology at any scale.
  * 
  * Typically the MAT contains too many branches caused by minute details on the
  * boundary of the shape. The SAT is a simplification of the MAT that preserves
  * less detail the higher the applied scale factor. The severity at which noise
  * are removed depends on the local scale of the shape.
- * @param mat The Medial Axis Transform (`Mat`) on which to apply the SAT. 
- * @param s The scale factor >= 1 (e.g. 1.3)
+ * 
+ * @param mat the Medial Axis Transform (MAT) on which to apply the SAT
+ * @param s the scale factor >= 1 (e.g. 1.3)
  */
 function toScaleAxis(
-		mat: Mat, 
-		s: number): Mat {
+        mat: Mat,
+        s: number): Mat {
 
-	let timingStart = 0;
-	if (typeof _debug_ !== 'undefined') {
-		timingStart = performance.now();
-	}
+    let timingStart = 0;
+    if (typeof _debug_ !== 'undefined') {
+        timingStart = performance.now();
+    }
 
-	const cpNode = getLargestVertex(clone(mat.cpNode));
-	const culls = getSatCulls(cpNode, s);
+    const cpNode = getLargestVertex(clone(mat.cpNode));
+    const culls = getSatCulls(cpNode, s);
 
-	cull(culls, cpNode);
+    cull(culls, cpNode);
 
-	const sat: Mat = {
+    const sat: Mat = {
         cpNode: cpNode,
         meta: {
             ...mat.meta,
-			cpTrees: createNewCpTree(cpNode)
+            cpTrees: createNewCpTree(cpNode)
         }
     };
 
 
-	addDebugInfo(timingStart);
+    addDebugInfo(timingStart);
 
-	return sat;
+    return sat;
 }
 
 

package/src/utils/bezier-piece-to-bezier.ts

@@ -1,13 +1,13 @@
-import { BezierPiece, fromTo } from "flo-bezier3";
+// import { BezierPiece, fromTo } from "flo-bezier3";
 
 
-function bezierPieceToBezier(
-        piece: BezierPiece) {
+// function bezierPieceToBezier(
+//         piece: BezierPiece) {
 
-    const { ps, ts } = piece;
+//     const { ps, ts } = piece;
 
-    return fromTo(ps, ts[0], ts[1]);
-}
+//     return fromTo(ps, ts[0], ts[1]);
+// }
 
 
-export { bezierPieceToBezier }
+// export { bezierPieceToBezier }

package/node/cp-node/fs/cp-nodes-to-boundary-beziers.d.ts

@@ -1,3 +0,0 @@
-import { CpNode } from "../cp-node.js";
-declare function cpNodesToBoundaryBeziers(cpNodes: CpNode[]): number[][][];
-export { cpNodesToBoundaryBeziers };

package/node/cp-node/fs/cp-nodes-to-boundary-beziers.js

@@ -1,6 +0,0 @@
-import { getBoundaryBeziersToNext } from "./get-boundary-beziers-to-next.js";
-function cpNodesToBoundaryBeziers(cpNodes) {
-    return cpNodes.flatMap(getBoundaryBeziersToNext);
-}
-export { cpNodesToBoundaryBeziers };
-//# sourceMappingURL=cp-nodes-to-boundary-beziers.js.map

package/node/cp-node/fs/cp-nodes-to-boundary-beziers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cp-nodes-to-boundary-beziers.js","sourceRoot":"","sources":["../../../src/cp-node/fs/cp-nodes-to-boundary-beziers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAG7E,SAAS,wBAAwB,CAAC,OAAiB;IAC/C,OAAO,OAAO,CAAC,OAAO,CAAC,wBAAwB,CAAC,CAAA;AACpD,CAAC;AAGD,OAAO,EAAE,wBAAwB,EAAE,CAAA"}

package/src/closest-boundary-point/get-closest-boundary-point-certified.ts

@@ -1,70 +0,0 @@
-// import { getObjClosestTo } from 'flo-vector2d';
-// import { Curve } from '../curve/curve.js';
-// import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-// import { createPos } from '../point-on-shape/create-pos.js';
-// import { BezierPiece  } from '../mat/bezier-piece.js';
-// import { cullBezierPieces1 } from './cull-bezier-pieces.js';
-// import { getPotentialClosestPointsOnCurveCertified } from './get-potential-closest-points-on-curve-certified.js';
-// import { squaredDistanceBetweenDd } from '../find-2-prong/squared-distance-between-dd.js';
-
-
-// /**
-//  * @internal
-//  * Returns the closest boundary point to the given point, limited to the given 
-//  * bezier pieces, including the beziers actually checked after culling.
-//  * @param bezierPieces
-//  * @param x
-//  * @param touchedCurve
-//  * @param t
-//  * @param extreme
-//  */
-// function getClosestBoundaryPointCertified(
-// 		angle: number,
-//         bezierPieces: BezierPiece[], 
-//         x: number[], 
-// 		touchedCurve: Curve, 
-// 		t: number,
-// 		for1Prong: boolean) {
-	
-// 	bezierPieces = cullBezierPieces1(bezierPieces, x);
- 
-// 	let bestDistance = Number.POSITIVE_INFINITY;
-// 	let pos: PointOnShape;
-// 	for (let i=0; i<bezierPieces.length; i++) {
-// 		const bezierPiece = bezierPieces[i];
-
-//         const ps = getPotentialClosestPointsOnCurveCertified(
-//             bezierPiece.curve, 
-//             x, 
-//             bezierPiece.ts, 
-//             touchedCurve, 
-//             t,
-// 			for1Prong,
-// 			angle
-//         );
-
-// 		const p = getObjClosestTo(x, ps, p => p.p)
-
-// 		if (p === undefined) { continue; }
-
-// 		const d = squaredDistanceBetweenDd(p.p, x);
-
-// 		let curve = bezierPiece.curve;
-// 		let t_= p.t;
-
-// 		if (d < bestDistance) {
-// 			if (t_ === 0) {
-// 				t_ = 1;
-// 				curve = bezierPiece.curve.prev;
-// 			}
-			
-// 			pos = createPos(curve, t_, false);
-// 			bestDistance = d;
-// 		}
-// 	}
-
-// 	return pos!;
-// }
-
-
-// export { getClosestBoundaryPointCertified };

package/src/cp-node/fs/cp-nodes-to-boundary-beziers.ts

@@ -1,10 +0,0 @@
-import { CpNode } from "../cp-node.js";
-import { getBoundaryBeziersToNext } from "./get-boundary-beziers-to-next.js";
-
-
-function cpNodesToBoundaryBeziers(cpNodes: CpNode[]) {
-    return cpNodes.flatMap(getBoundaryBeziersToNext)
-}
-
-
-export { cpNodesToBoundaryBeziers }