flo-mat 2.0.2 → 2.0.3

package/node/mat/find-mat/get-sharp-corners.js

@@ -1,18 +1,18 @@
-import { isPosQuiteSharpCorner } from '../../point-on-shape.js';
-/** @hidden */
-function getSharpCorners(possPerLoop) {
-    const sharpCornersPerLoop = [];
-    for (const poss of possPerLoop) {
-        const sharpCorners = [];
-        for (const pos of poss) {
-            //if (PointOnShape.isQuiteSharpCorner(pos)) {
-            if (isPosQuiteSharpCorner(pos)) {
-                sharpCorners.push(pos);
-            }
-        }
-        sharpCornersPerLoop.push(sharpCorners);
-    }
-    return sharpCornersPerLoop;
-}
-export { getSharpCorners };
+import { isPosQuiteSharpCorner } from '../../point-on-shape.js';
+/** @hidden */
+function getSharpCorners(possPerLoop) {
+    const sharpCornersPerLoop = [];
+    for (const poss of possPerLoop) {
+        const sharpCorners = [];
+        for (const pos of poss) {
+            //if (PointOnShape.isQuiteSharpCorner(pos)) {
+            if (isPosQuiteSharpCorner(pos)) {
+                sharpCorners.push(pos);
+            }
+        }
+        sharpCornersPerLoop.push(sharpCorners);
+    }
+    return sharpCornersPerLoop;
+}
+export { getSharpCorners };
 //# sourceMappingURL=get-sharp-corners.js.map

package/node/mat/geometry/get-closest-square-distance-to-rect.d.ts

@@ -1,5 +1,5 @@
-/**
- * @hidden
- */
-declare function getClosestSquareDistanceToRect(box: number[][], p: number[]): number;
-export { getClosestSquareDistanceToRect };
+/**
+ * @hidden
+ */
+declare function getClosestSquareDistanceToRect(box: number[][], p: number[]): number;
+export { getClosestSquareDistanceToRect };

package/node/mat/geometry/get-closest-square-distance-to-rect.js

@@ -1,50 +1,50 @@
-import { squaredDistanceBetween as squaredDistanceBetween_ } from 'flo-vector2d';
-const squaredDistanceBetween = squaredDistanceBetween_;
-/**
- * @hidden
- */
-function getClosestSquareDistanceToRect(box, p) {
-    const p0 = box[0];
-    const p1 = box[1];
-    const x0 = p0[0];
-    const y0 = p0[1];
-    const x1 = p1[0];
-    const y1 = p1[1];
-    const xp = p[0];
-    const yp = p[1];
-    //let [[x0,y0],[x1,y1]] = box;
-    //let [xp,yp] = p;
-    if (xp < x0) {
-        if (yp < y0) {
-            return squaredDistanceBetween(box[0], p);
-        }
-        else if (yp > y1) {
-            return squaredDistanceBetween([x0, y1], p);
-        }
-        else {
-            return (x0 - xp) ** 2;
-        }
-    }
-    else if (xp > x1) {
-        if (yp < y0) {
-            return squaredDistanceBetween([x1, y0], p);
-        }
-        else if (yp > y1) {
-            return squaredDistanceBetween(box[1], p);
-        }
-        else {
-            return (xp - x1) ** 2;
-        }
-    }
-    else {
-        if (yp < y0) {
-            return (y0 - yp) ** 2;
-        }
-        else if (yp > y1) {
-            return (yp - y1) ** 2;
-        }
-        return 0;
-    }
-}
-export { getClosestSquareDistanceToRect };
+import { squaredDistanceBetween as squaredDistanceBetween_ } from 'flo-vector2d';
+const squaredDistanceBetween = squaredDistanceBetween_;
+/**
+ * @hidden
+ */
+function getClosestSquareDistanceToRect(box, p) {
+    const p0 = box[0];
+    const p1 = box[1];
+    const x0 = p0[0];
+    const y0 = p0[1];
+    const x1 = p1[0];
+    const y1 = p1[1];
+    const xp = p[0];
+    const yp = p[1];
+    //let [[x0,y0],[x1,y1]] = box;
+    //let [xp,yp] = p;
+    if (xp < x0) {
+        if (yp < y0) {
+            return squaredDistanceBetween(box[0], p);
+        }
+        else if (yp > y1) {
+            return squaredDistanceBetween([x0, y1], p);
+        }
+        else {
+            return (x0 - xp) ** 2;
+        }
+    }
+    else if (xp > x1) {
+        if (yp < y0) {
+            return squaredDistanceBetween([x1, y0], p);
+        }
+        else if (yp > y1) {
+            return squaredDistanceBetween(box[1], p);
+        }
+        else {
+            return (xp - x1) ** 2;
+        }
+    }
+    else {
+        if (yp < y0) {
+            return (y0 - yp) ** 2;
+        }
+        else if (yp > y1) {
+            return (yp - y1) ** 2;
+        }
+        return 0;
+    }
+}
+export { getClosestSquareDistanceToRect };
 //# sourceMappingURL=get-closest-square-distance-to-rect.js.map

