flo-mat 2.0.2 → 2.0.3

package/node/get-boundary-beziers-to-next.js

@@ -1,45 +1,45 @@
-// qqq import { fromTo, fromTTo1, from0ToT } from 'flo-bezier3';
-import { fromTo } from 'flo-bezier3';
-/**
- * Returns the ordered bezier curves from this CpNode to the next CpNode
- * on the boundary.
- * @param cpNode
- */
-function getBoundaryBeziersToNext(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 beziers = [];
-    if (curveNext === curveThis) {
-        beziers.push(fromTo(posThis.curve.ps, posThis.t, posNext.t));
-    }
-    else {
-        beziers.push(fromTo(posThis.curve.ps, posThis.t, 1));
-        addSkippedBeziers(beziers, posThis.curve, posNext.curve, posNext.t);
-    }
-    return beziers;
-}
-/**
- * Adds pieces of skipped beziers.
- * @hidden
- */
-function addSkippedBeziers(beziers, curveStart, curveEnd, t1) {
-    let curveThis = curveStart;
-    do {
-        curveThis = curveThis.next;
-        const tEnd = curveThis === curveEnd ? t1 : 1;
-        beziers.push(
-        // qqq from0ToT(curveThis.ps, tEnd) 
-        fromTo(curveThis.ps, 0, tEnd));
-    } while (curveThis !== curveEnd);
-}
-export { getBoundaryBeziersToNext };
+// qqq import { fromTo, fromTTo1, from0ToT } from 'flo-bezier3';
+import { fromTo } from 'flo-bezier3';
+/**
+ * Returns the ordered bezier curves from this CpNode to the next CpNode
+ * on the boundary.
+ * @param cpNode
+ */
+function getBoundaryBeziersToNext(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 beziers = [];
+    if (curveNext === curveThis) {
+        beziers.push(fromTo(posThis.curve.ps, posThis.t, posNext.t));
+    }
+    else {
+        beziers.push(fromTo(posThis.curve.ps, posThis.t, 1));
+        addSkippedBeziers(beziers, posThis.curve, posNext.curve, posNext.t);
+    }
+    return beziers;
+}
+/**
+ * Adds pieces of skipped beziers.
+ * @hidden
+ */
+function addSkippedBeziers(beziers, curveStart, curveEnd, t1) {
+    let curveThis = curveStart;
+    do {
+        curveThis = curveThis.next;
+        const tEnd = curveThis === curveEnd ? t1 : 1;
+        beziers.push(
+        // qqq from0ToT(curveThis.ps, tEnd) 
+        fromTo(curveThis.ps, 0, tEnd));
+    } while (curveThis !== curveEnd);
+}
+export { getBoundaryBeziersToNext };
 //# sourceMappingURL=get-boundary-beziers-to-next.js.map

package/node/get-bounding-box-.d.ts

@@ -1,2 +1,2 @@
-declare const getBoundingBox_: (a: number[][]) => number[][];
-export { getBoundingBox_ };
+declare const getBoundingBox_: (a: number[][]) => number[][];
+export { getBoundingBox_ };

package/node/get-bounding-box-.js

@@ -1,5 +1,5 @@
-import { getBoundingBox } from "flo-bezier3";
-import { memoize } from "flo-memoize";
-const getBoundingBox_ = memoize(getBoundingBox);
-export { getBoundingBox_ };
+import { getBoundingBox } from "flo-bezier3";
+import { memoize } from "flo-memoize";
+const getBoundingBox_ = memoize(getBoundingBox);
+export { getBoundingBox_ };
 //# sourceMappingURL=get-bounding-box-.js.map

package/node/get-branches.d.ts

