@laminapdf/wasm 0.2.0-alpha.3 → 0.2.0-alpha.5

package/dist/lamina_pdf_extract.js

@@ -240,6 +240,25 @@ export class WasmDocument {
         }
         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`,
+     * run the model, hand the result to `provide`), and once every page is done, the output in
+     * `options.format` (the extract and text modules).
+     *
+     * # Errors
+     * As `extract`, for the options and the pages asked for.
+     * @param {ExtractInit} options
+     * @returns {WasmExtractJob}
+     */
+    extractJob(options) {
+        let ret;
+        ret = wasm.wasmdocument_extractJob(this.__wbg_ptr, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmExtractJob.__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).
@@ -293,6 +312,40 @@ export class WasmDocument {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Whether the document says it is tagged (`/MarkInfo /Marked true`; the extract and text modules).
+     *
+     * # Errors
+     * Reading errors.
+     * @returns {boolean}
+     */
+    isTagged() {
+        let ret;
+        ret = wasm.wasmdocument_isTagged(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 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).
+     *
+     * # Errors
+     * `data-pending` and the reading errors.
+     * @param {string} name
+     * @returns {TargetJs | undefined}
+     */
+    namedDestination(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        ret = wasm.wasmdocument_namedDestination(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Opens a document from its bytes.
      *
@@ -333,6 +386,22 @@ export class WasmDocument {
         }
         return WasmDocument.__wrap(ret[0]);
     }
+    /**
+     * The outline's top-level items, each with its children; empty without an outline (the
+     * extract and text modules).
+     *
+     * # Errors
+     * `data-pending` and the reading errors.
+     * @returns {OutlineNodeJs[]}
+     */
+    outline() {
+        let ret;
+        ret = wasm.wasmdocument_outline(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * A handle on the page with `id` (`p12.0`).
      *
@@ -397,6 +466,22 @@ export class WasmDocument {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * The visible links on page `index`, in annotation order (the extract and text modules).
+     *
+     * # Errors
+     * `page-index-out-of-range`, `data-pending` and the reading errors.
+     * @param {number} index
+     * @returns {PageLinkJs[]}
+     */
+    pageLinks(index) {
+        let ret;
+        ret = wasm.wasmdocument_pageLinks(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * A handle on page `index` that follows the page by its ID (F2).
      *
@@ -413,6 +498,21 @@ export class WasmDocument {
         }
         return WasmPage.__wrap(ret[0]);
     }
+    /**
+     * The document's properties (the extract and text modules). Reads every object once.
+     *
+     * # Errors
+     * `data-pending` and the reading errors.
+     * @returns {PropertiesJs}
+     */
+    properties() {
+        let ret;
+        ret = wasm.wasmdocument_properties(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Rebases onto `bytes`, the output of a save whose rebase failed (`not-rebased`).
      *
@@ -444,6 +544,34 @@ export class WasmDocument {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * The document for reader mode, as JSON: whether it can be shown and why not, its
+     * language, its blocks in the structure tree's order (figures, formulas and tables as crops
+     * with their alternate text) and the checks' measures (the extract module only).
+     *
+     * # Errors
+     * `data-pending` and the reading errors.
+     * @returns {string}
+     */
+    reflow() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            let ret;
+            ret = wasm.wasmdocument_reflow(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);
+        }
+    }
     /**
      * A save as a job, stepped with a budget of work units (ADR 0028 §3, §4).
      *
@@ -476,6 +604,22 @@ export class WasmDocument {
         }
         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).
+     *
+     * # Errors
+     * Reading errors.
+     * @returns {StructureNodeJs[] | undefined}
+     */
+    structureTree() {
+        let ret;
+        ret = wasm.wasmdocument_structureTree(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Undoes the newest transaction; `undefined` when there is nothing to undo.
      *
@@ -503,6 +647,73 @@ export class WasmDocument {
 }
 if (Symbol.dispose) WasmDocument.prototype[Symbol.dispose] = WasmDocument.prototype.free;
 
+/**
+ * An extraction in progress, from `WasmDocument.extractJob`; it holds its document weakly.
+ */
+export class WasmExtractJob {
+    static __wrap(ptr) {
+        const obj = Object.create(WasmExtractJob.prototype);
+        obj.__wbg_ptr = ptr;
+        Object.defineProperty(obj, '__wbg_inst', { value: __wbg_instance_id, writable: true });
+
+        WasmExtractJobFinalization.register(obj, { ptr, instance: __wbg_instance_id }, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmExtractJobFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmextractjob_free(ptr, 0);
+
+    }
+    /**
+     * Stops the job: its next step fails with `cancelled`.
+     */
+    cancel() {
+        wasm.wasmextractjob_cancel(this.__wbg_ptr);
+    }
+    /**
+     * Hands the job the result of its open request: `{ kind: "layout", regions }` or
+     * `{ kind: "ocr", words }`, boxes as `[x, y, width, height]` in top-left points.
+     *
+     * # Errors
+     * `model-result-unexpected` when nothing was asked for or `result` is the other kind;
+     * `invalid-argument` / `unknown-option` for a malformed result.
+     * @param {ModelResultInit} result
+     */
+    provide(result) {
+        let ret;
+        ret = wasm.wasmextractjob_provide(this.__wbg_ptr, result);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Extracts up to `budget` pages: `{ state: "progress", done, total, phase, request? }` or
+     * `{ state: "done", output }`, the output in the job's format. While `request` is set, a
+     * step does nothing until `provide` answers it.
+     *
+     * # Errors
+     * `cancelled`, `document-changed`, `job-finished`, `disposed` when the document is freed,
+     * and the reading errors.
+     * @param {number} budget
+     * @returns {({ state: "progress" } & ExtractProgressJs) | { state: "done"; output: string }}
+     */
+    step(budget) {
+        let ret;
+        ret = wasm.wasmextractjob_step(this.__wbg_ptr, budget);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) WasmExtractJob.prototype[Symbol.dispose] = WasmExtractJob.prototype.free;
+
 /**
  * An image to draw (decoded or passed through once, shared by every use).
  */
@@ -721,7 +932,8 @@ export class WasmPageBuilder {
     }
     /**
      * Opens an artifact until the matching `endTag`: `kind` is `layout`, `page`, `pagination`
-     * or `background`.
+     * or `background`, or a pagination artifact that says what it is: `header` (attached to the
+     * top edge), `footer` (the bottom) or `watermark`.
      *
      * # Errors
      * `invalid-argument` for another kind.
@@ -1488,6 +1700,11 @@ const WasmDocumentFinalization = (typeof FinalizationRegistry === 'undefined')
     : new FinalizationRegistry(({ ptr, instance }) => {
     if (instance === __wbg_instance_id) wasm.__wbg_wasmdocument_free(ptr, 1);
 });
+const WasmExtractJobFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(({ ptr, instance }) => {
+    if (instance === __wbg_instance_id) wasm.__wbg_wasmextractjob_free(ptr, 1);
+});
 const WasmImageFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(({ ptr, instance }) => {

package/dist/lamina_pdf_render_hayro.d.ts

@@ -35,12 +35,15 @@ export class HayroDocument {
      */
     plan(page: number, scale: number, x: number, y: number, width: number, height: number, rotation: number, flags: number, background?: number | null): Uint32Array;
     /**
-     * Renders the request into `out` (exactly `width × height × 4` bytes, straight RGBA).
+     * Renders the request into `out` (exactly `width × height × 4` bytes, straight RGBA), in
+     * the page appearance `appearance` (0 original, 1 sepia, 2 dark, 3 high contrast with `ink`
+     * and `paper` as `0xRRGGBBAA`; the colours are ignored otherwise).
      *
      * # Errors
-     * As [`HayroDocument::plan`], plus `render-failed` and `invalid-argument` for a wrong size.
+     * As [`HayroDocument::plan`], plus `render-failed`, and `invalid-argument` for a wrong size
+     * or an unknown appearance.
      */
-    render(page: number, scale: number, x: number, y: number, width: number, height: number, rotation: number, flags: number, background: number | null | undefined, out: Uint8Array): void;
+    render(page: number, scale: number, x: number, y: number, width: number, height: number, rotation: number, flags: number, background: number | null | undefined, appearance: number, ink: number, paper: number, out: Uint8Array): void;
 }
 
 /**
@@ -78,7 +81,7 @@ export interface InitOutput {
     readonly hayrodocument_page: (a: number, b: number) => [number, number, number, number];
     readonly hayrodocument_pageCount: (a: number) => number;
     readonly hayrodocument_plan: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number, number, number];
-    readonly hayrodocument_render: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: any) => [number, number];
+    readonly hayrodocument_render: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: any) => [number, number];
     readonly inputbuffer_new: (a: number) => [number, number, number];
     readonly inputbuffer_write: (a: number, b: number, c: number, d: number) => [number, number];
     readonly __wbindgen_exn_store: (a: number) => void;

package/dist/lamina_pdf_render_hayro.js

@@ -95,10 +95,13 @@ export class HayroDocument {
         return v1;
     }
     /**
-     * Renders the request into `out` (exactly `width × height × 4` bytes, straight RGBA).
+     * Renders the request into `out` (exactly `width × height × 4` bytes, straight RGBA), in
+     * the page appearance `appearance` (0 original, 1 sepia, 2 dark, 3 high contrast with `ink`
+     * and `paper` as `0xRRGGBBAA`; the colours are ignored otherwise).
      *
      * # Errors
-     * As [`HayroDocument::plan`], plus `render-failed` and `invalid-argument` for a wrong size.
+     * As [`HayroDocument::plan`], plus `render-failed`, and `invalid-argument` for a wrong size
+     * or an unknown appearance.
      * @param {number} page
      * @param {number} scale
      * @param {number} x
@@ -108,12 +111,15 @@ export class HayroDocument {
      * @param {number} rotation
      * @param {number} flags
      * @param {number | null | undefined} background
+     * @param {number} appearance
+     * @param {number} ink
+     * @param {number} paper
      * @param {Uint8Array} out
      */
-    render(page, scale, x, y, width, height, rotation, flags, background, out) {
+    render(page, scale, x, y, width, height, rotation, flags, background, appearance, ink, paper, out) {
         var ptr0 = passArray8ToWasm0(out, wasm.__wbindgen_malloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hayrodocument_render(this.__wbg_ptr, page, scale, x, y, width, height, rotation, flags, isLikeNone(background) ? Number.MAX_SAFE_INTEGER : (background) >>> 0, ptr0, len0, out);
+        const ret = wasm.hayrodocument_render(this.__wbg_ptr, page, scale, x, y, width, height, rotation, flags, isLikeNone(background) ? Number.MAX_SAFE_INTEGER : (background) >>> 0, appearance, ink, paper, ptr0, len0, out);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }