@iconify/tools 1.3.17 → 2.0.0-dev.2

package/lib/optimise/svgo.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSVGO = exports.shapeModifiyingSVGOPlugins = exports.defaultSVGOPlugins = void 0;
+const svgo_1 = require("svgo");
+exports.defaultSVGOPlugins = [
+    'cleanupAttrs',
+    'mergeStyles',
+    'inlineStyles',
+    'removeComments',
+    'removeUselessDefs',
+    'removeEditorsNSData',
+    'removeEmptyAttrs',
+    'removeEmptyContainers',
+    'convertStyleToAttrs',
+    'convertColors',
+    'convertTransform',
+    'removeUnknownsAndDefaults',
+    'removeNonInheritableGroupAttrs',
+    'removeUselessStrokeAndFill',
+    'removeUnusedNS',
+    'cleanupNumericValues',
+    'cleanupListOfValues',
+    'moveElemsAttrsToGroup',
+    'moveGroupAttrsToElems',
+    'collapseGroups',
+    'sortDefsChildren',
+    'sortAttrs',
+];
+/**
+ * Plugins that modify shapes. Added to plugins list, unless 'keepShapes' option is enabled
+ */
+exports.shapeModifiyingSVGOPlugins = [
+    'removeHiddenElems',
+    'convertShapeToPath',
+    'convertEllipseToCircle',
+    {
+        name: 'convertPathData',
+        params: {
+            noSpaceAfterFlags: true,
+        },
+    },
+    {
+        name: 'mergePaths',
+        params: {
+            noSpaceAfterFlags: true,
+        },
+    },
+    'removeOffCanvasPaths',
+    'reusePaths',
+];
+/**
+ * Run SVGO on icon
+ */
+async function runSVGO(svg, options = {}) {
+    // Options
+    const multipass = options.multipass !== false;
+    // Plugins list
+    let plugins;
+    if (options.plugins) {
+        plugins = options.plugins;
+    }
+    else {
+        plugins = exports.defaultSVGOPlugins.concat(options.keepShapes ? [] : exports.shapeModifiyingSVGOPlugins, options.cleanupIDs !== false
+            ? [
+                {
+                    name: 'cleanupIDs',
+                    params: {
+                        prefix: typeof options.cleanupIDs === 'string'
+                            ? options.cleanupIDs
+                            : 'svg-',
+                    },
+                },
+            ]
+            : []);
+    }
+    // Run SVGO
+    const pluginOptions = {
+        plugins,
+        multipass,
+    };
+    // Load data (changing type because SVGO types do not include error ?????)
+    const result = (0, svgo_1.optimize)(svg.toString(), pluginOptions);
+    if (typeof result.error === 'string') {
+        throw new Error(result.error);
+    }
+    svg.load(result.data);
+}
+exports.runSVGO = runSVGO;

package/lib/optimise/svgo.mjs

@@ -0,0 +1,75 @@
+// src/optimise/svgo.ts
+import { optimize } from "svgo";
+var defaultSVGOPlugins = [
+  "cleanupAttrs",
+  "mergeStyles",
+  "inlineStyles",
+  "removeComments",
+  "removeUselessDefs",
+  "removeEditorsNSData",
+  "removeEmptyAttrs",
+  "removeEmptyContainers",
+  "convertStyleToAttrs",
+  "convertColors",
+  "convertTransform",
+  "removeUnknownsAndDefaults",
+  "removeNonInheritableGroupAttrs",
+  "removeUselessStrokeAndFill",
+  "removeUnusedNS",
+  "cleanupNumericValues",
+  "cleanupListOfValues",
+  "moveElemsAttrsToGroup",
+  "moveGroupAttrsToElems",
+  "collapseGroups",
+  "sortDefsChildren",
+  "sortAttrs"
+];
+var shapeModifiyingSVGOPlugins = [
+  "removeHiddenElems",
+  "convertShapeToPath",
+  "convertEllipseToCircle",
+  {
+    name: "convertPathData",
+    params: {
+      noSpaceAfterFlags: true
+    }
+  },
+  {
+    name: "mergePaths",
+    params: {
+      noSpaceAfterFlags: true
+    }
+  },
+  "removeOffCanvasPaths",
+  "reusePaths"
+];
+async function runSVGO(svg, options = {}) {
+  const multipass = options.multipass !== false;
+  let plugins;
+  if (options.plugins) {
+    plugins = options.plugins;
+  } else {
+    plugins = defaultSVGOPlugins.concat(options.keepShapes ? [] : shapeModifiyingSVGOPlugins, options.cleanupIDs !== false ? [
+      {
+        name: "cleanupIDs",
+        params: {
+          prefix: typeof options.cleanupIDs === "string" ? options.cleanupIDs : "svg-"
+        }
+      }
+    ] : []);
+  }
+  const pluginOptions = {
+    plugins,
+    multipass
+  };
+  const result = optimize(svg.toString(), pluginOptions);
+  if (typeof result.error === "string") {
+    throw new Error(result.error);
+  }
+  svg.load(result.data);
+}
+export {
+  defaultSVGOPlugins,
+  runSVGO,
+  shapeModifiyingSVGOPlugins
+};

