ooxml-ui 0.27.2 → 0.29.0

package/dist/docx/editor-chrome.d.ts

@@ -0,0 +1,59 @@
+import { type DocumentModel } from 'ooxml-core/docx';
+import { type Backstage } from './backstage';
+import type { BackstageOptions, BackstageOptionKey } from './backstage-options';
+import { type FileCommand } from './file-commands';
+import { type EditorLocale } from './localization';
+import { type StatusBar } from './status-bar';
+import { type SaveState, type TitleBar } from './title-bar';
+/** What the chrome needs from the editor element; keeps component.ts free of chrome details. */
+export interface ChromeHost {
+    element: HTMLElement;
+    model(): DocumentModel;
+    ribbon(): HTMLElement | undefined;
+    wordCount(): number;
+    locale(): EditorLocale;
+    readOnly(): boolean;
+    setReadOnly(readOnly: boolean): void;
+    newDocument(): void;
+    load(bytes: Uint8Array): Promise<void>;
+    save(): Promise<Uint8Array>;
+    print(): void;
+    history(key: 'undo' | 'redo'): void;
+    toggleComments(): void;
+    setViewMode(mode: 'draft' | 'print'): void;
+    setZoom(percent: number): void;
+    reportError(error: Error): void;
+    /** Mirrors the title bar's save state into `element.dirty`. */
+    saveStateChanged?(state: SaveState): void;
+    /** Editor options shown on File > Options. */
+    options(): BackstageOptions;
+    setOption(key: BackstageOptionKey, value: string): void;
+    hiddenActions(): readonly string[];
+    setHiddenActions(ids: string[]): void;
+}
+export declare const DEFAULT_FILE_NAME = "Document1.docx";
+/** Title bar, File tab/backstage, status bar and the default browser file workflow. */
+export declare class EditorChrome {
+    private readonly host;
+    readonly titleBar: TitleBar;
+    readonly backstage: Backstage;
+    readonly statusBar: StatusBar;
+    readonly fileInput: HTMLInputElement;
+    private ribbon;
+    private _fileName;
+    private state;
+    constructor(host: ChromeHost);
+    /** Adds the chrome around an existing frame: title bar first, status bar and backstage last. */
+    mount(frame: HTMLElement, ribbon: HTMLElement): void;
+    get fileName(): string;
+    set fileName(value: string);
+    get isDirty(): boolean;
+    setSaveState(state: SaveState): void;
+    setLocale(locale: EditorLocale): void;
+    refresh(pageText: string, wordText: string): void;
+    closeBackstage(): void;
+    /** Runs a file command unless a host cancels the `file-command` event to handle it itself. */
+    run(command: FileCommand, fileName?: string): Promise<void>;
+    private newDocument;
+    private openSelectedFile;
+}

package/dist/docx/editor-commands.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+import type { RibbonAction } from './ribbon';
+/** ProseMirror bindings the editor adds on top of the base keymap; the help dialog lists these. */
+export declare const editorBindings: Record<string, Command>;
+export declare function editorKeymap(showSearch: () => void): import("prosemirror-state").Plugin<any>;
+export declare function runRibbonCommand(view: EditorView, action: RibbonAction, nextId?: (kind: string) => string): void;

package/dist/docx/editor-controls.d.ts

@@ -0,0 +1,10 @@
+import type { EditorView } from 'prosemirror-view';
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { EditorLocale } from './localization';
+export declare function refreshEditorControls(toolbar: HTMLElement | undefined, view: EditorView | undefined, model: DocumentModel, readOnly: boolean, collaboration: boolean, locale: EditorLocale, language: string, printPageStatus?: {
+    current: number;
+    total: number;
+} | null, commentsOpen?: boolean): {
+    pageText: string;
+    wordText: string;
+} | undefined;

package/dist/docx/editor-core.d.ts

