orcaq 1.0.20

package/.output/server/node_modules/@iconify/utils/lib/css/format.mjs

@@ -0,0 +1,38 @@
+const format = {
+  selectorStart: {
+    compressed: "{",
+    compact: " {",
+    expanded: " {"
+  },
+  selectorEnd: {
+    compressed: "}",
+    compact: "; }\n",
+    expanded: ";\n}\n"
+  },
+  rule: {
+    compressed: "{key}:",
+    compact: " {key}: ",
+    expanded: "\n  {key}: "
+  }
+};
+function formatCSS(data, mode = "expanded") {
+  const results = [];
+  for (let i = 0; i < data.length; i++) {
+    const { selector, rules } = data[i];
+    const fullSelector = selector instanceof Array ? selector.join(mode === "compressed" ? "," : ", ") : selector;
+    let entry = fullSelector + format.selectorStart[mode];
+    let firstRule = true;
+    for (const key in rules) {
+      if (!firstRule) {
+        entry += ";";
+      }
+      entry += format.rule[mode].replace("{key}", key) + rules[key];
+      firstRule = false;
+    }
+    entry += format.selectorEnd[mode];
+    results.push(entry);
+  }
+  return results.join(mode === "compressed" ? "" : "\n");
+}
+
+export { formatCSS };

package/.output/server/node_modules/@iconify/utils/lib/css/icon.mjs

@@ -0,0 +1,76 @@
+import { defaultIconProps } from '../icon/defaults.mjs';
+import { getCommonCSSRules, generateItemCSSRules, generateItemContent } from './common.mjs';
+import { formatCSS } from './format.mjs';
+import '../svg/html.mjs';
+import '../svg/size.mjs';
+import '../svg/url.mjs';
+import '../icon/square.mjs';
+import '../svg/build.mjs';
+import '../customisations/defaults.mjs';
+import '../svg/defs.mjs';
+
+function getIconCSS(icon, options = {}) {
+  const body = options.customise ? options.customise(icon.body) : icon.body;
+  const mode = options.mode || (options.color || !body.includes("currentColor") ? "background" : "mask");
+  let varName = options.varName;
+  if (varName === void 0 && mode === "mask") {
+    varName = "svg";
+  }
+  const newOptions = {
+    ...options,
+    // Override mode and varName
+    mode,
+    varName
+  };
+  if (mode === "background") {
+    delete newOptions.varName;
+  }
+  const rules = {
+    ...options.rules,
+    ...getCommonCSSRules(newOptions),
+    ...generateItemCSSRules(
+      {
+        ...defaultIconProps,
+        ...icon,
+        body
+      },
+      newOptions
+    )
+  };
+  const selector = options.iconSelector || ".icon";
+  return formatCSS(
+    [
+      {
+        selector,
+        rules
+      }
+    ],
+    newOptions.format
+  );
+}
+function getIconContentCSS(icon, options) {
+  const body = options.customise ? options.customise(icon.body) : icon.body;
+  const content = generateItemContent(
+    {
+      ...defaultIconProps,
+      ...icon,
+      body
+    },
+    options
+  );
+  const selector = options.iconSelector || ".icon::after";
+  return formatCSS(
+    [
+      {
+        selector,
+        rules: {
+          ...options.rules,
+          content
+        }
+      }
+    ],
+    options.format
+  );
+}
+
+export { getIconCSS, getIconContentCSS };

package/.output/server/node_modules/@iconify/utils/lib/css/icons.mjs

