ooxml-ui 0.27.2 → 0.28.0

package/dist/docx/localization.d.ts

@@ -0,0 +1,24 @@
+/** Display-language strings for the shared editor UI. This locale never changes DOCX language marks. */
+import { EDITOR_LOCALES, type LocalizationKey } from './localization-strings';
+export type EditorLocale = (typeof EDITOR_LOCALES)[number];
+/** A locale code a host may pass: a canonical code (autocompleted) or any BCP 47 tag such as `de-DE`. */
+export type EditorLocaleInput = EditorLocale | (string & {});
+export { EDITOR_LOCALES };
+export type { LocalizationKey };
+/**
+ * Maps any BCP 47 tag to a supported display locale, falling back to English. Region variants
+ * resolve to their language (`fr-CA`, `de-DE`, `es-MX`); `zh`, `zh-CN`, `zh-Hans` and `zh-SG` use
+ * Simplified Chinese, while Traditional tags (`zh-TW`, `zh-HK`, `zh-Hant`) are unsupported.
+ */
+export declare function normalizeEditorLocale(value: string | null | undefined): EditorLocale;
+export declare function translate(locale: EditorLocale, key: LocalizationKey): string;
+/** Translates a `{name}` template key and fills its placeholders. */
+export declare function translateTemplate(locale: EditorLocale, key: LocalizationKey, values: Record<string, string | number>): string;
+export declare function translateUiText(root: HTMLElement, englishText: string): string;
+export declare function formatWordCount(locale: EditorLocale, count: number): string;
+export declare function formatPageStatus(locale: EditorLocale, current: number, total: number): string;
+/** The display locale of the editor chrome that contains `element`. */
+export declare function localeOf(element: Element): EditorLocale;
+/** Translate literal UI labels in-place while retaining action data and current control state. */
+export declare function localizeElement(root: HTMLElement, locale: EditorLocale): void;
+export declare function findLocalizedControl<T extends HTMLElement>(root: ParentNode, label: string): T | null;

package/dist/docx/model-adapter.d.ts

@@ -0,0 +1,6 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { Node as ProseMirrorNode } from 'prosemirror-model';
+export declare function modelToDoc(model: DocumentModel): ProseMirrorNode;
+export declare function docToModel(doc: ReturnType<typeof modelToDoc>, prior: DocumentModel): DocumentModel;
+export declare function assignMissingParagraphIds(state: EditorState): Transaction | null;

package/dist/docx/multilevel-list-dialog.d.ts

@@ -0,0 +1,5 @@
+import { type DocumentModel } from 'ooxml-core/docx';
+import type { EditorView } from 'prosemirror-view';
+import type { FormatDialog } from './font-dialog';
+/** Creates a fresh definition for the selection; imported definitions remain untouched. */
+export declare function createMultilevelListDialog(getView: () => EditorView | undefined, getModel: () => DocumentModel, canEdit?: () => boolean): FormatDialog;

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

@@ -0,0 +1,14 @@
+import type { EditorView } from 'prosemirror-view';
+export type LanguageField = 'language' | 'eastAsiaLanguage' | 'bidiLanguage';
+export type MultilingualAction = {
+    type: 'paragraphDirection';
+    value: 'inherit' | 'ltr' | 'rtl';
+} | {
+    type: 'language';
+    key: LanguageField;
+    value: string;
+} | {
+    type: 'runRtl';
+    value: 'inherit' | 'on' | 'off';
+};
+export declare function applyMultilingualAction(view: EditorView, action: MultilingualAction): void;

package/dist/docx/multilingual-ribbon.d.ts

@@ -0,0 +1,6 @@
+import type { EditorState } from 'prosemirror-state';
+import type { LanguageField, MultilingualAction } from './multilingual-commands';
+export type { LanguageField, MultilingualAction };
+export { applyMultilingualAction } from './multilingual-commands';
+export declare function createMultilingualControls(locale?: string): HTMLElement;
+export declare function syncMultilingualControls(toolbar: HTMLElement, state: EditorState): void;

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