@@ -0,0 +1,78 @@
+import { FormatDialogs } from './format-dialogs';
+import type { EditorState, Transaction } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { loadDocument } from 'ooxml-core/docx/load';
+import type { SearchPanelHandle } from './search-panel';
+import { CollaborationSession } from './collaboration-session';
+import type { EditorTheme, EditorThemeMode } from 'ooxml-core/docx/ui';
+import type { EditorLocale } from './localization';
+import type { PrintLayoutController } from './print-layout-view';
+import type { ReviewDisplayMode } from './review-display';
+import type { ReviewController } from './review-controller';
+import { ImageMediaCache } from './image-media';
+import type { EditorChrome } from './editor-chrome';
+import { type EditorHost } from './editor-host';
+import { PartsController } from './parts-controller';
+import { PageController } from './page-controller';
+import { InsertController } from './insert-controller';
+import { DirtyState } from 'ooxml-core/docx/ui';
+import { PageTracker } from './page-sync';
+import type { PageNavigator } from './page-navigator';
+import type { HeadingNavigator } from './heading-navigator';
+import { ViewOptions } from './view-options';
+export type LoadedDocument = Awaited<ReturnType<typeof loadDocument>>;
+/** DOM pieces created by the shell once the element connects. */
+export interface ShellParts {
+    toolbar?: HTMLElement;
+    canvas?: HTMLElement;
+    paper?: HTMLElement;
+    searchPanel?: SearchPanelHandle;
+    review?: ReviewController;
+    chrome?: EditorChrome;
+    printLayout?: PrintLayoutController;
+    navigator?: PageNavigator;
+    headings?: HeadingNavigator;
+}
+/**
+ * Mutable editor state and the controllers that share it. `<docx-editor>` is a thin facade over
+ * this object; the shell, render, ribbon and chrome modules take it instead of reaching into the
+ * element's private fields.
+ */
+export declare class EditorCore {
+    readonly element: HTMLElement;
+    model: DocumentModel;
+    view?: EditorView | undefined;
+    loaded?: LoadedDocument | undefined;
+    loadGeneration: number;
+    readOnly: boolean;
+    locale: EditorLocale;
+    reviewAuthor: string;
+    theme: EditorThemeMode;
+    themeColors?: Partial<EditorTheme> | undefined;
+    appliedThemeVars: string[];
+    reviewDisplayMode: ReviewDisplayMode;
+    detachedState?: EditorState | undefined;
+    pendingFileName?: string;
+    readonly shell: ShellParts;
+    readonly collab: CollaborationSession;
+    readonly inserts: InsertController;
+    readonly formatDialogs: FormatDialogs;
+    readonly imageMedia: ImageMediaCache;
+    readonly host: EditorHost;
+    readonly parts: PartsController;
+    readonly pages: PageController;
+    readonly viewOptions: ViewOptions;
+    readonly dirtyState: DirtyState;
+    readonly pageTracker: PageTracker;
+    constructor(element: HTMLElement);
+    contentWidth(): number;
+    /** The ribbon acts on an open header/footer/note editor, otherwise on the main text. */
+    targetView(): EditorView | undefined;
+    notifyChange(): void;
+    markEditedOutsideBody(): void;
+    scheduleCollaborationSend(): void;
+    pendingCollaboration(): import("ooxml-core/docx/ui").StepBatch | null;
+    applyTransaction(transaction: Transaction, remote?: boolean): void;
+    refreshControls(): void;
+}

package/dist/docx/editor-host.d.ts

@@ -0,0 +1,19 @@
+import type { EditorView } from 'prosemirror-view';
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { EditorLocale } from './localization';
+/** What feature controllers need from the editor element, without reaching into its internals. */
+export interface EditorHost {
+    readonly element: HTMLElement;
+    view(): EditorView | undefined;
+    model(): DocumentModel;
+    /** Replaces the model for edits made outside the main editing surface. */
+    setModel(model: DocumentModel): void;
+    locale(): EditorLocale;
+    /** Editable and not in a collaboration session (parts and page setup aren't synced). */
+    canEditOutsideBody(): boolean;
+    /** Marks the document changed after an edit outside the main surface. */
+    edited(): void;
+    reportError(cause: unknown): void;
+}
+/** Raises the editor's `document-error` event for any thrown value. */
+export declare function dispatchDocumentError(element: HTMLElement, cause: unknown): void;

package/dist/docx/editor-interactions.d.ts

@@ -0,0 +1,2 @@
+import type { EditorCore } from './editor-core';
+export declare function attachEditorInteractions(core: EditorCore, frame: HTMLElement): void;

package/dist/docx/editor-plugins.d.ts

