emoji-picker-react 4.22.3 → 5.0.0

package/dist/data/registerDefaultEmojiData.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/data/registerDefaultEmojiData.js

@@ -0,0 +1,3 @@
+import { registerDefaultEmojiData } from './defaultEmojiData';
+import emojis from './emojis';
+registerDefaultEmojiData(emojis);

package/dist/data-core/pickerData.d.ts

@@ -0,0 +1,12 @@
+import type { CustomEmoji } from '../config/customEmojiConfig';
+import { DataEmoji, DataEmojis } from '../dataUtils/DataTypes';
+import { type EmojiData } from '../types/exposedTypes';
+export interface PickerDataSnapshot {
+    emojiData: EmojiData;
+    allEmojis: DataEmojis;
+    allEmojisByUnified: Record<string, DataEmoji>;
+    customGroups: Record<string, DataEmojis>;
+}
+export declare function getPickerDataSnapshot(genericEmojiData?: EmojiData, customEmojis?: CustomEmoji[]): PickerDataSnapshot;
+/** Test-only: expose cache state without breaking WeakMap encapsulation. */
+export declare function __isSnapshotCached(genericEmojiData?: EmojiData, customEmojis?: CustomEmoji[]): boolean;

package/dist/data-core/prepare.d.ts

@@ -0,0 +1,23 @@
+import type { EmojiData } from '../types/exposedTypes';
+import type { EmojiInfo } from './types';
+export interface PreparedCore {
+    /** Stable dataset order of canonical base records. */
+    readonly records: readonly EmojiInfo[];
+    /** Base unified -> record plus variation unified -> base record. */
+    readonly byUnified: ReadonlyMap<string, EmojiInfo>;
+    /**
+     * Single-character bucket: char -> base records whose joined lowercase
+     * names include it, in dataset order. Preserves v4's useful O(1)
+     * first-keystroke narrowing on top of the shared immutable core, so
+     * cold single-char queries never pay a full scan.
+     */
+    readonly byChar: ReadonlyMap<string, readonly EmojiInfo[]>;
+    /** Per-core query memo: normalized query -> matching records. */
+    readonly queryMemo: Map<string, readonly EmojiInfo[]>;
+}
+export declare function __getPrepareCount(): number;
+export declare function __resetPrepareCount(): void;
+export declare function __clearCoreCacheForTest(): void;
+export declare function normalizeUnified(input: string): string;
+export declare function normalizeQuery(input: string): string;
+export declare function getPreparedCore(emojiData?: EmojiData): PreparedCore;

package/dist/data-core/search.d.ts

@@ -0,0 +1,13 @@
+import type { EmojiDataOptions, EmojiInfo } from './types';
+export type { EmojiDataOptions, EmojiInfo };
+/**
+ * Lookup by base or variation unified code.
+ * Trims/lowercases input, returns the canonical base record or undefined.
+ */
+export declare function getEmojiByUnified(unified: string, options?: EmojiDataOptions): EmojiInfo | undefined;
+/**
+ * Dataset search (not a snapshot of one picker instance's visible results).
+ * Picker-only layers such as emojiVersion/hiddenEmojis/customEmojis are
+ * intentionally not applied here; they remain Root-local filters.
+ */
+export declare function searchEmojis(query: string, options?: EmojiDataOptions): readonly EmojiInfo[];

package/dist/data-core/types.d.ts

@@ -0,0 +1,23 @@
+import type { EmojiData } from '../types/exposedTypes';
+export type { EmojiData };
+export type EmojiInfo = Readonly<{
+    /** Canonical/base lowercase unified code. */
+    unified: string;
+    /** The native emoji text for `unified`, ready to insert or render. */
+    emoji: string;
+    /** Display name: the dataset's full name (the last of `names`). */
+    name: string;
+    /** Search/display names in dataset order. */
+    names: readonly string[];
+    /** Lowercase unified codes for supported variations. */
+    variations: readonly string[];
+    /** Unicode/emoji version from the dataset. */
+    addedIn: string;
+}>;
+export type EmojiDataOptions = Readonly<{
+    /**
+     * Optional dataset in the same shape accepted by the picker's emojiData prop.
+     * Omit for the packaged default English dataset.
+     */
+    emojiData?: EmojiData;
+}>;