@@ -0,0 +1,168 @@
+import { getIconData } from '../icon-set/get-icon.mjs';
+import { defaultIconProps } from '../icon/defaults.mjs';
+import { getCommonCSSRules, generateItemCSSRules, generateItemContent } from './common.mjs';
+import { formatCSS } from './format.mjs';
+import '../icon/merge.mjs';
+import '../icon/transformations.mjs';
+import '../icon-set/tree.mjs';
+import '../svg/html.mjs';
+import '../svg/size.mjs';
+import '../svg/url.mjs';
+import '../icon/square.mjs';
+import '../svg/build.mjs';
+import '../customisations/defaults.mjs';
+import '../svg/defs.mjs';
+
+const commonSelector = ".icon--{prefix}";
+const iconSelector = ".icon--{prefix}--{name}";
+const contentSelector = ".icon--{prefix}--{name}::after";
+const defaultSelectors = {
+  commonSelector,
+  iconSelector,
+  overrideSelector: commonSelector + iconSelector
+};
+function getIconsCSSData(iconSet, names, options = {}) {
+  const css = [];
+  const errors = [];
+  const palette = options.color ? true : void 0;
+  let mode = options.mode || typeof palette === "boolean" && (palette ? "background" : "mask");
+  if (!mode) {
+    for (let i = 0; i < names.length; i++) {
+      const name = names[i];
+      const icon = getIconData(iconSet, name);
+      if (icon) {
+        const body = options.customise ? options.customise(icon.body, name) : icon.body;
+        mode = body.includes("currentColor") ? "mask" : "background";
+        break;
+      }
+    }
+    if (!mode) {
+      mode = "mask";
+      errors.push(
+        "/* cannot detect icon mode: not set in options and icon set is missing info, rendering as " + mode + " */"
+      );
+    }
+  }
+  let varName = options.varName;
+  if (varName === void 0 && mode === "mask") {
+    varName = "svg";
+  }
+  const newOptions = {
+    ...options,
+    // Override mode and varName
+    mode,
+    varName
+  };
+  const { commonSelector: commonSelector2, iconSelector: iconSelector2, overrideSelector } = newOptions.iconSelector ? newOptions : defaultSelectors;
+  const iconSelectorWithPrefix = iconSelector2.replace(
+    /{prefix}/g,
+    iconSet.prefix
+  );
+  const commonRules = {
+    ...options.rules,
+    ...getCommonCSSRules(newOptions)
+  };
+  const hasCommonRules = commonSelector2 && commonSelector2 !== iconSelector2;
+  const commonSelectors = /* @__PURE__ */ new Set();
+  if (hasCommonRules) {
+    css.push({
+      selector: commonSelector2.replace(/{prefix}/g, iconSet.prefix),
+      rules: commonRules
+    });
+  }
+  for (let i = 0; i < names.length; i++) {
+    const name = names[i];
+    const iconData = getIconData(iconSet, name);
+    if (!iconData) {
+      errors.push("/* Could not find icon: " + name + " */");
+      continue;
+    }
+    const body = options.customise ? options.customise(iconData.body, name) : iconData.body;
+    const rules = generateItemCSSRules(
+      {
+        ...defaultIconProps,
+        ...iconData,
+        body
+      },
+      newOptions
+    );
+    let requiresOverride = false;
+    if (hasCommonRules && overrideSelector) {
+      for (const key in rules) {
+        if (key in commonRules) {
+          requiresOverride = true;
+        }
+      }
+    }
+    const selector = (requiresOverride && overrideSelector ? overrideSelector.replace(/{prefix}/g, iconSet.prefix) : iconSelectorWithPrefix).replace(/{name}/g, name);
+    css.push({
+      selector,
+      rules
+    });
+    if (!hasCommonRules) {
+      commonSelectors.add(selector);
+    }
+  }
+  const result = {
+    css,
+    errors
+  };
+  if (!hasCommonRules && commonSelectors.size) {
+    const selector = Array.from(commonSelectors).join(
+      newOptions.format === "compressed" ? "," : ", "
+    );
+    result.common = {
+      selector,
+      rules: commonRules
+    };
+  }
+  return result;
+}
+function getIconsCSS(iconSet, names, options = {}) {
+  const { css, errors, common } = getIconsCSSData(iconSet, names, options);
+  if (common) {
+    if (css.length === 1 && css[0].selector === common.selector) {
+      css[0].rules = {
+        // Common first, override later
+        ...common.rules,
+        ...css[0].rules
+      };
+    } else {
+      css.unshift(common);
+    }
+  }
+  return formatCSS(css, options.format) + (errors.length ? "\n" + errors.join("\n") + "\n" : "");
+}
+function getIconsContentCSS(iconSet, names, options) {
+  const errors = [];
+  const css = [];
+  const iconSelectorWithPrefix = (options.iconSelector ?? contentSelector).replace(/{prefix}/g, iconSet.prefix);
+  for (let i = 0; i < names.length; i++) {
+    const name = names[i];
+    const iconData = getIconData(iconSet, name);
+    if (!iconData) {
+      errors.push("/* Could not find icon: " + name + " */");
+      continue;
+    }
+    const body = options.customise ? options.customise(iconData.body, name) : iconData.body;
+    const content = generateItemContent(
+      {
+        ...defaultIconProps,
+        ...iconData,
+        body
+      },
+      options
+    );
+    const selector = iconSelectorWithPrefix.replace(/{name}/g, name);
+    css.push({
+      selector,
+      rules: {
+        ...options.rules,
+        content
+      }
+    });
+  }
+  return formatCSS(css, options.format) + (errors.length ? "\n" + errors.join("\n") + "\n" : "");
+}
+
+export { getIconsCSS, getIconsCSSData, getIconsContentCSS };