@@ -0,0 +1,16 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { Plugin } from 'prosemirror-state';
+import { type ReviewDisplayMode } from './review-display';
+/** What the body editor's plugins read from the editor element. */
+export interface BodyPluginHost {
+    model(): DocumentModel;
+    reviewAuthor(): string;
+    reviewDisplayMode(): ReviewDisplayMode;
+    insertNote(kind: 'footnote' | 'endnote'): void;
+    showSearch(): void;
+    /** Controller and collaboration plugins, in the order they apply. */
+    extraPlugins: Plugin[];
+    collaborationPlugins: Plugin[];
+}
+/** The main body editor's plugins: history, structure guards, style decorations, review and keys. */
+export declare function bodyPlugins(host: BodyPluginHost): Plugin[];

package/dist/docx/editor-presence.d.ts

@@ -0,0 +1,20 @@
+import type { EditorView } from 'prosemirror-view';
+import { PresenceClient, type PresenceConfig, type PresenceMessage, type PresenceReceiveResult } from './presence';
+export declare class EditorPresence {
+    private element;
+    private view;
+    readonly client: PresenceClient;
+    private profile?;
+    private scheduled;
+    constructor(config: PresenceConfig, element: HTMLElement, view: () => EditorView | undefined);
+    publish(profile: {
+        name: string;
+        color: string;
+    }): PresenceMessage | null;
+    receive(input: unknown): PresenceReceiveResult['status'];
+    leave(): PresenceMessage | null;
+    /** Re-renders peer labels after a display-locale change. */
+    relocalize(): void;
+    schedule(): void;
+    private emit;
+}

package/dist/docx/editor-render.d.ts

@@ -0,0 +1,3 @@
+import type { EditorCore } from './editor-core';
+/** Rebuilds the ProseMirror view for the current model (or the detached state kept while unmounted). */
+export declare function renderDocument(core: EditorCore): void;

package/dist/docx/editor-shell.d.ts

@@ -0,0 +1,11 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { EditorCore } from './editor-core';
+/** Element-level operations the chrome needs; they stay on the element because they are public API. */
+export interface ShellApi {
+    setReadOnly(readOnly: boolean): void;
+    setDocumentModel(model: DocumentModel): void;
+    load(bytes: Uint8Array | ArrayBuffer): Promise<void>;
+    saveBytes(): Promise<Uint8Array>;
+}
+/** Builds the shadow-DOM shell (ribbon, canvas, panels, chrome) once; later calls are no-ops. */
+export declare function buildShell(core: EditorCore, api: ShellApi): void;

package/dist/docx/element-api.d.ts

@@ -0,0 +1,35 @@
+import type { EditorCore } from './editor-core';
+import { type RibbonActionId, type RibbonActionInput } from 'ooxml-core/docx/ui';
+declare const HTMLElementBase: typeof HTMLElement;
+/**
+ * Save, dirty-tracking and UI-customisation surface of `<docx-editor>`. It only reads and writes
+ * the shared `EditorCore`, so the element class stays a thin lifecycle facade.
+ */
+export declare abstract class DocxEditorApi extends HTMLElementBase {
+    protected abstract readonly core: EditorCore;
+    abstract fileName: string;
+    /** Shows the left rail of page thumbnails. Needs Print Layout; reflected to `show-thumbnails`. */
+    get showThumbnails(): boolean;
+    set showThumbnails(value: boolean);
+    /** Hides the ribbon (the title bar and status bar stay). Default true; `show-toolbar="false"`. */
+    get showToolbar(): boolean;
+    set showToolbar(value: boolean);
+    /**
+     * Ribbon controls to hide, by stable id (`RIBBON_ACTION_IDS`, e.g. `'bold'`). Unknown ids are
+     * ignored. The old English labels (`'Bold'`) are still accepted for one release: they are mapped
+     * to ids and reported through a `document-warning` event. Reading returns ids only.
+     */
+    get hiddenActions(): readonly RibbonActionId[];
+    set hiddenActions(value: readonly RibbonActionInput[]);
+    /** True after an edit until the document is saved through File > Save, `download()`, loaded or `markClean()`. */
+    get dirty(): boolean;
+    /** Declares the current content saved, for hosts that persist the result of `save()` themselves. */
+    markClean(): void;
+    /** Serialized document bytes: the loaded package's own writer, else a fresh DOCX from the model. */
+    saveBytes(): Promise<Uint8Array>;
+    /** The saved document as a Blob. Does not change `dirty`; call `markClean()` after persisting it. */
+    save(): Promise<Blob>;
+    /** Saves and starts a browser download, then marks the document clean. */
+    download(fileName?: string): Promise<void>;
+}
+export {};

