@iconify/tools 2.0.14 → 2.0.15

package/lib/css/parse.mjs

@@ -1,11 +1,14 @@
-// src/css/parse.ts
-import { getTokens } from "./parser/tokens.mjs";
+import { getTokens } from './parser/tokens.mjs';
+import './parser/error.mjs';
+import './parser/strings.mjs';
+import './parser/text.mjs';
+
 function parseInlineStyle(style) {
   const tokens = getTokens(style);
   if (!(tokens instanceof Array)) {
     return null;
   }
-  const results = Object.create(null);
+  const results = /* @__PURE__ */ Object.create(null);
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i];
     if (token.type !== "rule") {
@@ -15,6 +18,5 @@ function parseInlineStyle(style) {
   }
   return results;
 }
-export {
-  parseInlineStyle
-};
+
+export { parseInlineStyle };

package/lib/css/parser/error.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function styleParseError(message, code, index) {
+  let fullMessage = message;
+  if (typeof index === "number" && index !== -1) {
+    const start = index;
+    const remaining = code.slice(index) + "!";
+    const trimmed = remaining.trim();
+    const end = start + remaining.length - trimmed.length;
+    const code2 = code.slice(0, end);
+    const line = code2.length - code2.replace(/\n/g, "").length + 1;
+    fullMessage = message + " on line " + line;
+  }
+  return {
+    type: "style-parse-error",
+    message,
+    code,
+    index,
+    fullMessage
+  };
+}
+
+exports.styleParseError = styleParseError;

package/lib/css/parser/error.d.ts