@@ -0,0 +1,17 @@
+import { Plugin } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+import { type DocumentModel, type Note } from 'ooxml-core/docx';
+export type NoteKind = 'footnote' | 'endnote';
+/** The next free note id: Word numbers user notes from 1 (separators use -1 and 0). */
+export declare function nextNoteId(notes: Note[] | undefined): string;
+/**
+ * Word's Insert Footnote/Endnote: adds a note (number mark plus a space, in the note text style
+ * when the document defines one) and inserts its superscript reference at the selection.
+ * Returns the updated model and the new note's id.
+ */
+export declare function insertNote(view: EditorView, model: DocumentModel, kind: NoteKind): {
+    model: DocumentModel;
+    id: string;
+};
+/** Keeps note reference numbers in document order, as Word renumbers notes after every change. */
+export declare function noteNumberingPlugin(): Plugin;

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

@@ -0,0 +1,10 @@
+import type { Block, Note } from 'ooxml-core/docx';
+import { type InlineEditorOptions } from './header-footer-editor';
+export interface NoteEditingOptions {
+    editor?: InlineEditorOptions;
+    note(id: string): Note | undefined;
+    change(id: string, blocks: Block[]): void;
+    editable(): boolean;
+}
+/** Double-click a footnote or endnote to edit its text in place. */
+export declare function attachNoteEditing(root: HTMLElement, options: NoteEditingOptions): void;

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

@@ -0,0 +1,3 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+/** Footnotes then endnotes, read-only, rendered at the end of the continuous surface. */
+export declare function buildNotesElement(model: DocumentModel, locale: string): HTMLElement | null;

package/dist/docx/page-borders-dialog.d.ts

@@ -0,0 +1,16 @@
+import type { PageBorders, SectionProperties } from 'ooxml-core/docx';
+import type { FormatDialog } from './font-dialog';
+export interface PageBordersHost {
+    section(): SectionProperties | undefined;
+    canEdit(): boolean;
+    /** Replaces the current section's page borders; undefined removes them. */
+    apply(borders: PageBorders | undefined): void;
+    restoreFocus(): void;
+}
+/**
+ * Word's Page Borders for the section holding the selection: the sides, one pen, where the lines
+ * are measured from, and which pages show them. They print in Print Layout; the continuous editing
+ * surface has no pages to put them on. Art borders are not offered, and a pen chosen here replaces an
+ * imported art side with a plain line.
+ */
+export declare function createPageBordersDialog(host: PageBordersHost): FormatDialog;

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

@@ -0,0 +1,5 @@
+import type { Command } from 'prosemirror-state';
+/** Inserts a visible, editable Word page or column break marker (Ctrl+Enter for a page break). */
+export declare function insertBreakCommand(kind: 'page' | 'column'): Command;
+export declare const insertPageBreak: Command;
+export declare const insertColumnBreak: Command;

package/dist/docx/page-controller.d.ts

