react-emoji-text 1.0.0-alpha.0

package/dist/tokenize-CyKMb3O9.cjs

@@ -0,0 +1,364 @@
+//#region src/core/ascii.ts
+const CURATED_ASCII = {
+	":)": "slightly_smiling_face",
+	":-)": "slightly_smiling_face",
+	":(": "slightly_frowning_face",
+	":-(": "slightly_frowning_face",
+	";)": "wink",
+	";-)": "wink",
+	":P": "stuck_out_tongue",
+	":-P": "stuck_out_tongue",
+	":p": "stuck_out_tongue",
+	":-p": "stuck_out_tongue",
+	":D": "grinning",
+	":-D": "grinning",
+	"<3": "heart",
+	":|": "neutral_face",
+	":-|": "neutral_face",
+	":/": "confused",
+	":-/": "confused",
+	":'(": "cry",
+	":O": "open_mouth",
+	":-O": "open_mouth",
+	":o": "open_mouth",
+	":-o": "open_mouth",
+	">:(": "angry",
+	"B)": "sunglasses",
+	"B-)": "sunglasses"
+};
+function buildAsciiIndex(data) {
+	const index = /* @__PURE__ */ new Map();
+	for (const [ascii, emojiId] of Object.entries(data.aliases)) if (/^[^a-zA-Z0-9]/.test(ascii) && ascii.length <= 4) index.set(ascii, emojiId);
+	for (const [ascii, emojiId] of Object.entries(CURATED_ASCII)) if (!index.has(ascii) && data.emojis[emojiId]) index.set(ascii, emojiId);
+	return index;
+}
+function buildAsciiCandidates(asciiIndex) {
+	return Array.from(asciiIndex.keys()).sort((first, second) => second.length - first.length);
+}
+const BOUNDARY_BEFORE = /(?:^|[\s\n])$/;
+const BOUNDARY_AFTER = /^(?:[\s\n]|$)/;
+function matchAscii(input, position, asciiIndex, asciiCandidates = buildAsciiCandidates(asciiIndex)) {
+	const before = input.slice(0, position);
+	if (position > 0 && !BOUNDARY_BEFORE.test(before)) return;
+	for (const ascii of asciiCandidates) {
+		if (!input.startsWith(ascii, position)) continue;
+		const after = input.slice(position + ascii.length);
+		if (BOUNDARY_AFTER.test(after)) {
+			const emojiId = asciiIndex.get(ascii);
+			if (emojiId) return {
+				ascii,
+				emojiId
+			};
+		}
+	}
+}
+//#endregion
+//#region src/core/indexes.ts
+function unifiedToNative(unified) {
+	return unified.split("-").map((hex) => String.fromCodePoint(Number.parseInt(hex, 16))).join("");
+}
+function escapeRegex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildIndexes(data, customEmojis, extraAliases) {
+	const unicodeMap = /* @__PURE__ */ new Map();
+	const emojiMap = /* @__PURE__ */ new Map();
+	const shortcodeIndex = /* @__PURE__ */ new Map();
+	const unicodeChars = [];
+	for (const [emojiId, emoji] of Object.entries(data.emojis)) {
+		emojiMap.set(emojiId, emoji);
+		shortcodeIndex.set(emojiId, { emojiId });
+		if (emoji.aliases) for (const alias of emoji.aliases) shortcodeIndex.set(alias, { emojiId });
+		for (const skin of emoji.skins) {
+			const native = skin.native ?? unifiedToNative(skin.unified);
+			unicodeMap.set(native, emojiId);
+			unicodeChars.push(escapeRegex(native));
+		}
+	}
+	for (const [alias, emojiId] of Object.entries(data.aliases)) if (!shortcodeIndex.has(alias)) shortcodeIndex.set(alias, { emojiId });
+	if (customEmojis) for (const category of customEmojis) for (const emoji of category.emojis) {
+		const entry = {
+			id: emoji.id,
+			name: emoji.name,
+			keywords: emoji.keywords ?? [],
+			skins: emoji.skins.map((skin) => ({
+				unified: "",
+				native: "",
+				src: skin.src
+			}))
+		};
+		emojiMap.set(emoji.id, entry);
+		shortcodeIndex.set(emoji.id, {
+			emojiId: emoji.id,
+			isCustom: true
+		});
+	}
+	if (extraAliases) for (const [alias, emojiId] of Object.entries(extraAliases)) {
+		const cleanAlias = alias.replace(/^:|:$/g, "");
+		const resolvedEmojiId = emojiMap.has(emojiId) ? emojiId : shortcodeIndex.get(emojiId)?.emojiId ?? emojiId;
+		const isCustom = shortcodeIndex.get(resolvedEmojiId)?.isCustom;
+		shortcodeIndex.set(cleanAlias, {
+			emojiId: resolvedEmojiId,
+			isCustom
+		});
+	}
+	unicodeChars.sort((first, second) => second.length - first.length);
+	const unicodeRegex = unicodeChars.length > 0 ? new RegExp(unicodeChars.join("|"), "y") : /(?!)/y;
+	const asciiIndex = buildAsciiIndex(data);
+	return {
+		asciiCandidates: buildAsciiCandidates(asciiIndex),
+		unicodeRegex,
+		unicodeMap,
+		shortcodeIndex,
+		asciiIndex,
+		emojiMap
+	};
+}
+//#endregion
+//#region src/core/skin.ts
+const SKIN_TONE_MODIFIERS = {
+	"1f3fb": 2,
+	"1f3fc": 3,
+	"1f3fd": 4,
+	"1f3fe": 5,
+	"1f3ff": 6
+};
+function detectSkinToneFromUnified(unified) {
+	const normalizedUnified = unified.toLowerCase();
+	for (const [modifier, tone] of Object.entries(SKIN_TONE_MODIFIERS)) if (normalizedUnified.includes(modifier)) return tone;
+}
+function resolveSkin(emoji, explicitSkin, defaultSkin) {
+	const tone = explicitSkin ?? defaultSkin;
+	if (!tone || tone === 1 || emoji.skins.length <= 1) return {
+		native: emoji.skins[0]?.native ?? "",
+		skin: explicitSkin
+	};
+	const skinIndex = tone - 1;
+	return {
+		native: (emoji.skins[skinIndex] ?? emoji.skins[0])?.native ?? emoji.skins[0]?.native ?? "",
+		skin: tone
+	};
+}
+function skinToneShortcodeToTone(shortcode) {
+	const toneMatch = /^skin-tone-([1-6])$/.test(shortcode) ? shortcode.charAt(shortcode.length - 1) : void 0;
+	if (toneMatch) return Number.parseInt(toneMatch, 10);
+}
+//#endregion
+//#region src/core/tokenize.ts
+const SHORTCODE_RE = /^:([a-zA-Z0-9_+-]+):/;
+const SKIN_TONE_SHORTCODE_RE = /^:skin-tone-([1-6]):/;
+const indexCache = /* @__PURE__ */ new WeakMap();
+function getIndexes(options) {
+	if (options.indexes) return options.indexes;
+	const cachedEntries = indexCache.get(options.data);
+	const cachedEntry = cachedEntries?.find((entry) => entry.customEmojis === options.customEmojis && entry.extraAliases === options.extraAliases);
+	if (cachedEntry) return cachedEntry.indexes;
+	const indexes = buildIndexes(options.data, options.customEmojis, options.extraAliases);
+	const nextEntry = {
+		customEmojis: options.customEmojis,
+		extraAliases: options.extraAliases,
+		indexes
+	};
+	if (cachedEntries) cachedEntries.push(nextEntry);
+	else indexCache.set(options.data, [nextEntry]);
+	return indexes;
+}
+function tryMatchUnicode(input, position, indexes) {
+	indexes.unicodeRegex.lastIndex = position;
+	const regexResult = indexes.unicodeRegex.exec(input);
+	if (regexResult) {
+		const native = regexResult[0];
+		const emojiId = indexes.unicodeMap.get(native);
+		if (emojiId) return {
+			native,
+			emojiId,
+			unified: (indexes.emojiMap.get(emojiId)?.skins.find((skinEntry) => skinEntry.native === native))?.unified
+		};
+	}
+}
+function tryMatchShortcode(input, position, indexes) {
+	const remaining = input.slice(position);
+	const regexResult = SHORTCODE_RE.exec(remaining);
+	if (regexResult?.[1]) {
+		const shortcode = regexResult[1];
+		const entry = indexes.shortcodeIndex.get(shortcode);
+		if (entry) return {
+			shortcode,
+			emojiId: entry.emojiId,
+			fullMatch: regexResult[0],
+			isCustom: entry.isCustom
+		};
+	}
+}
+function tryMatchUnknownShortcode(input, position) {
+	const remaining = input.slice(position);
+	const regexResult = SHORTCODE_RE.exec(remaining);
+	if (regexResult?.[1]) return {
+		shortcode: regexResult[1],
+		fullMatch: regexResult[0]
+	};
+}
+function tokenize(input, options) {
+	return tokenizeWithIndexes(input, options);
+}
+function tokenizeWithIndexes(input, options) {
+	const indexes = getIndexes(options);
+	const tokens = [];
+	const ascii = options.ascii ?? true;
+	let position = 0;
+	let textBuffer = "";
+	function flushText() {
+		if (textBuffer.length > 0) {
+			tokens.push({
+				type: "text",
+				value: textBuffer
+			});
+			textBuffer = "";
+		}
+	}
+	while (position < input.length) {
+		let matched = false;
+		const unicodeResult = tryMatchUnicode(input, position, indexes);
+		if (unicodeResult) {
+			flushText();
+			const detectedSkin = detectSkinToneFromUnified(unicodeResult.unified ?? "");
+			const emoji = indexes.emojiMap.get(unicodeResult.emojiId);
+			if (emoji) {
+				const resolved = resolveSkin(emoji, detectedSkin, options.defaultSkin);
+				tokens.push({
+					type: "emoji",
+					emoji,
+					native: resolved.native || unicodeResult.native,
+					skin: resolved.skin,
+					match: unicodeResult.native,
+					source: "unicode"
+				});
+			}
+			position += unicodeResult.native.length;
+			matched = true;
+		}
+		if (!matched) {
+			const shortcodeResult = tryMatchShortcode(input, position, indexes);
+			if (shortcodeResult) {
+				flushText();
+				let skinTone;
+				let totalLength = shortcodeResult.fullMatch.length;
+				const afterShortcode = input.slice(position + totalLength);
+				const skinRegexResult = SKIN_TONE_SHORTCODE_RE.exec(afterShortcode);
+				if (skinRegexResult?.[1]) {
+					skinTone = skinToneShortcodeToTone(`skin-tone-${skinRegexResult[1]}`);
+					totalLength += skinRegexResult[0].length;
+				}
+				const emoji = indexes.emojiMap.get(shortcodeResult.emojiId);
+				if (emoji) {
+					const isCustom = shortcodeResult.isCustom;
+					const resolved = resolveSkin(emoji, skinTone, options.defaultSkin);
+					tokens.push({
+						type: "emoji",
+						emoji,
+						native: resolved.native,
+						skin: resolved.skin,
+						shortcode: shortcodeResult.shortcode,
+						match: input.slice(position, position + totalLength),
+						source: isCustom ? "custom" : "shortcode"
+					});
+				}
+				position += totalLength;
+				matched = true;
+			}
+		}
+		if (!matched) {
+			const unknownResult = tryMatchUnknownShortcode(input, position);
+			if (unknownResult) {
+				flushText();
+				tokens.push({
+					type: "unknown",
+					shortcode: unknownResult.shortcode,
+					match: unknownResult.fullMatch
+				});
+				position += unknownResult.fullMatch.length;
+				matched = true;
+			}
+		}
+		if (!matched && ascii) {
+			const asciiResult = matchAscii(input, position, indexes.asciiIndex, indexes.asciiCandidates);
+			if (asciiResult) {
+				flushText();
+				const emoji = indexes.emojiMap.get(asciiResult.emojiId);
+				if (emoji) {
+					const resolved = resolveSkin(emoji, void 0, options.defaultSkin);
+					tokens.push({
+						type: "emoji",
+						emoji,
+						native: resolved.native,
+						match: asciiResult.ascii,
+						source: "ascii"
+					});
+				}
+				position += asciiResult.ascii.length;
+				matched = true;
+			}
+		}
+		if (!matched) {
+			textBuffer += input[position];
+			position += 1;
+		}
+	}
+	flushText();
+	return tokens;
+}
+//#endregion
+Object.defineProperty(exports, "buildAsciiCandidates", {
+	enumerable: true,
+	get: function() {
+		return buildAsciiCandidates;
+	}
+});
+Object.defineProperty(exports, "buildAsciiIndex", {
+	enumerable: true,
+	get: function() {
+		return buildAsciiIndex;
+	}
+});
+Object.defineProperty(exports, "buildIndexes", {
+	enumerable: true,
+	get: function() {
+		return buildIndexes;
+	}
+});
+Object.defineProperty(exports, "detectSkinToneFromUnified", {
+	enumerable: true,
+	get: function() {
+		return detectSkinToneFromUnified;
+	}
+});
+Object.defineProperty(exports, "matchAscii", {
+	enumerable: true,
+	get: function() {
+		return matchAscii;
+	}
+});
+Object.defineProperty(exports, "resolveSkin", {
+	enumerable: true,
+	get: function() {
+		return resolveSkin;
+	}
+});
+Object.defineProperty(exports, "skinToneShortcodeToTone", {
+	enumerable: true,
+	get: function() {
+		return skinToneShortcodeToTone;
+	}
+});
+Object.defineProperty(exports, "tokenize", {
+	enumerable: true,
+	get: function() {
+		return tokenize;
+	}
+});
+Object.defineProperty(exports, "tokenizeWithIndexes", {
+	enumerable: true,
+	get: function() {
+		return tokenizeWithIndexes;
+	}
+});

