flo-mat 3.0.0 → 3.0.2

package/src/index.ts

@@ -1,134 +1,53 @@
-import { beziersToSvgPathStr, getPathsFromStr } from 'flo-boolean';	
 
-import { Mat } from './mat/mat.js';
-import { Loop } from 'flo-boolean';
-import { Curve } from './curve/curve.js';
-import {
-	CpNode,
-	matCurveToNextVertex,
-	getChildren,
-	vertexChildren,
-	getAllOnLoop,
-	insertCpNode,
-	getCpNodesOnCircle,
-	isOnSameCircle,
-	isTerminating,
-	isFullyTerminating,
-	getFirstExit,
-	isSharp,
-	getProngCount,
-	getRealProngCount,
-	cpNodeComparator,
-	removeCpNode
-} from './cp-node/cp-node.js';
-import { createCpNode } from './cp-node/create-cp-node.js';
-import { enhanceCpNode } from './cp-node/enhance-cp-node.js';
-import { traverseCp } from './cp-node/traverse-cp.js';
-import { PointOnShape } from './point-on-shape/point-on-shape.js';
-import { createPos } from './point-on-shape/create-pos.js';
-import { Circle } from './geometry/circle.js';
-import { ContactPoint } from './contact-point/contact-point.js';
-import { BezierPiece } from './mat/bezier-piece.js';
-import { findMats } from './find-mat/find-mats.js';
-import { trimMat } from './mat/trim-mat.js';
-import { toScaleAxis } from './sat/to-scale-axis.js';
-import { traverseEdges } from './cp-node/traverse-edges.js';
-import { getBranches } from './mat/get-branches.js';
-import { traverseVertices } from './cp-node/traverse-vertices.js';
-import { Debug, enableDebugForMat } from './debug/debug.js';
-import { drawBranch } from './debug/functions/draw-elem/branch.js';
-import { drawMat } from './debug/functions/draw-elem/mat.js';
-import { IDebugElems } from './debug/debug-elem-types.js';
-import { TDrawElemFunctions } from './debug/functions/draw-elem/draw-elem.js';
-import { ICpNodeForDebugging } from './debug/cp-node-for-debugging.js';
-import { ITiming } from './debug/debug.js';
-import { getClosestBoundaryPointCertified } from './closest-boundary-point/get-closest-boundary-point-certified.js';
-import { getShapeBounds } from './svg/get-shape-bounds.js';
-import { getBoundaryBeziersToNext } from './cp-node/get-boundary-beziers-to-next.js';
-import { getBoundaryBezierPartsToNext } from './cp-node/get-boundary-bezier-parts-to-next.js';
-import { getBoundaryPieceBeziers } from './mat/get-boundary-piece-beziers.js';
-import { simplifyMat } from './mat/simplify-mat.js';
-import { simplifyMatMapOnly } from './mat/simplify-mat-map-only.js';
-import { drawElemFunctions } from './debug/functions/draw-elem/draw-elem.js';
-import { getCurveToNext } from './cp-node/get-curve-to-next.js';
-import { getCurveBetween } from './get-curve/get-curve-between.js';
-import { sweepLine } from './sweep-line/sweep-line.js';
-import { getClosestSquareDistanceToRect } from './geometry/get-closest-square-distance-to-rect.js';
-import { loopFromBeziers } from 'flo-boolean';
-
-
-export { 
-	// Data structures
-	Mat,
-	PointOnShape,
-	// IPointOnShape,
-	Curve,
-	Loop,
-	CpNode,
-	Circle,
-	ContactPoint,
-	BezierPiece,
-
-	// Main functions
-	findMats,
-	toScaleAxis,
-	trimMat,
-	traverseVertices,
-	traverseEdges,
-	getBranches,
-	getBoundaryBeziersToNext,
-	getBoundaryBezierPartsToNext,
-	simplifyMat,
-	simplifyMatMapOnly,
-
-	// CpNode
-	createCpNode,
-	matCurveToNextVertex,
-	getChildren,
-	vertexChildren,
-	getAllOnLoop,
-	insertCpNode,
-	getCpNodesOnCircle,
-	isOnSameCircle,
-	isTerminating,
-	isFullyTerminating,
-	getFirstExit,
-	isSharp,
-	getProngCount,
-	getRealProngCount,
-	cpNodeComparator,
-	removeCpNode,
-	enhanceCpNode,
-	traverseCp,
-
-
-	// SVG functions
-	beziersToSvgPathStr,
-	getPathsFromStr,
-	getShapeBounds, 
-	drawBranch,
-	drawMat,
-
-	// Other functions
-	getClosestBoundaryPointCertified,
-	getCurveToNext, getCurveBetween,
-	createPos,
-
-	// Debug
-	Debug,
-	IDebugElems,
-	TDrawElemFunctions,
-	ICpNodeForDebugging,
-	ITiming,
-
-	getBoundaryPieceBeziers,
-
-	drawElemFunctions,
-
-	sweepLine,
-
-	getClosestSquareDistanceToRect,
-
-	loopFromBeziers,
-	enableDebugForMat
-}
+export { loopFromBeziers, beziersToSvgPathStr, getPathsFromStr } from 'flo-boolean';	
+
+export type { MatMeta } from './mat/mat-meta.js';
+export type { Loop } from 'flo-boolean';	
+export type { Mat } from './mat/mat.js';
+export type { Curve } from './curve/curve.js';
+export type { CpNode  } from './cp-node/cp-node.js';
+export type { PointOnShape } from './point-on-shape/point-on-shape.js';
+export type { Circle } from './geometry/circle.js';
+export type { ContactPoint } from './contact-point/contact-point.js';
+export type { CurvePiece } from './mat/curve-piece.js';
+export type { DrawElemFunctions } from './debug/functions/draw-elem/draw-elem.js';
+export type { ICpNodeForDebugging } from './debug/cp-node-for-debugging.js';
+export type { ITiming } from './debug/debug.js';
+export type { DebugElems } from './debug/debug-elem-types.js';
+export type { Debug } from './debug/debug.js';
+export type { DebugElemKey } from './debug/debug-elem-types.js';
+export type { MatOptions } from './find-mat/mat-options.js';
+
+export { drawBeziersAsSinglePath } from './debug/functions/draw/draw-beziers-as-single-path.js';
+export { floydWarshall } from './floyd-warshall/floyd-warshall.js';
+export { CpNodeFs } from './cp-node/cp-node-fs.js';
+export { isVertexSpecial } from './cp-node/fs/is-vertex-special.js';
+export { createPos } from './point-on-shape/create-pos.js';
+export { findMats } from './find-mat/find-mats.js';
+export { trimMat } from './mat/trim-mat.js';
+export { toScaleAxis } from './sat/to-scale-axis.js';
+export { getBranches } from './mat/get-branches.js';
+export { enableDebugForMat } from './debug/debug.js';
+export { drawBranch } from './debug/functions/draw-elem/draw-branch.js';
+export { drawMat } from './debug/functions/draw-elem/draw-mat.js';
+export { debugElemNames, emptyDebugElems } from './debug/debug-elem-types.js';
+export { getShapeBounds } from './svg/get-shape-bounds.js';
+export { getBoundaryPieceBeziers } from './mat/get-boundary-piece-beziers.js';
+export { simplifyMat } from './mat/simplify-mat.js';
+export { drawElemFs, drawElemFsDetailed } from './debug/functions/draw-elem/draw-elem.js';
+export { sweepLine } from './sweep-line/sweep-line.js';
+export { getClosestSquareDistanceToRect } from './geometry/get-closest-square-distance-to-rect.js';
+export { connectHoleClosers } from './mat/connect-hole-closers.js';
+export { findAndAdd2Prong } from './find-2-prong/find-and-add-2-prong.js';
+export { getBoundaryBeziersToNext } from './cp-node/fs/get-boundary-beziers-to-next.js';
+export { getImpliedBoundaryBezierBetween } from './cp-node/fs/get-implied-boundary-bezier-between.js';
+export { getSatCulls } from './sat/get-sat-culls.js';
+export { getGraph } from './floyd-warshall/get-graph.js';
+export { find2Prong } from './find-2-prong/find-2-prong.js';
+export { createInitialCpTree } from './find-mat/create-initial-cp-tree.js';
+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';