package/dist/data.d.mts

@@ -0,0 +1,72 @@
+import * as React from 'react';
+
+type CategoryConfig = {
+    category: Categories;
+    name: string;
+    icon?: React.ReactNode;
+    /**
+     * Selects a `CustomEmoji` group for `Categories.CUSTOM` entries. Each
+     * grouped entry renders its own section and nav tab; ungrouped entries
+     * share the classic customs bucket.
+     */
+    group?: string;
+};
+type EmojiData = {
+    categories: Partial<Record<Categories, CategoryConfig>>;
+    emojis: Record<string, DataEmoji[]>;
+};
+interface DataEmoji {
+    n: string[];
+    u: string;
+    v?: string[];
+    a: string;
+}
+declare enum Categories {
+    SUGGESTED = "suggested",
+    CUSTOM = "custom",
+    SMILEYS_PEOPLE = "smileys_people",
+    ANIMALS_NATURE = "animals_nature",
+    FOOD_DRINK = "food_drink",
+    TRAVEL_PLACES = "travel_places",
+    ACTIVITIES = "activities",
+    OBJECTS = "objects",
+    SYMBOLS = "symbols",
+    FLAGS = "flags"
+}
+
+type EmojiInfo = Readonly<{
+    /** Canonical/base lowercase unified code. */
+    unified: string;
+    /** The native emoji text for `unified`, ready to insert or render. */
+    emoji: string;
+    /** Display name: the dataset's full name (the last of `names`). */
+    name: string;
+    /** Search/display names in dataset order. */
+    names: readonly string[];
+    /** Lowercase unified codes for supported variations. */
+    variations: readonly string[];
+    /** Unicode/emoji version from the dataset. */
+    addedIn: string;
+}>;
+type EmojiDataOptions = Readonly<{
+    /**
+     * Optional dataset in the same shape accepted by the picker's emojiData prop.
+     * Omit for the packaged default English dataset.
+     */
+    emojiData?: EmojiData;
+}>;
+
+/**
+ * Lookup by base or variation unified code.
+ * Trims/lowercases input, returns the canonical base record or undefined.
+ */
+declare function getEmojiByUnified(unified: string, options?: EmojiDataOptions): EmojiInfo | undefined;
+/**
+ * Dataset search (not a snapshot of one picker instance's visible results).
+ * Picker-only layers such as emojiVersion/hiddenEmojis/customEmojis are
+ * intentionally not applied here; they remain Root-local filters.
+ */
+declare function searchEmojis(query: string, options?: EmojiDataOptions): readonly EmojiInfo[];
+
+export { getEmojiByUnified, searchEmojis };
+export type { EmojiData, EmojiDataOptions, EmojiInfo };

package/dist/data.d.ts