package/dist/types-Dyzdpq-R.d.cts

@@ -0,0 +1,92 @@
+//#region src/core/types.d.ts
+interface EmojiSkin {
+  unified: string;
+  native: string;
+  src?: string;
+}
+interface EmojiEntry {
+  id: string;
+  name: string;
+  keywords: string[];
+  skins: EmojiSkin[];
+  aliases?: string[];
+}
+interface CustomEmoji {
+  id: string;
+  name: string;
+  keywords?: string[];
+  skins: Array<{
+    src: string;
+  }>;
+}
+interface CustomEmojiCategory {
+  id: string;
+  name: string;
+  emojis: CustomEmoji[];
+}
+interface SpriteConfig {
+  src: string;
+  size: number;
+  columns: number;
+  sheet: Record<string, {
+    x: number;
+    y: number;
+  }>;
+}
+type EmojiSet = 'native' | 'apple' | 'google' | 'twitter' | 'facebook';
+type SkinTone = 1 | 2 | 3 | 4 | 5 | 6;
+type EmojiSource = 'unicode' | 'shortcode' | 'ascii' | 'custom';
+interface EmojiImageContext {
+  set: EmojiSet;
+  skin: SkinTone;
+  unified: string;
+}
+type GetImageUrl = (emoji: EmojiEntry, context: EmojiImageContext) => string;
+interface EmojiConfig {
+  data: EmojiData;
+  customEmojis?: CustomEmojiCategory[];
+  set?: EmojiSet;
+  defaultSkin?: SkinTone;
+  ascii?: boolean;
+  getImageUrl?: GetImageUrl;
+  imageUrlTemplate?: string;
+  sprite?: SpriteConfig;
+  extraAliases?: Record<string, string>;
+}
+interface EmojiData {
+  emojis: Record<string, EmojiEntry>;
+  aliases: Record<string, string>;
+  categories: Array<{
+    id: string;
+    emojis: string[];
+  }>;
+}
+type TextToken = {
+  type: 'text';
+  value: string;
+};
+type EmojiToken = {
+  type: 'emoji';
+  emoji: EmojiEntry;
+  native: string;
+  skin?: SkinTone;
+  shortcode?: string;
+  match: string;
+  source: EmojiSource;
+};
+type UnknownToken = {
+  type: 'unknown';
+  shortcode: string;
+  match: string;
+};
+type Token = TextToken | EmojiToken | UnknownToken;
+interface TokenizeOptions {
+  data: EmojiData;
+  customEmojis?: CustomEmojiCategory[];
+  ascii?: boolean;
+  defaultSkin?: SkinTone;
+  extraAliases?: Record<string, string>;
+}
+//#endregion
+export { UnknownToken as _, EmojiEntry as a, EmojiSkin as c, GetImageUrl as d, SkinTone as f, TokenizeOptions as g, Token as h, EmojiData as i, EmojiSource as l, TextToken as m, CustomEmojiCategory as n, EmojiImageContext as o, SpriteConfig as p, EmojiConfig as r, EmojiSet as s, CustomEmoji as t, EmojiToken as u };
+//# sourceMappingURL=types-Dyzdpq-R.d.cts.map

