nuvra 0.5.0 → 0.7.0

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

@@ -1,10 +1,11 @@
+import type { Collaborator, SelectionOffsets } from '../core/collaboration';
 import { type DocumentComment } from '../core/comments';
 import { DocumentEngine } from '../core/engine/engine';
 import { type EditorLocaleInput } from '../core/labels';
 import { type DocumentViewMode, type PageSettings } from '../core/page';
 import type { SlashCommand } from '../core/slash-commands';
 import type { TemplateVariable } from '../core/templates';
-import type { DocumentImageUploadHandler } from '../core/types';
+import type { DocumentImageUploadHandler, ToolbarTool } from '../core/types';
 import { type EditorUiState } from '../core/ui-state';
 import '../styles/document-content.css';
 import '../styles/editor-ui.css';
@@ -15,6 +16,8 @@ interface Props {
     autofocus?: boolean;
     /** Gray space around the page or web sheet that separates the document from the editor frame. */
     canvasPadding?: CssSize;
+    /** Other people editing the document; their carets and selections are drawn over it. */
+    collaborators?: readonly Collaborator[];
     /** Name written as the author of new comments, replies and tracked changes. */
     author?: string;
     /** View shown first; form fields use the lighter web view. */
@@ -41,6 +44,11 @@ interface Props {
     ruler?: boolean;
     /** Used as the print title and the exported file name. */
     title?: string;
+    /**
+     * Toolbar tools to show, such as `['history', 'marks', 'lists', 'link']`; every tool without a list. Keyboard
+     * shortcuts, the `/` menu and the right-click menu are not affected.
+     */
+    tools?: readonly ToolbarTool[];
     /** Uploads an inserted image and resolves with its URL; without it images are embedded as data URLs. */
     uploadImage?: DocumentImageUploadHandler;
     /** Template variables the user can insert; typing `{{name}}` of one of them inserts it as well. */
@@ -76,6 +84,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
     exportHtml: () => Promise<void>;
     /** Downloads the document as a Word-compatible file. */
     exportWord: () => Promise<void>;
+    /** Downloads the document as a PDF drawn from its pages. */
+    exportPdf: () => Promise<void>;
     /** Moves keyboard focus into the document. */
     focus: () => void | undefined;
     /** Returns the document HTML, including edits not yet written to the model. */
@@ -94,6 +104,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
     "update:page": (value: PageSettings) => any;
     uploadError: (error: unknown) => any;
     importError: (error: unknown) => any;
+    exportError: (error: unknown) => any;
+    selectionChange: (selection: SelectionOffsets | null) => any;
     "update:modelValue": (value: string) => any;
     "update:trackChanges": (value: boolean) => any;
     "update:comments": (value: DocumentComment[] | undefined) => any;
@@ -103,6 +115,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
     "onUpdate:page"?: ((value: PageSettings) => any) | undefined;
     onUploadError?: ((error: unknown) => any) | undefined;
     onImportError?: ((error: unknown) => any) | undefined;
+    onExportError?: ((error: unknown) => any) | undefined;
+    onSelectionChange?: ((selection: SelectionOffsets | null) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
     "onUpdate:trackChanges"?: ((value: boolean) => any) | undefined;
     "onUpdate:comments"?: ((value: DocumentComment[] | undefined) => any) | undefined;
@@ -111,12 +125,14 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
     height: CssSize;
     locale: EditorLocaleInput;
     ruler: boolean;
+    variables: readonly TemplateVariable[];
     placeholder: string;
     disabled: boolean;
     minHeight: CssSize;
+    collaborators: readonly Collaborator[];
     maxHeight: CssSize;
     maxLength: number;
-    variables: readonly TemplateVariable[];
+    tools: readonly ToolbarTool[];
     author: string;
     autofocus: boolean;
     canvasPadding: CssSize;

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

@@ -2,6 +2,7 @@ import type { ParagraphIndents } from '../core/engine/blocks';
 import type { DocumentEngine } from '../core/engine/engine';
 import { type SheetFootnote } from '../core/footnotes';
 import { type DocumentViewMode, type PageMargins, type PageMetrics, type PageSettings } from '../core/page';
+import { type SheetGeometry } from '../core/pagination';
 interface Props {
     /** Grow with the content between the editor's min and max height instead of filling a fixed height. */
     autoHeight: boolean;
@@ -21,6 +22,8 @@ interface Props {
     metrics: PageMetrics;
     /** Number of sheets drawn behind the content in page view. */
     pageCount: number;
+    /** Position, size and orientation of every sheet, as laid out by pagination; empty until the first layout. */
+    sheets: readonly SheetGeometry[];
     /** Whether the ruler is drawn above the sheet; it is only ever shown in the page view. */
     rulerVisible: boolean;
     /** Paginated sheets or a single web sheet. */

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

@@ -0,0 +1,17 @@
+import { type Collaborator } from '../core/collaboration';
+import type { DocumentEngine } from '../core/engine/engine';
+interface Props {
+    /** Engine that measures positions in the document. */
+    engine: DocumentEngine;
+    /** People whose carets are drawn. */
+    collaborators: readonly Collaborator[];
+    /** Element the marks are positioned in; it must be positioned itself. */
+    container: HTMLElement;
+    /** Scrolling canvas; marks outside it are hidden. */
+    scrollTarget: HTMLElement;
+    /** Changes whenever the layout may move text (zoom, view mode, page setup), so the marks are measured again. */
+    layoutKey: string;
+}
+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-outline.vue.d.ts

@@ -1,16 +1,36 @@
-import type { OutlineHeading } from '../core/outline';
+import type { OutlineHeading, OutlineView } from '../core/outline';
+import type { PageMetrics } from '../core/page';
+import type { SheetGeometry } from '../core/pagination';
 interface Props {
     /** Headings of the document with the page each starts on, `null` outside the page view. */
     headings: ReadonlyArray<OutlineHeading & {
         page: number | null;
     }>;
+    /** Clean HTML of every sheet, shown as page thumbnails; empty outside the page view. */
+    pages: readonly string[];
+    /** Page geometry the thumbnails are scaled from. */
+    metrics: PageMetrics;
+    /** Size of every sheet; a sheet turned by a section break gets a turned thumbnail. */
+    sheets: readonly SheetGeometry[];
+    /** Number printed on the first sheet. */
+    firstPageNumber: number;
 }
-declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+type __VLS_Props = Props;
+type __VLS_ModelProps = {
+    /** Which list is shown; the editor reads it to lay out thumbnails only while they are visible. */
+    'view'?: OutlineView;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     select: (heading: HTMLElement) => any;
     close: () => any;
-}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    selectPage: (index: number) => any;
+    "update:view": (value: OutlineView) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     onSelect?: ((heading: HTMLElement) => any) | undefined;
     onClose?: (() => any) | undefined;
+    onSelectPage?: ((index: number) => any) | undefined;
+    "onUpdate:view"?: ((value: OutlineView) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,7 +1,7 @@
 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 DocumentMenuAction, type ToolbarTool } from '../core/types';
 import { type EditorUiState } from '../core/ui-state';
 interface Props {
     /** Read-only document: every editing control is disabled. */
@@ -36,10 +36,12 @@ interface Props {
     uploading: boolean;
     /** Template variables offered by the variable menu; the menu is hidden without any. */
     variables: ReadonlyArray<TemplateVariable>;
+    /** Tools to show; every tool without a list. */
+    tools: readonly ToolbarTool[] | undefined;
 }
-declare var __VLS_604: {};
+declare var __VLS_626: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_604) => any;
+    default?: (props: typeof __VLS_626) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<Props, {
     /** Opens the link popover. */

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 edits the same document. */
+export interface Collaborator {
+    /** Stable id of the person or connection. */
+    id: string;
+    /** Name shown next to the caret. */
+    name: string;
+    /** CSS color 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 color 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/docx/import.d.ts

@@ -8,7 +8,7 @@ import { type PageSettings } from '../page';
 export interface DocxImport {
     /** Document content as HTML. */
     html: string;
-    /** Page setup of the document's last section. */
+    /** Page setup of the document's first section; later sections are section breaks in the HTML. */
     page: PageSettings;
 }
 /**

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

@@ -15,7 +15,7 @@ export declare const imageFiles: (content: TransferContent) => File[];
 export declare const singleUrl: (content: TransferContent) => string | null;
 /** Converts plain text into paragraphs, one per line; a final line break does not add an empty paragraph. */
 export declare const textToFragment: (text: string) => DocumentFragment;
-/** Converts a payload into editor blocks, preferring sanitised HTML over plain text; `null` when it has neither. */
+/** Converts a payload into editor blocks, preferring sanitized HTML over plain text; `null` when it has neither. */
 export declare const transferToFragment: (content: TransferContent) => DocumentFragment | null;
 /** Clean HTML and plain text of a selection, as put on the clipboard by copy, cut and drag. */
 export declare const selectionClipboardData: (root: HTMLElement, range: Range) => {

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

@@ -13,8 +13,15 @@ export declare const FOOTNOTE_ATTRIBUTE = "data-footnote";
 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 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. */

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

@@ -6,6 +6,7 @@ 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 {
@@ -162,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. */
@@ -395,6 +409,8 @@ 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;
     /**

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

@@ -2,8 +2,16 @@
 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 of a section turned against the document's orientation; editor-only. */
+export declare const ROTATED_ATTRIBUTE = "data-doc-rotated";
 /** Attribute pagination writes on blocks it moved to the next sheet; editor-only. */
 export declare const GAP_ATTRIBUTE = "data-doc-gap";
+/** Attribute pagination writes on table rows it moved down to the next sheet, with the shift in pixels; editor-only. */
+export declare const ROW_SHIFT_ATTRIBUTE = "data-doc-row-shift";
+/** Attribute pagination writes on tables split over sheets, with the space their moved rows add; editor-only. */
+export declare const TABLE_SHIFT_ATTRIBUTE = "data-doc-table-shift";
+/** Attribute pagination sets on the editable root while the document is laid out on sheets; editor-only. */
+export declare const PAGED_ATTRIBUTE = "data-doc-paged";
 /** Class marking table cells in a drag selection; editor-only. */
 export declare const SELECTED_CELL_CLASS = "doc-cell-selected";
 /** Attribute holding the space a paragraph keeps before it, in points. */

package/dist/core/export.d.ts

@@ -9,6 +9,8 @@ interface DocumentSnapshot {
      * with real page numbers and breaks the pages exactly where the editor shows them.
      */
     pages?: string[];
+    /** For every sheet of `pages`, whether a section break turned it against the document's orientation. */
+    rotated?: boolean[];
     /** 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. */
@@ -16,6 +18,11 @@ interface DocumentSnapshot {
     /** Page size, orientation, margins and the running texts. */
     page: PageSettings;
 }
+/** Paper width and height in millimetres, in the chosen orientation. */
+export declare const paperSize: ({ size, orientation }: PageSettings) => {
+    width: number;
+    height: number;
+};
 /** Turns a document title into a safe file name without extension. */
 export declare const toFileName: (title: string) => string;
 /**
@@ -24,7 +31,7 @@ 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, footnotes, title, page }: DocumentSnapshot) => string;
+export declare const buildPrintableHtml: ({ html, pages, rotated, 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. */

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

@@ -59,6 +59,7 @@ export declare const uz: {
     readonly 'editor.enterFullscreen': "To‘liq ekran";
     readonly 'editor.exitFullscreen': "To‘liq ekrandan chiqish";
     readonly 'editor.exportHtml': "HTML sifatida yuklab olish";
+    readonly 'editor.exportPdf': "PDF sifatida yuklab olish";
     readonly 'editor.exportWord': "Word (.docx) sifatida yuklab olish";
     readonly 'editor.fitWidth': "Kenglikka moslash";
     readonly 'editor.fontFamily': "Shrift";
@@ -112,6 +113,10 @@ export declare const uz: {
     readonly 'editor.numbering.legal': "Ko‘p darajali raqamlash (1.1, 1.2)";
     readonly 'editor.outline': "Navigatsiya paneli";
     readonly 'editor.outline.empty': "Hujjatda sarlavhalar yo‘q. Sarlavha uslubini qo‘llang, ular shu yerda ko‘rinadi.";
+    readonly 'editor.outline.headings': "Sarlavhalar";
+    readonly 'editor.outline.noPages': "Sahifalar faqat sahifa ko‘rinishida chiqadi.";
+    readonly 'editor.outline.page': "{page}-sahifa";
+    readonly 'editor.outline.pages': "Sahifalar";
     readonly 'editor.openLink': "Havolani ochish";
     readonly 'editor.or': "yoki havola orqali";
     readonly 'editor.orderedList': "Raqamli ro‘yxat";
@@ -147,6 +152,7 @@ export declare const uz: {
     readonly 'editor.replace.one': "Almashtirish";
     readonly 'editor.replace.placeholder': "Almashtirish";
     readonly 'editor.replace.toggle': "Almashtirishni ko‘rsatish";
+    readonly 'editor.review': "Taqriz: izohlar va o‘zgarishlar";
     readonly 'editor.ruler': "Chizg‘ich";
     readonly 'editor.ruler.firstLine': "Birinchi qator chekinishi";
     readonly 'editor.ruler.indentLeft': "Chap chekinish";
@@ -160,6 +166,8 @@ export declare const uz: {
     readonly 'editor.search.title': "Qidirish va almashtirish";
     readonly 'editor.search.wholeWord': "Butun so‘z";
     readonly 'editor.selectAll': "Barchasini tanlash";
+    readonly 'editor.sectionBreak.landscape': "Bo‘lim uzilishi: albom sahifalar";
+    readonly 'editor.sectionBreak.portrait': "Bo‘lim uzilishi: kitob sahifalar";
     readonly 'editor.signature': "Imzo bloki";
     readonly 'editor.signature.agreed': "KELISHILDI grifi";
     readonly 'editor.signature.approval': "TASDIQLAYMAN grifi";

package/dist/core/outline.d.ts

@@ -12,6 +12,8 @@ export interface OutlineHeading {
     /** The heading element in the editable document. */
     element: HTMLElement;
 }
+/** What the navigation panel lists: the headings, or thumbnails of the pages. */
+export type OutlineView = 'headings' | 'pages';
 /** A line of the table of contents. */
 export interface TableOfContentsEntry {
     /** Heading level, 1 to 6; deeper levels are indented. */

package/dist/core/pagination.d.ts

@@ -1,5 +1,18 @@
 import { type SheetFootnote } from './footnotes';
-import type { PageMetrics } from './page';
+import type { PageMetrics, PageOrientation } from './page';
+/** Where a sheet is drawn and which way it is turned. */
+export interface SheetGeometry {
+    /** Distance of the sheet from the top of the first sheet, in pixels. */
+    top: number;
+    /** Sheet width in pixels. */
+    width: number;
+    /** Sheet height in pixels. */
+    height: number;
+    /** Orientation of the sheet. */
+    orientation: PageOrientation;
+    /** Whether the sheet is turned against the document's own orientation, by a section break. */
+    rotated: boolean;
+}
 /** Handle returned by {@link createPagination}. */
 export interface PaginationController {
     /** Sets the page geometry and re-runs the layout; pass `null` to switch pagination off (web view). */
@@ -15,15 +28,21 @@ interface PaginationOptions {
     onPageCount: (count: number) => void;
     /** Receives the footnotes of every sheet whenever they change; the web view is one sheet holding all of them. */
     onFootnotes?: (sheets: SheetFootnote[][]) => void;
+    /** Receives the position, size and orientation of every sheet whenever they change; empty in the web view. */
+    onSheets?: (sheets: SheetGeometry[]) => void;
     /** Whether an IME composition is in progress, during which blocks must not move. */
     isComposing: () => boolean;
 }
+/** Sheets of a document without section breaks, all alike. */
+export declare const uniformSheets: (metrics: PageMetrics, count: number) => SheetGeometry[];
+/** Index of the sheet a vertical position falls on, counted from the top of the first sheet. */
+export declare const sheetIndexAt: (sheets: readonly SheetGeometry[], offset: number) => number;
 /**
  * Splits the laid-out document into the clean HTML of every sheet, for printing and export. Pagination has already
  * moved every block onto its page, so a block belongs to the page its top falls on; blocks taller than a page stay
  * whole, exactly as they are shown on screen. Footnote references keep their document-wide numbers.
  */
-export declare const splitIntoPages: (root: HTMLElement, metrics: PageMetrics, pageCount: number) => string[];
+export declare const splitIntoPages: (root: HTMLElement, metrics: PageMetrics, pageCount: number, geometry?: readonly SheetGeometry[]) => string[];
 /**
  * Keeps the document laid out on sheets. Layout passes are batched to one per animation frame and re-run when the
  * document resizes, images or fonts load, or the host schedules one after an edit.

package/dist/core/pdf.d.ts

@@ -0,0 +1,43 @@
+/**
+ * PDF download without the print dialog and without dependencies. Every sheet of the printable document is drawn into
+ * a canvas through an SVG `foreignObject`, and the pictures are written into a PDF, one per page. The PDF looks like
+ * the printout, but its text cannot be selected or searched.
+ */
+/** A rendered page: a JPEG picture of the sheet and the paper size it is printed on. */
+export interface PdfPage {
+    /** JPEG data of the page picture. */
+    jpeg: Uint8Array;
+    /** Picture width in pixels. */
+    width: number;
+    /** Picture height in pixels. */
+    height: number;
+    /** Paper width in PDF points (1/72 inch). */
+    widthPt: number;
+    /** Paper height in PDF points. */
+    heightPt: number;
+}
+/** Options of {@link renderPdf}. */
+export interface PdfOptions {
+    /** Pixels per CSS pixel of the page pictures; higher is sharper and larger. Defaults to 2. */
+    scale?: number;
+    /** JPEG quality between 0 and 1. Defaults to 0.92. */
+    quality?: number;
+}
+/** MIME type of PDF files. */
+export declare const PDF_MIME = "application/pdf";
+/**
+ * Writes JPEG pictures into a PDF document, one picture filling each page.
+ *
+ * @returns the PDF file content.
+ */
+export declare const buildPdf: (pages: readonly PdfPage[]) => Uint8Array;
+/**
+ * Turns the printable HTML of a paginated document (one `section.doc-sheet` per page) into a PDF.
+ *
+ * @param printableHtml Standalone HTML as built for printing from the page view.
+ * @param paper Paper width and height in millimetres, in the chosen orientation.
+ */
+export declare const renderPdf: (printableHtml: string, paper: {
+    width: number;
+    height: number;
+}, options?: PdfOptions) => Promise<Blob>;

package/dist/core/types.d.ts

@@ -1,3 +1,10 @@
 /** Uploads an image and resolves with its public URL. Without a handler, images are embedded as data URLs. */
 export type DocumentImageUploadHandler = (file: File) => Promise<string>;
-export type DocumentMenuAction = 'source' | 'print' | 'exportHtml' | 'exportWord' | 'importWord' | 'formattingMarks' | 'ruler' | 'outline' | 'tableOfContents' | 'comments' | 'addComment' | 'footnote' | 'trackChanges' | 'changes' | 'fullscreen';
+export type DocumentMenuAction = 'source' | 'print' | 'exportHtml' | 'exportWord' | 'exportPdf' | 'importWord' | 'formattingMarks' | 'ruler' | 'outline' | 'tableOfContents' | 'comments' | 'addComment' | 'footnote' | 'trackChanges' | 'changes' | 'fullscreen';
+/**
+ * Tools of the editor toolbar, in the order they appear. Pass a list of them as the `tools` prop to show only those;
+ * keyboard shortcuts, the `/` menu and the right-click menu keep working either way.
+ */
+export declare const TOOLBAR_TOOLS: readonly ["history", "formatPainter", "blockStyle", "fontFamily", "fontSize", "marks", "textCase", "color", "highlight", "align", "lineHeight", "direction", "lists", "indent", "link", "image", "table", "specialCharacters", "variables", "signature", "insert", "review", "search", "templates", "headerFooter", "pageSetup", "more"];
+/** A tool of the editor toolbar; see {@link TOOLBAR_TOOLS}. */
+export type ToolbarTool = (typeof TOOLBAR_TOOLS)[number];

package/dist/editor.vue.d.ts

@@ -1,6 +1,6 @@
 import type { EditorLocaleInput } from './core/labels';
 import type { TemplateVariable } from './core/templates';
-import type { DocumentImageUploadHandler } from './core/types';
+import type { DocumentImageUploadHandler, ToolbarTool } from './core/types';
 interface Props {
     /** Places the caret at the end of the content once the editor is ready. */
     autofocus?: boolean;
@@ -20,6 +20,8 @@ interface Props {
     minHeight?: number | string;
     /** Text shown while the field is empty. */
     placeholder?: string;
+    /** Toolbar tools to show; every tool without a list. */
+    tools?: readonly ToolbarTool[];
     /** Uploads an image and resolves with its URL; without it images are embedded as data URLs. */
     uploadImage?: DocumentImageUploadHandler;
     /** Template variables the user can insert; typing `{{name}}` of one of them inserts it as well. */
@@ -43,12 +45,13 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {},
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {
     locale: EditorLocaleInput;
+    variables: readonly TemplateVariable[];
     placeholder: string;
     disabled: boolean;
     minHeight: number | string;
     maxHeight: number | string;
     maxLength: number;
-    variables: readonly TemplateVariable[];
+    tools: readonly ToolbarTool[];
     autofocus: boolean;
     canvasPadding: number | string;
     maxImageSizeMb: number;

package/dist/{export-DhHI3ZrQ.js → export-B06RXLqn.js}

@@ -33,18 +33,20 @@ var c = ".doc-content{color:#1f2328;white-space:pre-wrap;overflow-wrap:break-wor
 	let { width: i, height: a } = y(e), s = t(i * m, a * m, r.text, r.diagonal), c = r.diagonal ? " transform: rotate(-35deg);" : "";
 	return `
 .doc-watermark { position: ${n ? "fixed" : "absolute"}; inset: 0; display: flex; align-items: center; justify-content: center; overflow: hidden; color: ${r.color}; font: 700 ${s}px/1 'Times New Roman', Times, serif; letter-spacing: 0.06em; opacity: ${h}; text-transform: uppercase; white-space: nowrap; pointer-events: none;${c} }`;
-}, E = (t, n, r, a = []) => t.map((o, c) => {
-	let l = {
-		page: e(n, c + 1),
+}, E = (t, n, r, a = [], o = []) => t.map((c, l) => {
+	let u = {
+		page: e(n, l + 1),
 		pages: t.length,
 		title: r
-	}, u = i(n, c + 1), d = u ? C(n.header, "header", l) : "", f = u ? C(n.footer, "footer", l) : "";
-	return `<section class="doc-sheet">${w(n.watermark)}${d}<article class="doc-content">${o}</article>${a[c]?.length ? `<div class="doc-sheet__notes">${s(a[c] ?? [])}</div>` : ""}${f}</section>`;
+	}, d = i(n, l + 1), f = d ? C(n.header, "header", u) : "", p = d ? C(n.footer, "footer", u) : "", m = w(n.watermark), h = a[l]?.length ? `<div class="doc-sheet__notes">${s(a[l] ?? [])}</div>` : "";
+	return `<section class="${o[l] ? "doc-sheet is-rotated" : "doc-sheet"}">${m}${f}<article class="doc-content">${c}</article>${h}${p}</section>`;
 }).join(""), D = (e) => {
 	let { width: t, height: n } = y(e), { margins: r } = e;
 	return `@page { size: ${t}mm ${n}mm; margin: 0; }
 .doc-sheet { position: relative; box-sizing: border-box; width: ${t}mm; min-height: ${n}mm; padding: ${r.top}mm ${r.right}mm ${r.bottom}mm ${r.left}mm; overflow: hidden; background: #fff; break-after: page; }
 .doc-sheet:last-child { break-after: auto; }
+@page rotated { size: ${n}mm ${t}mm; margin: 0; }
+.doc-sheet.is-rotated { width: ${n}mm; min-height: ${t}mm; page: rotated; }
 .doc-running { position: absolute; right: ${r.right}mm; left: ${r.left}mm; }
 .doc-sheet__notes { position: absolute; right: ${r.right}mm; bottom: ${r.bottom}mm; left: ${r.left}mm; }
 .doc-running--header { top: ${x(r.top)}mm; }
@@ -55,20 +57,20 @@ var c = ".doc-content{color:#1f2328;white-space:pre-wrap;overflow-wrap:break-wor
 .doc-running { position: fixed; right: 0; left: 0; }
 .doc-running--header { top: -${x(t.top)}mm; }
 .doc-running--footer { bottom: -${x(t.bottom)}mm; }${S}${T(e, !0)}`;
-}, k = (e) => e.replace(u, " ").trim() || d, A = ({ html: e, pages: t, footnotes: n, title: r, page: i }) => {
-	let a = t !== void 0 && t.length > 0, o = {
+}, k = (e) => e.replace(u, " ").trim() || d, A = ({ html: e, pages: t, rotated: n, footnotes: r, title: i, page: a }) => {
+	let o = t !== void 0 && t.length > 0, l = {
 		page: 1,
 		pages: 1,
-		title: r
-	}, l = `${w(i.watermark)}${C(i.header, "header", o)}${C(i.footer, "footer", o)}<article class="doc-content">${e}</article>${s(n?.flat() ?? [])}`;
+		title: i
+	}, u = `${w(a.watermark)}${C(a.header, "header", l)}${C(a.footer, "footer", l)}<article class="doc-content">${e}</article>${s(r?.flat() ?? [])}`;
 	return `<!doctype html>
 <html lang="uz">
 <head>
 <meta charset="utf-8">
-<title>${v(r)}</title>
-<style>${a ? D(i) : O(i)} html, body { margin: 0; background: #fff; } ${c}</style>
+<title>${v(i)}</title>
+<style>${o ? D(a) : O(a)} html, body { margin: 0; background: #fff; } ${c}</style>
 </head>
-<body>${a && t ? E(t, i, r, n) : l}</body>
+<body>${o && t ? E(t, a, i, r, n) : u}</body>
 </html>`;
 }, j = (e, t, n) => {
 	let r = URL.createObjectURL(e instanceof Blob ? e : new Blob([e], { type: n })), i = document.createElement("a");
@@ -89,6 +91,6 @@ var c = ".doc-content{color:#1f2328;white-space:pre-wrap;overflow-wrap:break-wor
 	}, t.srcdoc = e, document.body.appendChild(t);
 };
 //#endregion
-export { A as buildPrintableHtml, j as downloadFile, M as printHtml, k as toFileName };
+export { A as buildPrintableHtml, j as downloadFile, y as paperSize, M as printHtml, k as toFileName };
 
-//# sourceMappingURL=export-DhHI3ZrQ.js.map
+//# sourceMappingURL=export-B06RXLqn.js.map