flo-mat 2.0.2 → 2.0.4

package/node/get-interface-ccw.js

@@ -1,98 +1,98 @@
-import { orient2d } from 'big-float-ts';
-import { dot } from "flo-vector2d";
-import { compareCurvaturesAtInterface } from "./compare-curvatures-at-interface.js";
-/**
- * Returns a positive value if the second bezier (of order 1, 2 or 3) curves
- * anti-clockwise with respect to the first at the point where the first bezier
- * ends and the second one starts. Returns a negative number if the turn is
- * clockwise. Returns 0 otherwise.
- *
- * The algorithm is a generalization of `ccw`, a.k.a `orient2d`.
- *
- * The above obviously necessitates that their endpoints coincide as described.
- *
- * Preconditions (for robustness):
- * * The beziers has control points with max bit-length of 25 and bit-aligned.
- * * The bezier does not have infinite curvature at either endpoint
- *
- * This is so the vectors between control points can be
- * calculated exactly without resorting to adaptive infinite precision floating
- * point operations. Note: aligned to 'grid' here means if you bitwise-and all
- * values together the resulting bitlength === the max bithlength of any value.
- *
- * @param psI The incoming bezier that ends at the interface
- * @param psO The outgoing bezier that starts at the interface
- */
-// TODO - improve and make at least 46-bitlength precondition
-function getInterfaceCcw(psI, psO) {
-    const lenI = psI.length;
-    // second last control point of incoming curve
-    const p0 = psI[lenI - 2];
-    // last control point of incoming curve / first control point of outgoing
-    const p1 = psO[0];
-    // second control point of outgoing curve
-    const p2 = psO[1];
-    /*
-    if (typeof _bez_debug_ !== 'undefined') {
-        let maxBitLength = 25;
-        let p1_ = psI[lenI-1];
-        // ---- precondition: does endpoints coincide
-        if (p1_[0] !== p1[0] || p1_[1] !== p1[1]) {
-            throw new Error('Curve endpoints must coincide.');
-        }
-        // ---- precondition: are coordinates grid-aligned
-        // Get all coordinate values into an array
-        let xs: number[] = [];
-        [psI, psO].forEach(ps => ps.forEach(p => p.forEach(x => {
-            xs.push(x);
-        })));
-        
-        let msb = xs.reduce((prevX, x) => Math.max(prevX, msbExponent(x)), Number.NEGATIVE_INFINITY);
-        let lsb = xs.reduce((prevX, x) => Math.min(prevX, lsbExponent(x)), Number.POSITIVE_INFINITY);
-        let bitlengthAll = msb - lsb + 1;
-        if (bitlengthAll > maxBitLength) {
-            throw new Error(
-                `Curve control point coordinates must be bit-aligned and <= ${maxBitLength}. bitlength === ${bitlengthAll}, coordinates: ${xs}`
-            );
-        }
-    }
-    */
-    // Max one bit can be added in the calculations below due to bit-alignment
-    const xE = p1[0] - p0[0]; // tangent x-coordinate
-    const yE = p1[1] - p0[1]; // tangent y-coordinate
-    const xS = p2[0] - p1[0]; // tangent x-coordinate
-    const yS = p2[1] - p1[1]; // tangent y-coordinate
-    // If the tangent is to be found at t === 0 or t === 1 then using a basic 
-    // property of bezier curves we can find the tangents easily as below
-    // (non-normalized) tangent of incoming curve at t === 1
-    const tangentAtEnd = [xE, yE];
-    // (non-normalized) tangent of outgoing curve at t === 0
-    const tangentAtStart = [xS, yS];
-    // The cross calculated below will have a max bitlength of 
-    // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
-    // If the preconditions are met it is exact
-    //let crossTangents = cross(tangentAtEnd, tangentAtStart);
-    // The cross below is exact by adaptive infinite precision
-    const crossTangents = orient2d(p0, p1, p2);
-    if (crossTangents !== 0) {
-        return crossTangents;
-    }
-    // The dot calculated below will have a max bitlength of 
-    // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
-    // If the preconditions are met it is exact
-    const dotTangents = dot(tangentAtEnd, tangentAtStart);
-    if (dotTangents > 0) {
-        // Curves go in same direction at interface - neither clock or 
-        // anti-clockwise.
-        // Note: The above comment is not strictly true but as this case is not
-        // important for the algorithm we return 0
-        return 0;
-    }
-    // Curves go in opposite directions at interface starting off with the exact
-    // same tangent - look now at curvature to see which has the largest 
-    // curvature so we can base the clock or anti-clockwise result on that
-    // Look at curvature
-    return compareCurvaturesAtInterface(psI.slice().reverse(), psO);
-}
-export { getInterfaceCcw };
+import { orient2d } from 'big-float-ts';
+import { dot } from "flo-vector2d";
+import { compareCurvaturesAtInterface } from "./compare-curvatures-at-interface.js";
+/**
+ * Returns a positive value if the second bezier (of order 1, 2 or 3) curves
+ * anti-clockwise with respect to the first at the point where the first bezier
+ * ends and the second one starts. Returns a negative number if the turn is
+ * clockwise. Returns 0 otherwise.
+ *
+ * The algorithm is a generalization of `ccw`, a.k.a `orient2d`.
+ *
+ * The above obviously necessitates that their endpoints coincide as described.
+ *
+ * Preconditions (for robustness):
+ * * The beziers has control points with max bit-length of 25 and bit-aligned.
+ * * The bezier does not have infinite curvature at either endpoint
+ *
+ * This is so the vectors between control points can be
+ * calculated exactly without resorting to adaptive infinite precision floating
+ * point operations. Note: aligned to 'grid' here means if you bitwise-and all
+ * values together the resulting bitlength === the max bithlength of any value.
+ *
+ * @param psI The incoming bezier that ends at the interface
+ * @param psO The outgoing bezier that starts at the interface
+ */
+// TODO - improve and make at least 46-bitlength precondition
+function getInterfaceCcw(psI, psO) {
+    const lenI = psI.length;
+    // second last control point of incoming curve
+    const p0 = psI[lenI - 2];
+    // last control point of incoming curve / first control point of outgoing
+    const p1 = psO[0];
+    // second control point of outgoing curve
+    const p2 = psO[1];
+    /*
+    if (typeof _bez_debug_ !== 'undefined') {
+        let maxBitLength = 25;
+        let p1_ = psI[lenI-1];
+        // ---- precondition: does endpoints coincide
+        if (p1_[0] !== p1[0] || p1_[1] !== p1[1]) {
+            throw new Error('Curve endpoints must coincide.');
+        }
+        // ---- precondition: are coordinates grid-aligned
+        // Get all coordinate values into an array
+        let xs: number[] = [];
+        [psI, psO].forEach(ps => ps.forEach(p => p.forEach(x => {
+            xs.push(x);
+        })));
+        
+        let msb = xs.reduce((prevX, x) => Math.max(prevX, msbExponent(x)), Number.NEGATIVE_INFINITY);
+        let lsb = xs.reduce((prevX, x) => Math.min(prevX, lsbExponent(x)), Number.POSITIVE_INFINITY);
+        let bitlengthAll = msb - lsb + 1;
+        if (bitlengthAll > maxBitLength) {
+            throw new Error(
+                `Curve control point coordinates must be bit-aligned and <= ${maxBitLength}. bitlength === ${bitlengthAll}, coordinates: ${xs}`
+            );
+        }
+    }
+    */
+    // Max one bit can be added in the calculations below due to bit-alignment
+    const xE = p1[0] - p0[0]; // tangent x-coordinate
+    const yE = p1[1] - p0[1]; // tangent y-coordinate
+    const xS = p2[0] - p1[0]; // tangent x-coordinate
+    const yS = p2[1] - p1[1]; // tangent y-coordinate
+    // If the tangent is to be found at t === 0 or t === 1 then using a basic 
+    // property of bezier curves we can find the tangents easily as below
+    // (non-normalized) tangent of incoming curve at t === 1
+    const tangentAtEnd = [xE, yE];
+    // (non-normalized) tangent of outgoing curve at t === 0
+    const tangentAtStart = [xS, yS];
+    // The cross calculated below will have a max bitlength of 
+    // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
+    // If the preconditions are met it is exact
+    //let crossTangents = cross(tangentAtEnd, tangentAtStart);
+    // The cross below is exact by adaptive infinite precision
+    const crossTangents = orient2d(p0, p1, p2);
+    if (crossTangents !== 0) {
+        return crossTangents;
+    }
+    // The dot calculated below will have a max bitlength of 
+    // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
+    // If the preconditions are met it is exact
+    const dotTangents = dot(tangentAtEnd, tangentAtStart);
+    if (dotTangents > 0) {
+        // Curves go in same direction at interface - neither clock or 
+        // anti-clockwise.
+        // Note: The above comment is not strictly true but as this case is not
+        // important for the algorithm we return 0
+        return 0;
+    }
+    // Curves go in opposite directions at interface starting off with the exact
+    // same tangent - look now at curvature to see which has the largest 
+    // curvature so we can base the clock or anti-clockwise result on that
+    // Look at curvature
+    return compareCurvaturesAtInterface(psI.slice().reverse(), psO);
+}
+export { getInterfaceCcw };
 //# sourceMappingURL=get-interface-ccw.js.map

