@opentiny/fluent-editor 4.0.0-alpha.7 → 4.0.0-alpha.8

package/dist/types/modules/custom-clipboard.d.ts

@@ -0,0 +1,25 @@
+import { default as TypeClipboard } from 'quill/modules/clipboard';
+import { default as FluentEditor } from '../fluent-editor';
+declare const Clipboard: typeof TypeClipboard;
+export declare class CustomClipboard extends Clipboard {
+    quill: FluentEditor;
+    prepareMatching(container: HTMLElement, nodeMatches: any): any[][];
+    onCaptureCopy(e: any, isCut?: boolean): void;
+    onCapturePaste(e: ClipboardEvent): void;
+    onPaste(range: any, { html, text, files: clipboardFiles, rtf }: {
+        html: any;
+        text: any;
+        files: any;
+        rtf: any;
+    }): void;
+    files2urls(files: File[], placeholders: any, originalUrls: any, pastedDelta: any, imageIndexs: any): Promise<unknown[]>;
+    flipFilesArray(filesArr: any): any[][];
+    convertHexToBase64(hexString: any): string;
+    extractImageDataFromRtf(rtfData: any): any[];
+    extractFilesFromDelta(delta: any, clipboardFiles: any, hexImages?: any): Promise<any[]>;
+    getImgSelection(delta: any, imageIndex: any): {
+        index: number;
+        length: number;
+    };
+}
+export {};

package/dist/types/modules/custom-image/actions/action.d.ts

@@ -0,0 +1,8 @@
+import { BlotFormatter } from '../blot-formatter';
+export declare class Action {
+    formatter: BlotFormatter;
+    constructor(formatter: BlotFormatter);
+    onCreate(): void;
+    onDestroy(): void;
+    onUpdate(): void;
+}

package/dist/types/modules/custom-image/actions/custom-resize-action.d.ts

@@ -0,0 +1,23 @@
+import { Action } from './action';
+export declare class CustomResizeAction extends Action {
+    topLeftHandle: HTMLElement;
+    topRightHandle: HTMLElement;
+    bottomRightHandle: HTMLElement;
+    bottomLeftHandle: HTMLElement;
+    dragHandle: HTMLElement;
+    dragStartX: number;
+    preDragWidth: number;
+    targetRatio: number;
+    maxWidth: number;
+    minWidth: number;
+    constructor(formatter: any);
+    onCreate(): void;
+    onDestroy(): void;
+    createHandle(position: string, cursor: string): HTMLElement;
+    repositionHandles(handleStyle: any): void;
+    setCursor(value: string): void;
+    onMouseDown: (event: MouseEvent) => void;
+    findTd: (node: HTMLElement, level: number) => any;
+    onDrag: (event: MouseEvent) => void;
+    onMouseUp: () => void;
+}

package/dist/types/modules/custom-image/actions/delete-action.d.ts

@@ -0,0 +1,6 @@
+import { Action } from './action';
+export declare class DeleteAction extends Action {
+    onCreate(): void;
+    onDestroy(): void;
+    onKeyUp: (event: any) => void;
+}

package/dist/types/modules/custom-image/actions/image-toolbar-buttons.d.ts

@@ -0,0 +1,16 @@
+import { ToolbarButtonOptions, ToolButtonOption } from '../options';
+export declare const ALIGN_ATTR = "data-align";
+export declare function setAlignStyle(el: HTMLElement, display: string | null, float: string | null, margin: string | null): void;
+export declare const alignmentHandler: {
+    left: (el: HTMLElement, toolbarButtons: ImageToolbarButtons) => void;
+    center: (el: HTMLElement, toolbarButtons: ImageToolbarButtons) => void;
+    right: (el: HTMLElement, toolbarButtons: ImageToolbarButtons) => void;
+    download: (el: HTMLImageElement, toolbarButtons: ImageToolbarButtons) => void;
+    copy: (el: HTMLImageElement, toolbarButtons: ImageToolbarButtons) => Promise<void>;
+};
+export declare class ImageToolbarButtons {
+    buttons: Record<string, ToolButtonOption>;
+    constructor(options: ToolbarButtonOptions);
+    getItems(): ToolButtonOption[];
+    clear(el: HTMLElement): void;
+}

package/dist/types/modules/custom-image/actions/index.d.ts

@@ -0,0 +1,6 @@
+export * from './action';
+export * from './custom-resize-action';
+export * from './delete-action';
+export * from './image-toolbar-buttons';
+export * from './toolbar';
+export * from './toolbar-action';

