@emasoft/svg-matrix 1.1.0 → 1.2.0

package/src/gjk-collision.js

@@ -29,16 +29,16 @@
  * @module gjk-collision
  */
 
-import Decimal from 'decimal.js';
+import Decimal from "decimal.js";
 
 // Set high precision for all calculations
 Decimal.set({ precision: 80 });
 
 // Helper to convert to Decimal
-const D = x => (x instanceof Decimal ? x : new Decimal(x));
+const D = (x) => (x instanceof Decimal ? x : new Decimal(x));
 
 // Near-zero threshold for comparisons
-const EPSILON = new Decimal('1e-40');
+const EPSILON = new Decimal("1e-40");
 
 // Maximum iterations to prevent infinite loops
 const MAX_ITERATIONS = 100;
@@ -55,8 +55,10 @@ const MAX_ITERATIONS = 100;
  * @throws {TypeError} If x or y is null or undefined
  */
 export function point(x, y) {
-  if (x == null) throw new TypeError('point: x coordinate cannot be null or undefined');
-  if (y == null) throw new TypeError('point: y coordinate cannot be null or undefined');
+  if (x == null)
+    throw new TypeError("point: x coordinate cannot be null or undefined");
+  if (y == null)
+    throw new TypeError("point: y coordinate cannot be null or undefined");
   return { x: D(x), y: D(y) };
 }
 
