@laminapdf/wasm 0.2.0-alpha.6 → 0.3.0

package/dist/lamina_pdf_text.js

@@ -75,6 +75,30 @@ export class WasmBuilder {
         }
         return WasmDocument.__wrap(ret[0]);
     }
+    /**
+     * Lays `document` out as tagged pages that flow, after any pages already added, filled from
+     * `options.data` first when it is given. The document's profiles are the builder's to set
+     * (`profiles` in its options); its warnings are the finished document's.
+     *
+     * # Errors
+     * `builder-finished`; `unknown-option`, `invalid-argument`; `invalid-document` with the JSON
+     * Pointer at fault and the closest keys in `didYouMean`; `template-data-missing`,
+     * `template-data-type`, `template-too-large`; `unknown-font` and `unknown-image` for a name
+     * `resources` lacks; `missing-glyph`, `flow-content-too-large`.
+     * @param {unknown} document
+     * @param {WasmFlowResources} resources
+     * @param {FlowOptionsInit | undefined} options
+     * @returns {FlowReportJs}
+     */
+    flow(document, resources, options) {
+        _assertClass(resources, WasmFlowResources);
+        let ret;
+        ret = wasm.wasmbuilder_flow(this.__wbg_ptr, document, resources.__wbg_ptr, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Loads a font from its bytes (TrueType or OpenType/CFF) and registers it; it is
      * subset to the glyphs drawn.
@@ -287,6 +311,48 @@ export class WasmDocument {
         wasm.__wbg_wasmdocument_free(ptr, 0);
 
     }
+    /**
+     * Adds another PDF as a source document: `{ id, pages }`, its ID (64 hex digits, the
+     * SHA-256 of `bytes`) and its page IDs in order. An encrypted one opens with `password`,
+     * which no op ever holds.
+     *
+     * # Errors
+     * `wrong-password`, `password-required`, and the errors of a file that doesn't open.
+     * @param {Uint8Array} bytes
+     * @param {string | null} [password]
+     * @returns {{ id: string; pages: string[] }}
+     */
+    addSource(bytes, password) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(password) ? 0 : passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmdocument_addSource(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Makes `bytes`, the whole output of `saveCopy`, the document's saved file (it rebases onto
+     * them), once they are written where the document lives; `historyCleared` is the copy's
+     * report's.
+     *
+     * # Errors
+     * `nested-transaction`, `saved-not-rebased`; `not-rebased` when `bytes` can't be read.
+     * @param {Uint8Array} bytes
+     * @param {boolean} historyCleared
+     */
+    adoptCopy(bytes, historyCleared) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmdocument_adoptCopy(this.__wbg_ptr, ptr0, len0, historyCleared);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Applies an op log (`{ "v": 1, "ops": [ … ] }`) as one transaction.
      *
@@ -322,6 +388,24 @@ export class WasmDocument {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * `view` (page space) on page `page` as the destination the outline and named-destination
+     * ops take, in the page's user space (the extract and text modules).
+     *
+     * # Errors
+     * `invalid-argument` for a view that isn't one; `page-index-out-of-range`; reading errors.
+     * @param {number} page
+     * @param {TargetViewJs} view
+     * @returns {ExplicitDestination}
+     */
+    destinationAt(page, view) {
+        let ret;
+        ret = wasm.wasmdocument_destinationAt(this.__wbg_ptr, page, view);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * An extraction stepped a page at a time, whose models the host runs: each step returns
      * its progress, with the result it waits for under `request` (render that page at `dpi`,
@@ -341,6 +425,23 @@ export class WasmDocument {
         }
         return WasmExtractJob.__wrap(ret[0]);
     }
+    /**
+     * A new document of `pages` of this one, in the order given.
+     *
+     * # Errors
+     * `invalid-argument` for a value that isn't a list of page IDs, `unknown-page`; reading
+     * errors.
+     * @param {string[]} pages
+     * @returns {WasmDocument}
+     */
+    extractPages(pages) {
+        let ret;
+        ret = wasm.wasmdocument_extractPages(this.__wbg_ptr, pages);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmDocument.__wrap(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).
@@ -394,6 +495,21 @@ export class WasmDocument {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * How the document asks to be shown when it opens (the extract and text modules).
+     *
+     * # Errors
+     * `data-pending` and the reading errors.
+     * @returns {InitialViewJs}
+     */
+    initialView() {
+        let ret;
+        ret = wasm.wasmdocument_initialView(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Whether the file is encrypted (it opened with its password, or the empty one).
      * @returns {boolean}
@@ -418,6 +534,42 @@ export class WasmDocument {
         }
         return ret[0] !== 0;
     }
+    /**
+     * A new document of `inputs` (each `{ bytes, password?, title? }`) one after another,
+     * with their bookmarks, named destinations, form fields, layers and page labels; `options`
+     * as `mergeDocuments`' (`outline`, `fields`).
+     *
+     * # Errors
+     * `invalid-argument` / `unknown-option` for bad values, `wrong-password`,
+     * `password-required`, and the errors of a file that doesn't open.
+     * @param {{ bytes: Uint8Array; password?: string; title?: string }[]} inputs
+     * @param {MergeOptions | undefined} options
+     * @returns {WasmDocument}
+     */
+    static merge(inputs, options) {
+        let ret;
+        ret = wasm.wasmdocument_merge(inputs, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmDocument.__wrap(ret[0]);
+    }
+    /**
+     * The document's metadata, read from Info and XMP together, with the fields where they
+     * disagree.
+     *
+     * # Errors
+     * Reading errors.
+     * @returns {DocumentMetadata}
+     */
+    metadata() {
+        let ret;
+        ret = wasm.wasmdocument_metadata(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * The named destination `name`, or `undefined` when the document has none by that name or
      * it names no page here (the extract and text modules).
@@ -437,6 +589,21 @@ export class WasmDocument {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Every named destination, sorted by name (the extract and text modules).
+     *
+     * # Errors
+     * `data-pending` and the reading errors.
+     * @returns {NamedDestinationJs[]}
+     */
+    namedDestinations() {
+        let ret;
+        ret = wasm.wasmdocument_namedDestinations(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Opens a document from its bytes.
      *
@@ -493,6 +660,23 @@ export class WasmDocument {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * The annotations on page `index`, in the order of its `/Annots`, every subtype included
+     * (the extract and text modules).
+     *
+     * # Errors
+     * `page-index-out-of-range`, `data-pending` and the reading errors.
+     * @param {number} index
+     * @returns {PageAnnotationJs[]}
+     */
+    pageAnnotations(index) {
+        let ret;
+        ret = wasm.wasmdocument_pageAnnotations(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * A handle on the page with `id` (`p12.0`).
      *
@@ -589,6 +773,22 @@ export class WasmDocument {
         }
         return WasmPage.__wrap(ret[0]);
     }
+    /**
+     * How a save with `options` would go, without saving.
+     *
+     * # Errors
+     * `invalid-argument` / `unknown-option` for bad options; reading errors.
+     * @param {SaveOptionsInit | undefined} options
+     * @returns {PlannedSaveJs}
+     */
+    plan(options) {
+        let ret;
+        ret = wasm.wasmdocument_plan(this.__wbg_ptr, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * The document's properties (the extract and text modules). Reads every object once.
      *
@@ -636,6 +836,23 @@ export class WasmDocument {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Writes what `save` would and leaves the document as it was: not rebased, its changes
+     * still unsaved, the save-time stamp in the copy only (Save a copy).
+     *
+     * # Errors
+     * As `save`; the document is unchanged either way.
+     * @param {SaveOptionsInit | undefined} options
+     * @returns {{ bytes: Uint8Array<ArrayBuffer>; report: SaveReportJs }}
+     */
+    saveCopy(options) {
+        let ret;
+        ret = wasm.wasmdocument_saveCopy(this.__wbg_ptr, options);
+        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).
      *
@@ -668,6 +885,26 @@ export class WasmDocument {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * This document cut into new ones: `{ count: n }` parts of `n` pages, `{ ranges: [[id, …],
+     * …] }` one part per list of page IDs, or `{ bookmarks: level }` a part from each bookmark
+     * at that depth (1: the top level). Each part carries what its pages reach and the
+     * bookmarks that go to them.
+     *
+     * # Errors
+     * `invalid-argument` / `unknown-option` for a value that isn't one of those, `unknown-page`,
+     * `no-pages-left` for an empty list; reading errors.
+     * @param {{ readonly count: number } | { readonly ranges: readonly (readonly string[])[] } | { readonly bookmarks: number }} by
+     * @returns {WasmDocument[]}
+     */
+    split(by) {
+        let ret;
+        ret = wasm.wasmdocument_split(this.__wbg_ptr, by);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * The structure tree's top-level elements in reading order, or `undefined` without one (the
      * extract and text modules, beside `WasmPage.text`, whose runs it links by MCID).
@@ -684,6 +921,21 @@ export class WasmDocument {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * The document's article threads; empty without any (the extract and text modules).
+     *
+     * # Errors
+     * `data-pending` and the reading errors.
+     * @returns {ThreadJs[]}
+     */
+    threads() {
+        let ret;
+        ret = wasm.wasmdocument_threads(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Undoes the newest transaction: how it went and the pages it touched; `undefined` when
      * there is nothing to undo.
@@ -709,6 +961,37 @@ export class WasmDocument {
         ret = wasm.wasmdocument_warnings(this.__wbg_ptr);
         return WasmWarningCursor.__wrap(ret);
     }
+    /**
+     * The signature restrictions `op` would break if it were applied and saved.
+     *
+     * # Errors
+     * `invalid-argument` for a value that isn't an op; reading errors.
+     * @param {Op} op
+     * @returns {ViolationJs[]}
+     */
+    wouldViolate(op) {
+        let ret;
+        ret = wasm.wasmdocument_wouldViolate(this.__wbg_ptr, op);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The document's XMP packet as text, with the edits made so far.
+     *
+     * # Errors
+     * Reading errors.
+     * @returns {XmpTextJs}
+     */
+    xmpPacket() {
+        let ret;
+        ret = wasm.wasmdocument_xmpPacket(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
 }
 if (Symbol.dispose) WasmDocument.prototype[Symbol.dispose] = WasmDocument.prototype.free;
 
@@ -779,6 +1062,57 @@ export class WasmExtractJob {
 }
 if (Symbol.dispose) WasmExtractJob.prototype[Symbol.dispose] = WasmExtractJob.prototype.free;
 
+/**
+ * The fonts and images a document names, by the names it gives them.
+ */
+export class WasmFlowResources {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmFlowResourcesFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmflowresources_free(ptr, 0);
+
+    }
+    /**
+     * `font` for the styles that name `name`; the same name again replaces it.
+     * @param {string} name
+     * @param {WasmFont} font
+     */
+    font(name, font) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(font, WasmFont);
+        wasm.wasmflowresources_font(this.__wbg_ptr, ptr0, len0, font.__wbg_ptr);
+    }
+    /**
+     * `image` for the figures that name `name`; the same name again replaces it.
+     * @param {string} name
+     * @param {WasmImage} image
+     */
+    image(name, image) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(image, WasmImage);
+        wasm.wasmflowresources_image(this.__wbg_ptr, ptr0, len0, image.__wbg_ptr);
+    }
+    /**
+     * No fonts and no images.
+     */
+    constructor() {
+        let ret;
+        ret = wasm.wasmflowresources_new();
+        this.__wbg_ptr = ret;
+        Object.defineProperty(this, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+        WasmFlowResourcesFinalization.register(this, { ptr: ret, instance: __wbg_instance_id }, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WasmFlowResources.prototype[Symbol.dispose] = WasmFlowResources.prototype.free;
+
 /**
  * A font registered with a [`WasmBuilder`].
  */
@@ -948,6 +1282,44 @@ export class WasmImage {
 }
 if (Symbol.dispose) WasmImage.prototype[Symbol.dispose] = WasmImage.prototype.free;
 
+/**
+ * The images of [`images_to_pdf`], in page order. Images are JavaScript-owned objects, which a
+ * record can't carry, so they are added one by one.
+ */
+export class WasmImageList {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmImageListFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmimagelist_free(ptr, 0);
+
+    }
+    /**
+     * An empty list.
+     */
+    constructor() {
+        let ret;
+        ret = wasm.wasmimagelist_new();
+        this.__wbg_ptr = ret;
+        Object.defineProperty(this, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+        WasmImageListFinalization.register(this, { ptr: ret, instance: __wbg_instance_id }, this);
+        return this;
+    }
+    /**
+     * Adds `image` as the next page. The image stays usable: the list holds its own copy.
+     * @param {WasmImage} image
+     */
+    push(image) {
+        _assertClass(image, WasmImage);
+        wasm.wasmimagelist_push(this.__wbg_ptr, image.__wbg_ptr);
+    }
+}
+if (Symbol.dispose) WasmImageList.prototype[Symbol.dispose] = WasmImageList.prototype.free;
+
 /**
  * The fonts and images of a Markdown build, by role and by the target the Markdown names.
  */
@@ -1814,6 +2186,27 @@ export function hasText() {
     return ret !== 0;
 }
 
+/**
+ * A new document with one page per image of `images`, in order: a JPEG embedded as it is, a PNG
+ * with its transparency, each drawn the way up its EXIF orientation says.
+ *
+ * # Errors
+ * `invalid-geometry` for no images, a negative margin or resolution, or a page too small for its
+ * margins; `unknown-option`, `invalid-argument` for bad options.
+ * @param {WasmImageList} images
+ * @param {ImagesOptionsInit | undefined} options
+ * @returns {WasmDocument}
+ */
+export function imagesToPdf(images, options) {
+    _assertClass(images, WasmImageList);
+    let ret;
+    ret = wasm.imagesToPdf(images.__wbg_ptr, options);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDocument.__wrap(ret[0]);
+}
+
 /**
  * The crate version (`@laminapdf/wasm`'s).
  * @returns {string}
@@ -1858,14 +2251,48 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
+        __wbg_get_31af05bd4842a84f: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_828cef2aaacafc31: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_e15a2ff68ffdbef2: function(arg0) {
+            const ret = Array.isArray(arg0);
+            return ret;
+        },
         __wbg_keys_440be172f17c0265: function(arg0) {
             const ret = Object.keys(arg0);
             return ret;
         },
+        __wbg_length_7f3c00c40364105e: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_d4bdea10311bd9cf: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_new_617a8cdb8bb1130e: function() {
             const ret = new Object();
             return ret;
         },
+        __wbg_new_ee2291f50781bf1d: function() {
+            const ret = new Array();
+            return ret;
+        },
         __wbg_new_from_slice_37a3c3a194266cb8: function(arg0, arg1) {
             const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
             return ret;
@@ -1886,6 +2313,13 @@ function __wbg_get_imports() {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
         }, arguments); },
+        __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_push_2baf45db356cf468: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
         __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
@@ -1901,6 +2335,10 @@ function __wbg_get_imports() {
             const ret = JSON.stringify(arg0);
             return ret;
         }, arguments); },
+        __wbg_wasmdocument_new: function(arg0) {
+            const ret = WasmDocument.__wrap(arg0);
+            return ret;
+        },
         __wbindgen_generic_0000000000000001: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
@@ -1951,6 +2389,11 @@ const WasmExtractJobFinalization = (typeof FinalizationRegistry === 'undefined')
     : new FinalizationRegistry(({ ptr, instance }) => {
     if (instance === __wbg_instance_id) wasm.__wbg_wasmextractjob_free(ptr, 1);
 });
+const WasmFlowResourcesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmflowresources_free(ptr, 1);
+});
 const WasmFontFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(({ ptr, instance }) => {
@@ -1961,6 +2404,11 @@ const WasmImageFinalization = (typeof FinalizationRegistry === 'undefined')
     : new FinalizationRegistry(({ ptr, instance }) => {
     if (instance === __wbg_instance_id) wasm.__wbg_wasmimage_free(ptr, 1);
 });
+const WasmImageListFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmimagelist_free(ptr, 1);
+});
 const WasmMarkdownOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(({ ptr, instance }) => {

package/dist/lamina_pdf_tiff.d.ts

@@ -0,0 +1,71 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A TIFF file being written, one page per [`TiffFile::add_page`].
+ */
+export class TiffFile {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Adds a page of `width` × `height` straight RGBA pixels, row by row, drawn at `dpi`.
+     *
+     * # Errors
+     * `invalid-argument` when `rgba` isn't `width × height × 4` bytes, `dpi` isn't
+     * positive, or the file is finished; `export-failed` if the encoder fails.
+     */
+    addPage(width: number, height: number, rgba: Uint8Array, dpi: number): void;
+    /**
+     * The file's bytes. The file is finished: it takes no more pages.
+     *
+     * # Errors
+     * `invalid-argument` when it was already finished.
+     */
+    finish(): Uint8Array;
+    /**
+     * An empty file.
+     *
+     * # Errors
+     * `export-failed` if the encoder can't write the file's header.
+     */
+    constructor();
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_tifffile_free: (a: number, b: number) => void;
+    readonly tifffile_addPage: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly tifffile_finish: (a: number) => [number, number, number, number];
+    readonly tifffile_new: () => [number, number, number];
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;