package/.output/server/node_modules/@iconify/utils/lib/customisations/bool.mjs

@@ -0,0 +1,22 @@
+function toBoolean(name, value, defaultValue) {
+  switch (typeof value) {
+    case "boolean":
+      return value;
+    case "number":
+      return !!value;
+    case "string":
+      switch (value.toLowerCase()) {
+        case "1":
+        case "true":
+        case name.toLowerCase():
+          return true;
+        case "0":
+        case "false":
+        case "":
+          return false;
+      }
+  }
+  return defaultValue;
+}
+
+export { toBoolean };

package/.output/server/node_modules/@iconify/utils/lib/customisations/defaults.mjs

@@ -0,0 +1,14 @@
+import { defaultIconTransformations } from '../icon/defaults.mjs';
+
+const defaultIconSizeCustomisations = Object.freeze({
+  width: null,
+  height: null
+});
+const defaultIconCustomisations = Object.freeze({
+  // Dimensions
+  ...defaultIconSizeCustomisations,
+  // Transformations
+  ...defaultIconTransformations
+});
+
+export { defaultIconCustomisations, defaultIconSizeCustomisations };

package/.output/server/node_modules/@iconify/utils/lib/customisations/flip.mjs

@@ -0,0 +1,16 @@
+const separator = /[\s,]+/;
+function flipFromString(custom, flip) {
+  flip.split(separator).forEach((str) => {
+    const value = str.trim();
+    switch (value) {
+      case "horizontal":
+        custom.hFlip = true;
+        break;
+      case "vertical":
+        custom.vFlip = true;
+        break;
+    }
+  });
+}
+
+export { flipFromString };

package/.output/server/node_modules/@iconify/utils/lib/customisations/merge.mjs

@@ -0,0 +1,22 @@
+import { defaultIconSizeCustomisations } from './defaults.mjs';
+import '../icon/defaults.mjs';
+
+function mergeCustomisations(defaults, item) {
+  const result = {
+    ...defaults
+  };
+  for (const key in item) {
+    const value = item[key];
+    const valueType = typeof value;
+    if (key in defaultIconSizeCustomisations) {
+      if (value === null || value && (valueType === "string" || valueType === "number")) {
+        result[key] = value;
+      }
+    } else if (valueType === typeof result[key]) {
+      result[key] = key === "rotate" ? value % 4 : value;
+    }
+  }
+  return result;
+}
+
+export { mergeCustomisations };

package/.output/server/node_modules/@iconify/utils/lib/customisations/rotate.mjs

@@ -0,0 +1,33 @@
+function rotateFromString(value, defaultValue = 0) {
+  const units = value.replace(/^-?[0-9.]*/, "");
+  function cleanup(value2) {
+    while (value2 < 0) {
+      value2 += 4;
+    }
+    return value2 % 4;
+  }
+  if (units === "") {
+    const num = parseInt(value);
+    return isNaN(num) ? 0 : cleanup(num);
+  } else if (units !== value) {
+    let split = 0;
+    switch (units) {
+      case "%":
+        split = 25;
+        break;
+      case "deg":
+        split = 90;
+    }
+    if (split) {
+      let num = parseFloat(value.slice(0, value.length - units.length));
+      if (isNaN(num)) {
+        return 0;
+      }
+      num = num / split;
+      return num % 1 === 0 ? cleanup(num) : 0;
+    }
+  }
+  return defaultValue;
+}
+
+export { rotateFromString };

package/.output/server/node_modules/@iconify/utils/lib/emoji/cleanup.mjs