package/dist/docx/equation-schema.d.ts

@@ -0,0 +1,4 @@
+import type { NodeSpec } from 'prosemirror-model';
+/** Read-only native MathML display. The source OMML stays in the atom for saving. */
+export declare function equationDom(omml: string, display: boolean): HTMLElement;
+export declare const equationNodeSpec: NodeSpec;

package/dist/docx/events.d.ts

@@ -0,0 +1,45 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { StepBatch } from 'ooxml-core/docx/ui';
+import type { FileCommandDetail } from './file-commands';
+import type { PageChangeDetail } from './page-sync';
+import type { PresenceMessage } from './presence';
+import type { RibbonAction } from './ribbon';
+/** Every CustomEvent the `<docx-editor>` element (and its controllers) dispatches, with its detail. */
+export interface DocxEditorEventMap {
+    /** The document changed through editing, review actions or edits outside the main surface. */
+    'document-change': CustomEvent<DocumentModel>;
+    /** Loading, saving, printing or an edit failed. */
+    'document-error': CustomEvent<Error>;
+    /** Non-fatal notice, for example that a print layout could not be produced faithfully. */
+    'document-warning': CustomEvent<string>;
+    /** The user toggled read-only from the editor chrome. */
+    'readonly-change': CustomEvent<boolean>;
+    /** A ribbon control was activated. Bubbles from inside the shadow tree. */
+    'ribbon-action': CustomEvent<RibbonAction>;
+    /** The user changed which ribbon commands are shown (File > Customize Ribbon); persist the ids if you want them kept. */
+    'ribbon-customize': CustomEvent<readonly string[]>;
+    /** Cancelable: call `preventDefault()` to handle a File command (open/save/…) yourself. */
+    'file-command': CustomEvent<FileCommandDetail>;
+    /** Print Layout's current page or page count changed (approximate pagination, not Word's). */
+    'page-change': CustomEvent<PageChangeDetail>;
+    /** Unsaved-changes state flipped: true after an edit, false after save, load or `markClean()`. */
+    'dirty-change': CustomEvent<boolean>;
+    /** Local presence changed; transport it to other clients. */
+    'presence-send': CustomEvent<PresenceMessage>;
+    /** Local steps are pending; transport the batch to the collaboration authority. */
+    'collaboration-send': CustomEvent<StepBatch>;
+}
+export type DocxEditorEventName = keyof DocxEditorEventMap;
+/** Detail payload type of the named event. */
+export type DocxEditorEventDetail<K extends DocxEditorEventName> = DocxEditorEventMap[K] extends CustomEvent<infer D> ? D : never;
+/** Runtime list of every event name; the `satisfies` check keeps it a subset of the map. */
+export declare const DOCX_EDITOR_EVENTS: readonly ["document-change", "document-error", "document-warning", "readonly-change", "ribbon-action", "ribbon-customize", "file-command", "page-change", "dirty-change", "presence-send", "collaboration-send"];
+/** Typed listener for plain elements (such as the ribbon) that are not a `<docx-editor>`. */
+export declare function on<K extends DocxEditorEventName>(target: EventTarget, name: K, listener: (event: DocxEditorEventMap[K]) => void): void;
+/**
+ * Dispatches a typed, bubbling, composed CustomEvent. Returns false when a cancelable event was
+ * canceled by a listener (same contract as `EventTarget.dispatchEvent`).
+ */
+export declare function emit<K extends DocxEditorEventName>(target: EventTarget, name: K, detail: DocxEditorEventDetail<K>, options?: {
+    cancelable?: boolean;
+}): boolean;

package/dist/docx/field-update.d.ts

