flo-mat 2.0.2 → 2.0.4

package/node/circle.d.ts

@@ -1,20 +1,20 @@
-/**
- * Canonical circle representation.
- */
-interface Circle {
-    center: number[];
-    radius: number;
-}
-/**
- * Returns a scaled version of the given circle without changing its center.
- * @param circle
- * @param s multiplier
- */
-declare function scaleCircle(circle: Circle, s: number): Circle;
-/**
- * Returns true if the first circle engulfs the second.
- * @param c1
- * @param c2
- */
-declare function engulfsCircle(c1: Circle, c2: Circle): boolean;
-export { Circle, scaleCircle, engulfsCircle };
+/**
+ * Canonical circle representation.
+ */
+interface Circle {
+    center: number[];
+    radius: number;
+}
+/**
+ * Returns a scaled version of the given circle without changing its center.
+ * @param circle
+ * @param s multiplier
+ */
+declare function scaleCircle(circle: Circle, s: number): Circle;
+/**
+ * Returns true if the first circle engulfs the second.
+ * @param c1
+ * @param c2
+ */
+declare function engulfsCircle(c1: Circle, c2: Circle): boolean;
+export { Circle, scaleCircle, engulfsCircle };

package/node/circle.js

@@ -1,32 +1,32 @@
-import { squaredDistanceBetween } from 'flo-vector2d';
-/**
- * Returns a scaled version of the given circle without changing its center.
- * @param circle
- * @param s multiplier
- */
-function scaleCircle(circle, s) {
-    return { center: circle.center, radius: s * circle.radius };
-}
-/**
- * Returns true if the first circle engulfs the second.
- * @param c1
- * @param c2
- */
-function engulfsCircle(c1, c2) {
-    if (c1.radius <= c2.radius) {
-        return false;
-    }
-    const d = squaredDistanceBetween(c1.center, c2.center);
-    const dr = c1.radius - c2.radius;
-    const δ = dr * dr;
-    return δ > d;
-}
-/**
- * Returns a human-readable string description of the given circle.
- * @param circle
- */
-function toString(circle) {
-    return 'c: ' + circle.center + ' r: ' + circle.radius;
-}
-export { scaleCircle, engulfsCircle };
+import { squaredDistanceBetween } from 'flo-vector2d';
+/**
+ * Returns a scaled version of the given circle without changing its center.
+ * @param circle
+ * @param s multiplier
+ */
+function scaleCircle(circle, s) {
+    return { center: circle.center, radius: s * circle.radius };
+}
+/**
+ * Returns true if the first circle engulfs the second.
+ * @param c1
+ * @param c2
+ */
+function engulfsCircle(c1, c2) {
+    if (c1.radius <= c2.radius) {
+        return false;
+    }
+    const d = squaredDistanceBetween(c1.center, c2.center);
+    const dr = c1.radius - c2.radius;
+    const δ = dr * dr;
+    return δ > d;
+}
+/**
+ * Returns a human-readable string description of the given circle.
+ * @param circle
+ */
+function toString(circle) {
+    return 'c: ' + circle.center + ' r: ' + circle.radius;
+}
+export { scaleCircle, engulfsCircle };
 //# sourceMappingURL=circle.js.map

package/node/compare-curvatures-at-interface.d.ts

@@ -1,19 +1,19 @@
-/**
- * Compare the curvature, κ, between two curves at t === 0.
- *
- * Returns a positive number if κ for psI > κ for psO, negative if κ for psI < κ
- * for psO or zero if the curve extensions are identical (i.e. in same K-family).
- *
- * Precondition: The point psI evaluated at zero must === the point psO
- * evaluated at zero.
- *
- * // TODO - is this correct?
- * Exact: Returns the exact result if the bithlength of all
- * coordinates <= 53 - 5 === 48 and are bit-aligned.
- *
- * @param psI An order 1, 2 or 3 bezier, e.g. [[0,0],[1,1],[2,1],[2,0]]
- * representing the incoming curve
- * @param psO Another bezier representing the outgoing curve
- */
-declare function compareCurvaturesAtInterface(psI: number[][], psO: number[][]): number;
-export { compareCurvaturesAtInterface };
+/**
+ * Compare the curvature, κ, between two curves at t === 0.
+ *
+ * Returns a positive number if κ for psI > κ for psO, negative if κ for psI < κ
+ * for psO or zero if the curve extensions are identical (i.e. in same K-family).
+ *
+ * Precondition: The point psI evaluated at zero must === the point psO
+ * evaluated at zero.
+ *
+ * // TODO - is this correct?
+ * Exact: Returns the exact result if the bithlength of all
+ * coordinates <= 53 - 5 === 48 and are bit-aligned.
+ *
+ * @param psI An order 1, 2 or 3 bezier, e.g. [[0,0],[1,1],[2,1],[2,0]]
+ * representing the incoming curve
+ * @param psO Another bezier representing the outgoing curve
+ */
+declare function compareCurvaturesAtInterface(psI: number[][], psO: number[][]): number;
+export { compareCurvaturesAtInterface };

package/node/compare-curvatures-at-interface.js

@@ -1,125 +1,125 @@
-import { eSign, twoProduct, eDiff, expansionProduct, fastExpansionSum, scaleExpansion } from "big-float-ts";
-import { tangentAt0, evaluate2ndDerivativeAt0, toPowerBasis_3rdDerivative } from "flo-bezier3";
-/**
- * Compare the curvature, κ, between two curves at t === 0.
- *
- * Returns a positive number if κ for psI > κ for psO, negative if κ for psI < κ
- * for psO or zero if the curve extensions are identical (i.e. in same K-family).
- *
- * Precondition: The point psI evaluated at zero must === the point psO
- * evaluated at zero.
- *
- * // TODO - is this correct?
- * Exact: Returns the exact result if the bithlength of all
- * coordinates <= 53 - 5 === 48 and are bit-aligned.
- *
- * @param psI An order 1, 2 or 3 bezier, e.g. [[0,0],[1,1],[2,1],[2,0]]
- * representing the incoming curve
- * @param psO Another bezier representing the outgoing curve
- */
-function compareCurvaturesAtInterface(psI, psO) {
-    // Get x' and y' for incoming curve evaluated at 0
-    const [dxI, dyI] = tangentAt0(psI); // max bitlength increase / max shift === 3
-    // Get x'' and y'' for incoming curve evaluated at 0
-    const [ddxI, ddyI] = evaluate2ndDerivativeAt0(psI); // max bitlength increase / max shift === 5
-    // Get x' and y' for outgoing curve evaluated at 0
-    const [dxO, dyO] = tangentAt0(psO); // max bitlength increase / max shift === 3
-    // Get x'' and y'' for outgoing curve evaluated at 0
-    const [ddxO, ddyO] = evaluate2ndDerivativeAt0(psO); // max bitlength increase / max shift === 5
-    //console.log('κI: ', κ(psI, 0));
-    //console.log('κO: ', κ(psO, 0));
-    // Remember the formula for the signed curvature of a parametric curve:
-    // κ = x′y′′ - y′x′′ / sqrt(x′² + y′²)³
-    // κ² = (x′y′′ - y′x′′)² / (x′² + y′²)³
-    // This allows us to do an exact comparison of curvatures
-    // Simplifying the above gives (denoting the incoming curve with a subscript
-    // of 1 and the outgoing with a 2):
-    //      κIncoming > κOutgoing
-    // <=>  (x₁′y₁′′ - y₁′x₁′′)²(x₂′² + y₂′²)³ > (x₂′y₂′′ - y₂′x₂′′)²(x₁′² + y₁′²)³
-    // <=>  a²b³ > c²d³
-    // Note b³ > 0 and d³ > 0
-    // max aggregate bitlength increase (let original bitlength === p):
-    // a -> 2 x ((p+3)+(p+5) + 1) === 4p + 18 -> max p in double precision === 8 -> too low
-    //let a = (dxI*ddyI - dyI*ddxI)**2;
-    // b -> 3 x ((p+3) + 1) === 3p + 12
-    //let b = (dxO*dxO  + dyO*dyO )**3;
-    // c -> 2 x ((p+3)+(p+5) + 1) === 4p + 18
-    //let c = (dxO*ddyO - dyO*ddxO)**2;
-    // d -> 3 x ((p+3) + 1) === 3p + 12
-    //let d = (dxI*dxI  + dyI*dyI )**3;
-    // We need to resort to exact floating point arithmetic at this point
-    const a = eDiff(twoProduct(dxI, ddyI), twoProduct(dyI, ddxI));
-    const c = eDiff(twoProduct(dxO, ddyO), twoProduct(dyO, ddxO));
-    const signA = eSign(a);
-    const signC = eSign(c);
-    if (signA !== signC) {
-        //console.log('branch 3');
-        return signA - signC;
-    }
-    const b = fastExpansionSum(twoProduct(dxO, dxO), twoProduct(dyO, dyO));
-    const d = fastExpansionSum(twoProduct(dxI, dxI), twoProduct(dyI, dyI));
-    const b2 = expansionProduct(b, b);
-    const b3 = expansionProduct(b2, b);
-    const d2 = expansionProduct(d, d);
-    const d3 = expansionProduct(d2, d);
-    if (signA !== 0 || signC !== 0) {
-        //console.log('branch 4');
-        const a2 = expansionProduct(a, a);
-        const c2 = expansionProduct(c, c);
-        // max aggregate bitlength increase (let original bitlength === p):
-        // κ -> (2 x ((p+3)+(p+5) + 1)) + (3 x ((p+3) + 1)) === 7p + 30
-        // e.g. for bit-aligned input bitlength p of 10 we get output bitlength 
-        // of 100, or for p === 3 (the max exact bitlength allowed to have exact
-        // results without resorting to infinite precision) we get 51 bits.
-        const κI = expansionProduct(a2, b3);
-        const κO = expansionProduct(c2, d3);
-        const δκ = eSign(eDiff(κI, κO));
-        if (δκ !== 0) {
-            //console.log('branch 5');
-            // At this point signA === signC, both +tive or -tive
-            return signA > 0 ? δκ : -δκ;
-        }
-    }
-    // At this point signA === signC, both +tive or -tive or 0
-    // Now we have to look at the change of curvature w.r.t. the parameter t,
-    // i.e. 
-    // κ′ = [(x′²+y′²)(x′y′′′-y′x′′′) - 3(x′y′′-y′x′′)(x′x′′+y′y′′)] / (x′²+y′²)^(5/2)
-    // Therefore: (denoting the incoming curve with a subscript of 1 and the outgoing with a 2)
-    // κ′Incoming > κ′Outgoing
-    // <=> [(x₁′²+y₁′²)(x₁′y₁′′′-y₁′x₁′′′) - 3(x₁′y₁′′-y₁′x₁′′)(x₁′x₁′′+y₁′y₁′′)]²(x₂′²+y₂′²)⁵ >
-    //     [(x₂′²+y₂′²)(x₂′y₂′′′-y₂′x₂′′′) - 3(x₂′y₂′′-y₂′x₂′′)(x₂′x₂′′+y₂′y₂′′)]²(x₁′²+y₁′²)⁵
-    // <=> (de - 3af)²b⁵ > (bg - 3ch)²d⁵
-    // <=> i²b⁵ > j²d⁵
-    // Get x′′′ and y′′′ for incoming curve evaluated at 1
-    const [dddxI, dddyI] = toPowerBasis_3rdDerivative(psI); // max bitlength increase === max shift === 6
-    const [dddxO, dddyO] = toPowerBasis_3rdDerivative(psO); // max bitlength increase === max shift === 6
-    const e = eDiff(twoProduct(dxI, dddyI), twoProduct(dyI, dddxI));
-    const f = fastExpansionSum(twoProduct(dxI, ddxI), twoProduct(dyI, ddyI));
-    const g = eDiff(twoProduct(dxO, dddyO), twoProduct(dyO, dddxO));
-    const h = fastExpansionSum(twoProduct(dxO, ddxO), twoProduct(dyO, ddyO));
-    // (de - 3af)²b⁵ > (bg - 3ch)²d⁵
-    // i²b⁵ > j²d⁵
-    const i = eDiff(expansionProduct(d, e), scaleExpansion(expansionProduct(a, f), 3));
-    const j = eDiff(expansionProduct(b, g), scaleExpansion(expansionProduct(c, h), 3));
-    const signI = eSign(i);
-    const signJ = eSign(j);
-    if (signA !== signC) {
-        return signI - signJ;
-    }
-    if (signI === 0 && signJ === 0) {
-        // Both curve extensions are identical, i.e. in the same K-family
-        return 0;
-    }
-    const i2 = expansionProduct(i, i);
-    const b5 = expansionProduct(b2, b3);
-    const j2 = expansionProduct(j, j);
-    const d5 = expansionProduct(d2, d3);
-    const dκI = expansionProduct(i2, b5);
-    const dκO = expansionProduct(j2, d5);
-    const sgn = eSign(eDiff(dκI, dκO));
-    return signI > 0 ? sgn : -sgn;
-    // If the above returned value is still zero then the two curve extensions 
-    // are identical, i.e. in the same K-family
-}
-export { compareCurvaturesAtInterface };
+import { eSign, twoProduct, eDiff, expansionProduct, fastExpansionSum, scaleExpansion } from "big-float-ts";
+import { tangentAt0, evaluate2ndDerivativeAt0, toPowerBasis_3rdDerivative } from "flo-bezier3";
+/**
+ * Compare the curvature, κ, between two curves at t === 0.
+ *
+ * Returns a positive number if κ for psI > κ for psO, negative if κ for psI < κ
+ * for psO or zero if the curve extensions are identical (i.e. in same K-family).
+ *
+ * Precondition: The point psI evaluated at zero must === the point psO
+ * evaluated at zero.
+ *
+ * // TODO - is this correct?
+ * Exact: Returns the exact result if the bithlength of all
+ * coordinates <= 53 - 5 === 48 and are bit-aligned.
+ *
+ * @param psI An order 1, 2 or 3 bezier, e.g. [[0,0],[1,1],[2,1],[2,0]]
+ * representing the incoming curve
+ * @param psO Another bezier representing the outgoing curve
+ */
+function compareCurvaturesAtInterface(psI, psO) {
+    // Get x' and y' for incoming curve evaluated at 0
+    const [dxI, dyI] = tangentAt0(psI); // max bitlength increase / max shift === 3
+    // Get x'' and y'' for incoming curve evaluated at 0
+    const [ddxI, ddyI] = evaluate2ndDerivativeAt0(psI); // max bitlength increase / max shift === 5
+    // Get x' and y' for outgoing curve evaluated at 0
+    const [dxO, dyO] = tangentAt0(psO); // max bitlength increase / max shift === 3
+    // Get x'' and y'' for outgoing curve evaluated at 0
+    const [ddxO, ddyO] = evaluate2ndDerivativeAt0(psO); // max bitlength increase / max shift === 5
+    //console.log('κI: ', κ(psI, 0));
+    //console.log('κO: ', κ(psO, 0));
+    // Remember the formula for the signed curvature of a parametric curve:
+    // κ = x′y′′ - y′x′′ / sqrt(x′² + y′²)³
+    // κ² = (x′y′′ - y′x′′)² / (x′² + y′²)³
+    // This allows us to do an exact comparison of curvatures
+    // Simplifying the above gives (denoting the incoming curve with a subscript
+    // of 1 and the outgoing with a 2):
+    //      κIncoming > κOutgoing
+    // <=>  (x₁′y₁′′ - y₁′x₁′′)²(x₂′² + y₂′²)³ > (x₂′y₂′′ - y₂′x₂′′)²(x₁′² + y₁′²)³
+    // <=>  a²b³ > c²d³
+    // Note b³ > 0 and d³ > 0
+    // max aggregate bitlength increase (let original bitlength === p):
+    // a -> 2 x ((p+3)+(p+5) + 1) === 4p + 18 -> max p in double precision === 8 -> too low
+    //let a = (dxI*ddyI - dyI*ddxI)**2;
+    // b -> 3 x ((p+3) + 1) === 3p + 12
+    //let b = (dxO*dxO  + dyO*dyO )**3;
+    // c -> 2 x ((p+3)+(p+5) + 1) === 4p + 18
+    //let c = (dxO*ddyO - dyO*ddxO)**2;
+    // d -> 3 x ((p+3) + 1) === 3p + 12
+    //let d = (dxI*dxI  + dyI*dyI )**3;
+    // We need to resort to exact floating point arithmetic at this point
+    const a = eDiff(twoProduct(dxI, ddyI), twoProduct(dyI, ddxI));
+    const c = eDiff(twoProduct(dxO, ddyO), twoProduct(dyO, ddxO));
+    const signA = eSign(a);
+    const signC = eSign(c);
+    if (signA !== signC) {
+        //console.log('branch 3');
+        return signA - signC;
+    }
+    const b = fastExpansionSum(twoProduct(dxO, dxO), twoProduct(dyO, dyO));
+    const d = fastExpansionSum(twoProduct(dxI, dxI), twoProduct(dyI, dyI));
+    const b2 = expansionProduct(b, b);
+    const b3 = expansionProduct(b2, b);
+    const d2 = expansionProduct(d, d);
+    const d3 = expansionProduct(d2, d);
+    if (signA !== 0 || signC !== 0) {
+        //console.log('branch 4');
+        const a2 = expansionProduct(a, a);
+        const c2 = expansionProduct(c, c);
+        // max aggregate bitlength increase (let original bitlength === p):
+        // κ -> (2 x ((p+3)+(p+5) + 1)) + (3 x ((p+3) + 1)) === 7p + 30
+        // e.g. for bit-aligned input bitlength p of 10 we get output bitlength 
+        // of 100, or for p === 3 (the max exact bitlength allowed to have exact
+        // results without resorting to infinite precision) we get 51 bits.
+        const κI = expansionProduct(a2, b3);
+        const κO = expansionProduct(c2, d3);
+        const δκ = eSign(eDiff(κI, κO));
+        if (δκ !== 0) {
+            //console.log('branch 5');
+            // At this point signA === signC, both +tive or -tive
+            return signA > 0 ? δκ : -δκ;
+        }
+    }
+    // At this point signA === signC, both +tive or -tive or 0
+    // Now we have to look at the change of curvature w.r.t. the parameter t,
+    // i.e. 
+    // κ′ = [(x′²+y′²)(x′y′′′-y′x′′′) - 3(x′y′′-y′x′′)(x′x′′+y′y′′)] / (x′²+y′²)^(5/2)
+    // Therefore: (denoting the incoming curve with a subscript of 1 and the outgoing with a 2)
+    // κ′Incoming > κ′Outgoing
+    // <=> [(x₁′²+y₁′²)(x₁′y₁′′′-y₁′x₁′′′) - 3(x₁′y₁′′-y₁′x₁′′)(x₁′x₁′′+y₁′y₁′′)]²(x₂′²+y₂′²)⁵ >
+    //     [(x₂′²+y₂′²)(x₂′y₂′′′-y₂′x₂′′′) - 3(x₂′y₂′′-y₂′x₂′′)(x₂′x₂′′+y₂′y₂′′)]²(x₁′²+y₁′²)⁵
+    // <=> (de - 3af)²b⁵ > (bg - 3ch)²d⁵
+    // <=> i²b⁵ > j²d⁵
+    // Get x′′′ and y′′′ for incoming curve evaluated at 1
+    const [dddxI, dddyI] = toPowerBasis_3rdDerivative(psI); // max bitlength increase === max shift === 6
+    const [dddxO, dddyO] = toPowerBasis_3rdDerivative(psO); // max bitlength increase === max shift === 6
+    const e = eDiff(twoProduct(dxI, dddyI), twoProduct(dyI, dddxI));
+    const f = fastExpansionSum(twoProduct(dxI, ddxI), twoProduct(dyI, ddyI));
+    const g = eDiff(twoProduct(dxO, dddyO), twoProduct(dyO, dddxO));
+    const h = fastExpansionSum(twoProduct(dxO, ddxO), twoProduct(dyO, ddyO));
+    // (de - 3af)²b⁵ > (bg - 3ch)²d⁵
+    // i²b⁵ > j²d⁵
+    const i = eDiff(expansionProduct(d, e), scaleExpansion(expansionProduct(a, f), 3));
+    const j = eDiff(expansionProduct(b, g), scaleExpansion(expansionProduct(c, h), 3));
+    const signI = eSign(i);
+    const signJ = eSign(j);
+    if (signA !== signC) {
+        return signI - signJ;
+    }
+    if (signI === 0 && signJ === 0) {
+        // Both curve extensions are identical, i.e. in the same K-family
+        return 0;
+    }
+    const i2 = expansionProduct(i, i);
+    const b5 = expansionProduct(b2, b3);
+    const j2 = expansionProduct(j, j);
+    const d5 = expansionProduct(d2, d3);
+    const dκI = expansionProduct(i2, b5);
+    const dκO = expansionProduct(j2, d5);
+    const sgn = eSign(eDiff(dκI, dκO));
+    return signI > 0 ? sgn : -sgn;
+    // If the above returned value is still zero then the two curve extensions 
+    // are identical, i.e. in the same K-family
+}
+export { compareCurvaturesAtInterface };
 //# sourceMappingURL=compare-curvatures-at-interface.js.map

