flo-mat 4.0.2 → 4.0.3

package/src/debug/debug.ts

@@ -1,20 +1,20 @@
-import { generalDebugFunctions } from './functions/general.js';
-import { IGeneralDebugFunctions } from './functions/general.js'; 
-import { DrawElemFunctions } from './functions/draw-elem/draw-elem.js';
-import { DebugElems } from './debug-elem-types.js';
+import type { DrawElemFunctions } from './functions/draw-elem/draw-elem.js';
+import type { DebugElems } from './debug-elem-types.js';
 import { drawElemFs } from './functions/draw-elem/draw-elem.js';
 
 
 /** @internal */
 interface Debug {
     /** Generated by debug object for later inspection */
-    generated: Generated;
+    elems: GeneratedElems;
+    timing: Timing;
+
     /**
      * These functions are meant to be used in the console, e.g. in the 
      * console try typing d.fs.twoProng.traceConvergence(0);
      */
-    fs: IDebugFunctions;
-    directives: IDirectives;
+    fs: DebugFunctions;
+    directives: Directives;
 }
 
 
@@ -23,32 +23,23 @@ type GeneratedElems = { [T in keyof DebugElems]: DebugElems[T][] };
 
 
 /** @internal */
-interface ITiming {
-    //normalize     : number;
-    //simplifyPaths : number;
-    holeClosers   : number;
-    oneAnd2Prongs : number;
-    threeProngs   : number;
-    sats          : number;
-    simplifyMat   : number;
-}
-
-
-/** @internal */
-interface Generated {
-    elems: GeneratedElems;
-    timing: ITiming;
+interface Timing {
+    holeClosers: number;
+    oneAnd2Prongs: number;
+    threeProngs: number;
+    sats: number;
+    simplifyMat: number;
 }
 
 
 /** @internal */
-interface IDebugFunctions extends IGeneralDebugFunctions {
-    drawElem   : DrawElemFunctions,
+interface DebugFunctions {
+    drawElem: DrawElemFunctions,
 }
 
 
 /** @internal */
-interface IDirectives {
+interface Directives {
     stopAfterHoleClosers: boolean,
     stopAfterHoleClosersNum: number,
     stopAfterTwoProngs: boolean,
@@ -68,59 +59,50 @@ function enableDebugForMat(debugOn: boolean) {
 
     debug = { 
         ...debug, 
-        generated: { 
-            //...debug?.generated,
-            ...(!debug ? {} : !debug.generated ? {} : debug.generated),
+        elems: { 
+            ...debug?.elems,
             // @ts-ignore
-            elems: { 
-                //...debug?.generated?.elems,
-                ...(!debug ? {} : !debug.generated ? {} : !debug.generated.elems ? {} : debug.generated.elems),
-                oneProng             : [],
-                // oneProngAtDullCorner : [],
-                twoProng             : [],
-                // twoProng_regular     : [],
-                // twoProng_failed      : [],
-                // twoProng_notAdded    : [],
-                // twoProng_deleted     : [],
-                // twoProng_holeClosing : [],
-                looseBoundingBox     : [],
-                tightBoundingBox     : [],
-                // sharpCorner          : [],
-                // dullCorner           : [],
-                vertex               : [],
-                threeProng           : [],
-                boundingHull         : [],
-                mat                  : [],
-                // sat                  : [],
-                cpNode               : [],
-                maxVertex            : [],
-                leaves               : [],
-                // culls                : [],
-            },
-            timing: {
-                //...debug?.generated?.timing,
-                ...(!debug ? {} : !debug.generated ? {} : !debug.generated.timing ? {} : debug.generated.timing),
-                holeClosers   : 0,
-                oneAnd2Prongs : 0,
-                threeProngs   : 0,
-                sats          : 0,
-                simplifyMat   : 0,
-            }
+
+            oneProng             : [],
+            // oneProngAtDullCorner : [],
+            twoProng             : [],
+            // twoProng_regular     : [],
+            // twoProng_failed      : [],
+            // twoProng_notAdded    : [],
+            // twoProng_deleted     : [],
+            // twoProng_holeClosing : [],
+            looseBoundingBox     : [],
+            tightBoundingBox     : [],
+            // sharpCorner          : [],
+            // dullCorner           : [],
+            vertex               : [],
+            threeProng           : [],
+            boundingHull         : [],
+            mat                  : [],
+            // sat                  : [],
+            cpNode               : [],
+            maxVertex            : [],
+            leaves               : [],
+            // culls                : [],
+        },
+        timing: {
+            ...debug?.timing,
+            holeClosers: 0,
+            oneAnd2Prongs: 0,
+            threeProngs: 0,
+            sats: 0,
+            simplifyMat: 0,
         },
         fs: {
-            //...debug?.fs,
-            ...(!debug ? {} : !debug.fs ? {} : debug.fs),
-            // @ts-ignore
+            ...debug?.fs,
             drawElem: {
-                //...debug?.fs?.drawElem,
-                ...(!debug ? {} : !debug.fs ? {} : !debug.fs.drawElem ? {} : debug.fs.drawElem),
+                ...debug?.fs?.drawElem,
                 ...drawElemFs
-            },
-            ...generalDebugFunctions
+            }
         },
         directives: {
             //...debug?.directives,
-            ...(!debug ? {} : !debug.directives ? {} : debug.directives),
+            ...debug?.directives,
             stopAfterHoleClosers: false,
             stopAfterHoleClosersNum: undefined!,
             stopAfterTwoProngs: false,
@@ -135,6 +117,6 @@ function enableDebugForMat(debugOn: boolean) {
 
 
 export { 
-    Debug, GeneratedElems, ITiming, Generated,
-    IDebugFunctions, IDirectives, enableDebugForMat
+    Debug, GeneratedElems, Timing,
+    DebugFunctions, Directives, enableDebugForMat
 }

package/src/find-2-prong/add-1-prong.ts

@@ -50,11 +50,7 @@ function add1Prong(
         return;
     }
 
-    const { anyFailed, cpNodes } = addToCpTree(false, false, circle, [-0.5, +0.5], meta, [pos, pos]); 
-    
-    // if (typeof _debug_ !== 'undefined') { 
-    //     _debug_.generated.elems.oneProng.push(cpNodes);
-    // }
+    addToCpTree(false, false, circle, [-0.5, +0.5], meta, [pos, pos]); 
 }
 
 

package/src/find-mat/find-mat.ts

@@ -8,7 +8,7 @@ import type { MatOptions } from './mat-options.js';
 import type { MatMeta } from '../mat/mat-meta.js';
 import { findAndAdd3ProngsOnLoop } from '../find-3-prong/find-and-add-3-prongs-on-loop.js';
 import { createInitialCpTree } from './create-initial-cp-tree.js';
-import { /*getPointToCpNode,*/ getPartialMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4, getPointToCpNode } from './get-meta.js';
+import { getPartialMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
 import { getSharpCornersOnLoop } from './get-sharp-corners.js';
 import { getDullCornersOnLoop } from './get-dull-corners-on-loop.js';
 import { findAndAdd2ProngsOnAllLoops } from '../find-2-prong/find-and-add-2-prongs-on-all-loops.js';
@@ -49,7 +49,6 @@ function findMat(
     const cpTrees = createInitialCpTree(loops, sharpCornersPerLoop, lastInsertId);
 
     const _meta = getPartialMeta(loops);
-    const pointToCpNode = getPointToCpNode(loops, cpTrees);
     const meta: MatMeta = {
         maxCoordPowerOf2, squaredDiagonalLength, loops, cpTrees,// pointToCpNode,
         lastInsertId, ..._meta

package/src/find-mat/get-meta.ts

@@ -1,13 +1,9 @@
 import type { Debug }   from '../debug/debug.js';
 import type { Loop } from 'flo-boolean';
 import type { Curve } from 'flo-boolean';
-import type { CpNode } from '../cp-node/cp-node.js';
-import type { TriMap } from '../utils/tri-map.js';
 import type { MatMeta } from '../mat/mat-meta.js';
-// import { TriMapFs } from '../utils/tri-map.js';
 import { getBoundingHull, getBoundingBoxTight } from 'flo-bezier3';
 import { getBoundingBox$ } from '../geometry/get-bounding-box-.js';
-import { RbTree } from 'flo-ll-rb-tree';
 import { getCorner } from '../corner/get-corner.js';
 
 
@@ -18,30 +14,6 @@ declare const _debug_: Debug;
 let timingStart: number;
 
 
-/** @internal */
-function getPointToCpNode(
-        loops: Loop[],
-        cpTrees: Map<Loop, RbTree<CpNode>>): TriMap<Loop,number,number,CpNode> {
-
-    timingStart = performance.now();
-
-    // const pointToCpNode: TriMap<Loop,number,number,CpNode> = new Map();
-
-    // for (const loop of loops) {
-    //     // Populate `posMap`
-    //     const cpTree = cpTrees.get(loop)!;
-    //     const cpNodes = cpTree.toArrayInOrder();
-    //     for (const cpNode of cpNodes) {
-    //         const { p, t } = cpNode.pointOnShape;
-    //         TriMapFs.set(pointToCpNode,loop,p[0],p[1],cpNode);
-    //     }
-    // }
-
-    // return pointToCpNode;
-    return undefined!
-}
-
-
 /** @internal */
 function getPartialMeta(
         loops: Loop[]): Omit<
@@ -96,9 +68,8 @@ function getPartialMeta(
 function addDebugInfo2() {
     if (typeof _debug_ === 'undefined') { return; }
 
-    const timing = _debug_.generated.timing;
     const now = performance.now();
-    timing.holeClosers += now - timingStart;
+    _debug_.timing.holeClosers += now - timingStart;
     timingStart = now;
 }
 
@@ -106,11 +77,9 @@ function addDebugInfo2() {
 function addDebugInfo3() {
     if (typeof _debug_ === 'undefined') { return; }
 
-    const generated = _debug_.generated;
-    const timing = generated.timing;
     const now = performance.now();
 
-    timing.oneAnd2Prongs += now - timingStart;
+    _debug_.timing.oneAnd2Prongs += now - timingStart;
     timingStart = now;
 }
 
@@ -118,15 +87,11 @@ function addDebugInfo3() {
 function addDebugInfo4() {
     if (typeof _debug_ === 'undefined') { return; }
 
-    const generated = _debug_.generated;
-    const timing = generated.timing;
-
-    timing.threeProngs += performance.now() - timingStart;
+    _debug_.timing.threeProngs += performance.now() - timingStart;
 }
 
 
 export {
-    getPointToCpNode,
     getPartialMeta,
     addDebugInfo2,
     addDebugInfo3,

package/src/index.ts

@@ -8,7 +8,7 @@ export type { PointOnShape } from './point-on-shape/point-on-shape.js';
 export type { Circle } from './geometry/circle.js';
 export type { CurvePiece } from './mat/curve-piece.js';
 export type { DrawElemFunctions } from './debug/functions/draw-elem/draw-elem.js';
-export type { ITiming } from './debug/debug.js';
+export type { Timing as ITiming } from './debug/debug.js';
 export type { DebugElems } from './debug/debug-elem-types.js';
 export type { Debug } from './debug/debug.js';
 export type { DebugElemKey } from './debug/debug-elem-types.js';
@@ -41,7 +41,7 @@ export { getSharpCornersOnLoop } from './find-mat/get-sharp-corners.js';
 export { getFor2ProngsOnLoop } from './find-mat/get-for-2-prongs-on-loop.js';
 export { getPotentialClosestPointsOnCurveCertified } from './closest-boundary-point/get-potential-closest-points-on-curve-certified.js';
 export { getCloseBoundaryPointsCertified } from './closest-boundary-point/get-close-boundary-points-certified.js';
-export { getPartialMeta, getPointToCpNode } from './find-mat/get-meta.js';
+export { getPartialMeta } from './find-mat/get-meta.js';
 export { findAndAddHoleClosing2Prongs } from './find-2-prong/find-and-add-hole-closing-2-prongs.js';
 
 
@@ -80,4 +80,6 @@ export { getHoleClosers } from './cp-node/fs/get-hole-closers.js';
 export { getInitialDegAngleBetweenMatCurves } from './cp-node/fs/get-angle-between-mat-curves.js';
 export { getAllVertices } from './cp-node/fs/get-all-vertices.js';
 export { isTrivial } from './cp-node/fs/is-trivial.js';
-export { scaleCircle } from './geometry/circle.js';
+export { scaleCircle } from './geometry/circle.js';
+export { isOnSameLoop } from './cp-node/fs/is-on-same-loop.js';
+export { reconstructFromMats } from './reconstruct-from-mat/reconstruct-from-mat.js';

package/src/reconstruct-from-mat/filter-zero-length.ts

@@ -0,0 +1,23 @@
+import type { BezierPiece } from "flo-bezier3";
+import { isBezierPieceZeroLength } from "flo-bezier3";
+
+
+/**
+ * Filters out zero-length bezier pieces.
+ * 
+ * * **note** will return at least one bezier piece, even if all pieces are zero-length.
+ * 
+ * @param bezierPieces 
+ */
+function filterZeroLength(
+        bezierPieces: BezierPiece[]): BezierPiece[] {
+
+    const bezierPieces_ = bezierPieces.filter(
+        bezierPiece => !isBezierPieceZeroLength(bezierPiece)
+    );
+
+    return bezierPieces_.length > 0 ? bezierPieces_ : [bezierPieces[0]];
+}
+
+
+export { filterZeroLength }

package/src/reconstruct-from-mat/get-all-on-loop-by-loop.ts

@@ -0,0 +1,52 @@
+import type { CpNode } from '../cp-node/cp-node.js';
+
+
+/**
+ * Returns all `CpNode`s on the MAT that this `CpNode` is part of 
+ * starting from the current one and going anti-clockwise around the shape.
+ */
+function getAllOnLoop_ByLoop(
+        cpNode: CpNode) {
+
+    const cpNodess: CpNode[][] = [];
+
+    const cpStarts: CpNode[] = [cpNode];
+    const cpStartSet = new Set(cpStarts);
+    if (cpNode.isHoleClosing) {
+        cpStartSet.add(cpNode.prevOnCircle.holeCloserTwin!);
+    }
+    cpStartSet.add(cpNode);
+
+    while (cpStarts.length > 0) {
+        const cpNodes: CpNode[] = [];
+
+        const cpStart = cpStarts.pop()!;
+        const _loop = cpStart.pointOnShape.curve.loop;
+        let cpNode = cpStart;
+
+        do {
+            const loop = cpNode.pointOnShape.curve.loop;
+            if (_loop === loop) {
+                cpNodes.push(cpNode);
+                cpNode = cpNode.next;
+                continue;
+            }
+
+            const twin = cpNode.holeCloserTwin!;
+            if (!cpStartSet.has(twin)) {
+                cpStartSet.add(twin);
+                cpStartSet.add(twin.prevOnCircle.holeCloserTwin!);
+                cpStarts.push(twin);
+            }
+
+            cpNode = cpNode.prev.holeCloserTwin!;
+        } while (cpNode !== cpStart);
+
+        cpNodess.push(cpNodes);
+    }
+
+    return cpNodess;
+}
+
+
+export { getAllOnLoop_ByLoop }

package/src/reconstruct-from-mat/get-bezier-piece-length.ts

@@ -0,0 +1,12 @@
+import type { BezierPiece } from "flo-bezier3";
+import { length } from 'flo-bezier3';
+
+
+function getBezierPieceLength(
+        bezierPiece: BezierPiece): number {
+
+    return length(bezierPiece.ts, bezierPiece.ps);
+}
+
+
+export { getBezierPieceLength }

package/src/reconstruct-from-mat/get-boundary.ts

@@ -0,0 +1,32 @@
+import type { BezierPiece } from 'flo-bezier3';
+import type { CpNode } from '../cp-node/cp-node.js';
+import { getBoundaryBezierPartsToNext } from '../cp-node/fs/get-boundary-bezier-parts-to-next.js';
+import { filterZeroLength } from "./filter-zero-length.js";
+import { isFullyTerminating } from './is-fully-terminating.js';
+
+
+function getBoundary(
+        cpNode: CpNode): {
+            boundaryBeziers: BezierPiece[];
+            boundaryBeziersOpp: BezierPiece[] | undefined;
+        } {
+
+    const cpNodeOpp = isFullyTerminating(cpNode)
+        ? undefined // no opposite boundary
+        : cpNode.next.prevOnCircle;
+
+    const boundaryBeziers =
+        filterZeroLength(getBoundaryBezierPartsToNext(cpNode));
+
+    const boundaryBeziersOpp = cpNodeOpp === undefined
+        ? undefined
+        : filterZeroLength(getBoundaryBezierPartsToNext(cpNodeOpp));
+
+    return {
+        boundaryBeziers,
+        boundaryBeziersOpp
+    };
+}
+
+
+export { getBoundary }

package/src/reconstruct-from-mat/get-cp-nodess-for-sat.ts

@@ -0,0 +1,24 @@
+import type { CpNode } from "../cp-node/cp-node.js";
+import type { Mat } from '../mat/mat.js';
+import { isOnSameLoop } from "../cp-node/fs/is-on-same-loop.js";
+import { isFullyTerminating } from "./is-fully-terminating.js";
+import { getAllOnLoop_ByLoop } from "./get-all-on-loop-by-loop.js";
+
+
+function getCpNodessForSat(
+        sat: Mat): CpNode[][] {
+
+    let { cpNode } = sat;
+
+    while (!isFullyTerminating(cpNode)) {
+        cpNode = cpNode.next;
+    }
+    if (!isOnSameLoop(cpNode, cpNode.next)) {
+        cpNode = cpNode.holeCloserTwin!;
+    }
+
+    return getAllOnLoop_ByLoop(cpNode);
+}
+
+
+export { getCpNodessForSat }

package/src/reconstruct-from-mat/get-matching-beziers.ts

@@ -0,0 +1,46 @@
+import type { BezierPiece } from 'flo-bezier3';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { MatchedBeziers } from './matched-beziers.js';
+import { getMatCurveToNext } from '../cp-node/fs/get-mat-curve-to-next.js'
+import { splitTriPath } from './split-tri-path.js';
+import { getBoundary } from './get-boundary.js';
+import { isOnSameLoop } from '../cp-node/fs/is-on-same-loop.js';
+
+
+/**
+ * Returns a correspondence between boundary bezier curves and a medial axis
+ * bezier curve. They will later be interpolated.
+ * 
+ * @param cpNode the start `CpNode`
+ */
+function getMatchingBeziers(
+        cpNode: CpNode): MatchedBeziers[] | undefined {
+
+    const medialBezier: BezierPiece = {
+        ps: getMatCurveToNext(cpNode),
+        ts: [0,1]
+    };
+
+    if (cpNode.isHoleClosing &&  // short-circuit
+        !isOnSameLoop(cpNode, cpNode.next)) {
+
+        // We get here for half of hole-closers, as only half of hole-closers are on a different loop.
+        // This cpNode indicates we should connect the hole
+        // console.log('hole-closing dummy case');
+        return undefined;
+    }
+
+    const r = getBoundary(cpNode);
+    const { boundaryBeziers, boundaryBeziersOpp } = r;
+
+    const matchedBezierss: MatchedBeziers[] = splitTriPath(
+        boundaryBeziers,
+        medialBezier,
+        boundaryBeziersOpp ?? []
+    );
+
+    return matchedBezierss;
+}
+
+
+export { getMatchingBeziers }

package/src/reconstruct-from-mat/get-mbss-by-loop-per-sat.ts

@@ -0,0 +1,19 @@
+import type { Mat } from "../mat/mat.js";
+import { getSats2 } from "./get-sats2.js";
+import { getMbssByLoopWithOppArr } from "./get-mbss-by-loop-with-opp-arr.js";
+import { getCpNodessForSat } from "./get-cp-nodess-for-sat.js";
+
+
+function getMbssByLoopPerSat(
+        mats: Mat[],
+        satScale: number) {
+
+    const sats = getSats2(mats, satScale);
+
+    const cpNodessPerSat = sats.map(getCpNodessForSat);
+
+    return cpNodessPerSat.map(getMbssByLoopWithOppArr);
+}
+
+
+export { getMbssByLoopPerSat }

package/src/reconstruct-from-mat/get-mbss-by-loop-with-opp-arr.ts

@@ -0,0 +1,69 @@
+import type { CpNode } from "../cp-node/cp-node.js";
+import type { MatchedBeziers } from "./matched-beziers.js";
+import { getMatchingBeziers } from "./get-matching-beziers.js";
+import { isFullyTerminating } from "./is-fully-terminating.js";
+
+
+function getMbssByLoopWithOppArr(
+        cpNodess: CpNode[][]) {
+
+    const mbssByLoop: (MatchedBeziers[] | undefined)[][] = [];
+
+    /**
+     * An array with each entry being a pair of indices mapping from
+     * `MatchedBeziers[]` on one side to `MatchedBeziers[]` on the other side
+     */
+    const mbMap: Map<CpNode, [number,number]> = new Map();
+
+    for (let l=0; l<cpNodess.length; l++) {
+        const cpNodes = cpNodess[l];
+
+        const mbss: (MatchedBeziers[] | undefined)[] = [];
+        for (let i=0; i<cpNodes.length; i++) {
+            const cpNode = cpNodes[i];
+
+            mbMap.set(cpNode, [l,i]);
+
+            const mbs = getMatchingBeziers(cpNode);
+
+            mbss.push(mbs);
+        }
+
+        mbssByLoop.push(mbss);
+    }
+
+
+    const oppArr: [[number,number],[number,number]][] = [];
+
+    for (let l=0; l<cpNodess.length; l++) {
+        const cpNodes = cpNodess[l];
+
+        for (let i=0; i<cpNodes.length; i++) {
+            const cpNode = cpNodes[i];
+
+            const cpNodeOpp = isFullyTerminating(cpNode)
+                ? undefined // no opposite boundary
+                : cpNode.next.prevOnCircle;
+            
+            // if (cpNodeOpp === undefined) {
+            //     continue;
+            // }
+
+            const oppIdxs = cpNodeOpp === undefined
+                ? [255,65535] as [number,number]
+                : mbMap.get(cpNodeOpp);
+
+            const mbs = mbssByLoop[l][i];
+            if (oppIdxs !== undefined && mbs !== undefined) {
+                oppArr.push([[l,i], oppIdxs]);
+            } else {
+                oppArr.push([[l,i], [255,65535]]);
+            }
+        }
+    }
+
+    return { mbssByLoop, oppArr };
+}
+
+
+export { getMbssByLoopWithOppArr }

package/src/reconstruct-from-mat/get-sats2.ts

@@ -0,0 +1,25 @@
+import type { Mat } from '../mat/mat.js';
+import { findMats } from '../find-mat/find-mats.js';
+import { removeSatInducedTrivial3Prongs } from "./remove-sat-induced-trivial-3prongs.js";
+import { toScaleAxis } from '../sat/to-scale-axis.js';
+
+
+/**
+ * Returns the shape information.
+ * 
+ * @param font$$ the font from which the glyph outlines will be retrieved
+ * @param glyphId the glyph id for which the shape is to be retrieved
+ * @param options the options for SAT computation
+ */
+// TODO
+function getSats2(
+        mats: Mat[],
+        satScale: number): Mat[] {
+
+    const sats = mats.map(mat => toScaleAxis(mat, satScale));
+
+    return sats.map(removeSatInducedTrivial3Prongs);
+}
+
+
+export { getSats2 }

package/src/reconstruct-from-mat/is-fully-terminating.ts

@@ -0,0 +1,27 @@
+import type { CpNode } from '../cp-node/cp-node.js';
+import { getAllOnCircle } from '../cp-node/fs/get-all-on-circle.js';
+import { isTerminating } from '../cp-node/fs/is-terminating.js';
+import { isTrivial } from '../cp-node/fs/is-trivial.js';
+
+
+// TODO - DUPLICATE! -> likely other version needs fixing
+function isFullyTerminating(cpNode: CpNode) {
+    if (!isTerminating(cpNode)) {
+        return false;
+    }
+
+    if (isTrivial(cpNode)) {
+        return true;
+    }
+
+    while (cpNode.prev === cpNode.prevOnCircle) {
+        cpNode = cpNode.prev;
+    }
+
+    const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
+
+    return otherOnCircle.every(isTerminating);
+}
+
+
+export { isFullyTerminating }

package/src/reconstruct-from-mat/matched-beziers.ts

@@ -0,0 +1,14 @@
+import type { BezierPiece } from 'flo-bezier3';
+
+
+/**
+ * A type representing a correspondence between 3 bezier curves (one on the
+ * boundary, one on the medial axis and one on the opposite boundary)
+ */
+interface MatchedBeziers {
+    readonly medialBezier: BezierPiece;
+    readonly boundaryBezier: BezierPiece;
+}
+
+
+export type { MatchedBeziers }