orcaq 1.0.20

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

@@ -0,0 +1,105 @@
+import { emojiComponents } from '../data.mjs';
+
+function mergeComponentTypes(value) {
+  return "[" + value.join(",") + "]";
+}
+function mergeComponentsCount(value) {
+  const keys = [];
+  for (const key in emojiComponents) {
+    const type = key;
+    for (let i = 0; i < value[type]; i++) {
+      keys.push(type);
+    }
+  }
+  return keys.length ? mergeComponentTypes(keys) : "";
+}
+function getGroupItem(items, components) {
+  const key = mergeComponentsCount(components);
+  const item = items[key];
+  if (item) {
+    item.parsed = true;
+    return item.item;
+  }
+}
+function getEmojiTestDataTree(data) {
+  const groups = /* @__PURE__ */ Object.create(null);
+  for (const key in data) {
+    const item = data[key];
+    const text = item.name.key;
+    const parent = groups[text] || (groups[text] = {});
+    const components = {
+      "hair-style": 0,
+      "skin-tone": 0
+    };
+    item.sequence.forEach((value) => {
+      if (typeof value !== "number") {
+        components[value]++;
+      }
+    });
+    const componentsKey = mergeComponentsCount(components);
+    if (parent[componentsKey]) {
+      throw new Error(`Duplicate components tree item for "${text}"`);
+    }
+    parent[componentsKey] = {
+      item: {
+        ...item,
+        components,
+        componentsKey
+      }
+    };
+  }
+  const results = /* @__PURE__ */ Object.create(null);
+  for (const key in groups) {
+    const items = groups[key];
+    const check = (parent, parentComponents, type) => {
+      const item = parse(parentComponents, [type]);
+      if (item) {
+        const children = parent.children || (parent.children = {});
+        children[type] = item;
+        return true;
+      }
+    };
+    const parse = (parentComponents, newComponents) => {
+      const components = {
+        "hair-style": 0,
+        "skin-tone": 0
+      };
+      const componentsList = parentComponents.concat(newComponents);
+      componentsList.forEach((type) => {
+        components[type]++;
+      });
+      let item = getGroupItem(items, components);
+      if (!item && newComponents.length === 1 && newComponents[0] === "skin-tone") {
+        const doubleComponents = {
+          ...components
+        };
+        doubleComponents["skin-tone"]++;
+        item = getGroupItem(items, doubleComponents);
+      }
+      if (item) {
+        const result = {
+          item
+        };
+        for (const key2 in emojiComponents) {
+          check(result, componentsList, key2);
+        }
+        return result;
+      }
+    };
+    const root = parse([], []);
+    if (!root) {
+      throw new Error(`Cannot find parent item for "${key}"`);
+    }
+    for (const itemsKey in items) {
+      if (!items[itemsKey].parsed) {
+        throw new Error(`Error generating tree for "${key}"`);
+      }
+    }
+    if (root.children) {
+      results[key] = root;
+    }
+  }
+  return results;
+}
+
+export { getEmojiTestDataTree };

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

@@ -0,0 +1,54 @@
+import { splitEmojiSequences, joinEmojiSequences, getUnqualifiedEmojiSequence } from '../cleanup.mjs';
+import { convertEmojiSequenceToUTF32 } from '../convert.mjs';
+import { vs16Emoji, keycapEmoji, emojiComponents } from '../data.mjs';
+import { getEmojiSequenceKeyword } from '../format.mjs';
+
+function guessQualifiedEmojiSequence(sequence) {
+  const split = splitEmojiSequences(sequence).map((part) => {
+    if (part.indexOf(vs16Emoji) !== -1) {
+      return part;
+    }
+    if (part.length === 2) {
+      const lastNum = part[1];
+      if (lastNum === keycapEmoji) {
+        return [part[0], vs16Emoji, lastNum];
+      }
+      for (const key in emojiComponents) {
+        const range = emojiComponents[key];
+        if (lastNum >= range[0] && lastNum < range[1]) {
+          return [part[0], vs16Emoji, lastNum];
+        }
+      }
+    }
+    return part.length === 1 ? [part[0], vs16Emoji] : part;
+  });
+  return joinEmojiSequences(split);
+}
+function getQualifiedEmojiVariation(item) {
+  const unqualifiedSequence = getUnqualifiedEmojiSequence(
+    convertEmojiSequenceToUTF32(item.sequence)
+  );
+  const result = {
+    ...item,
+    sequence: guessQualifiedEmojiSequence(unqualifiedSequence)
+  };
+  if (result.sequenceKey) {
+    result.sequenceKey = getEmojiSequenceKeyword(unqualifiedSequence);
+  }
+  return result;
+}
+function getQualifiedEmojiVariations(items) {
+  const results = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < items.length; i++) {
+    const result = getQualifiedEmojiVariation(items[i]);
+    const key = getEmojiSequenceKeyword(
+      getUnqualifiedEmojiSequence(result.sequence)
+    );
+    if (!results[key] || results[key].sequence.length < result.sequence.length) {
+      results[key] = result;
+    }
+  }
+  return Object.values(results);
+}
+
+export { getQualifiedEmojiVariation, getQualifiedEmojiVariations, guessQualifiedEmojiSequence };

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