package/node/contact-point.d.ts

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

package/node/contact-point.js

@@ -1,26 +1,26 @@
-import { comparePoss } from './point-on-shape.js';
-/**
- * Primarily for internal use.
- *
- * Compares the two contact points according to their order along the shape
- * boundary. Returns > 0 if a > b, < 0 if a < b or 0 if a === b.
- * @param a The first contact point.
- * @param b The second contact point.
- */
-function compareCps(a, b) {
-    //let res = PointOnShape.compare(a.pointOnShape, b.pointOnShape);
-    let res = comparePoss(a.pointOnShape, b.pointOnShape);
-    if (res === undefined) {
-        return undefined;
-    }
-    if (res !== 0) {
-        return res;
-    }
-    res = a.order - b.order;
-    if (res !== 0) {
-        return res;
-    }
-    return a.order2 - b.order2;
-}
-export { compareCps };
+import { comparePoss } from './point-on-shape.js';
+/**
+ * Primarily for internal use.
+ *
+ * Compares the two contact points according to their order along the shape
+ * boundary. Returns > 0 if a > b, < 0 if a < b or 0 if a === b.
+ * @param a The first contact point.
+ * @param b The second contact point.
+ */
+function compareCps(a, b) {
+    //let res = PointOnShape.compare(a.pointOnShape, b.pointOnShape);
+    let res = comparePoss(a.pointOnShape, b.pointOnShape);
+    if (res === undefined) {
+        return undefined;
+    }
+    if (res !== 0) {
+        return res;
+    }
+    res = a.order - b.order;
+    if (res !== 0) {
+        return res;
+    }
+    return a.order2 - b.order2;
+}
+export { compareCps };
 //# sourceMappingURL=contact-point.js.map

