@iconify/tools 2.0.14 → 2.0.15

package/lib/svg/data/tags.mjs

@@ -1,5 +1,4 @@
-// src/svg/data/tags.ts
-var badTags = new Set([
+const badTags = /* @__PURE__ */ new Set([
   "foreignObject",
   "script",
   "image",
@@ -19,12 +18,12 @@ var badTags = new Set([
   "view",
   "a"
 ]);
-var unsupportedTags = new Set(["metadata", "desc", "title"]);
-var styleTag = new Set(["style"]);
-var defsTag = new Set(["defs"]);
-var maskTags = new Set(["clipPath", "mask"]);
-var symbolTag = new Set(["symbol"]);
-var shapeTags = new Set([
+const unsupportedTags = /* @__PURE__ */ new Set(["metadata", "desc", "title"]);
+const styleTag = /* @__PURE__ */ new Set(["style"]);
+const defsTag = /* @__PURE__ */ new Set(["defs"]);
+const maskTags = /* @__PURE__ */ new Set(["clipPath", "mask"]);
+const symbolTag = /* @__PURE__ */ new Set(["symbol"]);
+const shapeTags = /* @__PURE__ */ new Set([
   "circle",
   "ellipse",
   "line",
@@ -33,26 +32,26 @@ var shapeTags = new Set([
   "polyline",
   "rect"
 ]);
-var useTag = new Set(["use"]);
-var groupTag = new Set(["g"]);
-var markerTag = new Set(["marker"]);
-var animateTags = new Set([
+const useTag = /* @__PURE__ */ new Set(["use"]);
+const groupTag = /* @__PURE__ */ new Set(["g"]);
+const markerTag = /* @__PURE__ */ new Set(["marker"]);
+const animateTags = /* @__PURE__ */ new Set([
   "animate",
   "animateMotion",
   "animateTransform",
   "discard",
   "set"
 ]);
-var animateMotionChildTags = new Set(["mpath"]);
-var gradientTags = new Set(["linearGradient", "radialGradient"]);
-var gradientChildTags = new Set(["stop"]);
-var patternTag = new Set(["pattern"]);
-var filterTag = new Set(["filter"]);
-var feLightningTags = new Set([
+const animateMotionChildTags = /* @__PURE__ */ new Set(["mpath"]);
+const gradientTags = /* @__PURE__ */ new Set(["linearGradient", "radialGradient"]);
+const gradientChildTags = /* @__PURE__ */ new Set(["stop"]);
+const patternTag = /* @__PURE__ */ new Set(["pattern"]);
+const filterTag = /* @__PURE__ */ new Set(["filter"]);
+const feLightningTags = /* @__PURE__ */ new Set([
   "feDiffuseLighting",
   "feSpecularLighting"
 ]);
-var filterChildTags = new Set([
+const filterChildTags = /* @__PURE__ */ new Set([
   "feBlend",
   "feColorMatrix",
   "feComponentTransfer",
@@ -69,26 +68,26 @@ var filterChildTags = new Set([
   "feTurbulence",
   ...feLightningTags
 ]);
-var feComponentTransferChildTag = new Set([
+const feComponentTransferChildTag = /* @__PURE__ */ new Set([
   "feFuncR",
   "feFuncG",
   "feFuncB",
   "feFuncA"
 ]);
-var feLightningChildTags = new Set([
+const feLightningChildTags = /* @__PURE__ */ new Set([
   "feSpotLight",
   "fePointLight",
   "feDistantLight"
 ]);
-var feMergeChildTags = new Set(["feMergeNode"]);
-var reusableElementsWithPalette = new Set([
+const feMergeChildTags = /* @__PURE__ */ new Set(["feMergeNode"]);
+const reusableElementsWithPalette = /* @__PURE__ */ new Set([
   ...gradientTags,
   ...patternTag,
   ...markerTag,
   ...symbolTag,
   ...filterTag
 ]);
-var allValidTags = new Set([
+const allValidTags = /* @__PURE__ */ new Set([
   ...styleTag,
   ...defsTag,
   ...maskTags,
@@ -108,28 +107,5 @@ var allValidTags = new Set([
   ...feLightningChildTags,
   ...feMergeChildTags
 ]);
-export {
-  allValidTags,
-  animateMotionChildTags,
-  animateTags,
-  badTags,
-  defsTag,
-  feComponentTransferChildTag,
-  feLightningChildTags,
-  feLightningTags,
-  feMergeChildTags,
-  filterChildTags,
-  filterTag,
-  gradientChildTags,
-  gradientTags,
-  groupTag,
-  markerTag,
-  maskTags,
-  patternTag,
-  reusableElementsWithPalette,
-  shapeTags,
-  styleTag,
-  symbolTag,
-  unsupportedTags,
-  useTag
-};
+
+export { allValidTags, animateMotionChildTags, animateTags, badTags, defsTag, feComponentTransferChildTag, feLightningChildTags, feLightningTags, feMergeChildTags, filterChildTags, filterTag, gradientChildTags, gradientTags, groupTag, markerTag, maskTags, patternTag, reusableElementsWithPalette, shapeTags, styleTag, symbolTag, unsupportedTags, useTag };

package/lib/svg/index.cjs

@@ -0,0 +1,130 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const cheerio = require('cheerio');
+const utils = require('@iconify/utils');
+const icon = require('@iconify/utils/lib/icon');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
+const cheerio__default = /*#__PURE__*/_interopDefaultLegacy(cheerio);
+
+class SVG {
+  constructor(content) {
+    this.load(content);
+  }
+  toString(customisations) {
+    if (customisations) {
+      const data = utils.iconToSVG(icon.fullIcon(this.getIcon()), {
+        ...utils.defaultCustomisations,
+        ...customisations
+      });
+      let svgAttributes = ' xmlns="http://www.w3.org/2000/svg"';
+      if (data.body.indexOf("xlink:") !== -1) {
+        svgAttributes += ' xmlns:xlink="http://www.w3.org/1999/xlink"';
+      }
+      for (const key in data.attributes) {
+        const value = data.attributes[key];
+        svgAttributes += " " + key + '="' + value + '"';
+      }
+      if (data.inline) {
+        svgAttributes += ' style="vertical-align: -0.125em;"';
+      }
+      return "<svg" + svgAttributes + ">" + data.body + "</svg>";
+    }
+    const $root = this.$svg(":root");
+    const box = this.viewBox;
+    if ($root.attr("viewBox") === void 0) {
+      $root.attr("viewBox", box.left + " " + box.top + " " + box.width + " " + box.height);
+    }
+    if ($root.attr("width") === void 0) {
+      $root.attr("width", box.width + "");
+    }
+    if ($root.attr("height") === void 0) {
+      $root.attr("height", box.height + "");
+    }
+    return this.$svg.html();
+  }
+  toMinifiedString(customisations) {
+    return utils.trimSVG(this.toString(customisations));
+  }
+  getBody() {
+    const $root = this.$svg(":root");
+    const attribs = $root.get(0).attribs;
+    for (const key in attribs) {
+      switch (key.split("-").shift()) {
+        case "fill":
+        case "stroke":
+        case "opacity":
+          throw new Error(`Cannot use getBody() on icon that was not cleaned up with cleanupSVGRoot(). Icon has attribute ${key}="${attribs[key]}"`);
+      }
+    }
+    return utils.trimSVG(this.$svg("svg").html());
+  }
+  getIcon() {
+    const props = this.viewBox;
+    const body = this.getBody();
+    return {
+      ...props,
+      body
+    };
+  }
+  load(content) {
+    function remove(str1, str2, append) {
+      let start = 0;
+      while ((start = content.indexOf(str1, start)) !== -1) {
+        const end = content.indexOf(str2, start + str1.length);
+        if (end === -1) {
+          return;
+        }
+        content = content.slice(0, start) + append + content.slice(end + str2.length);
+        start = start + append.length;
+      }
+    }
+    remove("<!--", "-->", "");
+    remove("<?xml", "?>", "");
+    remove("<!DOCTYPE svg", "<svg", "<svg");
+    remove('xmlns:x="&ns_extend;" xmlns:i="&ns_ai;" xmlns:graph="&ns_graphs;"', "", "");
+    remove('xml:space="preserve"', "", "");
+    content = content.replace(/<g>\s*<\/g>/g, "");
+    this.$svg = cheerio__default.load(content.trim(), {
+      lowerCaseAttributeNames: false,
+      xmlMode: true
+    });
+    const $root = this.$svg(":root");
+    if ($root.length > 1 || $root.get(0).tagName !== "svg") {
+      throw new Error("Invalid SVG file: bad root tag");
+    }
+    const viewBox = $root.attr("viewBox");
+    if (viewBox !== void 0) {
+      const list = viewBox.split(" ");
+      this.viewBox = {
+        left: parseFloat(list[0]),
+        top: parseFloat(list[1]),
+        width: parseFloat(list[2]),
+        height: parseFloat(list[3])
+      };
+    } else {
+      const width = $root.attr("width");
+      const height = $root.attr("height");
+      if (!width || !height) {
+        throw new Error("Invalid SVG file: missing dimensions");
+      }
+      this.viewBox = {
+        left: 0,
+        top: 0,
+        width: parseFloat(width),
+        height: parseFloat(height)
+      };
+    }
+    Object.keys(this.viewBox).forEach((key) => {
+      const attr = key;
+      if (isNaN(this.viewBox[attr])) {
+        throw new Error(`Invalid SVG file: invalid ${attr}`);
+      }
+    });
+  }
+}
+
+exports.SVG = SVG;

package/lib/svg/index.d.ts

@@ -1,14 +1,19 @@
-/// <reference types="cheerio" />
-export interface ViewBox {
+import { IconifyIcon } from '@iconify/types';
+export { IconifyIcon } from '@iconify/types';
+import { IconifyIconCustomisations } from '@iconify/utils/lib/customisations';
+export { IconifyIconCustomisations } from '@iconify/utils/lib/customisations';
+
+interface ViewBox {
     left: number;
     top: number;
     width: number;
     height: number;
 }
+
 /**
  * SVG class, used to manipulate icon content.
  */
-export declare class SVG {
+declare class SVG {
     $svg: cheerio.Root;
     viewBox: ViewBox;
     /**
@@ -18,15 +23,19 @@ export declare class SVG {
     /**
      * Get SVG as string
      */
-    toString(): string;
+    toString(customisations?: IconifyIconCustomisations): string;
     /**
      * Get SVG as string without whitespaces
      */
-    toMinifiedString(): string;
+    toMinifiedString(customisations?: IconifyIconCustomisations): string;
     /**
      * Get body
      */
     getBody(): string;
+    /**
+     * Get icon as IconifyIcon
+     */
+    getIcon(): IconifyIcon;
     /**
      * Load SVG
      *
@@ -34,3 +43,5 @@ export declare class SVG {
      */
     load(content: string): void;
 }
+
+export { SVG, ViewBox };

package/lib/svg/index.mjs

@@ -1,13 +1,30 @@
-// src/svg/index.ts
-import cheerio from "cheerio";
-function minify(str) {
-  return str.replace(/(["';{}}><])\s*\n\s*/g, "$1").replace(/\s*\n\s*/g, " ").trim();
-}
-var SVG = class {
+import cheerio from 'cheerio';
+import { iconToSVG, defaultCustomisations, trimSVG } from '@iconify/utils';
+import { fullIcon } from '@iconify/utils/lib/icon';
+
+class SVG {
   constructor(content) {
     this.load(content);
   }
-  toString() {
+  toString(customisations) {
+    if (customisations) {
+      const data = iconToSVG(fullIcon(this.getIcon()), {
+        ...defaultCustomisations,
+        ...customisations
+      });
+      let svgAttributes = ' xmlns="http://www.w3.org/2000/svg"';
+      if (data.body.indexOf("xlink:") !== -1) {
+        svgAttributes += ' xmlns:xlink="http://www.w3.org/1999/xlink"';
+      }
+      for (const key in data.attributes) {
+        const value = data.attributes[key];
+        svgAttributes += " " + key + '="' + value + '"';
+      }
+      if (data.inline) {
+        svgAttributes += ' style="vertical-align: -0.125em;"';
+      }
+      return "<svg" + svgAttributes + ">" + data.body + "</svg>";
+    }
     const $root = this.$svg(":root");
     const box = this.viewBox;
     if ($root.attr("viewBox") === void 0) {
@@ -21,11 +38,29 @@ var SVG = class {
     }
     return this.$svg.html();
   }
-  toMinifiedString() {
-    return minify(this.toString());
+  toMinifiedString(customisations) {
+    return trimSVG(this.toString(customisations));
   }
   getBody() {
-    return minify(this.$svg("svg").html());
+    const $root = this.$svg(":root");
+    const attribs = $root.get(0).attribs;
+    for (const key in attribs) {
+      switch (key.split("-").shift()) {
+        case "fill":
+        case "stroke":
+        case "opacity":
+          throw new Error(`Cannot use getBody() on icon that was not cleaned up with cleanupSVGRoot(). Icon has attribute ${key}="${attribs[key]}"`);
+      }
+    }
+    return trimSVG(this.$svg("svg").html());
+  }
+  getIcon() {
+    const props = this.viewBox;
+    const body = this.getBody();
+    return {
+      ...props,
+      body
+    };
   }
   load(content) {
     function remove(str1, str2, append) {
@@ -82,7 +117,6 @@ var SVG = class {
       }
     });
   }
-};
-export {
-  SVG
-};
+}
+
+export { SVG };

package/lib/svg/parse-style.cjs

@@ -0,0 +1,134 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const css_parse = require('../css/parse.cjs');
+const css_parser_export = require('../css/parser/export.cjs');
+const css_parser_tokens = require('../css/parser/tokens.cjs');
+const css_parser_tree = require('../css/parser/tree.cjs');
+const svg_parse = require('./parse.cjs');
+require('../css/parser/error.cjs');
+require('../css/parser/strings.cjs');
+require('../css/parser/text.cjs');
+
+async function parseSVGStyle(svg, callback) {
+  return svg_parse.parseSVG(svg, async (item) => {
+    const tagName = item.tagName;
+    const $element = item.$element;
+    if (tagName === "style") {
+      const content = $element.html();
+      if (typeof content !== "string") {
+        $element.remove();
+        return;
+      }
+      const tokens = css_parser_tokens.getTokens(content);
+      if (!(tokens instanceof Array)) {
+        throw new Error("Error parsing style");
+      }
+      let changed2 = false;
+      const selectorStart = [];
+      const newTokens = [];
+      for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        switch (token.type) {
+          case "selector":
+          case "at-rule":
+            selectorStart.push(newTokens.length);
+            break;
+          case "close":
+            selectorStart.pop();
+            break;
+        }
+        if (token.type !== "rule") {
+          newTokens.push(token);
+          continue;
+        }
+        const value = token.value;
+        const selectorTokens = selectorStart.map((index) => newTokens[index]).filter((item2) => item2 !== null);
+        let result = callback({
+          type: "global",
+          prop: token.prop,
+          value,
+          token,
+          selectorTokens,
+          selectors: selectorTokens.reduce((prev, current) => {
+            switch (current.type) {
+              case "selector": {
+                return prev.concat(current.selectors);
+              }
+            }
+            return prev;
+          }, []),
+          prevTokens: newTokens,
+          nextTokens: tokens.slice(i + 1)
+        });
+        if (result instanceof Promise) {
+          result = await result;
+        }
+        if (result !== void 0) {
+          if (result !== value) {
+            changed2 = true;
+            token.value = result;
+          }
+          newTokens.push(token);
+        } else {
+          changed2 = true;
+        }
+      }
+      if (!changed2) {
+        return;
+      }
+      const tree = css_parser_tree.tokensTree(newTokens.filter((token) => token !== null));
+      if (!tree.length) {
+        $element.remove();
+        return;
+      }
+      const newContent = css_parser_export.tokensToString(tree);
+      item.$element.text(newContent);
+      return;
+    }
+    const attribs = item.element.attribs;
+    if (attribs.style === void 0) {
+      return;
+    }
+    const parsedStyle = css_parse.parseInlineStyle(attribs.style);
+    if (parsedStyle === null) {
+      $element.removeAttr("style");
+      return;
+    }
+    const props = Object.keys(parsedStyle);
+    let changed = false;
+    for (let i = 0; i < props.length; i++) {
+      const prop = props[i];
+      const value = parsedStyle[prop];
+      let result = callback({
+        type: "inline",
+        prop,
+        value,
+        item
+      });
+      if (result instanceof Promise) {
+        result = await result;
+      }
+      if (result !== value) {
+        changed = true;
+        if (result === void 0) {
+          delete parsedStyle[prop];
+        } else {
+          parsedStyle[prop] = result;
+        }
+      }
+    }
+    if (!changed) {
+      return;
+    }
+    const newStyle = Object.keys(parsedStyle).map((key) => key + ":" + parsedStyle[key] + ";").join("");
+    if (!newStyle.length) {
+      $element.removeAttr("style");
+    } else {
+      $element.attr("style", newStyle);
+    }
+  });
+}
+
+exports.parseSVGStyle = parseSVGStyle;

package/lib/svg/parse-style.d.ts

@@ -1,6 +1,9 @@
-import type { SVG } from '.';
-import type { CSSRuleToken, CSSToken } from '../css/parser/types';
-import { ParseSVGCallbackItem } from './parse';
+import { SVG } from './index.js';
+import { CSSRuleToken, CSSToken } from '../css/parser/types.js';
+import { ParseSVGCallbackItem } from './parse.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
 /**
  * Item in callback
  */
@@ -20,15 +23,15 @@ interface ParseSVGStyleCallbackItemGlobal extends ParseSVGStyleCallbackItemCommo
     prevTokens: (CSSToken | null)[];
     nextTokens: CSSToken[];
 }
-export declare type ParseSVGStyleCallbackItem = ParseSVGStyleCallbackItemInline | ParseSVGStyleCallbackItemGlobal;
+declare type ParseSVGStyleCallbackItem = ParseSVGStyleCallbackItemInline | ParseSVGStyleCallbackItemGlobal;
 /**
  * Result: undefined to remove item, string to change/keep item
  */
-export declare type ParseSVGStyleCallbackResult = string | undefined;
+declare type ParseSVGStyleCallbackResult = string | undefined;
 /**
  * Callback function
  */
-export declare type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult | Promise<ParseSVGStyleCallbackResult>;
+declare type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult | Promise<ParseSVGStyleCallbackResult>;
 /**
  * Parse styles in SVG
  *
@@ -36,5 +39,6 @@ export declare type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) =>
  * Callback should return new value (string) or undefined to remove rule.
  * Callback can be asynchronous.
  */
-export declare function parseSVGStyle(svg: SVG, callback: ParseSVGStyleCallback): Promise<void>;
-export {};
+declare function parseSVGStyle(svg: SVG, callback: ParseSVGStyleCallback): Promise<void>;
+
+export { ParseSVGStyleCallback, ParseSVGStyleCallbackItem, ParseSVGStyleCallbackResult, parseSVGStyle };

package/lib/svg/parse-style.mjs

@@ -1,9 +1,12 @@
-// src/svg/parse-style.ts
-import { parseInlineStyle } from "../css/parse.mjs";
-import { tokensToString } from "../css/parser/export.mjs";
-import { getTokens } from "../css/parser/tokens.mjs";
-import { tokensTree } from "../css/parser/tree.mjs";
-import { parseSVG } from "./parse.mjs";
+import { parseInlineStyle } from '../css/parse.mjs';
+import { tokensToString } from '../css/parser/export.mjs';
+import { getTokens } from '../css/parser/tokens.mjs';
+import { tokensTree } from '../css/parser/tree.mjs';
+import { parseSVG } from './parse.mjs';
+import '../css/parser/error.mjs';
+import '../css/parser/strings.mjs';
+import '../css/parser/text.mjs';
+
 async function parseSVGStyle(svg, callback) {
   return parseSVG(svg, async (item) => {
     const tagName = item.tagName;
@@ -123,6 +126,5 @@ async function parseSVGStyle(svg, callback) {
     }
   });
 }
-export {
-  parseSVGStyle
-};
+
+export { parseSVGStyle };

package/lib/svg/parse.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+async function parseSVG(svg, callback) {
+  async function checkNode(element, parents) {
+    if (element.type !== "tag") {
+      return;
+    }
+    const $element = cheerio(element);
+    const tagName = element.tagName;
+    const item = {
+      tagName,
+      element,
+      $element,
+      svg,
+      parents,
+      testChildren: true,
+      removeNode: false
+    };
+    const result = callback(item);
+    if (result instanceof Promise) {
+      await result;
+    }
+    const newParents = parents.slice(0);
+    newParents.unshift(item);
+    if (tagName !== "style" && item.testChildren && !item.removeNode) {
+      const children = $element.children().toArray();
+      for (let i = 0; i < children.length; i++) {
+        await checkNode(children[i], newParents);
+      }
+    }
+    if (item.removeNode) {
+      $element.remove();
+    }
+  }
+  const cheerio = svg.$svg;
+  const $root = svg.$svg(":root");
+  await checkNode($root.get(0), []);
+}
+
+exports.parseSVG = parseSVG;

package/lib/svg/parse.d.ts

@@ -1,14 +1,16 @@
-/// <reference types="cheerio" />
-import type { SVG } from './';
+import { SVG } from './index.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
 /**
  * Shortcuts for Cheerio elements
  */
-export declare type CheerioElement = cheerio.TagElement;
-export declare type WrappedCheerioElement = cheerio.Cheerio;
+declare type CheerioElement = cheerio.TagElement;
+declare type WrappedCheerioElement = cheerio.Cheerio;
 /**
  * Item in callback
  */
-export interface ParseSVGCallbackItem {
+interface ParseSVGCallbackItem {
     tagName: string;
     element: CheerioElement;
     $element: WrappedCheerioElement;
@@ -20,11 +22,13 @@ export interface ParseSVGCallbackItem {
 /**
  * Callback function
  */
-export declare type ParseSVGCallback = (item: ParseSVGCallbackItem) => void | Promise<void>;
+declare type ParseSVGCallback = (item: ParseSVGCallbackItem) => void | Promise<void>;
 /**
  * Parse SVG
  *
  * This function finds all elements in SVG and calls callback for each element.
  * Callback can be asynchronous.
  */
-export declare function parseSVG(svg: SVG, callback: ParseSVGCallback): Promise<void>;
+declare function parseSVG(svg: SVG, callback: ParseSVGCallback): Promise<void>;
+
+export { CheerioElement, ParseSVGCallback, ParseSVGCallbackItem, WrappedCheerioElement, parseSVG };

package/lib/svg/parse.mjs

@@ -1,4 +1,3 @@
-// src/svg/parse.ts
 async function parseSVG(svg, callback) {
   async function checkNode(element, parents) {
     if (element.type !== "tag") {
@@ -35,6 +34,5 @@ async function parseSVG(svg, callback) {
   const $root = svg.$svg(":root");
   await checkNode($root.get(0), []);
 }
-export {
-  parseSVG
-};
+
+export { parseSVG };