@@ -0,0 +1,72 @@
+import * as React from 'react';
+
+type CategoryConfig = {
+    category: Categories;
+    name: string;
+    icon?: React.ReactNode;
+    /**
+     * Selects a `CustomEmoji` group for `Categories.CUSTOM` entries. Each
+     * grouped entry renders its own section and nav tab; ungrouped entries
+     * share the classic customs bucket.
+     */
+    group?: string;
+};
+type EmojiData = {
+    categories: Partial<Record<Categories, CategoryConfig>>;
+    emojis: Record<string, DataEmoji[]>;
+};
+interface DataEmoji {
+    n: string[];
+    u: string;
+    v?: string[];
+    a: string;
+}
+declare enum Categories {
+    SUGGESTED = "suggested",
+    CUSTOM = "custom",
+    SMILEYS_PEOPLE = "smileys_people",
+    ANIMALS_NATURE = "animals_nature",
+    FOOD_DRINK = "food_drink",
+    TRAVEL_PLACES = "travel_places",
+    ACTIVITIES = "activities",
+    OBJECTS = "objects",
+    SYMBOLS = "symbols",
+    FLAGS = "flags"
+}
+
+type EmojiInfo = Readonly<{
+    /** Canonical/base lowercase unified code. */
+    unified: string;
+    /** The native emoji text for `unified`, ready to insert or render. */
+    emoji: string;
+    /** Display name: the dataset's full name (the last of `names`). */
+    name: string;
+    /** Search/display names in dataset order. */
+    names: readonly string[];
+    /** Lowercase unified codes for supported variations. */
+    variations: readonly string[];
+    /** Unicode/emoji version from the dataset. */
+    addedIn: string;
+}>;
+type EmojiDataOptions = Readonly<{
+    /**
+     * Optional dataset in the same shape accepted by the picker's emojiData prop.
+     * Omit for the packaged default English dataset.
+     */
+    emojiData?: EmojiData;
+}>;
+
+/**
+ * Lookup by base or variation unified code.
+ * Trims/lowercases input, returns the canonical base record or undefined.
+ */
+declare function getEmojiByUnified(unified: string, options?: EmojiDataOptions): EmojiInfo | undefined;
+/**
+ * Dataset search (not a snapshot of one picker instance's visible results).
+ * Picker-only layers such as emojiVersion/hiddenEmojis/customEmojis are
+ * intentionally not applied here; they remain Root-local filters.
+ */
+declare function searchEmojis(query: string, options?: EmojiDataOptions): readonly EmojiInfo[];
+
+export { getEmojiByUnified, searchEmojis };
+export type { EmojiData, EmojiDataOptions, EmojiInfo };

package/dist/dataUtils/DataTypes.d.ts

@@ -1,19 +1,23 @@
-import { Categories } from '../types/exposedTypes';
-export declare enum EmojiProperties {
-    name = "n",
-    unified = "u",
-    variations = "v",
-    added_in = "a",
-    imgUrl = "imgUrl"
-}
-export interface DataEmoji extends WithName {
-    [EmojiProperties.unified]: string;
-    [EmojiProperties.variations]?: string[];
-    [EmojiProperties.added_in]: string;
-    [EmojiProperties.imgUrl]?: string;
-}
-export declare type DataEmojis = DataEmoji[];
-export declare type DataGroups = Categories;
-export declare type WithName = {
-    [EmojiProperties.name]: string[];
-};
+import { Categories } from '../types/exposedTypes';
+export declare enum EmojiProperties {
+    name = "n",
+    unified = "u",
+    variations = "v",
+    added_in = "a",
+    imgUrl = "imgUrl"
+}
+export interface DataEmoji extends WithName {
+    /** Exact rendered identity; canonical unified remains the search identity. */
+    renderUnified?: string;
+    /** Stored recent identity when the active tone has no matching variation. */
+    fallbackUnified?: string;
+    [EmojiProperties.unified]: string;
+    [EmojiProperties.variations]?: string[];
+    [EmojiProperties.added_in]: string;
+    [EmojiProperties.imgUrl]?: string;
+}
+export type DataEmojis = DataEmoji[];
+export type DataGroups = Categories;
+export type WithName = {
+    [EmojiProperties.name]: string[];
+};

package/dist/dataUtils/emojiSelectors.d.ts