@@ -0,0 +1,16 @@
+import type { Transaction } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+/**
+ * Word's Update Field for the whole body: every `SEQ` caption is renumbered, then `REF` results
+ * follow their bookmarked paragraph and `PAGEREF` results take the page from `pageOf`. A REF that
+ * pointed at a caption's label and number keeps showing the label; a longer result is treated as
+ * the entire caption. Fields with other switches or a missing bookmark are left as they are.
+ * One undoable step; returns whether anything changed.
+ */
+export declare function updateFields(view: EditorView, pageOf: (id: string) => string | undefined): boolean;
+/**
+ * The refresh behind `updateFields`, applied to `tr` so other commands (a new caption) can include
+ * it in their own undo step. Without `pageOf`, `PAGEREF` results are left alone: pages need a layout.
+ * With `captionsOnly`, only references that quote a caption are refreshed.
+ */
+export declare function refreshFieldResults(tr: Transaction, pageOf?: (id: string) => string | undefined, captionsOnly?: boolean): Transaction;

package/dist/docx/file-commands.d.ts

@@ -0,0 +1,15 @@
+export type FileCommand = 'new' | 'open' | 'save' | 'saveAs' | 'export' | 'exportText' | 'print';
+export interface FileCommandDetail {
+    command: FileCommand;
+    /** Save As: the name the user chose. */
+    fileName?: string;
+}
+export declare function announceFileCommand(host: HTMLElement, command: FileCommand, fileName?: string): boolean;
+/** Wraps saved bytes in a Blob typed from the file name's extension (docx unless `.doc`). */
+export declare function wordBlob(bytes: Uint8Array, fileName: string): Blob;
+/** Starts a browser download of `bytes` named `fileName`. */
+export declare function downloadBytes(bytes: Uint8Array, fileName: string): void;
+/** Starts a browser download of `text` as a UTF-8 plain-text file. */
+export declare function downloadText(text: string, fileName: string): void;
+/** Replaces the extension of `fileName` (or appends one). */
+export declare function withExtension(fileName: string, extension: string): string;

package/dist/docx/focus-view.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from 'prosemirror-view';
+/** Returns focus to the editor where the platform supports it (jsdom and SSR do not). */
+export declare function focusView(view: EditorView | undefined): void;

package/dist/docx/font-advanced.d.ts

@@ -0,0 +1,18 @@
+import type { FontFormat, FontFormatState } from './font-format';
+/** Word's Advanced character spacing controls. Untouched mixed values stay mixed. */
+export declare function createFontAdvanced(mark: (...fields: Array<keyof FontFormat>) => void): {
+    element: HTMLFieldSetElement;
+    spacingKind: HTMLSelectElement;
+    spacingBy: HTMLInputElement;
+    reset(state: FontFormatState): void;
+    valid(dirty: Set<keyof FontFormat>, reveal?: () => void): boolean;
+    collect(dirty: Set<keyof FontFormat>): Partial<FontFormat>;
+    previewStyle(size: number): {
+        fontVariantLigatures: string;
+        transform: string;
+        letterSpacing: string;
+        position: string;
+        top: string;
+        fontKerning: string;
+    };
+};

package/dist/docx/font-dialog-tabs.d.ts

@@ -0,0 +1,8 @@
+/** Accessible Font/Advanced tabs, with roving keyboard focus. */
+export declare function createFontDialogTabs(): {
+    list: HTMLDivElement;
+    basic: HTMLDivElement;
+    advanced: HTMLDivElement;
+    reset: () => void;
+    showAdvanced: () => void;
+};

package/dist/docx/font-dialog.d.ts

@@ -0,0 +1,11 @@
+import type { EditorView } from 'prosemirror-view';
+import { type EditorLocale } from './localization';
+export interface FormatDialog {
+    element: HTMLElement;
+    open(): void;
+    close(): void;
+    setLocale(locale: EditorLocale): void;
+    readonly isOpen: boolean;
+}
+/** Word's Font dialog: family, style, size, colour, underline, effects and character spacing. */
+export declare function createFontDialog(getView: () => EditorView | undefined, getHistoryView?: () => EditorView | undefined): FormatDialog;

package/dist/docx/font-format-batch.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from 'prosemirror-view';
+/** Runs Font's existing commands against a draft state, then dispatches one atomic change. */
+export declare function batchFontFormat(view: EditorView, apply: (draft: EditorView) => void): void;

