nuxt-ignis 0.5.1 → 0.5.3

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

@@ -1,216 +0,0 @@
-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/.output/server/node_modules/@iconify/utils/lib/emoji/regex/tree.mjs

@@ -1,113 +0,0 @@
-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/.output/server/node_modules/@iconify/utils/lib/emoji/replace/find.mjs

@@ -1,104 +0,0 @@
-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/.output/server/node_modules/@iconify/utils/lib/emoji/replace/replace.mjs

@@ -1,34 +0,0 @@
-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/.output/server/node_modules/@iconify/utils/lib/emoji/test/components.mjs

@@ -1,75 +0,0 @@
-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/.output/server/node_modules/@iconify/utils/lib/emoji/test/missing.mjs

@@ -1,97 +0,0 @@
-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/.output/server/node_modules/@iconify/utils/lib/emoji/test/name.mjs

@@ -1,54 +0,0 @@
-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 };