orcaq 1.0.20

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

@@ -0,0 +1,231 @@
+function toString(number) {
+  if (number < 255) {
+    if (number > 32 && number < 127) {
+      const char = String.fromCharCode(number);
+      if (
+        // 0-9
+        number > 47 && number < 58 || // A-Z
+        number > 64 && number < 91 || // _`a-z
+        number > 94 && number < 123
+      ) {
+        return char;
+      }
+      return "\\" + char;
+    }
+    return "\\x" + (number < 16 ? "0" : "") + number.toString(16).toUpperCase();
+  }
+  return "\\u" + number.toString(16).toUpperCase();
+}
+function wrapRegexInGroup(regex) {
+  return "(?:" + regex + ")";
+}
+function updateUTF16EmojiRegexItem(item) {
+  const numbers = item.numbers;
+  if (numbers.length === 1) {
+    const num = numbers[0];
+    return item.regex = toString(num);
+  }
+  numbers.sort((a, b) => a - b);
+  const chars = [];
+  let range = null;
+  const addRange = () => {
+    if (range) {
+      const { start, last, numbers: numbers2 } = range;
+      range = null;
+      if (last > start + 1) {
+        chars.push(toString(start) + "-" + toString(last));
+      } else {
+        for (let i = 0; i < numbers2.length; i++) {
+          chars.push(toString(numbers2[i]));
+        }
+      }
+    }
+  };
+  for (let i = 0; i < numbers.length; i++) {
+    const num = numbers[i];
+    if (range) {
+      if (range.last === num) {
+        continue;
+      }
+      if (range.last === num - 1) {
+        range.numbers.push(num);
+        range.last = num;
+        continue;
+      }
+    }
+    addRange();
+    range = {
+      start: num,
+      last: num,
+      numbers: [num]
+    };
+  }
+  addRange();
+  if (!chars.length) {
+    throw new Error("Unexpected empty range");
+  }
+  return item.regex = "[" + chars.join("") + "]";
+}
+function createUTF16EmojiRegexItem(numbers) {
+  const result = {
+    type: "utf16",
+    regex: "",
+    numbers,
+    length: 1,
+    group: true
+  };
+  updateUTF16EmojiRegexItem(result);
+  return result;
+}
+function updateSequenceEmojiRegexItem(item) {
+  return item.regex = item.items.map((childItem) => {
+    if (!childItem.group && childItem.type === "set") {
+      return wrapRegexInGroup(childItem.regex);
+    }
+    return childItem.regex;
+  }).join("");
+}
+function createSequenceEmojiRegexItem(sequence, numbers) {
+  let items = [];
+  sequence.forEach((item) => {
+    if (item.type === "sequence") {
+      items = items.concat(item.items);
+    } else {
+      items.push(item);
+    }
+  });
+  if (!items.length) {
+    throw new Error("Empty sequence");
+  }
+  const result = {
+    type: "sequence",
+    items,
+    regex: "",
+    length: items.reduce((length, item) => item.length + length, 0),
+    group: false
+  };
+  if (sequence.length === 1) {
+    const firstItem = sequence[0];
+    result.group = firstItem.group;
+    if (firstItem.type !== "optional") {
+      const numbers2 = firstItem.numbers;
+      if (numbers2) {
+        result.numbers = numbers2;
+      }
+    }
+  }
+  if (numbers) {
+    result.numbers = numbers;
+  }
+  updateSequenceEmojiRegexItem(result);
+  return result;
+}
+function updateSetEmojiRegexItem(item) {
+  if (item.sets.length === 1) {
+    const firstItem = item.sets[0];
+    item.group = firstItem.group;
+    return item.regex = firstItem.regex;
+  }
+  item.group = false;
+  return item.regex = item.sets.map((childItem) => childItem.regex).join("|");
+}
+function createSetEmojiRegexItem(set) {
+  let sets = [];
+  let numbers = [];
+  set.forEach((item) => {
+    if (item.type === "set") {
+      sets = sets.concat(item.sets);
+    } else {
+      sets.push(item);
+    }
+    if (numbers) {
+      if (item.type === "optional" || !item.numbers) {
+        numbers = null;
+      } else {
+        numbers = [...numbers, ...item.numbers];
+      }
+    }
+  });
+  sets.sort((a, b) => {
+    if (a.length === b.length) {
+      return a.regex.localeCompare(b.regex);
+    }
+    return b.length - a.length;
+  });
+  const result = {
+    type: "set",
+    sets,
+    regex: "",
+    length: sets.reduce(
+      (length, item) => length ? Math.min(length, item.length) : item.length,
+      0
+    ),
+    group: false
+  };
+  if (numbers) {
+    result.numbers = numbers;
+  }
+  if (set.length === 1) {
+    const firstItem = set[0];
+    result.group = firstItem.group;
+  }
+  updateSetEmojiRegexItem(result);
+  return result;
+}
+function updateOptionalEmojiRegexItem(item) {
+  const childItem = item.item;
+  const regex = (childItem.group ? childItem.regex : wrapRegexInGroup(childItem.regex)) + "?";
+  return item.regex = regex;
+}
+function createOptionalEmojiRegexItem(item) {
+  if (item.type === "optional") {
+    return item;
+  }
+  const result = {
+    type: "optional",
+    item,
+    regex: "",
+    length: item.length,
+    group: true
+  };
+  updateOptionalEmojiRegexItem(result);
+  return result;
+}
+function cloneEmojiRegexItem(item, shallow = false) {
+  const result = {
+    ...item
+  };
+  if (result.type !== "optional" && result.numbers) {
+    result.numbers = [...result.numbers];
+  }
+  switch (result.type) {
+    case "utf16":
+      break;
+    case "sequence":
+      if (shallow) {
+        result.items = [...result.items];
+      } else {
+        result.items = result.items.map(
+          (item2) => cloneEmojiRegexItem(item2, false)
+        );
+      }
+      break;
+    case "set":
+      if (shallow) {
+        result.sets = [...result.sets];
+      } else {
+        result.sets = result.sets.map(
+          (item2) => cloneEmojiRegexItem(item2, false)
+        );
+      }
+      break;
+    case "optional":
+      if (!shallow) {
+        result.item = cloneEmojiRegexItem(result.item, false);
+      }
+      break;
+  }
+  return result;
+}
+
+export { cloneEmojiRegexItem, createOptionalEmojiRegexItem, createSequenceEmojiRegexItem, createSetEmojiRegexItem, createUTF16EmojiRegexItem, updateOptionalEmojiRegexItem, updateSequenceEmojiRegexItem, updateSetEmojiRegexItem, updateUTF16EmojiRegexItem, wrapRegexInGroup };

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