package/node/mat/geometry/get-closest-squared-distance-to-rotated-rect.d.ts

@@ -1,5 +1,5 @@
-/**
- * @hidden
- */
-declare function getClosestSquaredDistanceToRotatedRect(ps: number[][], p: number[]): number;
-export { getClosestSquaredDistanceToRotatedRect };
+/**
+ * @hidden
+ */
+declare function getClosestSquaredDistanceToRotatedRect(ps: number[][], p: number[]): number;
+export { getClosestSquaredDistanceToRotatedRect };

package/node/mat/geometry/get-closest-squared-distance-to-rotated-rect.js

@@ -1,16 +1,16 @@
-import { squaredDistanceBetweenPointAndLineSegment, squaredDistanceBetween } from 'flo-vector2d';
-/**
- * @hidden
- */
-function getClosestSquaredDistanceToRotatedRect(ps, p) {
-    const ds = [0, 1, 2, 3].map(i => squaredDistanceBetweenPointAndLineSegment(p, [ps[i], ps[(i + 1) % 4]]));
-    const width = squaredDistanceBetween(ps[0], ps[1]);
-    const height = squaredDistanceBetween(ps[0], ps[3]);
-    if (ds[0] <= height && ds[2] <= height &&
-        ds[1] <= width && ds[3] <= width) {
-        return 0; // Inside rotated rect
-    }
-    return Math.min(...ds);
-}
-export { getClosestSquaredDistanceToRotatedRect };
+import { squaredDistanceBetweenPointAndLineSegment, squaredDistanceBetween } from 'flo-vector2d';
+/**
+ * @hidden
+ */
+function getClosestSquaredDistanceToRotatedRect(ps, p) {
+    const ds = [0, 1, 2, 3].map(i => squaredDistanceBetweenPointAndLineSegment(p, [ps[i], ps[(i + 1) % 4]]));
+    const width = squaredDistanceBetween(ps[0], ps[1]);
+    const height = squaredDistanceBetween(ps[0], ps[3]);
+    if (ds[0] <= height && ds[2] <= height &&
+        ds[1] <= width && ds[3] <= width) {
+        return 0; // Inside rotated rect
+    }
+    return Math.min(...ds);
+}
+export { getClosestSquaredDistanceToRotatedRect };
 //# sourceMappingURL=get-closest-squared-distance-to-rotated-rect.js.map

package/node/mat/get-boundary-piece-beziers.d.ts

@@ -1,11 +1,11 @@
-import { CpNode } from '../cp-node.js';
-import { BezierPiece } from './bezier-piece.js';
-/**
- * @hidden
- * 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
- */
-declare function getBoundaryPieceBeziers(cpNodes: CpNode[]): BezierPiece[];
-export { getBoundaryPieceBeziers };
+import { CpNode } from '../cp-node.js';
+import { BezierPiece } from './bezier-piece.js';
+/**
+ * @hidden
+ * 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
+ */
+declare function getBoundaryPieceBeziers(cpNodes: CpNode[]): BezierPiece[];
+export { getBoundaryPieceBeziers };

package/node/mat/get-boundary-piece-beziers.js