@@ -1,16 +1,15 @@
-import { CustomEmoji } from '../config/customEmojiConfig';
-import { EmojiStyle, SkinTones } from '../types/exposedTypes';
-import { DataEmoji, DataEmojis, WithName } from './DataTypes';
-export declare function emojiNames(emoji: WithName): string[];
-export declare function addedIn(emoji: DataEmoji): number;
-export declare function emojiName(emoji?: WithName): string;
-export declare function unifiedWithoutSkinTone(unified: string): string;
-export declare function emojiUnified(emoji: DataEmoji, skinTone?: string): string;
-export declare function emojiUrlByUnified(unified: string, emojiStyle: EmojiStyle): string;
-export declare function emojiVariations(emoji: DataEmoji): string[];
-export declare function emojiHasVariations(emoji: DataEmoji): boolean;
-export declare function emojiVariationUnified(emoji: DataEmoji, skinTone?: string): string | undefined;
-export declare function emojiByUnified(unified?: string): DataEmoji | undefined;
-export declare const allEmojis: DataEmojis;
-export declare function setCustomEmojis(customEmojis: CustomEmoji[]): void;
-export declare function activeVariationFromUnified(unified: string): SkinTones | null;
+import { EmojiStyleValue, SkinTones } from '../types/exposedTypes';
+import { DataEmoji, WithName } from './DataTypes';
+export declare function emojiNames(emoji: WithName): string[];
+export declare function addedIn(emoji: DataEmoji): number;
+export declare function emojiName(emoji?: WithName): string;
+export declare function unifiedWithoutSkinTone(unified: string): string;
+export declare function emojiCanonicalUnified(emoji: DataEmoji): string;
+export declare function emojiUnified(emoji: DataEmoji, skinTone?: string): string;
+export declare function emojiUrlByUnified(unified: string, emojiStyle: EmojiStyleValue): string;
+export declare function emojiVariations(emoji: DataEmoji): string[];
+export declare function emojiHasVariations(emoji: DataEmoji): boolean;
+export declare function emojiVariationUnified(emoji: DataEmoji, skinTone?: string): string | undefined;
+export declare function emojiByUnified(unified?: string): DataEmoji | undefined;
+export declare function activeVariationFromUnified(unified: string): SkinTones | null;
+export declare function skinToneFromEmoji(emoji: DataEmoji, unified: string, activeTone: SkinTones): SkinTones;

package/dist/dataUtils/emojiUtils.d.ts

@@ -1,12 +1 @@
-import { EmojiStyle, SkinTones } from '../types/exposedTypes';
-import { DataEmoji, WithName } from './DataTypes';
-export declare function emojiNames(emoji: WithName): string[];
-export declare function addedIn(emoji: DataEmoji): number;
-export declare function emojiName(emoji?: WithName): string;
-export declare function unifiedWithoutSkinTone(unified: string): string;
-export declare function emojiUnified(emoji: DataEmoji, skinTone?: string): string;
-export declare function emojiUrlByUnified(unified: string, emojiStyle: EmojiStyle): string;
-export declare function emojiVariations(emoji: DataEmoji): string[];
-export declare function emojiHasVariations(emoji: DataEmoji): boolean;
-export declare function emojiVariationUnified(emoji: DataEmoji, skinTone?: string): string | undefined;
-export declare function activeVariationFromUnified(unified: string): SkinTones | null;
+export { activeVariationFromUnified, skinToneFromEmoji, addedIn, emojiHasVariations, emojiName, emojiNames, emojiUnified, emojiCanonicalUnified, emojiUrlByUnified, emojiVariations, emojiVariationUnified, unifiedWithoutSkinTone, } from './emojiSelectors';

package/dist/dataUtils/nativeEmojiSequenceSupport.d.ts

@@ -0,0 +1,10 @@
+export declare const NATIVE_PROBE_BATCH = 64;
+/** One reusable canvas and result cache per detected document/font. */
+export declare function createNativeEmojiSequenceSupport(ctx: CanvasRenderingContext2D, baselineWidth: number): {
+    prime: (ids: Iterable<string>) => void;
+    supports(unified: string): boolean | null;
+    /** Whether an identity was probed (results may still be null). */
+    has: (unified: string) => boolean;
+    /** Frozen results so far. Unprobed identities read as undefined. */
+    snapshot(): (unified: string) => boolean | null | undefined;
+};

