orcaq 1.0.20

package/.output/server/node_modules/@iconify/utils/lib/icon-set/tree.mjs

@@ -0,0 +1,23 @@
+function getIconsTree(data, names) {
+  const icons = data.icons;
+  const aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  const resolved = /* @__PURE__ */ Object.create(null);
+  function resolve(name) {
+    if (icons[name]) {
+      return resolved[name] = [];
+    }
+    if (!(name in resolved)) {
+      resolved[name] = null;
+      const parent = aliases[name] && aliases[name].parent;
+      const value = parent && resolve(parent);
+      if (value) {
+        resolved[name] = [parent].concat(value);
+      }
+    }
+    return resolved[name];
+  }
+  (names || Object.keys(icons).concat(Object.keys(aliases))).forEach(resolve);
+  return resolved;
+}
+
+export { getIconsTree };

package/.output/server/node_modules/@iconify/utils/lib/icon-set/validate-basic.mjs

@@ -0,0 +1,62 @@
+import { defaultIconDimensions, defaultExtendedIconProps } from '../icon/defaults.mjs';
+
+const optionalPropertyDefaults = {
+  provider: "",
+  aliases: {},
+  not_found: {},
+  ...defaultIconDimensions
+};
+function checkOptionalProps(item, defaults) {
+  for (const prop in defaults) {
+    if (prop in item && typeof item[prop] !== typeof defaults[prop]) {
+      return false;
+    }
+  }
+  return true;
+}
+function quicklyValidateIconSet(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return null;
+  }
+  const data = obj;
+  if (typeof data.prefix !== "string" || !obj.icons || typeof obj.icons !== "object") {
+    return null;
+  }
+  if (!checkOptionalProps(obj, optionalPropertyDefaults)) {
+    return null;
+  }
+  const icons = data.icons;
+  for (const name in icons) {
+    const icon = icons[name];
+    if (
+      // Name cannot be empty
+      !name || // Must have body
+      typeof icon.body !== "string" || // Check other props
+      !checkOptionalProps(
+        icon,
+        defaultExtendedIconProps
+      )
+    ) {
+      return null;
+    }
+  }
+  const aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  for (const name in aliases) {
+    const icon = aliases[name];
+    const parent = icon.parent;
+    if (
+      // Name cannot be empty
+      !name || // Parent must be set and point to existing icon
+      typeof parent !== "string" || !icons[parent] && !aliases[parent] || // Check other props
+      !checkOptionalProps(
+        icon,
+        defaultExtendedIconProps
+      )
+    ) {
+      return null;
+    }
+  }
+  return data;
+}
+
+export { quicklyValidateIconSet };

package/.output/server/node_modules/@iconify/utils/lib/icon-set/validate.mjs