package/node/cp-node/clone.d.ts

@@ -1,8 +1,8 @@
-import { CpNode } from "../cp-node.js";
-/**
- * Returns a deep clone of this [[CpNode]]. Can be used to copy the MAT
- * since cloning a single [[CpNode]] necessarily implies cloning all
- * [[CpNode]]s on the same MAT tree.
- */
-declare function clone(cpNode: CpNode): CpNode;
-export { clone };
+import { CpNode } from "../cp-node.js";
+/**
+ * Returns a deep clone of this [[CpNode]]. Can be used to copy the MAT
+ * since cloning a single [[CpNode]] necessarily implies cloning all
+ * [[CpNode]]s on the same MAT tree.
+ */
+declare function clone(cpNode: CpNode): CpNode;
+export { clone };

package/node/cp-node/clone.js

@@ -1,32 +1,32 @@
-import { CpNode } from "../cp-node.js";
-/** @hidden */
-const EDGES = ['prev', 'next', 'prevOnCircle', 'nextOnCircle'];
-/**
- * Returns a deep clone of this [[CpNode]]. Can be used to copy the MAT
- * since cloning a single [[CpNode]] necessarily implies cloning all
- * [[CpNode]]s on the same MAT tree.
- */
-function clone(cpNode) {
-    // Don't change this function to be recursive, the call stack may 
-    // overflow if there are too many CpNodes.
-    const nodeMap = new Map();
-    const newCpNode = new CpNode(cpNode.cp, cpNode.isHoleClosing, cpNode.isIntersection);
-    nodeMap.set(cpNode, newCpNode);
-    const cpStack = [{ cpNode, newCpNode }];
-    while (cpStack.length) {
-        const { cpNode, newCpNode } = cpStack.pop();
-        for (const edge of EDGES) {
-            const node = cpNode[edge];
-            let newNode = nodeMap.get(node);
-            if (!newNode) {
-                newNode = new CpNode(node.cp, node.isHoleClosing, node.isIntersection);
-                nodeMap.set(node, newNode);
-                cpStack.push({ cpNode: node, newCpNode: newNode });
-            }
-            newCpNode[edge] = newNode;
-        }
-    }
-    return newCpNode;
-}
-export { clone };
+import { CpNode } from "../cp-node.js";
+/** @hidden */
+const EDGES = ['prev', 'next', 'prevOnCircle', 'nextOnCircle'];
+/**
+ * Returns a deep clone of this [[CpNode]]. Can be used to copy the MAT
+ * since cloning a single [[CpNode]] necessarily implies cloning all
+ * [[CpNode]]s on the same MAT tree.
+ */
+function clone(cpNode) {
+    // Don't change this function to be recursive, the call stack may 
+    // overflow if there are too many CpNodes.
+    const nodeMap = new Map();
+    const newCpNode = new CpNode(cpNode.cp, cpNode.isHoleClosing, cpNode.isIntersection);
+    nodeMap.set(cpNode, newCpNode);
+    const cpStack = [{ cpNode, newCpNode }];
+    while (cpStack.length) {
+        const { cpNode, newCpNode } = cpStack.pop();
+        for (const edge of EDGES) {
+            const node = cpNode[edge];
+            let newNode = nodeMap.get(node);
+            if (!newNode) {
+                newNode = new CpNode(node.cp, node.isHoleClosing, node.isIntersection);
+                nodeMap.set(node, newNode);
+                cpStack.push({ cpNode: node, newCpNode: newNode });
+            }
+            newCpNode[edge] = newNode;
+        }
+    }
+    return newCpNode;
+}
+export { clone };
 //# sourceMappingURL=clone.js.map