@@ -1,12 +1,12 @@
-import { CpNode } from './cp-node.js';
-/**
- * Traverses all edges (depth first) of the given MAT tree starting at the given
- * vertex (represented by a [[CpNode]]). Returns the result as an array of
- * smooth branches, where smoothness is total or within a given tolerance.
- * @param cpNode Any [[CpNode]] representing the start vertex.
- * @param tolerance Tolerance given as the degrees difference of the unit
- * direction vectors at the interface between curves. A tolerance of zero means
- * perfect smoothness is required.
- */
-declare function getBranches(cpNode: CpNode, tolerance?: number): CpNode[][];
-export { getBranches };
+import { CpNode } from './cp-node.js';
+/**
+ * Traverses all edges (depth first) of the given MAT tree starting at the given
+ * vertex (represented by a [[CpNode]]). Returns the result as an array of
+ * smooth branches, where smoothness is total or within a given tolerance.
+ * @param cpNode Any [[CpNode]] representing the start vertex.
+ * @param tolerance Tolerance given as the degrees difference of the unit
+ * direction vectors at the interface between curves. A tolerance of zero means
+ * perfect smoothness is required.
+ */
+declare function getBranches(cpNode: CpNode, tolerance?: number): CpNode[][];
+export { getBranches };

package/node/get-branches.js

@@ -1,69 +1,69 @@
-import { tangent } from 'flo-bezier3';
-import { cross, toUnitVector } from 'flo-vector2d';
-import { getCurveToNext } from './get-curve-to-next.js';
-/** @hidden */
-const defaultTolerance = 1; // 1 degree
-/**
- * Traverses all edges (depth first) of the given MAT tree starting at the given
- * vertex (represented by a [[CpNode]]). Returns the result as an array of
- * smooth branches, where smoothness is total or within a given tolerance.
- * @param cpNode Any [[CpNode]] representing the start vertex.
- * @param tolerance Tolerance given as the degrees difference of the unit
- * direction vectors at the interface between curves. A tolerance of zero means
- * perfect smoothness is required.
- */
-function getBranches(cpNode, tolerance = defaultTolerance) {
-    // Start from a leaf
-    while (!cpNode.isFullyTerminating()) {
-        cpNode = cpNode.next;
-    }
-    const branches = [];
-    // Since the tree is unrooted we must iterate in all directions from the
-    // given vertex.
-    const cps = [cpNode.prevOnCircle];
-    let branchCpNodes = [];
-    while (cps.length) {
-        const cp = cps.pop();
-        branchCpNodes.push(cp);
-        let children = cp.getChildren();
-        if (cp.isFullyTerminating()) {
-            if (branchCpNodes.length > 1) {
-                branches.push(branchCpNodes);
-            }
-            branchCpNodes = [];
-            continue;
-        }
-        if (children.length === 1) {
-            cps.push(children[0]);
-            continue;
-        }
-        children = children.filter(cpNode => !cpNode.isTerminating());
-        if (children.length === 0) {
-            branches.push(branchCpNodes);
-            branchCpNodes = [];
-            continue;
-        }
-        if (children.length > 1) {
-            // More than one branch comes together
-            branches.push(branchCpNodes);
-            branchCpNodes = [];
-            cps.push(...children);
-            continue;
-        }
-        const backPointingTan = toUnitVector(tangent(getCurveToNext(cp.next.prevOnCircle), 0));
-        const forwardPointingTan = toUnitVector(tangent(getCurveToNext(children[0]), 0));
-        const cross_ = cross(backPointingTan, forwardPointingTan);
-        const angle = Math.abs(Math.asin(cross_) * (180 / Math.PI));
-        if (angle > tolerance) {
-            branches.push(branchCpNodes);
-            branchCpNodes = [];
-        }
-        cps.push(children[0]);
-    }
-    if (branchCpNodes.length) {
-        branches.push(branchCpNodes);
-    }
-    return branches;
-}
-export { getBranches };
+import { tangent } from 'flo-bezier3';
+import { cross, toUnitVector } from 'flo-vector2d';
+import { getCurveToNext } from './get-curve-to-next.js';
+/** @hidden */
+const defaultTolerance = 1; // 1 degree
+/**
+ * Traverses all edges (depth first) of the given MAT tree starting at the given
+ * vertex (represented by a [[CpNode]]). Returns the result as an array of
+ * smooth branches, where smoothness is total or within a given tolerance.
+ * @param cpNode Any [[CpNode]] representing the start vertex.
+ * @param tolerance Tolerance given as the degrees difference of the unit
+ * direction vectors at the interface between curves. A tolerance of zero means
+ * perfect smoothness is required.
+ */
+function getBranches(cpNode, tolerance = defaultTolerance) {
+    // Start from a leaf
+    while (!cpNode.isFullyTerminating()) {
+        cpNode = cpNode.next;
+    }
+    const branches = [];
+    // Since the tree is unrooted we must iterate in all directions from the
+    // given vertex.
+    const cps = [cpNode.prevOnCircle];
+    let branchCpNodes = [];
+    while (cps.length) {
+        const cp = cps.pop();
+        branchCpNodes.push(cp);
+        let children = cp.getChildren();
+        if (cp.isFullyTerminating()) {
+            if (branchCpNodes.length > 1) {
+                branches.push(branchCpNodes);
+            }
+            branchCpNodes = [];
+            continue;
+        }
+        if (children.length === 1) {
+            cps.push(children[0]);
+            continue;
+        }
+        children = children.filter(cpNode => !cpNode.isTerminating());
+        if (children.length === 0) {
+            branches.push(branchCpNodes);
+            branchCpNodes = [];
+            continue;
+        }
+        if (children.length > 1) {
+            // More than one branch comes together
+            branches.push(branchCpNodes);
+            branchCpNodes = [];
+            cps.push(...children);
+            continue;
+        }
+        const backPointingTan = toUnitVector(tangent(getCurveToNext(cp.next.prevOnCircle), 0));
+        const forwardPointingTan = toUnitVector(tangent(getCurveToNext(children[0]), 0));
+        const cross_ = cross(backPointingTan, forwardPointingTan);
+        const angle = Math.abs(Math.asin(cross_) * (180 / Math.PI));
+        if (angle > tolerance) {
+            branches.push(branchCpNodes);
+            branchCpNodes = [];
+        }
+        cps.push(children[0]);
+    }
+    if (branchCpNodes.length) {
+        branches.push(branchCpNodes);
+    }
+    return branches;
+}
+export { getBranches };
 //# sourceMappingURL=get-branches.js.map

package/node/get-curve/get-curve-between.d.ts

@@ -1,9 +1,9 @@
-import { CpNode } from '../cp-node.js';
-/**
- * Returns the bezier curve from the maximal disk of one [[CpNode]] to another
- * [[CpNode]]'s maximal disk.
- * @param cpNodeFrom
- * @param cpNodeTo
- */
-declare function getCurveBetween(cpNodeFrom: CpNode, cpNodeTo: CpNode): number[][];
-export { getCurveBetween };
+import { CpNode } from '../cp-node.js';
+/**
+ * Returns the bezier curve from the maximal disk of one [[CpNode]] to another
+ * [[CpNode]]'s maximal disk.
+ * @param cpNodeFrom
+ * @param cpNodeTo
+ */
+declare function getCurveBetween(cpNodeFrom: CpNode, cpNodeTo: CpNode): number[][];
+export { getCurveBetween };

package/node/get-curve/get-curve-between.js

@@ -1,57 +1,57 @@
-import { fromTo, dot, cross, rotate90Degrees, interpolate, translate, lineLineIntersection } from 'flo-vector2d';
-import { getEdgeDirection } from './get-edge-direction.js';
-/** @hidden */
-const TOLERANCE_ADD_2PRONG = 0.01;
-/** @hidden */
-const TOLERANCE_USE_LINE = 0.0001; // else cubic
-/**
- * Returns the bezier curve from the maximal disk of one [[CpNode]] to another
- * [[CpNode]]'s maximal disk.
- * @param cpNodeFrom
- * @param cpNodeTo
- */
-function getCurveBetween(cpNodeFrom, cpNodeTo) {
-    const fromCc = cpNodeFrom.cp.circle.center;
-    const fromL = getEdgeDirection(cpNodeFrom);
-    const toCc = cpNodeTo.cp.circle.center;
-    const toL = getEdgeDirection(cpNodeTo.prevOnCircle);
-    const mid = lineLineIntersection(fromL, toL);
-    const c = fromTo(fromCc, toCc);
-    let twisted;
-    if (!mid) {
-        twisted = true;
-    }
-    else {
-        const a = fromTo(fromCc, mid);
-        const b = fromTo(toCc, mid);
-        twisted = dot(a, c) < 0 || dot(b, c) > 0;
-    }
-    if (!twisted) {
-        return [fromCc, mid, toCc];
-    }
-    const r = rotate90Degrees(c);
-    const w1 = fromTo(fromL[0], fromL[1]); // This is a unit vector
-    const w2 = fromTo(toL[0], toL[1]); // This is a unit vector
-    const d1 = Math.abs(cross(c, w1)) / (3 * 3);
-    const d2 = Math.abs(cross(c, w2)) / (3 * 3);
-    if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
-        // TODO - not within tolerance - must add additional 2-prong
-        return [fromCc, toCc];
-    }
-    if (d1 > TOLERANCE_USE_LINE || d2 > TOLERANCE_USE_LINE) {
-        // approximate with cubic bezier
-        const m1 = interpolate(fromCc, toCc, 1 / 3);
-        const m2 = interpolate(fromCc, toCc, 2 / 3);
-        const v1 = translate(r, m1);
-        const v2 = translate(r, m2);
-        const l1 = [m1, v1];
-        const l2 = [m2, v2];
-        const mid1 = lineLineIntersection(fromL, l1);
-        const mid2 = lineLineIntersection(toL, l2);
-        return [fromCc, mid1, mid2, toCc];
-    }
-    // Within tolerance - approximate with a straight line.
-    return [fromCc, toCc];
-}
-export { getCurveBetween };
+import { fromTo, dot, cross, rotate90Degrees, interpolate, translate, lineLineIntersection } from 'flo-vector2d';
+import { getEdgeDirection } from './get-edge-direction.js';
+/** @hidden */
+const TOLERANCE_ADD_2PRONG = 0.01;
+/** @hidden */
+const TOLERANCE_USE_LINE = 0.0001; // else cubic
+/**
+ * Returns the bezier curve from the maximal disk of one [[CpNode]] to another
+ * [[CpNode]]'s maximal disk.
+ * @param cpNodeFrom
+ * @param cpNodeTo
+ */
+function getCurveBetween(cpNodeFrom, cpNodeTo) {
+    const fromCc = cpNodeFrom.cp.circle.center;
+    const fromL = getEdgeDirection(cpNodeFrom);
+    const toCc = cpNodeTo.cp.circle.center;
+    const toL = getEdgeDirection(cpNodeTo.prevOnCircle);
+    const mid = lineLineIntersection(fromL, toL);
+    const c = fromTo(fromCc, toCc);
+    let twisted;
+    if (!mid) {
+        twisted = true;
+    }
+    else {
+        const a = fromTo(fromCc, mid);
+        const b = fromTo(toCc, mid);
+        twisted = dot(a, c) < 0 || dot(b, c) > 0;
+    }
+    if (!twisted) {
+        return [fromCc, mid, toCc];
+    }
+    const r = rotate90Degrees(c);
+    const w1 = fromTo(fromL[0], fromL[1]); // This is a unit vector
+    const w2 = fromTo(toL[0], toL[1]); // This is a unit vector
+    const d1 = Math.abs(cross(c, w1)) / (3 * 3);
+    const d2 = Math.abs(cross(c, w2)) / (3 * 3);
+    if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
+        // TODO - not within tolerance - must add additional 2-prong
+        return [fromCc, toCc];
+    }
+    if (d1 > TOLERANCE_USE_LINE || d2 > TOLERANCE_USE_LINE) {
+        // approximate with cubic bezier
+        const m1 = interpolate(fromCc, toCc, 1 / 3);
+        const m2 = interpolate(fromCc, toCc, 2 / 3);
+        const v1 = translate(r, m1);
+        const v2 = translate(r, m2);
+        const l1 = [m1, v1];
+        const l2 = [m2, v2];
+        const mid1 = lineLineIntersection(fromL, l1);
+        const mid2 = lineLineIntersection(toL, l2);
+        return [fromCc, mid1, mid2, toCc];
+    }
+    // Within tolerance - approximate with a straight line.
+    return [fromCc, toCc];
+}
+export { getCurveBetween };
 //# sourceMappingURL=get-curve-between.js.map

package/node/get-curve/get-edge-direction.d.ts

@@ -1,9 +1,9 @@
-import { CpNode } from '../cp-node.js';
-/**
- * @hidden
- * Returns a line segment of unit length starting in the given Vertex center and
- * pointing in the direction of the medial axis (viewed as a rooted tree).
- * @param cpNode
- */
-declare function getEdgeDirection(cpNode: CpNode): number[][];
-export { getEdgeDirection };
+import { CpNode } from '../cp-node.js';
+/**
+ * @hidden
+ * Returns a line segment of unit length starting in the given Vertex center and
+ * pointing in the direction of the medial axis (viewed as a rooted tree).
+ * @param cpNode
+ */
+declare function getEdgeDirection(cpNode: CpNode): number[][];
+export { getEdgeDirection };

package/node/get-curve/get-edge-direction.js

@@ -1,54 +1,54 @@
-import { toUnitVector, fromTo, rotate, translate, rotate90Degrees, reverse, dot } from 'flo-vector2d';
-import { tangent } from 'flo-bezier3';
-import { isPosSharpCorner } from '../point-on-shape.js';
-/**
- * @hidden
- * Returns a line segment of unit length starting in the given Vertex center and
- * pointing in the direction of the medial axis (viewed as a rooted tree).
- * @param cpNode
- */
-function getEdgeDirection(cpNode) {
-    const circleCenter = cpNode.cp.circle.center;
-    const cp1 = cpNode;
-    const cp2 = cpNode.nextOnCircle;
-    const pos1 = cp1.cp.pointOnShape;
-    const pos2 = cp2.cp.pointOnShape;
-    const p1 = pos1.p;
-    const p2 = pos2.p;
-    let vDir;
-    //if (!PointOnShape.isSharpCorner(pos1)) {
-    if (!isPosSharpCorner(pos1)) {
-        if (p1[0] === p2[0] && p1[1] === p2[1]) {
-            vDir = fromTo(p1, circleCenter); // A 1-prong
-        }
-        else {
-            vDir = rotate90Degrees(fromTo(p1, p2)); // not a 1-prong.
-        }
-    }
-    else {
-        let curve1;
-        let curve2;
-        // TODO - test if pos1.t can ever be 0 - it is terminating
-        if (pos1.t === 0) {
-            curve1 = pos1.curve;
-            curve2 = pos1.curve.prev;
-        }
-        else if (pos1.t === 1) {
-            curve1 = pos1.curve.next;
-            curve2 = pos1.curve;
-        }
-        const tan1 = toUnitVector(tangent(curve1.ps, 0));
-        const tan2 = reverse(toUnitVector(tangent(curve2.ps, 1)));
-        const x = dot(tan1, tan2);
-        // Recall the identities sin(acos(x)) = sqrt(1-x^2), etc. Also 
-        // recall the half angle formulas. Then the rotation matrix, R, can 
-        // be calculated.
-        const cosθ = Math.sqrt((1 + x) / 2);
-        const sinθ = Math.sqrt((1 - x) / 2);
-        vDir = rotate(sinθ, cosθ, tan2);
-    }
-    const v = translate(toUnitVector(vDir), circleCenter);
-    return [circleCenter, v];
-}
-export { getEdgeDirection };
+import { toUnitVector, fromTo, rotate, translate, rotate90Degrees, reverse, dot } from 'flo-vector2d';
+import { tangent } from 'flo-bezier3';
+import { isPosSharpCorner } from '../point-on-shape.js';
+/**
+ * @hidden
+ * Returns a line segment of unit length starting in the given Vertex center and
+ * pointing in the direction of the medial axis (viewed as a rooted tree).
+ * @param cpNode
+ */
+function getEdgeDirection(cpNode) {
+    const circleCenter = cpNode.cp.circle.center;
+    const cp1 = cpNode;
+    const cp2 = cpNode.nextOnCircle;
+    const pos1 = cp1.cp.pointOnShape;
+    const pos2 = cp2.cp.pointOnShape;
+    const p1 = pos1.p;
+    const p2 = pos2.p;
+    let vDir;
+    //if (!PointOnShape.isSharpCorner(pos1)) {
+    if (!isPosSharpCorner(pos1)) {
+        if (p1[0] === p2[0] && p1[1] === p2[1]) {
+            vDir = fromTo(p1, circleCenter); // A 1-prong
+        }
+        else {
+            vDir = rotate90Degrees(fromTo(p1, p2)); // not a 1-prong.
+        }
+    }
+    else {
+        let curve1;
+        let curve2;
+        // TODO - test if pos1.t can ever be 0 - it is terminating
+        if (pos1.t === 0) {
+            curve1 = pos1.curve;
+            curve2 = pos1.curve.prev;
+        }
+        else if (pos1.t === 1) {
+            curve1 = pos1.curve.next;
+            curve2 = pos1.curve;
+        }
+        const tan1 = toUnitVector(tangent(curve1.ps, 0));
+        const tan2 = reverse(toUnitVector(tangent(curve2.ps, 1)));
+        const x = dot(tan1, tan2);
+        // Recall the identities sin(acos(x)) = sqrt(1-x^2), etc. Also 
+        // recall the half angle formulas. Then the rotation matrix, R, can 
+        // be calculated.
+        const cosθ = Math.sqrt((1 + x) / 2);
+        const sinθ = Math.sqrt((1 - x) / 2);
+        vDir = rotate(sinθ, cosθ, tan2);
+    }
+    const v = translate(toUnitVector(vDir), circleCenter);
+    return [circleCenter, v];
+}
+export { getEdgeDirection };
 //# sourceMappingURL=get-edge-direction.js.map

