@lobehub/editor 4.5.0 → 4.6.0

package/es/index-BfKEHYDe.d.ts

@@ -0,0 +1,889 @@
+import { HistoryState, HistoryStateEntry } from "@lexical/history";
+import * as _$lexical from "lexical";
+import { CommandListener, CommandListenerPriority, CommandPayloadType, DOMConversionMap, DOMExportOutput, DecoratorNode, EditorConfig, EditorState, ElementNode, LexicalCommand, LexicalEditor, LexicalNode, LexicalNodeConfig, LexicalUpdateJSON, RangeSelection, SerializedLexicalNode, Spread, TextNode } from "lexical";
+import { HeadingTagType } from "@lexical/rich-text";
+import * as _$react from "react";
+import { CSSProperties, CompositionEvent, FC, FocusEvent, MouseEvent, ReactElement, ReactNode } from "react";
+import { DropdownMenuItemType } from "@lobehub/ui";
+import Fuse, { IFuseOptions } from "fuse.js";
+
+//#region src/editor-kernel/data-source.d.ts
+interface IWriteOptions {
+  selection?: boolean;
+}
+declare class DataSource {
+  protected dataType: string;
+  constructor(dataType: string);
+  get type(): string;
+  read(editor: LexicalEditor, data: any, options?: Record<string, unknown>): void;
+  write(editor: LexicalEditor, options?: IWriteOptions): any;
+}
+//#endregion
+//#region src/types/hotkey.d.ts
+declare const KeyEnum: {
+  readonly Alt: "alt";
+  readonly Backquote: "backquote";
+  readonly Backslash: "backslash";
+  readonly Backspace: "backspace";
+  readonly BracketLeft: "bracketleft";
+  readonly BracketRight: "bracketright";
+  readonly Comma: "comma";
+  readonly Ctrl: "ctrl";
+  readonly Down: "down";
+  readonly Enter: "enter";
+  readonly Equal: "equal";
+  readonly Esc: "esc";
+  readonly Left: "left";
+  readonly LeftClick: "left-click";
+  readonly LeftDoubleClick: "left-double-click";
+  readonly Meta: "meta";
+  readonly MiddleClick: "middle-click";
+  readonly Minus: "minus";
+  readonly Mod: "mod";
+  readonly Number: "1-9";
+  readonly Period: "period";
+  readonly Plus: "equal";
+  readonly QuestionMark: "slash";
+  readonly Quote: "quote";
+  readonly Right: "right";
+  readonly RightClick: "right-click";
+  readonly RightDoubleClick: "right-double-click";
+  readonly Semicolon: "semicolon";
+  readonly Shift: "shift";
+  readonly Slash: "slash";
+  readonly Space: "space";
+  readonly Tab: "tab";
+  readonly Up: "up";
+  readonly Zero: "0";
+};
+declare const HotkeyEnum: {
+  readonly Bold: "bold";
+  readonly BulletList: "bulletList";
+  readonly CodeInline: "codeInline";
+  readonly Italic: "italic";
+  readonly Link: "link";
+  readonly Mention: "mention";
+  readonly NumberList: "numberList";
+  readonly PasteAsPlainText: "pasteAsPlainText";
+  readonly Redo: "redo";
+  readonly Slash: "slash";
+  readonly Strikethrough: "strikethrough";
+  readonly Underline: "underline";
+  readonly Undo: "undo";
+};
+declare const HotkeyScopeEnum: {
+  readonly Format: "format";
+  readonly Insert: "insert";
+  readonly Plugin: "plugin";
+  readonly Slash: "slash";
+};
+type HotkeyId = (typeof HotkeyEnum)[keyof typeof HotkeyEnum];
+type HotkeyScopeId = (typeof HotkeyScopeEnum)[keyof typeof HotkeyScopeEnum];
+interface HotkeyItem {
+  id: HotkeyId;
+  keys: string;
+  priority: CommandListenerPriority;
+  scopes?: HotkeyScopeId[];
+}
+type ModifierCombination = {
+  altKey?: boolean;
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  shiftKey?: boolean;
+} | Record<string, never>;
+//#endregion
+//#region src/utils/hotkey/registerHotkey.d.ts
+type HotkeysEvent = {
+  key?: string;
+  keys: string;
+  modifiers: ModifierCombination;
+  scopes?: string[];
+};
+type HotkeyOptions = {
+  enabled?: boolean;
+  preventDefault?: boolean;
+  stopImmediatePropagation?: boolean;
+  stopPropagation?: boolean;
+};
+declare const getHotkeyById: (id: HotkeyId) => HotkeyItem;
+//#endregion
+//#region src/locale/index.d.ts
+declare const _default: {
+  cancel: string;
+  codemirror: {
+    copyFailed: string;
+    copySuccess: string;
+    selectLanguage: string;
+    selectTheme: string;
+    showLineNumbers: string;
+    tabSize: string;
+    theme: string;
+    useTabs: string;
+  };
+  confirm: string;
+  file: {
+    error: string;
+    uploading: string;
+  };
+  image: {
+    broken: string;
+    replace: string;
+  };
+  link: {
+    edit: string;
+    editLinkTitle: string;
+    editTextTitle: string;
+    open: string;
+    placeholder: string;
+    unlink: string;
+  };
+  markdown: {
+    autoFormatMessage: string;
+    autoFormatTitle: string;
+    cancel: string;
+    confirm: string;
+    parseMessage: string;
+    parseTitle: string;
+  };
+  math: {
+    placeholder: string;
+  };
+  modifier: {
+    accept: string;
+    acceptAll: string;
+    reject: string;
+    rejectedAll: string;
+  };
+  table: {
+    delete: string;
+    deleteColumn: string;
+    deleteRow: string;
+    insertColumnLeft: string;
+    insertColumnRight: string;
+    insertRowAbove: string;
+    insertRowBelow: string;
+  };
+};
+//#endregion
+//#region src/types/locale.d.ts
+/**
+ * Internationalization key type declaration, plugins can extend through declaration merging
+ */
+type LocaleType = typeof _default;
+type FlattenKeys<T, Prefix extends string = ''> = { [K in keyof T & string]: T[K] extends string ? Prefix extends '' ? K : `${Prefix}.${K}` : T[K] extends Record<string, any> ? FlattenKeys<T[K], Prefix extends '' ? K : `${Prefix}.${K}`> : never }[keyof T & string];
+type ILocaleKeys = Record<FlattenKeys<LocaleType>, string>;
+//#endregion
+//#region src/types/kernel.d.ts
+type IDecoratorFunc = (_node: LexicalNode, _editor: LexicalEditor) => any;
+type IDecorator = {
+  queryDOM: (_element: HTMLElement) => HTMLElement;
+  render: IDecoratorFunc;
+} | IDecoratorFunc;
+/**
+ * Service ID type
+ */
+type IServiceID<Service> = {
+  readonly __serviceId: string;
+  __serviceType?: Service;
+};
+interface ISelectionObject {
+  endNodeId: string;
+  endOffset: number;
+  startNodeId: string;
+  startOffset: number;
+  type: 'range' | 'node' | 'table';
+}
+interface IDocumentOptions {
+  [key: string]: unknown;
+  keepHistory?: boolean;
+  /** only work for json datasource */
+  keepId?: boolean;
+}
+interface IKernelEventMap {
+  /**
+   * Document change event
+   */
+  documentChange: (type: string, content: any) => void;
+  /**
+   * Editor editable state change event
+   */
+  editableChange: (editable: boolean) => void;
+  /**
+   * Editor error event
+   */
+  error: (error: Error) => void;
+  /**
+   * Initialization event
+   * @param editor Lexical editor instance
+   * @returns
+   */
+  initialized: (editor: LexicalEditor) => void;
+  /**
+   * handle markdown parse event
+   */
+  markdownParse: (params: {
+    cacheState: EditorState;
+    historyState: HistoryStateEntry | null;
+    markdown: string;
+    matchedPatterns: string[];
+    score: number;
+  }) => void;
+  /**
+   * handle paste event
+   */
+  onPaste: (event: ClipboardEvent) => void;
+}
+/**
+ * External API
+ */
+interface IEditor {
+  /**
+   * Lose focus
+   */
+  blur(): void;
+  /**
+   * Clean editor content (clear all content)
+   */
+  cleanDocument(): void;
+  /**
+   * Destroy editor instance
+   */
+  destroy(): void;
+  /**
+   * Execute editor commands to manipulate editor content
+   * @param type
+   * @param payload
+   */
+  dispatchCommand<TCommand extends LexicalCommand<unknown>>(type: TCommand, payload: CommandPayloadType<TCommand>): boolean;
+  /**
+   * Focus editor
+   */
+  focus(): void;
+  /**
+   * Get editor content of specified type
+   */
+  getDocument(type: string): DataSource | undefined;
+  /**
+   * Lexical history state (undo stack metadata)
+   */
+  getHistoryState(): HistoryState;
+  /**
+   * Get Lexical editor instance
+   */
+  getLexicalEditor(): LexicalEditor | null;
+  /**
+   * Get document editor root node
+   */
+  getRootElement(): HTMLElement | null;
+  /**
+   * Get editor selection information
+   */
+  getSelection(): ISelectionObject | null;
+  /**
+   * Get document editor selection content of specified type
+   * @param type
+   */
+  getSelectionDocument(type: string): unknown | null;
+  /**
+   * Get editor theme
+   */
+  getTheme(): Record<string, string | Record<string, string>>;
+  /**
+   * Get node editor instance
+   */
+  initNodeEditor(): LexicalEditor | null;
+  /**
+   * Check if editor is editable
+   */
+  isEditable(): boolean;
+  /**
+   * Check if editor content is empty
+   * @returns true if editor content is empty, false otherwise
+   */
+  get isEmpty(): boolean;
+  /**
+   * Check if editor has active selection
+   * @returns true if editor has selection, false otherwise
+   */
+  get isSelected(): boolean;
+  /**
+   * Remove editor event listener
+   * @param event
+   * @param listener
+   */
+  off<T extends keyof IKernelEventMap>(event: T, listener: IKernelEventMap[T]): this;
+  /**
+   * Add editor event listener
+   * @param event
+   * @param listener
+   */
+  on<T extends keyof IKernelEventMap>(event: T, listener: IKernelEventMap[T]): this;
+  /**
+   * Listen to event once, automatically remove listener after trigger
+   * @param event
+   * @param listener
+   */
+  once<T extends keyof IKernelEventMap>(event: T, listener: IKernelEventMap[T]): this;
+  /**
+   * Extends the priority level of Lexical commands.
+   * Registers a listener that triggers when the provided command is dispatched
+   * via {@link LexicalEditor.dispatch}. The listener is triggered based on its priority.
+   * Listeners with higher priority can "intercept" commands and prevent them
+   * from propagating to other handlers by returning true.
+   *
+   * Listeners are always invoked within {@link LexicalEditor.update} and can call dollar functions.
+   *
+   * Listeners registered at the same priority level will deterministically run
+   * in the order of registration.
+   *
+   * @param command - The command that triggers the callback.
+   * @param listener - The function executed when the command is dispatched.
+   * @param priority - The relative priority of the listener. 0 | 1 | 2 | 3 | 4
+   *   (or {@link COMMAND_PRIORITY_EDITOR} |
+   *     {@link COMMAND_PRIORITY_LOW} |
+   *     {@link COMMAND_PRIORITY_NORMAL} |
+   *     {@link COMMAND_PRIORITY_HIGH} |
+   *     {@link COMMAND_PRIORITY_CRITICAL})
+   * @returns A teardown function to clean up the listener.
+   */
+  registerHighCommand<P>(command: LexicalCommand<P>, listener: CommandListener<P>, priority: CommandListenerPriority): () => void;
+  /**
+   * Register keyboard shortcut
+   * @param hotkey
+   * @param callback
+   * @param options
+   */
+  registerHotkey(hotkey: HotkeyId, callback: (event: KeyboardEvent, handler: HotkeysEvent) => void, options?: HotkeyOptions): () => void;
+  /**
+   * Register internationalization text
+   * @param locale Internationalization text object
+   */
+  registerLocale(locale: Partial<Record<keyof ILocaleKeys, string>>): void;
+  /**
+   * Register editor plugin
+   */
+  registerPlugin<T>(plugin: IEditorPluginConstructor<T>, config?: T): IEditor;
+  /**
+   * Register multiple editor plugins
+   */
+  registerPlugins(plugins: Array<IPlugin>): IEditor;
+  /**
+   * Get editor Service, usually provided by plugins to extend certain functionalities
+   * @param serviceId
+   */
+  requireService<T>(serviceId: IServiceID<T>): T | null;
+  /**
+   * Set editor content, type is content type, content is content data
+   * @param type
+   * @param content
+   */
+  setDocument(type: string, content: any, options?: IDocumentOptions): void;
+  /**
+   * Enable or disable editor editing capability
+   * @param editable
+   */
+  setEditable(editable: boolean): void;
+  /**
+   * Set document editor root node
+   * @param dom
+   */
+  setRootElement(dom: HTMLElement, editable?: boolean): LexicalEditor;
+  /**
+   * set editor selection
+   * @param selection
+   */
+  setSelection(selection: ISelectionObject, opt?: {
+    collapseToEnd?: boolean;
+    collapseToStart?: boolean;
+  }): Promise<boolean>;
+  /**
+   * Get translation text
+   * @param key Translation key
+   * @param params Parameter replacement
+   */
+  t<K extends keyof ILocaleKeys>(key: K, params?: Record<string, any>): string;
+  /**
+   * Update editor theme
+   * @param key
+   * @param value
+   */
+  updateTheme(key: string, value: string | Record<string, string>): void;
+}
+/**
+ * API provided to plugins
+ */
+interface IEditorKernel extends IEditor {
+  /**
+   * Clone the current editor kernel instance
+   */
+  cloneNodeEditor(): IEditorKernel;
+  emit<T extends keyof IKernelEventMap>(event: T, params: Parameters<IKernelEventMap[T]>[0]): void;
+  /**
+   * Get editor Node decorator for specific Node rendering
+   * @param name
+   */
+  getDecorator(name: string): IDecorator | undefined;
+  /**
+   * Get all registered decorator names
+   */
+  getRegisteredDecorators(): string[];
+  /**
+   * Check if hot reload mode is enabled
+   */
+  isHotReloadMode(): boolean;
+  /**
+   * Register data source for multi-format data conversion
+   * @param dataSource
+   */
+  registerDataSource(dataSource: DataSource): void;
+  /**
+   * Register editor node decorator
+   * @param name
+   * @param decorator
+   */
+  registerDecorator(name: string, decorator: IDecorator): void;
+  /**
+   * Register Lexical Node
+   * @param nodes
+   */
+  registerNodes(nodes: Array<LexicalNodeConfig>): void;
+  /**
+   * Register service
+   * @param serviceId
+   * @param service
+   */
+  registerService<T>(serviceId: IServiceID<T>, service: T): void;
+  /**
+   * Register service with hot reload support - allows overriding existing services
+   * @param serviceId Service identifier
+   * @param service Service instance
+   */
+  registerServiceHotReload<T>(serviceId: IServiceID<T>, service: T): void;
+  /**
+   * Register theme
+   * @param themes
+   */
+  registerThemes(themes: Record<string, any>): void;
+  /**
+   * Enable or disable hot reload mode
+   * @param enabled Whether to enable hot reload mode
+   */
+  setHotReloadMode(enabled: boolean): void;
+  /**
+   * Unregister editor node decorator
+   * @param name Decorator name
+   */
+  unregisterDecorator(name: string): boolean;
+}
+/**
+ * Plugin interface
+ */
+interface IEditorPlugin<IConfig> {
+  config?: IConfig;
+  /**
+   * Editor destruction
+   */
+  destroy(): void;
+  /**
+   * After Lexical editor instantiation
+   * @param editor Lexical editor instance
+   */
+  onInit?(editor: LexicalEditor): void;
+}
+/**
+ * Plugin class interface
+ */
+interface IEditorPluginConstructor<IConfig> {
+  readonly pluginName: string;
+  new (kernel: IEditorKernel, config?: IConfig): IEditorPlugin<IConfig>;
+}
+type IPlugin<T = any> = IEditorPluginConstructor<T> | [IEditorPluginConstructor<T>, T?];
+//#endregion
+//#region src/plugins/common/command/index.d.ts
+declare const INSERT_QUOTE_COMMAND: _$lexical.LexicalCommand<unknown>;
+declare const INSERT_HEADING_COMMAND: _$lexical.LexicalCommand<{
+  tag: HeadingTagType;
+}>;
+//#endregion
+//#region src/plugins/common/node/cursor.d.ts
+declare class CardLikeElementNode extends ElementNode {
+  isCardLike(): boolean;
+}
+declare const cursorNodeSerialized: SerializedLexicalNode;
+declare class CursorNode extends TextNode {
+  static getType(): string;
+  isUnmergeable(): boolean;
+}
+declare function $createCursorNode(): CursorNode;
+declare function $isCardLikeElementNode(node: LexicalNode | null | undefined): node is CardLikeElementNode;
+declare function $isCursorNode(node: LexicalNode | null | undefined): node is CursorNode;
+//#endregion
+//#region src/plugins/common/plugin/paste-handler.d.ts
+/**
+ * Configuration options relevant to paste handling
+ */
+interface PasteHandlerConfig {
+  pasteVSCodeAsCodeBlock?: boolean;
+}
+//#endregion
+//#region src/plugins/common/plugin/index.d.ts
+interface CommonPluginOptions extends PasteHandlerConfig {
+  enableHotkey?: boolean;
+  /**
+   * Enable/disable markdown shortcuts
+   * @default true - most formats enabled, but subscript/superscript are disabled by default
+   */
+  markdownOption?: boolean | {
+    bold?: boolean;
+    code?: boolean;
+    header?: boolean;
+    italic?: boolean;
+    quote?: boolean;
+    strikethrough?: boolean;
+    subscript?: boolean;
+    superscript?: boolean;
+    underline?: boolean;
+    underlineStrikethrough?: boolean;
+  };
+  /**
+   * Force paste as plain text, stripping all rich text formatting
+   * @default false
+   */
+  pasteAsPlainText?: boolean;
+  theme?: {
+    quote?: string;
+    textBold?: string;
+    textCode?: string;
+    textHighlight?: string;
+    textItalic?: string;
+    textStrikethrough?: string;
+    textSubscript?: string;
+    textSuperscript?: string;
+    textUnderline?: string;
+    textUnderlineStrikethrough?: string;
+  };
+}
+declare const CommonPlugin: IEditorPluginConstructor<CommonPluginOptions>;
+//#endregion
+//#region src/plugins/common/react/type.d.ts
+interface ReactEditorContentProps {
+  content: any;
+  lineEmptyPlaceholder?: string;
+  placeholder?: ReactNode;
+  type: string;
+}
+interface ReactPlainTextProps {
+  autoFocus?: boolean;
+  /**
+   * Automatically convert pasted markdown once the detection threshold is reached
+   * @default true
+   */
+  autoFormatMarkdown?: boolean;
+  children: ReactElement<ReactEditorContentProps>;
+  className?: string;
+  editable?: boolean;
+  enableHotkey?: boolean;
+  /**
+   * Enable automatic markdown conversion for pasted content
+   * @default true
+   */
+  enablePasteMarkdown?: boolean;
+  /**
+   * Enable/disable markdown shortcuts
+   * @default true - all formats enabled
+   */
+  markdownOption?: CommonPluginOptions['markdownOption'];
+  onBlur?: (props: {
+    editor: IEditor;
+    event: FocusEvent<HTMLDivElement>;
+  }) => void;
+  onChange?: (editor: IEditor) => void;
+  onCompositionEnd?: (props: {
+    editor: IEditor;
+    event: CompositionEvent<HTMLDivElement>;
+  }) => void;
+  onCompositionStart?: (props: {
+    editor: IEditor;
+    event: CompositionEvent<HTMLDivElement>;
+  }) => void;
+  onContextMenu?: (props: {
+    editor: IEditor;
+    event: MouseEvent<HTMLDivElement>;
+  }) => void;
+  onFocus?: (props: {
+    editor: IEditor;
+    event: FocusEvent<HTMLDivElement>;
+  }) => void;
+  onKeyDown?: (props: {
+    editor: IEditor;
+    event: KeyboardEvent;
+  }) => boolean | void;
+  onPressEnter?: (props: {
+    editor: IEditor;
+    event: KeyboardEvent;
+  }) => boolean | void;
+  /**
+   * Callback triggered only when text content changes
+   * Unlike onChange, this won't trigger on cursor movement or selection changes
+   */
+  onTextChange?: (editor: IEditor) => void;
+  /**
+   * Force paste as plain text, stripping all rich text formatting
+   * @default false
+   */
+  pasteAsPlainText?: boolean;
+  /**
+   * Minimum markdown score required before auto conversion runs
+   * @default 5
+   */
+  pasteMarkdownAutoConvertThreshold?: number;
+  /**
+   * When pasting VS Code content (detected via vscode-editor-data clipboard type),
+   * create a code block with the language from VS Code instead of pasting as plain text.
+   * This option only takes effect when pasteAsPlainText is enabled.
+   * @default true
+   */
+  pasteVSCodeAsCodeBlock?: boolean;
+  style?: CSSProperties;
+  theme?: CommonPluginOptions['theme'] & {
+    fontSize?: number;
+    headerMultiple?: number;
+    lineHeight?: number;
+    marginMultiple?: number;
+  };
+  variant?: 'default' | 'chat';
+}
+//#endregion
+//#region src/plugins/common/react/ReactEditorContent.d.ts
+declare const ReactEditorContent: FC<ReactEditorContentProps>;
+//#endregion
+//#region src/plugins/common/react/ReactPlainText.d.ts
+declare const ReactPlainText: _$react.NamedExoticComponent<ReactPlainTextProps>;
+//#endregion
+//#region src/plugins/mention/node/MentionNode.d.ts
+type SerializedMentionNode = Spread<{
+  label?: string;
+  metadata?: Record<string, unknown>;
+}, SerializedLexicalNode>;
+declare class MentionNode extends DecoratorNode<any> {
+  static getType(): string;
+  static clone(node: MentionNode): MentionNode;
+  static importJSON(serializedNode: SerializedMentionNode): MentionNode;
+  static importDOM(): DOMConversionMap | null;
+  __label: string;
+  __metadata: Record<string, unknown>;
+  constructor(label?: string, metadata?: Record<string, unknown>, key?: string);
+  get label(): string;
+  get metadata(): Record<string, unknown>;
+  exportDOM(): DOMExportOutput;
+  createDOM(config: EditorConfig): HTMLElement;
+  getTextContent(): string;
+  isInline(): true;
+  updateDOM(): boolean;
+  exportJSON(): SerializedMentionNode;
+  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedMentionNode>): this;
+  decorate(editor: LexicalEditor): any;
+}
+//#endregion
+//#region src/plugins/mention/react/type.d.ts
+interface ReactMentionPluginProps {
+  className?: string;
+  markdownWriter?: (file: MentionNode) => string;
+  theme?: {
+    mention?: string;
+  };
+}
+//#endregion
+//#region src/plugins/mention/react/ReactMentionPlugin.d.ts
+declare const ReactMentionPlugin: FC<ReactMentionPluginProps>;
+//#endregion
+//#region src/plugins/slash/service/i-slash-service.d.ts
+type ISlashDividerOption = {
+  type: 'divider';
+};
+interface ISlashMenuOption extends DropdownMenuItemType {
+  metadata?: Record<string, any>;
+  onSelect?: (editor: IEditor, matchingString: string) => void;
+}
+type ISlashOption = ISlashMenuOption | ISlashDividerOption;
+interface SlashOptions {
+  allowWhitespace?: boolean;
+  /**
+   * Complete Fuse.js configuration options
+   * @example
+   * {
+   *   keys: ['key', 'label', 'description'],
+   *   threshold: 0.3,
+   *   includeScore: true,
+   *   includeMatches: true
+   * }
+   */
+  fuseOptions?: IFuseOptions<ISlashMenuOption>;
+  items: Array<ISlashOption> | ((search: {
+    leadOffset: number;
+    matchingString: string;
+    replaceableString: string;
+  } | null) => Promise<Array<ISlashOption>>);
+  maxLength?: number;
+  minLength?: number;
+  punctuation?: string;
+  /**
+   * Fuse.js search keys for fuzzy matching
+   * Default is ['key']
+   * @example ['key', 'label', 'description']
+   * @deprecated Use fuseOptions instead
+   */
+  searchKeys?: string[];
+  trigger: string;
+}
+interface ISlashService {
+  registerSlash(options: SlashOptions): void;
+  updateOptions(options: SlashOptions[]): void;
+}
+declare const ISlashService: IServiceID<ISlashService>;
+//#endregion
+//#region src/plugins/slash/plugin/index.d.ts
+interface ITriggerContext {
+  getRect: () => DOMRect;
+  items: Array<ISlashOption> | ((search: {
+    leadOffset: number;
+    matchingString: string;
+    replaceableString: string;
+  } | null) => Promise<Array<ISlashOption>>);
+  lastIndex: number;
+  match?: {
+    leadOffset: number;
+    matchingString: string;
+    replaceableString: string;
+  } | null;
+  trigger: SlashOptions['trigger'];
+}
+interface SlashPluginOptions {
+  slashOptions?: SlashOptions[];
+  triggerClose: () => void;
+  triggerOpen: (ctx: ITriggerContext) => void;
+}
+declare const SlashPlugin: IEditorPluginConstructor<SlashPluginOptions>;
+//#endregion
+//#region src/plugins/slash/react/type.d.ts
+interface ReactSlashOptionProps {
+  /**
+   * Complete Fuse.js configuration options
+   * @example
+   * {
+   *   keys: ['key', 'label', 'description'],
+   *   threshold: 0.3,
+   *   includeScore: true,
+   *   includeMatches: true
+   * }
+   */
+  fuseOptions?: IFuseOptions<ISlashMenuOption>;
+  /**
+   * Searchable options
+   */
+  items?: SlashOptions['items'];
+  /**
+   * Maximum search length
+   * Default is 75
+   */
+  maxLength?: number;
+  onSelect?: (editor: IEditor, option: ISlashMenuOption) => void;
+  /**
+   * Custom render component
+   */
+  renderComp?: FC<MenuRenderProps>;
+  /**
+   * Fuse.js search keys for fuzzy matching
+   * Default is ['key']
+   * @example ['key', 'label', 'description']
+   * @deprecated Use fuseOptions instead
+   */
+  searchKeys?: string[];
+  /**
+   * Trigger character
+   */
+  trigger?: SlashOptions['trigger'];
+}
+interface MenuRenderProps {
+  /**
+   * Current active option key
+   */
+  activeKey: string | null;
+  /**
+   * Loading state
+   */
+  loading?: boolean;
+  /**
+   * Actively trigger selection
+   * @param option Currently selected element
+   */
+  onSelect?: (option: ISlashMenuOption) => void;
+  open?: boolean;
+  /**
+   * Currently searched options
+   */
+  options: Array<ISlashOption>;
+  /**
+   * Actively set current active option key
+   * @param key
+   * @returns
+   */
+  setActiveKey: (key: string | null) => void;
+}
+/**
+ * SlashMenu component props - only responsible for rendering
+ */
+interface SlashMenuProps {
+  /** Current active option key */
+  activeKey: string | null;
+  /** Anchor element className */
+  anchorClassName?: string;
+  /** Custom render component if provided */
+  customRender?: FC<MenuRenderProps>;
+  /** Custom popup container for portal rendering and scroll tracking */
+  getPopupContainer?: () => HTMLElement | null;
+  /** Loading state */
+  loading: boolean;
+  /** Callback to set active key */
+  onActiveKeyChange: (key: string | null) => void;
+  /** Callback when menu should close */
+  onClose: () => void;
+  /** Callback when an option is selected */
+  onSelect: (option: ISlashMenuOption) => void;
+  /** Whether the menu is open */
+  open: boolean;
+  /** Available options to display */
+  options: Array<ISlashOption>;
+  /** Force menu placement direction, skipping auto-flip detection */
+  placement?: 'bottom' | 'top';
+  /** Menu position */
+  position: {
+    getRect?: () => DOMRect;
+    rect?: DOMRect;
+    x: number;
+    y: number;
+  };
+}
+interface ReactSlashPluginProps {
+  anchorClassName?: string;
+  children?: (ReactElement<ReactSlashOptionProps> | undefined) | (ReactElement<ReactSlashOptionProps> | undefined)[];
+  /** Custom popup container for portal rendering and scroll tracking */
+  getPopupContainer?: () => HTMLElement | null;
+  /** Force menu placement direction, skipping auto-flip detection */
+  placement?: 'bottom' | 'top';
+}
+//#endregion
+//#region src/plugins/slash/react/components/SlashMenu.d.ts
+/**
+ * SlashMenu component - Only responsible for rendering the menu UI
+ * All state management and plugin registration is handled by ReactSlashPlugin
+ */
+declare const SlashMenu: FC<SlashMenuProps>;
+//#endregion
+//#region src/plugins/slash/react/ReactSlashOption.d.ts
+declare const ReactSlashOption: FC<ReactSlashOptionProps>;
+//#endregion
+//#region src/plugins/slash/react/ReactSlashPlugin.d.ts
+declare const ReactSlashPlugin: FC<ReactSlashPluginProps>;
+//#endregion
+export { IWriteOptions as $, INSERT_HEADING_COMMAND as A, ILocaleKeys as B, CommonPlugin as C, $isCursorNode as D, $isCardLikeElementNode as E, IEditorKernel as F, HotkeyEnum as G, HotkeyOptions as H, IEditorPluginConstructor as I, HotkeyScopeEnum as J, HotkeyId as K, IPlugin as L, IDecorator as M, IDocumentOptions as N, CardLikeElementNode as O, IEditor as P, DataSource as Q, ISelectionObject as R, ReactPlainTextProps as S, $createCursorNode as T, HotkeysEvent as U, _default as V, getHotkeyById as W, KeyEnum as X, HotkeyScopeId as Y, ModifierCombination as Z, MentionNode as _, ReactSlashOptionProps as a, ReactEditorContent as b, ITriggerContext as c, ISlashMenuOption as d, ISlashOption as f, ReactMentionPluginProps as g, ReactMentionPlugin as h, MenuRenderProps as i, INSERT_QUOTE_COMMAND as j, cursorNodeSerialized as k, SlashPlugin as l, SlashOptions as m, ReactSlashOption as n, ReactSlashPluginProps as o, ISlashService as p, HotkeyItem as q, SlashMenu as r, SlashMenuProps as s, ReactSlashPlugin as t, SlashPluginOptions as u, SerializedMentionNode as v, CommonPluginOptions as w, ReactEditorContentProps as x, ReactPlainText as y, IServiceID as z };