loro-crdt 1.0.9 → 1.1.0

package/web/loro_wasm.d.ts

@@ -26,12 +26,13 @@ export function setDebug(): void;
 * - endVersionVector
 * - startTimestamp
 * - endTimestamp
-* - isSnapshot
+* - mode
 * - changeNum
 * @param {Uint8Array} blob
+* @param {boolean} check_checksum
 * @returns {ImportBlobMetadata}
 */
-export function decodeImportBlobMeta(blob: Uint8Array): ImportBlobMetadata;
+export function decodeImportBlobMeta(blob: Uint8Array, check_checksum: boolean): ImportBlobMetadata;
 
 /**
 * Container types supported by loro.
@@ -262,7 +263,7 @@ export interface ImportBlobMetadata {
     startFrontiers: OpId[],
     startTimestamp: number;
     endTimestamp: number;
-    isSnapshot: boolean;
+    mode: "outdated-snapshot" | "outdated-update" | "snapshot" | "shallow-snapshot" | "update";
     changeNum: number;
 }
 
@@ -351,6 +352,11 @@ export type TreeNodeValue = {
     children: TreeNodeValue[],
 }
 
+export type TreeNodeJSON<T> = Omit<TreeNodeValue, 'meta' | 'children'> & {
+    meta: T,
+    children: TreeNodeJSON<T>[],
+}
+
 interface LoroTree{
     toArray(): TreeNodeValue[];
     getNodes(options?: { withDeleted: boolean = false }): LoroTreeNode[];
@@ -432,6 +438,11 @@ export type JsonChange = {
   ops: JsonOp[]
 }
 
+export interface TextUpdateOptions {
+    timeoutMs?: number,
+    useRefinedDiff?: boolean,
+}
+
 export type ExportMode = {
     mode: "update",
     from?: VersionVector,
@@ -1012,6 +1023,32 @@ interface LoroText {
     insert(pos: number, text: string): void;
     delete(pos: number, len: number): void;
     subscribe(listener: Listener): Subscription;
+    /**
+     * Update the current text to the target text.
+     *
+     * It will calculate the minimal difference and apply it to the current text.
+     * It uses Myers' diff algorithm to compute the optimal difference.
+     *
+     * This could take a long time for large texts (e.g. > 50_000 characters).
+     * In that case, you should use `updateByLine` instead.
+     *
+     * @example
+     * ```ts
+     * import { LoroDoc } from "loro-crdt";
+     *
+     * const doc = new LoroDoc();
+     * const text = doc.getText("text");
+     * text.insert(0, "Hello");
+     * text.update("Hello World");
+     * console.log(text.toString()); // "Hello World"
+     * ```
+     */
+    update(text: string, options?: TextUpdateOptions): void;
+    /**
+     * Update the current text based on the provided text.
+     * This update calculation is line-based, which will be more efficient but less precise.
+     */
+    updateByLine(text: string, options?: TextUpdateOptions): void;
 }
 interface LoroTree<T extends Record<string, unknown> = Record<string, unknown>> {
     new(): LoroTree<T>;
@@ -1080,6 +1117,7 @@ interface LoroTreeNode<T extends Record<string, unknown> = Record<string, unknow
      * the WASM boundary.
      */
     children(): Array<LoroTreeNode<T>> | undefined;
+    toJSON(): TreeNodeJSON<T>;
 }
 interface AwarenessWasm<T extends Value = Value> {
     getState(peer: PeerID): T | undefined;
@@ -1532,9 +1570,9 @@ export class LoroDoc {
 * @param ids - the changes to visit
 * @param f - the callback function, return `true` to continue visiting, return `false` to stop
 * @param {({ peer: PeerID, counter: number })[]} ids
-* @param {Function} f
+* @param {(change: ChangeMeta) => boolean} f
 */
-  travelChangeAncestors(ids: ({ peer: PeerID, counter: number })[], f: Function): void;
+  travelChangeAncestors(ids: ({ peer: PeerID, counter: number })[], f: (change: ChangeMeta) => boolean): void;
 /**
 * Checkout the `DocState` to a specific version.
 *
@@ -2010,6 +2048,23 @@ export class LoroDoc {
 */
   getCursorPos(cursor: Cursor): { update?: Cursor, offset: number, side: Side };
 /**
+* Gets container IDs modified in the given ID range.
+*
+* **NOTE:** This method will implicitly commit.
+*
+* This method identifies which containers were affected by changes in a given range of operations.
+* It can be used together with `doc.travelChangeAncestors()` to analyze the history of changes
+* and determine which containers were modified by each change.
+*
+* @param id - The starting ID of the change range
+* @param len - The length of the change range to check
+* @returns An array of container IDs that were modified in the given range
+* @param {{ peer: PeerID, counter: number }} id
+* @param {number} len
+* @returns {(ContainerID)[]}
+*/
+  getChangedContainersIn(id: { peer: PeerID, counter: number }, len: number): (ContainerID)[];
+/**
 * Peer ID of the current writer.
 */
   readonly peerId: bigint;
@@ -2105,6 +2160,11 @@ export class LoroList {
 */
   clear(): void;
 /**
+* @param {number} pos
+* @returns {{ peer: PeerID, counter: number } | undefined}
+*/
+  getIdAt(pos: number): { peer: PeerID, counter: number } | undefined;
+/**
 * Get the id of this container.
 */
   readonly id: ContainerID;
@@ -2255,6 +2315,12 @@ export class LoroMap {
 */
   clear(): void;
 /**
+* Get the peer id of the last editor on the given entry
+* @param {string} key
+* @returns {PeerID | undefined}
+*/
+  getLastEditor(key: string): PeerID | undefined;
+/**
 * The container id of this handler.
 */
   readonly id: ContainerID;
@@ -2375,6 +2441,24 @@ export class LoroMovableList {
 */
   clear(): void;
 /**
+* Get the creator of the list item at the given position.
+* @param {number} pos
+* @returns {PeerID | undefined}
+*/
+  getCreatorAt(pos: number): PeerID | undefined;
+/**
+* Get the last mover of the list item at the given position.
+* @param {number} pos
+* @returns {PeerID | undefined}
+*/
+  getLastMoverAt(pos: number): PeerID | undefined;
+/**
+* Get the last editor of the list item at the given position.
+* @param {number} pos
+* @returns {PeerID | undefined}
+*/
+  getLastEditorAt(pos: number): PeerID | undefined;
+/**
 * Get the id of this container.
 */
   readonly id: ContainerID;
@@ -2415,11 +2499,14 @@ export class LoroText {
 */
   kind(): 'Text';
 /**
-* Iterate each span(internal storage unit) of the text.
+* Iterate each text span(internal storage unit)
 *
 * The callback function will be called for each span in the text.
 * If the callback returns `false`, the iteration will stop.
 *
+* Limitation: you cannot access or alter the doc state when iterating (this is for performance consideration).
+* If you need to access or alter the doc state, please use `toString` instead.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt";
@@ -2433,35 +2520,6 @@ export class LoroText {
 */
   iter(callback: Function): void;
 /**
-* Update the current text to the target text.
-*
-* It will calculate the minimal difference and apply it to the current text.
-* It uses Myers' diff algorithm to compute the optimal difference.
-*
-* This could take a long time for large texts (e.g. > 50_000 characters).
-* In that case, you should use `updateByLine` instead.
-*
-* @example
-* ```ts
-* import { LoroDoc } from "loro-crdt";
-*
-* const doc = new LoroDoc();
-* const text = doc.getText("text");
-* text.insert(0, "Hello");
-* text.update("Hello World");
-* console.log(text.toString()); // "Hello World"
-* ```
-* @param {string} text
-*/
-  update(text: string): void;
-/**
-* Update the current text to the target text, the difference is calculated line by line.
-*
-* It uses Myers' diff algorithm to compute the optimal difference.
-* @param {string} text
-*/
-  updateByLine(text: string): void;
-/**
 * Insert the string at the given index (utf-16 index).
 *
 * @example
@@ -2705,6 +2763,12 @@ export class LoroText {
 */
   push(s: string): void;
 /**
+* Get the editor of the text at the given position.
+* @param {number} pos
+* @returns {PeerID | undefined}
+*/
+  getEditorOf(pos: number): PeerID | undefined;
+/**
 * Get the container id of the text.
 */
   readonly id: ContainerID;
@@ -2974,6 +3038,21 @@ export class LoroTreeNode {
 */
   isDeleted(): boolean;
 /**
+* Get the last mover of this node.
+* @returns {{ peer: PeerID, counter: number } | undefined}
+*/
+  getLastMoveId(): { peer: PeerID, counter: number } | undefined;
+/**
+* Get the creation id of this node.
+* @returns {{ peer: PeerID, counter: number }}
+*/
+  creationId(): { peer: PeerID, counter: number };
+/**
+* Get the creator of this node.
+* @returns {PeerID}
+*/
+  creator(): PeerID;
+/**
 * The TreeID of the node.
 */
   readonly id: TreeID;
@@ -3212,12 +3291,13 @@ export interface InitOutput {
   readonly lorodoc_vvToFrontiers: (a: number, b: number, c: number) => void;
   readonly lorodoc_getByPath: (a: number, b: number, c: number) => number;
   readonly lorodoc_getCursorPos: (a: number, b: number, c: number) => void;
+  readonly lorodoc_getChangedContainersIn: (a: number, b: number, c: number, d: number) => void;
   readonly __wbg_lorotext_free: (a: number) => void;
   readonly lorotext_new: () => number;
   readonly lorotext_kind: (a: number) => number;
   readonly lorotext_iter: (a: number, b: number) => void;
-  readonly lorotext_update: (a: number, b: number, c: number) => void;
-  readonly lorotext_updateByLine: (a: number, b: number, c: number) => void;
+  readonly lorotext_update: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly lorotext_updateByLine: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly lorotext_insert: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly lorotext_slice: (a: number, b: number, c: number, d: number) => void;
   readonly lorotext_charAt: (a: number, b: number, c: number) => void;
@@ -3237,6 +3317,7 @@ export interface InitOutput {
   readonly lorotext_getAttached: (a: number) => number;
   readonly lorotext_getCursor: (a: number, b: number, c: number) => number;
   readonly lorotext_push: (a: number, b: number, c: number, d: number) => void;
+  readonly lorotext_getEditorOf: (a: number, b: number) => number;
   readonly __wbg_loromap_free: (a: number) => void;
   readonly loromap_new: () => number;
   readonly loromap_kind: (a: number) => number;
@@ -3255,6 +3336,7 @@ export interface InitOutput {
   readonly loromap_parent: (a: number) => number;
   readonly loromap_getAttached: (a: number) => number;
   readonly loromap_clear: (a: number, b: number) => void;
+  readonly loromap_getLastEditor: (a: number, b: number, c: number) => number;
   readonly __wbg_lorolist_free: (a: number) => void;
   readonly lorolist_new: () => number;
   readonly lorolist_kind: (a: number) => number;
@@ -3275,6 +3357,7 @@ export interface InitOutput {
   readonly lorolist_push: (a: number, b: number, c: number) => void;
   readonly lorolist_pop: (a: number, b: number) => void;
   readonly lorolist_clear: (a: number, b: number) => void;
+  readonly lorolist_getIdAt: (a: number, b: number) => number;
   readonly loromovablelist_new: () => number;
   readonly loromovablelist_kind: (a: number) => number;
   readonly loromovablelist_insert: (a: number, b: number, c: number, d: number) => void;
@@ -3295,6 +3378,9 @@ export interface InitOutput {
   readonly loromovablelist_push: (a: number, b: number, c: number) => void;
   readonly loromovablelist_pop: (a: number, b: number) => void;
   readonly loromovablelist_clear: (a: number, b: number) => void;
+  readonly loromovablelist_getCreatorAt: (a: number, b: number) => number;
+  readonly loromovablelist_getLastMoverAt: (a: number, b: number) => number;
+  readonly loromovablelist_getLastEditorAt: (a: number, b: number) => number;
   readonly __wbg_lorotree_free: (a: number) => void;
   readonly lorotreenode___getClassname: (a: number, b: number) => void;
   readonly __wbg_lorotreenode_free: (a: number) => void;
@@ -3306,9 +3392,13 @@ export interface InitOutput {
   readonly lorotreenode_index: (a: number, b: number) => void;
   readonly lorotreenode_fractionalIndex: (a: number, b: number) => void;
   readonly lorotreenode_data: (a: number, b: number) => void;
+  readonly lorotreenode_toJSON: (a: number, b: number) => void;
   readonly lorotreenode_parent: (a: number, b: number) => void;
   readonly lorotreenode_children: (a: number) => number;
   readonly lorotreenode_isDeleted: (a: number, b: number) => void;
+  readonly lorotreenode_getLastMoveId: (a: number) => number;
+  readonly lorotreenode_creationId: (a: number) => number;
+  readonly lorotreenode_creator: (a: number) => number;
   readonly lorotree_new: () => number;
   readonly lorotree_kind: (a: number) => number;
   readonly lorotree_createNode: (a: number, b: number, c: number, d: number, e: number) => void;
@@ -3358,7 +3448,7 @@ export interface InitOutput {
   readonly versionvector_decode: (a: number, b: number, c: number) => void;
   readonly versionvector_get: (a: number, b: number, c: number) => void;
   readonly versionvector_compare: (a: number, b: number, c: number) => void;
-  readonly decodeImportBlobMeta: (a: number, b: number, c: number) => void;
+  readonly decodeImportBlobMeta: (a: number, b: number, c: number, d: number) => void;
   readonly __wbg_loromovablelist_free: (a: number) => void;
   readonly loromovablelist_parent: (a: number) => number;
   readonly lorotext_isAttached: (a: number) => number;

package/web/loro_wasm.js

@@ -360,17 +360,18 @@ function _assertClass(instance, klass) {
 * - endVersionVector
 * - startTimestamp
 * - endTimestamp
-* - isSnapshot
+* - mode
 * - changeNum
 * @param {Uint8Array} blob
+* @param {boolean} check_checksum
 * @returns {ImportBlobMetadata}
 */
-export function decodeImportBlobMeta(blob) {
+export function decodeImportBlobMeta(blob, check_checksum) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passArray8ToWasm0(blob, wasm.__wbindgen_export_0);
         const len0 = WASM_VECTOR_LEN;
-        wasm.decodeImportBlobMeta(retptr, ptr0, len0);
+        wasm.decodeImportBlobMeta(retptr, ptr0, len0, check_checksum);
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1202,7 +1203,7 @@ export class LoroDoc {
     * @param ids - the changes to visit
     * @param f - the callback function, return `true` to continue visiting, return `false` to stop
     * @param {({ peer: PeerID, counter: number })[]} ids
-    * @param {Function} f
+    * @param {(change: ChangeMeta) => boolean} f
     */
     travelChangeAncestors(ids, f) {
         try {
@@ -2349,6 +2350,40 @@ export class LoroDoc {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * Gets container IDs modified in the given ID range.
+    *
+    * **NOTE:** This method will implicitly commit.
+    *
+    * This method identifies which containers were affected by changes in a given range of operations.
+    * It can be used together with `doc.travelChangeAncestors()` to analyze the history of changes
+    * and determine which containers were modified by each change.
+    *
+    * @param id - The starting ID of the change range
+    * @param len - The length of the change range to check
+    * @returns An array of container IDs that were modified in the given range
+    * @param {{ peer: PeerID, counter: number }} id
+    * @param {number} len
+    * @returns {(ContainerID)[]}
+    */
+    getChangedContainersIn(id, len) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.lorodoc_getChangedContainersIn(retptr, this.__wbg_ptr, addHeapObject(id), len);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_5(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
 }
 
 const LoroListFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -2749,6 +2784,14 @@ export class LoroList {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * @param {number} pos
+    * @returns {{ peer: PeerID, counter: number } | undefined}
+    */
+    getIdAt(pos) {
+        const ret = wasm.lorolist_getIdAt(this.__wbg_ptr, pos);
+        return takeObject(ret);
+    }
 }
 
 const LoroMapFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3180,6 +3223,17 @@ export class LoroMap {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * Get the peer id of the last editor on the given entry
+    * @param {string} key
+    * @returns {PeerID | undefined}
+    */
+    getLastEditor(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.loromap_getLastEditor(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
 }
 
 const LoroMovableListFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3652,6 +3706,33 @@ export class LoroMovableList {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * Get the creator of the list item at the given position.
+    * @param {number} pos
+    * @returns {PeerID | undefined}
+    */
+    getCreatorAt(pos) {
+        const ret = wasm.loromovablelist_getCreatorAt(this.__wbg_ptr, pos);
+        return takeObject(ret);
+    }
+    /**
+    * Get the last mover of the list item at the given position.
+    * @param {number} pos
+    * @returns {PeerID | undefined}
+    */
+    getLastMoverAt(pos) {
+        const ret = wasm.loromovablelist_getLastMoverAt(this.__wbg_ptr, pos);
+        return takeObject(ret);
+    }
+    /**
+    * Get the last editor of the list item at the given position.
+    * @param {number} pos
+    * @returns {PeerID | undefined}
+    */
+    getLastEditorAt(pos) {
+        const ret = wasm.loromovablelist_getLastEditorAt(this.__wbg_ptr, pos);
+        return takeObject(ret);
+    }
 }
 
 const LoroTextFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3703,11 +3784,14 @@ export class LoroText {
         return takeObject(ret);
     }
     /**
-    * Iterate each span(internal storage unit) of the text.
+    * Iterate each text span(internal storage unit)
     *
     * The callback function will be called for each span in the text.
     * If the callback returns `false`, the iteration will stop.
     *
+    * Limitation: you cannot access or alter the doc state when iterating (this is for performance consideration).
+    * If you need to access or alter the doc state, please use `toString` instead.
+    *
     * @example
     * ```ts
     * import { LoroDoc } from "loro-crdt";
@@ -3746,22 +3830,44 @@ export class LoroText {
     * console.log(text.toString()); // "Hello World"
     * ```
     * @param {string} text
+    * @param {any} options
     */
-    update(text) {
-        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.lorotext_update(this.__wbg_ptr, ptr0, len0);
+    update(text, options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.lorotext_update(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(options));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
     * Update the current text to the target text, the difference is calculated line by line.
     *
     * It uses Myers' diff algorithm to compute the optimal difference.
     * @param {string} text
+    * @param {any} options
     */
-    updateByLine(text) {
-        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.lorotext_updateByLine(this.__wbg_ptr, ptr0, len0);
+    updateByLine(text, options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.lorotext_updateByLine(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(options));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
     * Insert the string at the given index (utf-16 index).
@@ -4259,6 +4365,15 @@ export class LoroText {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * Get the editor of the text at the given position.
+    * @param {number} pos
+    * @returns {PeerID | undefined}
+    */
+    getEditorOf(pos) {
+        const ret = wasm.lorotext_getEditorOf(this.__wbg_ptr, pos);
+        return takeObject(ret);
+    }
 }
 
 const LoroTreeFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -4953,6 +5068,24 @@ export class LoroTreeNode {
         }
     }
     /**
+    * @returns {any}
+    */
+    toJSON() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.lorotreenode_toJSON(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);
+        }
+    }
+    /**
     * Get the parent node of this node.
     *
     * - The parent of the root node is `undefined`.
@@ -5005,6 +5138,30 @@ export class LoroTreeNode {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * Get the last mover of this node.
+    * @returns {{ peer: PeerID, counter: number } | undefined}
+    */
+    getLastMoveId() {
+        const ret = wasm.lorotreenode_getLastMoveId(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Get the creation id of this node.
+    * @returns {{ peer: PeerID, counter: number }}
+    */
+    creationId() {
+        const ret = wasm.lorotreenode_creationId(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Get the creator of this node.
+    * @returns {PeerID}
+    */
+    creator() {
+        const ret = wasm.lorotreenode_creator(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 
 const UndoManagerFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -5416,6 +5573,10 @@ function __wbg_get_imports() {
         const ret = VersionVector.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_is_function = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'function';
+        return ret;
+    };
     imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
@@ -5489,10 +5650,6 @@ function __wbg_get_imports() {
         const ret = +getObject(arg0);
         return ret;
     };
-    imports.wbg.__wbindgen_is_function = function(arg0) {
-        const ret = typeof(getObject(arg0)) === 'function';
-        return ret;
-    };
     imports.wbg.__wbindgen_is_string = function(arg0) {
         const ret = typeof(getObject(arg0)) === 'string';
         return ret;
@@ -5859,11 +6016,11 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper488 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper491 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 9, __wbg_adapter_58);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper491 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper494 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 11, __wbg_adapter_61);
         return addHeapObject(ret);
     };