@@ -0,0 +1,66 @@
+import type { SectionProperties, WatermarkSpec } from 'ooxml-core/docx';
+import { type PageSetupValues } from 'ooxml-core/docx';
+import type { EditorHost } from './editor-host';
+import type { PrintLayoutController } from './print-layout-view';
+import type { RibbonAction } from './ribbon';
+import type { StatusBar } from './status-bar';
+import { type ZoomFit } from 'ooxml-core/docx/ui';
+export interface PageControllerHost extends EditorHost {
+    paper(): HTMLElement | undefined;
+    toolbar(): HTMLElement | undefined;
+    statusBar(): StatusBar | undefined;
+    printLayout(): PrintLayoutController | undefined;
+    refreshControls(): void;
+}
+/** Page setup, section breaks, zoom, Web/Print Layout and printing. */
+export declare class PageController {
+    private readonly host;
+    zoom: number;
+    viewMode: 'draft' | 'print';
+    constructor(host: PageControllerHost);
+    /** Page setup applies to the section holding the selection, as in Word, and is undoable. */
+    changePageSetup(key: Extract<RibbonAction, {
+        type: 'page';
+    }>['key'], value: string): void;
+    /** Shows the selection's section settings in the Layout tab. */
+    syncControls(): void;
+    /** The section holding the selection, for the Page Setup dialog. */
+    currentSection(): SectionProperties | undefined;
+    /** Applies the Page Setup dialog to the current section as one undoable step. */
+    applyPageSetupValues(values: PageSetupValues): void;
+    /** Layout > More Columns, recorded as one undoable section edit. */
+    applyColumns(columns: SectionProperties['columns']): void;
+    /** Layout > Line Numbers options, recorded as one undoable section edit. */
+    applyLineNumberSettings(settings: SectionProperties['lineNumberSettings']): void;
+    /** Layout > Watermark: a text watermark in every header (or none), one undoable step. */
+    applyWatermark(spec: WatermarkSpec | undefined): void;
+    /** The document's current watermark, for the Watermark dialog. */
+    currentWatermark(): WatermarkSpec | undefined;
+    /** Layout > Page Borders, recorded as one undoable section edit. */
+    applyPageBorders(borders: SectionProperties['pageBorders']): void;
+    /** Insert > Page Number: a PAGE field in the header or footer, creating the part when needed. */
+    insertPageNumber(position: 'top' | 'bottom', align: 'left' | 'center' | 'right', style?: 'plain' | 'pageOfTotal', slot?: 'default' | 'first' | 'even'): boolean;
+    /** Insert > Header / Footer: an empty part when the document has none. */
+    insertHeaderFooter(kind: 'header' | 'footer', slot?: 'default' | 'first' | 'even'): boolean;
+    private changeHeaderFooter;
+    /** Layout > Page Color (document-wide, undoable): hex with or without `#`, or `none` to clear. */
+    setPageColor(value: string): void;
+    /** Layout > Hyphenation: `auto` sets `w:autoHyphenation`, `none` clears it (document-wide, undoable). */
+    setHyphenation(value: string): void;
+    /** Header & Footer > Different Odd & Even Pages (document-wide, undoable). */
+    toggleEvenOddHeaders(): void;
+    insertSectionBreak(kind: 'nextPage' | 'continuous' | 'evenPage' | 'oddPage'): void;
+    /** Records page geometry and section layout on the editor document as one undoable step. */
+    private dispatchSections;
+    /** Page size and margins from the model; one multi-column section also shows its columns. */
+    refreshPageStyles(): void;
+    /** Zoom to 100%, the page width or a whole page, from the section holding the selection. */
+    zoomTo(mode: ZoomFit): void;
+    /** `sideBySide` lays Print Layout's pages out two across (View > Multiple Pages). */
+    setZoom(percent: number, sideBySide?: boolean): void;
+    /** Switches between the continuous editing surface and the paginated Print Layout render. */
+    setViewMode(mode: 'draft' | 'print'): void;
+    /** Re-lays out Print Layout after a model change (debounced by the layout view). */
+    relayout(): void;
+    print(): void;
+}

package/dist/docx/page-navigator.d.ts