package/dist/docx/font-format.d.ts

@@ -0,0 +1,38 @@
+import { type Ligatures } from 'ooxml-core/docx';
+import type { EditorState } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+export type UnderlineKind = 'none' | 'single' | 'double' | 'dotted' | 'dash' | 'wave';
+export type Script = 'none' | 'superscript' | 'subscript';
+/** Formatting edited by the Font dialog, in UI units (points instead of twips). */
+export interface FontFormat {
+    family: string;
+    size: number;
+    color: string;
+    bold: boolean;
+    italic: boolean;
+    underline: UnderlineKind;
+    /** `null` is Word's "Automatic" (the text colour). */
+    underlineColor: string | null;
+    strike: boolean;
+    doubleStrike: boolean;
+    script: Script;
+    smallCaps: boolean;
+    caps: boolean;
+    hidden: boolean;
+    /** Expanded (positive) or condensed (negative) character spacing in points. */
+    spacing: number;
+    scale: number;
+    /** Baseline displacement in points; positive raises, negative lowers. */
+    position: number;
+    /** Minimum point size for kerning; zero means off. */
+    kerning: number;
+    ligatures: Ligatures;
+}
+/** A selection's format, with `null` for a field whose value differs across the selection. */
+export type FontFormatState = {
+    [K in keyof FontFormat]: FontFormat[K] | null;
+};
+/** The selection's font format (or the caret's), with `null` where the selection mixes values. */
+export declare function readFontFormat(state: EditorState): FontFormatState;
+/** Applies the fields present in `changes` to the selection; untouched fields keep their values. */
+export declare function applyFontFormat(view: EditorView, changes: Partial<FontFormat>): void;

package/dist/docx/font-step.d.ts

@@ -0,0 +1,5 @@
+import type { EditorView } from 'prosemirror-view';
+/** The next size on Word's ladder above or below `size`; beyond the ends it steps by 2 pt. */
+export declare function steppedFontSize(size: number, direction: 'grow' | 'shrink'): number;
+/** Grows or shrinks the font size of the selection (or of the next typed text) by one step. */
+export declare function stepFontSize(view: EditorView, direction: 'grow' | 'shrink'): void;

package/dist/docx/font-sync.d.ts

@@ -0,0 +1,9 @@
+import type { Node as ProseMirrorNode } from 'prosemirror-model';
+import type { EditorState } from 'prosemirror-state';
+/** The family and size text shows in the editor: direct marks, then character/paragraph style and theme. */
+export declare function effectiveFont(state: EditorState, text: ProseMirrorNode, paragraph: ProseMirrorNode): {
+    family: string;
+    size: number;
+};
+/** Shows the selection's font family and size in the two combo boxes (blank when they differ). */
+export declare function syncFontControls(toolbar: HTMLElement, state: EditorState): void;

package/dist/docx/format-dialogs.d.ts

@@ -0,0 +1,37 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { EditorView } from 'prosemirror-view';
+import { type FormatDialog } from './font-dialog';
+import type { EditorLocale } from './localization';
+import { type WatermarkHost } from './watermark-dialog';
+import { type PageBordersHost } from './page-borders-dialog';
+import { type PageSetupHost } from './page-setup-dialog';
+import { type ZoomHost } from './zoom-dialog';
+import { type LineNumberHost } from './line-number-dialog';
+import { type ColumnsHost } from './columns-dialog';
+export type FormatDialogKind = 'font' | 'paragraph' | 'bookmark' | 'pageSetup' | 'caption' | 'crossReference' | 'zoom' | 'borders' | 'tableProperties' | 'lineNumbers' | 'textBox' | 'pageBorders' | 'watermark' | 'dropCap' | 'columns' | 'multilevelList';
+export interface FormatDialogsHost {
+    view(): EditorView | undefined;
+    /** Header/footer edits use the main document's history; notes use their own. */
+    historyView?(): EditorView | undefined;
+    model(): DocumentModel;
+    canDefineList?(): boolean;
+    /** Page Setup edits the section holding the selection. */
+    pageSetup?: Omit<PageSetupHost, 'restoreFocus'>;
+    /** View > Zoom: the current zoom and how to change it. */
+    zoom?: Omit<ZoomHost, 'restoreFocus'>;
+    lineNumbers?: Omit<LineNumberHost, 'restoreFocus'>;
+    pageBorders?: Omit<PageBordersHost, 'restoreFocus'>;
+    watermark?: Omit<WatermarkHost, 'restoreFocus'>;
+    columns?: Omit<ColumnsHost, 'restoreFocus'>;
+}
+/** The Font and Paragraph dialogs opened from the ribbon's group launchers. */
+export declare class FormatDialogs {
+    private readonly dialogs;
+    constructor(host: FormatDialogsHost);
+    get elements(): HTMLElement[];
+    get list(): FormatDialog[];
+    /** Opens `kind`, closing the other one first. */
+    open(kind: FormatDialogKind): void;
+    closeAll(): void;
+    setLocale(locale: EditorLocale): void;
+}

