loro-crdt 1.3.1 → 1.3.3

package/bundler/loro_wasm.d.ts

@@ -48,7 +48,7 @@ export function decodeImportBlobMeta(blob: Uint8Array, check_checksum: boolean):
 * const text = list.insertContainer(1, new LoroText());
 * ```
 */
-export type ContainerType = "Text" | "Map" | "List"| "Tree" | "MovableList";
+export type ContainerType = "Text" | "Map" | "List"| "Tree" | "MovableList" | "Counter";
 
 export type PeerID = `${number}`;
 /**
@@ -292,7 +292,7 @@ export type UndoConfig = {
     onPush?: (isUndo: boolean, counterRange: { start: number, end: number }, event?: LoroEventBatch) => { value: Value, cursors: Cursor[] },
     onPop?: (isUndo: boolean, value: { value: Value, cursors: Cursor[] }, counterRange: { start: number, end: number }) => void
 };
-export type Container = LoroList | LoroMap | LoroText | LoroTree | LoroMovableList;
+export type Container = LoroList | LoroMap | LoroText | LoroTree | LoroMovableList | LoroCounter;
 
 export interface ImportBlobMetadata {
     /**
@@ -1023,6 +1023,7 @@ interface LoroMovableList<T = unknown> {
      */
     setContainer<C extends Container>(pos: number, child: C): T extends C ? T : C;
 }
+
 interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
     new(): LoroMap<T>;
     /**
@@ -1076,9 +1077,13 @@ interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
      */
     get<Key extends keyof T>(key: Key): T[Key];
     /**
-     * Set the key with the value.
+     *  Set the key with the value.
+     *
+     *  If the key already exists, its value will be updated. If the key doesn't exist,
+     *  a new key-value pair will be created.
      *
-     *  If the value of the key is exist, the old value will be updated.
+     *  > **Note**: When calling `map.set(key, value)` on a LoroMap, if `map.get(key)` already returns `value`, 
+     *  > the operation will be a no-op (no operation recorded) to avoid unnecessary updates.
      *
      *  @example
      *  ```ts
@@ -1155,7 +1160,7 @@ interface LoroTree<T extends Record<string, unknown> = Record<string, unknown>>
     /**
      * Get LoroTreeNode by the TreeID.
      */
-    getNodeByID(target: TreeID): LoroTreeNode<T>;
+    getNodeByID(target: TreeID): LoroTreeNode<T> | undefined;
     subscribe(listener: Listener): Subscription;
     toArray(): TreeNodeValue[];
     getNodes(options?: { withDeleted?: boolean } ): LoroTreeNode<T>[];