@@ -0,0 +1,64 @@
+import { type EditorLocale } from './localization';
+/** What the navigator needs from the Print Layout view and the element. */
+export interface PageNavigatorHost {
+    /** Laid-out page sheets in order; empty until a layout exists. */
+    pages(): HTMLElement[];
+    /** Changes whenever the layout was rebuilt. */
+    version(): number;
+    goTo(page: number): void;
+    close(): void;
+}
+export interface PageNavigatorState {
+    /** Print Layout is the active view. */
+    active: boolean;
+    /** Current page and total, or null while no layout exists. */
+    status: {
+        current: number;
+        total: number;
+    } | null;
+    locale: EditorLocale;
+}
+export declare const THUMBNAIL_WIDTH = 120;
+/**
+ * Collapsible left rail of scaled page thumbnails. Thumbnails are clones of the Print Layout
+ * sheets, drawn only while near the rail's viewport, so large documents stay cheap. Pagination
+ * comes from the approximate layout engine, so the rail says so rather than implying Word parity.
+ */
+export declare class PageNavigator {
+    private readonly host;
+    readonly element: HTMLElement;
+    private readonly heading;
+    private readonly closeButton;
+    private readonly message;
+    private readonly list;
+    private thumbs;
+    private observer?;
+    private open;
+    private built;
+    private marked;
+    private labels;
+    private state;
+    constructor(host: PageNavigatorHost);
+    get isOpen(): boolean;
+    get pageCount(): number;
+    /** The 1-based page currently marked, or 0 when no thumbnails exist. */
+    get currentPage(): number;
+    setOpen(open: boolean): void;
+    /** Called after every layout, scroll and locale change; cheap when nothing moved. */
+    sync(state: PageNavigatorState): void;
+    private render;
+    private relabelChrome;
+    private relabelThumbs;
+    private clear;
+    private rebuild;
+    private createThumb;
+    private draw;
+    private hasFocus;
+    /** Highlights `page` and, unless focus is inside the rail, makes it the tab stop and scrolls to it. */
+    private mark;
+    private setStop;
+    /** Scrolls only the rail's own list, never an ancestor (`scrollIntoView` would move the page). */
+    private reveal;
+    private indexOf;
+    private onKey;
+}

package/dist/docx/page-setup-change.d.ts

@@ -0,0 +1,7 @@
+import { type DocumentModel, type SectionProperties } from 'ooxml-core/docx';
+import type { RibbonAction } from './ribbon-action';
+export type PageSetupKey = Extract<RibbonAction, {
+    type: 'page';
+}>['key'];
+/** The model with one Layout-tab page setting changed for section `index`. */
+export declare function pageSetupChange(model: DocumentModel, index: number, section: SectionProperties, key: PageSetupKey, value: string): DocumentModel;

package/dist/docx/page-setup-dialog.d.ts

@@ -0,0 +1,12 @@
+import type { SectionProperties } from 'ooxml-core/docx';
+import type { FormatDialog } from './font-dialog';
+import { type PageSetupValues } from 'ooxml-core/docx';
+export interface PageSetupHost {
+    /** The section holding the selection, or undefined when there is none to edit. */
+    section(): SectionProperties | undefined;
+    canEdit(): boolean;
+    apply(values: PageSetupValues): void;
+    restoreFocus(): void;
+}
+/** Word's Page Setup dialog: margins, gutter, header and footer distances, orientation and paper. */
+export declare function createPageSetupDialog(host: PageSetupHost): FormatDialog;

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

@@ -0,0 +1,22 @@
+import type { EditorCore } from './editor-core';
+/** Payload of the `page-change` event. Pages are 1-based and come from the approximate layout. */
+export interface PageChangeDetail {
+    page: number;
+    pageCount: number;
+}
+/** Emits `page-change` only when the page or the page count really changed. */
+export declare class PageTracker {
+    private readonly target;
+    private last?;
+    constructor(target: EventTarget);
+    report(status: {
+        current: number;
+        total: number;
+    } | null): void;
+}
+/**
+ * Single source for page state: Print Layout's `pageStatus()` feeds the navigator rail, the
+ * `page-change` event and (through `refreshControls`) the status bar. Outside Print Layout there is
+ * no pagination, so nothing is reported and the rail explains why.
+ */
+export declare function syncPageState(core: EditorCore): void;

package/dist/docx/paragraph-decoration.d.ts

