@emasoft/svg-matrix 1.0.30 → 1.0.31

package/src/css-specificity.js

@@ -46,7 +46,6 @@ export function parseSelector(selectorString) {
 
   const selector = selectorString.trim();
   const components = [];
-  const _i = 0;
 
   // Split by combinators first (>, +, ~, space) to handle complex selectors
   const parts = splitByCombinators(selector);
@@ -69,6 +68,10 @@ export function parseSelector(selectorString) {
  * @returns {Array<string>} Parts split by combinators
  */
 function splitByCombinators(selector) {
+  if (typeof selector !== "string") {
+    throw new Error("Selector must be a string");
+  }
+
   // Match combinators outside of brackets and parentheses
   const parts = [];
   let current = "";
@@ -84,12 +87,18 @@ function splitByCombinators(selector) {
       depth++;
     } else if (char === "]") {
       depth--;
+      if (depth < 0) {
+        throw new Error(`Unbalanced brackets at position ${i}`);
+      }
       if (depth === 0) inBracket = false;
     } else if (char === "(") {
       inParen = true;
       depth++;
     } else if (char === ")") {
       depth--;
+      if (depth < 0) {
+        throw new Error(`Unbalanced parentheses at position ${i}`);
+      }
       if (depth === 0) inParen = false;
     }
 
@@ -111,6 +120,10 @@ function splitByCombinators(selector) {
     current += char;
   }
 
+  if (depth !== 0) {
+    throw new Error("Unclosed brackets or parentheses in selector");
+  }
+
   if (current.trim()) {
     parts.push(current.trim());
   }
@@ -125,6 +138,10 @@ function splitByCombinators(selector) {
  * @returns {Array<Object>} Array of component objects
  */
 function parseSimpleSelector(selector) {
+  if (typeof selector !== "string") {
+    throw new Error("Selector must be a string");
+  }
+
   const components = [];
   let i = 0;
 
@@ -156,7 +173,7 @@ function parseSimpleSelector(selector) {
     }
     // Pseudo-element (::) or pseudo-class (:)
     else if (char === ":") {
-      if (selector[i + 1] === ":") {
+      if (i + 1 < selector.length && selector[i + 1] === ":") {
         // Pseudo-element
         const match = selector.slice(i).match(/^::([\w-]+)/);
         if (!match) throw new Error(`Invalid pseudo-element at position ${i}`);
@@ -174,7 +191,7 @@ function parseSimpleSelector(selector) {
         i += match[0].length;
 
         // Check for function notation like :not()
-        if (selector[i] === "(") {
+        if (i < selector.length && selector[i] === "(") {
           const endIdx = findMatchingParen(selector, i);
           if (endIdx === -1)
             throw new Error(`Unclosed pseudo-class function at position ${i}`);
@@ -219,6 +236,13 @@ function parseSimpleSelector(selector) {
  * @returns {number} Index of closing bracket or -1 if not found
  */
 function findMatchingBracket(str, startIdx) {
+  if (typeof str !== "string") {
+    throw new Error("str must be a string");
+  }
+  if (typeof startIdx !== "number" || startIdx < 0 || startIdx >= str.length) {
+    throw new Error("startIdx must be a valid index within the string");
+  }
+
   let depth = 0;
   for (let i = startIdx; i < str.length; i++) {
     if (str[i] === "[") depth++;
@@ -238,6 +262,13 @@ function findMatchingBracket(str, startIdx) {
  * @returns {number} Index of closing parenthesis or -1 if not found
  */
 function findMatchingParen(str, startIdx) {
+  if (typeof str !== "string") {
+    throw new Error("str must be a string");
+  }
+  if (typeof startIdx !== "number" || startIdx < 0 || startIdx >= str.length) {
+    throw new Error("startIdx must be a valid index within the string");
+  }
+
   let depth = 0;
   for (let i = startIdx; i < str.length; i++) {
     if (str[i] === "(") depth++;
@@ -272,11 +303,18 @@ export function calculateSpecificity(selector) {
   const components =
     typeof selector === "string" ? parseSelector(selector) : selector;
 
+  if (!Array.isArray(components)) {
+    throw new Error("Selector must be a string or an array of components");
+  }
+
   let a = 0; // IDs
   let b = 0; // Classes, attributes, pseudo-classes
   let c = 0; // Types, pseudo-elements
 
   for (const component of components) {
+    if (!component || typeof component.type !== "string") {
+      throw new Error("Invalid component: must have a 'type' property");
+    }
     switch (component.type) {
       case SELECTOR_TYPES.ID:
         a++;
@@ -289,12 +327,15 @@ export function calculateSpecificity(selector) {
 
       case SELECTOR_TYPES.PSEUDO_CLASS:
         // Handle :not() - it doesn't count itself, but its argument does
-        if (component.value.startsWith("not(")) {
+        if (component.value.startsWith("not(") && component.value.endsWith(")")) {
           const notContent = component.value.slice(4, -1); // Extract content inside :not()
-          const notSpec = calculateSpecificity(notContent);
-          a += notSpec[0];
-          b += notSpec[1];
-          c += notSpec[2];
+          if (notContent.trim()) {
+            // Only process non-empty :not() content
+            const notSpec = calculateSpecificity(notContent);
+            a += notSpec[0];
+            b += notSpec[1];
+            c += notSpec[2];
+          }
         } else {
           b++;
         }
@@ -310,7 +351,8 @@ export function calculateSpecificity(selector) {
         break;
 
       default:
-        // Unknown type, ignore
+        // No default case needed - all known SELECTOR_TYPES handled above
+        // Unknown types are silently ignored per CSS spec
         break;
     }
   }
@@ -337,6 +379,16 @@ export function compareSpecificity(spec1, spec2) {
     throw new Error("spec2 must be an array of 3 numbers");
   }
 
+  // Validate all elements are valid numbers
+  for (let i = 0; i < 3; i++) {
+    if (typeof spec1[i] !== "number" || !Number.isFinite(spec1[i]) || spec1[i] < 0) {
+      throw new Error(`spec1[${i}] must be a non-negative finite number`);
+    }
+    if (typeof spec2[i] !== "number" || !Number.isFinite(spec2[i]) || spec2[i] < 0) {
+      throw new Error(`spec2[${i}] must be a non-negative finite number`);
+    }
+  }
+
   // Compare lexicographically: a first, then b, then c
   for (let i = 0; i < 3; i++) {
     if (spec1[i] < spec2[i]) return -1;
@@ -400,7 +452,13 @@ export function stringifySelector(components) {
   }
 
   return components
-    .map((component) => {
+    .map((component, index) => {
+      if (!component || typeof component.type !== "string") {
+        throw new Error(`Component at index ${index} must have a 'type' property`);
+      }
+      if (component.value === undefined) {
+        throw new Error(`Component at index ${index} must have a 'value' property`);
+      }
       switch (component.type) {
         case SELECTOR_TYPES.ID:
           return `#${component.value}`;
@@ -417,6 +475,7 @@ export function stringifySelector(components) {
         case SELECTOR_TYPES.UNIVERSAL:
           return "*";
         default:
+          // Unknown types stringify to empty string for graceful degradation
           return "";
       }
     })
@@ -431,6 +490,10 @@ export function stringifySelector(components) {
  * @returns {boolean} True if round-trip matches
  */
 export function verifySelector(selector) {
+  if (typeof selector !== "string") {
+    throw new Error("Selector must be a string");
+  }
+
   const components = parseSelector(selector);
   const reconstructed = stringifySelector(components);
 

package/src/douglas-peucker.js

@@ -18,6 +18,24 @@
  * @returns {number} Perpendicular distance
  */
 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');
+  }
+
+  // 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');
+  }
+
   const dx = lineEnd.x - lineStart.x;
   const dy = lineEnd.y - lineStart.y;
 
@@ -46,6 +64,36 @@ export function perpendicularDistance(point, lineStart, lineEnd) {
  * @returns {Array<{x: number, y: number}>} Simplified points
  */
 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');
+  }
+  if (points.length === 0) {
+    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 (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`);
+    }
+  }
+
+  // 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 (tolerance < 0) {
+    throw new RangeError('douglasPeucker: tolerance cannot be negative');
+  }
+
   if (points.length <= 2) {
     return points;
   }
@@ -90,6 +138,36 @@ export function douglasPeucker(points, tolerance) {
  * @returns {Array<{x: number, y: number}>} Simplified points
  */
 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');
+  }
+  if (points.length === 0) {
+    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 (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`);
+    }
+  }
+
+  // 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 (minArea < 0) {
+    throw new RangeError('visvalingamWhyatt: minArea cannot be negative');
+  }
+
   if (points.length <= 2) {
     return points;
   }
@@ -171,6 +249,31 @@ export function visvalingamWhyatt(points, minArea) {
  * @returns {Array<{x: number, y: number}>} Simplified points
  */
 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');
+  }
+  if (points.length === 0) {
+    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 (tolerance < 0) {
+    throw new RangeError('simplifyPolyline: tolerance cannot be negative');
+  }
+
+  // Validate algorithm parameter to ensure only valid algorithms are used
+  if (typeof algorithm !== 'string') {
+    throw new TypeError('simplifyPolyline: algorithm must be a string');
+  }
+  const validAlgorithms = ['douglas-peucker', 'visvalingam'];
+  if (!validAlgorithms.includes(algorithm)) {
+    throw new RangeError(`simplifyPolyline: algorithm must be one of: ${validAlgorithms.join(', ')}`);
+  }
+
   if (algorithm === 'visvalingam') {
     // For Visvalingam, tolerance is the minimum triangle area
     return visvalingamWhyatt(points, tolerance * tolerance);
@@ -184,43 +287,91 @@ export function simplifyPolyline(points, tolerance, algorithm = 'douglas-peucker
  * @returns {Array<{x: number, y: number}>} Extracted points
  */
 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');
+  }
+
   const points = [];
   let cx = 0, cy = 0;
   let startX = 0, startY = 0;
 
-  for (const { command, args } of commands) {
+  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 (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');
+    }
+
+    const { command, args } = cmd;
+
+    // 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}`);
+      }
+    };
+
+    // 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]}`);
+      }
+    };
+
     switch (command) {
       case 'M':
+        requireArgs(2);
+        requireFiniteNumber(0); requireFiniteNumber(1);
         cx = args[0]; cy = args[1];
         startX = cx; startY = cy;
         points.push({ x: cx, y: cy });
         break;
       case 'm':
+        requireArgs(2);
+        requireFiniteNumber(0); requireFiniteNumber(1);
         cx += args[0]; cy += args[1];
         startX = cx; startY = cy;
         points.push({ x: cx, y: cy });
         break;
       case 'L':
+        requireArgs(2);
+        requireFiniteNumber(0); requireFiniteNumber(1);
         cx = args[0]; cy = args[1];
         points.push({ x: cx, y: cy });
         break;
       case 'l':
+        requireArgs(2);
+        requireFiniteNumber(0); requireFiniteNumber(1);
         cx += args[0]; cy += args[1];
         points.push({ x: cx, y: cy });
         break;
       case 'H':
+        requireArgs(1);
+        requireFiniteNumber(0);
         cx = args[0];
         points.push({ x: cx, y: cy });
         break;
       case 'h':
+        requireArgs(1);
+        requireFiniteNumber(0);
         cx += args[0];
         points.push({ x: cx, y: cy });
         break;
       case 'V':
+        requireArgs(1);
+        requireFiniteNumber(0);
         cy = args[0];
         points.push({ x: cx, y: cy });
         break;
       case 'v':
+        requireArgs(1);
+        requireFiniteNumber(0);
         cy += args[0];
         points.push({ x: cx, y: cy });
         break;
@@ -233,21 +384,39 @@ export function extractPolylinePoints(commands) {
         break;
       // For curves (C, S, Q, T, A), we just track the endpoint
       case 'C':
+        requireArgs(6);
+        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':
+        requireArgs(4);
+        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':
+        requireArgs(2);
+        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':
+        requireArgs(7);
+        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;
+      default:
+        break;
     }
   }
 
@@ -261,8 +430,32 @@ export function extractPolylinePoints(commands) {
  * @returns {Array<{command: string, args: number[]}>} Path 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');
+  }
+
   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');
+  }
+
+  // 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 (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`);
+    }
+  }
+
   const commands = [];
 
   // First point is M
@@ -286,8 +479,19 @@ export function rebuildPathFromPoints(points, closed = false) {
  * @returns {boolean} True if pure polyline
  */
 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 => polylineCommands.has(cmd.command));
+  return commands.every(cmd => {
+    // Validate each command has the required structure to prevent undefined access
+    if (!cmd || typeof cmd !== 'object' || typeof cmd.command !== 'string') {
+      return false;
+    }
+    return polylineCommands.has(cmd.command);
+  });
 }
 
 /**
@@ -298,6 +502,19 @@ export function isPurePolyline(commands) {
  * @returns {{commands: Array<{command: string, args: number[]}>, simplified: boolean, originalPoints: number, simplifiedPoints: number}}
  */
 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');
+  }
+
+  // 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 (tolerance < 0) {
+    throw new RangeError('simplifyPath: tolerance cannot be negative');
+  }
+
   if (!isPurePolyline(commands) || commands.length < 3) {
     return {
       commands,