flo-mat 2.0.3 → 2.0.5

package/browser/index.js

@@ -24,32 +24,32 @@ var __webpack_exports__ = {};
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  "M1": () => (/* reexport */ CpNode),
-  "bt": () => (/* reexport */ PointOnShape),
-  "A3": () => (/* reexport */ beziersToSvgPathStr),
-  "zh": () => (/* reexport */ drawBranch),
-  "Ls": () => (/* reexport */ drawElemFunctions),
-  "CU": () => (/* reexport */ drawMat),
-  "gM": () => (/* reexport */ enableDebugForMat),
-  "SQ": () => (/* reexport */ findMats),
-  "BG": () => (/* reexport */ getBoundaryBezierPartsToNext),
-  "Ij": () => (/* reexport */ getBoundaryBeziersToNext),
-  "tQ": () => (/* reexport */ getBoundaryPieceBeziers),
-  "C_": () => (/* reexport */ getBranches),
-  "aS": () => (/* reexport */ getClosestBoundaryPoint),
-  "DZ": () => (/* reexport */ getClosestSquareDistanceToRect),
-  "wH": () => (/* reexport */ getCurveBetween),
-  "N0": () => (/* reexport */ getCurveToNext),
-  "Jt": () => (/* reexport */ getPathsFromStr),
-  "tO": () => (/* reexport */ getShapeBounds),
-  "bQ": () => (/* reexport */ loop_loopFromBeziers),
-  "UW": () => (/* reexport */ simplifyMat),
-  "_T": () => (/* reexport */ simplifyMatMapOnly),
-  "Dw": () => (/* reexport */ sweep_line_sweepLine),
-  "xs": () => (/* reexport */ toScaleAxis),
-  "y9": () => (/* reexport */ traverseEdges),
-  "Fw": () => (/* reexport */ traverseVertices),
-  "QE": () => (/* reexport */ trimMat)
+  M1: () => (/* reexport */ CpNode),
+  bt: () => (/* reexport */ PointOnShape),
+  A3: () => (/* reexport */ beziersToSvgPathStr),
+  zh: () => (/* reexport */ drawBranch),
+  Ls: () => (/* reexport */ drawElemFunctions),
+  CU: () => (/* reexport */ drawMat),
+  gM: () => (/* reexport */ enableDebugForMat),
+  SQ: () => (/* reexport */ findMats),
+  BG: () => (/* reexport */ getBoundaryBezierPartsToNext),
+  Ij: () => (/* reexport */ getBoundaryBeziersToNext),
+  tQ: () => (/* reexport */ getBoundaryPieceBeziers),
+  C_: () => (/* reexport */ getBranches),
+  aS: () => (/* reexport */ getClosestBoundaryPoint),
+  DZ: () => (/* reexport */ getClosestSquareDistanceToRect),
+  wH: () => (/* reexport */ getCurveBetween),
+  N0: () => (/* reexport */ getCurveToNext),
+  Jt: () => (/* reexport */ getPathsFromStr),
+  tO: () => (/* reexport */ getShapeBounds),
+  bQ: () => (/* reexport */ loop_loopFromBeziers),
+  UW: () => (/* reexport */ simplifyMat),
+  _T: () => (/* reexport */ simplifyMatMapOnly),
+  Dw: () => (/* reexport */ sweep_line_sweepLine),
+  xs: () => (/* reexport */ toScaleAxis),
+  y9: () => (/* reexport */ traverseEdges),
+  Fw: () => (/* reexport */ traverseVertices),
+  QE: () => (/* reexport */ trimMat)
 });
 
 ;// CONCATENATED MODULE: ./node_modules/flo-boolean/node/svg/beziers-to-svg-path-str.js
@@ -937,52 +937,33 @@ function dot(a, b) {
 }
 
 //# sourceMappingURL=dot.js.map
