loro-crdt 1.4.5 → 1.5.0

package/nodejs/loro_wasm.d.ts

@@ -161,6 +161,126 @@ interface LoroDoc {
      */
     subscribeLocalUpdates(f: (bytes: Uint8Array) => void): () => void
 
+    /**
+     * Subscribe to the first commit from a peer. Operations performed on the `LoroDoc` within this callback
+     * will be merged into the current commit.
+     *
+     * This is useful for managing the relationship between `PeerID` and user information.
+     * For example, you could store user names in a `LoroMap` using `PeerID` as the key and the `UserID` as the value.
+     *
+     * @param f - A callback function that receives a peer id.
+     *
+     * @example
+     * ```ts
+     * const doc = new LoroDoc();
+     * doc.setPeerId(0);
+     * const p = [];
+     * doc.subscribeFirstCommitFromPeer((peer) => {
+     *   p.push(peer);
+     *   doc.getMap("map").set(e.peer, "user-" + e.peer);
+     * });
+     * doc.getList("list").insert(0, 100);
+     * doc.commit();
+     * doc.getList("list").insert(0, 200);
+     * doc.commit();
+     * doc.setPeerId(1);
+     * doc.getList("list").insert(0, 300);
+     * doc.commit();
+     * expect(p).toEqual(["0", "1"]);
+     * expect(doc.getMap("map").get("0")).toBe("user-0");
+     * ```
+     **/
+    subscribeFirstCommitFromPeer(f: (e: { peer: PeerID }) => void): () => void
+
+    /**
+     * Subscribe to the pre-commit event.
+     *
+     * The callback will be called when the changes are committed but not yet applied to the OpLog.
+     * You can modify the commit message and timestamp in the callback by `ChangeModifier`.
+     *
+     * @example
+     * ```ts
+     * const doc = new LoroDoc();
+     * doc.subscribePreCommit((e) => {
+     *   e.modifier.setMessage("test").setTimestamp(Date.now());
+     * });
+     * doc.getList("list").insert(0, 100);
+     * doc.commit();
+     * expect(doc.getChangeAt({ peer: "0", counter: 0 }).message).toBe("test");
+     * ```
+     * 
+     * ### Advanced Example: Creating a Merkle DAG
+     * 
+     * By combining `doc.subscribePreCommit` with `doc.exportJsonInIdSpan`, you can implement advanced features like representing Loro's editing history as a Merkle DAG:
+     * 
+     * ```ts
+     * const doc = new LoroDoc();
+     * doc.setPeerId(0);
+     * doc.subscribePreCommit((e) => {
+     *   const changes = doc.exportJsonInIdSpan(e.changeMeta)
+     *   expect(changes).toHaveLength(1);
+     *   const hash = crypto.createHash('sha256');
+     *   const change = {
+     *     ...changes[0],
+     *     deps: changes[0].deps.map(d => {
+     *       const depChange = doc.getChangeAt(idStrToId(d))
+     *       return depChange.message;
+     *     })
+     *   }
+     *   console.log(change); // The output is shown below
+     *   hash.update(JSON.stringify(change));
+     *   const sha256Hash = hash.digest('hex');
+     *   e.modifier.setMessage(sha256Hash);
+     * });
+     * 
+     * doc.getList("list").insert(0, 100);
+     * doc.commit();
+     * // Change 0
+     * // {
+     * //   id: '0@0',
+     * //   timestamp: 0,
+     * //   deps: [],
+     * //   lamport: 0,
+     * //   msg: undefined,
+     * //   ops: [
+     * //     {
+     * //       container: 'cid:root-list:List',
+     * //       content: { type: 'insert', pos: 0, value: [100] },
+     * //       counter: 0
+     * //     }
+     * //   ]
+     * // }
+     * 
+     * 
+     * doc.getList("list").insert(0, 200);
+     * doc.commit();
+     * // Change 1
+     * // {
+     * //   id: '1@0',
+     * //   timestamp: 0,
+     * //   deps: [
+     * //     '2af99cf93869173984bcf6b1ce5412610b0413d027a5511a8f720a02a4432853'
+     * //   ],
+     * //   lamport: 1,
+     * //   msg: undefined,
+     * //   ops: [
+     * //     {
+     * //       container: 'cid:root-list:List',
+     * //       content: { type: 'insert', pos: 0, value: [200] },
+     * //       counter: 1
+     * //     }
+     * //   ]
+     * // }
+     * 
+     * expect(doc.getChangeAt({ peer: "0", counter: 0 }).message).toBe("2af99cf93869173984bcf6b1ce5412610b0413d027a5511a8f720a02a4432853");
+     * expect(doc.getChangeAt({ peer: "0", counter: 1 }).message).toBe("aedbb442c554ecf59090e0e8339df1d8febf647f25cc37c67be0c6e27071d37f");
+     * ```
+     * 
+     * @param f - A callback function that receives a pre commit event.
+     * 
+     **/
+    subscribePreCommit(f: (e: { changeMeta: Change, origin: string, modifier: ChangeModifier }) => void): () => void
+
     /**
      * Convert the document to a JSON value with a custom replacer function.
      *
@@ -759,7 +879,6 @@ export type AwarenessListener = (
     origin: "local" | "timeout" | "remote" | string,
 ) => void;
 
-
 interface Listener {
     (event: LoroEventBatch): void;
 }
@@ -856,10 +975,15 @@ interface LoroDoc<T extends Record<string, Container> = Record<string, Container
      */
     exportJsonUpdates(start?: VersionVector, end?: VersionVector, withPeerCompression?: boolean): JsonSchema;
     /**
-     * Export the readable [`Change`]s in the given [`IdSpan`].
+     * Exports changes within the specified ID span to JSON schema format.
      *
-     * The peers are not compressed in the returned changes.
+     * The JSON schema format produced by this method is identical to the one generated by `export_json_updates`.
+     * It ensures deterministic output, making it ideal for hash calculations and integrity checks.
      *
+     * This method can also export pending changes from the uncommitted transaction that have not yet been applied to the OpLog.
+     * 
+     * This method will NOT trigger a new commit implicitly.
+     * 
      * @param idSpan - The id span to export.
      * @returns The changes in the given id span.
      */
@@ -1274,6 +1398,25 @@ interface AwarenessWasm<T extends Value = Value> {
     removeOutdated(): PeerID[];
 }
 
+type EphemeralListener = (event: EphemeralStoreEvent) => void;
+type EphemeralLocalListener = (bytes: Uint8Array) => void;
+
+interface EphemeralStoreWasm<T extends Value = Value> {
+    set(key: string, value: T): void;
+    get(key: string): T | undefined;
+    getAllStates(): Record<string, T>;
+    removeOutdated();
+    subscribeLocalUpdates(f: EphemeralLocalListener): () => void;
+    subscribe(f: EphemeralListener): () => void;
+}
+
+interface EphemeralStoreEvent {
+    by: "local" | "import" | "timeout";
+    added: string[];
+    updated: string[];
+    removed: string[];
+}
+
 
 
 /**
@@ -1349,6 +1492,21 @@ export class AwarenessWasm {
   peers(): (PeerID)[];
 }
 /**
+*/
+export class ChangeModifier {
+  free(): void;
+/**
+* @param {string} message
+* @returns {ChangeModifier}
+*/
+  setMessage(message: string): ChangeModifier;
+/**
+* @param {number} timestamp
+* @returns {ChangeModifier}
+*/
+  setTimestamp(timestamp: number): ChangeModifier;
+}
+/**
 * Cursor is a stable position representation in the doc.
 * When expressing the position of a cursor, using "index" can be unstable
 * because the cursor's position may change due to other deletions and insertions,
@@ -1418,6 +1576,63 @@ export class Cursor {
   kind(): any;
 }
 /**
+*/
+export class EphemeralStoreWasm {
+  free(): void;
+/**
+* Creates a new `EphemeralStore` instance.
+*
+* The `timeout` parameter specifies the duration in milliseconds.
+* A state of a peer is considered outdated, if the last update of the state of the peer
+* is older than the `timeout`.
+* @param {number} timeout
+*/
+  constructor(timeout: number);
+/**
+* @param {string} key
+* @param {any} value
+*/
+  set(key: string, value: any): void;
+/**
+* @param {string} key
+*/
+  delete(key: string): void;
+/**
+* @param {string} key
+* @returns {any}
+*/
+  get(key: string): any;
+/**
+* @returns {any}
+*/
+  getAllStates(): any;
+/**
+* @param {string} key
+* @returns {Uint8Array}
+*/
+  encode(key: string): Uint8Array;
+/**
+* @returns {Uint8Array}
+*/
+  encodeAll(): Uint8Array;
+/**
+* @param {Uint8Array} data
+*/
+  apply(data: Uint8Array): void;
+/**
+*/
+  removeOutdated(): void;
+/**
+* If the state is empty.
+* @returns {boolean}
+*/
+  isEmpty(): boolean;
+/**
+* @returns {(string)[]}
+*/
+  keys(): (string)[];
+}
+/**
 * The handler of a counter container.
 */
 export class LoroCounter {
@@ -2443,6 +2658,27 @@ export class LoroDoc {
 */
   applyDiff(diff: [ContainerID, Diff|JsonDiff][]): void;
 /**
+* Get the pending operations from the current transaction in JSON format
+*
+* This method returns a JSON representation of operations that have been applied
+* but not yet committed in the current transaction.
+*
+* It will use the same data format as `doc.exportJsonUpdates()`
+*
+* @example
+* ```ts
+* const doc = new LoroDoc();
+* const text = doc.getText("text");
+* text.insert(0, "Hello");
+* // Get pending ops before commit
+* const pendingOps = doc.getPendingOpsFromCurrentTxnAsJson();
+* doc.commit();
+* const emptyOps = doc.getPendingOpsFromCurrentTxnAsJson(); // this is undefined
+* ```
+* @returns {JsonSchema | undefined}
+*/
+  getUncommittedOpsAsJson(): JsonSchema | undefined;
+/**
 * Peer ID of the current writer.
 */
   readonly peerId: bigint;
@@ -3104,8 +3340,6 @@ export class LoroText {
 *
 * You can use it to create a highlight, make a range of text bold, or add a link to a range of text.
 *
-* Note: this is not suitable for unmergeable annotations like comments.
-*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt";

package/nodejs/loro_wasm.js

@@ -617,6 +617,53 @@ class AwarenessWasm {
 }
 module.exports.AwarenessWasm = AwarenessWasm;
 
+const ChangeModifierFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_changemodifier_free(ptr >>> 0));
+/**
+*/
+class ChangeModifier {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ChangeModifier.prototype);
+        obj.__wbg_ptr = ptr;
+        ChangeModifierFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChangeModifierFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_changemodifier_free(ptr);
+    }
+    /**
+    * @param {string} message
+    * @returns {ChangeModifier}
+    */
+    setMessage(message) {
+        const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.changemodifier_setMessage(this.__wbg_ptr, ptr0, len0);
+        return ChangeModifier.__wrap(ret);
+    }
+    /**
+    * @param {number} timestamp
+    * @returns {ChangeModifier}
+    */
+    setTimestamp(timestamp) {
+        const ret = wasm.changemodifier_setTimestamp(this.__wbg_ptr, timestamp);
+        return ChangeModifier.__wrap(ret);
+    }
+}
+module.exports.ChangeModifier = ChangeModifier;
+
 const CursorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cursor_free(ptr >>> 0));
