react-emoji-text 1.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 drenther
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,408 @@
+# react-emoji-text
+
+A modern React 19 renderer that converts plain text into rendered emojis, backed by `@emoji-mart/data`.
+
+## Entry Points
+
+```ts
+import { EmojiProvider, EmojiText } from 'react-emoji-text/react';
+import { tokenize } from 'react-emoji-text/core';
+import Emoji, { toArray } from 'react-emoji-text/compat';
+```
+
+The root entry (`react-emoji-text`) re-exports the core and React APIs. Use the subpath entries when you want the smallest import surface.
+
+## React Usage
+
+Wrap your app (or subtree) with `EmojiProvider` and use `EmojiText` to render emoji-enriched text.
+
+```tsx
+import data from '@emoji-mart/data';
+import { EmojiProvider, EmojiText } from 'react-emoji-text/react';
+
+export function Message() {
+  return (
+    <EmojiProvider data={data}>
+      <EmojiText>hello :wave:</EmojiText>
+    </EmojiProvider>
+  );
+}
+```
+
+`EmojiText` accepts content as a `children` string or via the `text` prop. Use `text` when `children` contains slots (see [Custom Rendering](#custom-rendering)).
+
+### EmojiProvider Props
+
+| Prop               | Type                                                         | Default    | Description                                                         |
+| ------------------ | ------------------------------------------------------------ | ---------- | ------------------------------------------------------------------- |
+| `data`             | `EmojiData`                                                  | _required_ | Emoji dataset (e.g. `@emoji-mart/data`)                             |
+| `set`              | `"native" \| "apple" \| "google" \| "twitter" \| "facebook"` | `"native"` | Emoji image set                                                     |
+| `defaultSkin`      | `1 \| 2 \| 3 \| 4 \| 5 \| 6`                                 | —          | Default skin tone applied to all emojis                             |
+| `ascii`            | `boolean`                                                    | `true`     | Match ASCII emoticons like `:)` and `<3`                            |
+| `customEmojis`     | `CustomEmojiCategory[]`                                      | —          | Custom emoji categories (see [Custom Emojis](#custom-emojis))       |
+| `extraAliases`     | `Record<string, string>`                                     | —          | Additional shortcode mappings (see [Extra Aliases](#extra-aliases)) |
+| `getImageUrl`      | `(emoji, context) => string`                                 | —          | Custom image URL resolver                                           |
+| `imageUrlTemplate` | `string`                                                     | —          | URL template with `{set}`, `{unified}`, `{skin}` placeholders       |
+| `sprite`           | `SpriteConfig`                                               | —          | Sprite sheet configuration                                          |
+
+### EmojiText Props
+
+All `EmojiProvider` props except `data` can be overridden per-instance on `EmojiText`.
+
+| Prop                 | Type                          | Default  | Description                                                    |
+| -------------------- | ----------------------------- | -------- | -------------------------------------------------------------- |
+| `children`           | `string`                      | —        | Source text (mutually exclusive with `text`)                   |
+| `text`               | `string`                      | —        | Source text (use when `children` contains slots)               |
+| `as`                 | `keyof HTMLElementTagNameMap` | `"span"` | Wrapper element tag                                            |
+| `className`          | `string`                      | —        | Class on the wrapper element                                   |
+| `emojiClassName`     | `string`                      | —        | Class applied to individual emoji images                       |
+| `onlyEmojiClassName` | `string`                      | —        | Class applied to the wrapper when content contains only emojis |
+| `ref`                | `Ref<HTMLElement>`            | —        | Forwarded ref to the wrapper element                           |
+
+Any additional HTML attributes are forwarded to the wrapper element.
+
+```tsx
+<EmojiText as="p" className="message" data-testid="msg" title="Greeting">
+  hello :wave:
+</EmojiText>
+```
+
+## Custom Rendering
+
+Customize token rendering with compound slots. Use `text` for the source string when `children` contains slots.
+
+```tsx
+<EmojiText text="hello :wave: :missing:">
+  <EmojiText.Emoji>
+    {(token) => <strong title={token.shortcode}>{token.native}</strong>}
+  </EmojiText.Emoji>
+  <EmojiText.Unknown>{(token) => <code>{token.match}</code>}</EmojiText.Unknown>
+</EmojiText>
+```
+
+The `EmojiText.Emoji` slot receives an `EmojiToken` with fields: `emoji`, `native`, `skin`, `shortcode`, `match`, and `source`. The `EmojiText.Unknown` slot receives an `UnknownToken` with `shortcode` and `match`.
+
+For full control over every token type, compose the `useTokens` hook with `renderTokenDefault`:
+
+```tsx
+import { useTokens, renderTokenDefault } from 'react-emoji-text/react';
+
+function CustomRenderer({ text }: { text: string }) {
+  const tokens = useTokens(text);
+
+  return (
+    <span>
+      {tokens.map((token, index) => {
+        if (token.type === 'emoji') {
+          return (
+            <span key={index} className="emoji">
+              {token.native}
+            </span>
+          );
+        }
+        return renderTokenDefault(token, { set: 'native' });
+      })}
+    </span>
+  );
+}
+```
+
+## Image Rendering
+
+By default, emojis render as native Unicode characters. To render image-based emojis, configure one of the image resolution strategies on the provider or per-instance.
+
+### Image URL Template
+
+Use `{set}`, `{unified}`, and `{skin}` placeholders:
+
+```tsx
+<EmojiProvider data={data} set="apple" imageUrlTemplate="/emoji/{set}/{unified}.png">
+  <EmojiText>:wave:</EmojiText>
+</EmojiProvider>
+```
+
+### Custom Image URL Function
+
+For full control, provide a `getImageUrl` function:
+
+```tsx
+<EmojiProvider
+  data={data}
+  set="apple"
+  getImageUrl={(emoji, context) => `/cdn/${context.set}/${context.unified}.svg`}
+>
+  <EmojiText>:wave:</EmojiText>
+</EmojiProvider>
+```
+
+### Sprite Sheets
+
+Render emojis from a sprite sheet by providing a `sprite` config:
+
+```tsx
+<EmojiText
+  set="apple"
+  sprite={{
+    src: '/emoji-sheet.png',
+    size: 20,
+    columns: 4,
+    sheet: { '1F44B': { x: 1, y: 2 } },
+  }}
+>
+  :wave:
+</EmojiText>
+```
+
+Sprite coordinates are matched case-insensitively. Emojis without coordinates fall back to native rendering.
+
+### Resolution Priority
+
+When multiple image strategies are configured, they resolve in this order:
+
+1. `getImageUrl` (highest priority)
+2. `sprite`
+3. `imageUrlTemplate`
+4. Native Unicode (fallback)
+
+The `emojiClassName` prop is applied to rendered `<img>` and sprite `<span>` elements.
+
+## Skin Tones
+
+### Default Skin Tone
+
+Set a default skin tone on the provider or per-instance. Values range from `1` (default yellow) to `6`.
+
+```tsx
+<EmojiProvider data={data} defaultSkin={3}>
+  <EmojiText>:wave:</EmojiText> {/* renders 👋🏼 */}
+</EmojiProvider>
+```
+
+### Shortcode Skin Tone Suffix
+
+Append `:skin-tone-N:` to a shortcode to override the skin tone for that emoji:
+
+```tsx
+<EmojiText>:wave::skin-tone-5:</EmojiText> {/* renders 👋🏾 */}
+```
+
+Unicode skin tone modifiers embedded in the source text are always preserved.
+
+## ASCII Emoticons
+
+ASCII emoticons like `:)`, `<3`, `:D`, and `;)` are matched by default. They require whitespace or string boundaries on both sides to avoid false positives inside words.
+
+Disable ASCII matching on the provider or per-instance:
+
+```tsx
+<EmojiProvider data={data} ascii={false}>
+  <EmojiText>hello :)</EmojiText> {/* renders as plain text */}
+</EmojiProvider>
+```
+
+## Only-Emoji Detection
+
+When the rendered content contains only emoji tokens (and optional whitespace), the `onlyEmojiClassName` is applied to the wrapper element. This is useful for styling messages that contain only emojis differently (e.g., rendering them larger).
+
+```tsx
+<EmojiText className="message" onlyEmojiClassName="jumbo">
+  :wave:
+</EmojiText>;
+{
+  /* wrapper gets class="message jumbo" */
+}
+
+<EmojiText className="message" onlyEmojiClassName="jumbo">
+  hello :wave:
+</EmojiText>;
+{
+  /* wrapper gets class="message" */
+}
+```
+
+Empty content does not receive `onlyEmojiClassName`.
+
+## Custom Emojis
+
+Register custom emojis via the provider or per-instance. Each category contains an array of emojis with image sources.
+
+```tsx
+<EmojiProvider
+  data={data}
+  customEmojis={[
+    {
+      id: 'custom',
+      name: 'Custom',
+      emojis: [
+        {
+          id: 'partyparrot',
+          name: 'Party Parrot',
+          keywords: ['party', 'parrot'],
+          skins: [{ src: '/emojis/partyparrot.gif' }],
+        },
+      ],
+    },
+  ]}
+>
+  <EmojiText>:partyparrot:</EmojiText>
+</EmojiProvider>
+```
+
+Custom emojis render as `<img>` elements. If a custom emoji shares the same ID as a built-in emoji, the custom emoji takes precedence.
+
+## Extra Aliases
+
+Map additional shortcodes to existing emoji IDs via `extraAliases`. Values can reference built-in emoji IDs, built-in shortcodes, or custom emoji IDs.
+
+```tsx
+<EmojiProvider data={data}>
+  <EmojiText extraAliases={{ hi: 'wave', dance: 'partyparrot' }}>:hi: :dance:</EmojiText>
+</EmojiProvider>
+```
+
+### Shortcode Resolution Priority
+
+When multiple sources define the same shortcode, the last writer wins. Resolution runs in this order, where later entries overwrite earlier ones:
+
+1. Built-in emoji IDs and their aliases
+2. Data-level aliases (`data.aliases`)
+3. Custom emoji IDs
+4. Extra aliases
+
+This means an `extraAliases` entry with the same key as a custom emoji ID will override that custom emoji's shortcode. This is intentional — `extraAliases` acts as the highest-priority override.
+
+## Core API
+
+The `tokenize` function is framework-agnostic and can be used without React.
+
+```ts
+import { tokenize } from 'react-emoji-text/core';
+import data from '@emoji-mart/data';
+
+const tokens = tokenize('hello :wave: world', { data });
+// [
+//   { type: "text", value: "hello " },
+//   { type: "emoji", emoji: {...}, native: "👋", source: "shortcode", ... },
+//   { type: "text", value: " world" },
+// ]
+```
+
+### TokenizeOptions
+
+| Option         | Type                     | Default    | Description                   |
+| -------------- | ------------------------ | ---------- | ----------------------------- |
+| `data`         | `EmojiData`              | _required_ | Emoji dataset                 |
+| `customEmojis` | `CustomEmojiCategory[]`  | —          | Custom emoji categories       |
+| `ascii`        | `boolean`                | `true`     | Match ASCII emoticons         |
+| `defaultSkin`  | `SkinTone`               | —          | Default skin tone             |
+| `extraAliases` | `Record<string, string>` | —          | Additional shortcode mappings |
+
+### Token Types
+
+```ts
+type Token = TextToken | EmojiToken | UnknownToken;
+
+type TextToken = { type: 'text'; value: string };
+
+type EmojiToken = {
+  type: 'emoji';
+  emoji: EmojiEntry;
+  native: string;
+  skin?: SkinTone;
+  shortcode?: string;
+  match: string;
+  source: 'unicode' | 'shortcode' | 'ascii' | 'custom';
+};
+
+type UnknownToken = {
+  type: 'unknown';
+  shortcode: string;
+  match: string;
+};
+```
+
+## Compat API
+
+A drop-in replacement for `react-emoji-render`. Pass adapted emoji data directly via `options` — no provider needed. Works with both `@emoji-mart/data` and `emojibase-data`.
+
+### Emoji Component
+
+#### With @emoji-mart/data
+
+```tsx
+import emojiMartData from '@emoji-mart/data';
+import { fromEmojiMart } from 'react-emoji-text/adapters/emoji-mart';
+import Emoji from 'react-emoji-text/compat';
+
+const data = fromEmojiMart(emojiMartData);
+
+<Emoji text="hello :wave:" options={{ data }} />
+<Emoji text=":wave:" onlyEmojiClassName="jumbo" options={{ data }} />
+<Emoji text=":wave:" svg options={{ data, imageUrlTemplate: "/emoji/{set}/{unified}.png" }} />
+```
+
+#### With emojibase
+
+```tsx
+import emojis from 'emojibase-data/en/data.json';
+import shortcodes from 'emojibase-data/en/shortcodes/emojibase.json';
+import { fromEmojibase } from 'react-emoji-text/adapters/emojibase';
+import Emoji from 'react-emoji-text/compat';
+
+const data = fromEmojibase(emojis, { shortcodes });
+
+<Emoji text="hello :wave:" options={{ data }} />;
+```
+
+| Prop                 | Type                   | Default    | Description                               |
+| -------------------- | ---------------------- | ---------- | ----------------------------------------- |
+| `text`               | `string`               | _required_ | Source text                               |
+| `onlyEmojiClassName` | `string`               | —          | Class when content is only emojis         |
+| `svg`                | `boolean`              | —          | When `true`, uses the `"apple"` image set |
+| `options`            | `CompatOptions`        | _required_ | Tokenize and render options               |
+| `ref`                | `Ref<HTMLSpanElement>` | —          | Forwarded ref                             |
+
+All additional HTML attributes are forwarded to the wrapper `<span>`.
+
+### toArray
+
+Returns an array of strings and React elements for manual rendering:
+
+```ts
+import { toArray } from 'react-emoji-text/compat';
+
+const elements = toArray('hello :wave:', { data });
+// ["hello ", <span title="wave">👋</span>]
+```
+
+Accepts the same `CompatOptions` as the `Emoji` component's `options` prop.
+
+### Wrapper Pattern
+
+Create a thin wrapper to pre-configure the data source, then use it everywhere without repeating the adapter setup:
+
+```tsx
+// emoji.tsx
+import emojiMartData from '@emoji-mart/data';
+import { fromEmojiMart } from 'react-emoji-text/adapters/emoji-mart';
+import BaseEmoji, { toArray as baseToArray } from 'react-emoji-text/compat';
+import type { EmojiProps } from 'react-emoji-text/compat';
+
+const data = fromEmojiMart(emojiMartData);
+
+export default function Emoji(props: Omit<EmojiProps, 'options'>) {
+  return <BaseEmoji {...props} options={{ data }} />;
+}
+
+export function toArray(text: string) {
+  return baseToArray(text, { data });
+}
+```
+
+```tsx
+// usage
+import Emoji, { toArray } from './emoji';
+
+<Emoji text="hello :wave:" />;
+toArray('hello :wave:');
+```

package/dist/adapters/emoji-mart.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/adapters/emoji-mart.ts
+function fromEmojiMart(data) {
+	const record = data;
+	if (!record.emojis || !record.aliases || !record.categories) throw new Error("Invalid @emoji-mart/data: expected \"emojis\", \"aliases\", and \"categories\" fields");
+	return data;
+}
+//#endregion
+exports.fromEmojiMart = fromEmojiMart;

package/dist/adapters/emoji-mart.d.cts

@@ -0,0 +1,7 @@
+import { i as EmojiData } from "../types-Dyzdpq-R.cjs";
+
+//#region src/adapters/emoji-mart.d.ts
+declare function fromEmojiMart(data: unknown): EmojiData;
+//#endregion
+export { fromEmojiMart };
+//# sourceMappingURL=emoji-mart.d.cts.map

package/dist/adapters/emoji-mart.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emoji-mart.d.cts","names":[],"sources":["../../src/adapters/emoji-mart.ts"],"mappings":";;;iBAEgB,aAAA,CAAc,IAAA,YAAgB,SAAA"}

package/dist/adapters/emoji-mart.d.mts

@@ -0,0 +1,7 @@
+import { i as EmojiData } from "../types-o0mRO30y.mjs";
+
+//#region src/adapters/emoji-mart.d.ts
+declare function fromEmojiMart(data: unknown): EmojiData;
+//#endregion
+export { fromEmojiMart };
+//# sourceMappingURL=emoji-mart.d.mts.map

package/dist/adapters/emoji-mart.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emoji-mart.d.mts","names":[],"sources":["../../src/adapters/emoji-mart.ts"],"mappings":";;;iBAEgB,aAAA,CAAc,IAAA,YAAgB,SAAA"}

package/dist/adapters/emoji-mart.mjs

@@ -0,0 +1,10 @@
+//#region src/adapters/emoji-mart.ts
+function fromEmojiMart(data) {
+	const record = data;
+	if (!record.emojis || !record.aliases || !record.categories) throw new Error("Invalid @emoji-mart/data: expected \"emojis\", \"aliases\", and \"categories\" fields");
+	return data;
+}
+//#endregion
+export { fromEmojiMart };
+
+//# sourceMappingURL=emoji-mart.mjs.map

package/dist/adapters/emoji-mart.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"emoji-mart.mjs","names":[],"sources":["../../src/adapters/emoji-mart.ts"],"sourcesContent":["import type { EmojiData } from '../core/types';\n\nexport function fromEmojiMart(data: unknown): EmojiData {\n  const record = data as Record<string, unknown>;\n  if (!record.emojis || !record.aliases || !record.categories) {\n    throw new Error(\n      'Invalid @emoji-mart/data: expected \"emojis\", \"aliases\", and \"categories\" fields',\n    );\n  }\n  return data as EmojiData;\n}\n"],"mappings":";AAEA,SAAgB,cAAc,MAA0B;CACtD,MAAM,SAAS;AACf,KAAI,CAAC,OAAO,UAAU,CAAC,OAAO,WAAW,CAAC,OAAO,WAC/C,OAAM,IAAI,MACR,wFACD;AAEH,QAAO"}

package/dist/adapters/emojibase.cjs

@@ -0,0 +1,71 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/adapters/emojibase.ts
+const GROUP_NAMES = {
+	0: "smileys-emotion",
+	1: "people-body",
+	2: "component",
+	3: "animals-nature",
+	4: "food-drink",
+	5: "travel-places",
+	6: "activities",
+	7: "objects",
+	8: "symbols",
+	9: "flags"
+};
+function getNative(entry) {
+	return "emoji" in entry ? entry.emoji : entry.unicode;
+}
+function resolveShortcodes(hexcode, shortcodesMap) {
+	if (!shortcodesMap) return [];
+	const value = shortcodesMap[hexcode];
+	if (!value) return [];
+	return Array.isArray(value) ? value : [value];
+}
+function toSkin(entry) {
+	return {
+		unified: entry.hexcode,
+		native: getNative(entry)
+	};
+}
+function fromEmojibase(emojis, options) {
+	const shortcodesMap = options?.shortcodes;
+	const emojiRecord = {};
+	const aliases = {};
+	const categoryBuckets = /* @__PURE__ */ new Map();
+	for (const raw of emojis) {
+		const codes = resolveShortcodes(raw.hexcode, shortcodesMap);
+		const emojiId = codes[0] ?? raw.hexcode;
+		const skins = [toSkin(raw)];
+		if (raw.skins) for (const skinVariant of raw.skins) skins.push(toSkin(skinVariant));
+		const entryAliases = codes.length > 1 ? codes.slice(1) : void 0;
+		emojiRecord[emojiId] = {
+			id: emojiId,
+			name: raw.label,
+			keywords: raw.tags ?? [],
+			skins,
+			aliases: entryAliases
+		};
+		if (entryAliases) for (const alias of entryAliases) aliases[alias] = emojiId;
+		const emoticons = raw.emoticon ? Array.isArray(raw.emoticon) ? raw.emoticon : [raw.emoticon] : [];
+		for (const emoticon of emoticons) aliases[emoticon] = emojiId;
+		if (raw.group !== void 0) {
+			const categoryName = GROUP_NAMES[raw.group] ?? `group-${String(raw.group)}`;
+			let bucket = categoryBuckets.get(categoryName);
+			if (!bucket) {
+				bucket = [];
+				categoryBuckets.set(categoryName, bucket);
+			}
+			bucket.push(emojiId);
+		}
+	}
+	return {
+		emojis: emojiRecord,
+		aliases,
+		categories: Array.from(categoryBuckets, ([id, emojiIds]) => ({
+			id,
+			emojis: emojiIds
+		}))
+	};
+}
+//#endregion
+exports.fromEmojibase = fromEmojibase;

package/dist/adapters/emojibase.d.cts

@@ -0,0 +1,38 @@
+import { i as EmojiData } from "../types-Dyzdpq-R.cjs";
+
+//#region src/adapters/types.d.ts
+interface EmojibaseEmoji {
+  label: string;
+  hexcode: string;
+  emoji: string;
+  text: string;
+  type: number;
+  order?: number;
+  group?: number;
+  subgroup?: number;
+  version: number;
+  tags?: string[];
+  emoticon?: string | string[];
+  skins?: EmojibaseEmoji[];
+  tone?: number | number[];
+}
+interface EmojibaseCompactEmoji {
+  label: string;
+  hexcode: string;
+  unicode: string;
+  order?: number;
+  group?: number;
+  tags?: string[];
+  emoticon?: string | string[];
+  skins?: EmojibaseCompactEmoji[];
+}
+type EmojibaseShortcodes = Record<string, string | string[]>;
+//#endregion
+//#region src/adapters/emojibase.d.ts
+interface FromEmojibaseOptions {
+  shortcodes?: EmojibaseShortcodes;
+}
+declare function fromEmojibase(emojis: EmojibaseEmoji[] | EmojibaseCompactEmoji[], options?: FromEmojibaseOptions): EmojiData;
+//#endregion
+export { fromEmojibase };
+//# sourceMappingURL=emojibase.d.cts.map

package/dist/adapters/emojibase.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emojibase.d.cts","names":[],"sources":["../../src/adapters/types.ts","../../src/adapters/emojibase.ts"],"mappings":";;;UAAiB,cAAA;EACf,KAAA;EACA,OAAA;EACA,KAAA;EACA,IAAA;EACA,IAAA;EACA,KAAA;EACA,KAAA;EACA,QAAA;EACA,OAAA;EACA,IAAA;EACA,QAAA;EACA,KAAA,GAAQ,cAAA;EACR,IAAA;AAAA;AAAA,UAGe,qBAAA;EACf,KAAA;EACA,OAAA;EACA,OAAA;EACA,KAAA;EACA,KAAA;EACA,IAAA;EACA,QAAA;EACA,KAAA,GAAQ,qBAAA;AAAA;AAAA,KAGE,mBAAA,GAAsB,MAAA;;;UCXxB,oBAAA;EACR,UAAA,GAAa,mBAAA;AAAA;AAAA,iBAwBC,aAAA,CACd,MAAA,EAAQ,cAAA,KAAmB,qBAAA,IAC3B,OAAA,GAAU,oBAAA,GACT,SAAA"}

package/dist/adapters/emojibase.d.mts

@@ -0,0 +1,38 @@
+import { i as EmojiData } from "../types-o0mRO30y.mjs";
+
+//#region src/adapters/types.d.ts
+interface EmojibaseEmoji {
+  label: string;
+  hexcode: string;
+  emoji: string;
+  text: string;
+  type: number;
+  order?: number;
+  group?: number;
+  subgroup?: number;
+  version: number;
+  tags?: string[];
+  emoticon?: string | string[];
+  skins?: EmojibaseEmoji[];
+  tone?: number | number[];
+}
+interface EmojibaseCompactEmoji {
+  label: string;
+  hexcode: string;
+  unicode: string;
+  order?: number;
+  group?: number;
+  tags?: string[];
+  emoticon?: string | string[];
+  skins?: EmojibaseCompactEmoji[];
+}
+type EmojibaseShortcodes = Record<string, string | string[]>;
+//#endregion
+//#region src/adapters/emojibase.d.ts
+interface FromEmojibaseOptions {
+  shortcodes?: EmojibaseShortcodes;
+}
+declare function fromEmojibase(emojis: EmojibaseEmoji[] | EmojibaseCompactEmoji[], options?: FromEmojibaseOptions): EmojiData;
+//#endregion
+export { fromEmojibase };
+//# sourceMappingURL=emojibase.d.mts.map

package/dist/adapters/emojibase.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emojibase.d.mts","names":[],"sources":["../../src/adapters/types.ts","../../src/adapters/emojibase.ts"],"mappings":";;;UAAiB,cAAA;EACf,KAAA;EACA,OAAA;EACA,KAAA;EACA,IAAA;EACA,IAAA;EACA,KAAA;EACA,KAAA;EACA,QAAA;EACA,OAAA;EACA,IAAA;EACA,QAAA;EACA,KAAA,GAAQ,cAAA;EACR,IAAA;AAAA;AAAA,UAGe,qBAAA;EACf,KAAA;EACA,OAAA;EACA,OAAA;EACA,KAAA;EACA,KAAA;EACA,IAAA;EACA,QAAA;EACA,KAAA,GAAQ,qBAAA;AAAA;AAAA,KAGE,mBAAA,GAAsB,MAAA;;;UCXxB,oBAAA;EACR,UAAA,GAAa,mBAAA;AAAA;AAAA,iBAwBC,aAAA,CACd,MAAA,EAAQ,cAAA,KAAmB,qBAAA,IAC3B,OAAA,GAAU,oBAAA,GACT,SAAA"}