flo-mat 2.0.2 → 2.0.4

package/node/debug/three-prong-for-debugging.d.ts

@@ -1,31 +1,31 @@
-import { CpNode } from '../cp-node.js';
-import { IPointOnShape } from '../point-on-shape.js';
-import { Circle } from '../circle.js';
-import { Generated } from './debug.js';
-/**
- * @hidden
- * Used for debugging only. A three-prong is a maximally inscribed circle that
- * touches the shape boundary (tangentially) at 3 points.
- */
-interface ThreeProngForDebugging {
-    generated: Generated;
-    /** The best fit circle found for the 3-prong. */
-    circle: Circle;
-    /** The best fit 3 points found for the 3-prong. */
-    poss: IPointOnShape[];
-    /** The 3 boundary pieces on which the three prong points were found. */
-    cp3ss: CpNode[][];
-    /** The boundary pieces that were used to search the three prong on. */
-    cpss: CpNode[][];
-    bestIndx: number;
-    /** An array of 3-prongs, each of which may be a best fit 3-prong. */
-    candidateThreeProngs: {
-        circle: Circle;
-        ps: IPointOnShape[];
-    }[];
-    visitedCps: CpNode[];
-    boundaries: number[][][][];
-    traces: number[][][];
-}
-declare function createEmptyThreeProngForDebugging(): ThreeProngForDebugging;
-export { ThreeProngForDebugging, createEmptyThreeProngForDebugging };
+import { CpNode } from '../cp-node.js';
+import { IPointOnShape } from '../point-on-shape.js';
+import { Circle } from '../circle.js';
+import { Generated } from './debug.js';
+/**
+ * @hidden
+ * Used for debugging only. A three-prong is a maximally inscribed circle that
+ * touches the shape boundary (tangentially) at 3 points.
+ */
+interface ThreeProngForDebugging {
+    generated: Generated;
+    /** The best fit circle found for the 3-prong. */
+    circle: Circle;
+    /** The best fit 3 points found for the 3-prong. */
+    poss: IPointOnShape[];
+    /** The 3 boundary pieces on which the three prong points were found. */
+    cp3ss: CpNode[][];
+    /** The boundary pieces that were used to search the three prong on. */
+    cpss: CpNode[][];
+    bestIndx: number;
+    /** An array of 3-prongs, each of which may be a best fit 3-prong. */
+    candidateThreeProngs: {
+        circle: Circle;
+        ps: IPointOnShape[];
+    }[];
+    visitedCps: CpNode[];
+    boundaries: number[][][][];
+    traces: number[][][];
+}
+declare function createEmptyThreeProngForDebugging(): ThreeProngForDebugging;
+export { ThreeProngForDebugging, createEmptyThreeProngForDebugging };

package/node/debug/three-prong-for-debugging.js

@@ -1,21 +1,21 @@
-import { posToHumanString } from '../point-on-shape.js';
-function createEmptyThreeProngForDebugging() {
-    return {
-        generated: undefined,
-        circle: undefined,
-        poss: undefined,
-        cp3ss: undefined,
-        cpss: undefined,
-        bestIndx: undefined,
-        candidateThreeProngs: undefined,
-        visitedCps: undefined,
-        boundaries: undefined,
-        traces: undefined,
-    };
-}
-function cpsSimple(threeProngForDebugging) {
-    return threeProngForDebugging.cpss.map(δ => [posToHumanString(δ[0].cp.pointOnShape),
-        posToHumanString(δ[1].cp.pointOnShape)]);
-}
-export { createEmptyThreeProngForDebugging };
+import { posToHumanString } from '../point-on-shape.js';
+function createEmptyThreeProngForDebugging() {
+    return {
+        generated: undefined,
+        circle: undefined,
+        poss: undefined,
+        cp3ss: undefined,
+        cpss: undefined,
+        bestIndx: undefined,
+        candidateThreeProngs: undefined,
+        visitedCps: undefined,
+        boundaries: undefined,
+        traces: undefined,
+    };
+}
+function cpsSimple(threeProngForDebugging) {
+    return threeProngForDebugging.cpss.map(δ => [posToHumanString(δ[0].cp.pointOnShape),
+        posToHumanString(δ[1].cp.pointOnShape)]);
+}
+export { createEmptyThreeProngForDebugging };
 //# sourceMappingURL=three-prong-for-debugging.js.map

package/node/debug/two-prong-for-debugging.d.ts

