@iconify/tools 1.3.17 → 2.0.0-dev.2

package/lib/css/parser/error.mjs

@@ -0,0 +1,23 @@
+// src/css/parser/error.ts
+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
+  };
+}
+export {
+  styleParseError
+};

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

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

package/lib/css/parser/export.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokensToString = void 0;
+const tab = '\t';
+const nl = '\n';
+/**
+ * Convert tokens tree to string
+ */
+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('');
+}
+exports.tokensToString = tokensToString;
+/**
+ * Old code
+ */
+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));
+}
+/**
+ * Join at-rule values
+ */
+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 ? ',' : ', ');
+}

package/lib/css/parser/export.mjs

@@ -0,0 +1,46 @@
+// src/css/parser/export.ts
+var tab = "	";
+var 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 ? "," : ", ");
+}
+export {
+  tokensToString
+};

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

@@ -0,0 +1,13 @@
+import { StyleParseError } from './error';
+/**
+ * Find end of quoted string
+ *
+ * Returns index of character after quote
+ */
+export 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;

package/lib/css/parser/strings.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findEndOfURL = exports.findEndOfQuotedString = void 0;
+const error_1 = require("./error");
+/**
+ * Find end of quoted string
+ *
+ * Returns index of character after quote
+ */
+function findEndOfQuotedString(code, quote, start) {
+    let nextEscape = code.indexOf('\\', start + 1);
+    let end = code.indexOf(quote, start + 1);
+    if (end === -1) {
+        // Invalid string
+        return null;
+    }
+    while (nextEscape !== -1 && nextEscape < end) {
+        if (end === nextEscape + 1) {
+            end = code.indexOf(quote, end + 1);
+            if (end === -1) {
+                // Invalid string
+                return null;
+            }
+        }
+        nextEscape = code.indexOf('\\', nextEscape + 2);
+    }
+    return end + 1;
+}
+exports.findEndOfQuotedString = findEndOfQuotedString;
+/**
+ * Find end of url
+ *
+ * Returns index of character after end of URL
+ */
+function findEndOfURL(code, start) {
+    let index = (start || 0) + 4;
+    const length = code.length;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if (index >= length) {
+            return (0, error_1.styleParseError)('Cannot find end of URL', code, start);
+        }
+        let next = code.charAt(index);
+        switch (next) {
+            case '"':
+            case "'": {
+                // quoted url
+                let end = findEndOfQuotedString(code, next, index);
+                if (end === null) {
+                    return (0, error_1.styleParseError)('Incomplete string', code, index);
+                }
+                end = code.indexOf(')', end);
+                return end === -1
+                    ? (0, error_1.styleParseError)('Cannot find end of URL', code, start)
+                    : end + 1;
+            }
+            case ' ':
+            case '\t':
+            case '\r':
+            case '\n':
+                // skip whitespace
+                index++;
+                break;
+            default:
+                // unquoted url
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    switch (next) {
+                        case ')':
+                            return index + 1;
+                        case '"':
+                        case "'":
+                        case '(':
+                        case ' ':
+                        case '\t':
+                        case '\r':
+                        case '\n':
+                            return (0, error_1.styleParseError)('Invalid URL', code, start);
+                        default:
+                            if (code.charCodeAt(index) < 32) {
+                                return (0, error_1.styleParseError)('Invalid URL', code, start);
+                            }
+                    }
+                    index++;
+                    if (index >= length) {
+                        return (0, error_1.styleParseError)('Cannot find end of URL', code, start);
+                    }
+                    next = code.charAt(index);
+                }
+        }
+    }
+}
+exports.findEndOfURL = findEndOfURL;

package/lib/css/parser/strings.mjs

@@ -0,0 +1,74 @@
+// src/css/parser/strings.ts
+import { styleParseError } from "./error.mjs";
+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 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 styleParseError("Incomplete string", code, index);
+        }
+        end = code.indexOf(")", end);
+        return end === -1 ? 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 styleParseError("Invalid URL", code, start);
+            default:
+              if (code.charCodeAt(index) < 32) {
+                return styleParseError("Invalid URL", code, start);
+              }
+          }
+          index++;
+          if (index >= length) {
+            return styleParseError("Cannot find end of URL", code, start);
+          }
+          next = code.charAt(index);
+        }
+    }
+  }
+}
+export {
+  findEndOfQuotedString,
+  findEndOfURL
+};

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

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