package/node/index.d.ts

@@ -1,36 +1,36 @@
-import { beziersToSvgPathStr, getPathsFromStr } from 'flo-boolean';
-import { Mat } from './mat.js';
-import { Loop } from './loop.js';
-import { Curve } from './curve.js';
-import { CpNode } from './cp-node.js';
-import { PointOnShape, IPointOnShape } from './point-on-shape.js';
-import { Circle } from './circle.js';
-import { ContactPoint } from './contact-point.js';
-import { BezierPiece } from './mat/bezier-piece.js';
-import { findMats } from './find-mats.js';
-import { trimMat } from './mat/trim-mat.js';
-import { toScaleAxis } from './to-scale-axis.js';
-import { traverseEdges } from './traverse-edges.js';
-import { getBranches } from './get-branches.js';
-import { traverseVertices } from './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 { getClosestBoundaryPoint } from './mat/closest-boundary-point/get-closest-boundary-point.js';
-import { getShapeBounds } from './svg/get-shape-bounds.js';
-import { getBoundaryBeziersToNext } from './get-boundary-beziers-to-next.js';
-import { getBoundaryBezierPartsToNext } from './get-boundary-bezier-parts-to-next.js';
-import { getBoundaryPieceBeziers } from './mat/get-boundary-piece-beziers.js';
-import { simplifyMat } from './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 './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 './mat/geometry/get-closest-square-distance-to-rect.js';
-import { loopFromBeziers } from './loop.js';
-export { Mat, PointOnShape, IPointOnShape, Curve, Loop, CpNode, Circle, ContactPoint, BezierPiece, findMats, toScaleAxis, trimMat, traverseVertices, traverseEdges, getBranches, getBoundaryBeziersToNext, getBoundaryBezierPartsToNext, simplifyMat, simplifyMatMapOnly, beziersToSvgPathStr, getPathsFromStr, getShapeBounds, drawBranch, drawMat, getClosestBoundaryPoint, getCurveToNext, getCurveBetween, Debug, IDebugElems, TDrawElemFunctions, ICpNodeForDebugging, ITiming, getBoundaryPieceBeziers, drawElemFunctions, sweepLine, getClosestSquareDistanceToRect, loopFromBeziers, enableDebugForMat };
+import { beziersToSvgPathStr, getPathsFromStr } from 'flo-boolean';
+import { Mat } from './mat.js';
+import { Loop } from './loop.js';
+import { Curve } from './curve.js';
+import { CpNode } from './cp-node.js';
+import { PointOnShape, IPointOnShape } from './point-on-shape.js';
+import { Circle } from './circle.js';
+import { ContactPoint } from './contact-point.js';
+import { BezierPiece } from './mat/bezier-piece.js';
+import { findMats } from './find-mats.js';
+import { trimMat } from './mat/trim-mat.js';
+import { toScaleAxis } from './to-scale-axis.js';
+import { traverseEdges } from './traverse-edges.js';
+import { getBranches } from './get-branches.js';
+import { traverseVertices } from './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 { getClosestBoundaryPoint } from './mat/closest-boundary-point/get-closest-boundary-point.js';
+import { getShapeBounds } from './svg/get-shape-bounds.js';
+import { getBoundaryBeziersToNext } from './get-boundary-beziers-to-next.js';
+import { getBoundaryBezierPartsToNext } from './get-boundary-bezier-parts-to-next.js';
+import { getBoundaryPieceBeziers } from './mat/get-boundary-piece-beziers.js';
+import { simplifyMat } from './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 './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 './mat/geometry/get-closest-square-distance-to-rect.js';
+import { loopFromBeziers } from './loop.js';
+export { Mat, PointOnShape, IPointOnShape, Curve, Loop, CpNode, Circle, ContactPoint, BezierPiece, findMats, toScaleAxis, trimMat, traverseVertices, traverseEdges, getBranches, getBoundaryBeziersToNext, getBoundaryBezierPartsToNext, simplifyMat, simplifyMatMapOnly, beziersToSvgPathStr, getPathsFromStr, getShapeBounds, drawBranch, drawMat, getClosestBoundaryPoint, getCurveToNext, getCurveBetween, Debug, IDebugElems, TDrawElemFunctions, ICpNodeForDebugging, ITiming, getBoundaryPieceBeziers, drawElemFunctions, sweepLine, getClosestSquareDistanceToRect, loopFromBeziers, enableDebugForMat };