@@ -1,26 +1,26 @@
-import { CpNode } from '../cp-node.js';
-import { IPointOnShape } from '../point-on-shape.js';
-import { Circle } from '../circle.js';
-import { BezierPiece } from '../mat/bezier-piece.js';
-import { Generated } from './debug.js';
-/** @hidden */
-interface TwoProngForDebugging {
-    generated: Generated;
-    bezierPieces: BezierPiece[];
-    pos: IPointOnShape;
-    δ: CpNode[];
-    z: number[];
-    circle: Circle;
-    xs: {
-        x: number[];
-        y: IPointOnShape;
-        z: IPointOnShape;
-        t: number;
-    }[];
-    failed: boolean;
-    holeClosing: boolean;
-    notAdded: boolean;
-    deleted: boolean;
-    cpNode: CpNode;
-}
-export { TwoProngForDebugging };
+import { CpNode } from '../cp-node.js';
+import { IPointOnShape } from '../point-on-shape.js';
+import { Circle } from '../circle.js';
+import { BezierPiece } from '../mat/bezier-piece.js';
+import { Generated } from './debug.js';
+/** @hidden */
+interface TwoProngForDebugging {
+    generated: Generated;
+    bezierPieces: BezierPiece[];
+    pos: IPointOnShape;
+    δ: CpNode[];
+    z: number[];
+    circle: Circle;
+    xs: {
+        x: number[];
+        y: IPointOnShape;
+        z: IPointOnShape;
+        t: number;
+    }[];
+    failed: boolean;
+    holeClosing: boolean;
+    notAdded: boolean;
+    deleted: boolean;
+    cpNode: CpNode;
+}
+export { TwoProngForDebugging };

package/node/debug/two-prong-for-debugging.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=two-prong-for-debugging.js.map

package/node/find-mats.d.ts

@@ -1,26 +1,26 @@
-import { Mat } from './mat.js';
-/**
- * Finds and returns the Medial Axis Transforms (MATs) from the given array of
- * bezier loops representing shape boundaries.
- *
- * @param bezierLoops An array of (possibly intersecting) loops with each loop
- * representing one or more piecewise smooth closed curves (i.e. shapes). Each
- * loop consists of an array of beziers represented by an array of control
- * points with 2,3 or 4 elements corresponding to linear, quadratic and cubic
- * beziers respectively. Each point is a two-element array (ordered pair), the
- * first of which is the x-coordinate and the second the y-coordinate.
- *
- * @param maxCurviness The maximum value the 'curviness' of a curve can have
- * before an additional MAT point is inserted in between. Defaults to 0.4.
- * (Curviness is measured as the total angle in radians between the consecutive
- * vectors formed by the ordered control points of th bezier curve). The value
- * is clipped in the range `[0.05,3]`.
- * @param maxLength The maximum length a curve can have before an additional MAT
- * point is inserted. This value is scaled to a reference 1024 x 1024
- * grid (e.g. if the shape fits in a 512 x 512 axis-aligned box the value will be
- * halved, e.g. from 10 to 5). Together with maxCurviness it represents a
- * tolerance for the accuracy of the MAT. Defaults to 4. The value is clipped
- * in [1,100].
- */
-declare function findMats(bezierLoops: number[][][][], maxCurviness?: number, maxLength?: number): Mat[];
-export { findMats };
+import { Mat } from './mat.js';
+/**
+ * Finds and returns the Medial Axis Transforms (MATs) from the given array of
+ * bezier loops representing shape boundaries.
+ *
+ * @param bezierLoops An array of (possibly intersecting) loops with each loop
+ * representing one or more piecewise smooth closed curves (i.e. shapes). Each
+ * loop consists of an array of beziers represented by an array of control
+ * points with 2,3 or 4 elements corresponding to linear, quadratic and cubic
+ * beziers respectively. Each point is a two-element array (ordered pair), the
+ * first of which is the x-coordinate and the second the y-coordinate.
+ *
+ * @param maxCurviness The maximum value the 'curviness' of a curve can have
+ * before an additional MAT point is inserted in between. Defaults to 0.4.
+ * (Curviness is measured as the total angle in radians between the consecutive
+ * vectors formed by the ordered control points of th bezier curve). The value
+ * is clipped in the range `[0.05,3]`.
+ * @param maxLength The maximum length a curve can have before an additional MAT
+ * point is inserted. This value is scaled to a reference 1024 x 1024
+ * grid (e.g. if the shape fits in a 512 x 512 axis-aligned box the value will be
+ * halved, e.g. from 10 to 5). Together with maxCurviness it represents a
+ * tolerance for the accuracy of the MAT. Defaults to 4. The value is clipped
+ * in [1,100].
+ */
+declare function findMats(bezierLoops: number[][][][], maxCurviness?: number, maxLength?: number): Mat[];
+export { findMats };