package/src/mat/add-to-cp-tree.ts

@@ -0,0 +1,56 @@
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Loop } from 'flo-boolean';
+import { Circle } from '../geometry/circle.js';
+import { ContactPoint } from '../contact-point/contact-point.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { CpNodeFs } from '../cp-node/cp-node-fs.js';
+import { getCpNodeToLeftOrSame } from './get-cp-node-to-left-or-same.js';
+import { insertCpNode } from '../cp-node/fs/insert-cp-node.js';
+import { joinSpokes } from '../add-n-prong.ts/join-spokes.js';
+
+
+/**
+ * @param circle 
+ * @param orders 
+ * @param cpTrees 
+ * @param poss 
+ * @param neighbors 
+ * 
+ * @internal
+ */
+function addToCpTree(
+        insertIfOrderIsWrong: boolean,
+        isHoleClosing: boolean,
+        circle: Circle, 
+        orders: number[],
+        cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        poss: PointOnShape[],
+        neighbors? : CpNode[]): { anyFailed: boolean, cpNodes: (CpNode | undefined) [] } {
+
+    let anyFailed = false;
+    const cpNodes = poss.map((pos,i) => {
+        const order = orders[i];
+        const cpTree = cpTrees.get(pos.curve.loop)!;
+        const cp: ContactPoint = { pointOnShape: pos, circle, order, order2: 0 };
+
+        const pred = neighbors === undefined
+            ? getCpNodeToLeftOrSame(cpTree, pos, order, 0)
+            : neighbors[i];
+
+        const cpNode = insertCpNode(insertIfOrderIsWrong, isHoleClosing, false, cpTree, cp, pred);
+
+        if (cpNode === undefined) { anyFailed = true; }
+
+        return cpNode;
+    });
+
+    if (!anyFailed) {
+        joinSpokes(circle, cpNodes as CpNode[]);
+    }
+
+    return { anyFailed, cpNodes };
+}
+
+
+export { addToCpTree }

