@iconify/tools 1.3.17 → 2.0.0-dev.2

package/lib/svg/data/tags.mjs

@@ -0,0 +1,136 @@
+// src/svg/data/tags.ts
+var badTags = new Set([
+  "foreignObject",
+  "script",
+  "image",
+  "feImage",
+  "animateColor",
+  "altGlyph",
+  "text",
+  "tspan",
+  "switch",
+  "textPath",
+  "font",
+  "font-face",
+  "glyph",
+  "missing-glyph",
+  "hkern",
+  "vhern",
+  "view",
+  "a"
+]);
+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 shapeTags = new Set([
+  "circle",
+  "ellipse",
+  "line",
+  "path",
+  "polygon",
+  "polyline",
+  "rect"
+]);
+var useTag = new Set(["use"]);
+var groupTag = new Set(["g"]);
+var markerTag = new Set(["marker"]);
+var animateTags = 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([
+  "feDiffuseLighting",
+  "feSpecularLighting"
+]);
+var filterChildTags = new Set([
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDisplacementMap",
+  "feDropShadow",
+  "feFlood",
+  "feGaussianBlur",
+  "feMerge",
+  "feMorphology",
+  "feOffset",
+  "feTile",
+  "feTurbulence",
+  ...feLightningTags
+]);
+var feComponentTransferChildTag = new Set([
+  "feFuncR",
+  "feFuncG",
+  "feFuncB",
+  "feFuncA"
+]);
+var feLightningChildTags = new Set([
+  "feSpotLight",
+  "fePointLight",
+  "feDistantLight"
+]);
+var feMergeChildTags = new Set(["feMergeNode"]);
+var tagsInsideDefs = new Set([
+  ...gradientTags,
+  ...patternTag,
+  ...markerTag
+]);
+var tagsBeforeAnimation = new Set([
+  ...shapeTags,
+  ...filterChildTags,
+  ...feComponentTransferChildTag
+]);
+var allValidTags = new Set([
+  ...styleTag,
+  ...defsTag,
+  ...maskAndSymbolTags,
+  ...shapeTags,
+  ...useTag,
+  ...groupTag,
+  ...markerTag,
+  ...animateTags,
+  ...animateMotionChildTags,
+  ...gradientTags,
+  ...gradientChildTags,
+  ...patternTag,
+  ...filterTag,
+  ...filterChildTags,
+  ...feComponentTransferChildTag,
+  ...feLightningChildTags,
+  ...feMergeChildTags
+]);
+export {
+  allValidTags,
+  animateMotionChildTags,
+  animateTags,
+  badTags,
+  defsTag,
+  feComponentTransferChildTag,
+  feLightningChildTags,
+  feLightningTags,
+  feMergeChildTags,
+  filterChildTags,
+  filterTag,
+  gradientChildTags,
+  gradientTags,
+  groupTag,
+  markerTag,
+  maskAndSymbolTags,
+  patternTag,
+  shapeTags,
+  styleTag,
+  tagsBeforeAnimation,
+  tagsInsideDefs,
+  unsupportedTags,
+  useTag
+};