package/dist/docx/format-painter.d.ts

@@ -0,0 +1,12 @@
+import type { Mark } from 'prosemirror-model';
+import type { EditorView } from 'prosemirror-view';
+export declare function isFormatPainterArmed(view: EditorView): boolean;
+/** Replaces the character formatting of `[from, to]` with `marks`. */
+export declare function paintMarks(view: EditorView, marks: readonly Mark[], from: number, to: number): void;
+/**
+ * Word's Format Painter: the first call copies the character formatting at the selection and arms
+ * the painter; the next non-empty selection made with the mouse or keyboard receives it. Calling it
+ * again, pressing Escape or editing cancels it. Paragraph formatting is not carried.
+ * Returns whether the painter is now armed.
+ */
+export declare function toggleFormatPainter(view: EditorView, onChange: (armed: boolean) => void): boolean;

package/dist/docx/go-to-panel.d.ts

@@ -0,0 +1,4 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { EditorView } from 'prosemirror-view';
+/** Word's Go To, as a panel under the Find menu: pick what to go to, then pick the item. */
+export declare function openGoToPanel(anchor: HTMLElement, view: EditorView, model: DocumentModel, onClose: () => void): void;

package/dist/docx/go-to.d.ts

@@ -0,0 +1,23 @@
+import { type DocumentModel } from 'ooxml-core/docx';
+import type { Node as ProseMirrorNode } from 'prosemirror-model';
+import type { EditorView } from 'prosemirror-view';
+export type GoToKind = 'heading' | 'bookmark' | 'table' | 'graphic';
+export interface GoToTarget {
+    label: string;
+    /** Document position to select: a text position, or a node position for a picture. */
+    pos: number;
+    /** Set when the target is a picture (an inline atom that gets a node selection). */
+    node?: boolean;
+}
+/**
+ * Everything Word's Go To can jump to that this editor models: headings (by style), bookmarks,
+ * tables and pictures, in document order. Bookmarks are listed once, at their paragraph.
+ */
+export declare function goToTargets(doc: ProseMirrorNode, model: DocumentModel, kind: GoToKind): GoToTarget[];
+/** Selects `target` and scrolls it into view. Returns false when the position no longer exists. */
+export declare function goToTarget(view: EditorView, target: GoToTarget): boolean;
+/**
+ * Word's Select > Select Objects: selects the next picture after the selection, wrapping to the
+ * first one. Returns false when the document has no pictures.
+ */
+export declare function selectNextObject(view: EditorView): boolean;

package/dist/docx/hard-break-command.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'prosemirror-state';
+/** Replaces the current selection with an inline Word-style line break. */
+export declare const insertHardBreak: Command;

package/dist/docx/header-footer-commands.d.ts

