@sveltia/ui 0.63.1 → 0.65.0

package/dist/components/emoji/emoji-suggestions.svelte.d.ts

@@ -0,0 +1,66 @@
+export default EmojiSuggestions;
+type EmojiSuggestions = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<Props>): void;
+} & {
+    isOpen: () => boolean;
+    close: (dismissed?: boolean | undefined) => void;
+    update: (newTrigger?: EmojiTrigger | undefined) => Promise<void>;
+    moveSelection: (delta: number) => void;
+    selectHighlighted: () => void;
+    handleKeyDown: (event: KeyboardEvent) => boolean;
+};
+/**
+ * The dropdown shown while an emoji shortcode is being typed, along with the state behind it. This
+ * knows nothing about where the text is being typed; a host component detects the shortcode, feeds
+ * it in with {@link update} and applies the chosen emoji through the `onSelect` callback.
+ *
+ * The list is rendered in the top layer with the Popover API, so it’s never clipped by whatever
+ * contains the field, and it never takes the focus, so the user can keep typing to narrow down the
+ * suggestions.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Popover_API
+ */
+declare const EmojiSuggestions: import("svelte").Component<{
+    /**
+     * Get the
+     * viewport-relative bounds of the shortcode being typed, which the dropdown is anchored to.
+     */
+    getAnchorRect: (trigger: EmojiTrigger) => EmojiAnchorRect | undefined;
+    /**
+     * Called with the emoji
+     * the user picked and the shortcode it should replace.
+     */
+    onSelect: (entry: EmojiEntry, trigger: EmojiTrigger) => void;
+    /**
+     * The element holding the caret, which is labelled with the
+     * highlighted suggestion because the focus never moves to the dropdown.
+     */
+    ariaOwner?: HTMLElement | undefined;
+}, {
+    isOpen: () => boolean;
+    close: (dismissed?: boolean | undefined) => void;
+    update: (newTrigger?: EmojiTrigger | undefined) => Promise<void>;
+    moveSelection: (delta: number) => void;
+    selectHighlighted: () => void;
+    handleKeyDown: (event: KeyboardEvent) => boolean;
+}, "">;
+type Props = {
+    /**
+     * Get the
+     * viewport-relative bounds of the shortcode being typed, which the dropdown is anchored to.
+     */
+    getAnchorRect: (trigger: EmojiTrigger) => EmojiAnchorRect | undefined;
+    /**
+     * Called with the emoji
+     * the user picked and the shortcode it should replace.
+     */
+    onSelect: (entry: EmojiEntry, trigger: EmojiTrigger) => void;
+    /**
+     * The element holding the caret, which is labelled with the
+     * highlighted suggestion because the focus never moves to the dropdown.
+     */
+    ariaOwner?: HTMLElement | undefined;
+};
+import type { EmojiTrigger } from '../../typedefs';
+import type { EmojiAnchorRect } from '../../typedefs';
+import type { EmojiEntry } from '../../typedefs';

package/dist/components/emoji/emoji.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @import { EmojiData, EmojiEntry } from '../../typedefs';
+ */
+/**
+ * Regular expression that matches an emoji shortcode being typed at the end of a line, like `:smi`.
+ * The colon must be at the beginning of the text or preceded by a whitespace or an opening bracket,
+ * so a colon in the middle of a word, as in `https://` or `12:34`, doesn’t trigger the suggestions.
+ */
+export const EMOJI_TRIGGER_REGEX: RegExp;
+/**
+ * Maximum number of emoji suggestions shown at a time.
+ */
+export const MAX_EMOJI_SUGGESTIONS: 10;
+export function parseEmojiData(data: EmojiData): EmojiEntry[];
+export function loadEmojiList(): Promise<EmojiEntry[]>;
+/**
+ * Rank given when there is no match at all. Higher than any real rank, so an unmatched emoji sorts
+ * last and the ranks can still be compared arithmetically.
+ */
+export const NO_EMOJI_MATCH: 9;
+export function getEmojiNameMatchRank(name: string, query: string): number;
+export function getEmojiAliasMatchRank(aliases: string[], query: string): number;
+export function getEmojiMatchRank({ name, aliases }: EmojiEntry, query: string): {
+    rank: number;
+    nameRank: number;
+};
+export function searchEmojis(query: string): EmojiEntry[];
+export function getEmojiInsertText(emoji: string, textAfterCaret: string): string;
+export function detectEmojiTrigger(textBeforeCaret: string): string | undefined;
+import type { EmojiData } from '../../typedefs';
+import type { EmojiEntry } from '../../typedefs';