package/dist/types/modules/custom-image/actions/toolbar-action.d.ts

@@ -0,0 +1,11 @@
+import { BlotFormatter } from '../blot-formatter';
+import { Action } from './action';
+import { ImageToolbarButtons } from './image-toolbar-buttons';
+import { ImageToolbar } from './toolbar';
+export declare class ImageToolbarAction extends Action {
+    toolbar: ImageToolbar;
+    buttons: ImageToolbarButtons;
+    constructor(formatter: BlotFormatter);
+    onCreate(): void;
+    onDestroy(): void;
+}

package/dist/types/modules/custom-image/actions/toolbar.d.ts

@@ -0,0 +1,19 @@
+import { BlotFormatter } from '../blot-formatter';
+import { ToolButtonOption } from '../options';
+import { ImageToolbarButtons } from './image-toolbar-buttons';
+export declare class ImageToolbar {
+    toolbar?: HTMLElement;
+    buttons: HTMLElement[];
+    constructor();
+    create(formatter: BlotFormatter, toolButton: ImageToolbarButtons): HTMLElement;
+    destroy(): void;
+    getElement(): HTMLElement;
+    addToolbarStyle(formatter: BlotFormatter, toolbar: HTMLElement): void;
+    addButtonStyle(button: HTMLElement, index: number, formatter: BlotFormatter): void;
+    addButtons(formatter: BlotFormatter, toolbar: HTMLElement, toolButton: ImageToolbarButtons): void;
+    preselectButton(button: HTMLElement, toolButtonOption: ToolButtonOption, formatter: BlotFormatter, toolButton: ImageToolbarButtons): void;
+    onButtonClick(button: HTMLElement, formatter: BlotFormatter, toolButtonOption: ToolButtonOption, toolButton: ImageToolbarButtons): void;
+    clickButton(button: HTMLElement, target: HTMLImageElement, formatter: BlotFormatter, toolButtonOption: ToolButtonOption, toolButton: ImageToolbarButtons): void;
+    selectButton(formatter: BlotFormatter, button: HTMLElement): void;
+    deselectButton(formatter: BlotFormatter, button: HTMLElement): void;
+}

package/dist/types/modules/custom-image/blot-formatter.d.ts

@@ -0,0 +1,23 @@
+import { default as FluentEditor } from '../../core/fluent-editor';
+import { Action } from './actions';
+import { BlotFormatterOptions } from './options';
+import { BlotSpec } from './specs';
+export declare class BlotFormatter {
+    quill: FluentEditor;
+    options: BlotFormatterOptions;
+    currentSpec: BlotSpec;
+    specs: BlotSpec[];
+    overlay: HTMLElement;
+    actions: Action[];
+    observer: MutationObserver;
+    static register(): void;
+    constructor(quill: FluentEditor, options?: Partial<BlotFormatterOptions>);
+    show(spec: BlotSpec): void;
+    hide(): void;
+    update(): void;
+    createActions(spec: BlotSpec): void;
+    destroyActions(): void;
+    repositionOverlay(): void;
+    setUserSelect(value: string): void;
+    onClick: () => void;
+}

package/dist/types/modules/custom-image/image.d.ts

@@ -0,0 +1,28 @@
+import { Parchment as TypeParchment } from 'quill';
+import { default as TypeEmbed } from 'quill/blots/embed';
+declare const Embed: typeof TypeEmbed;
+export type ImageValue = string | {
+    src: string;
+    align?: string;
+    height?: number;
+    width?: number;
+};
+export declare class CustomImage extends Embed {
+    static blotName: string;
+    static tagName: string;
+    static ID_SEED: number;
+    static allowInvalidUrl: boolean;
+    domNode: HTMLElement;
+    static setOptions(allowInvalidUrl: boolean): void;
+    static create(value: ImageValue): HTMLElement;
+    static formats(domNode: HTMLElement): {};
+    static match(url: string): boolean;
+    static register(): void;
+    static sanitize(url: string): string;
+    static value(domNode: HTMLElement): any;
+    format(name: string, value: any): void;
+    unWrap(): void;
+    wrap(name: string, value?: any): TypeParchment.Parent;
+    wrap(wrapper: TypeParchment.Parent): TypeParchment.Parent;
+}
+export {};

package/dist/types/modules/custom-image/index.d.ts

@@ -0,0 +1,4 @@
+export * from './actions';
+export * from './blot-formatter';
+export * from './image';
+export * from './specs';