package/dist/dataUtils/nativeEmojiSupport.d.ts

@@ -0,0 +1,40 @@
+import { createNativeEmojiSequenceSupport } from './nativeEmojiSequenceSupport';
+export declare const DEFAULT_NATIVE_EMOJI_FONT = "\"Segoe UI Emoji\", \"Segoe UI Symbol\", \"Segoe UI\", \"Apple Color Emoji\", \"Twemoji Mozilla\", \"Noto Color Emoji\", \"EmojiOne Color\", \"Android Emoji\"";
+export type NativeEmojiProbe = ReturnType<typeof createNativeEmojiSequenceSupport>;
+/**
+ * Platform support as filtering reads it. `supports` returns a probed
+ * identity's exact result (null when inconclusive, undefined when not
+ * probed yet); the version and flag fields predict the rest.
+ */
+export type NativeEmojiSupport = {
+    supports: (unified: string) => boolean | null | undefined;
+    /** Emoji versions whose sample the font cannot draw. */
+    failedVersions: Set<number>;
+    countryFlags: boolean;
+};
+export declare const UNKNOWN_SUPPORT: {};
+/**
+ * Probes the font synchronously, sampling versions and flags only.
+ * Exact sequence results accumulate on the returned probe through
+ * `prime`, which pickers call in background batches.
+ */
+export declare function detectNativeEmojiSupport(fontFamily?: string, refresh?: boolean, ownerDocument?: Document | undefined): NativeEmojiProbe | typeof UNKNOWN_SUPPORT;
+/**
+ * Whether a rendered identity should show. An exact result wins; until
+ * one exists, flags and emojis of a version whose sample failed are
+ * predicted unsupported. `addedIn` is the emoji's version, when known.
+ */
+export declare function isNativeEmojiSupported(support: NativeEmojiSupport | null, unified: string, addedIn?: number): boolean;
+/** The picker's view of a probe: frozen results, never drawing. */
+/**
+ * The picker's view of a probe: frozen results, never drawing, plus a
+ * prediction for identities not checked yet. `samples` maps each emoji
+ * version to one emoji introduced in it. Versions are judged one by one:
+ * fonts often draw a newer version's single glyphs but not an older
+ * version's sequences.
+ */
+export declare function nativeSupportSnapshot(probe: NativeEmojiProbe, samples: Map<number, string>): NativeEmojiSupport;
+/** Test-only: forget cached probe results. */
+export declare function __resetNativeEmojiSupportForTest(): void;
+/** Whether a unified code is a regional-indicator country flag. */
+export declare function isCountryFlagUnified(unified: string): boolean;

package/dist/dataUtils/parseNativeEmoji.d.ts

@@ -1 +1 @@
-export declare function parseNativeEmoji(unified: string): string;
+export declare function parseNativeEmoji(unified: string): string;

package/dist/dataUtils/suggested.d.ts

@@ -1,11 +1,11 @@
-import { SkinTones, SuggestionMode } from '../types/exposedTypes';
-import { DataEmoji } from './DataTypes';
-declare type SuggestedItem = {
-    unified: string;
-    original: string;
-    count: number;
-};
-declare type Suggested = SuggestedItem[];
-export declare function getSuggested(mode?: SuggestionMode): Suggested;
-export declare function setSuggested(emoji: DataEmoji, skinTone: SkinTones): void;
-export {};
+import { SkinTones, SuggestionModeValue } from '../types/exposedTypes';
+import { DataEmoji } from './DataTypes';
+type SuggestedItem = {
+    unified: string;
+    original: string;
+    count: number;
+};
+type Suggested = SuggestedItem[];
+export declare function getSuggested(mode?: SuggestionModeValue): Suggested;
+export declare function setSuggested(emoji: DataEmoji, skinTone: SkinTones): void;
+export {};

package/dist/dataUtils/suggestedEmojis.d.ts