@@ -1378,7 +1383,7 @@ export class Cursor {
   kind(): any;
 }
 /**
-* The handler of a tree(forest) container.
+* The handler of a counter container.
 */
 export class LoroCounter {
   free(): void;
@@ -1387,6 +1392,11 @@ export class LoroCounter {
 */
   constructor();
 /**
+* "Counter"
+* @returns {'Counter'}
+*/
+  kind(): 'Counter';
+/**
 * Increment the counter by the given value.
 * @param {number} value
 */
@@ -1431,6 +1441,10 @@ export class LoroCounter {
 */
   getShallowValue(): number;
 /**
+* The container id of this handler.
+*/
+  readonly id: ContainerID;
+/**
 * Get the value of the counter.
 */
   readonly value: number;
@@ -1440,6 +1454,10 @@ export class LoroCounter {
 * [**RichText**](LoroText), [**Map**](LoroMap) and [**Movable Tree**](LoroTree),
 * you could build all kind of applications by these.
 *
+* **Important:** Loro is a pure library and does not handle network protocols.
+* It is the responsibility of the user to manage the storage, loading, and synchronization
+* of the bytes exported by Loro in a manner suitable for their specific environment.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt"
@@ -3498,12 +3516,6 @@ export class UndoManager {
 */
   addExcludeOriginPrefix(prefix: string): void;
 /**
-* Check if the undo manager is bound to the given document.
-* @param {LoroDoc} doc
-* @returns {boolean}
-*/
-  checkBinding(doc: LoroDoc): boolean;
-/**
 */
   clear(): void;
 }

package/bundler/loro_wasm_bg.js

@@ -736,7 +736,7 @@ const LoroCounterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_lorocounter_free(ptr >>> 0));
 /**
-* The handler of a tree(forest) container.
+* The handler of a counter container.
 */
 export class LoroCounter {
 
@@ -768,6 +768,22 @@ export class LoroCounter {
         return this;
     }
     /**
+    * "Counter"
+    * @returns {'Counter'}
+    */
+    kind() {
+        const ret = wasm.lorocounter_kind(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * The container id of this handler.
+    * @returns {ContainerID}
+    */
+    get id() {
+        const ret = wasm.lorocounter_id(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
     * Increment the counter by the given value.
     * @param {number} value
     */
@@ -879,6 +895,10 @@ const LoroDocFinalization = (typeof FinalizationRegistry === 'undefined')
 * [**RichText**](LoroText), [**Map**](LoroMap) and [**Movable Tree**](LoroTree),
 * you could build all kind of applications by these.
 *
+* **Important:** Loro is a pure library and does not handle network protocols.
+* It is the responsibility of the user to manage the storage, loading, and synchronization
+* of the bytes exported by Loro in a manner suitable for their specific environment.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt"
@@ -2095,7 +2115,7 @@ export class LoroDoc {
     importUpdateBatch(data) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.lorodoc_importUpdateBatch(retptr, this.__wbg_ptr, addHeapObject(data));
+            wasm.lorodoc_importBatch(retptr, this.__wbg_ptr, addHeapObject(data));
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -5723,16 +5743,6 @@ export class UndoManager {
         wasm.undomanager_addExcludeOriginPrefix(this.__wbg_ptr, ptr0, len0);
     }
     /**
-    * Check if the undo manager is bound to the given document.
-    * @param {LoroDoc} doc
-    * @returns {boolean}
-    */
-    checkBinding(doc) {
-        _assertClass(doc, LoroDoc);
-        const ret = wasm.undomanager_checkBinding(this.__wbg_ptr, doc.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
     * Set the on push event listener.
     *
     * Every time an undo step or redo step is pushed, the on push event listener will be called.
@@ -5978,8 +5988,8 @@ export function __wbindgen_object_drop_ref(arg0) {
     takeObject(arg0);
 };
 
-export function __wbg_lorolist_new(arg0) {
-    const ret = LoroList.__wrap(arg0);
+export function __wbg_lorotreenode_new(arg0) {
+    const ret = LoroTreeNode.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -5988,33 +5998,33 @@ export function __wbg_lorocounter_new(arg0) {
     return addHeapObject(ret);
 };
 
-export function __wbg_loromap_new(arg0) {
-    const ret = LoroMap.__wrap(arg0);
+export function __wbg_lorotext_new(arg0) {
+    const ret = LoroText.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorotreenode_new(arg0) {
-    const ret = LoroTreeNode.__wrap(arg0);
+export function __wbg_lorolist_new(arg0) {
+    const ret = LoroList.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorotree_new(arg0) {
-    const ret = LoroTree.__wrap(arg0);
+export function __wbg_loromap_new(arg0) {
+    const ret = LoroMap.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_loromovablelist_new(arg0) {
-    const ret = LoroMovableList.__wrap(arg0);
+export function __wbg_cursor_new(arg0) {
+    const ret = Cursor.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_cursor_new(arg0) {
-    const ret = Cursor.__wrap(arg0);
+export function __wbg_loromovablelist_new(arg0) {
+    const ret = LoroMovableList.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorotext_new(arg0) {
-    const ret = LoroText.__wrap(arg0);
+export function __wbg_lorotree_new(arg0) {
+    const ret = LoroTree.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -6141,11 +6151,11 @@ export function __wbindgen_typeof(arg0) {
     return addHeapObject(ret);
 };
 
-export function __wbg_error_c8c2cca30a630316(arg0, arg1) {
+export function __wbg_error_9384d761bf46409d(arg0, arg1) {
     console.error(getStringFromWasm0(arg0, arg1));
 };
 
-export function __wbg_log_d8fdbde28117925d(arg0, arg1) {
+export function __wbg_log_c86c3e1bf097ba35(arg0, arg1) {
     console.log(getStringFromWasm0(arg0, arg1));
 };
 
@@ -6246,7 +6256,7 @@ export function __wbg_error_f851667af71bcfc6(arg0, arg1) {
     }
 };
 
-export const __wbg_now_15d99db1ebc1f0b2 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+export const __wbg_now_6dd635953150ee31 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
 
 export function __wbg_crypto_1d1f22824a6a080c(arg0) {
     const ret = getObject(arg0).crypto;
@@ -6570,13 +6580,13 @@ export function __wbindgen_memory() {
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper491(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 9, __wbg_adapter_60);
+export function __wbindgen_closure_wrapper482(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_60);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper494(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 11, __wbg_adapter_63);
+export function __wbindgen_closure_wrapper484(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_63);
     return addHeapObject(ret);
 };
 

package/bundler/loro_wasm_bg.wasm.d.ts

@@ -3,6 +3,8 @@
 export const memory: WebAssembly.Memory;
 export function __wbg_lorocounter_free(a: number): void;
 export function lorocounter_new(): number;
+export function lorocounter_kind(a: number): number;
+export function lorocounter_id(a: number): number;
 export function lorocounter_increment(a: number, b: number, c: number): void;
 export function lorocounter_decrement(a: number, b: number, c: number): void;
 export function lorocounter_value(a: number): number;
@@ -78,7 +80,6 @@ export function lorodoc_exportJsonUpdates(a: number, b: number, c: number, d: nu
 export function lorodoc_exportJsonInIdSpan(a: number, b: number, c: number): void;
 export function lorodoc_importJsonUpdates(a: number, b: number, c: number): void;
 export function lorodoc_import(a: number, b: number, c: number, d: number): void;
-export function lorodoc_importUpdateBatch(a: number, b: number, c: number): void;
 export function lorodoc_importBatch(a: number, b: number, c: number): void;
 export function lorodoc_getShallowValue(a: number, b: number): void;
 export function lorodoc_toJSON(a: number, b: number): void;
@@ -253,7 +254,6 @@ export function undomanager_canRedo(a: number): number;
 export function undomanager_setMaxUndoSteps(a: number, b: number): void;
 export function undomanager_setMergeInterval(a: number, b: number): void;
 export function undomanager_addExcludeOriginPrefix(a: number, b: number, c: number): void;
-export function undomanager_checkBinding(a: number, b: number): number;
 export function undomanager_setOnPush(a: number, b: number): void;
 export function undomanager_setOnPop(a: number, b: number): void;
 export function undomanager_clear(a: number): void;
@@ -271,6 +271,7 @@ export function versionvector_remove(a: number, b: number, c: number): void;
 export function versionvector_length(a: number): number;
 export function decodeImportBlobMeta(a: number, b: number, c: number, d: number): void;
 export function __wbg_loromovablelist_free(a: number): void;
+export function lorodoc_importUpdateBatch(a: number, b: number, c: number): void;
 export function loromovablelist_parent(a: number): number;
 export function lorotext_isAttached(a: number): number;
 export function loromap_isAttached(a: number): number;

package/nodejs/loro_wasm.d.ts

@@ -48,7 +48,7 @@ export function decodeImportBlobMeta(blob: Uint8Array, check_checksum: boolean):
 * const text = list.insertContainer(1, new LoroText());
 * ```
 */
-export type ContainerType = "Text" | "Map" | "List"| "Tree" | "MovableList";
+export type ContainerType = "Text" | "Map" | "List"| "Tree" | "MovableList" | "Counter";
 
 export type PeerID = `${number}`;
 /**
@@ -292,7 +292,7 @@ export type UndoConfig = {
     onPush?: (isUndo: boolean, counterRange: { start: number, end: number }, event?: LoroEventBatch) => { value: Value, cursors: Cursor[] },
     onPop?: (isUndo: boolean, value: { value: Value, cursors: Cursor[] }, counterRange: { start: number, end: number }) => void
 };
-export type Container = LoroList | LoroMap | LoroText | LoroTree | LoroMovableList;
+export type Container = LoroList | LoroMap | LoroText | LoroTree | LoroMovableList | LoroCounter;
 
 export interface ImportBlobMetadata {
     /**
@@ -1023,6 +1023,7 @@ interface LoroMovableList<T = unknown> {
      */
     setContainer<C extends Container>(pos: number, child: C): T extends C ? T : C;
 }
+
 interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
     new(): LoroMap<T>;
     /**
@@ -1076,9 +1077,13 @@ interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
      */
     get<Key extends keyof T>(key: Key): T[Key];
     /**
-     * Set the key with the value.
+     *  Set the key with the value.
+     *
+     *  If the key already exists, its value will be updated. If the key doesn't exist,
+     *  a new key-value pair will be created.
      *
-     *  If the value of the key is exist, the old value will be updated.
+     *  > **Note**: When calling `map.set(key, value)` on a LoroMap, if `map.get(key)` already returns `value`, 
+     *  > the operation will be a no-op (no operation recorded) to avoid unnecessary updates.
      *
      *  @example
      *  ```ts
@@ -1155,7 +1160,7 @@ interface LoroTree<T extends Record<string, unknown> = Record<string, unknown>>
     /**
      * Get LoroTreeNode by the TreeID.
      */
-    getNodeByID(target: TreeID): LoroTreeNode<T>;
+    getNodeByID(target: TreeID): LoroTreeNode<T> | undefined;
     subscribe(listener: Listener): Subscription;
     toArray(): TreeNodeValue[];
     getNodes(options?: { withDeleted?: boolean } ): LoroTreeNode<T>[];
@@ -1378,7 +1383,7 @@ export class Cursor {
   kind(): any;
 }
 /**
-* The handler of a tree(forest) container.
+* The handler of a counter container.
 */
 export class LoroCounter {
   free(): void;
@@ -1387,6 +1392,11 @@ export class LoroCounter {
 */
   constructor();
 /**
+* "Counter"
+* @returns {'Counter'}
+*/
+  kind(): 'Counter';
+/**
 * Increment the counter by the given value.
 * @param {number} value
 */
@@ -1431,6 +1441,10 @@ export class LoroCounter {
 */
   getShallowValue(): number;
 /**
+* The container id of this handler.
+*/
+  readonly id: ContainerID;
+/**
 * Get the value of the counter.
 */
   readonly value: number;
@@ -1440,6 +1454,10 @@ export class LoroCounter {
 * [**RichText**](LoroText), [**Map**](LoroMap) and [**Movable Tree**](LoroTree),
 * you could build all kind of applications by these.
 *
+* **Important:** Loro is a pure library and does not handle network protocols.
+* It is the responsibility of the user to manage the storage, loading, and synchronization
+* of the bytes exported by Loro in a manner suitable for their specific environment.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt"
@@ -3498,12 +3516,6 @@ export class UndoManager {
 */
   addExcludeOriginPrefix(prefix: string): void;
 /**
-* Check if the undo manager is bound to the given document.
-* @param {LoroDoc} doc
-* @returns {boolean}
-*/
-  checkBinding(doc: LoroDoc): boolean;
-/**
 */
   clear(): void;
 }

package/nodejs/loro_wasm.js

@@ -733,7 +733,7 @@ const LoroCounterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_lorocounter_free(ptr >>> 0));
 /**
-* The handler of a tree(forest) container.
+* The handler of a counter container.
 */
 class LoroCounter {
 
@@ -765,6 +765,22 @@ class LoroCounter {
         return this;
     }
     /**
+    * "Counter"
+    * @returns {'Counter'}
+    */
+    kind() {
+        const ret = wasm.lorocounter_kind(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * The container id of this handler.
+    * @returns {ContainerID}
+    */
+    get id() {
+        const ret = wasm.lorocounter_id(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
     * Increment the counter by the given value.
     * @param {number} value
     */
@@ -877,6 +893,10 @@ const LoroDocFinalization = (typeof FinalizationRegistry === 'undefined')
 * [**RichText**](LoroText), [**Map**](LoroMap) and [**Movable Tree**](LoroTree),
 * you could build all kind of applications by these.
 *
+* **Important:** Loro is a pure library and does not handle network protocols.
+* It is the responsibility of the user to manage the storage, loading, and synchronization
+* of the bytes exported by Loro in a manner suitable for their specific environment.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt"
@@ -2093,7 +2113,7 @@ class LoroDoc {
     importUpdateBatch(data) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.lorodoc_importUpdateBatch(retptr, this.__wbg_ptr, addHeapObject(data));
+            wasm.lorodoc_importBatch(retptr, this.__wbg_ptr, addHeapObject(data));
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -5728,16 +5748,6 @@ class UndoManager {
         wasm.undomanager_addExcludeOriginPrefix(this.__wbg_ptr, ptr0, len0);
     }
     /**
-    * Check if the undo manager is bound to the given document.
-    * @param {LoroDoc} doc
-    * @returns {boolean}
-    */
-    checkBinding(doc) {
-        _assertClass(doc, LoroDoc);
-        const ret = wasm.undomanager_checkBinding(this.__wbg_ptr, doc.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
     * Set the on push event listener.
     *
     * Every time an undo step or redo step is pushed, the on push event listener will be called.
@@ -5985,8 +5995,8 @@ module.exports.__wbindgen_object_drop_ref = function(arg0) {
     takeObject(arg0);
 };
 
-module.exports.__wbg_lorolist_new = function(arg0) {
-    const ret = LoroList.__wrap(arg0);
+module.exports.__wbg_lorotreenode_new = function(arg0) {
+    const ret = LoroTreeNode.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -5995,33 +6005,33 @@ module.exports.__wbg_lorocounter_new = function(arg0) {
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_loromap_new = function(arg0) {
-    const ret = LoroMap.__wrap(arg0);
+module.exports.__wbg_lorotext_new = function(arg0) {
+    const ret = LoroText.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_lorotreenode_new = function(arg0) {
-    const ret = LoroTreeNode.__wrap(arg0);
+module.exports.__wbg_lorolist_new = function(arg0) {
+    const ret = LoroList.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_lorotree_new = function(arg0) {
-    const ret = LoroTree.__wrap(arg0);
+module.exports.__wbg_loromap_new = function(arg0) {
+    const ret = LoroMap.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_loromovablelist_new = function(arg0) {
-    const ret = LoroMovableList.__wrap(arg0);
+module.exports.__wbg_cursor_new = function(arg0) {
+    const ret = Cursor.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_cursor_new = function(arg0) {
-    const ret = Cursor.__wrap(arg0);
+module.exports.__wbg_loromovablelist_new = function(arg0) {
+    const ret = LoroMovableList.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_lorotext_new = function(arg0) {
-    const ret = LoroText.__wrap(arg0);
+module.exports.__wbg_lorotree_new = function(arg0) {
+    const ret = LoroTree.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -6148,11 +6158,11 @@ module.exports.__wbindgen_typeof = function(arg0) {
     return addHeapObject(ret);
 };
 
-module.exports.__wbg_error_c8c2cca30a630316 = function(arg0, arg1) {
+module.exports.__wbg_error_9384d761bf46409d = function(arg0, arg1) {
     console.error(getStringFromWasm0(arg0, arg1));
 };
 
-module.exports.__wbg_log_d8fdbde28117925d = function(arg0, arg1) {
+module.exports.__wbg_log_c86c3e1bf097ba35 = function(arg0, arg1) {
     console.log(getStringFromWasm0(arg0, arg1));
 };
 
@@ -6253,7 +6263,7 @@ module.exports.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
     }
 };
 
-module.exports.__wbg_now_15d99db1ebc1f0b2 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+module.exports.__wbg_now_6dd635953150ee31 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
 
 module.exports.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
     const ret = getObject(arg0).crypto;
@@ -6577,13 +6587,13 @@ module.exports.__wbindgen_memory = function() {
     return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_closure_wrapper491 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 9, __wbg_adapter_60);
+module.exports.__wbindgen_closure_wrapper482 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_60);
     return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_closure_wrapper494 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 11, __wbg_adapter_63);
+module.exports.__wbindgen_closure_wrapper484 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_63);
     return addHeapObject(ret);
 };
 

package/nodejs/loro_wasm_bg.wasm.d.ts

@@ -3,6 +3,8 @@
 export const memory: WebAssembly.Memory;
 export function __wbg_lorocounter_free(a: number): void;
 export function lorocounter_new(): number;
+export function lorocounter_kind(a: number): number;
+export function lorocounter_id(a: number): number;
 export function lorocounter_increment(a: number, b: number, c: number): void;
 export function lorocounter_decrement(a: number, b: number, c: number): void;
 export function lorocounter_value(a: number): number;
@@ -78,7 +80,6 @@ export function lorodoc_exportJsonUpdates(a: number, b: number, c: number, d: nu
 export function lorodoc_exportJsonInIdSpan(a: number, b: number, c: number): void;
 export function lorodoc_importJsonUpdates(a: number, b: number, c: number): void;
 export function lorodoc_import(a: number, b: number, c: number, d: number): void;
-export function lorodoc_importUpdateBatch(a: number, b: number, c: number): void;
 export function lorodoc_importBatch(a: number, b: number, c: number): void;
 export function lorodoc_getShallowValue(a: number, b: number): void;
 export function lorodoc_toJSON(a: number, b: number): void;
@@ -253,7 +254,6 @@ export function undomanager_canRedo(a: number): number;
 export function undomanager_setMaxUndoSteps(a: number, b: number): void;
 export function undomanager_setMergeInterval(a: number, b: number): void;
 export function undomanager_addExcludeOriginPrefix(a: number, b: number, c: number): void;
-export function undomanager_checkBinding(a: number, b: number): number;
 export function undomanager_setOnPush(a: number, b: number): void;
 export function undomanager_setOnPop(a: number, b: number): void;
 export function undomanager_clear(a: number): void;
@@ -271,6 +271,7 @@ export function versionvector_remove(a: number, b: number, c: number): void;
 export function versionvector_length(a: number): number;
 export function decodeImportBlobMeta(a: number, b: number, c: number, d: number): void;
 export function __wbg_loromovablelist_free(a: number): void;
+export function lorodoc_importUpdateBatch(a: number, b: number, c: number): void;
 export function loromovablelist_parent(a: number): number;
 export function lorotext_isAttached(a: number): number;
 export function loromap_isAttached(a: number): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loro-crdt",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "Loro CRDTs is a high-performance CRDT framework that makes your app state synchronized, collaborative and maintainable effortlessly.",
   "keywords": [
     "crdt",