businesslens 0.2.2

package/.output/server/node_modules/@iconify/utils/lib/emoji/parse.js

@@ -0,0 +1,48 @@
+import { getEmojiSequenceFromString, getUnqualifiedEmojiSequence } from "./cleanup.js";
+import { getEmojiSequenceKeyword } from "./format.js";
+import { parseEmojiTestFile } from "./test/parse.js";
+import { getQualifiedEmojiVariations } from "./test/variations.js";
+import { findMissingEmojis } from "./test/missing.js";
+import { createOptimisedRegexForEmojiSequences } from "./regex/create.js";
+import { combineSimilarEmojiTestData } from "./test/similar.js";
+import { getEmojiTestDataTree } from "./test/tree.js";
+/**
+* Prepare emoji for icons list
+*
+* Test data should be fetched from 'https://unicode.org/Public/emoji/17.0/emoji-test.txt'
+* It is used to detect missing emojis and optimise regular expression
+*/
+function prepareEmojiForIconsList(icons, rawTestData) {
+	const testData = rawTestData ? parseEmojiTestFile(rawTestData) : void 0;
+	let iconsList = [];
+	for (const char in icons) {
+		const sequence = getEmojiSequenceFromString(char);
+		iconsList.push({
+			icon: icons[char],
+			sequence
+		});
+	}
+	iconsList = getQualifiedEmojiVariations(iconsList);
+	if (testData) iconsList = iconsList.concat(findMissingEmojis(iconsList, getEmojiTestDataTree(combineSimilarEmojiTestData(testData))));
+	const preparedIcons = iconsList.map((item) => {
+		const sequence = getEmojiSequenceKeyword(getUnqualifiedEmojiSequence(item.sequence));
+		return {
+			icon: item.icon,
+			sequence
+		};
+	});
+	return {
+		regex: createOptimisedRegexForEmojiSequences(iconsList.map((item) => item.sequence)),
+		icons: preparedIcons
+	};
+}
+/**
+* Prepare emoji for an icon set
+*
+* Test data should be fetched from 'https://unicode.org/Public/emoji/15.1/emoji-test.txt'
+* It is used to detect missing emojis and optimise regular expression
+*/
+function prepareEmojiForIconSet(iconSet, rawTestData) {
+	return prepareEmojiForIconsList(iconSet.chars || {}, rawTestData);
+}
+export { prepareEmojiForIconSet, prepareEmojiForIconsList };

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

@@ -0,0 +1,203 @@
+/**
+* Convert number to string
+*/
+function toString(number) {
+	if (number < 255) {
+		if (number > 32 && number < 127) {
+			const char = String.fromCharCode(number);
+			if (number > 47 && number < 58 || number > 64 && number < 91 || number > 94 && number < 123) return char;
+			return "\\" + char;
+		}
+		return "\\x" + (number < 16 ? "0" : "") + number.toString(16).toUpperCase();
+	}
+	return "\\u" + number.toString(16).toUpperCase();
+}
+/**
+* Typescript stuff
+*/
+function assertNever(v) {}
+/**
+* Wrap regex in group
+*/
+function wrapRegexInGroup(regex) {
+	return "(?:" + regex + ")";
+}
+/**
+* Update UTF16 item, 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 } = range;
+			range = null;
+			if (last > start + 1) chars.push(toString(start) + "-" + toString(last));
+			else for (let i = 0; i < numbers.length; i++) chars.push(toString(numbers[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("") + "]";
+}
+/**
+* Create UTF-16 regex
+*/
+function createUTF16EmojiRegexItem(numbers) {
+	const result = {
+		type: "utf16",
+		regex: "",
+		numbers,
+		length: 1,
+		group: true
+	};
+	updateUTF16EmojiRegexItem(result);
+	return result;
+}
+/**
+* Update sequence regex. Does not update group
+*/
+function updateSequenceEmojiRegexItem(item) {
+	return item.regex = item.items.map((childItem) => {
+		if (!childItem.group && childItem.type === "set") return wrapRegexInGroup(childItem.regex);
+		return childItem.regex;
+	}).join("");
+}
+/**
+* Create sequence regex
+*/
+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 numbers = firstItem.numbers;
+			if (numbers) result.numbers = numbers;
+		}
+	}
+	if (numbers) result.numbers = numbers;
+	updateSequenceEmojiRegexItem(result);
+	return result;
+}
+/**
+* Update set regex and group
+*/
+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("|");
+}
+/**
+* Create set regex
+*/
+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) result.group = set[0].group;
+	updateSetEmojiRegexItem(result);
+	return result;
+}
+/**
+* Update optional regex
+*/
+function updateOptionalEmojiRegexItem(item) {
+	const childItem = item.item;
+	return item.regex = (childItem.group ? childItem.regex : wrapRegexInGroup(childItem.regex)) + "?";
+}
+/**
+* Create optional item
+*/
+function createOptionalEmojiRegexItem(item) {
+	if (item.type === "optional") return item;
+	const result = {
+		type: "optional",
+		item,
+		regex: "",
+		length: item.length,
+		group: true
+	};
+	updateOptionalEmojiRegexItem(result);
+	return result;
+}
+/**
+* Clone item
+*/
+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((item) => cloneEmojiRegexItem(item, false));
+			break;
+		case "set":
+			if (shallow) result.sets = [...result.sets];
+			else result.sets = result.sets.map((item) => cloneEmojiRegexItem(item, false));
+			break;
+		case "optional":
+			if (!shallow) result.item = cloneEmojiRegexItem(result.item, false);
+			break;
+		default: assertNever(result);
+	}
+	return result;
+}
+export { cloneEmojiRegexItem, createOptionalEmojiRegexItem, createSequenceEmojiRegexItem, createSetEmojiRegexItem, createUTF16EmojiRegexItem, updateOptionalEmojiRegexItem, updateSequenceEmojiRegexItem, updateSetEmojiRegexItem, updateUTF16EmojiRegexItem, wrapRegexInGroup };

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

