@iconify/tools 2.2.6 → 3.0.0-beta.1

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

@@ -13,8 +13,8 @@ requiredParentTags.set(svg_data_tags.feLightningTags, svg_data_tags.feLightningC
 requiredParentTags.set(svg_data_tags.filterTag, svg_data_tags.filterChildTags);
 requiredParentTags.set(svg_data_tags.gradientTags, svg_data_tags.gradientChildTags);
 requiredParentTags.set(/* @__PURE__ */ new Set(["animateMotion"]), svg_data_tags.animateMotionChildTags);
-async function checkBadTags(svg) {
-  await svg_parse.parseSVG(svg, (item) => {
+function checkBadTags(svg) {
+  svg_parse.parseSVGSync(svg, (item) => {
     const tagName = item.tagName;
     const $element = item.$element;
     if (tagName === "svg") {

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

@@ -5,6 +5,6 @@ import '@iconify/utils/lib/customisations/defaults';
 /**
  * Test for bag tags
  */
-declare function checkBadTags(svg: SVG): Promise<void>;
+declare function checkBadTags(svg: SVG): void;
 
 export { checkBadTags };

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

@@ -1,4 +1,4 @@
-import { parseSVG } from '../parse.mjs';
+import { parseSVGSync } from '../parse.mjs';
 import { feComponentTransferChildTag, feMergeChildTags, feLightningTags, feLightningChildTags, filterTag, filterChildTags, gradientTags, gradientChildTags, animateMotionChildTags, unsupportedTags, badTags, allValidTags } from '../data/tags.mjs';
 
 const requiredParentTags = /* @__PURE__ */ new Map();
@@ -11,8 +11,8 @@ requiredParentTags.set(feLightningTags, feLightningChildTags);
 requiredParentTags.set(filterTag, filterChildTags);
 requiredParentTags.set(gradientTags, gradientChildTags);
 requiredParentTags.set(/* @__PURE__ */ new Set(["animateMotion"]), animateMotionChildTags);
-async function checkBadTags(svg) {
-  await parseSVG(svg, (item) => {
+function checkBadTags(svg) {
+  parseSVGSync(svg, (item) => {
     const tagName = item.tagName;
     const $element = item.$element;
     if (tagName === "svg") {

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

@@ -9,8 +9,8 @@ require('../../css/parser/strings.cjs');
 require('../../css/parser/text.cjs');
 require('../data/tags.cjs');
 
-async function cleanupInlineStyle(svg) {
-  await svg_parse.parseSVG(svg, (item) => {
+function cleanupInlineStyle(svg) {
+  svg_parse.parseSVGSync(svg, (item) => {
     const $element = item.$element;
     const attribs = item.element.attribs;
     const tagName = item.tagName;

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

@@ -5,6 +5,6 @@ import '@iconify/utils/lib/customisations/defaults';
 /**
  * Expand inline style
  */
-declare function cleanupInlineStyle(svg: SVG): Promise<void>;
+declare function cleanupInlineStyle(svg: SVG): void;
 
 export { cleanupInlineStyle };

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

@@ -1,14 +1,14 @@
 import { parseInlineStyle } from '../../css/parse.mjs';
 import { badAttributes, tagSpecificNonPresentationalAttributes, tagSpecificAnimatedAttributes, tagSpecificPresentationalAttributes, tagSpecificInlineStyles, insideClipPathAttributes, badSoftwareAttributes, badAttributePrefixes } from '../data/attributes.mjs';
-import { parseSVG } from '../parse.mjs';
+import { parseSVGSync } 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) => {
+function cleanupInlineStyle(svg) {
+  parseSVGSync(svg, (item) => {
     const $element = item.$element;
     const attribs = item.element.attribs;
     const tagName = item.tagName;

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

@@ -11,7 +11,7 @@ require('../../css/parser/tree.cjs');
 require('../parse.cjs');
 
 function cleanupRootStyle(svg) {
-  return svg_parseStyle.parseSVGStyle(svg, (item) => {
+  svg_parseStyle.parseSVGStyleSync(svg, (item) => {
     if (
       // If global style
       item.type === "global" && // If selector tokens contain at-rule

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

@@ -1,16 +1,12 @@
 import { SVG } from '../index.js';
-import { parseSVGStyle } from '../parse-style.js';
 import '@iconify/types';
 import '@iconify/utils/lib/customisations/defaults';
-import '../../css/parser/types.js';
-import '../parse.js';
-import '../../misc/cheerio.js';
 
 /**
  * Clean up root style
  *
  * This function removes all at-rule tokens, such as `@font-face`, `@media`
  */
-declare function cleanupRootStyle(svg: SVG): ReturnType<typeof parseSVGStyle>;
+declare function cleanupRootStyle(svg: SVG): void;
 
 export { cleanupRootStyle };

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

@@ -1,4 +1,4 @@
-import { parseSVGStyle } from '../parse-style.mjs';
+import { parseSVGStyleSync } from '../parse-style.mjs';
 import '../../css/parse.mjs';
 import '../../css/parser/tokens.mjs';
 import '../../css/parser/error.mjs';
@@ -9,7 +9,7 @@ import '../../css/parser/tree.mjs';
 import '../parse.mjs';
 
 function cleanupRootStyle(svg) {
-  return parseSVGStyle(svg, (item) => {
+  parseSVGStyleSync(svg, (item) => {
     if (
       // If global style
       item.type === "global" && // If selector tokens contain at-rule

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

@@ -15,9 +15,9 @@ require('../parse.cjs');
 require('svgo');
 require('@iconify/utils/lib/svg/id');
 
-async function convertStyleToAttrs(svg) {
+function convertStyleToAttrs(svg) {
   let hasStyle = false;
-  await svg_parseStyle.parseSVGStyle(svg, (item) => {
+  svg_parseStyle.parseSVGStyleSync(svg, (item) => {
     const prop = item.prop;
     if (
       // Attributes / properties now allowed

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

@@ -5,6 +5,6 @@ import '@iconify/utils/lib/customisations/defaults';
 /**
  * Expand inline style
  */
-declare function convertStyleToAttrs(svg: SVG): Promise<void>;
+declare function convertStyleToAttrs(svg: SVG): void;
 
 export { convertStyleToAttrs };

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

@@ -1,5 +1,5 @@
 import { badAttributes, badSoftwareAttributes, badAttributePrefixes } from '../data/attributes.mjs';
-import { parseSVGStyle } from '../parse-style.mjs';
+import { parseSVGStyleSync } from '../parse-style.mjs';
 import { runSVGO } from '../../optimise/svgo.mjs';
 import '../data/tags.mjs';
 import '../../css/parse.mjs';
@@ -13,9 +13,9 @@ import '../parse.mjs';
 import 'svgo';
 import '@iconify/utils/lib/svg/id';
 
-async function convertStyleToAttrs(svg) {
+function convertStyleToAttrs(svg) {
   let hasStyle = false;
-  await parseSVGStyle(svg, (item) => {
+  parseSVGStyleSync(svg, (item) => {
     const prop = item.prop;
     if (
       // Attributes / properties now allowed

package/lib/svg/cleanup.cjs

@@ -21,13 +21,13 @@ require('../optimise/svgo.cjs');
 require('svgo');
 require('@iconify/utils/lib/svg/id');
 
-async function cleanupSVG(svg) {
-  await svg_cleanup_inlineStyle.cleanupInlineStyle(svg);
-  await svg_cleanup_svgoStyle.convertStyleToAttrs(svg);
+function cleanupSVG(svg) {
+  svg_cleanup_inlineStyle.cleanupInlineStyle(svg);
+  svg_cleanup_svgoStyle.convertStyleToAttrs(svg);
   svg_cleanup_rootSvg.cleanupSVGRoot(svg);
-  await svg_cleanup_badTags.checkBadTags(svg);
-  await svg_cleanup_attribs.removeBadAttributes(svg);
-  await svg_cleanup_rootStyle.cleanupRootStyle(svg);
+  svg_cleanup_badTags.checkBadTags(svg);
+  svg_cleanup_attribs.removeBadAttributes(svg);
+  svg_cleanup_rootStyle.cleanupRootStyle(svg);
 }
 
 exports.cleanupSVG = cleanupSVG;

package/lib/svg/cleanup.d.ts

@@ -5,6 +5,6 @@ import '@iconify/utils/lib/customisations/defaults';
 /**
  * Clean up SVG before parsing/optimising it
  */
-declare function cleanupSVG(svg: SVG): Promise<void>;
+declare function cleanupSVG(svg: SVG): void;
 
 export { cleanupSVG };

package/lib/svg/cleanup.mjs

@@ -19,13 +19,13 @@ import '../optimise/svgo.mjs';
 import 'svgo';
 import '@iconify/utils/lib/svg/id';
 
-async function cleanupSVG(svg) {
-  await cleanupInlineStyle(svg);
-  await convertStyleToAttrs(svg);
+function cleanupSVG(svg) {
+  cleanupInlineStyle(svg);
+  convertStyleToAttrs(svg);
   cleanupSVGRoot(svg);
-  await checkBadTags(svg);
-  await removeBadAttributes(svg);
-  await cleanupRootStyle(svg);
+  checkBadTags(svg);
+  removeBadAttributes(svg);
+  cleanupRootStyle(svg);
 }
 
 export { cleanupSVG };

package/lib/svg/index.cjs

@@ -3,6 +3,10 @@
 const cheerio = require('cheerio');
 const utils = require('@iconify/utils');
 
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const cheerio__default = /*#__PURE__*/_interopDefaultCompat(cheerio);
+
 class SVG {
   /**
    * Constructor
@@ -104,7 +108,7 @@ class SVG {
     );
     remove('xml:space="preserve"', "", "");
     content = content.replace(/<g>\s*<\/g>/g, "");
-    this.$svg = cheerio.load(content.trim(), {
+    this.$svg = cheerio__default.load(content.trim(), {
       lowerCaseAttributeNames: false,
       xmlMode: true
     });

package/lib/svg/parse-style.cjs

@@ -9,41 +9,58 @@ 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.text();
-      if (typeof content !== "string") {
-        $element.remove();
-        return;
+function parseItem(item, callback, done) {
+  const tagName = item.tagName;
+  const $element = item.$element;
+  function parseStyleItem(done2) {
+    const content = $element.text();
+    if (typeof content !== "string") {
+      $element.remove();
+      return done2();
+    }
+    const tokens = css_parser_tokens.getTokens(content);
+    if (!(tokens instanceof Array)) {
+      throw new Error("Error parsing style");
+    }
+    let changed2 = false;
+    const selectorStart = [];
+    const newTokens = [];
+    const parsedTokens = () => {
+      if (changed2) {
+        const tree = css_parser_tree.tokensTree(
+          newTokens.filter((token) => token !== null)
+        );
+        if (!tree.length) {
+          $element.remove();
+        } else {
+          const newContent = css_parser_export.tokensToString(tree);
+          item.$element.text(newContent);
+        }
       }
-      const tokens = css_parser_tokens.getTokens(content);
-      if (!(tokens instanceof Array)) {
-        throw new Error("Error parsing style");
+      done2();
+    };
+    const nextToken = () => {
+      const token = tokens.shift();
+      if (token === void 0) {
+        return parsedTokens();
       }
-      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({
+      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);
+        return nextToken();
+      }
+      const value = token.value;
+      const selectorTokens = selectorStart.map((index) => newTokens[index]).filter((item2) => item2 !== null);
+      callback(
+        {
           type: "global",
           prop: token.prop,
           value,
@@ -61,77 +78,120 @@ async function parseSVGStyle(svg, callback) {
             []
           ),
           prevTokens: newTokens,
-          nextTokens: tokens.slice(i + 1)
-        });
-        if (result instanceof Promise) {
-          result = await result;
-        }
-        if (result !== void 0) {
-          if (result !== value) {
+          nextTokens: tokens.slice(0)
+        },
+        (result) => {
+          if (result !== void 0) {
+            if (result !== value) {
+              changed2 = true;
+              token.value = result;
+            }
+            newTokens.push(token);
+          } else {
             changed2 = true;
-            token.value = result;
           }
-          newTokens.push(token);
-        } else {
-          changed2 = true;
+          nextToken();
         }
-      }
-      if (!changed2) {
-        return;
-      }
-      const tree = css_parser_tree.tokensTree(
-        newTokens.filter((token) => token !== null)
       );
-      if (!tree.length) {
-        $element.remove();
-        return;
+    };
+    nextToken();
+  }
+  if (tagName === "style") {
+    return parseStyleItem(done);
+  }
+  const attribs = item.element.attribs;
+  if (attribs.style === void 0) {
+    return done();
+  }
+  const parsedStyle = css_parse.parseInlineStyle(attribs.style);
+  if (parsedStyle === null) {
+    $element.removeAttr("style");
+    return done();
+  }
+  const propsQueue = Object.keys(parsedStyle);
+  let changed = false;
+  const parsedProps = () => {
+    if (changed) {
+      const newStyle = Object.keys(parsedStyle).map((key) => key + ":" + parsedStyle[key] + ";").join("");
+      if (!newStyle.length) {
+        $element.removeAttr("style");
+      } else {
+        $element.attr("style", newStyle);
       }
-      const newContent = css_parser_export.tokensToString(tree);
-      item.$element.text(newContent);
-      return;
     }
-    const attribs = item.element.attribs;
-    if (attribs.style === void 0) {
-      return;
+    done();
+  };
+  const nextProp = () => {
+    const prop = propsQueue.shift();
+    if (prop === void 0) {
+      return parsedProps();
     }
-    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({
+    const value = parsedStyle[prop];
+    callback(
+      {
         type: "inline",
         prop,
         value,
         item
-      });
-      if (result instanceof Promise) {
-        result = await result;
+      },
+      (result) => {
+        if (result !== value) {
+          changed = true;
+          if (result === void 0) {
+            delete parsedStyle[prop];
+          } else {
+            parsedStyle[prop] = result;
+          }
+        }
+        nextProp();
       }
-      if (result !== value) {
-        changed = true;
-        if (result === void 0) {
-          delete parsedStyle[prop];
-        } else {
-          parsedStyle[prop] = result;
+    );
+  };
+  nextProp();
+}
+async function parseSVGStyle(svg, callback) {
+  return svg_parse.parseSVG(svg, (item) => {
+    return new Promise((fulfill, reject) => {
+      try {
+        parseItem(
+          item,
+          (styleItem, done) => {
+            try {
+              const result = callback(styleItem);
+              if (result instanceof Promise) {
+                result.then(done).catch(reject);
+              } else {
+                done(result);
+              }
+            } catch (err) {
+              reject(err);
+            }
+          },
+          fulfill
+        );
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+}
+function parseSVGStyleSync(svg, callback) {
+  let isSync = true;
+  svg_parse.parseSVGSync(svg, (item) => {
+    parseItem(
+      item,
+      (styleItem, done) => {
+        done(callback(styleItem));
+      },
+      () => {
+        if (!isSync) {
+          throw new Error("parseSVGStyleSync callback was async");
         }
       }
-    }
-    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);
-    }
+    );
   });
+  isSync = false;
 }
 
 exports.parseSVGStyle = parseSVGStyle;
+exports.parseSVGStyleSync = parseSVGStyleSync;

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

@@ -33,6 +33,7 @@ type ParseSVGStyleCallbackResult = string | undefined;
  * Callback function
  */
 type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult | Promise<ParseSVGStyleCallbackResult>;
+type ParseSVGStyleCallbackSync = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult;
 /**
  * Parse styles in SVG
  *
@@ -41,5 +42,9 @@ type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleC
  * Callback can be asynchronous.
  */
 declare function parseSVGStyle(svg: SVG, callback: ParseSVGStyleCallback): Promise<void>;
+/**
+ * Synchronous version
+ */
+declare function parseSVGStyleSync(svg: SVG, callback: ParseSVGStyleCallbackSync): void;
 
-export { ParseSVGStyleCallback, ParseSVGStyleCallbackItem, ParseSVGStyleCallbackResult, parseSVGStyle };
+export { ParseSVGStyleCallback, ParseSVGStyleCallbackItem, ParseSVGStyleCallbackResult, ParseSVGStyleCallbackSync, parseSVGStyle, parseSVGStyleSync };