@@ -1,59 +1,59 @@
-import { isPosQuiteSharpCorner } from '../point-on-shape.js';
-import { compareCps } from '../contact-point.js';
-/**
- * @hidden
- * 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) {
-    let cpThis = cpNodes[0];
-    const cpEnd = cpNodes[1];
-    const bezierPieces = [];
-    // As opposed to going around the circle and taking the last exit
-    let goStraight = true;
-    do {
-        if (!goStraight) {
-            goStraight = true;
-            cpThis = cpThis.prevOnCircle; // take last exit
-            continue;
-        }
-        goStraight = false;
-        const posThis = cpThis.cp.pointOnShape;
-        const posNext = cpThis.next.cp.pointOnShape;
-        if (posNext.curve === posThis.curve &&
-            //PointOnShape.isQuiteSharpCorner(posThis) && 
-            //PointOnShape.isQuiteSharpCorner(posNext)) {
-            isPosQuiteSharpCorner(posThis) &&
-            isPosQuiteSharpCorner(posNext)) {
-            // Do nothing
-        }
-        else if (posNext.curve === posThis.curve &&
-            compareCps(cpThis.next.cp, cpThis.cp) > 0) {
-            bezierPieces.push({ curve: posThis.curve, ts: [posThis.t, posNext.t] });
-        }
-        else {
-            bezierPieces.push({ curve: posThis.curve, ts: [posThis.t, 1] });
-            if (cpThis.cp.pointOnShape.curve.loop === cpThis.next.cp.pointOnShape.curve.loop) {
-                addSkippedBeziers(bezierPieces, posThis.curve, posNext.curve, posNext.t);
-            }
-        }
-        cpThis = cpThis.next;
-    } while (cpThis !== cpEnd);
-    return bezierPieces;
-}
-/**
- * @hidden
- * Adds pieces of skipped beziers
- */
-function addSkippedBeziers(bezierPieces, curveStart, curveEnd, t1) {
-    let curveThis = curveStart;
-    do {
-        curveThis = curveThis.next;
-        const tEnd = curveThis === curveEnd ? t1 : 1;
-        bezierPieces.push({ curve: curveThis, ts: [0, tEnd] });
-    } while (curveThis !== curveEnd);
-}
-export { getBoundaryPieceBeziers };
+import { isPosQuiteSharpCorner } from '../point-on-shape.js';
+import { compareCps } from '../contact-point.js';
+/**
+ * @hidden
+ * 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) {
+    let cpThis = cpNodes[0];
+    const cpEnd = cpNodes[1];
+    const bezierPieces = [];
+    // As opposed to going around the circle and taking the last exit
+    let goStraight = true;
+    do {
+        if (!goStraight) {
+            goStraight = true;
+            cpThis = cpThis.prevOnCircle; // take last exit
+            continue;
+        }
+        goStraight = false;
+        const posThis = cpThis.cp.pointOnShape;
+        const posNext = cpThis.next.cp.pointOnShape;
+        if (posNext.curve === posThis.curve &&
+            //PointOnShape.isQuiteSharpCorner(posThis) && 
+            //PointOnShape.isQuiteSharpCorner(posNext)) {
+            isPosQuiteSharpCorner(posThis) &&
+            isPosQuiteSharpCorner(posNext)) {
+            // Do nothing
+        }
+        else if (posNext.curve === posThis.curve &&
+            compareCps(cpThis.next.cp, cpThis.cp) > 0) {
+            bezierPieces.push({ curve: posThis.curve, ts: [posThis.t, posNext.t] });
+        }
+        else {
+            bezierPieces.push({ curve: posThis.curve, ts: [posThis.t, 1] });
+            if (cpThis.cp.pointOnShape.curve.loop === cpThis.next.cp.pointOnShape.curve.loop) {
+                addSkippedBeziers(bezierPieces, posThis.curve, posNext.curve, posNext.t);
+            }
+        }
+        cpThis = cpThis.next;
+    } while (cpThis !== cpEnd);
+    return bezierPieces;
+}
+/**
+ * @hidden
+ * Adds pieces of skipped beziers
+ */
+function addSkippedBeziers(bezierPieces, curveStart, curveEnd, t1) {
+    let curveThis = curveStart;
+    do {
+        curveThis = curveThis.next;
+        const tEnd = curveThis === curveEnd ? t1 : 1;
+        bezierPieces.push({ curve: curveThis, ts: [0, tEnd] });
+    } while (curveThis !== curveEnd);
+}
+export { getBoundaryPieceBeziers };
 //# sourceMappingURL=get-boundary-piece-beziers.js.map

package/node/mat/get-contact-circles-at-interface.d.ts

@@ -1,8 +1,8 @@
-import { Curve } from '../curve.js';
-import { IPointOnShape } from '../point-on-shape.js';
-/**
- * @hidden
- * @param curve
- */
-declare function getContactCirclesAtInterface(curve: Curve): IPointOnShape[];
-export { getContactCirclesAtInterface };
+import { Curve } from '../curve.js';
+import { IPointOnShape } from '../point-on-shape.js';
+/**
+ * @hidden
+ * @param curve
+ */
+declare function getContactCirclesAtInterface(curve: Curve): IPointOnShape[];
+export { getContactCirclesAtInterface };

package/node/mat/get-contact-circles-at-interface.js