package/lib/svg/index.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="cheerio" />
+export interface ViewBox {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare class SVG {
+    $svg: cheerio.Root;
+    viewBox: ViewBox;
+    /**
+     * Constructor
+     */
+    constructor(content: string);
+    /**
+     * Get SVG as string
+     */
+    toString(): string;
+    /**
+     * Get SVG as string without whitespaces
+     */
+    toMinifiedString(): string;
+    /**
+     * Get body
+     */
+    getBody(): string;
+    /**
+     * Load SVG
+     *
+     * @param {string} content
+     */
+    load(content: string): void;
+}

package/lib/svg/index.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SVG = void 0;
+const cheerio_1 = __importDefault(require("cheerio"));
+class SVG {
+    /**
+     * Constructor
+     */
+    constructor(content) {
+        this.load(content);
+    }
+    /**
+     * Get SVG as string
+     */
+    toString() {
+        const $root = this.$svg(':root');
+        const box = this.viewBox;
+        // Add missing viewBox attribute
+        if ($root.attr('viewBox') === void 0) {
+            $root.attr('viewBox', box.left + ' ' + box.top + ' ' + box.width + ' ' + box.height);
+        }
+        // Add missing width/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();
+    }
+    /**
+     * Get SVG as string without whitespaces
+     */
+    toMinifiedString() {
+        return this.toString().replace(/\s*\n\s*/g, '');
+    }
+    /**
+     * Get body
+     */
+    getBody() {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this.$svg('svg')
+            .html()
+            .replace(/\s*\n\s*/g, '');
+    }
+    /**
+     * Load SVG
+     *
+     * @param {string} content
+     */
+    load(content) {
+        // Remove junk
+        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 comments
+        remove('<!--', '-->', '');
+        // Remove doctype and XML declaration
+        remove('<?xml', '?>', '');
+        remove('<!DOCTYPE svg', '<svg', '<svg');
+        // Remove Adobe Illustrator junk
+        remove('xmlns:x="&ns_extend;" xmlns:i="&ns_ai;" xmlns:graph="&ns_graphs;"', '', '');
+        remove('xml:space="preserve"', '', '');
+        // Remove empty <g> elements
+        content = content.replace(/<g>\s*<\/g>/g, '');
+        // Load content
+        this.$svg = cheerio_1.default.load(content.trim(), {
+            lowerCaseAttributeNames: false,
+            xmlMode: true,
+        });
+        // Check root
+        const $root = this.$svg(':root');
+        if ($root.length > 1 || $root.get(0).tagName !== 'svg') {
+            throw new Error('Invalid SVG file: bad root tag');
+        }
+        // Get dimensions and origin
+        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.mjs

@@ -0,0 +1,85 @@
+// src/svg/index.ts
+import cheerio from "cheerio";
+var SVG = class {
+  constructor(content) {
+    this.load(content);
+  }
+  toString() {
+    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() {
+    return this.toString().replace(/\s*\n\s*/g, "");
+  }
+  getBody() {
+    return this.$svg("svg").html().replace(/\s*\n\s*/g, "");
+  }
+  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.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}`);
+      }
+    });
+  }
+};
+export {
+  SVG
+};

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

@@ -0,0 +1,40 @@
+import type { SVG } from '.';
+import { ParseSVGCallbackItem } from './parse';
+/**
+ * Item in callback
+ */
+interface ParseSVGStyleCallbackItemCommon {
+    prop: string;
+    value: string;
+}
+interface ParseSVGStyleCallbackItemInline extends ParseSVGStyleCallbackItemCommon {
+    type: 'inline';
+    item: ParseSVGCallbackItem;
+}
+interface ParseSVGStyleCallbackItemGlobal extends ParseSVGStyleCallbackItemCommon {
+    type: 'global';
+}
+export declare type ParseSVGStyleCallbackItem = ParseSVGStyleCallbackItemInline | ParseSVGStyleCallbackItemGlobal;
+/**
+ * Result: undefined to remove item, string to change/keep item
+ */
+export declare type ParseSVGStyleCallbackResult = string | undefined;
+/**
+ * Callback function
+ */
+export declare type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult | Promise<ParseSVGStyleCallbackResult>;
+/**
+ * Options
+ */
+interface ParseSVGStyleOptions {
+    skipMasks?: boolean;
+}
+/**
+ * Parse styles in SVG
+ *
+ * This function finds CSS in SVG, parses it, calls callback for each rule.
+ * Callback should return new value (string) or undefined to remove rule.
+ * Callback can be asynchronous.
+ */
+export declare function parseSVGStyle(svg: SVG, callback: ParseSVGStyleCallback, options?: ParseSVGStyleOptions): Promise<void>;
+export {};

package/lib/svg/parse-style.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSVGStyle = void 0;
+const parse_1 = require("../css/parse");
+const export_1 = require("../css/parser/export");
+const tokens_1 = require("../css/parser/tokens");
+const tree_1 = require("../css/parser/tree");
+const tags_1 = require("./data/tags");
+const parse_2 = require("./parse");
+/**
+ * Parse styles in SVG
+ *
+ * This function finds CSS in SVG, parses it, calls callback for each rule.
+ * Callback should return new value (string) or undefined to remove rule.
+ * Callback can be asynchronous.
+ */
+async function parseSVGStyle(svg, callback, options = {}) {
+    return (0, parse_2.parseSVG)(svg, async (item) => {
+        const tagName = item.tagName;
+        const $element = item.$element;
+        if (tagName === 'style') {
+            // Style tag
+            const content = $element.html();
+            if (typeof content !== 'string') {
+                $element.remove();
+                return;
+            }
+            const tokens = (0, tokens_1.getTokens)(content);
+            if (!(tokens instanceof Array)) {
+                // Invalid style
+                throw new Error('Error parsing style');
+            }
+            // Parse all tokens
+            let changed = false;
+            const newTokens = [];
+            for (let i = 0; i < tokens.length; i++) {
+                const token = tokens[i];
+                if (token.type !== 'rule') {
+                    newTokens.push(token);
+                    continue;
+                }
+                const value = token.value;
+                let result = callback({
+                    type: 'global',
+                    prop: token.prop,
+                    value,
+                });
+                if (result instanceof Promise) {
+                    result = await result;
+                }
+                if (result !== void 0) {
+                    if (result !== value) {
+                        changed = true;
+                        token.value = result;
+                    }
+                    newTokens.push(token);
+                }
+                else {
+                    // Delete token
+                    changed = true;
+                }
+            }
+            if (!changed) {
+                return;
+            }
+            // Update style
+            const tree = (0, tree_1.tokensTree)(newTokens);
+            if (!tree.length) {
+                // Empty
+                $element.remove();
+                return;
+            }
+            const newContent = (0, export_1.tokensToString)(tree);
+            item.$element.text(newContent);
+            return;
+        }
+        // Skip masks
+        if (options.skipMasks && tags_1.maskAndSymbolTags.has(tagName)) {
+            return;
+        }
+        // Parse style
+        const attribs = item.element.attribs;
+        if (attribs.style === void 0) {
+            return;
+        }
+        const parsedStyle = (0, parse_1.parseInlineStyle)(attribs.style);
+        if (parsedStyle === null) {
+            // Ignore style
+            $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;
+                }
+            }
+        }
+        // Update style
+        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.mjs

@@ -0,0 +1,109 @@
+// 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 { maskAndSymbolTags } from "./data/tags.mjs";
+import { parseSVG } from "./parse.mjs";
+async function parseSVGStyle(svg, callback, options = {}) {
+  return 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 = getTokens(content);
+      if (!(tokens instanceof Array)) {
+        throw new Error("Error parsing style");
+      }
+      let changed2 = false;
+      const newTokens = [];
+      for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.type !== "rule") {
+          newTokens.push(token);
+          continue;
+        }
+        const value = token.value;
+        let result = callback({
+          type: "global",
+          prop: token.prop,
+          value
+        });
+        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 = tokensTree(newTokens);
+      if (!tree.length) {
+        $element.remove();
+        return;
+      }
+      const newContent = tokensToString(tree);
+      item.$element.text(newContent);
+      return;
+    }
+    if (options.skipMasks && maskAndSymbolTags.has(tagName)) {
+      return;
+    }
+    const attribs = item.element.attribs;
+    if (attribs.style === void 0) {
+      return;
+    }
+    const parsedStyle = 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);
+    }
+  });
+}
+export {
+  parseSVGStyle
+};

package/lib/svg/parse.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="cheerio" />
+import type { SVG } from './';
+/**
+ * Shortcuts for Cheerio elements
+ */
+export declare type CheerioElement = cheerio.TagElement;
+export declare type WrappedCheerioElement = cheerio.Cheerio;
+/**
+ * Item in callback
+ */
+export interface ParseSVGCallbackItem {
+    tagName: string;
+    element: CheerioElement;
+    $element: WrappedCheerioElement;
+    svg: SVG;
+    parents: ParseSVGCallbackItem[];
+    testChildren: boolean;
+    removeNode: boolean;
+}
+/**
+ * Callback function
+ */
+export 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>;