package/dist/types-Dyzdpq-R.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-Dyzdpq-R.d.cts","names":[],"sources":["../src/core/types.ts"],"mappings":";UAAiB,SAAA;EACf,OAAA;EACA,MAAA;EACA,GAAA;AAAA;AAAA,UAGe,UAAA;EACf,EAAA;EACA,IAAA;EACA,QAAA;EACA,KAAA,EAAO,SAAA;EACP,OAAA;AAAA;AAAA,UAGe,WAAA;EACf,EAAA;EACA,IAAA;EACA,QAAA;EACA,KAAA,EAAO,KAAA;IAAQ,GAAA;EAAA;AAAA;AAAA,UAGA,mBAAA;EACf,EAAA;EACA,IAAA;EACA,MAAA,EAAQ,WAAA;AAAA;AAAA,UAGO,YAAA;EACf,GAAA;EACA,IAAA;EACA,OAAA;EACA,KAAA,EAAO,MAAA;IAAiB,CAAA;IAAW,CAAA;EAAA;AAAA;AAAA,KAGzB,QAAA;AAAA,KACA,QAAA;AAAA,KACA,WAAA;AAAA,UAEK,iBAAA;EACf,GAAA,EAAK,QAAA;EACL,IAAA,EAAM,QAAA;EACN,OAAA;AAAA;AAAA,KAGU,WAAA,IAAe,KAAA,EAAO,UAAA,EAAY,OAAA,EAAS,iBAAA;AAAA,UAEtC,WAAA;EACf,IAAA,EAAM,SAAA;EACN,YAAA,GAAe,mBAAA;EACf,GAAA,GAAM,QAAA;EACN,WAAA,GAAc,QAAA;EACd,KAAA;EACA,WAAA,GAAc,WAAA;EACd,gBAAA;EACA,MAAA,GAAS,YAAA;EACT,YAAA,GAAe,MAAA;AAAA;AAAA,UAGA,SAAA;EACf,MAAA,EAAQ,MAAA,SAAe,UAAA;EACvB,OAAA,EAAS,MAAA;EACT,UAAA,EAAY,KAAA;IAAQ,EAAA;IAAY,MAAA;EAAA;AAAA;AAAA,KAGtB,SAAA;EACV,IAAA;EACA,KAAA;AAAA;AAAA,KAGU,UAAA;EACV,IAAA;EACA,KAAA,EAAO,UAAA;EACP,MAAA;EACA,IAAA,GAAO,QAAA;EACP,SAAA;EACA,KAAA;EACA,MAAA,EAAQ,WAAA;AAAA;AAAA,KAGE,YAAA;EACV,IAAA;EACA,SAAA;EACA,KAAA;AAAA;AAAA,KAGU,KAAA,GAAQ,SAAA,GAAY,UAAA,GAAa,YAAA;AAAA,UAE5B,eAAA;EACf,IAAA,EAAM,SAAA;EACN,YAAA,GAAe,mBAAA;EACf,KAAA;EACA,WAAA,GAAc,QAAA;EACd,YAAA,GAAe,MAAA;AAAA"}

