@iconify/tools 2.0.14 → 2.0.15

package/lib/svg/analyse.js

@@ -1,352 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyseSVGStructure = void 0;
-const parse_1 = require("./parse");
-const attributes_1 = require("./data/attributes");
-const tags_1 = require("./data/tags");
-const error_1 = require("./analyse/error");
-/**
- * Find all IDs, links, which elements use palette, which items aren't used
- *
- * Before running this function run cleanup functions to change inline style to attributes and fix attributes
- */
-async function analyseSVGStructure(svg, options = {}) {
-    // Options
-    const fixErrors = options.fixErrors;
-    // Root element
-    let root = svg.$svg(':root').get(0);
-    if (root._parsed) {
-        // Reload to reset custom properties
-        svg.load(svg.toString());
-        root = svg.$svg(':root').get(0);
-    }
-    root._parsed = true;
-    const cheerio = svg.$svg;
-    // List of all elements
-    const elements = new Map();
-    // List of IDs
-    const ids = Object.create(null);
-    // Links
-    let links = [];
-    /**
-     * Found element with id
-     */
-    function addID(element, id) {
-        if (ids[id]) {
-            throw new Error(`Duplicate id "${id}"`);
-        }
-        element._id = id;
-        ids[id] = element._index;
-        return true;
-    }
-    /**
-     * Add _belongsTo
-     */
-    function gotElementWithID(element, id, isMask) {
-        addID(element, id);
-        if (!element._belongsTo) {
-            element._belongsTo = [];
-        }
-        element._belongsTo.push({
-            id,
-            isMask,
-            indexes: new Set([element._index]),
-        });
-        return;
-    }
-    /**
-     * Mark element as reusable, set properties
-     */
-    function gotReusableElement(item, isMask) {
-        const element = item.element;
-        const attribs = element.attribs;
-        const index = element._index;
-        const id = attribs['id'];
-        if (typeof id !== 'string') {
-            const message = `Definition element ${(0, error_1.analyseTagError)(element)} does not have id`;
-            if (fixErrors) {
-                item.removeNode = true;
-                item.testChildren = false;
-                console.warn(message);
-                return false;
-            }
-            throw new Error(message);
-        }
-        if (ids[id] && fixErrors) {
-            console.warn(`Duplicate id "${id}"`);
-            item.removeNode = true;
-            item.testChildren = false;
-            return false;
-        }
-        element._reusableElement = {
-            id,
-            isMask,
-            index,
-        };
-        gotElementWithID(element, id, isMask);
-        return true;
-    }
-    /**
-     * Found element that uses another element
-     */
-    function gotElementReference(item, id, usedAsMask) {
-        const element = item.element;
-        const usedByIndex = element._index;
-        const link = {
-            id,
-            usedByIndex,
-            usedAsMask,
-        };
-        // Add to global list
-        links.push(link);
-        // Add to element and parent elements
-        if (!element._linksTo) {
-            element._linksTo = [];
-        }
-        element._linksTo.push(link);
-    }
-    // Find all reusable elements and all usages
-    let index = 0;
-    await (0, parse_1.parseSVG)(svg, (item) => {
-        var _a;
-        const { tagName, parents } = item;
-        if (tags_1.styleTag.has(tagName)) {
-            item.testChildren = false;
-            return;
-        }
-        const element = item.element;
-        const attribs = element.attribs;
-        // Set index
-        index++;
-        element._index = index;
-        elements.set(index, element);
-        if (!parents.length) {
-            // root <svg>
-            element._usedAsMask = false;
-            element._usedAsPaint = true;
-            return;
-        }
-        element._usedAsMask = false;
-        element._usedAsPaint = false;
-        // Get parent element
-        const parentItem = parents[0];
-        const parentElement = parentItem.element;
-        // Check for mask or clip path
-        if (tags_1.maskTags.has(tagName)) {
-            // Element can only be used as mask or clip path
-            if (!gotReusableElement(item, true)) {
-                return;
-            }
-        }
-        else if (tags_1.reusableElementsWithPalette.has(tagName)) {
-            // Reusable element that uses palette
-            if (!gotReusableElement(item, false)) {
-                return;
-            }
-        }
-        else if (tags_1.defsTag.has(parentItem.tagName)) {
-            // Symbol without <symbol> tag
-            if (!gotReusableElement(item, false)) {
-                return;
-            }
-        }
-        else if (!tags_1.defsTag.has(tagName)) {
-            // Not reusable element, not <defs>. Copy parent stuff
-            element._usedAsMask = parentElement._usedAsMask;
-            element._usedAsPaint = parentElement._usedAsPaint;
-            element._parentElement = parentElement._index;
-            if (!parentElement._childElements) {
-                parentElement._childElements = [];
-            }
-            parentElement._childElements.push(index);
-            // Copy id of reusable element from parent
-            const parentReusableElement = parentElement._reusableElement;
-            if (parentReusableElement) {
-                if (element._reusableElement) {
-                    // Reusable element inside reusable element: should not happen!
-                    throw new Error(`Reusable element ${(0, error_1.analyseTagError)(element)} is inside another reusable element id="${parentReusableElement.id}"`);
-                }
-                element._reusableElement = parentReusableElement;
-            }
-            // Copy all parent ids
-            const parentBelongsTo = parentElement._belongsTo;
-            if (parentBelongsTo) {
-                const list = element._belongsTo || (element._belongsTo = []);
-                parentBelongsTo.forEach((item) => {
-                    item.indexes.add(index);
-                    list.push(item);
-                });
-            }
-            // Check if element has its own id
-            if (element._id === void 0) {
-                const id = attribs['id'];
-                if (typeof id === 'string') {
-                    if (ids[id] && fixErrors) {
-                        console.warn(`Duplicate id "${id}"`);
-                        cheerio(element).removeAttr('id');
-                    }
-                    else {
-                        gotElementWithID(element, id, false);
-                    }
-                }
-            }
-        }
-        // Check if element uses any ID
-        if ((_a = attributes_1.tagSpecificNonPresentationalAttributes[tagName]) === null || _a === void 0 ? void 0 : _a.has('href')) {
-            const href = attribs['href'] || attribs['xlink:href'];
-            if (typeof href === 'string') {
-                if (href.slice(0, 1) !== '#') {
-                    throw new Error(`Invalid link in ${(0, error_1.analyseTagError)(element)}`);
-                }
-                const id = href.slice(1);
-                gotElementReference(item, id, false);
-            }
-        }
-        // Check colors
-        Object.keys(attribs).forEach((attr) => {
-            // Get id
-            let value = attribs[attr];
-            if (value.slice(0, 5).toLowerCase() !== 'url(#') {
-                return;
-            }
-            value = value.slice(5);
-            if (value.slice(-1) !== ')') {
-                return;
-            }
-            const id = value.slice(0, value.length - 1).trim();
-            if (attributes_1.urlPresentationalAttributes.has(attr)) {
-                // Used as mask, clip path or filter
-                gotElementReference(item, id, attr !== 'filter');
-                return;
-            }
-            if (attributes_1.commonColorPresentationalAttributes.has(attr) ||
-                attributes_1.markerAttributes.has(attr)) {
-                // Used as paint
-                gotElementReference(item, id, false);
-                return;
-            }
-        });
-    });
-    // Make sure all required IDs exist
-    links = links.filter((item) => {
-        const id = item.id;
-        if (ids[id]) {
-            return true;
-        }
-        // Attempt to fix error
-        function fix() {
-            const index = item.usedByIndex;
-            const element = elements.get(index);
-            const tagName = element.tagName;
-            function remove() {
-                var _a;
-                const $element = cheerio(element);
-                const parent = element.parent;
-                if (parent) {
-                    if (parent._childElements) {
-                        parent._childElements = parent._childElements.filter((num) => num !== index);
-                    }
-                    (_a = parent._belongsTo) === null || _a === void 0 ? void 0 : _a.forEach((list) => {
-                        list.indexes.delete(index);
-                    });
-                }
-                $element.remove();
-            }
-            // Remove links
-            if (element._linksTo) {
-                element._linksTo = element._linksTo.filter((item) => item.id !== id);
-            }
-            // Remove <use /> without children
-            if (!element.children.length) {
-                if (tags_1.useTag.has(tagName)) {
-                    remove();
-                    return;
-                }
-            }
-            // Remove attributes that use id
-            const matches = new Set(['#' + id, 'url(#' + id + ')']);
-            const attribs = element.attribs;
-            for (const attr in attribs) {
-                if (matches.has(attribs[attr])) {
-                    cheerio(element).removeAttr(attr);
-                }
-            }
-        }
-        const message = `Missing element with id="${id}"`;
-        if (fixErrors) {
-            fix();
-            console.warn(message);
-        }
-        else {
-            throw new Error(message);
-        }
-        return false;
-    });
-    // Check if tree item already has child item
-    function hasChildItem(tree, child, canThrow) {
-        const item = tree.children.find((item) => item.index === child.index &&
-            item.usedAsMask === child.usedAsMask);
-        if (item && canThrow) {
-            throw new Error('Recursion');
-        }
-        return !!item;
-    }
-    // Generate tree
-    const tree = {
-        index: 1,
-        usedAsMask: false,
-        children: [],
-    };
-    function parseTreeItem(tree, usedItems, inMask) {
-        var _a, _b;
-        const element = elements.get(tree.index);
-        // Add usage
-        if (tree.usedAsMask || inMask) {
-            element._usedAsMask = true;
-            inMask = true;
-        }
-        else {
-            element._usedAsPaint = true;
-        }
-        usedItems = usedItems.slice(0);
-        usedItems.push(element._index);
-        // Add all child elements
-        (_a = element._childElements) === null || _a === void 0 ? void 0 : _a.forEach((childIndex) => {
-            if (usedItems.indexOf(childIndex) !== -1) {
-                throw new Error('Recursion');
-            }
-            const childItem = {
-                index: childIndex,
-                usedAsMask: false,
-                children: [],
-                parent: tree,
-            };
-            tree.children.push(childItem);
-            parseTreeItem(childItem, usedItems, inMask);
-        });
-        // Add all links
-        (_b = element._linksTo) === null || _b === void 0 ? void 0 : _b.forEach((link) => {
-            const linkIndex = ids[link.id];
-            const usedAsMask = link.usedAsMask;
-            const childItem = {
-                index: linkIndex,
-                usedAsMask,
-                children: [],
-                parent: tree,
-            };
-            if (hasChildItem(tree, childItem, false)) {
-                return;
-            }
-            tree.children.push(childItem);
-            parseTreeItem(childItem, usedItems, inMask || usedAsMask);
-        });
-    }
-    parseTreeItem(tree, [0], false);
-    return {
-        elements,
-        ids,
-        links,
-        tree,
-    };
-}
-exports.analyseSVGStructure = analyseSVGStructure;