package/node/cp-node/remove.d.ts

@@ -1,9 +1,9 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from "../cp-node.js";
-/**
- * Removes a cpNode from the MAT.
- * @param cpTree The tree graph holding the [[CpNodes]] of the MAT.
- * @param cpNode The [[CpNode]] to remove.
- */
-declare function removeCpNode(cpNode: CpNode, cpTree?: LlRbTree<CpNode>): void;
-export { removeCpNode };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { CpNode } from "../cp-node.js";
+/**
+ * Removes a cpNode from the MAT.
+ * @param cpTree The tree graph holding the [[CpNodes]] of the MAT.
+ * @param cpNode The [[CpNode]] to remove.
+ */
+declare function removeCpNode(cpNode: CpNode, cpTree?: LlRbTree<CpNode>): void;
+export { removeCpNode };

package/node/cp-node/remove.js

@@ -1,20 +1,20 @@
-/**
- * Removes a cpNode from the MAT.
- * @param cpTree The tree graph holding the [[CpNodes]] of the MAT.
- * @param cpNode The [[CpNode]] to remove.
- */
-function removeCpNode(cpNode, cpTree) {
-    const prev = cpNode.prev;
-    const next = cpNode.next;
-    prev.next = next;
-    next.prev = prev;
-    const nextOpposite = next.prevOnCircle;
-    const prevOpposite = prev.nextOnCircle;
-    nextOpposite.next = prevOpposite;
-    prevOpposite.prev = nextOpposite;
-    if (cpTree) {
-        cpTree.remove(cpNode, false);
-    }
-}
-export { removeCpNode };
+/**
+ * Removes a cpNode from the MAT.
+ * @param cpTree The tree graph holding the [[CpNodes]] of the MAT.
+ * @param cpNode The [[CpNode]] to remove.
+ */
+function removeCpNode(cpNode, cpTree) {
+    const prev = cpNode.prev;
+    const next = cpNode.next;
+    prev.next = next;
+    next.prev = prev;
+    const nextOpposite = next.prevOnCircle;
+    const prevOpposite = prev.nextOnCircle;
+    nextOpposite.next = prevOpposite;
+    prevOpposite.prev = nextOpposite;
+    if (cpTree) {
+        cpTree.remove(cpNode, false);
+    }
+}
+export { removeCpNode };
 //# sourceMappingURL=remove.js.map