package/dist/types-o0mRO30y.d.mts

@@ -0,0 +1,92 @@
+//#region src/core/types.d.ts
+interface EmojiSkin {
+  unified: string;
+  native: string;
+  src?: string;
+}
+interface EmojiEntry {
+  id: string;
+  name: string;
+  keywords: string[];
+  skins: EmojiSkin[];
+  aliases?: string[];
+}
+interface CustomEmoji {
+  id: string;
+  name: string;
+  keywords?: string[];
+  skins: Array<{
+    src: string;
+  }>;
+}
+interface CustomEmojiCategory {
+  id: string;
+  name: string;
+  emojis: CustomEmoji[];
+}
+interface SpriteConfig {
+  src: string;
+  size: number;
+  columns: number;
+  sheet: Record<string, {
+    x: number;
+    y: number;
+  }>;
+}
+type EmojiSet = 'native' | 'apple' | 'google' | 'twitter' | 'facebook';
+type SkinTone = 1 | 2 | 3 | 4 | 5 | 6;
+type EmojiSource = 'unicode' | 'shortcode' | 'ascii' | 'custom';
+interface EmojiImageContext {
+  set: EmojiSet;
+  skin: SkinTone;
+  unified: string;
+}
+type GetImageUrl = (emoji: EmojiEntry, context: EmojiImageContext) => string;
+interface EmojiConfig {
+  data: EmojiData;
+  customEmojis?: CustomEmojiCategory[];
+  set?: EmojiSet;
+  defaultSkin?: SkinTone;
+  ascii?: boolean;
+  getImageUrl?: GetImageUrl;
+  imageUrlTemplate?: string;
+  sprite?: SpriteConfig;
+  extraAliases?: Record<string, string>;
+}
+interface EmojiData {
+  emojis: Record<string, EmojiEntry>;
+  aliases: Record<string, string>;
+  categories: Array<{
+    id: string;
+    emojis: string[];
+  }>;
+}
+type TextToken = {
+  type: 'text';
+  value: string;
+};
+type EmojiToken = {
+  type: 'emoji';
+  emoji: EmojiEntry;
+  native: string;
+  skin?: SkinTone;
+  shortcode?: string;
+  match: string;
+  source: EmojiSource;
+};
+type UnknownToken = {
+  type: 'unknown';
+  shortcode: string;
+  match: string;
+};
+type Token = TextToken | EmojiToken | UnknownToken;
+interface TokenizeOptions {
+  data: EmojiData;
+  customEmojis?: CustomEmojiCategory[];
+  ascii?: boolean;
+  defaultSkin?: SkinTone;
+  extraAliases?: Record<string, string>;
+}
+//#endregion
+export { UnknownToken as _, EmojiEntry as a, EmojiSkin as c, GetImageUrl as d, SkinTone as f, TokenizeOptions as g, Token as h, EmojiData as i, EmojiSource as l, TextToken as m, CustomEmojiCategory as n, EmojiImageContext as o, SpriteConfig as p, EmojiConfig as r, EmojiSet as s, CustomEmoji as t, EmojiToken as u };
+//# sourceMappingURL=types-o0mRO30y.d.mts.map