package/dist/types/modules/custom-image/options.d.ts

@@ -0,0 +1,47 @@
+import { ImageToolbar, ImageToolbarButtons } from './actions';
+import { BlotSpec } from './specs';
+export interface OverlayOptions {
+    className: string;
+    style: Record<string, string>;
+}
+export interface ResizeOptions {
+    handleClassName: string;
+    handleStyle: Record<string, string>;
+}
+export interface ToolButtonOption {
+    name: string;
+    icon: string;
+    isActive?: (el: HTMLElement) => boolean;
+    apply: (this: ImageToolbar, el: HTMLImageElement, toolbarButtons: ImageToolbarButtons) => void;
+}
+export interface ToolbarButtonOptions {
+    buttons: Record<string, ToolButtonOption | boolean>;
+}
+export interface ToolbarOptions extends ToolbarButtonOptions {
+    mainClassName: string;
+    mainStyle: Record<string, unknown>;
+    buttonClassName: string;
+    addButtonSelectStyle: boolean;
+    buttonStyle: Record<string, unknown>;
+    svgStyle: Record<string, unknown>;
+}
+export interface BlotFormatterOptionsInput {
+    specs: typeof BlotSpec[];
+    overlay: Partial<OverlayOptions>;
+    resize: Partial<ResizeOptions>;
+    toolbar: Partial<ToolbarOptions>;
+}
+export interface BlotFormatterOptions {
+    specs: typeof BlotSpec[];
+    overlay: OverlayOptions;
+    resize: ResizeOptions;
+    toolbar: ToolbarOptions;
+    allowInvalidUrl: boolean;
+}
+export declare const LEFT_ALIGN = "align-left";
+export declare const CENTER_ALIGN = "align-center";
+export declare const RIGHT_ALIGN = "align-right";
+export declare const COPY = "copy";
+export declare const DOWNLOAD = "download";
+declare const DefaultOptions: BlotFormatterOptions;
+export default DefaultOptions;

package/dist/types/modules/custom-image/specs/blot-spec.d.ts

@@ -0,0 +1,12 @@
+import { BlotFormatter } from '../blot-formatter';
+import { CustomResizeAction, DeleteAction, ImageToolbarAction } from '../actions';
+export declare class BlotSpec {
+    formatter: BlotFormatter;
+    constructor(formatter: BlotFormatter);
+    init(): void;
+    getActions(): (typeof ImageToolbarAction | typeof CustomResizeAction | typeof DeleteAction)[];
+    getTargetElement(): HTMLElement | null;
+    getOverlayElement(): HTMLElement;
+    setSelection(): void;
+    onHide(): void;
+}

package/dist/types/modules/custom-image/specs/custom-image-spec.d.ts

@@ -0,0 +1,17 @@
+import { BlotFormatter } from '../blot-formatter';
+import { ImageSpec } from './image-spec';
+export declare class CustomImageSpec extends ImageSpec {
+    editorElem: HTMLElement | undefined;
+    observer: any;
+    oldRootScrollTop: number;
+    constructor(formatter: BlotFormatter);
+    handleQuillRootScroll(): void;
+    init(): void;
+    imageMouseOver(event: any): void;
+    imageMouseout: (event: any) => void;
+    addImagePreviewOverlay(event: any): void;
+    removeImagePreviewOverlay(): void;
+    onHide(): void;
+    resetOverlayMarginTop(): void;
+    onClick: (event: MouseEvent) => void;
+}

package/dist/types/modules/custom-image/specs/image-spec.d.ts

@@ -0,0 +1,8 @@
+import { BlotSpec } from './blot-spec';
+export declare class ImageSpec extends BlotSpec {
+    img: HTMLImageElement | null;
+    init(): void;
+    getTargetElement(): HTMLImageElement;
+    onHide(): void;
+    onClick: (event: MouseEvent) => void;
+}

package/dist/types/modules/custom-image/specs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './blot-spec';
+export * from './custom-image-spec';
+export * from './image-spec';

package/dist/types/modules/custom-uploader.d.ts

