@emasoft/svg-matrix 1.0.30 → 1.0.31

package/src/path-simplification.js

@@ -57,28 +57,37 @@ const DEFAULT_TOLERANCE = new Decimal('1e-10');
  * @returns {Decimal} Angle in radians (-π to π)
  */
 function decimalAtan2(y, x) {
+  if (y === null || y === undefined) throw new Error('decimalAtan2: y parameter is null or undefined');
+  if (x === null || x === undefined) throw new Error('decimalAtan2: x parameter is null or undefined');
   const yD = D(y);
   const xD = D(x);
+  if (!yD.isFinite()) throw new Error('decimalAtan2: y must be finite');
+  if (!xD.isFinite()) throw new Error('decimalAtan2: x must be finite');
   const PI = Decimal.acos(-1);
 
+  // Check x=0 cases first to avoid division by zero
+  if (xD.equals(0)) {
+    if (yD.greaterThan(0)) {
+      // Positive y-axis
+      return PI.div(2);
+    } else if (yD.lessThan(0)) {
+      // Negative y-axis
+      return PI.div(2).neg();
+    } else {
+      // x=0, y=0 - undefined, return 0
+      return D(0);
+    }
+  }
+
   if (xD.greaterThan(0)) {
     // Quadrant I or IV
     return Decimal.atan(yD.div(xD));
   } else if (xD.lessThan(0) && yD.greaterThanOrEqualTo(0)) {
     // Quadrant II
     return Decimal.atan(yD.div(xD)).plus(PI);
-  } else if (xD.lessThan(0) && yD.lessThan(0)) {
-    // Quadrant III
-    return Decimal.atan(yD.div(xD)).minus(PI);
-  } else if (xD.equals(0) && yD.greaterThan(0)) {
-    // Positive y-axis
-    return PI.div(2);
-  } else if (xD.equals(0) && yD.lessThan(0)) {
-    // Negative y-axis
-    return PI.div(2).neg();
   } else {
-    // x=0, y=0 - undefined, return 0
-    return D(0);
+    // Quadrant III (xD.lessThan(0) && yD.lessThan(0))
+    return Decimal.atan(yD.div(xD)).minus(PI);
   }
 }
 