@@ -0,0 +1,31 @@
+import { getSequenceFromEmojiStringOrKeyword } from '../cleanup.mjs';
+import { convertEmojiSequenceToUTF32 } from '../convert.mjs';
+import { getQualifiedEmojiVariations } from '../test/variations.mjs';
+import { createEmojisTree, parseEmojiTree } from './tree.mjs';
+import '../data.mjs';
+import '../format.mjs';
+import './base.mjs';
+import './numbers.mjs';
+import './similar.mjs';
+
+function createOptimisedRegexForEmojiSequences(sequences) {
+  sequences = sequences.map((item) => convertEmojiSequenceToUTF32(item));
+  const tree = createEmojisTree(sequences);
+  const regex = parseEmojiTree(tree);
+  return regex.regex;
+}
+function createOptimisedRegex(emojis) {
+  let sequences = emojis.map(
+    (item) => typeof item === "string" ? getSequenceFromEmojiStringOrKeyword(item) : item
+  );
+  sequences = getQualifiedEmojiVariations(
+    sequences.map((sequence) => {
+      return {
+        sequence
+      };
+    })
+  ).map((item) => item.sequence);
+  return createOptimisedRegexForEmojiSequences(sequences);
+}
+
+export { createOptimisedRegex, createOptimisedRegexForEmojiSequences };

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