@@ -0,0 +1,51 @@
+import { getEmojiCodePoint } from './convert.mjs';
+import { joinerEmoji, vs16Emoji } from './data.mjs';
+
+function getEmojiSequenceFromString(value) {
+  return value.trim().split(/[^0-9A-F]+/i).filter((item) => item.length > 0).map(getEmojiCodePoint);
+}
+function getSequenceFromEmojiStringOrKeyword(value) {
+  if (!value.match(/^[0-9a-fA-F-\s]+$/)) {
+    const results = [];
+    for (const codePoint of value) {
+      const code = codePoint.codePointAt(0);
+      if (code) {
+        results.push(code);
+      } else {
+        return getEmojiSequenceFromString(value);
+      }
+    }
+    return results;
+  }
+  return getEmojiSequenceFromString(value);
+}
+function splitEmojiSequences(sequence, separator = joinerEmoji) {
+  const results = [];
+  let queue = [];
+  for (let i = 0; i < sequence.length; i++) {
+    const code = sequence[i];
+    if (code === separator) {
+      results.push(queue);
+      queue = [];
+    } else {
+      queue.push(code);
+    }
+  }
+  results.push(queue);
+  return results;
+}
+function joinEmojiSequences(sequences, separator = joinerEmoji) {
+  let results = [];
+  for (let i = 0; i < sequences.length; i++) {
+    if (i > 0) {
+      results.push(separator);
+    }
+    results = results.concat(sequences[i]);
+  }
+  return results;
+}
+function getUnqualifiedEmojiSequence(sequence) {
+  return sequence.filter((num) => num !== vs16Emoji);
+}
+
+export { getEmojiSequenceFromString, getSequenceFromEmojiStringOrKeyword, getUnqualifiedEmojiSequence, joinEmojiSequences, splitEmojiSequences };

package/.output/server/node_modules/@iconify/utils/lib/emoji/convert.mjs

@@ -0,0 +1,84 @@
+import { minUTF32, startUTF32Pair1, startUTF32Pair2, endUTF32Pair } from './data.mjs';
+
+function getEmojiCodePoint(code) {
+  return parseInt(code, 16);
+}
+function utf32FirstNum(code) {
+  return (code - minUTF32 >> 10 | 0) + startUTF32Pair1;
+}
+function utf32SecondNum(code) {
+  return (code - minUTF32 & 1023) + startUTF32Pair2;
+}
+function splitUTF32Number(code) {
+  if (code >= minUTF32) {
+    return [utf32FirstNum(code), utf32SecondNum(code)];
+  }
+}
+function isUTF32SplitNumber(value) {
+  if (value >= startUTF32Pair1) {
+    if (value < startUTF32Pair2) {
+      return 1;
+    }
+    if (value < endUTF32Pair) {
+      return 2;
+    }
+  }
+  return false;
+}
+function mergeUTF32Numbers(part1, part2) {
+  if (part1 < startUTF32Pair1 || part1 >= startUTF32Pair2 || part2 < startUTF32Pair2 || part2 >= endUTF32Pair) {
+    return;
+  }
+  return (part1 - startUTF32Pair1 << 10) + (part2 - startUTF32Pair2) + minUTF32;
+}
+function getEmojiUnicode(code) {
+  return String.fromCodePoint(
+    typeof code === "number" ? code : getEmojiCodePoint(code)
+  );
+}
+function convertEmojiSequenceToUTF16(numbers) {
+  const results = [];
+  for (let i = 0; i < numbers.length; i++) {
+    const code = numbers[i];
+    if (code >= minUTF32) {
+      results.push(utf32FirstNum(code));
+      results.push(utf32SecondNum(code));
+    } else {
+      results.push(code);
+    }
+  }
+  return results;
+}
+function convertEmojiSequenceToUTF32(numbers, throwOnError = true) {
+  const results = [];
+  for (let i = 0; i < numbers.length; i++) {
+    const code = numbers[i];
+    if (code >= minUTF32) {
+      results.push(code);
+      continue;
+    }
+    const part = isUTF32SplitNumber(code);
+    if (!part) {
+      results.push(code);
+      continue;
+    }
+    if (part === 1 && numbers.length > i + 1) {
+      const merged = mergeUTF32Numbers(code, numbers[i + 1]);
+      if (merged) {
+        i++;
+        results.push(merged);
+        continue;
+      }
+    }
+    if (throwOnError) {
+      const nextCode = numbers[i + 1];
+      throw new Error(
+        `Invalid UTF-16 sequence: ${code.toString(16)}-${nextCode ? nextCode.toString(16) : "undefined"}`
+      );
+    }
+    results.push(code);
+  }
+  return results;
+}
+
+export { convertEmojiSequenceToUTF16, convertEmojiSequenceToUTF32, getEmojiCodePoint, getEmojiUnicode, isUTF32SplitNumber, mergeUTF32Numbers, splitUTF32Number };

package/.output/server/node_modules/@iconify/utils/lib/emoji/data.mjs