@@ -1,4 +1,4 @@
-export interface StyleParseError {
+interface StyleParseError {
     type: 'style-parse-error';
     message: string;
     code: string;
@@ -8,4 +8,6 @@ export interface StyleParseError {
 /**
  * Create error message
  */
-export declare function styleParseError(message: string, code: string, index?: number): StyleParseError;
+declare function styleParseError(message: string, code: string, index?: number): StyleParseError;
+
+export { StyleParseError, styleParseError };

package/lib/css/parser/error.mjs

@@ -1,4 +1,3 @@
-// src/css/parser/error.ts
 function styleParseError(message, code, index) {
   let fullMessage = message;
   if (typeof index === "number" && index !== -1) {
@@ -18,6 +17,5 @@ function styleParseError(message, code, index) {
     fullMessage
   };
 }
-export {
-  styleParseError
-};
+
+export { styleParseError };

package/lib/css/parser/export.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const tab = "	";
+const nl = "\n";
+function tokensToString(tree) {
+  let compact = true;
+  for (let i = 0; i < tree.length; i++) {
+    if (tree[i].type !== "rule") {
+      compact = false;
+      break;
+    }
+  }
+  return tree.map((token) => {
+    return parseToken(token, compact, 0);
+  }).join("");
+}
+function parseToken(token, compact, depth) {
+  let content;
+  switch (token.type) {
+    case "rule": {
+      return (compact ? "" : tab.repeat(depth)) + token.prop + (compact ? ":" : ": ") + token.value + ";" + (compact ? "" : nl);
+    }
+    case "at-rule": {
+      content = "@" + token.atRule + joinAtValues(token.atValues, compact);
+      break;
+    }
+    case "selector": {
+      content = token.selectors.join(compact ? "," : ", ");
+    }
+  }
+  const children = token.children.map((item) => {
+    return parseToken(item, compact, depth + 1);
+  });
+  return (compact ? "" : tab.repeat(depth)) + content + (compact ? "{" : " {" + nl) + children.join("") + (compact ? "}" : tab.repeat(depth) + "}" + nl);
+}
+function joinAtValues(values, compact) {
+  return values.map((item) => {
+    const value = typeof item === "string" ? item : joinAtValues(item, compact);
+    if (value.slice(0, 1) === "(" || value.slice(-1) === ")") {
+      return value;
+    }
+    return "(" + value + ")";
+  }).join(compact ? "," : ", ");
+}
+
+exports.tokensToString = tokensToString;

package/lib/css/parser/export.d.ts

@@ -1,5 +1,8 @@
-import type { CSSTreeToken } from './types';
+import { CSSTreeToken } from './types.js';
+
 /**
  * Convert tokens tree to string
  */
-export declare function tokensToString(tree: CSSTreeToken[]): string;
+declare function tokensToString(tree: CSSTreeToken[]): string;
+
+export { tokensToString };

package/lib/css/parser/export.mjs

@@ -1,6 +1,5 @@
-// src/css/parser/export.ts
-var tab = "	";
-var nl = "\n";
+const tab = "	";
+const nl = "\n";
 function tokensToString(tree) {
   let compact = true;
   for (let i = 0; i < tree.length; i++) {
@@ -41,6 +40,5 @@ function joinAtValues(values, compact) {
     return "(" + value + ")";
   }).join(compact ? "," : ", ");
 }
-export {
-  tokensToString
-};
+
+export { tokensToString };

package/lib/css/parser/strings.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const css_parser_error = require('./error.cjs');
+
+function findEndOfQuotedString(code, quote, start) {
+  let nextEscape = code.indexOf("\\", start + 1);
+  let end = code.indexOf(quote, start + 1);
+  if (end === -1) {
+    return null;
+  }
+  while (nextEscape !== -1 && nextEscape < end) {
+    if (end === nextEscape + 1) {
+      end = code.indexOf(quote, end + 1);
+      if (end === -1) {
+        return null;
+      }
+    }
+    nextEscape = code.indexOf("\\", nextEscape + 2);
+  }
+  return end + 1;
+}
+function findEndOfURL(code, start) {
+  let index = (start || 0) + 4;
+  const length = code.length;
+  while (true) {
+    if (index >= length) {
+      return css_parser_error.styleParseError("Cannot find end of URL", code, start);
+    }
+    let next = code.charAt(index);
+    switch (next) {
+      case '"':
+      case "'": {
+        let end = findEndOfQuotedString(code, next, index);
+        if (end === null) {
+          return css_parser_error.styleParseError("Incomplete string", code, index);
+        }
+        end = code.indexOf(")", end);
+        return end === -1 ? css_parser_error.styleParseError("Cannot find end of URL", code, start) : end + 1;
+      }
+      case " ":
+      case "	":
+      case "\r":
+      case "\n":
+        index++;
+        break;
+      default:
+        while (true) {
+          switch (next) {
+            case ")":
+              return index + 1;
+            case '"':
+            case "'":
+            case "(":
+            case " ":
+            case "	":
+            case "\r":
+            case "\n":
+              return css_parser_error.styleParseError("Invalid URL", code, start);
+            default:
+              if (code.charCodeAt(index) < 32) {
+                return css_parser_error.styleParseError("Invalid URL", code, start);
+              }
+          }
+          index++;
+          if (index >= length) {
+            return css_parser_error.styleParseError("Cannot find end of URL", code, start);
+          }
+          next = code.charAt(index);
+        }
+    }
+  }
+}
+
+exports.findEndOfQuotedString = findEndOfQuotedString;
+exports.findEndOfURL = findEndOfURL;

package/lib/css/parser/strings.d.ts

@@ -1,13 +1,16 @@
-import { StyleParseError } from './error';
+import { StyleParseError } from './error.js';
+
 /**
  * Find end of quoted string
  *
  * Returns index of character after quote
  */
-export declare function findEndOfQuotedString(code: string, quote: string, start: number): number | null;
+declare function findEndOfQuotedString(code: string, quote: string, start: number): number | null;
 /**
  * Find end of url
  *
  * Returns index of character after end of URL
  */
-export declare function findEndOfURL(code: string, start: number): number | StyleParseError;
+declare function findEndOfURL(code: string, start: number): number | StyleParseError;
+
+export { findEndOfQuotedString, findEndOfURL };

package/lib/css/parser/strings.mjs

@@ -1,5 +1,5 @@
-// src/css/parser/strings.ts
-import { styleParseError } from "./error.mjs";
+import { styleParseError } from './error.mjs';
+
 function findEndOfQuotedString(code, quote, start) {
   let nextEscape = code.indexOf("\\", start + 1);
   let end = code.indexOf(quote, start + 1);
@@ -68,7 +68,5 @@ function findEndOfURL(code, start) {
     }
   }
 }
-export {
-  findEndOfQuotedString,
-  findEndOfURL
-};
+
+export { findEndOfQuotedString, findEndOfURL };

package/lib/css/parser/text.cjs

@@ -0,0 +1,135 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function mergeTextTokens(tokens) {
+  return tokens.map((token) => token.text).join("").trim();
+}
+function getSelectors(tokens) {
+  const selectors = [];
+  let selector = "";
+  tokens.forEach((token) => {
+    if (token.type !== "chunk") {
+      selector += token.text;
+      return;
+    }
+    const list = token.text.split(",");
+    selector += list.shift();
+    while (list.length > 0) {
+      selectors.push(selector.trim());
+      selector = list.shift();
+    }
+  });
+  selectors.push(selector.trim());
+  return selectors.filter((item) => item.length > 0);
+}
+function textTokensToRule(tokens) {
+  let prop = "";
+  let value = "";
+  let isProp = true;
+  let error = false;
+  tokens.forEach((token) => {
+    if (error) {
+      return;
+    }
+    if (token.type !== "chunk") {
+      if (isProp) {
+        error = true;
+      } else {
+        value += token.text;
+      }
+      return;
+    }
+    const pairs = token.text.split(":");
+    if (pairs.length > 2) {
+      error = true;
+      return;
+    }
+    if (pairs.length === 2) {
+      if (!isProp) {
+        error = true;
+        return;
+      }
+      prop += pairs[0];
+      value = pairs[1];
+      isProp = false;
+      return;
+    }
+    if (isProp) {
+      prop += token.text;
+    } else {
+      value += token.text;
+    }
+  });
+  if (error || isProp) {
+    return null;
+  }
+  prop = prop.trim();
+  value = value.trim();
+  if (!prop.length || !value.length) {
+    return null;
+  }
+  const result = {
+    type: "rule",
+    prop: prop.toLowerCase(),
+    value,
+    index: tokens[0].index
+  };
+  ["important"].forEach((word) => {
+    if (result.value.slice(-1 - word.length).toLowerCase() === "!" + word) {
+      result[word] = true;
+      result.value = result.value.slice(0, -1 - word.length).trim();
+    }
+  });
+  return result.value.length ? result : null;
+}
+const nestableAtRules = ["media", "supports"];
+function textTokensToSelector(tokens) {
+  const selectors = getSelectors(tokens);
+  const code = mergeTextTokens(tokens);
+  const index = tokens[0].index;
+  if (!selectors.length) {
+    return null;
+  }
+  if (selectors[0].charAt(0) === "@") {
+    const atRule = selectors[0].split(/\s+/, 1)[0].slice(1).toLowerCase();
+    selectors[0] = selectors[0].slice(1 + atRule.length).trim();
+    const atValues = selectors;
+    if (nestableAtRules.indexOf(atRule) !== -1) {
+      atValues.forEach((item, index2) => {
+        if (typeof item !== "string" || item.charAt(0) !== "(" || item.charAt(item.length - 1) !== ")") {
+          return;
+        }
+        const list = item.slice(1, -1).split(/\)\s?and\s?\(/i).map((item2) => item2.trim());
+        let match = true;
+        list.forEach((item2) => {
+          if (item2.indexOf("(") !== -1 || item2.indexOf(")") !== -1) {
+            match = false;
+          }
+        });
+        if (match) {
+          atValues[index2] = list;
+        }
+      });
+    }
+    return {
+      type: "at-rule",
+      code,
+      index,
+      atRule,
+      atValues
+    };
+  } else {
+    return {
+      type: "selector",
+      code,
+      index,
+      selectors
+    };
+  }
+}
+
+exports.getSelectors = getSelectors;
+exports.mergeTextTokens = mergeTextTokens;
+exports.textTokensToRule = textTokensToRule;
+exports.textTokensToSelector = textTokensToSelector;

package/lib/css/parser/text.d.ts

@@ -1,17 +1,20 @@
-import type { CSSRuleToken, CSSTokenWithSelector, TextToken } from './types';
+import { TextToken, CSSRuleToken, CSSTokenWithSelector } from './types.js';
+
 /**
  * Merge text tokens to string
  */
-export declare function mergeTextTokens(tokens: TextToken[]): string;
+declare function mergeTextTokens(tokens: TextToken[]): string;
 /**
  * Get list of selectors from list of words
  */
-export declare function getSelectors(tokens: TextToken[]): string[];
+declare function getSelectors(tokens: TextToken[]): string[];
 /**
  * Convert text token to rule
  */
-export declare function textTokensToRule(tokens: TextToken[]): CSSRuleToken | null;
+declare function textTokensToRule(tokens: TextToken[]): CSSRuleToken | null;
 /**
  * Create at-rule or selector token from text tokens
  */
-export declare function textTokensToSelector(tokens: TextToken[]): CSSTokenWithSelector | null;
+declare function textTokensToSelector(tokens: TextToken[]): CSSTokenWithSelector | null;
+
+export { getSelectors, mergeTextTokens, textTokensToRule, textTokensToSelector };

package/lib/css/parser/text.mjs

@@ -1,4 +1,3 @@
-// src/css/parser/text.ts
 function mergeTextTokens(tokens) {
   return tokens.map((token) => token.text).join("").trim();
 }
@@ -80,7 +79,7 @@ function textTokensToRule(tokens) {
   });
   return result.value.length ? result : null;
 }
-var nestableAtRules = ["media", "supports"];
+const nestableAtRules = ["media", "supports"];
 function textTokensToSelector(tokens) {
   const selectors = getSelectors(tokens);
   const code = mergeTextTokens(tokens);
@@ -125,9 +124,5 @@ function textTokensToSelector(tokens) {
     };
   }
 }