@@ -1,21 +1,21 @@
-import { getCornerAtEnd } from '../curve.js';
-import { PointOnShape } from '../point-on-shape.js';
-/**
- * @hidden
- * @param curve
- */
-function getContactCirclesAtInterface(curve) {
-    const { isQuiteSharp, isQuiteDull } = getCornerAtEnd(curve);
-    if (isQuiteSharp) {
-        return [new PointOnShape(curve, 1)];
-    }
-    else if (isQuiteDull) {
-        return [
-            new PointOnShape(curve, 1),
-            new PointOnShape(curve.next, 0)
-        ];
-    }
-    return [];
-}
-export { getContactCirclesAtInterface };
+import { getCornerAtEnd } from '../curve.js';
+import { PointOnShape } from '../point-on-shape.js';
+/**
+ * @hidden
+ * @param curve
+ */
+function getContactCirclesAtInterface(curve) {
+    const { isQuiteSharp, isQuiteDull } = getCornerAtEnd(curve);
+    if (isQuiteSharp) {
+        return [new PointOnShape(curve, 1)];
+    }
+    else if (isQuiteDull) {
+        return [
+            new PointOnShape(curve, 1),
+            new PointOnShape(curve.next, 0)
+        ];
+    }
+    return [];
+}
+export { getContactCirclesAtInterface };
 //# sourceMappingURL=get-contact-circles-at-interface.js.map

package/node/mat/get-largest-vertex.d.ts

@@ -1,4 +1,4 @@
-import { CpNode } from '../cp-node.js';
-/** @hidden */
-declare function getLargestVertex(cpNodes: CpNode[]): CpNode;
-export { getLargestVertex };
+import { CpNode } from '../cp-node.js';
+/** @hidden */
+declare function getLargestVertex(cpNodes: CpNode[]): CpNode;
+export { getLargestVertex };

package/node/mat/get-largest-vertex.js

@@ -1,10 +1,10 @@
-/** @hidden */
-function getLargestVertex(cpNodes) {
-    return cpNodes.reduce(function (maxCpNode, cpNode) {
-        return maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius
-            ? maxCpNode
-            : cpNode;
-    }, cpNodes[0]);
-}
-export { getLargestVertex };
+/** @hidden */
+function getLargestVertex(cpNodes) {
+    return cpNodes.reduce(function (maxCpNode, cpNode) {
+        return maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius
+            ? maxCpNode
+            : cpNode;
+    }, cpNodes[0]);
+}
+export { getLargestVertex };
 //# sourceMappingURL=get-largest-vertex.js.map

package/node/mat/get-leaves.d.ts

@@ -1,4 +1,4 @@
-import { CpNode } from '../cp-node.js';
-/** @hidden */
-declare function getLeaves(cpNode: CpNode): CpNode[];
-export { getLeaves };
+import { CpNode } from '../cp-node.js';
+/** @hidden */
+declare function getLeaves(cpNode: CpNode): CpNode[];
+export { getLeaves };

package/node/mat/get-leaves.js

@@ -1,13 +1,13 @@
-/** @hidden */
-function getLeaves(cpNode) {
-    const leaves = [];
-    const cps = cpNode.getAllOnLoop();
-    cps.forEach(function (cp) {
-        if (cp.isTerminating()) {
-            leaves.push(cp);
-        }
-    });
-    return leaves;
-}
-export { getLeaves };
+/** @hidden */
+function getLeaves(cpNode) {
+    const leaves = [];
+    const cps = cpNode.getAllOnLoop();
+    cps.forEach(function (cp) {
+        if (cp.isTerminating()) {
+            leaves.push(cp);
+        }
+    });
+    return leaves;
+}
+export { getLeaves };
 //# sourceMappingURL=get-leaves.js.map

package/node/mat/get-neighboring-cps.d.ts

@@ -1,14 +1,14 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { IPointOnShape } from '../point-on-shape.js';
-import { CpNode } from '../cp-node.js';
-/**
- * @hidden
- * Returns the boundary piece that starts at the immediate previous point on the
- * shape and ends at the immediate next point.
- * @param cpTree
- * @param pos
- * @param order
- * @param order2
- */
-declare function getNeighbouringPoints(cpTree: LlRbTree<CpNode>, pos: IPointOnShape, order: number, order2: number): CpNode[];
-export { getNeighbouringPoints };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { IPointOnShape } from '../point-on-shape.js';
+import { CpNode } from '../cp-node.js';
+/**
+ * @hidden
+ * Returns the boundary piece that starts at the immediate previous point on the
+ * shape and ends at the immediate next point.
+ * @param cpTree
+ * @param pos
+ * @param order
+ * @param order2
+ */
+declare function getNeighbouringPoints(cpTree: LlRbTree<CpNode>, pos: IPointOnShape, order: number, order2: number): CpNode[];
+export { getNeighbouringPoints };

package/node/mat/get-neighboring-cps.js

