nuvra 0.7.1 → 0.7.2

package/README.md

@@ -19,8 +19,8 @@ files (`.docx`) you can open again.
   the editor shows them, and the Word export uses Word's own header, footer and page fields.
 - A ruler above the page for the margins and for the first line, left and right indents of a paragraph.
 - A page watermark such as DRAFT or COPY, drawn behind the text of every page and carried into print, HTML and Word.
-- Real `.docx` export and import, PDF download without the print dialog, multilevel (1.1.1) numbering, a table of
-  contents and a navigation pane with headings and page thumbnails.
+- Real `.docx` export and import, PDF import as editable text, PDF download without the print dialog, multilevel
+  (1.1.1) numbering, a table of contents and a navigation pane with headings and page thumbnails.
 - Footnotes at the bottom of their page, carried into print and Word.
 - Comments with replies, tracked changes that round-trip with Word, a comparison of two versions, and templates
   filled in as a form.
@@ -135,7 +135,7 @@ Numbers are pixels; strings are used as CSS lengths (`'100%'`, `'50vh'`).
 | `focus`           | —                                   | The document received focus.                                   |
 | `blur`            | —                                   | The document lost focus; the model is up to date.              |
 | `uploadError`     | `error: unknown`                    | An image was rejected or its upload failed.                    |
-| `importError`     | `error: unknown`                    | A Word file could not be read.                                 |
+| `importError`     | `error: unknown`                    | A Word or PDF file could not be read.                          |
 | `exportError`     | `error: unknown`                    | The PDF could not be drawn; no file is downloaded.             |
 | `selectionChange` | `selection: SelectionOffsets \| null` | The caret or selection moved; `null` when it left the document. |
 
@@ -148,6 +148,7 @@ Numbers are pixels; strings are used as CSS lengths (`'100%'`, `'50vh'`).
 | `insertVariable(name)`    | Inserts a template variable at the selection.                    |
 | `updateTableOfContents()` | Inserts or refreshes the table of contents.                      |
 | `importWord(file)`        | Replaces the document with the content of a `.docx` file.        |
+| `importPdf(file)`         | Replaces the document with the content of a `.pdf` file.         |
 | `print()`                 | Opens the browser print dialog.                                  |
 | `exportHtml()`            | Downloads the document as an HTML page.                          |
 | `exportWord()`            | Downloads the document as a Word file (`.docx`).                 |
@@ -221,6 +222,16 @@ included; a file that cannot be read emits `importError`. `buildDocx` and `readD
 document with several sections takes the page setup of its first section, and every further section starts with a
 section break; the content of a different first page header is not imported.
 
+"Open PDF file (.pdf)" (or `importPdf(file)`) turns a PDF into an editable document that can then be saved as Word.
+PDF keeps positioned glyphs rather than paragraphs, so the structure is rebuilt from the layout: paragraphs with their
+alignment, first-line indent and spacing, headings by font size, bulleted and numbered lists, tables from aligned
+columns (bordered when the PDF draws borders, signature tables otherwise), bold, italic, colour, size and font, the
+running header and footer with page numbers, pictures, and the page size and margins. Latin and Cyrillic text of
+embedded and standard fonts is read, including Uzbek letters. Scanned pages come in as their pictures, since reading
+them would take OCR, and encrypted files emit `importError`. The reader has no dependencies and loads on demand;
+`readPdf` does the same in your own code and rejects with a `PdfImportError` whose `reason` is `'invalid'`,
+`'encrypted'` or `'empty'`.
+
 Tables longer than a page break between their rows in the page view, in print and in the PDF, as in Word: the rows
 that do not fit continue at the top of the next page, and rows joined by a merged cell stay together.
 
@@ -380,8 +391,8 @@ underline and more), `textCase`, `color`, `highlight`, `align`, `lineHeight`, `d
 
 ## Languages
 
-The interface ships in Uzbek (`uz`, the default), Uzbek Cyrillic (`uzCyrl`), English (`en`) and Russian (`ru`). The translations are part of
-the package and cannot be changed from outside; an app only picks the language.
+The interface ships in Uzbek (`uz`, the default), English (`en`) and Russian (`ru`). The translations are part of the
+package and cannot be changed from outside; an app only picks the language.
 
 For one editor, pass the locale (or just its code) to the `locale` prop:
 

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