package/node/find-mats.js

@@ -1,123 +1,123 @@
-import { simplifyPaths } from 'flo-boolean';
-import { findAndAddAll3Prongs } from './mat/find-mat/find-and-add-3-prongs.js';
-import { createInitialCpGraph } from './mat/find-mat/create-initial-cp-graph.js';
-import { addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './mat/find-mat/add-debug-info.js';
-import { getPotential2Prongs } from './mat/find-mat/get-potential-2-prongs.js';
-import { getSharpCorners } from './mat/find-mat/get-sharp-corners.js';
-import { findAndAdd2ProngsOnAllPaths } from './mat/find-mat/find-and-add-2-prongs-on-all-paths.js';
-import { getInterestingPointsOnLoop } from './mat/find-mat/create-get-interesting-points-on-loop.js';
-import { findAndAddHoleClosing2Prongs } from './mat/find-mat/find-and-add-hole-closing-2-prongs.js';
-import { getLoopsMetrics } from './loop/get-max-coordinate.js';
-/**
- * Finds and returns the Medial Axis Transforms (MATs) from the given array of
- * bezier loops representing shape boundaries.
- *
- * @param bezierLoops An array of (possibly intersecting) loops with each loop
- * representing one or more piecewise smooth closed curves (i.e. shapes). Each
- * loop consists of an array of beziers represented by an array of control
- * points with 2,3 or 4 elements corresponding to linear, quadratic and cubic
- * beziers respectively. Each point is a two-element array (ordered pair), the
- * first of which is the x-coordinate and the second the y-coordinate.
- *
- * @param maxCurviness The maximum value the 'curviness' of a curve can have
- * before an additional MAT point is inserted in between. Defaults to 0.4.
- * (Curviness is measured as the total angle in radians between the consecutive
- * vectors formed by the ordered control points of th bezier curve). The value
- * is clipped in the range `[0.05,3]`.
- * @param maxLength The maximum length a curve can have before an additional MAT
- * point is inserted. This value is scaled to a reference 1024 x 1024
- * grid (e.g. if the shape fits in a 512 x 512 axis-aligned box the value will be
- * halved, e.g. from 10 to 5). Together with maxCurviness it represents a
- * tolerance for the accuracy of the MAT. Defaults to 4. The value is clipped
- * in [1,100].
- */
-function findMats(bezierLoops, maxCurviness = 0.4, maxLength = 4) {
-    // if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
-    let maxCoordinate;
-    let minBezLength;
-    ({ maxCurviness, maxLength, maxCoordinate, minBezLength } =
-        getSizeParams(bezierLoops, maxCurviness, maxLength));
-    const loopss = simplifyPaths(bezierLoops, maxCoordinate);
-    const mats = [];
-    for (const loops of loopss) {
-        const mat = findMat(loops, minBezLength, maxCurviness, maxLength, maxCoordinate);
-        if (mat) {
-            mats.push(mat);
-        }
-    }
-    return mats;
-}
-function getSizeParams(bezierLoops, maxCurviness, maxLength) {
-    // Gather some shape metrics
-    const { maxCoordinate, maxRadius } = getLoopsMetrics(bezierLoops);
-    const expMax = Math.ceil(Math.log2(maxCoordinate));
-    const minBezLengthSigBits = 14;
-    /**
-     * If a curve is shorter than this value then no points on it will be
-     * selected for the purpose of finding the MAT.
-     */
-    const minBezLength = 2 ** expMax * 2 ** (-minBezLengthSigBits);
-    // Limit the tolerance to a reasonable level
-    if (maxCurviness < 0.05) {
-        maxCurviness = 0.05;
-    }
-    if (maxCurviness > 3) {
-        maxCurviness = 3;
-    }
-    // Limit the tolerance to a reasonable level
-    if (maxLength < 0.1) {
-        maxLength = 0.1;
-    }
-    if (maxLength > 100) {
-        maxLength = 100;
-    }
-    // Adjust length tolerance according to a reference max coordinate
-    const expMaxRadius = Math.ceil(Math.log2(maxRadius));
-    const maxLengthSigBits = 10; // 1024 x 1024
-    maxLength = maxLength * (2 ** expMaxRadius * 2 ** (-maxLengthSigBits));
-    return { maxCurviness, maxLength, maxCoordinate, minBezLength };
-}
-/**
- * @hidden
- * Find the MAT of the given loops.
- * @param loops The loops (that as a precondition must be ordered from highest
- * (i.e. smallest y-value) topmost point loops to lowest)
- */
-function findMat(loops, minBezLength, maxCurviness, maxLength, maxCoordinate) {
-    addDebugInfo1(loops);
-    // Gets interesting points on the shape, i.e. those that makes sense to use 
-    // for the 2-prong procedure.
-    const pointsPerLoop = loops.map(getInterestingPointsOnLoop(minBezLength, maxCurviness, maxLength));
-    const for2ProngsPerLoop = getPotential2Prongs(pointsPerLoop);
-    const sharpCornersPerLoop = getSharpCorners(pointsPerLoop);
-    const cpTrees = new Map();
-    let cpNode = createInitialCpGraph(loops, cpTrees, sharpCornersPerLoop);
-    findAndAddHoleClosing2Prongs(loops, cpTrees, maxCoordinate);
-    if (typeof _debug_ !== 'undefined') {
-        if (_debug_.directives.stopAfterHoleClosers) {
-            return undefined;
-        }
-    }
-    addDebugInfo2();
-    cpNode = findAndAdd2ProngsOnAllPaths(loops, cpTrees, for2ProngsPerLoop, maxCoordinate);
-    addDebugInfo3();
-    if (typeof _debug_ !== 'undefined') {
-        if (_debug_.directives.stopAfterTwoProngs) {
-            return undefined;
-        }
-    }
-    if (cpNode === undefined) {
-        return undefined;
-    }
-    findAndAddAll3Prongs(cpTrees, cpNode, maxCoordinate);
-    if (typeof _debug_ !== 'undefined') {
-        if (_debug_.directives.stopAfterThreeProngs) {
-            return undefined;
-        }
-    }
-    const mat = { cpNode, cpTrees };
-    addDebugInfo4(mat);
-    return mat;
-}
-export { findMats };
+import { simplifyPaths } from 'flo-boolean';
+import { findAndAddAll3Prongs } from './mat/find-mat/find-and-add-3-prongs.js';
+import { createInitialCpGraph } from './mat/find-mat/create-initial-cp-graph.js';
+import { addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './mat/find-mat/add-debug-info.js';
+import { getPotential2Prongs } from './mat/find-mat/get-potential-2-prongs.js';
+import { getSharpCorners } from './mat/find-mat/get-sharp-corners.js';
+import { findAndAdd2ProngsOnAllPaths } from './mat/find-mat/find-and-add-2-prongs-on-all-paths.js';
+import { getInterestingPointsOnLoop } from './mat/find-mat/create-get-interesting-points-on-loop.js';
+import { findAndAddHoleClosing2Prongs } from './mat/find-mat/find-and-add-hole-closing-2-prongs.js';
+import { getLoopsMetrics } from './loop/get-max-coordinate.js';
+/**
+ * Finds and returns the Medial Axis Transforms (MATs) from the given array of
+ * bezier loops representing shape boundaries.
+ *
+ * @param bezierLoops An array of (possibly intersecting) loops with each loop
+ * representing one or more piecewise smooth closed curves (i.e. shapes). Each
+ * loop consists of an array of beziers represented by an array of control
+ * points with 2,3 or 4 elements corresponding to linear, quadratic and cubic
+ * beziers respectively. Each point is a two-element array (ordered pair), the
+ * first of which is the x-coordinate and the second the y-coordinate.
+ *
+ * @param maxCurviness The maximum value the 'curviness' of a curve can have
+ * before an additional MAT point is inserted in between. Defaults to 0.4.
+ * (Curviness is measured as the total angle in radians between the consecutive
+ * vectors formed by the ordered control points of th bezier curve). The value
+ * is clipped in the range `[0.05,3]`.
+ * @param maxLength The maximum length a curve can have before an additional MAT
+ * point is inserted. This value is scaled to a reference 1024 x 1024
+ * grid (e.g. if the shape fits in a 512 x 512 axis-aligned box the value will be
+ * halved, e.g. from 10 to 5). Together with maxCurviness it represents a
+ * tolerance for the accuracy of the MAT. Defaults to 4. The value is clipped
+ * in [1,100].
+ */
+function findMats(bezierLoops, maxCurviness = 0.4, maxLength = 4) {
+    // if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
+    let maxCoordinate;
+    let minBezLength;
+    ({ maxCurviness, maxLength, maxCoordinate, minBezLength } =
+        getSizeParams(bezierLoops, maxCurviness, maxLength));
+    const loopss = simplifyPaths(bezierLoops, maxCoordinate);
+    const mats = [];
+    for (const loops of loopss) {
+        const mat = findMat(loops, minBezLength, maxCurviness, maxLength, maxCoordinate);
+        if (mat) {
+            mats.push(mat);
+        }
+    }
+    return mats;
+}
+function getSizeParams(bezierLoops, maxCurviness, maxLength) {
+    // Gather some shape metrics
+    const { maxCoordinate, maxRadius } = getLoopsMetrics(bezierLoops);
+    const expMax = Math.ceil(Math.log2(maxCoordinate));
+    const minBezLengthSigBits = 14;
+    /**
+     * If a curve is shorter than this value then no points on it will be
+     * selected for the purpose of finding the MAT.
+     */
+    const minBezLength = 2 ** expMax * 2 ** (-minBezLengthSigBits);
+    // Limit the tolerance to a reasonable level
+    if (maxCurviness < 0.05) {
+        maxCurviness = 0.05;
+    }
+    if (maxCurviness > 3) {
+        maxCurviness = 3;
+    }
+    // Limit the tolerance to a reasonable level
+    if (maxLength < 0.1) {
+        maxLength = 0.1;
+    }
+    if (maxLength > 100) {
+        maxLength = 100;
+    }
+    // Adjust length tolerance according to a reference max coordinate
+    const expMaxRadius = Math.ceil(Math.log2(maxRadius));
+    const maxLengthSigBits = 10; // 1024 x 1024
+    maxLength = maxLength * (2 ** expMaxRadius * 2 ** (-maxLengthSigBits));
+    return { maxCurviness, maxLength, maxCoordinate, minBezLength };
+}
+/**
+ * @hidden
+ * Find the MAT of the given loops.
+ * @param loops The loops (that as a precondition must be ordered from highest
+ * (i.e. smallest y-value) topmost point loops to lowest)
+ */
+function findMat(loops, minBezLength, maxCurviness, maxLength, maxCoordinate) {
+    addDebugInfo1(loops);
+    // Gets interesting points on the shape, i.e. those that makes sense to use 
+    // for the 2-prong procedure.
+    const pointsPerLoop = loops.map(getInterestingPointsOnLoop(minBezLength, maxCurviness, maxLength));
+    const for2ProngsPerLoop = getPotential2Prongs(pointsPerLoop);
+    const sharpCornersPerLoop = getSharpCorners(pointsPerLoop);
+    const cpTrees = new Map();
+    let cpNode = createInitialCpGraph(loops, cpTrees, sharpCornersPerLoop);
+    findAndAddHoleClosing2Prongs(loops, cpTrees, maxCoordinate);
+    if (typeof _debug_ !== 'undefined') {
+        if (_debug_.directives.stopAfterHoleClosers) {
+            return undefined;
+        }
+    }
+    addDebugInfo2();
+    cpNode = findAndAdd2ProngsOnAllPaths(loops, cpTrees, for2ProngsPerLoop, maxCoordinate);
+    addDebugInfo3();
+    if (typeof _debug_ !== 'undefined') {
+        if (_debug_.directives.stopAfterTwoProngs) {
+            return undefined;
+        }
+    }
+    if (cpNode === undefined) {
+        return undefined;
+    }
+    findAndAddAll3Prongs(cpTrees, cpNode, maxCoordinate);
+    if (typeof _debug_ !== 'undefined') {
+        if (_debug_.directives.stopAfterThreeProngs) {
+            return undefined;
+        }
+    }
+    const mat = { cpNode, cpTrees };
+    addDebugInfo4(mat);
+    return mat;
+}
+export { findMats };
 //# sourceMappingURL=find-mats.js.map

package/node/get-boundary-bezier-parts-to-next.d.ts

@@ -1,9 +1,9 @@
-import { BezierPiece } from 'flo-bezier3';
-import { CpNode } from './cp-node.js';
-/**
- * Returns the ordered bezier curves from this CpNode to the next CpNode
- * on the boundary.
- * @param cpNode
- */
-declare function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[];
-export { getBoundaryBezierPartsToNext };
+import { BezierPiece } from 'flo-bezier3';
+import { CpNode } from './cp-node.js';
+/**
+ * Returns the ordered bezier curves from this CpNode to the next CpNode
+ * on the boundary.
+ * @param cpNode
+ */
+declare function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[];
+export { getBoundaryBezierPartsToNext };

package/node/get-boundary-bezier-parts-to-next.js

@@ -1,43 +1,43 @@
-/**
- * Returns the ordered bezier curves from this CpNode to the next CpNode
- * on the boundary.
- * @param cpNode
- */
-function getBoundaryBezierPartsToNext(cpNode) {
-    const cpThis = cpNode;
-    const cpNext = cpNode.next;
-    const posThis = cpThis.cp.pointOnShape;
-    const posNext = cpNext.cp.pointOnShape;
-    const curveThis = posThis.curve;
-    const curveNext = posNext.curve;
-    if (curveThis.loop !== curveNext.loop) {
-        // It is a hole-closer going over to the other loop - a kind of terminal
-        // CpNode.
-        return undefined;
-    }
-    const bezierParts = [];
-    if (curveNext === curveThis) {
-        bezierParts.push({ ps: posThis.curve.ps, ts: [posThis.t, posNext.t] });
-    }
-    else {
-        bezierParts.push({ ps: posThis.curve.ps, ts: [posThis.t, 1] });
-        addSkippedBeziers(bezierParts, posThis.curve, posNext.curve, posNext.t);
-    }
-    return bezierParts;
-}
-/**
- * @hidden
- * Adds pieces of skipped beziers.
- */
-function addSkippedBeziers(bezierParts, curveStart, curveEnd, t1) {
-    let curveThis = curveStart;
-    do {
-        curveThis = curveThis.next;
-        const bezierPart = curveThis === curveEnd
-            ? { ps: curveThis.ps, ts: [0, t1] }
-            : { ps: curveThis.ps, ts: [0, 1] };
-        bezierParts.push(bezierPart);
-    } while (curveThis !== curveEnd);
-}
-export { getBoundaryBezierPartsToNext };
+/**
+ * Returns the ordered bezier curves from this CpNode to the next CpNode
+ * on the boundary.
+ * @param cpNode
+ */
+function getBoundaryBezierPartsToNext(cpNode) {
+    const cpThis = cpNode;
+    const cpNext = cpNode.next;
+    const posThis = cpThis.cp.pointOnShape;
+    const posNext = cpNext.cp.pointOnShape;
+    const curveThis = posThis.curve;
+    const curveNext = posNext.curve;
+    if (curveThis.loop !== curveNext.loop) {
+        // It is a hole-closer going over to the other loop - a kind of terminal
+        // CpNode.
+        return undefined;
+    }
+    const bezierParts = [];
+    if (curveNext === curveThis) {
+        bezierParts.push({ ps: posThis.curve.ps, ts: [posThis.t, posNext.t] });
+    }
+    else {
+        bezierParts.push({ ps: posThis.curve.ps, ts: [posThis.t, 1] });
+        addSkippedBeziers(bezierParts, posThis.curve, posNext.curve, posNext.t);
+    }
+    return bezierParts;
+}
+/**
+ * @hidden
+ * Adds pieces of skipped beziers.
+ */
+function addSkippedBeziers(bezierParts, curveStart, curveEnd, t1) {
+    let curveThis = curveStart;
+    do {
+        curveThis = curveThis.next;
+        const bezierPart = curveThis === curveEnd
+            ? { ps: curveThis.ps, ts: [0, t1] }
+            : { ps: curveThis.ps, ts: [0, 1] };
+        bezierParts.push(bezierPart);
+    } while (curveThis !== curveEnd);
+}
+export { getBoundaryBezierPartsToNext };
 //# sourceMappingURL=get-boundary-bezier-parts-to-next.js.map

package/node/get-boundary-beziers-to-next.d.ts

@@ -1,8 +1,8 @@
-import { CpNode } from './cp-node.js';
-/**
- * Returns the ordered bezier curves from this CpNode to the next CpNode
- * on the boundary.
- * @param cpNode
- */
-declare function getBoundaryBeziersToNext(cpNode: CpNode): number[][][];
-export { getBoundaryBeziersToNext };
+import { CpNode } from './cp-node.js';
+/**
+ * Returns the ordered bezier curves from this CpNode to the next CpNode
+ * on the boundary.
+ * @param cpNode
+ */
+declare function getBoundaryBeziersToNext(cpNode: CpNode): number[][][];
+export { getBoundaryBeziersToNext };