@pixerate/editor 0.23.0 → 0.25.0

package/dist/index-CCr_z9kF.d.cts

@@ -1,899 +0,0 @@
-import { Mark, Extension, Node, Editor, Extensions } from '@tiptap/core';
-import { C as ColorGradient, f as Template } from './tokens-CyLZmIei.cjs';
-import { EditorState, PluginKey, Transaction } from '@tiptap/pm/state';
-import { DecorationSet, EditorView } from '@tiptap/pm/view';
-import { Node as Node$1 } from '@tiptap/pm/model';
-import { R as ReviewAuthor, b as CommentStore, C as CommentAnchor, i as MentionOptions, k as TrackChangesOptions } from './track-changes-BSF58RK0.cjs';
-import { MarkdownOptions } from 'tiptap-markdown';
-import { ImageOptions as ImageOptions$1 } from '@tiptap/extension-image';
-import { c as ImportAdapter, I as ImportAdapterRegistry, b as FindImportAdapterQuery, i as ImportTarget, h as ImportInput, g as ImportFileOptions, a as ImportOutcome, R as RegisterImportAdapterOptions, F as FileLike } from './registry-GJI4gToU.cjs';
-
-interface GradientTextOptions {
-    templateColorMap: Map<string, ColorGradient>;
-    speed?: number;
-    jsonVariables?: string[] | Set<string>;
-    onTemplateClick?: (templateName: string, event: MouseEvent) => void;
-}
-declare const GradientText: Mark<GradientTextOptions, any>;
-
-interface SlashCommandMatchData {
-    match: RegExpMatchArray;
-    query: string;
-    from: number;
-    to: number;
-    coords: {
-        top: number;
-        left: number;
-        bottom: number;
-        right: number;
-    };
-}
-interface SlashCommandsOptions {
-    trigger?: string;
-    onMatch?: (data: SlashCommandMatchData) => void;
-    onClear?: () => void;
-    containerId?: string;
-}
-declare const SlashCommands: Extension<SlashCommandsOptions, any>;
-
-interface TemplateSuggestionsOptions {
-    templates: Template[];
-    char?: string;
-    onSuggestion?: (props: {
-        query: string;
-        range: {
-            from: number;
-            to: number;
-        };
-        clientRect?: (() => DOMRect | null) | null;
-        items: Template[];
-        command: (props: {
-            name: string;
-        }) => void;
-    }) => void;
-}
-declare const TemplateSuggestions: Extension<TemplateSuggestionsOptions, any>;
-
-declare const LoadingNode: Node<any, any>;
-
-/**
- * Context passed to function replacements.
- */
-interface AutocorrectContext {
-    /** Text of the current block before the caret, including the typed text. */
-    textBefore: string;
-    /** Returns true if `text` is in the exceptions list (case-insensitive). */
-    isException: (text: string) => boolean;
-    /** Editor state before the typed text was inserted. */
-    state: EditorState;
-}
-/**
- * An autocorrect rule. Rules are checked in order after every typed character
- * against the text before the caret; the first one that produces a
- * replacement wins.
- *
- * - `find: string` matches when the text before the caret ends with it.
- *   With `wholeWord: true` it must also be a whole word followed by a space or
- *   punctuation (Word's AutoCorrect entries, e.g. `teh ` -> `the `); the
- *   delimiter is kept.
- * - `find: RegExp` must match at the end of the text (anchor it with `$`).
- *
- * `replace` replaces the whole match. A string is inserted literally (no `$1`
- * patterns); use a function to reuse capture groups. Return `null` from a
- * function to skip the correction.
- */
-interface AutocorrectRule {
-    id: string;
-    find: string | RegExp;
-    replace: string | ((match: RegExpMatchArray, context: AutocorrectContext) => string | null | undefined);
-    wholeWord?: boolean;
-}
-/**
- * A correction that was applied.
- */
-interface AutocorrectCorrection {
-    ruleId: string;
-    /** Document range of the replacement text after the correction. */
-    from: number;
-    to: number;
-    original: string;
-    replacement: string;
-}
-interface AutocorrectOptions {
-    /** Rules in priority order. Defaults to `defaultAutocorrectRules`. */
-    rules: AutocorrectRule[];
-    /**
-     * Exceptions (Word's AutoCorrect exceptions). Matched case-insensitively.
-     * - Abbreviations ending in `.` (e.g. `e.g.`) do not end a sentence, so the
-     *   next word is not capitalized.
-     * - Words like `IDs` are not "fixed" by the two-initial-capitals rule.
-     * - Any other entry is text that should never be corrected (the matched
-     *   text, e.g. `(c)` or `teh`).
-     */
-    exceptions: string[];
-    /** Node types in which nothing is corrected (plus any node with `code: true`). */
-    ignoreNodes: string[];
-    /** Mark types in which nothing is corrected (plus any mark with `code: true`). */
-    ignoreMarks: string[];
-    /** Skip corrections inside `{{template}}`, `{variable}` and `__instruction__` tokens. */
-    ignorePromptTokens: boolean;
-    /** Called after each correction. */
-    onCorrection?: (correction: AutocorrectCorrection) => void;
-}
-interface AutocorrectStorage {
-    /** Whether corrections are applied. Toggle with `setAutocorrectEnabled`. */
-    enabled: boolean;
-    /** Live exceptions set (lowercased). Edit with the exception commands. */
-    exceptions: Set<string>;
-}
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        autocorrect: {
-            /** Reverts the last correction if nothing else has changed since. */
-            undoAutocorrect: () => ReturnType;
-            /** Enables or disables autocorrect. */
-            setAutocorrectEnabled: (enabled: boolean) => ReturnType;
-            /** Adds an entry to the exceptions list. */
-            addAutocorrectException: (text: string) => ReturnType;
-            /** Removes an entry from the exceptions list. */
-            removeAutocorrectException: (text: string) => ReturnType;
-        };
-    }
-}
-/** Smart (curly) quotes and apostrophes. */
-declare const smartQuoteRules: AutocorrectRule[];
-/** Symbols: em dash, ellipsis, arrows, copyright, registered, trademark. */
-declare const symbolRules: AutocorrectRule[];
-/** Fractions (`1/2`, `1/4`, `3/4`), corrected once the number is complete. */
-declare const fractionRules: AutocorrectRule[];
-/**
- * Capitalizes the first letter of a sentence when the word is completed.
- * Abbreviations in the exceptions list (and single-letter initials such as
- * `J.`) do not end a sentence.
- */
-declare const capitalizeSentenceRules: AutocorrectRule[];
-/** Fixes TWo INitial CApitals (`THe ` -> `The `), unless the word is an exception. */
-declare const twoInitialCapitalsRules: AutocorrectRule[];
-/**
- * The default rule set: smart quotes, symbols, fractions, sentence
- * capitalization and two-initial-capitals.
- */
-declare const defaultAutocorrectRules: AutocorrectRule[];
-/** Default exceptions: common abbreviations and two-capital words. */
-declare const DEFAULT_AUTOCORRECT_EXCEPTIONS: string[];
-declare const autocorrectPluginKey: PluginKey<AutocorrectPluginState>;
-interface AutocorrectPluginState {
-    last: AutocorrectCorrection | null;
-    /** The next typed text should start a new undo group. */
-    closePending: boolean;
-}
-/**
- * Finds the first matching rule for `textBefore`. Exported for testing and for
- * custom input pipelines.
- */
-declare function findAutocorrection(textBefore: string, rules: readonly AutocorrectRule[], context: Omit<AutocorrectContext, "textBefore">): {
-    ruleId: string;
-    start: number;
-    original: string;
-    replacement: string;
-} | null;
-/**
- * True when the end of `textBefore` is inside an unclosed prompt token:
- * `{{template`, `{variable` or `__instruction`.
- */
-declare function isInsidePromptToken(textBefore: string): boolean;
-/**
- * Word-style AutoCorrect with a configurable rule registry and exceptions
- * list. Each correction is its own undo step: undo (Mod-z) right after a
- * correction restores exactly what was typed. Corrections never apply inside
- * code blocks, inline code or (by default) prompt tokens.
- *
- * Do not combine with `@tiptap/extension-typography`: TipTap's input rules
- * run first and would pre-empt the overlapping rules. `createRichTextPreset`
- * drops Typography when `autocorrect` is enabled.
- */
-declare const Autocorrect: Extension<AutocorrectOptions, AutocorrectStorage>;
-
-/**
- * Smilie patterns (each ending in a typed space) and their replacements.
- * Longer patterns come first so they win over their prefixes.
- */
-declare const SMILIE_REPLACEMENTS: ReadonlyArray<readonly [RegExp, string]>;
-/**
- * The smilies as `Autocorrect` rules. Straight apostrophes in the patterns
- * also match curly `‘` and `’`, because the smart-quote rule converts `'` as soon as
- * it is typed.
- */
-declare const smilieAutocorrectRules: AutocorrectRule[];
-declare const SmilieReplacer: Extension<any, any>;
-
-declare function findHexColors(doc: Node$1): DecorationSet;
-declare const ColorHighlighter: Extension<any, any>;
-
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        fontSize: {
-            setFontSize: (size: string) => ReturnType;
-            unsetFontSize: () => ReturnType;
-        };
-    }
-}
-declare const FontSize: Extension<any, any>;
-
-/**
- * Built-in native Markdown extension for @pixerate/editor based on tiptap-markdown.
- * Enables automatic markdown parsing, serialization, and clipboard handling.
- */
-declare const Markdown: any;
-
-interface ImageOptions extends Partial<ImageOptions$1> {
-    /**
-     * Custom upload handler called when an image is pasted or dropped.
-     * Resolves to the uploaded image URL string.
-     */
-    upload?: (file: File) => Promise<string> | string;
-    /**
-     * Callback invoked if the upload handler throws or rejects, or if an image
-     * exceeds maxBase64Size when no upload handler is configured.
-     */
-    onUploadError?: (error: Error, file: File) => void;
-    /**
-     * Maximum allowed file size (in bytes) when embedding images as base64 data URLs
-     * without an upload handler. Defaults to 65536 (64 KB).
-     * Files larger than this will be rejected to avoid memory bloat and prompt/stream saturation.
-     */
-    maxBase64Size?: number;
-    /**
-     * Whether to enable automatic image pasting from clipboard. Defaults to true.
-     */
-    enablePaste?: boolean;
-    /**
-     * Whether to enable automatic image drop. Defaults to true.
-     */
-    enableDrop?: boolean;
-}
-declare const imagePastePluginKey: PluginKey<any>;
-/**
- * Inserts an image node into the editor view at the current selection.
- */
-declare function insertImageNode(view: any, src: string, alt?: string): void;
-/**
- * Updates an existing image node's src attribute across document positions.
- */
-declare function updateImageSrc(view: any, oldSrc: string, newSrc: string): void;
-/**
- * Removes an existing image node matching src attribute across document positions.
- */
-declare function removeImageNode(view: any, src: string): void;
-/**
- * Handles inserting a pasted or dropped image file, supporting both async upload
- * handlers and direct base64/object-URL fallbacks.
- */
-declare function handleImageInsertion(view: any, file: File, options: ImageOptions): void;
-declare const Image: any;
-
-interface CommentsOptions {
-    /**
-     * The store holding the threads. Pass your own to share it with UI or to
-     * persist it; otherwise one is created and exposed as
-     * `editor.storage.comment.store`.
-     */
-    store: CommentStore | null;
-    /** The current user, used as author of new comments. */
-    author: ReviewAuthor | (() => ReviewAuthor);
-    HTMLAttributes: Record<string, any>;
-    /** Class for unresolved comment ranges (applied as a decoration). */
-    commentClass: string;
-    /** Extra class for the active thread's range. */
-    activeClass: string;
-    /** Class for resolved comment ranges. Empty hides them. */
-    resolvedClass: string;
-    /** Make the thread under the caret active when the selection moves. */
-    activateOnSelection: boolean;
-}
-interface CommentsStorage {
-    store: CommentStore;
-}
-interface AddCommentOptions {
-    body?: string;
-    id?: string;
-    author?: ReviewAuthor;
-}
-interface CommentRange {
-    from: number;
-    to: number;
-}
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        comment: {
-            /**
-             * Adds a comment thread on the current (non-empty) selection. The new
-             * thread becomes active. An empty `body` creates a draft for the UI to
-             * fill in.
-             */
-            addComment: (options?: AddCommentOptions) => ReturnType;
-            /** Resolves (or re-opens with `false`) a thread. */
-            resolveComment: (id: string, resolved?: boolean) => ReturnType;
-            /** Removes the thread's mark from the document and deletes the thread. */
-            deleteComment: (id: string) => ReturnType;
-            setActiveComment: (id: string | null) => ReturnType;
-            /** Selects the thread's text, scrolls to it and makes it active. */
-            focusComment: (id: string) => ReturnType;
-        };
-    }
-}
-declare const commentsPluginKey: PluginKey<any>;
-declare const COMMENT_MARK_NAME = "comment";
-/**
- * Returns every range covered by a `comment` mark, grouped by thread id and
- * merged where contiguous, in document order.
- */
-declare function findCommentRanges(doc: Node$1): Map<string, CommentRange[]>;
-/**
- * Computes one anchor per thread (spanning all of its ranges) from the document.
- */
-declare function getCommentAnchors(doc: Node$1): Map<string, CommentAnchor>;
-/** Thread ids of the comment marks at a position (caret or selection start). */
-declare function getCommentIdsAt(state: EditorState, pos?: number): string[];
-/** Returns the comment store of an editor using the `Comments` extension. */
-declare function getCommentStore(editor: Editor | null | undefined): CommentStore | null;
-/**
- * Comment threads anchored to text with a `comment` mark. Thread content
- * (bodies, replies, resolved state) lives in a headless `CommentStore`; the
- * document only stores thread ids, so overlapping comments are allowed.
- *
- * Threads whose text is deleted are flagged `orphaned` (not removed), so
- * undoing the deletion re-attaches them.
- */
-declare const Comments: Mark<CommentsOptions, CommentsStorage>;
-/** The current author configured on an editor's `Comments` extension. */
-declare function getCommentAuthor(editor: Editor | null | undefined): ReviewAuthor | null;
-
-/** Result of every `document` adapter: sanitized TipTap HTML plus plain text. */
-interface DocumentImport {
-    /** Sanitized HTML ready for `setContent` / `insertContent`. */
-    html: string;
-    /** Plain-text version, used by plain-text (prompt) editors. */
-    text: string;
-}
-type DocumentImportAdapter = ImportAdapter<DocumentImport>;
-/**
- * Markdown files. Rendered with the same sanitizing pipeline as
- * `markdownToTipTapHtml`. `.txt` is deliberately left to the plain-text
- * adapter so ordinary text files are not reinterpreted as markdown; `.md.txt`
- * still matches here because the longest extension wins.
- */
-declare const markdownImportAdapter: DocumentImportAdapter;
-/** HTML files and fragments, sanitized with `sanitizeImportedHtml`. */
-declare const htmlImportAdapter: DocumentImportAdapter;
-/** Plain text: one paragraph per line, always escaped. */
-declare const plainTextImportAdapter: DocumentImportAdapter;
-/**
- * RTF: best-effort text extraction with `rtfToPlainText` (paragraphs and
- * characters only; formatting, tables and images are dropped).
- */
-declare const rtfImportAdapter: DocumentImportAdapter;
-declare const BUILT_IN_IMPORT_ADAPTERS: readonly DocumentImportAdapter[];
-interface CreateImportAdapterRegistryOptions {
-    /** Register the built-in document adapters (default `true`). */
-    builtIns?: boolean;
-}
-declare function createImportAdapterRegistry(options?: CreateImportAdapterRegistryOptions): ImportAdapterRegistry;
-/** Shared registry used by the module-level helpers and editor integrations. */
-declare const defaultImportRegistry: ImportAdapterRegistry;
-/** Registers an adapter on the default registry; returns an unregister function. */
-declare function registerImportAdapter<TResult>(adapter: ImportAdapter<TResult>, options?: RegisterImportAdapterOptions): () => void;
-declare function unregisterImportAdapter(adapterOrId: string | ImportAdapter<any>): boolean;
-declare function findImportAdapter(query: FindImportAdapterQuery): ImportAdapter | undefined;
-/** Imports a file with the default registry. */
-declare function importFile<TResult = unknown>(input: ImportInput, options?: ImportFileOptions): Promise<ImportOutcome<TResult>>;
-/** `accept` attribute value for the default registry. */
-declare function getImportAccept(target?: ImportTarget): string;
-
-interface FileImportOptions {
-    /** Registry used to match files (default: the shared default registry). */
-    registry?: ImportAdapterRegistry;
-    /** Insert extracted plain text instead of HTML (plain-text / prompt editors). */
-    asPlainText?: boolean;
-    /** Import files dropped onto the editor (default `true`). */
-    enableDrop?: boolean;
-    /** Import files pasted into the editor, e.g. copied in a file manager (default `true`). */
-    enablePaste?: boolean;
-    /** Called after each imported file has been inserted. */
-    onImport?: (outcome: ImportOutcome<DocumentImport>, file: FileLike) => void;
-    /** Called when a file fails to import. */
-    onImportError?: (error: Error, file: FileLike) => void;
-}
-declare const fileImportPluginKey: PluginKey<any>;
-/**
- * Imports files dropped or pasted into the editor through the import adapter
- * registry (markdown, HTML, plain text and RTF by default) and inserts the
- * converted content at the drop position or selection.
- *
- * Opt-in: add it to `extensions` or pass `fileImport: true` to
- * `createRichTextPreset`. Only drops where every file has a `document`
- * adapter are handled; anything else (e.g. images) falls through.
- */
-declare const FileImport: Extension<FileImportOptions, any>;
-
-interface RichClipboardOptions {
-    /** MIME type for the slice JSON (default `application/x.pixerate.document+json`). */
-    mimeType?: string;
-    /**
-     * Never paste the rich payload; leave paste to the existing plain-text
-     * handling. `EditorController` sets this automatically in `plainTextMode`.
-     */
-    plainTextMode?: boolean;
-}
-interface RichClipboardStorage {
-    plainTextMode: boolean;
-}
-declare const richClipboardPluginKey: PluginKey<any>;
-/**
- * Writes the selection to the clipboard event as HTML, plain text and the
- * custom slice JSON. Mirrors ProseMirror's own copy handler (which would
- * otherwise clear the extra MIME type) and returns `false` when the event has
- * no writable clipboard data, so ProseMirror's handler runs instead.
- */
-declare function writeRichClipboard(view: EditorView, event: ClipboardEvent, options?: {
-    cut?: boolean;
-    mimeType?: string;
-}): boolean;
-/**
- * Internal rich-text clipboard. On copy/cut it also writes the selection as a
- * ProseMirror slice under `application/x.pixerate.document+json` together
- * with the schema signature; on paste it prefers that payload when the
- * signature matches the target editor and otherwise falls back to the normal
- * HTML / plain-text handling.
- *
- * Opt-in: add it to `extensions` or pass `richClipboard: true` to
- * `createRichTextPreset`.
- */
-declare const RichClipboard: Extension<RichClipboardOptions, RichClipboardStorage>;
-
-/**
- * A heading in the document outline, in document order.
- */
-interface OutlineHeading {
-    /** Stable id stored on the heading node (`id` attribute). */
-    id: string;
-    /** Heading level (1-6). */
-    level: number;
-    /** Plain text of the heading. */
-    text: string;
-    /** Position of the heading node in the current document. */
-    pos: number;
-    /** Index of the heading in the outline. */
-    index: number;
-    /**
-     * Nesting depth (0-based) relative to the enclosing headings, so skipped
-     * levels (an h1 followed directly by an h3) only indent one step.
-     */
-    depth: number;
-}
-/**
- * A heading with its nested sub-headings.
- */
-interface OutlineTreeItem extends OutlineHeading {
-    children: OutlineTreeItem[];
-}
-interface OutlineOptions {
-    /** Node types treated as headings. Defaults to `["heading"]`. */
-    types: string[];
-    /** Generates ids for headings that have none. */
-    generateId: () => string;
-    /** Called with the new outline whenever it changes. */
-    onUpdate?: (headings: OutlineHeading[]) => void;
-}
-interface OutlineStorage {
-    /** The latest outline. Prefer `getOutline(editor)` for a fresh read. */
-    headings: OutlineHeading[];
-}
-interface FocusHeadingOptions {
-    /** Scroll behaviour for the heading's DOM node. Defaults to `"smooth"`. */
-    behavior?: ScrollBehavior;
-    /** Whether to focus the editor and place the caret in the heading. Defaults to `true`. */
-    focus?: boolean;
-}
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        outline: {
-            /** Places the caret at the start of a heading, focuses and scrolls to it. */
-            focusHeading: (id: string, options?: FocusHeadingOptions) => ReturnType;
-            /** Scrolls a heading into view without moving the selection. */
-            scrollToHeading: (id: string, options?: Omit<FocusHeadingOptions, "focus">) => ReturnType;
-        };
-    }
-}
-declare const outlinePluginKey: PluginKey<OutlineHeading[]>;
-/**
- * Derives the heading outline from a document. Only block nodes are visited
- * (headings cannot nest inside text), so the cost is proportional to the number
- * of blocks, not characters.
- */
-declare function computeOutline(doc: Node$1, types?: readonly string[]): OutlineHeading[];
-/**
- * Nests a flat outline into a tree by heading level.
- */
-declare function buildOutlineTree(headings: readonly OutlineHeading[]): OutlineTreeItem[];
-/**
- * Returns the outline of an editor state. Uses the Outline plugin's cached
- * outline when the extension is installed, otherwise computes it.
- */
-declare function getOutline(editorOrState: Editor | EditorState): OutlineHeading[];
-/**
- * Returns the heading whose section contains the selection head: the last
- * heading starting at or before it.
- */
-declare function getActiveHeading(editorOrState: Editor | EditorState, headings?: readonly OutlineHeading[]): OutlineHeading | null;
-/**
- * Snapshot of the outline for UI bindings. Snapshots are immutable and only
- * replaced when the outline or the active heading changes, so they can be used
- * directly with `useSyncExternalStore` or Svelte state.
- */
-interface OutlineSnapshot {
-    headings: OutlineHeading[];
-    tree: OutlineTreeItem[];
-    activeId: string | null;
-}
-interface OutlineStore {
-    getSnapshot: () => OutlineSnapshot;
-    subscribe: (listener: () => void) => () => void;
-    destroy: () => void;
-}
-/**
- * Creates an observable outline store for an editor, shared by the React and
- * Svelte outline panels.
- */
-declare function createOutlineStore(editor: Editor | null | undefined): OutlineStore;
-/**
- * Moves the caret to the start of a heading, focuses the editor and scrolls the
- * heading into view. Works with or without the Outline extension installed.
- */
-declare function navigateToHeading(editor: Editor, heading: Pick<OutlineHeading, "id" | "pos">, options?: FocusHeadingOptions): boolean;
-/**
- * Headless document outline. Gives every heading a stable `id` attribute
- * (rendered as the HTML `id`, so `#id` links work in exported HTML) and keeps
- * an up-to-date outline in plugin state. Read it with `getOutline(editor)` or
- * observe it with `createOutlineStore(editor)`.
- */
-declare const Outline: Extension<OutlineOptions, OutlineStorage>;
-
-/**
- * An entry rendered by a table of contents node.
- */
-interface TableOfContentsEntry {
-    id: string | null;
-    level: number;
-    text: string;
-    depth: number;
-}
-interface TableOfContentsOptions {
-    HTMLAttributes: Record<string, any>;
-    /** Heading node types to list. Defaults to `["heading"]`. */
-    headingTypes: string[];
-    /** Default title for newly inserted tables of contents. */
-    defaultTitle: string;
-    /** Text shown when the document has no headings. */
-    emptyText: string;
-}
-interface InsertTableOfContentsOptions {
-    title?: string;
-    minLevel?: number;
-    maxLevel?: number;
-}
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        tableOfContents: {
-            /** Inserts a table of contents block at the selection. */
-            insertTableOfContents: (options?: InsertTableOfContentsOptions) => ReturnType;
-        };
-    }
-}
-declare const tableOfContentsPluginKey: PluginKey<boolean>;
-/**
- * Builds table of contents entries from an outline, limited to a level range.
- * Depth is recomputed within the range so the shallowest listed level is 0.
- */
-declare function getTableOfContentsEntries(headings: readonly OutlineHeading[], minLevel?: number, maxLevel?: number): TableOfContentsEntry[];
-/**
- * Table of contents block. An atom node whose entries mirror the document's
- * headings; they are refreshed on every document change, so exported HTML
- * always contains the current, linked list. Install the `Outline` extension
- * alongside it so headings get stable ids to link to.
- *
- * Markdown: serialized as a `[[toc]]` line and parsed back from `[[toc]]` or
- * `[TOC]`.
- */
-declare const TableOfContents: Node<TableOfContentsOptions, any>;
-
-/**
- * A footnote as listed by `getFootnotes`.
- */
-interface FootnoteInfo {
-    id: string;
-    /** 1-based number, in document order of the references. */
-    number: number;
-    /** Plain text of the footnote content (paragraphs joined by blank lines). */
-    text: string;
-    /** Position of the reference node. */
-    referencePos: number;
-    /** Position of the footnote node in the footnotes list, if present. */
-    footnotePos: number | null;
-}
-interface FootnotesOptions {
-    HTMLAttributes: Record<string, any>;
-    /** Generates ids for new footnotes. */
-    generateId: () => string;
-}
-interface InsertFootnoteOptions {
-    /** Plain-text content. Blank lines separate paragraphs. */
-    content?: string;
-    /** Explicit id; generated when omitted. */
-    id?: string;
-    /**
-     * Move the caret into the new footnote (Word's behaviour). Defaults to `true`
-     * when no `content` is given.
-     */
-    focusContent?: boolean;
-}
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        footnotes: {
-            /** Inserts a footnote reference at the selection, plus its footnote. */
-            insertFootnote: (options?: InsertFootnoteOptions) => ReturnType;
-            /** Replaces a footnote's content with plain text. */
-            updateFootnote: (id: string, content: string) => ReturnType;
-            /** Removes a footnote and its reference. */
-            deleteFootnote: (id: string) => ReturnType;
-            /** Moves the caret into a footnote's content. */
-            goToFootnote: (id: string) => ReturnType;
-            /** Selects a footnote's reference in the body text. */
-            goToFootnoteReference: (id: string) => ReturnType;
-        };
-    }
-}
-declare const footnotesPluginKey: PluginKey<boolean>;
-/**
- * Lists the footnotes of a document in reference order.
- */
-declare function getFootnotes(doc: Node$1): FootnoteInfo[];
-/**
- * Brings the footnotes list in line with the references: one footnote per
- * reference, in reference order, numbered 1..n, in a single list that is the
- * last child of the document. Orphaned footnotes are dropped, missing ones are
- * created (empty, or with `contents[id]`), and duplicated references (from
- * copy/paste) get a new id with a copy of the original footnote.
- *
- * Returns true if the transaction was modified.
- */
-declare function syncFootnotes(tr: Transaction, options?: {
-    generateId?: () => string;
-    contents?: Record<string, string>;
-}): boolean;
-/**
- * Inline footnote reference, auto-numbered in document order. Its content
- * lives in a `footnote` item of the `footnotes` list at the end of the
- * document, which is created, renumbered, reordered and pruned automatically.
- *
- * Markdown: serialized as `[^n]` with `[^n]: text` definitions, and parsed
- * back when the Markdown extension is installed.
- */
-declare const FootnoteReference: Node<FootnotesOptions, any>;
-/**
- * The footnotes list at the end of the document. Managed automatically by
- * `FootnoteReference`; you rarely create it directly.
- */
-declare const Footnotes: Node<any, any>;
-/**
- * A single footnote's content inside the `footnotes` list.
- */
-declare const Footnote: Node<any, any>;
-
-/**
- * A bookmark as listed by `getBookmarks`.
- */
-interface BookmarkInfo {
-    id: string;
-    name: string;
-    /** Bookmarked text (all ranges carrying the bookmark, in document order). */
-    text: string;
-    /** Start of the first bookmarked range. */
-    from: number;
-    /** End of the last bookmarked range. */
-    to: number;
-}
-interface BookmarkOptions {
-    HTMLAttributes: Record<string, any>;
-    /** Generates ids for new bookmarks. */
-    generateId: () => string;
-}
-interface SetBookmarkOptions {
-    /** Display name. Setting a name that already exists moves that bookmark. */
-    name: string;
-    /** Explicit id; generated (or reused from a same-named bookmark) when omitted. */
-    id?: string;
-}
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        bookmark: {
-            /**
-             * Bookmarks the selected text (or the word at the caret when the
-             * selection is empty).
-             */
-            setBookmark: (options: SetBookmarkOptions) => ReturnType;
-            /** Removes a bookmark (the text stays). */
-            removeBookmark: (id: string) => ReturnType;
-            /** Renames a bookmark. */
-            renameBookmark: (id: string, name: string) => ReturnType;
-            /** Selects a bookmark's text and scrolls to it. */
-            goToBookmark: (id: string) => ReturnType;
-        };
-    }
-}
-/**
- * Lists the bookmarks in a document, merging the text nodes that carry each
- * bookmark into one entry.
- */
-declare function getBookmarks(doc: Node$1): BookmarkInfo[];
-/**
- * Word-style bookmark: a named, non-inclusive mark over a text range. Several
- * bookmarks may overlap. Cross-references (`CrossReference`) can point to a
- * bookmark by id and display its current text.
- */
-declare const Bookmark: Mark<BookmarkOptions, any>;
-
-type CrossReferenceTargetType = "heading" | "bookmark";
-/**
- * Something a cross-reference can point to.
- */
-interface CrossReferenceTarget {
-    type: CrossReferenceTargetType;
-    id: string;
-    /** Current text of the target (heading text or bookmarked text). */
-    text: string;
-    /** Bookmark name, or heading text. */
-    name: string;
-    /** Heading level (headings only). */
-    level?: number;
-}
-interface CrossReferenceOptions {
-    HTMLAttributes: Record<string, any>;
-    /** Heading node types that can be referenced. Defaults to `["heading"]`. */
-    headingTypes: string[];
-    /** Text shown while the target no longer exists (Word: "Error! Reference source not found."). */
-    brokenText: string;
-}
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        crossReference: {
-            /** Inserts a cross-reference to a heading or bookmark at the selection. */
-            insertCrossReference: (target: {
-                targetType: CrossReferenceTargetType;
-                targetId: string;
-            }) => ReturnType;
-            /**
-             * Moves the caret to the target of the cross-reference at `pos` (or the
-             * selected cross-reference).
-             */
-            followCrossReference: (pos?: number) => ReturnType;
-        };
-    }
-}
-declare const crossReferencePluginKey: PluginKey<boolean>;
-/**
- * Lists the headings (with stable ids, see `Outline`) and bookmarks in a
- * document, for building a cross-reference picker.
- */
-declare function getCrossReferenceTargets(doc: Node$1, headingTypes?: readonly string[]): CrossReferenceTarget[];
-/**
- * Inline cross-reference to a heading or bookmark. It displays the target's
- * current text, follows renames, and switches to a broken-reference state
- * (class `is-broken`, `brokenText`) when the target is removed. Undoing the
- * removal restores it. Heading targets need the `Outline` extension, which
- * gives headings stable ids.
- */
-declare const CrossReference: Node<CrossReferenceOptions, any>;
-
-interface DocumentStructureCommandArgs {
-    /** Range to delete first, e.g. the `/toc` text matched by `SlashCommands`. */
-    range?: {
-        from: number;
-        to: number;
-    };
-    /** Bookmark name (bookmark item). */
-    name?: string;
-    /** Footnote text (footnote item). */
-    content?: string;
-    /** Cross-reference target (cross-reference item). */
-    targetType?: CrossReferenceTargetType;
-    targetId?: string;
-}
-/**
- * A framework-agnostic menu entry for slash menus and toolbars.
- */
-interface DocumentStructureCommandItem {
-    id: "table-of-contents" | "footnote" | "bookmark" | "cross-reference";
-    title: string;
-    description: string;
-    keywords: string[];
-    /** Name of the extension that must be installed for the item to work. */
-    extension: string;
-    /**
-     * Input the host UI must collect before calling `run`: a bookmark name, or
-     * a cross-reference target (see `getCrossReferenceTargets`).
-     */
-    requires?: "name" | "target";
-    run: (editor: Editor, args?: DocumentStructureCommandArgs) => boolean;
-}
-/**
- * Menu entries for the document-structure commands.
- */
-declare const documentStructureCommandItems: DocumentStructureCommandItem[];
-/**
- * Returns the document-structure items whose extension is installed in the
- * editor, optionally filtered by a slash-command query.
- */
-declare function getDocumentStructureCommandItems(editor: Editor | null | undefined, query?: string): DocumentStructureCommandItem[];
-
-/**
- * markdown-it plugins used by the document-structure extensions' markdown
- * parse hooks (tiptap-markdown). tiptap-markdown calls every extension's
- * `parse.setup` before *each* parse on the same markdown-it instance, so the
- * plugins guard against registering their rules twice.
- */
-/**
- * Parses a line containing only `[[toc]]` (or `[TOC]`) into a table of
- * contents placeholder that the `TableOfContents` node parses.
- */
-declare function tableOfContentsMarkdownIt(md: any): void;
-/**
- * Minimal footnote syntax: `[^label]` references and `[^label]: text`
- * definitions (continuation paragraphs indented by four spaces). Renders the
- * HTML the `FootnoteReference`, `Footnotes` and `Footnote` nodes parse.
- */
-declare function footnotesMarkdownIt(md: any): void;
-
-interface RichTextPresetOptions {
-    placeholder?: string | ((props: {
-        node: any;
-    }) => string);
-    characterLimit?: number;
-    openLinksOnClick?: boolean;
-    enableSmilies?: boolean;
-    enableColorHighlighter?: boolean;
-    headingLevels?: (1 | 2 | 3 | 4 | 5 | 6)[];
-    mention?: MentionOptions | boolean;
-    markdown?: MarkdownOptions | boolean;
-    image?: ImageOptions | boolean;
-    /** Adds the `Comments` extension (off by default). */
-    comments?: Partial<CommentsOptions> | boolean;
-    /** Adds the `TrackChanges` extension (off by default). */
-    trackChanges?: Partial<TrackChangesOptions> | boolean;
-    /** Import dropped/pasted .md, .html, .txt and .rtf files (opt-in). */
-    fileImport?: FileImportOptions | boolean;
-    /** Copy/paste lossless ProseMirror slices between editors (opt-in). */
-    richClipboard?: RichClipboardOptions | boolean;
-    /**
-     * Word-style AutoCorrect (smart quotes, symbols, fractions, sentence
-     * capitalization, ...). Off by default. Replaces the Typography extension
-     * when enabled, since both handle quotes and dashes.
-     */
-    autocorrect?: Partial<AutocorrectOptions> | boolean;
-    /** Heading outline with stable heading ids. Off by default. */
-    outline?: Partial<OutlineOptions> | boolean;
-    /** Table of contents block (also enables `outline`). Off by default. */
-    tableOfContents?: Partial<TableOfContentsOptions> | boolean;
-    /** Footnote references and the footnotes list. Off by default. */
-    footnotes?: Partial<FootnotesOptions> | boolean;
-    /** Named bookmarks. Off by default. */
-    bookmarks?: Partial<BookmarkOptions> | boolean;
-    /** Cross-references to headings and bookmarks (also enables `outline`). Off by default. */
-    crossReferences?: Partial<CrossReferenceOptions> | boolean;
-}
-/**
- * Creates a standard rich-text extensions bundle with full formatting support.
- */
-declare function createRichTextPreset(options?: RichTextPresetOptions): Extensions;
-
-export { type RichClipboardStorage as $, type AddCommentOptions as A, BUILT_IN_IMPORT_ADAPTERS as B, COMMENT_MARK_NAME as C, type DocumentImport as D, Footnote as E, FileImport as F, type FootnoteInfo as G, FootnoteReference as H, Footnotes as I, type FootnotesOptions as J, GradientText as K, type GradientTextOptions as L, Image as M, type ImageOptions as N, type InsertFootnoteOptions as O, type InsertTableOfContentsOptions as P, LoadingNode as Q, Markdown as R, Outline as S, type OutlineHeading as T, type OutlineOptions as U, type OutlineSnapshot as V, type OutlineStorage as W, type OutlineStore as X, type OutlineTreeItem as Y, RichClipboard as Z, type RichClipboardOptions as _, type DocumentImportAdapter as a, tableOfContentsPluginKey as a$, type RichTextPresetOptions as a0, SMILIE_REPLACEMENTS as a1, type SetBookmarkOptions as a2, type SlashCommandMatchData as a3, SlashCommands as a4, type SlashCommandsOptions as a5, SmilieReplacer as a6, TableOfContents as a7, type TableOfContentsEntry as a8, type TableOfContentsOptions as a9, getCommentIdsAt as aA, getCommentStore as aB, getCrossReferenceTargets as aC, getDocumentStructureCommandItems as aD, getFootnotes as aE, getImportAccept as aF, getOutline as aG, getTableOfContentsEntries as aH, handleImageInsertion as aI, htmlImportAdapter as aJ, imagePastePluginKey as aK, importFile as aL, insertImageNode as aM, isInsidePromptToken as aN, markdownImportAdapter as aO, navigateToHeading as aP, outlinePluginKey as aQ, plainTextImportAdapter as aR, registerImportAdapter as aS, removeImageNode as aT, richClipboardPluginKey as aU, rtfImportAdapter as aV, smartQuoteRules as aW, smilieAutocorrectRules as aX, symbolRules as aY, syncFootnotes as aZ, tableOfContentsMarkdownIt as a_, TemplateSuggestions as aa, type TemplateSuggestionsOptions as ab, autocorrectPluginKey as ac, buildOutlineTree as ad, capitalizeSentenceRules as ae, commentsPluginKey as af, computeOutline as ag, createImportAdapterRegistry as ah, createOutlineStore as ai, createRichTextPreset as aj, crossReferencePluginKey as ak, defaultAutocorrectRules as al, defaultImportRegistry as am, documentStructureCommandItems as an, fileImportPluginKey as ao, findAutocorrection as ap, findCommentRanges as aq, findHexColors as ar, findImportAdapter as as, footnotesMarkdownIt as at, footnotesPluginKey as au, fractionRules as av, getActiveHeading as aw, getBookmarks as ax, getCommentAnchors as ay, getCommentAuthor as az, Autocorrect as b, twoInitialCapitalsRules as b0, unregisterImportAdapter as b1, updateImageSrc as b2, writeRichClipboard as b3, type AutocorrectContext as c, type AutocorrectCorrection as d, type AutocorrectOptions as e, type AutocorrectRule as f, type AutocorrectStorage as g, Bookmark as h, type BookmarkInfo as i, type BookmarkOptions as j, ColorHighlighter as k, type CommentRange as l, Comments as m, type CommentsOptions as n, type CommentsStorage as o, type CreateImportAdapterRegistryOptions as p, CrossReference as q, type CrossReferenceOptions as r, type CrossReferenceTarget as s, type CrossReferenceTargetType as t, DEFAULT_AUTOCORRECT_EXCEPTIONS as u, type DocumentStructureCommandArgs as v, type DocumentStructureCommandItem as w, type FileImportOptions as x, type FocusHeadingOptions as y, FontSize as z };