@@ -93,7 +102,13 @@ function decimalAtan2(y, x) {
  * @returns {{x: Decimal, y: Decimal}} Point object
  */
 export function point(x, y) {
-  return { x: D(x), y: D(y) };
+  if (x === null || x === undefined) throw new Error('point: x parameter is null or undefined');
+  if (y === null || y === undefined) throw new Error('point: y parameter is null or undefined');
+  const xD = D(x);
+  const yD = D(y);
+  if (!xD.isFinite()) throw new Error('point: x must be finite');
+  if (!yD.isFinite()) throw new Error('point: y must be finite');
+  return { x: xD, y: yD };
 }
 
 /**
@@ -104,6 +119,9 @@ export function point(x, y) {
  * @returns {Decimal} Squared distance
  */
 export function distanceSquared(p1, p2) {
+  if (!p1 || !p2) throw new Error('distanceSquared: points cannot be null or undefined');
+  if (!(p1.x instanceof Decimal) || !(p1.y instanceof Decimal)) throw new Error('distanceSquared: p1 must have Decimal x and y properties');
+  if (!(p2.x instanceof Decimal) || !(p2.y instanceof Decimal)) throw new Error('distanceSquared: p2 must have Decimal x and y properties');
   const dx = p2.x.minus(p1.x);
   const dy = p2.y.minus(p1.y);
   return dx.mul(dx).plus(dy.mul(dy));
@@ -116,6 +134,7 @@ export function distanceSquared(p1, p2) {
  * @returns {Decimal} Distance
  */
 export function distance(p1, p2) {
+  // Validation is done in distanceSquared
   return distanceSquared(p1, p2).sqrt();
 }
 
@@ -130,6 +149,10 @@ export function distance(p1, p2) {
  * @returns {Decimal} Perpendicular distance
  */
 export function pointToLineDistance(pt, lineStart, lineEnd) {
+  if (!pt || !lineStart || !lineEnd) throw new Error('pointToLineDistance: points cannot be null or undefined');
+  if (!(pt.x instanceof Decimal) || !(pt.y instanceof Decimal)) throw new Error('pointToLineDistance: pt must have Decimal x and y properties');
+  if (!(lineStart.x instanceof Decimal) || !(lineStart.y instanceof Decimal)) throw new Error('pointToLineDistance: lineStart must have Decimal x and y properties');
+  if (!(lineEnd.x instanceof Decimal) || !(lineEnd.y instanceof Decimal)) throw new Error('pointToLineDistance: lineEnd must have Decimal x and y properties');
   const x0 = pt.x, y0 = pt.y;
   const x1 = lineStart.x, y1 = lineStart.y;
   const x2 = lineEnd.x, y2 = lineEnd.y;
@@ -162,6 +185,10 @@ export function pointToLineDistance(pt, lineStart, lineEnd) {
  * @returns {Decimal} Cross product (positive = CCW, negative = CW, zero = collinear)
  */
 export function crossProduct(p1, p2, p3) {
+  if (!p1 || !p2 || !p3) throw new Error('crossProduct: points cannot be null or undefined');
+  if (!(p1.x instanceof Decimal) || !(p1.y instanceof Decimal)) throw new Error('crossProduct: p1 must have Decimal x and y properties');
+  if (!(p2.x instanceof Decimal) || !(p2.y instanceof Decimal)) throw new Error('crossProduct: p2 must have Decimal x and y properties');
+  if (!(p3.x instanceof Decimal) || !(p3.y instanceof Decimal)) throw new Error('crossProduct: p3 must have Decimal x and y properties');
   const v1x = p2.x.minus(p1.x);
   const v1y = p2.y.minus(p1.y);
   const v2x = p3.x.minus(p1.x);
@@ -185,7 +212,15 @@ export function crossProduct(p1, p2, p3) {
  * @returns {{x: Decimal, y: Decimal}} Point on curve
  */
 export function evaluateCubicBezier(p0, p1, p2, p3, t) {
+  if (!p0 || !p1 || !p2 || !p3) throw new Error('evaluateCubicBezier: points cannot be null or undefined');
+  if (!(p0.x instanceof Decimal) || !(p0.y instanceof Decimal)) throw new Error('evaluateCubicBezier: p0 must have Decimal x and y properties');
+  if (!(p1.x instanceof Decimal) || !(p1.y instanceof Decimal)) throw new Error('evaluateCubicBezier: p1 must have Decimal x and y properties');
+  if (!(p2.x instanceof Decimal) || !(p2.y instanceof Decimal)) throw new Error('evaluateCubicBezier: p2 must have Decimal x and y properties');
+  if (!(p3.x instanceof Decimal) || !(p3.y instanceof Decimal)) throw new Error('evaluateCubicBezier: p3 must have Decimal x and y properties');
+  if (t === null || t === undefined) throw new Error('evaluateCubicBezier: t parameter is null or undefined');
   const tD = D(t);
+  if (!tD.isFinite()) throw new Error('evaluateCubicBezier: t must be finite');
+  if (tD.lessThan(0) || tD.greaterThan(1)) throw new Error('evaluateCubicBezier: t must be in range [0, 1]');
   const oneMinusT = D(1).minus(tD);
 
   // Bernstein basis polynomials
@@ -211,7 +246,14 @@ export function evaluateCubicBezier(p0, p1, p2, p3, t) {
  * @returns {{x: Decimal, y: Decimal}} Point on curve
  */
 export function evaluateQuadraticBezier(p0, p1, p2, t) {
+  if (!p0 || !p1 || !p2) throw new Error('evaluateQuadraticBezier: points cannot be null or undefined');
+  if (!(p0.x instanceof Decimal) || !(p0.y instanceof Decimal)) throw new Error('evaluateQuadraticBezier: p0 must have Decimal x and y properties');
+  if (!(p1.x instanceof Decimal) || !(p1.y instanceof Decimal)) throw new Error('evaluateQuadraticBezier: p1 must have Decimal x and y properties');
+  if (!(p2.x instanceof Decimal) || !(p2.y instanceof Decimal)) throw new Error('evaluateQuadraticBezier: p2 must have Decimal x and y properties');
+  if (t === null || t === undefined) throw new Error('evaluateQuadraticBezier: t parameter is null or undefined');
   const tD = D(t);
+  if (!tD.isFinite()) throw new Error('evaluateQuadraticBezier: t must be finite');
+  if (tD.lessThan(0) || tD.greaterThan(1)) throw new Error('evaluateQuadraticBezier: t must be in range [0, 1]');
   const oneMinusT = D(1).minus(tD);
 
   // Bernstein basis polynomials
@@ -235,7 +277,13 @@ export function evaluateQuadraticBezier(p0, p1, p2, t) {
  * @returns {{x: Decimal, y: Decimal}} Point on line
  */
 export function evaluateLine(p0, p1, t) {
+  if (!p0 || !p1) throw new Error('evaluateLine: points cannot be null or undefined');
+  if (!(p0.x instanceof Decimal) || !(p0.y instanceof Decimal)) throw new Error('evaluateLine: p0 must have Decimal x and y properties');
+  if (!(p1.x instanceof Decimal) || !(p1.y instanceof Decimal)) throw new Error('evaluateLine: p1 must have Decimal x and y properties');
+  if (t === null || t === undefined) throw new Error('evaluateLine: t parameter is null or undefined');
   const tD = D(t);
+  if (!tD.isFinite()) throw new Error('evaluateLine: t must be finite');
+  if (tD.lessThan(0) || tD.greaterThan(1)) throw new Error('evaluateLine: t must be in range [0, 1]');
   const oneMinusT = D(1).minus(tD);
   return {
     x: oneMinusT.mul(p0.x).plus(tD.mul(p1.x)),
@@ -264,7 +312,14 @@ export function evaluateLine(p0, p1, t) {
  * @returns {{isStraight: boolean, maxDeviation: Decimal, verified: boolean}}
  */
 export function isCubicBezierStraight(p0, p1, p2, p3, tolerance = DEFAULT_TOLERANCE) {
+  if (!p0 || !p1 || !p2 || !p3) throw new Error('isCubicBezierStraight: points cannot be null or undefined');
+  if (!(p0.x instanceof Decimal) || !(p0.y instanceof Decimal)) throw new Error('isCubicBezierStraight: p0 must have Decimal x and y properties');
+  if (!(p1.x instanceof Decimal) || !(p1.y instanceof Decimal)) throw new Error('isCubicBezierStraight: p1 must have Decimal x and y properties');
+  if (!(p2.x instanceof Decimal) || !(p2.y instanceof Decimal)) throw new Error('isCubicBezierStraight: p2 must have Decimal x and y properties');
+  if (!(p3.x instanceof Decimal) || !(p3.y instanceof Decimal)) throw new Error('isCubicBezierStraight: p3 must have Decimal x and y properties');
+  if (tolerance === null || tolerance === undefined) throw new Error('isCubicBezierStraight: tolerance parameter is null or undefined');
   const tol = D(tolerance);
+  if (!tol.isFinite() || tol.lessThan(0)) throw new Error('isCubicBezierStraight: tolerance must be a non-negative finite number');
 
   // Check if start and end are the same point (degenerate case)
   const chordLength = distance(p0, p3);
@@ -325,7 +380,13 @@ export function isCubicBezierStraight(p0, p1, p2, p3, tolerance = DEFAULT_TOLERA
  * @returns {{isStraight: boolean, maxDeviation: Decimal, verified: boolean}}
  */
 export function isQuadraticBezierStraight(p0, p1, p2, tolerance = DEFAULT_TOLERANCE) {
+  if (!p0 || !p1 || !p2) throw new Error('isQuadraticBezierStraight: points cannot be null or undefined');
+  if (!(p0.x instanceof Decimal) || !(p0.y instanceof Decimal)) throw new Error('isQuadraticBezierStraight: p0 must have Decimal x and y properties');
+  if (!(p1.x instanceof Decimal) || !(p1.y instanceof Decimal)) throw new Error('isQuadraticBezierStraight: p1 must have Decimal x and y properties');
+  if (!(p2.x instanceof Decimal) || !(p2.y instanceof Decimal)) throw new Error('isQuadraticBezierStraight: p2 must have Decimal x and y properties');
+  if (tolerance === null || tolerance === undefined) throw new Error('isQuadraticBezierStraight: tolerance parameter is null or undefined');
   const tol = D(tolerance);
+  if (!tol.isFinite() || tol.lessThan(0)) throw new Error('isQuadraticBezierStraight: tolerance must be a non-negative finite number');
 
   // Check if start and end are the same point (degenerate case)
   const chordLength = distance(p0, p2);
@@ -383,6 +444,7 @@ export function isQuadraticBezierStraight(p0, p1, p2, tolerance = DEFAULT_TOLERA
  * @returns {{start: {x: Decimal, y: Decimal}, end: {x: Decimal, y: Decimal}, maxDeviation: Decimal} | null}
  */
 export function cubicBezierToLine(p0, p1, p2, p3, tolerance = DEFAULT_TOLERANCE) {
+  // Validation is done in isCubicBezierStraight
   const result = isCubicBezierStraight(p0, p1, p2, p3, tolerance);
   if (!result.isStraight || !result.verified) {
     return null;
@@ -419,7 +481,14 @@ export function cubicBezierToLine(p0, p1, p2, p3, tolerance = DEFAULT_TOLERANCE)
  * @returns {{canLower: boolean, quadraticControl: {x: Decimal, y: Decimal} | null, maxDeviation: Decimal, verified: boolean}}
  */
 export function canLowerCubicToQuadratic(p0, p1, p2, p3, tolerance = DEFAULT_TOLERANCE) {
+  if (!p0 || !p1 || !p2 || !p3) throw new Error('canLowerCubicToQuadratic: points cannot be null or undefined');
+  if (!(p0.x instanceof Decimal) || !(p0.y instanceof Decimal)) throw new Error('canLowerCubicToQuadratic: p0 must have Decimal x and y properties');
+  if (!(p1.x instanceof Decimal) || !(p1.y instanceof Decimal)) throw new Error('canLowerCubicToQuadratic: p1 must have Decimal x and y properties');
+  if (!(p2.x instanceof Decimal) || !(p2.y instanceof Decimal)) throw new Error('canLowerCubicToQuadratic: p2 must have Decimal x and y properties');
+  if (!(p3.x instanceof Decimal) || !(p3.y instanceof Decimal)) throw new Error('canLowerCubicToQuadratic: p3 must have Decimal x and y properties');
+  if (tolerance === null || tolerance === undefined) throw new Error('canLowerCubicToQuadratic: tolerance parameter is null or undefined');
   const tol = D(tolerance);
+  if (!tol.isFinite() || tol.lessThan(0)) throw new Error('canLowerCubicToQuadratic: tolerance must be a non-negative finite number');
   const three = D(3);
   const two = D(2);
 
@@ -487,6 +556,7 @@ export function canLowerCubicToQuadratic(p0, p1, p2, p3, tolerance = DEFAULT_TOL
  * @returns {{p0: {x: Decimal, y: Decimal}, p1: {x: Decimal, y: Decimal}, p2: {x: Decimal, y: Decimal}, maxDeviation: Decimal} | null}
  */
 export function cubicToQuadratic(p0, p1, p2, p3, tolerance = DEFAULT_TOLERANCE) {
+  // Validation is done in canLowerCubicToQuadratic
   const result = canLowerCubicToQuadratic(p0, p1, p2, p3, tolerance);
   if (!result.canLower || !result.quadraticControl) {
     return null;
@@ -513,10 +583,22 @@ export function cubicToQuadratic(p0, p1, p2, p3, tolerance = DEFAULT_TOLERANCE)
  * @returns {{center: {x: Decimal, y: Decimal}, radius: Decimal} | null}
  */
 export function fitCircleToPoints(points) {
+  if (!points) throw new Error('fitCircleToPoints: points array cannot be null or undefined');
+  if (!Array.isArray(points)) throw new Error('fitCircleToPoints: points must be an array');
+  if (points.length === 0) throw new Error('fitCircleToPoints: points array cannot be empty');
   if (points.length < 3) {
     return null;
   }
 
+  // Validate all points have Decimal x and y properties
+  for (let i = 0; i < points.length; i++) {
+    const p = points[i];
+    if (!p) throw new Error(`fitCircleToPoints: point at index ${i} is null or undefined`);
+    if (!(p.x instanceof Decimal) || !(p.y instanceof Decimal)) {
+      throw new Error(`fitCircleToPoints: point at index ${i} must have Decimal x and y properties`);
+    }
+  }
+
   const n = D(points.length);
   let sumX = D(0), sumY = D(0);
   let sumX2 = D(0), sumY2 = D(0);
@@ -589,7 +671,14 @@ export function fitCircleToPoints(points) {
  * @returns {{isArc: boolean, circle: {center: {x: Decimal, y: Decimal}, radius: Decimal} | null, maxDeviation: Decimal, verified: boolean}}
  */
 export function fitCircleToCubicBezier(p0, p1, p2, p3, tolerance = DEFAULT_TOLERANCE) {
+  if (!p0 || !p1 || !p2 || !p3) throw new Error('fitCircleToCubicBezier: points cannot be null or undefined');
+  if (!(p0.x instanceof Decimal) || !(p0.y instanceof Decimal)) throw new Error('fitCircleToCubicBezier: p0 must have Decimal x and y properties');
+  if (!(p1.x instanceof Decimal) || !(p1.y instanceof Decimal)) throw new Error('fitCircleToCubicBezier: p1 must have Decimal x and y properties');
+  if (!(p2.x instanceof Decimal) || !(p2.y instanceof Decimal)) throw new Error('fitCircleToCubicBezier: p2 must have Decimal x and y properties');
+  if (!(p3.x instanceof Decimal) || !(p3.y instanceof Decimal)) throw new Error('fitCircleToCubicBezier: p3 must have Decimal x and y properties');
+  if (tolerance === null || tolerance === undefined) throw new Error('fitCircleToCubicBezier: tolerance parameter is null or undefined');
   const tol = D(tolerance);
+  if (!tol.isFinite() || tol.lessThan(0)) throw new Error('fitCircleToCubicBezier: tolerance must be a non-negative finite number');
 
   // Sample points along the curve for fitting
   const sampleCount = 9; // Including endpoints
@@ -646,6 +735,7 @@ export function fitCircleToCubicBezier(p0, p1, p2, p3, tolerance = DEFAULT_TOLER
  * @returns {{rx: Decimal, ry: Decimal, rotation: Decimal, largeArc: number, sweep: number, endX: Decimal, endY: Decimal, maxDeviation: Decimal} | null}
  */
 export function cubicBezierToArc(p0, p1, p2, p3, tolerance = DEFAULT_TOLERANCE) {
+  // Validation is done in fitCircleToCubicBezier
   const result = fitCircleToCubicBezier(p0, p1, p2, p3, tolerance);
 
   if (!result.isArc || !result.circle) {
@@ -714,8 +804,14 @@ export function cubicBezierToArc(p0, p1, p2, p3, tolerance = DEFAULT_TOLERANCE)
  * @returns {Decimal | null} Sagitta value, or null if chord > diameter
  */
 export function calculateSagitta(radius, chordLength) {
+  if (radius === null || radius === undefined) throw new Error('calculateSagitta: radius parameter is null or undefined');
+  if (chordLength === null || chordLength === undefined) throw new Error('calculateSagitta: chordLength parameter is null or undefined');
   const r = D(radius);
   const c = D(chordLength);
+  if (!r.isFinite()) throw new Error('calculateSagitta: radius must be finite');
+  if (!c.isFinite()) throw new Error('calculateSagitta: chordLength must be finite');
+  if (r.lessThan(0)) throw new Error('calculateSagitta: radius must be non-negative');
+  if (c.lessThan(0)) throw new Error('calculateSagitta: chordLength must be non-negative');
   const halfChord = c.div(2);
 
   // Check if chord is valid (must be <= 2*r)
@@ -748,9 +844,23 @@ export function calculateSagitta(radius, chordLength) {
  * @returns {{isStraight: boolean, sagitta: Decimal | null, maxDeviation: Decimal, verified: boolean}}
  */
 export function isArcStraight(rx, ry, rotation, largeArc, sweep, start, end, tolerance = DEFAULT_TOLERANCE) {
+  if (rx === null || rx === undefined) throw new Error('isArcStraight: rx parameter is null or undefined');
+  if (ry === null || ry === undefined) throw new Error('isArcStraight: ry parameter is null or undefined');
+  if (rotation === null || rotation === undefined) throw new Error('isArcStraight: rotation parameter is null or undefined');
+  if (largeArc === null || largeArc === undefined) throw new Error('isArcStraight: largeArc parameter is null or undefined');
+  if (sweep === null || sweep === undefined) throw new Error('isArcStraight: sweep parameter is null or undefined');
+  if (!start || !end) throw new Error('isArcStraight: start and end points cannot be null or undefined');
+  if (!(start.x instanceof Decimal) || !(start.y instanceof Decimal)) throw new Error('isArcStraight: start must have Decimal x and y properties');
+  if (!(end.x instanceof Decimal) || !(end.y instanceof Decimal)) throw new Error('isArcStraight: end must have Decimal x and y properties');
+  if (tolerance === null || tolerance === undefined) throw new Error('isArcStraight: tolerance parameter is null or undefined');
+  if (largeArc !== 0 && largeArc !== 1) throw new Error('isArcStraight: largeArc must be 0 or 1');
+  if (sweep !== 0 && sweep !== 1) throw new Error('isArcStraight: sweep must be 0 or 1');
   const tol = D(tolerance);
+  if (!tol.isFinite() || tol.lessThan(0)) throw new Error('isArcStraight: tolerance must be a non-negative finite number');
   const rxD = D(rx);
   const ryD = D(ry);
+  if (!rxD.isFinite()) throw new Error('isArcStraight: rx must be finite');
+  if (!ryD.isFinite()) throw new Error('isArcStraight: ry must be finite');
 
   // Check for zero or near-zero radii
   if (rxD.abs().lessThan(EPSILON) || ryD.abs().lessThan(EPSILON)) {
@@ -814,7 +924,13 @@ export function isArcStraight(rx, ry, rotation, largeArc, sweep, start, end, tol
  * @returns {boolean} True if collinear
  */
 export function areCollinear(p1, p2, p3, tolerance = DEFAULT_TOLERANCE) {
+  if (!p1 || !p2 || !p3) throw new Error('areCollinear: points cannot be null or undefined');
+  if (!(p1.x instanceof Decimal) || !(p1.y instanceof Decimal)) throw new Error('areCollinear: p1 must have Decimal x and y properties');
+  if (!(p2.x instanceof Decimal) || !(p2.y instanceof Decimal)) throw new Error('areCollinear: p2 must have Decimal x and y properties');
+  if (!(p3.x instanceof Decimal) || !(p3.y instanceof Decimal)) throw new Error('areCollinear: p3 must have Decimal x and y properties');
+  if (tolerance === null || tolerance === undefined) throw new Error('areCollinear: tolerance parameter is null or undefined');
   const tol = D(tolerance);
+  if (!tol.isFinite() || tol.lessThan(0)) throw new Error('areCollinear: tolerance must be a non-negative finite number');
 
   // Check using cross product (area of triangle)
   const cross = crossProduct(p1, p2, p3).abs();
@@ -838,11 +954,26 @@ export function areCollinear(p1, p2, p3, tolerance = DEFAULT_TOLERANCE) {
  * @returns {{points: Array<{x: Decimal, y: Decimal}>, mergeCount: number, verified: boolean}}
  */
 export function mergeCollinearSegments(points, tolerance = DEFAULT_TOLERANCE) {
+  if (!points) throw new Error('mergeCollinearSegments: points array cannot be null or undefined');
+  if (!Array.isArray(points)) throw new Error('mergeCollinearSegments: points must be an array');
+  if (points.length === 0) throw new Error('mergeCollinearSegments: points array cannot be empty');
+  if (tolerance === null || tolerance === undefined) throw new Error('mergeCollinearSegments: tolerance parameter is null or undefined');
+
+  // Validate all points have Decimal x and y properties
+  for (let i = 0; i < points.length; i++) {
+    const p = points[i];
+    if (!p) throw new Error(`mergeCollinearSegments: point at index ${i} is null or undefined`);
+    if (!(p.x instanceof Decimal) || !(p.y instanceof Decimal)) {
+      throw new Error(`mergeCollinearSegments: point at index ${i} must have Decimal x and y properties`);
+    }
+  }
+
   if (points.length < 3) {
     return { points: [...points], mergeCount: 0, verified: true };
   }
 
   const tol = D(tolerance);
+  if (!tol.isFinite() || tol.lessThan(0)) throw new Error('mergeCollinearSegments: tolerance must be a non-negative finite number');
   const result = [points[0]];
   let mergeCount = 0;
 
@@ -904,7 +1035,13 @@ export function mergeCollinearSegments(points, tolerance = DEFAULT_TOLERANCE) {
  * @returns {boolean} True if zero-length
  */
 export function isZeroLengthSegment(start, end, tolerance = EPSILON) {
-  return distance(start, end).lessThan(D(tolerance));
+  if (!start || !end) throw new Error('isZeroLengthSegment: points cannot be null or undefined');
+  if (!(start.x instanceof Decimal) || !(start.y instanceof Decimal)) throw new Error('isZeroLengthSegment: start must have Decimal x and y properties');
+  if (!(end.x instanceof Decimal) || !(end.y instanceof Decimal)) throw new Error('isZeroLengthSegment: end must have Decimal x and y properties');
+  if (tolerance === null || tolerance === undefined) throw new Error('isZeroLengthSegment: tolerance parameter is null or undefined');
+  const tol = D(tolerance);
+  if (!tol.isFinite() || tol.lessThan(0)) throw new Error('isZeroLengthSegment: tolerance must be a non-negative finite number');
+  return distance(start, end).lessThan(tol);
 }
 
 /**
@@ -915,19 +1052,30 @@ export function isZeroLengthSegment(start, end, tolerance = EPSILON) {
  * @returns {{pathData: Array<{command: string, args: Array<Decimal>}>, removeCount: number, verified: boolean}}
  */
 export function removeZeroLengthSegments(pathData, tolerance = EPSILON) {
+  if (!pathData) throw new Error('removeZeroLengthSegments: pathData cannot be null or undefined');
+  if (!Array.isArray(pathData)) throw new Error('removeZeroLengthSegments: pathData must be an array');
+  if (tolerance === null || tolerance === undefined) throw new Error('removeZeroLengthSegments: tolerance parameter is null or undefined');
+
   const tol = D(tolerance);
+  if (!tol.isFinite() || tol.lessThan(0)) throw new Error('removeZeroLengthSegments: tolerance must be a non-negative finite number');
   const result = [];
   let removeCount = 0;
   let currentX = D(0), currentY = D(0);
   let startX = D(0), startY = D(0);
 
-  for (const item of pathData) {
+  for (let idx = 0; idx < pathData.length; idx++) {
+    const item = pathData[idx];
+    if (!item) throw new Error(`removeZeroLengthSegments: item at index ${idx} is null or undefined`);
+    if (typeof item.command !== 'string') throw new Error(`removeZeroLengthSegments: item at index ${idx} must have a string command property`);
+    if (!Array.isArray(item.args)) throw new Error(`removeZeroLengthSegments: item at index ${idx} must have an args array property`);
+
     const { command, args } = item;
     let keep = true;
 
     switch (command.toUpperCase()) {
       case 'M':
         // Update current position (absolute M) or move relative (lowercase m)
+        if (args.length < 2) throw new Error(`removeZeroLengthSegments: M command at index ${idx} requires 2 args, got ${args.length}`);
         currentX = command === 'M' ? D(args[0]) : currentX.plus(D(args[0]));
         currentY = command === 'M' ? D(args[1]) : currentY.plus(D(args[1]));
         // CRITICAL: Update subpath start for EVERY M command (BUG 3 FIX)
@@ -937,6 +1085,7 @@ export function removeZeroLengthSegments(pathData, tolerance = EPSILON) {
 
       case 'L': {
         // Line to: x y (2 args)
+        if (args.length < 2) throw new Error(`removeZeroLengthSegments: L command at index ${idx} requires 2 args, got ${args.length}`);
         const endX = command === 'L' ? D(args[0]) : currentX.plus(D(args[0]));
         const endY = command === 'L' ? D(args[1]) : currentY.plus(D(args[1]));
         if (isZeroLengthSegment({ x: currentX, y: currentY }, { x: endX, y: endY }, tol)) {
@@ -951,6 +1100,7 @@ export function removeZeroLengthSegments(pathData, tolerance = EPSILON) {
 
       case 'T': {
         // Smooth quadratic Bezier: x y (2 args) - BUG 4 FIX (separated from L)
+        if (args.length < 2) throw new Error(`removeZeroLengthSegments: T command at index ${idx} requires 2 args, got ${args.length}`);
         const endX = command === 'T' ? D(args[0]) : currentX.plus(D(args[0]));
         const endY = command === 'T' ? D(args[1]) : currentY.plus(D(args[1]));
         if (isZeroLengthSegment({ x: currentX, y: currentY }, { x: endX, y: endY }, tol)) {
@@ -964,28 +1114,31 @@ export function removeZeroLengthSegments(pathData, tolerance = EPSILON) {
       }
 
       case 'H': {
+        if (args.length < 1) throw new Error(`removeZeroLengthSegments: H command at index ${idx} requires 1 arg, got ${args.length}`);
         const endX = command === 'H' ? D(args[0]) : currentX.plus(D(args[0]));
         if (endX.minus(currentX).abs().lessThan(tol)) {
           keep = false;
           removeCount++;
-        } else {
-          currentX = endX;
         }
+        // CRITICAL: Always update position, even when removing segment (consistency with L command)
+        currentX = endX;
         break;
       }
 
       case 'V': {
+        if (args.length < 1) throw new Error(`removeZeroLengthSegments: V command at index ${idx} requires 1 arg, got ${args.length}`);
         const endY = command === 'V' ? D(args[0]) : currentY.plus(D(args[0]));
         if (endY.minus(currentY).abs().lessThan(tol)) {
           keep = false;
           removeCount++;
-        } else {
-          currentY = endY;
         }
+        // CRITICAL: Always update position, even when removing segment (consistency with L command)
+        currentY = endY;
         break;
       }
 
       case 'C': {
+        if (args.length < 6) throw new Error(`removeZeroLengthSegments: C command at index ${idx} requires 6 args, got ${args.length}`);
         const endX = command === 'C' ? D(args[4]) : currentX.plus(D(args[4]));
         const endY = command === 'C' ? D(args[5]) : currentY.plus(D(args[5]));
         // For curves, also check if all control points are at the same location
@@ -1002,15 +1155,16 @@ export function removeZeroLengthSegments(pathData, tolerance = EPSILON) {
         if (allSame) {
           keep = false;
           removeCount++;
-        } else {
-          currentX = endX;
-          currentY = endY;
         }
+        // CRITICAL: Always update position, even when removing segment (consistency with L command)
+        currentX = endX;
+        currentY = endY;
         break;
       }
 
       case 'Q': {
         // Quadratic Bezier: x1 y1 x y (4 args)
+        if (args.length < 4) throw new Error(`removeZeroLengthSegments: Q command at index ${idx} requires 4 args, got ${args.length}`);
         const endX = command === 'Q' ? D(args[2]) : currentX.plus(D(args[2]));
         const endY = command === 'Q' ? D(args[3]) : currentY.plus(D(args[3]));
         if (isZeroLengthSegment({ x: currentX, y: currentY }, { x: endX, y: endY }, tol)) {
@@ -1022,15 +1176,15 @@ export function removeZeroLengthSegments(pathData, tolerance = EPSILON) {
             removeCount++;
           }
         }
-        if (keep) {
-          currentX = endX;
-          currentY = endY;
-        }
+        // CRITICAL: Always update position, even when removing segment (consistency with L command)
+        currentX = endX;
+        currentY = endY;
         break;
       }
 
       case 'S': {
         // Smooth cubic Bezier: x2 y2 x y (4 args) - BUG 4 FIX
+        if (args.length < 4) throw new Error(`removeZeroLengthSegments: S command at index ${idx} requires 4 args, got ${args.length}`);
         const endX = command === 'S' ? D(args[2]) : currentX.plus(D(args[2]));
         const endY = command === 'S' ? D(args[3]) : currentY.plus(D(args[3]));
         if (isZeroLengthSegment({ x: currentX, y: currentY }, { x: endX, y: endY }, tol)) {
@@ -1042,23 +1196,23 @@ export function removeZeroLengthSegments(pathData, tolerance = EPSILON) {
             removeCount++;
           }
         }
-        if (keep) {
-          currentX = endX;
-          currentY = endY;
-        }
+        // CRITICAL: Always update position, even when removing segment (consistency with L command)
+        currentX = endX;
+        currentY = endY;
         break;
       }
 
       case 'A': {
+        if (args.length < 7) throw new Error(`removeZeroLengthSegments: A command at index ${idx} requires 7 args, got ${args.length}`);
         const endX = command === 'A' ? D(args[5]) : currentX.plus(D(args[5]));
         const endY = command === 'A' ? D(args[6]) : currentY.plus(D(args[6]));
         if (isZeroLengthSegment({ x: currentX, y: currentY }, { x: endX, y: endY }, tol)) {
           keep = false;
           removeCount++;
-        } else {
-          currentX = endX;
-          currentY = endY;
         }
+        // CRITICAL: Always update position, even when removing segment (consistency with L command)
+        currentX = endX;
+        currentY = endY;
         break;
       }
 
@@ -1070,6 +1224,8 @@ export function removeZeroLengthSegments(pathData, tolerance = EPSILON) {
         currentX = startX;
         currentY = startY;
         break;
+      default:
+        break;
     }
 
     if (keep) {