@@ -0,0 +1,40 @@
+import { Range, default as Quill } from 'quill';
+import { default as TypeUploader } from 'quill/modules/uploader';
+import { default as FluentEditor } from '../core/fluent-editor';
+declare const Uploader: typeof TypeUploader;
+interface UploaderOptions {
+    mimetypes: string[];
+    handler: (this: {
+        quill: Quill;
+    }, range: Range, files: File[]) => void;
+}
+export interface FileUploaderOptions {
+    mimetypes: string[];
+    maxSize: number;
+    handler: (this: {
+        quill: FluentEditor;
+    }, range: Range, files: File[]) => Promise<(string | false)[]> | (string | false)[];
+    success: (this: {
+        quill: FluentEditor;
+    }, file: File, range: Range) => void;
+    fail: (this: {
+        quill: FluentEditor;
+    }, file: File, range: Range) => void;
+}
+export declare class FileUploader extends Uploader {
+    quill: FluentEditor;
+    static DEFAULTS: any;
+    options: Partial<UploaderOptions> & FileUploaderOptions;
+    constructor(quill: FluentEditor, options: Partial<FileUploaderOptions>);
+    resolveOptions(options?: Partial<FileUploaderOptions>): {
+        mimetypes: string[];
+        maxSize: number;
+        handler(range: Range, files: File[]): string[];
+        success(): void;
+        fail(): void;
+    } & Partial<FileUploaderOptions>;
+    validateFile(file: File): boolean;
+    getFileUrls(files: File[], range: Range): Promise<(string | false)[]>;
+    upload(range: Range, files: FileList | File[]): Promise<void>;
+}
+export {};

package/dist/types/modules/divider.d.ts

@@ -0,0 +1,8 @@
+import { BlockEmbed as TypeBlockEmbed } from 'quill/blots/block';
+declare const BlockEmbed: typeof TypeBlockEmbed;
+export declare class DividerBlot extends BlockEmbed {
+    static blotName: string;
+    static tagName: string;
+    static create(): HTMLElement;
+}
+export {};

package/dist/types/modules/emoji.d.ts

@@ -0,0 +1,39 @@
+import { EmojiMartData } from '@emoji-mart/data';
+import { computePosition } from '@floating-ui/dom';
+import { Picker } from 'emoji-mart';
+import { default as FluentEditor } from '../fluent-editor';
+export interface EmojiModuleOptions {
+    emojiData?: EmojiMartData;
+    EmojiPicker?: new (props: any) => Picker;
+    emojiPickerPosition?: typeof computePosition;
+    theme?: string;
+    locale?: string;
+    set?: string;
+    skinTonePosition?: string;
+    previewPosition?: string;
+    searchPosition?: string;
+    categories?: string[];
+    maxFrequentRows?: number;
+    perLine?: number;
+    navPosition?: string;
+    noCountryFlags?: boolean;
+    dynamicWidth?: boolean;
+}
+declare class EmojiModule {
+    private readonly quill;
+    private readonly options;
+    private picker;
+    private isPickerVisible;
+    private cleanupResizeObserver;
+    constructor(quill: FluentEditor, options?: EmojiModuleOptions);
+    private getEmojiButton;
+    private updatePickerPosition;
+    private setupContainerResizeObserver;
+    private createPicker;
+    openDialog(): void;
+    closeDialog(): void;
+    private handleEmojiSelect;
+    private handleClickOutside;
+    destroy(): void;
+}
+export { EmojiModule };

package/dist/types/modules/file/formats/file.d.ts

@@ -0,0 +1,18 @@
+import { default as TypeEmbed } from 'quill/blots/embed';
+declare const Embed: typeof TypeEmbed;
+export interface FileValue {
+    size: number;
+    src: string;
+    title: string;
+}
+export declare class File extends Embed {
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    static PROTOCOL_WHITELIST: string[];
+    static create(value: FileValue): HTMLAnchorElement;
+    static value(domNode: HTMLAnchorElement): Record<string, string>;
+    static getFormats(domNode: HTMLAnchorElement): Record<string, string>;
+    static sanitize(url: string): string;
+}
+export {};

package/dist/types/modules/file/index.d.ts

@@ -0,0 +1,3 @@
+export * from './formats/file';
+export * from './modules/file-bar';
+export * from './modules/file-module';

package/dist/types/modules/file/modules/file-bar.d.ts

@@ -0,0 +1,14 @@
+export declare class FileBar {
+    quill: any;
+    file: any;
+    domNode: HTMLElement;
+    fileRange: any;
+    template: string;
+    constructor(quill: any, target: any);
+    createFileBar(): void;
+    destroy(): void;
+    operateFile(event: any, operate: any): void;
+    setPosition(): void;
+    css(domNode: any, rules: any): void;
+    formatDate(timestamp: any): string;
+}

