@iconify/tools 2.0.9 → 2.0.13

package/lib/svg/analyse.mjs

@@ -0,0 +1,302 @@
+// src/svg/analyse.ts
+import { parseSVG } from "./parse.mjs";
+import {
+  commonColorPresentationalAttributes,
+  markerAttributes,
+  tagSpecificNonPresentationalAttributes,
+  urlPresentationalAttributes
+} from "./data/attributes.mjs";
+import {
+  defsTag,
+  maskTags,
+  reusableElementsWithPalette,
+  styleTag,
+  useTag
+} from "./data/tags.mjs";
+import { analyseTagError } from "./analyse/error.mjs";
+async function analyseSVGStructure(svg, options = {}) {
+  const fixErrors = options.fixErrors;
+  let root = svg.$svg(":root").get(0);
+  if (root._parsed) {
+    svg.load(svg.toString());
+    root = svg.$svg(":root").get(0);
+  }
+  root._parsed = true;
+  const cheerio = svg.$svg;
+  const elements = new Map();
+  const ids = Object.create(null);
+  let links = [];
+  function addID(element, id) {
+    if (ids[id]) {
+      throw new Error(`Duplicate id "${id}"`);
+    }
+    element._id = id;
+    ids[id] = element._index;
+    return true;
+  }
+  function gotElementWithID(element, id, isMask) {
+    addID(element, id);
+    if (!element._belongsTo) {
+      element._belongsTo = [];
+    }
+    element._belongsTo.push({
+      id,
+      isMask,
+      indexes: new Set([element._index])
+    });
+    return;
+  }
+  function gotReusableElement(item, isMask) {
+    const element = item.element;
+    const attribs = element.attribs;
+    const index2 = element._index;
+    const id = attribs["id"];
+    if (typeof id !== "string") {
+      const message = `Definition element ${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: index2
+    };
+    gotElementWithID(element, id, isMask);
+    return true;
+  }
+  function gotElementReference(item, id, usedAsMask) {
+    const element = item.element;
+    const usedByIndex = element._index;
+    const link = {
+      id,
+      usedByIndex,
+      usedAsMask
+    };
+    links.push(link);
+    if (!element._linksTo) {
+      element._linksTo = [];
+    }
+    element._linksTo.push(link);
+  }
+  let index = 0;
+  await parseSVG(svg, (item) => {
+    var _a;
+    const { tagName, parents } = item;
+    if (styleTag.has(tagName)) {
+      item.testChildren = false;
+      return;
+    }
+    const element = item.element;
+    const attribs = element.attribs;
+    index++;
+    element._index = index;
+    elements.set(index, element);
+    if (!parents.length) {
+      element._usedAsMask = false;
+      element._usedAsPaint = true;
+      return;
+    }
+    element._usedAsMask = false;
+    element._usedAsPaint = false;
+    const parentItem = parents[0];
+    const parentElement = parentItem.element;
+    if (maskTags.has(tagName)) {
+      if (!gotReusableElement(item, true)) {
+        return;
+      }
+    } else if (reusableElementsWithPalette.has(tagName)) {
+      if (!gotReusableElement(item, false)) {
+        return;
+      }
+    } else if (defsTag.has(parentItem.tagName)) {
+      if (!gotReusableElement(item, false)) {
+        return;
+      }
+    } else if (!defsTag.has(tagName)) {
+      element._usedAsMask = parentElement._usedAsMask;
+      element._usedAsPaint = parentElement._usedAsPaint;
+      element._parentElement = parentElement._index;
+      if (!parentElement._childElements) {
+        parentElement._childElements = [];
+      }
+      parentElement._childElements.push(index);
+      const parentReusableElement = parentElement._reusableElement;
+      if (parentReusableElement) {
+        if (element._reusableElement) {
+          throw new Error(`Reusable element ${analyseTagError(element)} is inside another reusable element id="${parentReusableElement.id}"`);
+        }
+        element._reusableElement = parentReusableElement;
+      }
+      const parentBelongsTo = parentElement._belongsTo;
+      if (parentBelongsTo) {
+        const list = element._belongsTo || (element._belongsTo = []);
+        parentBelongsTo.forEach((item2) => {
+          item2.indexes.add(index);
+          list.push(item2);
+        });
+      }
+      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);
+          }
+        }
+      }
+    }
+    if ((_a = tagSpecificNonPresentationalAttributes[tagName]) == null ? 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 ${analyseTagError(element)}`);
+        }
+        const id = href.slice(1);
+        gotElementReference(item, id, false);
+      }
+    }
+    Object.keys(attribs).forEach((attr) => {
+      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 (urlPresentationalAttributes.has(attr)) {
+        gotElementReference(item, id, attr !== "filter");
+        return;
+      }
+      if (commonColorPresentationalAttributes.has(attr) || markerAttributes.has(attr)) {
+        gotElementReference(item, id, false);
+        return;
+      }
+    });
+  });
+  links = links.filter((item) => {
+    const id = item.id;
+    if (ids[id]) {
+      return true;
+    }
+    function fix() {
+      const index2 = item.usedByIndex;
+      const element = elements.get(index2);
+      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 !== index2);
+          }
+          (_a = parent._belongsTo) == null ? void 0 : _a.forEach((list) => {
+            list.indexes.delete(index2);
+          });
+        }
+        $element.remove();
+      }
+      if (element._linksTo) {
+        element._linksTo = element._linksTo.filter((item2) => item2.id !== id);
+      }
+      if (!element.children.length) {
+        if (useTag.has(tagName)) {
+          remove();
+          return;
+        }
+      }
+      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;
+  });
+  function hasChildItem(tree2, child, canThrow) {
+    const item = tree2.children.find((item2) => item2.index === child.index && item2.usedAsMask === child.usedAsMask);
+    if (item && canThrow) {
+      throw new Error("Recursion");
+    }
+    return !!item;
+  }
+  const tree = {
+    index: 1,
+    usedAsMask: false,
+    children: []
+  };
+  function parseTreeItem(tree2, usedItems, inMask) {
+    var _a, _b;
+    const element = elements.get(tree2.index);
+    if (tree2.usedAsMask || inMask) {
+      element._usedAsMask = true;
+      inMask = true;
+    } else {
+      element._usedAsPaint = true;
+    }
+    usedItems = usedItems.slice(0);
+    usedItems.push(element._index);
+    (_a = element._childElements) == null ? void 0 : _a.forEach((childIndex) => {
+      if (usedItems.indexOf(childIndex) !== -1) {
+        throw new Error("Recursion");
+      }
+      const childItem = {
+        index: childIndex,
+        usedAsMask: false,
+        children: [],
+        parent: tree2
+      };
+      tree2.children.push(childItem);
+      parseTreeItem(childItem, usedItems, inMask);
+    });
+    (_b = element._linksTo) == null ? void 0 : _b.forEach((link) => {
+      const linkIndex = ids[link.id];
+      const usedAsMask = link.usedAsMask;
+      const childItem = {
+        index: linkIndex,
+        usedAsMask,
+        children: [],
+        parent: tree2
+      };
+      if (hasChildItem(tree2, childItem, false)) {
+        return;
+      }
+      tree2.children.push(childItem);
+      parseTreeItem(childItem, usedItems, inMask || usedAsMask);
+    });
+  }
+  parseTreeItem(tree, [0], false);
+  return {
+    elements,
+    ids,
+    links,
+    tree
+  };
+}
+export {
+  analyseSVGStructure
+};

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