package/src/mat/clone-mat.ts

@@ -0,0 +1,14 @@
+import { clone } from "../cp-node/fs/clone.js";
+import { cloneMeta } from "./clone-meta.js";
+import { Mat } from "./mat.js";
+
+
+function cloneMat(mat: Mat): Mat {
+    return {
+        cpNode: clone(mat.cpNode),
+        meta: cloneMeta(mat.meta)
+    }
+}
+
+
+export { cloneMat }

package/src/mat/clone-meta.ts

@@ -0,0 +1,17 @@
+import { MatMeta } from './mat-meta.js';
+
+
+function cloneMeta(meta: MatMeta): MatMeta {
+    // const {
+    //     boundingHulls, cpTrees, dullCorners,
+    //     loops, looseBoundingBoxes, pointToCpNode, sharpCorners,
+    //     tightBoundingBoxes, salientCulls, satCulls, maxCoordinate,
+    //     squaredDiagonalLength
+    // } = meta;
+
+    // TODO2
+    return { ...meta }
+}
+
+
+export { cloneMeta }

package/src/mat/connect-hole-closers.ts

@@ -0,0 +1,9 @@
+import { Mat } from "./mat.js";
+
+
+function connectHoleClosers(mat: Mat) {
+    return mat;
+}
+
+
+export { connectHoleClosers }

package/src/mat/create-new-cp-tree.ts

@@ -1,6 +1,9 @@
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode, cpNodeComparator, getAllOnLoop } from '../cp-node/cp-node.js';
 import { Loop } from 'flo-boolean';
+import { CpNode } from '../cp-node/cp-node.js';
+import { CpNodeFs } from '../cp-node/cp-node-fs.js';
+
+const { cpNodeComparator, getAllOnLoop } = CpNodeFs;
 
 
 /**

package/src/mat/{bezier-piece.ts → curve-piece.ts}

@@ -5,7 +5,7 @@ import { Curve } from '../curve/curve.js';
  * @internal
  * Represents a part of a bezier within the shape boundary.
  */