@@ -0,0 +1,161 @@
+import { defaultExtendedIconProps } from '../icon/defaults.mjs';
+import { getIconsTree } from './tree.mjs';
+
+const matchChar = /^[a-f0-9]+(-[a-f0-9]+)*$/;
+function validateIconProps(item, fix, checkOtherProps) {
+  for (const key in item) {
+    const attr = key;
+    const value = item[attr];
+    const type = typeof value;
+    if (type === "undefined") {
+      delete item[attr];
+      continue;
+    }
+    const expectedType = typeof defaultExtendedIconProps[attr];
+    if (expectedType !== "undefined") {
+      if (type !== expectedType) {
+        if (fix) {
+          delete item[attr];
+          continue;
+        }
+        return attr;
+      }
+      continue;
+    }
+    if (checkOtherProps && type === "object") {
+      if (fix) {
+        delete item[attr];
+      } else {
+        return key;
+      }
+    }
+  }
+  return null;
+}
+function validateIconSet(obj, options) {
+  const fix = !!(options && options.fix);
+  if (typeof obj !== "object" || obj === null || typeof obj.icons !== "object" || !obj.icons) {
+    throw new Error("Bad icon set");
+  }
+  const data = obj;
+  if (options && typeof options.prefix === "string") {
+    data.prefix = options.prefix;
+  } else if (
+    // Prefix must be a string and not empty
+    typeof data.prefix !== "string" || !data.prefix
+  ) {
+    throw new Error("Invalid prefix");
+  }
+  if (options && typeof options.provider === "string") {
+    data.provider = options.provider;
+  } else if (data.provider !== void 0) {
+    const value = data.provider;
+    if (typeof value !== "string") {
+      if (fix) {
+        delete data.provider;
+      } else {
+        throw new Error("Invalid provider");
+      }
+    }
+  }
+  if (data.aliases !== void 0) {
+    if (typeof data.aliases !== "object" || data.aliases === null) {
+      if (fix) {
+        delete data.aliases;
+      } else {
+        throw new Error("Invalid aliases list");
+      }
+    }
+  }
+  const tree = getIconsTree(data);
+  const icons = data.icons;
+  const aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  for (const name in tree) {
+    const treeItem = tree[name];
+    const isAlias = !icons[name];
+    const parentObj = isAlias ? aliases : icons;
+    if (!treeItem) {
+      if (fix) {
+        delete parentObj[name];
+        continue;
+      }
+      throw new Error(`Invalid alias: ${name}`);
+    }
+    if (!name) {
+      if (fix) {
+        delete parentObj[name];
+        continue;
+      }
+      throw new Error(`Invalid icon name: "${name}"`);
+    }
+    const item = parentObj[name];
+    if (!isAlias) {
+      if (typeof item.body !== "string") {
+        if (fix) {
+          delete parentObj[name];
+          continue;
+        }
+        throw new Error(`Invalid icon: "${name}"`);
+      }
+    }
+    const requiredProp = isAlias ? "parent" : "body";
+    const key = typeof item[requiredProp] !== "string" ? requiredProp : validateIconProps(item, fix, true);
+    if (key !== null) {
+      throw new Error(`Invalid property "${key}" in "${name}"`);
+    }
+  }
+  if (data.not_found !== void 0 && !(data.not_found instanceof Array)) {
+    if (fix) {
+      delete data.not_found;
+    } else {
+      throw new Error("Invalid not_found list");
+    }
+  }
+  if (!Object.keys(data.icons).length && !(data.not_found && data.not_found.length)) {
+    throw new Error("Icon set is empty");
+  }
+  if (fix && !Object.keys(aliases).length) {
+    delete data.aliases;
+  }
+  const failedOptionalProp = validateIconProps(data, false, false);
+  if (failedOptionalProp) {
+    throw new Error(`Invalid value type for "${failedOptionalProp}"`);
+  }
+  if (data.chars !== void 0) {
+    if (typeof data.chars !== "object" || data.chars === null) {
+      if (fix) {
+        delete data.chars;
+      } else {
+        throw new Error("Invalid characters map");
+      }
+    }
+  }
+  if (typeof data.chars === "object") {
+    const chars = data.chars;
+    Object.keys(chars).forEach((char) => {
+      if (!matchChar.exec(char) || typeof chars[char] !== "string") {
+        if (fix) {
+          delete chars[char];
+          return;
+        }
+        throw new Error(`Invalid character "${char}"`);
+      }
+      const target = chars[char];
+      if (!data.icons[target] && (!data.aliases || !data.aliases[target])) {
+        if (fix) {
+          delete chars[char];
+          return;
+        }
+        throw new Error(
+          `Character "${char}" points to missing icon "${target}"`
+        );
+      }
+    });
+    if (fix && !Object.keys(data.chars).length) {
+      delete data.chars;
+    }
+  }
+  return data;
+}
+
+export { matchChar, validateIconSet };

package/.output/server/node_modules/@iconify/utils/lib/index.mjs

@@ -0,0 +1,64 @@
+export { defaultIconCustomisations, defaultIconSizeCustomisations } from './customisations/defaults.mjs';
+export { mergeCustomisations } from './customisations/merge.mjs';
+export { toBoolean } from './customisations/bool.mjs';
+export { flipFromString } from './customisations/flip.mjs';
+export { rotateFromString } from './customisations/rotate.mjs';
+export { matchIconName, stringToIcon, validateIconName } from './icon/name.mjs';
+export { mergeIconData } from './icon/merge.mjs';
+export { mergeIconTransformations } from './icon/transformations.mjs';
+export { defaultExtendedIconProps, defaultIconDimensions, defaultIconProps, defaultIconTransformations } from './icon/defaults.mjs';
+export { makeIconSquare } from './icon/square.mjs';
+export { getIconsTree } from './icon-set/tree.mjs';
+export { parseIconSet, parseIconSetAsync } from './icon-set/parse.mjs';
+export { validateIconSet } from './icon-set/validate.mjs';
+export { quicklyValidateIconSet } from './icon-set/validate-basic.mjs';
+export { expandIconSet } from './icon-set/expand.mjs';
+export { minifyIconSet } from './icon-set/minify.mjs';
+export { getIcons } from './icon-set/get-icons.mjs';
+export { getIconData } from './icon-set/get-icon.mjs';
+export { convertIconSetInfo } from './icon-set/convert-info.mjs';
+export { iconToSVG } from './svg/build.mjs';
+export { mergeDefsAndContent, splitSVGDefs, wrapSVGContent } from './svg/defs.mjs';
+export { replaceIDs } from './svg/id.mjs';
+export { calculateSize } from './svg/size.mjs';
+export { encodeSvgForCss } from './svg/encode-svg-for-css.mjs';
+export { trimSVG } from './svg/trim.mjs';
+export { prettifySVG } from './svg/pretty.mjs';
+export { iconToHTML } from './svg/html.mjs';
+export { svgToData, svgToURL } from './svg/url.mjs';
+export { cleanUpInnerHTML } from './svg/inner-html.mjs';
+export { getSVGViewBox } from './svg/viewbox.mjs';
+export { buildParsedSVG, convertParsedSVG, parseSVGContent } from './svg/parse.mjs';
+export { colorKeywords } from './colors/keywords.mjs';
+export { colorToString, compareColors, stringToColor } from './colors/index.mjs';
+export { getIconCSS, getIconContentCSS } from './css/icon.mjs';
+export { getIconsCSS, getIconsContentCSS } from './css/icons.mjs';
+export { mergeIconProps } from './loader/utils.mjs';
+export { getCustomIcon } from './loader/custom.mjs';
+export { searchForIcon } from './loader/modern.mjs';
+export { loadIcon } from './loader/loader.mjs';
+export { getEmojiSequenceFromString, getUnqualifiedEmojiSequence } from './emoji/cleanup.mjs';
+export { convertEmojiSequenceToUTF16, convertEmojiSequenceToUTF32, getEmojiCodePoint, getEmojiUnicode, isUTF32SplitNumber, mergeUTF32Numbers, splitUTF32Number } from './emoji/convert.mjs';
+export { getEmojiSequenceKeyword, getEmojiSequenceString, getEmojiUnicodeString } from './emoji/format.mjs';
+export { parseEmojiTestFile } from './emoji/test/parse.mjs';
+export { getQualifiedEmojiVariations } from './emoji/test/variations.mjs';
+export { findMissingEmojis } from './emoji/test/missing.mjs';
+export { createOptimisedRegex, createOptimisedRegexForEmojiSequences } from './emoji/regex/create.mjs';
+export { prepareEmojiForIconSet, prepareEmojiForIconsList } from './emoji/parse.mjs';
+export { findAndReplaceEmojisInText } from './emoji/replace/replace.mjs';
+export { camelToKebab, camelize, pascalize, snakelize } from './misc/strings.mjs';
+export { commonObjectProps, compareObjects, unmergeObjects } from './misc/objects.mjs';
+export { sanitiseTitleAttribute } from './misc/title.mjs';
+import './css/common.mjs';
+import './css/format.mjs';
+import 'debug';
+import './emoji/data.mjs';
+import './emoji/test/components.mjs';
+import './emoji/regex/tree.mjs';
+import './emoji/regex/base.mjs';
+import './emoji/regex/numbers.mjs';
+import './emoji/regex/similar.mjs';
+import './emoji/test/similar.mjs';
+import './emoji/test/name.mjs';
+import './emoji/test/tree.mjs';
+import './emoji/replace/find.mjs';

