@pixerate/editor 0.23.0 → 0.24.0

package/dist/{index-Ck6ajwXh.d.ts → index-fJrlkJCd.d.ts}

@@ -1,12 +1,15 @@
 import { Mark, Extension, Node, Editor, Extensions } from '@tiptap/core';
-import { C as ColorGradient, f as Template } from './tokens-CyLZmIei.js';
+import { C as ColorGradient, T as Template } from './tokens-D7yXvUU6.js';
 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.js';
+import { b as MentionOptions, d as TrackChangesOptions } from './track-changes-CDjCrwKe.js';
 import { MarkdownOptions } from 'tiptap-markdown';
 import { ImageOptions as ImageOptions$1 } from '@tiptap/extension-image';
+import { R as ReviewAuthor, b as CommentStore, C as CommentAnchor } from './comment-store-BEMgVlAA.js';
 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.js';
+import { b as CompareSource, C as CompareDocumentsOptions, a as CompareDocumentsResult } from './documents-BQjzJNe2.js';
+import { c as CommandSpec } from './registry-evKTP4ls.js';
 
 interface GradientTextOptions {
     templateColorMap: Map<string, ColorGradient>;
@@ -854,6 +857,310 @@ declare function tableOfContentsMarkdownIt(md: any): void;
  */
 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>;
+
 interface RichTextPresetOptions {
     placeholder?: string | ((props: {
         node: any;
@@ -868,7 +1175,7 @@ interface RichTextPresetOptions {
     image?: ImageOptions | boolean;
     /** Adds the `Comments` extension (off by default). */
     comments?: Partial<CommentsOptions> | boolean;
-    /** Adds the `TrackChanges` extension (off by default). */
+    /** 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;
@@ -890,10 +1197,69 @@ interface RichTextPresetOptions {
     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;
 }
 /**
  * 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 };
+/** 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 { FindReplaceStore as $, type AddCommentOptions as A, BUILT_IN_IMPORT_ADAPTERS as B, COMMENT_MARK_NAME as C, type DocumentImport as D, type DocumentSearchOptions as E, type DocumentSearchResult as F, type DocumentStructureCommandArgs as G, type DocumentStructureCommandItem as H, EMPTY_FIND_REPLACE_SNAPSHOT as I, type EditorCompareOptions as J, FIND_OPTION_TOGGLES as K, FIND_PARAGRAPH_MARK as L, FileImport as M, type FileImportOptions as N, type FindAllOptions as O, type FindAllResult as P, type FindMatch as Q, type FindOptionToggle as R, type FindOptions as S, type FindPatternError as T, type FindPatternErrorCode as U, FindReplace as V, type FindReplaceCommandOptions as W, type FindReplaceMode as X, type FindReplaceOptions as Y, type FindReplaceSnapshot as Z, type FindReplaceStorage as _, type DocumentImportAdapter as a, fileImportPluginKey as a$, type FocusHeadingOptions as a0, FontSize as a1, Footnote as a2, type FootnoteInfo as a3, FootnoteReference as a4, Footnotes as a5, type FootnotesOptions as a6, GradientText as a7, type GradientTextOptions as a8, Image as a9, SlashCommands as aA, type SlashCommandsOptions as aB, SmilieReplacer as aC, TableOfContents as aD, type TableOfContentsEntry as aE, type TableOfContentsOptions as aF, TemplateSuggestions as aG, type TemplateSuggestionsOptions as aH, applyDocumentComparison as aI, applyReplacements as aJ, autocorrectPluginKey as aK, buildOutlineTree as aL, capitalizeSentenceRules as aM, commentsPluginKey as aN, compareInEditor as aO, compileFindPattern as aP, computeOutline as aQ, createFindReplaceCommands as aR, createImportAdapterRegistry as aS, createOutlineStore as aT, createRichTextPreset as aU, createSearchBudget as aV, crossReferencePluginKey as aW, defaultAutocorrectRules as aX, defaultImportRegistry as aY, documentStructureCommandItems as aZ, expandReplacement as a_, type ImageOptions as aa, type InsertFootnoteOptions as ab, type InsertTableOfContentsOptions as ac, LoadingNode as ad, MAX_FIND_PATTERN_LENGTH as ae, Markdown as af, type OpenFindReplaceParams as ag, Outline as ah, type OutlineHeading as ai, type OutlineOptions as aj, type OutlineSnapshot as ak, type OutlineStorage as al, type OutlineStore as am, type OutlineTreeItem as an, type PatternMatch as ao, type ReplacePiece as ap, RichClipboard as aq, type RichClipboardOptions as ar, type RichClipboardStorage as as, type RichTextPresetOptions as at, SMILIE_REPLACEMENTS as au, type SearchBudget as av, type SearchBudgetOptions as aw, type SetBookmarkOptions as ax, type SetSearchParams as ay, type SlashCommandMatchData as az, Autocorrect as b, findAllMatches as b0, findAutocorrection as b1, findCommentRanges as b2, findHexColors as b3, findImportAdapter as b4, findReplacePluginKey as b5, foldCodePoint as b6, footnotesMarkdownIt as b7, footnotesPluginKey as b8, formatFindStatus as b9, registerImportAdapter as bA, removeImageNode as bB, richClipboardPluginKey as bC, rtfImportAdapter as bD, searchDocument as bE, smartQuoteRules as bF, smilieAutocorrectRules as bG, symbolRules as bH, syncFootnotes as bI, tableOfContentsMarkdownIt as bJ, tableOfContentsPluginKey as bK, twoInitialCapitalsRules as bL, unregisterImportAdapter as bM, updateImageSrc as bN, validateFindPattern as bO, writeRichClipboard as bP, fractionRules as ba, getActiveHeading as bb, getBookmarks as bc, getCommentAnchors as bd, getCommentAuthor as be, getCommentIdsAt as bf, getCommentStore as bg, getCrossReferenceTargets as bh, getDocumentStructureCommandItems as bi, getFindReplaceState as bj, getFindReplaceStore as bk, getFootnotes as bl, getImportAccept as bm, getOutline as bn, getTableOfContentsEntries as bo, handleImageInsertion as bp, htmlImportAdapter as bq, imagePastePluginKey as br, importFile as bs, insertImageNode as bt, isInsidePromptToken as bu, markdownImportAdapter as bv, navigateToHeading as bw, outlinePluginKey as bx, parseReplacement as by, plainTextImportAdapter as bz, 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 CompileFindPatternResult as p, type CompiledFindPattern as q, type CreateImportAdapterRegistryOptions as r, CrossReference as s, type CrossReferenceOptions as t, type CrossReferenceTarget as u, type CrossReferenceTargetType as v, DEFAULT_AUTOCORRECT_EXCEPTIONS as w, DocumentCompare as x, type DocumentCompareOptions as y, type DocumentCompareStorage as z };