flo-mat 4.1.4 → 5.0.1

package/__tests__/get-mats1.ts

@@ -1,83 +1,90 @@
 import type { Mat } from "../src/mat/mat.js";
 import type { CpNodeStringifyable } from "../src/cp-node/stringification/cp-node-stringifyable.js";
+import type { Circle } from "../src/geometry/circle.js";
 import { findMats } from "../src/find-mat/find-mats.js";
 import { fromStringifyable } from "../src/cp-node/stringification/from-stringifyable.js";
 
 
 
-// Cache; we use this one in tests since it is fixed and not susceptible to
-// small perturbations in the algorithm.
-let mats1: Mat[] | undefined = undefined;
-function getMats1() {
-    const _cpNode: CpNodeStringifyable = {
-        cpNodes: [
-            {
-                id: 0,
-                isHoleClosing: false,
-                isIntersection: false,
-                pointOnShape: {
-                    circle: {
-                        center: [24,8],
-                        radius: 0
-                    },
-                    curveIdx: 0,
-                    loopIdx: 0,
-                    p: [24, 8],
-                    pDd: [[0,24],[0,8]],
-                    t: 1,
-                    isSource: true,
-                    order: -1,
-                    order2: 0
-                },
-                prev: 11,
-                next: 1,
-                prevOnCircle: 1,
-                nextOnCircle: 1
+// One `Circle` object per on-circle ring (shared by all the ring's `CpNode`s
+// and by no other ring) - see `PointOnShape.circle`. The fixture has no hole
+// closers, so there are no twin rings with equal-but-distinct circles.
+const circle_0_1: Circle = { center: [24, 8], radius: 0 };
+const circle_10_11: Circle = { center: [46, -5.21425847941623], radius: 13.21425847941623 };
+const circle_142_143_144: Circle = { center: [81.5, -12.641417453935567], radius: 41.064803841095305 };
+const circle_145_146_147: Circle = { center: [81.5, 18.5], radius: 35.5 };
+const circle_2_3: Circle = { center: [46, 54], radius: 0 };
+const circle_4_5: Circle = { center: [117, 54], radius: 0 };
+const circle_6_7: Circle = { center: [139, 8], radius: 0 };
+const circle_8_9: Circle = { center: [82, -101], radius: 0 };
+const circle_148_149_150: Circle = { center: [81.68410160768288, -12.970446490933696], radius: 41.07276841516263 };
+const circle_118_119: Circle = { center: [115.9110440340909, -5.952334953607174], radius: 13.994766012811272 };
+
+
+/** mat-demo: "achispado" font, "comma" glyph - fixed MAT fixture */
+const cpNodeStringifyable1: CpNodeStringifyable = {
+    cpNodes: [
+        {
+            id: 0,
+            isHoleClosing: false,
+            isIntersection: false,
+            pointOnShape: {
+                circle: circle_0_1,
+                curveIdx: 0,
+                loopIdx: 0,
+                p: [24, 8],
+                pDd: [[0,24],[0,8]],
+                t: 1,
+                isSource: true,
+                order: -1,
+                order2: 0
             },
-            { id: 1,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [24, 8],                           radius: 0                    }, curveIdx: 0, loopIdx: 0, p: [24, 8],                           t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,24],[0,8]] }, prev: 0,   next: 10,  prevOnCircle: 0,   nextOnCircle: 0   },
-            { id: 10,  isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [46, -5.21425847941623],           radius: 13.21425847941623    }, curveIdx: 1, loopIdx: 0, p: [46, 8],                           t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,46],[0,8]] }, prev: 1,   next: 144, prevOnCircle: 11,  nextOnCircle: 11  },
-            { id: 144, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, -12.641417453935567],       radius: 41.064803841095305   }, curveIdx: 1, loopIdx: 0, p: [46, 8],                           t: 1,                    isSource: false , order: -0.5026547194480646,   order2: 0, pDd: [[0,46],[0,8]] }, prev: 10,  next: 147, prevOnCircle: 143, nextOnCircle: 142 },
-            { id: 147, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, 18.5],                     radius: 35.5                 }, curveIdx: 2, loopIdx: 0, p: [46, 18.499999999999996],           t: 0.2282608695652173,   isSource: false , order: 0,                     order2: 0, pDd: [[0,46],[0,18.499999999999996]] }, prev: 144, next: 2,   prevOnCircle: 146, nextOnCircle: 145 },
-            { id: 2,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [46, 54],                         radius: 0                    }, curveIdx: 2, loopIdx: 0, p: [46, 54],                          t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,46],[0,54]] }, prev: 147, next: 3,   prevOnCircle: 3,   nextOnCircle: 3   },
-            { id: 3,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [46, 54],                         radius: 0                    }, curveIdx: 2, loopIdx: 0, p: [46, 54],                          t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,46],[0,54]] }, prev: 2,   next: 145, prevOnCircle: 2,   nextOnCircle: 2   },
-            { id: 145, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, 18.5],                     radius: 35.5                 }, curveIdx: 3, loopIdx: 0, p: [81.5, 54],                        t: 0.5,                  isSource: false , order: 0,                     order2: 0, pDd: [[0,81.5],[0,54]] }, prev: 3,   next: 4,   prevOnCircle: 147, nextOnCircle: 146 },
-            { id: 4,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [117, 54],                        radius: 0                    }, curveIdx: 3, loopIdx: 0, p: [117, 54],                         t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,117],[0,54]] }, prev: 145, next: 5,   prevOnCircle: 5,   nextOnCircle: 5   },
-            { id: 5,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [117, 54],                        radius: 0                    }, curveIdx: 3, loopIdx: 0, p: [117, 54],                         t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,117],[0,54]] }, prev: 4,   next: 146, prevOnCircle: 4,   nextOnCircle: 4   },
-            { id: 146, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, 18.5],                     radius: 35.5                 }, curveIdx: 4, loopIdx: 0, p: [117, 18.499999999999996],          t: 0.7717391304347827,   isSource: false , order: 0,                     order2: 0, pDd: [[0,117],[0,18.499999999999996]] }, prev: 5,   next: 142, prevOnCircle: 145, nextOnCircle: 147 },
-            { id: 142, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, -12.641417453935567],       radius: 41.064803841095305   }, curveIdx: 4, loopIdx: 0, p: [117, 8],                          t: 1,                    isSource: false , order: -0.8644872659655476,   order2: 0, pDd: [[0,117],[0,8]] }, prev: 146, next: 148, prevOnCircle: 144, nextOnCircle: 143 },
-            { id: 148, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.68410160768288, -12.970446490933696], radius: 41.07276841516263  }, curveIdx: 4, loopIdx: 0, p: [117, 8],                   t: 1,                    isSource: false , order: -0.8598373023056252,   order2: 0, pDd: [[0,117],[0,8]] }, prev: 142, next: 119, prevOnCircle: 150, nextOnCircle: 149 },
-            { id: 119, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [115.9110440340909, -5.952334953607174], radius: 13.994766012811272  }, curveIdx: 4, loopIdx: 0, p: [117, 8],                   t: 1,                    isSource: false , order: -0.07781165936695383,  order2: 0, pDd: [[0,117],[0,8]] }, prev: 148, next: 6,   prevOnCircle: 118, nextOnCircle: 118 },
-            { id: 6,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [139, 8],                          radius: 0                    }, curveIdx: 5, loopIdx: 0, p: [139, 8],                          t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,139],[0,8]] }, prev: 119, next: 7,   prevOnCircle: 7,   nextOnCircle: 7   },
-            { id: 7,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [139, 8],                          radius: 0                    }, curveIdx: 5, loopIdx: 0, p: [139, 8],                          t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,139],[0,8]] }, prev: 6,   next: 118, prevOnCircle: 6,   nextOnCircle: 6   },
-            { id: 118, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [115.9110440340909, -5.952334953607174], radius: 13.994766012811272  }, curveIdx: 6, loopIdx: 0, p: [128.3125, -12.4375],         t: 0.1875,               isSource: true  , order: 0,                     order2: 0, pDd: [[0,128.3125],[0,-12.4375]] }, prev: 7,   next: 149, prevOnCircle: 119, nextOnCircle: 119 },
-            { id: 149, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.68410160768288, -12.970446490933696], radius: 41.07276841516263  }, curveIdx: 6, loopIdx: 0, p: [118.08071791640388, -32.003539423017145], t: 0.36700494883501966, isSource: false , order: 0, order2: 0, pDd: [[0,118.08071791640388],[0,-32.003539423017145]] }, prev: 118, next: 8,   prevOnCircle: 148, nextOnCircle: 150 },
-            { id: 8,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [82, -101],                        radius: 0                    }, curveIdx: 6, loopIdx: 0, p: [82, -101],                        t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,82],[0,-101]] }, prev: 149, next: 9,   prevOnCircle: 9,   nextOnCircle: 9   },
-            { id: 9,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [82, -101],                        radius: 0                    }, curveIdx: 6, loopIdx: 0, p: [82, -101],                        t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,82],[0,-101]] }, prev: 8,   next: 150, prevOnCircle: 8,   nextOnCircle: 8   },
-            { id: 150, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.68410160768288, -12.970446490933696], radius: 41.07276841516263  }, curveIdx: 0, loopIdx: 0, p: [45.425023320690585, -32.264267964746104],  t: 0.6306030461949899, isSource: false , order: 0, order2: 0, pDd: [[0,45.425023320690585],[0,-32.264267964746104]] }, prev: 9,   next: 143, prevOnCircle: 149, nextOnCircle: 148 },
-            { id: 143, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, -12.641417453935567],         radius: 41.064803841095305   }, curveIdx: 0, loopIdx: 0, p: [45.24795284642707, -31.931497590699145],   t: 0.6336559854064299, isSource: false , order: 0, order2: 0, pDd: [[0,45.24795284642707],[0,-31.931497590699145]] }, prev: 150, next: 11,  prevOnCircle: 142, nextOnCircle: 144 },
-            { id: 11,  isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [46, -5.21425847941623],            radius: 13.21425847941623    }, curveIdx: 0, loopIdx: 0, p: [34.33444028251029, -11.421620530924521],   t: 0.8218199951291328, isSource: false , order: 0, order2: 0, pDd: [[0,34.33444028251029],[0,-11.421620530924521]] }, prev: 143, next: 0,   prevOnCircle: 10,  nextOnCircle: 10  }
-        ],
-        loops: [
-            { idx: 0, beziers: [[[82, -101], [24, 8]], [[24, 8], [46, 8]], [[46, 8], [46, 54]], [[46, 54], [117, 54]], [[117, 54], [117, 8]], [[117, 8], [139, 8]], [[139, 8], [82, -101]]] }
-        ]
-    };
-
-    const cpNode = fromStringifyable(_cpNode);
-
-    mats1 = [{ cpNode, meta: {
-        boundingHulls: undefined!,
+            prev: 11,
+            next: 1,
+            prevOnCircle: 1,
+            nextOnCircle: 1
+        },
+        { id: 1,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_0_1, curveIdx: 0, loopIdx: 0, p: [24, 8],                           t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,24],[0,8]] }, prev: 0,   next: 10,  prevOnCircle: 0,   nextOnCircle: 0   },
+        { id: 10,  isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_10_11, curveIdx: 1, loopIdx: 0, p: [46, 8],                           t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,46],[0,8]] }, prev: 1,   next: 144, prevOnCircle: 11,  nextOnCircle: 11  },
+        { id: 144, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_142_143_144, curveIdx: 1, loopIdx: 0, p: [46, 8],                           t: 1,                    isSource: false , order: -0.5026547194480646,   order2: 0, pDd: [[0,46],[0,8]] }, prev: 10,  next: 147, prevOnCircle: 143, nextOnCircle: 142 },
+        { id: 147, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_145_146_147, curveIdx: 2, loopIdx: 0, p: [46, 18.499999999999996],           t: 0.2282608695652173,   isSource: false , order: 0,                     order2: 0, pDd: [[0,46],[0,18.499999999999996]] }, prev: 144, next: 2,   prevOnCircle: 146, nextOnCircle: 145 },
+        { id: 2,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_2_3, curveIdx: 2, loopIdx: 0, p: [46, 54],                          t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,46],[0,54]] }, prev: 147, next: 3,   prevOnCircle: 3,   nextOnCircle: 3   },
+        { id: 3,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_2_3, curveIdx: 2, loopIdx: 0, p: [46, 54],                          t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,46],[0,54]] }, prev: 2,   next: 145, prevOnCircle: 2,   nextOnCircle: 2   },
+        { id: 145, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_145_146_147, curveIdx: 3, loopIdx: 0, p: [81.5, 54],                        t: 0.5,                  isSource: false , order: 0,                     order2: 0, pDd: [[0,81.5],[0,54]] }, prev: 3,   next: 4,   prevOnCircle: 147, nextOnCircle: 146 },
+        { id: 4,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_4_5, curveIdx: 3, loopIdx: 0, p: [117, 54],                         t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,117],[0,54]] }, prev: 145, next: 5,   prevOnCircle: 5,   nextOnCircle: 5   },
+        { id: 5,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_4_5, curveIdx: 3, loopIdx: 0, p: [117, 54],                         t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,117],[0,54]] }, prev: 4,   next: 146, prevOnCircle: 4,   nextOnCircle: 4   },
+        { id: 146, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_145_146_147, curveIdx: 4, loopIdx: 0, p: [117, 18.499999999999996],          t: 0.7717391304347827,   isSource: false , order: 0,                     order2: 0, pDd: [[0,117],[0,18.499999999999996]] }, prev: 5,   next: 142, prevOnCircle: 145, nextOnCircle: 147 },
+        { id: 142, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_142_143_144, curveIdx: 4, loopIdx: 0, p: [117, 8],                          t: 1,                    isSource: false , order: -0.8644872659655476,   order2: 0, pDd: [[0,117],[0,8]] }, prev: 146, next: 148, prevOnCircle: 144, nextOnCircle: 143 },
+        { id: 148, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_148_149_150, curveIdx: 4, loopIdx: 0, p: [117, 8],                   t: 1,                    isSource: false , order: -0.8598373023056252,   order2: 0, pDd: [[0,117],[0,8]] }, prev: 142, next: 119, prevOnCircle: 150, nextOnCircle: 149 },
+        { id: 119, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_118_119, curveIdx: 4, loopIdx: 0, p: [117, 8],                   t: 1,                    isSource: false , order: -0.07781165936695383,  order2: 0, pDd: [[0,117],[0,8]] }, prev: 148, next: 6,   prevOnCircle: 118, nextOnCircle: 118 },
+        { id: 6,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_6_7, curveIdx: 5, loopIdx: 0, p: [139, 8],                          t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,139],[0,8]] }, prev: 119, next: 7,   prevOnCircle: 7,   nextOnCircle: 7   },
+        { id: 7,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_6_7, curveIdx: 5, loopIdx: 0, p: [139, 8],                          t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,139],[0,8]] }, prev: 6,   next: 118, prevOnCircle: 6,   nextOnCircle: 6   },
+        { id: 118, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_118_119, curveIdx: 6, loopIdx: 0, p: [128.3125, -12.4375],         t: 0.1875,               isSource: true  , order: 0,                     order2: 0, pDd: [[0,128.3125],[0,-12.4375]] }, prev: 7,   next: 149, prevOnCircle: 119, nextOnCircle: 119 },
+        { id: 149, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_148_149_150, curveIdx: 6, loopIdx: 0, p: [118.08071791640388, -32.003539423017145], t: 0.36700494883501966, isSource: false , order: 0, order2: 0, pDd: [[0,118.08071791640388],[0,-32.003539423017145]] }, prev: 118, next: 8,   prevOnCircle: 148, nextOnCircle: 150 },
+        { id: 8,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_8_9, curveIdx: 6, loopIdx: 0, p: [82, -101],                        t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,82],[0,-101]] }, prev: 149, next: 9,   prevOnCircle: 9,   nextOnCircle: 9   },
+        { id: 9,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_8_9, curveIdx: 6, loopIdx: 0, p: [82, -101],                        t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,82],[0,-101]] }, prev: 8,   next: 150, prevOnCircle: 8,   nextOnCircle: 8   },
+        { id: 150, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_148_149_150, curveIdx: 0, loopIdx: 0, p: [45.425023320690585, -32.264267964746104],  t: 0.6306030461949899, isSource: false , order: 0, order2: 0, pDd: [[0,45.425023320690585],[0,-32.264267964746104]] }, prev: 9,   next: 143, prevOnCircle: 149, nextOnCircle: 148 },
+        { id: 143, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_142_143_144, curveIdx: 0, loopIdx: 0, p: [45.24795284642707, -31.931497590699145],   t: 0.6336559854064299, isSource: false , order: 0, order2: 0, pDd: [[0,45.24795284642707],[0,-31.931497590699145]] }, prev: 150, next: 11,  prevOnCircle: 142, nextOnCircle: 144 },
+        { id: 11,  isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_10_11, curveIdx: 0, loopIdx: 0, p: [34.33444028251029, -11.421620530924521],   t: 0.8218199951291328, isSource: false , order: 0, order2: 0, pDd: [[0,34.33444028251029],[0,-11.421620530924521]] }, prev: 143, next: 0,   prevOnCircle: 10,  nextOnCircle: 10  }
+    ],
+    loops: [
+        { idx: 0, beziers: [[[82, -101], [24, 8]], [[24, 8], [46, 8]], [[46, 8], [46, 54]], [[46, 54], [117, 54]], [[117, 54], [117, 8]], [[117, 8], [139, 8]], [[139, 8], [82, -101]]] }
+    ]
+};
+
+
+// We use this one in tests since it is fixed and not susceptible to
+// small perturbations in the algorithm.
+function getMats1(): Mat[] {
+    const cpNode = fromStringifyable(cpNodeStringifyable1);
+
+    return [{ cpNode, meta: {
         cpTrees: undefined!,
         loops: undefined!,
-        dullCorners: undefined!,
         lastInsertId: undefined!,
-        looseBoundingBoxes: undefined!,
         maxCoordPowerOf2: undefined!,
-        sharpCorners: undefined!,
-        squaredDiagonalLength: undefined!,
-        tightBoundingBoxes: undefined!
+        squaredDiagonalLength: undefined!
     } }];
-
-    return mats1;
 }
 
 