package/.output/server/node_modules/@iconify/utils/lib/loader/custom.mjs

@@ -0,0 +1,50 @@
+import createDebugger from 'debug';
+import { mergeIconProps } from './utils.mjs';
+import { trimSVG } from '../svg/trim.mjs';
+import '../svg/build.mjs';
+import '../icon/defaults.mjs';
+import '../customisations/defaults.mjs';
+import '../svg/size.mjs';
+import '../svg/defs.mjs';
+
+const debug = createDebugger("@iconify-loader:custom");
+async function getCustomIcon(custom, collection, icon, options) {
+  let result;
+  debug(`${collection}:${icon}`);
+  try {
+    if (typeof custom === "function") {
+      result = await custom(icon);
+    } else {
+      const inline = custom[icon];
+      result = typeof inline === "function" ? await inline() : inline;
+    }
+  } catch (err) {
+    console.warn(
+      `Failed to load custom icon "${icon}" in "${collection}":`,
+      err
+    );
+    return;
+  }
+  if (result) {
+    const cleanupIdx = result.indexOf("<svg");
+    if (cleanupIdx > 0)
+      result = result.slice(cleanupIdx);
+    const { transform } = options?.customizations ?? {};
+    result = typeof transform === "function" ? await transform(result, collection, icon) : result;
+    if (!result.startsWith("<svg")) {
+      console.warn(
+        `Custom icon "${icon}" in "${collection}" is not a valid SVG`
+      );
+      return result;
+    }
+    return await mergeIconProps(
+      options?.customizations?.trimCustomSvg === true ? trimSVG(result) : result,
+      collection,
+      icon,
+      options,
+      void 0
+    );
+  }
+}
+
+export { getCustomIcon };

package/.output/server/node_modules/@iconify/utils/lib/loader/loader.mjs

@@ -0,0 +1,59 @@
+import { getCustomIcon } from './custom.mjs';
+import { searchForIcon } from './modern.mjs';
+import 'debug';
+import './utils.mjs';
+import '../svg/build.mjs';
+import '../icon/defaults.mjs';
+import '../customisations/defaults.mjs';
+import '../svg/size.mjs';
+import '../svg/defs.mjs';
+import '../svg/trim.mjs';
+import '../icon-set/get-icon.mjs';
+import '../icon/merge.mjs';
+import '../icon/transformations.mjs';
+import '../icon-set/tree.mjs';
+
+const loadIcon = async (collection, icon, options) => {
+  const custom = options?.customCollections?.[collection];
+  if (custom) {
+    if (typeof custom === "function") {
+      let result;
+      try {
+        result = await custom(icon);
+      } catch (err) {
+        console.warn(
+          `Failed to load custom icon "${icon}" in "${collection}":`,
+          err
+        );
+        return;
+      }
+      if (result) {
+        if (typeof result === "string") {
+          return await getCustomIcon(
+            () => result,
+            collection,
+            icon,
+            options
+          );
+        }
+        if ("icons" in result) {
+          const ids = [
+            icon,
+            icon.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase(),
+            icon.replace(/([a-z])(\d+)/g, "$1-$2")
+          ];
+          return await searchForIcon(
+            result,
+            collection,
+            ids,
+            options
+          );
+        }
+      }
+    } else {
+      return await getCustomIcon(custom, collection, icon, options);
+    }
+  }
+};
+
+export { loadIcon };

package/.output/server/node_modules/@iconify/utils/lib/loader/modern.mjs