@@ -0,0 +1,24 @@
+const defaultIconDimensions = Object.freeze(
+  {
+    left: 0,
+    top: 0,
+    width: 16,
+    height: 16
+  }
+);
+const defaultIconTransformations = Object.freeze({
+  rotate: 0,
+  vFlip: false,
+  hFlip: false
+});
+const defaultIconProps = Object.freeze({
+  ...defaultIconDimensions,
+  ...defaultIconTransformations
+});
+const defaultExtendedIconProps = Object.freeze({
+  ...defaultIconProps,
+  body: "",
+  hidden: false
+});
+
+export { defaultExtendedIconProps, defaultIconDimensions, defaultIconProps, defaultIconTransformations };

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

@@ -0,0 +1,20 @@
+import { defaultExtendedIconProps, defaultIconTransformations } from './defaults.mjs';
+import { mergeIconTransformations } from './transformations.mjs';
+
+function mergeIconData(parent, child) {
+  const result = mergeIconTransformations(parent, child);
+  for (const key in defaultExtendedIconProps) {
+    if (key in defaultIconTransformations) {
+      if (key in parent && !(key in result)) {
+        result[key] = defaultIconTransformations[key];
+      }
+    } else if (key in child) {
+      result[key] = child[key];
+    } else if (key in parent) {
+      result[key] = parent[key];
+    }
+  }
+  return result;
+}
+
+export { mergeIconData };

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

@@ -0,0 +1,53 @@
+const matchIconName = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const stringToIcon = (value, validate, allowSimpleName, provider = "") => {
+  const colonSeparated = value.split(":");
+  if (value.slice(0, 1) === "@") {
+    if (colonSeparated.length < 2 || colonSeparated.length > 3) {
+      return null;
+    }
+    provider = colonSeparated.shift().slice(1);
+  }
+  if (colonSeparated.length > 3 || !colonSeparated.length) {
+    return null;
+  }
+  if (colonSeparated.length > 1) {
+    const name2 = colonSeparated.pop();
+    const prefix = colonSeparated.pop();
+    const result = {
+      // Allow provider without '@': "provider:prefix:name"
+      provider: colonSeparated.length > 0 ? colonSeparated[0] : provider,
+      prefix,
+      name: name2
+    };
+    return validate && !validateIconName(result) ? null : result;
+  }
+  const name = colonSeparated[0];
+  const dashSeparated = name.split("-");
+  if (dashSeparated.length > 1) {
+    const result = {
+      provider,
+      prefix: dashSeparated.shift(),
+      name: dashSeparated.join("-")
+    };
+    return validate && !validateIconName(result) ? null : result;
+  }
+  if (allowSimpleName && provider === "") {
+    const result = {
+      provider,
+      prefix: "",
+      name
+    };
+    return validate && !validateIconName(result, allowSimpleName) ? null : result;
+  }
+  return null;
+};
+const validateIconName = (icon, allowSimpleName) => {
+  if (!icon) {
+    return false;
+  }
+  return !!// Check prefix: cannot be empty, unless allowSimpleName is enabled
+  // Check name: cannot be empty
+  ((allowSimpleName && icon.prefix === "" || !!icon.prefix) && !!icon.name);
+};
+
+export { matchIconName, stringToIcon, validateIconName };

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