@@ -750,6 +797,162 @@ class Cursor {
 }
 module.exports.Cursor = Cursor;
 
+const EphemeralStoreWasmFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ephemeralstorewasm_free(ptr >>> 0));
+/**
+*/
+class EphemeralStoreWasm {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EphemeralStoreWasmFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ephemeralstorewasm_free(ptr);
+    }
+    /**
+    * Creates a new `EphemeralStore` instance.
+    *
+    * The `timeout` parameter specifies the duration in milliseconds.
+    * A state of a peer is considered outdated, if the last update of the state of the peer
+    * is older than the `timeout`.
+    * @param {number} timeout
+    */
+    constructor(timeout) {
+        const ret = wasm.ephemeralstorewasm_new(timeout);
+        this.__wbg_ptr = ret >>> 0;
+        return this;
+    }
+    /**
+    * @param {string} key
+    * @param {any} value
+    */
+    set(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ephemeralstorewasm_set(this.__wbg_ptr, ptr0, len0, addHeapObject(value));
+    }
+    /**
+    * @param {string} key
+    */
+    delete(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ephemeralstorewasm_delete(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+    * @param {string} key
+    * @returns {any}
+    */
+    get(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ephemeralstorewasm_get(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {any}
+    */
+    getAllStates() {
+        const ret = wasm.ephemeralstorewasm_getAllStates(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @param {Function} f
+    * @returns {any}
+    */
+    subscribeLocalUpdates(f) {
+        const ret = wasm.ephemeralstorewasm_subscribeLocalUpdates(this.__wbg_ptr, addHeapObject(f));
+        return takeObject(ret);
+    }
+    /**
+    * @param {Function} f
+    * @returns {any}
+    */
+    subscribe(f) {
+        const ret = wasm.ephemeralstorewasm_subscribe(this.__wbg_ptr, addHeapObject(f));
+        return takeObject(ret);
+    }
+    /**
+    * @param {string} key
+    * @returns {Uint8Array}
+    */
+    encode(key) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ephemeralstorewasm_encode(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_5(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    encodeAll() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ephemeralstorewasm_encodeAll(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_5(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {Uint8Array} data
+    */
+    apply(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export_0);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ephemeralstorewasm_apply(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+    */
+    removeOutdated() {
+        wasm.ephemeralstorewasm_removeOutdated(this.__wbg_ptr);
+    }
+    /**
+    * If the state is empty.
+    * @returns {boolean}
+    */
+    isEmpty() {
+        const ret = wasm.ephemeralstorewasm_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * @returns {(string)[]}
+    */
+    keys() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ephemeralstorewasm_keys(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_5(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+module.exports.EphemeralStoreWasm = EphemeralStoreWasm;
+
 const LoroCounterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_lorocounter_free(ptr >>> 0));
@@ -2803,6 +3006,61 @@ class LoroDoc {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * Get the pending operations from the current transaction in JSON format
+    *
+    * This method returns a JSON representation of operations that have been applied
+    * but not yet committed in the current transaction.
+    *
+    * It will use the same data format as `doc.exportJsonUpdates()`
+    *
+    * @example
+    * ```ts
+    * const doc = new LoroDoc();
+    * const text = doc.getText("text");
+    * text.insert(0, "Hello");
+    * // Get pending ops before commit
+    * const pendingOps = doc.getPendingOpsFromCurrentTxnAsJson();
+    * doc.commit();
+    * const emptyOps = doc.getPendingOpsFromCurrentTxnAsJson(); // this is undefined
+    * ```
+    * @returns {JsonSchema | undefined}
+    */
+    getUncommittedOpsAsJson() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.lorodoc_getUncommittedOpsAsJson(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {Function} f
+    * @returns {any}
+    */
+    subscribeFirstCommitFromPeer(f) {
+        const ret = wasm.lorodoc_subscribeFirstCommitFromPeer(this.__wbg_ptr, addHeapObject(f));
+        return takeObject(ret);
+    }
+    /**
+    * Subscribe to the pre-commit event.
+    *
+    * The callback will be called when the changes are committed but not yet applied to the OpLog.
+    * You can modify the commit message and timestamp in the callback by `ChangeModifier`.
+    * @param {Function} f
+    * @returns {any}
+    */
+    subscribePreCommit(f) {
+        const ret = wasm.lorodoc_subscribePreCommit(this.__wbg_ptr, addHeapObject(f));
+        return takeObject(ret);
+    }
 }
 module.exports.LoroDoc = LoroDoc;
 
@@ -4637,8 +4895,6 @@ class LoroText {
     *
     * You can use it to create a highlight, make a range of text bold, or add a link to a range of text.
     *
-    * Note: this is not suitable for unmergeable annotations like comments.
-    *
     * @example
     * ```ts
     * import { LoroDoc } from "loro-crdt";
@@ -6159,11 +6415,6 @@ module.exports.__wbg_lorocounter_new = function(arg0) {
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_lorotreenode_new = function(arg0) {
-    const ret = LoroTreeNode.__wrap(arg0);
-    return addHeapObject(ret);
-};
-
 module.exports.__wbg_cursor_new = function(arg0) {
     const ret = Cursor.__wrap(arg0);
     return addHeapObject(ret);
@@ -6174,13 +6425,18 @@ module.exports.__wbg_loromap_new = function(arg0) {
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_lorotext_new = function(arg0) {
-    const ret = LoroText.__wrap(arg0);
+module.exports.__wbg_lorotreenode_new = function(arg0) {
+    const ret = LoroTreeNode.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_lorotree_new = function(arg0) {
-    const ret = LoroTree.__wrap(arg0);
+module.exports.__wbg_lorolist_new = function(arg0) {
+    const ret = LoroList.__wrap(arg0);
+    return addHeapObject(ret);
+};
+
+module.exports.__wbg_lorotext_new = function(arg0) {
+    const ret = LoroText.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -6189,8 +6445,8 @@ module.exports.__wbg_loromovablelist_new = function(arg0) {
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_lorolist_new = function(arg0) {
-    const ret = LoroList.__wrap(arg0);
+module.exports.__wbg_lorotree_new = function(arg0) {
+    const ret = LoroTree.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -6199,6 +6455,11 @@ module.exports.__wbg_versionvector_new = function(arg0) {
     return addHeapObject(ret);
 };
 
+module.exports.__wbg_changemodifier_new = function(arg0) {
+    const ret = ChangeModifier.__wrap(arg0);
+    return addHeapObject(ret);
+};
+
 module.exports.__wbindgen_is_function = function(arg0) {
     const ret = typeof(getObject(arg0)) === 'function';
     return ret;
@@ -6422,7 +6683,7 @@ module.exports.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
     }
 };
 
-module.exports.__wbg_now_cd30a09c9b727b65 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+module.exports.__wbg_now_761faa1e2f3f9d93 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
 
 module.exports.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
     const ret = getObject(arg0).crypto;
@@ -6454,14 +6715,14 @@ module.exports.__wbg_msCrypto_eb05e62b530a1508 = function(arg0) {
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_getRandomValues_3aa56aa6edec874c = function() { return handleError(function (arg0, arg1) {
-    getObject(arg0).getRandomValues(getObject(arg1));
-}, arguments) };
-
 module.exports.__wbg_randomFillSync_5c9c955aa56b6049 = function() { return handleError(function (arg0, arg1) {
     getObject(arg0).randomFillSync(takeObject(arg1));
 }, arguments) };
 
+module.exports.__wbg_getRandomValues_3aa56aa6edec874c = function() { return handleError(function (arg0, arg1) {
+    getObject(arg0).getRandomValues(getObject(arg1));
+}, arguments) };
+
 module.exports.__wbg_self_ce0dbfc45cf2f5be = function() { return handleError(function () {
     const ret = self.self;
     return addHeapObject(ret);
@@ -6746,13 +7007,13 @@ module.exports.__wbindgen_memory = function() {
     return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_closure_wrapper482 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_60);
+module.exports.__wbindgen_closure_wrapper487 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_60);
     return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_closure_wrapper485 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_63);
+module.exports.__wbindgen_closure_wrapper489 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_63);
     return addHeapObject(ret);
 };