@@ -0,0 +1,29 @@
+import { type EditorState } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+export type BorderPreset = 'horizontal' | 'none' | 'bottom' | 'top' | 'left' | 'right' | 'all' | 'outside' | 'insideH' | 'insideV';
+/** Sets the shading fill of the selected paragraphs to `#rrggbb`, or with `null` removes it. */
+export declare function setShading(view: EditorView, value: string | null): boolean;
+/**
+ * Borders > Horizontal Line: a new empty paragraph with a bottom border after the current one,
+ * followed by an empty paragraph for the caret. It is saved as an ordinary paragraph border.
+ */
+export declare function insertHorizontalLine(view: EditorView): boolean;
+/**
+ * Word's Borders menu. A side preset toggles: when every selected paragraph already has all of its
+ * sides the borders are removed, otherwise they are added. `none` removes every border.
+ */
+export declare function setBorders(view: EditorView, preset: BorderPreset): boolean;
+export interface BordersAndShading {
+    /** Sides to draw; the other sides lose their border. */
+    sides: Partial<Record<'top' | 'bottom' | 'left' | 'right', boolean>>;
+    style: 'single' | 'double' | 'dotted' | 'dashed';
+    sizeEighthPoints: number;
+    /** `#rrggbb`, or `null` for automatic. */
+    color: string | null;
+    /** `#rrggbb`, or `null` for no shading. */
+    fill: string | null;
+}
+/** What the Borders and Shading dialog shows: the first selected paragraph's pen, sides and fill. */
+export declare function readBordersAndShading(state: EditorState): BordersAndShading;
+/** Borders and Shading dialog: one pen for the chosen sides plus a fill, on every selected paragraph. */
+export declare function applyBordersAndShading(view: EditorView, settings: BordersAndShading): boolean;

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

@@ -0,0 +1,5 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { EditorView } from 'prosemirror-view';
+import type { FormatDialog } from './font-dialog';
+/** Word's Paragraph dialog: alignment, indentation, spacing, line spacing and pagination. */
+export declare function createParagraphDialog(getView: () => EditorView | undefined, getModel: () => DocumentModel): FormatDialog;

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

@@ -0,0 +1,37 @@
+import { type DocumentModel } from 'ooxml-core/docx';
+import type { EditorState } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+export type Alignment = 'left' | 'center' | 'right' | 'justify';
+export type Special = 'none' | 'firstLine' | 'hanging';
+export type LineRule = 'single' | 'oneAndHalf' | 'double' | 'atLeast' | 'exactly' | 'multiple';
+/** Everything Word's Paragraph dialog edits, in the units it shows (inches for indents, points for spacing). */
+export interface ParagraphFormat {
+    align: Alignment;
+    leftInches: number;
+    rightInches: number;
+    special: Special;
+    specialInches: number;
+    beforePt: number;
+    afterPt: number;
+    lineRule: LineRule;
+    /** Points for `atLeast` and `exactly`, a line multiple for `multiple`. */
+    lineAt: number;
+    contextualSpacing: boolean;
+    widowControl: boolean;
+    keepNext: boolean;
+    keepLines: boolean;
+    pageBreakBefore: boolean;
+    suppressLineNumbers: boolean;
+}
+/** A selection's paragraph format, with `null` for a field that differs between paragraphs. */
+export type ParagraphFormatState = {
+    [K in keyof ParagraphFormat]: ParagraphFormat[K] | null;
+};
+type Attrs = Record<string, unknown>;
+/** Direct paragraph attributes with the style chain and document defaults resolved beneath them. */
+export declare function resolvedAttrs(attrs: Attrs, model: DocumentModel | undefined): Attrs;
+/** The selected paragraphs' format, with `null` where they disagree. */
+export declare function readParagraphFormat(state: EditorState, model: DocumentModel | undefined): ParagraphFormatState;
+/** Applies the fields present in `changes` to every selected paragraph as one undoable step. */
+export declare function applyParagraphFormat(view: EditorView, changes: Partial<ParagraphFormat>): boolean;
+export {};

package/dist/docx/paragraph-styles.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from 'prosemirror-state';
+import { type DocumentModel } from 'ooxml-core/docx';
+/** Derived display formatting stays out of document attributes and collaboration steps. */
+export declare function paragraphStylesPlugin(getModel: () => DocumentModel): Plugin<any>;
+export { resetStylePicker, syncStylePicker } from './styles-group';

package/dist/docx/paragraph-toggle-sync.d.ts

@@ -0,0 +1,8 @@
+import type { DocumentModel } from 'ooxml-core/docx';
+import type { EditorView } from 'prosemirror-view';
+/**
+ * Reflects the selection in the toggle-style Home buttons: which alignment applies (only when every
+ * selected paragraph agrees), whether the selection is a bulleted or numbered list, and which
+ * clipboard commands have something to act on.
+ */
+export declare function syncParagraphToggles(toolbar: HTMLElement, view: EditorView, model: DocumentModel): void;