@@ -0,0 +1,23 @@
+function makeIconSquare(icon) {
+  if (icon.width !== icon.height) {
+    const max = Math.max(icon.width, icon.height);
+    return {
+      ...icon,
+      width: max,
+      height: max,
+      left: icon.left - (max - icon.width) / 2,
+      top: icon.top - (max - icon.height) / 2
+    };
+  }
+  return icon;
+}
+function makeViewBoxSquare(viewBox) {
+  const [left, top, width, height] = viewBox;
+  if (width !== height) {
+    const max = Math.max(width, height);
+    return [left - (max - width) / 2, top - (max - height) / 2, max, max];
+  }
+  return viewBox;
+}
+
+export { makeIconSquare, makeViewBoxSquare };

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

@@ -0,0 +1,16 @@
+function mergeIconTransformations(obj1, obj2) {
+  const result = {};
+  if (!obj1.hFlip !== !obj2.hFlip) {
+    result.hFlip = true;
+  }
+  if (!obj1.vFlip !== !obj2.vFlip) {
+    result.vFlip = true;
+  }
+  const rotate = ((obj1.rotate || 0) + (obj2.rotate || 0)) % 4;
+  if (rotate) {
+    result.rotate = rotate;
+  }
+  return result;
+}
+
+export { mergeIconTransformations };

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

@@ -0,0 +1,182 @@
+const minDisplayHeight = 16;
+const maxDisplayHeight = 24;
+function validateDisplayHeight(value) {
+  while (value < minDisplayHeight) {
+    value *= 2;
+  }
+  while (value > maxDisplayHeight) {
+    value /= 2;
+  }
+  return value === Math.round(value) && value >= minDisplayHeight && value <= maxDisplayHeight ? value : 0;
+}
+function convertIconSetInfo(data, expectedPrefix = "") {
+  if (typeof data !== "object" || data === null) {
+    return null;
+  }
+  const source = data;
+  const getSourceNestedString = (field, key, defaultValue = "") => {
+    if (typeof source[field] !== "object") {
+      return defaultValue;
+    }
+    const obj = source[field];
+    return typeof obj[key] === "string" ? obj[key] : defaultValue;
+  };
+  let name;
+  if (typeof source.name === "string") {
+    name = source.name;
+  } else if (typeof source.title === "string") {
+    name = source.title;
+  } else {
+    return null;
+  }
+  if (expectedPrefix !== "" && typeof source.prefix === "string" && source.prefix !== expectedPrefix) {
+    return null;
+  }
+  const info = {
+    name
+  };
+  switch (typeof source.total) {
+    case "number":
+      info.total = source.total;
+      break;
+    case "string": {
+      const num = parseInt(source.total);
+      if (num > 0) {
+        info.total = num;
+      }
+      break;
+    }
+  }
+  if (typeof source.version === "string") {
+    info.version = source.version;
+  }
+  info.author = {
+    name: getSourceNestedString(
+      "author",
+      "name",
+      typeof source.author === "string" ? source.author : ""
+    )
+  };
+  if (typeof source.author === "object") {
+    const sourceAuthor = source.author;
+    if (typeof sourceAuthor.url === "string") {
+      info.author.url = sourceAuthor.url;
+    }
+  }
+  info.license = {
+    title: getSourceNestedString(
+      "license",
+      "title",
+      typeof source.license === "string" ? source.license : ""
+    )
+  };
+  if (typeof source.license === "object") {
+    const sourceLicense = source.license;
+    if (typeof sourceLicense.spdx === "string") {
+      info.license.spdx = sourceLicense.spdx;
+    }
+    if (typeof sourceLicense.url === "string") {
+      info.license.url = sourceLicense.url;
+    }
+  }
+  if (source.samples instanceof Array) {
+    const samples = [];
+    source.samples.forEach((item) => {
+      if (typeof item === "string" && !samples.includes(item)) {
+        samples.push(item);
+      }
+    });
+    if (samples.length) {
+      info.samples = samples;
+    }
+  }
+  if (typeof source.height === "number" || typeof source.height === "string") {
+    const num = parseInt(source.height);
+    if (num > 0) {
+      info.height = num;
+    }
+  }
+  if (source.height instanceof Array) {
+    source.height.forEach((item) => {
+      const num = parseInt(item);
+      if (num > 0) {
+        if (!(info.height instanceof Array)) {
+          info.height = [];
+        }
+        info.height.push(num);
+      }
+    });
+    switch (info.height.length) {
+      case 0:
+        delete info.height;
+        break;
+      case 1:
+        info.height = info.height[0];
+    }
+  }
+  if (typeof info.height === "number") {
+    const displayHeight = validateDisplayHeight(info.height);
+    if (displayHeight && displayHeight !== info.height) {
+      info.displayHeight = displayHeight;
+    }
+  }
+  ["samplesHeight", "displayHeight"].forEach((prop) => {
+    const value = source[prop];
+    if (typeof value === "number" || typeof value === "string") {
+      const displayHeight = validateDisplayHeight(
+        parseInt(value)
+      );
+      if (displayHeight) {
+        info.displayHeight = displayHeight;
+      }
+    }
+  });
+  if (typeof source.category === "string") {
+    info.category = source.category;
+  }
+  if (source.tags instanceof Array) {
+    info.tags = source.tags;
+  }
+  switch (typeof source.palette) {
+    case "boolean":
+      info.palette = source.palette;
+      break;
+    case "string":
+      switch (source.palette.toLowerCase()) {
+        case "colorless":
+        case "false":
+          info.palette = false;
+          break;
+        case "colorful":
+        case "true":
+          info.palette = true;
+      }
+      break;
+  }
+  if (source.hidden === true) {
+    info.hidden = true;
+  }
+  Object.keys(source).forEach((key) => {
+    const value = source[key];
+    if (typeof value !== "string") {
+      return;
+    }
+    switch (key) {
+      case "url":
+      case "uri":
+        info.author.url = value;
+        break;
+      case "licenseURL":
+      case "licenseURI":
+        info.license.url = value;
+        break;
+      case "licenseID":
+      case "licenseSPDX":
+        info.license.spdx = value;
+        break;
+    }
+  });
+  return info;
+}
+
+export { convertIconSetInfo };

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