@@ -68,8 +70,12 @@ export function point(x, y) {
  * @throws {TypeError} If a or b is invalid or missing x/y properties
  */
 export function vectorAdd(a, b) {
-  if (!a || a.x == null || a.y == null) throw new TypeError('vectorAdd: first vector must have x and y properties');
-  if (!b || b.x == null || b.y == null) throw new TypeError('vectorAdd: second vector must have x and y properties');
+  if (!a || a.x == null || a.y == null)
+    throw new TypeError("vectorAdd: first vector must have x and y properties");
+  if (!b || b.x == null || b.y == null)
+    throw new TypeError(
+      "vectorAdd: second vector must have x and y properties",
+    );
   return { x: a.x.plus(b.x), y: a.y.plus(b.y) };
 }
 
@@ -81,8 +87,12 @@ export function vectorAdd(a, b) {
  * @throws {TypeError} If a or b is invalid or missing x/y properties
  */
 export function vectorSub(a, b) {
-  if (!a || a.x == null || a.y == null) throw new TypeError('vectorSub: first vector must have x and y properties');
-  if (!b || b.x == null || b.y == null) throw new TypeError('vectorSub: second vector must have x and y properties');
+  if (!a || a.x == null || a.y == null)
+    throw new TypeError("vectorSub: first vector must have x and y properties");
+  if (!b || b.x == null || b.y == null)
+    throw new TypeError(
+      "vectorSub: second vector must have x and y properties",
+    );
   return { x: a.x.minus(b.x), y: a.y.minus(b.y) };
 }
 
@@ -93,7 +103,8 @@ export function vectorSub(a, b) {
  * @throws {TypeError} If v is invalid or missing x/y properties
  */
 export function vectorNeg(v) {
-  if (!v || v.x == null || v.y == null) throw new TypeError('vectorNeg: vector must have x and y properties');
+  if (!v || v.x == null || v.y == null)
+    throw new TypeError("vectorNeg: vector must have x and y properties");
   return { x: v.x.neg(), y: v.y.neg() };
 }
 
@@ -105,8 +116,12 @@ export function vectorNeg(v) {
  * @throws {TypeError} If v is invalid, missing x/y properties, or s is null/undefined
  */
 export function vectorScale(v, s) {
-  if (!v || v.x == null || v.y == null) throw new TypeError('vectorScale: vector must have x and y properties');
-  if (s == null) throw new TypeError('vectorScale: scale factor cannot be null or undefined');
+  if (!v || v.x == null || v.y == null)
+    throw new TypeError("vectorScale: vector must have x and y properties");
+  if (s == null)
+    throw new TypeError(
+      "vectorScale: scale factor cannot be null or undefined",
+    );
   const sd = D(s);
   return { x: v.x.mul(sd), y: v.y.mul(sd) };
 }
@@ -119,8 +134,10 @@ export function vectorScale(v, s) {
  * @throws {TypeError} If a or b is invalid or missing x/y properties
  */
 export function dot(a, b) {
-  if (!a || a.x == null || a.y == null) throw new TypeError('dot: first vector must have x and y properties');
-  if (!b || b.x == null || b.y == null) throw new TypeError('dot: second vector must have x and y properties');
+  if (!a || a.x == null || a.y == null)
+    throw new TypeError("dot: first vector must have x and y properties");
+  if (!b || b.x == null || b.y == null)
+    throw new TypeError("dot: second vector must have x and y properties");
   return a.x.mul(b.x).plus(a.y.mul(b.y));
 }
 
@@ -132,8 +149,10 @@ export function dot(a, b) {
  * @throws {TypeError} If a or b is invalid or missing x/y properties
  */
 export function cross(a, b) {
-  if (!a || a.x == null || a.y == null) throw new TypeError('cross: first vector must have x and y properties');
-  if (!b || b.x == null || b.y == null) throw new TypeError('cross: second vector must have x and y properties');
+  if (!a || a.x == null || a.y == null)
+    throw new TypeError("cross: first vector must have x and y properties");
+  if (!b || b.x == null || b.y == null)
+    throw new TypeError("cross: second vector must have x and y properties");
   return a.x.mul(b.y).minus(a.y.mul(b.x));
 }
 
@@ -144,7 +163,10 @@ export function cross(a, b) {
  * @throws {TypeError} If v is invalid or missing x/y properties
  */
 export function magnitudeSquared(v) {
-  if (!v || v.x == null || v.y == null) throw new TypeError('magnitudeSquared: vector must have x and y properties');
+  if (!v || v.x == null || v.y == null)
+    throw new TypeError(
+      "magnitudeSquared: vector must have x and y properties",
+    );
   return v.x.mul(v.x).plus(v.y.mul(v.y));
 }
 
@@ -155,7 +177,8 @@ export function magnitudeSquared(v) {
  * @throws {TypeError} If v is invalid or missing x/y properties
  */
 export function magnitude(v) {
-  if (!v || v.x == null || v.y == null) throw new TypeError('magnitude: vector must have x and y properties');
+  if (!v || v.x == null || v.y == null)
+    throw new TypeError("magnitude: vector must have x and y properties");
   return magnitudeSquared(v).sqrt();
 }
 
@@ -166,7 +189,8 @@ export function magnitude(v) {
  * @throws {TypeError} If v is invalid or missing x/y properties
  */
 export function normalize(v) {
-  if (!v || v.x == null || v.y == null) throw new TypeError('normalize: vector must have x and y properties');
+  if (!v || v.x == null || v.y == null)
+    throw new TypeError("normalize: vector must have x and y properties");
   const mag = magnitude(v);
   if (mag.lessThan(EPSILON)) {
     return { x: D(0), y: D(0) };
@@ -181,7 +205,8 @@ export function normalize(v) {
  * @throws {TypeError} If v is invalid or missing x/y properties
  */
 export function perpendicular(v) {
-  if (!v || v.x == null || v.y == null) throw new TypeError('perpendicular: vector must have x and y properties');
+  if (!v || v.x == null || v.y == null)
+    throw new TypeError("perpendicular: vector must have x and y properties");
   return { x: v.y.neg(), y: v.x };
 }
 
@@ -195,9 +220,18 @@ export function perpendicular(v) {
  * @throws {TypeError} If any vector is invalid or missing x/y properties
  */
 export function tripleProduct(a, b, c) {
-  if (!a || a.x == null || a.y == null) throw new TypeError('tripleProduct: first vector must have x and y properties');
-  if (!b || b.x == null || b.y == null) throw new TypeError('tripleProduct: second vector must have x and y properties');
-  if (!c || c.x == null || c.y == null) throw new TypeError('tripleProduct: third vector must have x and y properties');
+  if (!a || a.x == null || a.y == null)
+    throw new TypeError(
+      "tripleProduct: first vector must have x and y properties",
+    );
+  if (!b || b.x == null || b.y == null)
+    throw new TypeError(
+      "tripleProduct: second vector must have x and y properties",
+    );
+  if (!c || c.x == null || c.y == null)
+    throw new TypeError(
+      "tripleProduct: third vector must have x and y properties",
+    );
   // In 2D: (A × B) × C = B(A·C) - A(B·C)
   const ac = dot(a, c);
   const bc = dot(b, c);
@@ -220,15 +254,19 @@ export function tripleProduct(a, b, c) {
  * @throws {TypeError} If polygon is not an array or direction is invalid
  */
 export function supportPoint(polygon, direction) {
-  if (!Array.isArray(polygon)) throw new TypeError('supportPoint: polygon must be an array');
-  if (!direction || direction.x == null || direction.y == null) throw new TypeError('supportPoint: direction must have x and y properties');
+  if (!Array.isArray(polygon))
+    throw new TypeError("supportPoint: polygon must be an array");
+  if (!direction || direction.x == null || direction.y == null)
+    throw new TypeError("supportPoint: direction must have x and y properties");
   if (polygon.length === 0) {
-    throw new TypeError('supportPoint: polygon cannot be empty');
+    throw new TypeError("supportPoint: polygon cannot be empty");
   }
 
   // Validate first point
   if (!polygon[0] || polygon[0].x == null || polygon[0].y == null) {
-    throw new TypeError('supportPoint: polygon[0] must have x and y properties');
+    throw new TypeError(
+      "supportPoint: polygon[0] must have x and y properties",
+    );
   }
 
   let maxDot = dot(polygon[0], direction);
@@ -236,7 +274,9 @@ export function supportPoint(polygon, direction) {
 
   for (let i = 1; i < polygon.length; i++) {
     if (!polygon[i] || polygon[i].x == null || polygon[i].y == null) {
-      throw new TypeError(`supportPoint: polygon[${i}] must have x and y properties`);
+      throw new TypeError(
+        `supportPoint: polygon[${i}] must have x and y properties`,
+      );
     }
     const d = dot(polygon[i], direction);
     if (d.greaterThan(maxDot)) {
@@ -261,9 +301,14 @@ export function supportPoint(polygon, direction) {
  * @throws {TypeError} If polygons are not arrays or direction is invalid
  */
 export function minkowskiSupport(polygonA, polygonB, direction) {
-  if (!Array.isArray(polygonA)) throw new TypeError('minkowskiSupport: polygonA must be an array');
-  if (!Array.isArray(polygonB)) throw new TypeError('minkowskiSupport: polygonB must be an array');
-  if (!direction || direction.x == null || direction.y == null) throw new TypeError('minkowskiSupport: direction must have x and y properties');
+  if (!Array.isArray(polygonA))
+    throw new TypeError("minkowskiSupport: polygonA must be an array");
+  if (!Array.isArray(polygonB))
+    throw new TypeError("minkowskiSupport: polygonB must be an array");
+  if (!direction || direction.x == null || direction.y == null)
+    throw new TypeError(
+      "minkowskiSupport: direction must have x and y properties",
+    );
   const pointA = supportPoint(polygonA, direction);
   const pointB = supportPoint(polygonB, vectorNeg(direction));
   return vectorSub(pointA, pointB);
@@ -286,11 +331,24 @@ export function minkowskiSupport(polygonA, polygonB, direction) {
  * @throws {TypeError} If simplex is not an array, has wrong length, or direction is invalid
  */
 export function processLineSimplex(simplex, direction) {
-  if (!Array.isArray(simplex)) throw new TypeError('processLineSimplex: simplex must be an array');
-  if (simplex.length !== 2) throw new TypeError('processLineSimplex: simplex must have exactly 2 points');
-  if (!direction || direction.x == null || direction.y == null) throw new TypeError('processLineSimplex: direction must have x and y properties');
-  if (!simplex[0] || simplex[0].x == null || simplex[0].y == null) throw new TypeError('processLineSimplex: simplex[0] must have x and y properties');
-  if (!simplex[1] || simplex[1].x == null || simplex[1].y == null) throw new TypeError('processLineSimplex: simplex[1] must have x and y properties');
+  if (!Array.isArray(simplex))
+    throw new TypeError("processLineSimplex: simplex must be an array");
+  if (simplex.length !== 2)
+    throw new TypeError(
+      "processLineSimplex: simplex must have exactly 2 points",
+    );
+  if (!direction || direction.x == null || direction.y == null)
+    throw new TypeError(
+      "processLineSimplex: direction must have x and y properties",
+    );
+  if (!simplex[0] || simplex[0].x == null || simplex[0].y == null)
+    throw new TypeError(
+      "processLineSimplex: simplex[0] must have x and y properties",
+    );
+  if (!simplex[1] || simplex[1].x == null || simplex[1].y == null)
+    throw new TypeError(
+      "processLineSimplex: simplex[1] must have x and y properties",
+    );
   const A = simplex[0]; // Newest point
   const B = simplex[1];
 
@@ -317,7 +375,10 @@ export function processLineSimplex(simplex, direction) {
     // Origin is on the line - check if between A and B
     const dotAB_AO = dot(AB, AO);
 
-    if (dotAB_AO.greaterThanOrEqualTo(0) && dotAB_AO.lessThanOrEqualTo(ABmagSq)) {
+    if (
+      dotAB_AO.greaterThanOrEqualTo(0) &&
+      dotAB_AO.lessThanOrEqualTo(ABmagSq)
+    ) {
       // Origin is on the segment - we have intersection
       return { contains: true, newDirection: direction };
     }
@@ -343,12 +404,28 @@ export function processLineSimplex(simplex, direction) {
  * @throws {TypeError} If simplex is not an array, has wrong length, or direction is invalid
  */
 export function processTriangleSimplex(simplex, direction) {
-  if (!Array.isArray(simplex)) throw new TypeError('processTriangleSimplex: simplex must be an array');
-  if (simplex.length !== 3) throw new TypeError('processTriangleSimplex: simplex must have exactly 3 points');
-  if (!direction || direction.x == null || direction.y == null) throw new TypeError('processTriangleSimplex: direction must have x and y properties');
-  if (!simplex[0] || simplex[0].x == null || simplex[0].y == null) throw new TypeError('processTriangleSimplex: simplex[0] must have x and y properties');
-  if (!simplex[1] || simplex[1].x == null || simplex[1].y == null) throw new TypeError('processTriangleSimplex: simplex[1] must have x and y properties');
-  if (!simplex[2] || simplex[2].x == null || simplex[2].y == null) throw new TypeError('processTriangleSimplex: simplex[2] must have x and y properties');
+  if (!Array.isArray(simplex))
+    throw new TypeError("processTriangleSimplex: simplex must be an array");
+  if (simplex.length !== 3)
+    throw new TypeError(
+      "processTriangleSimplex: simplex must have exactly 3 points",
+    );
+  if (!direction || direction.x == null || direction.y == null)
+    throw new TypeError(
+      "processTriangleSimplex: direction must have x and y properties",
+    );
+  if (!simplex[0] || simplex[0].x == null || simplex[0].y == null)
+    throw new TypeError(
+      "processTriangleSimplex: simplex[0] must have x and y properties",
+    );
+  if (!simplex[1] || simplex[1].x == null || simplex[1].y == null)
+    throw new TypeError(
+      "processTriangleSimplex: simplex[1] must have x and y properties",
+    );
+  if (!simplex[2] || simplex[2].x == null || simplex[2].y == null)
+    throw new TypeError(
+      "processTriangleSimplex: simplex[2] must have x and y properties",
+    );
   const A = simplex[0]; // Newest point
   const B = simplex[1];
   const C = simplex[2];
@@ -366,7 +443,7 @@ export function processTriangleSimplex(simplex, direction) {
     return {
       contains: false,
       newDirection: tripleProduct(AC, AO, AC),
-      newSimplex: [A, C]
+      newSimplex: [A, C],
     };
   }
 
@@ -375,7 +452,7 @@ export function processTriangleSimplex(simplex, direction) {
     return {
       contains: false,
       newDirection: tripleProduct(AB, AO, AB),
-      newSimplex: [A, B]
+      newSimplex: [A, B],
     };
   }
 
@@ -384,7 +461,10 @@ export function processTriangleSimplex(simplex, direction) {
   const ACperp = tripleProduct(AB, AC, AC);
 
   // Check if perpendiculars are degenerate (collinear points)
-  if (magnitudeSquared(ABperp).lessThan(EPSILON) && magnitudeSquared(ACperp).lessThan(EPSILON)) {
+  if (
+    magnitudeSquared(ABperp).lessThan(EPSILON) &&
+    magnitudeSquared(ACperp).lessThan(EPSILON)
+  ) {
     // All three points are collinear - reduce to line segment
     // Choose the two points farthest apart
     const BC = vectorSub(C, B);
@@ -393,19 +473,19 @@ export function processTriangleSimplex(simplex, direction) {
       return {
         contains: false,
         newDirection: tripleProduct(BC, vectorNeg(B), BC),
-        newSimplex: [B, C]
+        newSimplex: [B, C],
       };
     } else if (ABmagSq.greaterThan(ACmagSq)) {
       return {
         contains: false,
         newDirection: tripleProduct(AB, AO, AB),
-        newSimplex: [A, B]
+        newSimplex: [A, B],
       };
     } else {
       return {
         contains: false,
         newDirection: tripleProduct(AC, AO, AC),
-        newSimplex: [A, C]
+        newSimplex: [A, C],
       };
     }
   }
@@ -417,7 +497,7 @@ export function processTriangleSimplex(simplex, direction) {
     return {
       contains: false,
       newDirection: ABperp,
-      newSimplex: [A, B]
+      newSimplex: [A, B],
     };
   }
 
@@ -428,7 +508,7 @@ export function processTriangleSimplex(simplex, direction) {
     return {
       contains: false,
       newDirection: ACperp,
-      newSimplex: [A, C]
+      newSimplex: [A, C],
     };
   }
 
@@ -436,7 +516,7 @@ export function processTriangleSimplex(simplex, direction) {
   return {
     contains: true,
     newDirection: direction,
-    newSimplex: simplex
+    newSimplex: simplex,
   };
 }
 
@@ -459,8 +539,10 @@ export function processTriangleSimplex(simplex, direction) {
  * @throws {TypeError} If polygons are not arrays
  */
 export function gjkIntersects(polygonA, polygonB) {
-  if (!Array.isArray(polygonA)) throw new TypeError('gjkIntersects: polygonA must be an array');
-  if (!Array.isArray(polygonB)) throw new TypeError('gjkIntersects: polygonB must be an array');
+  if (!Array.isArray(polygonA))
+    throw new TypeError("gjkIntersects: polygonA must be an array");
+  if (!Array.isArray(polygonB))
+    throw new TypeError("gjkIntersects: polygonB must be an array");
   // Handle empty polygons
   if (polygonA.length === 0 || polygonB.length === 0) {
     return { intersects: false, iterations: 0, simplex: [], verified: true };
@@ -469,25 +551,26 @@ export function gjkIntersects(polygonA, polygonB) {
   // Handle single points
   if (polygonA.length === 1 && polygonB.length === 1) {
     if (!polygonA[0] || polygonA[0].x == null || polygonA[0].y == null) {
-      throw new TypeError('gjkIntersects: polygonA[0] must have x and y properties');
+      throw new TypeError(
+        "gjkIntersects: polygonA[0] must have x and y properties",
+      );
     }
     if (!polygonB[0] || polygonB[0].x == null || polygonB[0].y == null) {
-      throw new TypeError('gjkIntersects: polygonB[0] must have x and y properties');
+      throw new TypeError(
+        "gjkIntersects: polygonB[0] must have x and y properties",
+      );
     }
     const dist = magnitude(vectorSub(polygonA[0], polygonB[0]));
     return {
       intersects: dist.lessThan(EPSILON),
       iterations: 1,
       simplex: [],
-      verified: true
+      verified: true,
     };
   }
 
   // Initial direction: from center of A to center of B
-  let direction = vectorSub(
-    centroid(polygonB),
-    centroid(polygonA)
-  );
+  let direction = vectorSub(centroid(polygonB), centroid(polygonA));
 
   // If centers are the same, use arbitrary direction
   if (magnitudeSquared(direction).lessThan(EPSILON)) {
@@ -506,7 +589,7 @@ export function gjkIntersects(polygonA, polygonB) {
       intersects: true,
       iterations: 1,
       simplex,
-      verified: verifyIntersection(polygonA, polygonB)
+      verified: verifyIntersection(polygonA, polygonB),
     };
   }
 
@@ -523,7 +606,7 @@ export function gjkIntersects(polygonA, polygonB) {
         intersects: false,
         iterations: iteration + 1,
         simplex,
-        verified: true
+        verified: true,
       };
     }
 
@@ -539,7 +622,7 @@ export function gjkIntersects(polygonA, polygonB) {
           intersects: true,
           iterations: iteration + 1,
           simplex,
-          verified: verifyIntersection(polygonA, polygonB)
+          verified: verifyIntersection(polygonA, polygonB),
         };
       }
       direction = result.newDirection;
@@ -551,7 +634,7 @@ export function gjkIntersects(polygonA, polygonB) {
           intersects: true,
           iterations: iteration + 1,
           simplex: result.newSimplex,
-          verified: verifyIntersection(polygonA, polygonB)
+          verified: verifyIntersection(polygonA, polygonB),
         };
       }
       simplex = result.newSimplex;
@@ -566,7 +649,7 @@ export function gjkIntersects(polygonA, polygonB) {
         intersects: false,
         iterations: iteration + 1,
         simplex,
-        verified: false
+        verified: false,
       };
     }
 
@@ -579,7 +662,7 @@ export function gjkIntersects(polygonA, polygonB) {
     intersects: false,
     iterations: MAX_ITERATIONS,
     simplex,
-    verified: false
+    verified: false,
   };
 }
 
@@ -594,9 +677,10 @@ export function gjkIntersects(polygonA, polygonB) {
  * @throws {TypeError} If polygon is not an array
  */
 export function centroid(polygon) {
-  if (!Array.isArray(polygon)) throw new TypeError('centroid: polygon must be an array');
+  if (!Array.isArray(polygon))
+    throw new TypeError("centroid: polygon must be an array");
   if (polygon.length === 0) {
-    throw new TypeError('centroid: polygon cannot be empty');
+    throw new TypeError("centroid: polygon cannot be empty");
   }
 
   let sumX = D(0);
@@ -604,7 +688,9 @@ export function centroid(polygon) {
 
   for (let i = 0; i < polygon.length; i++) {
     if (!polygon[i] || polygon[i].x == null || polygon[i].y == null) {
-      throw new TypeError(`centroid: polygon[${i}] must have x and y properties`);
+      throw new TypeError(
+        `centroid: polygon[${i}] must have x and y properties`,
+      );
     }
     sumX = sumX.plus(polygon[i].x);
     sumY = sumY.plus(polygon[i].y);
@@ -626,8 +712,12 @@ export function centroid(polygon) {
  * @throws {TypeError} If pt is invalid or polygon is not an array
  */
 export function pointInConvexPolygon(pt, polygon) {
-  if (!pt || pt.x == null || pt.y == null) throw new TypeError('pointInConvexPolygon: point must have x and y properties');
-  if (!Array.isArray(polygon)) throw new TypeError('pointInConvexPolygon: polygon must be an array');
+  if (!pt || pt.x == null || pt.y == null)
+    throw new TypeError(
+      "pointInConvexPolygon: point must have x and y properties",
+    );
+  if (!Array.isArray(polygon))
+    throw new TypeError("pointInConvexPolygon: polygon must be an array");
   if (polygon.length < 3) {
     return false;
   }
@@ -639,10 +729,14 @@ export function pointInConvexPolygon(pt, polygon) {
     const p2 = polygon[(i + 1) % polygon.length];
 
     if (!p1 || p1.x == null || p1.y == null) {
-      throw new TypeError(`pointInConvexPolygon: polygon[${i}] must have x and y properties`);
+      throw new TypeError(
+        `pointInConvexPolygon: polygon[${i}] must have x and y properties`,
+      );
     }
     if (!p2 || p2.x == null || p2.y == null) {
-      throw new TypeError(`pointInConvexPolygon: polygon[${(i + 1) % polygon.length}] must have x and y properties`);
+      throw new TypeError(
+        `pointInConvexPolygon: polygon[${(i + 1) % polygon.length}] must have x and y properties`,
+      );
     }
 
     const edge = vectorSub(p2, p1);
@@ -679,12 +773,16 @@ export function pointInConvexPolygon(pt, polygon) {
  * @throws {TypeError} If polygons are not arrays
  */
 export function verifyIntersection(polygonA, polygonB) {
-  if (!Array.isArray(polygonA)) throw new TypeError('verifyIntersection: polygonA must be an array');
-  if (!Array.isArray(polygonB)) throw new TypeError('verifyIntersection: polygonB must be an array');
+  if (!Array.isArray(polygonA))
+    throw new TypeError("verifyIntersection: polygonA must be an array");
+  if (!Array.isArray(polygonB))
+    throw new TypeError("verifyIntersection: polygonB must be an array");
   // Check if any vertex of A is inside B
   for (let i = 0; i < polygonA.length; i++) {
     if (!polygonA[i] || polygonA[i].x == null || polygonA[i].y == null) {
-      throw new TypeError(`verifyIntersection: polygonA[${i}] must have x and y properties`);
+      throw new TypeError(
+        `verifyIntersection: polygonA[${i}] must have x and y properties`,
+      );
     }
     if (pointInConvexPolygon(polygonA[i], polygonB)) {
       return true;
@@ -694,7 +792,9 @@ export function verifyIntersection(polygonA, polygonB) {
   // Check if any vertex of B is inside A
   for (let i = 0; i < polygonB.length; i++) {
     if (!polygonB[i] || polygonB[i].x == null || polygonB[i].y == null) {
-      throw new TypeError(`verifyIntersection: polygonB[${i}] must have x and y properties`);
+      throw new TypeError(
+        `verifyIntersection: polygonB[${i}] must have x and y properties`,
+      );
     }
     if (pointInConvexPolygon(polygonB[i], polygonA)) {
       return true;
@@ -707,10 +807,14 @@ export function verifyIntersection(polygonA, polygonB) {
     const a2 = polygonA[(i + 1) % polygonA.length];
 
     if (!a1 || a1.x == null || a1.y == null) {
-      throw new TypeError(`verifyIntersection: polygonA[${i}] must have x and y properties`);
+      throw new TypeError(
+        `verifyIntersection: polygonA[${i}] must have x and y properties`,
+      );
     }
     if (!a2 || a2.x == null || a2.y == null) {
-      throw new TypeError(`verifyIntersection: polygonA[${(i + 1) % polygonA.length}] must have x and y properties`);
+      throw new TypeError(
+        `verifyIntersection: polygonA[${(i + 1) % polygonA.length}] must have x and y properties`,
+      );
     }
 
     for (let j = 0; j < polygonB.length; j++) {
@@ -718,10 +822,14 @@ export function verifyIntersection(polygonA, polygonB) {
       const b2 = polygonB[(j + 1) % polygonB.length];
 
       if (!b1 || b1.x == null || b1.y == null) {
-        throw new TypeError(`verifyIntersection: polygonB[${j}] must have x and y properties`);
+        throw new TypeError(
+          `verifyIntersection: polygonB[${j}] must have x and y properties`,
+        );
       }
       if (!b2 || b2.x == null || b2.y == null) {
-        throw new TypeError(`verifyIntersection: polygonB[${(j + 1) % polygonB.length}] must have x and y properties`);
+        throw new TypeError(
+          `verifyIntersection: polygonB[${(j + 1) % polygonB.length}] must have x and y properties`,
+        );
       }
 
       if (segmentsIntersect(a1, a2, b1, b2)) {
@@ -744,10 +852,14 @@ export function verifyIntersection(polygonA, polygonB) {
  * @throws {TypeError} If any point is invalid or missing x/y properties
  */
 export function segmentsIntersect(a1, a2, b1, b2) {
-  if (!a1 || a1.x == null || a1.y == null) throw new TypeError('segmentsIntersect: a1 must have x and y properties');
-  if (!a2 || a2.x == null || a2.y == null) throw new TypeError('segmentsIntersect: a2 must have x and y properties');
-  if (!b1 || b1.x == null || b1.y == null) throw new TypeError('segmentsIntersect: b1 must have x and y properties');
-  if (!b2 || b2.x == null || b2.y == null) throw new TypeError('segmentsIntersect: b2 must have x and y properties');
+  if (!a1 || a1.x == null || a1.y == null)
+    throw new TypeError("segmentsIntersect: a1 must have x and y properties");
+  if (!a2 || a2.x == null || a2.y == null)
+    throw new TypeError("segmentsIntersect: a2 must have x and y properties");
+  if (!b1 || b1.x == null || b1.y == null)
+    throw new TypeError("segmentsIntersect: b1 must have x and y properties");
+  if (!b2 || b2.x == null || b2.y == null)
+    throw new TypeError("segmentsIntersect: b2 must have x and y properties");
 
   const d1 = vectorSub(a2, a1);
   const d2 = vectorSub(b2, b1);
@@ -791,8 +903,12 @@ export function segmentsIntersect(a1, a2, b1, b2) {
   const u = cross(d3, d1).div(crossD);
 
   // Check if intersection is within both segments
-  return t.greaterThanOrEqualTo(0) && t.lessThanOrEqualTo(1) &&
-    u.greaterThanOrEqualTo(0) && u.lessThanOrEqualTo(1);
+  return (
+    t.greaterThanOrEqualTo(0) &&
+    t.lessThanOrEqualTo(1) &&
+    u.greaterThanOrEqualTo(0) &&
+    u.lessThanOrEqualTo(1)
+  );
 }
 
 // ============================================================================
@@ -811,10 +927,14 @@ export function segmentsIntersect(a1, a2, b1, b2) {
  * @throws {TypeError} If polygons are not arrays or are empty
  */
 export function gjkDistance(polygonA, polygonB) {
-  if (!Array.isArray(polygonA)) throw new TypeError('gjkDistance: polygonA must be an array');
-  if (!Array.isArray(polygonB)) throw new TypeError('gjkDistance: polygonB must be an array');
-  if (polygonA.length === 0) throw new TypeError('gjkDistance: polygonA cannot be empty');
-  if (polygonB.length === 0) throw new TypeError('gjkDistance: polygonB cannot be empty');
+  if (!Array.isArray(polygonA))
+    throw new TypeError("gjkDistance: polygonA must be an array");
+  if (!Array.isArray(polygonB))
+    throw new TypeError("gjkDistance: polygonB must be an array");
+  if (polygonA.length === 0)
+    throw new TypeError("gjkDistance: polygonA cannot be empty");
+  if (polygonB.length === 0)
+    throw new TypeError("gjkDistance: polygonB cannot be empty");
 
   // First check if they intersect
   const intersection = gjkIntersects(polygonA, polygonB);
@@ -824,7 +944,7 @@ export function gjkDistance(polygonA, polygonB) {
       distance: D(0),
       closestA: centroid(polygonA),
       closestB: centroid(polygonB),
-      verified: true
+      verified: true,
     };
   }
 
@@ -836,10 +956,14 @@ export function gjkDistance(polygonA, polygonB) {
 
   // Validate first points before using them as initial values
   if (!polygonA[0] || polygonA[0].x == null || polygonA[0].y == null) {
-    throw new TypeError('gjkDistance: polygonA[0] must have x and y properties');
+    throw new TypeError(
+      "gjkDistance: polygonA[0] must have x and y properties",
+    );
   }
   if (!polygonB[0] || polygonB[0].x == null || polygonB[0].y == null) {
-    throw new TypeError('gjkDistance: polygonB[0] must have x and y properties');
+    throw new TypeError(
+      "gjkDistance: polygonB[0] must have x and y properties",
+    );
   }
 
   let minDist = D(Infinity);
@@ -849,11 +973,15 @@ export function gjkDistance(polygonA, polygonB) {
   // Check all pairs of vertices
   for (let i = 0; i < polygonA.length; i++) {
     if (!polygonA[i] || polygonA[i].x == null || polygonA[i].y == null) {
-      throw new TypeError(`gjkDistance: polygonA[${i}] must have x and y properties`);
+      throw new TypeError(
+        `gjkDistance: polygonA[${i}] must have x and y properties`,
+      );
     }
     for (let j = 0; j < polygonB.length; j++) {
       if (!polygonB[j] || polygonB[j].x == null || polygonB[j].y == null) {
-        throw new TypeError(`gjkDistance: polygonB[${j}] must have x and y properties`);
+        throw new TypeError(
+          `gjkDistance: polygonB[${j}] must have x and y properties`,
+        );
       }
       const dist = magnitude(vectorSub(polygonA[i], polygonB[j]));
       if (dist.lessThan(minDist)) {
@@ -867,16 +995,22 @@ export function gjkDistance(polygonA, polygonB) {
   // Check vertex-to-edge distances
   for (let i = 0; i < polygonA.length; i++) {
     if (!polygonA[i] || polygonA[i].x == null || polygonA[i].y == null) {
-      throw new TypeError(`gjkDistance: polygonA[${i}] must have x and y properties`);
+      throw new TypeError(
+        `gjkDistance: polygonA[${i}] must have x and y properties`,
+      );
     }
     for (let j = 0; j < polygonB.length; j++) {
       const e1 = polygonB[j];
       const e2 = polygonB[(j + 1) % polygonB.length];
       if (!e1 || e1.x == null || e1.y == null) {
-        throw new TypeError(`gjkDistance: polygonB[${j}] must have x and y properties`);
+        throw new TypeError(
+          `gjkDistance: polygonB[${j}] must have x and y properties`,
+        );
       }
       if (!e2 || e2.x == null || e2.y == null) {
-        throw new TypeError(`gjkDistance: polygonB[${(j + 1) % polygonB.length}] must have x and y properties`);
+        throw new TypeError(
+          `gjkDistance: polygonB[${(j + 1) % polygonB.length}] must have x and y properties`,
+        );
       }
       const closest = closestPointOnSegment(polygonA[i], e1, e2);
       const dist = magnitude(vectorSub(polygonA[i], closest));
@@ -890,16 +1024,22 @@ export function gjkDistance(polygonA, polygonB) {
 
   for (let i = 0; i < polygonB.length; i++) {
     if (!polygonB[i] || polygonB[i].x == null || polygonB[i].y == null) {
-      throw new TypeError(`gjkDistance: polygonB[${i}] must have x and y properties`);
+      throw new TypeError(
+        `gjkDistance: polygonB[${i}] must have x and y properties`,
+      );
     }
     for (let j = 0; j < polygonA.length; j++) {
       const e1 = polygonA[j];
       const e2 = polygonA[(j + 1) % polygonA.length];
       if (!e1 || e1.x == null || e1.y == null) {
-        throw new TypeError(`gjkDistance: polygonA[${j}] must have x and y properties`);
+        throw new TypeError(
+          `gjkDistance: polygonA[${j}] must have x and y properties`,
+        );
       }
       if (!e2 || e2.x == null || e2.y == null) {
-        throw new TypeError(`gjkDistance: polygonA[${(j + 1) % polygonA.length}] must have x and y properties`);
+        throw new TypeError(
+          `gjkDistance: polygonA[${(j + 1) % polygonA.length}] must have x and y properties`,
+        );
       }
       const closest = closestPointOnSegment(polygonB[i], e1, e2);
       const dist = magnitude(vectorSub(polygonB[i], closest));
@@ -919,7 +1059,7 @@ export function gjkDistance(polygonA, polygonB) {
     distance: minDist,
     closestA,
     closestB,
-    verified
+    verified,
   };
 }
 
@@ -933,9 +1073,18 @@ export function gjkDistance(polygonA, polygonB) {
  * @throws {TypeError} If any point is invalid or missing x/y properties
  */
 export function closestPointOnSegment(pt, a, b) {
-  if (!pt || pt.x == null || pt.y == null) throw new TypeError('closestPointOnSegment: pt must have x and y properties');
-  if (!a || a.x == null || a.y == null) throw new TypeError('closestPointOnSegment: a must have x and y properties');
-  if (!b || b.x == null || b.y == null) throw new TypeError('closestPointOnSegment: b must have x and y properties');
+  if (!pt || pt.x == null || pt.y == null)
+    throw new TypeError(
+      "closestPointOnSegment: pt must have x and y properties",
+    );
+  if (!a || a.x == null || a.y == null)
+    throw new TypeError(
+      "closestPointOnSegment: a must have x and y properties",
+    );
+  if (!b || b.x == null || b.y == null)
+    throw new TypeError(
+      "closestPointOnSegment: b must have x and y properties",
+    );
 
   const ab = vectorSub(b, a);
   const ap = vectorSub(pt, a);
@@ -969,18 +1118,24 @@ export function closestPointOnSegment(pt, a, b) {
  * @throws {TypeError} If polygons are not arrays
  */
 export function polygonsOverlap(polygonA, polygonB) {
-  if (!Array.isArray(polygonA)) throw new TypeError('polygonsOverlap: polygonA must be an array');
-  if (!Array.isArray(polygonB)) throw new TypeError('polygonsOverlap: polygonB must be an array');
+  if (!Array.isArray(polygonA))
+    throw new TypeError("polygonsOverlap: polygonA must be an array");
+  if (!Array.isArray(polygonB))
+    throw new TypeError("polygonsOverlap: polygonB must be an array");
   // Normalize input to Decimal
   const normA = polygonA.map((p, i) => {
     if (!p || p.x == null || p.y == null) {
-      throw new TypeError(`polygonsOverlap: polygonA[${i}] must have x and y properties`);
+      throw new TypeError(
+        `polygonsOverlap: polygonA[${i}] must have x and y properties`,
+      );
     }
     return point(p.x, p.y);
   });
   const normB = polygonB.map((p, i) => {
     if (!p || p.x == null || p.y == null) {
-      throw new TypeError(`polygonsOverlap: polygonB[${i}] must have x and y properties`);
+      throw new TypeError(
+        `polygonsOverlap: polygonB[${i}] must have x and y properties`,
+      );
     }
     return point(p.x, p.y);
   });
@@ -989,7 +1144,7 @@ export function polygonsOverlap(polygonA, polygonB) {
 
   return {
     overlaps: result.intersects,
-    verified: result.verified
+    verified: result.verified,
   };
 }
 
@@ -1002,18 +1157,24 @@ export function polygonsOverlap(polygonA, polygonB) {
  * @throws {TypeError} If polygons are not arrays
  */
 export function polygonsDistance(polygonA, polygonB) {
-  if (!Array.isArray(polygonA)) throw new TypeError('polygonsDistance: polygonA must be an array');
-  if (!Array.isArray(polygonB)) throw new TypeError('polygonsDistance: polygonB must be an array');
+  if (!Array.isArray(polygonA))
+    throw new TypeError("polygonsDistance: polygonA must be an array");
+  if (!Array.isArray(polygonB))
+    throw new TypeError("polygonsDistance: polygonB must be an array");
   // Normalize input to Decimal
   const normA = polygonA.map((p, i) => {
     if (!p || p.x == null || p.y == null) {
-      throw new TypeError(`polygonsDistance: polygonA[${i}] must have x and y properties`);
+      throw new TypeError(
+        `polygonsDistance: polygonA[${i}] must have x and y properties`,
+      );
     }
     return point(p.x, p.y);
   });
   const normB = polygonB.map((p, i) => {
     if (!p || p.x == null || p.y == null) {
-      throw new TypeError(`polygonsDistance: polygonB[${i}] must have x and y properties`);
+      throw new TypeError(
+        `polygonsDistance: polygonB[${i}] must have x and y properties`,
+      );
     }
     return point(p.x, p.y);
   });
@@ -1024,7 +1185,7 @@ export function polygonsDistance(polygonA, polygonB) {
     distance: result.distance,
     closestA: result.closestA,
     closestB: result.closestB,
-    verified: result.verified
+    verified: result.verified,
   };
 }
 
@@ -1037,12 +1198,16 @@ export function polygonsDistance(polygonA, polygonB) {
  * @throws {TypeError} If pt is invalid or polygon is not an array
  */
 export function isPointInPolygon(pt, polygon) {
-  if (!pt || pt.x == null || pt.y == null) throw new TypeError('isPointInPolygon: pt must have x and y properties');
-  if (!Array.isArray(polygon)) throw new TypeError('isPointInPolygon: polygon must be an array');
+  if (!pt || pt.x == null || pt.y == null)
+    throw new TypeError("isPointInPolygon: pt must have x and y properties");
+  if (!Array.isArray(polygon))
+    throw new TypeError("isPointInPolygon: polygon must be an array");
   const normPt = point(pt.x, pt.y);
   const normPoly = polygon.map((p, i) => {
     if (!p || p.x == null || p.y == null) {
-      throw new TypeError(`isPointInPolygon: polygon[${i}] must have x and y properties`);
+      throw new TypeError(
+        `isPointInPolygon: polygon[${i}] must have x and y properties`,
+      );
     }
     return point(p.x, p.y);
   });
@@ -1054,11 +1219,7 @@ export function isPointInPolygon(pt, polygon) {
 // Exports
 // ============================================================================
 
-export {
-  EPSILON,
-  MAX_ITERATIONS,
-  D
-};
+export { EPSILON, MAX_ITERATIONS, D };
 
 export default {
   // Point/vector utilities
@@ -1101,5 +1262,5 @@ export default {
 
   // Constants
   EPSILON,
-  MAX_ITERATIONS
+  MAX_ITERATIONS,
 };