@iconify/tools 2.0.14 → 2.0.15

package/lib/colors/attribs.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const commonColorAttributes = ["color"];
+const shapeColorAttributes = ["fill", "stroke"];
+const specialColorAttributes = [
+  "stop-color",
+  "flood-color"
+];
+const defaultBlackColor = {
+  type: "rgb",
+  r: 0,
+  g: 0,
+  b: 0,
+  alpha: 1
+};
+const defaultColorValues = {
+  "color": { type: "current" },
+  "fill": defaultBlackColor,
+  "stroke": { type: "none" },
+  "stop-color": defaultBlackColor,
+  "flood-color": defaultBlackColor
+};
+
+exports.commonColorAttributes = commonColorAttributes;
+exports.defaultBlackColor = defaultBlackColor;
+exports.defaultColorValues = defaultColorValues;
+exports.shapeColorAttributes = shapeColorAttributes;
+exports.specialColorAttributes = specialColorAttributes;

package/lib/colors/attribs.d.ts

@@ -1,16 +1,19 @@
-import type { Color } from '@iconify/utils/lib/colors/types';
+import { Color } from '@iconify/utils/lib/colors/types';
+
 /**
  * Color attributes
  */
-export declare type CommonColorAttributes = 'color';
-export declare const commonColorAttributes: CommonColorAttributes[];
-export declare type ShapeColorAttributes = 'fill' | 'stroke';
-export declare const shapeColorAttributes: ShapeColorAttributes[];
-export declare type SpecialColorAttributes = 'stop-color' | 'flood-color';
-export declare const specialColorAttributes: SpecialColorAttributes[];
-export declare type ColorAttributes = CommonColorAttributes | ShapeColorAttributes | SpecialColorAttributes;
+declare type CommonColorAttributes = 'color';
+declare const commonColorAttributes: CommonColorAttributes[];
+declare type ShapeColorAttributes = 'fill' | 'stroke';
+declare const shapeColorAttributes: ShapeColorAttributes[];
+declare type SpecialColorAttributes = 'stop-color' | 'flood-color';
+declare const specialColorAttributes: SpecialColorAttributes[];
+declare type ColorAttributes = CommonColorAttributes | ShapeColorAttributes | SpecialColorAttributes;
 /**
  * Default values
  */
-export declare const defaultBlackColor: Color;
-export declare const defaultColorValues: Record<ColorAttributes, Color>;
+declare const defaultBlackColor: Color;
+declare const defaultColorValues: Record<ColorAttributes, Color>;
+
+export { ColorAttributes, CommonColorAttributes, ShapeColorAttributes, SpecialColorAttributes, commonColorAttributes, defaultBlackColor, defaultColorValues, shapeColorAttributes, specialColorAttributes };

package/lib/colors/attribs.mjs