package/lib/svg/cleanup/attribs.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeBadAttributes = void 0;
-const attributes_1 = require("../data/attributes");
-const tags_1 = require("../data/tags");
-const parse_1 = require("../parse");
-/**
- * Remove useless attributes
- */
-async function removeBadAttributes(svg) {
-    await (0, parse_1.parseSVG)(svg, (item) => {
-        const tagName = item.tagName;
-        const attribs = item.element.attribs;
-        const $element = item.$element;
-        // Common tags
-        Object.keys(attribs).forEach((attr) => {
-            // Bad attributes, events
-            if (attr.slice(0, 2) === 'on' ||
-                attributes_1.badAttributes.has(attr) ||
-                attributes_1.badSoftwareAttributes.has(attr) ||
-                attributes_1.badAttributePrefixes.has(attr.split('-').shift())) {
-                $element.removeAttr(attr);
-                return;
-            }
-            // Attributes on <defs> aren't passed to child nodes, so remove everything)
-            if (tags_1.defsTag.has(tagName) &&
-                !attributes_1.tagSpecificPresentationalAttributes[tagName].has(attr)) {
-                $element.removeAttr(attr);
-                return;
-            }
-            // Check for namespace
-            const nsParts = attr.split(':');
-            if (nsParts.length > 1) {
-                const namespace = nsParts.shift();
-                const newAttr = nsParts.join(':');
-                switch (namespace) {
-                    case 'xlink': {
-                        // Deprecated: use without namespace
-                        if (attribs[newAttr] === void 0) {
-                            $element.attr(newAttr, attribs[attr]);
-                        }
-                        break;
-                    }
-                }
-                // Remove all namespace attributes
-                $element.removeAttr(attr);
-            }
-        });
-    });
-}
-exports.removeBadAttributes = removeBadAttributes;