@@ -0,0 +1,80 @@
+import { iconToSVG, isUnsetKeyword } from '../svg/build.mjs';
+import { getIconData } from '../icon-set/get-icon.mjs';
+import { calculateSize } from '../svg/size.mjs';
+import { mergeIconProps } from './utils.mjs';
+import createDebugger from 'debug';
+import { defaultIconCustomisations } from '../customisations/defaults.mjs';
+import '../icon/defaults.mjs';
+import '../svg/defs.mjs';
+import '../icon/merge.mjs';
+import '../icon/transformations.mjs';
+import '../icon-set/tree.mjs';
+
+const debug = createDebugger("@iconify-loader:icon");
+async function searchForIcon(iconSet, collection, ids, options) {
+  let iconData;
+  const { customize } = options?.customizations ?? {};
+  for (const id of ids) {
+    iconData = getIconData(iconSet, id);
+    if (iconData) {
+      debug(`${collection}:${id}`);
+      let defaultCustomizations = {
+        ...defaultIconCustomisations
+      };
+      if (typeof customize === "function") {
+        iconData = Object.assign({}, iconData);
+        defaultCustomizations = customize(
+          defaultCustomizations,
+          iconData,
+          `${collection}:${id}`
+        ) ?? defaultCustomizations;
+      }
+      const {
+        attributes: { width, height, ...restAttributes },
+        body
+      } = iconToSVG(iconData, defaultCustomizations);
+      const scale = options?.scale;
+      return await mergeIconProps(
+        // DON'T remove space on <svg >
+        `<svg >${body}</svg>`,
+        collection,
+        id,
+        options,
+        () => {
+          return { ...restAttributes };
+        },
+        (props) => {
+          const check = (prop, defaultValue) => {
+            const propValue = props[prop];
+            let value;
+            if (!isUnsetKeyword(propValue)) {
+              if (propValue) {
+                return;
+              }
+              if (typeof scale === "number") {
+                if (scale) {
+                  value = calculateSize(
+                    // Base on result from iconToSVG() or 1em
+                    defaultValue ?? "1em",
+                    scale
+                  );
+                }
+              } else {
+                value = defaultValue;
+              }
+            }
+            if (!value) {
+              delete props[prop];
+            } else {
+              props[prop] = value;
+            }
+          };
+          check("width", width);
+          check("height", height);
+        }
+      );
+    }
+  }
+}
+
+export { searchForIcon };

package/.output/server/node_modules/@iconify/utils/lib/loader/utils.mjs