-interface BezierPiece {
+interface CurvePiece {
     /** A bezier curve within the shape boundary. */
     curve: Curve;
     /** The start and end t parameter values of the bezier curve. */
@@ -13,4 +13,4 @@ interface BezierPiece {
 }
 
 
-export { BezierPiece }
+export { CurvePiece }

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

@@ -1,6 +1,6 @@
 import { CpNode } from '../cp-node/cp-node.js';
 import { Curve } from '../curve/curve.js';
-import { BezierPiece } from './bezier-piece.js';
+import { CurvePiece } from './curve-piece.js';
 import { isPosQuiteSharpCorner } from '../point-on-shape/is-pos-quite-sharp-corner.js';
 import { compareCps } from '../contact-point/contact-point.js';
 
@@ -9,14 +9,15 @@ import { compareCps } from '../contact-point/contact-point.js';
  * @internal
  * Returns the ordered cubic bezier pieces (i.e a bezier with a t range) 
  * from the given boundary piece.
+ * 
  * @param cpNodes - An ordered pair that represents the start and end points of 
  * the boundary piece
  */
-function getBoundaryPieceBeziers(cpNodes: CpNode[]): BezierPiece[] {
+function getBoundaryPieceBeziers(cpNodes: CpNode[]): CurvePiece[] {
     let cpThis = cpNodes[0]; 
     const cpEnd  = cpNodes[1];
     
-    const bezierPieces: BezierPiece[] = [];
+    const bezierPieces: CurvePiece[] = [];
 
     // As opposed to going around the circle and taking the last exit
     let goStraight = true; 
@@ -33,8 +34,6 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): BezierPiece[] {
         const posNext = cpThis.next.cp.pointOnShape;
 
         if (posNext.curve === posThis.curve && 
-            //PointOnShape.isQuiteSharpCorner(posThis) && 
-            //PointOnShape.isQuiteSharpCorner(posNext)) {
             isPosQuiteSharpCorner(posThis) && 
             isPosQuiteSharpCorner(posNext)) {
 
@@ -50,7 +49,7 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): BezierPiece[] {
                 { curve: posThis.curve, ts: [posThis.t, 1] }
             );
             
-            if (cpThis.cp.pointOnShape.curve.loop === cpThis.next.cp.pointOnShape.curve.loop) {
+            if (posThis.curve.loop === posNext.curve.loop) {
                 addSkippedBeziers(
                         bezierPieces, 
                         posThis.curve, 
@@ -58,7 +57,7 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): BezierPiece[] {
                         posNext.t
                 );
             }
-        }				
+        }
         
         cpThis = cpThis.next;
     } while (cpThis !== cpEnd);
@@ -73,10 +72,10 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): BezierPiece[] {
  * Adds pieces of skipped beziers
  */
 function addSkippedBeziers(
-        bezierPieces : BezierPiece[], 
-        curveStart   : Curve, 
-        curveEnd     : Curve, 
-        t1           : number) {
+        bezierPieces: CurvePiece[], 
+        curveStart: Curve, 
+        curveEnd: Curve, 
+        t1: number) {
 
     let curveThis = curveStart;
     do {

package/src/mat/get-branches.ts

@@ -1,95 +1,45 @@
-import { tangent } from 'flo-bezier3';
-import { cross, toUnitVector } from 'flo-vector2d';
-import { CpNode, getChildren, isFullyTerminating, isTerminating } from '../cp-node/cp-node.js';
-import { getCurveToNext } from '../cp-node/get-curve-to-next.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { getBranch } from '../cp-node/fs/get-branch.js';
+import { getNonTerminatingOnCircle } from '../cp-node/fs/get-non-terminating-on-circle.js';
 
 
-/** @internal */
-const defaultTolerance = 1; // 1 degree
-
-
-/**
- * Traverses all edges (depth first) of the given MAT tree starting at the given 
- * vertex (represented by a [[CpNode]]). Returns the result as an array of
- * smooth branches, where smoothness is total or within a given tolerance.
- * @param cpNode Any [[CpNode]] representing the start vertex.
- * @param tolerance Tolerance given as the degrees difference of the unit 
- * direction vectors at the interface between curves. A tolerance of zero means
- * perfect smoothness is required.
- */
 function getBranches(
-		cpNode: CpNode, 
-		tolerance: number = defaultTolerance): CpNode[][] {
-
-	// Start from a leaf
-	while (!isFullyTerminating(cpNode)) {
-		cpNode = cpNode.next;
-	}
+		cpNode: CpNode): CpNode[][] {
 
 	const branches: CpNode[][] = [];
+	const cpNodeStack: CpNode[] = [cpNode];
+	const takenBranches: Set<CpNode> = new Set();
+	while (cpNodeStack.length > 0) {
+		const cpNode = cpNodeStack.pop()!;
+		const branch = getBranch(cpNode);
 
-	// Since the tree is unrooted we must iterate in all directions from the
-	// given vertex.
-	const cps = [cpNode.prevOnCircle];
-
-	let branchCpNodes: CpNode[] = [];
-	while (cps.length) {
-		const cp = cps.pop()!;
-		branchCpNodes.push(cp);
-
-		let children = getChildren(cp);
-
-		if (isFullyTerminating(cp)) {
-			if (branchCpNodes.length > 1) {
-				branches.push(branchCpNodes);
-			}
-			branchCpNodes = [];
-			continue; 
-		}
-
-		if (children.length === 1) {
-			cps.push(children[0]);
+		if (branch.length === 0) {
 			continue;
 		}
 
-		children = children.filter(cpNode => !isTerminating(cpNode));
-
-		if (children.length === 0) {
-			branches.push(branchCpNodes);
-			branchCpNodes = [];
-			continue;
-		}
+		branches.push(branch);
 
-		if (children.length > 1) {
-			// More than one branch comes together
-			branches.push(branchCpNodes);
-			branchCpNodes = [];
-			cps.push(...children);
-			continue;
-		}
+		const cpNodeS = branch[0];
+		const cpNodeE = branch[branch.length-1].next.prevOnCircle;
 
-		const backPointingTan = toUnitVector(tangent(
-			getCurveToNext(cp.next.prevOnCircle), 
-			0
-		));
-		const forwardPointingTan = toUnitVector(tangent(
-			getCurveToNext(children[0]), 
-			0
-		));
+		takenBranches.add(cpNodeS);
+		takenBranches.add(cpNodeE);
 
-		const cross_ = cross(backPointingTan, forwardPointingTan);
-		const angle = Math.abs(Math.asin( cross_ ) * (180/Math.PI));
+		const _cpNodesS = getNonTerminatingOnCircle(cpNodeS, true);
+		const _cpNodesE = getNonTerminatingOnCircle(cpNodeE, true);
+		const cpNodesS = _cpNodesS.filter(cpNode => !takenBranches.has(cpNode));
+		const cpNodesE = _cpNodesE.filter(cpNode => !takenBranches.has(cpNode));
 
-		if (angle > tolerance) {
-			branches.push(branchCpNodes);
-			branchCpNodes = [];
+		for (const cpNode of cpNodesS) {
+			takenBranches.add(cpNode);
+		}
+		for (const cpNode of cpNodesE) {
+			takenBranches.add(cpNode);
 		}
 
-		cps.push(children[0]);
+		cpNodeStack.push(...cpNodesS, ...cpNodesE);
 	}
 
-	if (branchCpNodes.length) { branches.push(branchCpNodes); }
-
 	return branches;
 }
 

package/src/mat/get-closeby-cp-if-exist.ts

@@ -0,0 +1,75 @@
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { distanceBetween, toUnitVector, fromTo, dot } from 'flo-vector2d';
+import { Loop } from 'flo-boolean';
+import { CpNode } from '../cp-node/cp-node.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { Circle } from '../geometry/circle.js';
+import { getCpNodeToLeftOrSame } from './get-cp-node-to-left-or-same.js';
+import { MatMeta } from './mat-meta.js';
+
+
+/** @internal */
+const DEGREES = 1;
+const ANGLE_THRESHOLD = Math.cos(DEGREES * (Math.PI / 180));
+
+
+/**
+ * @internal
+ * If another `CpNode` is close by (to the given implied (via `pos`, `order` and
+ * `order2`) then return it, else return `undefined`.
+ * 
+ * @param meta
+ * @param pos 
+ * @param circle 
+ * @param order 
+ * @param order2 
+ */
+function getCloseByCpIfExist(
+        meta: MatMeta,
+        pos: PointOnShape,
+        circle: Circle,
+        order: number,
+        order2: number,
+        forProngCount?: number): CpNode | undefined {
+
+    const { cpTrees, maxCoordinate } = meta;
+
+    const DISTANCE_THRESHOLD = maxCoordinate * 2e-14;
+    const DISTANCE_THRESHOLD_2 = DISTANCE_THRESHOLD * 2e-2;
+
+    const cpTree = cpTrees.get(pos.curve.loop)!;
+    const cur = getCpNodeToLeftOrSame(cpTree, pos, order, order2);
+    if (!cur) { return undefined; }
+    const cpNodes = [cur, cur.next];
+
+    const { p, t } = pos;
+    for (const cpNode of cpNodes) {
+        const pos2 = cpNode.cp.pointOnShape;
+        const p2 = pos2.p;
+        const d = distanceBetween(p,p2);
+        if (d > DISTANCE_THRESHOLD) {
+            continue;
+        }
+
+        const v1 = toUnitVector(fromTo(p2, cpNode.cp.circle.center));
+        const v2 = toUnitVector(fromTo(p, circle.center));
+        const cosTheta = dot(v1,v2);
+
+        if (cosTheta > ANGLE_THRESHOLD ||
+            (d < DISTANCE_THRESHOLD_2 && t !== 0 && t !== 1)) {
+
+            if (forProngCount === 3) {
+                // console.log(cosTheta, d);
+                // console.log(t);
+                // console.log(d, DISTANCE_THRESHOLD_2)
+                // console.log(p,p2);
+            }
+            return cpNode;
+        }
+    }
+
+    return undefined;
+}
+
+
+export { getCloseByCpIfExist }

package/src/mat/get-cp-node-to-left-or-same.ts

@@ -0,0 +1,43 @@
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { CpNode } from '../cp-node/cp-node.js';
+
+
+/**
+ * @internal
+ * 
+ * Returns the predecessor `CpNode` in the `CpTree` or the same one if they fall
+ * on top of each other.
+ * 
+ * * returns `undefined` if the tree is still empty
+ * 
+ * @param cpTree 
+ * @param pos 
+ * @param order 
+ * @param order2 
+ */
+function getCpNodeToLeftOrSame(
+        cpTree: LlRbTree<CpNode>,
+        pos: PointOnShape,
+        order: number,
+        order2: number): CpNode | undefined {
+
+    const cp = { pointOnShape: pos, order, order2 };
+    const cps = cpTree.findBounds({ cp } as unknown as CpNode);
+
+    if (cps[0] === undefined && cps[1] === undefined) { 
+        // The tree is still empty
+        return undefined;
+    }
+
+    if (cps[0] === undefined || cps[1] === undefined) { 
+        // Smaller than all -> cptree.min() === cps[1].data OR
+        // Larger  than all -> cptree.max() === cps[0].data
+        return cpTree.max(cpTree.root);
+    }
+
+    return cps[0].datum;
+}
+
+
+export { getCpNodeToLeftOrSame }

package/src/mat/get-edges-as-array.ts

@@ -1,18 +1,18 @@
-import { CpNode } from '../cp-node/cp-node.js';
-import { traverseEdges } from '../cp-node/traverse-edges.js';
+// import { CpNode } from '../cp-node/cp-node.js';
+// import { traverseEdges } from '../cp-node/traverse-edges.js';
 
 
-/** @internal */
-function getEdgesAsArray(cpNode: CpNode) {	
-	const cpNodes: CpNode[] = [];
+// /** @internal */
+// function getEdgesAsArray(cpNode: CpNode) {	
+// 	const cpNodes: CpNode[] = [];
 	
-	traverseEdges(
-		cpNode, 
-		function(cpNode) { cpNodes.push(cpNode) }
-	);
+// 	traverseEdges(
+// 		cpNode, 
+// 		function(cpNode) { cpNodes.push(cpNode) }
+// 	);
 	
-	return cpNodes;
-}
+// 	return cpNodes;
+// }
 
 
-export { getEdgesAsArray };
+// export { getEdgesAsArray };