package/lib/svg/cleanup/bad-tags.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkBadTags = void 0;
-const parse_1 = require("../parse");
-const tags_1 = require("../data/tags");
-// List of required parent tags
-const requiredParentTags = new Map();
-// <feFunc*> must be children of <feComponentTransfer>
-requiredParentTags.set(new Set(['feComponentTransfer']), tags_1.feComponentTransferChildTag);
-// <feMergeNode> must be children of <feMerge>
-requiredParentTags.set(new Set(['feMerge']), tags_1.feMergeChildTags);
-// Children of <fe*Lightning>
-requiredParentTags.set(tags_1.feLightningTags, tags_1.feLightningChildTags);
-// Filter tags must be children of <filter>
-requiredParentTags.set(tags_1.filterTag, tags_1.filterChildTags);
-// <stop> must be inside gradient
-requiredParentTags.set(tags_1.gradientTags, tags_1.gradientChildTags);
-// <mpath> must be inside <animateMotion>
-requiredParentTags.set(new Set(['animateMotion']), tags_1.animateMotionChildTags);
-/**
- * Test for bag tags
- */
-async function checkBadTags(svg) {
-    await (0, parse_1.parseSVG)(svg, (item) => {
-        var _a;
-        const tagName = item.tagName;
-        const $element = item.$element;
-        // SVG as root
-        if (tagName === 'svg') {
-            if (item.parents.length) {
-                // Technically code is correct, but it badly complicates parsing, so not supported
-                throw new Error(`Unexpected element: <${tagName}>`);
-            }
-            return;
-        }
-        // Unsupported: quietly remove it
-        if (tags_1.unsupportedTags.has(tagName)) {
-            $element.remove();
-            item.testChildren = false;
-            return;
-        }
-        // Bad or unknown element
-        if (tags_1.badTags.has(tagName) || !tags_1.allValidTags.has(tagName)) {
-            const parts = tagName.split(':');
-            if (parts.length > 1) {
-                // Custom tag, most likely Inkscape junk
-                $element.remove();
-                item.testChildren = false;
-                return;
-            }
-            throw new Error(`Unexpected element: <${tagName}>`);
-        }
-        // Check for valid parent tag
-        const parentTagName = (_a = item.parents[0]) === null || _a === void 0 ? void 0 : _a.tagName;
-        for (const [parents, children] of requiredParentTags) {
-            if (children.has(tagName)) {
-                if (!parents.has(parentTagName)) {
-                    throw new Error(`Element <${tagName}> has wrong parent element`);
-                }
-                return;
-            }
-        }
-    });
-}
-exports.checkBadTags = checkBadTags;