@@ -0,0 +1,164 @@
+import { splitUTF32Number } from '../convert.mjs';
+import { createUTF16EmojiRegexItem, createSequenceEmojiRegexItem, createSetEmojiRegexItem, createOptionalEmojiRegexItem } from './base.mjs';
+import { vs16Emoji } from '../data.mjs';
+
+function createEmojiRegexItemForNumbers(numbers) {
+  const utf32 = [];
+  const utf16 = [];
+  numbers.sort((a, b) => a - b);
+  let lastNumber;
+  for (let i = 0; i < numbers.length; i++) {
+    const number = numbers[i];
+    if (number === lastNumber) {
+      continue;
+    }
+    lastNumber = number;
+    const split = splitUTF32Number(number);
+    if (!split) {
+      utf16.push(number);
+      continue;
+    }
+    const [first, second] = split;
+    const item = utf32.find((item2) => item2.first === first);
+    if (item) {
+      item.second.push(second);
+      item.numbers.push(number);
+    } else {
+      utf32.push({
+        first,
+        second: [second],
+        numbers: [number]
+      });
+    }
+  }
+  const results = [];
+  if (utf16.length) {
+    results.push(createUTF16EmojiRegexItem(utf16));
+  }
+  if (utf32.length) {
+    const utf32Set = [];
+    for (let i = 0; i < utf32.length; i++) {
+      const item = utf32[i];
+      const secondRegex = createUTF16EmojiRegexItem(item.second);
+      const listItem = utf32Set.find(
+        (item2) => item2.second.regex === secondRegex.regex
+      );
+      if (listItem) {
+        listItem.first.push(item.first);
+        listItem.numbers = [...listItem.numbers, ...item.numbers];
+      } else {
+        utf32Set.push({
+          second: secondRegex,
+          first: [item.first],
+          numbers: [...item.numbers]
+        });
+      }
+    }
+    for (let i = 0; i < utf32Set.length; i++) {
+      const item = utf32Set[i];
+      const firstRegex = createUTF16EmojiRegexItem(item.first);
+      const secondRegex = item.second;
+      results.push(
+        createSequenceEmojiRegexItem(
+          [firstRegex, secondRegex],
+          item.numbers
+        )
+      );
+    }
+  }
+  return results.length === 1 ? results[0] : createSetEmojiRegexItem(results);
+}
+function createRegexForNumbersSequence(numbers, optionalVariations = true) {
+  const items = [];
+  for (let i = 0; i < numbers.length; i++) {
+    const num = numbers[i];
+    const split = splitUTF32Number(num);
+    if (!split) {
+      const item = createUTF16EmojiRegexItem([num]);
+      if (optionalVariations && num === vs16Emoji) {
+        items.push(createOptionalEmojiRegexItem(item));
+      } else {
+        items.push(item);
+      }
+    } else {
+      items.push(createUTF16EmojiRegexItem([split[0]]));
+      items.push(createUTF16EmojiRegexItem([split[1]]));
+    }
+  }
+  if (items.length === 1) {
+    return items[0];
+  }
+  const result = createSequenceEmojiRegexItem(items);
+  if (numbers.length === 1 && items[0].type === "utf16") {
+    result.numbers = [...numbers];
+  }
+  return result;
+}
+function optimiseNumbersSet(set) {
+  const mandatoryMatches = {
+    numbers: [],
+    items: []
+  };
+  const optionalMatches = {
+    numbers: [],
+    items: []
+  };
+  const filteredItems = set.sets.filter((item) => {
+    if (item.type === "optional") {
+      const parentItem = item.item;
+      if (parentItem.numbers) {
+        optionalMatches.items.push(item);
+        optionalMatches.numbers = optionalMatches.numbers.concat(
+          parentItem.numbers
+        );
+        return false;
+      }
+      return true;
+    }
+    if (item.numbers) {
+      mandatoryMatches.items.push(item);
+      mandatoryMatches.numbers = mandatoryMatches.numbers.concat(
+        item.numbers
+      );
+      return false;
+    }
+    return true;
+  });
+  if (mandatoryMatches.items.length + optionalMatches.items.length < 2) {
+    return set;
+  }
+  const optionalNumbers = new Set(optionalMatches.numbers);
+  let foundMatches = false;
+  mandatoryMatches.numbers = mandatoryMatches.numbers.filter((number) => {
+    if (optionalNumbers.has(number)) {
+      foundMatches = true;
+      return false;
+    }
+    return true;
+  });
+  if (mandatoryMatches.items.length) {
+    if (!foundMatches && mandatoryMatches.items.length === 1) {
+      filteredItems.push(mandatoryMatches.items[0]);
+    } else if (mandatoryMatches.numbers.length) {
+      filteredItems.push(
+        createEmojiRegexItemForNumbers(mandatoryMatches.numbers)
+      );
+    }
+  }
+  switch (optionalMatches.items.length) {
+    case 0:
+      break;
+    case 1:
+      filteredItems.push(optionalMatches.items[0]);
+      break;
+    default:
+      filteredItems.push(
+        createOptionalEmojiRegexItem(
+          createEmojiRegexItemForNumbers(optionalMatches.numbers)
+        )
+      );
+  }
+  return filteredItems.length === 1 ? filteredItems[0] : createSetEmojiRegexItem(filteredItems);
+}
+
+export { createEmojiRegexItemForNumbers, createRegexForNumbersSequence, optimiseNumbersSet };

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