package/node/index.js

@@ -1,33 +1,33 @@
-import { beziersToSvgPathStr, getPathsFromStr } from 'flo-boolean';
-import { CpNode } from './cp-node.js';
-import { PointOnShape } from './point-on-shape.js';
-import { findMats } from './find-mats.js';
-import { trimMat } from './mat/trim-mat.js';
-import { toScaleAxis } from './to-scale-axis.js';
-import { traverseEdges } from './traverse-edges.js';
-import { getBranches } from './get-branches.js';
-import { traverseVertices } from './traverse-vertices.js';
-import { enableDebugForMat } from './debug/debug.js';
-import { drawBranch } from './debug/functions/draw-elem/branch.js';
-import { drawMat } from './debug/functions/draw-elem/mat.js';
-import { getClosestBoundaryPoint } from './mat/closest-boundary-point/get-closest-boundary-point.js';
-import { getShapeBounds } from './svg/get-shape-bounds.js';
-import { getBoundaryBeziersToNext } from './get-boundary-beziers-to-next.js';
-import { getBoundaryBezierPartsToNext } from './get-boundary-bezier-parts-to-next.js';
-import { getBoundaryPieceBeziers } from './mat/get-boundary-piece-beziers.js';
-import { simplifyMat } from './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 './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 './mat/geometry/get-closest-square-distance-to-rect.js';
-import { loopFromBeziers } from './loop.js';
-export { PointOnShape, CpNode, 
-// Main functions
-findMats, toScaleAxis, trimMat, traverseVertices, traverseEdges, getBranches, getBoundaryBeziersToNext, getBoundaryBezierPartsToNext, simplifyMat, simplifyMatMapOnly, 
-// SVG functions
-beziersToSvgPathStr, getPathsFromStr, getShapeBounds, drawBranch, drawMat, 
-// Other functions
-getClosestBoundaryPoint, getCurveToNext, getCurveBetween, getBoundaryPieceBeziers, drawElemFunctions, sweepLine, getClosestSquareDistanceToRect, loopFromBeziers, enableDebugForMat };
+import { beziersToSvgPathStr, getPathsFromStr } from 'flo-boolean';
+import { CpNode } from './cp-node.js';
+import { PointOnShape } from './point-on-shape.js';
+import { findMats } from './find-mats.js';
+import { trimMat } from './mat/trim-mat.js';
+import { toScaleAxis } from './to-scale-axis.js';
+import { traverseEdges } from './traverse-edges.js';
+import { getBranches } from './get-branches.js';
+import { traverseVertices } from './traverse-vertices.js';
+import { enableDebugForMat } from './debug/debug.js';
+import { drawBranch } from './debug/functions/draw-elem/branch.js';
+import { drawMat } from './debug/functions/draw-elem/mat.js';
+import { getClosestBoundaryPoint } from './mat/closest-boundary-point/get-closest-boundary-point.js';
+import { getShapeBounds } from './svg/get-shape-bounds.js';
+import { getBoundaryBeziersToNext } from './get-boundary-beziers-to-next.js';
+import { getBoundaryBezierPartsToNext } from './get-boundary-bezier-parts-to-next.js';
+import { getBoundaryPieceBeziers } from './mat/get-boundary-piece-beziers.js';
+import { simplifyMat } from './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 './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 './mat/geometry/get-closest-square-distance-to-rect.js';
+import { loopFromBeziers } from './loop.js';
+export { PointOnShape, CpNode, 
+// Main functions
+findMats, toScaleAxis, trimMat, traverseVertices, traverseEdges, getBranches, getBoundaryBeziersToNext, getBoundaryBezierPartsToNext, simplifyMat, simplifyMatMapOnly, 
+// SVG functions
+beziersToSvgPathStr, getPathsFromStr, getShapeBounds, drawBranch, drawMat, 
+// Other functions
+getClosestBoundaryPoint, getCurveToNext, getCurveBetween, getBoundaryPieceBeziers, drawElemFunctions, sweepLine, getClosestSquareDistanceToRect, loopFromBeziers, enableDebugForMat };
 //# sourceMappingURL=index.js.map