-;// CONCATENATED MODULE: ./node_modules/flo-memoize/node/index.js
-
-
-const SUPPORTED = typeof WeakMap === 'function';
-/**
- * Memoize (by reference on the input parameter) the given arity 1 function.
- */
-function memoize(f) {
-    if (!SUPPORTED) {
-        return f;
-    }
-    const results = new WeakMap();
-    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;
-    };
-}
-/**
- * Memoize (by reference on the ordered input parameters) the given arity 2 function.
- */
-function memoize2(f) {
-    if (!SUPPORTED) {
-        return f;
-    }
-    const results = new WeakMap();
-    return function (a, b) {
-        let result = pairMap_get(results, a, b);
-        if (result !== undefined) {
-            //console.log('cache hit');
-            return result;
-        }
-        //console.log('cache miss');
-        result = f(a, b);
-        pairMap_set(results, a, b, result);
-        return result;
-    };
-}
-
-//# sourceMappingURL=index.js.map
+;// CONCATENATED MODULE: ./node_modules/flo-memoize/node/memoize.js
+/**
+ * Memoize (by reference on the input parameter) the given arity 1 function.
+ *
+ * * the input parameter must be an `object` (so it can be used as a key to
+ * `WeakMap` and thus garbage collected later; this is especially important
+ * in functional programming where a lot of garbage collection takes place;
+ *
+ * * use `memoizePrimitive` instead if it is not important that the keys
+ * will *never* be garbage collected
+ */
+function memoize(f) {
+    const results = new WeakMap();
+    return function (t) {
+        let r = results.get(t);
+        if (r !== undefined) {
+            //console.log('cache hit');
+            return r;
+        }
+        //console.log('cache miss');
+        r = f(t);
+        results.set(t, r);
+        return r;
+    };
+}
+
+//# sourceMappingURL=memoize.js.map
 ;// CONCATENATED MODULE: ./node_modules/flo-bezier3/node/local-properties-at-t/evaluate/double/eval-de-casteljau.js
 /**
  * Returns the resulting point of evaluating the given bezier curve at the
@@ -9840,6 +9821,7 @@ function completeLoop(expMax, takenOuts, out) {
     // Move immediately to the outgoing start of the loop
     let out_ = out;
     let additionalBezier;
+    // console.log(out_);
     do {
         takenOuts.add(out_); // Mark this intersection as taken
         const { beziers: additionalBeziers, in_, inBez } = getBeziersToNextContainer(expMax, out_);
@@ -10939,43 +10921,53 @@ function getLoopsFromTree(root) {
 }
 
 //# sourceMappingURL=get-loops-from-tree.js.map
-;// CONCATENATED MODULE: ./node_modules/flo-bezier3/node/boxes/are-boxes-intersecting.js
-/**
- * Returns `true` if the 2 given axis-aligned rectangular boxes intersect.
- *
- * * **exact**: not susceptible to floating point round-off
- *
- * @param closed if `true`, interpret boxes as being closed (i.e. they contain
- * their border), otherwise open.
- * @param a an axis-aligned rectangular box (given by an array of two points,
- * e.g. `[[1,2], [3,4]]`)
- * @param b another axis-aligned rectangular box
- *
- * @doc mdx
- */
-function areBoxesIntersecting(closed, a, b) {
-    let [[ax0, ay0], [ax1, ay1]] = a;
-    let [[bx0, by0], [bx1, by1]] = b;
-    // Swap so smaller coordinate comes first
-    if (ay0 > ay1) {
-        [ay0, ay1] = [ay1, ay0];
-    }
-    if (by0 > by1) {
-        [by0, by1] = [by1, by0];
-    }
-    if (ax0 > ax1) {
-        [ax0, ax1] = [ax1, ax0];
-    }
-    if (bx0 > bx1) {
-        [bx0, bx1] = [bx1, bx0];
-    }
-    return closed
-        ? ax0 <= bx1 && ax1 >= bx0 &&
-            by0 <= ay1 && by1 >= ay0
-        : ax0 < bx1 && ax1 > bx0 &&
-            by0 < ay1 && by1 > ay0;
-}
-
+;// CONCATENATED MODULE: ./node_modules/flo-boolean/node/are-boxes-intersecting.js
+/**
+ * Returns `true` if the 2 given axis-aligned rectangular boxes intersect.
+ *
+ * * **exact**: not susceptible to floating point round-off
+ *
+ * @param closed if `true`, interpret boxes as being closed (i.e. they contain
+ * their border), otherwise open.
+ * @param a an axis-aligned rectangular box (given by an array of two points,
+ * e.g. `[[1,2], [3,4]]`)
+ * @param b another axis-aligned rectangular box
+ *
+ * @doc mdx
+ */
+function areBoxesIntersecting(closed, a, b) {
+    let [[ax0, ay0], [ax1, ay1]] = a;
+    let [[bx0, by0], [bx1, by1]] = b;
+    // Swap so smaller coordinate comes first
+    if (ay0 > ay1) {
+        [ay0, ay1] = [ay1, ay0];
+    }
+    if (by0 > by1) {
+        [by0, by1] = [by1, by0];
+    }
+    if (ax0 > ax1) {
+        [ax0, ax1] = [ax1, ax0];
+    }
+    if (bx0 > bx1) {
+        [bx0, bx1] = [bx1, bx0];
+    }
+    const closedX = closed || (ax0 === ax1 && bx0 === bx1);
+    const closedY = closed || (ay0 === ay1 && by0 === by1);
+    return ((closedX ? ax0 <= bx1 : ax0 < bx1) &&
+        (closedX ? ax1 >= bx0 : ax1 > bx0) &&
+        (closedY ? by0 <= ay1 : by0 < ay1) &&
+        (closedY ? by1 >= ay0 : by1 > ay0));
+    // return closed
+    //     ? ax0 <= bx1 &&
+    //       ax1 >= bx0 && 
+    //       by0 <= ay1 &&
+    //       by1 >= ay0
+    //     : ax0 < bx1 &&
+    //       ax1 > bx0 && 
+    //       by0 < ay1 &&
+    //       by1 > ay0
+}
+
 //# sourceMappingURL=are-boxes-intersecting.js.map
 ;// CONCATENATED MODULE: ./node_modules/flo-boolean/node/calc-containers/are-containers-intersecting.js
 