@@ -1,4 +1,4 @@
-import type { SVG } from '..';
+import type { SVG } from '../../svg';
 /**
  * Remove useless attributes
  */

package/lib/svg/cleanup/attribs.js

@@ -2,12 +2,14 @@
 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
@@ -20,6 +22,12 @@ async function removeBadAttributes(svg) {
                 $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) {

package/lib/svg/cleanup/attribs.mjs

@@ -2,11 +2,14 @@
 import {
   badAttributes,
   badAttributePrefixes,
-  badSoftwareAttributes
+  badSoftwareAttributes,
+  tagSpecificPresentationalAttributes
 } from "../data/attributes.mjs";
+import { defsTag } from "../data/tags.mjs";
 import { parseSVG } from "../parse.mjs";
 async function removeBadAttributes(svg) {
   await parseSVG(svg, (item) => {
+    const tagName = item.tagName;
     const attribs = item.element.attribs;
     const $element = item.$element;
     Object.keys(attribs).forEach((attr) => {
@@ -14,6 +17,10 @@ async function removeBadAttributes(svg) {
         $element.removeAttr(attr);
         return;
       }
+      if (defsTag.has(tagName) && !tagSpecificPresentationalAttributes[tagName].has(attr)) {
+        $element.removeAttr(attr);
+        return;
+      }
       const nsParts = attr.split(":");
       if (nsParts.length > 1) {
         const namespace = nsParts.shift();

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

@@ -1,4 +1,4 @@
-import type { SVG } from '..';
+import type { SVG } from '../../svg';
 /**
  * Test for bag tags
  */

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

@@ -13,8 +13,6 @@ requiredParentTags.set(new Set(['feMerge']), tags_1.feMergeChildTags);
 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);
 // <mpath> must be inside <animateMotion>

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

@@ -4,7 +4,6 @@ import {
   allValidTags,
   animateMotionChildTags,
   badTags,
-  defsTag,
   feComponentTransferChildTag,
   feLightningChildTags,
   feLightningTags,
@@ -13,7 +12,6 @@ import {
   filterTag,
   gradientChildTags,
   gradientTags,
-  tagsInsideDefs,
   unsupportedTags
 } from "../data/tags.mjs";
 var requiredParentTags = new Map();
@@ -21,7 +19,6 @@ requiredParentTags.set(new Set(["feComponentTransfer"]), feComponentTransferChil
 requiredParentTags.set(new Set(["feMerge"]), feMergeChildTags);
 requiredParentTags.set(feLightningTags, feLightningChildTags);
 requiredParentTags.set(filterTag, filterChildTags);
-requiredParentTags.set(defsTag, tagsInsideDefs);
 requiredParentTags.set(gradientTags, gradientChildTags);
 requiredParentTags.set(new Set(["animateMotion"]), animateMotionChildTags);
 async function checkBadTags(svg) {

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

@@ -1,4 +1,4 @@
-import type { SVG } from '..';
+import type { SVG } from '../../svg';
 /**
  * Expand inline style
  */

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

@@ -1,4 +1,4 @@
-import type { SVG } from '..';
+import type { SVG } from '../../svg';
 /**
  * Clean up SVG
  */

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

@@ -77,7 +77,7 @@ async function cleanupSVGRoot(svg) {
             $root.removeAttr(attr);
             return;
         }
-        console.log(`Removing unexpected attribute on SVG: ${attr}`);
+        console.warn(`Removing unexpected attribute on SVG: ${attr}`);
         $root.removeAttr(attr);
     });
     if (Object.keys(moveToChildren).length) {
@@ -93,7 +93,9 @@ async function cleanupSVGRoot(svg) {
                 return;
             }
             const tagName = child.tagName;
-            if (tagName === 'style' || tags_1.maskAndSymbolTags.has(tagName)) {
+            if (tagName === 'style' ||
+                tags_1.reusableElementsWithPalette.has(tagName) ||
+                tags_1.maskTags.has(tagName)) {
                 // Do not wrap these elements
                 return;
             }

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

@@ -9,7 +9,7 @@ import {
   tagSpecificNonPresentationalAttributes,
   tagSpecificPresentationalAttributes
 } from "../data/attributes.mjs";
-import { maskAndSymbolTags } from "../data/tags.mjs";
+import { maskTags, reusableElementsWithPalette } from "../data/tags.mjs";
 async function cleanupSVGRoot(svg) {
   const cheerio = svg.$svg;
   const $root = svg.$svg(":root");
@@ -60,7 +60,7 @@ async function cleanupSVGRoot(svg) {
       $root.removeAttr(attr);
       return;
     }
-    console.log(`Removing unexpected attribute on SVG: ${attr}`);
+    console.warn(`Removing unexpected attribute on SVG: ${attr}`);
     $root.removeAttr(attr);
   });
   if (Object.keys(moveToChildren).length) {
@@ -75,7 +75,7 @@ async function cleanupSVGRoot(svg) {
         return;
       }
       const tagName2 = child.tagName;
-      if (tagName2 === "style" || maskAndSymbolTags.has(tagName2)) {
+      if (tagName2 === "style" || reusableElementsWithPalette.has(tagName2) || maskTags.has(tagName2)) {
         return;
       }
       $child.appendTo($wrapper);

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

@@ -1,4 +1,4 @@
-import type { SVG } from '..';
+import type { SVG } from '../../svg';
 /**
  * Expand inline style
  */

package/lib/svg/data/attributes.js

@@ -221,7 +221,7 @@ exports.tagSpecificPresentationalAttributes = {
     svg: new Set(['width', 'height', ...exports.presentationalAttributes]),
     // Defnitions, containers and masks
     clipPath: new Set([...exports.presentationalAttributes]),
-    defs: new Set([...exports.presentationalAttributes]),
+    defs: new Set([]),
     g: new Set([...exports.presentationalAttributes]),
     mask: new Set(['x', 'y', 'width', 'height', ...exports.presentationalAttributes]),
     symbol: new Set(['x', 'y', 'width', 'height', ...exports.presentationalAttributes]),

package/lib/svg/data/attributes.mjs

@@ -156,7 +156,7 @@ var tagSpecificAnimatedAttributes = {
 var tagSpecificPresentationalAttributes = {
   svg: new Set(["width", "height", ...presentationalAttributes]),
   clipPath: new Set([...presentationalAttributes]),
-  defs: new Set([...presentationalAttributes]),
+  defs: new Set([]),
   g: new Set([...presentationalAttributes]),
   mask: new Set(["x", "y", "width", "height", ...presentationalAttributes]),
   symbol: new Set(["x", "y", "width", "height", ...presentationalAttributes]),

package/lib/svg/data/tags.d.ts

@@ -29,9 +29,13 @@ export declare const styleTag: Set<string>;
  */
 export declare const defsTag: Set<string>;
 /**
- * Masks: colors are ignored, child elements must have id
+ * Masks: colors are ignored, elements must have id
  */
-export declare const maskAndSymbolTags: Set<string>;
+export declare const maskTags: Set<string>;
+/**
+ * Symbol
+ */
+export declare const symbolTag: Set<string>;
 /**
  * SVG shapes
  */
@@ -45,7 +49,7 @@ export declare const useTag: Set<string>;
  */
 export declare const groupTag: Set<string>;
 /**
- * Marker, must be inside <defs>
+ * Marker, should be inside <defs>
  */
 export declare const markerTag: Set<string>;
 /**
@@ -54,7 +58,7 @@ export declare const markerTag: Set<string>;
 export declare const animateTags: Set<string>;
 export declare const animateMotionChildTags: Set<string>;
 /**
- * Gradients, must be inside <defs>
+ * Gradients, should be inside <defs>
  */
 export declare const gradientTags: Set<string>;
 /**
@@ -62,7 +66,7 @@ export declare const gradientTags: Set<string>;
  */
 export declare const gradientChildTags: Set<string>;
 /**
- * Pattern, must be inside <defs>
+ * Pattern, should be inside <defs>
  */
 export declare const patternTag: Set<string>;
 /**
@@ -76,9 +80,13 @@ export declare const feLightningChildTags: Set<string>;
 export declare const feMergeChildTags: Set<string>;
 /***** Combination of tags *****/
 /**
- * Tags that can be used only inside <defs>
+ * Reusable elements that use colors
+ *
+ * Most are used via color attributes like `fill`
+ * Some are used via custom attributes like `marker-start`
+ * Filter is used via `filter`
  */
-export declare const tagsInsideDefs: Set<string>;
+export declare const reusableElementsWithPalette: Set<string>;
 /**
  * All supported tags
  */

package/lib/svg/data/tags.js

@@ -4,7 +4,7 @@
  * Icons cannot have anything that requires external resources, anything that renders inconsistently.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.allValidTags = exports.tagsInsideDefs = exports.feMergeChildTags = exports.feLightningChildTags = exports.feComponentTransferChildTag = exports.filterChildTags = exports.feLightningTags = exports.filterTag = exports.patternTag = exports.gradientChildTags = exports.gradientTags = exports.animateMotionChildTags = exports.animateTags = exports.markerTag = exports.groupTag = exports.useTag = exports.shapeTags = exports.maskAndSymbolTags = exports.defsTag = exports.styleTag = exports.unsupportedTags = exports.badTags = void 0;
+exports.allValidTags = exports.reusableElementsWithPalette = exports.feMergeChildTags = exports.feLightningChildTags = exports.feComponentTransferChildTag = exports.filterChildTags = exports.feLightningTags = exports.filterTag = exports.patternTag = exports.gradientChildTags = exports.gradientTags = exports.animateMotionChildTags = exports.animateTags = exports.markerTag = exports.groupTag = exports.useTag = exports.shapeTags = exports.symbolTag = exports.maskTags = exports.defsTag = exports.styleTag = exports.unsupportedTags = exports.badTags = void 0;
 /**
  * Bad tags
  *
@@ -57,9 +57,13 @@ exports.styleTag = new Set(['style']);
  */
 exports.defsTag = new Set(['defs']);
 /**
- * Masks: colors are ignored, child elements must have id
+ * Masks: colors are ignored, elements must have id
  */
-exports.maskAndSymbolTags = new Set(['clipPath', 'mask', 'symbol']);
+exports.maskTags = new Set(['clipPath', 'mask']);
+/**
+ * Symbol
+ */
+exports.symbolTag = new Set(['symbol']);
 /**
  * SVG shapes
  */
@@ -81,7 +85,7 @@ exports.useTag = new Set(['use']);
  */
 exports.groupTag = new Set(['g']);
 /**
- * Marker, must be inside <defs>
+ * Marker, should be inside <defs>
  */
 exports.markerTag = new Set(['marker']);
 /**
@@ -96,7 +100,7 @@ exports.animateTags = new Set([
 ]);
 exports.animateMotionChildTags = new Set(['mpath']);
 /**
- * Gradients, must be inside <defs>
+ * Gradients, should be inside <defs>
  */
 exports.gradientTags = new Set(['linearGradient', 'radialGradient']);
 /**
@@ -104,7 +108,7 @@ exports.gradientTags = new Set(['linearGradient', 'radialGradient']);
  */
 exports.gradientChildTags = new Set(['stop']);
 /**
- * Pattern, must be inside <defs>
+ * Pattern, should be inside <defs>
  */
 exports.patternTag = new Set(['pattern']);
 /**
@@ -146,12 +150,18 @@ exports.feLightningChildTags = new Set([
 exports.feMergeChildTags = new Set(['feMergeNode']);
 /***** Combination of tags *****/
 /**
- * Tags that can be used only inside <defs>
+ * Reusable elements that use colors
+ *
+ * Most are used via color attributes like `fill`
+ * Some are used via custom attributes like `marker-start`
+ * Filter is used via `filter`
  */
-exports.tagsInsideDefs = new Set([
+exports.reusableElementsWithPalette = new Set([
     ...exports.gradientTags,
     ...exports.patternTag,
     ...exports.markerTag,
+    ...exports.symbolTag,
+    ...exports.filterTag,
 ]);
 /**
  * All supported tags
@@ -159,7 +169,8 @@ exports.tagsInsideDefs = new Set([
 exports.allValidTags = new Set([
     ...exports.styleTag,
     ...exports.defsTag,
-    ...exports.maskAndSymbolTags,
+    ...exports.maskTags,
+    ...exports.symbolTag,
     ...exports.shapeTags,
     ...exports.useTag,
     ...exports.groupTag,

package/lib/svg/data/tags.mjs

@@ -22,7 +22,8 @@ var badTags = new Set([
 var unsupportedTags = new Set(["metadata", "desc", "title"]);
 var styleTag = new Set(["style"]);
 var defsTag = new Set(["defs"]);
-var maskAndSymbolTags = new Set(["clipPath", "mask", "symbol"]);
+var maskTags = new Set(["clipPath", "mask"]);
+var symbolTag = new Set(["symbol"]);
 var shapeTags = new Set([
   "circle",
   "ellipse",
@@ -80,15 +81,18 @@ var feLightningChildTags = new Set([
   "feDistantLight"
 ]);
 var feMergeChildTags = new Set(["feMergeNode"]);
-var tagsInsideDefs = new Set([
+var reusableElementsWithPalette = new Set([
   ...gradientTags,
   ...patternTag,
-  ...markerTag
+  ...markerTag,
+  ...symbolTag,
+  ...filterTag
 ]);
 var allValidTags = new Set([
   ...styleTag,
   ...defsTag,
-  ...maskAndSymbolTags,
+  ...maskTags,
+  ...symbolTag,
   ...shapeTags,
   ...useTag,
   ...groupTag,
@@ -120,11 +124,12 @@ export {
   gradientTags,
   groupTag,
   markerTag,
-  maskAndSymbolTags,
+  maskTags,
   patternTag,
+  reusableElementsWithPalette,
   shapeTags,
   styleTag,
-  tagsInsideDefs,
+  symbolTag,
   unsupportedTags,
   useTag
 };