@@ -0,0 +1,92 @@
+import { isUnsetKeyword } from '../svg/build.mjs';
+import { calculateSize } from '../svg/size.mjs';
+import '../icon/defaults.mjs';
+import '../customisations/defaults.mjs';
+import '../svg/defs.mjs';
+
+const svgWidthRegex = /\swidth\s*=\s*["']([\w.]+)["']/;
+const svgHeightRegex = /\sheight\s*=\s*["']([\w.]+)["']/;
+const svgTagRegex = /<svg\s+/;
+function configureSvgSize(svg, props, scale) {
+  const svgNode = svg.slice(0, svg.indexOf(">"));
+  const check = (prop, regex) => {
+    const result = regex.exec(svgNode);
+    const isSet = result != null;
+    const propValue = props[prop];
+    if (!propValue && !isUnsetKeyword(propValue)) {
+      if (typeof scale === "number") {
+        if (scale > 0) {
+          props[prop] = calculateSize(
+            // Base on result from iconToSVG() or 1em
+            result?.[1] ?? "1em",
+            scale
+          );
+        }
+      } else if (result) {
+        props[prop] = result[1];
+      }
+    }
+    return isSet;
+  };
+  return [check("width", svgWidthRegex), check("height", svgHeightRegex)];
+}
+async function mergeIconProps(svg, collection, icon, options, propsProvider, afterCustomizations) {
+  const { scale, addXmlNs = false } = options ?? {};
+  const { additionalProps = {}, iconCustomizer } = options?.customizations ?? {};
+  const props = await propsProvider?.() ?? {};
+  await iconCustomizer?.(collection, icon, props);
+  Object.keys(additionalProps).forEach((p) => {
+    const v = additionalProps[p];
+    if (v !== void 0 && v !== null)
+      props[p] = v;
+  });
+  afterCustomizations?.(props);
+  const [widthOnSvg, heightOnSvg] = configureSvgSize(svg, props, scale);
+  if (addXmlNs) {
+    if (!svg.includes("xmlns=") && !props["xmlns"]) {
+      props["xmlns"] = "http://www.w3.org/2000/svg";
+    }
+    if (!svg.includes("xmlns:xlink=") && svg.includes("xlink:") && !props["xmlns:xlink"]) {
+      props["xmlns:xlink"] = "http://www.w3.org/1999/xlink";
+    }
+  }
+  const propsToAdd = Object.keys(props).map(
+    (p) => p === "width" && widthOnSvg || p === "height" && heightOnSvg ? null : `${p}="${props[p]}"`
+  ).filter((p) => p != null);
+  if (propsToAdd.length) {
+    svg = svg.replace(svgTagRegex, `<svg ${propsToAdd.join(" ")} `);
+  }
+  if (options) {
+    const { defaultStyle, defaultClass } = options;
+    if (defaultClass && !svg.includes("class=")) {
+      svg = svg.replace(svgTagRegex, `<svg class="${defaultClass}" `);
+    }
+    if (defaultStyle && !svg.includes("style=")) {
+      svg = svg.replace(svgTagRegex, `<svg style="${defaultStyle}" `);
+    }
+  }
+  const usedProps = options?.usedProps;
+  if (usedProps) {
+    Object.keys(additionalProps).forEach((p) => {
+      const v = props[p];
+      if (v !== void 0 && v !== null)
+        usedProps[p] = v;
+    });
+    if (typeof props.width !== "undefined" && props.width !== null) {
+      usedProps.width = props.width;
+    }
+    if (typeof props.height !== "undefined" && props.height !== null) {
+      usedProps.height = props.height;
+    }
+  }
+  return svg;
+}
+function getPossibleIconNames(icon) {
+  return [
+    icon,
+    icon.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase(),
+    icon.replace(/([a-z])(\d+)/g, "$1-$2")
+  ];
+}
+
+export { getPossibleIconNames, mergeIconProps };

package/.output/server/node_modules/@iconify/utils/lib/misc/objects.mjs

@@ -0,0 +1,30 @@
+function compareObjects(obj1, obj2, ref = obj1) {
+  for (const key in ref) {
+    if (obj1[key] !== obj2[key]) {
+      return false;
+    }
+  }
+  return Object.keys(obj1).length === Object.keys(obj2).length;
+}
+function unmergeObjects(obj1, obj2) {
+  const result = {
+    ...obj1
+  };
+  for (const key in obj2) {
+    if (result[key] === obj2[key]) {
+      delete result[key];
+    }
+  }
+  return result;
+}
+function commonObjectProps(item, reference) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key in reference) {
+    if (key in item) {
+      result[key] = item[key];
+    }
+  }
+  return result;
+}
+
+export { commonObjectProps, compareObjects, unmergeObjects };

package/.output/server/node_modules/@iconify/utils/lib/misc/strings.mjs

@@ -0,0 +1,17 @@
+function camelize(str) {
+  return str.replace(/-([a-z0-9])/g, (g) => g[1].toUpperCase());
+}
+function pascalize(str) {
+  const camel = camelize(str);
+  return camel.slice(0, 1).toUpperCase() + camel.slice(1);
+}
+function camelToKebab(key) {
+  const result = key.replace(/:/g, "-").replace(/([A-Z])/g, " $1").trim();
+  return result.split(/\s+/g).join("-").toLowerCase();
+}
+function snakelize(str) {
+  const kebab = camelToKebab(str);
+  return kebab.replace(/-/g, "_");
+}
+
+export { camelToKebab, camelize, pascalize, snakelize };

package/.output/server/node_modules/@iconify/utils/lib/misc/title.mjs

@@ -0,0 +1,5 @@
+function sanitiseTitleAttribute(content) {
+  return content.replace(/[<>&]+/g, "");
+}
+
+export { sanitiseTitleAttribute };