@@ -0,0 +1,16 @@
+const joinerEmoji = 8205;
+const vs16Emoji = 65039;
+const keycapEmoji = 8419;
+const emojiComponents = {
+  // Hair styles
+  "hair-style": [129456, 129460],
+  // Skin tones
+  "skin-tone": [127995, 128e3]
+};
+const minUTF32 = 65536;
+const startUTF32Pair1 = 55296;
+const startUTF32Pair2 = 56320;
+const endUTF32Pair = 57344;
+const emojiVersion = "16.0";
+
+export { emojiComponents, emojiVersion, endUTF32Pair, joinerEmoji, keycapEmoji, minUTF32, startUTF32Pair1, startUTF32Pair2, vs16Emoji };

package/.output/server/node_modules/@iconify/utils/lib/emoji/format.mjs

@@ -0,0 +1,44 @@
+import { convertEmojiSequenceToUTF16, convertEmojiSequenceToUTF32 } from './convert.mjs';
+import './data.mjs';
+
+const defaultUnicodeOptions = {
+  prefix: "",
+  separator: "",
+  case: "lower",
+  format: "utf-32",
+  add0: false,
+  throwOnError: true
+};
+function convert(sequence, options) {
+  const prefix = options.prefix;
+  const func = options.case === "upper" ? "toUpperCase" : "toLowerCase";
+  const cleanSequence = options.format === "utf-16" ? convertEmojiSequenceToUTF16(sequence) : convertEmojiSequenceToUTF32(sequence, options.throwOnError);
+  return cleanSequence.map((code) => {
+    let str = code.toString(16);
+    if (options.add0 && str.length < 4) {
+      str = "0".repeat(4 - str.length) + str;
+    }
+    return prefix + str[func]();
+  }).join(options.separator);
+}
+function getEmojiUnicodeString(code, options = {}) {
+  return convert([code], {
+    ...defaultUnicodeOptions,
+    ...options
+  });
+}
+const defaultSequenceOptions = {
+  ...defaultUnicodeOptions,
+  separator: "-"
+};
+function getEmojiSequenceString(sequence, options = {}) {
+  return convert(sequence, {
+    ...defaultSequenceOptions,
+    ...options
+  });
+}
+function getEmojiSequenceKeyword(sequence) {
+  return sequence.map((code) => code.toString(16)).join("-");
+}
+
+export { getEmojiSequenceKeyword, getEmojiSequenceString, getEmojiUnicodeString };

package/.output/server/node_modules/@iconify/utils/lib/emoji/parse.mjs

@@ -0,0 +1,58 @@
+import { getEmojiSequenceFromString, getUnqualifiedEmojiSequence } from './cleanup.mjs';
+import { getEmojiSequenceKeyword } from './format.mjs';
+import { createOptimisedRegexForEmojiSequences } from './regex/create.mjs';
+import { findMissingEmojis } from './test/missing.mjs';
+import { parseEmojiTestFile } from './test/parse.mjs';
+import { combineSimilarEmojiTestData } from './test/similar.mjs';
+import { getEmojiTestDataTree } from './test/tree.mjs';
+import { getQualifiedEmojiVariations } from './test/variations.mjs';
+import './convert.mjs';
+import './data.mjs';
+import './regex/tree.mjs';
+import './regex/base.mjs';
+import './regex/numbers.mjs';
+import './regex/similar.mjs';
+import './test/components.mjs';
+import './test/name.mjs';
+
+function prepareEmojiForIconsList(icons, rawTestData) {
+  const testData = rawTestData ? parseEmojiTestFile(rawTestData) : void 0;
+  let iconsList = [];
+  for (const char in icons) {
+    const sequence = getEmojiSequenceFromString(char);
+    iconsList.push({
+      icon: icons[char],
+      sequence
+    });
+  }
+  iconsList = getQualifiedEmojiVariations(iconsList);
+  if (testData) {
+    iconsList = iconsList.concat(
+      findMissingEmojis(
+        iconsList,
+        getEmojiTestDataTree(combineSimilarEmojiTestData(testData))
+      )
+    );
+  }
+  const preparedIcons = iconsList.map((item) => {
+    const sequence = getEmojiSequenceKeyword(
+      getUnqualifiedEmojiSequence(item.sequence)
+    );
+    return {
+      icon: item.icon,
+      sequence
+    };
+  });
+  const regex = createOptimisedRegexForEmojiSequences(
+    iconsList.map((item) => item.sequence)
+  );
+  return {
+    regex,
+    icons: preparedIcons
+  };
+}
+function prepareEmojiForIconSet(iconSet, rawTestData) {
+  return prepareEmojiForIconsList(iconSet.chars || {}, rawTestData);
+}
+
+export { prepareEmojiForIconSet, prepareEmojiForIconsList };