@laminapdf/wasm 0.0.0-stage → 0.2.0-alpha.3

package/dist/lamina_pdf_text.js

@@ -0,0 +1,1973 @@
+/* @ts-self-types="./lamina_pdf_text.d.ts" */
+
+/**
+ * Builds a new document: pages, navigation and metadata, then [`WasmBuilder::finish`]
+ * gives a [`WasmDocument`] (unsaved; its save is a full rewrite).
+ */
+export class WasmBuilder {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmbuilder_free(ptr, 0);
+
+    }
+    /**
+     * Attaches a file (`/EmbeddedFiles`, the catalog's `/AF`): `name`, its bytes and its MIME
+     * type. The same name again replaces the file.
+     *
+     * # Errors
+     * `builder-finished`; `invalid-argument` (a date that isn't a PDF date); `unknown-option`.
+     * @param {string} name
+     * @param {Uint8Array} bytes
+     * @param {string} mime
+     * @param {AttachmentInit | undefined} options
+     */
+    attach(name, bytes, mime, options) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(mime, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmbuilder_attach(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, options);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Defines the named destination `name`: page `index` shown as `fit` (default: the page).
+     *
+     * # Errors
+     * `builder-finished`; `invalid-argument` for a bad `fit`.
+     * @param {string} name
+     * @param {number} index
+     * @param {FitInit | undefined} fit
+     */
+    destination(name, index, fit) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmbuilder_destination(this.__wbg_ptr, ptr0, len0, index, fit);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Writes the fonts, links, page tree, outline and metadata, and returns the document.
+     * The builder is finished afterwards, and so are its unfinished pages.
+     *
+     * # Errors
+     * `builder-finished`; `page-index-out-of-range`, `unknown-destination`,
+     * `invalid-page-labels`, `invalid-geometry`, `subset-failed`.
+     * @returns {WasmDocument}
+     */
+    finish() {
+        let ret;
+        ret = wasm.wasmbuilder_finish(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmDocument.__wrap(ret[0]);
+    }
+    /**
+     * Loads a font from its bytes (TrueType or OpenType/CFF) and registers it; it is
+     * subset to the glyphs drawn.
+     *
+     * # Errors
+     * `builder-finished`; `invalid-font`, `font-not-embeddable`.
+     * @param {Uint8Array} bytes
+     * @returns {WasmFont}
+     */
+    fontBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmbuilder_fontBytes(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmFont.__wrap(ret[0]);
+    }
+    /**
+     * The natural language (`/Lang`), a BCP 47 tag.
+     *
+     * # Errors
+     * `builder-finished`.
+     * @param {string} lang
+     */
+    lang(lang) {
+        const ptr0 = passStringToWasm0(lang, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmbuilder_lang(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The metadata, written as the Info dictionary and an XMP packet.
+     *
+     * # Errors
+     * `builder-finished`; `invalid-argument` (a date that isn't a PDF date).
+     * @param {MetadataInit} metadata
+     */
+    metadata(metadata) {
+        let ret;
+        ret = wasm.wasmbuilder_metadata(this.__wbg_ptr, metadata);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * A builder for a new, empty document.
+     *
+     * # Errors
+     * `invalid-argument` / `unknown-option` for bad options.
+     * @param {BuildOptionsInit | undefined} options
+     */
+    constructor(options) {
+        let ret;
+        ret = wasm.wasmbuilder_new(options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        Object.defineProperty(this, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+        WasmBuilderFinalization.register(this, { ptr: ret[0], instance: __wbg_instance_id }, this);
+        return this;
+    }
+    /**
+     * Adds outline items (with their children); returns their IDs in pre-order.
+     *
+     * # Errors
+     * `builder-finished`; `invalid-argument`; `limit-exceeded`.
+     * @param {OutlineEntryInit[]} entries
+     * @returns {string[]}
+     */
+    outline(entries) {
+        let ret;
+        ret = wasm.wasmbuilder_outline(this.__wbg_ptr, entries);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The page labels, ranges by first page (checked at [`WasmBuilder::finish`]).
+     *
+     * # Errors
+     * `builder-finished`; `invalid-argument`.
+     * @param {PageLabelInit[]} ranges
+     */
+    pageLabels(ranges) {
+        let ret;
+        ret = wasm.wasmbuilder_pageLabels(this.__wbg_ptr, ranges);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * A page of `width` × `height` points, written by [`WasmPageBuilder::finish`].
+     * @param {number} width
+     * @param {number} height
+     * @returns {WasmPageBuilder}
+     */
+    page(width, height) {
+        let ret;
+        ret = wasm.wasmbuilder_page(this.__wbg_ptr, width, height);
+        return WasmPageBuilder.__wrap(ret);
+    }
+    /**
+     * One of the standard 14 fonts, by its PostScript name (`Helvetica`,
+     * `Times-Roman`, …): not embedded, Latin only, no shaping.
+     *
+     * # Errors
+     * `builder-finished`; `invalid-argument` for another name.
+     * @param {string} name
+     * @returns {WasmFont}
+     */
+    standardFont(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmbuilder_standardFont(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmFont.__wrap(ret[0]);
+    }
+    /**
+     * How viewers present the document when it opens.
+     *
+     * # Errors
+     * `builder-finished`; `invalid-argument`.
+     * @param {ViewerPreferencesInit} prefs
+     */
+    viewerPreferences(prefs) {
+        let ret;
+        ret = wasm.wasmbuilder_viewerPreferences(this.__wbg_ptr, prefs);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) WasmBuilder.prototype[Symbol.dispose] = WasmBuilder.prototype.free;
+
+/**
+ * An open PDF: read it, edit it with ops (with undo), save it. The binding of
+ * `laminapdf::Document`, method for method (F12).
+ */
+export class WasmDocument {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmDocument.prototype);
+        obj.__wbg_ptr = ptr;
+        Object.defineProperty(obj, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+
+        WasmDocumentFinalization.register(obj, { ptr, instance: __wbg_instance_id }, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmDocumentFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmdocument_free(ptr, 0);
+
+    }
+    /**
+     * Applies an op log (`{ "v": 1, "ops": [ … ] }`) as one transaction.
+     *
+     * # Errors
+     * `invalid-op-log`, `unsupported-version`; as [`WasmDocument::apply`].
+     * @param {string} json
+     * @returns {EditedJs}
+     */
+    applyLog(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmdocument_applyLog(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Applies `ops` (the op JSON of ADR 0006 §6) in order, as one transaction.
+     *
+     * # Errors
+     * `invalid-argument` / `unknown-option` for a value that isn't an op; the first op's
+     * error (nothing is applied).
+     * @param {Op[]} ops
+     * @returns {EditedJs}
+     */
+    apply(ops) {
+        let ret;
+        ret = wasm.wasmdocument_apply(this.__wbg_ptr, ops);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The document's text for retrieval and LLMs, as one string: Markdown, plain text, the
+     * `laminapdf.extract/1` JSON, or the chunks as a JSON array (the extract and text modules).
+     *
+     * # Errors
+     * `page-index-out-of-range` for a page in `pages` past the end; `data-pending` and the
+     * reading errors; `unknown-option` / `invalid-argument` for bad options.
+     * @param {ExtractInit} options
+     * @returns {string}
+     */
+    extract(options) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            let ret;
+            ret = wasm.wasmdocument_extract(this.__wbg_ptr, options);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Whether there are changes no save has written yet.
+     * @returns {boolean}
+     */
+    hasUnsavedChanges() {
+        let ret;
+        ret = wasm.wasmdocument_hasUnsavedChanges(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * The Info dictionary's text entries.
+     *
+     * # Errors
+     * Reading errors.
+     * @returns {DocumentInfoJs}
+     */
+    info() {
+        let ret;
+        ret = wasm.wasmdocument_info(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Opens a document from its bytes.
+     *
+     * # Errors
+     * The §1 object: `not-pdf`, `password-required`, `wrong-password`, `limit-exceeded`, …;
+     * `invalid-argument` / `unknown-option` for bad options.
+     * @param {Uint8Array} bytes
+     * @param {OpenOptionsInit | undefined} options
+     * @returns {WasmDocument}
+     */
+    static openBytes(bytes, options) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmdocument_openBytes(ptr0, len0, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmDocument.__wrap(ret[0]);
+    }
+    /**
+     * Opens a document over a sparse source whose bytes arrive later. Until the source holds
+     * what a call needs, the call throws `data-pending` with `data.ranges` (`[offset, length]`
+     * pairs): supply them and call again. Lazy reads on the document can do the same.
+     *
+     * # Errors
+     * As `openBytes`, and `data-pending`.
+     * @param {WasmSparseSource} source
+     * @param {OpenOptionsInit | undefined} options
+     * @returns {WasmDocument}
+     */
+    static openSource(source, options) {
+        _assertClass(source, WasmSparseSource);
+        let ret;
+        ret = wasm.wasmdocument_openSource(source.__wbg_ptr, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmDocument.__wrap(ret[0]);
+    }
+    /**
+     * A handle on the page with `id` (`p12.0`).
+     *
+     * # Errors
+     * `invalid-argument` for a malformed ID; `unknown-page`.
+     * @param {string} id
+     * @returns {WasmPage}
+     */
+    pageById(id) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmdocument_pageById(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmPage.__wrap(ret[0]);
+    }
+    /**
+     * The number of pages.
+     *
+     * # Errors
+     * Reading errors.
+     * @returns {number}
+     */
+    pageCount() {
+        let ret;
+        ret = wasm.wasmdocument_pageCount(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Page `index`'s facts.
+     *
+     * # Errors
+     * `page-index-out-of-range`; reading errors.
+     * @param {number} index
+     * @returns {PageInfoJs}
+     */
+    pageInfo(index) {
+        let ret;
+        ret = wasm.wasmdocument_pageInfo(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Every page's facts, in order (one page-tree walk).
+     *
+     * # Errors
+     * Reading errors.
+     * @returns {PageInfoJs[]}
+     */
+    pageInfos() {
+        let ret;
+        ret = wasm.wasmdocument_pageInfos(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * A handle on page `index` that follows the page by its ID (F2).
+     *
+     * # Errors
+     * `page-index-out-of-range`; reading errors.
+     * @param {number} index
+     * @returns {WasmPage}
+     */
+    page(index) {
+        let ret;
+        ret = wasm.wasmdocument_page(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmPage.__wrap(ret[0]);
+    }
+    /**
+     * Rebases onto `bytes`, the output of a save whose rebase failed (`not-rebased`).
+     *
+     * # Errors
+     * `no-pending-save`; reading errors in `bytes`.
+     * @param {Uint8Array} bytes
+     */
+    rebase(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmdocument_rebase(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Redoes the newest undone transaction; `undefined` when there is nothing to redo.
+     *
+     * # Errors
+     * As [`WasmDocument::undo`].
+     * @returns {UndoOutcomeJs | undefined}
+     */
+    redo() {
+        let ret;
+        ret = wasm.wasmdocument_redo(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * A save as a job, stepped with a budget of work units (ADR 0028 §3, §4).
+     *
+     * # Errors
+     * `invalid-argument` / `unknown-option` for bad options.
+     * @param {SaveOptionsInit | undefined} options
+     * @returns {WasmSaveJob}
+     */
+    saveJob(options) {
+        let ret;
+        ret = wasm.wasmdocument_saveJob(this.__wbg_ptr, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmSaveJob.__wrap(ret[0]);
+    }
+    /**
+     * Saves and rebases onto the output, running to completion: `{ bytes, report }`.
+     *
+     * # Errors
+     * The save's errors (`would-invalidate-signatures`, `requires-rewrite`, …).
+     * @param {SaveOptionsInit | undefined} options
+     * @returns {{ bytes: Uint8Array<ArrayBuffer>; report: SaveReportJs }}
+     */
+    save(options) {
+        let ret;
+        ret = wasm.wasmdocument_save(this.__wbg_ptr, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Undoes the newest transaction; `undefined` when there is nothing to undo.
+     *
+     * # Errors
+     * `nested-transaction`, `saved-not-rebased`; reading errors.
+     * @returns {UndoOutcomeJs | undefined}
+     */
+    undo() {
+        let ret;
+        ret = wasm.wasmdocument_undo(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * A cursor over the warnings so far (build warnings first), each as the §1 object.
+     * @returns {WasmWarningCursor}
+     */
+    warnings() {
+        let ret;
+        ret = wasm.wasmdocument_warnings(this.__wbg_ptr);
+        return WasmWarningCursor.__wrap(ret);
+    }
+}
+if (Symbol.dispose) WasmDocument.prototype[Symbol.dispose] = WasmDocument.prototype.free;
+
+/**
+ * A font registered with a [`WasmBuilder`].
+ */
+export class WasmFont {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmFont.prototype);
+        obj.__wbg_ptr = ptr;
+        Object.defineProperty(obj, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+
+        WasmFontFinalization.register(obj, { ptr, instance: __wbg_instance_id }, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmFontFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmfont_free(ptr, 0);
+
+    }
+    /**
+     * The family name.
+     * @returns {string}
+     */
+    get family() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            let ret;
+            ret = wasm.wasmfont_family(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Whether it is one of the standard 14 fonts (not embedded).
+     * @returns {boolean}
+     */
+    get isStandard() {
+        let ret;
+        ret = wasm.wasmfont_isStandard(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * The PostScript name.
+     * @returns {string}
+     */
+    get postscriptName() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            let ret;
+            ret = wasm.wasmfont_postscriptName(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) WasmFont.prototype[Symbol.dispose] = WasmFont.prototype.free;
+
+/**
+ * An image to draw (decoded or passed through once, shared by every use).
+ */
+export class WasmImage {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmImage.prototype);
+        obj.__wbg_ptr = ptr;
+        Object.defineProperty(obj, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+
+        WasmImageFinalization.register(obj, { ptr, instance: __wbg_instance_id }, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmImageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmimage_free(ptr, 0);
+
+    }
+    /**
+     * Height in pixels.
+     * @returns {number}
+     */
+    get height() {
+        let ret;
+        ret = wasm.wasmimage_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * A JPEG, passed through (`DCTDecode`).
+     *
+     * # Errors
+     * `invalid-image`, `unsupported-image`.
+     * @param {Uint8Array} bytes
+     * @returns {WasmImage}
+     */
+    static jpeg(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmimage_jpeg(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmImage.__wrap(ret[0]);
+    }
+    /**
+     * A PNG (alpha as an `/SMask`).
+     *
+     * # Errors
+     * `invalid-image`, `unsupported-image`, `image-too-large`.
+     * @param {Uint8Array} bytes
+     * @returns {WasmImage}
+     */
+    static png(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmimage_png(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmImage.__wrap(ret[0]);
+    }
+    /**
+     * Raw 8-bit RGBA pixels, row by row.
+     *
+     * # Errors
+     * `invalid-image` when the length isn't `width × height × 4`.
+     * @param {number} width
+     * @param {number} height
+     * @param {Uint8Array} rgba
+     * @returns {WasmImage}
+     */
+    static rgba(width, height, rgba) {
+        const ptr0 = passArray8ToWasm0(rgba, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmimage_rgba(width, height, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmImage.__wrap(ret[0]);
+    }
+    /**
+     * Width in pixels.
+     * @returns {number}
+     */
+    get width() {
+        let ret;
+        ret = wasm.wasmimage_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) WasmImage.prototype[Symbol.dispose] = WasmImage.prototype.free;
+
+/**
+ * A page of a [`WasmDocument`], held by its ID (F2): moving pages doesn't retarget it.
+ */
+export class WasmPage {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmPage.prototype);
+        obj.__wbg_ptr = ptr;
+        Object.defineProperty(obj, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+
+        WasmPageFinalization.register(obj, { ptr, instance: __wbg_instance_id }, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmPageFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmpage_free(ptr, 0);
+
+    }
+    /**
+     * The page's stable ID (`p12.0`).
+     * @returns {string}
+     */
+    get id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            let ret;
+            ret = wasm.wasmpage_id(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The page's current 0-based index.
+     *
+     * # Errors
+     * `unknown-page` when the page is gone; `disposed` when its document is freed; reading
+     * errors.
+     * @returns {number}
+     */
+    index() {
+        let ret;
+        ret = wasm.wasmpage_index(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * The page's facts now.
+     *
+     * # Errors
+     * As [`WasmPage::index`].
+     * @returns {PageInfoJs}
+     */
+    info() {
+        let ret;
+        ret = wasm.wasmpage_info(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The page's text: lines, runs, glyph quads and glyph text (the extract and text modules).
+     *
+     * # Errors
+     * `unknown-page` when the page is gone; `disposed` when its document is freed;
+     * `data-pending` and the reading errors; `unknown-option` / `invalid-argument` for bad
+     * options.
+     * @param {TextOptionsInit | undefined} options
+     * @returns {PageTextJs}
+     */
+    text(options) {
+        let ret;
+        ret = wasm.wasmpage_text(this.__wbg_ptr, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) WasmPage.prototype[Symbol.dispose] = WasmPage.prototype.free;
+
+/**
+ * One page being drawn, in page space (points from the top-left, y down; ADR 0027).
+ * Invalid geometry is reported by [`WasmPageBuilder::finish`] (`invalid-geometry`).
+ */
+export class WasmPageBuilder {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmPageBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        Object.defineProperty(obj, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+
+        WasmPageBuilderFinalization.register(obj, { ptr, instance: __wbg_instance_id }, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmPageBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmpagebuilder_free(ptr, 0);
+
+    }
+    /**
+     * Opens an artifact until the matching `endTag`: `kind` is `layout`, `page`, `pagination`
+     * or `background`.
+     *
+     * # Errors
+     * `invalid-argument` for another kind.
+     * @param {string} kind
+     */
+    beginArtifact(kind) {
+        const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_beginArtifact(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Opens a structure element until the matching `endTag`: `kind` names a standard type
+     * (`Document`, `Part`, `Sect`, `H1`–`H6`, `P`, `L`, `LI`, `Lbl`, `LBody`, `Table`, `TR`,
+     * `TH`, `TD`, `Figure`, `Caption`, `Link`, `Span`, `Quote`, `Note`, `Code`), the role of
+     * `custom` when given; `/Alt`, `/ActualText`, `/Lang`, `/E`; `scope` is `row`, `column` or
+     * `both` when given.
+     *
+     * # Errors
+     * `invalid-argument` for an unknown `kind` or `scope`.
+     * @param {string} kind
+     * @param {string | null} [custom]
+     * @param {string | null} [alt]
+     * @param {string | null} [actualText]
+     * @param {string | null} [lang]
+     * @param {string | null} [expansion]
+     * @param {string | null} [scope]
+     */
+    beginTag(kind, custom, alt, actualText, lang, expansion, scope) {
+        const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(custom) ? 0 : passStringToWasm0(custom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(alt) ? 0 : passStringToWasm0(alt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(actualText) ? 0 : passStringToWasm0(actualText, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        var ptr4 = isLikeNone(lang) ? 0 : passStringToWasm0(lang, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len4 = WASM_VECTOR_LEN;
+        var ptr5 = isLikeNone(expansion) ? 0 : passStringToWasm0(expansion, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len5 = WASM_VECTOR_LEN;
+        var ptr6 = isLikeNone(scope) ? 0 : passStringToWasm0(scope, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len6 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_beginTag(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The blend mode, camelCase (`multiply`, `colorDodge`, …).
+     *
+     * # Errors
+     * `invalid-argument` for an unknown mode.
+     * @param {string} mode
+     */
+    blendMode(mode) {
+        const ptr0 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_blendMode(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Clips to `path` (with `rule`) until the next `restore`.
+     *
+     * # Errors
+     * As [`WasmPageBuilder::fill_path`].
+     * @param {Float64Array} path
+     * @param {string} rule
+     */
+    clipPath(path, rule) {
+        const ptr0 = passArrayF64ToWasm0(path, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(rule, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_clipPath(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Ends the innermost open element or artifact (none open: nothing happens).
+     *
+     * # Errors
+     * `builder-finished`.
+     */
+    endTag() {
+        let ret;
+        ret = wasm.wasmpagebuilder_endTag(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The fill colour as `#rrggbb` or `#rgb` (`DeviceRGB`).
+     *
+     * # Errors
+     * `invalid-color`.
+     * @param {string} hex
+     */
+    fillColorHex(hex) {
+        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_fillColorHex(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The colour fills use: 1 (gray), 3 (RGB) or 4 (CMYK) components, 0 to 1.
+     *
+     * # Errors
+     * `invalid-argument` for another number of components.
+     * @param {Float64Array} components
+     */
+    fillColor(components) {
+        const ptr0 = passArrayF64ToWasm0(components, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_fillColor(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Fills `path` (the flat path encoding) with `rule` (`nonZero` or `evenOdd`).
+     *
+     * # Errors
+     * `invalid-argument` for a bad path or rule.
+     * @param {Float64Array} path
+     * @param {string} rule
+     */
+    fillPath(path, rule) {
+        const ptr0 = passArrayF64ToWasm0(path, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(rule, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_fillPath(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Fills `path` with `rule`, then strokes it with the current stroke style.
+     *
+     * # Errors
+     * As [`WasmPageBuilder::fill_path`].
+     * @param {Float64Array} path
+     * @param {string} rule
+     */
+    fillStrokePath(path, rule) {
+        const ptr0 = passArrayF64ToWasm0(path, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(rule, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_fillStrokePath(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Writes the page into its builder: content stream, resources and page dictionary.
+     * Returns its page ID. The page is finished afterwards: every later call on it fails
+     * with `builder-finished`.
+     *
+     * # Errors
+     * `builder-finished` (the page or its builder already finished); `invalid-geometry` for
+     * the first invalid value drawn; `unknown-font` for a font from another builder.
+     * @returns {string}
+     */
+    finish() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            let ret;
+            ret = wasm.wasmpagebuilder_finish(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Draws `image` scaled into the rectangle.
+     *
+     * # Errors
+     * `builder-finished`.
+     * @param {WasmImage} image
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     */
+    image(image, x, y, width, height) {
+        _assertClass(image, WasmImage);
+        let ret;
+        ret = wasm.wasmpagebuilder_image(this.__wbg_ptr, image.__wbg_ptr, x, y, width, height);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * A link annotation over the rectangle, with `contents` as its alternate text.
+     *
+     * # Errors
+     * `invalid-argument` / `unknown-option` for a bad target.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {LinkTargetInit} target
+     * @param {string | null} [contents]
+     */
+    link(x, y, width, height, target, contents) {
+        var ptr0 = isLikeNone(contents) ? 0 : passStringToWasm0(contents, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_link(this.__wbg_ptr, x, y, width, height, target, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Fill and stroke opacity, 0 to 1 (an `ExtGState`).
+     *
+     * # Errors
+     * `builder-finished`.
+     * @param {number} fill
+     * @param {number} stroke
+     */
+    opacity(fill, stroke) {
+        let ret;
+        ret = wasm.wasmpagebuilder_opacity(this.__wbg_ptr, fill, stroke);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Restores the graphics state (`Q`); one without a matching save is ignored.
+     *
+     * # Errors
+     * `builder-finished`.
+     */
+    restore() {
+        let ret;
+        ret = wasm.wasmpagebuilder_restore(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * `/Rotate`: 0, 90, 180 or 270 degrees.
+     *
+     * # Errors
+     * `invalid-argument` for another angle.
+     * @param {number} degrees
+     */
+    rotate(degrees) {
+        let ret;
+        ret = wasm.wasmpagebuilder_rotate(this.__wbg_ptr, degrees);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Saves the graphics state (`q`).
+     *
+     * # Errors
+     * `builder-finished` after [`WasmPageBuilder::finish`] (so does every drawing method).
+     */
+    save() {
+        let ret;
+        ret = wasm.wasmpagebuilder_save(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * `/CropBox`, `/BleedBox`, `/TrimBox` or `/ArtBox` (`kind`: `crop`, `bleed`, `trim`,
+     * `art`), in the media box's page space.
+     *
+     * # Errors
+     * `invalid-argument` for another kind.
+     * @param {"crop" | "bleed" | "trim" | "art"} kind
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     */
+    setBox(kind, x, y, width, height) {
+        const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_setBox(this.__wbg_ptr, ptr0, len0, x, y, width, height);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The stroke colour as `#rrggbb` or `#rgb`.
+     *
+     * # Errors
+     * `invalid-color`.
+     * @param {string} hex
+     */
+    strokeColorHex(hex) {
+        const ptr0 = passStringToWasm0(hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_strokeColorHex(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The colour strokes use (as [`WasmPageBuilder::fill_color`]).
+     *
+     * # Errors
+     * As [`WasmPageBuilder::fill_color`].
+     * @param {Float64Array} components
+     */
+    strokeColor(components) {
+        const ptr0 = passArrayF64ToWasm0(components, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_strokeColor(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Strokes `path` with the current stroke style.
+     *
+     * # Errors
+     * `invalid-argument` for a bad path.
+     * @param {Float64Array} path
+     */
+    strokePath(path) {
+        const ptr0 = passArrayF64ToWasm0(path, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_strokePath(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The style later strokes use: `width` (points), `cap` (`butt`, `round`, `square`),
+     * `join` (`miter`, `round`, `bevel`), the miter limit and a dash pattern (empty: solid).
+     *
+     * # Errors
+     * `invalid-argument` for an unknown cap or join.
+     * @param {number} width
+     * @param {string} cap
+     * @param {string} join
+     * @param {number} miterLimit
+     * @param {Float64Array} dash
+     * @param {number} dashPhase
+     */
+    strokeStyle(width, cap, join, miterLimit, dash, dashPhase) {
+        const ptr0 = passStringToWasm0(cap, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(join, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF64ToWasm0(dash, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_strokeStyle(this.__wbg_ptr, width, ptr0, len0, ptr1, len1, miterLimit, ptr2, len2, dashPhase);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Lays `text` out in `rect` (lines broken at Unicode line-break opportunities) and
+     * draws it.
+     *
+     * # Errors
+     * As [`WasmPageBuilder::text`]; `text-overflow` with `overflow: "error"`.
+     * @param {string} text
+     * @param {WasmFont} font
+     * @param {number} size
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {TextBoxOptionsInit | undefined} options
+     * @returns {TextLayoutJs}
+     */
+    textBox(text, font, size, x, y, width, height, options) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(font, WasmFont);
+        let ret;
+        ret = wasm.wasmpagebuilder_textBox(this.__wbg_ptr, ptr0, len0, font.__wbg_ptr, size, x, y, width, height, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Draws `text` in `font` at `size` points with the baseline at `y` (ADR 0027 §5):
+     * shaped, bidi-resolved, one line per line break.
+     *
+     * # Errors
+     * `missing-glyph`, `font-not-shapable`, `invalid-feature`, `invalid-geometry`;
+     * `invalid-argument` for bad options.
+     * @param {string} text
+     * @param {WasmFont} font
+     * @param {number} size
+     * @param {number} x
+     * @param {number} y
+     * @param {TextOptionsInit | undefined} options
+     * @returns {TextRunJs}
+     */
+    text(text, font, size, x, y, options) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(font, WasmFont);
+        let ret;
+        ret = wasm.wasmpagebuilder_text(this.__wbg_ptr, ptr0, len0, font.__wbg_ptr, size, x, y, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Applies `[a, b, c, d, e, f]` (page space) to what is drawn next.
+     *
+     * # Errors
+     * `invalid-argument` unless there are 6 numbers.
+     * @param {Float64Array} m
+     */
+    transform(m) {
+        const ptr0 = passArrayF64ToWasm0(m, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmpagebuilder_transform(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * `/UserUnit`, for pages larger than 14,400 units.
+     * @param {number} unit
+     */
+    userUnit(unit) {
+        wasm.wasmpagebuilder_userUnit(this.__wbg_ptr, unit);
+    }
+}
+if (Symbol.dispose) WasmPageBuilder.prototype[Symbol.dispose] = WasmPageBuilder.prototype.free;
+
+/**
+ * A save in progress (F10). Each `step` checks that the document is unchanged since the
+ * job was created (`document-changed`).
+ */
+export class WasmSaveJob {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmSaveJob.prototype);
+        obj.__wbg_ptr = ptr;
+        Object.defineProperty(obj, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+
+        WasmSaveJobFinalization.register(obj, { ptr, instance: __wbg_instance_id }, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSaveJobFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsavejob_free(ptr, 0);
+
+    }
+    /**
+     * Stops the job: its next step fails with `cancelled`.
+     */
+    cancel() {
+        wasm.wasmsavejob_cancel(this.__wbg_ptr);
+    }
+    /**
+     * Runs at most `budget` work units: `{ state: "progress", done, total?, phase }` or
+     * `{ state: "done", bytes, report }`.
+     *
+     * # Errors
+     * `cancelled`, `document-changed`, `job-finished`, `disposed` when the document is freed,
+     * or the save's own errors.
+     * @param {number} budget
+     * @returns {({ state: "progress" } & ProgressJs) | { state: "done"; bytes: Uint8Array<ArrayBuffer>; report: SaveReportJs }}
+     */
+    step(budget) {
+        let ret;
+        ret = wasm.wasmsavejob_step(this.__wbg_ptr, budget);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) WasmSaveJob.prototype[Symbol.dispose] = WasmSaveJob.prototype.free;
+
+/**
+ * A PDF of known size whose bytes arrive later: give it to `WasmDocument.openSource`, and
+ * after a `data-pending` error `supply` the ranges in its `data.ranges` and call again.
+ */
+export class WasmSparseSource {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSparseSourceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsparsesource_free(ptr, 0);
+
+    }
+    /**
+     * An empty source of `size` bytes holding at most `budget` bytes (no limit when omitted).
+     *
+     * # Errors
+     * `invalid-argument` when a number isn't a whole number of bytes.
+     * @param {number} size
+     * @param {number | null} [budget]
+     */
+    constructor(size, budget) {
+        let ret;
+        ret = wasm.wasmsparsesource_new(size, !isLikeNone(budget), isLikeNone(budget) ? 0 : budget);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        Object.defineProperty(this, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+        WasmSparseSourceFinalization.register(this, { ptr: ret[0], instance: __wbg_instance_id }, this);
+        return this;
+    }
+    /**
+     * The source's size in bytes.
+     * @returns {number}
+     */
+    get size() {
+        let ret;
+        ret = wasm.wasmsparsesource_size(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Adds `bytes` at `offset` (bytes already held win over overlapping ones).
+     *
+     * # Errors
+     * `invalid-argument` past the end; `source-budget-exceeded` over the budget.
+     * @param {number} offset
+     * @param {Uint8Array} bytes
+     */
+    supply(offset, bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmsparsesource_supply(this.__wbg_ptr, offset, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * What to fetch for the ranges a `data-pending` asked for (flat `[start, end, …]`): each
+     * widened to blocks of `block` bytes (0: as asked) plus `readahead`, merged, minus what is
+     * held, in the same flat form. The planning step of `laminapdf-source`'s `retry`, so every
+     * loop plans the same way.
+     *
+     * # Errors
+     * `invalid-argument` for an odd length or a value that isn't a whole number of bytes.
+     * @param {Float64Array} asked
+     * @param {number} block
+     * @param {number} readahead
+     * @returns {Float64Array}
+     */
+    toFetch(asked, block, readahead) {
+        const ptr0 = passArrayF64ToWasm0(asked, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmsparsesource_toFetch(this.__wbg_ptr, ptr0, len0, block, readahead);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) WasmSparseSource.prototype[Symbol.dispose] = WasmSparseSource.prototype.free;
+
+/**
+ * The warnings of a document, read in batches (F8).
+ */
+export class WasmWarningCursor {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmWarningCursor.prototype);
+        obj.__wbg_ptr = ptr;
+        Object.defineProperty(obj, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+
+        WasmWarningCursorFinalization.register(obj, { ptr, instance: __wbg_instance_id }, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmWarningCursorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmwarningcursor_free(ptr, 0);
+
+    }
+    /**
+     * Up to `max` more warnings, each as the ADR 0026 §1 object; empty at the end.
+     * @param {number} max
+     * @returns {Diagnostic[]}
+     */
+    nextBatch(max) {
+        let ret;
+        ret = wasm.wasmwarningcursor_nextBatch(this.__wbg_ptr, max);
+        return ret;
+    }
+    /**
+     * How many warnings are left.
+     * @returns {number}
+     */
+    remaining() {
+        let ret;
+        ret = wasm.wasmwarningcursor_remaining(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) WasmWarningCursor.prototype[Symbol.dispose] = WasmWarningCursor.prototype.free;
+
+export function __wbg_reset_state () {
+    __wbg_instance_id++;
+    cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    if (typeof numBytesDecoded !== 'undefined') numBytesDecoded = 0;
+    if (typeof WASM_VECTOR_LEN !== 'undefined') WASM_VECTOR_LEN = 0;
+    __wbg_reinit_scheduled = false;
+    wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+    wasm = wasmInstance.exports;
+    wasm.__wbindgen_start();
+}
+
+/**
+ * Whether the most recent allocation failed: after a trap, `true` means the module ran out of
+ * memory.
+ * @returns {boolean}
+ */
+export function allocationFailed() {
+    let ret;
+    ret = wasm.allocationFailed();
+    return ret !== 0;
+}
+
+/**
+ * Whether this module is the text module (fonts, `text`, `textBox`).
+ * @returns {boolean}
+ */
+export function hasText() {
+    let ret;
+    ret = wasm.hasText();
+    return ret !== 0;
+}
+
+/**
+ * The crate version (`@laminapdf/wasm`'s).
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        let ret;
+        ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_is_null_e343b7d08827ba72: function(arg0) {
+            const ret = arg0 === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_3c45d4f2dde4e749: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
+            const ret = arg0 === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_string_get_0380ccaa2f57f0d9: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_keys_440be172f17c0265: function(arg0) {
+            const ret = Object.keys(arg0);
+            return ret;
+        },
+        __wbg_new_617a8cdb8bb1130e: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_from_slice_37a3c3a194266cb8: function(arg0, arg1) {
+            const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_from_slice_9a868026ffa4208a: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_from_slice_ca6ad97db1f4779a: function(arg0, arg1) {
+            const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_from_slice_f545fd22ddc142b8: function(arg0, arg1) {
+            const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_parse_0fc53dead14b3b42: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return ret;
+        }, arguments); },
+        __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_slice_6da4cdc5d543fcd0: function(arg0, arg1) {
+            const ret = arg1.slice();
+            const ptr1 = passArrayJsValueToWasm0(ret, wasm.__wbindgen_malloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_stringify_52ff602c1cc4fbb6: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(arg0);
+            return ret;
+        }, arguments); },
+        __wbindgen_generic_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./lamina_pdf_text_bg.js": import0,
+    };
+}
+
+function __wbg_call_guard() {
+    if (__wbg_reinit_scheduled) {
+        __wbg_reset_state();
+        return;
+    }
+}
+
+
+let __wbg_instance_id = 0;
+const WasmBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmbuilder_free(ptr, 1);
+});
+const WasmDocumentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmdocument_free(ptr, 1);
+});
+const WasmFontFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmfont_free(ptr, 1);
+});
+const WasmImageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmimage_free(ptr, 1);
+});
+const WasmPageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmpage_free(ptr, 1);
+});
+const WasmPageBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmpagebuilder_free(ptr, 1);
+});
+const WasmSaveJobFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmsavejob_free(ptr, 1);
+});
+const WasmSparseSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmsparsesource_free(ptr, 1);
+});
+const WasmWarningCursorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmwarningcursor_free(ptr, 1);
+});
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let __wbg_reinit_scheduled = false;
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('lamina_pdf_text.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };