flo-mat 3.0.14 → 4.0.1

package/node/mat/connect-hole-closers.d.ts

@@ -1,3 +0,0 @@
-import { Mat } from "./mat.js";
-declare function connectHoleClosers(mat: Mat): Mat;
-export { connectHoleClosers };

package/node/mat/connect-hole-closers.js

@@ -1,5 +0,0 @@
-function connectHoleClosers(mat) {
-    return mat;
-}
-export { connectHoleClosers };
-//# sourceMappingURL=connect-hole-closers.js.map

package/node/mat/connect-hole-closers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"connect-hole-closers.js","sourceRoot":"","sources":["../../src/mat/connect-hole-closers.ts"],"names":[],"mappings":"AAGA,SAAS,kBAAkB,CAAC,GAAQ;IAChC,OAAO,GAAG,CAAC;AACf,CAAC;AAGD,OAAO,EAAE,kBAAkB,EAAE,CAAA"}

package/node/mat/create-new-cp-tree.d.ts

@@ -1,9 +0,0 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-/**
- * @internal
- * @param cpNode
- */
-declare function createNewCpTree(cpNode: CpNode): Map<Loop, LlRbTree<CpNode>>;
-export { createNewCpTree };

package/node/mat/create-new-cp-tree.js

@@ -1,23 +0,0 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNodeFs } from '../cp-node/cp-node-fs.js';
-const { cpNodeComparator, getAllOnLoop } = CpNodeFs;
-/**
- * @internal
- * @param cpNode
- */
-function createNewCpTree(cpNode) {
-    const newCpTrees = new Map();
-    getAllOnLoop(cpNode).forEach(createNewCpTree_);
-    function createNewCpTree_(cpNode) {
-        const loop = cpNode.cp.pointOnShape.curve.loop;
-        let cpTree = newCpTrees.get(loop);
-        if (!cpTree) {
-            cpTree = new LlRbTree(cpNodeComparator, false);
-            newCpTrees.set(loop, cpTree);
-        }
-        cpTree.insert(cpNode);
-    }
-    return newCpTrees;
-}
-export { createNewCpTree };
-//# sourceMappingURL=create-new-cp-tree.js.map

package/node/mat/create-new-cp-tree.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-new-cp-tree.js","sourceRoot":"","sources":["../../src/mat/create-new-cp-tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG1C,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,MAAM,EAAE,gBAAgB,EAAE,YAAY,EAAE,GAAG,QAAQ,CAAC;AAGpD;;;GAGG;AACH,SAAS,eAAe,CAAC,MAAc;IACnC,MAAM,UAAU,GAA+B,IAAI,GAAG,EAAE,CAAC;IAEzD,YAAY,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAE/C,SAAS,gBAAgB,CAAC,MAAc;QACpC,MAAM,IAAI,GAAG,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC;QAC/C,IAAI,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,MAAM,GAAG,IAAI,QAAQ,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;YAC/C,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACjC,CAAC;QACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,OAAO,UAAU,CAAC;AACtB,CAAC;AAGD,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/node/memoize-primitive.d.ts

@@ -1,11 +0,0 @@
-/**
- * Memoize (by reference on the input parameter) the given arity 1 function.
- *
- * * also works with primitive keys
- * * keys will *never* be garbage collected (even if they're not
- * primitive); this may or may not be ok, depending on the use case
- * * will also work with `object`s but since this will hold a reference and
- * prevent garbage collection, rather use `memoize` instead
- */
-declare function memoizePrimitive<T, U>(f: (a: T) => U): (a: T) => U;
-export { memoizePrimitive };

package/node/memoize-primitive.js

@@ -1,25 +0,0 @@
-/**
- * Memoize (by reference on the input parameter) the given arity 1 function.
- *
- * * also works with primitive keys
- * * keys will *never* be garbage collected (even if they're not
- * primitive); this may or may not be ok, depending on the use case
- * * will also work with `object`s but since this will hold a reference and
- * prevent garbage collection, rather use `memoize` instead
- */
-function memoizePrimitive(f) {
-    const results = new Map();
-    return function (a) {
-        let result = results.get(a);
-        if (result !== undefined) {
-            //console.log('cache hit');
-            return result;
-        }
-        //console.log('cache miss');
-        result = f(a);
-        results.set(a, result);
-        return result;
-    };
-}
-export { memoizePrimitive };
-//# sourceMappingURL=memoize-primitive.js.map

package/node/memoize-primitive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoize-primitive.js","sourceRoot":"","sources":["../src/memoize-primitive.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,SAAS,gBAAgB,CAAO,CAAc;IAC1C,MAAM,OAAO,GAAG,IAAI,GAAG,EAAO,CAAC;IAE/B,OAAO,UAAS,CAAI;QAChB,IAAI,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACvB,2BAA2B;YAC3B,OAAO,MAAM,CAAC;QAClB,CAAC;QAED,4BAA4B;QAC5B,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACd,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;QAEvB,OAAO,MAAM,CAAC;IAClB,CAAC,CAAA;AACL,CAAC;AAGD,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

package/node/point-on-shape/create-pos.d.ts

@@ -1,4 +0,0 @@
-import { Curve } from "../curve/curve.js";
-import { PointOnShape } from "./point-on-shape.js";
-declare function createPos(curve: Curve, t: number, isSource?: boolean): PointOnShape;
-export { createPos };

package/node/point-on-shape/create-pos.js

@@ -1,11 +0,0 @@
-import { evalDeCasteljauDd } from "flo-bezier3";
-function createPos(curve, t, isSource) {
-    return {
-        curve,
-        t,
-        p: evalDeCasteljauDd(curve.ps, [0, t]).map(c => c[1]),
-        isSource: isSource === undefined ? false : isSource
-    };
-}
-export { createPos };
-//# sourceMappingURL=create-pos.js.map

package/node/point-on-shape/create-pos.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-pos.js","sourceRoot":"","sources":["../../src/point-on-shape/create-pos.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAK/C,SAAS,SAAS,CACV,KAAY,EACZ,CAAS,EACT,QAAkB;IAEtB,OAAO;QACH,KAAK;QACL,CAAC;QACD,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpD,QAAQ,EAAE,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ;KACtD,CAAA;AACL,CAAC;AAGD,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/node/point-on-shape/is-pos-quite-sharp-corner.d.ts

@@ -1,17 +0,0 @@
-import { PointOnShape } from "./point-on-shape.js";
-/**
- * @internal
- */
-declare const isPosQuiteSharpCorner: ((pos: PointOnShape) => boolean) & {
-    readonly weakMapS: WeakMap<object, {
-        readonly weakMap: WeakMap<object, any>;
-        readonly map: Map<object, any>;
-    }>;
-    readonly mapS: Map<object, {
-        readonly weakMap: WeakMap<object, any>;
-        readonly map: Map<object, any>;
-    }>;
-    readonly clearCache: () => void;
-    readonly addToCache: (r: unknown, ...args: any) => void;
-};
-export { isPosQuiteSharpCorner };

package/node/point-on-shape/is-pos-quite-sharp-corner.js

@@ -1,14 +0,0 @@
-import { memoize } from 'flo-memoize';
-import { isPosCorner } from './is-pos-corner.js';
-import { getPosCorner } from './get-pos-corner.js';
-/**
- * @internal
- */
-const isPosQuiteSharpCorner = memoize((pos) => {
-    if (!isPosCorner(pos)) {
-        return false;
-    }
-    return getPosCorner(pos).isQuiteSharp;
-});
-export { isPosQuiteSharpCorner };
-//# sourceMappingURL=is-pos-quite-sharp-corner.js.map

package/node/point-on-shape/is-pos-quite-sharp-corner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-pos-quite-sharp-corner.js","sourceRoot":"","sources":["../../src/point-on-shape/is-pos-quite-sharp-corner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD;;GAEG;AACH,MAAM,qBAAqB,GAAG,OAAO,CAAC,CAAC,GAAiB,EAAE,EAAE;IACxD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;QAAC,OAAO,KAAK,CAAC;IAAC,CAAC;IAExC,OAAO,YAAY,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC;AAC1C,CAAC,CAAC,CAAC;AAGH,OAAO,EAAE,qBAAqB,EAAE,CAAA"}

package/src/bezier/fit-quads-to-cubic.ts

@@ -1,103 +0,0 @@
-import {
-    classify, fromToInclErrorBound, cubicToQuadratic, getAbsAreaBetween,
-    bezierSelfIntersection
-} from 'flo-bezier3';
-
-
-/**
- * TODO2 - change description - just basically copied from flo-bezier3
- * Approximate the given cubic bezier curve (up to the given tolerance) by 
- * fitting an array of ordered (by `t` value) piecewise bezier curves 
- * (of quadratic order or less).
- * 
- * * the start and end point of each approximating curve lies on the cubic 
- * curve and the the tangents of each approximating curve coincide with that of
- * the cubic at each such point
- * 
- * @param ps a cubic bezier curve given as an ordered array of its
- * control point coordinates, e.g. `[[0,0], [1,1], [2,1], [2,0]]`
- * @param tolerance tolerance given as the maximum total absolute area difference 
- * between the two curves
- * 
- * @doc mdx
- */
-function fitQuadsToCubicTsOnly(
-        ps: number[][], 
-        tolerance: number): number[] {
-
-    const { collinear, realOrder, nodeType } = classify(ps);
-
-    // if all points collinear or a line (or point)
-    if (collinear || realOrder <= 1) {
-        // return a quad that's a line between the first and last points
-        // return [ps[0], [(ps[0][0] + ps[3][0])/2, (ps[0][1] + ps[3][1])/2], ps[3]];
-        return [0,1];
-    }
-
-    if (realOrder === 2) {
-        // already a quadratic in disguise
-
-        // It is not possible that `toQuadraticFromCubic(ps)` be undefined here
-        // since the `real order` is exactly 2 and the control points are *not*
-        // collinear.
-        return [0,1];
-    }
-
-    const stack: number[][] = [];
-
-    // if endpoints coincide
-    if (ps[0][0] === ps[3][0] && ps[0][1] === ps[3][1]) {
-        stack.push([0, 0.5], [0.5,1]);
-    } else if (nodeType === 'cusp') {
-        const t = bezierSelfIntersection(ps)[0];
-        stack.push([0,t], [t,1]);  // split at cusp
-    } else if (nodeType === 'crunode') {
-        const ts = bezierSelfIntersection(ps);
-        if (ts.length > 1) {
-            stack.push(
-                [0, ts[0]],
-                [ts[0], ts[1]],
-                [ts[1], 1]
-            );  // split at intersections
-        } else {
-            // the intersection is outside the range [0,1]
-            stack.push([0,1]);
-        }
-    } else {
-        stack.push([0,1]);
-    }
-
-    const qs: number[][][] = [];
-    const r: number[] = [];
-    while (stack.length !== 0) {
-        const ts = stack.pop()!;
-
-        const [tS,tE] = ts;
-        /** the piece of the cubic bezier to approximate */
-        const psCubic = fromToInclErrorBound(ps, tS, tE).ps;
-        const psQuad = cubicToQuadratic(psCubic);
-        // const spanRatio = tE - tS;
-        if (psQuad === undefined || 
-            // spanRatio*getAbsAreaBetween(psQuad, psCubic) > tolerance) {
-                getAbsAreaBetween(psQuad, psCubic) > tolerance) {
-
-            const tM = (tE + tS)/2;
-            stack.push([tS,tM], [tM,tE]);  // split cubic in 2 equal pieces
-        } else {
-            qs.push(psQuad);
-            r.push(tS);
-        }
-    }
-
-    r.reverse();
-    r.push(1);
-
-    return r;
-}
-
-
-export { fitQuadsToCubicTsOnly }
-
-
-// TESTING
-// fitQuadsToCubicTsOnly([[0,0],[1,0],[0.5,1],[2,0.4]], 0.00001); //?