-export {
-  getSelectors,
-  mergeTextTokens,
-  textTokensToRule,
-  textTokensToSelector
-};
+
+export { getSelectors, mergeTextTokens, textTokensToRule, textTokensToSelector };

package/lib/css/parser/tokens.cjs

@@ -0,0 +1,184 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const css_parser_error = require('./error.cjs');
+const css_parser_strings = require('./strings.cjs');
+const css_parser_text = require('./text.cjs');
+
+function findTokens(code, tokens) {
+  const list = [];
+  const lc = code.toLowerCase();
+  tokens.forEach((token) => {
+    let index = 0;
+    while (true) {
+      index = lc.indexOf(token, index);
+      if (index === -1) {
+        return;
+      }
+      list.push({
+        token,
+        index
+      });
+      index++;
+    }
+  });
+  list.sort((a, b) => a.index - b.index);
+  return list;
+}
+function getTokens(css) {
+  const items = [];
+  let textQueue = [];
+  let start = 0;
+  let depth = 0;
+  try {
+    const checkRule = (text) => {
+      if (!textQueue.length) {
+        return;
+      }
+      const item = css_parser_text.textTokensToRule(textQueue);
+      if (item) {
+        items.push(item);
+        return;
+      }
+      const value = css_parser_text.mergeTextTokens(textQueue) + text;
+      if (!value.length) {
+        return;
+      }
+      throw css_parser_error.styleParseError("Invalid css rule", css, textQueue[0]?.index);
+    };
+    findTokens(css, ['"', "'", "/*", "{", "}", ";", "url(", "\\"]).forEach((token) => {
+      if (token.index < start) {
+        return;
+      }
+      switch (token.token) {
+        case "/*": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          start = token.index;
+          const end = css.indexOf("*/", start + 2);
+          if (end === -1) {
+            throw css_parser_error.styleParseError("Missing comment closing statement", css, start);
+          }
+          start = end + 2;
+          break;
+        }
+        case "\\":
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index + 2),
+            index: start
+          });
+          start = token.index + 2;
+          break;
+        case "url(": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          start = token.index;
+          const end = css_parser_strings.findEndOfURL(css, start);
+          if (typeof end !== "number") {
+            throw end;
+          }
+          textQueue.push({
+            type: "url",
+            text: css.slice(start, end),
+            index: start
+          });
+          start = end;
+          break;
+        }
+        case '"':
+        case "'": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          start = token.index;
+          const end = css_parser_strings.findEndOfQuotedString(css, token.token, start);
+          if (end === null) {
+            throw css_parser_error.styleParseError("Missing closing " + token.token, css, start);
+          }
+          textQueue.push({
+            type: "quoted-string",
+            text: css.slice(start, end),
+            index: start
+          });
+          start = end;
+          break;
+        }
+        case ";": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          checkRule(token.token);
+          start = token.index + 1;
+          textQueue = [];
+          break;
+        }
+        case "{": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          const item = css_parser_text.textTokensToSelector(textQueue);
+          if (!item) {
+            throw css_parser_error.styleParseError("Invalid css rule", css, start);
+          }
+          items.push(item);
+          start = token.index + 1;
+          textQueue = [];
+          depth++;
+          break;
+        }
+        case "}": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          checkRule("");
+          items.push({
+            type: "close",
+            index: token.index
+          });
+          if (!depth) {
+            throw css_parser_error.styleParseError("Unexpected }", css, token.index);
+          }
+          depth--;
+          start = token.index + 1;
+          textQueue = [];
+          break;
+        }
+        default:
+          throw new Error(`Forgot to parse token: ${token.token}`);
+      }
+    });
+    if (depth) {
+      return css_parser_error.styleParseError("Missing }", css);
+    }
+    textQueue.push({
+      type: "chunk",
+      text: css.slice(start),
+      index: start
+    });
+    checkRule("");
+  } catch (err) {
+    if (typeof err === "object" && err.type === "style-parse-error") {
+      return err;
+    }
+    throw err;
+  }
+  return items;
+}
+
+exports.getTokens = getTokens;

package/lib/css/parser/tokens.d.ts

@@ -1,6 +1,9 @@
-import { StyleParseError } from './error';
-import type { CSSToken } from './types';
+import { StyleParseError } from './error.js';
+import { CSSToken } from './types.js';
+
 /**
  * Get tokens
  */
-export declare function getTokens(css: string): CSSToken[] | StyleParseError;
+declare function getTokens(css: string): CSSToken[] | StyleParseError;
+
+export { getTokens };