package/node/loop/get-max-coordinate.d.ts

@@ -1,10 +1,10 @@
-/**
- * @hidden
- * Returns the maximum control point coordinate value (x or y) within any loop.
- * @param loops The array of loops
- */
-declare function getLoopsMetrics(loops: number[][][][]): {
-    maxCoordinate: number;
-    maxRadius: number;
-};
-export { getLoopsMetrics };
+/**
+ * @hidden
+ * Returns the maximum control point coordinate value (x or y) within any loop.
+ * @param loops The array of loops
+ */
+declare function getLoopsMetrics(loops: number[][][][]): {
+    maxCoordinate: number;
+    maxRadius: number;
+};
+export { getLoopsMetrics };

package/node/loop/get-max-coordinate.js

@@ -1,44 +1,44 @@
-const max = Math.max;
-const abs = Math.abs;
-/**
- * @hidden
- * Returns the maximum control point coordinate value (x or y) within any loop.
- * @param loops The array of loops
- */
-function getLoopsMetrics(loops) {
-    let maxCoordinate = 0;
-    let minX = Number.POSITIVE_INFINITY;
-    let maxX = Number.NEGATIVE_INFINITY;
-    let minY = Number.POSITIVE_INFINITY;
-    let maxY = Number.NEGATIVE_INFINITY;
-    for (const loop of loops) {
-        for (const ps of loop) {
-            for (const p of ps) {
-                const x = p[0];
-                const y = p[1];
-                const c = max(abs(x), abs(y));
-                if (c > maxCoordinate) {
-                    maxCoordinate = c;
-                }
-                if (x < minX) {
-                    minX = x;
-                }
-                if (x > maxX) {
-                    maxX = x;
-                }
-                if (y < minY) {
-                    minY = y;
-                }
-                if (y > maxY) {
-                    maxY = y;
-                }
-            }
-        }
-    }
-    const width = maxX - minX;
-    const height = maxY - minY;
-    const maxRadius = max(width, height);
-    return { maxCoordinate, maxRadius };
-}
-export { getLoopsMetrics };
+const max = Math.max;
+const abs = Math.abs;
+/**
+ * @hidden
+ * Returns the maximum control point coordinate value (x or y) within any loop.
+ * @param loops The array of loops
+ */
+function getLoopsMetrics(loops) {
+    let maxCoordinate = 0;
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const loop of loops) {
+        for (const ps of loop) {
+            for (const p of ps) {
+                const x = p[0];
+                const y = p[1];
+                const c = max(abs(x), abs(y));
+                if (c > maxCoordinate) {
+                    maxCoordinate = c;
+                }
+                if (x < minX) {
+                    minX = x;
+                }
+                if (x > maxX) {
+                    maxX = x;
+                }
+                if (y < minY) {
+                    minY = y;
+                }
+                if (y > maxY) {
+                    maxY = y;
+                }
+            }
+        }
+    }
+    const width = maxX - minX;
+    const height = maxY - minY;
+    const maxRadius = max(width, height);
+    return { maxCoordinate, maxRadius };
+}
+export { getLoopsMetrics };
 //# sourceMappingURL=get-max-coordinate.js.map