package/dist/types/modules/file/modules/file-module.d.ts

@@ -0,0 +1,9 @@
+import { default as FluentEditor } from '../../../core/fluent-editor';
+import { FileBar } from './file-bar';
+export declare class FileModule {
+    quill: FluentEditor;
+    fileBar: FileBar;
+    static register(): void;
+    constructor(quill: FluentEditor);
+    clickEvent(event: MouseEvent): void;
+}

package/dist/types/modules/i18n.d.ts

@@ -0,0 +1,14 @@
+import { default as FluentEditor } from '../fluent-editor';
+export interface I18NOptions {
+    lang: string;
+}
+export declare class I18N {
+    quill: FluentEditor;
+    static register(inputLangs: Record<string, Record<string, string>>, isCover?: boolean): void;
+    static parserText(text: string, lang: string): string;
+    options: I18NOptions;
+    constructor(quill: FluentEditor, options: Partial<I18NOptions>);
+    resolveLanguageOption(options: Partial<I18NOptions>): I18NOptions;
+    changeLanguage(options: Partial<I18NOptions>, force?: boolean): void;
+}
+export default I18N;

package/dist/types/modules/index.d.ts

@@ -0,0 +1,16 @@
+export * from './collaborative-editing';
+export * from './counter';
+export * from './custom-clipboard';
+export * from './custom-image';
+export * from './custom-uploader';
+export * from './divider';
+export * from './emoji';
+export * from './file';
+export * from './i18n';
+export * from './link';
+export * from './mathlive';
+export * from './mention';
+export * from './shortcut-key';
+export * from './syntax';
+export * from './table-up';
+export * from './toolbar';

package/dist/types/modules/link/formats/link.d.ts

@@ -0,0 +1,15 @@
+import { default as TypeInline } from 'quill/blots/inline';
+declare const Inline: typeof TypeInline;
+export declare class LinkBlot extends Inline {
+    static blotName: string;
+    static tagName: string;
+    static SANITIZED_URL: string;
+    static PROTOCOL_WHITELIST: string[];
+    static className: string;
+    static autoProtocol: string;
+    static create(value: string): HTMLElement;
+    static formats(domNode: HTMLElement): string | null;
+    static sanitize(url: string): string;
+    format(name: string, value: any): void;
+}
+export {};

package/dist/types/modules/link/index.d.ts

@@ -0,0 +1,2 @@
+export * from './formats/link';
+export * from './modules/tooltip';

package/dist/types/modules/link/modules/tooltip.d.ts

@@ -0,0 +1,27 @@
+import { default as FluentEditor } from '../../../core/fluent-editor';
+import { BaseTooltip } from 'quill/themes/base';
+export declare class LinkTooltip extends BaseTooltip {
+    quill: FluentEditor;
+    static TEMPLATE: string;
+    isInputFocus: boolean;
+    isHover: boolean;
+    debouncedHideToolTip: any;
+    debouncedShowToolTip: any;
+    options: {
+        autoProtocol: string;
+    };
+    constructor(quill: FluentEditor, bounds: any);
+    setTemplate(): void;
+    resolveOptions(): void;
+    shouldHide(): boolean;
+    hideToolTip(): void;
+    showToolTip(name: any, value: any, range: any): void;
+    handleMouseLeave(): void;
+    handleMouseEnter(event: MouseEvent): void;
+    listen(): void;
+    save(): void;
+    position(reference: any): number;
+    edit(mode: string, preview: any, range: any): void;
+    show(): void;
+    addHttpProtocol(url: string): string;
+}

package/dist/types/modules/mathlive/formats.d.ts

@@ -0,0 +1,22 @@
+import { MathfieldElement } from 'mathlive';
+import { Root } from 'parchment';
+declare const Parchment: typeof import("parchment");
+export type MathliveBlotMode = 'dialog' | 'only-read';
+export declare class MathliveBlot extends Parchment.EmbedBlot {
+    domNode: MathfieldElement;
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    mode: MathliveBlotMode;
+    static create(obj: {
+        value: string;
+        mode: MathliveBlotMode;
+    }): MathfieldElement;
+    static value(domNode: MathfieldElement): {
+        value: string;
+        mode: string;
+    };
+    constructor(scroll: Root, domNode: MathfieldElement);
+    html(): string;
+}
+export {};

package/dist/types/modules/mathlive/index.d.ts

@@ -0,0 +1,3 @@
+export * from './formats';
+export * from './module';
+export * from './tooltip';