@@ -1,28 +1,22 @@
-// src/colors/attribs.ts
-var commonColorAttributes = ["color"];
-var shapeColorAttributes = ["fill", "stroke"];
-var specialColorAttributes = [
+const commonColorAttributes = ["color"];
+const shapeColorAttributes = ["fill", "stroke"];
+const specialColorAttributes = [
   "stop-color",
   "flood-color"
 ];
-var defaultBlackColor = {
+const defaultBlackColor = {
   type: "rgb",
   r: 0,
   g: 0,
   b: 0,
   alpha: 1
 };
-var defaultColorValues = {
+const defaultColorValues = {
   "color": { type: "current" },
   "fill": defaultBlackColor,
   "stroke": { type: "none" },
   "stop-color": defaultBlackColor,
   "flood-color": defaultBlackColor
 };
-export {
-  commonColorAttributes,
-  defaultBlackColor,
-  defaultColorValues,
-  shapeColorAttributes,
-  specialColorAttributes
-};
+
+export { commonColorAttributes, defaultBlackColor, defaultColorValues, shapeColorAttributes, specialColorAttributes };

package/lib/colors/parse.cjs

@@ -0,0 +1,269 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const colors = require('@iconify/utils/lib/colors');
+const svg_data_tags = require('../svg/data/tags.cjs');
+const svg_parseStyle = require('../svg/parse-style.cjs');
+const colors_attribs = require('./attribs.cjs');
+const svg_data_attributes = require('../svg/data/attributes.cjs');
+const svg_analyse = require('../svg/analyse.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('../svg/parse.cjs');
+require('../svg/analyse/error.cjs');
+
+const propsToCheck = Object.keys(colors_attribs.defaultColorValues);
+const animatePropsToCheck = ["from", "to", "values"];
+async function parseColors(svg, options = {}) {
+  const result = {
+    colors: [],
+    hasUnsetColor: false,
+    hasGlobalStyle: false
+  };
+  const defaultColor = typeof options.defaultColor === "string" ? colors.stringToColor(options.defaultColor) : options.defaultColor;
+  function findColor(color, add = false) {
+    const isString = typeof color === "string";
+    for (let i = 0; i < result.colors.length; i++) {
+      const item = result.colors[i];
+      if (item === color) {
+        return item;
+      }
+      if (!isString && typeof item !== "string" && colors.compareColors(item, color)) {
+        return item;
+      }
+    }
+    if (add) {
+      result.colors.push(color);
+      return color;
+    }
+    return null;
+  }
+  function addColorToItem(prop, color, item, add = true) {
+    const addedColor = findColor(color, add !== false);
+    if (item) {
+      const itemColors = item._colors || (item._colors = {});
+      itemColors[prop] = addedColor === null ? color : addedColor;
+    }
+  }
+  function getElementColor(prop, item, elements2) {
+    function find(prop2) {
+      let currentItem = item;
+      while (currentItem) {
+        const element = elements2.get(currentItem.index);
+        const color = element._colors?.[prop2];
+        if (color !== void 0) {
+          return color;
+        }
+        currentItem = currentItem.parent;
+        if (currentItem?.usedAsMask) {
+          return colors_attribs.defaultColorValues[prop2];
+        }
+      }
+      return colors_attribs.defaultColorValues[prop2];
+    }
+    let propColor = find(prop);
+    if (typeof propColor === "object" && propColor.type === "current" && prop !== "color") {
+      propColor = find("color");
+    }
+    return propColor;
+  }
+  async function checkColor(prop, value, item) {
+    switch (value.trim().toLowerCase()) {
+      case "":
+      case "inherit":
+        return;
+    }
+    const parsedColor = colors.stringToColor(value);
+    const defaultValue = parsedColor || value;
+    if (parsedColor?.type === "function" && parsedColor.func === "url") {
+      addColorToItem(prop, defaultValue, item, false);
+      return value;
+    }
+    if (!options.callback) {
+      addColorToItem(prop, defaultValue, item);
+      return value;
+    }
+    let callbackResult = options.callback(prop, value, parsedColor, item?.tagName, item);
+    callbackResult = callbackResult instanceof Promise ? await callbackResult : callbackResult;
+    switch (callbackResult) {
+      case "remove": {
+        return item ? callbackResult : void 0;
+      }
+      case "unset":
+        return;
+    }
+    if (callbackResult === value || parsedColor && callbackResult === parsedColor) {
+      addColorToItem(prop, defaultValue, item);
+      return value;
+    }
+    if (typeof callbackResult === "string") {
+      const newColor = colors.stringToColor(callbackResult);
+      addColorToItem(prop, newColor || callbackResult, item);
+      return callbackResult;
+    }
+    const newValue = colors.colorToString(callbackResult);
+    addColorToItem(prop, callbackResult, item);
+    return newValue;
+  }
+  await svg_parseStyle.parseSVGStyle(svg, async (item) => {
+    const prop = item.prop;
+    const value = item.value;
+    if (propsToCheck.indexOf(prop) === -1) {
+      return value;
+    }
+    const attr = prop;
+    const newValue = await checkColor(attr, value);
+    if (newValue === void 0) {
+      return newValue;
+    }
+    if (item.type === "global") {
+      result.hasGlobalStyle = true;
+    }
+    return newValue;
+  });
+  const iconData = await svg_analyse.analyseSVGStructure(svg, options);
+  const { elements, tree } = iconData;
+  const cheerio = svg.$svg;
+  const removedElements = /* @__PURE__ */ new Set();
+  const parsedElements = /* @__PURE__ */ new Set();
+  function removeElement(index, element) {
+    function removeChildren(element2) {
+      element2.children.forEach((item) => {
+        if (item.type !== "tag") {
+          return;
+        }
+        const element3 = item;
+        const index2 = element3._index;
+        if (index2 && !removedElements.has(index2)) {
+          element3._removed = true;
+          removedElements.add(index2);
+          removeChildren(element3);
+        }
+      });
+    }
+    element._removed = true;
+    removedElements.add(index);
+    removeChildren(element);
+    cheerio(element).remove();
+  }
+  async function parseTreeItem(item) {
+    const index = item.index;
+    if (removedElements.has(index) || parsedElements.has(index)) {
+      return;
+    }
+    parsedElements.add(index);
+    const element = elements.get(index);
+    if (element._removed) {
+      return;
+    }
+    const { tagName, attribs } = element;
+    if (item.parent) {
+      const parentIndex = item.parent.index;
+      const parentElement = elements.get(parentIndex);
+      if (parentElement._colors) {
+        element._colors = {
+          ...parentElement._colors
+        };
+      }
+    }
+    for (let i = 0; i < propsToCheck.length; i++) {
+      const prop = propsToCheck[i];
+      if (prop === "fill" && svg_data_tags.animateTags.has(tagName)) {
+        continue;
+      }
+      const value = attribs[prop];
+      if (value !== void 0) {
+        const newValue = await checkColor(prop, value, element);
+        if (newValue !== value) {
+          if (newValue === void 0) {
+            cheerio(element).removeAttr(prop);
+            if (element._colors) {
+              delete element._colors[prop];
+            }
+          } else if (newValue === "remove") {
+            removeElement(index, element);
+            return;
+          } else {
+            cheerio(element).attr(prop, newValue);
+          }
+        }
+      }
+    }
+    if (svg_data_tags.animateTags.has(tagName)) {
+      const attr = attribs.attributeName;
+      if (propsToCheck.indexOf(attr) !== -1) {
+        for (let i = 0; i < animatePropsToCheck.length; i++) {
+          const elementProp = animatePropsToCheck[i];
+          const fullValue = attribs[elementProp];
+          if (typeof fullValue !== "string") {
+            continue;
+          }
+          const splitValues = fullValue.split(";");
+          let updatedValues = false;
+          for (let j = 0; j < splitValues.length; j++) {
+            const value = splitValues[j];
+            if (value !== void 0) {
+              const newValue = await checkColor(elementProp, value);
+              if (newValue !== value) {
+                updatedValues = true;
+                splitValues[j] = typeof newValue === "string" ? newValue : "";
+              }
+            }
+          }
+          if (updatedValues) {
+            cheerio(element).attr(elementProp, splitValues.join(";"));
+          }
+        }
+      }
+    }
+    if (!result.hasGlobalStyle) {
+      let requiredProps;
+      if (svg_data_tags.shapeTags.has(tagName)) {
+        requiredProps = colors_attribs.shapeColorAttributes;
+      }
+      colors_attribs.specialColorAttributes.forEach((attr) => {
+        if (svg_data_attributes.tagSpecificPresentationalAttributes[tagName]?.has(attr)) {
+          requiredProps = [attr];
+        }
+      });
+      if (requiredProps) {
+        const itemColors = element._colors || (element._colors = {});
+        for (let i = 0; i < requiredProps.length; i++) {
+          const prop = requiredProps[i];
+          const color = getElementColor(prop, item, elements);
+          if (color === colors_attribs.defaultBlackColor) {
+            if (defaultColor) {
+              const defaultColorValue = typeof defaultColor === "function" ? defaultColor(prop, element, item, iconData) : defaultColor;
+              findColor(defaultColorValue, true);
+              cheerio(element).attr(prop, colors.colorToString(defaultColorValue));
+              itemColors[prop] = defaultColorValue;
+            } else {
+              result.hasUnsetColor = true;
+            }
+          }
+        }
+      }
+    }
+    for (let i = 0; i < item.children.length; i++) {
+      const childItem = item.children[i];
+      if (!childItem.usedAsMask) {
+        await parseTreeItem(childItem);
+      }
+    }
+  }
+  await parseTreeItem(tree);
+  return result;
+}
+function isEmptyColor(color) {
+  const type = color.type;
+  return type === "none" || type === "transparent";
+}
+
+exports.isEmptyColor = isEmptyColor;
+exports.parseColors = parseColors;

package/lib/colors/parse.d.ts

@@ -1,11 +1,14 @@
-import type { Color } from '@iconify/utils/lib/colors/types';
-import type { SVG } from '../svg';
-import { ColorAttributes } from './attribs';
-import type { AnalyseSVGStructureResult, ElementsTreeItem, ExtendedTagElement, AnalyseSVGStructureOptions } from '../svg/analyse/types';
+import { Color } from '@iconify/utils/lib/colors/types';
+import { SVG } from '../svg/index.js';
+import { ColorAttributes } from './attribs.js';
+import { ElementsTreeItem, AnalyseSVGStructureResult, AnalyseSVGStructureOptions, ExtendedTagElement } from '../svg/analyse/types.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
 /**
  * Result
  */
-export interface FindColorsResult {
+interface FindColorsResult {
     colors: (Color | string)[];
     hasUnsetColor: boolean;
     hasGlobalStyle: boolean;
@@ -24,11 +27,11 @@ declare type ParseColorsCallback = (attr: ColorAttributes, colorString: string,
 /**
  * Callback for default color
  */
-export declare type ParseColorOptionsDefaultColorCallback = (prop: string, item: ExtendedTagElementWithColors, treeItem: ElementsTreeItem, iconData: AnalyseSVGStructureResult) => Color;
+declare type ParseColorOptionsDefaultColorCallback = (prop: string, item: ExtendedTagElementWithColors, treeItem: ElementsTreeItem, iconData: AnalyseSVGStructureResult) => Color;
 /**
  * Options
  */
-export interface ParseColorsOptions extends AnalyseSVGStructureOptions {
+interface ParseColorsOptions extends AnalyseSVGStructureOptions {
     callback?: ParseColorsCallback;
     defaultColor?: Color | string | ParseColorOptionsDefaultColorCallback;
 }
@@ -36,7 +39,7 @@ export interface ParseColorsOptions extends AnalyseSVGStructureOptions {
  * Extend properties for element
  */
 declare type ItemColors = Partial<Record<ColorAttributes, Color | string>>;
-export interface ExtendedTagElementWithColors extends ExtendedTagElement {
+interface ExtendedTagElementWithColors extends ExtendedTagElement {
     _colors?: ItemColors;
     _removed?: boolean;
 }
@@ -46,9 +49,10 @@ export interface ExtendedTagElementWithColors extends ExtendedTagElement {
  * Clean up icon before running this function to convert style to attributes using
  * cleanupInlineStyle() or cleanupSVG(), otherwise results might be inaccurate
  */
-export declare function parseColors(svg: SVG, options?: ParseColorsOptions): Promise<FindColorsResult>;
+declare function parseColors(svg: SVG, options?: ParseColorsOptions): Promise<FindColorsResult>;
 /**
  * Check if color is empty, such as 'none' or 'transparent'
  */
-export declare function isEmptyColor(color: Color): boolean;
-export {};
+declare function isEmptyColor(color: Color): boolean;
+
+export { ExtendedTagElementWithColors, FindColorsResult, ParseColorOptionsDefaultColorCallback, ParseColorsOptions, isEmptyColor, parseColors };

package/lib/colors/parse.mjs

@@ -1,21 +1,21 @@
-// src/colors/parse.ts
-import {
-  compareColors,
-  stringToColor,
-  colorToString
-} from "@iconify/utils/lib/colors";
-import { animateTags, shapeTags } from "../svg/data/tags.mjs";
-import { parseSVGStyle } from "../svg/parse-style.mjs";
-import {
-  defaultBlackColor,
-  defaultColorValues,
-  shapeColorAttributes,
-  specialColorAttributes
-} from "./attribs.mjs";
-import { tagSpecificPresentationalAttributes } from "../svg/data/attributes.mjs";
-import { analyseSVGStructure } from "../svg/analyse.mjs";
-var propsToCheck = Object.keys(defaultColorValues);
-var animatePropsToCheck = ["from", "to", "values"];
+import { stringToColor, colorToString, compareColors } from '@iconify/utils/lib/colors';
+import { animateTags, shapeTags } from '../svg/data/tags.mjs';
+import { parseSVGStyle } from '../svg/parse-style.mjs';
+import { specialColorAttributes, defaultBlackColor, defaultColorValues, shapeColorAttributes } from './attribs.mjs';
+import { tagSpecificPresentationalAttributes } from '../svg/data/attributes.mjs';
+import { analyseSVGStructure } from '../svg/analyse.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 '../svg/parse.mjs';
+import '../svg/analyse/error.mjs';
+
+const propsToCheck = Object.keys(defaultColorValues);
+const animatePropsToCheck = ["from", "to", "values"];
 async function parseColors(svg, options = {}) {
   const result = {
     colors: [],
@@ -49,16 +49,15 @@ async function parseColors(svg, options = {}) {
   }
   function getElementColor(prop, item, elements2) {
     function find(prop2) {
-      var _a;
       let currentItem = item;
       while (currentItem) {
         const element = elements2.get(currentItem.index);
-        const color = (_a = element._colors) == null ? void 0 : _a[prop2];
+        const color = element._colors?.[prop2];
         if (color !== void 0) {
           return color;
         }
         currentItem = currentItem.parent;
-        if (currentItem == null ? void 0 : currentItem.usedAsMask) {
+        if (currentItem?.usedAsMask) {
           return defaultColorValues[prop2];
         }
       }
@@ -78,7 +77,7 @@ async function parseColors(svg, options = {}) {
     }
     const parsedColor = stringToColor(value);
     const defaultValue = parsedColor || value;
-    if ((parsedColor == null ? void 0 : parsedColor.type) === "function" && parsedColor.func === "url") {
+    if (parsedColor?.type === "function" && parsedColor.func === "url") {
       addColorToItem(prop, defaultValue, item, false);
       return value;
     }
@@ -86,7 +85,7 @@ async function parseColors(svg, options = {}) {
       addColorToItem(prop, defaultValue, item);
       return value;
     }
-    let callbackResult = options.callback(prop, value, parsedColor, item == null ? void 0 : item.tagName, item);
+    let callbackResult = options.callback(prop, value, parsedColor, item?.tagName, item);
     callbackResult = callbackResult instanceof Promise ? await callbackResult : callbackResult;
     switch (callbackResult) {
       case "remove": {
@@ -127,8 +126,8 @@ async function parseColors(svg, options = {}) {
   const iconData = await analyseSVGStructure(svg, options);
   const { elements, tree } = iconData;
   const cheerio = svg.$svg;
-  const removedElements = new Set();
-  const parsedElements = new Set();
+  const removedElements = /* @__PURE__ */ new Set();
+  const parsedElements = /* @__PURE__ */ new Set();
   function removeElement(index, element) {
     function removeChildren(element2) {
       element2.children.forEach((item) => {
@@ -225,8 +224,7 @@ async function parseColors(svg, options = {}) {
         requiredProps = shapeColorAttributes;
       }
       specialColorAttributes.forEach((attr) => {
-        var _a;
-        if ((_a = tagSpecificPresentationalAttributes[tagName]) == null ? void 0 : _a.has(attr)) {
+        if (tagSpecificPresentationalAttributes[tagName]?.has(attr)) {
           requiredProps = [attr];
         }
       });
@@ -262,7 +260,5 @@ function isEmptyColor(color) {
   const type = color.type;
   return type === "none" || type === "transparent";
 }
-export {
-  isEmptyColor,
-  parseColors
-};
+
+export { isEmptyColor, parseColors };

package/lib/colors/validate.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const colors = require('@iconify/utils/lib/colors');
+const colors_parse = require('./parse.cjs');
+require('../svg/data/tags.cjs');
+require('../svg/parse-style.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('../svg/parse.cjs');
+require('./attribs.cjs');
+require('../svg/data/attributes.cjs');
+require('../svg/analyse.cjs');
+require('../svg/analyse/error.cjs');
+
+async function validateColors(svg, expectMonotone, options) {
+  const palette = await colors_parse.parseColors(svg, options);
+  palette.colors.forEach((color) => {
+    if (typeof color === "string") {
+      throw new Error("Unexpected color: " + color);
+    }
+    switch (color.type) {
+      case "none":
+      case "transparent":
+        return;
+      case "current":
+        if (!expectMonotone) {
+          throw new Error("Unexpected color: " + colors.colorToString(color));
+        }
+        return;
+      case "rgb":
+      case "hsl":
+        if (expectMonotone) {
+          throw new Error("Unexpected color: " + colors.colorToString(color));
+        }
+        return;
+      default:
+        if (color.type !== "function" || color.func !== "url") {
+          throw new Error("Unexpected color: " + colors.colorToString(color));
+        }
+    }
+  });
+  return palette;
+}
+
+exports.validateColors = validateColors;

package/lib/colors/validate.d.ts

@@ -1,6 +1,11 @@
-import type { SVG } from '../svg/index';
-import { ParseColorsOptions } from './parse';
-import type { FindColorsResult } from './parse';
+import { SVG } from '../svg/index.js';
+import { ParseColorsOptions, FindColorsResult } from './parse.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+import '@iconify/utils/lib/colors/types';
+import './attribs.js';
+import '../svg/analyse/types.js';
+
 /**
  * Validate colors in icon
  *
@@ -8,4 +13,6 @@ import type { FindColorsResult } from './parse';
  *
  * Throws exception on error
  */
-export declare function validateColors(svg: SVG, expectMonotone: boolean, options?: ParseColorsOptions): Promise<FindColorsResult>;
+declare function validateColors(svg: SVG, expectMonotone: boolean, options?: ParseColorsOptions): Promise<FindColorsResult>;
+
+export { validateColors };

package/lib/colors/validate.mjs

@@ -1,6 +1,20 @@
-// src/colors/validate.ts
-import { colorToString } from "@iconify/utils/lib/colors";
-import { parseColors } from "./parse.mjs";
+import { colorToString } from '@iconify/utils/lib/colors';
+import { parseColors } from './parse.mjs';
+import '../svg/data/tags.mjs';
+import '../svg/parse-style.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 '../svg/parse.mjs';
+import './attribs.mjs';
+import '../svg/data/attributes.mjs';
+import '../svg/analyse.mjs';
+import '../svg/analyse/error.mjs';
+
 async function validateColors(svg, expectMonotone, options) {
   const palette = await parseColors(svg, options);
   palette.colors.forEach((color) => {
@@ -30,6 +44,5 @@ async function validateColors(svg, expectMonotone, options) {
   });
   return palette;
 }
-export {
-  validateColors
-};
+
+export { validateColors };

package/lib/css/parse.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const css_parser_tokens = require('./parser/tokens.cjs');
+require('./parser/error.cjs');
+require('./parser/strings.cjs');
+require('./parser/text.cjs');
+
+function parseInlineStyle(style) {
+  const tokens = css_parser_tokens.getTokens(style);
+  if (!(tokens instanceof Array)) {
+    return null;
+  }
+  const results = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.type !== "rule") {
+      return null;
+    }
+    results[token.prop] = token.value;
+  }
+  return results;
+}
+
+exports.parseInlineStyle = parseInlineStyle;

package/lib/css/parse.d.ts

@@ -1,4 +1,6 @@
 /**
  * Parse inline style
  */
-export declare function parseInlineStyle(style: string): Record<string, string> | null;
+declare function parseInlineStyle(style: string): Record<string, string> | null;
+
+export { parseInlineStyle };