svger-cli 3.1.1 → 4.0.0

package/dist/optimizers/basic-cleaner.js

@@ -0,0 +1,198 @@
+/**
+ * Basic SVG Cleaner
+ * Extracts basic cleaning logic from svg-processor for use in optimizer pipeline
+ */
+/**
+ * Remove XML declarations from SVG content
+ */
+export function removeXMLDeclaration(svg, config) {
+    if (!config.removeXMLProcInst)
+        return svg;
+    return svg.replace(/<\?xml.*?\?>/g, '');
+}
+/**
+ * Remove DOCTYPE declarations from SVG content
+ */
+export function removeDoctype(svg, config) {
+    if (!config.removeDoctype)
+        return svg;
+    return svg.replace(/<!DOCTYPE.*?>/g, '');
+}
+/**
+ * Remove comments from SVG content
+ */
+export function removeComments(svg, config) {
+    if (!config.removeComments)
+        return svg;
+    return svg.replace(/<!--[\s\S]*?-->/g, '');
+}
+/**
+ * Normalize whitespace in SVG content
+ */
+export function normalizeWhitespace(svg, config) {
+    if (!config.normalizeWhitespace)
+        return svg;
+    return svg
+        .replace(/\r?\n|\r/g, '') // Remove line breaks
+        .replace(/\s{2,}/g, ' ') // Collapse multiple spaces
+        .trim();
+}
+/**
+ * Remove metadata elements from SVG content
+ */
+export function removeMetadata(svg, config) {
+    if (!config.removeMetadata)
+        return svg;
+    return svg
+        .replace(/<metadata[\s\S]*?<\/metadata>/gi, '')
+        .replace(/<title[\s\S]*?<\/title>/gi, '')
+        .replace(/<desc[\s\S]*?<\/desc>/gi, '');
+}
+/**
+ * Convert kebab-case attributes to camelCase for React compatibility
+ */
+export function convertToCamelCase(svg, config) {
+    if (!config.reactCompatibility)
+        return svg;
+    const attributeMap = {
+        'fill-rule': 'fillRule',
+        'clip-rule': 'clipRule',
+        'stroke-width': 'strokeWidth',
+        'stroke-linecap': 'strokeLinecap',
+        'stroke-linejoin': 'strokeLinejoin',
+        'stroke-miterlimit': 'strokeMiterlimit',
+        'stroke-dasharray': 'strokeDasharray',
+        'stroke-dashoffset': 'strokeDashoffset',
+        'font-family': 'fontFamily',
+        'font-size': 'fontSize',
+        'font-weight': 'fontWeight',
+        'text-anchor': 'textAnchor',
+        'stop-color': 'stopColor',
+        'stop-opacity': 'stopOpacity',
+        'fill-opacity': 'fillOpacity',
+        'stroke-opacity': 'strokeOpacity',
+    };
+    let result = svg;
+    for (const [kebab, camel] of Object.entries(attributeMap)) {
+        const regex = new RegExp(kebab, 'g');
+        result = result.replace(regex, camel);
+    }
+    return result;
+}
+/**
+ * Remove unnecessary XML namespace attributes
+ */
+export function removeXMLNamespaces(svg, config) {
+    if (!config.removeUnnecessaryAttrs)
+        return svg;
+    // Remove xmlns and xmlns:xlink (React handles these automatically)
+    return svg.replace(/\s+xmlns(:xlink)?="[^"]*"/g, '');
+}
+/**
+ * Remove inline style attributes
+ * Note: This can be aggressive - use with caution
+ */
+export function removeInlineStyles(svg, config) {
+    if (!config.inlineStyles)
+        return svg;
+    // Remove style attributes
+    return svg.replace(/\s+style="[^"]*"/g, '');
+}
+/**
+ * Shorten hex colors (#ffffff → #fff)
+ */
+export function shortenColors(svg, config) {
+    if (!config.shortenColors)
+        return svg;
+    // Match 6-digit hex colors that can be shortened
+    return svg.replace(/#([0-9a-f])\1([0-9a-f])\2([0-9a-f])\3/gi, '#$1$2$3');
+}
+/**
+ * Remove empty containers (g, defs without children or with only whitespace)
+ */
+export function removeEmptyContainers(svg, config) {
+    if (!config.removeEmptyContainers)
+        return svg;
+    let result = svg;
+    let previousResult = '';
+    // Iteratively remove empty containers until no more are found
+    while (result !== previousResult) {
+        previousResult = result;
+        result = result
+            .replace(/<g\s*><\/g>/gi, '') // Empty g tags
+            .replace(/<g\s*>\s*<\/g>/gi, '') // g tags with only whitespace
+            .replace(/<defs\s*><\/defs>/gi, '') // Empty defs tags
+            .replace(/<defs\s*>\s*<\/defs>/gi, ''); // defs with only whitespace
+    }
+    return result;
+}
+/**
+ * Remove hidden elements (display:none, opacity:0, visibility:hidden)
+ */
+/**
+ * Remove hidden elements (display:none, opacity:0, visibility:hidden)
+ * NOTE: Disabled because it's too aggressive with regex and breaks complex SVGs.
+ * Use tree-based optimization (remove-hidden-empty.ts) instead for safe removal.
+ */
+export function removeHiddenElements(svg) {
+    // DISABLED: Regex-based removal is too aggressive
+    // Tree-based optimizer handles this correctly
+    return svg;
+}
+/**
+ * Round float numbers to specified precision
+ */
+export function roundFloats(svg, config) {
+    const precision = config.floatPrecision;
+    // Match floating point numbers
+    return svg.replace(/(\d+\.\d+)/g, match => {
+        const num = parseFloat(match);
+        return num.toFixed(precision).replace(/\.?0+$/, ''); // Remove trailing zeros
+    });
+}
+/**
+ * Sort attributes alphabetically
+ */
+export function sortAttributes(svg, config) {
+    if (!config.sortAttrs)
+        return svg;
+    // Match SVG tags with attributes (both self-closing and regular)
+    return svg.replace(/<([a-z][a-z0-9]*)\s+([^>]+?)(\/?)>/gi, (_match, tagName, attrs, selfClosing) => {
+        // Parse attributes
+        const attrPairs = [];
+        const attrRegex = /([a-zA-Z][a-zA-Z0-9-]*)="([^"]*)"/g;
+        let attrMatch;
+        while ((attrMatch = attrRegex.exec(attrs)) !== null) {
+            attrPairs.push([attrMatch[1], attrMatch[2]]);
+        }
+        // Sort alphabetically
+        attrPairs.sort((a, b) => a[0].localeCompare(b[0]));
+        // Reconstruct tag, preserving self-closing status
+        const sortedAttrs = attrPairs
+            .map(([key, val]) => `${key}="${val}"`)
+            .join(' ');
+        return `<${tagName} ${sortedAttrs}${selfClosing}>`;
+    });
+}
+/**
+ * Basic cleaning stage - combines all basic cleaners
+ * This is the main entry point for the optimizer pipeline
+ */
+export async function basicCleaningStage(svg, config) {
+    let result = svg;
+    // Apply cleaners in sequence
+    result = removeXMLDeclaration(result, config);
+    result = removeDoctype(result, config);
+    result = removeComments(result, config);
+    result = removeMetadata(result, config);
+    result = normalizeWhitespace(result, config);
+    result = removeXMLNamespaces(result, config);
+    result = removeInlineStyles(result, config);
+    result = convertToCamelCase(result, config);
+    result = shortenColors(result, config);
+    result = roundFloats(result, config);
+    result = removeEmptyContainers(result, config);
+    result = removeHiddenElements(result);
+    result = sortAttributes(result, config);
+    return result;
+}

