@emasoft/svg-matrix 1.0.31 → 1.0.33

package/README.md

@@ -500,13 +500,13 @@ SVGFlatten.resolveLength('1in', 96);   // 96
 Find and fix problems:
 
 ```js
-import { validateSvg, fixInvalidSvg } from '@emasoft/svg-matrix';
+import { validateSVG, fixInvalidSVG } from '@emasoft/svg-matrix';
 
-const result = await validateSvg('icon.svg');
+const result = await validateSVG('icon.svg');
 console.log(result.valid);    // true/false
 console.log(result.issues);   // Array of problems
 
-const fixed = await fixInvalidSvg('broken.svg');
+const fixed = await fixInvalidSVG('broken.svg');
 console.log(fixed.svg);       // Fixed SVG string
 ```
 

package/bin/svg-matrix.js

@@ -2043,32 +2043,37 @@ function parseArgs(args) {
 
     switch (arg) {
       case "-o":
-      case "--output":
-        if (i + 1 >= args.length) {
-          logError("-o/--output requires a value");
+      case "--output": {
+        const value = argValue || (i + 1 < args.length ? args[++i] : null);
+        if (!value || !value.trim()) {
+          logError("-o/--output requires a non-empty value");
           process.exit(CONSTANTS.EXIT_ERROR);
         }
-        cfg.output = args[++i];
+        cfg.output = value.trim();
         break;
+      }
       case "-l":
-      case "--list":
-        if (i + 1 >= args.length) {
-          logError("-l/--list requires a value");
+      case "--list": {
+        const value = argValue || (i + 1 < args.length ? args[++i] : null);
+        if (!value || !value.trim()) {
+          logError("-l/--list requires a non-empty value");
           process.exit(CONSTANTS.EXIT_ERROR);
         }
-        cfg.listFile = args[++i];
+        cfg.listFile = value.trim();
         break;
+      }
       case "-r":
       case "--recursive":
         cfg.recursive = true;
         break;
       case "-p":
       case "--precision": {
-        if (i + 1 >= args.length) {
+        const value = argValue || (i + 1 < args.length ? args[++i] : null);
+        if (!value) {
           logError("-p/--precision requires a value");
           process.exit(CONSTANTS.EXIT_ERROR);
         }
-        const precision = parseInt(args[++i], 10);
+        const precision = parseInt(value, 10);
         if (
           isNaN(precision) ||
           precision < CONSTANTS.MIN_PRECISION ||
@@ -2098,13 +2103,15 @@ function parseArgs(args) {
       case "--verbose":
         cfg.verbose = true;
         break;
-      case "--log-file":
-        if (i + 1 >= args.length) {
-          logError("--log-file requires a value");
+      case "--log-file": {
+        const value = argValue || (i + 1 < args.length ? args[++i] : null);
+        if (!value || !value.trim()) {
+          logError("--log-file requires a non-empty value");
           process.exit(CONSTANTS.EXIT_ERROR);
         }
-        cfg.logFile = args[++i];
+        cfg.logFile = value.trim();
         break;
+      }
       case "-h":
       case "--help":
         // If a command is already set (not 'help'), show command-specific help
@@ -2185,11 +2192,12 @@ function parseArgs(args) {
         break;
       // E2E verification precision options
       case "--clip-segments": {
-        if (i + 1 >= args.length) {
+        const value = argValue || (i + 1 < args.length ? args[++i] : null);
+        if (!value) {
           logError("--clip-segments requires a value");
           process.exit(CONSTANTS.EXIT_ERROR);
         }
-        const segs = parseInt(args[++i], 10);
+        const segs = parseInt(value, 10);
         if (isNaN(segs) || segs < 8 || segs > 512) {
           logError("clip-segments must be between 8 and 512");
           process.exit(CONSTANTS.EXIT_ERROR);
@@ -2198,11 +2206,12 @@ function parseArgs(args) {
         break;
       }
       case "--bezier-arcs": {
-        if (i + 1 >= args.length) {
+        const value = argValue || (i + 1 < args.length ? args[++i] : null);
+        if (!value) {
           logError("--bezier-arcs requires a value");
           process.exit(CONSTANTS.EXIT_ERROR);
         }
-        const arcs = parseInt(args[++i], 10);
+        const arcs = parseInt(value, 10);
         if (isNaN(arcs) || arcs < 4 || arcs > 128) {
           logError("bezier-arcs must be between 4 and 128");
           process.exit(CONSTANTS.EXIT_ERROR);
@@ -2216,16 +2225,16 @@ function parseArgs(args) {
         break;
       }
       case "--e2e-tolerance": {
-        if (i + 1 >= args.length) {
+        const value = argValue || (i + 1 < args.length ? args[++i] : null);
+        if (!value) {
           logError("--e2e-tolerance requires a value");
           process.exit(CONSTANTS.EXIT_ERROR);
         }
-        const tol = args[++i];
-        if (!/^1e-\d+$/.test(tol)) {
+        if (!/^1e-\d+$/.test(value)) {
           logError("e2e-tolerance must be in format 1e-N (e.g., 1e-10, 1e-12)");
           process.exit(CONSTANTS.EXIT_ERROR);
         }
-        cfg.e2eTolerance = tol;
+        cfg.e2eTolerance = value;
         break;
       }
       // NOTE: --verify removed - verification is ALWAYS enabled
@@ -2254,6 +2263,13 @@ function parseArgs(args) {
     i++;
   }
   cfg.inputs = inputs;
+
+  // Validate conflicting options
+  if (cfg.quiet && cfg.verbose) {
+    logError("Cannot specify both --quiet and --verbose");
+    process.exit(CONSTANTS.EXIT_ERROR);
+  }
+
   return cfg;
 }
 

package/bin/svglinter.cjs

@@ -1192,6 +1192,12 @@ function loadConfig(configPath) {
       try {
         const files = fs.readdirSync(cwd).filter((f) => f.endsWith(pattern));
         if (files.length === 0) continue;
+        // BUG FIX: Warn if multiple files match the pattern
+        if (files.length > 1) {
+          verbose(
+            `Multiple files match pattern '${file}': ${files.join(", ")} - using first: ${files[0]}`,
+          );
+        }
         filepath = path.join(cwd, files[0]);
       } catch (err) {
         verbose(
@@ -2929,9 +2935,11 @@ async function globPromise(pattern) {
     const filePattern = path.basename(pattern);
     // Escape special regex chars, then convert glob * to [^/\\]* instead of .* to prevent
     // catastrophic backtracking and avoid matching across path separators
+    // BUG FIX: Use path.sep instead of hardcoded separators for cross-platform compatibility
+    const pathSepPattern = path.sep === "\\" ? "\\\\" : "/";
     const escapedPattern = escapeRegexCharsForGlob(filePattern).replace(
       /\*/g,
-      "[^/\\\\]*",
+      `[^${pathSepPattern}]*`,
     );
     const regex = new RegExp("^" + escapedPattern + "$");
 
@@ -3152,7 +3160,7 @@ function parseInlineDisables(content) {
   if (currentDisabled !== null) {
     disabledRanges.push({
       startLine: currentDisabled,
-      endLine: lines.length + 1,
+      endLine: lines.length, // BUG FIX: Use lines.length not lines.length + 1 to avoid off-by-one
       rules: disabledRules,
     });
   }
@@ -3615,6 +3623,17 @@ function truncateLineAroundColumn(line, column, maxWidth, _isErrorLine) {
   const safeColumn = Number.isFinite(column) && column >= 1 ? column : 1;
   const col = safeColumn - 1; // Convert to 0-based
 
+  // BUG FIX: Handle column beyond line length edge case
+  if (col >= expandedLine.length) {
+    // Column points beyond the line - clamp to end of line
+    const clampedCol = Math.max(0, expandedLine.length - 1);
+    return {
+      text: expandedLine.substring(0, maxWidth),
+      visibleColumn: clampedCol,
+      errorLength: 1,
+    };
+  }
+
   if (expandedLine.length <= maxWidth) {
     // No truncation needed
     return {
@@ -4103,13 +4122,16 @@ async function main() {
     verbose(`Color mode: ${useColors ? "enabled" : "disabled"}`);
   }
 
-  // Validate output format
-  if (!VALID_FORMATS.has(args.format)) {
+  // Validate output format (case-insensitive for better UX)
+  // BUG FIX: Normalize format to lowercase for case-insensitive matching
+  const normalizedFormat = args.format.toLowerCase();
+  if (!VALID_FORMATS.has(normalizedFormat)) {
     const validList = Array.from(VALID_FORMATS).join(", ");
     console.error(c("red", `Error: Invalid format '${args.format}'`));
-    console.error(`Valid formats: ${validList}`);
+    console.error(`Valid formats: ${validList} (case-insensitive)`);
     process.exit(2);
   }
+  args.format = normalizedFormat; // Use normalized format
   verbose(`Output format: ${args.format}`);
 
   // Validate maxLineWidth bounds
@@ -4573,13 +4595,20 @@ async function main() {
     // Validate output file path for safety
     const outputPath = path.resolve(args.outputFile);
     const normalizedOutput = path.normalize(outputPath);
-    const dangerousPaths = [
-      "/dev/",
-      "/proc/",
-      "/sys/",
-      "/etc/passwd",
-      "/etc/shadow",
-    ];
+    // BUG FIX: Only apply Unix dangerous paths on Unix systems (not Windows with drive letters)
+    const isWindows = process.platform === "win32";
+    const dangerousPaths = isWindows
+      ? [
+          // Windows-specific dangerous paths (don't block C:\dev\ which is a common dev folder)
+        ]
+      : [
+          // Unix-specific dangerous paths
+          "/dev/",
+          "/proc/",
+          "/sys/",
+          "/etc/passwd",
+          "/etc/shadow",
+        ];
     // BUG FIX: Use normalized paths and proper segment matching to avoid false positives
     // (e.g., /developer/ should NOT match /dev/)
     const isDangerous = dangerousPaths.some((p) => {

package/bin/svgm.js

@@ -20,6 +20,7 @@ import {
   mkdirSync,
   readdirSync,
   statSync,
+  realpathSync,
 } from "fs";
 import { join, dirname, basename, extname, resolve, isAbsolute } from "path";
 import yaml from "js-yaml";
@@ -383,26 +384,48 @@ function getSvgFiles(dir, recursive = false, exclude = []) {
     throw new TypeError(`getSvgFiles: expected array exclude, got ${typeof exclude}`);
   }
 
+  // Why: Validate and compile regex patterns once before scanning to fail fast
+  const excludeRegexes = [];
+  for (const pattern of exclude) {
+    try {
+      excludeRegexes.push(new RegExp(pattern));
+    } catch (e) {
+      logError(`Invalid exclusion pattern "${pattern}": ${e.message}`);
+      process.exit(CONSTANTS.EXIT_ERROR);
+    }
+  }
+
   const files = [];
+  // Why: Track visited directories to prevent infinite loops from symlinks
+  const visitedDirs = new Set();
+
   function scan(d) {
+    // Why: Resolve real path to detect symlink loops
+    let realPath;
+    try {
+      realPath = normalizePath(realpathSync(d));
+    } catch (e) {
+      // Why: Skip directories that can't be resolved (broken symlinks, permission errors)
+      logError(`Cannot access directory "${d}": ${e.message}`);
+      return;
+    }
+    if (visitedDirs.has(realPath)) {
+      return; // Skip already visited directories (symlink loop detected)
+    }
+    visitedDirs.add(realPath);
+
     for (const entry of readdirSync(d, { withFileTypes: true })) {
       const fullPath = join(d, entry.name);
-      // Check exclusion patterns
-      const shouldExclude = exclude.some((pattern) => {
-        try {
-          // Why: Wrap RegExp constructor in try-catch to handle invalid patterns
-          const regex = new RegExp(pattern);
-          return regex.test(fullPath) || regex.test(entry.name);
-        } catch (_e) {
-          // Why: Catch invalid regex patterns (unused error marked with underscore per ESLint)
-          logError(`Invalid exclusion pattern: ${pattern}`);
-          return false;
-        }
-      });
+
+      // Check exclusion patterns using pre-compiled regexes
+      const shouldExclude = excludeRegexes.some((regex) =>
+        regex.test(fullPath) || regex.test(entry.name)
+      );
       if (shouldExclude) continue;
 
-      if (entry.isDirectory() && recursive) scan(fullPath);
-      else if (
+      if (entry.isDirectory() && recursive) {
+        scan(fullPath);
+      } else if (
         entry.isFile() &&
         CONSTANTS.SVG_EXTENSIONS.includes(extname(entry.name).toLowerCase())
       ) {
@@ -411,7 +434,9 @@ function getSvgFiles(dir, recursive = false, exclude = []) {
     }
   }
   scan(dir);
-  return files;
+
+  // Why: Deduplicate file paths in case same file reached via different routes
+  return [...new Set(files)];
 }
 
 // ============================================================================
@@ -681,7 +706,11 @@ async function processFile(inputPath, outputPath, options) {
     if (outputPath === "-") {
       process.stdout.write(output);
     } else {
-      ensureDir(dirname(outputPath));
+      // Why: Validate output path and ensure parent directory exists
+      const outputDir = dirname(outputPath);
+      if (outputDir && outputDir !== ".") {
+        ensureDir(outputDir);
+      }
       writeFileSync(outputPath, output, "utf8");
     }
 
@@ -932,10 +961,16 @@ function parseArgs(args) {
     let argValue = null;
 
     // Handle --arg=value format
+    // Why: Validate that value after = is not empty to prevent silent failures
     if (arg.includes("=") && arg.startsWith("--")) {
       const eqIdx = arg.indexOf("=");
       argValue = arg.substring(eqIdx + 1);
       arg = arg.substring(0, eqIdx);
+      // Why: Empty value after = is invalid (e.g., --precision=)
+      if (argValue === "") {
+        logError(`${arg} requires a non-empty value`);
+        process.exit(CONSTANTS.EXIT_ERROR);
+      }
     }
 
     switch (arg) {
@@ -953,12 +988,20 @@ function parseArgs(args) {
 
       case "-i":
       case "--input":
-        i++;
-        while (i < args.length && !args[i].startsWith("-")) {
-          inputs.push(args[i]);
+        {
           i++;
+          const startIdx = i;
+          while (i < args.length && !args[i].startsWith("-")) {
+            inputs.push(args[i]);
+            i++;
+          }
+          // Why: Validate at least one input was provided after -i flag
+          if (i === startIdx) {
+            logError(`${arg} requires at least one input file`);
+            process.exit(CONSTANTS.EXIT_ERROR);
+          }
+          i--; // Back up one since the while loop went past
         }
-        i--; // Back up one since the while loop went past
         break;
 
       case "-s":
@@ -984,6 +1027,11 @@ function parseArgs(args) {
           outputs.push(args[i]);
           i++;
         }
+        // Why: Validate at least one output was provided after -o flag
+        if (outputs.length === 0) {
+          logError(`${arg} requires at least one output path`);
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         i--;
         cfg.output = outputs.length === 1 ? outputs[0] : outputs;
         break;
@@ -995,9 +1043,9 @@ function parseArgs(args) {
         {
           const precisionArg = getNextArg(args, i, arg);
           const parsed = parseInt(precisionArg, 10);
-          // Why: Validate parseInt result to prevent NaN values
-          if (isNaN(parsed)) {
-            logError(`--precision requires a valid number, got: ${precisionArg}`);
+          // Why: Validate parseInt result to prevent NaN and negative values
+          if (isNaN(parsed) || parsed < 0) {
+            logError(`--precision requires a non-negative number, got: ${precisionArg}`);
             process.exit(CONSTANTS.EXIT_ERROR);
           }
           cfg.precision = parsed;
@@ -1024,9 +1072,9 @@ function parseArgs(args) {
         {
           const indentArg = getNextArg(args, i, arg);
           const parsed = parseInt(indentArg, 10);
-          // Why: Validate parseInt result to prevent NaN values
-          if (isNaN(parsed)) {
-            logError(`--indent requires a valid number, got: ${indentArg}`);
+          // Why: Validate parseInt result to prevent NaN and negative values
+          if (isNaN(parsed) || parsed < 0) {
+            logError(`--indent requires a non-negative number, got: ${indentArg}`);
             process.exit(CONSTANTS.EXIT_ERROR);
           }
           cfg.indent = parsed;
@@ -1050,12 +1098,20 @@ function parseArgs(args) {
         break;
 
       case "--exclude":
-        i++;
-        while (i < args.length && !args[i].startsWith("-")) {
-          cfg.exclude.push(args[i]);
+        {
           i++;
+          const startIdx = i;
+          while (i < args.length && !args[i].startsWith("-")) {
+            cfg.exclude.push(args[i]);
+            i++;
+          }
+          // Why: Validate at least one exclusion pattern was provided
+          if (i === startIdx) {
+            logError(`${arg} requires at least one exclusion pattern`);
+            process.exit(CONSTANTS.EXIT_ERROR);
+          }
+          i--;
         }
-        i--;
         break;
 
       case "-q":
@@ -1070,9 +1126,10 @@ function parseArgs(args) {
       case "--preserve-ns":
         {
           // Why: Use helper to safely get next argument with bounds checking
-          const val = argValue || getNextArg(args, i, arg);
-          if (!argValue) i++; // Only increment if we used getNextArg
-          if (!val) {
+          const val = argValue !== null ? argValue : getNextArg(args, i, arg);
+          if (argValue === null) i++; // Only increment if we used getNextArg
+          // Why: Validate value is not empty (catches --preserve-ns= with no value)
+          if (!val || val.trim() === "") {
             logError(
               "--preserve-ns requires a comma-separated list of namespaces",
             );
@@ -1082,6 +1139,11 @@ function parseArgs(args) {
             .split(",")
             .map((s) => s.trim().toLowerCase())
             .filter((s) => s.length > 0);
+          // Why: Validate that after filtering empty strings, we have at least one namespace
+          if (cfg.preserveNamespaces.length === 0) {
+            logError("--preserve-ns requires at least one valid namespace");
+            process.exit(CONSTANTS.EXIT_ERROR);
+          }
         }
         break;
 
@@ -1172,9 +1234,9 @@ function parseArgs(args) {
         {
           const depthArg = getNextArg(args, i, arg);
           const parsed = parseInt(depthArg, 10);
-          // Why: Validate parseInt result to prevent NaN values
-          if (isNaN(parsed)) {
-            logError(`--embed-max-depth requires a valid number, got: ${depthArg}`);
+          // Why: Validate parseInt result to prevent NaN and negative/zero values
+          if (isNaN(parsed) || parsed < 1) {
+            logError(`--embed-max-depth requires a positive number, got: ${depthArg}`);
             process.exit(CONSTANTS.EXIT_ERROR);
           }
           cfg.embedMaxRecursionDepth = parsed;
@@ -1187,9 +1249,9 @@ function parseArgs(args) {
         {
           const timeoutArg = getNextArg(args, i, arg);
           const parsed = parseInt(timeoutArg, 10);
-          // Why: Validate parseInt result to prevent NaN values
-          if (isNaN(parsed)) {
-            logError(`--embed-timeout requires a valid number, got: ${timeoutArg}`);
+          // Why: Validate parseInt result to prevent NaN and negative/zero values
+          if (isNaN(parsed) || parsed < 1000) {
+            logError(`--embed-timeout requires a number >= 1000 (ms), got: ${timeoutArg}`);
             process.exit(CONSTANTS.EXIT_ERROR);
           }
           cfg.embedTimeout = parsed;
@@ -1352,6 +1414,16 @@ async function main() {
         ? toDataUri(result, config.datauri)
         : result;
       if (config.output && config.output !== "-") {
+        // Why: Validate output is not an array for string input mode
+        if (Array.isArray(config.output)) {
+          logError("Cannot specify multiple outputs with --string input");
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
+        // Why: Ensure parent directory exists before writing
+        const outputDir = dirname(config.output);
+        if (outputDir && outputDir !== ".") {
+          ensureDir(outputDir);
+        }
         writeFileSync(config.output, output, "utf8");
         log(`${colors.green}Done!${colors.reset}`);
       } else {
@@ -1411,17 +1483,34 @@ async function main() {
 
     if (config.output) {
       if (config.output === "-") {
+        // Why: Validate stdout output only works with single file
+        if (files.length > 1) {
+          logError("Cannot output multiple files to stdout (use -o <dir> instead)");
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
         outputPath = "-";
       } else if (Array.isArray(config.output)) {
-        // Why: Bounds check when accessing array to prevent undefined values
-        if (config.output.length === 0) {
-          logError("Output array is empty");
+        // Why: Validate array length matches input file count or error clearly
+        if (config.output.length !== files.length) {
+          logError(
+            `Output count mismatch: ${files.length} input file(s) but ${config.output.length} output path(s). ` +
+            `Provide either one output directory or exactly ${files.length} output file(s).`
+          );
           process.exit(CONSTANTS.EXIT_ERROR);
         }
-        outputPath = config.output[i] || config.output[config.output.length - 1];
+        outputPath = resolvePath(config.output[i]);
       } else if (files.length > 1 || isDir(resolvePath(config.output))) {
         // Multiple files or output is a directory
-        outputPath = join(resolvePath(config.output), basename(inputPath));
+        const outputDir = resolvePath(config.output);
+        // Why: Validate output is actually a directory when processing multiple files
+        if (files.length > 1 && !isDir(outputDir)) {
+          logError(
+            `Processing ${files.length} files but output "${config.output}" is not a directory. ` +
+            `Create the directory first or provide ${files.length} output paths.`
+          );
+          process.exit(CONSTANTS.EXIT_ERROR);
+        }
+        outputPath = join(outputDir, basename(inputPath));
       } else {
         outputPath = resolvePath(config.output);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emasoft/svg-matrix",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Arbitrary-precision matrix, vector and affine transformation library for JavaScript using decimal.js",
   "type": "module",
   "main": "src/index.js",

package/src/animation-optimization.js

@@ -80,8 +80,8 @@ export function formatSplineValue(value, precision = 3) {
     str = '-' + str.substring(2); // "-0.5" -> "-.5"
   }
 
-  // Handle edge case: ".0" should be "0"
-  if (str === '' || str === '.') str = '0';
+  // Handle edge cases: ".0" should be "0", "-0" should be "0"
+  if (str === '' || str === '.' || str === '-0') str = '0';
 
   return str;
 }
@@ -229,7 +229,7 @@ export function optimizeKeySplines(keySplines, options = {}) {
     return { value: null, allLinear: false, standardEasings: [] };
   }
 
-  // Check for all linear splines (wrap to avoid .every() passing index as tolerance)
+  // Must wrap in arrow function to avoid .every() passing index as tolerance
   const allLinear = splines.every(s => isLinearSpline(s));
 
   // Identify standard easings