@emasoft/svg-matrix 1.1.0 → 1.2.0

package/src/douglas-peucker.js

@@ -19,21 +19,42 @@
  */
 export function perpendicularDistance(point, lineStart, lineEnd) {
   // Validate parameters to prevent undefined access and ensure numeric properties
-  if (!point || typeof point.x !== 'number' || typeof point.y !== 'number') {
-    throw new TypeError('perpendicularDistance: point must be an object with numeric x and y properties');
-  }
-  if (!lineStart || typeof lineStart.x !== 'number' || typeof lineStart.y !== 'number') {
-    throw new TypeError('perpendicularDistance: lineStart must be an object with numeric x and y properties');
-  }
-  if (!lineEnd || typeof lineEnd.x !== 'number' || typeof lineEnd.y !== 'number') {
-    throw new TypeError('perpendicularDistance: lineEnd must be an object with numeric x and y properties');
+  if (!point || typeof point.x !== "number" || typeof point.y !== "number") {
+    throw new TypeError(
+      "perpendicularDistance: point must be an object with numeric x and y properties",
+    );
+  }
+  if (
+    !lineStart ||
+    typeof lineStart.x !== "number" ||
+    typeof lineStart.y !== "number"
+  ) {
+    throw new TypeError(
+      "perpendicularDistance: lineStart must be an object with numeric x and y properties",
+    );
+  }
+  if (
+    !lineEnd ||
+    typeof lineEnd.x !== "number" ||
+    typeof lineEnd.y !== "number"
+  ) {
+    throw new TypeError(
+      "perpendicularDistance: lineEnd must be an object with numeric x and y properties",
+    );
   }
 
   // Check for NaN/Infinity in coordinates to prevent invalid calculations
-  if (!Number.isFinite(point.x) || !Number.isFinite(point.y) ||
-      !Number.isFinite(lineStart.x) || !Number.isFinite(lineStart.y) ||
-      !Number.isFinite(lineEnd.x) || !Number.isFinite(lineEnd.y)) {
-    throw new RangeError('perpendicularDistance: all coordinates must be finite numbers');
+  if (
+    !Number.isFinite(point.x) ||
+    !Number.isFinite(point.y) ||
+    !Number.isFinite(lineStart.x) ||
+    !Number.isFinite(lineStart.y) ||
+    !Number.isFinite(lineEnd.x) ||
+    !Number.isFinite(lineEnd.y)
+  ) {
+    throw new RangeError(
+      "perpendicularDistance: all coordinates must be finite numbers",
+    );
   }
 
   const dx = lineEnd.x - lineStart.x;
@@ -50,7 +71,10 @@ export function perpendicularDistance(point, lineStart, lineEnd) {
   // Calculate perpendicular distance using cross product formula
   // |((y2-y1)*x0 - (x2-x1)*y0 + x2*y1 - y2*x1)| / sqrt((y2-y1)^2 + (x2-x1)^2)
   const numerator = Math.abs(
-    dy * point.x - dx * point.y + lineEnd.x * lineStart.y - lineEnd.y * lineStart.x
+    dy * point.x -
+      dx * point.y +
+      lineEnd.x * lineStart.y -
+      lineEnd.y * lineStart.x,
   );
   const denominator = Math.sqrt(lineLengthSq);
 
@@ -66,36 +90,44 @@ export function perpendicularDistance(point, lineStart, lineEnd) {
 export function douglasPeucker(points, tolerance) {
   // Validate points parameter to prevent crashes on invalid input
   if (!Array.isArray(points)) {
-    throw new TypeError('douglasPeucker: points must be an array');
+    throw new TypeError("douglasPeucker: points must be an array");
   }
   if (points.length === 0) {
-    throw new RangeError('douglasPeucker: points array cannot be empty');
+    throw new RangeError("douglasPeucker: points array cannot be empty");
   }
 
   // Validate each point has x and y properties with finite numeric values
   for (let i = 0; i < points.length; i++) {
     const p = points[i];
-    if (!p || typeof p !== 'object') {
-      throw new TypeError(`douglasPeucker: point at index ${i} must be an object`);
+    if (!p || typeof p !== "object") {
+      throw new TypeError(
+        `douglasPeucker: point at index ${i} must be an object`,
+      );
     }
-    if (typeof p.x !== 'number' || !Number.isFinite(p.x)) {
-      throw new TypeError(`douglasPeucker: point at index ${i} must have a finite numeric x property`);
+    if (typeof p.x !== "number" || !Number.isFinite(p.x)) {
+      throw new TypeError(
+        `douglasPeucker: point at index ${i} must have a finite numeric x property`,
+      );
     }
-    if (typeof p.y !== 'number' || !Number.isFinite(p.y)) {
-      throw new TypeError(`douglasPeucker: point at index ${i} must have a finite numeric y property`);
+    if (typeof p.y !== "number" || !Number.isFinite(p.y)) {
+      throw new TypeError(
+        `douglasPeucker: point at index ${i} must have a finite numeric y property`,
+      );
     }
   }
 
   // Validate tolerance parameter to ensure valid numeric simplification threshold
-  if (typeof tolerance !== 'number' || !Number.isFinite(tolerance)) {
-    throw new TypeError('douglasPeucker: tolerance must be a finite number');
+  if (typeof tolerance !== "number" || !Number.isFinite(tolerance)) {
+    throw new TypeError("douglasPeucker: tolerance must be a finite number");
   }
   if (tolerance < 0) {
-    throw new RangeError('douglasPeucker: tolerance cannot be negative');
+    throw new RangeError("douglasPeucker: tolerance cannot be negative");
   }
   // Prevent impractically small tolerances that cause numerical precision issues and extreme recursion depth
   if (tolerance > 0 && tolerance < 1e-10) {
-    throw new RangeError('douglasPeucker: tolerance must be either 0 or >= 1e-10 to avoid numerical precision issues');
+    throw new RangeError(
+      "douglasPeucker: tolerance must be either 0 or >= 1e-10 to avoid numerical precision issues",
+    );
   }
 
   if (points.length <= 2) {
@@ -192,32 +224,38 @@ function douglasPeuckerIterative(points, tolerance) {
 export function visvalingamWhyatt(points, minArea) {
   // Validate points parameter to prevent crashes on invalid input
   if (!Array.isArray(points)) {
-    throw new TypeError('visvalingamWhyatt: points must be an array');
+    throw new TypeError("visvalingamWhyatt: points must be an array");
   }
   if (points.length === 0) {
-    throw new RangeError('visvalingamWhyatt: points array cannot be empty');
+    throw new RangeError("visvalingamWhyatt: points array cannot be empty");
   }
 
   // Validate each point has x and y properties with finite numeric values
   for (let i = 0; i < points.length; i++) {
     const p = points[i];
-    if (!p || typeof p !== 'object') {
-      throw new TypeError(`visvalingamWhyatt: point at index ${i} must be an object`);
+    if (!p || typeof p !== "object") {
+      throw new TypeError(
+        `visvalingamWhyatt: point at index ${i} must be an object`,
+      );
     }
-    if (typeof p.x !== 'number' || !Number.isFinite(p.x)) {
-      throw new TypeError(`visvalingamWhyatt: point at index ${i} must have a finite numeric x property`);
+    if (typeof p.x !== "number" || !Number.isFinite(p.x)) {
+      throw new TypeError(
+        `visvalingamWhyatt: point at index ${i} must have a finite numeric x property`,
+      );
     }
-    if (typeof p.y !== 'number' || !Number.isFinite(p.y)) {
-      throw new TypeError(`visvalingamWhyatt: point at index ${i} must have a finite numeric y property`);
+    if (typeof p.y !== "number" || !Number.isFinite(p.y)) {
+      throw new TypeError(
+        `visvalingamWhyatt: point at index ${i} must have a finite numeric y property`,
+      );
     }
   }
 
   // Validate minArea parameter to ensure valid numeric threshold
-  if (typeof minArea !== 'number' || !Number.isFinite(minArea)) {
-    throw new TypeError('visvalingamWhyatt: minArea must be a finite number');
+  if (typeof minArea !== "number" || !Number.isFinite(minArea)) {
+    throw new TypeError("visvalingamWhyatt: minArea must be a finite number");
   }
   if (minArea < 0) {
-    throw new RangeError('visvalingamWhyatt: minArea cannot be negative');
+    throw new RangeError("visvalingamWhyatt: minArea cannot be negative");
   }
 
   if (points.length <= 2) {
@@ -226,9 +264,10 @@ export function visvalingamWhyatt(points, minArea) {
 
   // Calculate triangle area for three points
   const triangleArea = (p1, p2, p3) => {
-    return Math.abs(
-      (p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y)
-    ) / 2;
+    return (
+      Math.abs((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y)) /
+      2
+    );
   };
 
   // Create a copy with area information
@@ -276,15 +315,24 @@ export function visvalingamWhyatt(points, minArea) {
       let prevPrevIndex = prevIndex - 1;
       while (prevPrevIndex >= 0 && !kept[prevPrevIndex]) prevPrevIndex--;
       if (prevPrevIndex >= 0 && nextIndex < pts.length) {
-        areas[prevIndex] = triangleArea(pts[prevPrevIndex], pts[prevIndex], pts[nextIndex]);
+        areas[prevIndex] = triangleArea(
+          pts[prevPrevIndex],
+          pts[prevIndex],
+          pts[nextIndex],
+        );
       }
     }
 
     if (nextIndex < pts.length - 1) {
       let nextNextIndex = nextIndex + 1;
-      while (nextNextIndex < pts.length && !kept[nextNextIndex]) nextNextIndex++;
+      while (nextNextIndex < pts.length && !kept[nextNextIndex])
+        nextNextIndex++;
       if (nextNextIndex < pts.length && prevIndex >= 0) {
-        areas[nextIndex] = triangleArea(pts[prevIndex], pts[nextIndex], pts[nextNextIndex]);
+        areas[nextIndex] = triangleArea(
+          pts[prevIndex],
+          pts[nextIndex],
+          pts[nextNextIndex],
+        );
       }
     }
   }
@@ -300,37 +348,45 @@ export function visvalingamWhyatt(points, minArea) {
  * @param {'douglas-peucker' | 'visvalingam'} algorithm - Algorithm to use
  * @returns {Array<{x: number, y: number}>} Simplified points
  */
-export function simplifyPolyline(points, tolerance, algorithm = 'douglas-peucker') {
+export function simplifyPolyline(
+  points,
+  tolerance,
+  algorithm = "douglas-peucker",
+) {
   // Validate points parameter to prevent crashes on invalid input
   if (!Array.isArray(points)) {
-    throw new TypeError('simplifyPolyline: points must be an array');
+    throw new TypeError("simplifyPolyline: points must be an array");
   }
   if (points.length === 0) {
-    throw new RangeError('simplifyPolyline: points array cannot be empty');
+    throw new RangeError("simplifyPolyline: points array cannot be empty");
   }
 
   // Validate tolerance parameter to ensure valid numeric threshold
-  if (typeof tolerance !== 'number' || !Number.isFinite(tolerance)) {
-    throw new TypeError('simplifyPolyline: tolerance must be a finite number');
+  if (typeof tolerance !== "number" || !Number.isFinite(tolerance)) {
+    throw new TypeError("simplifyPolyline: tolerance must be a finite number");
   }
   if (tolerance < 0) {
-    throw new RangeError('simplifyPolyline: tolerance cannot be negative');
+    throw new RangeError("simplifyPolyline: tolerance cannot be negative");
   }
   // Prevent impractically small tolerances that cause numerical precision issues
   if (tolerance > 0 && tolerance < 1e-10) {
-    throw new RangeError('simplifyPolyline: tolerance must be either 0 or >= 1e-10 to avoid numerical precision issues');
+    throw new RangeError(
+      "simplifyPolyline: tolerance must be either 0 or >= 1e-10 to avoid numerical precision issues",
+    );
   }
 
   // Validate algorithm parameter to ensure only valid algorithms are used
-  if (typeof algorithm !== 'string') {
-    throw new TypeError('simplifyPolyline: algorithm must be a string');
+  if (typeof algorithm !== "string") {
+    throw new TypeError("simplifyPolyline: algorithm must be a string");
   }
-  const validAlgorithms = ['douglas-peucker', 'visvalingam'];
+  const validAlgorithms = ["douglas-peucker", "visvalingam"];
   if (!validAlgorithms.includes(algorithm)) {
-    throw new RangeError(`simplifyPolyline: algorithm must be one of: ${validAlgorithms.join(', ')}`);
+    throw new RangeError(
+      `simplifyPolyline: algorithm must be one of: ${validAlgorithms.join(", ")}`,
+    );
   }
 
-  if (algorithm === 'visvalingam') {
+  if (algorithm === "visvalingam") {
     // For Visvalingam, tolerance is the minimum triangle area
     return visvalingamWhyatt(points, tolerance * tolerance);
   }
@@ -345,23 +401,31 @@ export function simplifyPolyline(points, tolerance, algorithm = 'douglas-peucker
 export function extractPolylinePoints(commands) {
   // Validate commands parameter to prevent crashes on invalid input
   if (!Array.isArray(commands)) {
-    throw new TypeError('extractPolylinePoints: commands must be an array');
+    throw new TypeError("extractPolylinePoints: commands must be an array");
   }
 
   const points = [];
-  let cx = 0, cy = 0;
-  let startX = 0, startY = 0;
+  let cx = 0,
+    cy = 0;
+  let startX = 0,
+    startY = 0;
 
   for (const cmd of commands) {
     // Validate each command object to prevent undefined access
-    if (!cmd || typeof cmd !== 'object') {
-      throw new TypeError('extractPolylinePoints: each command must be an object');
+    if (!cmd || typeof cmd !== "object") {
+      throw new TypeError(
+        "extractPolylinePoints: each command must be an object",
+      );
     }
-    if (typeof cmd.command !== 'string') {
-      throw new TypeError('extractPolylinePoints: each command must have a string "command" property');
+    if (typeof cmd.command !== "string") {
+      throw new TypeError(
+        'extractPolylinePoints: each command must have a string "command" property',
+      );
     }
     if (!Array.isArray(cmd.args)) {
-      throw new TypeError('extractPolylinePoints: each command must have an "args" array');
+      throw new TypeError(
+        'extractPolylinePoints: each command must have an "args" array',
+      );
     }
 
     const { command, args } = cmd;
@@ -369,108 +433,149 @@ export function extractPolylinePoints(commands) {
     // Helper to validate args length to prevent out-of-bounds access
     const requireArgs = (count) => {
       if (args.length < count) {
-        throw new RangeError(`extractPolylinePoints: command "${command}" requires at least ${count} arguments, got ${args.length}`);
+        throw new RangeError(
+          `extractPolylinePoints: command "${command}" requires at least ${count} arguments, got ${args.length}`,
+        );
       }
     };
 
     // Helper to validate arg is a finite number to prevent NaN/Infinity in calculations
     const requireFiniteNumber = (index) => {
-      if (typeof args[index] !== 'number' || !Number.isFinite(args[index])) {
-        throw new TypeError(`extractPolylinePoints: command "${command}" argument at index ${index} must be a finite number, got ${args[index]}`);
+      if (typeof args[index] !== "number" || !Number.isFinite(args[index])) {
+        throw new TypeError(
+          `extractPolylinePoints: command "${command}" argument at index ${index} must be a finite number, got ${args[index]}`,
+        );
       }
     };
 
     switch (command) {
-      case 'M':
+      case "M":
         requireArgs(2);
-        requireFiniteNumber(0); requireFiniteNumber(1);
-        cx = args[0]; cy = args[1];
-        startX = cx; startY = cy;
+        requireFiniteNumber(0);
+        requireFiniteNumber(1);
+        cx = args[0];
+        cy = args[1];
+        startX = cx;
+        startY = cy;
         points.push({ x: cx, y: cy });
         break;
-      case 'm':
+      case "m":
         requireArgs(2);
-        requireFiniteNumber(0); requireFiniteNumber(1);
-        cx += args[0]; cy += args[1];
-        startX = cx; startY = cy;
+        requireFiniteNumber(0);
+        requireFiniteNumber(1);
+        cx += args[0];
+        cy += args[1];
+        startX = cx;
+        startY = cy;
         points.push({ x: cx, y: cy });
         break;
-      case 'L':
+      case "L":
         requireArgs(2);
-        requireFiniteNumber(0); requireFiniteNumber(1);
-        cx = args[0]; cy = args[1];
+        requireFiniteNumber(0);
+        requireFiniteNumber(1);
+        cx = args[0];
+        cy = args[1];
         points.push({ x: cx, y: cy });
         break;
-      case 'l':
+      case "l":
         requireArgs(2);
-        requireFiniteNumber(0); requireFiniteNumber(1);
-        cx += args[0]; cy += args[1];
+        requireFiniteNumber(0);
+        requireFiniteNumber(1);
+        cx += args[0];
+        cy += args[1];
         points.push({ x: cx, y: cy });
         break;
-      case 'H':
+      case "H":
         requireArgs(1);
         requireFiniteNumber(0);
         cx = args[0];
         points.push({ x: cx, y: cy });
         break;
-      case 'h':
+      case "h":
         requireArgs(1);
         requireFiniteNumber(0);
         cx += args[0];
         points.push({ x: cx, y: cy });
         break;
-      case 'V':
+      case "V":
         requireArgs(1);
         requireFiniteNumber(0);
         cy = args[0];
         points.push({ x: cx, y: cy });
         break;
-      case 'v':
+      case "v":
         requireArgs(1);
         requireFiniteNumber(0);
         cy += args[0];
         points.push({ x: cx, y: cy });
         break;
-      case 'Z':
-      case 'z':
+      case "Z":
+      case "z":
         if (cx !== startX || cy !== startY) {
           points.push({ x: startX, y: startY });
         }
-        cx = startX; cy = startY;
+        cx = startX;
+        cy = startY;
         break;
       // For curves (C, S, Q, T, A), we just track the endpoint
-      case 'C':
+      case "C":
         requireArgs(6);
-        requireFiniteNumber(4); requireFiniteNumber(5);
-        cx = args[4]; cy = args[5]; break;
-      case 'c':
+        requireFiniteNumber(4);
+        requireFiniteNumber(5);
+        cx = args[4];
+        cy = args[5];
+        break;
+      case "c":
         requireArgs(6);
-        requireFiniteNumber(4); requireFiniteNumber(5);
-        cx += args[4]; cy += args[5]; break;
-      case 'S': case 'Q':
+        requireFiniteNumber(4);
+        requireFiniteNumber(5);
+        cx += args[4];
+        cy += args[5];
+        break;
+      case "S":
+      case "Q":
         requireArgs(4);
-        requireFiniteNumber(2); requireFiniteNumber(3);
-        cx = args[2]; cy = args[3]; break;
-      case 's': case 'q':
+        requireFiniteNumber(2);
+        requireFiniteNumber(3);
+        cx = args[2];
+        cy = args[3];
+        break;
+      case "s":
+      case "q":
         requireArgs(4);
-        requireFiniteNumber(2); requireFiniteNumber(3);
-        cx += args[2]; cy += args[3]; break;
-      case 'T':
+        requireFiniteNumber(2);
+        requireFiniteNumber(3);
+        cx += args[2];
+        cy += args[3];
+        break;
+      case "T":
         requireArgs(2);
-        requireFiniteNumber(0); requireFiniteNumber(1);
-        cx = args[0]; cy = args[1]; break;
-      case 't':
+        requireFiniteNumber(0);
+        requireFiniteNumber(1);
+        cx = args[0];
+        cy = args[1];
+        break;
+      case "t":
         requireArgs(2);
-        requireFiniteNumber(0); requireFiniteNumber(1);
-        cx += args[0]; cy += args[1]; break;
-      case 'A':
+        requireFiniteNumber(0);
+        requireFiniteNumber(1);
+        cx += args[0];
+        cy += args[1];
+        break;
+      case "A":
         requireArgs(7);
-        requireFiniteNumber(5); requireFiniteNumber(6);
-        cx = args[5]; cy = args[6]; break;
-      case 'a':
+        requireFiniteNumber(5);
+        requireFiniteNumber(6);
+        cx = args[5];
+        cy = args[6];
+        break;
+      case "a":
         requireArgs(7);
-        requireFiniteNumber(5); requireFiniteNumber(6);
-        cx += args[5]; cy += args[6]; break;
+        requireFiniteNumber(5);
+        requireFiniteNumber(6);
+        cx += args[5];
+        cy += args[6];
+        break;
       default:
         break;
     }
@@ -488,42 +593,48 @@ export function extractPolylinePoints(commands) {
 export function rebuildPathFromPoints(points, closed = false) {
   // Validate points parameter to prevent crashes on invalid input
   if (!Array.isArray(points)) {
-    throw new TypeError('rebuildPathFromPoints: points must be an array');
+    throw new TypeError("rebuildPathFromPoints: points must be an array");
   }
 
   if (points.length === 0) return [];
 
   // Validate closed parameter to ensure boolean type
-  if (typeof closed !== 'boolean') {
-    throw new TypeError('rebuildPathFromPoints: closed must be a boolean');
+  if (typeof closed !== "boolean") {
+    throw new TypeError("rebuildPathFromPoints: closed must be a boolean");
   }
 
   // Validate each point has x and y properties with finite numeric values
   for (let i = 0; i < points.length; i++) {
     const p = points[i];
-    if (!p || typeof p !== 'object') {
-      throw new TypeError(`rebuildPathFromPoints: point at index ${i} must be an object`);
+    if (!p || typeof p !== "object") {
+      throw new TypeError(
+        `rebuildPathFromPoints: point at index ${i} must be an object`,
+      );
     }
-    if (typeof p.x !== 'number' || !Number.isFinite(p.x)) {
-      throw new TypeError(`rebuildPathFromPoints: point at index ${i} must have a finite numeric x property`);
+    if (typeof p.x !== "number" || !Number.isFinite(p.x)) {
+      throw new TypeError(
+        `rebuildPathFromPoints: point at index ${i} must have a finite numeric x property`,
+      );
     }
-    if (typeof p.y !== 'number' || !Number.isFinite(p.y)) {
-      throw new TypeError(`rebuildPathFromPoints: point at index ${i} must have a finite numeric y property`);
+    if (typeof p.y !== "number" || !Number.isFinite(p.y)) {
+      throw new TypeError(
+        `rebuildPathFromPoints: point at index ${i} must have a finite numeric y property`,
+      );
     }
   }
 
   const commands = [];
 
   // First point is M
-  commands.push({ command: 'M', args: [points[0].x, points[0].y] });
+  commands.push({ command: "M", args: [points[0].x, points[0].y] });
 
   // Remaining points are L
   for (let i = 1; i < points.length; i++) {
-    commands.push({ command: 'L', args: [points[i].x, points[i].y] });
+    commands.push({ command: "L", args: [points[i].x, points[i].y] });
   }
 
   if (closed) {
-    commands.push({ command: 'Z', args: [] });
+    commands.push({ command: "Z", args: [] });
   }
 
   return commands;
@@ -537,13 +648,24 @@ export function rebuildPathFromPoints(points, closed = false) {
 export function isPurePolyline(commands) {
   // Validate commands parameter to prevent crashes on invalid input
   if (!Array.isArray(commands)) {
-    throw new TypeError('isPurePolyline: commands must be an array');
-  }
-
-  const polylineCommands = new Set(['M', 'm', 'L', 'l', 'H', 'h', 'V', 'v', 'Z', 'z']);
-  return commands.every(cmd => {
+    throw new TypeError("isPurePolyline: commands must be an array");
+  }
+
+  const polylineCommands = new Set([
+    "M",
+    "m",
+    "L",
+    "l",
+    "H",
+    "h",
+    "V",
+    "v",
+    "Z",
+    "z",
+  ]);
+  return commands.every((cmd) => {
     // Validate each command has the required structure to prevent undefined access
-    if (!cmd || typeof cmd !== 'object' || typeof cmd.command !== 'string') {
+    if (!cmd || typeof cmd !== "object" || typeof cmd.command !== "string") {
       return false;
     }
     return polylineCommands.has(cmd.command);
@@ -557,22 +679,28 @@ export function isPurePolyline(commands) {
  * @param {string} algorithm - Algorithm to use
  * @returns {{commands: Array<{command: string, args: number[]}>, simplified: boolean, originalPoints: number, simplifiedPoints: number}}
  */
-export function simplifyPath(commands, tolerance, algorithm = 'douglas-peucker') {
+export function simplifyPath(
+  commands,
+  tolerance,
+  algorithm = "douglas-peucker",
+) {
   // Validate commands parameter to prevent crashes on invalid input
   if (!Array.isArray(commands)) {
-    throw new TypeError('simplifyPath: commands must be an array');
+    throw new TypeError("simplifyPath: commands must be an array");
   }
 
   // Validate tolerance parameter to ensure valid numeric threshold
-  if (typeof tolerance !== 'number' || !Number.isFinite(tolerance)) {
-    throw new TypeError('simplifyPath: tolerance must be a finite number');
+  if (typeof tolerance !== "number" || !Number.isFinite(tolerance)) {
+    throw new TypeError("simplifyPath: tolerance must be a finite number");
   }
   if (tolerance < 0) {
-    throw new RangeError('simplifyPath: tolerance cannot be negative');
+    throw new RangeError("simplifyPath: tolerance cannot be negative");
   }
   // Prevent impractically small tolerances that cause numerical precision issues
   if (tolerance > 0 && tolerance < 1e-10) {
-    throw new RangeError('simplifyPath: tolerance must be either 0 or >= 1e-10 to avoid numerical precision issues');
+    throw new RangeError(
+      "simplifyPath: tolerance must be either 0 or >= 1e-10 to avoid numerical precision issues",
+    );
   }
 
   if (!isPurePolyline(commands) || commands.length < 3) {
@@ -580,7 +708,7 @@ export function simplifyPath(commands, tolerance, algorithm = 'douglas-peucker')
       commands,
       simplified: false,
       originalPoints: 0,
-      simplifiedPoints: 0
+      simplifiedPoints: 0,
     };
   }
 
@@ -592,19 +720,22 @@ export function simplifyPath(commands, tolerance, algorithm = 'douglas-peucker')
       commands,
       simplified: false,
       originalPoints: originalCount,
-      simplifiedPoints: originalCount
+      simplifiedPoints: originalCount,
     };
   }
 
   // Check if path is closed
-  const isClosed = commands[commands.length - 1].command.toLowerCase() === 'z';
+  const isClosed = commands[commands.length - 1].command.toLowerCase() === "z";
 
   // For closed paths, remove duplicate endpoint to avoid degenerate zero-length line segment
   if (isClosed && points.length > 1) {
     const first = points[0];
     const last = points[points.length - 1];
     // Check if last point is duplicate of first (within floating point tolerance)
-    if (Math.abs(last.x - first.x) < 1e-10 && Math.abs(last.y - first.y) < 1e-10) {
+    if (
+      Math.abs(last.x - first.x) < 1e-10 &&
+      Math.abs(last.y - first.y) < 1e-10
+    ) {
       points = points.slice(0, -1);
     }
   }
@@ -617,7 +748,7 @@ export function simplifyPath(commands, tolerance, algorithm = 'douglas-peucker')
       commands,
       simplified: false,
       originalPoints: originalCount,
-      simplifiedPoints: originalCount
+      simplifiedPoints: originalCount,
     };
   }
 
@@ -627,7 +758,7 @@ export function simplifyPath(commands, tolerance, algorithm = 'douglas-peucker')
     commands: newCommands,
     simplified: true,
     originalPoints: originalCount,
-    simplifiedPoints: simplifiedCount
+    simplifiedPoints: simplifiedCount,
   };
 }
 
@@ -639,5 +770,5 @@ export default {
   extractPolylinePoints,
   rebuildPathFromPoints,
   isPurePolyline,
-  simplifyPath
+  simplifyPath,
 };