@emasoft/svg-matrix 1.0.28 → 1.0.30

package/src/path-data-plugins.js

@@ -33,7 +33,13 @@
  * @module path-data-plugins
  */
 
-import { parsePath, serializePath, toAbsolute, toRelative, formatNumber } from './convert-path-data.js';
+import {
+  parsePath,
+  serializePath,
+  toAbsolute,
+  toRelative,
+  formatNumber,
+} from "./convert-path-data.js";
 
 // ============================================================================
 // PLUGIN: removeLeadingZero
@@ -52,13 +58,13 @@ export function removeLeadingZero(d, precision = 3) {
   if (commands.length === 0) return d;
 
   // Format numbers with leading zero removal
-  const formatted = commands.map(cmd => ({
+  const formatted = commands.map((cmd) => ({
     command: cmd.command,
-    args: cmd.args.map(n => {
-      let str = formatNumber(n, precision);
+    args: cmd.args.map((n) => {
+      const str = formatNumber(n, precision);
       // formatNumber already handles leading zero removal
       return parseFloat(str);
-    })
+    }),
   }));
 
   return serializePath(formatted, precision);
@@ -99,8 +105,10 @@ export function convertToRelative(d, precision = 3) {
   const commands = parsePath(d);
   if (commands.length === 0) return d;
 
-  let cx = 0, cy = 0;
-  let startX = 0, startY = 0;
+  let cx = 0,
+    cy = 0;
+  let startX = 0,
+    startY = 0;
   const result = [];
 
   for (const cmd of commands) {
@@ -111,14 +119,40 @@ export function convertToRelative(d, precision = 3) {
     // Update position using absolute form
     const abs = toAbsolute(cmd, cx, cy);
     switch (abs.command) {
-      case 'M': cx = abs.args[0]; cy = abs.args[1]; startX = cx; startY = cy; break;
-      case 'L': case 'T': cx = abs.args[0]; cy = abs.args[1]; break;
-      case 'H': cx = abs.args[0]; break;
-      case 'V': cy = abs.args[0]; break;
-      case 'C': cx = abs.args[4]; cy = abs.args[5]; break;
-      case 'S': case 'Q': cx = abs.args[2]; cy = abs.args[3]; break;
-      case 'A': cx = abs.args[5]; cy = abs.args[6]; break;
-      case 'Z': cx = startX; cy = startY; break;
+      case "M":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        startX = cx;
+        startY = cy;
+        break;
+      case "L":
+      case "T":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        break;
+      case "H":
+        cx = abs.args[0];
+        break;
+      case "V":
+        cy = abs.args[0];
+        break;
+      case "C":
+        cx = abs.args[4];
+        cy = abs.args[5];
+        break;
+      case "S":
+      case "Q":
+        cx = abs.args[2];
+        cy = abs.args[3];
+        break;
+      case "A":
+        cx = abs.args[5];
+        cy = abs.args[6];
+        break;
+      case "Z":
+        cx = startX;
+        cy = startY;
+        break;
     }
   }
 
@@ -140,8 +174,10 @@ export function convertToAbsolute(d, precision = 3) {
   const commands = parsePath(d);
   if (commands.length === 0) return d;
 
-  let cx = 0, cy = 0;
-  let startX = 0, startY = 0;
+  let cx = 0,
+    cy = 0;
+  let startX = 0,
+    startY = 0;
   const result = [];
 
   for (const cmd of commands) {
@@ -151,14 +187,40 @@ export function convertToAbsolute(d, precision = 3) {
 
     // Update position
     switch (abs.command) {
-      case 'M': cx = abs.args[0]; cy = abs.args[1]; startX = cx; startY = cy; break;
-      case 'L': case 'T': cx = abs.args[0]; cy = abs.args[1]; break;
-      case 'H': cx = abs.args[0]; break;
-      case 'V': cy = abs.args[0]; break;
-      case 'C': cx = abs.args[4]; cy = abs.args[5]; break;
-      case 'S': case 'Q': cx = abs.args[2]; cy = abs.args[3]; break;
-      case 'A': cx = abs.args[5]; cy = abs.args[6]; break;
-      case 'Z': cx = startX; cy = startY; break;
+      case "M":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        startX = cx;
+        startY = cy;
+        break;
+      case "L":
+      case "T":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        break;
+      case "H":
+        cx = abs.args[0];
+        break;
+      case "V":
+        cy = abs.args[0];
+        break;
+      case "C":
+        cx = abs.args[4];
+        cy = abs.args[5];
+        break;
+      case "S":
+      case "Q":
+        cx = abs.args[2];
+        cy = abs.args[3];
+        break;
+      case "A":
+        cx = abs.args[5];
+        cy = abs.args[6];
+        break;
+      case "Z":
+        cx = startX;
+        cy = startY;
+        break;
     }
   }
 
@@ -182,28 +244,30 @@ export function lineShorthands(d, tolerance = 1e-6, precision = 3) {
   const commands = parsePath(d);
   if (commands.length === 0) return d;
 
-  let cx = 0, cy = 0;
-  let startX = 0, startY = 0;
+  let cx = 0,
+    cy = 0;
+  let startX = 0,
+    startY = 0;
   const result = [];
 
   for (const cmd of commands) {
     let newCmd = cmd;
 
-    if (cmd.command === 'L' || cmd.command === 'l') {
-      const isAbs = cmd.command === 'L';
+    if (cmd.command === "L" || cmd.command === "l") {
+      const isAbs = cmd.command === "L";
       const endX = isAbs ? cmd.args[0] : cx + cmd.args[0];
       const endY = isAbs ? cmd.args[1] : cy + cmd.args[1];
 
       if (Math.abs(endY - cy) < tolerance) {
         // Horizontal line
         newCmd = isAbs
-          ? { command: 'H', args: [endX] }
-          : { command: 'h', args: [endX - cx] };
+          ? { command: "H", args: [endX] }
+          : { command: "h", args: [endX - cx] };
       } else if (Math.abs(endX - cx) < tolerance) {
         // Vertical line
         newCmd = isAbs
-          ? { command: 'V', args: [endY] }
-          : { command: 'v', args: [endY - cy] };
+          ? { command: "V", args: [endY] }
+          : { command: "v", args: [endY - cy] };
       }
     }
 
@@ -212,14 +276,40 @@ export function lineShorthands(d, tolerance = 1e-6, precision = 3) {
     // Update position
     const abs = toAbsolute(newCmd, cx, cy);
     switch (abs.command) {
-      case 'M': cx = abs.args[0]; cy = abs.args[1]; startX = cx; startY = cy; break;
-      case 'L': case 'T': cx = abs.args[0]; cy = abs.args[1]; break;
-      case 'H': cx = abs.args[0]; break;
-      case 'V': cy = abs.args[0]; break;
-      case 'C': cx = abs.args[4]; cy = abs.args[5]; break;
-      case 'S': case 'Q': cx = abs.args[2]; cy = abs.args[3]; break;
-      case 'A': cx = abs.args[5]; cy = abs.args[6]; break;
-      case 'Z': cx = startX; cy = startY; break;
+      case "M":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        startX = cx;
+        startY = cy;
+        break;
+      case "L":
+      case "T":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        break;
+      case "H":
+        cx = abs.args[0];
+        break;
+      case "V":
+        cy = abs.args[0];
+        break;
+      case "C":
+        cx = abs.args[4];
+        cy = abs.args[5];
+        break;
+      case "S":
+      case "Q":
+        cx = abs.args[2];
+        cy = abs.args[3];
+        break;
+      case "A":
+        cx = abs.args[5];
+        cy = abs.args[6];
+        break;
+      case "Z":
+        cx = startX;
+        cy = startY;
+        break;
     }
   }
 
@@ -243,8 +333,10 @@ export function convertToZ(d, tolerance = 1e-6, precision = 3) {
   const commands = parsePath(d);
   if (commands.length === 0) return d;
 
-  let cx = 0, cy = 0;
-  let startX = 0, startY = 0;
+  let cx = 0,
+    cy = 0;
+  let startX = 0,
+    startY = 0;
   const result = [];
 
   for (let i = 0; i < commands.length; i++) {
@@ -252,14 +344,17 @@ export function convertToZ(d, tolerance = 1e-6, precision = 3) {
     let newCmd = cmd;
 
     // Check if this L command goes back to start
-    if (cmd.command === 'L' || cmd.command === 'l') {
-      const isAbs = cmd.command === 'L';
+    if (cmd.command === "L" || cmd.command === "l") {
+      const isAbs = cmd.command === "L";
       const endX = isAbs ? cmd.args[0] : cx + cmd.args[0];
       const endY = isAbs ? cmd.args[1] : cy + cmd.args[1];
 
-      if (Math.abs(endX - startX) < tolerance && Math.abs(endY - startY) < tolerance) {
+      if (
+        Math.abs(endX - startX) < tolerance &&
+        Math.abs(endY - startY) < tolerance
+      ) {
         // This line closes the path
-        newCmd = { command: 'z', args: [] };
+        newCmd = { command: "z", args: [] };
       }
     }
 
@@ -268,14 +363,40 @@ export function convertToZ(d, tolerance = 1e-6, precision = 3) {
     // Update position
     const abs = toAbsolute(newCmd, cx, cy);
     switch (abs.command) {
-      case 'M': cx = abs.args[0]; cy = abs.args[1]; startX = cx; startY = cy; break;
-      case 'L': case 'T': cx = abs.args[0]; cy = abs.args[1]; break;
-      case 'H': cx = abs.args[0]; break;
-      case 'V': cy = abs.args[0]; break;
-      case 'C': cx = abs.args[4]; cy = abs.args[5]; break;
-      case 'S': case 'Q': cx = abs.args[2]; cy = abs.args[3]; break;
-      case 'A': cx = abs.args[5]; cy = abs.args[6]; break;
-      case 'Z': cx = startX; cy = startY; break;
+      case "M":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        startX = cx;
+        startY = cy;
+        break;
+      case "L":
+      case "T":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        break;
+      case "H":
+        cx = abs.args[0];
+        break;
+      case "V":
+        cy = abs.args[0];
+        break;
+      case "C":
+        cx = abs.args[4];
+        cy = abs.args[5];
+        break;
+      case "S":
+      case "Q":
+        cx = abs.args[2];
+        cy = abs.args[3];
+        break;
+      case "A":
+        cx = abs.args[5];
+        cy = abs.args[6];
+        break;
+      case "Z":
+        cx = startX;
+        cy = startY;
+        break;
     }
   }
 
@@ -289,6 +410,16 @@ export function convertToZ(d, tolerance = 1e-6, precision = 3) {
 /**
  * Evaluate a cubic Bezier curve at parameter t.
  * B(t) = (1-t)^3*P0 + 3*(1-t)^2*t*P1 + 3*(1-t)*t^2*P2 + t^3*P3
+ * @param {number} t - Parameter value (0 to 1)
+ * @param {number} p0x - Start point X coordinate
+ * @param {number} p0y - Start point Y coordinate
+ * @param {number} p1x - First control point X coordinate
+ * @param {number} p1y - First control point Y coordinate
+ * @param {number} p2x - Second control point X coordinate
+ * @param {number} p2y - Second control point Y coordinate
+ * @param {number} p3x - End point X coordinate
+ * @param {number} p3y - End point Y coordinate
+ * @returns {{x: number, y: number}} Point on curve
  */
 function cubicBezierPoint(t, p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y) {
   const mt = 1 - t;
@@ -298,13 +429,23 @@ function cubicBezierPoint(t, p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y) {
   const t3 = t2 * t;
   return {
     x: mt3 * p0x + 3 * mt2 * t * p1x + 3 * mt * t2 * p2x + t3 * p3x,
-    y: mt3 * p0y + 3 * mt2 * t * p1y + 3 * mt * t2 * p2y + t3 * p3y
+    y: mt3 * p0y + 3 * mt2 * t * p1y + 3 * mt * t2 * p2y + t3 * p3y,
   };
 }
 
 /**
  * First derivative of cubic Bezier at t.
  * B'(t) = 3(1-t)^2(P1-P0) + 6(1-t)t(P2-P1) + 3t^2(P3-P2)
+ * @param {number} t - Parameter value (0 to 1)
+ * @param {number} p0x - Start point X coordinate
+ * @param {number} p0y - Start point Y coordinate
+ * @param {number} p1x - First control point X coordinate
+ * @param {number} p1y - First control point Y coordinate
+ * @param {number} p2x - Second control point X coordinate
+ * @param {number} p2y - Second control point Y coordinate
+ * @param {number} p3x - End point X coordinate
+ * @param {number} p3y - End point Y coordinate
+ * @returns {{x: number, y: number}} First derivative vector
  */
 function cubicBezierDeriv1(t, p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y) {
   const mt = 1 - t;
@@ -312,27 +453,61 @@ function cubicBezierDeriv1(t, p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y) {
   const t2 = t * t;
   return {
     x: 3 * mt2 * (p1x - p0x) + 6 * mt * t * (p2x - p1x) + 3 * t2 * (p3x - p2x),
-    y: 3 * mt2 * (p1y - p0y) + 6 * mt * t * (p2y - p1y) + 3 * t2 * (p3y - p2y)
+    y: 3 * mt2 * (p1y - p0y) + 6 * mt * t * (p2y - p1y) + 3 * t2 * (p3y - p2y),
   };
 }
 
 /**
  * Second derivative of cubic Bezier at t.
  * B''(t) = 6(1-t)(P2-2P1+P0) + 6t(P3-2P2+P1)
+ * @param {number} t - Parameter value (0 to 1)
+ * @param {number} p0x - Start point X coordinate
+ * @param {number} p0y - Start point Y coordinate
+ * @param {number} p1x - First control point X coordinate
+ * @param {number} p1y - First control point Y coordinate
+ * @param {number} p2x - Second control point X coordinate
+ * @param {number} p2y - Second control point Y coordinate
+ * @param {number} p3x - End point X coordinate
+ * @param {number} p3y - End point Y coordinate
+ * @returns {{x: number, y: number}} Second derivative vector
  */
 function cubicBezierDeriv2(t, p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y) {
   const mt = 1 - t;
   return {
     x: 6 * mt * (p2x - 2 * p1x + p0x) + 6 * t * (p3x - 2 * p2x + p1x),
-    y: 6 * mt * (p2y - 2 * p1y + p0y) + 6 * t * (p3y - 2 * p2y + p1y)
+    y: 6 * mt * (p2y - 2 * p1y + p0y) + 6 * t * (p3y - 2 * p2y + p1y),
   };
 }
 
 /**
  * Find closest t on cubic Bezier to point p using Newton's method.
  * Minimizes |B(t) - p|^2 by finding root of d/dt |B(t)-p|^2 = 2(B(t)-p)·B'(t) = 0
+ * @param {number} px - Query point X coordinate
+ * @param {number} py - Query point Y coordinate
+ * @param {number} p0x - Bezier start point X
+ * @param {number} p0y - Bezier start point Y
+ * @param {number} p1x - Bezier first control point X
+ * @param {number} p1y - Bezier first control point Y
+ * @param {number} p2x - Bezier second control point X
+ * @param {number} p2y - Bezier second control point Y
+ * @param {number} p3x - Bezier end point X
+ * @param {number} p3y - Bezier end point Y
+ * @param {number} tInit - Initial t value for Newton iteration
+ * @returns {number} Closest parameter t (0 to 1)
  */
-function closestTOnCubicBezier(px, py, p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y, tInit = 0.5) {
+function _closestTOnCubicBezier(
+  px,
+  py,
+  p0x,
+  p0y,
+  p1x,
+  p1y,
+  p2x,
+  p2y,
+  p3x,
+  p3y,
+  tInit = 0.5,
+) {
   let t = Math.max(0, Math.min(1, tInit));
 
   for (let iter = 0; iter < 10; iter++) {
@@ -351,7 +526,10 @@ function closestTOnCubicBezier(px, py, p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y, t
     if (Math.abs(fp) < 1e-12) break;
 
     const tNext = Math.max(0, Math.min(1, t - f / fp));
-    if (Math.abs(tNext - t) < 1e-9) { t = tNext; break; }
+    if (Math.abs(tNext - t) < 1e-9) {
+      t = tNext;
+      break;
+    }
     t = tNext;
   }
 
@@ -360,6 +538,13 @@ function closestTOnCubicBezier(px, py, p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y, t
 
 /**
  * Calculate distance from point to line segment (for straight curve check).
+ * @param {number} px - Point X coordinate
+ * @param {number} py - Point Y coordinate
+ * @param {number} x0 - Line segment start X
+ * @param {number} y0 - Line segment start Y
+ * @param {number} x1 - Line segment end X
+ * @param {number} y1 - Line segment end Y
+ * @returns {number} Distance from point to line segment
  */
 function pointToLineDistance(px, py, x0, y0, x1, y1) {
   const dx = x1 - x0;
@@ -370,7 +555,10 @@ function pointToLineDistance(px, py, x0, y0, x1, y1) {
     return Math.sqrt((px - x0) ** 2 + (py - y0) ** 2);
   }
 
-  const t = Math.max(0, Math.min(1, ((px - x0) * dx + (py - y0) * dy) / lengthSq));
+  const t = Math.max(
+    0,
+    Math.min(1, ((px - x0) * dx + (py - y0) * dy) / lengthSq),
+  );
   const projX = x0 + t * dx;
   const projY = y0 + t * dy;
 
@@ -380,7 +568,14 @@ function pointToLineDistance(px, py, x0, y0, x1, y1) {
 /**
  * Compute maximum error between cubic Bezier and a line segment.
  * Uses Newton's method to find closest points + midpoint checks to catch bulges.
- *
+ * @param {number} p0x - Bezier start point X
+ * @param {number} p0y - Bezier start point Y
+ * @param {number} cp1x - First control point X
+ * @param {number} cp1y - First control point Y
+ * @param {number} cp2x - Second control point X
+ * @param {number} cp2y - Second control point Y
+ * @param {number} p3x - Bezier end point X
+ * @param {number} p3y - Bezier end point Y
  * @returns {number} Maximum distance from any curve point to the line
  */
 function maxErrorCurveToLine(p0x, p0y, cp1x, cp1y, cp2x, cp2y, p3x, p3y) {
@@ -397,7 +592,17 @@ function maxErrorCurveToLine(p0x, p0y, cp1x, cp1y, cp2x, cp2y, p3x, p3y) {
   // Check midpoints between samples to catch bulges
   for (let i = 0; i < samples.length - 1; i++) {
     const tMid = (samples[i] + samples[i + 1]) / 2;
-    const pt = cubicBezierPoint(tMid, p0x, p0y, cp1x, cp1y, cp2x, cp2y, p3x, p3y);
+    const pt = cubicBezierPoint(
+      tMid,
+      p0x,
+      p0y,
+      cp1x,
+      cp1y,
+      cp2x,
+      cp2y,
+      p3x,
+      p3y,
+    );
     const dist = pointToLineDistance(pt.x, pt.y, p0x, p0y, p3x, p3y);
     if (dist > maxErr) maxErr = dist;
   }
@@ -420,6 +625,16 @@ function maxErrorCurveToLine(p0x, p0y, cp1x, cp1y, cp2x, cp2y, p3x, p3y) {
 /**
  * Check if a cubic bezier is effectively a straight line.
  * Uses comprehensive sampling + midpoint checks to find actual max deviation.
+ * @param {number} x0 - Bezier start point X
+ * @param {number} y0 - Bezier start point Y
+ * @param {number} cp1x - First control point X
+ * @param {number} cp1y - First control point Y
+ * @param {number} cp2x - Second control point X
+ * @param {number} cp2y - Second control point Y
+ * @param {number} x3 - Bezier end point X
+ * @param {number} y3 - Bezier end point Y
+ * @param {number} tolerance - Maximum deviation to consider straight
+ * @returns {boolean} True if curve is effectively straight
  */
 function isCurveStraight(x0, y0, cp1x, cp1y, cp2x, cp2y, x3, y3, tolerance) {
   const maxError = maxErrorCurveToLine(x0, y0, cp1x, cp1y, cp2x, cp2y, x3, y3);
@@ -438,15 +653,17 @@ export function straightCurves(d, tolerance = 0.5, precision = 3) {
   const commands = parsePath(d);
   if (commands.length === 0) return d;
 
-  let cx = 0, cy = 0;
-  let startX = 0, startY = 0;
+  let cx = 0,
+    cy = 0;
+  let startX = 0,
+    startY = 0;
   const result = [];
 
   for (const cmd of commands) {
     let newCmd = cmd;
 
-    if (cmd.command === 'C' || cmd.command === 'c') {
-      const isAbs = cmd.command === 'C';
+    if (cmd.command === "C" || cmd.command === "c") {
+      const isAbs = cmd.command === "C";
       const cp1x = isAbs ? cmd.args[0] : cx + cmd.args[0];
       const cp1y = isAbs ? cmd.args[1] : cy + cmd.args[1];
       const cp2x = isAbs ? cmd.args[2] : cx + cmd.args[2];
@@ -454,10 +671,12 @@ export function straightCurves(d, tolerance = 0.5, precision = 3) {
       const endX = isAbs ? cmd.args[4] : cx + cmd.args[4];
       const endY = isAbs ? cmd.args[5] : cy + cmd.args[5];
 
-      if (isCurveStraight(cx, cy, cp1x, cp1y, cp2x, cp2y, endX, endY, tolerance)) {
+      if (
+        isCurveStraight(cx, cy, cp1x, cp1y, cp2x, cp2y, endX, endY, tolerance)
+      ) {
         newCmd = isAbs
-          ? { command: 'L', args: [endX, endY] }
-          : { command: 'l', args: [endX - cx, endY - cy] };
+          ? { command: "L", args: [endX, endY] }
+          : { command: "l", args: [endX - cx, endY - cy] };
       }
     }
 
@@ -466,14 +685,40 @@ export function straightCurves(d, tolerance = 0.5, precision = 3) {
     // Update position
     const abs = toAbsolute(newCmd, cx, cy);
     switch (abs.command) {
-      case 'M': cx = abs.args[0]; cy = abs.args[1]; startX = cx; startY = cy; break;
-      case 'L': case 'T': cx = abs.args[0]; cy = abs.args[1]; break;
-      case 'H': cx = abs.args[0]; break;
-      case 'V': cy = abs.args[0]; break;
-      case 'C': cx = abs.args[4]; cy = abs.args[5]; break;
-      case 'S': case 'Q': cx = abs.args[2]; cy = abs.args[3]; break;
-      case 'A': cx = abs.args[5]; cy = abs.args[6]; break;
-      case 'Z': cx = startX; cy = startY; break;
+      case "M":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        startX = cx;
+        startY = cy;
+        break;
+      case "L":
+      case "T":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        break;
+      case "H":
+        cx = abs.args[0];
+        break;
+      case "V":
+        cy = abs.args[0];
+        break;
+      case "C":
+        cx = abs.args[4];
+        cy = abs.args[5];
+        break;
+      case "S":
+      case "Q":
+        cx = abs.args[2];
+        cy = abs.args[3];
+        break;
+      case "A":
+        cx = abs.args[5];
+        cy = abs.args[6];
+        break;
+      case "Z":
+        cx = startX;
+        cy = startY;
+        break;
     }
   }
 
@@ -518,9 +763,9 @@ export function floatPrecision(d, precision = 3) {
   if (commands.length === 0) return d;
 
   const factor = Math.pow(10, precision);
-  const rounded = commands.map(cmd => ({
+  const rounded = commands.map((cmd) => ({
     command: cmd.command,
-    args: cmd.args.map(n => Math.round(n * factor) / factor)
+    args: cmd.args.map((n) => Math.round(n * factor) / factor),
   }));
 
   return serializePath(rounded, precision);
@@ -543,8 +788,10 @@ export function removeUselessCommands(d, tolerance = 1e-6, precision = 3) {
   const commands = parsePath(d);
   if (commands.length === 0) return d;
 
-  let cx = 0, cy = 0;
-  let startX = 0, startY = 0;
+  let cx = 0,
+    cy = 0;
+  let startX = 0,
+    startY = 0;
   const result = [];
 
   for (const cmd of commands) {
@@ -553,30 +800,35 @@ export function removeUselessCommands(d, tolerance = 1e-6, precision = 3) {
 
     // Check for zero-length commands
     switch (abs.command) {
-      case 'L': case 'T':
-        if (Math.abs(abs.args[0] - cx) < tolerance &&
-            Math.abs(abs.args[1] - cy) < tolerance) {
+      case "L":
+      case "T":
+        if (
+          Math.abs(abs.args[0] - cx) < tolerance &&
+          Math.abs(abs.args[1] - cy) < tolerance
+        ) {
           keep = false;
         }
         break;
-      case 'H':
+      case "H":
         if (Math.abs(abs.args[0] - cx) < tolerance) {
           keep = false;
         }
         break;
-      case 'V':
+      case "V":
         if (Math.abs(abs.args[0] - cy) < tolerance) {
           keep = false;
         }
         break;
-      case 'C':
+      case "C":
         // Zero-length curve where all points are the same
-        if (Math.abs(abs.args[4] - cx) < tolerance &&
-            Math.abs(abs.args[5] - cy) < tolerance &&
-            Math.abs(abs.args[0] - cx) < tolerance &&
-            Math.abs(abs.args[1] - cy) < tolerance &&
-            Math.abs(abs.args[2] - cx) < tolerance &&
-            Math.abs(abs.args[3] - cy) < tolerance) {
+        if (
+          Math.abs(abs.args[4] - cx) < tolerance &&
+          Math.abs(abs.args[5] - cy) < tolerance &&
+          Math.abs(abs.args[0] - cx) < tolerance &&
+          Math.abs(abs.args[1] - cy) < tolerance &&
+          Math.abs(abs.args[2] - cx) < tolerance &&
+          Math.abs(abs.args[3] - cy) < tolerance
+        ) {
           keep = false;
         }
         break;
@@ -587,14 +839,40 @@ export function removeUselessCommands(d, tolerance = 1e-6, precision = 3) {
 
       // Update position
       switch (abs.command) {
-        case 'M': cx = abs.args[0]; cy = abs.args[1]; startX = cx; startY = cy; break;
-        case 'L': case 'T': cx = abs.args[0]; cy = abs.args[1]; break;
-        case 'H': cx = abs.args[0]; break;
-        case 'V': cy = abs.args[0]; break;
-        case 'C': cx = abs.args[4]; cy = abs.args[5]; break;
-        case 'S': case 'Q': cx = abs.args[2]; cy = abs.args[3]; break;
-        case 'A': cx = abs.args[5]; cy = abs.args[6]; break;
-        case 'Z': cx = startX; cy = startY; break;
+        case "M":
+          cx = abs.args[0];
+          cy = abs.args[1];
+          startX = cx;
+          startY = cy;
+          break;
+        case "L":
+        case "T":
+          cx = abs.args[0];
+          cy = abs.args[1];
+          break;
+        case "H":
+          cx = abs.args[0];
+          break;
+        case "V":
+          cy = abs.args[0];
+          break;
+        case "C":
+          cx = abs.args[4];
+          cy = abs.args[5];
+          break;
+        case "S":
+        case "Q":
+          cx = abs.args[2];
+          cy = abs.args[3];
+          break;
+        case "A":
+          cx = abs.args[5];
+          cy = abs.args[6];
+          break;
+        case "Z":
+          cx = startX;
+          cy = startY;
+          break;
       }
     }
   }
@@ -610,6 +888,14 @@ export function removeUselessCommands(d, tolerance = 1e-6, precision = 3) {
 /**
  * Evaluate a quadratic Bezier curve at parameter t.
  * B(t) = (1-t)^2*P0 + 2*(1-t)*t*P1 + t^2*P2
+ * @param {number} t - Parameter value (0 to 1)
+ * @param {number} p0x - Start point X coordinate
+ * @param {number} p0y - Start point Y coordinate
+ * @param {number} p1x - Control point X coordinate
+ * @param {number} p1y - Control point Y coordinate
+ * @param {number} p2x - End point X coordinate
+ * @param {number} p2y - End point Y coordinate
+ * @returns {{x: number, y: number}} Point on curve
  */
 function quadraticBezierPoint(t, p0x, p0y, p1x, p1y, p2x, p2y) {
   const mt = 1 - t;
@@ -617,26 +903,58 @@ function quadraticBezierPoint(t, p0x, p0y, p1x, p1y, p2x, p2y) {
   const t2 = t * t;
   return {
     x: mt2 * p0x + 2 * mt * t * p1x + t2 * p2x,
-    y: mt2 * p0y + 2 * mt * t * p1y + t2 * p2y
+    y: mt2 * p0y + 2 * mt * t * p1y + t2 * p2y,
   };
 }
 
 /**
  * Compute maximum error between cubic Bezier and quadratic Bezier.
  * Samples both curves and checks midpoints to find actual max deviation.
- *
+ * @param {number} p0x - Bezier start point X
+ * @param {number} p0y - Bezier start point Y
+ * @param {number} cp1x - Cubic first control point X
+ * @param {number} cp1y - Cubic first control point Y
+ * @param {number} cp2x - Cubic second control point X
+ * @param {number} cp2y - Cubic second control point Y
+ * @param {number} p3x - Bezier end point X
+ * @param {number} p3y - Bezier end point Y
+ * @param {number} qx - Quadratic control point X
+ * @param {number} qy - Quadratic control point Y
  * @returns {number} Maximum distance between corresponding points on both curves
  */
-function maxErrorCubicToQuadratic(p0x, p0y, cp1x, cp1y, cp2x, cp2y, p3x, p3y, qx, qy) {
+function maxErrorCubicToQuadratic(
+  p0x,
+  p0y,
+  cp1x,
+  cp1y,
+  cp2x,
+  cp2y,
+  p3x,
+  p3y,
+  qx,
+  qy,
+) {
   let maxErr = 0;
 
   // Dense sampling including midpoints
-  const samples = [0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5,
-                   0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95];
+  const samples = [
+    0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7,
+    0.75, 0.8, 0.85, 0.9, 0.95,
+  ];
 
   for (const t of samples) {
     // Point on original cubic
-    const cubic = cubicBezierPoint(t, p0x, p0y, cp1x, cp1y, cp2x, cp2y, p3x, p3y);
+    const cubic = cubicBezierPoint(
+      t,
+      p0x,
+      p0y,
+      cp1x,
+      cp1y,
+      cp2x,
+      cp2y,
+      p3x,
+      p3y,
+    );
     // Point on proposed quadratic
     const quad = quadraticBezierPoint(t, p0x, p0y, qx, qy, p3x, p3y);
 
@@ -650,10 +968,28 @@ function maxErrorCubicToQuadratic(p0x, p0y, cp1x, cp1y, cp2x, cp2y, p3x, p3y, qx
 /**
  * Check if a cubic bezier can be approximated by a quadratic.
  * VERIFIED by comparing actual curve points with comprehensive sampling.
- *
+ * @param {number} x0 - Bezier start point X
+ * @param {number} y0 - Bezier start point Y
+ * @param {number} cp1x - Cubic first control point X
+ * @param {number} cp1y - Cubic first control point Y
+ * @param {number} cp2x - Cubic second control point X
+ * @param {number} cp2y - Cubic second control point Y
+ * @param {number} x3 - Bezier end point X
+ * @param {number} y3 - Bezier end point Y
+ * @param {number} tolerance - Maximum deviation for conversion
  * @returns {{cpx: number, cpy: number} | null} Quadratic control point or null
  */
-function cubicToQuadraticControlPoint(x0, y0, cp1x, cp1y, cp2x, cp2y, x3, y3, tolerance) {
+function cubicToQuadraticControlPoint(
+  x0,
+  y0,
+  cp1x,
+  cp1y,
+  cp2x,
+  cp2y,
+  x3,
+  y3,
+  tolerance,
+) {
   // Calculate the best-fit quadratic control point
   // For a cubic to be exactly representable as quadratic:
   // Q = (3*(P1 + P2) - P0 - P3) / 4
@@ -661,7 +997,18 @@ function cubicToQuadraticControlPoint(x0, y0, cp1x, cp1y, cp2x, cp2y, x3, y3, to
   const qy = (3 * (cp1y + cp2y) - y0 - y3) / 4;
 
   // VERIFY by computing actual max error between the curves
-  const maxError = maxErrorCubicToQuadratic(x0, y0, cp1x, cp1y, cp2x, cp2y, x3, y3, qx, qy);
+  const maxError = maxErrorCubicToQuadratic(
+    x0,
+    y0,
+    cp1x,
+    cp1y,
+    cp2x,
+    cp2y,
+    x3,
+    y3,
+    qx,
+    qy,
+  );
 
   if (maxError <= tolerance) {
     return { cpx: qx, cpy: qy };
@@ -682,15 +1029,17 @@ export function convertCubicToQuadratic(d, tolerance = 0.5, precision = 3) {
   const commands = parsePath(d);
   if (commands.length === 0) return d;
 
-  let cx = 0, cy = 0;
-  let startX = 0, startY = 0;
+  let cx = 0,
+    cy = 0;
+  let startX = 0,
+    startY = 0;
   const result = [];
 
   for (const cmd of commands) {
     let newCmd = cmd;
 
-    if (cmd.command === 'C' || cmd.command === 'c') {
-      const isAbs = cmd.command === 'C';
+    if (cmd.command === "C" || cmd.command === "c") {
+      const isAbs = cmd.command === "C";
       const cp1x = isAbs ? cmd.args[0] : cx + cmd.args[0];
       const cp1y = isAbs ? cmd.args[1] : cy + cmd.args[1];
       const cp2x = isAbs ? cmd.args[2] : cx + cmd.args[2];
@@ -698,12 +1047,25 @@ export function convertCubicToQuadratic(d, tolerance = 0.5, precision = 3) {
       const endX = isAbs ? cmd.args[4] : cx + cmd.args[4];
       const endY = isAbs ? cmd.args[5] : cy + cmd.args[5];
 
-      const quadCP = cubicToQuadraticControlPoint(cx, cy, cp1x, cp1y, cp2x, cp2y, endX, endY, tolerance);
+      const quadCP = cubicToQuadraticControlPoint(
+        cx,
+        cy,
+        cp1x,
+        cp1y,
+        cp2x,
+        cp2y,
+        endX,
+        endY,
+        tolerance,
+      );
 
       if (quadCP) {
         newCmd = isAbs
-          ? { command: 'Q', args: [quadCP.cpx, quadCP.cpy, endX, endY] }
-          : { command: 'q', args: [quadCP.cpx - cx, quadCP.cpy - cy, endX - cx, endY - cy] };
+          ? { command: "Q", args: [quadCP.cpx, quadCP.cpy, endX, endY] }
+          : {
+              command: "q",
+              args: [quadCP.cpx - cx, quadCP.cpy - cy, endX - cx, endY - cy],
+            };
       }
     }
 
@@ -712,14 +1074,40 @@ export function convertCubicToQuadratic(d, tolerance = 0.5, precision = 3) {
     // Update position
     const abs = toAbsolute(newCmd, cx, cy);
     switch (abs.command) {
-      case 'M': cx = abs.args[0]; cy = abs.args[1]; startX = cx; startY = cy; break;
-      case 'L': case 'T': cx = abs.args[0]; cy = abs.args[1]; break;
-      case 'H': cx = abs.args[0]; break;
-      case 'V': cy = abs.args[0]; break;
-      case 'C': cx = abs.args[4]; cy = abs.args[5]; break;
-      case 'S': case 'Q': cx = abs.args[2]; cy = abs.args[3]; break;
-      case 'A': cx = abs.args[5]; cy = abs.args[6]; break;
-      case 'Z': cx = startX; cy = startY; break;
+      case "M":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        startX = cx;
+        startY = cy;
+        break;
+      case "L":
+      case "T":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        break;
+      case "H":
+        cx = abs.args[0];
+        break;
+      case "V":
+        cy = abs.args[0];
+        break;
+      case "C":
+        cx = abs.args[4];
+        cy = abs.args[5];
+        break;
+      case "S":
+      case "Q":
+        cx = abs.args[2];
+        cy = abs.args[3];
+        break;
+      case "A":
+        cx = abs.args[5];
+        cy = abs.args[6];
+        break;
+      case "Z":
+        cx = startX;
+        cy = startY;
+        break;
     }
   }
 
@@ -743,38 +1131,43 @@ export function convertQuadraticToSmooth(d, tolerance = 1e-6, precision = 3) {
   const commands = parsePath(d);
   if (commands.length === 0) return d;
 
-  let cx = 0, cy = 0;
-  let startX = 0, startY = 0;
-  let lastQcpX = null, lastQcpY = null;
+  let cx = 0,
+    cy = 0;
+  let startX = 0,
+    startY = 0;
+  let lastQcpX = null,
+    lastQcpY = null;
   const result = [];
 
   for (const cmd of commands) {
     let newCmd = cmd;
     const abs = toAbsolute(cmd, cx, cy);
 
-    if (abs.command === 'Q' && lastQcpX !== null) {
+    if (abs.command === "Q" && lastQcpX !== null) {
       // Calculate reflected control point
       const reflectedCpX = 2 * cx - lastQcpX;
       const reflectedCpY = 2 * cy - lastQcpY;
 
       // Check if current control point matches reflection
-      if (Math.abs(abs.args[0] - reflectedCpX) < tolerance &&
-          Math.abs(abs.args[1] - reflectedCpY) < tolerance) {
+      if (
+        Math.abs(abs.args[0] - reflectedCpX) < tolerance &&
+        Math.abs(abs.args[1] - reflectedCpY) < tolerance
+      ) {
         // Can use T command
-        const isAbs = cmd.command === 'Q';
+        const isAbs = cmd.command === "Q";
         newCmd = isAbs
-          ? { command: 'T', args: [abs.args[2], abs.args[3]] }
-          : { command: 't', args: [abs.args[2] - cx, abs.args[3] - cy] };
+          ? { command: "T", args: [abs.args[2], abs.args[3]] }
+          : { command: "t", args: [abs.args[2] - cx, abs.args[3] - cy] };
       }
     }
 
     result.push(newCmd);
 
     // Track control points for reflection
-    if (abs.command === 'Q') {
+    if (abs.command === "Q") {
       lastQcpX = abs.args[0];
       lastQcpY = abs.args[1];
-    } else if (abs.command === 'T') {
+    } else if (abs.command === "T") {
       // T uses reflected control point
       lastQcpX = 2 * cx - lastQcpX;
       lastQcpY = 2 * cy - lastQcpY;
@@ -785,14 +1178,40 @@ export function convertQuadraticToSmooth(d, tolerance = 1e-6, precision = 3) {
 
     // Update position
     switch (abs.command) {
-      case 'M': cx = abs.args[0]; cy = abs.args[1]; startX = cx; startY = cy; break;
-      case 'L': case 'T': cx = abs.args[0]; cy = abs.args[1]; break;
-      case 'H': cx = abs.args[0]; break;
-      case 'V': cy = abs.args[0]; break;
-      case 'C': cx = abs.args[4]; cy = abs.args[5]; break;
-      case 'S': case 'Q': cx = abs.args[2]; cy = abs.args[3]; break;
-      case 'A': cx = abs.args[5]; cy = abs.args[6]; break;
-      case 'Z': cx = startX; cy = startY; break;
+      case "M":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        startX = cx;
+        startY = cy;
+        break;
+      case "L":
+      case "T":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        break;
+      case "H":
+        cx = abs.args[0];
+        break;
+      case "V":
+        cy = abs.args[0];
+        break;
+      case "C":
+        cx = abs.args[4];
+        cy = abs.args[5];
+        break;
+      case "S":
+      case "Q":
+        cx = abs.args[2];
+        cy = abs.args[3];
+        break;
+      case "A":
+        cx = abs.args[5];
+        cy = abs.args[6];
+        break;
+      case "Z":
+        cx = startX;
+        cy = startY;
+        break;
     }
   }
 
@@ -816,38 +1235,54 @@ export function convertCubicToSmooth(d, tolerance = 1e-6, precision = 3) {
   const commands = parsePath(d);
   if (commands.length === 0) return d;
 
-  let cx = 0, cy = 0;
-  let startX = 0, startY = 0;
-  let lastCcp2X = null, lastCcp2Y = null;
+  let cx = 0,
+    cy = 0;
+  let startX = 0,
+    startY = 0;
+  let lastCcp2X = null,
+    lastCcp2Y = null;
   const result = [];
 
   for (const cmd of commands) {
     let newCmd = cmd;
     const abs = toAbsolute(cmd, cx, cy);
 
-    if (abs.command === 'C' && lastCcp2X !== null) {
+    if (abs.command === "C" && lastCcp2X !== null) {
       // Calculate reflected control point
       const reflectedCpX = 2 * cx - lastCcp2X;
       const reflectedCpY = 2 * cy - lastCcp2Y;
 
       // Check if first control point matches reflection
-      if (Math.abs(abs.args[0] - reflectedCpX) < tolerance &&
-          Math.abs(abs.args[1] - reflectedCpY) < tolerance) {
+      if (
+        Math.abs(abs.args[0] - reflectedCpX) < tolerance &&
+        Math.abs(abs.args[1] - reflectedCpY) < tolerance
+      ) {
         // Can use S command
-        const isAbs = cmd.command === 'C';
+        const isAbs = cmd.command === "C";
         newCmd = isAbs
-          ? { command: 'S', args: [abs.args[2], abs.args[3], abs.args[4], abs.args[5]] }
-          : { command: 's', args: [abs.args[2] - cx, abs.args[3] - cy, abs.args[4] - cx, abs.args[5] - cy] };
+          ? {
+              command: "S",
+              args: [abs.args[2], abs.args[3], abs.args[4], abs.args[5]],
+            }
+          : {
+              command: "s",
+              args: [
+                abs.args[2] - cx,
+                abs.args[3] - cy,
+                abs.args[4] - cx,
+                abs.args[5] - cy,
+              ],
+            };
       }
     }
 
     result.push(newCmd);
 
     // Track control points for reflection
-    if (abs.command === 'C') {
+    if (abs.command === "C") {
       lastCcp2X = abs.args[2];
       lastCcp2Y = abs.args[3];
-    } else if (abs.command === 'S') {
+    } else if (abs.command === "S") {
       // S uses its control point as the second cubic control point
       lastCcp2X = abs.args[0];
       lastCcp2Y = abs.args[1];
@@ -858,14 +1293,40 @@ export function convertCubicToSmooth(d, tolerance = 1e-6, precision = 3) {
 
     // Update position
     switch (abs.command) {
-      case 'M': cx = abs.args[0]; cy = abs.args[1]; startX = cx; startY = cy; break;
-      case 'L': case 'T': cx = abs.args[0]; cy = abs.args[1]; break;
-      case 'H': cx = abs.args[0]; break;
-      case 'V': cy = abs.args[0]; break;
-      case 'C': cx = abs.args[4]; cy = abs.args[5]; break;
-      case 'S': case 'Q': cx = abs.args[2]; cy = abs.args[3]; break;
-      case 'A': cx = abs.args[5]; cy = abs.args[6]; break;
-      case 'Z': cx = startX; cy = startY; break;
+      case "M":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        startX = cx;
+        startY = cy;
+        break;
+      case "L":
+      case "T":
+        cx = abs.args[0];
+        cy = abs.args[1];
+        break;
+      case "H":
+        cx = abs.args[0];
+        break;
+      case "V":
+        cy = abs.args[0];
+        break;
+      case "C":
+        cx = abs.args[4];
+        cy = abs.args[5];
+        break;
+      case "S":
+      case "Q":
+        cx = abs.args[2];
+        cy = abs.args[3];
+        break;
+      case "A":
+        cx = abs.args[5];
+        cy = abs.args[6];
+        break;
+      case "Z":
+        cx = startX;
+        cy = startY;
+        break;
     }
   }
 
@@ -889,8 +1350,8 @@ export function arcShorthands(d, precision = 3) {
   const commands = parsePath(d);
   if (commands.length === 0) return d;
 
-  const result = commands.map(cmd => {
-    if (cmd.command === 'A' || cmd.command === 'a') {
+  const result = commands.map((cmd) => {
+    if (cmd.command === "A" || cmd.command === "a") {
       const args = [...cmd.args];
       // Normalize rotation angle to 0-360
       args[2] = ((args[2] % 360) + 360) % 360;
@@ -924,5 +1385,5 @@ export default {
   convertCubicToQuadratic,
   convertQuadraticToSmooth,
   convertCubicToSmooth,
-  arcShorthands
+  arcShorthands,
 };