nuvra 0.4.1 → 0.6.0

package/dist/components/editor-slash-menu.vue.d.ts

@@ -0,0 +1,13 @@
+import type { DocumentEngine } from '../core/engine/engine';
+import { type SlashCommand } from '../core/slash-commands';
+interface Props {
+    /** Engine the commands run on. */
+    engine: DocumentEngine;
+    /** Every command the menu offers. */
+    commands: readonly SlashCommand[];
+    /** Element the menu is positioned in; it must be positioned itself. */
+    container: HTMLElement;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/editor-toolbar.vue.d.ts

@@ -1,5 +1,6 @@
 import type { DocumentEngine } from '../core/engine/engine';
 import { type PageSettings } from '../core/page';
+import type { TemplateVariable } from '../core/templates';
 import type { DocumentMenuAction } from '../core/types';
 import { type EditorUiState } from '../core/ui-state';
 interface Props {
@@ -13,6 +14,16 @@ interface Props {
     fullscreen: boolean;
     /** Whether the formatting marks (pilcrows) are shown in the document. */
     marksVisible: boolean;
+    /** Whether the navigation panel with the headings is open. */
+    outlineVisible: boolean;
+    /** Whether the host keeps comments (`v-model:comments`); the comment buttons are hidden otherwise. */
+    commentsEnabled: boolean;
+    /** Whether the comments panel is open. */
+    commentsVisible: boolean;
+    /** Whether edits are recorded as tracked changes. */
+    trackChanges: boolean;
+    /** Whether the tracked changes panel is open. */
+    changesVisible: boolean;
     /** Current page settings, edited in the page setup popover. */
     page: PageSettings;
     /** Whether the ruler is shown above the sheet. */
@@ -23,8 +34,14 @@ interface Props {
     state: EditorUiState;
     /** Whether images are being uploaded, shown on the upload button. */
     uploading: boolean;
+    /** Template variables offered by the variable menu; the menu is hidden without any. */
+    variables: ReadonlyArray<TemplateVariable>;
 }
-declare const __VLS_export: import("vue").DefineComponent<Props, {
+declare var __VLS_626: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_626) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {
     /** Opens the link popover. */
     openLink: () => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
@@ -38,5 +55,11 @@ declare const __VLS_export: import("vue").DefineComponent<Props, {
     onInsertImages?: ((files: File[]) => any) | undefined;
     "onUpdate:page"?: ((page: PageSettings) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/collaboration.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Hooks for editing a document together. The editor reports where the caret is and draws the carets and selections
+ * of other people; sending the document and the selections between them (WebSocket, WebRTC, a CRDT such as Yjs) is
+ * left to the application.
+ */
+/** A selection as character positions through the document; equal positions are a caret. */
+export interface SelectionOffsets {
+    /** Where selecting started. */
+    anchor: number;
+    /** Where the caret is. */
+    focus: number;
+}
+/** Someone else editing the same document. */
+export interface Collaborator {
+    /** Stable id of the person or connection. */
+    id: string;
+    /** Name shown next to the caret. */
+    name: string;
+    /** CSS colour of the caret and the selection; one is picked from the id when it is left out. */
+    color?: string;
+    /** Where the person's caret or selection is, or `null` while they are not in the document. */
+    selection: SelectionOffsets | null;
+}
+/** The colour of a collaborator: their own, or a stable one derived from the id. */
+export declare const collaboratorColor: (collaborator: Pick<Collaborator, "id" | "color">) => string;

package/dist/core/comments.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Comments on parts of a document. The document HTML only keeps the anchors, `<span data-comment="id">`; the comments
+ * themselves are plain data the host stores next to the document with `v-model:comments`.
+ */
+/** A reply in the thread of a comment. */
+export interface DocumentCommentReply {
+    /** Unique id of the reply. */
+    id: string;
+    /** Text of the reply. */
+    text: string;
+    /** Name of the person who wrote it, when the host knows it. */
+    author?: string;
+    /** When it was written, as an ISO 8601 string. */
+    createdAt: string;
+}
+/** A comment anchored to a span of the document text. */
+export interface DocumentComment extends DocumentCommentReply {
+    /** Whether the discussion is closed; resolved comments keep their anchor but are not highlighted. */
+    resolved?: boolean;
+    /** Replies in the order they were written. */
+    replies?: DocumentCommentReply[];
+}
+/** A new random id for a comment or a reply, usable as an HTML attribute value. */
+export declare const createCommentId: () => string;
+/** Comments in the order their anchors appear in the document; comments whose text was deleted come last. */
+export declare const sortComments: (comments: readonly DocumentComment[], anchoredIds: readonly string[]) => DocumentComment[];

package/dist/core/dates.d.ts

@@ -0,0 +1,8 @@
+import type { NumberWordsLocale } from './numbers';
+/** A date as `dd.mm.yyyy`, the short form of Uzbek and Russian documents. */
+export declare const formatShortDate: (date: Date) => string;
+/**
+ * A date written out as official documents do: `2026-yil 14-sentabr`, `2026 йил 14 сентябрь`, `14 сентября 2026 г.`
+ * or `14 September 2026`.
+ */
+export declare const formatLongDate: (date: Date, locale?: NumberWordsLocale) => string;

package/dist/core/diff.d.ts

@@ -0,0 +1,11 @@
+/** What changed between two versions. */
+export interface DocumentComparison {
+    /** Display HTML of the new version with insertions and deletions marked. */
+    html: string;
+    /** Number of inserted words, and of words in inserted blocks. */
+    insertions: number;
+    /** Number of deleted words, and of words in deleted blocks. */
+    deletions: number;
+}
+/** Compares two versions of a document and marks what was inserted and deleted in the new one. */
+export declare const compareDocuments: (before: string, after: string) => DocumentComparison;

package/dist/core/document-templates.d.ts

@@ -0,0 +1,22 @@
+import type { EditorLabelKey, EditorLocaleCode } from './labels';
+import type { TemplateVariable } from './templates';
+/** Built-in document templates. */
+export type DocumentTemplateId = 'letter' | 'order' | 'application' | 'certificate' | 'act';
+/** A document template ready to be inserted into the editor. */
+export interface DocumentTemplate {
+    /** Template identifier. */
+    id: DocumentTemplateId;
+    /** Document HTML with template variables. */
+    html: string;
+    /** Variables the template uses, with labels in the requested language. */
+    variables: TemplateVariable[];
+}
+/** Every built-in template with its menu label, in the order the menu lists them. */
+export declare const DOCUMENT_TEMPLATES: ReadonlyArray<{
+    id: DocumentTemplateId;
+    label: EditorLabelKey;
+}>;
+/** Label of a built-in template variable in the editor's language, or `undefined` for other names. */
+export declare const templateVariableLabel: (name: string, locale: EditorLocaleCode) => string | undefined;
+/** A built-in document template in the editor's language, with the variables it uses. */
+export declare const getDocumentTemplate: (id: DocumentTemplateId, locale?: EditorLocaleCode) => DocumentTemplate;

package/dist/core/docx/export.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Writes the document as a real Word file (Office Open XML, `.docx`): paragraphs and headings with their alignment,
+ * indents and spacing, character formatting, links, lists, tables with merged cells, images, page breaks, the page
+ * setup, headers and footers with page fields, and the watermark.
+ */
+import { type PageSettings } from '../page';
+/** What the Word writer needs to know about the document. */
+export interface DocxSource {
+    /** Clean document HTML as saved by the editor. */
+    html: string;
+    /** Document title, stored in the file properties and used by the `{title}` token. */
+    title: string;
+    /** Page size, orientation, margins, running texts and watermark. */
+    page: PageSettings;
+}
+/** MIME type of Word documents. */
+export declare const DOCX_MIME = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+/** Builds a `.docx` file of the document. Images are embedded from data URLs or fetched from their address. */
+export declare const buildDocx: ({ html, title, page }: DocxSource) => Promise<Blob>;

package/dist/core/docx/import.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Reads a Word document (`.docx`) into editor HTML: paragraphs and headings with alignment, indents and spacing,
+ * character formatting, links, lists, tables with merged cells, images, page breaks, the page setup and the header
+ * and footer texts. The result still passes through the editor's sanitiser.
+ */
+import { type PageSettings } from '../page';
+/** What was read from a Word document. */
+export interface DocxImport {
+    /** Document content as HTML. */
+    html: string;
+    /** Page setup of the document's last section. */
+    page: PageSettings;
+}
+/**
+ * Reads a `.docx` file into editor HTML and page settings.
+ *
+ * @throws Error when the file is not a Word document.
+ */
+export declare const readDocx: (data: ArrayBuffer | Uint8Array) => Promise<DocxImport>;

package/dist/core/docx/zip.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimal ZIP container support for Office documents, without dependencies: writing stores files uncompressed, which
+ * every ZIP reader (Word included) accepts; reading also inflates deflated entries with the browser's
+ * `DecompressionStream`.
+ */
+/** A file inside a ZIP archive. */
+export interface ZipEntry {
+    /** Path inside the archive, with forward slashes. */
+    name: string;
+    /** File content. */
+    data: Uint8Array;
+}
+/** CRC-32 checksum of the data. */
+export declare const crc32: (data: Uint8Array) => number;
+/** Packs files into an uncompressed ZIP archive. */
+export declare const createZip: (entries: ZipEntry[]) => Uint8Array;
+/**
+ * Reads every file of a ZIP archive. Stored and deflated entries are supported, which covers the files Office and
+ * other editors write.
+ *
+ * @throws Error when the data is not a ZIP archive or uses an unsupported compression method.
+ */
+export declare const readZip: (buffer: ArrayBuffer | Uint8Array) => Promise<Map<string, Uint8Array>>;

package/dist/core/engine/dom.d.ts

@@ -3,8 +3,25 @@
  * the editor root, element factories and the small structural fixes (caret placeholders, mark merging) that keep the
  * editable markup predictable.
  */
-/** Selector for blocks without editable text inside: rules, images and page breaks. */
-export declare const ATOM_SELECTOR = "hr, img, div[data-type=\"page-break\"]";
+/** Attribute naming the template variable of a variable chip. */
+export declare const VARIABLE_ATTRIBUTE = "data-variable";
+/** Selector for template variable chips: inline atoms that hold no text in the editor. */
+export declare const VARIABLE_SELECTOR = "span[data-variable]";
+/** Attribute holding the text of a footnote on its reference mark. */
+export declare const FOOTNOTE_ATTRIBUTE = "data-footnote";
+/** Selector for footnote references: inline atoms numbered by the editor, their note text in the attribute. */
+export declare const FOOTNOTE_SELECTOR = "sup[data-footnote]";
+/** Selector for every inline atom: elements inside a line that behave as one character and hold no editable text. */
+export declare const INLINE_ATOM_SELECTOR = "span[data-variable], sup[data-footnote]";
+/** Selector for blocks without editable text inside: rules, images, page breaks and section breaks. */
+export declare const ATOM_SELECTOR = "hr, img, div[data-type=\"page-break\"], div[data-type=\"section-break\"]";
+/** Whether a `<div>` is one of the break blocks the document model keeps: a page break or a section break. */
+export declare const isBreakBlock: (node: Node | null | undefined) => boolean;
+/**
+ * Creates a section break: the sheets after it are turned to `orientation`. It also starts a new sheet, so it is drawn
+ * and printed like a page break.
+ */
+export declare const createSectionBreak: (orientation: "portrait" | "landscape") => HTMLDivElement;
 /** Selector for blocks that hold editable inline text. */
 export declare const TEXT_BLOCK_SELECTOR = "p, h1, h2, h3, h4, h5, h6, pre";
 /** Marks the extra `<br>` that keeps an empty or break-terminated line visible; it is never serialised. */
@@ -17,6 +34,12 @@ export declare const isText: (node: Node | null | undefined) => node is Text;
 export declare const isTextBlock: (node: Node | null | undefined) => node is HTMLElement;
 /** Whether the node is an ordered or unordered list. */
 export declare const isList: (node: Node | null | undefined) => node is HTMLElement;
+/** Whether the node is a template variable chip. */
+export declare const isVariable: (node: Node | null | undefined) => node is HTMLElement;
+/** Whether the node is a footnote reference. */
+export declare const isFootnote: (node: Node | null | undefined) => node is HTMLElement;
+/** Whether the node is an inline atom: a variable chip or a footnote reference. */
+export declare const isInlineAtom: (node: Node | null | undefined) => node is HTMLElement;
 /** Whether the node is a block without editable text (rule, image, page break). */
 export declare const isAtom: (node: Node | null | undefined) => node is HTMLElement;
 /** Whether the node is a `<br>`, placeholder or real. */
@@ -31,13 +54,25 @@ export declare const closestTag: (node: Node | null | undefined, root: HTMLEleme
 export declare const closestTextBlock: (node: Node | null | undefined, root: HTMLElement) => HTMLElement | null;
 /** Creates an element with attributes and children in one call. */
 export declare const createElement: <K extends keyof HTMLElementTagNameMap>(tag: K, attributes?: Record<string, string>, children?: Array<Node | string>) => HTMLElementTagNameMap[K];
+/**
+ * Creates the chip of a template variable. It holds no text, so formatting and caret positions treat it as one
+ * character; its label is drawn by CSS from `data-label`, and serialising writes `{{name}}` into it.
+ */
+export declare const createVariable: (name: string) => HTMLSpanElement;
+/** Longest footnote text kept, in characters. */
+export declare const MAX_FOOTNOTE_LENGTH = 2000;
+/**
+ * Creates a footnote reference. Like a variable chip it holds no text in the editor: CSS draws its number, and
+ * serialising writes the number into it so saved HTML reads correctly anywhere.
+ */
+export declare const createFootnote: (text: string) => HTMLElement;
 /** Creates the placeholder `<br>` that gives empty lines their height. */
 export declare const createTrailingBreak: () => HTMLBRElement;
 /** Creates a paragraph with the given inline content and the placeholder break it needs. */
 export declare const createParagraph: (children?: Node[]) => HTMLParagraphElement;
 /** Whether the element contains text, an image or a real line break. */
 export declare const hasVisibleContent: (element: Element) => boolean;
-/** Whether a text block has no text and no image, holding at most one break. */
+/** Whether a text block has no text, image or inline atom, holding at most one break. */
 export declare const isEmptyTextBlock: (block: Element) => boolean;
 /**
  * Keeps exactly one placeholder `<br>` where the browser needs it: in empty blocks and after a user line break at the
@@ -56,6 +91,8 @@ export declare const mergeAdjacentMarks: (scope: HTMLElement) => void;
 export declare const textBlocksWithin: (scope: ParentNode) => HTMLElement[];
 /** Text blocks touched by the range, in document order. */
 export declare const textBlocksInRange: (root: HTMLElement, range: Range) => HTMLElement[];
+/** Whether a range covers no text, image, variable or real line break. */
+export declare const isVisuallyEmpty: (range: Range) => boolean;
 /** Whether nothing visible precedes the point inside its block. */
 export declare const isAtBlockStart: (block: HTMLElement, container: Node, offset: number) => boolean;
 /** Whether nothing visible follows the point inside its block. */

package/dist/core/engine/editing.d.ts

@@ -32,6 +32,17 @@ export declare const splitAtCaret: (root: HTMLElement, range: Range) => Caret |
 export declare const insertLineBreak: (root: HTMLElement, range: Range) => Caret | null;
 /** Inserts plain text at a collapsed range, creating a paragraph if the caret sits between blocks. */
 export declare const insertTextAtCaret: (root: HTMLElement, range: Range, text: string) => Caret;
+/**
+ * Inserts an inline atom (a variable chip or a footnote reference) at a collapsed range, creating a paragraph if the caret sits between
+ * blocks. Code blocks hold plain text only, so nothing is inserted there.
+ * @returns the caret right after the element, or `null` when it could not be inserted.
+ */
+export declare const insertInlineAtCaret: (root: HTMLElement, range: Range, element: HTMLElement) => Caret | null;
+/**
+ * Inline atom (variable chip or footnote reference) right before (`backward`) or right after the collapsed caret, with
+ * nothing visible in between, so Backspace and Delete remove it as one character in every browser.
+ */
+export declare const adjacentInlineAtom: (root: HTMLElement, range: Range, backward: boolean) => HTMLElement | null;
 /**
  * Pastes sanitised blocks at a collapsed range. A single paragraph flows into the current line; several blocks
  * split the current block, with the first and last pasted paragraphs merging into its halves as in Word.

package/dist/core/engine/engine.d.ts

@@ -1,10 +1,26 @@
+import { type OutlineHeading } from '../outline';
+import { type TransliterationDirection } from '../transliterate';
 import { type EditorUiState } from '../ui-state';
 import { type HeadingTag, type ParagraphIndents, type SpacingSide, type TextAlign, type TextDirection } from './blocks';
 import { EditorHistory } from './history';
 import { type ListKind } from './lists';
 import { type MarkName, type StyleName, type TextCase } from './marks';
 import { SearchController, type SearchState } from './search';
+import { type TextBookmark } from './selection';
 import { type TableCell } from './tables';
+/** A tracked insertion or deletion; the parts of one edit are joined. */
+export interface TrackedChange {
+    /** Id shared by the parts of the edit. */
+    id: string;
+    /** Whether text was inserted or deleted. */
+    type: 'insert' | 'delete';
+    /** Name of the author; may be empty. */
+    author: string;
+    /** When the change was made, as an ISO 8601 string. */
+    time: string;
+    /** Inserted or deleted text. */
+    text: string;
+}
 /** Settings the host component passes when it creates the engine. */
 interface DocumentEngineOptions {
     /** Initial HTML; it is sanitised before it reaches the DOM. */
@@ -17,6 +33,11 @@ interface DocumentEngineOptions {
     placeholder: () => string;
     /** Receives image files pasted or dropped into the document; the selection is already at the target. */
     onImageFiles: (files: File[]) => void;
+    /**
+     * Label a template variable chip shows, or `undefined` for a name the host does not know. Called on every refresh,
+     * so labels follow the host's variable list and locale; typed `{{name}}` becomes a chip only for known names.
+     */
+    variableLabel?: (name: string) => string | undefined;
 }
 /** Events emitted by the engine, mapped to their payloads. */
 interface EngineEvents {
@@ -100,6 +121,10 @@ export declare class DocumentEngine {
     private selectedImageElement;
     /** Formatting the format painter carries until it is painted onto a selection. */
     private painterFormat;
+    /** Author of tracked changes while changes are tracked, otherwise `null`. */
+    private trackingAuthor;
+    /** Change the running typing group adds to, so typed characters form one insertion. */
+    private typingChange;
     /**
      * Takes over `root` as the editable document, loads the initial content and starts listening to its events.
      *
@@ -138,10 +163,23 @@ export declare class DocumentEngine {
      * @param options.addToHistory Record the replacement as an undo step instead of clearing the history.
      * @param options.emitUpdate Emit `update` so the host saves the new content.
      */
-    setContent(html: string, { addToHistory, emitUpdate }?: {
+    setContent(html: string, { addToHistory, emitUpdate, keepSelection }?: {
         addToHistory?: boolean | undefined;
         emitUpdate?: boolean | undefined;
+        keepSelection?: boolean | undefined;
     }): void;
+    /**
+     * The selection as character positions through the document: `anchor` where selecting started, `focus` where the
+     * caret is. Positions survive changes to the markup, so they can be sent to other people editing the document.
+     */
+    getSelectionOffsets(): TextBookmark | null;
+    /**
+     * Viewport rectangles of the text between two character positions, for drawing someone else's selection; a
+     * collapsed position gives the rectangle of its caret line with no width.
+     */
+    getOffsetRects(offsets: TextBookmark): DOMRect[];
+    /** Number of character positions in the document, the largest offset a selection can have. */
+    private characterPositions;
     /** Switches between editing and read-only mode. */
     setEditable(editable: boolean): void;
     /** Word and character counts of the document text. */
@@ -173,7 +211,7 @@ export declare class DocumentEngine {
     private currentRange;
     /** Captures the document markup and selection for the undo history. */
     private snapshot;
-    /** Updates the placeholder state and search results, then notifies listeners. */
+    /** Updates the placeholder state, variable labels and search results, then notifies listeners. */
     private refresh;
     /**
      * Runs one edit as an undo step, then normalises the document and restores the selection by text position.
@@ -187,12 +225,38 @@ export declare class DocumentEngine {
     private finishEdit;
     /** Records an undo step for a change that does not depend on the selection (checkboxes, image attributes). */
     private mutate;
-    /** Deletes the selected content, if any, and returns a collapsed range where it started. */
+    /**
+     * Deletes the selected content, if any, and returns a collapsed range where the new content goes: where the selection
+     * started, or after the text marked as deleted while changes are tracked.
+     */
     private collapsedAfterDelete;
     /** Deletes the selection as one undo step and leaves a collapsed caret where it started. */
     private deleteSelection;
+    /** Whether edits are recorded as tracked changes. */
+    get tracksChanges(): boolean;
+    /** Starts or stops recording typing, deleting and pasting as tracked changes by `author`. */
+    setTrackChanges(enabled: boolean, author?: string): void;
+    /** A change mark for the next edit; typing keeps adding to one change until the caret moves. */
+    private nextChange;
+    /**
+     * Marks a range as deleted and returns a caret at its start or after it. A marker element keeps the end position
+     * while own insertions inside the range are removed for real.
+     */
+    private deleteTracked;
+    /** Moves a caret that sits inside deleted text to its end, so new text never becomes part of a deletion. */
+    private outsideDeletion;
+    /** Marks the text between two document positions as inserted by the tracking author. */
+    private markInsertedBetween;
+    /** Tracked insertions and deletions in document order, the parts of one edit grouped by id and kind. */
+    getChanges(): TrackedChange[];
+    /** Accepts (`true`) or rejects the tracked changes with the given id, or every change without one, as an undo step. */
+    resolveChanges(accept: boolean, id?: string): void;
+    /** Selects the text of a tracked change and scrolls it into view. */
+    selectChange(id: string): void;
     /** Number of characters in the document text. */
     private characterCount;
+    /** Text of every block as the document reads once its tracked changes are accepted: deleted text is left out. */
+    private blockTexts;
     /** Whether adding `extra` characters would exceed the configured maximum length. */
     private exceedsLimit;
     /** Remembers the selection; a selection moved by the user drops pending formatting and ends the typing group. */
@@ -206,6 +270,13 @@ export declare class DocumentEngine {
     private handleTextInput;
     /** Deletes selections and joins blocks at their edges itself; single characters are deleted natively. */
     private handleDeleteInput;
+    /**
+     * Marks the character, word or line next to the caret as deleted. Text that is already marked as deleted is
+     * stepped over, as in Word, instead of being deleted again.
+     */
+    private deleteTrackedAtCaret;
+    /** The range from a caret to the next character, word or line boundary in one direction. */
+    private extendCaret;
     /** Repairs the structure after a native edit and applies Markdown and typography rules to typed text. */
     private onInput;
     /** Browsers occasionally leave text outside paragraphs or a <div> after native edits; fix it in place. */
@@ -260,6 +331,13 @@ export declare class DocumentEngine {
     private restoreSnapshot;
     /** Inserts plain text at the selection, replacing selected content and applying pending formatting. */
     insertText(text: string): void;
+    /** Text of the current block before a collapsed caret, or `null` when the selection is not a caret in text. */
+    getTextBeforeCaret(): string | null;
+    /**
+     * Deletes the characters right before a collapsed caret, as one undo step; used by typed triggers such as the
+     * `/` command menu to remove what was typed.
+     */
+    deleteBeforeCaret(count: number): void;
     /** Formatting at the start of a range, or `null` when the text there is unformatted. */
     private captureFormat;
     /**
@@ -277,6 +355,15 @@ export declare class DocumentEngine {
     private setPending;
     /** Changes the letter case of the selected text. */
     changeTextCase(mode: TextCase): void;
+    /** Converts Uzbek text between the Latin and Cyrillic alphabet: the selection, or the whole document at a caret. */
+    transliterate(direction: TransliterationDirection): void;
+    /**
+     * Rewrites the amount that is selected, or the number right before the caret, with `format`; used to add an amount
+     * in words. Nothing changes when the text there is not an amount.
+     *
+     * @returns whether an amount was found and rewritten.
+     */
+    replaceAmount(format: (value: number) => string): boolean;
     /** Stores the format the painter carries and shows the painting cursor while it does. */
     private setPainterFormat;
     /**
@@ -308,6 +395,11 @@ export declare class DocumentEngine {
     setTextDirection(direction: TextDirection): void;
     /** Turns the selected blocks into a list of the given kind, converts another list kind, or lifts them out. */
     toggleList(kind: ListKind): void;
+    /**
+     * Switches the numbered list at the selection, together with its nested lists, between simple (1, 2, 3) and legal
+     * (1.1, 1.2) numbering. The setting lives on the outermost numbered list.
+     */
+    setListNumbering(style: 'default' | 'legal'): void;
     /** List items are nested or lifted; other paragraphs get indentation steps. */
     indent(direction: 1 | -1): void;
     /**
@@ -317,8 +409,74 @@ export declare class DocumentEngine {
     private insertBlock;
     /** Inserts a horizontal rule. */
     insertHorizontalRule(): void;
+    /** Inserts a section break: the sheets after it are turned to `orientation`, for example for a wide table. */
+    insertSectionBreak(orientation: 'portrait' | 'landscape'): void;
     /** Inserts a manual page break. */
     insertPageBreak(): void;
+    /**
+     * Inserts sanitised HTML at the selection as one undo step. By default it flows into the current line the way pasting
+     * does; with `asBlocks` the content starts on a line of its own after a non-empty paragraph, as prepared fragments
+     * such as signature blocks and document templates should.
+     */
+    insertContent(html: string, { asBlocks }?: {
+        asBlocks?: boolean | undefined;
+    }): void;
+    /** Headings written directly in the document, in document order, down to the given level. */
+    getOutline(depth?: number): OutlineHeading[];
+    /** Whether the document has a table of contents. */
+    get hasTableOfContents(): boolean;
+    /**
+     * Writes a table of contents: an existing one is replaced in place, keeping the selection, otherwise the table is
+     * inserted at the selection. Without `addToHistory` a replacement joins the previous undo step, e.g. when page
+     * numbers are corrected right after inserting the table.
+     */
+    setTableOfContents(html: string, { addToHistory }?: {
+        addToHistory?: boolean | undefined;
+    }): void;
+    /** Scrolls a heading to the top of the view and puts the caret at its start. */
+    goToHeading(heading: HTMLElement): void;
+    /**
+     * Inserts a footnote reference with its text at the selection, replacing selected content, as one undo step.
+     * @returns the new reference, or `null` when nothing could be inserted (for example in a code block).
+     */
+    insertFootnote(text: string): HTMLElement | null;
+    /** Changes the text of a footnote as one undo step; unchanged text records nothing. */
+    setFootnoteText(reference: HTMLElement, text: string): void;
+    /** Removes a footnote reference together with its note, as one undo step. */
+    removeFootnote(reference: HTMLElement): void;
+    /** Footnote references with their texts, in document order; the first one is number 1. */
+    getFootnotes(): Array<{
+        element: HTMLElement;
+        text: string;
+    }>;
+    /**
+     * Anchors a new comment to the selected text as one undo step.
+     * @returns whether text was selected and the id is valid.
+     */
+    addComment(id: string): boolean;
+    /** Removes the anchors of a comment, keeping their text, as one undo step. */
+    removeComment(id: string): void;
+    /** Ids of the comments anchored in the document, each once, in document order. */
+    getCommentIds(): string[];
+    /** Ids of the comments anchored around the caret or the start of the selection, innermost first. */
+    getCommentsAtSelection(): string[];
+    /** Selects the text of a comment and scrolls it into view. */
+    selectComment(id: string): void;
+    /**
+     * Shows resolved comments without their highlight and marks the active one. Only classes change, which saved HTML
+     * drops, so this is neither an edit nor an undo step.
+     */
+    decorateComments(resolved: ReadonlySet<string>, active: string | null): void;
+    /** Anchor elements of one comment, in document order. */
+    private commentAnchors;
+    /** Inserts the chip of a template variable at the selection; invalid names are ignored. */
+    insertVariable(name: string): void;
+    /** Names of the template variables used in the document, each once, in document order. */
+    getVariables(): string[];
+    /** Re-reads the labels of every variable chip, e.g. after the host's variable list or locale changed. */
+    refreshVariables(): void;
+    /** Writes the host's label into every chip that shows a different one; a chip of an unknown name shows `{{name}}`. */
+    private updateVariableLabels;
     /** Link that contains the start of the selection. */
     getActiveLink(): HTMLAnchorElement | null;
     /**

package/dist/core/engine/input-rules.d.ts

@@ -12,6 +12,8 @@ type InputRule = () => InputRuleResult;
 /**
  * Looks for a rule completed by the character that was just typed. The returned function performs the change,
  * so the caller can record an undo step first. Rules never apply inside code.
+ *
+ * @param isKnownVariable Whether a typed `{{name}}` names a template variable of the editor.
  */
-export declare const matchInputRule: (root: HTMLElement, range: Range, typed: string) => InputRule | null;
+export declare const matchInputRule: (root: HTMLElement, range: Range, typed: string, isKnownVariable?: (name: string) => boolean) => InputRule | null;
 export {};