flo-mat 3.0.6 → 3.0.7

package/src/cp-node/cp-node-fs.ts

@@ -41,23 +41,23 @@ const cpNodeComparator = (a: CpNode, b: CpNode) => compareCps(a.cp, b.cp);
 
 const CpNodeFs = {
 	/**
-	 * Returns the children of this [[CpNode]] when seen as a MAT edge. Only 
+	 * Returns the children of this `CpNode` when seen as a MAT edge. Only 
 	 * children in a 'forward' direction are returned. These include all edges 
-	 * except the 'backward' edge given by [[prevOnCircle]], even terminating
+	 * except the 'backward' edge given by `prevOnCircle`, even terminating
 	 * edges.
 	 */
 	getChildren,
 	/**
-	 * Similar to [[getChildren]] but returns the child nodes of the tree when 
-	 * [[CpNode]] is seen as a MAT vertex point (as opposed to edge). In this 
+	 * Similar to `getChildren` but returns the child nodes of the tree when 
+	 * `CpNode` is seen as a MAT vertex point (as opposed to edge). In this 
 	 * way the dual graph of the tree can easily be traversed - see e.g. 
-	 * [[traverseVertices]]. Generally, however, traversing the edges is 
+	 * `traverseVertices`. Generally, however, traversing the edges is 
 	 * preferred as it returns the entire Medial Axis (by utilizing 
-	 * [[getMatCurveToNext]] on each returned edge).
+	 * `getMatCurveToNext` on each returned edge).
 	 */
 	getVertexForwardChildren,
 	/**
-	 * Returns all [[CpNode]]s on the MAT that this [[CpNode]] is part of 
+	 * Returns all `CpNode`s on the MAT that this `CpNode` is part of 
 	 * starting from the current one and going anti-clockwise around the shape.
 	 */
 	getAllOnLoop,
@@ -65,18 +65,18 @@ const CpNodeFs = {
 	 * Return this (except if exclThis is truthy) and the the other CpNodes 
 	 * around the maximal disk vertex circle in an anti-clockwise order.
 	 * @param exclThis If true the returned array does not include this 
-	 * [[CpNode]].
+	 * `CpNode`.
 	 */
 	getAllOnCircle,
 	/**
-	 * Returns true if the 2 given [[CpNode]]s are on the same maximal disk 
+	 * Returns true if the 2 given `CpNode`s are on the same maximal disk 
 	 * circle.
-	 * @param cpNode1 A [[CpNode]].
-	 * @param cpNode2 Another [[CpNode]]
+	 * @param cpNode1 A `CpNode`.
+	 * @param cpNode2 Another `CpNode`
 	 */
 	isOnSameCircle,
 	/**
-	 * Returns true if this [[CpNode]] is terminating, i.e. implies a leaf MAT 
+	 * Returns true if this `CpNode` is terminating, i.e. implies a leaf MAT 
 	 * vertex.
 	 * 
 	 * This is always the case for sharp corners and maximal disks with
@@ -84,8 +84,8 @@ const CpNodeFs = {
 	 * two contact points stored (sitting 'on top' of each other) for the 
 	 * maximal disk. It can be seen as a limiting case of a two-prong where the
 	 * distance between two of the contact points tend to zero. One point 
-	 * (represented by a [[CpNode]] of course) will be terminating with the 
-	 * other point being its [[next]], whereas the other point will *not* be 
+	 * (represented by a `CpNode` of course) will be terminating with the 
+	 * other point being its `next`, whereas the other point will *not* be 
 	 * terminating and 'points' back into the shape.
 	 */
 	isTerminating,
@@ -95,48 +95,48 @@ const CpNodeFs = {
 	 */
 	isFullyTerminating,
 	/**
-	 * Returns the first [[CpNode]] (from this one by successively applying 
+	 * Returns the first `CpNode` (from this one by successively applying 
 	 * .nextOnCircle) that exits the circle.
 	 */
 	getFirstExit,
 	/**
-	 * Returns true if this [[CpNode]] represents a sharp corner, i.e. the 
+	 * Returns true if this `CpNode` represents a sharp corner, i.e. the 
 	 * limiting case of a two-prong having zero radius. 
 	 * 
-	 * Note that two [[CpNode]]s are stored for each sharp corner, one being
-	 * terminating and one not. See [[isTerminating]] for more details.
+	 * Note that two `CpNode`s are stored for each sharp corner, one being
+	 * terminating and one not. See `isTerminating` for more details.
 	 */
 	isSharp,
 	/**
-	 * Returns true if this [[CpNode]]'s maximal disk has only one contact point
+	 * Returns true if this `CpNode`'s maximal disk has only one contact point
 	 * on the shape boundary (up to planar coordinates). These includes sharp 
 	 * corners.
 	 * 
-	 * Note, however, that two [[CpNode]]s are stored for each such point to
-	 * preserve symmetry - see [[isTerminating]] for more details.
+	 * Note, however, that two `CpNode`s are stored for each such point to
+	 * preserve symmetry - see `isTerminating` for more details.
 	 */
 	isOneProng,
 	/**
 	 * Returns the number of contact points on the maximal disk circle implied
-	 * by this [[CpNode]]. 
+	 * by this `CpNode`. 
 	 * 
 	 * Note, however, that even one-prongs and sharp corners will return 2 (see
-	 * [[isTerminating]] for more details); if this is not desired use 
-	 * [[getRealProngCount]] instead which will return 1 in these cases.
+	 * `isTerminating` for more details); if this is not desired use 
+	 * `getRealProngCount` instead which will return 1 in these cases.
 	 */
 	getProngCount,
 	/**
 	 * Returns the number of contact points (up to planar coordinates) on the 
-	 * maximal disk circle implied by this [[CpNode]]. 
+	 * maximal disk circle implied by this `CpNode`. 
 	 * 
-	 * See also [[getProngCount]].
+	 * See also `getProngCount`.
 	 */
 	getRealProngCount,
 	/**
 	 * Primarily for internal use.
 	 * 
-	 * Compares the order of two [[CpNode]]s. The order is cyclic and depends
-	 * on a [[CpNode]]'s relative position along the shape boundary.
+	 * Compares the order of two `CpNode`s. The order is cyclic and depends
+	 * on a `CpNode`'s relative position along the shape boundary.
 	 */
 	cpNodeComparator,
     /**
@@ -156,26 +156,26 @@ const CpNodeFs = {
     traverseCp,
     /**
      * Traverses all edges (depth first) of the given MAT tree starting at the given 
-     * vertex (represented by a [[CpNode]]).
-     * @param cpNode Any [[CpNode]] representing the start vertex.
+     * vertex (represented by a `CpNode`).
+     * @param cpNode Any `CpNode` representing the start vertex.
      * @param traverseEdgesCallback A callback function for each CpNode representing the vertex at the 
      * start of an edge.
      */
     traverseEdges,
     /**
      * Traverses the MAT tree and calls the given callback function for each vertex
-     * (represented by a [[CpNode]]) on the MAT.
+     * (represented by a `CpNode`) on the MAT.
      * 
-     * It is usually preferable to use [[traverseEdges]] as it allows for the 
+     * It is usually preferable to use `traverseEdges` as it allows for the 
      * traversal of all the smooth curves representing the MAT.
-     * @param cpNode Any [[CpNode]] representing the start vertex.
-     * @param traverseVerticesCallback A callback function taking a single [[CpNode]] as parameter.
+     * @param cpNode Any `CpNode` representing the start vertex.
+     * @param traverseVerticesCallback A callback function taking a single `CpNode` as parameter.
      */
     traverseVertices,
     /**
-     * Returns a deep clone of this [[CpNode]]. Can be used to copy the MAT 
-     * since cloning a single [[CpNode]] necessarily implies cloning all 
-     * [[CpNode]]s on the same MAT tree.
+     * Returns a deep clone of this `CpNode`. Can be used to copy the MAT 
+     * since cloning a single `CpNode` necessarily implies cloning all 
+     * `CpNode`s on the same MAT tree.
      */
     clone,
     /**
@@ -192,13 +192,13 @@ const CpNodeFs = {
     getBoundaryBeziersToNext,
     /**
      * Removes a cpNode from the MAT.
-     * @param cpTree The tree graph holding the [[CpNodes]] of the MAT.
-     * @param cpNode The [[CpNode]] to remove.
+     * @param cpTree The tree graph holding the `CpNodes` of the MAT.
+     * @param cpNode The `CpNode` to remove.
      */
     removeVertex,
 	/**
-	 * Returns the bezier curve from the maximal disk of the given [[CpNode]] to the 
-	 * next [[CpNode]]'s maximal disk and thus directly represents a piece of the 
+	 * Returns the bezier curve from the maximal disk of the given `CpNode` to the 
+	 * next `CpNode`'s maximal disk and thus directly represents a piece of the 
 	 * medial axis.
 	 * @param cpNode 
 	 */
@@ -208,8 +208,8 @@ const CpNodeFs = {
 	getBranchBeziers,
 	getSalience,
 	/**
-	 * Returns the bezier curve from the maximal disk of one [[CpNode]] to another
-	 * [[CpNode]]'s maximal disk.
+	 * Returns the bezier curve from the maximal disk of one `CpNode` to another
+	 * `CpNode`'s maximal disk.
 	 * @param cpNodeFrom 
 	 * @param cpNodeTo 
 	 */

package/src/cp-node/cp-node.ts

@@ -7,66 +7,66 @@ import { ContactPoint } from '../contact-point/contact-point.js';
  * Since the MAT is a full representation of the shape boundary an instance of
  * this class contains both the information of a boundary point and a medial 
  * axis point (and edge to the next point(s)). It also contains edges to other 
- * [[CpNode]]s which allows for traversal of the MAT and thus implictly 
+ * `CpNode`s which allows for traversal of the MAT and thus implictly 
  * represents the entire MAT.
  * 
  * To get the maximal disk circle (of which the center is on the medial axis)
- * use [[cp]].circle.
+ * use `cp.circle`.
  * 
- * To get the boundary point, use [[cp]].pointOnShape.
+ * To get the boundary point, use `cp.pointOnShape`.
  * 
- * The edge [[next]] (resp. [[prev]]) allows one to move anti-clockwise (resp.
- * clockwise) on the shape boundary to the next [[CpNode]]. This also imposes a 
+ * The edge `next` (resp. `prev`) allows one to move anti-clockwise (resp.
+ * clockwise) on the shape boundary to the next `CpNode`. This also imposes a 
  * direction of traversal of the MAT edges and vertices. 
  * 
- * The edge [[nextOnCircle]] (resp. [[prevOnCircle]]) allows one to go 
+ * The edge `nextOnCircle` (resp. `prevOnCircle`) allows one to go 
  * anti-clockwise (resp. clockwise) around the maximal disks implied by
  * the CpNode to the next maximal disk contact point. This is equivalent to 
  * following other branches on the MAT.
  * 
- * Call [[getMatCurveBetween]](cpNodeFrom, cpNodeTo) or getMatCurveToNext(cpNode) 
- * (replacing the older CpNode.[[matCurveToNextVertex]]) to get a bezier curve 
- * from the maximal disk of this [[CpNode]] to the next [[CpNode]]'s 
+ * Call `getMatCurveBetween(cpNodeFrom, cpNodeTo)` or `getMatCurveToNext(cpNode)` 
+ * (replacing the older CpNode.`matCurveToNextVertex`) to get a bezier curve 
+ * from the maximal disk of this `CpNode` to the next `CpNode`'s 
  * maximal disk and thus directly representing a piece of the medial axis.
  * 
- * The function, [[getChildren]], returns the children of this [[CpNode]] when
+ * The function, `getChildren`, returns the children of this `CpNode` when
  * seen as a MAT edge. Only children in a 'forward' direction are returned. These
- * include all edges except the 'backward' edge given by [[prevOnCircle]]. For
- * [[CpNode]]s having a maximal disk with 2 contact points (a 2-prong, the usual 
- * case) the children will be the single edge [[next]]. For a 3-prong this will
- * be the edges [[next]] and [[nextOnCircle]], etc. [[getChildren]] allows one to
- * easily traverse the MAT tree - see e.g. the implementation of [[traverseEdges]].
+ * include all edges except the 'backward' edge given by `prevOnCircle`. For
+ * `CpNode`s having a maximal disk with 2 contact points (a 2-prong, the usual 
+ * case) the children will be the single edge `next`. For a 3-prong this will
+ * be the edges `next` and `nextOnCircle`, etc. `getChildren` allows one to
+ * easily traverse the MAT tree - see e.g. the implementation of `traverseEdges`.
  * 
- * The getter, [[getVertexForwardChildren]], is similar to [[getChildren]] but returns the 
- * child nodes of the tree when [[CpNode]] is seen as a MAT vertex point (as 
+ * The getter, `getVertexForwardChildren`, is similar to `getChildren` but returns the 
+ * child nodes of the tree when `CpNode` is seen as a MAT vertex point (as 
  * opposed to edge). In this way the dual graph of the tree can easily be 
- * traversed - see e.g. [[traverseVertices]]. Generally, however, traversing the 
+ * traversed - see e.g. `traverseVertices`. Generally, however, traversing the 
  * edges is preferred as it returns the entire Medial Axis (by utilizing 
- * [[getMatCurveToNext]] on each returned edge).
+ * `getMatCurveToNext` on each returned edge).
  * 
  * It may be worth mentioning that by traversing from the CpNode by following
- * [[next]] repeatedly until one is back at the same CpNode allows one
+ * `next` repeatedly until one is back at the same CpNode allows one
  * to 'go around' the shape boundary and at the same time traverse the MAT twice 
  * in opposite directions.
  */
 interface CpNode {
-	/** The shape boundary contact point, i.e. a [[CpNode]] without its edges. */
+	/** The shape boundary contact point, i.e. a `CpNode` without its edges. */
 	cp: ContactPoint;
-	/** If true, this [[CpNode]] belongs to a hole-closing maximal disk. */
+	/** If true, this `CpNode` belongs to a hole-closing maximal disk. */
 	isHoleClosing: boolean;
 	/** true if this cpNode is at a shape boundary intersection point, false otherwise */
 	isIntersection: boolean;
-	/** The previous (going clockwise around the boundary) contact point ([[CpNode]]).*/
+	/** The previous (going clockwise around the boundary) contact point (`CpNode`).*/
 	prev: CpNode;
-	/** The next (going anti-clockwise around the boundary) contact point ([[CpNode]]). */
+	/** The next (going anti-clockwise around the boundary) contact point (`CpNode`). */
 	next: CpNode;
 	/**
-	 * The previous [[CpNode]] (going clockwise around the inscribed circle
+	 * The previous `CpNode` (going clockwise around the inscribed circle
 	 * defined by the maximal disk).
 	 */
 	prevOnCircle: CpNode;
 	/**
-	 * The next [[CpNode]] (going anti-clockwise around 
+	 * The next `CpNode` (going anti-clockwise around 
 	 * the inscribed circle defined by the maximal disk).
 	 */
 	nextOnCircle: CpNode;
@@ -80,19 +80,7 @@ interface CpNode {
 	holeCloserPrev?: CpNode | undefined;
 
 	/** Only used in export */
-	id?: number;
-
-	/** Only used in export */
-	children?: number[];
-
-	/** Only used in export */
-	isRoot?: boolean;
-
-	/** Only used in export */
-	parentId?: number;
-
-	/** Only used in export */
-	childId?: number;
+	id: number;
 }
 
 

package/src/cp-node/fs/clone.ts

@@ -17,9 +17,9 @@ type CpNodeWithoutEdges =
 
 
 /**
- * Returns a deep clone of this [[CpNode]]. Can be used to copy the MAT 
- * since cloning a single [[CpNode]] necessarily implies cloning all 
- * [[CpNode]]s on the same MAT tree.
+ * Returns a deep clone of this `CpNode`. Can be used to copy the MAT 
+ * since cloning a single `CpNode` necessarily implies cloning all 
+ * `CpNode`s on the same MAT tree.
  */
 function clone(cpNode: CpNode): CpNode {
     // Don't change this function to be recursive, the call stack may 

package/src/cp-node/fs/enhance-cp-node.ts

@@ -1,6 +1,5 @@
 import { CpNode } from "../cp-node.js";
 import { getCpNodeOrdering } from './get-cp-node-ordering.js';
-import { CpNodeFs } from '../cp-node-fs.js';
 import { getProngCount } from './get-prong-count.js';
 import { getRealProngCount } from "./get-real-prong-count.js";
 import { isFullyTerminating } from "./is-fully-terminating.js";

package/src/cp-node/fs/get-all-between.ts

@@ -2,42 +2,45 @@ import { CpNode } from "../cp-node.js";
 
 
 /**
- * Returns all `CpNode`s between the two given ones (exclisive the last one).
+ * Returns all `CpNode`s between the two given ones (excluding the last one).
  * 
  * * If the second `CpNode` is never encountered all on the loop will be
  * returned.
  * 
- * @param cpNodeS 
- * @param cpNodeE 
+ * @param cpNodeS start `CpNode`
+ * @param cpNodeE end `CpNode`
  * @param inclAllIfEqual if `true` and first and last `CpNode`s are equal then
  * include all `CpNode`s around the loop, otherwise include none.
  */
 function getAllBetween(
-		cpNodeS: CpNode,
-		cpNodeE: CpNode,
-		inclAllIfEqual = true) {
-
-	if (!inclAllIfEqual && cpNodeS === cpNodeE) {
-		return { cpNodes: [], hasHoleCloser: false }
-	}
-
-	const cpStart = cpNodeS;
-	const cpNodes: CpNode[] = [cpStart];
-
-	let cpNode_ = cpNodeS.next;
-	let hasHoleCloser = cpStart.isHoleClosing;
-
-	while (cpNode_ !== cpNodeE &&
-		   cpNode_ !== cpStart) {
-
-		if (cpNode_.isHoleClosing) {
-			hasHoleCloser = true;
-		}
-		cpNodes.push(cpNode_);
-		cpNode_ = cpNode_.next;
-	}
-
-	return { cpNodes, hasHoleCloser };
+        cpNodeS: CpNode,
+        cpNodeE: CpNode,
+        inclAllIfEqual = true): {
+            cpNodes: CpNode[],
+            hasHoleCloser: boolean
+        } {
+
+    if (!inclAllIfEqual && cpNodeS === cpNodeE) {
+        return { cpNodes: [], hasHoleCloser: false }
+    }
+
+    const cpStart = cpNodeS;
+    const cpNodes: CpNode[] = [cpStart];
+
+    let cpNode_ = cpNodeS.next;
+    let hasHoleCloser = cpStart.isHoleClosing;
+
+    while (cpNode_ !== cpNodeE &&
+           cpNode_ !== cpStart) {
+
+        if (cpNode_.isHoleClosing) {
+            hasHoleCloser = true;
+        }
+        cpNodes.push(cpNode_);
+        cpNode_ = cpNode_.next;
+    }
+
+    return { cpNodes, hasHoleCloser };
 }
 
 

package/src/cp-node/fs/get-all-on-circle.ts

@@ -1,20 +1,25 @@
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
 
 
+/**
+ * Returns all the `CpNode`s on the same circle.
+ * 
+ * @param cpNode 
+ * @param exclThis 
+ */
 function getAllOnCircle(
         cpNode: CpNode,
         exclThis = false) {
 
     const startCpNode = cpNode;
-    let cpNode_ = startCpNode;
 
-    const cpNodes: CpNode[] = [];
-    do {
-        if (!(exclThis && cpNode_ === startCpNode)) {
-            cpNodes.push(cpNode_);
-        }
+    const cpNodes: CpNode[] = exclThis ? [] : [cpNode];
+
+    let cpNode_ = cpNode.nextOnCircle;
+    while (cpNode_ !== startCpNode) {
+        cpNodes.push(cpNode_);
         cpNode_ = cpNode_.nextOnCircle;
-    } while (cpNode_ !== startCpNode)
+    }
 
     return cpNodes;
 }

package/src/cp-node/fs/get-all-on-loop.ts

@@ -1,17 +1,19 @@
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
 
 
-function getAllOnLoop(cpNode: CpNode) {
-	const cpStart = cpNode;
-	const cpNodes: CpNode[] = [cpStart];
-	let cpNode_ = cpNode.next;
+function getAllOnLoop(
+		cpNode: CpNode) {
 
-	while (cpNode_ !== cpStart) {
-		cpNodes.push(cpNode_);
-		cpNode_ = cpNode_.next;
-	}
+    const cpStart = cpNode;
+    const cpNodes: CpNode[] = [cpStart];
+    let cpNode_ = cpNode.next;
 
-	return cpNodes;
+    while (cpNode_ !== cpStart) {
+        cpNodes.push(cpNode_);
+        cpNode_ = cpNode_.next;
+    }
+
+    return cpNodes;
 }
 
 

package/src/cp-node/fs/get-boundary-bezier-parts-to-next.ts

@@ -1,9 +1,20 @@
-import { BezierPiece } from 'flo-bezier3';
-import { CpNode } from '../cp-node.js';
-import { Curve  } from '../../curve/curve.js';
+import type { BezierPiece } from 'flo-bezier3';
+import type { CpNode } from '../cp-node.js';
+import type { Curve  } from '../../curve/curve.js';
 
 
-function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[] {
+/**
+ * Returns the boundary beziers pieces between this `CpNode` and the next
+ * one.
+ * 
+ * * returns `undefined` if the next `CpNode` is on a different loop,
+ * as this is a hole-closer and there are no boundary beziers between them.
+ * 
+ * @param cpNode 
+ */
+function getBoundaryBezierPartsToNext(
+        cpNode: CpNode): BezierPiece[] | undefined {
+
     const cpThis = cpNode; 
     const cpNext = cpNode.next;
 
@@ -16,29 +27,35 @@ function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[] {
     if (curveThis.loop !== curveNext.loop) {
         // It is a hole-closer going over to the other loop - a kind of terminal
         // CpNode.
-        return undefined!;
+        return undefined;
     }
     
-    const bezierParts: BezierPiece[] = [];
+    const bezierPieces: BezierPiece[] = [];
 
     if (curveNext === curveThis) {
-        bezierParts.push(
-            { ps: posThis.curve.ps, ts: [posThis.t, posNext.t] }
+        bezierPieces.push(
+            {
+                ps: posThis.curve.ps,
+                ts: [posThis.t, posNext.t]
+            }
         );
     } else {
-        bezierParts.push(
-            { ps: posThis.curve.ps, ts: [posThis.t, 1] }
+        bezierPieces.push(
+            {
+                ps: posThis.curve.ps,
+                ts: [posThis.t, 1]
+            }
         );
         
         addSkippedBeziers(
-                bezierParts,
-                posThis.curve, 
-                posNext.curve,
-                posNext.t
+            bezierPieces,
+            posThis.curve,
+            posNext.curve,
+            posNext.t
         );
-    }				
-        
-    return bezierParts;
+    }
+
+    return bezierPieces;
 }
 
 
@@ -47,10 +64,10 @@ function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[] {
  * Adds pieces of skipped beziers.
  */
 function addSkippedBeziers(
-        bezierParts: { ps: number[][]; ts: number[] }[], 
-        curveStart : Curve, 
-        curveEnd   : Curve, 
-        t1         : number) {
+        bezierPieces: BezierPiece[],
+        curveStart: Curve,
+        curveEnd: Curve,
+        t1: number) {
 
     let curveThis = curveStart;
     do {
@@ -59,7 +76,7 @@ function addSkippedBeziers(
             ? { ps: curveThis.ps, ts: [0, t1] }
             : { ps: curveThis.ps, ts: [0, 1] }
 
-        bezierParts.push(bezierPart);
+        bezierPieces.push(bezierPart);
     } while (curveThis !== curveEnd);
 }
 

package/src/cp-node/fs/get-boundary-beziers-between.ts

@@ -1,4 +1,5 @@
-import { CpNode } from "../cp-node.js";
+import type { BezierPiece } from "flo-bezier3";
+import type { CpNode } from "../cp-node.js";
 import { cpNodesToBoundaryBeziers } from "./cp-nodes-to-boundary-beziers.js";
 import { getAllBetween } from "./get-all-between.js";
 
@@ -17,7 +18,10 @@ import { getAllBetween } from "./get-all-between.js";
 function getBoundaryBeziersBetween(
         cpNode1: CpNode,
         cpNode2: CpNode,
-        inclAllIfEqual = true) {
+        inclAllIfEqual = true): {
+            pss: number[][][],
+            hasHoleCloser: boolean
+        } {
 
     const allBetween = getAllBetween(cpNode1,cpNode2,inclAllIfEqual);
 

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

@@ -3,7 +3,9 @@ import { CpNode } from '../cp-node.js';
 import { Curve  } from '../../curve/curve.js';
 
 
-function getBoundaryBeziersToNext(cpNode: CpNode): number[][][] {
+function getBoundaryBeziersToNext(
+        cpNode: CpNode): number[][][] {
+
     const cpThis = cpNode; 
     const cpNext = cpNode.next;
 
@@ -19,7 +21,7 @@ function getBoundaryBeziersToNext(cpNode: CpNode): number[][][] {
         // return undefined!;
         return [];
     }
-    
+
     const beziers = [];
 
     if (curveNext === curveThis) {
@@ -37,8 +39,8 @@ function getBoundaryBeziersToNext(cpNode: CpNode): number[][][] {
                 posNext.curve,
                 posNext.t
         );
-    }				
-        
+    }
+
     return beziers;
 }
 

package/src/cp-node/fs/insert-cp-node.ts

@@ -10,7 +10,8 @@ function insertCpNode(
         isIntersection: boolean,
         cpTree: LlRbTree<CpNode>,
         cp: ContactPoint, 
-        _prev: CpNode | undefined) {
+        _prev: CpNode | undefined,
+        lastInsertId: { id: number }): CpNode | undefined {
 
     if (_prev !== undefined &&
         !isOrderCorrect(cpTree, cp, _prev.next)) {
@@ -21,7 +22,17 @@ function insertCpNode(
         }
     }
 
-    const cpNode = { cp, isHoleClosing, isIntersection } as CpNode;
+    const cpNode: CpNode = {
+        cp,
+        isHoleClosing,
+        isIntersection,
+        id: lastInsertId.id,
+        next: undefined!,
+        prev: undefined!,
+        nextOnCircle: undefined!,
+        prevOnCircle: undefined!
+    };
+    lastInsertId.id++;
 
     const prev = _prev === undefined ? cpNode : _prev;
     const next = _prev === undefined ? cpNode : prev.next;

package/src/cp-node/fs/is-fully-terminating.ts

@@ -3,6 +3,13 @@ import { getAllOnCircle } from "./get-all-on-circle.js";
 import { isTerminating } from "./is-terminating.js";
 
 
+/**
+ * Returns `true` if this `CpNode` is fully terminating, meaning that all
+ * `CpNode`s (except `CpNode.prevOnCircle`) on the same circle are terminating,
+ * `false` otherwise.
+ * 
+ * @param cpNode 
+ */
 function isFullyTerminating(cpNode: CpNode) {
 	const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);