@qelos/aidev 0.11.0 → 1.0.0

package/ui/.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 };

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

@@ -0,0 +1,113 @@
+import { createUTF16EmojiRegexItem, createOptionalEmojiRegexItem, createSequenceEmojiRegexItem, createSetEmojiRegexItem } from './base.mjs';
+import { splitEmojiSequences } from '../cleanup.mjs';
+import { convertEmojiSequenceToUTF32 } from '../convert.mjs';
+import { createRegexForNumbersSequence } from './numbers.mjs';
+import { joinerEmoji } from '../data.mjs';
+import { mergeSimilarItemsInSet } from './similar.mjs';
+
+function createEmojisTree(sequences) {
+  const root = [];
+  for (let i = 0; i < sequences.length; i++) {
+    const split = splitEmojiSequences(
+      convertEmojiSequenceToUTF32(sequences[i])
+    );
+    let parent = root;
+    for (let j = 0; j < split.length; j++) {
+      const regex = createRegexForNumbersSequence(split[j]);
+      let item;
+      const match = parent.find(
+        (item2) => item2.regex.regex === regex.regex
+      );
+      if (!match) {
+        item = {
+          regex
+        };
+        parent.push(item);
+      } else {
+        item = match;
+      }
+      if (j === split.length - 1) {
+        item.end = true;
+        break;
+      }
+      parent = item.children || (item.children = []);
+    }
+  }
+  return root;
+}
+function parseEmojiTree(items) {
+  function mergeParsedChildren(items2) {
+    const parsedItems = [];
+    const mapWithoutEnd = /* @__PURE__ */ Object.create(null);
+    const mapWithEnd = /* @__PURE__ */ Object.create(null);
+    for (let i = 0; i < items2.length; i++) {
+      const item = items2[i];
+      const children = item.children;
+      if (children) {
+        const fullItem = item;
+        const target = item.end ? mapWithEnd : mapWithoutEnd;
+        const regex = children.regex;
+        if (!target[regex]) {
+          target[regex] = [fullItem];
+        } else {
+          target[regex].push(fullItem);
+        }
+      } else {
+        parsedItems.push(item.regex);
+      }
+    }
+    [mapWithEnd, mapWithoutEnd].forEach((source) => {
+      for (const regex in source) {
+        const items3 = source[regex];
+        const firstItem = items3[0];
+        let childSequence = [
+          createUTF16EmojiRegexItem([joinerEmoji]),
+          firstItem.children
+        ];
+        if (firstItem.end) {
+          childSequence = [
+            createOptionalEmojiRegexItem(
+              createSequenceEmojiRegexItem(childSequence)
+            )
+          ];
+        }
+        let mergedRegex;
+        if (items3.length === 1) {
+          mergedRegex = firstItem.regex;
+        } else {
+          mergedRegex = mergeSimilarItemsInSet(
+            createSetEmojiRegexItem(items3.map((item) => item.regex))
+          );
+        }
+        const sequence = createSequenceEmojiRegexItem([
+          mergedRegex,
+          ...childSequence
+        ]);
+        parsedItems.push(sequence);
+      }
+    });
+    if (parsedItems.length === 1) {
+      return parsedItems[0];
+    }
+    const set = createSetEmojiRegexItem(parsedItems);
+    const result = mergeSimilarItemsInSet(set);
+    return result;
+  }
+  function parseItemChildren(item) {
+    const result = {
+      regex: item.regex,
+      end: !!item.end
+    };
+    const children = item.children;
+    if (!children) {
+      return result;
+    }
+    const parsedChildren = children.map(parseItemChildren);
+    result.children = mergeParsedChildren(parsedChildren);
+    return result;
+  }
+  const parsed = items.map(parseItemChildren);
+  return mergeParsedChildren(parsed);
+}
+
+export { createEmojisTree, parseEmojiTree };

package/ui/.output/server/node_modules/@iconify/utils/lib/emoji/replace/find.mjs