package/dist/types/modules/mathlive/module.d.ts

@@ -0,0 +1,9 @@
+import { default as Quill } from 'quill';
+import { MathliveTooltip } from './tooltip';
+export declare class MathliveModule {
+    quill: Quill;
+    tooltip: MathliveTooltip;
+    static register(): void;
+    constructor(quill: Quill);
+    createDialog(value?: string): void;
+}

package/dist/types/modules/mathlive/tooltip.d.ts

@@ -0,0 +1,18 @@
+import { MathfieldElement } from 'mathlive';
+import { Bounds } from 'quill/core/selection';
+import { default as TypeTooltip } from 'quill/ui/tooltip';
+import { default as Quill } from 'quill';
+declare const Tooltip: typeof TypeTooltip;
+export declare class MathliveTooltip extends Tooltip {
+    static TEMPLATE: string;
+    mathliveDom: MathfieldElement;
+    editValue?: string;
+    constructor(quill: Quill, boundsContainer?: HTMLElement);
+    listen(): void;
+    cancel(): void;
+    edit(value?: string): void;
+    restoreFocus(): void;
+    save(): void;
+    position(reference: Bounds): number;
+}
+export {};

package/dist/types/modules/mention/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ON_MENTION_LINK_REMOVE = "mention-link/remove";
+export declare const MENTION_CHAR = "mentionChar";
+export declare const DEFAULT_MENTION_CHAR = "@";

package/dist/types/modules/mention/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mention';
+export * from './mention-link';

package/dist/types/modules/mention/mention-link.d.ts

@@ -0,0 +1,16 @@
+import { default as TypeEmbed } from 'quill/blots/embed';
+import { default as TypeScroll } from 'quill/blots/scroll';
+declare const Embed: typeof TypeEmbed;
+export declare class MentionLink extends Embed {
+    scroll: TypeScroll;
+    static blotName: string;
+    static tagName: string;
+    static className: string;
+    mentionData: any;
+    static create(data: any): HTMLElement;
+    static value(domNode: HTMLElement): Record<string, any>;
+    constructor(scroll: TypeScroll, domNode: any, data: any);
+    value(): any;
+    remove(): void;
+}
+export {};

package/dist/types/modules/mention/mention.d.ts

@@ -0,0 +1,53 @@
+import { default as Quill } from 'quill';
+export interface MentionOption {
+    containerClass?: string;
+    defaultLink?: string;
+    itemActiveClass?: string;
+    itemKey: string;
+    itemClass?: string;
+    listClass?: string;
+    listHideClass?: string;
+    maxHeight?: number;
+    mentionChar?: string;
+    remove?: (data: any) => void;
+    renderMentionItem?: (data: any) => string | HTMLElement;
+    renderMentionText?: (data: any) => string | HTMLElement;
+    search?: (term: string) => Promise<any[]> | any[];
+    searchKey: string;
+    select?: (data: any) => void;
+    target?: string;
+}
+export declare class Mention {
+    private quill;
+    private readonly options;
+    private readonly mentionListEL;
+    private activeMentionIndex;
+    private latestMentionList;
+    private latestMentionCharPos;
+    private latestCaretPos;
+    private searchTerm;
+    private needInsertBr;
+    private readonly defaultOptions;
+    static register(): void;
+    constructor(quill: Quill, options: MentionOption);
+    on(eventName: any, callback: any): void;
+    getMentionItemIndex(itemEl: Element): unknown;
+    handleTextChange: (_delta: any, _oldDelta: any, source: any) => void;
+    handleMouseClick(_itemEl: HTMLLIElement, index: number): void;
+    handleMouseEnter(_itemEl: HTMLLIElement, index: number): void;
+    handleArrowUpKey: () => boolean;
+    handleArrowDownKey: () => boolean;
+    handleEnterKey: () => boolean;
+    handleEscapeKey: () => boolean;
+    getActiveMentionItem(): Element;
+    isOpen(): boolean;
+    searchMentionListByTerm(term: string): Promise<void>;
+    showMentionList(mentionList: any[]): void;
+    hideMentionList(): void;
+    setMentionListPos(): void;
+    render(mentionList: any[]): void;
+    highlightMentionItem(index: number): void;
+    scrollIntoView(node: Element): void;
+    selectMentionItem(index?: number, isClick?: boolean): void;
+    insertMentionBlot(activeMentionItem: any, isClick?: boolean): void;
+}