@@ -0,0 +1,33 @@
+import { convertEmojiSequenceToUTF32 } from "../convert.js";
+import { getSequenceFromEmojiStringOrKeyword } from "../cleanup.js";
+import { getQualifiedEmojiVariations } from "../test/variations.js";
+import { createEmojisTree, parseEmojiTree } from "./tree.js";
+/**
+* Create optimised regex
+*/
+function createOptimisedRegexForEmojiSequences(sequences) {
+	sequences = sequences.map((item) => convertEmojiSequenceToUTF32(item));
+	return parseEmojiTree(createEmojisTree(sequences)).regex;
+}
+/**
+* Create optimised regex for emojis
+*
+* First parameter is array of emojis, entry can be either list of
+* code points or emoji sequence as a string
+*
+* Examples of acceptable strings (case insensitive):
+* 	'1F636 200D 1F32B FE0F' - space separated UTF32 sequence
+* 	'1f636-200d-1f32b-fe0f' - dash separated UTF32 sequence
+*  'd83d-de36-200d-d83c-df2b-fe0f' - dash separated UTF16 sequence
+*  '\\uD83D\\uDE36\\u200D\\uD83C\\uDF2B\\uFE0F' - UTF16 sequence escaped with '\\u'
+*
+* All examples above refer to the same emoji and will generate the same regex result
+*/
+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.js

@@ -0,0 +1,132 @@
+import "../data.js";
+import { splitUTF32Number } from "../convert.js";
+import { createOptionalEmojiRegexItem, createSequenceEmojiRegexItem, createSetEmojiRegexItem, createUTF16EmojiRegexItem } from "./base.js";
+/**
+* Create regex item for set of numbers
+*/
+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((item) => item.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((item) => item.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);
+}
+/**
+* Create sequence of numbers
+*/
+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 === 65039) 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;
+}
+/**
+* Attempt to optimise numbers in a set
+*/
+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.js

@@ -0,0 +1,165 @@
+import { cloneEmojiRegexItem, createOptionalEmojiRegexItem, createSequenceEmojiRegexItem, createSetEmojiRegexItem } from "./base.js";
+import { optimiseNumbersSet } from "./numbers.js";
+/**
+* Typescript stuff
+*/
+function assertNever(v) {}
+/**
+* Find similar item sequences
+*
+* Returns sequence(s) with highest score. Only one of results should be
+* applied to items. If there are multiple sequences, clone items list,
+* attempt to apply each sequence, run further optimisations on each fork
+* and see which one returns better result.
+*
+* Returns undefined if no common sequences found
+*/
+function findSimilarRegexItemSequences(items) {
+	const startRegex = Object.create(null);
+	const endRegex = Object.create(null);
+	const addMapItem = (target, index, regex, slice) => {
+		if (!target[regex]) {
+			target[regex] = {
+				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");
+			default: assertNever(baseItem);
+		}
+	}
+	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;
+}
+/**
+* Merge similar sequences
+*
+* Accepts callback to run optimisation on created subset
+*/
+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 ? set.sets[0] : optimise ? optimise(set) : set;
+	if (hasFullSequence) mergedChunk = createOptionalEmojiRegexItem(mergedChunk);
+	sequence[type === "start" ? "push" : "unshift"](mergedChunk);
+	return [createSequenceEmojiRegexItem(sequence), ...items.filter((item, index) => !indexes.has(index))];
+}
+/**
+* Merge similar items
+*/
+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.js

@@ -0,0 +1,79 @@
+import { joinerEmoji } from "../data.js";
+import { convertEmojiSequenceToUTF32 } from "../convert.js";
+import { splitEmojiSequences } from "../cleanup.js";
+import { createOptionalEmojiRegexItem, createSequenceEmojiRegexItem, createSetEmojiRegexItem, createUTF16EmojiRegexItem } from "./base.js";
+import { createRegexForNumbersSequence } from "./numbers.js";
+import { mergeSimilarItemsInSet } from "./similar.js";
+/**
+* Create tree
+*/
+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((item) => item.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;
+}
+/**
+* Parse tree
+*/
+function parseEmojiTree(items) {
+	function mergeParsedChildren(items) {
+		const parsedItems = [];
+		const mapWithoutEnd = Object.create(null);
+		const mapWithEnd = Object.create(null);
+		for (let i = 0; i < items.length; i++) {
+			const item = items[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 items = source[regex];
+				const firstItem = items[0];
+				let childSequence = [createUTF16EmojiRegexItem([joinerEmoji]), firstItem.children];
+				if (firstItem.end) childSequence = [createOptionalEmojiRegexItem(createSequenceEmojiRegexItem(childSequence))];
+				let mergedRegex;
+				if (items.length === 1) mergedRegex = firstItem.regex;
+				else mergedRegex = mergeSimilarItemsInSet(createSetEmojiRegexItem(items.map((item) => item.regex)));
+				const sequence = createSequenceEmojiRegexItem([mergedRegex, ...childSequence]);
+				parsedItems.push(sequence);
+			}
+		});
+		if (parsedItems.length === 1) return parsedItems[0];
+		return mergeSimilarItemsInSet(createSetEmojiRegexItem(parsedItems));
+	}
+	function parseItemChildren(item) {
+		const result = {
+			regex: item.regex,
+			end: !!item.end
+		};
+		const children = item.children;
+		if (!children) return result;
+		result.children = mergeParsedChildren(children.map(parseItemChildren));
+		return result;
+	}
+	return mergeParsedChildren(items.map(parseItemChildren));
+}
+export { createEmojisTree, parseEmojiTree };