@@ -0,0 +1,104 @@
+import { convertEmojiSequenceToUTF32 } from '../convert.mjs';
+import { vs16Emoji } from '../data.mjs';
+import { getEmojiSequenceKeyword } from '../format.mjs';
+
+function createEmojiRegExp(regexp) {
+  return new RegExp(regexp, "g");
+}
+function getEmojiMatchesInText(regexp, content) {
+  const results = [];
+  const found = /* @__PURE__ */ new Set();
+  (regexp instanceof Array ? regexp : [regexp]).forEach((regexp2, index) => {
+    const matches = content.match(
+      typeof regexp2 === "string" ? createEmojiRegExp(regexp2) : regexp2
+    );
+    if (matches) {
+      for (let i = 0; i < matches.length; i++) {
+        const match = matches[i];
+        if (found.has(match)) {
+          continue;
+        }
+        found.add(match);
+        const sequence = [];
+        for (const codePoint of match) {
+          const num = codePoint.codePointAt(0);
+          if (num !== vs16Emoji) {
+            sequence.push(num);
+          }
+        }
+        results.push({
+          match,
+          sequence,
+          keyword: getEmojiSequenceKeyword(
+            convertEmojiSequenceToUTF32(sequence)
+          ),
+          regexp: index
+        });
+      }
+    }
+  });
+  results.sort((a, b) => {
+    const match1 = a.match;
+    const match2 = b.match;
+    if (match2.length === match1.length) {
+      return match1.localeCompare(match2);
+    }
+    return match2.length - match1.length;
+  });
+  return results;
+}
+function sortEmojiMatchesInText(content, matches) {
+  const ranges = [];
+  const check = (start, end) => {
+    for (let i = 0; i < ranges.length; i++) {
+      if (start < ranges[i].end && end > ranges[i].start) {
+        return false;
+      }
+    }
+    return true;
+  };
+  for (let i = 0; i < matches.length; i++) {
+    const match = matches[i];
+    const search = match.match;
+    let startFrom = 0;
+    let start;
+    while ((start = content.indexOf(search, startFrom)) !== -1) {
+      const end = start + search.length;
+      startFrom = end;
+      if (check(start, end)) {
+        ranges.push({
+          start,
+          end,
+          match
+        });
+      }
+    }
+  }
+  ranges.sort((a, b) => a.start - b.start);
+  const list = [];
+  let prevRange;
+  let lastEnd;
+  for (let i = 0; i < ranges.length; i++) {
+    const range = ranges[i];
+    const prev = content.slice(prevRange ? prevRange.end : 0, range.start);
+    list.push({
+      match: range.match,
+      prev
+    });
+    prevRange = range;
+    lastEnd = range.end;
+  }
+  if (!lastEnd) {
+    return [];
+  }
+  const replacements = list.map((item, index) => {
+    const nextItem = list[index + 1];
+    return {
+      ...item,
+      next: nextItem ? nextItem.prev : content.slice(lastEnd)
+    };
+  });
+  return replacements;
+}
+
+export { createEmojiRegExp, getEmojiMatchesInText, sortEmojiMatchesInText };

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

@@ -0,0 +1,34 @@
+import { getEmojiMatchesInText, sortEmojiMatchesInText } from './find.mjs';
+import '../convert.mjs';
+import '../data.mjs';
+import '../format.mjs';
+
+function findAndReplaceEmojisInText(regexp, content, callback) {
+  const matches = getEmojiMatchesInText(regexp, content);
+  if (!matches.length) {
+    return null;
+  }
+  const sortedMatches = sortEmojiMatchesInText(content, matches);
+  let result = "";
+  let replaced = false;
+  for (let i = 0; i < sortedMatches.length; i++) {
+    const item = sortedMatches[i];
+    result += item.prev;
+    const replacement = callback(
+      {
+        ...item.match
+      },
+      result
+    );
+    if (replacement === void 0) {
+      result += item.match.match;
+    } else {
+      result += replacement;
+      replaced = true;
+    }
+  }
+  result += sortedMatches[sortedMatches.length - 1].next;
+  return replaced ? result : null;
+}
+
+export { findAndReplaceEmojisInText };

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

@@ -0,0 +1,75 @@
+import { emojiComponents } from '../data.mjs';
+import { getEmojiSequenceKeyword } from '../format.mjs';
+import '../convert.mjs';
+
+function mapEmojiTestDataComponents(testSequences) {
+  const results = {
+    converted: /* @__PURE__ */ new Map(),
+    items: /* @__PURE__ */ new Map(),
+    names: /* @__PURE__ */ new Map(),
+    types: {},
+    keywords: {}
+  };
+  for (const key in emojiComponents) {
+    const type = key;
+    const range = emojiComponents[type];
+    for (let number = range[0]; number < range[1]; number++) {
+      const keyword = getEmojiSequenceKeyword([number]);
+      const item = testSequences[keyword];
+      if (!item) {
+        throw new Error(
+          `Missing emoji component in test sequence: "${keyword}"`
+        );
+      }
+      results.converted.set(number, keyword);
+      results.items.set(number, item);
+      results.items.set(keyword, item);
+      const name = item.name;
+      results.names.set(number, name);
+      results.names.set(keyword, name);
+      results.types[name] = type;
+      results.keywords[name] = keyword;
+    }
+  }
+  return results;
+}
+function emojiSequenceWithComponentsToString(sequence) {
+  return sequence.map((item) => typeof item === "number" ? item.toString(16) : item).join("-");
+}
+function findEmojiComponentsInSequence(sequence) {
+  const components = [];
+  for (let index = 0; index < sequence.length; index++) {
+    const code = sequence[index];
+    for (const key in emojiComponents) {
+      const type = key;
+      const range = emojiComponents[type];
+      if (code >= range[0] && code < range[1]) {
+        components.push({
+          index,
+          type
+        });
+        break;
+      }
+    }
+  }
+  return components;
+}
+function replaceEmojiComponentsInCombinedSequence(sequence, values) {
+  const indexes = {
+    "hair-style": 0,
+    "skin-tone": 0
+  };
+  return sequence.map((item) => {
+    if (typeof item === "number") {
+      return item;
+    }
+    const index = indexes[item]++;
+    const list = values[item];
+    if (!list || !list.length) {
+      throw new Error(`Cannot replace ${item}: no valid values provided`);
+    }
+    return list[index >= list.length ? list.length - 1 : index];
+  });
+}
+
+export { emojiSequenceWithComponentsToString, findEmojiComponentsInSequence, mapEmojiTestDataComponents, replaceEmojiComponentsInCombinedSequence };

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