package/src/bezier/total-curvature.ts

@@ -1,8 +0,0 @@
-import { totalCurvature } from "flo-bezier3";
-import { memoize } from "flo-memoize";
-
-
-const totalCurvature$ = memoize(totalCurvature);
-
-
-export { totalCurvature$ }

package/src/bezier/total-length.ts

@@ -1,8 +0,0 @@
-import { totalLength } from "flo-bezier3";
-import { memoize } from "flo-memoize";
-
-
-const totalLength$ = memoize(totalLength);
-
-
-export { totalLength$ }

package/src/closest-boundary-point/closest-points-on-curve-precise.ts

@@ -1,75 +0,0 @@
-// import { ddDeflate, allRootsCertified, RootInterval } from 'flo-poly';
-// import { evalDeCasteljauDd, getFootpointPolyDd } from 'flo-bezier3';
-// import { Curve } from "../curve/curve.js";
-
-
-// /**
-//  * @internal
-//  * @param curve The curve
-//  * @param p The point from which to check
-//  * @param tRange The allowed t range
-//  * @param touchedCurve The bezier on which p is located
-//  * @param t The t value of the bezier that locates p
-//  */
-// function closestPointsOnCurvePrecise(
-//         curve: Curve, 
-//         p: number[], 
-//         [tS,tE]: number[] = [0,1], 
-//         touchedCurve: Curve,
-//         t: number): {
-//             p: number[];
-//             t: number;
-//         }[] {
-
-//     const _poly = getFootpointPolyDd(curve.ps, p);
-
-//     const poly = curve === touchedCurve
-//         ? ddDeflate(_poly, t)
-//         : _poly;
-
-//     const roots: Omit<RootInterval,'multiplicity'>[] = 
-//         allRootsCertified(poly, tS, tE);
-
-//     // Also test the endpoints
-//     const dontPush0 = (
-//         (t === 1 && curve === touchedCurve.next) ||
-//         (t === 0 && curve === touchedCurve)
-//     );
-
-//     const dontPush1 = (
-//         (t === 0 && curve === touchedCurve.prev) ||
-//         (t === 1 && curve === touchedCurve)
-//     );
-
-//     if (tS === 0) {
-//         if (!dontPush0) { roots.push({ tS: 0, tE: 0 }); }
-//     } else if (tS === 1) {
-//         if (!dontPush1) { roots.push({ tS: 1, tE: 1 }); }
-//     } else {
-//         roots.push({ tS: tS, tE: tS });
-//     }
-
-//     if (tE === 0) {
-//         if (!dontPush0) { roots.push({ tS: 0, tE: 0 }); }
-//     } else if (tE === 1) {
-//         if (!dontPush1) { roots.push({ tS: 1, tE: 1 }); }
-//     } else {
-//         roots.push({ tS: tE, tE: tE });
-//     }
-
-//     const ps = roots.map(
-//         root => { 
-//             const tS = root.tS;
-//             const tE = root.tE;
-//             const t = tS < 0 
-//                 ? 0
-//                 : tE > 1 ? 1 : (tS + tE)/2;
-//             return { p: evalDeCasteljauDd(curve.ps,[0,t]).map(v => v[1]), t }
-//         }
-//     );
-
-//     return ps;
-// }
-
-
-// export { closestPointsOnCurvePrecise }

package/src/closest-boundary-point/closest-points-on-curve.ts

