nuvra 0.4.0 → 0.5.0

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,6 +3,16 @@
  * the editor root, element factories and the small structural fixes (caret placeholders, mark merging) that keep the
  * editable markup predictable.
  */
+/** 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 and page breaks. */
 export declare const ATOM_SELECTOR = "hr, img, div[data-type=\"page-break\"]";
 /** Selector for blocks that hold editable inline text. */
@@ -17,6 +27,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 +47,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 +84,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,3 +1,5 @@
+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';
@@ -5,6 +7,19 @@ import { type ListKind } from './lists';
 import { type MarkName, type StyleName, type TextCase } from './marks';
 import { SearchController, type SearchState } from './search';
 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 +32,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 +120,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.
      *
@@ -173,7 +197,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 +211,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 +256,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 +317,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 +341,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 +381,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;
     /**
@@ -319,6 +397,70 @@ export declare class DocumentEngine {
     insertHorizontalRule(): 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 {};

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

@@ -35,7 +35,49 @@ export declare const setHighlight: (root: HTMLElement, range: Range, color: stri
 export declare const setLink: (root: HTMLElement, range: Range, href: string, target: string | null) => boolean;
 /** Removes links from the selected text, keeping the text itself. */
 export declare const unsetLink: (root: HTMLElement, range: Range) => void;
-/** Removes every mark, span style, highlight and link from the selected text. */
+/** Attribute holding the id of the comment a span of text is anchored to. */
+export declare const COMMENT_ATTRIBUTE = "data-comment";
+/** A valid comment id: letters, digits, `_` and `-`. */
+export declare const COMMENT_ID: RegExp;
+/** Selector of every comment anchor. */
+export declare const COMMENT_SELECTOR = "span[data-comment]";
+/**
+ * Anchors a comment to the selected text. Text that already belongs to another comment keeps it, so comments may
+ * overlap.
+ * @returns whether any text was selected.
+ */
+export declare const addCommentAnchor: (root: HTMLElement, range: Range, id: string) => boolean;
+/** Attribute holding the id of a tracked change; inserted and deleted text of one edit share it. */
+export declare const CHANGE_ATTRIBUTE = "data-change";
+/** A valid change id. */
+export declare const CHANGE_ID: RegExp;
+/** Selector of every tracked insertion and deletion. */
+export declare const CHANGE_SELECTOR = "ins[data-change], del[data-change]";
+/** Who made a tracked change and when, written on its `<ins>` or `<del>`. */
+export interface ChangeMark {
+    /** Id shared by the parts of one edit. */
+    id: string;
+    /** Name of the author; may be empty. */
+    author: string;
+    /** When the change was made, as an ISO 8601 string. */
+    time: string;
+}
+/** Tracked deletion around `node`, if any. */
+export declare const deletionAncestor: (node: Node, root: HTMLElement) => HTMLElement | null;
+/** Marks the text and inline atoms of a range as inserted, unless they already are. */
+export declare const markInserted: (root: HTMLElement, range: Range, mark: ChangeMark) => void;
+/**
+ * Deletes a range the tracked way: text the same author inserted while tracking is removed for real, other text is
+ * marked as deleted and stays visible until the deletion is accepted.
+ * @returns whether anything was selected.
+ */
+export declare const markDeleted: (root: HTMLElement, range: Range, mark: ChangeMark) => boolean;
+/**
+ * Accepts or rejects tracked changes: accepting keeps inserted text and drops deleted text, rejecting does the
+ * opposite. Blocks left empty by removed text are kept, like Word keeps the paragraph.
+ */
+export declare const resolveChanges: (elements: HTMLElement[], accept: boolean) => void;
+/** Removes every mark, span style, highlight and link from the selected text; comment anchors and changes stay. */
 export declare const clearMarks: (root: HTMLElement, range: Range) => void;
 /** Letter case transformations offered by the toolbar. */
 export type TextCase = 'upper' | 'lower' | 'title' | 'sentence' | 'toggle';
@@ -46,6 +88,13 @@ export type TextCase = 'upper' | 'lower' | 'title' | 'sentence' | 'toggle';
  * @returns whether any text was selected.
  */
 export declare const applyTextCase: (root: HTMLElement, range: Range, mode: TextCase) => boolean;
+/**
+ * Rewrites the selected text node by node, so every mark around it stays; each call also receives the character
+ * before the node in the same block, so rules that depend on word boundaries work across formatting.
+ *
+ * @returns whether any text was selected.
+ */
+export declare const transformSelectedText: (root: HTMLElement, range: Range, transform: (text: string, previous: string) => string) => boolean;
 /** Which marks apply to `node`. */
 export declare const readMarks: (root: HTMLElement, node: Node) => Record<MarkName, boolean>;
 /** Value of a span style at `node`, or an empty string when none is set. */

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