@@ -18324,6 +18316,9 @@ function boxExpToBox(boxExp) {
 function getInOutsViaSides(container, ioIdx) {
     // We check one __X__ for each curve with an intersection within this container
     const xs_ = container.xs;
+    //if (xs_.length === 4) {
+    //    console.log(xs_.map(x => x.x.kind))
+    //}
     const inOuts = [];
     // get a map from each Curve to each __X__ of this container
     const xMap = new Map();
@@ -18496,6 +18491,7 @@ function getInOutsViaCrossing(container, ioIdx) {
 function getContainerInOuts(container, ioIdx) {
     // We check one __X__ for each curve with an intersection within this container
     const xs = container.xs;
+    // console.log(xs);
     // Check nature of Xs. If Xs is the very common case where two curves cross
     // we can use a faster check. Also in the bit less common case where all
     // curves are joining at an interface we can do a fast ccw (the ccw part
@@ -20828,6 +20824,7 @@ function makeSimpleX(t, curve, kind) {
 
 
 
+
 /**
  * Returns the pairs of intersection `t` values between the curves. Interface
  * intersections may not be returned - they should already be caught.
@@ -20846,7 +20843,9 @@ function getCurvesIntersections(expMax) {
             // curves are connected at endpoints
             // closed bounding boxes are guaranteed to intersect - don't check
             // check open bounding boxes
-            const aabbsIntersectOpen = areBoxesIntersecting(false, getBoundingBox_(psA), getBoundingBox_(psB));
+            const aabbsIntersectOpen = areBoxesIntersecting(false, 
+            // const aabbsIntersectOpen = areBoxesIntersecting(true,
+            getBoundingBox_(psA), getBoundingBox_(psB));
             if (!aabbsIntersectOpen) {
                 return checkEndpoints(curveA, curveB);
             }
@@ -20924,15 +20923,18 @@ function getLineLineIntersections(curveA, curveB, expMax) {
     let psB = curveB.ps;
     const bbA = getBoundingBox_(psA);
     const bbB = getBoundingBox_(psB);
+    // if (equal(psA,[[4,8],[4,7]]) && equal(psB,[[4,6],[4,8]])) {
+    //     console.log('testing');
+    // }
     if (curveA.next !== curveB && curveB.next !== curveA) {
-        // the two lines are not connected at their endpoints
+        // the two line curves are not consecutive in the loop
         if (areBoxesIntersecting(true, bbA, bbB)) {
             const xs = getIntersection(curveA, curveB, expMax, false);
             return xs.length ? xs : undefined;
         }
         return undefined;
     }
-    // the two lines are connected at their endpoints
+    // the two line curves are consecutive in the loop
     const swap = curveB.next === curveA;
     if (swap) {
         [curveA, curveB] = [curveB, curveA];
@@ -20952,16 +20954,14 @@ function getLineLineIntersections(curveA, curveB, expMax) {
     }
     // it is a line going back on itself 
     // - return endpoint intersections
-    const lenCurve1 = squared_distance_between_squaredDistanceBetween(psA[0], psA[1]);
-    const lenCurve2 = squared_distance_between_squaredDistanceBetween(psB[0], psB[1]);
+    const lenCurveA = squared_distance_between_squaredDistanceBetween(psA[0], psA[1]);
+    const lenCurveB = squared_distance_between_squaredDistanceBetween(psB[0], psB[1]);
     let tPair;
-    if (lenCurve1 > lenCurve2) {
-        // tPair = [inversion01Precise(psA, psB[1]), 1];
+    if (lenCurveA > lenCurveB) {
         const t0 = mid(closestPointOnBezierCertified(psA, psB[1])[0].ri);
         tPair = [t0, 1];
     }
     else {
-        // tPair = [0, inversion01Precise(psB, psA[0])];
         const t1 = mid(closestPointOnBezierCertified(psB, psA[0])[0].ri);
         tPair = [0, t1];
     }
@@ -21799,6 +21799,35 @@ function compareOrderedInOut(inOutA, inOutB) {
 }
 
 //# sourceMappingURL=compare-in-out.js.map
+;// CONCATENATED MODULE: ./node_modules/flo-boolean/node/calc-containers/filter-containers.js
+/**
+ * Returns the containers that is the given containers filtered so that those
+ * having only interface intersections or only a single (given as a pair) even
+ * multiple intersection are not included.
+ * @param containers
+ */
+function filterContainers(containers) {
+    const containers_ = containers.filter(container => {
+        const xs = container.xs;
+        if (container.xs.length === 2) {
+            const _x_ = xs[0];
+            if (_x_.x.kind === 1 && _x_.x.ri.multiplicity % 2 === 0) {
+                // multiple even intersection - exclude
+                return false;
+            }
+        }
+        for (const x of container.xs) {
+            if (x.x.kind !== 4) {
+                // include container if any __X__ is not an interface
+                return true;
+            }
+        }
+        return false; // exclude container
+    });
+    return containers_;
+}
+
+//# sourceMappingURL=filter-containers.js.map
 ;// CONCATENATED MODULE: ./node_modules/flo-boolean/node/calc-containers/get-containers.js
 
 
@@ -21813,6 +21842,7 @@ function compareOrderedInOut(inOutA, inOutB) {
 
 
 
+
 /**
  *
  * @param containerDim
@@ -21826,10 +21856,10 @@ function getContainers(loops, containerDim, expMax) {
     const xs3 = getInterfaceIntersections(loops);
     const { extremes, xs: xs4 } = getExtremes(loops);
     let xPairs = [...xs1, ...xs2, ...xs3, ...xs4];
-    //console.log('general  ', xs1);
-    //console.log('self     ', xs2);
-    //console.log('interface', xs3);
-    //console.log('topmost  ', xs4);
+    // console.log('general  ', xs1);
+    // console.log('self     ', xs2);
+    // console.log('interface', xs3);
+    // console.log('topmost  ', xs4);
     if (typeof _debug_ !== 'undefined') {
         for (const xPair of xs1) {
             _debug_.generated.elems.intersection.push(...xPair);
@@ -21927,32 +21957,6 @@ function getContainers(loops, containerDim, expMax) {
     }
     return { extremes, containers };
 }
-/**
- * Returns the containers that is the given containers filtered so that those
- * having only interface intersections or only a single (given as a pair) even
- * multiple intersection are not included.
- * @param containers
- */
-function filterContainers(containers) {
-    const containers_ = containers.filter(container => {
-        const xs = container.xs;
-        if (container.xs.length === 2) {
-            const _x_ = xs[0];
-            if (_x_.x.kind === 1 && _x_.x.ri.multiplicity % 2 === 0) {
-                // multiple even intersection - exclude
-                return false;
-            }
-        }
-        for (const x of container.xs) {
-            if (x.x.kind !== 4) {
-                // include container if any __X__ is not an interface
-                return true;
-            }
-        }
-        return false; // exclude container
-    });
-    return containers_;
-}
 function getLeftMost(container) {
     return container.box[0][0];
 }
@@ -22227,6 +22231,33 @@ function toLength(p, length) {
 }
 
 //# sourceMappingURL=to-length.js.map
+;// CONCATENATED MODULE: ./node_modules/flo-bezier3/node/simultaneous-properties/equal.js
+/**
+ * Returns `true` if the two given bezier curves are exactly equal when compared
+ * by value (deep equality), `false` otherwise
+ *
+ * @param ps1 an order 0,1,2 or 3 bezier curve given as an ordered array of its
+ * control points, e.g. `[[0,0],[1,1],[2,1],[2,0]]`
+ * @param ps2 another bezier curve
+ *
+ * @doc
+ */
+function equal_equal(ps1, ps2) {
+    if (ps1 === ps2) {
+        return true;
+    }
+    if (ps1.length !== ps2.length) {
+        return false;
+    }
+    for (let i = 0; i < ps1.length; i++) {
+        if (ps1[i][0] !== ps2[i][0] || ps1[i][1] !== ps2[i][1]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+//# sourceMappingURL=equal.js.map
 ;// CONCATENATED MODULE: ./node_modules/flo-boolean/node/loop/normalize/are-all-points-different.js
 /**
  * Returns true if all points in the given array are different, false otherwise.
@@ -22257,6 +22288,9 @@ const { abs: fix_bezier_by_point_spacing_abs } = Math;
  * @param ps A bezier
  */
 function fixBezierByPointSpacing(ps, gridSpacing, sendToGrid) {
+    if (ps === undefined) {
+        return undefined;
+    }
     // Early filter - if all points coincide, we're done - degenerate to point
     if (isReallyPoint(ps)) {
         return undefined; // Cannot fix
@@ -22276,9 +22310,8 @@ function fixBezierByPointSpacing(ps, gridSpacing, sendToGrid) {
         // Is the quadratic bezier overlapping onto itself? 
         if (arePsEqual(ps[0], ps[2])) {
             // a quadratic with equal endpoints (and not degenerate to a point)
-            // The overlap is of no consequence to the algorithm so make it a
-            // line
-            return [ps[0], ps[1]];
+            return undefined; // better to just remove it
+            // return [ps[0], ps[1]];
         }
         // At this point not all points same and not all points different and 
         // not endpoints coincide, so either:
@@ -22290,28 +22323,42 @@ function fixBezierByPointSpacing(ps, gridSpacing, sendToGrid) {
     // ---- at this point we must have a cubic
     // Early filter - if no points coincide, we're done - well spaced
     if (areAllPointsDifferent(ps)) {
-        return checkCubicForLineOrQuad(ps);
+        const ps_ = checkCubicForLineOrQuad(ps);
+        if (ps_ === undefined) {
+            return undefined;
+        }
+        if (equal_equal(ps_, ps)) {
+            return ps;
+        }
+        return fixBezierByPointSpacing(ps_, gridSpacing, sendToGrid);
     }
     if (arePsEqual(ps[0], ps[3])) {
         // we should simply handle this case for cubics - lines and quadratics 
         // degenerate into a point and a self-overlapping curve respectively.
-        if (arePsEqual(ps[1], ps[2])) {
-            // it is a cubic degenerated to a line
-            return [ps[0], ps[2]];
+        // if (isCollinear(ps)) { return [ps[0], ps[3]]; }
+        if (isCollinear(ps)) {
+            return undefined;
         }
+        // if (arePsEqual(ps[1], ps[2])) {
+        //     // it is a cubic degenerated to a line
+        //     return [ps[0], ps[2]];
+        // }
         // no need to fix anything - it is a loop - it cannot be a line or a
         // quadratic (they don't make loops)
         return ps;
     }
+    if (isCollinear(ps)) {
+        return [ps[0], ps[3]];
+    }
     // At this point, either:
     // * point 0, 1 and 2 coincide
     // * point 1, 2 and 3 coincide
     // * points 0,1 AND points 2,3 coincide
-    // * only point 0 and point 1 coincides
-    // * only point 0 and point 2 coincides        
-    // * only point 1 and point 2 coincides
-    // * only point 1 and point 3 coincides
-    // * only point 2 and point 3 coincides
+    // * only point 0 and point 1 coincide
+    // * only point 0 and point 2 coincide
+    // * only point 1 and point 2 coincide
+    // * only point 1 and point 3 coincide
+    // * only point 2 and point 3 coincide
     // If point 0, 1 and 2 coincide OR point 1, 2 and 3 coincide OR
     // points 0,1 AND points 2,3 coincide we have a line
     if ((arePsEqual(ps[0], ps[1]) &&
@@ -22320,17 +22367,24 @@ function fixBezierByPointSpacing(ps, gridSpacing, sendToGrid) {
             arePsEqual(ps[2], ps[3])) ||
         (arePsEqual(ps[0], ps[1]) &&
             arePsEqual(ps[2], ps[3]))) {
+        return fixBezierByPointSpacing([ps[0], ps[ps.length - 1]], gridSpacing, sendToGrid);
+        /*
         // Check if first and last point are sufficiently far apart to split
         // the bezier into a line so that all points differ.
-        if (fix_bezier_by_point_spacing_abs(ps[0][0] - ps[3][0]) > (3 + 1) * gridSpacing ||
-            fix_bezier_by_point_spacing_abs(ps[0][1] - ps[3][1]) > (3 + 1) * gridSpacing) {
-            return [ps[0], ps[ps.length - 1]];
-        }
-        else {
+
+        // TODO2 - is below maybe not correct?
+        //if ((ps[0][0] - ps[3][0]) > (3+1)*gridSpacing ||
+        //    (ps[0][1] - ps[3][1]) > (3+1)*gridSpacing) {
+        if (abs(ps[0][0] - ps[3][0]) > (3+1)*gridSpacing ||
+            abs(ps[0][1] - ps[3][1]) > (3+1)*gridSpacing) {
+
+            return [ps[0], ps[ps.length-1]];
+        } else {
             // Points are not sufficiently far apart to resolve onto grid -
             // cannot fix it - it is basically a point.
+
             return undefined;
-        }
+        }*/
     }
     // At this point, either:
     // * only point 0 and point 1 coincides
@@ -22360,12 +22414,7 @@ function fixBezierByPointSpacing(ps, gridSpacing, sendToGrid) {
         // move them onto each other - this shouldn't affect the overall 
         // accuracy of the algorithm and it ensures the move > gridSpacing.
         if (squared_distance_between_squaredDistanceBetween(ps[1], ps[2]) < 4 * gridSpacing) {
-            return [
-                ps[0],
-                ps[2],
-                ps[2],
-                ps[3]
-            ]; // cannot be a line or quad
+            return [ps[0], ps[2], ps[2], ps[3]]; // cannot be a line or quad
         }
         else {
             const v = toLength(fromTo(ps[1], ps[2]), 2 * gridSpacing);
@@ -22728,10 +22777,11 @@ function simplifyPaths(bezierLoops, maxCoordinate) {
      * A size (based on the max value of the tangent) for the containers holding
      * critical points.
      */
-    const containerSizeMultiplier = 2 ** 4;
-    //const containerSizeMultiplier = 2**39;
+    const containerSizeMultiplier = 2 ** 4; // TODO2 - put back!!
+    // const containerSizeMultiplier = 2**36;
     const containerDim = gridSpacing * containerSizeMultiplier;
     bezierLoops = normalizeLoops(bezierLoops, maxBitLength, expMax, false, true);
+    // console.log(bezierLoops)
     addDebugInfo1(bezierLoops);
     bezierLoops.sort(orderLoopAscendingByMinY);
     const loops = bezierLoops.map((loop, i) => loopFromBeziers(loop, i));
@@ -23228,8 +23278,6 @@ function evaluate(ps, t) {
 
 //# sourceMappingURL=evaluate.js.map
 ;// CONCATENATED MODULE: ./src/mat/closest-boundary-point/closest-points-on-curve.ts
-// qqq import { deflateQuad, allRootsMultiWithErrBounds, RootInterval } from 'flo-poly';
-// qqq import { getTangentPolyFromPointExact, evalDeCasteljau, evaluate, getFootpointPolyExact } from 'flo-bezier3';
 
 
 /**
@@ -23241,13 +23289,10 @@ function evaluate(ps, t) {
  * @param t The t value of the bezier that locates p
  */
 function closestPointsOnCurve(curve, p, [tS, tE] = [0, 1], touchedCurve, t) {
-    // qqq let poly = getTangentPolyFromPointExact(curve.ps, p);
     const _poly = getFootpointPolyDd(curve.ps, p);
-    // qqq poly = deflateQuad(poly, t);
     const poly = curve === touchedCurve
         ? ddDeflate(_poly, t)
         : _poly;
-    // let roots: Omit<RootInterval,'multiplicity'>[] = allRootsMultiWithErrBounds(
     const roots = allRootsCertified(poly, tS, tE);
     // Also test the endpoints
     let push0 = true;
@@ -23294,8 +23339,16 @@ function closestPointsOnCurve(curve, p, [tS, tE] = [0, 1], touchedCurve, t) {
             ? 0
             : tE > 1 ? 1 : (tS + tE) / 2;
         // TODO - why does evalDeCasteljau not work here?
-        return { p: evaluate(curve.ps, t), t };
         //return { p: evalDeCasteljau(curve.ps,t), t }
+        // TODO2 - will make it slower
+        // const aa = evaluate(curve.ps,t);
+        // const bb = evalDeCasteljauDd(curve.ps,[0,t]).map(v => v[1]);
+        // if (aa[0] !== bb[0] || aa[1] !== bb[1]) {
+        //     console.log(aa);
+        //     console.log(bb);
+        // }
+        return { p: evaluate(curve.ps, t), t };
+        // return { p: evalDeCasteljauDd(curve.ps,[0,t]).map(v => v[1]), t }
     });
     return ps;
 }
@@ -23804,12 +23857,7 @@ function addToCpGraph(circle, orders, cpTrees, poss, neighbors) {
 
 
 /** @hidden */
-//const ANGLE_THRESHOLD = Math.cos(3 * (Math.PI / 180)); // 3 degrees
-const ANGLE_THRESHOLD = 0.9986295347545738; // === Math.cos(3  degrees)
-//const ANGLE_THRESHOLD = 0.9848077530122080; // === Math.cos(10 degrees)
-//const ANGLE_THRESHOLD = 0.9998476951563913; // === Math.cos(1 degrees)
-//const ANGLE_THRESHOLD = 0.9999984769132877; // === Math.cos(0.1 degrees)   
-//const ANGLE_THRESHOLD = 0.9999999847691291  // === Math.cos(0.01 degrees)   
+const ANGLE_THRESHOLD = Math.cos(15 * (Math.PI / 180)); // 15 degrees
 /**
  * @hidden
  * Returns true if another CpNode is close to the given implied (via pos, order
@@ -23824,15 +23872,7 @@ const ANGLE_THRESHOLD = 0.9986295347545738; // === Math.cos(3  degrees)
  * @param color Used for debugging only
  */
 function isAnotherCpCloseby(cpTrees, pos, circle, order, order2, extreme, color) {
-    //console.log(extreme)
-    //const DISTANCE_THRESHOLD = extreme * 1e-1; 
-    //const DISTANCE_THRESHOLD = extreme * 1e-1;
     const DISTANCE_THRESHOLD = extreme * 1e-4;
-    //const DISTANCE_THRESHOLD = extreme * 1e-4; - was this
-    //const DISTANCE_THRESHOLD = extreme * 1e-6;
-    //const DISTANCE_THRESHOLD = extreme * 1e-12;
-    // It seems this can be zero else the ordering should be correct
-    //const DISTANCE_THRESHOLD = 0;
     const cpTree = cpTrees.get(pos.curve.loop);
     const cpNodes = getNeighbouringPoints(cpTree, pos, order, order2);
     if (!cpNodes[0]) {
@@ -23845,11 +23885,13 @@ function isAnotherCpCloseby(cpTrees, pos, circle, order, order2, extreme, color)
         if (distanceBetween(p1, p2) > DISTANCE_THRESHOLD) {
             continue;
         }
-        const v1 = toUnitVector(fromTo(cpNode.cp.pointOnShape.p, cpNode.cp.circle.center));
+        // TODO2
+        return true;
+        const v1 = toUnitVector(fromTo(p2, cpNode.cp.circle.center));
         const v2 = toUnitVector(fromTo(p1, circle.center));
         const cosTheta = dot(v1, v2);
         if (cosTheta > ANGLE_THRESHOLD) {
-            //console.log(`%c${cosTheta} - ${distanceBetween(p1,p2)}`, `color: ${color}`);
+            // console.log(`%c${cosTheta} - ${distanceBetween(p1,p2)}`, `color: ${color}`);
             return true;
         }
     }
@@ -23874,24 +23916,27 @@ function add3Prong(cpTrees, orders, threeProng) {
     /*
     if (typeof _debug_ !== 'undefined') {
         for (let i=0; i<3; i++) {
-            let cpBef = threeProng.δ3s[i][0].cp;
-            let cpAft = threeProng.δ3s[i][1].cp;
-            //let cmpBef = PointOnShape.compareInclOrder(cpBef.pointOnShape, ps[i], cpBef.order, orders[i]);
-            //let cmpAft = PointOnShape.compareInclOrder(cpAft.pointOnShape, ps[i], cpAft.order, orders[i]);
+            const cpBef = threeProng.δ3s[i][0].cp;
+            const cpAft = threeProng.δ3s[i][1].cp;
 
-            let cmpBef = PointOnShape.compare(cpBef.pointOnShape, ps[i]);
-            let cmpAft = PointOnShape.compare(cpAft.pointOnShape, ps[i]);
+            //let cmpBef = PointOnShape.compareInclOrder(cpBef.pointOnShape, poss[i], cpBef.order, orders[i]);
+            //let cmpAft = PointOnShape.compareInclOrder(cpAft.pointOnShape, poss[i], cpAft.order, orders[i]);
+            const cmpBef = compareCps(cpBef, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
+            const cmpAft = compareCps(cpAft, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
+
+            // const cmpBef = comparePoss(cpBef.pointOnShape, poss[i]);
+            // const cmpAft = comparePoss(cpAft.pointOnShape, poss[i]);
 
             // len is used by debug functions to reference a particular
             // three-prong.
-            let len = _debug_.generated.elems.threeProng.length-1;
+            const len = _debug_.generated.elems.threeProng.length-1;
             if (cmpBef > 0) {
                 console.log('----------------------------------------');
                 console.log(`3-prong order is wrong (bef) : i: ${i} - cmp: ${cmpBef} - n: ${len}`);
                 console.log(threeProng);
                 console.log(cpBef);
                 console.log(cpAft);
-                console.log(ps[i]);
+                console.log(poss[i]);
             }
             if (cmpAft < 0) {
                 console.log('----------------------------------------');
@@ -23899,15 +23944,16 @@ function add3Prong(cpTrees, orders, threeProng) {
                 console.log(threeProng);
                 console.log(cpBef);
                 console.log(cpAft);
-                console.log(ps[i]);
+                console.log(poss[i]);
             }
         }
     }
     */
     // TODO - replace 1000 below with correct value
-    isAnotherCpCloseby(cpTrees, poss[0], circle, orders[0], 0, 1000, 'blue');
-    isAnotherCpCloseby(cpTrees, poss[1], circle, orders[1], 0, 1000, 'blue');
-    isAnotherCpCloseby(cpTrees, poss[2], circle, orders[2], 0, 1000, 'blue');
+    const c1 = isAnotherCpCloseby(cpTrees, poss[0], circle, orders[0], 0, 1000, 'blue');
+    const c2 = isAnotherCpCloseby(cpTrees, poss[1], circle, orders[1], 0, 1000, 'blue');
+    const c3 = isAnotherCpCloseby(cpTrees, poss[2], circle, orders[2], 0, 1000, 'blue');
+    // console.log(c1,c2,c3);
     addToCpGraph(circle, orders, cpTrees, poss, δ3s);
     return circle;
 }
@@ -24753,7 +24799,6 @@ function getSharpCorners(possPerLoop) {
     for (const poss of possPerLoop) {
         const sharpCorners = [];
         for (const pos of poss) {
-            //if (PointOnShape.isQuiteSharpCorner(pos)) {
             if (isPosQuiteSharpCorner(pos)) {
                 sharpCorners.push(pos);
             }
@@ -25120,11 +25165,7 @@ function getCloseBoundaryPoints(bezierPieces, point, y, distance) {
         // comparing closeness!
         const indexesToCheck = [];
         for (let i = 0; i < posInfos.length; i++) {
-            const pi = posInfos[i];
-            // Only check if they are close to the edges. Why??
-            //if (pi.pos.t < 1e-2 || 1-pi.pos.t < 1e-2) {
             indexesToCheck.push(i);
-            //}
         }
         const indexesToRemove = [];
         for (let i = 0; i < indexesToCheck.length; i++) {
@@ -25191,9 +25232,11 @@ const find_2_prong_evalDeCasteljau = evalDeCasteljau;
  */
 function find2Prong(loops, extreme, squaredDiagonalLength, cpTrees, y, isHoleClosing, k) {
     const MAX_ITERATIONS = 25;
-    const squaredSeperationTolerance = (1e-6 * extreme) ** 2;
+    const squaredSeperationTolerance = (1e-5 * extreme) ** 2;
     // TODO - base deltas on theory or remove
     const oneProngTolerance = (1e-4) ** 2;
+    // const oneProngTolerance = (1e-5)**2;
+    // const oneProngTolerance = 0;
     const squaredErrorTolerance = 1e-2 * squaredSeperationTolerance;
     const maxOsculatingCircleRadiusSquared = squaredDiagonalLength;
     // The boundary piece that should contain the other point of 
@@ -25211,7 +25254,6 @@ function find2Prong(loops, extreme, squaredDiagonalLength, cpTrees, y, isHoleClo
     }
     else {
         p = y.p;
-        //x = PointOnShape.getOsculatingCircle(maxOsculatingCircleRadiusSquared, y).center;
         x = getOsculatingCircle(maxOsculatingCircleRadiusSquared, y).center;
         r = squared_distance_between_squaredDistanceBetween(p, x);
     }
@@ -25232,8 +25274,8 @@ function find2Prong(loops, extreme, squaredDiagonalLength, cpTrees, y, isHoleClo
     do {
         i++;
         /** squared distance between source boundary point and circle center */
-        const r = squared_distance_between_squaredDistanceBetween(x, y.p);
-        bezierPieces_ = cull_bezier_pieces_cullBezierPieces(bezierPieces_, x, r);
+        const xy = squared_distance_between_squaredDistanceBetween(x, y.p);
+        bezierPieces_ = cull_bezier_pieces_cullBezierPieces(bezierPieces_, x, xy);
         z = getClosestBoundaryPoint(bezierPieces_, x, y.curve, y.t);
         if (z === undefined) {
             if (typeof _debug_ !== 'undefined') {
@@ -25253,16 +25295,18 @@ function find2Prong(loops, extreme, squaredDiagonalLength, cpTrees, y, isHoleClo
             xs.push({ x, y, z: z.pos, t: y.t });
         }
         /** squared distance between anti-pode boundary point and circle center */
-        const d = squared_distance_between_squaredDistanceBetween(x, z.pos.p);
+        const xz = squared_distance_between_squaredDistanceBetween(x, z.pos.p);
         //if (i === 1 && d*oneProngTolerance >= r) {
-        if (i === 1 && r < d + oneProngTolerance) {
+        if (i === 1 && xy < xz + oneProngTolerance) {
             // It is a 1-prong.
+            // TODO2 - below line was removed (maybe)
             add1Prong(Math.sqrt(maxOsculatingCircleRadiusSquared), cpTrees, y);
             return undefined;
         }
         // TODO - squaredSeperationTolerance should in future be replaced with
         // a relative error, i.e. distance between y (or z) / length(y (or z)).
-        if (!isHoleClosing && squared_distance_between_squaredDistanceBetween(y.p, z.pos.p) <= squaredSeperationTolerance) {
+        const yz = squared_distance_between_squaredDistanceBetween(y.p, z.pos.p);
+        if (!isHoleClosing && yz <= squaredSeperationTolerance) {
             if (typeof _debug_ !== 'undefined') {
                 /*
                 let elems = _debug_.generated.elems;
@@ -25284,8 +25328,10 @@ function find2Prong(loops, extreme, squaredDiagonalLength, cpTrees, y, isHoleClo
         // nextX, but rather (distance from x to y) - (distance from x to z)
         // Find the point on the line connecting y with x that is  
         // equidistant from y and z. This will be our next x.
+        // const nextX = findEquidistantPointOnLineDd(x, y.p, z.pos.p);
         const nextX = findEquidistantPointOnLine(x, y.p, z.pos.p);
         const squaredError = squared_distance_between_squaredDistanceBetween(x, nextX);
+        // const squaredError = Math.abs(xy - xz);
         x = nextX;
         if (squaredError < squaredErrorTolerance) {
             done++; // Do one more iteration
@@ -25296,6 +25342,29 @@ function find2Prong(loops, extreme, squaredDiagonalLength, cpTrees, y, isHoleClo
             break; // We're done
         }
     } while (done < 1);
+    /************************************************************************ */
+    /* Do one more double-double precision iteration
+    /************************************************************************ */
+    /*
+    z = getClosestBoundaryPoint(
+        bezierPieces_, x, y.curve, y.t
+    );
+
+    if (z === undefined) {
+        failed = true;
+    }
+    
+    if (typeof _debug_ !== 'undefined') {
+        xs.push({ x, y, z: z.pos, t: y.t });
+    }
+    
+    if (!isHoleClosing && squaredDistanceBetween(y.p, z.pos.p) <= squaredSeperationTolerance) {
+        failed = true;
+    } else {
+        x = findEquidistantPointOnLineDd(x, y.p, z.pos.p);
+    }
+    /************************************************************************ */
+    /************************************************************************ */
     // TODO - Optimization: only do this if second closest point is within the
     // tolerance which can be checked in getClosestBoundaryPoint algorithm
     let zs = [];
@@ -25310,6 +25379,8 @@ function find2Prong(loops, extreme, squaredDiagonalLength, cpTrees, y, isHoleClo
     if (z !== undefined) {
         circle = { center: x, radius: distanceBetween(x, z.pos.p) };
     }
+    // TODO2
+    // if (Math.random() > 0.8 && !isHoleClosing) { return undefined; }
     if (typeof _debug_ !== 'undefined' && !failed) {
         xs.push({ x, y, z: z.pos, t: y.t });
         addDebugInfo(bezierPieces, failed, y, circle, z.pos, δ, xs, isHoleClosing);
@@ -26087,10 +26158,11 @@ function getInterestingPointsOnLoop(minBezLength, maxCurviness, maxLength) {
             // qqq let maxAbsCurvatures = [...maxCurvatureTs, ...maxNegativeCurvatureTs].map(t => new PointOnShape(curve, t));
             const maxAbsCurvatures = [...maxima].map(t => new PointOnShape(curve, t));
             allPoints.push(...getContactCirclesAtInterface(curve), ...maxAbsCurvatures);
-            let ts = splitByCurvatureAndLength(curve.ps, maxCurviness, maxLength);
-            if (ts.length === 2) {
-                ts = [0, 0.5, 1];
-            }
+            const ts = splitByCurvatureAndLength(curve.ps, maxCurviness, maxLength);
+            // if (ts.length > 10) { console.log(ts); }
+            // if (ts.length === 2) {
+            //     ts = [0, 0.5, 1];
+            // }
             for (let i = 1; i < ts.length - 1; i++) {
                 allPoints.push(new PointOnShape(curve, ts[i]));
             }
@@ -28295,7 +28367,7 @@ function drawOneProng(g, pos, classes, delay = 0) {
 
 /** @hidden */
 function twoProng(g, twoProng) {
-    const scaleFactor = 0.3;
+    const scaleFactor = 0.01;
     let $failedDot = [];
     let $center = [];
     let $circle = [];
@@ -28319,7 +28391,7 @@ function twoProng(g, twoProng) {
         $failedDot = drawFs.dot(g, twoProng.pos.p, 1 * scaleFactor, 'black');
     }
     else if (!twoProng.failed) {
-        $center = drawFs.dot(g, twoProng.circle.center, 1 * scaleFactor, 'yellow');
+        $center = drawFs.dot(g, twoProng.circle.center, 0.02 * scaleFactor, 'yellow');
         $circle = drawFs.circle(g, twoProng.circle, color + 'thin' + thin + ' nofill');
         $cp1 = drawFs.dot(g, twoProng.pos.p, 0.035 * scaleFactor, color);
         $cp2 = drawFs.dot(g, twoProng.z, 0.07 * scaleFactor, color);
@@ -28332,7 +28404,7 @@ function twoProng(g, twoProng) {
 
 
 /** @hidden */
-const three_prong_scaleFactor = 0.3;
+const three_prong_scaleFactor = 0.1;
 /** @hidden */
 function threeProng(g, threeProng) {
     const circle = scaleCircle(threeProng.circle, 1);