@@ -0,0 +1,19 @@
+import type { DocumentModel, Paragraph } from 'ooxml-core/docx';
+export type HeaderFooterKind = 'headers' | 'footers';
+export type PageNumberAlign = 'left' | 'center' | 'right';
+export type PageNumberStyle = 'plain' | 'pageOfTotal';
+export type HeaderFooterSlot = 'default' | 'first' | 'even';
+/** A block id for new header/footer content, unique within this session and the document. */
+export declare const newHeaderFooterId: () => string;
+/** The first free `word/headerN.xml` / `word/footerN.xml` name among the parts the model uses. */
+export declare function nextPartName(model: DocumentModel, kind: HeaderFooterKind): string;
+/** A paragraph holding Word's PAGE field (`fldSimple`), showing 1 until Print Layout recalculates. */
+export declare function pageNumberParagraph(id: string, align: PageNumberAlign, style?: PageNumberStyle): Paragraph;
+/**
+ * Insert > Page Number: puts a PAGE field at the given position of the selected section's header or
+ * footer, creating that part when the document has none. An existing header or footer keeps its
+ * content; its page-number paragraph is re-aligned, or one is added at the end.
+ */
+export declare function withPageNumber(model: DocumentModel, position: 'top' | 'bottom', align: PageNumberAlign, newId: () => string, sectionIndex?: number, style?: PageNumberStyle, slot?: HeaderFooterSlot): DocumentModel;
+/** Insert > Header or Footer > Blank: creates an empty part when there is none; otherwise a no-op. */
+export declare function withBlankHeaderFooter(model: DocumentModel, kind: HeaderFooterKind, newId: () => string, sectionIndex?: number, slot?: HeaderFooterSlot): DocumentModel;

package/dist/docx/header-footer-editor.d.ts

@@ -0,0 +1,40 @@
+import { type Plugin } from 'prosemirror-state';
+import { EditorView, type EditorProps } from 'prosemirror-view';
+import { type Block, type DocumentModel, type HeaderFooterContent } from 'ooxml-core/docx';
+export type HeaderFooterSlotName = 'default' | 'first' | 'even';
+/** Picture support for in-place editors: node views, and a hook to finish previews after closing. */
+export interface InlineEditorOptions {
+    /** Owner document formatting for the preview after this editor closes. */
+    contextModel?(): DocumentModel;
+    nodeViews?: EditorProps['nodeViews'];
+    decorate?(preview: HTMLElement): void;
+    /** Extra plugins, e.g. the editor's Ctrl+K link shortcut. */
+    plugins?: Plugin[];
+    /** Reports the editor becoming the ribbon's target, and closing. */
+    activate?(view: EditorView): void;
+    deactivate?(view: EditorView): void;
+    /** Focus moving into these (the ribbon, dialogs) keeps the editor open. */
+    keepOpenWithin?(): (Element | undefined)[];
+    /** Header/footer editors share the body document's undo stack. Notes may keep local history. */
+    history?(key: 'undo' | 'redo'): boolean;
+    registerClose?(close: () => void): void;
+}
+export interface HeaderFooterEditingOptions {
+    editor?: InlineEditorOptions;
+    /** The content currently shown in `slot`, if any. */
+    content(slot: HeaderFooterSlotName): HeaderFooterContent | undefined;
+    /** Called with the slot's new blocks after every edit. */
+    change(slot: HeaderFooterSlotName, blocks: Block[]): void;
+    /** Header/footer editing is off in Viewing mode and during collaboration. */
+    editable(): boolean;
+}
+/**
+ * Word-style header/footer editing on the continuous surface: double-click a header or footer
+ * slot to edit it in place; Escape or moving focus elsewhere returns to the read-only preview.
+ */
+export declare function attachHeaderFooterEditing(root: HTMLElement, options: HeaderFooterEditingOptions): void;
+/**
+ * Replaces `body` with an in-place editor for `blocks` (same schema, history and formatting keys as
+ * the main editor). Escape or moving focus elsewhere closes it and re-renders a read-only preview.
+ */
+export declare function openBlocksEditor(container: HTMLElement, body: HTMLElement, blocks: Block[], change: (blocks: Block[]) => void, options?: InlineEditorOptions): void;

package/dist/docx/header-footer-link.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentModel, HeaderFooterContent, HeaderFooterSlots } from 'ooxml-core/docx';
+import { type HeaderFooterKind, type HeaderFooterSlot } from './header-footer-commands';
+/** Missing references inherit independently for each story, as in Word. */
+export declare function effectiveHeaderFooter(model: DocumentModel, index: number, kind: HeaderFooterKind, slot: HeaderFooterSlot): HeaderFooterContent | undefined;
+export declare function effectiveSlots(model: DocumentModel, index: number, kind: HeaderFooterKind): HeaderFooterSlots;
+export declare function withHeaderFooterLink(model: DocumentModel, index: number, kind: HeaderFooterKind, slot: HeaderFooterSlot, linked: boolean): DocumentModel;