package/dist/optimizers/collapse-useless-groups.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Collapse Useless Groups
+ * Remove <g> with no attrs and single child
+ * Merge attrs upward if safe (no conflicts)
+ */
+import type { SVGNode } from './svg-tree-parser.js';
+/**
+ * Collapse useless groups in the tree
+ * A group is useless if:
+ * 1. It has no attributes and exactly one child
+ * 2. It has attributes that don't conflict with its single child
+ */
+export declare function collapseUselessGroups(root: SVGNode): {
+    collapsedCount: number;
+    collapsedNodes: string[];
+};
+/**
+ * Collapse useless groups stage
+ */
+export declare function collapseUselessGroupsStage(root: SVGNode): {
+    modified: boolean;
+    stats: {
+        collapsedCount: number;
+        collapsedNodes: string[];
+    };
+};

package/dist/optimizers/collapse-useless-groups.js

@@ -0,0 +1,104 @@
+/**
+ * Collapse Useless Groups
+ * Remove <g> with no attrs and single child
+ * Merge attrs upward if safe (no conflicts)
+ */
+import { traverseTree, replaceNode } from './svg-tree-parser.js';
+/**
+ * Check if a group is useless (no attributes and single child)
+ */
+function isUselessGroup(node) {
+    return (node.tag === 'g' &&
+        node.attrs.size === 0 &&
+        node.children.length === 1 &&
+        !node.content);
+}
+/**
+ * Check if attributes can be safely merged from child to parent
+ * Returns true if no conflicts exist
+ */
+function canMergeAttributes(parent, child) {
+    // Check for attribute conflicts
+    for (const [key] of child.attrs.entries()) {
+        if (parent.attrs.has(key)) {
+            // Conflict: both have the same attribute
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Merge child attributes to parent
+ */
+function mergeAttributesToParent(parent, child) {
+    for (const [key, value] of child.attrs.entries()) {
+        if (!parent.attrs.has(key)) {
+            parent.attrs.set(key, value);
+        }
+    }
+}
+/**
+ * Collapse useless groups in the tree
+ * A group is useless if:
+ * 1. It has no attributes and exactly one child
+ * 2. It has attributes that don't conflict with its single child
+ */
+export function collapseUselessGroups(root) {
+    let collapsedCount = 0;
+    const collapsedNodes = [];
+    // We need to collect nodes to collapse first
+    // to avoid modifying tree during traversal
+    const nodesToCollapse = [];
+    traverseTree(root, node => {
+        if (node.tag === 'g') {
+            // Case 1: Group with no attributes and single child
+            if (isUselessGroup(node)) {
+                nodesToCollapse.push(node);
+            }
+            // Case 2: Group with single child and no attribute conflicts
+            else if (node.children.length === 1 && !node.content) {
+                const child = node.children[0];
+                if (canMergeAttributes(child, node)) {
+                    nodesToCollapse.push(node);
+                }
+            }
+        }
+    });
+    // Collapse collected nodes
+    for (const node of nodesToCollapse) {
+        if (!node.parent)
+            continue;
+        const child = node.children[0];
+        // For groups with no attrs, just replace group with child
+        if (node.attrs.size === 0) {
+            if (replaceNode(node, child)) {
+                const id = node.attrs.get('id') || 'anonymous';
+                collapsedNodes.push(id);
+                collapsedCount++;
+            }
+        }
+        // For groups with attrs, merge them to child first
+        else if (canMergeAttributes(child, node)) {
+            mergeAttributesToParent(child, node);
+            if (replaceNode(node, child)) {
+                const id = node.attrs.get('id') || 'anonymous';
+                collapsedNodes.push(id);
+                collapsedCount++;
+            }
+        }
+    }
+    return {
+        collapsedCount,
+        collapsedNodes,
+    };
+}
+/**
+ * Collapse useless groups stage
+ */
+export function collapseUselessGroupsStage(root) {
+    const result = collapseUselessGroups(root);
+    return {
+        modified: result.collapsedCount > 0,
+        stats: result,
+    };
+}

package/dist/optimizers/command-optimizer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Path Command Optimizer (Phase 4.3)
+ *
+ * Goal: Achieve 50-70% reduction on complex paths with smart curve transformation
+ *
+ * Main features:
+ * 1. Curve shortening (C→S, C→Q, Q→T)
+ * 2. Smart command substitution (C/Q→L when straight)
+ * 3. Relative/Absolute re-evaluation after changes
+ * 4. Configurable tolerance based on optimization level
+ *
+ * Expected improvement: 10-25% additional reduction on complex icons
+ */
+import type { PathCommand } from './path-parser.js';
+/**
+ * Optimize path commands by transforming curves to simpler forms
+ *
+ * Priority:
+ * 1. C → S (smooth cubic)
+ * 2. C → Q (cubic to quadratic)
+ * 3. Q → T (smooth quadratic)
+ * 4. C/Q → L (curve to line when straight)
+ * 5. Re-evaluate absolute/relative after changes
+ */
+export declare function optimizeCommands(commands: PathCommand[], tolerance?: number, precision?: number): {
+    commands: PathCommand[];
+    stats: {
+        convertedCtoS: number;
+        convertedCtoQ: number;
+        convertedQtoT: number;
+        convertedCurveToLine: number;
+        reoptimizedAbsRel: number;
+    };
+};
+/**
+ * Command optimization stage for pipeline integration
+ * Applies curve shortening, smart substitution, and re-optimization
+ */
+export declare function commandOptimizationStage(commands: PathCommand[], tolerance?: number, precision?: number): {
+    commands: PathCommand[];
+    stats: {
+        convertedCtoS: number;
+        convertedCtoQ: number;
+        convertedQtoT: number;
+        convertedCurveToLine: number;
+        reoptimizedAbsRel: number;
+    };
+};

package/dist/optimizers/command-optimizer.js

@@ -0,0 +1,299 @@
+/**
+ * Path Command Optimizer (Phase 4.3)
+ *
+ * Goal: Achieve 50-70% reduction on complex paths with smart curve transformation
+ *
+ * Main features:
+ * 1. Curve shortening (C→S, C→Q, Q→T)
+ * 2. Smart command substitution (C/Q→L when straight)
+ * 3. Relative/Absolute re-evaluation after changes
+ * 4. Configurable tolerance based on optimization level
+ *
+ * Expected improvement: 10-25% additional reduction on complex icons
+ */
+import { toAbsolute, toRelative, compareAbsoluteRelativeSize, } from './path-parser.js';
+/**
+ * Distance between two points
+ */
+function distance(x1, y1, x2, y2) {
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+/**
+ * Check if three points are approximately collinear
+ * Returns true if the middle point is very close to the line connecting the first and third points
+ */
+function isCollinear(x1, y1, x2, y2, x3, y3, tolerance = 0.1) {
+    // Calculate the distance from point 2 to the line formed by points 1 and 3
+    // Using the formula: distance = |ax + by + c| / sqrt(a² + b²)
+    // Where line is: (y3-y1)x - (x3-x1)y + (x3-x1)y1 - (y3-y1)x1 = 0
+    const a = y3 - y1;
+    const b = -(x3 - x1);
+    const c = (x3 - x1) * y1 - (y3 - y1) * x1;
+    const denominator = Math.sqrt(a * a + b * b);
+    if (denominator < 1e-10) {
+        // Points 1 and 3 are the same, check if point 2 is also the same
+        return distance(x1, y1, x2, y2) < tolerance;
+    }
+    const dist = Math.abs(a * x2 + b * y2 + c) / denominator;
+    return dist < tolerance;
+}
+/**
+ * Check if a cubic bezier curve is approximately a quadratic bezier
+ * Returns the quadratic control point if true, null otherwise
+ */
+function cubicToQuadratic(x0, y0, x1, y1, x2, y2, x3, y3, tolerance = 1.0) {
+    // A cubic bezier C(x0,y0, x1,y1, x2,y2, x3,y3) can be approximated by
+    // quadratic Q(x0,y0, qx,qy, x3,y3) if the cubic control points are positioned correctly.
+    //
+    // For a perfect conversion: qx = (3*x1 - x0)/2, qy = (3*y1 - y0)/2 (from first control point)
+    // and also: qx = (3*x2 - x3)/2, qy = (3*y2 - y3)/2 (from second control point)
+    //
+    // These should give the same result for a true quadratic.
+    const qx1 = (3 * x1 - x0) / 2;
+    const qy1 = (3 * y1 - y0) / 2;
+    const qx2 = (3 * x2 - x3) / 2;
+    const qy2 = (3 * y2 - y3) / 2;
+    // Check if both calculations give approximately the same control point
+    const dist = distance(qx1, qy1, qx2, qy2);
+    if (dist < tolerance) {
+        // Use the average for better accuracy
+        return {
+            qx: (qx1 + qx2) / 2,
+            qy: (qy1 + qy2) / 2,
+        };
+    }
+    return null;
+}
+/**
+ * Check if a curve segment is approximately a straight line
+ */
+function isCurveApproximatelyStraight(x0, y0, controlPoints, xEnd, yEnd, tolerance = 1.0) {
+    // Check if all control points are close to the line from start to end
+    for (let i = 0; i < controlPoints.length; i += 2) {
+        const cx = controlPoints[i];
+        const cy = controlPoints[i + 1];
+        if (!isCollinear(x0, y0, cx, cy, xEnd, yEnd, tolerance)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Check if Q command can be converted to T (smooth quadratic)
+ * Q can become T if the current control point is the reflection of the previous one
+ */
+function canConvertQtoT(prevCmd, currentX, currentY, qx, qy, tolerance = 0.1) {
+    if (!prevCmd ||
+        (prevCmd.type !== 'Q' &&
+            prevCmd.type !== 'q' &&
+            prevCmd.type !== 'T' &&
+            prevCmd.type !== 't')) {
+        return false;
+    }
+    // Get the previous control point
+    let prevQx, prevQy;
+    if (prevCmd.type === 'Q' || prevCmd.type === 'q') {
+        if (prevCmd.type === 'Q') {
+            prevQx = prevCmd.values[0];
+            prevQy = prevCmd.values[1];
+        }
+        else {
+            // Convert relative to absolute
+            const absX = prevCmd.absolutePosition?.x || 0;
+            const absY = prevCmd.absolutePosition?.y || 0;
+            prevQx = absX + prevCmd.values[0];
+            prevQy = absY + prevCmd.values[1];
+        }
+    }
+    else {
+        // T/t command - the control point is reflected from previous
+        return false; // Can't check, assume no
+    }
+    // Calculate expected reflected control point
+    const reflectedQx = 2 * currentX - prevQx;
+    const reflectedQy = 2 * currentY - prevQy;
+    // Check if current control point matches the reflection
+    const dist = distance(qx, qy, reflectedQx, reflectedQy);
+    return dist < tolerance;
+}
+/**
+ * Check if C command can be converted to S (smooth cubic)
+ * C can become S if the first control point is the reflection of the previous second control point
+ */
+function canConvertCtoS(prevCmd, currentX, currentY, x1, y1, tolerance = 0.1) {
+    if (!prevCmd ||
+        (prevCmd.type !== 'C' &&
+            prevCmd.type !== 'c' &&
+            prevCmd.type !== 'S' &&
+            prevCmd.type !== 's')) {
+        return false;
+    }
+    // Get the previous second control point
+    let prevX2, prevY2;
+    if (prevCmd.type === 'C' || prevCmd.type === 'c') {
+        if (prevCmd.type === 'C') {
+            prevX2 = prevCmd.values[2];
+            prevY2 = prevCmd.values[3];
+        }
+        else {
+            // Convert relative to absolute
+            const absX = prevCmd.absolutePosition?.x || 0;
+            const absY = prevCmd.absolutePosition?.y || 0;
+            prevX2 = absX + prevCmd.values[2];
+            prevY2 = absY + prevCmd.values[3];
+        }
+    }
+    else if (prevCmd.type === 'S' || prevCmd.type === 's') {
+        if (prevCmd.type === 'S') {
+            prevX2 = prevCmd.values[0];
+            prevY2 = prevCmd.values[1];
+        }
+        else {
+            const absX = prevCmd.absolutePosition?.x || 0;
+            const absY = prevCmd.absolutePosition?.y || 0;
+            prevX2 = absX + prevCmd.values[0];
+            prevY2 = absY + prevCmd.values[1];
+        }
+    }
+    else {
+        return false;
+    }
+    // Calculate expected reflected control point
+    const reflectedX1 = 2 * currentX - prevX2;
+    const reflectedY1 = 2 * currentY - prevY2;
+    // Check if current first control point matches the reflection
+    const dist = distance(x1, y1, reflectedX1, reflectedY1);
+    return dist < tolerance;
+}
+/**
+ * Optimize path commands by transforming curves to simpler forms
+ *
+ * Priority:
+ * 1. C → S (smooth cubic)
+ * 2. C → Q (cubic to quadratic)
+ * 3. Q → T (smooth quadratic)
+ * 4. C/Q → L (curve to line when straight)
+ * 5. Re-evaluate absolute/relative after changes
+ */
+export function optimizeCommands(commands, tolerance = 1.0, precision = 3) {
+    const stats = {
+        convertedCtoS: 0,
+        convertedCtoQ: 0,
+        convertedQtoT: 0,
+        convertedCurveToLine: 0,
+        reoptimizedAbsRel: 0,
+    };
+    const optimized = [];
+    let currentX = 0;
+    let currentY = 0;
+    let prevCmd = null;
+    for (let i = 0; i < commands.length; i++) {
+        let cmd = commands[i];
+        let modified = false;
+        // Update current position for absolute commands
+        if (cmd.absolutePosition) {
+            currentX = cmd.absolutePosition.x;
+            currentY = cmd.absolutePosition.y;
+        }
+        // Get absolute coordinates for analysis
+        const absCmd = cmd.type === cmd.type.toLowerCase()
+            ? toAbsolute(cmd, currentX, currentY)
+            : cmd;
+        // 1. Try C → S (smooth cubic bezier)
+        if (absCmd.type === 'C') {
+            const [x1, y1, x2, y2, x, y] = absCmd.values;
+            if (canConvertCtoS(prevCmd, currentX, currentY, x1, y1, tolerance)) {
+                // Convert to S command (only need second control point and end point)
+                cmd = {
+                    type: 'S',
+                    values: [x2, y2, x, y],
+                    absolutePosition: { x, y },
+                };
+                stats.convertedCtoS++;
+                modified = true;
+            }
+        }
+        // 2. Try C → Q (cubic to quadratic)
+        if (!modified && absCmd.type === 'C') {
+            const [x1, y1, x2, y2, x, y] = absCmd.values;
+            const quadratic = cubicToQuadratic(currentX, currentY, x1, y1, x2, y2, x, y, tolerance);
+            if (quadratic) {
+                // Convert to Q command
+                cmd = {
+                    type: 'Q',
+                    values: [quadratic.qx, quadratic.qy, x, y],
+                    absolutePosition: { x, y },
+                };
+                stats.convertedCtoQ++;
+                modified = true;
+            }
+        }
+        // 3. Try Q → T (smooth quadratic)
+        if (!modified && absCmd.type === 'Q') {
+            const [qx, qy, x, y] = absCmd.values;
+            if (canConvertQtoT(prevCmd, currentX, currentY, qx, qy, tolerance)) {
+                // Convert to T command (only need end point)
+                cmd = {
+                    type: 'T',
+                    values: [x, y],
+                    absolutePosition: { x, y },
+                };
+                stats.convertedQtoT++;
+                modified = true;
+            }
+        }
+        // 4. Try C/Q → L (curve to line when approximately straight)
+        if (!modified && (absCmd.type === 'C' || absCmd.type === 'Q')) {
+            const values = absCmd.values;
+            const endX = values[values.length - 2];
+            const endY = values[values.length - 1];
+            const controlPoints = values.slice(0, -2);
+            if (isCurveApproximatelyStraight(currentX, currentY, controlPoints, endX, endY, tolerance)) {
+                // Convert to L command
+                cmd = {
+                    type: 'L',
+                    values: [endX, endY],
+                    absolutePosition: { x: endX, y: endY },
+                };
+                stats.convertedCurveToLine++;
+                modified = true;
+            }
+        }
+        // 5. Re-evaluate absolute/relative after modifications
+        if (modified) {
+            // Try both absolute and relative, keep whichever is shorter
+            const absCmd = cmd.type === cmd.type.toLowerCase()
+                ? toAbsolute(cmd, currentX, currentY)
+                : cmd;
+            const relCmd = toRelative(absCmd, currentX, currentY);
+            const sizeDiff = compareAbsoluteRelativeSize(absCmd, currentX, currentY, precision);
+            if (sizeDiff > 0) {
+                // Relative is shorter
+                cmd = relCmd;
+                stats.reoptimizedAbsRel++;
+            }
+            else if (sizeDiff < 0) {
+                // Absolute is shorter
+                cmd = absCmd;
+                stats.reoptimizedAbsRel++;
+            }
+        }
+        optimized.push(cmd);
+        // Update position and previous command
+        if (cmd.absolutePosition) {
+            currentX = cmd.absolutePosition.x;
+            currentY = cmd.absolutePosition.y;
+        }
+        prevCmd = cmd;
+    }
+    return { commands: optimized, stats };
+}
+/**
+ * Command optimization stage for pipeline integration
+ * Applies curve shortening, smart substitution, and re-optimization
+ */
+export function commandOptimizationStage(commands, tolerance = 1.0, precision = 3) {
+    return optimizeCommands(commands, tolerance, precision);
+}

package/dist/optimizers/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * SVG Optimizer Module
+ * Advanced SVG optimization system with pluggable pipeline architecture
+ */
+export { OptimizerPipeline, createOptimizerPipeline, } from './optimizer-pipeline.js';
+export { OptLevel, type OptConfig, type OptimizationPlugin, type OptimizedNode, type OptimizedTree, type OptimizationStage, type OptimizationResult, getDefaultOptConfig, } from './types.js';
+export { basicCleaningStage, removeXMLDeclaration, removeDoctype, removeComments, normalizeWhitespace, removeMetadata, convertToCamelCase, removeXMLNamespaces, removeInlineStyles, shortenColors, removeEmptyContainers, removeHiddenElements, roundFloats, sortAttributes, } from './basic-cleaner.js';
+export { type SVGNode, parseSVG, traverseTree, findNodesByTag, findNodeById, getAllIds, removeNode, replaceNode, cloneNode, } from './svg-tree-parser.js';
+export { type SerializerOptions, serializeNode, serializeSVG, serializeSVGPretty, serializeSVGMinified, calculateReduction, } from './tree-serializer.js';
+export { treeOptimizationStage, treeRemoveUnusedDefsStage, treeCollapseGroupsStage, treeMoveAttributesToParentStage, treeRemoveHiddenEmptyStage, } from './tree-stages.js';
+export { removeUnusedDefs, removeUnusedDefsStage, } from './remove-unused-defs.js';
+export { collapseUselessGroups, collapseUselessGroupsStage, } from './collapse-useless-groups.js';
+export { moveAttributesToParent, moveAttributesToParentStage, } from './move-attrs-to-parent.js';
+export { removeHiddenAndEmptyElements, removeHiddenAndEmptyElementsStage, } from './remove-hidden-empty.js';