package/lib/svg/cleanup/attribs.d.ts

@@ -0,0 +1,5 @@
+import type { SVG } from '..';
+/**
+ * Remove useless attributes
+ */
+export declare function removeBadAttributes(svg: SVG): Promise<void>;

package/lib/svg/cleanup/attribs.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeBadAttributes = void 0;
+const attributes_1 = require("../data/attributes");
+const parse_1 = require("../parse");
+/**
+ * Remove useless attributes
+ */
+async function removeBadAttributes(svg) {
+    await (0, parse_1.parseSVG)(svg, (item) => {
+        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;
+            }
+            // 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/attribs.mjs

@@ -0,0 +1,36 @@
+// src/svg/cleanup/attribs.ts
+import {
+  badAttributes,
+  badAttributePrefixes,
+  badSoftwareAttributes
+} from "../data/attributes.mjs";
+import { parseSVG } from "../parse.mjs";
+async function removeBadAttributes(svg) {
+  await parseSVG(svg, (item) => {
+    const attribs = item.element.attribs;
+    const $element = item.$element;
+    Object.keys(attribs).forEach((attr) => {
+      if (attr.slice(0, 2) === "on" || badAttributes.has(attr) || badSoftwareAttributes.has(attr) || badAttributePrefixes.has(attr.split("-").shift())) {
+        $element.removeAttr(attr);
+        return;
+      }
+      const nsParts = attr.split(":");
+      if (nsParts.length > 1) {
+        const namespace = nsParts.shift();
+        const newAttr = nsParts.join(":");
+        switch (namespace) {
+          case "xlink": {
+            if (attribs[newAttr] === void 0) {
+              $element.attr(newAttr, attribs[attr]);
+            }
+            break;
+          }
+        }
+        $element.removeAttr(attr);
+      }
+    });
+  });
+}
+export {
+  removeBadAttributes
+};

package/lib/svg/cleanup/bad-tags.d.ts

@@ -0,0 +1,5 @@
+import type { SVG } from '..';
+/**
+ * Test for bag tags
+ */
+export declare function checkBadTags(svg: SVG): Promise<void>;

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

@@ -0,0 +1,69 @@
+"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);
+// Tags that must be inside <defs>: gradients, <pattern>, <marker>
+requiredParentTags.set(tags_1.defsTag, tags_1.tagsInsideDefs);
+// <stop> must be inside gradient
+requiredParentTags.set(tags_1.gradientTags, tags_1.gradientChildTags);
+// Animations must be inside shapes or filters
+requiredParentTags.set(tags_1.tagsBeforeAnimation, tags_1.animateTags);
+// <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/bad-tags.mjs

@@ -0,0 +1,68 @@
+// src/svg/cleanup/bad-tags.ts
+import { parseSVG } from "../parse.mjs";
+import {
+  allValidTags,
+  animateMotionChildTags,
+  animateTags,
+  badTags,
+  defsTag,
+  feComponentTransferChildTag,
+  feLightningChildTags,
+  feLightningTags,
+  feMergeChildTags,
+  filterChildTags,
+  filterTag,
+  gradientChildTags,
+  gradientTags,
+  tagsBeforeAnimation,
+  tagsInsideDefs,
+  unsupportedTags
+} from "../data/tags.mjs";
+var requiredParentTags = new Map();
+requiredParentTags.set(new Set(["feComponentTransfer"]), feComponentTransferChildTag);
+requiredParentTags.set(new Set(["feMerge"]), feMergeChildTags);
+requiredParentTags.set(feLightningTags, feLightningChildTags);
+requiredParentTags.set(filterTag, filterChildTags);
+requiredParentTags.set(defsTag, tagsInsideDefs);
+requiredParentTags.set(gradientTags, gradientChildTags);
+requiredParentTags.set(tagsBeforeAnimation, animateTags);
+requiredParentTags.set(new Set(["animateMotion"]), animateMotionChildTags);
+async function checkBadTags(svg) {
+  await parseSVG(svg, (item) => {
+    var _a;
+    const tagName = item.tagName;
+    const $element = item.$element;
+    if (tagName === "svg") {
+      if (item.parents.length) {
+        throw new Error(`Unexpected element: <${tagName}>`);
+      }
+      return;
+    }
+    if (unsupportedTags.has(tagName)) {
+      $element.remove();
+      item.testChildren = false;
+      return;
+    }
+    if (badTags.has(tagName) || !allValidTags.has(tagName)) {
+      const parts = tagName.split(":");
+      if (parts.length > 1) {
+        $element.remove();
+        item.testChildren = false;
+        return;
+      }
+      throw new Error(`Unexpected element: <${tagName}>`);
+    }
+    const parentTagName = (_a = item.parents[0]) == null ? 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;
+      }
+    }
+  });
+}
+export {
+  checkBadTags
+};

