@emasoft/svg-matrix 1.0.30 → 1.0.31

package/src/gjk-collision.js

@@ -52,8 +52,11 @@ const MAX_ITERATIONS = 100;
  * @param {number|string|Decimal} x - X coordinate
  * @param {number|string|Decimal} y - Y coordinate
  * @returns {{x: Decimal, y: Decimal}} Point object
+ * @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');
   return { x: D(x), y: D(y) };
 }
 
@@ -62,8 +65,11 @@ export function point(x, y) {
  * @param {{x: Decimal, y: Decimal}} a - First vector
  * @param {{x: Decimal, y: Decimal}} b - Second vector
  * @returns {{x: Decimal, y: Decimal}} Sum vector
+ * @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');
   return { x: a.x.plus(b.x), y: a.y.plus(b.y) };
 }
 
@@ -72,8 +78,11 @@ export function vectorAdd(a, b) {
  * @param {{x: Decimal, y: Decimal}} a - First vector
  * @param {{x: Decimal, y: Decimal}} b - Second vector
  * @returns {{x: Decimal, y: Decimal}} Difference vector (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');
   return { x: a.x.minus(b.x), y: a.y.minus(b.y) };
 }
 
@@ -81,8 +90,10 @@ export function vectorSub(a, b) {
  * Negate a vector.
  * @param {{x: Decimal, y: Decimal}} v - Vector to negate
  * @returns {{x: Decimal, y: Decimal}} Negated vector
+ * @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');
   return { x: v.x.neg(), y: v.y.neg() };
 }
 
@@ -91,8 +102,11 @@ export function vectorNeg(v) {
  * @param {{x: Decimal, y: Decimal}} v - Vector to scale
  * @param {number|string|Decimal} s - Scale factor
  * @returns {{x: Decimal, y: Decimal}} Scaled vector
+ * @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');
   const sd = D(s);
   return { x: v.x.mul(sd), y: v.y.mul(sd) };
 }
@@ -102,8 +116,11 @@ export function vectorScale(v, s) {
  * @param {{x: Decimal, y: Decimal}} a - First vector
  * @param {{x: Decimal, y: Decimal}} b - Second vector
  * @returns {Decimal} Dot product
+ * @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');
   return a.x.mul(b.x).plus(a.y.mul(b.y));
 }
 
@@ -112,8 +129,11 @@ export function dot(a, b) {
  * @param {{x: Decimal, y: Decimal}} a - First vector
  * @param {{x: Decimal, y: Decimal}} b - Second vector
  * @returns {Decimal} Cross product (a.x * b.y - a.y * b.x)
+ * @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');
   return a.x.mul(b.y).minus(a.y.mul(b.x));
 }
 
@@ -121,8 +141,10 @@ export function cross(a, b) {
  * Squared magnitude of a vector.
  * @param {{x: Decimal, y: Decimal}} v - Vector
  * @returns {Decimal} Squared magnitude
+ * @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');
   return v.x.mul(v.x).plus(v.y.mul(v.y));
 }
 
@@ -130,8 +152,10 @@ export function magnitudeSquared(v) {
  * Magnitude of a vector.
  * @param {{x: Decimal, y: Decimal}} v - Vector
  * @returns {Decimal} Magnitude
+ * @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');
   return magnitudeSquared(v).sqrt();
 }
 
@@ -139,8 +163,10 @@ export function magnitude(v) {
  * Normalize a vector to unit length.
  * @param {{x: Decimal, y: Decimal}} v - Vector to normalize
  * @returns {{x: Decimal, y: Decimal}} Unit vector
+ * @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');
   const mag = magnitude(v);
   if (mag.lessThan(EPSILON)) {
     return { x: D(0), y: D(0) };
@@ -152,8 +178,10 @@ export function normalize(v) {
  * Get perpendicular vector (90° counter-clockwise rotation).
  * @param {{x: Decimal, y: Decimal}} v - Vector
  * @returns {{x: Decimal, y: Decimal}} Perpendicular vector
+ * @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');
   return { x: v.y.neg(), y: v.x };
 }
 
@@ -164,8 +192,12 @@ export function perpendicular(v) {
  * @param {{x: Decimal, y: Decimal}} b - Second vector
  * @param {{x: Decimal, y: Decimal}} c - Third vector
  * @returns {{x: Decimal, y: Decimal}} Triple product result
+ * @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');
   // In 2D: (A × B) × C = B(A·C) - A(B·C)
   const ac = dot(a, c);
   const bc = dot(b, c);
@@ -185,16 +217,27 @@ export function tripleProduct(a, b, c) {
  * @param {Array<{x: Decimal, y: Decimal}>} polygon - Convex polygon vertices
  * @param {{x: Decimal, y: Decimal}} direction - Direction to search
  * @returns {{x: Decimal, y: Decimal}} Farthest point
+ * @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 (polygon.length === 0) {
     return point(0, 0);
   }
 
+  // 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');
+  }
+
   let maxDot = dot(polygon[0], direction);
   let maxPoint = polygon[0];
 
   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`);
+    }
     const d = dot(polygon[i], direction);
     if (d.greaterThan(maxDot)) {
       maxDot = d;
@@ -215,8 +258,12 @@ export function supportPoint(polygon, direction) {
  * @param {Array<{x: Decimal, y: Decimal}>} polygonB - Second convex polygon
  * @param {{x: Decimal, y: Decimal}} direction - Direction to search
  * @returns {{x: Decimal, y: Decimal}} Support point on Minkowski difference
+ * @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');
   const pointA = supportPoint(polygonA, direction);
   const pointB = supportPoint(polygonB, vectorNeg(direction));
   return vectorSub(pointA, pointB);
@@ -236,8 +283,14 @@ export function minkowskiSupport(polygonA, polygonB, direction) {
  * @param {Array<{x: Decimal, y: Decimal}>} simplex - Current simplex (modified in place)
  * @param {{x: Decimal, y: Decimal}} direction - Current search direction (modified)
  * @returns {{contains: boolean, newDirection: {x: Decimal, y: Decimal}}}
+ * @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');
   const A = simplex[0]; // Newest point
   const B = simplex[1];
 
@@ -276,8 +329,15 @@ export function processLineSimplex(simplex, direction) {
  * @param {Array<{x: Decimal, y: Decimal}>} simplex - Current simplex (modified in place)
  * @param {{x: Decimal, y: Decimal}} direction - Current search direction
  * @returns {{contains: boolean, newDirection: {x: Decimal, y: Decimal}, newSimplex: Array}}
+ * @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');
   const A = simplex[0]; // Newest point
   const B = simplex[1];
   const C = simplex[2];
@@ -336,8 +396,11 @@ export function processTriangleSimplex(simplex, direction) {
  * @param {Array<{x: Decimal, y: Decimal}>} polygonA - First convex polygon
  * @param {Array<{x: Decimal, y: Decimal}>} polygonB - Second convex polygon
  * @returns {{intersects: boolean, iterations: number, simplex: Array, verified: boolean}}
+ * @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');
   // Handle empty polygons
   if (polygonA.length === 0 || polygonB.length === 0) {
     return { intersects: false, iterations: 0, simplex: [], verified: true };
@@ -345,6 +408,12 @@ 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');
+    }
+    if (!polygonB[0] || polygonB[0].x == null || polygonB[0].y == null) {
+      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),
@@ -460,8 +529,10 @@ export function gjkIntersects(polygonA, polygonB) {
  * Calculate centroid of a polygon.
  * @param {Array<{x: Decimal, y: Decimal}>} polygon - Polygon vertices
  * @returns {{x: Decimal, y: Decimal}} Centroid point
+ * @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 (polygon.length === 0) {
     return point(0, 0);
   }
@@ -469,9 +540,12 @@ export function centroid(polygon) {
   let sumX = D(0);
   let sumY = D(0);
 
-  for (const p of polygon) {
-    sumX = sumX.plus(p.x);
-    sumY = sumY.plus(p.y);
+  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`);
+    }
+    sumX = sumX.plus(polygon[i].x);
+    sumY = sumY.plus(polygon[i].y);
   }
 
   const n = D(polygon.length);
@@ -487,8 +561,11 @@ export function centroid(polygon) {
  * @param {{x: Decimal, y: Decimal}} pt - Point to test
  * @param {Array<{x: Decimal, y: Decimal}>} polygon - Convex polygon
  * @returns {boolean} True if point is inside (including boundary)
+ * @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 (polygon.length < 3) {
     return false;
   }
@@ -499,6 +576,13 @@ export function pointInConvexPolygon(pt, polygon) {
     const p1 = polygon[i];
     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`);
+    }
+    if (!p2 || p2.x == null || p2.y == null) {
+      throw new TypeError(`pointInConvexPolygon: polygon[${(i + 1) % polygon.length}] must have x and y properties`);
+    }
+
     const edge = vectorSub(p2, p1);
     const toPoint = vectorSub(pt, p1);
     const crossVal = cross(edge, toPoint);
@@ -530,18 +614,27 @@ export function pointInConvexPolygon(pt, polygon) {
  * @param {Array<{x: Decimal, y: Decimal}>} polygonA - First polygon
  * @param {Array<{x: Decimal, y: Decimal}>} polygonB - Second polygon
  * @returns {boolean} True if intersection is verified
+ * @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');
   // Check if any vertex of A is inside B
-  for (const p of polygonA) {
-    if (pointInConvexPolygon(p, polygonB)) {
+  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`);
+    }
+    if (pointInConvexPolygon(polygonA[i], polygonB)) {
       return true;
     }
   }
 
   // Check if any vertex of B is inside A