@@ -1,72 +0,0 @@
-import { allRoots, deflate } from 'flo-poly';
-import { evalDeCasteljau, getFootpointPoly } from 'flo-bezier3';
-import { Curve } from "../curve/curve.js";
-import { eAdd, growExpansion } from 'big-float-ts';
-
-
-/**
- * @internal
- * @param curve The curve
- * @param p The point from which to check
- * @param tRange The allowed t range
- * @param touchedCurve The bezier on which p is located
- * @param t The t value of the bezier that locates p
- */
-function closestPointsOnCurve(
-        curve: Curve, 
-        p: number[], 
-        [tS,tE]: number[] = [0,1], 
-        touchedCurve: Curve,
-        t: number): {
-            p: number[];
-            t: number;
-        }[] {
-
-    const _poly = getFootpointPoly(curve.ps, p);
-
-    const poly = curve === touchedCurve
-        ? deflate(_poly, t)
-        : _poly;
-
-    const roots = allRoots(poly, tS, tE);
-
-    // Also test the endpoints
-    let push0 = true;
-    let push1 = true;
-    if ((t === 1 && curve === touchedCurve.next) ||
-        (t === 0 && curve === touchedCurve)) {
-        push0 = false;
-    }
-    if ((t === 0 && curve === touchedCurve.prev) ||
-        (t === 1 && curve === touchedCurve)) {
-        push1 = false;
-    }
-
-    if (tS === 0) {
-        if (push0) { roots.push(0); }
-    } else if (tS === 1) {
-        if (push1) { roots.push(1); }
-    } else {
-        roots.push(tS);
-    }
-
-    if (tE === 0) {
-        if (push0) { roots.push(0); }
-    } else if (tE === 1) {
-        if (push1) { roots.push(1); }
-    } else {
-        roots.push(tE);
-    }
-
-    const ps = roots.map(
-        r => { 
-            const t = r < 0 ? 0 : r > 1 ? 1 : r;
-            return { p: evalDeCasteljau(curve.ps,t), t }
-        }
-    );
-
-    return ps;
-}
-
-
-export { closestPointsOnCurve }

package/src/closest-boundary-point/dd-deflate-with-running-error.ts

@@ -1,88 +0,0 @@
-// TODO - import from `flo-poly` in the future
-import { ddMultDouble2 } from "double-double";
-import { ddAddDd } from "double-double";
-import { γγ } from '../error-analysis/gamma.js';
-
-
-// We *have* to do the below❗ The assignee is a getter❗ The assigned is a pure function❗ Otherwise code is too slow❗
-const qmd = ddMultDouble2;
-const qaq = ddAddDd;
-
-const { abs } = Math;
-
-const γγ3 = γγ(3);
-
-
-/**
- * Deflates the given polynomial *approximately* by removing a factor (x - t).
- * 
- * @param p a polynomial with coefficients given densely as an array of 
- * double-double precision floating point numbers from highest to lowest power, 
- * e.g. `[[0,5],[0,-3],[0,0]]` represents the polynomial `5x^2 - 3x`
- * @param pE the coefficient-wise absolute error of the input polynomial that
- * still need to be multiplied by γγ3, i.e. it is `γγ3` times too big.
- * @param t an evaluation point of the polynomial.
- * 
- * @example
- * ```typescript
- * // The polynomial x^3 - 5x^2 + 8x - 4 has a root at 1 and a double root at 2 
- * ddDeflate([[0,1], [0,-5], [0,8], [0,-4]], [0,2]); //=> [[0,1], [0,-3], [0,2]] 
- * ddDeflate([[0,1], [0,-3], [0,2], [0,2]);          //=> [[0,1], [0,-1]] 
- * ddDeflate([[0,1], [0,-1]], [0,1]);                //=> [[0,1]]
- * ```
- * 
- * @doc
- */
-function ddDeflateWithRunningError(
-        p: number[][],
-        pE: number[],
-        t: number): {
-            coeffs: number[][];
-            errBound: number[];
-        } {
-
-    //--------------------------------------------------------------------------
-    // `var` -> a variable
-    // `$var` -> the double precision approximation to `var`
-    // `_var` -> the absolute value of $var (a prefix underscore on a variable means absolute value)
-    // `var_` -> the error in var (a postfix underscore means error bound but should still be multiplied by 3*γ²)
-    // `_var_` -> means both absolute value and absolute error bound
-    // recall: `a*b`, where both `a` and `b` have errors |a| and |b| we get for the
-    //   * error bound of (a*b) === a_|b| + |a|b_ + |a*b|   (when either of a and b is double)
-    //   * error bound of (a*b) === a_|b| + |a|b_ + 2|a*b|  (when both a and b is double-double)
-    //   * error bound of (a+b) === a_ + b_ + |a+b|         (when a and/or b is double or double-double)
-    // * the returned errors need to be multiplied by 3γ² to get the true error
-    // * can use either `$var` or `var[var.length-1]` (the approx value) in error calculations
-    //   due to multiplication by 3*γ² and not 3*u²
-    //--------------------------------------------------------------------------
-    const d = p.length - 1;
-    const bs = [p[0]];    // coefficients
-    let b_ = pE[0];       // running error
-    const bEs = [b_];     // coefficient-wise error bound
-
-    for (let i=1; i<d; i++) {
-        // p[i] + t*bs[i-1];
-
-        const a = bs[i-1];
-        const $m = t*a[1];
-        const _t = abs(t);
-        const m_ = _t*b_ + abs($m);
-
-        const pi = p[i];
-        const p_ = pE[i];
-        b_ = p_ + m_ + abs(pi[1] + $m);
-
-        const b = qaq(pi,qmd(t,a));
-
-        bs.push(b);
-        bEs.push(b_);
-    }
-
-    return {
-        coeffs: bs,
-        errBound: bEs.map(e => γγ3*e)
-    };
-}
-
-
-export { ddDeflateWithRunningError }