package/lib/svg/cleanup/inline-style.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanupInlineStyle = void 0;
-const parse_1 = require("../../css/parse");
-const attributes_1 = require("../data/attributes");
-const parse_2 = require("../parse");
-/**
- * Expand inline style
- */
-async function cleanupInlineStyle(svg) {
-    await (0, parse_2.parseSVG)(svg, (item) => {
-        const $element = item.$element;
-        const attribs = item.element.attribs;
-        const tagName = item.tagName;
-        // Expand style
-        if (attribs.style) {
-            const parsedStyle = (0, parse_1.parseInlineStyle)(attribs.style);
-            if (parsedStyle === null) {
-                // Ignore style
-                $element.removeAttr('style');
-            }
-            else {
-                const newStyle = Object.create(null);
-                const checkRule = (prop, value) => {
-                    var _a, _b, _c;
-                    function warn() {
-                        console.warn(`Removing unexpected style on "${tagName}": ${prop}`);
-                    }
-                    // Check for bad attributes that should be removed
-                    if (attributes_1.badAttributes.has(prop) ||
-                        ((_a = attributes_1.tagSpecificNonPresentationalAttributes[tagName]) === null || _a === void 0 ? void 0 : _a.has(prop))) {
-                        return;
-                    }
-                    // Valid attributes
-                    if (((_b = attributes_1.tagSpecificAnimatedAttributes[tagName]) === null || _b === void 0 ? void 0 : _b.has(prop)) ||
-                        ((_c = attributes_1.tagSpecificPresentationalAttributes[tagName]) === null || _c === void 0 ? void 0 : _c.has(prop))) {
-                        $element.attr(prop, value);
-                        return;
-                    }
-                    // Attributes inside <clipPath>
-                    if (attributes_1.insideClipPathAttributes.has(prop)) {
-                        if (item.parents.find((item) => item.tagName === 'clipPath')) {
-                            $element.attr(prop, value);
-                        }
-                        return;
-                    }
-                    // Bad software stuff
-                    if (attributes_1.badSoftwareAttributes.has(prop) ||
-                        attributes_1.badAttributePrefixes.has(prop.split('-').shift())) {
-                        return;
-                    }
-                    // Vendor specific junk
-                    if (prop.slice(0, 1) === '-') {
-                        return;
-                    }
-                    // Unknown
-                    warn();
-                };
-                // Check all properties
-                for (const prop in parsedStyle) {
-                    checkRule(prop, parsedStyle[prop]);
-                }
-                // Update style
-                const newStyleStr = Object.keys(newStyle)
-                    .map((key) => key + ':' + newStyle[key] + ';')
-                    .join('');
-                if (newStyleStr.length) {
-                    $element.attr('style', newStyleStr);
-                }
-                else {
-                    $element.removeAttr('style');
-                }
-            }
-        }
-    });
-}
-exports.cleanupInlineStyle = cleanupInlineStyle;

