svger-cli 4.0.1 → 4.0.3

package/dist/index.js

@@ -4,10 +4,16 @@
  * A high-performance, framework-agnostic SVG processing toolkit with enterprise-grade
  * architecture and comprehensive styling capabilities.
  *
- * @version 2.0.0
  * @author SVGER-CLI Development Team
  * @license MIT
  */
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+// Get package version dynamically
+const __index_filename = fileURLToPath(import.meta.url);
+const __index_dirname = dirname(__index_filename);
+const __packageJson = JSON.parse(readFileSync(join(__index_dirname, '../package.json'), 'utf-8'));
 // ============================================================================
 // CORE SERVICES
 // ============================================================================
@@ -149,7 +155,7 @@ export const SVGER = {
 /**
  * Package Version Information
  */
-export const VERSION = '2.0.0';
+export const VERSION = __packageJson.version;
 export const PACKAGE_NAME = 'svger-cli';
 // ============================================================================
 // BUILD TOOL INTEGRATIONS

package/dist/integrations/jest-preset.js

@@ -72,12 +72,40 @@ module.exports.default = ${componentName};
         }
     },
 };
+/**
+ * Synchronous SVG content cleaning for Jest compatibility.
+ * svgProcessor.cleanSVGContent() is async (uses optimizer pipeline) and cannot
+ * be called from Jest's synchronous process() method. This provides equivalent
+ * basic cleaning without the async optimizer pipeline.
+ */
+function cleanSVGContentSync(svgContent) {
+    return (svgContent
+        // Remove XML declaration
+        .replace(/<\?xml.*?\?>/g, '')
+        // Remove DOCTYPE declaration
+        .replace(/<!DOCTYPE.*?>/g, '')
+        // Remove comments
+        .replace(/<!--[\s\S]*?-->/g, '')
+        // Normalize whitespace
+        .replace(/\r?\n|\r/g, '')
+        .replace(/\s{2,}/g, ' ')
+        // Remove xmlns attributes
+        .replace(/\s+xmlns(:xlink)?="[^"]*"/g, '')
+        // Remove metadata
+        .replace(/<metadata[\s\S]*?<\/metadata>/gi, '')
+        .replace(/<title[\s\S]*?<\/title>/gi, '')
+        .replace(/<desc[\s\S]*?<\/desc>/gi, '')
+        .trim()
+        // Extract inner content from <svg> tag
+        .replace(/^<svg[^>]*>([\s\S]*)<\/svg>$/i, '$1')
+        .trim());
+}
 /**
  * Generate component synchronously (for Jest compatibility)
  */
 function generateComponentSync(componentName, svgContent, options) {
-    // Clean SVG content
-    const cleanedContent = svgProcessor.cleanSVGContent(svgContent);
+    // Clean SVG content synchronously (cleanSVGContent is async and cannot be used here)
+    const cleanedContent = cleanSVGContentSync(svgContent);
     // For Jest, we'll generate a simple React component
     const viewBox = svgProcessor.extractViewBox(svgContent);
     const template = `

package/dist/lock.js

@@ -7,7 +7,7 @@ const LOCK_FILE = '.svg-lock';
  * @returns {string} Absolute path to .svg-lock
  */
 function getLockFilePath() {
-    return path.resolve(LOCK_FILE);
+    return path.resolve(process.cwd(), LOCK_FILE);
 }
 /**
  * Read the current locked SVG files from the lock file.

package/dist/optimizers/basic-cleaner.js

@@ -204,6 +204,10 @@ export function sortAttributes(svg, config) {
         const attrRegex = /([a-zA-Z][a-zA-Z0-9-]*)="([^"]*)"/g;
         let attrMatch;
         while ((attrMatch = attrRegex.exec(attrs)) !== null) {
+            // Prevent infinite loop if regex doesn't advance
+            if (attrMatch.index === attrRegex.lastIndex) {
+                attrRegex.lastIndex++;
+            }
             attrPairs.push([attrMatch[1], attrMatch[2]]);
         }
         // Sort alphabetically

package/dist/optimizers/path-parser.js

@@ -37,16 +37,55 @@ const COMMAND_PARAMS = {
     z: 0, // no params
 };
 /**
- * Check if character is a path command letter
+ * Check if character is a path command letter - O(1) Set lookup
  */
+const COMMAND_LETTERS = new Set([
+    'M',
+    'm',
+    'L',
+    'l',
+    'H',
+    'h',
+    'V',
+    'v',
+    'C',
+    'c',
+    'S',
+    's',
+    'Q',
+    'q',
+    'T',
+    't',
+    'A',
+    'a',
+    'Z',
+    'z',
+]);
 function isCommandLetter(char) {
-    return /[MmLlHhVvCcSsQqTtAaZz]/.test(char);
+    return COMMAND_LETTERS.has(char);
 }
 /**
- * Check if character is numeric (digit, decimal, sign, exponent)
+ * Check if character is numeric (digit, decimal, sign, exponent) - O(1) Set lookup
  */
+const NUMERIC_CHARS = new Set([
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    '.',
+    'e',
+    'E',
+    '+',
+    '-',
+]);
 function isNumericChar(char) {
-    return /[\d.eE+-]/.test(char);
+    return NUMERIC_CHARS.has(char);
 }
 /**
  * Tokenize path string into array of tokens (commands and numbers)
@@ -158,67 +197,87 @@ export function parsePath(pathData) {
             // Skip incomplete command
             continue;
         }
-        // Update current position
+        // Update current position using O(1) object lookup instead of switch
         const isUpperCase = currentCommand === currentCommand.toUpperCase();
         if (isUpperCase) {
-            // Absolute commands
-            switch (currentCommand) {
-                case 'M':
-                case 'L':
-                case 'T':
-                    currentX = values[values.length - 2];
-                    currentY = values[values.length - 1];
-                    break;
-                case 'H':
-                    currentX = values[values.length - 1];
-                    break;
-                case 'V':
-                    currentY = values[values.length - 1];
-                    break;
-                case 'C':
-                    currentX = values[values.length - 2];
-                    currentY = values[values.length - 1];
-                    break;
-                case 'S':
-                case 'Q':
-                    currentX = values[values.length - 2];
-                    currentY = values[values.length - 1];
-                    break;
-                case 'A':
-                    currentX = values[values.length - 2];
-                    currentY = values[values.length - 1];
-                    break;
-            }
+            // Absolute position update handlers
+            const absoluteHandlers = {
+                M: v => {
+                    currentX = v[v.length - 2];
+                    currentY = v[v.length - 1];
+                },
+                L: v => {
+                    currentX = v[v.length - 2];
+                    currentY = v[v.length - 1];
+                },
+                T: v => {
+                    currentX = v[v.length - 2];
+                    currentY = v[v.length - 1];
+                },
+                H: v => {
+                    currentX = v[v.length - 1];
+                },
+                V: v => {
+                    currentY = v[v.length - 1];
+                },
+                C: v => {
+                    currentX = v[v.length - 2];
+                    currentY = v[v.length - 1];
+                },
+                S: v => {
+                    currentX = v[v.length - 2];
+                    currentY = v[v.length - 1];
+                },
+                Q: v => {
+                    currentX = v[v.length - 2];
+                    currentY = v[v.length - 1];
+                },
+                A: v => {
+                    currentX = v[v.length - 2];
+                    currentY = v[v.length - 1];
+                },
+            };
+            absoluteHandlers[currentCommand]?.(values);
         }
         else {
-            // Relative commands
-            switch (currentCommand) {
-                case 'm':
-                case 'l':
-                case 't':
-                    currentX += values[values.length - 2];
-                    currentY += values[values.length - 1];
-                    break;
-                case 'h':
-                    currentX += values[values.length - 1];
-                    break;
-                case 'v':
-                    currentY += values[values.length - 1];
-                    break;
-                case 'c':
-                    currentX += values[values.length - 2];
-                    currentY += values[values.length - 1];
-                    break;
-                case 's':
-                case 'q':
-                    currentX += values[values.length - 2];
-                    currentY += values[values.length - 1];
-                    break;
-                case 'a':
-                    currentX += values[values.length - 2];
-                    currentY += values[values.length - 1];
-                    break;
-            }
+            // Relative position update handlers
+            const relativeHandlers = {
+                m: v => {
+                    currentX += v[v.length - 2];
+                    currentY += v[v.length - 1];
+                },
+                l: v => {
+                    currentX += v[v.length - 2];
+                    currentY += v[v.length - 1];
+                },
+                t: v => {
+                    currentX += v[v.length - 2];
+                    currentY += v[v.length - 1];
+                },
+                h: v => {
+                    currentX += v[v.length - 1];
+                },
+                v: v => {
+                    currentY += v[v.length - 1];
+                },
+                c: v => {
+                    currentX += v[v.length - 2];
+                    currentY += v[v.length - 1];
+                },
+                s: v => {
+                    currentX += v[v.length - 2];
+                    currentY += v[v.length - 1];
+                },
+                q: v => {
+                    currentX += v[v.length - 2];
+                    currentY += v[v.length - 1];
+                },
+                a: v => {
+                    currentX += v[v.length - 2];
+                    currentY += v[v.length - 1];
+                },
+            };
+            relativeHandlers[currentCommand]?.(values);
         }
         // Store command with absolute position
         commands.push({
@@ -248,33 +307,40 @@ export function toAbsolute(cmd, prevX = 0, prevY = 0) {
     if (type === type.toUpperCase()) {
         return cmd;
     }
-    // Convert relative to absolute
+    // Convert relative to absolute using O(1) lookup
     const absoluteType = type.toUpperCase();
     const values = [...cmd.values];
-    switch (type) {
-        case 'm':
-        case 'l':
-        case 't':
-            // x y → x+prevX y+prevY
+    // Transformation strategies keyed by command letter
+    const transformers = {
+        m: () => {
             for (let i = 0; i < values.length; i += 2) {
                 values[i] += prevX;
                 values[i + 1] += prevY;
             }
-            break;
-        case 'h':
-            // x → x+prevX
+        },
+        l: () => {
+            for (let i = 0; i < values.length; i += 2) {
+                values[i] += prevX;
+                values[i + 1] += prevY;
+            }
+        },
+        t: () => {
+            for (let i = 0; i < values.length; i += 2) {
+                values[i] += prevX;
+                values[i + 1] += prevY;
+            }
+        },
+        h: () => {
             for (let i = 0; i < values.length; i++) {
                 values[i] += prevX;
             }
-            break;
-        case 'v':
-            // y → y+prevY
+        },
+        v: () => {
             for (let i = 0; i < values.length; i++) {
                 values[i] += prevY;
             }
-            break;
-        case 'c':
-            // x1 y1 x2 y2 x y → all +prev
+        },
+        c: () => {
             for (let i = 0; i < values.length; i += 6) {
                 values[i] += prevX;
                 values[i + 1] += prevY;
@@ -283,28 +349,34 @@ export function toAbsolute(cmd, prevX = 0, prevY = 0) {
                 values[i + 4] += prevX;
                 values[i + 5] += prevY;
             }
-            break;
-        case 's':
-        case 'q':
-            // x1 y1 x y → all +prev
+        },
+        s: () => {
+            for (let i = 0; i < values.length; i += 4) {
+                values[i] += prevX;
+                values[i + 1] += prevY;
+                values[i + 2] += prevX;
+                values[i + 3] += prevY;
+            }
+        },
+        q: () => {
             for (let i = 0; i < values.length; i += 4) {
                 values[i] += prevX;
                 values[i + 1] += prevY;
                 values[i + 2] += prevX;
                 values[i + 3] += prevY;
             }
-            break;
-        case 'a':
-            // rx ry rotation large-arc sweep x y → only x,y +prev
+        },
+        a: () => {
             for (let i = 0; i < values.length; i += 7) {
                 values[i + 5] += prevX;
                 values[i + 6] += prevY;
             }
-            break;
-        case 'z':
-            // No conversion needed
-            break;
-    }
+        },
+        z: () => {
+            /* No conversion needed */
+        },
+    };
+    transformers[type]?.();
     return {
         type: absoluteType,
         values,
@@ -320,33 +392,39 @@ export function toRelative(cmd, prevX = 0, prevY = 0) {
     if (type === type.toLowerCase()) {
         return cmd;
     }
-    // Convert absolute to relative
+    // Convert absolute to relative using O(1) lookup
     const relativeType = type.toLowerCase();
     const values = [...cmd.values];
-    switch (type) {
-        case 'M':
-        case 'L':
-        case 'T':
-            // x y → x-prevX y-prevY
+    const transformers = {
+        M: () => {
+            for (let i = 0; i < values.length; i += 2) {
+                values[i] -= prevX;
+                values[i + 1] -= prevY;
+            }
+        },
+        L: () => {
+            for (let i = 0; i < values.length; i += 2) {
+                values[i] -= prevX;
+                values[i + 1] -= prevY;
+            }
+        },
+        T: () => {
             for (let i = 0; i < values.length; i += 2) {
                 values[i] -= prevX;
                 values[i + 1] -= prevY;
             }
-            break;
-        case 'H':
-            // x → x-prevX
+        },
+        H: () => {
             for (let i = 0; i < values.length; i++) {
                 values[i] -= prevX;
             }
-            break;
-        case 'V':
-            // y → y-prevY
+        },
+        V: () => {
             for (let i = 0; i < values.length; i++) {
                 values[i] -= prevY;
             }
-            break;
-        case 'C':
-            // x1 y1 x2 y2 x y → all -prev
+        },
+        C: () => {
             for (let i = 0; i < values.length; i += 6) {
                 values[i] -= prevX;
                 values[i + 1] -= prevY;
@@ -355,28 +433,34 @@ export function toRelative(cmd, prevX = 0, prevY = 0) {
                 values[i + 4] -= prevX;
                 values[i + 5] -= prevY;
             }
-            break;
-        case 'S':
-        case 'Q':
-            // x1 y1 x y → all -prev
+        },
+        S: () => {
             for (let i = 0; i < values.length; i += 4) {
                 values[i] -= prevX;
                 values[i + 1] -= prevY;
                 values[i + 2] -= prevX;
                 values[i + 3] -= prevY;
             }
-            break;
-        case 'A':
-            // rx ry rotation large-arc sweep x y → only x,y -prev
+        },
+        Q: () => {
+            for (let i = 0; i < values.length; i += 4) {
+                values[i] -= prevX;
+                values[i + 1] -= prevY;
+                values[i + 2] -= prevX;
+                values[i + 3] -= prevY;
+            }
+        },
+        A: () => {
             for (let i = 0; i < values.length; i += 7) {
                 values[i + 5] -= prevX;
                 values[i + 6] -= prevY;
             }
-            break;
-        case 'Z':
-            // No conversion needed
-            break;
-    }
+        },
+        Z: () => {
+            /* No conversion needed */
+        },
+    };
+    transformers[type]?.();
     return {
         type: relativeType,
         values,

package/dist/optimizers/path-simplifier.js

@@ -179,45 +179,48 @@ function extractLinearPoints(commands, startX, startY) {
     for (let i = 0; i < commands.length; i++) {
         const cmd = commands[i];
         const isRelative = cmd.type === cmd.type.toLowerCase();
-        switch (cmd.type.toUpperCase()) {
-            case 'L': {
+        const upperType = cmd.type.toUpperCase();
+        // O(1) object lookup for command type → point extraction
+        const pointExtractors = {
+            L: () => {
                 const x = isRelative ? currentX + cmd.values[0] : cmd.values[0];
                 const y = isRelative ? currentY + cmd.values[1] : cmd.values[1];
                 points.push({ x, y, cmdIndex: i + 1 });
                 indices.push(i + 1);
                 currentX = x;
                 currentY = y;
-                break;
-            }
-            case 'H': {
+            },
+            H: () => {
                 const x = isRelative ? currentX + cmd.values[0] : cmd.values[0];
                 points.push({ x, y: currentY, cmdIndex: i + 1 });
                 indices.push(i + 1);
                 currentX = x;
-                break;
-            }
-            case 'V': {
+            },
+            V: () => {
                 const y = isRelative ? currentY + cmd.values[0] : cmd.values[0];
                 points.push({ x: currentX, y, cmdIndex: i + 1 });
                 indices.push(i + 1);
                 currentY = y;
-                break;
+            },
+        };
+        const extractor = pointExtractors[upperType];
+        if (extractor) {
+            extractor();
+        }
+        else {
+            // Update position for other commands but don't add to points
+            if (upperType === 'M') {
+                currentX = isRelative ? currentX + cmd.values[0] : cmd.values[0];
+                currentY = isRelative ? currentY + cmd.values[1] : cmd.values[1];
+            }
+            else if (upperType === 'C') {
+                currentX = isRelative ? currentX + cmd.values[4] : cmd.values[4];
+                currentY = isRelative ? currentY + cmd.values[5] : cmd.values[5];
+            }
+            else if (upperType === 'Q') {
+                currentX = isRelative ? currentX + cmd.values[2] : cmd.values[2];
+                currentY = isRelative ? currentY + cmd.values[3] : cmd.values[3];
             }
-            default:
-                // Update position for other commands but don't add to points
-                if (cmd.type.toUpperCase() === 'M') {
-                    currentX = isRelative ? currentX + cmd.values[0] : cmd.values[0];
-                    currentY = isRelative ? currentY + cmd.values[1] : cmd.values[1];
-                }
-                else if (cmd.type.toUpperCase() === 'C') {
-                    currentX = isRelative ? currentX + cmd.values[4] : cmd.values[4];
-                    currentY = isRelative ? currentY + cmd.values[5] : cmd.values[5];
-                }
-                else if (cmd.type.toUpperCase() === 'Q') {
-                    currentX = isRelative ? currentX + cmd.values[2] : cmd.values[2];
-                    currentY = isRelative ? currentY + cmd.values[3] : cmd.values[3];
-                }
-                break;
         }
     }
     return { points, indices };

package/dist/optimizers/remove-unused-defs.js

@@ -39,12 +39,20 @@ function findReferencedIds(root) {
                 let match;
                 URL_REFERENCE_REGEX.lastIndex = 0;
                 while ((match = URL_REFERENCE_REGEX.exec(attrValue)) !== null) {
+                    // Prevent infinite loop if regex doesn't advance
+                    if (match.index === URL_REFERENCE_REGEX.lastIndex) {
+                        URL_REFERENCE_REGEX.lastIndex++;
+                    }
                     referencedIds.add(match[1]);
                 }
                 // Check for #id pattern (href, xlink:href)
                 if (attrName === 'href' || attrName === 'xlink:href') {
                     HREF_REFERENCE_REGEX.lastIndex = 0;
                     while ((match = HREF_REFERENCE_REGEX.exec(attrValue)) !== null) {
+                        // Prevent infinite loop if regex doesn't advance
+                        if (match.index === HREF_REFERENCE_REGEX.lastIndex) {
+                            HREF_REFERENCE_REGEX.lastIndex++;
+                        }
                         referencedIds.add(match[1]);
                     }
                 }
@@ -56,6 +64,10 @@ function findReferencedIds(root) {
             let match;
             URL_REFERENCE_REGEX.lastIndex = 0;
             while ((match = URL_REFERENCE_REGEX.exec(style)) !== null) {
+                // Prevent infinite loop if regex doesn't advance
+                if (match.index === URL_REFERENCE_REGEX.lastIndex) {
+                    URL_REFERENCE_REGEX.lastIndex++;
+                }
                 referencedIds.add(match[1]);
             }
         }
@@ -64,6 +76,10 @@ function findReferencedIds(root) {
             let match;
             URL_REFERENCE_REGEX.lastIndex = 0;
             while ((match = URL_REFERENCE_REGEX.exec(node.content)) !== null) {
+                // Prevent infinite loop if regex doesn't advance
+                if (match.index === URL_REFERENCE_REGEX.lastIndex) {
+                    URL_REFERENCE_REGEX.lastIndex++;
+                }
                 referencedIds.add(match[1]);
             }
         }