package/dist/components/emoji/emoji.js

@@ -0,0 +1,208 @@
+import { cacheEmojiData, getCachedEmojiData } from './cache.js';
+import { getEmojiDataLoader } from './loader.js';
+
+/**
+ * @import { EmojiData, EmojiEntry } from '../../typedefs';
+ */
+
+/**
+ * Regular expression that matches an emoji shortcode being typed at the end of a line, like `:smi`.
+ * The colon must be at the beginning of the text or preceded by a whitespace or an opening bracket,
+ * so a colon in the middle of a word, as in `https://` or `12:34`, doesn’t trigger the suggestions.
+ */
+export const EMOJI_TRIGGER_REGEX = /(?<=^|[\s([{"'«])(?::)(?<query>[a-zA-Z0-9_+-]{1,32})$/;
+
+/**
+ * Maximum number of emoji suggestions shown at a time.
+ */
+export const MAX_EMOJI_SUGGESTIONS = 10;
+
+/**
+ * Cached emoji list. This is `undefined` until {@link loadEmojiList} resolves for the first time.
+ * @type {EmojiEntry[] | undefined}
+ */
+let emojiList;
+/**
+ * In-flight or completed loader for {@link emojiList}, so the data is only fetched once.
+ * @type {Promise<EmojiEntry[]> | undefined}
+ */
+let loader;
+
+/**
+ * Convert the raw emoji data into a searchable list.
+ * @internal
+ * @param {EmojiData} data Emoji data, keyed by emoji character, with each value listing the name
+ * followed by any keywords.
+ * @returns {EmojiEntry[]} Emoji list.
+ */
+export const parseEmojiData = (data) =>
+  Object.entries(data).map(([emoji, [name, ...aliases]]) => ({
+    emoji,
+    name,
+    // Some of the keywords are capitalized, e.g. `NASA` and `XD`
+    aliases: aliases.map((alias) => alias.toLowerCase()),
+  }));
+
+/**
+ * Load the emoji list, from the local cache if it’s there and from the CDN otherwise.
+ *
+ * The data is a few hundred kilobytes that most sessions never need, so it’s deliberately kept out
+ * of the bundle. A failure here is not worth surfacing: no suggestions are ever shown, and the
+ * shortcode the user typed stays as plain text.
+ * @returns {Promise<EmojiEntry[]>} Emoji list, or an empty list if the data can’t be obtained.
+ */
+export const loadEmojiList = async () => {
+  loader ??= (async () => {
+    try {
+      let data = await getCachedEmojiData();
+
+      if (!data) {
+        data = await getEmojiDataLoader()();
+        // Don’t make the caller wait on the write
+        cacheEmojiData(data);
+      }
+
+      emojiList = parseEmojiData(data);
+    } catch (ex) {
+      // Allow a later attempt to retry, so a transient network failure isn’t permanent
+      loader = undefined;
+      emojiList = [];
+      // eslint-disable-next-line no-console
+      console.error(ex);
+    }
+
+    return /** @type {EmojiEntry[]} */ (emojiList);
+  })();
+
+  return loader;
+};
+
+/**
+ * Rank given when there is no match at all. Higher than any real rank, so an unmatched emoji sorts
+ * last and the ranks can still be compared arithmetically.
+ */
+export const NO_EMOJI_MATCH = 9;
+
+/**
+ * Get how well an emoji’s name matches the given query. A lower rank means a better match.
+ *
+ * The name is matched word by word rather than only as a whole, so a partly typed `:cana` reaches
+ * `flag_canada`’s second word just as `:canada` does. The whole name is tested as well, so a query
+ * spanning a word boundary, like `:flag_can`, still matches.
+ * @internal
+ * @param {string} name Canonical emoji name.
+ * @param {string} query Lower-cased search query without the leading colon.
+ * @returns {number} Rank, or {@link NO_EMOJI_MATCH}.
+ */
+export const getEmojiNameMatchRank = (name, query) => {
+  const words = name.split('_');
+
+  if (name === query) {
+    return 0;
+  }
+
+  if (words.includes(query)) {
+    return 1;
+  }
+
+  if (name.startsWith(query) || words.some((word) => word.startsWith(query))) {
+    return 3;
+  }
+
+  if (name.includes(query)) {
+    return 5;
+  }
+
+  return NO_EMOJI_MATCH;
+};
+
+/**
+ * Get how well an emoji’s keywords match the given query. A lower rank means a better match. The
+ * ranks interleave with {@link getEmojiNameMatchRank}’s: an exact keyword sits between a whole word
+ * of the name and a partial one.
+ * @internal
+ * @param {string[]} aliases Lower-cased alternative keywords.
+ * @param {string} query Lower-cased search query without the leading colon.
+ * @returns {number} Rank, or {@link NO_EMOJI_MATCH}.
+ */
+export const getEmojiAliasMatchRank = (aliases, query) => {
+  if (aliases.includes(query)) {
+    return 2;
+  }
+
+  if (aliases.some((alias) => alias.startsWith(query))) {
+    return 4;
+  }
+
+  return NO_EMOJI_MATCH;
+};
+
+/**
+ * Get how well an emoji matches the given query, as the best of its name and keyword ranks plus the
+ * name rank on its own.
+ *
+ * The name rank is kept so it can break ties, because the name is what the emoji actually depicts
+ * while the keywords are merely associated with it. Many emojis share a keyword — `ca` and `canada`
+ * belong to 🍁, 🇨🇦 and 🫎 alike — and the one that also carries the query in its name,
+ * `flag_canada`, is the one the user is after.
+ * @internal
+ * @param {EmojiEntry} entry Emoji entry.
+ * @param {string} query Lower-cased search query without the leading colon.
+ * @returns {{ rank: number, nameRank: number }} Best rank and name rank, either of which is
+ * {@link NO_EMOJI_MATCH} when there is nothing to match.
+ */
+export const getEmojiMatchRank = ({ name, aliases }, query) => {
+  const nameRank = getEmojiNameMatchRank(name, query);
+  const aliasRank = getEmojiAliasMatchRank(aliases, query);
+
+  return { rank: Math.min(nameRank, aliasRank), nameRank };
+};
+
+/**
+ * Search the loaded emoji list for the given query. This returns an empty list unless
+ * {@link loadEmojiList} has been resolved beforehand.
+ * @param {string} query Search query without the leading colon, e.g. `smi`.
+ * @returns {EmojiEntry[]} Matching emojis, best match first, capped at
+ * {@link MAX_EMOJI_SUGGESTIONS}.
+ */
+export const searchEmojis = (query) => {
+  const normalizedQuery = query.toLowerCase();
+
+  if (!emojiList || !normalizedQuery) {
+    return [];
+  }
+
+  return (
+    emojiList
+      .map((entry) => ({ entry, ...getEmojiMatchRank(entry, normalizedQuery) }))
+      .filter(({ rank }) => rank < NO_EMOJI_MATCH)
+      // Equally ranked emojis are settled by the name, then by the original order, which roughly
+      // goes from the most to the least commonly used — `Array.prototype.sort()` is stable
+      .sort((a, b) => a.rank - b.rank || a.nameRank - b.nameRank)
+      .slice(0, MAX_EMOJI_SUGGESTIONS)
+      .map(({ entry }) => entry)
+  );
+};
+
+/**
+ * Get the text to insert in place of a shortcode.
+ *
+ * A space follows the emoji, so the user can carry straight on typing the next word, the way it
+ * works on GitHub, Slack and Discord. It’s left out when the caret is already followed by
+ * whitespace, which would otherwise leave a double space behind.
+ * @param {string} emoji Emoji character.
+ * @param {string} textAfterCaret Text between the caret and the end of the line.
+ * @returns {string} Text to insert.
+ */
+export const getEmojiInsertText = (emoji, textAfterCaret) =>
+  /^\s/.test(textAfterCaret) ? emoji : `${emoji} `;
+
+/**
+ * Detect an emoji shortcode being typed right before the caret.
+ * @param {string} textBeforeCaret Text between the beginning of the current text node and the
+ * caret.
+ * @returns {string | undefined} Query without the leading colon, or `undefined` if there is no
+ * shortcode.
+ */
+export const detectEmojiTrigger = (textBeforeCaret) =>
+  textBeforeCaret.match(EMOJI_TRIGGER_REGEX)?.groups?.query;

package/dist/components/emoji/loader.d.ts

@@ -0,0 +1,6 @@
+export function getEmojiDataURL(): string;
+export { EMOJILIB_VERSION };
+export function setEmojiDataLoader(newLoader: () => Promise<EmojiData>): void;
+export function getEmojiDataLoader(): () => Promise<EmojiData>;
+import { version as EMOJILIB_VERSION } from 'emojilib/package.json';
+import type { EmojiData } from '../../typedefs';

package/dist/components/emoji/loader.js

@@ -0,0 +1,74 @@
+import { version as EMOJILIB_VERSION } from 'emojilib/package.json';
+
+/**
+ * @import { EmojiData } from '../../typedefs';
+ */
+
+const CDN_BASE_URL = 'https://unpkg.com/emojilib';
+/**
+ * How long to wait for the emoji data, in milliseconds. The suggestions are a convenience, so a
+ * slow or unreachable CDN should never leave a request hanging around.
+ */
+const FETCH_TIMEOUT = 5000;
+
+/**
+ * Get the URL of the emoji data.
+ *
+ * The data is fetched rather than bundled because it’s a few hundred kilobytes that most sessions
+ * never need, and a single-file bundle — our main consumer, Sveltia CMS — would otherwise inline it
+ * wholesale. The version comes from the installed `emojilib`, so the URL always matches the
+ * package this was developed against.
+ * @returns {string} URL.
+ */
+export const getEmojiDataURL = () => `${CDN_BASE_URL}@${EMOJILIB_VERSION}/dist/emoji-en-US.json`;
+
+/**
+ * Version of the emoji data, used to scope the cache so a bump invalidates it.
+ */
+export { EMOJILIB_VERSION };
+
+/**
+ * Fetch the emoji data from the CDN.
+ * @returns {Promise<EmojiData>} Emoji data, keyed by emoji character.
+ * @throws {Error} When the request fails, times out or returns a non-OK response.
+ */
+const loadEmojiData = async () => {
+  const response = await fetch(getEmojiDataURL(), {
+    signal: AbortSignal.timeout(FETCH_TIMEOUT),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to load emoji data: ${response.status}`);
+  }
+
+  return response.json();
+};
+
+/**
+ * Loader in effect.
+ * @type {() => Promise<EmojiData>}
+ */
+let loader = loadEmojiData;
+
+/**
+ * Override how the emoji suggestions obtain their data.
+ *
+ * By default the data is fetched from a CDN and cached locally, which keeps it out of the
+ * consumer’s bundle. Consumers who would rather bundle it, self-host it, or run without any
+ * outbound requests at all can replace the loader.
+ *
+ * ```js
+ * setEmojiDataLoader(async () => (await import('emojilib')).default);
+ * ```
+ * @param {() => Promise<EmojiData>} newLoader Loader returning the emoji data, keyed by emoji
+ * character, with each value listing the name followed by any keywords.
+ */
+export const setEmojiDataLoader = (newLoader) => {
+  loader = newLoader;
+};
+
+/**
+ * Get the loader currently in effect.
+ * @returns {() => Promise<EmojiData>} Active loader.
+ */
+export const getEmojiDataLoader = () => loader;

package/dist/components/text-editor/emoji-autocomplete.svelte

@@ -0,0 +1,225 @@
+<!--
+  @component
+  Emoji autocomplete for the rich text editor. Typing a colon followed by one or more characters,
+  like `:smi`, brings up a list of matching emojis that can be inserted with a click or the Enter
+  key, the same way it works on GitHub, Slack and other apps. This wires the Lexical editor up to
+  `<EmojiSuggestions>`, which owns the dropdown itself.
+-->
+<script>
+  import { $isCodeNode as isCodeNode } from '@lexical/code-core';
+  import {
+    COMMAND_PRIORITY_CRITICAL,
+    $getNodeByKey as getNodeByKey,
+    $getSelection as getSelection,
+    $isRangeSelection as isRangeSelection,
+    $isTextNode as isTextNode,
+    KEY_ARROW_DOWN_COMMAND,
+    KEY_ARROW_UP_COMMAND,
+    KEY_ENTER_COMMAND,
+    KEY_ESCAPE_COMMAND,
+    KEY_TAB_COMMAND,
+  } from 'lexical';
+  import { getContext } from 'svelte';
+  import { detectEmojiTrigger, getEmojiInsertText } from '../emoji/emoji.js';
+  import EmojiSuggestions from '../emoji/emoji-suggestions.svelte';
+
+  /**
+   * @import { EmojiAnchorRect, EmojiEntry, EmojiTrigger, TextEditorStore } from '../../typedefs';
+   */
+
+  /**
+   * A shortcode within the Lexical editor, identified by the text node it sits in and where its
+   * colon is, which doesn’t change as the query grows.
+   * @typedef {EmojiTrigger & { nodeKey: string, offset: number }} LexicalEmojiTrigger
+   */
+
+  /** @type {TextEditorStore} */
+  const editorStore = getContext('editorStore');
+
+  /**
+   * A reference to the dropdown.
+   * @type {ReturnType<typeof EmojiSuggestions> | undefined}
+   */
+  let list = $state();
+
+  /**
+   * Look for a shortcode being typed right before the caret. This must be called within an editor
+   * state read.
+   * @returns {LexicalEmojiTrigger | undefined} Shortcode state, if any.
+   */
+  const findTrigger = () => {
+    const selection = getSelection();
+
+    // Never suggest emojis within code, where a colon is much more likely to be code than a
+    // shortcode
+    if (!isRangeSelection(selection) || !selection.isCollapsed() || selection.hasFormat('code')) {
+      return undefined;
+    }
+
+    const node = selection.anchor.getNode();
+
+    if (!isTextNode(node) || !node.isSimpleText() || isCodeNode(node.getParent())) {
+      return undefined;
+    }
+
+    const { offset } = selection.anchor;
+    const query = detectEmojiTrigger(node.getTextContent().slice(0, offset));
+
+    if (query === undefined) {
+      return undefined;
+    }
+
+    const nodeKey = node.getKey();
+
+    return { id: `${nodeKey}:${offset - query.length - 1}`, query, nodeKey, offset };
+  };
+
+  /**
+   * Get the viewport-relative bounds of the shortcode being typed. The DOM selection is used rather
+   * than the Lexical node, because the caret is exactly where the shortcode ends, and the browser
+   * has already laid it out by the time an update listener runs.
+   * @param {EmojiTrigger} trigger Shortcode state.
+   * @returns {EmojiAnchorRect | undefined} Bounds, or `undefined` if they can’t be determined.
+   */
+  const getAnchorRect = ({ query }) => {
+    const domSelection = window.getSelection();
+
+    if (!domSelection?.rangeCount) {
+      return undefined;
+    }
+
+    const range = domSelection.getRangeAt(0).cloneRange();
+
+    try {
+      range.setStart(range.startContainer, Math.max(0, range.startOffset - query.length - 1));
+    } catch {
+      // The container turned out to be shorter than expected; fall back to the collapsed caret
+    }
+
+    const { top, bottom, left, right, width, height } = range.getBoundingClientRect();
+
+    // A range with no client rects yields an all-zero rectangle
+    return top || bottom || left || width || height ? { top, bottom, left, right } : undefined;
+  };
+
+  /**
+   * Replace the shortcode being typed with the given emoji.
+   * @param {EmojiEntry} entry Emoji to insert.
+   * @param {EmojiTrigger} trigger Shortcode to replace.
+   */
+  const insertEmoji = (entry, trigger) => {
+    const { editor } = editorStore;
+    const { query, nodeKey, offset } = /** @type {LexicalEmojiTrigger} */ (trigger);
+    const start = offset - query.length - 1;
+
+    editor?.update(() => {
+      const node = getNodeByKey(nodeKey);
+
+      // Make sure the shortcode is still where it was when the suggestions appeared
+      if (!isTextNode(node) || node.getTextContent().slice(start, offset) !== `:${query}`) {
+        return;
+      }
+
+      const text = getEmojiInsertText(entry.emoji, node.getTextContent().slice(offset));
+
+      node.spliceText(start, query.length + 1, text, true);
+    });
+  };
+
+  /**
+   * Register the keyboard shortcuts that drive the list, as well as the listener that watches for
+   * shortcodes. The shortcuts are registered with the highest priority, so they take precedence
+   * over the editor’s own handling while the list is open, and return `false` otherwise to leave
+   * the editor alone.
+   * @returns {Array<() => void>} Cleanup handlers.
+   */
+  const registerCommands = () => {
+    const { editor } = editorStore;
+
+    if (!editor) {
+      return [];
+    }
+
+    /**
+     * Create a command listener that only acts while the list is open.
+     * @param {() => void} handler Handler to be called.
+     * @returns {(event: KeyboardEvent | null) => boolean} Command listener.
+     */
+    const whileOpen = (handler) => (event) => {
+      if (!list?.isOpen()) {
+        return false;
+      }
+
+      event?.preventDefault();
+      handler();
+
+      return true;
+    };
+
+    return [
+      editor.registerCommand(
+        KEY_ARROW_DOWN_COMMAND,
+        whileOpen(() => list?.moveSelection(1)),
+        COMMAND_PRIORITY_CRITICAL,
+      ),
+      editor.registerCommand(
+        KEY_ARROW_UP_COMMAND,
+        whileOpen(() => list?.moveSelection(-1)),
+        COMMAND_PRIORITY_CRITICAL,
+      ),
+      editor.registerCommand(
+        KEY_ENTER_COMMAND,
+        whileOpen(() => list?.selectHighlighted()),
+        COMMAND_PRIORITY_CRITICAL,
+      ),
+      editor.registerCommand(
+        KEY_TAB_COMMAND,
+        whileOpen(() => list?.selectHighlighted()),
+        COMMAND_PRIORITY_CRITICAL,
+      ),
+      editor.registerCommand(
+        KEY_ESCAPE_COMMAND,
+        whileOpen(() => list?.close(true)),
+        COMMAND_PRIORITY_CRITICAL,
+      ),
+      editor.registerUpdateListener(({ editorState }) => {
+        /** @type {LexicalEmojiTrigger | undefined} */
+        let trigger;
+
+        editorState.read(() => {
+          trigger = findTrigger();
+        });
+
+        list?.update(trigger);
+      }),
+    ];
+  };
+
+  $effect(() => {
+    if (!editorStore.editor || !list) {
+      return undefined;
+    }
+
+    const unregisters = registerCommands();
+
+    return () => {
+      unregisters.forEach((unregister) => unregister());
+      list?.close();
+    };
+  });
+
+  // The rich text editor can be swapped for the plain text one at any time, in which case there is
+  // no caret to anchor the dropdown to anymore
+  $effect(() => {
+    if (!editorStore.useRichText) {
+      list?.close();
+    }
+  });
+</script>
+
+<EmojiSuggestions
+  bind:this={list}
+  {getAnchorRect}
+  onSelect={insertEmoji}
+  ariaOwner={editorStore.editor?.getRootElement() ?? undefined}
+/>

package/dist/components/text-editor/emoji-autocomplete.svelte.d.ts

@@ -0,0 +1,12 @@
+export default EmojiAutocomplete;
+type EmojiAutocomplete = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<Record<string, never>>): void;
+};
+/**
+ * Emoji autocomplete for the rich text editor. Typing a colon followed by one or more characters,
+ * like `:smi`, brings up a list of matching emojis that can be inserted with a click or the Enter
+ * key, the same way it works on GitHub, Slack and other apps. This wires the Lexical editor up to
+ * `<EmojiSuggestions>`, which owns the dropdown itself.
+ */
+declare const EmojiAutocomplete: import("svelte").Component<Record<string, never>, {}, "">;

package/dist/components/text-editor/shiki/generated.d.ts

@@ -7,7 +7,7 @@ export const SHIKI_VERSION: "4.4.3";
 /**
  * Version of this package, used to resolve the prebuilt Shiki engine chunk from a CDN.
  */
-export const UI_VERSION: "0.63.1";
+export const UI_VERSION: "0.65.0";
 /**
  * Available syntax highlighting languages, sorted by display name.
  * @type {{ id: string, name: string, aliases?: string[] }[]}

package/dist/components/text-editor/shiki/generated.js

@@ -10,7 +10,7 @@ export const SHIKI_VERSION = "4.4.3";
 /**
  * Version of this package, used to resolve the prebuilt Shiki engine chunk from a CDN.
  */
-export const UI_VERSION = "0.63.1";
+export const UI_VERSION = "0.65.0";
 
 /**
  * Available syntax highlighting languages, sorted by display name.

package/dist/components/text-editor/store.svelte.js

@@ -28,6 +28,7 @@ export const createEditorStore = () => {
     components: [],
     useMarkdownShortcuts: true,
     isCodeEditor: false,
+    useEmojiAutocomplete: false,
   });
 
   /** @type {string} */