-  for (const p of polygonB) {
-    if (pointInConvexPolygon(p, polygonA)) {
+  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`);
+    }
+    if (pointInConvexPolygon(polygonB[i], polygonA)) {
       return true;
     }
   }
@@ -551,10 +644,24 @@ export function verifyIntersection(polygonA, polygonB) {
     const a1 = polygonA[i];
     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`);
+    }
+    if (!a2 || a2.x == null || a2.y == null) {
+      throw new TypeError(`verifyIntersection: polygonA[${(i + 1) % polygonA.length}] must have x and y properties`);
+    }
+
     for (let j = 0; j < polygonB.length; j++) {
       const b1 = polygonB[j];
       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`);
+      }
+      if (!b2 || b2.x == null || b2.y == null) {
+        throw new TypeError(`verifyIntersection: polygonB[${(j + 1) % polygonB.length}] must have x and y properties`);
+      }
+
       if (segmentsIntersect(a1, a2, b1, b2)) {
         return true;
       }
@@ -572,8 +679,14 @@ export function verifyIntersection(polygonA, polygonB) {
  * @param {{x: Decimal, y: Decimal}} b1 - Second segment start
  * @param {{x: Decimal, y: Decimal}} b2 - Second segment end
  * @returns {boolean} True if segments intersect
+ * @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');
+
   const d1 = vectorSub(a2, a1);
   const d2 = vectorSub(b2, b1);
 
@@ -585,9 +698,22 @@ export function segmentsIntersect(a1, a2, b1, b2) {
     const d3 = vectorSub(b1, a1);
     if (cross(d1, d3).abs().lessThan(EPSILON)) {
       // Collinear - check overlap
-      const t0 = dot(d3, d1).div(dot(d1, d1));
+      const d1LengthSq = dot(d1, d1);
+      // Handle degenerate first segment (a1 == a2)
+      if (d1LengthSq.lessThan(EPSILON)) {
+        // First segment is a point - check if it lies on second segment
+        const d2LengthSq = dot(d2, d2);
+        if (d2LengthSq.lessThan(EPSILON)) {
+          // Both segments are points - check if same point
+          return magnitude(d3).lessThan(EPSILON);
+        }
+        // Check if point a1 is on segment b1-b2
+        const t = dot(d3, d2).div(d2LengthSq);
+        return t.greaterThanOrEqualTo(0) && t.lessThanOrEqualTo(1);
+      }
+      const t0 = dot(d3, d1).div(d1LengthSq);
       const d4 = vectorSub(b2, a1);
-      const t1 = dot(d4, d1).div(dot(d1, d1));
+      const t1 = dot(d4, d1).div(d1LengthSq);
 
       const tMin = Decimal.min(t0, t1);
       const tMax = Decimal.max(t0, t1);
@@ -620,8 +746,14 @@ export function segmentsIntersect(a1, a2, b1, b2) {
  * @param {Array<{x: Decimal, y: Decimal}>} polygonA - First convex polygon
  * @param {Array<{x: Decimal, y: Decimal}>} polygonB - Second convex polygon
  * @returns {{distance: Decimal, closestA: {x: Decimal, y: Decimal}, closestB: {x: Decimal, y: Decimal}, verified: boolean}}
+ * @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');
+
   // First check if they intersect
   const intersection = gjkIntersects(polygonA, polygonB);
 
@@ -640,47 +772,79 @@ export function gjkDistance(polygonA, polygonB) {
   // For non-intersecting shapes, find the closest points by
   // examining all vertex-edge pairs
 
+  // 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');
+  }
+  if (!polygonB[0] || polygonB[0].x == null || polygonB[0].y == null) {
+    throw new TypeError('gjkDistance: polygonB[0] must have x and y properties');
+  }
+
   let minDist = D(Infinity);
   let closestA = polygonA[0];
   let closestB = polygonB[0];
 
   // Check all pairs of vertices
-  for (const pA of polygonA) {
-    for (const pB of polygonB) {
-      const dist = magnitude(vectorSub(pA, pB));
+  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`);
+    }
+    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`);
+      }
+      const dist = magnitude(vectorSub(polygonA[i], polygonB[j]));
       if (dist.lessThan(minDist)) {
         minDist = dist;
-        closestA = pA;
-        closestB = pB;
+        closestA = polygonA[i];
+        closestB = polygonB[j];
       }
     }
   }
 
   // Check vertex-to-edge distances
-  for (const pA of polygonA) {
-    for (let i = 0; i < polygonB.length; i++) {
-      const e1 = polygonB[i];
-      const e2 = polygonB[(i + 1) % polygonB.length];
-      const closest = closestPointOnSegment(pA, e1, e2);
-      const dist = magnitude(vectorSub(pA, closest));
+  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`);
+    }
+    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`);
+      }
+      if (!e2 || e2.x == null || e2.y == null) {
+        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));
       if (dist.lessThan(minDist)) {
         minDist = dist;
-        closestA = pA;
+        closestA = polygonA[i];
         closestB = closest;
       }
     }
   }
 
-  for (const pB of polygonB) {
-    for (let i = 0; i < polygonA.length; i++) {
-      const e1 = polygonA[i];
-      const e2 = polygonA[(i + 1) % polygonA.length];
-      const closest = closestPointOnSegment(pB, e1, e2);
-      const dist = magnitude(vectorSub(pB, closest));
+  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`);
+    }
+    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`);
+      }
+      if (!e2 || e2.x == null || e2.y == null) {
+        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));
       if (dist.lessThan(minDist)) {
         minDist = dist;
         closestA = closest;
-        closestB = pB;
+        closestB = polygonB[i];
       }
     }
   }
@@ -704,8 +868,13 @@ export function gjkDistance(polygonA, polygonB) {
  * @param {{x: Decimal, y: Decimal}} a - Segment start
  * @param {{x: Decimal, y: Decimal}} b - Segment end
  * @returns {{x: Decimal, y: Decimal}} Closest point on segment
+ * @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');
+
   const ab = vectorSub(b, a);
   const ap = vectorSub(pt, a);
 
@@ -735,11 +904,24 @@ export function closestPointOnSegment(pt, a, b) {
  * @param {Array<{x: number|Decimal, y: number|Decimal}>} polygonA - First polygon
  * @param {Array<{x: number|Decimal, y: number|Decimal}>} polygonB - Second polygon
  * @returns {{overlaps: boolean, verified: boolean}}
+ * @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');
   // Normalize input to Decimal
-  const normA = polygonA.map(p => point(p.x, p.y));
-  const normB = polygonB.map(p => point(p.x, p.y));
+  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`);
+    }
+    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`);
+    }
+    return point(p.x, p.y);
+  });
 
   const result = gjkIntersects(normA, normB);
 
@@ -755,11 +937,24 @@ export function polygonsOverlap(polygonA, polygonB) {
  * @param {Array<{x: number|Decimal, y: number|Decimal}>} polygonA - First polygon
  * @param {Array<{x: number|Decimal, y: number|Decimal}>} polygonB - Second polygon
  * @returns {{distance: Decimal, verified: boolean}}
+ * @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');
   // Normalize input to Decimal
-  const normA = polygonA.map(p => point(p.x, p.y));
-  const normB = polygonB.map(p => point(p.x, p.y));
+  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`);
+    }
+    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`);
+    }
+    return point(p.x, p.y);
+  });
 
   const result = gjkDistance(normA, normB);
 
@@ -777,10 +972,18 @@ export function polygonsDistance(polygonA, polygonB) {
  * @param {{x: number|Decimal, y: number|Decimal}} pt - Point to test
  * @param {Array<{x: number|Decimal, y: number|Decimal}>} polygon - Polygon
  * @returns {boolean} True if inside
+ * @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');
   const normPt = point(pt.x, pt.y);
-  const normPoly = polygon.map(p => point(p.x, p.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`);
+    }
+    return point(p.x, p.y);
+  });
 
   return pointInConvexPolygon(normPt, normPoly);
 }