clipper2-ts 2.0.1-7 → 2.0.1-9

package/dist/Core.js

@@ -37,557 +37,555 @@ export var PointInPolygonResult;
     PointInPolygonResult[PointInPolygonResult["IsInside"] = 1] = "IsInside";
     PointInPolygonResult[PointInPolygonResult["IsOutside"] = 2] = "IsOutside";
 })(PointInPolygonResult || (PointInPolygonResult = {}));
-export var InternalClipper;
-(function (InternalClipper) {
-    InternalClipper.MaxInt64 = 9223372036854775807n;
-    InternalClipper.MaxCoord = Number(InternalClipper.MaxInt64 / 4n);
-    InternalClipper.max_coord = InternalClipper.MaxCoord;
-    InternalClipper.min_coord = -InternalClipper.MaxCoord;
-    InternalClipper.Invalid64 = Number(InternalClipper.MaxInt64);
-    InternalClipper.floatingPointTolerance = 1E-12;
-    InternalClipper.defaultMinimumEdgeLength = 0.1;
-    const maxSafeInteger = Number.MAX_SAFE_INTEGER;
-    const maxDeltaForSafeProduct = Math.floor(Math.sqrt(maxSafeInteger));
-    InternalClipper.maxCoordForSafeAreaProduct = Math.floor(maxDeltaForSafeProduct / 2);
-    // Bound for |a|,|b|,|c|,|d| so cross^2 and denom stay safe
-    InternalClipper.maxCoordForSafeCrossSq = Math.floor(Math.sqrt(Math.sqrt(maxSafeInteger / 4)));
-    function maxSafeCoordinateForScale(scale) {
-        if (!Number.isFinite(scale)) {
-            throw new RangeError("Scale must be a finite number");
-        }
-        const absScale = Math.abs(scale);
-        if (absScale === 0)
-            return Number.POSITIVE_INFINITY;
-        return maxSafeInteger / absScale;
-    }
-    InternalClipper.maxSafeCoordinateForScale = maxSafeCoordinateForScale;
-    function checkSafeScaleValue(value, maxAbs, context) {
-        if (!Number.isFinite(value) || Math.abs(value) > maxAbs) {
-            throw new RangeError(`Scaled coordinate exceeds Number.MAX_SAFE_INTEGER in ${context}`);
-        }
-    }
-    InternalClipper.checkSafeScaleValue = checkSafeScaleValue;
-    function ensureSafeInteger(value, context) {
-        if (!Number.isFinite(value) || Math.abs(value) > maxSafeInteger) {
-            throw new RangeError(`Coordinate exceeds Number.MAX_SAFE_INTEGER in ${context}`);
-        }
-    }
-    InternalClipper.ensureSafeInteger = ensureSafeInteger;
-    function isSafeProduct(a, b) {
-        if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b))
-            return false;
-        if (a === 0 || b === 0)
-            return true;
-        return Math.abs(a) <= maxSafeInteger / Math.abs(b);
-    }
-    function isSafeSum(a, b) {
-        return Math.abs(a) + Math.abs(b) <= maxSafeInteger;
-    }
-    function safeMultiplyDifference(a, b, c, d) {
-        if (isSafeProduct(a, b) && isSafeProduct(c, d)) {
-            const prod1 = a * b;
-            const prod2 = c * d;
-            if (isSafeSum(prod1, prod2)) {
-                return prod1 - prod2;
-            }
-        }
-        if (Number.isSafeInteger(a) && Number.isSafeInteger(b) &&
-            Number.isSafeInteger(c) && Number.isSafeInteger(d)) {
-            return Number((BigInt(a) * BigInt(b)) - (BigInt(c) * BigInt(d)));
-        }
+// InternalClipper - converted from namespace to plain const object to avoid
+// the IIFE wrapper that tsc emits for namespaces. All functions are defined at
+// module level so internal cross-calls (e.g. isCollinear -> productsAreEqual)
+// are direct calls without property lookup overhead. The exported object bundles
+// them for external callers that use InternalClipper.foo() syntax.
+// --- private helpers (module-level, not exported) ---
+const maxSafeInteger = Number.MAX_SAFE_INTEGER;
+const maxDeltaForSafeProduct = Math.floor(Math.sqrt(maxSafeInteger));
+function isSafeProduct(a, b) {
+    if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b))
+        return false;
+    if (a === 0 || b === 0)
+        return true;
+    return Math.abs(a) <= maxSafeInteger / Math.abs(b);
+}
+function isSafeSum(a, b) {
+    return Math.abs(a) + Math.abs(b) <= maxSafeInteger;
+}
+function safeMultiplyDifference(a, b, c, d) {
+    if (isSafeProduct(a, b) && isSafeProduct(c, d)) {
+        const prod1 = a * b;
+        const prod2 = c * d;
+        if (isSafeSum(prod1, prod2)) {
+            return prod1 - prod2;
+        }
+    }
+    if (Number.isSafeInteger(a) && Number.isSafeInteger(b) &&
+        Number.isSafeInteger(c) && Number.isSafeInteger(d)) {
+        return Number((BigInt(a) * BigInt(b)) - (BigInt(c) * BigInt(d)));
+    }
+    return (a * b) - (c * d);
+}
+function safeMultiplySum(a, b, c, d) {
+    if (isSafeProduct(a, b) && isSafeProduct(c, d)) {
+        const prod1 = a * b;
+        const prod2 = c * d;
+        if (isSafeSum(prod1, prod2)) {
+            return prod1 + prod2;
+        }
+    }
+    if (Number.isSafeInteger(a) && Number.isSafeInteger(b) &&
+        Number.isSafeInteger(c) && Number.isSafeInteger(d)) {
+        return Number((BigInt(a) * BigInt(b)) + (BigInt(c) * BigInt(d)));
+    }
+    return (a * b) + (c * d);
+}
+// --- public constants (module-level for cross-referencing) ---
+const IC_MaxInt64 = 9223372036854775807n;
+const IC_MaxCoord = Number(IC_MaxInt64 / 4n);
+const IC_Invalid64 = Number(IC_MaxInt64);
+const IC_floatingPointTolerance = 1E-12;
+const IC_defaultMinimumEdgeLength = 0.1;
+const IC_maxCoordForSafeAreaProduct = Math.floor(maxDeltaForSafeProduct / 2);
+// Bound for |a|,|b|,|c|,|d| so cross^2 and denom stay safe
+const IC_maxCoordForSafeCrossSq = Math.floor(Math.sqrt(Math.sqrt(maxSafeInteger / 4)));
+// --- public functions (module-level for direct internal calls) ---
+function maxSafeCoordinateForScale(scale) {
+    if (!Number.isFinite(scale)) {
+        throw new RangeError("Scale must be a finite number");
+    }
+    const absScale = Math.abs(scale);
+    if (absScale === 0)
+        return Number.POSITIVE_INFINITY;
+    return maxSafeInteger / absScale;
+}
+function checkSafeScaleValue(value, maxAbs, context) {
+    if (!Number.isFinite(value) || Math.abs(value) > maxAbs) {
+        throw new RangeError(`Scaled coordinate exceeds Number.MAX_SAFE_INTEGER in ${context}`);
+    }
+}
+function ensureSafeInteger(value, context) {
+    if (!Number.isFinite(value) || Math.abs(value) > maxSafeInteger) {
+        throw new RangeError(`Coordinate exceeds Number.MAX_SAFE_INTEGER in ${context}`);
+    }
+}
+function crossProduct(pt1, pt2, pt3) {
+    const a = pt2.x - pt1.x;
+    const b = pt3.y - pt2.y;
+    const c = pt2.y - pt1.y;
+    const d = pt3.x - pt2.x;
+    // Fast path for small coordinates
+    if (Math.abs(a) < maxDeltaForSafeProduct && Math.abs(b) < maxDeltaForSafeProduct &&
+        Math.abs(c) < maxDeltaForSafeProduct && Math.abs(d) < maxDeltaForSafeProduct) {
         return (a * b) - (c * d);
     }
-    function safeMultiplySum(a, b, c, d) {
-        if (isSafeProduct(a, b) && isSafeProduct(c, d)) {
-            const prod1 = a * b;
-            const prod2 = c * d;
-            if (isSafeSum(prod1, prod2)) {
-                return prod1 + prod2;
-            }
-        }
-        if (Number.isSafeInteger(a) && Number.isSafeInteger(b) &&
-            Number.isSafeInteger(c) && Number.isSafeInteger(d)) {
-            return Number((BigInt(a) * BigInt(b)) + (BigInt(c) * BigInt(d)));
-        }
+    return safeMultiplyDifference(a, b, c, d);
+}
+function crossProductSign(pt1, pt2, pt3) {
+    const a = pt2.x - pt1.x;
+    const b = pt3.y - pt2.y;
+    const c = pt2.y - pt1.y;
+    const d = pt3.x - pt2.x;
+    // Fast check for safe integer range
+    // Using Math.abs inline allows short-circuiting
+    if (Math.abs(a) < maxDeltaForSafeProduct && Math.abs(b) < maxDeltaForSafeProduct &&
+        Math.abs(c) < maxDeltaForSafeProduct && Math.abs(d) < maxDeltaForSafeProduct) {
+        const prod1 = a * b;
+        const prod2 = c * d;
+        return (prod1 > prod2) ? 1 : (prod1 < prod2) ? -1 : 0;
+    }
+    if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b) ||
+        !Number.isSafeInteger(c) || !Number.isSafeInteger(d)) {
+        const prod1 = a * b;
+        const prod2 = c * d;
+        return (prod1 > prod2) ? 1 : (prod1 < prod2) ? -1 : 0;
+    }
+    const bigProd1 = BigInt(a) * BigInt(b);
+    const bigProd2 = BigInt(c) * BigInt(d);
+    if (bigProd1 === bigProd2)
+        return 0;
+    return (bigProd1 > bigProd2) ? 1 : -1;
+}
+function checkPrecision(precision) {
+    if (precision < -8 || precision > 8) {
+        throw new Error("Error: Precision is out of range.");
+    }
+}
+function isAlmostZero(value) {
+    return Math.abs(value) <= IC_floatingPointTolerance;
+}
+function triSign(x) {
+    return (x < 0) ? -1 : (x > 0) ? 1 : 0;
+}
+function multiplyUInt64(a, b) {
+    // Fix: a and b might be larger than 2^32, so don't use >>> 0
+    const aBig = BigInt(a);
+    const bBig = BigInt(b);
+    const res = aBig * bBig;
+    return {
+        lo64: res & 0xffffffffffffffffn,
+        hi64: res >> 64n
+    };
+}
+// returns true if (and only if) a * b == c * d
+function productsAreEqual(a, b, c, d) {
+    const absA = Math.abs(a);
+    const absB = Math.abs(b);
+    const absC = Math.abs(c);
+    const absD = Math.abs(d);
+    // Fast path for safe integer range (covers all typical coordinates)
+    if (absA < maxDeltaForSafeProduct && absB < maxDeltaForSafeProduct &&
+        absC < maxDeltaForSafeProduct && absD < maxDeltaForSafeProduct) {
+        return a * b === c * d;
+    }
+    const signAb = (a < 0 ? -1 : (a > 0 ? 1 : 0)) * (b < 0 ? -1 : (b > 0 ? 1 : 0));
+    const signCd = (c < 0 ? -1 : (c > 0 ? 1 : 0)) * (d < 0 ? -1 : (d > 0 ? 1 : 0));
+    if (signAb !== signCd)
+        return false;
+    if (signAb === 0)
+        return true;
+    if (!Number.isSafeInteger(absA) || !Number.isSafeInteger(absB) ||
+        !Number.isSafeInteger(absC) || !Number.isSafeInteger(absD)) {
+        return a * b === c * d;
+    }
+    const bigA = BigInt(absA);
+    const bigB = BigInt(absB);
+    const bigC = BigInt(absC);
+    const bigD = BigInt(absD);
+    return (bigA * bigB) === (bigC * bigD);
+}
+function isCollinear(pt1, sharedPt, pt2) {
+    const a = sharedPt.x - pt1.x;
+    const b = pt2.y - sharedPt.y;
+    const c = sharedPt.y - pt1.y;
+    const d = pt2.x - sharedPt.x;
+    // When checking for collinearity with very large coordinate values
+    // then ProductsAreEqual is more accurate than using CrossProduct.
+    return productsAreEqual(a, b, c, d);
+}
+function dotProduct(pt1, pt2, pt3) {
+    const a = pt2.x - pt1.x;
+    const b = pt3.x - pt2.x;
+    const c = pt2.y - pt1.y;
+    const d = pt3.y - pt2.y;
+    // Fast path for small coordinates
+    if (Math.abs(a) < maxDeltaForSafeProduct && Math.abs(b) < maxDeltaForSafeProduct &&
+        Math.abs(c) < maxDeltaForSafeProduct && Math.abs(d) < maxDeltaForSafeProduct) {
         return (a * b) + (c * d);
     }
-    function crossProduct(pt1, pt2, pt3) {
-        const a = pt2.x - pt1.x;
-        const b = pt3.y - pt2.y;
-        const c = pt2.y - pt1.y;
-        const d = pt3.x - pt2.x;
-        // Fast path for small coordinates
-        if (Math.abs(a) < maxDeltaForSafeProduct && Math.abs(b) < maxDeltaForSafeProduct &&
-            Math.abs(c) < maxDeltaForSafeProduct && Math.abs(d) < maxDeltaForSafeProduct) {
-            return (a * b) - (c * d);
-        }
-        return safeMultiplyDifference(a, b, c, d);
-    }
-    InternalClipper.crossProduct = crossProduct;
-    function crossProductSign(pt1, pt2, pt3) {
-        const a = pt2.x - pt1.x;
-        const b = pt3.y - pt2.y;
-        const c = pt2.y - pt1.y;
-        const d = pt3.x - pt2.x;
-        // Fast check for safe integer range
-        // Using Math.abs inline allows short-circuiting
-        if (Math.abs(a) < maxDeltaForSafeProduct && Math.abs(b) < maxDeltaForSafeProduct &&
-            Math.abs(c) < maxDeltaForSafeProduct && Math.abs(d) < maxDeltaForSafeProduct) {
-            const prod1 = a * b;
-            const prod2 = c * d;
-            return (prod1 > prod2) ? 1 : (prod1 < prod2) ? -1 : 0;
-        }
-        if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b) ||
-            !Number.isSafeInteger(c) || !Number.isSafeInteger(d)) {
-            const prod1 = a * b;
-            const prod2 = c * d;
-            return (prod1 > prod2) ? 1 : (prod1 < prod2) ? -1 : 0;
-        }
-        const bigProd1 = BigInt(a) * BigInt(b);
-        const bigProd2 = BigInt(c) * BigInt(d);
-        if (bigProd1 === bigProd2)
-            return 0;
-        return (bigProd1 > bigProd2) ? 1 : -1;
-    }
-    InternalClipper.crossProductSign = crossProductSign;
-    function checkPrecision(precision) {
-        if (precision < -8 || precision > 8) {
-            throw new Error("Error: Precision is out of range.");
-        }
-    }
-    InternalClipper.checkPrecision = checkPrecision;
-    function isAlmostZero(value) {
-        return Math.abs(value) <= InternalClipper.floatingPointTolerance;
-    }
-    InternalClipper.isAlmostZero = isAlmostZero;
-    function triSign(x) {
-        return (x < 0) ? -1 : (x > 0) ? 1 : 0;
-    }
-    InternalClipper.triSign = triSign;
-    function multiplyUInt64(a, b) {
-        // Fix: a and b might be larger than 2^32, so don't use >>> 0
-        const aBig = BigInt(a);
-        const bBig = BigInt(b);
-        const res = aBig * bBig;
-        return {
-            lo64: res & 0xffffffffffffffffn,
-            hi64: res >> 64n
-        };
-    }
-    InternalClipper.multiplyUInt64 = multiplyUInt64;
-    // returns true if (and only if) a * b == c * d
-    function productsAreEqual(a, b, c, d) {
-        const absA = Math.abs(a);
-        const absB = Math.abs(b);
-        const absC = Math.abs(c);
-        const absD = Math.abs(d);
-        // Fast path for typical coordinates
-        if (absA < 46341 && absB < 46341 && absC < 46341 && absD < 46341) {
-            return a * b === c * d;
-        }
-        // Extended fast path for safe integer range
-        if (absA < maxDeltaForSafeProduct && absB < maxDeltaForSafeProduct &&
-            absC < maxDeltaForSafeProduct && absD < maxDeltaForSafeProduct) {
-            return a * b === c * d;
-        }
-        const signAb = (a < 0 ? -1 : (a > 0 ? 1 : 0)) * (b < 0 ? -1 : (b > 0 ? 1 : 0));
-        const signCd = (c < 0 ? -1 : (c > 0 ? 1 : 0)) * (d < 0 ? -1 : (d > 0 ? 1 : 0));
-        if (signAb !== signCd)
-            return false;
-        if (signAb === 0)
-            return true;
-        if (!Number.isSafeInteger(absA) || !Number.isSafeInteger(absB) ||
-            !Number.isSafeInteger(absC) || !Number.isSafeInteger(absD)) {
-            return a * b === c * d;
-        }
-        const bigA = BigInt(absA);
-        const bigB = BigInt(absB);
-        const bigC = BigInt(absC);
-        const bigD = BigInt(absD);
-        return (bigA * bigB) === (bigC * bigD);
-    }
-    InternalClipper.productsAreEqual = productsAreEqual;
-    function isCollinear(pt1, sharedPt, pt2) {
-        const a = sharedPt.x - pt1.x;
-        const b = pt2.y - sharedPt.y;
-        const c = sharedPt.y - pt1.y;
-        const d = pt2.x - sharedPt.x;
-        // When checking for collinearity with very large coordinate values
-        // then ProductsAreEqual is more accurate than using CrossProduct.
-        return productsAreEqual(a, b, c, d);
-    }
-    InternalClipper.isCollinear = isCollinear;
-    function dotProduct(pt1, pt2, pt3) {
-        const a = pt2.x - pt1.x;
-        const b = pt3.x - pt2.x;
-        const c = pt2.y - pt1.y;
-        const d = pt3.y - pt2.y;
-        // Fast path for small coordinates
-        if (Math.abs(a) < maxDeltaForSafeProduct && Math.abs(b) < maxDeltaForSafeProduct &&
-            Math.abs(c) < maxDeltaForSafeProduct && Math.abs(d) < maxDeltaForSafeProduct) {
-            return (a * b) + (c * d);
-        }
-        return safeMultiplySum(a, b, c, d);
-    }
-    InternalClipper.dotProduct = dotProduct;
-    function dotProductSign(pt1, pt2, pt3) {
-        const a = pt2.x - pt1.x;
-        const b = pt3.x - pt2.x;
-        const c = pt2.y - pt1.y;
-        const d = pt3.y - pt2.y;
-        if (Math.abs(a) < maxDeltaForSafeProduct && Math.abs(b) < maxDeltaForSafeProduct &&
-            Math.abs(c) < maxDeltaForSafeProduct && Math.abs(d) < maxDeltaForSafeProduct) {
-            const sum = (a * b) + (c * d);
-            return sum > 0 ? 1 : (sum < 0 ? -1 : 0);
-        }
-        if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b) ||
-            !Number.isSafeInteger(c) || !Number.isSafeInteger(d)) {
-            const sum = (a * b) + (c * d);
-            return sum > 0 ? 1 : (sum < 0 ? -1 : 0);
-        }
-        const bigSum = (BigInt(a) * BigInt(b)) + (BigInt(c) * BigInt(d));
-        if (bigSum === 0n)
-            return 0;
-        return bigSum > 0n ? 1 : -1;
-    }
-    InternalClipper.dotProductSign = dotProductSign;
-    function area(path) {
-        // https://en.wikipedia.org/wiki/Shoelace_formula
-        const cnt = path.length;
-        if (cnt < 3)
-            return 0.0;
-        // Fast path when coords are small enough that (y1+y2)*(x1-x2) won't overflow
-        // maxCoordForSafeAreaProduct is floor(sqrt(Number.MAX_SAFE_INTEGER) / 2)
-        let allSmall = true;
-        for (let i = 0; i < cnt && allSmall; i++) {
-            const pt = path[i];
-            if (Math.abs(pt.x) >= InternalClipper.maxCoordForSafeAreaProduct ||
-                Math.abs(pt.y) >= InternalClipper.maxCoordForSafeAreaProduct) {
-                allSmall = false;
-            }
-        }
-        let prevPt = path[cnt - 1];
-        if (allSmall) {
-            // Fast path - no overflow checks needed
-            let total = 0.0;
-            for (const pt of path) {
-                total += (prevPt.y + pt.y) * (prevPt.x - pt.x);
-                prevPt = pt;
-            }
-            return total * 0.5;
-        }
-        // Safe path - use BigInt for accumulation
-        let totalBig = 0n;
+    return safeMultiplySum(a, b, c, d);
+}
+function dotProductSign(pt1, pt2, pt3) {
+    const a = pt2.x - pt1.x;
+    const b = pt3.x - pt2.x;
+    const c = pt2.y - pt1.y;
+    const d = pt3.y - pt2.y;
+    if (Math.abs(a) < maxDeltaForSafeProduct && Math.abs(b) < maxDeltaForSafeProduct &&
+        Math.abs(c) < maxDeltaForSafeProduct && Math.abs(d) < maxDeltaForSafeProduct) {
+        const sum = (a * b) + (c * d);
+        return sum > 0 ? 1 : (sum < 0 ? -1 : 0);
+    }
+    if (!Number.isSafeInteger(a) || !Number.isSafeInteger(b) ||
+        !Number.isSafeInteger(c) || !Number.isSafeInteger(d)) {
+        const sum = (a * b) + (c * d);
+        return sum > 0 ? 1 : (sum < 0 ? -1 : 0);
+    }
+    const bigSum = (BigInt(a) * BigInt(b)) + (BigInt(c) * BigInt(d));
+    if (bigSum === 0n)
+        return 0;
+    return bigSum > 0n ? 1 : -1;
+}
+function icArea(path) {
+    // https://en.wikipedia.org/wiki/Shoelace_formula
+    const cnt = path.length;
+    if (cnt < 3)
+        return 0.0;
+    // Fast path when coords are small enough that (y1+y2)*(x1-x2) won't overflow
+    // maxCoordForSafeAreaProduct is floor(sqrt(Number.MAX_SAFE_INTEGER) / 2)
+    let allSmall = true;
+    for (let i = 0; i < cnt && allSmall; i++) {
+        const pt = path[i];
+        if (Math.abs(pt.x) >= IC_maxCoordForSafeAreaProduct ||
+            Math.abs(pt.y) >= IC_maxCoordForSafeAreaProduct) {
+            allSmall = false;
+        }
+    }
+    let prevPt = path[cnt - 1];
+    if (allSmall) {
+        // Fast path - no overflow checks needed
+        let total = 0.0;
         for (const pt of path) {
-            const sum = prevPt.y + pt.y;
-            const diff = prevPt.x - pt.x;
-            if (Number.isSafeInteger(sum) && Number.isSafeInteger(diff)) {
-                totalBig += BigInt(sum) * BigInt(diff);
-            }
-            else if (Number.isSafeInteger(prevPt.y) && Number.isSafeInteger(pt.y) &&
-                Number.isSafeInteger(prevPt.x) && Number.isSafeInteger(pt.x)) {
-                const sumBig = BigInt(prevPt.y) + BigInt(pt.y);
-                const diffBig = BigInt(prevPt.x) - BigInt(pt.x);
-                totalBig += sumBig * diffBig;
-            }
-            else {
-                // Coordinates not safe integers - fall back to float
-                totalBig += BigInt(Math.round(sum * diff));
-            }
+            total += (prevPt.y + pt.y) * (prevPt.x - pt.x);
             prevPt = pt;
         }
-        return Number(totalBig) * 0.5;
-    }
-    InternalClipper.area = area;
-    function crossProductD(vec1, vec2) {
-        return (vec1.y * vec2.x - vec2.y * vec1.x);
-    }
-    InternalClipper.crossProductD = crossProductD;
-    function dotProductD(vec1, vec2) {
-        return (vec1.x * vec2.x + vec1.y * vec2.y);
-    }
-    InternalClipper.dotProductD = dotProductD;
-    // Banker's rounding (round half to even) to match C# MidpointRounding.ToEven
-    function roundToEven(value) {
-        // Use the built-in behavior that's closer to C# MidpointRounding.ToEven
-        // JavaScript's Math.round actually implements "round half away from zero"
-        // but for most practical cases, the difference is minimal
-        const floor = Math.floor(value);
-        const diff = value - floor;
-        if (Math.abs(diff - 0.5) < 1e-10) {
-            // Exactly halfway - round to even
-            return floor % 2 === 0 ? floor : floor + 1;
-        }
-        return Math.round(value);
-    }
-    InternalClipper.roundToEven = roundToEven;
-    function checkCastInt64(val) {
-        if ((val >= InternalClipper.max_coord) || (val <= InternalClipper.min_coord))
-            return InternalClipper.Invalid64;
-        return Math.round(val);
-    }
-    InternalClipper.checkCastInt64 = checkCastInt64;
-    // GetLineIntersectPt - a 'true' result is non-parallel. The 'ip' will also
-    // be constrained to seg1. However, it's possible that 'ip' won't be inside
-    // seg2, even when 'ip' hasn't been constrained (ie 'ip' is inside seg1).
-    function getLineIntersectPt(ln1a, ln1b, ln2a, ln2b) {
-        const dy1 = (ln1b.y - ln1a.y);
-        const dx1 = (ln1b.x - ln1a.x);
-        const dy2 = (ln2b.y - ln2a.y);
-        const dx2 = (ln2b.x - ln2a.x);
-        const det = safeMultiplyDifference(dy1, dx2, dy2, dx1);
-        if (det === 0.0) {
-            return { intersects: false, point: { x: 0, y: 0 } };
-        }
-        const t = safeMultiplyDifference((ln1a.x - ln2a.x), dy2, (ln1a.y - ln2a.y), dx2) / det;
-        let ip;
-        if (t <= 0.0) {
-            // Create a copy to avoid mutating original.
-            ip = { x: ln1a.x, y: ln1a.y };
-        }
-        else if (t >= 1.0) {
-            ip = { x: ln1b.x, y: ln1b.y };
-        }
-        else {
-            // avoid using constructor (and rounding too) as they affect performance
-            // Use Math.trunc to match C# (long) cast behavior which truncates towards zero
-            const rawX = ln1a.x + t * dx1;
-            const rawY = ln1a.y + t * dy1;
-            ip = {
-                x: Math.trunc(rawX),
-                y: Math.trunc(rawY)
-            };
-        }
-        return { intersects: true, point: ip };
-    }
-    InternalClipper.getLineIntersectPt = getLineIntersectPt;
-    function getLineIntersectPtD(ln1a, ln1b, ln2a, ln2b) {
-        const dy1 = ln1b.y - ln1a.y;
-        const dx1 = ln1b.x - ln1a.x;
-        const dy2 = ln2b.y - ln2a.y;
-        const dx2 = ln2b.x - ln2a.x;
-        const det = dy1 * dx2 - dy2 * dx1;
-        if (det === 0.0) {
-            return { success: false, ip: { x: 0, y: 0, z: 0 } };
-        }
-        const t = ((ln1a.x - ln2a.x) * dy2 - (ln1a.y - ln2a.y) * dx2) / det;
-        let ip;
-        if (t <= 0.0) {
-            ip = { ...ln1a, z: 0 };
+        return total * 0.5;
+    }
+    // Safe path - use BigInt for accumulation
+    let totalBig = 0n;
+    for (const pt of path) {
+        const sum = prevPt.y + pt.y;
+        const diff = prevPt.x - pt.x;
+        if (Number.isSafeInteger(sum) && Number.isSafeInteger(diff)) {
+            totalBig += BigInt(sum) * BigInt(diff);
         }
-        else if (t >= 1.0) {
-            ip = { ...ln1b, z: 0 };
+        else if (Number.isSafeInteger(prevPt.y) && Number.isSafeInteger(pt.y) &&
+            Number.isSafeInteger(prevPt.x) && Number.isSafeInteger(pt.x)) {
+            const sumBig = BigInt(prevPt.y) + BigInt(pt.y);
+            const diffBig = BigInt(prevPt.x) - BigInt(pt.x);
+            totalBig += sumBig * diffBig;
         }
         else {
-            ip = {
-                x: ln1a.x + t * dx1,
-                y: ln1a.y + t * dy1,
-                z: 0
-            };
-        }
-        return { success: true, ip };
-    }
-    InternalClipper.getLineIntersectPtD = getLineIntersectPtD;
-    function segsIntersect(seg1a, seg1b, seg2a, seg2b, inclusive = false) {
-        if (!inclusive) {
-            // Match C# fast path - use cross product multiplication
-            // This avoids floating point equality checks (safer than === 0)
-            const s1 = crossProductSign(seg1a, seg2a, seg2b);
-            const s2 = crossProductSign(seg1b, seg2a, seg2b);
-            const s3 = crossProductSign(seg2a, seg1a, seg1b);
-            const s4 = crossProductSign(seg2b, seg1a, seg1b);
-            return (s1 !== 0 && s2 !== 0 && s1 !== s2) &&
-                (s3 !== 0 && s4 !== 0 && s3 !== s4);
-        }
-        // Inclusive case - match C# implementation
-        const res1 = crossProductSign(seg1a, seg2a, seg2b);
-        const res2 = crossProductSign(seg1b, seg2a, seg2b);
-        if (res1 !== 0 && res1 === res2)
-            return false;
-        const res3 = crossProductSign(seg2a, seg1a, seg1b);
-        const res4 = crossProductSign(seg2b, seg1a, seg1b);
-        if (res3 !== 0 && res3 === res4)
-            return false;
-        // ensure NOT collinear
-        return (res1 !== 0 || res2 !== 0 || res3 !== 0 || res4 !== 0);
-    }
-    InternalClipper.segsIntersect = segsIntersect;
-    function getBounds(path) {
-        if (path.length === 0)
-            return { left: 0, top: 0, right: 0, bottom: 0 };
-        const result = {
-            left: Number.MAX_SAFE_INTEGER,
-            top: Number.MAX_SAFE_INTEGER,
-            right: Number.MIN_SAFE_INTEGER,
-            bottom: Number.MIN_SAFE_INTEGER
-        };
-        for (const pt of path) {
-            if (pt.x < result.left)
-                result.left = pt.x;
-            if (pt.x > result.right)
-                result.right = pt.x;
-            if (pt.y < result.top)
-                result.top = pt.y;
-            if (pt.y > result.bottom)
-                result.bottom = pt.y;
-        }
-        return result.left === Number.MAX_SAFE_INTEGER ?
-            { left: 0, top: 0, right: 0, bottom: 0 } : result;
-    }
-    InternalClipper.getBounds = getBounds;
-    function getClosestPtOnSegment(offPt, seg1, seg2) {
-        if (seg1.x === seg2.x && seg1.y === seg2.y)
-            return { x: seg1.x, y: seg1.y, z: 0 }; // Return copy, not reference
-        const dx = (seg2.x - seg1.x);
-        const dy = (seg2.y - seg1.y);
-        const q = safeMultiplySum((offPt.x - seg1.x), dx, (offPt.y - seg1.y), dy) /
-            safeMultiplySum(dx, dx, dy, dy);
-        const qClamped = q < 0 ? 0 : (q > 1 ? 1 : q);
+            // Coordinates not safe integers - fall back to float
+            totalBig += BigInt(Math.round(sum * diff));
+        }
+        prevPt = pt;
+    }
+    return Number(totalBig) * 0.5;
+}
+function crossProductD(vec1, vec2) {
+    return (vec1.y * vec2.x - vec2.y * vec1.x);
+}
+function dotProductD(vec1, vec2) {
+    return (vec1.x * vec2.x + vec1.y * vec2.y);
+}
+// Banker's rounding (round half to even) to match C# MidpointRounding.ToEven.
+function roundToEven(value) {
+    const r = Math.round(value);
+    if (value === r - 0.5 && (r & 1) !== 0)
+        return r - 1;
+    return r;
+}
+function checkCastInt64(val) {
+    if ((val >= IC_MaxCoord) || (val <= -IC_MaxCoord))
+        return IC_Invalid64;
+    return Math.round(val);
+}
+// GetLineIntersectPt - returns the intersection point if non-parallel, or null.
+// The point will be constrained to seg1. However, it's possible that the point
+// won't be inside seg2, even when it hasn't been constrained (ie inside seg1).
+// Returns Point64 | null to avoid allocating a wrapper object on every call.
+function getLineIntersectPt(ln1a, ln1b, ln2a, ln2b) {
+    const dy1 = (ln1b.y - ln1a.y);
+    const dx1 = (ln1b.x - ln1a.x);
+    const dy2 = (ln2b.y - ln2a.y);
+    const dx2 = (ln2b.x - ln2a.x);
+    const det = safeMultiplyDifference(dy1, dx2, dy2, dx1);
+    if (det === 0.0) {
+        return null;
+    }
+    const t = safeMultiplyDifference((ln1a.x - ln2a.x), dy2, (ln1a.y - ln2a.y), dx2) / det;
+    if (t <= 0.0) {
+        // Create a copy to avoid mutating original.
+        return { x: ln1a.x, y: ln1a.y };
+    }
+    else if (t >= 1.0) {
+        return { x: ln1b.x, y: ln1b.y };
+    }
+    else {
+        // avoid using constructor (and rounding too) as they affect performance
+        // Use Math.trunc to match C# (long) cast behavior which truncates towards zero
         return {
-            // use Math.round to match the C# MidpointRounding.ToEven behavior
-            x: Math.round(seg1.x + qClamped * dx),
-            y: Math.round(seg1.y + qClamped * dy),
+            x: Math.trunc(ln1a.x + t * dx1),
+            y: Math.trunc(ln1a.y + t * dy1)
+        };
+    }
+}
+function getLineIntersectPtD(ln1a, ln1b, ln2a, ln2b) {
+    const dy1 = ln1b.y - ln1a.y;
+    const dx1 = ln1b.x - ln1a.x;
+    const dy2 = ln2b.y - ln2a.y;
+    const dx2 = ln2b.x - ln2a.x;
+    const det = dy1 * dx2 - dy2 * dx1;
+    if (det === 0.0) {
+        return { success: false, ip: { x: 0, y: 0, z: 0 } };
+    }
+    const t = ((ln1a.x - ln2a.x) * dy2 - (ln1a.y - ln2a.y) * dx2) / det;
+    let ip;
+    if (t <= 0.0) {
+        ip = { ...ln1a, z: 0 };
+    }
+    else if (t >= 1.0) {
+        ip = { ...ln1b, z: 0 };
+    }
+    else {
+        ip = {
+            x: ln1a.x + t * dx1,
+            y: ln1a.y + t * dy1,
             z: 0
         };
     }
-    InternalClipper.getClosestPtOnSegment = getClosestPtOnSegment;
-    function pointInPolygon(pt, polygon) {
-        const len = polygon.length;
-        let start = 0;
-        if (len < 3)
-            return PointInPolygonResult.IsOutside;
-        while (start < len && polygon[start].y === pt.y)
-            start++;
-        if (start === len)
-            return PointInPolygonResult.IsOutside;
-        let isAbove = polygon[start].y < pt.y;
-        const startingAbove = isAbove;
-        let val = 0;
-        let i = start + 1;
-        let end = len;
-        while (true) {
-            if (i === end) {
-                if (end === 0 || start === 0)
-                    break;
-                end = start;
-                i = 0;
-            }
-            if (isAbove) {
-                while (i < end && polygon[i].y < pt.y)
-                    i++;
-            }
-            else {
-                while (i < end && polygon[i].y > pt.y)
-                    i++;
-            }
-            if (i === end)
-                continue;
-            const curr = polygon[i];
-            const prev = i > 0 ? polygon[i - 1] : polygon[len - 1];
-            if (curr.y === pt.y) {
-                if (curr.x === pt.x || (curr.y === prev.y &&
-                    ((pt.x < prev.x) !== (pt.x < curr.x)))) {
-                    return PointInPolygonResult.IsOn;
-                }
+    return { success: true, ip };
+}
+function segsIntersect(seg1a, seg1b, seg2a, seg2b, inclusive = false) {
+    if (!inclusive) {
+        // Match C# fast path - use cross product multiplication
+        // This avoids floating point equality checks (safer than === 0)
+        const s1 = crossProductSign(seg1a, seg2a, seg2b);
+        const s2 = crossProductSign(seg1b, seg2a, seg2b);
+        const s3 = crossProductSign(seg2a, seg1a, seg1b);
+        const s4 = crossProductSign(seg2b, seg1a, seg1b);
+        return (s1 !== 0 && s2 !== 0 && s1 !== s2) &&
+            (s3 !== 0 && s4 !== 0 && s3 !== s4);
+    }
+    // Inclusive case - match C# implementation
+    const res1 = crossProductSign(seg1a, seg2a, seg2b);
+    const res2 = crossProductSign(seg1b, seg2a, seg2b);
+    if (res1 !== 0 && res1 === res2)
+        return false;
+    const res3 = crossProductSign(seg2a, seg1a, seg1b);
+    const res4 = crossProductSign(seg2b, seg1a, seg1b);
+    if (res3 !== 0 && res3 === res4)
+        return false;
+    // ensure NOT collinear
+    return (res1 !== 0 || res2 !== 0 || res3 !== 0 || res4 !== 0);
+}
+function icGetBounds(path) {
+    if (path.length === 0)
+        return { left: 0, top: 0, right: 0, bottom: 0 };
+    const result = {
+        left: Number.MAX_SAFE_INTEGER,
+        top: Number.MAX_SAFE_INTEGER,
+        right: Number.MIN_SAFE_INTEGER,
+        bottom: Number.MIN_SAFE_INTEGER
+    };
+    for (const pt of path) {
+        if (pt.x < result.left)
+            result.left = pt.x;
+        if (pt.x > result.right)
+            result.right = pt.x;
+        if (pt.y < result.top)
+            result.top = pt.y;
+        if (pt.y > result.bottom)
+            result.bottom = pt.y;
+    }
+    return result.left === Number.MAX_SAFE_INTEGER ?
+        { left: 0, top: 0, right: 0, bottom: 0 } : result;
+}
+function getClosestPtOnSegment(offPt, seg1, seg2) {
+    if (seg1.x === seg2.x && seg1.y === seg2.y)
+        return { x: seg1.x, y: seg1.y, z: 0 }; // Return copy, not reference
+    const dx = (seg2.x - seg1.x);
+    const dy = (seg2.y - seg1.y);
+    const q = safeMultiplySum((offPt.x - seg1.x), dx, (offPt.y - seg1.y), dy) /
+        safeMultiplySum(dx, dx, dy, dy);
+    const qClamped = q < 0 ? 0 : (q > 1 ? 1 : q);
+    return {
+        // use Math.round to match the C# MidpointRounding.ToEven behavior
+        x: Math.round(seg1.x + qClamped * dx),
+        y: Math.round(seg1.y + qClamped * dy),
+        z: 0
+    };
+}
+function icPointInPolygon(pt, polygon) {
+    const len = polygon.length;
+    let start = 0;
+    if (len < 3)
+        return PointInPolygonResult.IsOutside;
+    while (start < len && polygon[start].y === pt.y)
+        start++;
+    if (start === len)
+        return PointInPolygonResult.IsOutside;
+    let isAbove = polygon[start].y < pt.y;
+    const startingAbove = isAbove;
+    let val = 0;
+    let i = start + 1;
+    let end = len;
+    while (true) {
+        if (i === end) {
+            if (end === 0 || start === 0)
+                break;
+            end = start;
+            i = 0;
+        }
+        if (isAbove) {
+            while (i < end && polygon[i].y < pt.y)
                 i++;
-                if (i === start)
-                    break;
-                continue;
-            }
-            if (pt.x < curr.x && pt.x < prev.x) {
-                // we're only interested in edges crossing on the left
-            }
-            else if (pt.x > prev.x && pt.x > curr.x) {
-                val = 1 - val; // toggle val
-            }
-            else {
-                const cps = crossProductSign(prev, curr, pt);
-                if (cps === 0)
-                    return PointInPolygonResult.IsOn;
-                if ((cps < 0) === isAbove)
-                    val = 1 - val;
-            }
-            isAbove = !isAbove;
-            i++;
         }
-        if (isAbove === startingAbove) {
-            return val === 0 ? PointInPolygonResult.IsOutside : PointInPolygonResult.IsInside;
+        else {
+            while (i < end && polygon[i].y > pt.y)
+                i++;
         }
-        if (i === len)
-            i = 0;
-        const cps = i === 0 ?
-            crossProductSign(polygon[len - 1], polygon[0], pt) :
-            crossProductSign(polygon[i - 1], polygon[i], pt);
-        if (cps === 0)
-            return PointInPolygonResult.IsOn;
-        if ((cps < 0) === isAbove)
-            val = 1 - val;
-        return val === 0 ? PointInPolygonResult.IsOutside : PointInPolygonResult.IsInside;
-    }
-    InternalClipper.pointInPolygon = pointInPolygon;
-    function path2ContainsPath1(path1, path2) {
-        // we need to make some accommodation for rounding errors
-        // so we won't jump if the first vertex is found outside
-        let pip = PointInPolygonResult.IsOn;
-        for (const pt of path1) {
-            switch (pointInPolygon(pt, path2)) {
-                case PointInPolygonResult.IsOutside:
-                    if (pip === PointInPolygonResult.IsOutside)
-                        return false;
-                    pip = PointInPolygonResult.IsOutside;
-                    break;
-                case PointInPolygonResult.IsInside:
-                    if (pip === PointInPolygonResult.IsInside)
-                        return true;
-                    pip = PointInPolygonResult.IsInside;
-                    break;
-                default:
-                    break;
+        if (i === end)
+            continue;
+        const curr = polygon[i];
+        const prev = i > 0 ? polygon[i - 1] : polygon[len - 1];
+        if (curr.y === pt.y) {
+            if (curr.x === pt.x || (curr.y === prev.y &&
+                ((pt.x < prev.x) !== (pt.x < curr.x)))) {
+                return PointInPolygonResult.IsOn;
             }
+            i++;
+            if (i === start)
+                break;
+            continue;
+        }
+        if (pt.x < curr.x && pt.x < prev.x) {
+            // we're only interested in edges crossing on the left
         }
-        // since path1's location is still equivocal, check its midpoint
-        const mp = getBounds(path1);
-        let midX, midY;
-        if (Number.isSafeInteger(mp.left) && Number.isSafeInteger(mp.right) &&
-            Math.abs(mp.left) + Math.abs(mp.right) > Number.MAX_SAFE_INTEGER) {
-            midX = Number((BigInt(mp.left) + BigInt(mp.right)) / 2n);
-            midY = Number((BigInt(mp.top) + BigInt(mp.bottom)) / 2n);
+        else if (pt.x > prev.x && pt.x > curr.x) {
+            val = 1 - val; // toggle val
         }
         else {
-            midX = Math.round((mp.left + mp.right) / 2);
-            midY = Math.round((mp.top + mp.bottom) / 2);
+            const cps = crossProductSign(prev, curr, pt);
+            if (cps === 0)
+                return PointInPolygonResult.IsOn;
+            if ((cps < 0) === isAbove)
+                val = 1 - val;
         }
-        const midPt = { x: midX, y: midY };
-        return pointInPolygon(midPt, path2) !== PointInPolygonResult.IsOutside;
-    }
-    InternalClipper.path2ContainsPath1 = path2ContainsPath1;
-})(InternalClipper || (InternalClipper = {}));
-// Point64 utility functions
-export var Point64Utils;
-(function (Point64Utils) {
-    function create(x = 0, y = 0, z = 0) {
-        return { x: Math.round(x), y: Math.round(y), z };
+        isAbove = !isAbove;
+        i++;
     }
-    Point64Utils.create = create;
-    function fromPointD(pt) {
+    if (isAbove === startingAbove) {
+        return val === 0 ? PointInPolygonResult.IsOutside : PointInPolygonResult.IsInside;
+    }
+    if (i === len)
+        i = 0;
+    const cps = i === 0 ?
+        crossProductSign(polygon[len - 1], polygon[0], pt) :
+        crossProductSign(polygon[i - 1], polygon[i], pt);
+    if (cps === 0)
+        return PointInPolygonResult.IsOn;
+    if ((cps < 0) === isAbove)
+        val = 1 - val;
+    return val === 0 ? PointInPolygonResult.IsOutside : PointInPolygonResult.IsInside;
+}
+function path2ContainsPath1(path1, path2) {
+    // we need to make some accommodation for rounding errors
+    // so we won't jump if the first vertex is found outside
+    let pip = PointInPolygonResult.IsOn;
+    for (const pt of path1) {
+        switch (icPointInPolygon(pt, path2)) {
+            case PointInPolygonResult.IsOutside:
+                if (pip === PointInPolygonResult.IsOutside)
+                    return false;
+                pip = PointInPolygonResult.IsOutside;
+                break;
+            case PointInPolygonResult.IsInside:
+                if (pip === PointInPolygonResult.IsInside)
+                    return true;
+                pip = PointInPolygonResult.IsInside;
+                break;
+            default:
+                break;
+        }
+    }
+    // since path1's location is still equivocal, check its midpoint
+    const mp = icGetBounds(path1);
+    let midX, midY;
+    if (Number.isSafeInteger(mp.left) && Number.isSafeInteger(mp.right) &&
+        Math.abs(mp.left) + Math.abs(mp.right) > Number.MAX_SAFE_INTEGER) {
+        midX = Number((BigInt(mp.left) + BigInt(mp.right)) / 2n);
+        midY = Number((BigInt(mp.top) + BigInt(mp.bottom)) / 2n);
+    }
+    else {
+        midX = Math.round((mp.left + mp.right) / 2);
+        midY = Math.round((mp.top + mp.bottom) / 2);
+    }
+    const midPt = { x: midX, y: midY };
+    return icPointInPolygon(midPt, path2) !== PointInPolygonResult.IsOutside;
+}
+// Plain const object replaces the namespace. External callers use InternalClipper.foo()
+// unchanged; tsc emits a simple object literal instead of an IIFE.
+export const InternalClipper = {
+    MaxInt64: IC_MaxInt64,
+    MaxCoord: IC_MaxCoord,
+    max_coord: IC_MaxCoord,
+    min_coord: -IC_MaxCoord,
+    Invalid64: IC_Invalid64,
+    floatingPointTolerance: IC_floatingPointTolerance,
+    defaultMinimumEdgeLength: IC_defaultMinimumEdgeLength,
+    maxCoordForSafeAreaProduct: IC_maxCoordForSafeAreaProduct,
+    maxCoordForSafeCrossSq: IC_maxCoordForSafeCrossSq,
+    maxSafeCoordinateForScale,
+    checkSafeScaleValue,
+    ensureSafeInteger,
+    crossProduct,
+    crossProductSign,
+    checkPrecision,
+    isAlmostZero,
+    triSign,
+    multiplyUInt64,
+    productsAreEqual,
+    isCollinear,
+    dotProduct,
+    dotProductSign,
+    area: icArea,
+    crossProductD,
+    dotProductD,
+    roundToEven,
+    checkCastInt64,
+    getLineIntersectPt,
+    getLineIntersectPtD,
+    segsIntersect,
+    getBounds: icGetBounds,
+    getClosestPtOnSegment,
+    pointInPolygon: icPointInPolygon,
+    path2ContainsPath1,
+};
+// Point64 utility functions (plain object, avoids namespace IIFE)
+export const Point64Utils = {
+    create(x = 0, y = 0, z = 0) {
+        return { x: Math.round(x), y: Math.round(y), z };
+    },
+    fromPointD(pt) {
         InternalClipper.ensureSafeInteger(pt.x, "Point64Utils.fromPointD");
         InternalClipper.ensureSafeInteger(pt.y, "Point64Utils.fromPointD");
         return { x: Math.round(pt.x), y: Math.round(pt.y), z: pt.z || 0 };
-    }
-    Point64Utils.fromPointD = fromPointD;
-    function scale(pt, scale) {
+    },
+    scale(pt, scale) {
         return {
             x: Math.round(pt.x * scale),
             y: Math.round(pt.y * scale),
             z: pt.z || 0
         };
-    }
-    Point64Utils.scale = scale;
-    function equals(a, b) {
+    },
+    equals(a, b) {
         return a.x === b.x && a.y === b.y;
-    }
-    Point64Utils.equals = equals;
-    function add(a, b) {
+    },
+    add(a, b) {
         if (Number.isSafeInteger(a.x) && Number.isSafeInteger(b.x) &&
             Number.isSafeInteger(a.y) && Number.isSafeInteger(b.y)) {
             const sumX = a.x + b.x;
@@ -602,86 +600,69 @@ export var Point64Utils;
             };
         }
         return { x: a.x + b.x, y: a.y + b.y, z: 0 };
-    }
-    Point64Utils.add = add;
-    function subtract(a, b) {
+    },
+    subtract(a, b) {
         return { x: a.x - b.x, y: a.y - b.y, z: 0 };
-    }
-    Point64Utils.subtract = subtract;
-    function toString(pt) {
+    },
+    toString(pt) {
         if (pt.z !== undefined && pt.z !== 0) {
             return `${pt.x},${pt.y},${pt.z} `;
         }
         return `${pt.x},${pt.y} `;
-    }
-    Point64Utils.toString = toString;
-})(Point64Utils || (Point64Utils = {}));
-// PointD utility functions
-export var PointDUtils;
-(function (PointDUtils) {
-    function create(x = 0, y = 0, z = 0) {
+    },
+};
+// PointD utility functions (plain object, avoids namespace IIFE)
+export const PointDUtils = {
+    create(x = 0, y = 0, z = 0) {
         return { x, y, z };
-    }
-    PointDUtils.create = create;
-    function fromPoint64(pt) {
+    },
+    fromPoint64(pt) {
         return { x: pt.x, y: pt.y, z: pt.z || 0 };
-    }
-    PointDUtils.fromPoint64 = fromPoint64;
-    function scale(pt, scale) {
+    },
+    scale(pt, scale) {
         return { x: pt.x * scale, y: pt.y * scale, z: pt.z || 0 };
-    }
-    PointDUtils.scale = scale;
-    function equals(a, b) {
+    },
+    equals(a, b) {
         return InternalClipper.isAlmostZero(a.x - b.x) &&
             InternalClipper.isAlmostZero(a.y - b.y);
-    }
-    PointDUtils.equals = equals;
-    function negate(pt) {
+    },
+    negate(pt) {
         pt.x = -pt.x;
         pt.y = -pt.y;
-    }
-    PointDUtils.negate = negate;
-    function toString(pt, precision = 2) {
+    },
+    toString(pt, precision = 2) {
         if (pt.z !== undefined && pt.z !== 0) {
             return `${pt.x.toFixed(precision)},${pt.y.toFixed(precision)},${pt.z}`;
         }
         return `${pt.x.toFixed(precision)},${pt.y.toFixed(precision)}`;
-    }
-    PointDUtils.toString = toString;
-})(PointDUtils || (PointDUtils = {}));
-// Rect64 utility functions
-export var Rect64Utils;
-(function (Rect64Utils) {
-    function create(l = 0, t = 0, r = 0, b = 0) {
+    },
+};
+// Rect64 utility functions (plain object, avoids namespace IIFE)
+export const Rect64Utils = {
+    create(l = 0, t = 0, r = 0, b = 0) {
         return { left: l, top: t, right: r, bottom: b };
-    }
-    Rect64Utils.create = create;
-    function createInvalid() {
+    },
+    createInvalid() {
         return {
             left: Number.MAX_SAFE_INTEGER,
             top: Number.MAX_SAFE_INTEGER,
             right: Number.MIN_SAFE_INTEGER,
             bottom: Number.MIN_SAFE_INTEGER
         };
-    }
-    Rect64Utils.createInvalid = createInvalid;
-    function width(rect) {
+    },
+    width(rect) {
         return rect.right - rect.left;
-    }
-    Rect64Utils.width = width;
-    function height(rect) {
+    },
+    height(rect) {
         return rect.bottom - rect.top;
-    }
-    Rect64Utils.height = height;
-    function isEmpty(rect) {
+    },
+    isEmpty(rect) {
         return rect.bottom <= rect.top || rect.right <= rect.left;
-    }
-    Rect64Utils.isEmpty = isEmpty;
-    function isValid(rect) {
+    },
+    isValid(rect) {
         return rect.left < Number.MAX_SAFE_INTEGER;
-    }
-    Rect64Utils.isValid = isValid;
-    function midPoint(rect) {
+    },
+    midPoint(rect) {
         if (Number.isSafeInteger(rect.left) && Number.isSafeInteger(rect.right) &&
             Math.abs(rect.left) + Math.abs(rect.right) > Number.MAX_SAFE_INTEGER) {
             const midX = Number((BigInt(rect.left) + BigInt(rect.right)) / 2n);
@@ -692,105 +673,87 @@ export var Rect64Utils;
             x: Math.round((rect.left + rect.right) / 2),
             y: Math.round((rect.top + rect.bottom) / 2)
         };
-    }
-    Rect64Utils.midPoint = midPoint;
-    function contains(rect, pt) {
+    },
+    contains(rect, pt) {
         return pt.x > rect.left && pt.x < rect.right &&
             pt.y > rect.top && pt.y < rect.bottom;
-    }
-    Rect64Utils.contains = contains;
-    function containsRect(rect, rec) {
+    },
+    containsRect(rect, rec) {
         return rec.left >= rect.left && rec.right <= rect.right &&
             rec.top >= rect.top && rec.bottom <= rect.bottom;
-    }
-    Rect64Utils.containsRect = containsRect;
-    function intersects(rect, rec) {
+    },
+    intersects(rect, rec) {
         return (Math.max(rect.left, rec.left) <= Math.min(rect.right, rec.right)) &&
             (Math.max(rect.top, rec.top) <= Math.min(rect.bottom, rec.bottom));
-    }
-    Rect64Utils.intersects = intersects;
-    function asPath(rect) {
+    },
+    asPath(rect) {
         return [
             { x: rect.left, y: rect.top, z: 0 },
             { x: rect.right, y: rect.top, z: 0 },
             { x: rect.right, y: rect.bottom, z: 0 },
             { x: rect.left, y: rect.bottom, z: 0 }
         ];
-    }
-    Rect64Utils.asPath = asPath;
-})(Rect64Utils || (Rect64Utils = {}));
-// RectD utility functions
-export var RectDUtils;
-(function (RectDUtils) {
-    function create(l = 0, t = 0, r = 0, b = 0) {
+    },
+};
+// RectD utility functions (plain object, avoids namespace IIFE)
+export const RectDUtils = {
+    create(l = 0, t = 0, r = 0, b = 0) {
         return { left: l, top: t, right: r, bottom: b };
-    }
-    RectDUtils.create = create;
-    function createInvalid() {
+    },
+    createInvalid() {
         return {
             left: Number.MAX_VALUE,
             top: Number.MAX_VALUE,
             right: -Number.MAX_VALUE,
             bottom: -Number.MAX_VALUE
         };
-    }
-    RectDUtils.createInvalid = createInvalid;
-    function width(rect) {
+    },
+    width(rect) {
         return rect.right - rect.left;
-    }
-    RectDUtils.width = width;
-    function height(rect) {
+    },
+    height(rect) {
         return rect.bottom - rect.top;
-    }
-    RectDUtils.height = height;
-    function isEmpty(rect) {
+    },
+    isEmpty(rect) {
         return rect.bottom <= rect.top || rect.right <= rect.left;
-    }
-    RectDUtils.isEmpty = isEmpty;
-    function midPoint(rect) {
+    },
+    midPoint(rect) {
         return {
             x: (rect.left + rect.right) / 2,
             y: (rect.top + rect.bottom) / 2
         };
-    }
-    RectDUtils.midPoint = midPoint;
-    function contains(rect, pt) {
+    },
+    contains(rect, pt) {
         return pt.x > rect.left && pt.x < rect.right &&
             pt.y > rect.top && pt.y < rect.bottom;
-    }
-    RectDUtils.contains = contains;
-    function containsRect(rect, rec) {
+    },
+    containsRect(rect, rec) {
         return rec.left >= rect.left && rec.right <= rect.right &&
             rec.top >= rect.top && rec.bottom <= rect.bottom;
-    }
-    RectDUtils.containsRect = containsRect;
-    function intersects(rect, rec) {
+    },
+    intersects(rect, rec) {
         return (Math.max(rect.left, rec.left) < Math.min(rect.right, rec.right)) &&
             (Math.max(rect.top, rec.top) < Math.min(rect.bottom, rec.bottom));
-    }
-    RectDUtils.intersects = intersects;
-    function asPath(rect) {
+    },
+    asPath(rect) {
         return [
             { x: rect.left, y: rect.top, z: 0 },
             { x: rect.right, y: rect.top, z: 0 },
             { x: rect.right, y: rect.bottom, z: 0 },
             { x: rect.left, y: rect.bottom, z: 0 }
         ];
-    }
-    RectDUtils.asPath = asPath;
-})(RectDUtils || (RectDUtils = {}));
-// Path utility functions
-export var PathUtils;
-(function (PathUtils) {
-    function toString64(path) {
+    },
+};
+// Path utility functions (plain object, avoids namespace IIFE)
+export const PathUtils = {
+    toString64(path) {
         let result = "";
         for (const pt of path) {
             result += Point64Utils.toString(pt);
         }
         return result + '\n';
-    }
-    PathUtils.toString64 = toString64;
-    function toStringD(path, precision = 2) {
+    },
+    toStringD(path, precision = 2) {
         let result = "";
         for (const pt of path) {
             result += PointDUtils.toString(pt, precision) + ", ";
@@ -798,45 +761,37 @@ export var PathUtils;
         if (result !== "")
             result = result.slice(0, -2);
         return result;
-    }
-    PathUtils.toStringD = toStringD;
-    function reverse64(path) {
+    },
+    reverse64(path) {
         return [...path].reverse();
-    }
-    PathUtils.reverse64 = reverse64;
-    function reverseD(path) {
+    },
+    reverseD(path) {
         return [...path].reverse();
-    }
-    PathUtils.reverseD = reverseD;
-})(PathUtils || (PathUtils = {}));
-export var PathsUtils;
-(function (PathsUtils) {
-    function toString64(paths) {
+    },
+};
+export const PathsUtils = {
+    toString64(paths) {
         let result = "";
         for (const path of paths) {
             result += PathUtils.toString64(path);
         }
         return result;
-    }
-    PathsUtils.toString64 = toString64;
-    function toStringD(paths, precision = 2) {
+    },
+    toStringD(paths, precision = 2) {
         let result = "";
         for (const path of paths) {
             result += PathUtils.toStringD(path, precision) + "\n";
         }
         return result;
-    }
-    PathsUtils.toStringD = toStringD;
-    function reverse64(paths) {
+    },
+    reverse64(paths) {
         return paths.map(path => PathUtils.reverse64(path));
-    }
-    PathsUtils.reverse64 = reverse64;
-    function reverseD(paths) {
+    },
+    reverseD(paths) {
         return paths.map(path => PathUtils.reverseD(path));
-    }
-    PathsUtils.reverseD = reverseD;
-})(PathsUtils || (PathsUtils = {}));
-// Constants
-export const InvalidRect64 = Rect64Utils.createInvalid();
-export const InvalidRectD = RectDUtils.createInvalid();
+    },
+};
+// Constants (frozen to prevent accidental mutation of shared singletons)
+export const InvalidRect64 = Object.freeze(Rect64Utils.createInvalid());
+export const InvalidRectD = Object.freeze(RectDUtils.createInvalid());
 //# sourceMappingURL=Core.js.map