@@ -0,0 +1,22 @@
+import { defaultIconDimensions } from '../icon/defaults.mjs';
+
+function expandIconSet(data) {
+  const icons = Object.keys(data.icons);
+  Object.keys(
+    defaultIconDimensions
+  ).forEach((prop) => {
+    if (typeof data[prop] !== typeof defaultIconDimensions[prop]) {
+      return;
+    }
+    const value = data[prop];
+    icons.forEach((name) => {
+      const item = data.icons[name];
+      if (!(prop in item)) {
+        item[prop] = value;
+      }
+    });
+    delete data[prop];
+  });
+}
+
+export { expandIconSet };

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

@@ -0,0 +1,28 @@
+import { mergeIconData } from '../icon/merge.mjs';
+import { getIconsTree } from './tree.mjs';
+import '../icon/defaults.mjs';
+import '../icon/transformations.mjs';
+
+function internalGetIconData(data, name, tree) {
+  const icons = data.icons;
+  const aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  let currentProps = {};
+  function parse(name2) {
+    currentProps = mergeIconData(
+      icons[name2] || aliases[name2],
+      currentProps
+    );
+  }
+  parse(name);
+  tree.forEach(parse);
+  return mergeIconData(data, currentProps);
+}
+function getIconData(data, name) {
+  if (data.icons[name]) {
+    return internalGetIconData(data, name, []);
+  }
+  const tree = getIconsTree(data, [name])[name];
+  return tree ? internalGetIconData(data, name, tree) : null;
+}
+
+export { getIconData, internalGetIconData };

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

@@ -0,0 +1,46 @@
+import { defaultIconDimensions } from '../icon/defaults.mjs';
+import { getIconsTree } from './tree.mjs';
+
+const propsToCopy = Object.keys(defaultIconDimensions).concat([
+  "provider"
+]);
+function getIcons(data, names, not_found) {
+  const icons = /* @__PURE__ */ Object.create(null);
+  const aliases = /* @__PURE__ */ Object.create(null);
+  const result = {
+    prefix: data.prefix,
+    icons
+  };
+  const sourceIcons = data.icons;
+  const sourceAliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  if (data.lastModified) {
+    result.lastModified = data.lastModified;
+  }
+  const tree = getIconsTree(data, names);
+  let empty = true;
+  for (const name in tree) {
+    if (!tree[name]) {
+      if (not_found && names.indexOf(name) !== -1) {
+        (result.not_found || (result.not_found = [])).push(name);
+      }
+    } else if (sourceIcons[name]) {
+      icons[name] = {
+        ...sourceIcons[name]
+      };
+      empty = false;
+    } else {
+      aliases[name] = {
+        ...sourceAliases[name]
+      };
+      result.aliases = aliases;
+    }
+  }
+  propsToCopy.forEach((attr) => {
+    if (attr in data) {
+      result[attr] = data[attr];
+    }
+  });
+  return empty && not_found !== true ? null : result;
+}
+
+export { getIcons, propsToCopy };

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

