@laminapdf/wasm 0.2.0-alpha.6 → 0.3.0

package/dist/lamina_pdf_base.js

@@ -205,6 +205,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.
      *
@@ -240,6 +282,23 @@ export class WasmDocument {
         }
         return takeFromExternrefTable0(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]);
+    }
     /**
      * Whether there are changes no save has written yet.
      * @returns {boolean}
@@ -273,6 +332,42 @@ export class WasmDocument {
         ret = wasm.wasmdocument_isEncrypted(this.__wbg_ptr);
         return ret !== 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]);
+    }
     /**
      * Opens a document from its bytes.
      *
@@ -393,6 +488,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]);
+    }
     /**
      * Rebases onto `bytes`, the output of a save whose rebase failed (`not-rebased`).
      *
@@ -425,6 +536,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).
      *
@@ -457,6 +585,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]);
+    }
     /**
      * Undoes the newest transaction: how it went and the pages it touched; `undefined` when
      * there is nothing to undo.
@@ -482,6 +630,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;
 
@@ -1363,14 +1542,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_9a868026ffa4208a: function(arg0, arg1) {
             const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
             return ret;
@@ -1383,6 +1596,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;
@@ -1398,6 +1618,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, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);