@@ -119,5 +126,6 @@ function _getMats1() {
 
 export {
     getMats1,
+    cpNodeStringifyable1,
     // _getMats1
 }

package/__tests__/helpers/cp-node-by-id.ts

@@ -0,0 +1,27 @@
+import type { CpNode } from "../../src/cp-node/cp-node.js";
+import { getAllOnLoop } from "../../src/cp-node/fs/get-all-on-loop.js";
+
+
+/**
+ * Returns the `CpNode` with the given `id` on the same loop as the given 
+ * `CpNode` (throws if not found) - for picking out specific nodes of the 
+ * `getMats1` fixture.
+ */
+function cpNodeById(
+        cpNode: CpNode,
+        id: number): CpNode {
+
+    const found = getAllOnLoop(cpNode).find(cp => cp.id === id);
+    if (!found) { throw new Error(`no CpNode with id ${id}`); }
+
+    return found;
+}
+
+
+/** Returns a function mapping ids to `CpNode`s on the given loop. */
+function cpNodesByIdOn(cpNode: CpNode) {
+    return (id: number) => cpNodeById(cpNode, id);
+}
+
+
+export { cpNodeById, cpNodesByIdOn }

package/__tests__/helpers/expect-point-close.ts

@@ -0,0 +1,42 @@
+import { expect } from '@jest/globals';
+
+
+/** Asserts two points (or any equal-length number arrays) are nearly equal. */
+function expectPointClose(
+        actual: number[],
+        expected: number[],
+        digits = 9): void {
+
+    expect(actual.length).toBe(expected.length);
+    for (let i=0; i<actual.length; i++) {
+        expect(actual[i]).toBeCloseTo(expected[i], digits);
+    }
+}
+
+
+/** Asserts two bezier curves are nearly equal (same order and control points). */
+function expectBezierClose(
+        actual: number[][],
+        expected: number[][],
+        digits = 9): void {
+
+    expect(actual.length).toBe(expected.length);
+    for (let i=0; i<actual.length; i++) {
+        expectPointClose(actual[i], expected[i], digits);
+    }
+}
+
+
+/** Asserts consecutive beziers in the array join up end-to-start. */
+function expectBeziersConnected(
+        pss: number[][][],
+        digits = 9): void {
+
+    for (let i=1; i<pss.length; i++) {
+        const prev = pss[i-1];
+        expectPointClose(pss[i][0], prev[prev.length-1], digits);
+    }
+}
+
+
+export { expectPointClose, expectBezierClose, expectBeziersConnected }

package/__tests__/mat/hausdorff-distance-one-sided-exceeds.spec.ts

@@ -0,0 +1,129 @@
+import { describe, expect, test } from '@jest/globals';
+import { hausdorffDistanceOneSided, closestPointOnBezier, evalDeCasteljau } from 'flo-bezier3';
+import { hausdorffDistanceOneSidedExceeds, distanceToCurves } from '../../src/mat/hausdorff-distance-one-sided-exceeds.js';
+
+
+/**
+ * The one-sided Hausdorff distance from `A` to the piecewise curve `B`
+ * approximated by dense sampling of `A` (a lower bound, accurate to within
+ * the sample spacing times the speed of `A`).
+ */
+function sampledHausdorffDistanceOneSided(
+        A: number[][],
+        B: number[][][],
+        samples = 4096): number {
+
+    let worst = 0;
+    for (let i=0; i<=samples; i++) {
+        const p = evalDeCasteljau(A, i/samples);
+        let best = Infinity;
+        for (const qs of B) {
+            best = Math.min(best, closestPointOnBezier(qs, p).d);
+        }
+        worst = Math.max(worst, best);
+    }
+
+    return worst;
+}
+
+
+// a handful of 'from' curves of all orders
+const As: number[][][] = [
+    [[0,0], [100,0]],                           // a line
+    [[0,0], [50,30], [100,0]],                  // a quadratic
+    [[0,0], [30,40], [70,-40], [100,0]],        // a cubic with an inflection
+    [[0,0], [10,80], [90,80], [100,0]],         // a 'tall' cubic
+    [[0,0], [100,0], [0,0]],                    // a degenerate (folded) quadratic
+];
+
+// a handful of 'to' curves
+const Bs: number[][][] = [
+    [[0,1], [100,1]],                           // a line (offset by 1)
+    [[0,0], [50,10], [100,0]],                  // a quadratic
+    [[0,0], [50,-10], [100,0]],                 // a quadratic bending the other way
+    [[-10,5], [40,60], [110,-20]],              // a quadratic not sharing endpoints
+    [[0,0], [30,10], [70,10], [100,0]],         // a cubic
+];
+
+// relative margin beyond which the answers must certainly agree
+const MARGIN = 2**-10;
+
+
+describe('hausdorffDistanceOneSidedExceeds', function() {
+    test('agrees with the computed one-sided Hausdorff distance (single curve B)', function() {
+        let checks = 0;
+        for (const A of As) {
+            for (const B of Bs) {
+                // a very accurate reference value
+                const hd = hausdorffDistanceOneSided(A, B, 2**-30, 10_000);
+                expect(hd).toBeGreaterThan(0);
+
+                // tolerances on both sides of the reference value (a large
+                // iteration budget is given since certifying a distance that
+                // is *just* within tolerance requires resolving the curve to
+                // within the margin - e.g. the folded quadratic is at a
+                // uniform distance of 1 from the first line)
+                for (const f of [1/4, 1/2, 1 - 2*MARGIN, 1 + 2*MARGIN, 2, 4]) {
+                    const tolerance = f*hd;
+                    const exceeds = hausdorffDistanceOneSidedExceeds(A, [B], tolerance, 1_000_000);
+                    expect(exceeds).toBe(hd > tolerance);
+                    checks++;
+                }
+            }
+        }
+        expect(checks).toBe(As.length*Bs.length*6);
+    });
+
+    test('agrees with a densely sampled one-sided Hausdorff distance (piecewise B)', function() {
+        // piecewise 'to' curves - two quads joined at a point, and two
+        // disconnected pieces
+        const Bss: number[][][][] = [
+            [[[0,0], [25,20], [50,10]], [[50,10], [75,0], [100,0]]],
+            [[[0,2], [40,2]], [[60,-2], [100,-2]]],
+            [[[0,0], [30,10], [50,0]], [[50,0], [70,-10], [100,0]]],
+        ];
+
+        for (const A of As) {
+            for (const Bs of Bss) {
+                const hd = sampledHausdorffDistanceOneSided(A, Bs);
+                expect(hd).toBeGreaterThan(0);
+
+                // the sampled value is a lower bound accurate to about
+                // `speed/4096` which is ~0.05 here, so stay well clear of it
+                expect(hausdorffDistanceOneSidedExceeds(A, Bs, hd*(1 - 2**-3), 1000)).toBe(true);
+                expect(hausdorffDistanceOneSidedExceeds(A, Bs, hd*(1 + 2**-3), 1000)).toBe(false);
+            }
+        }
+    });
+
+    test('decides trivially for a point or line to a line', function() {
+        const B = [[[0,1], [100,1]]];
+        expect(hausdorffDistanceOneSidedExceeds([[50,0]], B, 0.5)).toBe(true);
+        expect(hausdorffDistanceOneSidedExceeds([[50,0]], B, 1.5)).toBe(false);
+        expect(hausdorffDistanceOneSidedExceeds([[0,0], [100,0]], B, 0.5)).toBe(true);
+        expect(hausdorffDistanceOneSidedExceeds([[0,0], [100,0]], B, 1.5)).toBe(false);
+        // a line to a line not parallel to it - the max is at an endpoint
+        expect(hausdorffDistanceOneSidedExceeds([[0,0], [100,0]], [[[0,0], [100,10]]], 9.9)).toBe(true);
+        expect(hausdorffDistanceOneSidedExceeds([[0,0], [100,0]], [[[0,0], [100,10]]], 10.1)).toBe(false);
+    });
+
+    test('is conservative when the iteration budget is exhausted', function() {
+        // the endpoints of `A` lie on `B` but the middle is 10 away; the
+        // initial upper bound is half the control polygon length (~54) so
+        // with no bisections allowed a tolerance of 30 cannot be certified
+        // either way and the check must fail
+        const A = [[0,0], [50,20], [100,0]];
+        const B = [[[0,0], [100,0]]];
+        expect(hausdorffDistanceOneSidedExceeds(A, B, 30, 0)).toBe(true);
+        // with a budget it decides correctly
+        expect(hausdorffDistanceOneSidedExceeds(A, B, 30, 50)).toBe(false);
+        expect(hausdorffDistanceOneSidedExceeds(A, B, 9.9, 50)).toBe(true);
+    });
+
+    test('distanceToCurves is the minimum over the pieces', function() {
+        const Bs = [[[0,0], [100,0]], [[0,10], [100,10]]];
+        expect(distanceToCurves([50,2], Bs)).toBeCloseTo(2, 12);
+        expect(distanceToCurves([50,8], Bs)).toBeCloseTo(2, 12);
+        expect(distanceToCurves([150,0], Bs)).toBeCloseTo(50, 12);
+    });
+});

package/__tests__/mat/simplify-mat.spec.ts

@@ -0,0 +1,85 @@
+import { expect, test } from '@jest/globals';
+import { getPathsFromStr } from 'flo-boolean';
+import { closestPointOnBezier, evalDeCasteljau } from 'flo-bezier3';
+import { distanceBetween } from 'flo-vector2d';
+import { findMats } from '../../src/find-mat/find-mats.js';
+import { simplifyMat } from '../../src/mat/simplify-mat.js';
+import { getAllOnLoop } from '../../src/cp-node/fs/get-all-on-loop.js';
+import { getMatCurveToNext } from '../../src/cp-node/fs/get-mat-curve-to-next.js';
+import { isTerminating } from '../../src/cp-node/fs/is-terminating.js';
+import type { CpNode } from '../../src/cp-node/cp-node.js';
+
+
+/** All the bezier pieces making up the MAT. */
+function getMatBeziers(cpNode: CpNode): number[][][] {
+    return getAllOnLoop(cpNode)
+        .filter(cp => !isTerminating(cp))
+        .flatMap(getMatCurveToNext);
+}
+
+
+/**
+ * The one-sided Hausdorff distance from the curves `A` to the curves `B`,
+ * approximated by sampling points on `A`.
+ */
+function sampledHausdorffDistanceOneSided(
+        A: number[][][],
+        B: number[][][],
+        samplesPerCurve = 16): number {
+
+    let worst = 0;
+    for (const ps of A) {
+        for (let i=0; i<=samplesPerCurve; i++) {
+            const p = evalDeCasteljau(ps, i/samplesPerCurve);
+            let best = Infinity;
+            for (const qs of B) {
+                const { p: q } = closestPointOnBezier(qs, p);
+                best = Math.min(best, distanceBetween(p, q));
+            }
+            worst = Math.max(worst, best);
+        }
+    }
+
+    return worst;
+}
+
+
+test('simplifyMat', function() {
+    // A smooth blob: its MAT is a single long branch made up of very many
+    // 2-prongs, so there is a lot to simplify.
+    const loops = getPathsFromStr(
+        'M0 0 C 50 -40 150 -40 200 0 C 250 40 250 80 200 120 ' +
+        'C 150 160 50 160 0 120 C -50 80 -50 40 0 0 Z'
+    );
+    const [mat] = findMats(loops, { simplify: false, applySat: false });
+    const original = getMatBeziers(mat.cpNode);
+    const originalCount = getAllOnLoop(mat.cpNode).length;
+    const originalTreeSizes = [...mat.meta.cpTrees.values()].map(t => t.size);
+
+    const hausdorffTolerance = 2**-3;
+    const simplified = simplifyMat(mat, hausdorffTolerance);
+    const simplifiedBeziers = getMatBeziers(simplified.cpNode);
+
+    // it did simplify...
+    expect(getAllOnLoop(simplified.cpNode).length).toBeLessThan(originalCount);
+    expect(simplifiedBeziers.length).toBeLessThan(original.length);
+
+    // ...but stayed within the tolerance: no point of the original MAT is
+    // further than `hausdorffTolerance` from the simplified MAT (the tolerance
+    // is a certified bound, up to floating point roundoff)
+    const hd = sampledHausdorffDistanceOneSided(original, simplifiedBeziers);
+    expect(hd).toBeLessThanOrEqual(hausdorffTolerance * (1 + 2**-20));
+
+    // the input MAT is left intact - its linked list *and* its `cpTrees`
+    expect(getAllOnLoop(mat.cpNode).length).toBe(originalCount);
+    expect([...mat.meta.cpTrees.values()].map(t => t.size)).toEqual(originalTreeSizes);
+
+    // the simplified MAT has its own `cpTrees`, consistent with its nodes
+    expect(simplified.meta.cpTrees).not.toBe(mat.meta.cpTrees);
+    const simplifiedNodes = getAllOnLoop(simplified.cpNode);
+    for (const [loop, tree] of simplified.meta.cpTrees) {
+        const onLoop = simplifiedNodes.filter(cp => cp.pointOnShape.curve.loop === loop);
+        expect(tree.size).toBe(onLoop.length);
+        for (const cp of onLoop) { expect(tree.find(cp)?.datum).toBe(cp); }
+    }
+});

package/__tests__/reconstruct-from-mat/reconstruct-from-mat.spec.ts

@@ -0,0 +1,39 @@
+import { expect, test } from '@jest/globals';
+import { reconstructFromMats } from '../../src/reconstruct-from-mat/reconstruct-from-mat.js';
+import { getAllOnLoop } from '../../src/cp-node/fs/get-all-on-loop.js';
+import { getMatsWithHole } from '../get-mats-with-hole.js';
+
+
+test('reconstructFromMats - does not modify the given MATs', function() {
+    // (the fixture is SAT-processed, so SAT-induced trivial 3-prongs - which
+    // `reconstructFromMats` removes before reconstructing - may be present)
+    const mats = getMatsWithHole();
+    const before = mats.map(mat => ({
+        cpNode: mat.cpNode,
+        nodes: getAllOnLoop(mat.cpNode),
+        links: getAllOnLoop(mat.cpNode).map(cp =>
+            [cp.prev, cp.next, cp.prevOnCircle, cp.nextOnCircle]
+        )
+    }));
+
+    const piecesss = reconstructFromMats(mats);
+    expect(piecesss.length).toBe(mats.length);
+    for (const piecess of piecesss) {
+        for (const pieces of piecess) { expect(pieces.length).toBeGreaterThan(0); }
+    }
+
+    // same start node, same nodes, same links
+    mats.forEach((mat, i) => {
+        expect(mat.cpNode).toBe(before[i].cpNode);
+        const nodes = getAllOnLoop(mat.cpNode);
+        expect(nodes.length).toBe(before[i].nodes.length);
+        expect(nodes.every((cp, k) => cp === before[i].nodes[k])).toBe(true);
+        nodes.forEach((cp, k) => {
+            const [prev, next, prevOnCircle, nextOnCircle] = before[i].links[k];
+            expect(cp.prev).toBe(prev);
+            expect(cp.next).toBe(next);
+            expect(cp.prevOnCircle).toBe(prevOnCircle);
+            expect(cp.nextOnCircle).toBe(nextOnCircle);
+        });
+    });
+});

package/__tests__/specific-cases/test-svgs/achispado.svg

@@ -7,6 +7,20 @@
     <glyph glyph-name=".notdef" horiz-adv-x="500" 
 d="M15 609v-593h469v593h-469zM500 0h-500v625h500v-625z" />
 
+<glyph glyph-name="Q_V2"
+d="
+        M 600 700
+        L 570 670
+        L 551.4300900092946 724.4845356715714 
+        C 550.4300900092946 726.2165864791402 550.2961154130791 728.4486372867091 550.6621408168635 729.8146626904936 
+        C 550.0281662206479 732.9127389018469 550.7602170282167 735.6447897094158 551.4922678357857 738.3768405169847 
+        C 552.3582932395701 738.8768405169847 552.7243186433545 740.2428659207691 552.7243186433545 740.2428659207691 
+        C 554.6884202584923 744.8409421321223 558.5185472774145 748.2069675359069 562.8486742963368 750.7069675359069 
+        C 568.0448267190433 753.7069675359069 573.3749537379655 754.474916728338 578.3390553531033 753.8768405169847 
+        z
+        "
+/>
+
 <glyph glyph-name="Q_V" unicode="&#xe015;" horiz-adv-x="750"
     d="
         M 1154.0678381635485 290.68533730950645