@@ -0,0 +1,7 @@
+import { DataEmoji } from './DataTypes';
+export declare function resolveSuggestedRenderIds(entries: readonly string[], lookup: (normalizedId: string) => DataEmoji | undefined): string[];
+/**
+ * A lowercased unified ID, custom ID or emoji character, resolved to a
+ * known render identity (see resolveSuggestedRenderIds).
+ */
+export declare function resolveEntryId(id: string, lookup: (normalizedId: string) => DataEmoji | undefined): string | undefined;

package/dist/esm/chunks/chunk-46BUDQLE.mjs

@@ -0,0 +1,228 @@
+import {
+  __esm
+} from "./chunk-LO4TPPLH.mjs";
+
+// src/data/defaultEmojiData.ts
+function registerDefaultEmojiData(data) {
+  registered = data;
+}
+function getRegisteredDefaultEmojiData() {
+  return registered;
+}
+function defaultEmojiDataOrEmpty() {
+  return registered ?? EMPTY_EMOJI_DATA;
+}
+function loadDefaultEmojiData() {
+  if (registered) {
+    return Promise.resolve(registered);
+  }
+  if (!pending) {
+    pending = import("./emojis-6L3GRBAP.mjs").then((module) => {
+      const data = module.default ?? module;
+      registered = registered ?? data;
+      return registered;
+    }).catch((error) => {
+      pending = null;
+      throw error;
+    });
+  }
+  return pending;
+}
+var registered, EMPTY_EMOJI_DATA, pending;
+var init_defaultEmojiData = __esm({
+  "src/data/defaultEmojiData.ts"() {
+    "use strict";
+    registered = null;
+    EMPTY_EMOJI_DATA = Object.freeze({
+      categories: {},
+      emojis: {}
+    });
+    pending = null;
+  }
+});
+
+// src/data-core/prepare.ts
+init_defaultEmojiData();
+
+// src/dataUtils/parseNativeEmoji.ts
+function parseNativeEmoji(unified) {
+  return unified.split("-").map((hex) => String.fromCodePoint(parseInt(hex, 16))).join("");
+}
+
+// src/data-core/prepare.ts
+var coreCache = /* @__PURE__ */ new WeakMap();
+var prepareCount = 0;
+function normalizeUnified(input) {
+  return input.trim().toLowerCase();
+}
+function normalizeQuery(input) {
+  if (!input || typeof input !== "string") {
+    return "";
+  }
+  return input.trim().toLowerCase();
+}
+function toEmojiInfo(unified, names, variations, addedIn) {
+  return Object.freeze({
+    unified,
+    emoji: parseNativeEmoji(unified),
+    name: names[names.length - 1] || "",
+    names: Object.freeze([...names]),
+    variations: Object.freeze([...variations ?? []]),
+    addedIn
+  });
+}
+function readStringArray(raw) {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.filter((n) => typeof n === "string").map(
+    (n) => n.toLowerCase()
+  );
+}
+function appendEntry(byUnified, byCharMutable, records, entry) {
+  const rawUnified = entry.u;
+  if (typeof rawUnified !== "string" || rawUnified.length === 0) {
+    return;
+  }
+  const unified = rawUnified.toLowerCase();
+  if (byUnified.has(unified)) {
+    return;
+  }
+  const names = readStringArray(entry.n);
+  const variations = readStringArray(entry.v);
+  const rawAddedIn = entry.a;
+  const addedIn = typeof rawAddedIn === "string" ? rawAddedIn : String(rawAddedIn ?? "");
+  const info = toEmojiInfo(unified, names, variations, addedIn);
+  records.push(info);
+  byUnified.set(unified, info);
+  for (const variation of info.variations) {
+    if (!byUnified.has(variation)) {
+      byUnified.set(variation, info);
+    }
+  }
+  indexCharBucket(byCharMutable, names, info);
+}
+function indexCharBucket(byCharMutable, names, info) {
+  const distinctChars = Array.from(new Set(names.join("")));
+  for (const char of distinctChars) {
+    const bucket = byCharMutable.get(char);
+    if (bucket) {
+      bucket.push(info);
+    } else {
+      byCharMutable.set(char, [info]);
+    }
+  }
+}
+function getPreparedCore(emojiData) {
+  const source = emojiData ?? defaultEmojiDataOrEmpty();
+  const cached = coreCache.get(source);
+  if (cached) {
+    return cached;
+  }
+  prepareCount += 1;
+  const byUnified = /* @__PURE__ */ new Map();
+  const byCharMutable = /* @__PURE__ */ new Map();
+  const records = [];
+  const groups = source.emojis ?? {};
+  for (const key of Object.keys(groups)) {
+    const list = groups[key] ?? [];
+    for (const entry of list) {
+      appendEntry(byUnified, byCharMutable, records, entry);
+    }
+  }
+  const byChar = /* @__PURE__ */ new Map();
+  byCharMutable.forEach((bucket, char) => {
+    byChar.set(char, Object.freeze(bucket));
+  });
+  const core = {
+    records,
+    byUnified,
+    byChar,
+    queryMemo: /* @__PURE__ */ new Map()
+  };
+  coreCache.set(source, core);
+  return core;
+}
+
+// src/data-core/search.ts
+var EMPTY_RESULTS = Object.freeze([]);
+var MAX_QUERY_MEMO_SIZE = 500;
+function memoizeQuery(core, normalized, results) {
+  const memo = core.queryMemo;
+  if (memo.has(normalized)) {
+    memo.delete(normalized);
+  } else if (memo.size >= MAX_QUERY_MEMO_SIZE) {
+    const oldest = memo.keys().next();
+    if (!oldest.done) {
+      memo.delete(oldest.value);
+    }
+  }
+  memo.set(normalized, results);
+}
+function smallestCandidateBucket(core, normalized) {
+  let smallest = core.records;
+  for (const char of Array.from(normalized)) {
+    const bucket = core.byChar.get(char);
+    if (!bucket) {
+      return EMPTY_RESULTS;
+    }
+    if (bucket.length < smallest.length) {
+      smallest = bucket;
+    }
+  }
+  return smallest;
+}
+function getEmojiByUnified(unified, options) {
+  if (!unified || typeof unified !== "string") {
+    return void 0;
+  }
+  const normalized = normalizeUnified(unified);
+  if (!normalized) {
+    return void 0;
+  }
+  const core = getPreparedCore(options?.emojiData);
+  return core.byUnified.get(normalized);
+}
+function searchEmojis(query, options) {
+  const normalized = normalizeQuery(query);
+  if (!normalized) {
+    return EMPTY_RESULTS;
+  }
+  const core = getPreparedCore(options?.emojiData);
+  const memoized = core.queryMemo.get(normalized);
+  if (memoized) {
+    memoizeQuery(core, normalized, memoized);
+    return Object.freeze([...memoized]);
+  }
+  if (normalized.length === 1) {
+    const bucket = core.byChar.get(normalized) ?? EMPTY_RESULTS;
+    memoizeQuery(core, normalized, bucket);
+    return Object.freeze([...bucket]);
+  }
+  const matches = [];
+  for (const record of smallestCandidateBucket(core, normalized)) {
+    const names = record.names;
+    for (let i = 0; i < names.length; i += 1) {
+      if (names[i].includes(normalized)) {
+        matches.push(record);
+        break;
+      }
+    }
+  }
+  memoizeQuery(core, normalized, matches);
+  return Object.freeze([...matches]);
+}
+
+export {
+  registerDefaultEmojiData,
+  getRegisteredDefaultEmojiData,
+  EMPTY_EMOJI_DATA,
+  defaultEmojiDataOrEmpty,
+  loadDefaultEmojiData,
+  init_defaultEmojiData,
+  parseNativeEmoji,
+  normalizeQuery,
+  getPreparedCore,
+  getEmojiByUnified,
+  searchEmojis
+};