package/src/contact-point/contact-point.ts

@@ -1,42 +0,0 @@
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { comparePoss } from '../point-on-shape/compare-poss.js';
-import { Circle } from '../geometry/circle.js';
-
-
-/**
- * Represents a point on the shape boundary for which MAT data has been
- * calculated.  
- */
-interface ContactPoint {
-    /** Identifies the point on the shape boundary. */
-    pointOnShape: PointOnShape;
-    /** The maximal disk circle touching this point. */
-    circle: Circle;
-    /** Internally used to order two points lying at the same planar point. */
-    order: number;
-    /** Internally used to order two points lying at the same planar point. */
-    order2: number;
-}
-
-
-/**
- * Primarily for internal use.
- * 
- * Compares the two contact points according to their order along the shape
- * boundary. Returns > 0 if a > b, < 0 if a < b or 0 if a === b.
- * @param a The first contact point.
- * @param b The second contact point.
- */
-function compareCps(a: ContactPoint, b: ContactPoint) {
-    let res = comparePoss(a.pointOnShape, b.pointOnShape);
-
-    if (res !== 0) { return res; }
-
-    res = a.order - b.order;
-    if (res !== 0) { return res; }
-
-    return a.order2 - b.order2;
-} 
-
-
-export { ContactPoint, compareCps }

package/src/cp-node/fs/get-avg-speed.ts

@@ -1,31 +0,0 @@
-import { totalAbsoluteCurvature, totalLength } from "flo-bezier3";
-import { memoize } from "flo-memoize";
-import { totalCurvature$ } from "../../bezier/total-curvature.js";
-import { CpNode } from "../cp-node.js";
-import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
-import { getRealProngCount } from "./get-real-prong-count.js";
-
-const { min, abs } = Math;
-
-
-const getAvgSpeed$ = memoize(getAvgSpeed);
-
-
-function getAvgSpeed(cpNode: CpNode): number | undefined {
-    if (getRealProngCount(cpNode) !== 2) {
-        return 0;
-    }
-
-    const { radius: r } = cpNode.cp.circle;
-    const matPs = getMatCurveToNext(cpNode);
-    const T = totalCurvature$(matPs);
-    const l = totalLength(matPs);
-    if (l === 0) {
-        return undefined;
-    }
-    
-    return -r*T/l;
-}
-
-
-export { getAvgSpeed, getAvgSpeed$ }