package/lib/svg/cleanup/inline-style.d.ts

@@ -0,0 +1,5 @@
+import type { SVG } from '..';
+/**
+ * Expand inline style
+ */
+export declare function cleanupInlineStyle(svg: SVG): Promise<void>;

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

@@ -0,0 +1,77 @@
+"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/inline-style.mjs

@@ -0,0 +1,65 @@
+// src/svg/cleanup/inline-style.ts
+import { parseInlineStyle } from "../../css/parse.mjs";
+import {
+  badAttributes,
+  badAttributePrefixes,
+  badSoftwareAttributes,
+  insideClipPathAttributes,
+  tagSpecificAnimatedAttributes,
+  tagSpecificNonPresentationalAttributes,
+  tagSpecificPresentationalAttributes
+} from "../data/attributes.mjs";
+import { parseSVG } from "../parse.mjs";
+async function cleanupInlineStyle(svg) {
+  await parseSVG(svg, (item) => {
+    const $element = item.$element;
+    const attribs = item.element.attribs;
+    const tagName = item.tagName;
+    if (attribs.style) {
+      const parsedStyle = parseInlineStyle(attribs.style);
+      if (parsedStyle === null) {
+        $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}`);
+          }
+          if (badAttributes.has(prop) || ((_a = tagSpecificNonPresentationalAttributes[tagName]) == null ? void 0 : _a.has(prop))) {
+            return;
+          }
+          if (((_b = tagSpecificAnimatedAttributes[tagName]) == null ? void 0 : _b.has(prop)) || ((_c = tagSpecificPresentationalAttributes[tagName]) == null ? void 0 : _c.has(prop))) {
+            $element.attr(prop, value);
+            return;
+          }
+          if (insideClipPathAttributes.has(prop)) {
+            if (item.parents.find((item2) => item2.tagName === "clipPath")) {
+              $element.attr(prop, value);
+            }
+            return;
+          }
+          if (badSoftwareAttributes.has(prop) || badAttributePrefixes.has(prop.split("-").shift())) {
+            return;
+          }
+          if (prop.slice(0, 1) === "-") {
+            return;
+          }
+          warn();
+        };
+        for (const prop in parsedStyle) {
+          checkRule(prop, parsedStyle[prop]);
+        }
+        const newStyleStr = Object.keys(newStyle).map((key) => key + ":" + newStyle[key] + ";").join("");
+        if (newStyleStr.length) {
+          $element.attr("style", newStyleStr);
+        } else {
+          $element.removeAttr("style");
+        }
+      }
+    }
+  });
+}
+export {
+  cleanupInlineStyle
+};

package/lib/svg/cleanup/root-svg.d.ts

@@ -0,0 +1,5 @@
+import type { SVG } from '..';
+/**
+ * Clean up SVG
+ */
+export declare function cleanupSVGRoot(svg: SVG): Promise<void>;

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

@@ -0,0 +1,106 @@
+"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.log(`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]);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars-experimental
+        $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.maskAndSymbolTags.has(tagName)) {
+                // Do not wrap these elements
+                return;
+            }
+            $child.appendTo($wrapper);
+        });
+        $wrapper.appendTo($root);
+    }
+}
+exports.cleanupSVGRoot = cleanupSVGRoot;