@iconify/tools 2.0.14 → 2.0.17

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

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const css_parse = require('../../css/parse.cjs');
+const svg_data_attributes = require('../data/attributes.cjs');
+const svg_parse = require('../parse.cjs');
+require('../../css/parser/tokens.cjs');
+require('../../css/parser/error.cjs');
+require('../../css/parser/strings.cjs');
+require('../../css/parser/text.cjs');
+require('../data/tags.cjs');
+
+async function cleanupInlineStyle(svg) {
+  await svg_parse.parseSVG(svg, (item) => {
+    const $element = item.$element;
+    const attribs = item.element.attribs;
+    const tagName = item.tagName;
+    if (attribs.style) {
+      const parsedStyle = css_parse.parseInlineStyle(attribs.style);
+      if (parsedStyle === null) {
+        $element.removeAttr("style");
+      } else {
+        const newStyle = /* @__PURE__ */ Object.create(null);
+        const checkRule = (prop, value) => {
+          function warn() {
+            console.warn(`Removing unexpected style on "${tagName}": ${prop}`);
+          }
+          if (svg_data_attributes.badAttributes.has(prop) || svg_data_attributes.tagSpecificNonPresentationalAttributes[tagName]?.has(prop)) {
+            return;
+          }
+          if (svg_data_attributes.tagSpecificAnimatedAttributes[tagName]?.has(prop) || svg_data_attributes.tagSpecificPresentationalAttributes[tagName]?.has(prop)) {
+            $element.attr(prop, value);
+            return;
+          }
+          if (svg_data_attributes.insideClipPathAttributes.has(prop)) {
+            if (item.parents.find((item2) => item2.tagName === "clipPath")) {
+              $element.attr(prop, value);
+            }
+            return;
+          }
+          if (svg_data_attributes.badSoftwareAttributes.has(prop) || svg_data_attributes.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");
+        }
+      }
+    }
+  });
+}
+
+exports.cleanupInlineStyle = cleanupInlineStyle;

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

@@ -1,5 +1,10 @@
-import type { SVG } from '../../svg';
+import { SVG } from '../index.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
 /**
  * Expand inline style
  */
-export declare function cleanupInlineStyle(svg: SVG): Promise<void>;
+declare function cleanupInlineStyle(svg: SVG): Promise<void>;
+
+export { cleanupInlineStyle };

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

@@ -1,15 +1,12 @@
-// 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";
+import { parseInlineStyle } from '../../css/parse.mjs';
+import { badAttributes, tagSpecificNonPresentationalAttributes, tagSpecificAnimatedAttributes, tagSpecificPresentationalAttributes, insideClipPathAttributes, badSoftwareAttributes, badAttributePrefixes } from '../data/attributes.mjs';
+import { parseSVG } from '../parse.mjs';
+import '../../css/parser/tokens.mjs';
+import '../../css/parser/error.mjs';
+import '../../css/parser/strings.mjs';
+import '../../css/parser/text.mjs';
+import '../data/tags.mjs';
+
 async function cleanupInlineStyle(svg) {
   await parseSVG(svg, (item) => {
     const $element = item.$element;
@@ -20,16 +17,15 @@ async function cleanupInlineStyle(svg) {
       if (parsedStyle === null) {
         $element.removeAttr("style");
       } else {
-        const newStyle = Object.create(null);
+        const newStyle = /* @__PURE__ */ 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))) {
+          if (badAttributes.has(prop) || tagSpecificNonPresentationalAttributes[tagName]?.has(prop)) {
             return;
           }
-          if (((_b = tagSpecificAnimatedAttributes[tagName]) == null ? void 0 : _b.has(prop)) || ((_c = tagSpecificPresentationalAttributes[tagName]) == null ? void 0 : _c.has(prop))) {
+          if (tagSpecificAnimatedAttributes[tagName]?.has(prop) || tagSpecificPresentationalAttributes[tagName]?.has(prop)) {
             $element.attr(prop, value);
             return;
           }
@@ -60,6 +56,5 @@ async function cleanupInlineStyle(svg) {
     }
   });
 }
-export {
-  cleanupInlineStyle
-};
+
+export { cleanupInlineStyle };

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

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const svg_data_attributes = require('../data/attributes.cjs');
+const svg_data_tags = require('../data/tags.cjs');
+
+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;
+  const moveToChildren = {};
+  Object.keys(attribs).forEach((attr) => {
+    const value = attribs[attr];
+    if (svg_data_attributes.commonAttributes.has(attr) || svg_data_attributes.badAttributes.has(attr) || svg_data_attributes.junkSVGAttributes.has(attr) || svg_data_attributes.badSoftwareAttributes.has(attr) || svg_data_attributes.badAttributePrefixes.has(attr.split("-").shift()) || attr.split(":").length > 1) {
+      $root.removeAttr(attr);
+      return;
+    }
+    switch (attr) {
+      case "width":
+      case "height":
+        if (value.slice(-2) === "px") {
+          const num = value.replace("px", "");
+          if (parseFloat(num) + "" === num) {
+            $root.attr(attr, num);
+          }
+        }
+        return;
+    }
+    if (svg_data_attributes.tagSpecificNonPresentationalAttributes[tagName]?.has(attr)) {
+      return;
+    }
+    if (svg_data_attributes.tagSpecificPresentationalAttributes[tagName]?.has(attr) && svg_data_attributes.tagSpecificPresentationalAttributes.g.has(attr)) {
+      moveToChildren[attr] = value;
+      $root.removeAttr(attr);
+      return;
+    }
+    if (svg_data_attributes.stylingAttributes.has(attr)) {
+      switch (attr) {
+        case "style":
+          return;
+        case "class":
+          $root.removeAttr(attr);
+          return;
+      }
+      throw new Error(`Unexpected attribute "${attr}" on <${tagName}>`);
+    }
+    if (attr.slice(0, 2) === "on" || attr.slice(0, 5) === "aria-" || 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) {
+    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 tagName2 = child.tagName;
+      if (tagName2 === "style" || svg_data_tags.reusableElementsWithPalette.has(tagName2) || svg_data_tags.maskTags.has(tagName2)) {
+        return;
+      }
+      $child.appendTo($wrapper);
+    });
+    $wrapper.appendTo($root);
+  }
+}
+
+exports.cleanupSVGRoot = cleanupSVGRoot;

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

@@ -1,5 +1,10 @@
-import type { SVG } from '../../svg';
+import { SVG } from '../index.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
 /**
  * Clean up SVG
  */
-export declare function cleanupSVGRoot(svg: SVG): Promise<void>;
+declare function cleanupSVGRoot(svg: SVG): Promise<void>;
+
+export { cleanupSVGRoot };

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

@@ -1,15 +1,6 @@
-// src/svg/cleanup/root-svg.ts
-import {
-  badAttributes,
-  badAttributePrefixes,
-  badSoftwareAttributes,
-  commonAttributes,
-  junkSVGAttributes,
-  stylingAttributes,
-  tagSpecificNonPresentationalAttributes,
-  tagSpecificPresentationalAttributes
-} from "../data/attributes.mjs";
-import { maskTags, reusableElementsWithPalette } from "../data/tags.mjs";
+import { commonAttributes, badAttributes, junkSVGAttributes, badSoftwareAttributes, badAttributePrefixes, tagSpecificNonPresentationalAttributes, tagSpecificPresentationalAttributes, stylingAttributes } from '../data/attributes.mjs';
+import { reusableElementsWithPalette, maskTags } from '../data/tags.mjs';
+
 async function cleanupSVGRoot(svg) {
   const cheerio = svg.$svg;
   const $root = svg.$svg(":root");
@@ -21,7 +12,6 @@ async function cleanupSVGRoot(svg) {
   const attribs = root.attribs;
   const moveToChildren = {};
   Object.keys(attribs).forEach((attr) => {
-    var _a, _b;
     const value = attribs[attr];
     if (commonAttributes.has(attr) || badAttributes.has(attr) || junkSVGAttributes.has(attr) || badSoftwareAttributes.has(attr) || badAttributePrefixes.has(attr.split("-").shift()) || attr.split(":").length > 1) {
       $root.removeAttr(attr);
@@ -38,10 +28,10 @@ async function cleanupSVGRoot(svg) {
         }
         return;
     }
-    if ((_a = tagSpecificNonPresentationalAttributes[tagName]) == null ? void 0 : _a.has(attr)) {
+    if (tagSpecificNonPresentationalAttributes[tagName]?.has(attr)) {
       return;
     }
-    if (((_b = tagSpecificPresentationalAttributes[tagName]) == null ? void 0 : _b.has(attr)) && tagSpecificPresentationalAttributes.g.has(attr)) {
+    if (tagSpecificPresentationalAttributes[tagName]?.has(attr) && tagSpecificPresentationalAttributes.g.has(attr)) {
       moveToChildren[attr] = value;
       $root.removeAttr(attr);
       return;
@@ -83,6 +73,5 @@ async function cleanupSVGRoot(svg) {
     $wrapper.appendTo($root);
   }
 }
-export {
-  cleanupSVGRoot
-};
+
+export { cleanupSVGRoot };

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

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const svg_data_attributes = require('../data/attributes.cjs');
+const svg_parseStyle = require('../parse-style.cjs');
+const optimise_svgo = require('../../optimise/svgo.cjs');
+require('../data/tags.cjs');
+require('../../css/parse.cjs');
+require('../../css/parser/tokens.cjs');
+require('../../css/parser/error.cjs');
+require('../../css/parser/strings.cjs');
+require('../../css/parser/text.cjs');
+require('../../css/parser/export.cjs');
+require('../../css/parser/tree.cjs');
+require('../parse.cjs');
+require('svgo');
+
+async function convertStyleToAttrs(svg) {
+  let hasStyle = false;
+  await svg_parseStyle.parseSVGStyle(svg, (item) => {
+    const prop = item.prop;
+    if (svg_data_attributes.badAttributes.has(prop) || svg_data_attributes.badSoftwareAttributes.has(prop) || svg_data_attributes.badAttributePrefixes.has(prop.split("-").shift())) {
+      return void 0;
+    }
+    hasStyle = true;
+    return item.value;
+  });
+  if (!hasStyle) {
+    return;
+  }
+  await optimise_svgo.runSVGO(svg, {
+    plugins: ["convertStyleToAttrs", "inlineStyles"],
+    multipass: true
+  });
+}
+
+exports.convertStyleToAttrs = convertStyleToAttrs;

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

@@ -1,5 +1,10 @@
-import type { SVG } from '../../svg';
+import { SVG } from '../index.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
 /**
  * Expand inline style
  */
-export declare function convertStyleToAttrs(svg: SVG): Promise<void>;
+declare function convertStyleToAttrs(svg: SVG): Promise<void>;
+
+export { convertStyleToAttrs };

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

@@ -1,11 +1,17 @@
-// src/svg/cleanup/svgo-style.ts
-import {
-  badAttributes,
-  badAttributePrefixes,
-  badSoftwareAttributes
-} from "../data/attributes.mjs";
-import { parseSVGStyle } from "../parse-style.mjs";
-import { runSVGO } from "../../optimise/svgo.mjs";
+import { badAttributes, badSoftwareAttributes, badAttributePrefixes } from '../data/attributes.mjs';
+import { parseSVGStyle } from '../parse-style.mjs';
+import { runSVGO } from '../../optimise/svgo.mjs';
+import '../data/tags.mjs';
+import '../../css/parse.mjs';
+import '../../css/parser/tokens.mjs';
+import '../../css/parser/error.mjs';
+import '../../css/parser/strings.mjs';
+import '../../css/parser/text.mjs';
+import '../../css/parser/export.mjs';
+import '../../css/parser/tree.mjs';
+import '../parse.mjs';
+import 'svgo';
+
 async function convertStyleToAttrs(svg) {
   let hasStyle = false;
   await parseSVGStyle(svg, (item) => {
@@ -24,6 +30,5 @@ async function convertStyleToAttrs(svg) {
     multipass: true
   });
 }
-export {
-  convertStyleToAttrs
-};
+
+export { convertStyleToAttrs };

package/lib/svg/cleanup.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const svg_cleanup_attribs = require('./cleanup/attribs.cjs');
+const svg_cleanup_badTags = require('./cleanup/bad-tags.cjs');
+const svg_cleanup_inlineStyle = require('./cleanup/inline-style.cjs');
+const svg_cleanup_rootSvg = require('./cleanup/root-svg.cjs');
+const svg_cleanup_svgoStyle = require('./cleanup/svgo-style.cjs');
+require('./data/attributes.cjs');
+require('./data/tags.cjs');
+require('./parse.cjs');
+require('../css/parse.cjs');
+require('../css/parser/tokens.cjs');
+require('../css/parser/error.cjs');
+require('../css/parser/strings.cjs');
+require('../css/parser/text.cjs');
+require('./parse-style.cjs');
+require('../css/parser/export.cjs');
+require('../css/parser/tree.cjs');
+require('../optimise/svgo.cjs');
+require('svgo');
+
+async function cleanupSVG(svg) {
+  await svg_cleanup_inlineStyle.cleanupInlineStyle(svg);
+  await svg_cleanup_svgoStyle.convertStyleToAttrs(svg);
+  await svg_cleanup_rootSvg.cleanupSVGRoot(svg);
+  await svg_cleanup_badTags.checkBadTags(svg);
+  await svg_cleanup_attribs.removeBadAttributes(svg);
+}
+
+exports.cleanupSVG = cleanupSVG;

package/lib/svg/cleanup.d.ts

@@ -1,5 +1,10 @@
-import type { SVG } from '.';
+import { SVG } from './index.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
 /**
  * Clean up SVG before parsing/optimising it
  */
-export declare function cleanupSVG(svg: SVG): Promise<void>;
+declare function cleanupSVG(svg: SVG): Promise<void>;
+
+export { cleanupSVG };

package/lib/svg/cleanup.mjs

@@ -1,9 +1,22 @@
-// src/svg/cleanup.ts
-import { removeBadAttributes } from "./cleanup/attribs.mjs";
-import { checkBadTags } from "./cleanup/bad-tags.mjs";
-import { cleanupInlineStyle } from "./cleanup/inline-style.mjs";
-import { cleanupSVGRoot } from "./cleanup/root-svg.mjs";
-import { convertStyleToAttrs } from "./cleanup/svgo-style.mjs";
+import { removeBadAttributes } from './cleanup/attribs.mjs';
+import { checkBadTags } from './cleanup/bad-tags.mjs';
+import { cleanupInlineStyle } from './cleanup/inline-style.mjs';
+import { cleanupSVGRoot } from './cleanup/root-svg.mjs';
+import { convertStyleToAttrs } from './cleanup/svgo-style.mjs';
+import './data/attributes.mjs';
+import './data/tags.mjs';
+import './parse.mjs';
+import '../css/parse.mjs';
+import '../css/parser/tokens.mjs';
+import '../css/parser/error.mjs';
+import '../css/parser/strings.mjs';
+import '../css/parser/text.mjs';
+import './parse-style.mjs';
+import '../css/parser/export.mjs';
+import '../css/parser/tree.mjs';
+import '../optimise/svgo.mjs';
+import 'svgo';
+
 async function cleanupSVG(svg) {
   await cleanupInlineStyle(svg);
   await convertStyleToAttrs(svg);
@@ -11,6 +24,5 @@ async function cleanupSVG(svg) {
   await checkBadTags(svg);
   await removeBadAttributes(svg);
 }
-export {
-  cleanupSVG
-};
+
+export { cleanupSVG };