package/lib/css/parser/text.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textTokensToSelector = exports.textTokensToRule = exports.getSelectors = exports.mergeTextTokens = void 0;
+/**
+ * Merge text tokens to string
+ */
+function mergeTextTokens(tokens) {
+    return tokens
+        .map((token) => token.text)
+        .join('')
+        .trim();
+}
+exports.mergeTextTokens = mergeTextTokens;
+/**
+ * Get list of selectors from list of words
+ */
+function getSelectors(tokens) {
+    const selectors = [];
+    let selector = '';
+    tokens.forEach((token) => {
+        if (token.type !== 'chunk') {
+            // Add entire URL or quoted string
+            selector += token.text;
+            return;
+        }
+        // Split by comma
+        const list = token.text.split(',');
+        selector += list.shift();
+        while (list.length > 0) {
+            selectors.push(selector.trim());
+            selector = list.shift();
+        }
+    });
+    selectors.push(selector.trim());
+    // Filter empty entries
+    return selectors.filter((item) => item.length > 0);
+}
+exports.getSelectors = getSelectors;
+/**
+ * Convert text token to rule
+ */
+function textTokensToRule(tokens) {
+    let prop = '';
+    let value = '';
+    let isProp = true;
+    let error = false;
+    // Merge all tokens into property and value
+    tokens.forEach((token) => {
+        if (error) {
+            return;
+        }
+        if (token.type !== 'chunk') {
+            // URL or quoted string
+            if (isProp) {
+                // Cannot have URL or quoted string in property
+                error = true;
+            }
+            else {
+                value += token.text;
+            }
+            return;
+        }
+        // Code token
+        const pairs = token.text.split(':');
+        if (pairs.length > 2) {
+            // Too many ':' in code
+            error = true;
+            return;
+        }
+        if (pairs.length === 2) {
+            if (!isProp) {
+                // Double ':' in code
+                error = true;
+                return;
+            }
+            prop += pairs[0];
+            value = pairs[1];
+            isProp = false;
+            return;
+        }
+        // Add content to property or value
+        if (isProp) {
+            prop += token.text;
+        }
+        else {
+            value += token.text;
+        }
+    });
+    if (error || isProp) {
+        // Error or still assembling a property
+        return null;
+    }
+    prop = prop.trim();
+    value = value.trim();
+    if (!prop.length || !value.length) {
+        return null;
+    }
+    const result = {
+        type: 'rule',
+        prop: prop.toLowerCase(),
+        value: value,
+        index: tokens[0].index,
+    };
+    // Check for !important (with possibility to support other stuff like !default in future)
+    ['important'].forEach((word) => {
+        if (result.value.slice(0 - word.length - 1).toLowerCase() ===
+            '!' + word) {
+            result[word] = true;
+            result.value = result.value
+                .slice(0, result.value.length - word.length - 1)
+                .trim();
+        }
+    });
+    // Value cannot be empty
+    return result.value.length ? result : null;
+}
+exports.textTokensToRule = textTokensToRule;
+// Rules that needs extra parsing
+const nestableAtRules = ['media', 'supports'];
+/**
+ * Create at-rule or selector token from text tokens
+ */
+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;
+        // Remove parenthesis for at-rules that can be nested, such as @media
+        if (nestableAtRules.indexOf(atRule) !== -1) {
+            atValues.forEach((item, index) => {
+                if (typeof item !== 'string' ||
+                    item.charAt(0) !== '(' ||
+                    item.charAt(item.length - 1) !== ')') {
+                    return;
+                }
+                const list = item
+                    .slice(1, item.length - 1)
+                    .split(/\)\s?and\s?\(/i)
+                    .map((item) => item.trim());
+                let match = true;
+                list.forEach((item) => {
+                    if (item.indexOf('(') !== -1 || item.indexOf(')') !== -1) {
+                        match = false;
+                    }
+                });
+                if (match) {
+                    atValues[index] = list;
+                }
+            });
+        }
+        return {
+            type: 'at-rule',
+            code,
+            index,
+            atRule,
+            atValues,
+        };
+    }
+    else {
+        return {
+            type: 'selector',
+            code,
+            index,
+            selectors,
+        };
+    }
+}
+exports.textTokensToSelector = textTokensToSelector;

package/lib/css/parser/text.mjs

@@ -0,0 +1,133 @@
+// src/css/parser/text.ts
+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(0 - word.length - 1).toLowerCase() === "!" + word) {
+      result[word] = true;
+      result.value = result.value.slice(0, result.value.length - word.length - 1).trim();
+    }
+  });
+  return result.value.length ? result : null;
+}
+var 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, item.length - 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
+    };
+  }
+}
+export {
+  getSelectors,
+  mergeTextTokens,
+  textTokensToRule,
+  textTokensToSelector
+};

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

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