package/dist/docx/parts-controller.d.ts

@@ -0,0 +1,52 @@
+import { type Plugin } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+import type { EditorHost } from './editor-host';
+import { type HeaderFooterSlotName } from './header-footer-editor';
+import { type ImageMediaCache } from './image-media';
+import { type NoteKind } from './note-commands';
+import type { HeaderFooterContext } from './header-footer-ribbon';
+export interface PartsControllerHost extends EditorHost {
+    images(): ImageMediaCache;
+    /** Plugins shared with in-place editors (e.g. Ctrl+K). */
+    plugins(): Plugin[];
+    /** Where focus may go without closing an in-place editor: the ribbon and dialogs. */
+    keepOpenWithin(): (Element | undefined)[];
+    sectionIndex?(): number;
+    refreshControls?(): void;
+}
+/** Headers, footers, footnotes and endnotes around the continuous editing surface. */
+export declare class PartsController {
+    private readonly host;
+    private headerEl?;
+    private footerEl?;
+    private notesEl?;
+    private active?;
+    private closeActive?;
+    private headerContext?;
+    private shownSection;
+    private renderingContext?;
+    constructor(host: PartsControllerHost);
+    /** The in-place header/footer/note editor currently open, which the ribbon then targets. */
+    activeView(): EditorView | undefined;
+    /** Page-number insertion follows the first/even/default story currently being edited. */
+    activeHeaderFooterSlot(): HeaderFooterSlotName | undefined;
+    headerFooterContext(): HeaderFooterContext | undefined;
+    closeHeaderFooter(canvas?: HTMLElement, paper?: HTMLElement): void;
+    navigate(target: 'header' | 'footer' | 'previous' | 'next', canvas?: HTMLElement, paper?: HTMLElement): void;
+    toggleLink(): void;
+    /** Sets picture sources in a read-only preview from the package media. */
+    private readonly decorate;
+    private editorOptions;
+    /** Header/footer typing and insertion use the body history; notes retain their local stack. */
+    runHistory(key: 'undo' | 'redo'): boolean;
+    usesBodyHistory(): boolean;
+    syncSection(canvas?: HTMLElement, paper?: HTMLElement): void;
+    /** Rebuilds the header/footer/note previews and wires in-place editing. */
+    render(canvas: HTMLElement | undefined, paper: HTMLElement | undefined, keepEditor?: boolean): void;
+    /** Inserts a footnote or endnote reference at the selection and opens the new note for typing. */
+    insertNote(kind: NoteKind, canvas?: HTMLElement, paper?: HTMLElement): void;
+    /** Replaces one footnote's or endnote's blocks. */
+    private updateNote;
+    /** Applies header/footer edits to every section slot that shares the edited part. */
+    private updateHeaderFooter;
+}

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

@@ -0,0 +1,35 @@
+import type { EditorView } from 'prosemirror-view';
+import type { InlineImage, PendingMediaPart } from 'ooxml-core/docx';
+/** Raster formats Word stores directly; SVG would need a PNG fallback part, which is not produced. */
+export declare const PICTURE_TYPES: Record<string, string>;
+/** A package part name for a newly inserted picture that cannot collide with existing media. */
+export declare function newPicturePartName(contentType: string): string;
+/** Scales `width`×`height` down (never up) to fit `maxWidth`, keeping the aspect ratio. */
+export declare function fitPicture(width: number, height: number, maxWidth: number): {
+    widthPx: number;
+    heightPx: number;
+};
+/** Reads a Blob's bytes, falling back to FileReader where `Blob.arrayBuffer` is unavailable. */
+export declare function readBytes(file: Blob): Promise<Uint8Array>;
+/** Reads a picture's natural pixel size in the browser. */
+export declare function pictureSize(file: Blob): Promise<{
+    width: number;
+    height: number;
+}>;
+/** Prepares an inline picture and the media bytes that must be written with it on save. */
+/** Draws an SVG to a PNG (Word keeps a raster fallback beside every SVG picture). */
+export declare function rasterizeSvg(svg: Uint8Array): Promise<{
+    png: Uint8Array;
+    width: number;
+    height: number;
+}>;
+export interface StagedPicture {
+    image: InlineImage;
+    media: PendingMediaPart;
+    /** For SVG pictures: the SVG original, stored alongside the PNG fallback in `media`. */
+    svg?: PendingMediaPart;
+}
+/** Prepares an inline picture and the media bytes that must be written with it on save. */
+export declare function stagePicture(file: File, maxWidthPx: number): Promise<StagedPicture>;
+/** Inserts an inline picture at the selection, replacing any selected content. */
+export declare function insertPicture(view: EditorView, image: InlineImage): boolean;

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