@@ -5,7 +5,7 @@ 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, ToolbarTool } from '../core/types';
+import type { DocumentImageUploadHandler, ToolbarLayout, ToolbarTool } from '../core/types';
 import { type EditorUiState } from '../core/ui-state';
 import '../styles/document-content.css';
 import '../styles/editor-ui.css';
@@ -49,6 +49,8 @@ interface Props {
      * shortcuts, the `/` menu and the right-click menu are not affected.
      */
     tools?: readonly ToolbarTool[];
+    /** `row` keeps every tool in one row; `tabs` splits them into Home, Insert, Layout and Review tabs. */
+    toolbarLayout?: ToolbarLayout;
     /** 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. */
@@ -92,6 +94,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
     getHTML: () => string;
     /** Replaces the document with the content and page setup of a `.docx` file. */
     importWord: (file: File) => Promise<void>;
+    /** Replaces the document with the content and page setup of a `.pdf` file, rebuilt as editable text. */
+    importPdf: (file: File) => Promise<void>;
     /** Inserts the chip of a template variable at the selection. */
     insertVariable: (name: string) => void | undefined;
     /** Inserts the table of contents at the selection, or refreshes the existing one. */
@@ -139,6 +143,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
     defaultViewMode: DocumentViewMode;
     maxImageSizeMb: number;
     slashCommands: readonly SlashCommand[];
+    toolbarLayout: ToolbarLayout;
     uploadImage: DocumentImageUploadHandler;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

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

@@ -1,13 +1,18 @@
 import type { OutlineHeading, OutlineView } from '../core/outline';
 import type { PageMetrics } from '../core/page';
 import type { SheetGeometry } from '../core/pagination';
+type Heading = OutlineHeading & {
+    page: number | null;
+};
 interface Props {
     /** Headings of the document with the page each starts on, `null` outside the page view. */
-    headings: ReadonlyArray<OutlineHeading & {
-        page: number | null;
-    }>;
+    headings: readonly Heading[];
+    /** Heading the caret is in or after, marked in the tree. */
+    active: HTMLElement | null;
     /** Clean HTML of every sheet, shown as page thumbnails; empty outside the page view. */
     pages: readonly string[];
+    /** Page that holds the caret, counted from 1; its thumbnail is marked. */
+    currentPage: number;
     /** Page geometry the thumbnails are scaled from. */
     metrics: PageMetrics;
     /** Size of every sheet; a sheet turned by a section break gets a turned thumbnail. */
@@ -19,6 +24,8 @@ 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;
+    /** Width of the panel in pixels; the editor keeps the document beside it. */
+    'width'?: number;
 };
 type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
 declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
@@ -26,11 +33,13 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {},
     close: () => any;
     selectPage: (index: number) => any;
     "update:view": (value: OutlineView) => any;
+    "update:width": (value: number) => 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;
+    "onUpdate:width"?: ((value: number) => 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, type ToolbarTool } from '../core/types';
+import { type DocumentMenuAction, type ToolbarLayout, type ToolbarTool } from '../core/types';
 import { type EditorUiState } from '../core/ui-state';
 interface Props {
     /** Read-only document: every editing control is disabled. */
@@ -38,14 +38,16 @@ interface Props {
     variables: ReadonlyArray<TemplateVariable>;
     /** Tools to show; every tool without a list. */
     tools: readonly ToolbarTool[] | undefined;
+    /** One row with every tool, or tabs that show one group of tools at a time. */
+    layout: ToolbarLayout;
 }
-declare var __VLS_626: {};
+declare var __VLS_661: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_626) => any;
+    default?: (props: typeof __VLS_661) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<Props, {
     /** Opens the link popover. */
-    openLink: () => void;
+    openLink: () => Promise<void>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     menu: (action: DocumentMenuAction) => any;
     find: () => any;

package/dist/core/dates.d.ts

@@ -1,8 +1,5 @@
 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`.
- */
+/** A date written out as official documents do: `2026-yil 14-sentabr`, `14 сентября 2026 г.` or `14 September 2026`. */
 export declare const formatLongDate: (date: Date, locale?: NumberWordsLocale) => string;

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

@@ -10,7 +10,7 @@ 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 shared by the parts of the edit. */
     id: string;
     /** Whether text was inserted or deleted. */
     type: 'insert' | 'delete';
@@ -97,6 +97,8 @@ export declare class DocumentEngine {
     readonly history: EditorHistory;
     /** Find and replace over the document text. */
     readonly search: SearchController;
+    /** Removes the mark of the heading last reached from the navigation panel. */
+    private jumpTimer;
     /** Registered listeners per event. */
     private readonly listeners;
     /** Removes every DOM listener added by the engine. */
@@ -157,9 +159,12 @@ export declare class DocumentEngine {
     /** Clean HTML of the document, without caret placeholders or other editor-only markup. */
     getHTML(): string;
     /**
-     * Replaces the whole document with sanitised HTML.
+     * Replaces the whole document with sanitized HTML.
      *
      * @param html New content; scripts, handlers and unsupported markup are dropped.
+     * @param addToHistory
+     * @param emitUpdate
+     * @param keepSelection
      * @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.
      */
@@ -414,7 +419,7 @@ export declare class DocumentEngine {
     /** 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
+     * 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.
      */
@@ -433,8 +438,14 @@ export declare class DocumentEngine {
     setTableOfContents(html: string, { addToHistory }?: {
         addToHistory?: boolean | undefined;
     }): void;
-    /** Scrolls a heading to the top of the view and puts the caret at its start. */
+    /**
+     * Scrolls a heading to the middle of the view, clear of the sticky ruler, puts the caret at its start and briefly
+     * marks its text, so the eye finds where the jump landed.
+     */
     goToHeading(heading: HTMLElement): void;
+    /** Paints the jump mark over a heading and fades it out after a moment; browsers without CSS highlights skip it. */
+    private markJump;
+    private clearJumpMark;
     /**
      * 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).

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: Uzbek in Latin and Cyrillic script, English and Russian. */
-export type EditorLocaleCode = 'uz' | 'uz-Cyrl' | 'en' | 'ru';
+/** Languages the editor interface is available in: Uzbek, English and Russian. */
+export type EditorLocaleCode = 'uz' | '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.
@@ -14,10 +14,8 @@ export interface EditorLocale {
 }
 /** A locale object, or just its code. */
 export type EditorLocaleInput = EditorLocale | EditorLocaleCode;
-/** Uzbek (Latin) interface. */
+/** Uzbek interface. */
 export declare const uzLocale: EditorLocale;
-/** Uzbek (Cyrillic) interface. */
-export declare const uzCyrlLocale: EditorLocale;
 /** English interface. */
 export declare const enLocale: EditorLocale;
 /** Russian interface. */

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

@@ -92,6 +92,7 @@ export declare const uz: {
     readonly 'editor.imageSizeError': "Rasm hajmi {size} MB dan oshmasligi kerak";
     readonly 'editor.imageTypeError': "Faqat rasm fayllarini qo‘shish mumkin";
     readonly 'editor.imageUploadError': "Rasmni yuklab bo‘lmadi";
+    readonly 'editor.importPdf': "PDF faylini ochish (.pdf)";
     readonly 'editor.importWord': "Word faylini ochish (.docx)";
     readonly 'editor.increaseFontSize': "Shriftni kattalashtirish";
     readonly 'editor.indent': "Chekinishni oshirish";
@@ -208,6 +209,11 @@ export declare const uz: {
     readonly 'editor.table.pickSize': "O‘lchamni tanlang";
     readonly 'editor.table.splitCell': "Katakni ajratish";
     readonly 'editor.table.title': "Jadval";
+    readonly 'editor.tabs': "Asboblar bo‘limlari";
+    readonly 'editor.tabs.home': "Asosiy";
+    readonly 'editor.tabs.insert': "Qo‘shish";
+    readonly 'editor.tabs.layout': "Sahifa";
+    readonly 'editor.tabs.review': "Ko‘rib chiqish";
     readonly 'editor.taskList': "Vazifalar ro‘yxati";
     readonly 'editor.templates': "Hujjat shablonlari";
     readonly 'editor.templates.act': "Dalolatnoma";

package/dist/core/numbers.d.ts

@@ -1,5 +1,5 @@
 /** Languages numbers can be written out in. */
-export type NumberWordsLocale = 'uz' | 'uz-Cyrl' | 'ru' | 'en';
+export type NumberWordsLocale = 'uz' | 'ru' | 'en';
 /**
  * Writes a whole number out in words, for example `15 000 000` as `o‘n besh million`. Fractions are dropped; negative
  * numbers get a minus word.

package/dist/core/pdf-import/content.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Runs page content streams far enough to know where text and pictures land: the graphics and text state, font
+ * changes, form XObjects and the page rotation. Glyphs that continue each other merge into text spans, so the layout
+ * step works with words and phrases instead of single characters. Coordinates are page points from the top-left
+ * corner of the page as it is displayed.
+ */
+import type { PdfDocument, PdfPage } from './document';
+import { PdfFont } from './fonts';
+import { type PdfDict, type PdfStream } from './objects';
+/** A run of text in one style on one baseline. */
+export interface TextSpan {
+    text: string;
+    /** Left edge and baseline, in points from the top-left corner. */
+    x: number;
+    y: number;
+    width: number;
+    /** Font size in points as displayed. */
+    size: number;
+    bold: boolean;
+    italic: boolean;
+    family: string | undefined;
+    /** Fill colour as `#rrggbb`. */
+    color: string;
+}
+/** A picture placed on the page. */
+export interface PageImage {
+    src: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** A painted rectangle, such as a table border or a rule, in page points from the top-left corner. */
+export interface Box {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** What one page shows. */
+export interface PageContent {
+    width: number;
+    height: number;
+    spans: TextSpan[];
+    images: PageImage[];
+    /** Thin painted lines: table borders, underlines and separators. */
+    rules: Box[];
+}
+/** Reads the text spans and pictures of pages; fonts and pictures are shared across pages. */
+export declare class ContentReader {
+    private readonly doc;
+    private readonly fonts;
+    private readonly images;
+    constructor(doc: PdfDocument);
+    read(page: PdfPage): PageContent;
+    get document(): PdfDocument;
+    font(dict: PdfDict): PdfFont;
+    image(stream: PdfStream): string | null;
+}

package/dist/core/pdf-import/document.d.ts

@@ -0,0 +1,61 @@
+import { PdfDict, type PdfObject, PdfStream } from './objects';
+/** A page with the attributes it inherits from the page tree. */
+export interface PdfPage {
+    dict: PdfDict;
+    resources: PdfDict;
+    /** Visible area in default user space: `[x0, y0, x1, y1]`. */
+    box: [number, number, number, number];
+    /** Clockwise rotation in degrees: 0, 90, 180 or 270. */
+    rotate: number;
+}
+export declare class PdfDocument {
+    readonly data: Uint8Array;
+    private readonly xref;
+    private readonly cache;
+    /** Objects being loaded, to stop reference loops such as a `/Length` pointing back at its stream. */
+    private readonly loading;
+    private readonly objectStreams;
+    private trailer;
+    /** Whether the cross-references were rebuilt by scanning, which is done at most once. */
+    private repaired;
+    constructor(data: Uint8Array);
+    /** Resolves a reference; other values are returned as they are. */
+    get(value: PdfObject | undefined): PdfObject | undefined;
+    dict(value: PdfObject | undefined): PdfDict | undefined;
+    number(value: PdfObject | undefined): number | undefined;
+    name(value: PdfObject | undefined): string | undefined;
+    array(value: PdfObject | undefined): PdfObject[] | undefined;
+    numbers(value: PdfObject | undefined): number[] | undefined;
+    stream(value: PdfObject | undefined): PdfStream | undefined;
+    /** Filter names of a stream, in the order they are applied. */
+    filters(stream: PdfStream): string[];
+    /**
+     * Decoded stream data. Decoding stops in front of an image codec, so a JPEG picture comes back as its JPEG bytes;
+     * `imageFilter` then names that codec.
+     */
+    decode(stream: PdfStream): {
+        data: Uint8Array;
+        imageFilter?: string;
+    };
+    /** Decoded data of a stream, or an empty array when it cannot be decoded. */
+    bytes(value: PdfObject | undefined): Uint8Array;
+    private predictor;
+    /** The pages in order, with inherited resources, boxes and rotation applied. */
+    pages(): PdfPage[];
+    private box;
+    /** Concatenated, decoded content streams of a page. */
+    contents(page: PdfPage): Uint8Array;
+    private object;
+    private parserAt;
+    /** Parses `num gen obj … endobj` at an offset; `undefined` when the offset does not hold that object. */
+    private objectAt;
+    private compressedObject;
+    /** Follows `startxref` and every `/Prev`; entries of newer sections win. */
+    private readXrefChain;
+    private readXrefSection;
+    private readXrefTable;
+    private readXrefStream;
+    /** Rebuilds the cross-references by scanning the file for `num gen obj`; later definitions win. */
+    private rebuildXref;
+    private indexObjectStream;
+}

package/dist/core/pdf-import/encodings.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Character encodings of simple PDF fonts: the predefined encodings, glyph names from `/Differences` mapped to
+ * Unicode, and the glyph widths of the standard fonts, which PDF files may use without embedding or measuring them.
+ */
+/** Unicode text of each code 0..255 of a simple font encoding; `''` for unused codes. */
+export type Encoding = readonly string[];
+export declare const WIN_ANSI: Encoding;
+export declare const MAC_ROMAN: Encoding;
+/** Adobe StandardEncoding: ASCII with curly quotes, plus its own upper half. */
+export declare const STANDARD: Encoding;
+/** Unicode text of a glyph name, or `undefined` for names that carry no meaning, such as `g42`. */
+export declare const glyphToUnicode: (name: string) => string | undefined;
+/**
+ * Width of a character in a standard font that the file does not measure, in thousandths of the font size. Only the
+ * ASCII range is tabulated; other characters take the font's average width.
+ */
+export declare const standardWidth: (fontName: string, text: string) => number;

package/dist/core/pdf-import/errors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The error of the PDF reader, kept apart from the reader so it can be exported and checked with `instanceof`
+ * without loading the reader itself.
+ */
+/** Why a PDF file could not be opened. */
+export type PdfImportErrorReason = 'invalid' | 'encrypted' | 'empty';
+/** Thrown for PDF files this reader cannot open; the message names the reason. */
+export declare class PdfImportError extends Error {
+    readonly reason: PdfImportErrorReason;
+    constructor(reason: PdfImportErrorReason);
+}

package/dist/core/pdf-import/filters.d.ts

@@ -0,0 +1,18 @@
+/** Filters whose output is an image format; decoding stops in front of them. */
+export declare const IMAGE_FILTERS: Set<string>;
+/** Predictor settings from a filter's `DecodeParms`. */
+export interface PredictorParams {
+    predictor: number;
+    colors: number;
+    bitsPerComponent: number;
+    columns: number;
+    /** LZW only: whether code widths grow one code early, as the specification's default. */
+    earlyChange: number;
+}
+export declare const DEFAULT_PREDICTOR: PredictorParams;
+/**
+ * Applies one decoding filter.
+ *
+ * @throws Error for a filter this reader does not implement.
+ */
+export declare const applyFilter: (name: string, data: Uint8Array, params: PredictorParams) => Uint8Array;

package/dist/core/pdf-import/fonts.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Fonts as the text extractor needs them: how a string splits into character codes, the Unicode text and advance
+ * width of every code, and the style the font name and descriptor imply. Composite (Type0) fonts are read through
+ * their CMaps; simple fonts through `/ToUnicode`, their encoding and `/Differences`.
+ */
+import type { PdfDocument } from './document';
+import { type PdfDict } from './objects';
+/** One shown character code. */
+export interface Glyph {
+    /** Unicode text; empty for codes without a known meaning. */
+    text: string;
+    /** Advance width in thousandths of the font size. */
+    width: number;
+    /** Whether word spacing applies: single-byte code 32. */
+    wordSpace: boolean;
+}
+/** A range of valid codes of one byte length. */
+interface CodespaceRange {
+    length: number;
+    low: number;
+    high: number;
+}
+/** What a CMap stream maps codes to. */
+interface CMap {
+    codespaces: CodespaceRange[];
+    /** Unicode text per code (ToUnicode CMaps). */
+    unicode: Map<number, string>;
+    /** CID per code (encoding CMaps of composite fonts). */
+    cids: Map<number, number>;
+}
+/** Parses a CMap stream: code space, `bfchar`/`bfrange` to Unicode and `cidchar`/`cidrange` to CIDs. */
+export declare const parseCMap: (data: Uint8Array) => CMap;
+export declare class PdfFont {
+    /** Font name without the subset prefix, such as `TimesNewRomanPS-BoldMT`. */
+    readonly name: string;
+    readonly bold: boolean;
+    readonly italic: boolean;
+    /** CSS family of the editor's font list, when the font is one of them. */
+    readonly family: string | undefined;
+    /** Factor from the text space size to the displayed size; Type3 fonts scale glyphs by their own matrix. */
+    readonly sizeScale: number;
+    /** Whether the font is a composite (Type0) font with multibyte codes. */
+    private readonly composite;
+    private readonly codespaces;
+    private readonly toUnicode;
+    private readonly cids;
+    private readonly encoding;
+    private readonly differences;
+    private readonly widths;
+    private readonly defaultWidth;
+    /** Scale of widths into thousandths of the font size; Type3 fonts have their own glyph space. */
+    private readonly widthScale;
+    /** Whether the font carries no widths, as unembedded standard fonts may. */
+    private readonly measuredByName;
+    private readonly glyphCache;
+    constructor(doc: PdfDocument, dict: PdfDict);
+    private readEncoding;
+    private readCidWidths;
+    /** Splits a shown string into its character codes and describes each one. */
+    decode(bytes: Uint8Array): Glyph[];
+    private codeLength;
+    private describe;
+    private unicodeOf;
+    private widthOf;
+}
+export {};

package/dist/core/pdf-import/images.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Pictures of a PDF as `data:` URLs: JPEG data is embedded as it is, and decoded pixel data (gray, RGB, CMYK, ICC
+ * based and indexed color, 1 to 16 bits per component, with a soft mask) is painted into a canvas and saved as PNG.
+ * Without a DOM canvas, as in tests or workers, only JPEG pictures come through.
+ */
+import type { PdfDocument } from './document';
+import { PdfStream } from './objects';
+/** `data:` URL of an image XObject, or `null` when it cannot be shown. */
+export declare const imageSource: (doc: PdfDocument, stream: PdfStream) => string | null;

package/dist/core/pdf-import/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Opens a PDF document as editable content: text with its formatting, headings, lists, tables and pictures, plus the
+ * page setup. PDF stores positioned glyphs rather than paragraphs, so the structure is reconstructed from the layout;
+ * text drawn as pictures (scanned pages) comes through as the pictures themselves. Encrypted files are refused.
+ */
+import type { PageSettings } from '../page';
+import { PdfImportError } from './errors';
+export { PdfImportError };
+export type { PdfImportErrorReason } from './errors';
+/** What was read from a PDF document. */
+export interface PdfImport {
+    /** Document content as HTML; the editor's sanitiser still runs over it. */
+    html: string;
+    /** Paper size, orientation, margins and running header and footer of the document. */
+    page: PageSettings;
+}
+/**
+ * Reads a `.pdf` file into editor HTML and page settings.
+ *
+ * @throws PdfImportError when the file is not a PDF, is encrypted, or shows neither text nor pictures.
+ */
+export declare const readPdf: (data: ArrayBuffer | Uint8Array) => Promise<PdfImport>;

package/dist/core/pdf-import/inflate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Synchronous zlib/DEFLATE decoder (RFC 1950/1951). PDF streams are decoded while objects are resolved, which keeps
+ * the whole reader synchronous; the browser's `DecompressionStream` is asynchronous and rejects the truncated or
+ * checksum-less streams that many PDF writers produce. Decoding is lenient: a damaged stream yields the bytes read so
+ * far instead of an error.
+ */
+/**
+ * Decodes zlib data, or raw DEFLATE data when the zlib header is missing. The Adler-32 checksum is not verified:
+ * PDF writers get it wrong often enough that checking it would only lose content.
+ */
+export declare const inflate: (data: Uint8Array) => Uint8Array;

package/dist/core/pdf-import/layout.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Rebuilds document structure from positioned text: spans become lines, repeated lines at the page edges become the
+ * header and footer, aligned columns become tables, and lines become paragraphs, headings and lists with their
+ * alignment, indents and spacing. The result is editor HTML and the page setup the text was laid out on.
+ */
+import { type PageSettings } from '../page';
+import type { PageContent } from './content';
+/** What the layout step produces. */
+export interface LayoutResult {
+    html: string;
+    page: PageSettings;
+    /** Number of text characters read, to tell a scanned document from an empty one. */
+    characters: number;
+}
+/** Turns the content of every page into editor HTML and page settings. */
+export declare const layoutPages: (contents: PageContent[]) => LayoutResult;

package/dist/core/pdf-import/load.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The public entry of the PDF reader. The reader is loaded on the first call, so applications that never open a PDF
+ * do not carry it in their main bundle.
+ */
+import type { PdfImport } from '.';
+/**
+ * Reads a `.pdf` file into editor HTML and page settings: text with its formatting, headings, lists, tables and
+ * pictures, rebuilt from the layout of the pages. Scanned pages come through as their pictures.
+ *
+ * @throws PdfImportError when the file is not a PDF, is encrypted, or shows neither text nor pictures.
+ */
+export declare const readPdf: (data: ArrayBuffer | Uint8Array) => Promise<PdfImport>;