n8n-nodes-svgr 0.1.1 → 0.2.0

package/dist/nodes/Svgr/svgo.js

@@ -0,0 +1,670 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizeSvg = optimizeSvg;
+exports.optimizeSvgBasic = optimizeSvgBasic;
+const defaultOptions = {
+    removeDoctype: true,
+    removeXMLProcInst: true,
+    removeComments: true,
+    removeMetadata: true,
+    removeEditorsNSData: true,
+    cleanupAttrs: true,
+    cleanupIds: false,
+    removeEmptyAttrs: true,
+    removeUnusedNS: true,
+    prefixIds: false,
+    removeTitle: false,
+    removeDesc: false,
+    removeHiddenElems: true,
+    removeEmptyContainers: true,
+    removeEmptyText: true,
+    removeUselessDefs: false,
+    convertColors: true,
+    minifyStyles: true,
+    inlineStyles: false,
+    mergeStyles: false,
+    cleanupNumericValues: true,
+    collapseGroups: true,
+    moveElemsAttrsToGroup: false,
+    moveGroupAttrsToElems: false,
+    convertPathData: false,
+    convertTransform: false,
+    convertShapeToPath: false,
+    mergePaths: false,
+    removeXmlns: true,
+    removeStyleAttr: true,
+    removeShapeRendering: true,
+    removeDimensions: false,
+    removeViewBox: false,
+};
+function removeDoctype(svg) {
+    return svg.replace(/<!DOCTYPE[^>]*>/gi, '');
+}
+function removeXMLProcInst(svg) {
+    return svg.replace(/<\?xml[^?]*\?>\s*/gi, '');
+}
+function removeComments(svg) {
+    return svg.replace(/<!--[\s\S]*?-->/g, '');
+}
+function removeMetadata(svg) {
+    return svg.replace(/<metadata[\s\S]*?<\/metadata>/gi, '');
+}
+function removeEditorsNSData(svg) {
+    let result = svg;
+    result = result.replace(/\s+xmlns:inkscape="[^"]*"/gi, '');
+    result = result.replace(/\s+inkscape:[a-z-]+="[^"]*"/gi, '');
+    result = result.replace(/\s+xmlns:sodipodi="[^"]*"/gi, '');
+    result = result.replace(/\s+sodipodi:[a-z-]+="[^"]*"/gi, '');
+    result = result.replace(/\s+xmlns:sketch="[^"]*"/gi, '');
+    result = result.replace(/\s+sketch:[a-z-]+="[^"]*"/gi, '');
+    result = result.replace(/\s+xmlns:i="[^"]*"/gi, '');
+    result = result.replace(/\s+i:[a-z-]+="[^"]*"/gi, '');
+    result = result.replace(/\s+xmlns:x="[^"]*"/gi, '');
+    result = result.replace(/\s+data-figma[a-z-]*="[^"]*"/gi, '');
+    result = result.replace(/\s+data-name="[^"]*"/gi, '');
+    return result;
+}
+function cleanupAttrs(svg) {
+    return svg.replace(/(\w+)="([^"]*)"/g, (match, attr, value) => {
+        const cleaned = value.replace(/\s+/g, ' ').trim();
+        return `${attr}="${cleaned}"`;
+    });
+}
+function removeEmptyAttrs(svg) {
+    return svg.replace(/\s+[\w-]+=""/g, '');
+}
+function removeUnusedNS(svg) {
+    let result = svg;
+    result = result.replace(/\s+xmlns="[^"]*"/g, '');
+    if (!result.includes('xlink:') && !result.includes('xlinkHref')) {
+        result = result.replace(/\s+xmlns:xlink="[^"]*"/g, '');
+    }
+    return result;
+}
+function prefixIds(svg, prefix) {
+    if (!prefix)
+        return svg;
+    let result = svg;
+    result = result.replace(/\bid="([^"]*)"/g, `id="${prefix}$1"`);
+    result = result.replace(/url\(#([^)]*)\)/g, `url(#${prefix}$1)`);
+    result = result.replace(/href="#([^"]*)"/g, `href="#${prefix}$1"`);
+    result = result.replace(/xlink:href="#([^"]*)"/g, `xlink:href="#${prefix}$1"`);
+    result = result.replace(/\bclass="([^"]*)"/g, (match, classes) => {
+        const prefixedClasses = classes
+            .split(/\s+/)
+            .map((cls) => (cls ? `${prefix}${cls}` : ''))
+            .join(' ');
+        return `class="${prefixedClasses}"`;
+    });
+    return result;
+}
+function cleanupIds(svg) {
+    let result = svg;
+    const idMatches = result.matchAll(/\bid="([^"]*)"/g);
+    const definedIds = new Set();
+    for (const match of idMatches) {
+        definedIds.add(match[1]);
+    }
+    const referencedIds = new Set();
+    const urlRefs = result.matchAll(/url\(#([^)]*)\)/g);
+    for (const match of urlRefs) {
+        referencedIds.add(match[1]);
+    }
+    const hrefRefs = result.matchAll(/href="#([^"]*)"/g);
+    for (const match of hrefRefs) {
+        referencedIds.add(match[1]);
+    }
+    const xlinkRefs = result.matchAll(/xlink:href="#([^"]*)"/g);
+    for (const match of xlinkRefs) {
+        referencedIds.add(match[1]);
+    }
+    for (const id of definedIds) {
+        if (!referencedIds.has(id)) {
+            result = result.replace(new RegExp(`\\s+id="${id}"`, 'g'), '');
+        }
+    }
+    return result;
+}
+function removeTitle(svg) {
+    return svg.replace(/<title[\s\S]*?<\/title>/gi, '');
+}
+function removeDesc(svg) {
+    return svg.replace(/<desc[\s\S]*?<\/desc>/gi, '');
+}
+function removeHiddenElems(svg) {
+    let result = svg;
+    result = result.replace(/<[^>]+display\s*:\s*none[^>]*>[\s\S]*?<\/[^>]+>/gi, '');
+    result = result.replace(/<[^>]+display\s*=\s*["']none["'][^>]*\/?>/gi, '');
+    result = result.replace(/<[^>]+visibility\s*:\s*hidden[^>]*>[\s\S]*?<\/[^>]+>/gi, '');
+    result = result.replace(/<[^>]+visibility\s*=\s*["']hidden["'][^>]*\/?>/gi, '');
+    result = result.replace(/<[^>]+\s+opacity\s*=\s*["']0["'][^>]*>[\s\S]*?<\/[^>]+>/gi, '');
+    result = result.replace(/<[^>]+\s+opacity\s*=\s*["']0["'][^>]*\/>/gi, '');
+    return result;
+}
+function removeEmptyContainers(svg) {
+    let result = svg;
+    let prevResult = '';
+    while (result !== prevResult) {
+        prevResult = result;
+        result = result.replace(/<g[^>]*>\s*<\/g>/gi, '');
+        result = result.replace(/<defs[^>]*>\s*<\/defs>/gi, '');
+        result = result.replace(/<pattern[^>]*>\s*<\/pattern>/gi, '');
+        result = result.replace(/<clipPath[^>]*>\s*<\/clipPath>/gi, '');
+        result = result.replace(/<mask[^>]*>\s*<\/mask>/gi, '');
+        result = result.replace(/<symbol[^>]*>\s*<\/symbol>/gi, '');
+    }
+    return result;
+}
+function removeEmptyText(svg) {
+    return svg.replace(/<text[^>]*>\s*<\/text>/gi, '');
+}
+function removeUselessDefs(svg) {
+    let result = svg;
+    const defsMatch = result.match(/<defs[^>]*>([\s\S]*?)<\/defs>/gi);
+    if (!defsMatch)
+        return result;
+    const referencedIds = new Set();
+    const urlRefs = result.matchAll(/url\(#([^)]*)\)/g);
+    for (const match of urlRefs) {
+        referencedIds.add(match[1]);
+    }
+    const hrefRefs = result.matchAll(/href="#([^"]*)"/g);
+    for (const match of hrefRefs) {
+        referencedIds.add(match[1]);
+    }
+    const xlinkRefs = result.matchAll(/xlink:href="#([^"]*)"/g);
+    for (const match of xlinkRefs) {
+        referencedIds.add(match[1]);
+    }
+    for (const defsContent of defsMatch) {
+        let newDefsContent = defsContent;
+        const elementsWithId = defsContent.matchAll(/<(\w+)[^>]*\s+id="([^"]*)"[^>]*(?:\/>|>[\s\S]*?<\/\1>)/gi);
+        for (const elemMatch of elementsWithId) {
+            const fullElement = elemMatch[0];
+            const elementId = elemMatch[2];
+            if (!referencedIds.has(elementId)) {
+                newDefsContent = newDefsContent.replace(fullElement, '');
+            }
+        }
+        result = result.replace(defsContent, newDefsContent);
+    }
+    return result;
+}
+function convertColors(svg) {
+    let result = svg;
+    result = result.replace(/rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/gi, (_, r, g, b) => {
+        const toHex = (n) => parseInt(n, 10).toString(16).padStart(2, '0');
+        return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    });
+    const colorMap = {
+        '#000000': '#000',
+        '#ffffff': '#fff',
+        '#ff0000': 'red',
+        '#00ff00': 'lime',
+        '#0000ff': 'blue',
+        '#ffff00': 'yellow',
+        '#00ffff': 'cyan',
+        '#ff00ff': 'magenta',
+    };
+    for (const [hex, name] of Object.entries(colorMap)) {
+        const regex = new RegExp(hex, 'gi');
+        result = result.replace(regex, name);
+    }
+    result = result.replace(/#([0-9a-fA-F])\1([0-9a-fA-F])\2([0-9a-fA-F])\3/gi, '#$1$2$3');
+    return result;
+}
+function minifyStyles(svg) {
+    return svg.replace(/<style[^>]*>([\s\S]*?)<\/style>/gi, (match, content) => {
+        let minified = content;
+        minified = minified.replace(/\/\*[\s\S]*?\*\//g, '');
+        minified = minified.replace(/\s+/g, ' ');
+        minified = minified.replace(/;\s+/g, ';');
+        minified = minified.replace(/:\s+/g, ':');
+        minified = minified.replace(/\s*{\s*/g, '{');
+        minified = minified.replace(/\s*}\s*/g, '}');
+        minified = minified.trim();
+        return `<style>${minified}</style>`;
+    });
+}
+function inlineStyles(svg) {
+    let result = svg;
+    const styleMatch = result.match(/<style[^>]*>([\s\S]*?)<\/style>/i);
+    if (!styleMatch)
+        return result;
+    const styleContent = styleMatch[1];
+    const rules = {};
+    const ruleMatches = styleContent.matchAll(/([.#]?[\w-]+)\s*\{\s*([^}]*?)\s*\}/g);
+    for (const match of ruleMatches) {
+        const selector = match[1].trim();
+        let declarations = match[2].trim();
+        if (declarations.endsWith(';')) {
+            declarations = declarations.slice(0, -1);
+        }
+        rules[selector] = declarations;
+    }
+    for (const [selector, declarations] of Object.entries(rules)) {
+        if (selector.startsWith('.')) {
+            const className = selector.slice(1);
+            result = result.replace(new RegExp(`(<\\w+\\s+[^>]*?class="[^"]*${className}[^"]*"[^>]*?)(\\s*\\/?>)`, 'gi'), (match, before, closing) => {
+                if (before.includes('style="')) {
+                    return before.replace(/style="([^"]*)"/, `style="$1;${declarations}"`) + closing;
+                }
+                return `${before} style="${declarations}"${closing}`;
+            });
+        }
+    }
+    for (const [selector, declarations] of Object.entries(rules)) {
+        if (selector.startsWith('#')) {
+            const idName = selector.slice(1);
+            result = result.replace(new RegExp(`(<[^>]*\\bid="${idName}"[^>]*?)(\\s*\\/?>)`, 'gi'), (match, before, closing) => {
+                if (before.includes('style="')) {
+                    return before.replace(/style="([^"]*)"/, `style="$1;${declarations}"`) + closing;
+                }
+                return `${before} style="${declarations}"${closing}`;
+            });
+        }
+    }
+    for (const [selector, declarations] of Object.entries(rules)) {
+        if (!selector.startsWith('.') && !selector.startsWith('#')) {
+            result = result.replace(new RegExp(`(<${selector}\\b[^>]*?)(\\s*\\/?>)`, 'gi'), (match, before, closing) => {
+                if (before.includes('style="')) {
+                    return before.replace(/style="([^"]*)"/, `style="$1;${declarations}"`) + closing;
+                }
+                return `${before} style="${declarations}"${closing}`;
+            });
+        }
+    }
+    result = result.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
+    return result;
+}
+function mergeStyles(svg) {
+    const styleMatches = svg.matchAll(/<style[^>]*>([\s\S]*?)<\/style>/gi);
+    const allStyles = [];
+    for (const match of styleMatches) {
+        allStyles.push(match[1].trim());
+    }
+    if (allStyles.length <= 1)
+        return svg;
+    let result = svg.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
+    const mergedStyle = `<style>${allStyles.join('')}</style>`;
+    result = result.replace(/(<svg[^>]*>)/, `$1${mergedStyle}`);
+    return result;
+}
+function cleanupNumericValues(svg) {
+    let result = svg;
+    result = result.replace(/="([^"]*)"/g, (match, value) => {
+        let cleaned = value;
+        cleaned = cleaned.replace(/\b0+\.(\d)/g, '.$1');
+        cleaned = cleaned.replace(/(\d)\.0+\b/g, '$1');
+        cleaned = cleaned.replace(/\b0(px|em|ex|pt|pc|cm|mm|in|%)\b/gi, '0');
+        cleaned = cleaned.replace(/\s+/g, ' ');
+        return `="${cleaned}"`;
+    });
+    return result;
+}
+function collapseGroups(svg) {
+    let result = svg;
+    let prevResult = '';
+    while (result !== prevResult) {
+        prevResult = result;
+        result = result.replace(/<g>\s*([\s\S]*?)\s*<\/g>/gi, '$1');
+    }
+    return result;
+}
+function moveElemsAttrsToGroup(svg) {
+    let result = svg;
+    const presentationAttrs = [
+        'fill',
+        'stroke',
+        'stroke-width',
+        'stroke-linecap',
+        'stroke-linejoin',
+        'stroke-dasharray',
+        'stroke-dashoffset',
+        'stroke-miterlimit',
+        'stroke-opacity',
+        'fill-opacity',
+        'fill-rule',
+        'opacity',
+        'font-family',
+        'font-size',
+        'font-weight',
+        'text-anchor',
+        'dominant-baseline',
+    ];
+    result = result.replace(/<g([^>]*)>([\s\S]*?)<\/g>/gi, (match, groupAttrs, content) => {
+        var _a;
+        const childElements = content.match(/<\w+[^>]*(?:\/>|>[^<]*<\/\w+>)/g);
+        if (!childElements || childElements.length < 2)
+            return match;
+        const childAttrsArray = [];
+        for (const child of childElements) {
+            const attrs = {};
+            const attrMatches = child.matchAll(/\s([\w-]+)="([^"]*)"/g);
+            for (const attrMatch of attrMatches) {
+                if (presentationAttrs.includes(attrMatch[1])) {
+                    attrs[attrMatch[1]] = attrMatch[2];
+                }
+            }
+            childAttrsArray.push(attrs);
+        }
+        const commonAttrs = {};
+        for (const attr of presentationAttrs) {
+            const firstValue = (_a = childAttrsArray[0]) === null || _a === void 0 ? void 0 : _a[attr];
+            if (firstValue && childAttrsArray.every((attrs) => attrs[attr] === firstValue)) {
+                commonAttrs[attr] = firstValue;
+            }
+        }
+        if (Object.keys(commonAttrs).length === 0)
+            return match;
+        let newContent = content;
+        for (const [attr, value] of Object.entries(commonAttrs)) {
+            newContent = newContent.replace(new RegExp(`\\s${attr}="${value}"`, 'g'), '');
+        }
+        const commonAttrsStr = Object.entries(commonAttrs)
+            .map(([attr, value]) => ` ${attr}="${value}"`)
+            .join('');
+        return `<g${groupAttrs}${commonAttrsStr}>${newContent}</g>`;
+    });
+    return result;
+}
+function moveGroupAttrsToElems(svg) {
+    let result = svg;
+    const presentationAttrs = [
+        'fill',
+        'stroke',
+        'stroke-width',
+        'stroke-linecap',
+        'stroke-linejoin',
+        'stroke-dasharray',
+        'stroke-dashoffset',
+        'stroke-miterlimit',
+        'stroke-opacity',
+        'fill-opacity',
+        'fill-rule',
+        'opacity',
+        'font-family',
+        'font-size',
+        'font-weight',
+        'text-anchor',
+        'dominant-baseline',
+    ];
+    result = result.replace(/<g([^>]*)>([\s\S]*?)<\/g>/gi, (match, groupAttrs, content) => {
+        const groupPresentationAttrs = {};
+        let remainingGroupAttrs = groupAttrs;
+        for (const attr of presentationAttrs) {
+            const attrMatch = groupAttrs.match(new RegExp(`\\s${attr}="([^"]*)"`));
+            if (attrMatch) {
+                groupPresentationAttrs[attr] = attrMatch[1];
+                remainingGroupAttrs = remainingGroupAttrs.replace(attrMatch[0], '');
+            }
+        }
+        if (Object.keys(groupPresentationAttrs).length === 0)
+            return match;
+        const newContent = content.replace(/<(\w+)((?:\s+[\w-]+="[^"]*")*)\s*(\/?)>/g, (_elemMatch, tag, attrs, selfClose) => {
+            let newAttrs = attrs;
+            for (const [attr, value] of Object.entries(groupPresentationAttrs)) {
+                if (!attrs.includes(`${attr}="`)) {
+                    newAttrs += ` ${attr}="${value}"`;
+                }
+            }
+            return `<${tag}${newAttrs}${selfClose ? ' />' : '>'}`;
+        });
+        return `<g${remainingGroupAttrs}>${newContent}</g>`;
+    });
+    return result;
+}
+function convertPathData(svg) {
+    return svg.replace(/\sd="([^"]*)"/g, (match, d) => {
+        let optimized = d;
+        optimized = optimized.replace(/\s+/g, ' ');
+        optimized = optimized.replace(/([MLHVCSQTAZ])\s+/gi, '$1');
+        optimized = optimized.replace(/\s+([MLHVCSQTAZ])/gi, '$1');
+        optimized = optimized.replace(/(\d)\s+(-)/g, '$1$2');
+        optimized = optimized.replace(/\s*,\s*/g, ',');
+        optimized = optimized.replace(/,/g, ' ');
+        optimized = optimized.replace(/\s+/g, ' ').trim();
+        optimized = optimized.replace(/\b0+\.(\d)/g, '.$1');
+        optimized = optimized.replace(/(\.\d*?)0+(\s|$|[A-Za-z])/g, '$1$2');
+        optimized = optimized.replace(/\.(\s|$|[A-Za-z])/g, '$1');
+        return ` d="${optimized}"`;
+    });
+}
+function convertTransform(svg) {
+    return svg.replace(/\stransform="([^"]*)"/g, (match, transform) => {
+        let optimized = transform;
+        optimized = optimized.replace(/translate\(\s*0\s*(,\s*0\s*)?\)/gi, '');
+        optimized = optimized.replace(/rotate\(\s*0\s*(,\s*[\d.]+\s*,\s*[\d.]+\s*)?\)/gi, '');
+        optimized = optimized.replace(/scale\(\s*1\s*(,\s*1\s*)?\)/gi, '');
+        optimized = optimized.replace(/skew[XY]\(\s*0\s*\)/gi, '');
+        optimized = optimized.replace(/\s+/g, ' ').trim();
+        if (!optimized)
+            return '';
+        return ` transform="${optimized}"`;
+    });
+}
+function convertShapeToPath(svg) {
+    let result = svg;
+    result = result.replace(/<rect([^>]*)\/>/gi, (match, attrs) => {
+        var _a, _b, _c, _d, _e, _f;
+        const x = parseFloat(((_a = attrs.match(/\sx="([^"]*)"/)) === null || _a === void 0 ? void 0 : _a[1]) || '0');
+        const y = parseFloat(((_b = attrs.match(/\sy="([^"]*)"/)) === null || _b === void 0 ? void 0 : _b[1]) || '0');
+        const width = parseFloat(((_c = attrs.match(/\swidth="([^"]*)"/)) === null || _c === void 0 ? void 0 : _c[1]) || '0');
+        const height = parseFloat(((_d = attrs.match(/\sheight="([^"]*)"/)) === null || _d === void 0 ? void 0 : _d[1]) || '0');
+        const rx = parseFloat(((_e = attrs.match(/\srx="([^"]*)"/)) === null || _e === void 0 ? void 0 : _e[1]) || '0');
+        const ry = parseFloat(((_f = attrs.match(/\sry="([^"]*)"/)) === null || _f === void 0 ? void 0 : _f[1]) || rx.toString());
+        if (width === 0 || height === 0)
+            return match;
+        const otherAttrs = attrs
+            .replace(/\s[xy]="[^"]*"/g, '')
+            .replace(/\swidth="[^"]*"/g, '')
+            .replace(/\sheight="[^"]*"/g, '')
+            .replace(/\sr[xy]="[^"]*"/g, '');
+        let d;
+        if (rx > 0 || ry > 0) {
+            const r = Math.min(rx, width / 2, height / 2);
+            d = `M${x + r},${y}h${width - 2 * r}a${r},${r} 0 0 1 ${r},${r}v${height - 2 * r}a${r},${r} 0 0 1 -${r},${r}h-${width - 2 * r}a${r},${r} 0 0 1 -${r},-${r}v-${height - 2 * r}a${r},${r} 0 0 1 ${r},-${r}z`;
+        }
+        else {
+            d = `M${x},${y}h${width}v${height}h-${width}z`;
+        }
+        return `<path${otherAttrs} d="${d}"/>`;
+    });
+    result = result.replace(/<circle([^>]*)\/>/gi, (match, attrs) => {
+        var _a, _b, _c;
+        const cx = parseFloat(((_a = attrs.match(/\scx="([^"]*)"/)) === null || _a === void 0 ? void 0 : _a[1]) || '0');
+        const cy = parseFloat(((_b = attrs.match(/\scy="([^"]*)"/)) === null || _b === void 0 ? void 0 : _b[1]) || '0');
+        const r = parseFloat(((_c = attrs.match(/\sr="([^"]*)"/)) === null || _c === void 0 ? void 0 : _c[1]) || '0');
+        if (r === 0)
+            return match;
+        const otherAttrs = attrs.replace(/\sc[xy]="[^"]*"/g, '').replace(/\sr="[^"]*"/g, '');
+        const d = `M${cx - r},${cy}a${r},${r} 0 1 0 ${2 * r},0a${r},${r} 0 1 0 -${2 * r},0`;
+        return `<path${otherAttrs} d="${d}"/>`;
+    });
+    result = result.replace(/<ellipse([^>]*)\/>/gi, (match, attrs) => {
+        var _a, _b, _c, _d;
+        const cx = parseFloat(((_a = attrs.match(/\scx="([^"]*)"/)) === null || _a === void 0 ? void 0 : _a[1]) || '0');
+        const cy = parseFloat(((_b = attrs.match(/\scy="([^"]*)"/)) === null || _b === void 0 ? void 0 : _b[1]) || '0');
+        const rx = parseFloat(((_c = attrs.match(/\srx="([^"]*)"/)) === null || _c === void 0 ? void 0 : _c[1]) || '0');
+        const ry = parseFloat(((_d = attrs.match(/\sry="([^"]*)"/)) === null || _d === void 0 ? void 0 : _d[1]) || '0');
+        if (rx === 0 || ry === 0)
+            return match;
+        const otherAttrs = attrs.replace(/\sc[xy]="[^"]*"/g, '').replace(/\sr[xy]="[^"]*"/g, '');
+        const d = `M${cx - rx},${cy}a${rx},${ry} 0 1 0 ${2 * rx},0a${rx},${ry} 0 1 0 -${2 * rx},0`;
+        return `<path${otherAttrs} d="${d}"/>`;
+    });
+    result = result.replace(/<line([^>]*)\/>/gi, (match, attrs) => {
+        var _a, _b, _c, _d;
+        const x1 = parseFloat(((_a = attrs.match(/\sx1="([^"]*)"/)) === null || _a === void 0 ? void 0 : _a[1]) || '0');
+        const y1 = parseFloat(((_b = attrs.match(/\sy1="([^"]*)"/)) === null || _b === void 0 ? void 0 : _b[1]) || '0');
+        const x2 = parseFloat(((_c = attrs.match(/\sx2="([^"]*)"/)) === null || _c === void 0 ? void 0 : _c[1]) || '0');
+        const y2 = parseFloat(((_d = attrs.match(/\sy2="([^"]*)"/)) === null || _d === void 0 ? void 0 : _d[1]) || '0');
+        const otherAttrs = attrs.replace(/\s[xy][12]="[^"]*"/g, '');
+        const d = `M${x1},${y1}L${x2},${y2}`;
+        return `<path${otherAttrs} d="${d}"/>`;
+    });
+    result = result.replace(/<polygon([^>]*)\/>/gi, (match, attrs) => {
+        var _a;
+        const points = (_a = attrs.match(/\spoints="([^"]*)"/)) === null || _a === void 0 ? void 0 : _a[1];
+        if (!points)
+            return match;
+        const otherAttrs = attrs.replace(/\spoints="[^"]*"/g, '');
+        const pointArray = points.trim().split(/[\s,]+/);
+        if (pointArray.length < 4)
+            return match;
+        let d = `M${pointArray[0]},${pointArray[1]}`;
+        for (let i = 2; i < pointArray.length; i += 2) {
+            d += `L${pointArray[i]},${pointArray[i + 1]}`;
+        }
+        d += 'z';
+        return `<path${otherAttrs} d="${d}"/>`;
+    });
+    result = result.replace(/<polyline([^>]*)\/>/gi, (match, attrs) => {
+        var _a;
+        const points = (_a = attrs.match(/\spoints="([^"]*)"/)) === null || _a === void 0 ? void 0 : _a[1];
+        if (!points)
+            return match;
+        const otherAttrs = attrs.replace(/\spoints="[^"]*"/g, '');
+        const pointArray = points.trim().split(/[\s,]+/);
+        if (pointArray.length < 4)
+            return match;
+        let d = `M${pointArray[0]},${pointArray[1]}`;
+        for (let i = 2; i < pointArray.length; i += 2) {
+            d += `L${pointArray[i]},${pointArray[i + 1]}`;
+        }
+        return `<path${otherAttrs} d="${d}"/>`;
+    });
+    return result;
+}
+function mergePaths(svg) {
+    let result = svg;
+    result = result.replace(/(<path\s+)([^>]*d="[^"]*")([^>]*)(\/?>)\s*(<path\s+)([^>]*d="[^"]*")([^>]*)(\/?>)/gi, (match, p1Start, p1D, p1Rest, p1End, p2Start, p2D, p2Rest) => {
+        var _a, _b;
+        const attrs1 = (p1Rest || '').trim();
+        const attrs2 = (p2Rest || '').trim();
+        if (attrs1 !== attrs2)
+            return match;
+        const d1 = ((_a = p1D.match(/d="([^"]*)"/)) === null || _a === void 0 ? void 0 : _a[1]) || '';
+        const d2 = ((_b = p2D.match(/d="([^"]*)"/)) === null || _b === void 0 ? void 0 : _b[1]) || '';
+        const mergedD = `${d1} ${d2}`;
+        return `${p1Start}d="${mergedD}"${p1Rest}${p1End}`;
+    });
+    return result;
+}
+function removeStyleAttr(svg) {
+    return svg.replace(/\s+style="[^"]*"/g, '');
+}
+function removeShapeRendering(svg) {
+    let result = svg;
+    result = result.replace(/\s+shape-rendering="[^"]*"/g, '');
+    result = result.replace(/\s+shapeRendering="[^"]*"/g, '');
+    return result;
+}
+function removeDimensions(svg) {
+    let result = svg;
+    result = result.replace(/\s+width="[^"]*"/g, '');
+    result = result.replace(/\s+height="[^"]*"/g, '');
+    return result;
+}
+function removeViewBox(svg) {
+    return svg.replace(/\s+viewBox="[^"]*"/g, '');
+}
+function optimizeSvg(svg, options = {}) {
+    const opts = { ...defaultOptions, ...options };
+    let result = svg.trim();
+    const shouldRemoveNS = options.removeUnusedNS !== false && (opts.removeUnusedNS || opts.removeXmlns);
+    if (opts.removeDoctype)
+        result = removeDoctype(result);
+    if (opts.removeXMLProcInst)
+        result = removeXMLProcInst(result);
+    if (opts.removeComments)
+        result = removeComments(result);
+    if (opts.removeMetadata)
+        result = removeMetadata(result);
+    if (opts.removeEditorsNSData)
+        result = removeEditorsNSData(result);
+    if (opts.cleanupAttrs)
+        result = cleanupAttrs(result);
+    if (opts.cleanupIds)
+        result = cleanupIds(result);
+    if (opts.removeEmptyAttrs)
+        result = removeEmptyAttrs(result);
+    if (shouldRemoveNS)
+        result = removeUnusedNS(result);
+    if (opts.prefixIds) {
+        const prefix = typeof opts.prefixIds === 'string' ? opts.prefixIds : 'svgr_';
+        result = prefixIds(result, prefix);
+    }
+    if (opts.removeTitle)
+        result = removeTitle(result);
+    if (opts.removeDesc)
+        result = removeDesc(result);
+    if (opts.removeHiddenElems)
+        result = removeHiddenElems(result);
+    if (opts.removeEmptyText)
+        result = removeEmptyText(result);
+    if (opts.removeUselessDefs)
+        result = removeUselessDefs(result);
+    if (opts.convertColors)
+        result = convertColors(result);
+    if (opts.mergeStyles)
+        result = mergeStyles(result);
+    if (opts.minifyStyles)
+        result = minifyStyles(result);
+    if (opts.inlineStyles)
+        result = inlineStyles(result);
+    if (opts.cleanupNumericValues)
+        result = cleanupNumericValues(result);
+    if (opts.moveElemsAttrsToGroup)
+        result = moveElemsAttrsToGroup(result);
+    if (opts.moveGroupAttrsToElems)
+        result = moveGroupAttrsToElems(result);
+    if (opts.collapseGroups)
+        result = collapseGroups(result);
+    if (opts.removeEmptyContainers)
+        result = removeEmptyContainers(result);
+    if (opts.convertShapeToPath)
+        result = convertShapeToPath(result);
+    if (opts.convertPathData)
+        result = convertPathData(result);
+    if (opts.convertTransform)
+        result = convertTransform(result);
+    if (opts.mergePaths)
+        result = mergePaths(result);
+    if (opts.removeStyleAttr && !opts.inlineStyles)
+        result = removeStyleAttr(result);
+    if (opts.removeShapeRendering)
+        result = removeShapeRendering(result);
+    if (opts.removeDimensions)
+        result = removeDimensions(result);
+    if (opts.removeViewBox)
+        result = removeViewBox(result);
+    return result;
+}
+function optimizeSvgBasic(svg, options = {}) {
+    return optimizeSvg(svg, {
+        removeDoctype: true,
+        removeXMLProcInst: true,
+        removeComments: true,
+        removeMetadata: true,
+        removeEditorsNSData: true,
+        removeUnusedNS: true,
+        removeStyleAttr: true,
+        removeShapeRendering: true,
+        removeDimensions: options.icon || !options.dimensions,
+        removeViewBox: options.removeViewBox,
+        cleanupAttrs: false,
+        removeEmptyAttrs: false,
+        prefixIds: false,
+        removeTitle: false,
+        removeDesc: false,
+        removeHiddenElems: false,
+        removeEmptyContainers: false,
+        removeEmptyText: false,
+        convertColors: false,
+        minifyStyles: false,
+        cleanupNumericValues: false,
+        collapseGroups: false,
+    });
+}
+//# sourceMappingURL=svgo.js.map