@@ -0,0 +1,11 @@
+import type { EditorView } from 'prosemirror-view';
+import { type EditorLocale } from './localization';
+export interface PictureDialog {
+    element: HTMLElement;
+    open(pos: number): void;
+    close(): void;
+    setLocale(locale: EditorLocale): void;
+    readonly isOpen: boolean;
+}
+/** Word's Format Picture essentials: alt text and size (px) with an aspect-ratio lock. */
+export declare function createPictureDialog(getView: () => EditorView | undefined): PictureDialog;

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

@@ -0,0 +1,6 @@
+import { DecorationSet } from 'prosemirror-view';
+import type { EditorState } from 'prosemirror-state';
+import { type EditorLocale } from './localization';
+import type { PeerPresence } from './presence';
+/** Inline selection highlights and labelled cursors for remote peers. */
+export declare function peerDecorations(doc: EditorState['doc'], peers: Map<string, PeerPresence>, locale: EditorLocale): DecorationSet;

package/dist/docx/presence.d.ts

@@ -0,0 +1,63 @@
+import { DecorationSet } from 'prosemirror-view';
+import { Plugin, type EditorState, type Transaction } from 'prosemirror-state';
+import type { EditorLocale } from './localization';
+export declare const PRESENCE_PALETTE: readonly ['#2563eb', '#c2410c', '#15803d', '#a21caf', '#0e7490', '#b91c1c', '#4f46e5', '#a16207'];
+export declare function validatePresenceProfile(profile: {
+    name: string;
+    color: string;
+}): {
+    name: string;
+    color: string;
+};
+export interface PresenceConfig {
+    sessionId: string;
+    clientId: string;
+    /** Display locale of peer labels; English when omitted. */
+    locale?: () => EditorLocale;
+}
+export interface PresenceMessage {
+    protocol: 1;
+    sessionId: string;
+    clientId: string;
+    kind: 'selection' | 'leave';
+    sequence: number;
+    version: number;
+    name?: string;
+    color?: string;
+    anchor?: number;
+    head?: number;
+}
+export type PresenceReceiveResult = {
+    status: 'applied';
+    transaction: Transaction;
+} | {
+    status: 'duplicate' | 'stale' | 'out-of-order' | 'wrong-session' | 'invalid';
+    reason?: string;
+};
+export interface PeerPresence {
+    clientId: string;
+    name: string;
+    color: (typeof PRESENCE_PALETTE)[number];
+    anchor: number;
+    head: number;
+    fingerprint: string;
+    sequence: number;
+}
+/** A no-op transaction that makes the presence plugin recompute its localized labels. */
+export declare function refreshPresenceLabels(state: EditorState): Transaction;
+export declare function getPresenceDecorations(state: EditorState, locale?: EditorLocale): DecorationSet;
+/** Transient selection sharing for a host-provided transport; it does not send data itself. */
+export declare class PresenceClient {
+    readonly plugin: Plugin;
+    readonly sessionId: string;
+    readonly clientId: string;
+    private readonly received;
+    private sequence;
+    constructor(config: PresenceConfig);
+    publish(state: EditorState, profile: {
+        name: string;
+        color: string;
+    }): PresenceMessage | null;
+    leave(state: EditorState): PresenceMessage;
+    receive(state: EditorState, input: unknown): PresenceReceiveResult;
+}