package/node/get-curve-to-next.d.ts

@@ -1,9 +1,9 @@
-import { CpNode } from './cp-node.js';
-/**
- * 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
- */
-declare function getCurveToNext(cpNode: CpNode): number[][];
-export { getCurveToNext };
+import { CpNode } from './cp-node.js';
+/**
+ * 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
+ */
+declare function getCurveToNext(cpNode: CpNode): number[][];
+export { getCurveToNext };

package/node/get-curve-to-next.js

@@ -1,12 +1,12 @@
-import { getCurveBetween } from './get-curve/get-curve-between.js';
-/**
- * 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
- */
-function getCurveToNext(cpNode) {
-    return getCurveBetween(cpNode, cpNode.next);
-}
-export { getCurveToNext };
+import { getCurveBetween } from './get-curve/get-curve-between.js';
+/**
+ * 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
+ */
+function getCurveToNext(cpNode) {
+    return getCurveBetween(cpNode, cpNode.next);
+}
+export { getCurveToNext };
 //# sourceMappingURL=get-curve-to-next.js.map

package/node/get-interface-ccw.d.ts

@@ -1,24 +1,24 @@
-/**
- * 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
- */
-declare function getInterfaceCcw(psI: number[][], psO: number[][]): number;
-export { getInterfaceCcw };
+/**
+ * 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
+ */
+declare function getInterfaceCcw(psI: number[][], psO: number[][]): number;
+export { getInterfaceCcw };