package/node/loop.d.ts

@@ -1,16 +1,16 @@
-import { Curve } from './curve.js';
-/**
- * Represents a two-way linked loop of [[ICurve]]s - mostly used internally to
- * conveniently represent shape boundaries.
- */
-interface Loop {
-    /** The curves that represent the shape boundary as an array. */
-    curves: Curve[];
-    /** A pre-ordered array of bezier curves to add initially.*/
-    beziers: number[][][];
-}
-/**
- * @param beziers A pre-ordered array of bezier curves to add initially.
- */
-declare function loopFromBeziers(beziers?: number[][][]): Loop;
-export { Loop, loopFromBeziers };
+import { Curve } from './curve.js';
+/**
+ * Represents a two-way linked loop of [[ICurve]]s - mostly used internally to
+ * conveniently represent shape boundaries.
+ */
+interface Loop {
+    /** The curves that represent the shape boundary as an array. */
+    curves: Curve[];
+    /** A pre-ordered array of bezier curves to add initially.*/
+    beziers: number[][][];
+}
+/**
+ * @param beziers A pre-ordered array of bezier curves to add initially.
+ */
+declare function loopFromBeziers(beziers?: number[][][]): Loop;
+export { Loop, loopFromBeziers };

package/node/loop.js

@@ -1,35 +1,35 @@
-/**
- * @param beziers A pre-ordered array of bezier curves to add initially.
- */
-function loopFromBeziers(beziers = []) {
-    const curves = [];
-    const loop = {
-        beziers,
-        curves
-    };
-    if (!beziers.length) {
-        return loop;
-    }
-    let prev;
-    for (let i = 0; i < beziers.length; i++) {
-        const curve = {
-            loop,
-            ps: beziers[i],
-            prev,
-            next: undefined,
-            idx: i
-        };
-        if (prev) {
-            prev.next = curve;
-        }
-        prev = curve;
-        curves.push(curve);
-    }
-    // close loop
-    const lastCurve = curves[curves.length - 1];
-    curves[0].prev = lastCurve;
-    lastCurve.next = curves[0];
-    return loop;
-}
-export { loopFromBeziers };
+/**
+ * @param beziers A pre-ordered array of bezier curves to add initially.
+ */
+function loopFromBeziers(beziers = []) {
+    const curves = [];
+    const loop = {
+        beziers,
+        curves
+    };
+    if (!beziers.length) {
+        return loop;
+    }
+    let prev;
+    for (let i = 0; i < beziers.length; i++) {
+        const curve = {
+            loop,
+            ps: beziers[i],
+            prev,
+            next: undefined,
+            idx: i
+        };
+        if (prev) {
+            prev.next = curve;
+        }
+        prev = curve;
+        curves.push(curve);
+    }
+    // close loop
+    const lastCurve = curves[curves.length - 1];
+    curves[0].prev = lastCurve;
+    lastCurve.next = curves[0];
+    return loop;
+}
+export { loopFromBeziers };
 //# sourceMappingURL=loop.js.map