package/dist/docx/preview-run-styles.d.ts

@@ -0,0 +1,4 @@
+import { type Block, type DocumentModel } from 'ooxml-core/docx';
+import { DOMSerializer } from 'prosemirror-model';
+/** Read-only story previews resolve styles for display without changing the source runs. */
+export declare function stylePreviewRuns(element: HTMLElement, block: Block, model: DocumentModel, serializer: DOMSerializer): void;

package/dist/docx/preview-scale-fonts.d.ts

@@ -0,0 +1,3 @@
+import type { RunFormatting } from 'ooxml-core/docx';
+/** Closed previews have no editor lifecycle. Keep only weak element references while fonts load. */
+export declare function refreshPreviewScaleWithFonts(element: HTMLElement, text: string, formatting: RunFormatting, family: string | undefined): void;

package/dist/docx/print-fragment-hit.d.ts

@@ -0,0 +1,7 @@
+import type { LayoutFragment } from 'ooxml-core/docx/layout';
+export interface PrintFragmentHit {
+    element: HTMLElement;
+    fragment: LayoutFragment;
+}
+/** Returns undefined for old layout results that do not include fragment source ranges. */
+export declare function resolveFragmentClick(fragments: PrintFragmentHit[], clientX: number): number | undefined;

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

@@ -0,0 +1,28 @@
+import { type DocumentModel, type HeaderFooterContent, type TextRun } from 'ooxml-core/docx';
+import { type LayoutPageBox } from 'ooxml-core/docx/layout';
+import type { PictureUrl } from './print-layout';
+/** Page facts a header or footer field can show. */
+export interface PageFieldValues {
+    page: string;
+    numPages: string;
+    sectionPages: string;
+    /** When the layout was produced; DATE and TIME fields update to it, as Word updates them. */
+    now?: Date;
+    /** Resolves header/footer pictures to displayable URLs. */
+    pictureUrl?: PictureUrl;
+}
+/** Word page numbers per laid-out page, honoring each section's restart value and number format. */
+export declare function pageNumbers(model: DocumentModel, pages: LayoutPageBox[]): string[];
+/**
+ * The header or footer Word shows on a page: the first-page slot on a section's first page when
+ * `titlePg` is set, the even slot on even pages when `evenAndOddHeaders` is on, else the default.
+ * Sections without their own reference inherit the previous section's.
+ */
+export declare function headerFooterForPage(model: DocumentModel, page: LayoutPageBox, pageNumber: number, kind: 'headers' | 'footers'): HeaderFooterContent | undefined;
+/** Recalculates page fields; other fields keep the result Word last saved. */
+export declare function fieldDisplayText(run: TextRun, values: PageFieldValues): string;
+/** Renders read-only header/footer content with page fields filled in for one page. */
+export declare function renderHeaderFooter(content: HeaderFooterContent, values: PageFieldValues, kind: 'header' | 'footer'): HTMLElement;
+/** The header's text watermark as a centered, rotated layer behind the page text, or null. */
+export declare function watermarkElement(content: HeaderFooterContent, page: Pick<LayoutPageBox, 'widthPx' | 'heightPx'>): HTMLElement | null;
+export declare function decoratePages(model: DocumentModel, pages: LayoutPageBox[], sheets: HTMLElement[], now?: Date, pictureUrl?: PictureUrl): void;

package/dist/docx/print-layout-cursor.d.ts

@@ -0,0 +1,9 @@
+import type { EditorView } from 'prosemirror-view';
+/**
+ * Maps a Print Layout click (`{ blockId, offset }`, from `print-layout.ts`'s
+ * `resolveClick`) back to a ProseMirror document position: finds the
+ * paragraph node whose `id` attribute matches, then clamps `offset` into its
+ * content. Print Layout resolves the fragment/glyph boundary first; this
+ * function clamps it to a valid editor position before focusing the editor.
+ */
+export declare function moveCursorToBlock(view: EditorView, blockId: string, offset: number): boolean;