package/dist/types-o0mRO30y.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-o0mRO30y.d.mts","names":[],"sources":["../src/core/types.ts"],"mappings":";UAAiB,SAAA;EACf,OAAA;EACA,MAAA;EACA,GAAA;AAAA;AAAA,UAGe,UAAA;EACf,EAAA;EACA,IAAA;EACA,QAAA;EACA,KAAA,EAAO,SAAA;EACP,OAAA;AAAA;AAAA,UAGe,WAAA;EACf,EAAA;EACA,IAAA;EACA,QAAA;EACA,KAAA,EAAO,KAAA;IAAQ,GAAA;EAAA;AAAA;AAAA,UAGA,mBAAA;EACf,EAAA;EACA,IAAA;EACA,MAAA,EAAQ,WAAA;AAAA;AAAA,UAGO,YAAA;EACf,GAAA;EACA,IAAA;EACA,OAAA;EACA,KAAA,EAAO,MAAA;IAAiB,CAAA;IAAW,CAAA;EAAA;AAAA;AAAA,KAGzB,QAAA;AAAA,KACA,QAAA;AAAA,KACA,WAAA;AAAA,UAEK,iBAAA;EACf,GAAA,EAAK,QAAA;EACL,IAAA,EAAM,QAAA;EACN,OAAA;AAAA;AAAA,KAGU,WAAA,IAAe,KAAA,EAAO,UAAA,EAAY,OAAA,EAAS,iBAAA;AAAA,UAEtC,WAAA;EACf,IAAA,EAAM,SAAA;EACN,YAAA,GAAe,mBAAA;EACf,GAAA,GAAM,QAAA;EACN,WAAA,GAAc,QAAA;EACd,KAAA;EACA,WAAA,GAAc,WAAA;EACd,gBAAA;EACA,MAAA,GAAS,YAAA;EACT,YAAA,GAAe,MAAA;AAAA;AAAA,UAGA,SAAA;EACf,MAAA,EAAQ,MAAA,SAAe,UAAA;EACvB,OAAA,EAAS,MAAA;EACT,UAAA,EAAY,KAAA;IAAQ,EAAA;IAAY,MAAA;EAAA;AAAA;AAAA,KAGtB,SAAA;EACV,IAAA;EACA,KAAA;AAAA;AAAA,KAGU,UAAA;EACV,IAAA;EACA,KAAA,EAAO,UAAA;EACP,MAAA;EACA,IAAA,GAAO,QAAA;EACP,SAAA;EACA,KAAA;EACA,MAAA,EAAQ,WAAA;AAAA;AAAA,KAGE,YAAA;EACV,IAAA;EACA,SAAA;EACA,KAAA;AAAA;AAAA,KAGU,KAAA,GAAQ,SAAA,GAAY,UAAA,GAAa,YAAA;AAAA,UAE5B,eAAA;EACf,IAAA,EAAM,SAAA;EACN,YAAA,GAAe,mBAAA;EACf,KAAA;EACA,WAAA,GAAc,QAAA;EACd,YAAA,GAAe,MAAA;AAAA"}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "react-emoji-text",
+  "version": "1.0.0-alpha.0",
+  "description": "A modern React renderer that converts plain text into rendered emojis, with adapters for @emoji-mart/data and emojibase",
+  "keywords": [
+    "emoji",
+    "emoji-mart",
+    "emojibase",
+    "emoticon",
+    "react",
+    "renderer",
+    "shortcode",
+    "text",
+    "unicode"
+  ],
+  "license": "MIT",
+  "author": "drenther",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/drenther/react-emoji-text.git",
+    "directory": "packages/react-emoji-text"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./core": {
+      "types": "./dist/core.d.mts",
+      "import": "./dist/core.mjs",
+      "require": "./dist/core.cjs"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.mts",
+      "import": "./dist/react/index.mjs",
+      "require": "./dist/react/index.cjs"
+    },
+    "./compat": {
+      "types": "./dist/compat/index.d.mts",
+      "import": "./dist/compat/index.mjs",
+      "require": "./dist/compat/index.cjs"
+    },
+    "./adapters/emoji-mart": {
+      "types": "./dist/adapters/emoji-mart.d.mts",
+      "import": "./dist/adapters/emoji-mart.mjs",
+      "require": "./dist/adapters/emoji-mart.cjs"
+    },
+    "./adapters/emojibase": {
+      "types": "./dist/adapters/emojibase.d.mts",
+      "import": "./dist/adapters/emojibase.mjs",
+      "require": "./dist/adapters/emojibase.cjs"
+    },
+    "./package.json": {
+      "default": "./package.json"
+    }
+  },
+  "devDependencies": {
+    "@emoji-mart/data": "1.2.1",
+    "@testing-library/jest-dom": "6.9.1",
+    "@testing-library/react": "16.3.2",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
+    "@vitest/coverage-v8": "4.1.5",
+    "emojibase-data": "17.0.0",
+    "happy-dom": "20.9.0",
+    "react": "19.2.5",
+    "react-dom": "19.2.5",
+    "tsdown": "0.21.10",
+    "typescript": "6.0.3",
+    "vitest": "4.1.5"
+  },
+  "peerDependencies": {
+    "@emoji-mart/data": ">=1.2.0",
+    "emojibase-data": ">=16.0.0",
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@emoji-mart/data": {
+      "optional": true
+    },
+    "emojibase-data": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=24.15.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit"
+  }
+}