@@ -0,0 +1,216 @@
+import { createSequenceEmojiRegexItem, createSetEmojiRegexItem, createOptionalEmojiRegexItem, cloneEmojiRegexItem } from './base.mjs';
+import { optimiseNumbersSet } from './numbers.mjs';
+import '../convert.mjs';
+import '../data.mjs';
+
+function findSimilarRegexItemSequences(items) {
+  const startRegex = /* @__PURE__ */ Object.create(null);
+  const endRegex = /* @__PURE__ */ Object.create(null);
+  const addMapItem = (target, index, regex, slice) => {
+    if (!target[regex]) {
+      target[regex] = {
+        // Start with 0. One item will remain after replacement
+        score: 0,
+        slices: [
+          {
+            index,
+            slice
+          }
+        ]
+      };
+      return;
+    }
+    const item = target[regex];
+    item.score += regex.length;
+    item.slices.push({
+      index,
+      slice
+    });
+  };
+  for (let index = 0; index < items.length; index++) {
+    const baseItem = items[index];
+    switch (baseItem.type) {
+      case "optional":
+      case "utf16": {
+        addMapItem(startRegex, index, baseItem.regex, "full");
+        addMapItem(endRegex, index, baseItem.regex, "full");
+        break;
+      }
+      case "sequence": {
+        addMapItem(startRegex, index, baseItem.regex, "full");
+        addMapItem(endRegex, index, baseItem.regex, "full");
+        const sequence = baseItem.items;
+        for (let i = 1; i < sequence.length; i++) {
+          const startSequence = createSequenceEmojiRegexItem(
+            sequence.slice(0, i)
+          );
+          addMapItem(startRegex, index, startSequence.regex, i);
+          const endSequence = createSequenceEmojiRegexItem(
+            sequence.slice(i)
+          );
+          addMapItem(endRegex, index, endSequence.regex, i);
+        }
+        break;
+      }
+      case "set":
+        throw new Error("Unexpected set within a set");
+    }
+  }
+  let result;
+  const checkResults = (target, type) => {
+    for (const regex in target) {
+      const item = target[regex];
+      if (!item.score) {
+        continue;
+      }
+      if (!result || result.score < item.score) {
+        result = {
+          score: item.score,
+          sequences: [
+            {
+              type,
+              slices: item.slices
+            }
+          ]
+        };
+        continue;
+      }
+      if (result.score === item.score) {
+        result.sequences.push({
+          type,
+          slices: item.slices
+        });
+      }
+    }
+  };
+  checkResults(startRegex, "start");
+  checkResults(endRegex, "end");
+  return result;
+}
+function mergeSimilarRegexItemSequences(items, merge, optimise) {
+  const { type, slices } = merge;
+  const indexes = /* @__PURE__ */ new Set();
+  let hasFullSequence = false;
+  let longestMatch = 0;
+  let longestMatchIndex = -1;
+  const differentSequences = [];
+  for (let i = 0; i < slices.length; i++) {
+    const { index, slice } = slices[i];
+    const item = items[index];
+    let length;
+    if (slice === "full") {
+      hasFullSequence = true;
+      if (item.type === "sequence") {
+        length = item.items.length;
+      } else {
+        length = 1;
+      }
+    } else {
+      if (item.type !== "sequence") {
+        throw new Error(
+          `Unexpected partial match for type "${item.type}"`
+        );
+      }
+      length = type === "start" ? slice : item.items.length - slice;
+      differentSequences.push(
+        type === "start" ? item.items.slice(slice) : item.items.slice(0, slice)
+      );
+    }
+    if (length > longestMatch) {
+      longestMatchIndex = index;
+      longestMatch = length;
+    }
+    indexes.add(index);
+  }
+  if (longestMatch < 1 || longestMatchIndex < 0) {
+    throw new Error("Cannot find common sequence");
+  }
+  const commonItem = items[longestMatchIndex];
+  let sequence;
+  if (commonItem.type !== "sequence") {
+    if (longestMatch !== 1) {
+      throw new Error(
+        "Something went wrong. Cannot have long match in non-sequence"
+      );
+    }
+    sequence = [commonItem];
+  } else {
+    sequence = type === "start" ? commonItem.items.slice(0, longestMatch) : commonItem.items.slice(
+      commonItem.items.length - longestMatch
+    );
+  }
+  const setItems = [];
+  for (let i = 0; i < differentSequences.length; i++) {
+    const list = differentSequences[i];
+    if (list.length === 1) {
+      setItems.push(list[0]);
+    } else {
+      setItems.push(createSequenceEmojiRegexItem(list));
+    }
+  }
+  const set = createSetEmojiRegexItem(setItems);
+  let mergedChunk = set.sets.length === 1 ? (
+    // Do not run callback if only 1 item
+    set.sets[0]
+  ) : optimise ? (
+    // Run callback to optimise it
+    optimise(set)
+  ) : (
+    // Use set as is
+    set
+  );
+  if (hasFullSequence) {
+    mergedChunk = createOptionalEmojiRegexItem(mergedChunk);
+  }
+  sequence[type === "start" ? "push" : "unshift"](mergedChunk);
+  const results = [
+    createSequenceEmojiRegexItem(sequence),
+    ...items.filter((item, index) => !indexes.has(index))
+  ];
+  return results;
+}
+function mergeSimilarItemsInSet(set) {
+  const updatedSet = optimiseNumbersSet(set);
+  if (updatedSet.type !== "set") {
+    return updatedSet;
+  }
+  set = updatedSet;
+  let merges;
+  while (merges = findSimilarRegexItemSequences(set.sets)) {
+    const sequences = merges.sequences;
+    if (sequences.length === 1) {
+      const merged = mergeSimilarRegexItemSequences(
+        set.sets.map((item) => cloneEmojiRegexItem(item, true)),
+        sequences[0],
+        mergeSimilarItemsInSet
+      );
+      if (merged.length === 1) {
+        return merged[0];
+      }
+      set = createSetEmojiRegexItem(merged);
+      continue;
+    }
+    let newItem;
+    for (let i = 0; i < sequences.length; i++) {
+      const merged = mergeSimilarRegexItemSequences(
+        set.sets.map((item) => cloneEmojiRegexItem(item, true)),
+        sequences[i],
+        mergeSimilarItemsInSet
+      );
+      const mergedItem = merged.length === 1 ? merged[0] : createSetEmojiRegexItem(merged);
+      if (!newItem || mergedItem.regex.length < newItem.regex.length) {
+        newItem = mergedItem;
+      }
+    }
+    if (!newItem) {
+      throw new Error("Empty sequences list");
+    }
+    if (newItem.type !== "set") {
+      return newItem;
+    }
+    set = newItem;
+  }
+  return set;
+}
+
+export { findSimilarRegexItemSequences, mergeSimilarItemsInSet, mergeSimilarRegexItemSequences };