@@ -1,3 +1,7 @@
+/** A valid template variable name: letters, digits, `_`, `.` and `-`, as used in `{{name}}`. */
+export declare const VARIABLE_NAME: RegExp;
+/** Attribute holding the label a variable chip shows in the editor; editor-only. */
+export declare const VARIABLE_LABEL_ATTRIBUTE = "data-label";
 /** Attribute pagination writes on blocks it moved to the next sheet; editor-only. */
 export declare const GAP_ATTRIBUTE = "data-doc-gap";
 /** Class marking table cells in a drag selection; editor-only. */
@@ -32,9 +36,10 @@ export declare const normalizeContainer: (container: ParentNode & Node, isRoot?:
 export declare const sanitizeHtml: (html: string) => DocumentFragment;
 /**
  * Removes editor-only markup (pagination gaps, cell selection). With `forExport` it also drops caret placeholders
- * and editing attributes, which history snapshots keep so the restored DOM is immediately editable.
+ * and editing attributes, which history snapshots keep so the restored DOM is immediately editable, and numbers the
+ * footnote references from `firstFootnote` (a sheet of a longer document continues the numbering).
  */
-export declare const cleanEditorArtifacts: (scope: Element | DocumentFragment, forExport: boolean) => void;
+export declare const cleanEditorArtifacts: (scope: Element | DocumentFragment, forExport: boolean, firstFootnote?: number) => void;
 /** Clean HTML of the editor content, as stored in the model and exported. */
 export declare const serialize: (root: HTMLElement) => string;
 /** Whether the document is a single unformatted, empty paragraph. */

package/dist/core/export.d.ts

@@ -1,3 +1,4 @@
+import { type SheetFootnote } from './footnotes';
 import { type PageSettings } from './page';
 /** Everything needed to print or export the document. */
 interface DocumentSnapshot {
@@ -8,6 +9,8 @@ interface DocumentSnapshot {
      * with real page numbers and breaks the pages exactly where the editor shows them.
      */
     pages?: string[];
+    /** Footnotes of every sheet of `pages`; without pages, the notes of all of them are printed after the document. */
+    footnotes?: SheetFootnote[][];
     /** Document title, used for the print title and file names. */
     title: string;
     /** Page size, orientation, margins and the running texts. */
@@ -21,11 +24,9 @@ export declare const toFileName: (title: string) => string;
  * the pages break where the editor shows them; without them the document flows and the browser repeats one fixed
  * header and footer on every page.
  */
-export declare const buildPrintableHtml: ({ html, pages, title, page }: DocumentSnapshot) => string;
-/** Word opens HTML saved with the Office namespaces as a regular document in print layout. */
-export declare const buildWordHtml: ({ html, title, page }: DocumentSnapshot) => string;
-/** Offers text content as a file download. */
-export declare const downloadFile: (content: string, fileName: string, type: string) => void;
+export declare const buildPrintableHtml: ({ html, pages, footnotes, title, page }: DocumentSnapshot) => string;
+/** Offers text or binary content as a file download. */
+export declare const downloadFile: (content: string | Blob, fileName: string, type: string) => void;
 /** Prints through a detached iframe so the application chrome never ends up on paper. Waits for images first. */
 export declare const printHtml: (documentHtml: string) => void;
 export {};

package/dist/core/footnotes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The notes of footnotes as they are drawn at the bottom of a sheet. The editor, the layout measurement and printing
+ * all render them with this markup, so the space pagination reserves matches what is drawn.
+ */
+/** A footnote as it appears at the bottom of a sheet. */
+export interface SheetFootnote {
+    /** Number of the footnote in the document, starting at 1. */
+    number: number;
+    /** Text of the note. */
+    text: string;
+}
+/** Class of the notes block; its look is defined in `document-content.css`. */
+export declare const FOOTNOTES_CLASS = "doc-footnotes";
+/** HTML of the notes block of one sheet, or an empty string when the sheet has no footnotes. */
+export declare const footnotesHtml: (notes: readonly SheetFootnote[]) => string;

package/dist/core/icons.d.ts

@@ -3,7 +3,7 @@
  * from Lucide 1.44.0 (https://lucide.dev, ISC license, see LICENSE); the data is generated, not edited by hand.
  */
 /** Name of an icon in the editor's set. */
-export type IconName = 'a-arrow-down' | 'a-arrow-up' | 'between-horizontal-end' | 'between-horizontal-start' | 'between-vertical-end' | 'between-vertical-start' | 'bold' | 'calendar-days' | 'case-sensitive' | 'chevron-down' | 'chevron-right' | 'chevron-up' | 'clipboard' | 'code' | 'columns-2' | 'copy' | 'ellipsis' | 'external-link' | 'file-code' | 'file-down' | 'file-sliders' | 'file-text' | 'file-type' | 'grid-2x2-x' | 'grid-3x3' | 'highlighter' | 'image-plus' | 'italic' | 'languages' | 'link' | 'list' | 'list-indent-decrease' | 'list-indent-increase' | 'list-ordered' | 'list-todo' | 'loader-circle' | 'maximize-2' | 'minimize-2' | 'minus' | 'move-horizontal' | 'omega' | 'paintbrush' | 'panel-top' | 'panel-top-dashed' | 'pencil' | 'pilcrow' | 'pilcrow-left' | 'pilcrow-right' | 'plus' | 'printer' | 'quote' | 'rectangle-horizontal' | 'rectangle-vertical' | 'redo-2' | 'remove-formatting' | 'rows-2' | 'ruler' | 'scissors' | 'scroll-text' | 'search' | 'separator-horizontal' | 'square-code' | 'square-split-vertical' | 'strikethrough' | 'subscript' | 'superscript' | 'table-cells-merge' | 'table-cells-split' | 'text-align-center' | 'text-align-end' | 'text-align-justify' | 'text-align-start' | 'text-cursor-input' | 'trash' | 'underline' | 'undo-2' | 'unfold-vertical' | 'unlink' | 'upload' | 'whole-word' | 'x';
+export type IconName = 'a-arrow-down' | 'a-arrow-up' | 'banknote' | 'between-horizontal-end' | 'between-horizontal-start' | 'between-vertical-end' | 'between-vertical-start' | 'bold' | 'braces' | 'calendar-days' | 'case-sensitive' | 'check' | 'chevron-down' | 'chevron-right' | 'chevron-up' | 'clipboard' | 'code' | 'columns-2' | 'copy' | 'ellipsis' | 'external-link' | 'file-code' | 'file-down' | 'file-sliders' | 'file-text' | 'file-type' | 'grid-2x2-x' | 'grid-3x3' | 'highlighter' | 'image-plus' | 'italic' | 'languages' | 'link' | 'list' | 'list-checks' | 'list-indent-decrease' | 'list-indent-increase' | 'list-ordered' | 'list-todo' | 'loader-circle' | 'maximize-2' | 'message-square' | 'message-square-plus' | 'minimize-2' | 'minus' | 'move-horizontal' | 'omega' | 'paintbrush' | 'panel-left' | 'panel-top' | 'panel-top-dashed' | 'pencil' | 'pilcrow' | 'pilcrow-left' | 'pilcrow-right' | 'plus' | 'printer' | 'quote' | 'rectangle-horizontal' | 'rectangle-vertical' | 'redo-2' | 'remove-formatting' | 'reply' | 'rows-2' | 'ruler' | 'scissors' | 'scroll-text' | 'search' | 'separator-horizontal' | 'signature' | 'square-code' | 'square-split-vertical' | 'strikethrough' | 'subscript' | 'superscript' | 'table-cells-merge' | 'table-cells-split' | 'table-of-contents' | 'text-align-center' | 'text-align-end' | 'text-align-justify' | 'text-align-start' | 'text-cursor-input' | 'trash' | 'underline' | 'undo-2' | 'unfold-vertical' | 'unlink' | 'upload' | 'whole-word' | 'x';
 /** One SVG element of an icon: its tag and attributes. */
 export type IconElement = readonly [tag: string, attributes: Readonly<Record<string, string | number>>];
 /** Elements of every icon, by name. */

package/dist/core/labels.d.ts

@@ -1,7 +1,7 @@
 import { type EditorLabelKey } from './locales/uz';
 export type { EditorLabelKey };
-/** Languages the editor interface is available in. */
-export type EditorLocaleCode = 'uz' | 'en' | 'ru';
+/** Languages the editor interface is available in: Uzbek in Latin and Cyrillic script, English and Russian. */
+export type EditorLocaleCode = 'uz' | 'uz-Cyrl' | 'en' | 'ru';
 /**
  * A built-in interface language. Locales only select one of the translations shipped with the editor; the texts
  * themselves cannot be changed from outside.
@@ -16,6 +16,8 @@ export interface EditorLocale {
 export type EditorLocaleInput = EditorLocale | EditorLocaleCode;
 /** Uzbek (Latin) interface. */
 export declare const uzLocale: EditorLocale;
+/** Uzbek (Cyrillic) interface. */
+export declare const uzCyrlLocale: EditorLocale;
 /** English interface. */
 export declare const enLocale: EditorLocale;
 /** Russian interface. */
@@ -35,4 +37,6 @@ export declare const formatShortcut: (shortcut: string) => string;
 export declare const useEditorLabels: (locale?: () => EditorLocaleInput | undefined) => {
     t: (key: EditorLabelKey, named?: Record<string, unknown>) => string;
     withShortcut: (key: EditorLabelKey, shortcut: string) => string;
+    /** Code of the editor's language, e.g. for numbers and dates written into the document. */
+    locale: import("vue").ComputedRef<EditorLocaleCode>;
 };

package/dist/core/locales/uz-cyrl.d.ts

@@ -0,0 +1,3 @@
+import type { EditorLabelKey } from './uz';
+/** Uzbek (Cyrillic) texts of the editor interface, generated by `scripts/generate-uz-cyrl.mjs`. */
+export declare const uzCyrl: Readonly<Record<EditorLabelKey, string>>;