@@ -0,0 +1,66 @@
+import { defaultIconDimensions } from '../icon/defaults.mjs';
+
+function minifyIconSet(data) {
+  const icons = Object.keys(data.icons);
+  Object.keys(
+    defaultIconDimensions
+  ).forEach((prop) => {
+    if (data[prop] === defaultIconDimensions[prop]) {
+      delete data[prop];
+    }
+    const defaultValue = defaultIconDimensions[prop];
+    const propType = typeof defaultValue;
+    const hasMinifiedDefault = typeof data[prop] === propType && data[prop] !== defaultValue;
+    let maxCount = 0;
+    let maxValue = null;
+    const counters = /* @__PURE__ */ new Map();
+    for (let i = 0; i < icons.length; i++) {
+      const item = data.icons[icons[i]];
+      let value;
+      if (typeof item[prop] === propType) {
+        value = item[prop];
+      } else if (hasMinifiedDefault) {
+        value = data[prop];
+      } else {
+        value = defaultIconDimensions[prop];
+      }
+      if (i === 0) {
+        maxCount = 1;
+        maxValue = value;
+        counters.set(value, 1);
+        continue;
+      }
+      if (!counters.has(value)) {
+        counters.set(value, 1);
+        continue;
+      }
+      const count = counters.get(value) + 1;
+      counters.set(value, count);
+      if (count > maxCount) {
+        maxCount = count;
+        maxValue = value;
+      }
+    }
+    const canMinify = maxValue !== null && maxCount > 1;
+    const oldDefault = hasMinifiedDefault ? data[prop] : null;
+    const newDefault = canMinify ? maxValue : oldDefault;
+    if (newDefault === defaultValue) {
+      delete data[prop];
+    } else if (canMinify) {
+      data[prop] = newDefault;
+    }
+    icons.forEach((key) => {
+      const item = data.icons[key];
+      const value = prop in item ? item[prop] : hasMinifiedDefault ? oldDefault : defaultValue;
+      if (value === newDefault || newDefault === null && value === defaultValue) {
+        delete item[prop];
+        return;
+      }
+      if (canMinify && !(prop in item)) {
+        item[prop] = value;
+      }
+    });
+  });
+}
+
+export { minifyIconSet };

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

@@ -0,0 +1,51 @@
+import { internalGetIconData } from './get-icon.mjs';
+import { getIconsTree } from './tree.mjs';
+import '../icon/merge.mjs';
+import '../icon/defaults.mjs';
+import '../icon/transformations.mjs';
+
+function parseIconSet(data, callback) {
+  const names = [];
+  if (typeof data !== "object" || typeof data.icons !== "object") {
+    return names;
+  }
+  if (data.not_found instanceof Array) {
+    data.not_found.forEach((name) => {
+      callback(name, null);
+      names.push(name);
+    });
+  }
+  const tree = getIconsTree(data);
+  for (const name in tree) {
+    const item = tree[name];
+    if (item) {
+      callback(name, internalGetIconData(data, name, item));
+      names.push(name);
+    }
+  }
+  return names;
+}
+async function parseIconSetAsync(data, callback) {
+  const names = [];
+  if (typeof data !== "object" || typeof data.icons !== "object") {
+    return names;
+  }
+  if (data.not_found instanceof Array) {
+    for (let i = 0; i < data.not_found.length; i++) {
+      const name = data.not_found[i];
+      await callback(name, null);
+      names.push(name);
+    }
+  }
+  const tree = getIconsTree(data);
+  for (const name in tree) {
+    const item = tree[name];
+    if (item) {
+      await callback(name, internalGetIconData(data, name, item));
+      names.push(name);
+    }
+  }
+  return names;
+}
+
+export { parseIconSet, parseIconSetAsync };