package/node/mat/add-to-cp-graph.d.ts

@@ -1,16 +1,16 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from '../loop.js';
-import { Circle } from '../circle.js';
-import { IPointOnShape } from '../point-on-shape.js';
-import { CpNode } from '../cp-node.js';
-/**
- * @hidden
- * @param circle
- * @param orders
- * @param cpTrees
- * @param poss
- * @param neighbors
- * @hidden
- */
-declare function addToCpGraph(circle: Circle, orders: number[], cpTrees: Map<Loop, LlRbTree<CpNode>>, poss: IPointOnShape[], neighbors?: CpNode[][]): void;
-export { addToCpGraph };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Loop } from '../loop.js';
+import { Circle } from '../circle.js';
+import { IPointOnShape } from '../point-on-shape.js';
+import { CpNode } from '../cp-node.js';
+/**
+ * @hidden
+ * @param circle
+ * @param orders
+ * @param cpTrees
+ * @param poss
+ * @param neighbors
+ * @hidden
+ */
+declare function addToCpGraph(circle: Circle, orders: number[], cpTrees: Map<Loop, LlRbTree<CpNode>>, poss: IPointOnShape[], neighbors?: CpNode[][]): void;
+export { addToCpGraph };

package/node/mat/add-to-cp-graph.js

@@ -1,31 +1,31 @@
-import { CpNode } from '../cp-node.js';
-import { getNeighbouringPoints } from './get-neighboring-cps.js';
-/**
- * @hidden
- * @param circle
- * @param orders
- * @param cpTrees
- * @param poss
- * @param neighbors
- * @hidden
- */
-function addToCpGraph(circle, orders, cpTrees, poss, neighbors) {
-    const newCps = poss.map((pos, i) => {
-        const cpTree = cpTrees.get(pos.curve.loop);
-        const newCp_ = { pointOnShape: pos, circle, order: orders[i], order2: 0 };
-        const neighboringCp = neighbors
-            ? neighbors[i]
-            : getNeighbouringPoints(cpTree, pos, orders[i], 0);
-        const newCp = CpNode.insert(false, false, cpTree, newCp_, neighboringCp[0]);
-        return newCp;
-    });
-    const len = poss.length;
-    for (let i = 0; i < len; i++) {
-        const indxPrev = i === 0 ? len - 1 : i - 1;
-        const indxNext = i === len - 1 ? 0 : i + 1;
-        newCps[i].prevOnCircle = newCps[indxPrev];
-        newCps[i].nextOnCircle = newCps[indxNext];
-    }
-}
-export { addToCpGraph };
+import { CpNode } from '../cp-node.js';
+import { getNeighbouringPoints } from './get-neighboring-cps.js';
+/**
+ * @hidden
+ * @param circle
+ * @param orders
+ * @param cpTrees
+ * @param poss
+ * @param neighbors
+ * @hidden
+ */
+function addToCpGraph(circle, orders, cpTrees, poss, neighbors) {
+    const newCps = poss.map((pos, i) => {
+        const cpTree = cpTrees.get(pos.curve.loop);
+        const newCp_ = { pointOnShape: pos, circle, order: orders[i], order2: 0 };
+        const neighboringCp = neighbors
+            ? neighbors[i]
+            : getNeighbouringPoints(cpTree, pos, orders[i], 0);
+        const newCp = CpNode.insert(false, false, cpTree, newCp_, neighboringCp[0]);
+        return newCp;
+    });
+    const len = poss.length;
+    for (let i = 0; i < len; i++) {
+        const indxPrev = i === 0 ? len - 1 : i - 1;
+        const indxNext = i === len - 1 ? 0 : i + 1;
+        newCps[i].prevOnCircle = newCps[indxPrev];
+        newCps[i].nextOnCircle = newCps[indxNext];
+    }
+}
+export { addToCpGraph };
 //# sourceMappingURL=add-to-cp-graph.js.map