@@ -1,31 +1,31 @@
-import { CpNode } from '../cp-node.js';
-/**
- * @hidden
- * Returns the boundary piece that starts at the immediate previous point on the
- * shape and ends at the immediate next point.
- * @param cpTree
- * @param pos
- * @param order
- * @param order2
- */
-function getNeighbouringPoints(cpTree, pos, order, order2) {
-    const cps = cpTree.findBounds(new CpNode({ pointOnShape: pos, circle: undefined, order, order2 }, false, false));
-    if (!cps[0] && !cps[1]) {
-        // The tree is still empty
-        return [undefined, undefined];
-    }
-    if (!cps[0] || !cps[1]) {
-        // Smaller than all -> cptree.min() === cps[1].data OR
-        // Larger  than all -> cptree.max() === cps[0].data
-        return [
-            cpTree.max(cpTree.root),
-            cpTree.min(cpTree.root)
-        ];
-    }
-    return [
-        cps[0].datum,
-        cps[1].datum
-    ];
-}
-export { getNeighbouringPoints };
+import { CpNode } from '../cp-node.js';
+/**
+ * @hidden
+ * Returns the boundary piece that starts at the immediate previous point on the
+ * shape and ends at the immediate next point.
+ * @param cpTree
+ * @param pos
+ * @param order
+ * @param order2
+ */
+function getNeighbouringPoints(cpTree, pos, order, order2) {
+    const cps = cpTree.findBounds(new CpNode({ pointOnShape: pos, circle: undefined, order, order2 }, false, false));
+    if (!cps[0] && !cps[1]) {
+        // The tree is still empty
+        return [undefined, undefined];
+    }
+    if (!cps[0] || !cps[1]) {
+        // Smaller than all -> cptree.min() === cps[1].data OR
+        // Larger  than all -> cptree.max() === cps[0].data
+        return [
+            cpTree.max(cpTree.root),
+            cpTree.min(cpTree.root)
+        ];
+    }
+    return [
+        cps[0].datum,
+        cps[1].datum
+    ];
+}
+export { getNeighbouringPoints };
 //# sourceMappingURL=get-neighboring-cps.js.map

package/node/mat/get-two-prong-type.d.ts

@@ -1,5 +1,5 @@
-import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
-import { ElemType_TwoProng } from './elem-type-two-prong.js';
-/** @hidden */
-declare function getTwoProngType(e: TwoProngForDebugging): ElemType_TwoProng;
-export { getTwoProngType };
+import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
+import { ElemType_TwoProng } from './elem-type-two-prong.js';
+/** @hidden */
+declare function getTwoProngType(e: TwoProngForDebugging): ElemType_TwoProng;
+export { getTwoProngType };

package/node/mat/get-two-prong-type.js

@@ -1,9 +1,9 @@
-/** @hidden */
-function getTwoProngType(e) {
-    if (e.holeClosing) {
-        return 'twoProng_holeClosing';
-    }
-    return 'twoProng_regular';
-}
-export { getTwoProngType };
+/** @hidden */
+function getTwoProngType(e) {
+    if (e.holeClosing) {
+        return 'twoProng_holeClosing';
+    }
+    return 'twoProng_regular';
+}
+export { getTwoProngType };
 //# sourceMappingURL=get-two-prong-type.js.map

package/node/mat/is-another-cp-closeby.d.ts

@@ -1,20 +1,20 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from '../loop.js';
-import { CpNode } from '../cp-node.js';
-import { IPointOnShape } from '../point-on-shape.js';
-import { Circle } from '../circle.js';
-/**
- * @hidden
- * Returns true if another CpNode is close to the given implied (via pos, order
- * and order2) CpNode.
- * @param cpTrees
- * @param pos
- * @param circle
- * @param order
- * @param order2
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- * @param color Used for debugging only
- */
-declare function isAnotherCpCloseby(cpTrees: Map<Loop, LlRbTree<CpNode>>, pos: IPointOnShape, circle: Circle, order: number, order2: number, extreme: number, color: string): boolean;
-export { isAnotherCpCloseby };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Loop } from '../loop.js';
+import { CpNode } from '../cp-node.js';
+import { IPointOnShape } from '../point-on-shape.js';
+import { Circle } from '../circle.js';
+/**
+ * @hidden
+ * Returns true if another CpNode is close to the given implied (via pos, order
+ * and order2) CpNode.
+ * @param cpTrees
+ * @param pos
+ * @param circle
+ * @param order
+ * @param order2
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ * @param color Used for debugging only
+ */
+declare function isAnotherCpCloseby(cpTrees: Map<Loop, LlRbTree<CpNode>>, pos: IPointOnShape, circle: Circle, order: number, order2: number, extreme: number, color: string): boolean;
+export { isAnotherCpCloseby };