@@ -0,0 +1,97 @@
+import { getUnqualifiedEmojiSequence } from '../cleanup.mjs';
+import { emojiComponents } from '../data.mjs';
+import { getEmojiSequenceKeyword } from '../format.mjs';
+import { replaceEmojiComponentsInCombinedSequence } from './components.mjs';
+import '../convert.mjs';
+
+function findMissingEmojis(sequences, testDataTree) {
+  const results = [];
+  const existingItems = /* @__PURE__ */ Object.create(null);
+  const copiedItems = /* @__PURE__ */ Object.create(null);
+  sequences.forEach((item) => {
+    const sequence = getUnqualifiedEmojiSequence(item.sequence);
+    const key = getEmojiSequenceKeyword(sequence);
+    if (!existingItems[key] || // If multiple matches for same sequence exist, use longest version
+    existingItems[key].sequence.length < item.sequence.length) {
+      existingItems[key] = item;
+    }
+  });
+  const iterate = (type, parentTree, parentValues, parentItem, deep) => {
+    const childTree = parentTree.children?.[type];
+    if (!childTree) {
+      return;
+    }
+    const range = emojiComponents[type];
+    for (let number = range[0]; number < range[1]; number++) {
+      const values = {
+        "hair-style": [...parentValues["hair-style"]],
+        "skin-tone": [...parentValues["skin-tone"]]
+      };
+      values[type].push(number);
+      const sequence = replaceEmojiComponentsInCombinedSequence(
+        childTree.item.sequence,
+        values
+      );
+      const key = getEmojiSequenceKeyword(
+        getUnqualifiedEmojiSequence(sequence)
+      );
+      const oldItem = existingItems[key];
+      let item;
+      if (oldItem) {
+        item = oldItem;
+      } else {
+        item = copiedItems[key];
+        if (!item) {
+          item = {
+            ...parentItem,
+            sequence
+          };
+          if (item.sequenceKey) {
+            item.sequenceKey = key;
+          }
+          copiedItems[key] = item;
+          results.push(item);
+        }
+      }
+      if (deep || oldItem) {
+        for (const key2 in values) {
+          iterate(
+            key2,
+            childTree,
+            values,
+            item,
+            deep
+          );
+        }
+      }
+    }
+  };
+  const parse = (key, deep) => {
+    const treeItem = testDataTree[key];
+    const sequenceKey = treeItem.item.sequenceKey;
+    const rootItem = existingItems[sequenceKey];
+    if (!rootItem) {
+      return;
+    }
+    const values = {
+      "skin-tone": [],
+      "hair-style": []
+    };
+    for (const key2 in values) {
+      iterate(
+        key2,
+        treeItem,
+        values,
+        rootItem,
+        deep
+      );
+    }
+  };
+  for (const key in testDataTree) {
+    parse(key, false);
+    parse(key, true);
+  }
+  return results;
+}
+
+export { findMissingEmojis };

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

@@ -0,0 +1,54 @@
+import { emojiComponents } from '../data.mjs';
+
+const nameSplit = ": ";
+const variationSplit = ", ";
+const ignoredVariations = /* @__PURE__ */ new Set(["person"]);
+function splitEmojiNameVariations(name, sequence, componentsData) {
+  const parts = name.split(nameSplit);
+  const base = parts.shift();
+  if (!parts.length) {
+    return {
+      base,
+      key: base
+    };
+  }
+  const baseVariations = parts.join(nameSplit).split(variationSplit).filter((text) => {
+    const type = componentsData.types[text];
+    if (!type) {
+      return !ignoredVariations.has(text);
+    }
+    return false;
+  });
+  const key = base + (baseVariations.length ? nameSplit + baseVariations.join(variationSplit) : "");
+  const result = {
+    base,
+    key
+  };
+  let components = 0;
+  const variations = [
+    ...baseVariations
+  ];
+  for (let index = 0; index < sequence.length; index++) {
+    const num = sequence[index];
+    for (const key2 in emojiComponents) {
+      const type = key2;
+      const range = emojiComponents[type];
+      if (num >= range[0] && num < range[1]) {
+        variations.push({
+          index,
+          type
+        });
+        components++;
+      }
+    }
+  }
+  if (variations.length) {
+    result.variations = variations;
+  }
+  if (components) {
+    result.components = components;
+  }
+  return result;
+}
+
+export { splitEmojiNameVariations };