svger-cli 4.0.2 → 4.0.3

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/shape-conversion.js

@@ -144,8 +144,9 @@ function shouldConvert(element, pathData, threshold) {
 function convertShapeToPath(node, threshold) {
     const tag = node.tag;
     let pathData = null;
-    switch (tag) {
-        case 'rect': {
+    // O(1) object lookup for shape tag → path converter
+    const shapeConverters = {
+        rect: () => {
             const x = parseFloat(node.attrs.get('x') || '0');
             const y = parseFloat(node.attrs.get('y') || '0');
             const width = parseFloat(node.attrs.get('width') || '0');
@@ -156,41 +157,35 @@ function convertShapeToPath(node, threshold) {
             const ry = node.attrs.has('ry')
                 ? parseFloat(node.attrs.get('ry'))
                 : undefined;
-            pathData = rectToPath(x, y, width, height, rx, ry);
-            break;
-        }
-        case 'circle': {
+            return rectToPath(x, y, width, height, rx, ry);
+        },
+        circle: () => {
             const cx = parseFloat(node.attrs.get('cx') || '0');
             const cy = parseFloat(node.attrs.get('cy') || '0');
             const r = parseFloat(node.attrs.get('r') || '0');
-            pathData = circleToPath(cx, cy, r);
-            break;
-        }
-        case 'ellipse': {
+            return circleToPath(cx, cy, r);
+        },
+        ellipse: () => {
             const cx = parseFloat(node.attrs.get('cx') || '0');
             const cy = parseFloat(node.attrs.get('cy') || '0');
             const rx = parseFloat(node.attrs.get('rx') || '0');
             const ry = parseFloat(node.attrs.get('ry') || '0');
-            pathData = ellipseToPath(cx, cy, rx, ry);
-            break;
-        }
-        case 'polygon': {
+            return ellipseToPath(cx, cy, rx, ry);
+        },
+        polygon: () => {
             const points = node.attrs.get('points');
-            if (points) {
-                pathData = polygonToPath(points);
-            }
-            break;
-        }
-        case 'polyline': {
+            return points ? polygonToPath(points) : null;
+        },
+        polyline: () => {
             const points = node.attrs.get('points');
-            if (points) {
-                pathData = polylineToPath(points);
-            }
-            break;
-        }
-        default:
-            return { converted: false, savings: 0 };
+            return points ? polylineToPath(points) : null;
+        },
+    };
+    const converter = shapeConverters[tag];
+    if (!converter) {
+        return { converted: false, savings: 0 };
     }
+    pathData = converter();
     // Check if conversion was possible
     if (!pathData) {
         return { converted: false, savings: 0 };

package/dist/optimizers/transform-collapsing.js

@@ -220,21 +220,17 @@ function applyTransformToPath(node, matrix) {
  * Apply transform to shape coordinates
  */
 function applyTransformToShape(node, matrix) {
-    switch (node.tag) {
-        case 'rect':
-            return applyTransformToRect(node, matrix);
-        case 'circle':
-            return applyTransformToCircle(node, matrix);
-        case 'line':
-            return applyTransformToLine(node, matrix);
-        case 'polygon':
-        case 'polyline':
-            return applyTransformToPoints(node, matrix);
-        case 'path':
-            return applyTransformToPath(node, matrix);
-        default:
-            return false;
-    }
+    // O(1) object lookup for shape tag → transform handler
+    const shapeHandlers = {
+        rect: applyTransformToRect,
+        circle: applyTransformToCircle,
+        line: applyTransformToLine,
+        polygon: applyTransformToPoints,
+        polyline: applyTransformToPoints,
+        path: applyTransformToPath,
+    };
+    const handler = shapeHandlers[node.tag];
+    return handler ? handler(node, matrix) : false;
 }
 /**
  * Collapse transforms by propagating down the tree

package/dist/optimizers/transform-optimizer.js

@@ -67,32 +67,27 @@ function multiplyMatrices(m1, m2) {
  */
 function transformToMatrix(transform) {
     const { type, values } = transform;
-    switch (type) {
-        case 'matrix':
-            if (values.length === 6) {
-                return values;
-            }
-            return IDENTITY_MATRIX;
-        case 'translate': {
+    // O(1) object lookup for transform type → matrix factory
+    const matrixFactories = {
+        matrix: () => (values.length === 6 ? values : IDENTITY_MATRIX),
+        translate: () => {
             const tx = values[0] || 0;
             const ty = values[1] || 0;
             return [1, 0, 0, 1, tx, ty];
-        }
-        case 'scale': {
+        },
+        scale: () => {
             const sx = values[0] || 1;
             const sy = values[1] !== undefined ? values[1] : sx;
             return [sx, 0, 0, sy, 0, 0];
-        }
-        case 'rotate': {
+        },
+        rotate: () => {
             const angle = values[0] || 0;
             const rad = (angle * Math.PI) / 180;
             const cos = Math.cos(rad);
             const sin = Math.sin(rad);
-            // Rotate around point (cx, cy) if provided
             if (values.length === 3) {
                 const cx = values[1];
                 const cy = values[2];
-                // translate(-cx, -cy) × rotate(angle) × translate(cx, cy)
                 return [
                     cos,
                     sin,
@@ -103,22 +98,22 @@ function transformToMatrix(transform) {
                 ];
             }
             return [cos, sin, -sin, cos, 0, 0];
-        }
-        case 'skewX': {
+        },
+        skewX: () => {
             const angle = values[0] || 0;
             const rad = (angle * Math.PI) / 180;
             const tan = Math.tan(rad);
             return [1, 0, tan, 1, 0, 0];
-        }
-        case 'skewY': {
+        },
+        skewY: () => {
             const angle = values[0] || 0;
             const rad = (angle * Math.PI) / 180;
             const tan = Math.tan(rad);
             return [1, tan, 0, 1, 0, 0];
-        }
-        default:
-            return IDENTITY_MATRIX;
-    }
+        },
+    };
+    const factory = matrixFactories[type];
+    return factory ? factory() : IDENTITY_MATRIX;
 }
 /**
  * Consolidate transform list into single matrix