loro-crdt 1.0.9 → 1.1.1

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 {
@@ -1575,7 +1576,7 @@ export class LoroDoc {
     /**
     * Get the path from the root to the container
     * @param {ContainerID} id
-    * @returns {Array<any> | undefined}
+    * @returns {(string|number)[] | undefined}
     */
     getPathToContainer(id) {
         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,22 @@ 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);
+    }
+    /**
+    * Check if the container is deleted
+    * @returns {boolean}
+    */
+    isDeleted() {
+        const ret = wasm.lorolist_isDeleted(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 
 const LoroMapFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3180,6 +3231,25 @@ 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);
+    }
+    /**
+    * Check if the container is deleted
+    * @returns {boolean}
+    */
+    isDeleted() {
+        const ret = wasm.loromap_isDeleted(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 
 const LoroMovableListFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3652,6 +3722,41 @@ 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);
+    }
+    /**
+    * Check if the container is deleted
+    * @returns {boolean}
+    */
+    isDeleted() {
+        const ret = wasm.loromovablelist_isDeleted(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 
 const LoroTextFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3703,11 +3808,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 +3854,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 +4389,23 @@ 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);
+    }
+    /**
+    * Check if the container is deleted
+    * @returns {boolean}
+    */
+    isDeleted() {
+        const ret = wasm.lorotext_isDeleted(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 
 const LoroTreeFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -4695,6 +4842,14 @@ export class LoroTree {
         const ret = wasm.lorotree_isFractionalIndexEnabled(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+    * Check if the container is deleted
+    * @returns {boolean}
+    */
+    isDeleted() {
+        const ret = wasm.lorotree_isDeleted(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 
 const LoroTreeNodeFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -4953,6 +5108,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 +5178,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')
@@ -5341,6 +5538,63 @@ export class VersionVector {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * set the exclusive ending point. target id will NOT be included by self
+    * @param {{ peer: PeerID, counter: number }} id
+    */
+    setEnd(id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.versionvector_setEnd(retptr, this.__wbg_ptr, addHeapObject(id));
+            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);
+        }
+    }
+    /**
+    * set the inclusive ending point. target id will be included
+    * @param {{ peer: PeerID, counter: number }} id
+    */
+    setLast(id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.versionvector_setLast(retptr, this.__wbg_ptr, addHeapObject(id));
+            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);
+        }
+    }
+    /**
+    * @param {PeerID} peer
+    */
+    remove(peer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.versionvector_remove(retptr, this.__wbg_ptr, addHeapObject(peer));
+            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);
+        }
+    }
+    /**
+    * @returns {number}
+    */
+    length() {
+        const ret = wasm.versionvector_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
 }
 
 async function __wbg_load(module, imports) {
@@ -5380,26 +5634,30 @@ function __wbg_get_imports() {
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
-    imports.wbg.__wbg_loromap_new = function(arg0) {
-        const ret = LoroMap.__wrap(arg0);
+    imports.wbg.__wbg_lorotreenode_new = function(arg0) {
+        const ret = LoroTreeNode.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_lorotree_new = function(arg0) {
         const ret = LoroTree.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_lorolist_new = function(arg0) {
-        const ret = LoroList.__wrap(arg0);
+    imports.wbg.__wbg_lorotext_new = function(arg0) {
+        const ret = LoroText.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_lorotreenode_new = function(arg0) {
-        const ret = LoroTreeNode.__wrap(arg0);
+    imports.wbg.__wbg_loromap_new = function(arg0) {
+        const ret = LoroMap.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_lorocounter_new = function(arg0) {
         const ret = LoroCounter.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_lorolist_new = function(arg0) {
+        const ret = LoroList.__wrap(arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_loromovablelist_new = function(arg0) {
         const ret = LoroMovableList.__wrap(arg0);
         return addHeapObject(ret);
@@ -5408,14 +5666,14 @@ function __wbg_get_imports() {
         const ret = Cursor.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_lorotext_new = function(arg0) {
-        const ret = LoroText.__wrap(arg0);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_versionvector_new = function(arg0) {
         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 +5747,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;
@@ -5600,7 +5854,7 @@ function __wbg_get_imports() {
             wasm.__wbindgen_export_5(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_now_faeb7e893612c45a = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+    imports.wbg.__wbg_now_11683c634f92ae89 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
     imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
         const ret = getObject(arg0).crypto;
         return addHeapObject(ret);
@@ -5859,12 +6113,12 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper488 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 9, __wbg_adapter_58);
+    imports.wbg.__wbindgen_closure_wrapper485 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 11, __wbg_adapter_58);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper491 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 11, __wbg_adapter_61);
+    imports.wbg.__wbindgen_closure_wrapper488 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 9, __wbg_adapter_61);
         return addHeapObject(ret);
     };
 

package/web/loro_wasm_bg.wasm.d.ts

@@ -89,12 +89,13 @@ export function lorodoc_frontiersToVV(a: number, b: number, c: number, d: number
 export function lorodoc_vvToFrontiers(a: number, b: number, c: number): void;
 export function lorodoc_getByPath(a: number, b: number, c: number): number;
 export function lorodoc_getCursorPos(a: number, b: number, c: number): void;
+export function lorodoc_getChangedContainersIn(a: number, b: number, c: number, d: number): void;
 export function __wbg_lorotext_free(a: number): void;
 export function lorotext_new(): number;
 export function lorotext_kind(a: number): number;
 export function lorotext_iter(a: number, b: number): void;
-export function lorotext_update(a: number, b: number, c: number): void;
-export function lorotext_updateByLine(a: number, b: number, c: number): void;
+export function lorotext_update(a: number, b: number, c: number, d: number, e: number): void;
+export function lorotext_updateByLine(a: number, b: number, c: number, d: number, e: number): void;
 export function lorotext_insert(a: number, b: number, c: number, d: number, e: number): void;
 export function lorotext_slice(a: number, b: number, c: number, d: number): void;
 export function lorotext_charAt(a: number, b: number, c: number): void;
@@ -114,6 +115,8 @@ export function lorotext_parent(a: number): number;
 export function lorotext_getAttached(a: number): number;
 export function lorotext_getCursor(a: number, b: number, c: number): number;
 export function lorotext_push(a: number, b: number, c: number, d: number): void;
+export function lorotext_getEditorOf(a: number, b: number): number;
+export function lorotext_isDeleted(a: number): number;
 export function __wbg_loromap_free(a: number): void;
 export function loromap_new(): number;
 export function loromap_kind(a: number): number;
@@ -132,6 +135,8 @@ export function loromap_size(a: number): number;
 export function loromap_parent(a: number): number;
 export function loromap_getAttached(a: number): number;
 export function loromap_clear(a: number, b: number): void;
+export function loromap_getLastEditor(a: number, b: number, c: number): number;
+export function loromap_isDeleted(a: number): number;
 export function __wbg_lorolist_free(a: number): void;
 export function lorolist_new(): number;
 export function lorolist_kind(a: number): number;
@@ -152,6 +157,8 @@ export function lorolist_getCursor(a: number, b: number, c: number): number;
 export function lorolist_push(a: number, b: number, c: number): void;
 export function lorolist_pop(a: number, b: number): void;
 export function lorolist_clear(a: number, b: number): void;
+export function lorolist_getIdAt(a: number, b: number): number;
+export function lorolist_isDeleted(a: number): number;
 export function loromovablelist_new(): number;
 export function loromovablelist_kind(a: number): number;
 export function loromovablelist_insert(a: number, b: number, c: number, d: number): void;
@@ -172,6 +179,10 @@ export function loromovablelist_setContainer(a: number, b: number, c: number, d:
 export function loromovablelist_push(a: number, b: number, c: number): void;
 export function loromovablelist_pop(a: number, b: number): void;
 export function loromovablelist_clear(a: number, b: number): void;
+export function loromovablelist_getCreatorAt(a: number, b: number): number;
+export function loromovablelist_getLastMoverAt(a: number, b: number): number;
+export function loromovablelist_getLastEditorAt(a: number, b: number): number;
+export function loromovablelist_isDeleted(a: number): number;
 export function __wbg_lorotree_free(a: number): void;
 export function lorotreenode___getClassname(a: number, b: number): void;
 export function __wbg_lorotreenode_free(a: number): void;
@@ -183,9 +194,13 @@ export function lorotreenode_moveBefore(a: number, b: number, c: number): void;
 export function lorotreenode_index(a: number, b: number): void;
 export function lorotreenode_fractionalIndex(a: number, b: number): void;
 export function lorotreenode_data(a: number, b: number): void;
+export function lorotreenode_toJSON(a: number, b: number): void;
 export function lorotreenode_parent(a: number, b: number): void;
 export function lorotreenode_children(a: number): number;
 export function lorotreenode_isDeleted(a: number, b: number): void;
+export function lorotreenode_getLastMoveId(a: number): number;
+export function lorotreenode_creationId(a: number): number;
+export function lorotreenode_creator(a: number): number;
 export function lorotree_new(): number;
 export function lorotree_kind(a: number): number;
 export function lorotree_createNode(a: number, b: number, c: number, d: number, e: number): void;
@@ -207,6 +222,7 @@ export function lorotree_getAttached(a: number): number;
 export function lorotree_enableFractionalIndex(a: number, b: number): void;
 export function lorotree_disableFractionalIndex(a: number): void;
 export function lorotree_isFractionalIndexEnabled(a: number): number;
+export function lorotree_isDeleted(a: number): number;
 export function __wbg_cursor_free(a: number): void;
 export function cursor_containerId(a: number): number;
 export function cursor_pos(a: number): number;
@@ -235,7 +251,11 @@ export function versionvector_encode(a: number, b: number): void;
 export function versionvector_decode(a: number, b: number, c: number): void;
 export function versionvector_get(a: number, b: number, c: number): void;
 export function versionvector_compare(a: number, b: number, c: number): void;
-export function decodeImportBlobMeta(a: number, b: number, c: number): void;
+export function versionvector_setEnd(a: number, b: number, c: number): void;
+export function versionvector_setLast(a: number, b: number, c: number): void;
+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 loromovablelist_parent(a: number): number;
 export function lorotext_isAttached(a: number): number;