@pixerate/editor 0.23.0 → 0.25.0

package/dist/index-Csd5qI8u.d.cts

@@ -0,0 +1,1754 @@
+import { Mark, Extension, Node, Editor, Extensions } from '@tiptap/core';
+import { C as ColorGradient, T as Template } from './tokens-D7yXvUU6.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 * as _tiptap_extension_underline from '@tiptap/extension-underline';
+import * as _tiptap_extension_text_style from '@tiptap/extension-text-style';
+import * as _tiptap_extension_text_align from '@tiptap/extension-text-align';
+import * as _tiptap_extension_task_list from '@tiptap/extension-task-list';
+import * as _tiptap_extension_link from '@tiptap/extension-link';
+import * as _tiptap_extension_image from '@tiptap/extension-image';
+import { ImageOptions as ImageOptions$1 } from '@tiptap/extension-image';
+import * as _tiptap_extension_highlight from '@tiptap/extension-highlight';
+import * as _tiptap_extension_color from '@tiptap/extension-color';
+import * as _tiptap_starter_kit from '@tiptap/starter-kit';
+import { f as MentionOptions, h as TrackChangesOptions } from './track-changes-D_VAPELi.cjs';
+import { MarkdownOptions } from 'tiptap-markdown';
+import { R as ReviewAuthor, b as CommentStore, C as CommentAnchor } from './comment-store-BEMgVlAA.cjs';
+import { b as ImportAdapter, I as ImportAdapterRegistry, c as FindImportAdapterQuery, i as ImportTarget, h as ImportInput, g as ImportFileOptions, a as ImportOutcome, R as RegisterImportAdapterOptions, F as FileLike } from './registry-CEgwXED1.cjs';
+import { b as CompareSource, C as CompareDocumentsOptions, a as CompareDocumentsResult } from './documents-Gp7wb0Me.cjs';
+import { c as CommandSpec } from './registry-D32LpIc4.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;
+
+/** A positioned piece of text, e.g. a pdf.js text item. */
+interface PdfTextRun {
+    text: string;
+    /** Left edge (points). */
+    x: number;
+    /** Baseline, y up (points). */
+    y: number;
+    /** Advance width (points). Estimated from the text length when missing. */
+    width?: number;
+    /** Font size (points). Falls back to `height`, then 10. */
+    fontSize?: number;
+    height?: number;
+    /** Font name; `Bold` / `Italic` / `Oblique` in it set the style when `bold` / `italic` are absent. */
+    fontName?: string;
+    bold?: boolean;
+    italic?: boolean;
+}
+/** A stroked line or thin filled rectangle on a page (table rules). */
+interface PdfRuleLine {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+interface PdfLayoutPage {
+    runs: readonly PdfTextRun[];
+    /** Ruling lines, when the extractor can read the page's vector graphics. */
+    rules?: readonly PdfRuleLine[];
+}
+interface PdfLayoutOptions {
+    /**
+     * A baseline gap larger than this multiple of the typical line pitch starts
+     * a new paragraph (default `1.4`).
+     */
+    paragraphGap?: number;
+    /** Remove running headers, footers and page numbers repeated across pages (default `true`). */
+    removeHeadersAndFooters?: boolean;
+    /** Read multi-column pages column by column (default `true`). */
+    detectColumns?: boolean;
+    /** Detect headings from font size and weight (default `true`). */
+    detectHeadings?: boolean;
+    /** Detect bulleted and numbered lists (default `true`). */
+    detectLists?: boolean;
+    /** Detect tables from ruling lines and aligned columns (default `true`). */
+    detectTables?: boolean;
+    /** Re-join words hyphenated across line ends (default `true`). */
+    dehyphenate?: boolean;
+}
+interface PdfTableCell {
+    text: string;
+    colSpan: number;
+    rowSpan: number;
+    header: boolean;
+}
+type PdfLayoutBlock = {
+    type: "heading";
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    text: string;
+    page: number;
+    confidence: number;
+} | {
+    type: "paragraph";
+    text: string;
+    page: number;
+} | {
+    type: "list";
+    page: number;
+    confidence: number;
+    /** Items in order; `depth` 0 is the outermost level and grows by at most one per item. */
+    items: {
+        text: string;
+        depth: number;
+        ordered: boolean;
+        start?: number;
+    }[];
+} | {
+    type: "table";
+    page: number;
+    confidence: number;
+    /** `true` when the grid came from ruling lines. */
+    ruled: boolean;
+    /** Rows of cells; cells covered by a span are left out. */
+    rows: PdfTableCell[][];
+    columns: number;
+    headerRows: number;
+};
+/** One detected structure, for import reports. */
+interface ImportStructureItem {
+    type: "heading" | "list" | "table" | "columns";
+    /** 1-based page. */
+    page: number;
+    /** 0–1. */
+    confidence: number;
+    /** Short human-readable description, e.g. `H2 "Results"` or `3×4 table`. */
+    detail: string;
+}
+/**
+ * What a structure-aware importer recognised. Adapters attach it to
+ * `DocumentImport.structure`; `summarizeImportStructure` aggregates it.
+ */
+interface ImportStructureReport {
+    /** `"plain"` when structure detection was off (paragraphs only). */
+    mode: "structured" | "plain";
+    counts: {
+        headings: number;
+        lists: number;
+        tables: number;
+        paragraphs: number;
+    };
+    /** Pages read as several columns. */
+    multiColumnPages: number;
+    /** Mean confidence of the detected structures (1 when nothing was detected). */
+    confidence: number;
+    items: ImportStructureItem[];
+}
+interface PdfStructureReport extends ImportStructureReport {
+    pages: number;
+    removed: {
+        headers: number;
+        footers: number;
+        pageNumbers: number;
+    };
+    /** Words re-joined across a line-end hyphen. */
+    dehyphenated: number;
+}
+interface PdfLayoutResult {
+    blocks: PdfLayoutBlock[];
+    report: PdfStructureReport;
+}
+/**
+ * Analyses positioned text runs (one entry per page) and returns blocks in
+ * reading order plus a report of what was detected.
+ */
+declare function analyzePdfLayout(pages: readonly PdfLayoutPage[], options?: PdfLayoutOptions): PdfLayoutResult;
+/** Renders layout blocks as editor HTML (`h1`–`h6`, `p`, `ul`/`ol`, `table`). Text is escaped. */
+declare function pdfLayoutBlocksToHtml(blocks: readonly PdfLayoutBlock[]): string;
+
+/** 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;
+    /**
+     * What a structure-aware importer recognised (headings, lists, tables,
+     * columns) with confidences; set by the PDF adapter.
+     */
+    structure?: ImportStructureReport;
+}
+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;
+    /** Per-adapter options keyed by adapter id, e.g. `{ pdf: { structure: false } }`. */
+    adapterOptions?: Record<string, unknown>;
+    /** 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;
+
+/**
+ * Word's Find and Replace patterns: special characters (`^p`, `^t`, `^#` …),
+ * the "Use wildcards" language (`?`, `*`, `[a-z]`, `[!x]`, `{n,m}`, `@`, `<`,
+ * `>`, `( )`) and a raw regular-expression mode.
+ *
+ * Special and wildcard patterns are compiled to a small program run by a
+ * Pike VM, which takes time linear in the text for a given pattern, so no
+ * Find text can backtrack catastrophically (JavaScript's `RegExp` would). The
+ * raw regex mode uses the native `RegExp` engine; it rejects nested
+ * repetition and is bounded by the search budget between matches only.
+ *
+ * Pure TypeScript: no ProseMirror or DOM.
+ */
+/** A paragraph mark in the searched text (`^p`). */
+declare const FIND_PARAGRAPH_MARK = "\r";
+/** Longest Find what text, in characters. */
+declare const MAX_FIND_PATTERN_LENGTH = 1024;
+interface FindOptions {
+    matchCase?: boolean;
+    /** Find whole words only (ignored with wildcards, like Word). */
+    wholeWord?: boolean;
+    /** The match must start a word. */
+    matchPrefix?: boolean;
+    /** The match must end a word. */
+    matchSuffix?: boolean;
+    /** Skip punctuation between the characters of the Find text. */
+    ignorePunctuation?: boolean;
+    /** Skip spaces and tabs between the characters of the Find text. */
+    ignoreWhitespace?: boolean;
+    /** Word's "Use wildcards". Always matches case. */
+    wildcards?: boolean;
+    /** A JavaScript regular expression (wins over `wildcards`). Replace text is literal. */
+    regex?: boolean;
+    /** Read the Find and Replace text literally: no `^` codes. */
+    literal?: boolean;
+}
+type FindPatternErrorCode = "too_long" | "invalid_pattern" | "too_complex";
+/** Why a Find text cannot be used. Commands report it; they never throw it. */
+interface FindPatternError {
+    code: FindPatternErrorCode;
+    message: string;
+}
+/** One match in a searched string (UTF-16 offsets). */
+interface PatternMatch {
+    start: number;
+    end: number;
+    /** Text of each group; index 0 is the whole match, unmatched groups are `undefined`. */
+    groups: (string | undefined)[];
+}
+/** Shared limit on the work one search may do. */
+interface SearchBudget {
+    /** `performance.now()`/`Date.now()` value after which the search stops. */
+    deadline: number;
+    /** VM steps left. */
+    steps: number;
+    /** Set once the budget ran out. */
+    exhausted: boolean;
+}
+interface SearchBudgetOptions {
+    /** Wall-clock limit in milliseconds (default 250). */
+    timeLimitMs?: number;
+    /** Pike VM thread steps (default 50 million). */
+    maxSteps?: number;
+}
+declare function createSearchBudget(options?: SearchBudgetOptions): SearchBudget;
+interface CompiledFindPattern {
+    mode: "special" | "wildcards" | "regex";
+    /** The pattern can match a paragraph mark, so paragraphs must be read together. */
+    spansParagraphs: boolean;
+    caseInsensitive: boolean;
+    /** Number of capture groups (not counting the whole match). */
+    groupCount: number;
+    /**
+     * The leftmost match in `hay[start, end)`; text outside the range is
+     * context for word assertions. `"budget"` when the budget ran out.
+     */
+    exec(hay: string, start: number, end: number, budget: SearchBudget): PatternMatch | null | "budget";
+}
+type CompileFindPatternResult = {
+    ok: true;
+    pattern: CompiledFindPattern;
+} | {
+    ok: false;
+    error: FindPatternError;
+};
+/** Simple (one code point to one code point) lower-case fold. */
+declare function foldCodePoint(cp: number): number;
+/** Translates Word's Find what text. Never throws: invalid text returns `{ ok: false, error }`. */
+declare function compileFindPattern(query: string, options?: FindOptions): CompileFindPatternResult;
+interface FindAllOptions {
+    /**
+     * Offsets where the live text breaks (e.g. where tracked-deleted text was
+     * skipped): no match spans a cut.
+     */
+    cuts?: readonly number[];
+    budget?: SearchBudget;
+    /** Stop after this many matches (default 10 000). */
+    maxMatches?: number;
+}
+interface FindAllResult {
+    matches: PatternMatch[];
+    /** The search stopped early (match cap or time budget). */
+    truncated: boolean;
+}
+/**
+ * Every non-empty match in `hay`, left to right, without overlaps. Empty
+ * matches are stepped past so the search always moves on.
+ */
+declare function findAllMatches(pattern: CompiledFindPattern, hay: string, options?: FindAllOptions): FindAllResult;
+/** A piece of Replace with text. */
+type ReplacePiece = {
+    type: "text";
+    text: string;
+}
+/** `^&`: the text found. */
+ | {
+    type: "found";
+}
+/** `\n` with wildcards: group `n`. */
+ | {
+    type: "group";
+    index: number;
+}
+/** `^c`: the clipboard. */
+ | {
+    type: "clipboard";
+};
+/** Reads Replace with text: `^` codes (unless `literal`), and `\1`–`\9` with wildcards. Regex mode is literal. */
+declare function parseReplacement(replacement: string, options?: FindOptions): ReplacePiece[];
+/** Fills in Replace with text for one match. Paragraph marks in the result are `\r`. */
+declare function expandReplacement(pieces: readonly ReplacePiece[], match: PatternMatch, clipboardText?: string): string;
+
+interface FindMatch {
+    /** Document position of the first matched character. */
+    from: number;
+    /** Document position after the last matched character. */
+    to: number;
+    /** The matched text (`\r` for paragraph marks, `\n` for hard breaks). */
+    text: string;
+    /** The Replace with text for this match (`\r` splits paragraphs). */
+    replacement: string;
+}
+interface DocumentSearchOptions {
+    /** Replace with text (`^&`, `^c`, `\1`…). */
+    replacement?: string;
+    /** Text of `^c` in the replacement. */
+    clipboardText?: string;
+    /** Wall-clock budget for the whole search (default 250 ms). */
+    timeLimitMs?: number;
+    /** Match cap (default 10 000). */
+    maxMatches?: number;
+}
+interface DocumentSearchResult {
+    matches: FindMatch[];
+    /** The search stopped early at the match cap or time budget. */
+    truncated: boolean;
+    error: FindPatternError | null;
+}
+/**
+ * Finds `query` in a document. Each textblock is read as text without
+ * tracked-deleted runs (a deletion "cuts" the text, so no match spans it, but
+ * word boundaries see the live text on both sides); a pattern that can match
+ * `^p` reads runs of sibling textblocks as one text with `\r` between them.
+ */
+declare function searchDocument(doc: Node$1, query: string, options?: FindOptions, searchOptions?: DocumentSearchOptions): DocumentSearchResult;
+/**
+ * Replaces matches in one transaction, last first so earlier positions stay
+ * valid. A paragraph mark (`\r` or U+2029) in a replacement splits the
+ * paragraph. Returns the mapped end of each replacement (in match order).
+ */
+declare function applyReplacements(tr: Transaction, matches: readonly FindMatch[]): number[];
+
+type FindReplaceMode = "find" | "replace";
+/** Everything a find bar needs. Snapshots are cached, so they suit `useSyncExternalStore`. */
+interface FindReplaceSnapshot {
+    /** Whether the find bar should be shown (`openFindReplace` / Mod+F). */
+    open: boolean;
+    mode: FindReplaceMode;
+    query: string;
+    replacement: string;
+    options: Readonly<FindOptions>;
+    matches: readonly FindMatch[];
+    /** Index of the current match, or -1. */
+    currentIndex: number;
+    error: FindPatternError | null;
+    /** The search stopped at the match cap or time budget. */
+    truncated: boolean;
+    /** Replacements made by the last `replaceAll` / `replaceCurrent` (`null` before any). */
+    lastReplaceCount: number | null;
+    /** Bumped whenever the bar is asked to focus its find field (Mod+F while open). */
+    focusRequest: number;
+}
+declare const EMPTY_FIND_REPLACE_SNAPSHOT: FindReplaceSnapshot;
+/**
+ * External store over the find state. `subscribe` calls the listener
+ * immediately (Svelte store contract).
+ */
+declare class FindReplaceStore {
+    private snapshot;
+    private listeners;
+    subscribe: (listener: (snapshot: FindReplaceSnapshot) => void) => (() => void);
+    getSnapshot: () => FindReplaceSnapshot;
+    /** @internal Called by the extension's plugin view. */
+    set(snapshot: FindReplaceSnapshot): void;
+}
+interface FindReplaceOptions {
+    /** Bind Mod+F / Mod+H (and Mod+Shift+H) to open the bar, F3 / Mod+G to step. Default `true`. */
+    shortcuts: boolean;
+    /** Class of every match. */
+    matchClass: string;
+    /** Class of the current match. */
+    currentMatchClass: string;
+    /** Wall-clock budget per search in milliseconds (default 250). */
+    timeLimitMs: number;
+    /** Match cap per search (default 10 000). */
+    maxMatches: number;
+    /** Text of `^c` in Replace with (clipboard reads are async in browsers, so supply it). */
+    getClipboardText: () => string;
+    /** Longest selection copied into the find field by Mod+F. Default 256. */
+    maxPrefillLength: number;
+}
+interface FindReplaceStorage {
+    store: FindReplaceStore;
+}
+interface SetSearchParams {
+    query?: string;
+    replacement?: string;
+    /** Merged into the current options. */
+    options?: Partial<FindOptions>;
+}
+interface OpenFindReplaceParams {
+    mode?: FindReplaceMode;
+    /** Find text; defaults to the selected text (single paragraph, short). */
+    query?: string;
+}
+interface PluginState {
+    active: boolean;
+    open: boolean;
+    mode: FindReplaceMode;
+    query: string;
+    replacement: string;
+    options: Readonly<FindOptions>;
+    matches: readonly FindMatch[];
+    currentIndex: number;
+    /** Position the current match is chosen from (first match at or after it) after a re-search. */
+    anchor: number;
+    error: FindPatternError | null;
+    truncated: boolean;
+    lastReplaceCount: number | null;
+    focusRequest: number;
+    decorations: DecorationSet;
+}
+declare const findReplacePluginKey: PluginKey<PluginState>;
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        findReplace: {
+            /** Sets the find text, replace text and/or options and searches. */
+            setSearch: (params: SetSearchParams) => ReturnType;
+            /** Shows the find bar (and searches its text). */
+            openFindReplace: (params?: OpenFindReplaceParams) => ReturnType;
+            /** Hides the find bar and its highlights; the find text is kept. */
+            closeFindReplace: () => ReturnType;
+            /** Clears the find text and highlights. */
+            clearSearch: () => ReturnType;
+            /** Selects the next match after the selection, wrapping around. */
+            findNext: () => ReturnType;
+            /** Selects the previous match before the selection, wrapping around. */
+            findPrevious: () => ReturnType;
+            /** Replaces the current match and moves on to the next one. */
+            replaceCurrent: () => ReturnType;
+            /** Replaces every match in one transaction (one undo step). */
+            replaceAll: () => ReturnType;
+        };
+    }
+}
+/** The extension's plugin state, or `null` without `FindReplace`. */
+declare function getFindReplaceState(source: Editor | EditorState | null | undefined): FindReplaceSnapshot | null;
+/** Returns the find store of an editor using `FindReplace`. */
+declare function getFindReplaceStore(editor: Editor | null | undefined): FindReplaceStore | null;
+interface FindOptionToggle {
+    key: keyof FindOptions;
+    label: string;
+    /** Compact button text. */
+    short: string;
+    /** Shown under "More options" rather than as a toolbar toggle. */
+    advanced: boolean;
+}
+/** The option toggles of the React and Svelte find bars, in display order. */
+declare const FIND_OPTION_TOGGLES: readonly FindOptionToggle[];
+/**
+ * Text of a find bar's match counter: `"3 of 12"`, `"12 results"` (no
+ * current match), `"No results"`, `"10000+ results"` when truncated, or the
+ * pattern error. Empty without a query.
+ */
+declare function formatFindStatus(s: Pick<FindReplaceSnapshot, "query" | "matches" | "currentIndex" | "error" | "truncated">): string;
+/**
+ * Word-style Find and Replace: Match case, Whole words, prefix/suffix,
+ * Ignore punctuation/white space, `^` special characters, wildcards (with
+ * `\1` groups in the replacement) and a raw regex mode. Matches are
+ * decorated; tracked-deleted text is skipped, and replacements made while
+ * Track Changes is on become tracked changes.
+ */
+declare const FindReplace: Extension<FindReplaceOptions, FindReplaceStorage>;
+
+/** Paragraph styles format whole blocks; character styles format runs of text. */
+type StyleKind = "paragraph" | "character";
+/** Character formatting of a style (CSS values). */
+interface CharacterFormat {
+    fontFamily?: string;
+    /** CSS length, e.g. `"1.5em"` or `"18px"`. */
+    fontSize?: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    color?: string;
+    backgroundColor?: string;
+    letterSpacing?: string;
+    textTransform?: "none" | "uppercase" | "lowercase" | "capitalize";
+    smallCaps?: boolean;
+}
+/** Paragraph formatting of a style (CSS values). */
+interface ParagraphFormat {
+    textAlign?: "left" | "center" | "right" | "justify";
+    lineHeight?: string;
+    spaceBefore?: string;
+    spaceAfter?: string;
+    indentLeft?: string;
+    indentRight?: string;
+    indentFirstLine?: string;
+    /** CSS border shorthand, e.g. `"3px solid currentColor"`. */
+    borderLeft?: string;
+    paddingLeft?: string;
+    backgroundColor?: string;
+}
+/** The block node a paragraph style uses (`heading` with `level` for Heading N). */
+interface StyleBlock {
+    type: string;
+    attrs?: Record<string, any>;
+}
+interface StyleDefinition {
+    /** Stable id (`Heading1`): letters, digits, `_` and `-`, starting with a letter. */
+    id: string;
+    /** Display name (`Heading 1`). */
+    name: string;
+    kind: StyleKind;
+    /** Style this one inherits from; what it sets wins over its base. */
+    basedOn?: string | null;
+    /** Style of the paragraph after this one when Enter is pressed at its end (paragraph styles). */
+    next?: string | null;
+    /** Linked style: a paragraph style's character style, or a character style's paragraph style. */
+    linked?: string | null;
+    paragraph?: ParagraphFormat;
+    character?: CharacterFormat;
+    /** Block node of a paragraph style. Inherited along `basedOn`; `paragraph` by default. */
+    block?: StyleBlock | null;
+    /** Gallery order (lower first). */
+    priority?: number;
+    /** Shown in the styles gallery. */
+    quick?: boolean;
+    hidden?: boolean;
+    /** Built in (cannot be removed). */
+    builtin?: boolean;
+}
+/** A style with its `basedOn` chain and the defaults merged. */
+interface ResolvedStyle {
+    id: string;
+    paragraph: ParagraphFormat;
+    character: CharacterFormat;
+    block: StyleBlock;
+    /** Id of the style after Enter at the end of a paragraph. */
+    next: string;
+}
+interface StyleDefaults {
+    paragraph?: ParagraphFormat;
+    character?: CharacterFormat;
+}
+interface StyleRegistryOptions {
+    /** Styles added to (or replacing) the built-in ones. */
+    styles?: readonly StyleDefinition[];
+    /** Include the built-in styles. Default `true`. */
+    builtins?: boolean;
+    /** Document defaults, applied below every style. */
+    defaults?: StyleDefaults;
+}
+interface StyleRegistrySnapshot {
+    styles: readonly StyleDefinition[];
+    defaults: StyleDefaults;
+    /** Increases on every change. */
+    version: number;
+}
+/** Serializable registry content (`registry.toJSON()`). */
+interface StyleRegistryJSON {
+    styles: StyleDefinition[];
+    defaults: StyleDefaults;
+}
+interface StyleCSSOptions {
+    /** Selector the rules are scoped to. Default `.ProseMirror`. */
+    scope?: string;
+    /**
+     * Element selector of blocks that use a style without naming it
+     * (`data-style` absent), e.g. `h2` for Heading 2. Return `null` for none.
+     */
+    tagFor?: (block: StyleBlock) => string | null;
+}
+declare const NORMAL_STYLE_ID = "Normal";
+/** Whether `id` is a valid style id. */
+declare function isValidStyleId(id: unknown): id is string;
+/** The built-in styles: Normal, Title, Subtitle, Heading 1–6, Quote, Code, List Paragraph and character styles. */
+declare const DEFAULT_STYLES: readonly StyleDefinition[];
+/**
+ * Style definitions with `basedOn` inheritance, next-style and linked
+ * character/paragraph styles, resolved in cascade order: document defaults →
+ * style chain (base first) → direct formatting. Chains are cycle-safe.
+ *
+ * `subscribe` calls the listener immediately and on every change (Svelte
+ * store contract); `getSnapshot` is stable between changes.
+ */
+declare class StyleRegistry {
+    private styles;
+    private defaults;
+    private version;
+    private snapshot;
+    private listeners;
+    constructor(options?: StyleRegistryOptions);
+    get(id: string | null | undefined): StyleDefinition | undefined;
+    /** Finds a style by id or display name (case-insensitive). */
+    find(nameOrId: string): StyleDefinition | undefined;
+    /** All styles (optionally of one kind) in gallery order. */
+    list(kind?: StyleKind): StyleDefinition[];
+    /** Styles shown in the gallery (`quick`, not hidden), paragraph styles by default. */
+    gallery(kind?: StyleKind): StyleDefinition[];
+    /** The `basedOn` chain from the root style down to `id` (cycle-safe, bounded). */
+    chain(id: string): StyleDefinition[];
+    /**
+     * Resolves a paragraph style: defaults, then each style of the chain (base
+     * first). Unknown ids resolve to the defaults in a `paragraph` block.
+     */
+    resolve(id: string): ResolvedStyle;
+    /** Character formatting a paragraph style's chain sets (without defaults). */
+    private paragraphCharacter;
+    /**
+     * Character formatting of a character style's chain. A style linked to a
+     * paragraph style takes that style's character formatting first.
+     */
+    resolveCharacterStyle(id: string): CharacterFormat;
+    /**
+     * Character formatting of text: defaults → paragraph style chain →
+     * character style chain → direct formatting.
+     */
+    resolveText(input: {
+        paragraphStyle?: string | null;
+        characterStyle?: string | null;
+        direct?: CharacterFormat;
+    }): CharacterFormat;
+    /** The style after Enter at the end of a paragraph of `id` (itself when unset or unknown). */
+    nextStyleId(id: string): string;
+    /** The linked character style of a paragraph style, if any. */
+    linkedCharacterStyle(id: string): StyleDefinition | undefined;
+    /**
+     * The style a block uses when it names none: Normal for paragraphs,
+     * Heading N for headings of level N, Code for code blocks (the built-in
+     * style whose own `block` matches).
+     */
+    defaultStyleFor(type: string, attrs?: Record<string, any>): string | null;
+    /** The style of a block: its `styleId` when known, otherwise the block's default style. */
+    styleOfBlock(type: string, attrs?: Record<string, any>): string | null;
+    getSnapshot: () => StyleRegistrySnapshot;
+    subscribe: (listener: (snapshot: StyleRegistrySnapshot) => void) => (() => void);
+    toJSON(): StyleRegistryJSON;
+    /** Adds or replaces a style. Throws on an invalid id. */
+    upsert(style: StyleDefinition): StyleDefinition;
+    /** Merges `patch` into a style (formats are merged key by key). Returns `undefined` for unknown ids. */
+    update(id: string, patch: Partial<Omit<StyleDefinition, "id">>): StyleDefinition | undefined;
+    /**
+     * Removes a style and returns it. Built-in styles cannot be removed. Styles
+     * based on it are rebased onto its own base, and `next`/`linked`
+     * references to it are dropped.
+     */
+    remove(id: string): StyleDefinition | undefined;
+    /** Replaces the document defaults. */
+    setDefaults(defaults: StyleDefaults): void;
+    /** An unused id derived from a display name (`My Style` → `MyStyle`, then `MyStyle1`, …). */
+    newId(name: string): string;
+    /** CSS declarations (`property: value`) of a resolved paragraph or character style. */
+    cssDeclarations(id: string): Record<string, string>;
+    /**
+     * Declarations for previewing a style in a menu or gallery: font family,
+     * weight, style, color, decoration, case and letter spacing (no sizes,
+     * margins or borders).
+     */
+    previewDeclarations(id: string): Record<string, string>;
+    /**
+     * A stylesheet for the styles: `[data-style="Id"]` rules for paragraph
+     * styles (plus the plain element of blocks that use their default style,
+     * e.g. `h2:not([data-style])`), `[data-char-style="Id"]` for character
+     * styles and the defaults on the scope element.
+     */
+    toCSS(options?: StyleCSSOptions): string;
+    private put;
+    private changed;
+}
+/** A CSS value, or `undefined` when it is unsafe or empty. */
+declare function safeCSSValue(value: unknown): string | undefined;
+/** Creates a style registry with the built-in styles (unless `builtins: false`) and `styles`. */
+declare function createStyleRegistry(options?: StyleRegistryOptions | StyleRegistryJSON): StyleRegistry;
+
+/** Node attribute naming a block's paragraph style (`data-style` in HTML). */
+declare const STYLE_ID_ATTRIBUTE = "styleId";
+/** Mark applying a character style (`<span data-char-style>`). */
+declare const CHARACTER_STYLE_MARK_NAME = "characterStyle";
+interface ParagraphStylesOptions {
+    /** The style registry. Defaults to a new registry with the built-in styles per editor. */
+    registry: StyleRegistry | null;
+    /** Block types that carry the `styleId` attribute. */
+    types: string[];
+    /**
+     * Inject a `<style>` element with `registry.toCSS({ scope })` while the
+     * editor exists (kept up to date). Default `true`.
+     */
+    injectCSS: boolean;
+    /** Selector the injected CSS is scoped to. Default `.ProseMirror`. */
+    cssScope: string;
+    /** Nonce of the injected `<style>` element (Content Security Policy). */
+    cssNonce?: string;
+    /**
+     * Applying a paragraph style to a partial selection inside one paragraph
+     * applies its linked character style instead (as in Word). Default `true`.
+     */
+    linkedCharacterStyles: boolean;
+}
+interface ParagraphStylesStorage {
+    registry: StyleRegistry;
+}
+interface CreateStyleFromSelectionOptions {
+    /** Id of the new style. Default: derived from the name. */
+    id?: string;
+    /** Base style. Default: the style at the selection. */
+    basedOn?: string | null;
+    /** Apply the new style to the selected paragraphs. Default `true`. */
+    apply?: boolean;
+}
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        paragraphStyles: {
+            /** Applies a paragraph style to the selected blocks (changing headings/code blocks as the style needs). */
+            setParagraphStyle: (id: string) => ReturnType;
+            /** Resets the selected blocks to the Normal style. */
+            clearParagraphStyle: () => ReturnType;
+            /** Applies a character style to the selection. */
+            setCharacterStyle: (id: string) => ReturnType;
+            unsetCharacterStyle: () => ReturnType;
+            /**
+             * Updates a style (default: the style at the selection) to the direct
+             * formatting at the selection ("Update to match selection").
+             */
+            updateParagraphStyleFromSelection: (id?: string) => ReturnType;
+            /** Creates a paragraph style from the formatting at the selection ("New style from selection"). */
+            createParagraphStyleFromSelection: (name: string, options?: CreateStyleFromSelectionOptions) => ReturnType;
+        };
+    }
+}
+declare const paragraphStylesPluginKey: PluginKey<any>;
+/** The style registry of an editor using `ParagraphStyles`. */
+declare function getStyleRegistry(editor: Editor | null | undefined): StyleRegistry | null;
+/**
+ * Whether a paragraph style can be applied in this editor: its block type is
+ * in the schema (and, for headings, its level is configured).
+ */
+declare function isParagraphStyleAvailable(editor: Editor, registry: StyleRegistry, id: string): boolean;
+/** The paragraph style of the textblock at `pos` (defaults to the selection start). */
+declare function getParagraphStyleAt(state: EditorState, registry: StyleRegistry, pos?: number): string | null;
+/**
+ * The direct formatting at the selection, as style formats: bold, italic,
+ * underline, strike, font family/size, color and highlight from marks, and
+ * the alignment of the block.
+ */
+declare function captureSelectionFormat(state: EditorState): {
+    paragraph: ParagraphFormat;
+    character: CharacterFormat;
+};
+/** Character style applied to a run of text. */
+declare const CharacterStyle: Mark<any, any>;
+/**
+ * Paragraph styles (Normal, Title, Heading 1, …) from a `StyleRegistry`:
+ * a `styleId` attribute on paragraphs and headings (`data-style` in HTML),
+ * a `characterStyle` mark, apply/clear/update/create commands, next-style
+ * on Enter and an injected stylesheet. Headings without a `styleId` use
+ * Heading N, plain paragraphs Normal, so existing documents are unchanged.
+ */
+declare const ParagraphStyles: Extension<ParagraphStylesOptions, ParagraphStylesStorage>;
+interface ParagraphStylesSnapshot {
+    /** Paragraph styles for the gallery (quick, not hidden, available in this editor). */
+    gallery: readonly StyleDefinition[];
+    /** All paragraph styles available in this editor. */
+    styles: readonly StyleDefinition[];
+    /** Character styles. */
+    characterStyles: readonly StyleDefinition[];
+    /** The style of the block at the selection. */
+    currentStyleId: string | null;
+    /** Registry version (changes when styles change). */
+    version: number;
+}
+interface ParagraphStylesStore {
+    getSnapshot(): ParagraphStylesSnapshot;
+    subscribe(listener: () => void): () => void;
+    destroy(): void;
+}
+/**
+ * External store over an editor's paragraph styles and the style at the
+ * selection, for `useSyncExternalStore` and Svelte runes. Snapshots change
+ * only when the styles or the current style change. Listeners are attached
+ * to the editor only while subscribed.
+ */
+declare function createParagraphStylesStore(editor: Editor | null | undefined): ParagraphStylesStore;
+
+/**
+ * The TipTap packages whose commands the preset installs. Exported only so the
+ * published declarations import them: each package augments `@tiptap/core`'s
+ * `Commands` interface, which is what types `editor.chain().toggleBold()`,
+ * `toggleHeading()`, `setTextAlign()` and so on for apps that use the preset
+ * without depending on those packages themselves. (Triple-slash references are
+ * dropped by the declaration bundler, and runtime imports leave no trace in .d.ts.)
+ */
+type RichTextPresetCommandPackages = [
+    typeof _tiptap_starter_kit,
+    typeof _tiptap_extension_color,
+    typeof _tiptap_extension_highlight,
+    typeof _tiptap_extension_image,
+    typeof _tiptap_extension_link,
+    typeof _tiptap_extension_task_list,
+    typeof _tiptap_extension_text_align,
+    typeof _tiptap_extension_text_style,
+    typeof _tiptap_extension_underline
+];
+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` and `DocumentCompare` extensions (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;
+    /** Word-style Find and Replace (Mod+F / Mod+H, match highlights). Off by default. */
+    findReplace?: Partial<FindReplaceOptions> | boolean;
+    /**
+     * Paragraph styles (Normal, Title, Heading 1–6, Quote, …) with a style
+     * registry, `data-style` attributes and next-style on Enter. Off by default.
+     */
+    paragraphStyles?: Partial<ParagraphStylesOptions> | boolean;
+}
+/**
+ * Creates a standard rich-text extensions bundle with full formatting support.
+ */
+declare function createRichTextPreset(options?: RichTextPresetOptions): Extensions;
+
+/** Options of a comparison run in an editor (the schema is the editor's). */
+type EditorCompareOptions = Omit<CompareDocumentsOptions, "schema">;
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        documentCompare: {
+            /**
+             * Replaces the content with the comparison of `original` and
+             * `revised` (nodes, JSON or HTML) as tracked changes. The content is
+             * set without being tracked; the summary is stored in
+             * `editor.storage.documentCompare.lastResult`.
+             */
+            setContentFromComparison: (original: CompareSource, revised: CompareSource, options?: EditorCompareOptions) => ReturnType;
+        };
+    }
+}
+interface DocumentCompareOptions {
+    /** Defaults for every comparison (author defaults to the track-changes author). */
+    compare: EditorCompareOptions;
+}
+interface DocumentCompareStorage {
+    lastResult: CompareDocumentsResult | null;
+}
+/**
+ * Compares two versions in the editor's schema and returns the result
+ * without changing the editor. The author defaults to the `TrackChanges`
+ * author.
+ */
+declare function compareInEditor(editor: Editor, original: CompareSource, revised: CompareSource, options?: EditorCompareOptions): CompareDocumentsResult;
+/**
+ * Compares two versions and replaces the editor content with the result
+ * (one undoable step, not tracked). Works without the `DocumentCompare`
+ * extension; the schema needs `TrackChanges`.
+ */
+declare function applyDocumentComparison(editor: Editor, original: CompareSource, revised: CompareSource, options?: EditorCompareOptions): CompareDocumentsResult;
+/** Adds the `setContentFromComparison` command. Requires `TrackChanges`. */
+declare const DocumentCompare: Extension<DocumentCompareOptions, DocumentCompareStorage>;
+
+interface FindReplaceCommandOptions {
+    /** Id prefix (default `findReplace.`). */
+    prefix?: string;
+    group?: string;
+    scope?: string;
+    /**
+     * Give the open commands default shortcuts (Mod+F, Mod+H). Off by default
+     * because the `FindReplace` extension already binds them inside the editor.
+     */
+    shortcuts?: boolean;
+}
+/**
+ * Find and Replace commands for the command registry (`@pixerate/editor/commands`):
+ * open the bar, step through matches, and find / replace with explicit
+ * params (useful for agents). Requires the `FindReplace` extension.
+ */
+declare function createFindReplaceCommands(editor: Editor, options?: FindReplaceCommandOptions): CommandSpec[];
+/** Validates Find text without an editor (e.g. to show an error while typing). */
+declare function validateFindPattern(query: string, options?: FindOptions): FindPatternError | null;
+
+export { type FindOptions as $, type AddCommentOptions as A, BUILT_IN_IMPORT_ADAPTERS as B, CHARACTER_STYLE_MARK_NAME as C, type DocumentImport as D, type CrossReferenceOptions as E, type CrossReferenceTarget as F, type CrossReferenceTargetType as G, DEFAULT_AUTOCORRECT_EXCEPTIONS as H, DEFAULT_STYLES as I, DocumentCompare as J, type DocumentCompareOptions as K, type DocumentCompareStorage as L, type DocumentSearchOptions as M, type DocumentSearchResult as N, type DocumentStructureCommandArgs as O, type PdfStructureReport as P, type DocumentStructureCommandItem as Q, EMPTY_FIND_REPLACE_SNAPSHOT as R, type EditorCompareOptions as S, FIND_OPTION_TOGGLES as T, FIND_PARAGRAPH_MARK as U, FileImport as V, type FileImportOptions as W, type FindAllOptions as X, type FindAllResult as Y, type FindMatch as Z, type FindOptionToggle as _, type DocumentImportAdapter as a, SmilieReplacer as a$, type FindPatternError as a0, type FindPatternErrorCode as a1, FindReplace as a2, type FindReplaceCommandOptions as a3, type FindReplaceMode as a4, type FindReplaceOptions as a5, type FindReplaceSnapshot as a6, type FindReplaceStorage as a7, FindReplaceStore as a8, type FocusHeadingOptions as a9, type ParagraphFormat as aA, ParagraphStyles as aB, type ParagraphStylesOptions as aC, type ParagraphStylesSnapshot as aD, type ParagraphStylesStorage as aE, type ParagraphStylesStore as aF, type PatternMatch as aG, type PdfLayoutBlock as aH, type PdfLayoutPage as aI, type PdfLayoutResult as aJ, type PdfTableCell as aK, type ReplacePiece as aL, type ResolvedStyle as aM, RichClipboard as aN, type RichClipboardOptions as aO, type RichClipboardStorage as aP, type RichTextPresetCommandPackages as aQ, type RichTextPresetOptions as aR, SMILIE_REPLACEMENTS as aS, STYLE_ID_ATTRIBUTE as aT, type SearchBudget as aU, type SearchBudgetOptions as aV, type SetBookmarkOptions as aW, type SetSearchParams as aX, type SlashCommandMatchData as aY, SlashCommands as aZ, type SlashCommandsOptions as a_, FontSize as aa, Footnote as ab, type FootnoteInfo as ac, FootnoteReference as ad, Footnotes as ae, type FootnotesOptions as af, GradientText as ag, type GradientTextOptions as ah, Image as ai, type ImageOptions as aj, type ImportStructureItem as ak, type ImportStructureReport as al, type InsertFootnoteOptions as am, type InsertTableOfContentsOptions as an, LoadingNode as ao, MAX_FIND_PATTERN_LENGTH as ap, Markdown as aq, NORMAL_STYLE_ID as ar, type OpenFindReplaceParams as as, Outline as at, type OutlineHeading as au, type OutlineOptions as av, type OutlineSnapshot as aw, type OutlineStorage as ax, type OutlineStore as ay, type OutlineTreeItem as az, type PdfLayoutOptions as b, getStyleRegistry as b$, type StyleBlock as b0, type StyleCSSOptions as b1, type StyleDefaults as b2, type StyleDefinition as b3, type StyleKind as b4, StyleRegistry as b5, type StyleRegistryJSON as b6, type StyleRegistryOptions as b7, type StyleRegistrySnapshot as b8, TableOfContents as b9, expandReplacement as bA, fileImportPluginKey as bB, findAllMatches as bC, findAutocorrection as bD, findCommentRanges as bE, findHexColors as bF, findImportAdapter as bG, findReplacePluginKey as bH, foldCodePoint as bI, footnotesMarkdownIt as bJ, footnotesPluginKey as bK, formatFindStatus as bL, fractionRules as bM, getActiveHeading as bN, getBookmarks as bO, getCommentAnchors as bP, getCommentAuthor as bQ, getCommentIdsAt as bR, getCommentStore as bS, getCrossReferenceTargets as bT, getDocumentStructureCommandItems as bU, getFindReplaceState as bV, getFindReplaceStore as bW, getFootnotes as bX, getImportAccept as bY, getOutline as bZ, getParagraphStyleAt as b_, type TableOfContentsEntry as ba, type TableOfContentsOptions as bb, TemplateSuggestions as bc, type TemplateSuggestionsOptions as bd, analyzePdfLayout as be, applyDocumentComparison as bf, applyReplacements as bg, autocorrectPluginKey as bh, buildOutlineTree as bi, capitalizeSentenceRules as bj, captureSelectionFormat as bk, commentsPluginKey as bl, compareInEditor as bm, compileFindPattern as bn, computeOutline as bo, createFindReplaceCommands as bp, createImportAdapterRegistry as bq, createOutlineStore as br, createParagraphStylesStore as bs, createRichTextPreset as bt, createSearchBudget as bu, createStyleRegistry as bv, crossReferencePluginKey as bw, defaultAutocorrectRules as bx, defaultImportRegistry as by, documentStructureCommandItems as bz, type PdfRuleLine as c, getTableOfContentsEntries as c0, handleImageInsertion as c1, htmlImportAdapter as c2, imagePastePluginKey as c3, importFile as c4, insertImageNode as c5, isInsidePromptToken as c6, isParagraphStyleAvailable as c7, isValidStyleId as c8, markdownImportAdapter as c9, navigateToHeading as ca, outlinePluginKey as cb, paragraphStylesPluginKey as cc, parseReplacement as cd, pdfLayoutBlocksToHtml as ce, plainTextImportAdapter as cf, registerImportAdapter as cg, removeImageNode as ch, richClipboardPluginKey as ci, rtfImportAdapter as cj, safeCSSValue as ck, searchDocument as cl, smartQuoteRules as cm, smilieAutocorrectRules as cn, symbolRules as co, syncFootnotes as cp, tableOfContentsMarkdownIt as cq, tableOfContentsPluginKey as cr, twoInitialCapitalsRules as cs, unregisterImportAdapter as ct, updateImageSrc as cu, validateFindPattern as cv, writeRichClipboard as cw, type PdfTextRun as d, Autocorrect as e, type AutocorrectContext as f, type AutocorrectCorrection as g, type AutocorrectOptions as h, type AutocorrectRule as i, type AutocorrectStorage as j, Bookmark as k, type BookmarkInfo as l, type BookmarkOptions as m, COMMENT_MARK_NAME as n, type CharacterFormat as o, CharacterStyle as p, ColorHighlighter as q, type CommentRange as r, Comments as s, type CommentsOptions as t, type CommentsStorage as u, type CompileFindPatternResult as v, type CompiledFindPattern as w, type CreateImportAdapterRegistryOptions as x, type CreateStyleFromSelectionOptions as y, CrossReference as z };