package/lib/svg/cleanup/root-svg.js

@@ -1,107 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanupSVGRoot = void 0;
-const attributes_1 = require("../data/attributes");
-const tags_1 = require("../data/tags");
-/**
- * Clean up SVG
- */
-async function cleanupSVGRoot(svg) {
-    const cheerio = svg.$svg;
-    const $root = svg.$svg(':root');
-    const root = $root.get(0);
-    const tagName = 'svg';
-    if (root.tagName !== tagName) {
-        throw new Error(`Unexpected root tag <${root.tagName}>`);
-    }
-    const attribs = root.attribs;
-    // Check attributes
-    const moveToChildren = {};
-    Object.keys(attribs).forEach((attr) => {
-        var _a, _b;
-        const value = attribs[attr];
-        // Bad attributes, irrelevant common attributes, namespaces
-        if (attributes_1.commonAttributes.has(attr) ||
-            attributes_1.badAttributes.has(attr) ||
-            attributes_1.junkSVGAttributes.has(attr) ||
-            attributes_1.badSoftwareAttributes.has(attr) ||
-            attributes_1.badAttributePrefixes.has(attr.split('-').shift()) ||
-            attr.split(':').length > 1) {
-            $root.removeAttr(attr);
-            return;
-        }
-        // Special handling for dimensions
-        switch (attr) {
-            case 'width':
-            case 'height':
-                // Cleanup dimensions
-                if (value.slice(-2) === 'px') {
-                    // Remove 'px'
-                    const num = value.replace('px', '');
-                    if (parseFloat(num) + '' === num) {
-                        $root.attr(attr, num);
-                    }
-                }
-                return;
-        }
-        // Attributes that belong to <svg>
-        if ((_a = attributes_1.tagSpecificNonPresentationalAttributes[tagName]) === null || _a === void 0 ? void 0 : _a.has(attr)) {
-            return;
-        }
-        // Presentational attributes: move to child elements
-        if (((_b = attributes_1.tagSpecificPresentationalAttributes[tagName]) === null || _b === void 0 ? void 0 : _b.has(attr)) &&
-            attributes_1.tagSpecificPresentationalAttributes.g.has(attr)) {
-            moveToChildren[attr] = value;
-            $root.removeAttr(attr);
-            return;
-        }
-        // Styling: 'style' should be checked by expandInlineStyle(), remove others
-        if (attributes_1.stylingAttributes.has(attr)) {
-            switch (attr) {
-                case 'style':
-                    return;
-                case 'class':
-                    $root.removeAttr(attr);
-                    return;
-            }
-            throw new Error(`Unexpected attribute "${attr}" on <${tagName}>`);
-        }
-        // Junk from bad editors, mostly Adobe Illustrator and Inkscape
-        if (
-        // Events
-        attr.slice(0, 2) === 'on' ||
-            // aria-stuff
-            attr.slice(0, 5) === 'aria-' ||
-            // Junk
-            attr.slice(0, 6) === 'xmlns:') {
-            $root.removeAttr(attr);
-            return;
-        }
-        console.warn(`Removing unexpected attribute on SVG: ${attr}`);
-        $root.removeAttr(attr);
-    });
-    if (Object.keys(moveToChildren).length) {
-        // Wrap child elements
-        const $wrapper = cheerio('<g />');
-        for (const key in moveToChildren) {
-            $wrapper.attr(key, moveToChildren[key]);
-        }
-        $root.children().each((_index, child) => {
-            const $child = cheerio(child);
-            if (child.type !== 'tag') {
-                $child.appendTo($wrapper);
-                return;
-            }
-            const tagName = child.tagName;
-            if (tagName === 'style' ||
-                tags_1.reusableElementsWithPalette.has(tagName) ||
-                tags_1.maskTags.has(tagName)) {
-                // Do not wrap these elements
-                return;
-            }
-            $child.appendTo($wrapper);
-        });
-        $wrapper.appendTo($root);
-    }
-}
-exports.cleanupSVGRoot = cleanupSVGRoot;

package/lib/svg/cleanup/svgo-style.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertStyleToAttrs = void 0;
-const attributes_1 = require("../data/attributes");
-const parse_style_1 = require("../parse-style");
-const svgo_1 = require("../../optimise/svgo");
-/**
- * Expand inline style
- */
-async function convertStyleToAttrs(svg) {
-    let hasStyle = false;
-    // Clean up style, removing useless junk
-    await (0, parse_style_1.parseSVGStyle)(svg, (item) => {
-        const prop = item.prop;
-        if (
-        // Attributes / properties now allowed
-        attributes_1.badAttributes.has(prop) ||
-            attributes_1.badSoftwareAttributes.has(prop) ||
-            attributes_1.badAttributePrefixes.has(prop.split('-').shift())) {
-            return void 0;
-        }
-        hasStyle = true;
-        return item.value;
-    });
-    // Nothing to check?
-    if (!hasStyle) {
-        return;
-    }
-    // Run SVGO
-    await (0, svgo_1.runSVGO)(svg, {
-        plugins: ['convertStyleToAttrs', 'inlineStyles'],
-        multipass: true,
-    });
-}
-exports.convertStyleToAttrs = convertStyleToAttrs;