@rue-js/runtime-vapor 0.0.27 → 0.0.28

package/pkg/rue_runtime_vapor_bg.js

@@ -0,0 +1,1921 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export3(addHeapObject(e));
+    }
+}
+
+let heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            state.dtor(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+function __wasm_bindgen_func_elem_184(arg0, arg1, arg2, arg3, arg4, arg5) {
+    const ret = wasm.__wasm_bindgen_func_elem_184(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3), addHeapObject(arg4), addHeapObject(arg5));
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_178(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_178(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_183(arg0, arg1, arg2, arg3, arg4) {
+    const ret = wasm.__wasm_bindgen_func_elem_183(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3), addHeapObject(arg4));
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_1099(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1099(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+function __wasm_bindgen_func_elem_180(arg0, arg1, arg2) {
+    const ret = wasm.__wasm_bindgen_func_elem_180(arg0, arg1, addHeapObject(arg2));
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_182(arg0, arg1, arg2, arg3) {
+    const ret = wasm.__wasm_bindgen_func_elem_182(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+    return ret !== 0;
+}
+
+function __wasm_bindgen_func_elem_181(arg0, arg1, arg2, arg3) {
+    const ret = wasm.__wasm_bindgen_func_elem_181(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_179(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_179(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_177(arg0, arg1) {
+    const ret = wasm.__wasm_bindgen_func_elem_177(arg0, arg1);
+    return takeObject(ret);
+}
+
+const EffectHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_effecthandle_free(ptr >>> 0, 1));
+
+const SignalHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signalhandle_free(ptr >>> 0, 1));
+
+const WasmRueFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmrue_free(ptr >>> 0, 1));
+
+export class EffectHandle {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(EffectHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        EffectHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EffectHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_effecthandle_free(ptr, 0);
+    }
+    /**
+     * 销毁副作用：标记为已处置，并清空其清理回调
+     *
+     * 用法（JavaScript）：
+     * ```js
+     * const eh = createEffect(() => {
+     *   // ...effect body
+     *   onCleanup(() => {
+     *     // 这里注册的清理会在下一次执行前或 dispose() 时运行
+     *   })
+     * })
+     * // 需要停止该副作用时：
+     * eh.dispose() // 标记为已处置，并执行最后一次已注册的清理
+     * ```
+     */
+    dispose() {
+        wasm.effecthandle_dispose(this.__wbg_ptr);
+    }
+}
+if (Symbol.dispose) EffectHandle.prototype[Symbol.dispose] = EffectHandle.prototype.free;
+
+export class SignalHandle {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SignalHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        SignalHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignalHandleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signalhandle_free(ptr, 0);
+    }
+    /**
+     * 根据路径读取当前对象/数组的子项值（依赖收集）
+     *
+     * 用法（JavaScript）：
+     * ```js
+     * const s = createSignal({ user: { profile: { name: 'A' } } })
+     * const name1 = s.getPath(['user','profile','name']) // 'A'
+     * const name2 = s.getPath('user.profile.name') // 'A'
+     * // 在 watch 中使用路径读取会自动依赖收集
+     * watchFn(() => s.getPath(['user','profile','name']), (n, o) => {  })
+     * watchFn(() => s.getPath('user.profile.name'), (n, o) => {  })
+     * ```
+     * @param {any} path
+     * @returns {any}
+     */
+    getPath(path) {
+        const ret = wasm.signalhandle_getPath(this.__wbg_ptr, addHeapObject(path));
+        return takeObject(ret);
+    }
+    /**
+     * 根据路径设置对象/数组的子项值：不可变更新，生成新的根对象并触发订阅者
+     *
+     * 用法（JavaScript）：
+     * ```js
+     * const s = createSignal({ user: { profile: { name: 'A' }, age: 20 }, items: ['x'] })
+     * // 设置嵌套对象字段（数组路径）
+     * s.setPath(['user', 'profile', 'name'], 'B')
+     * // 设置数组元素（数组路径）
+     * s.setPath(['items', 0], 'y')
+     * // 字符串路径（以 . 分隔，数字段转为数组索引）
+     * s.setPath('user.profile.name', 'B')
+     * s.setPath('items.0', 'y')
+     * // 若根不是对象/数组，会以空对象作为根进行赋值
+     * s.setPath(['foo', 'bar'], 1)
+     * s.setPath('foo.bar', 1)
+     * ```
+     *
+     * 参数：
+     * - `path`: JS 数组或以 `.` 分隔的字符串（如 `['user','profile','name']`、`['items', 0]` 或 `'user.profile.name'`、`'items.0'`）
+     * - `value`: 目标路径的新值
+     * 行为与边界：
+     * - 路径缺失会自动以空对象占位，数组越界写入会扩展长度
+     * - 根为非对象/数组时以空对象为根进行赋值
+     * - 函数值作为普通值读写，不会被执行
+     * @param {any} path
+     * @param {any} value
+     */
+    setPath(path, value) {
+        wasm.signalhandle_setPath(this.__wbg_ptr, addHeapObject(path), addHeapObject(value));
+    }
+    /**
+     * 便于调试：`signal.valueOf()` 返回内部值
+     * @returns {any}
+     */
+    valueOf() {
+        const ret = wasm.signalhandle_valueOf(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * 路径偷看：不进行依赖收集（不订阅当前副作用），仅返回当前路径的值
+     * - 支持以 `.` 分隔的字符串路径（如 `user.profile.name`）或数组路径（如 `['user','profile','name']`、`['items', 0]`）
+     * - 行为与 `getPath` 相同，但不会触发依赖收集，适合用于调试/序列化
+     * @param {any} path
+     * @returns {any}
+     */
+    peekPath(path) {
+        const ret = wasm.signalhandle_peekPath(this.__wbg_ptr, addHeapObject(path));
+        return takeObject(ret);
+    }
+    /**
+     * 便于调试：`String(signal)` 返回值的 JSON 字符串或占位文本
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.signalhandle_toString(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * 只读调试：`signal.value` 直接返回内部值（不进行依赖收集）
+     * @returns {any}
+     */
+    get value() {
+        const ret = wasm.signalhandle_value(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * 调试写入：`signal.value = next` 等价于 `signal.set(next)`
+     * 用法示例（JavaScript）：
+     * ```js
+     * const s = createSignal(0)
+     * createEffect(() => { console.log('v =', s.get()) })
+     * s.value = 1         // 触发 effect（等价于 s.set(1)）
+     * s.value = 1         // 若等值比较认为相等，则不触发
+     * ```
+     * @param {any} v
+     */
+    set value(v) {
+        wasm.signalhandle_set(this.__wbg_ptr, addHeapObject(v));
+    }
+    /**
+     * 根据路径函数式更新子项：`updater(currentAtPath) -> nextAtPath`
+     *
+     * 用法（JavaScript）：
+     * ```js
+     * const s = createSignal({ user: { age: 20 }, items: ['x'] })
+     * s.updatePath(['user','age'], prev => prev + 1) // age: 21
+     * s.updatePath(['user','name'], prev => (prev || '').toUpperCase())
+     * // 使用字符串路径
+     * s.updatePath('user.age', prev => prev + 1) // age: 21
+     * s.updatePath('items.0', prev => (prev || '').toUpperCase())
+     * ```
+     * @param {any} path
+     * @param {Function} updater
+     */
+    updatePath(path, updater) {
+        wasm.signalhandle_updatePath(this.__wbg_ptr, addHeapObject(path), addHeapObject(updater));
+    }
+    /**
+     * 读取当前值，并在有正在运行的副作用时将其订阅到该信号
+     * @returns {any}
+     */
+    get() {
+        const ret = wasm.signalhandle_get(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * 设置新值，按等值比较决定是否通知订阅者
+     * @param {any} v
+     */
+    set(v) {
+        wasm.signalhandle_set(this.__wbg_ptr, addHeapObject(v));
+    }
+    /**
+     * 偷看当前值：不进行依赖收集（不订阅当前副作用）
+     * @returns {any}
+     */
+    peek() {
+        const ret = wasm.signalhandle_peek(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * 便于调试：`JSON.stringify(signal)` 时返回内部值
+     * @returns {any}
+     */
+    toJSON() {
+        const ret = wasm.signalhandle_toJSON(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * 根据回调对当前值进行计算并设置（相当于 set( updater(current) )）
+     * @param {Function} updater
+     */
+    update(updater) {
+        wasm.signalhandle_update(this.__wbg_ptr, addHeapObject(updater));
+    }
+}
+if (Symbol.dispose) SignalHandle.prototype[Symbol.dispose] = SignalHandle.prototype.free;
+
+export class WasmRue {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmRue.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmRueFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmRueFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmrue_free(ptr, 0);
+    }
+    /**
+     * @param {any} f
+     */
+    onCreated(f) {
+        wasm.wasmrue_onCreated(this.__wbg_ptr, addHeapObject(f));
+    }
+    /**
+     * @param {any} f
+     */
+    onMounted(f) {
+        wasm.wasmrue_onMounted(this.__wbg_ptr, addHeapObject(f));
+    }
+    /**
+     * @param {any} f
+     */
+    onUpdated(f) {
+        wasm.wasmrue_onUpdated(this.__wbg_ptr, addHeapObject(f));
+    }
+    /**
+     * 使用插件：将 options 归一化为 Vec<JsValue> 并调用内部 use_plugin
+     * @param {any} plugin
+     * @param {any} options
+     */
+    use(plugin, options) {
+        wasm.wasmrue_use(this.__wbg_ptr, addHeapObject(plugin), addHeapObject(options));
+    }
+    /**
+     * @param {any} f
+     */
+    onUnmounted(f) {
+        wasm.wasmrue_onUnmounted(this.__wbg_ptr, addHeapObject(f));
+    }
+    /**
+     * 创建元素/组件的 VNode（开发态对象或注册表引用）
+     *
+     * - 组件函数：构建 Component 类型并输出注册表 ID
+     * - 普通标签：构建 VNodeType，归一化 children，入注册表或内联对象
+     * @param {any} type_tag
+     * @param {any} props
+     * @param {any} children
+     * @returns {any}
+     */
+    createElement(type_tag, props, children) {
+        const ret = wasm.wasmrue_createElement(this.__wbg_ptr, addHeapObject(type_tag), addHeapObject(props), addHeapObject(children));
+        return takeObject(ret);
+    }
+    /**
+     * 区间渲染入口：解析 id/函数组件/对象为 VNode，并提交区间信息
+     * @param {any} vnode_id
+     * @param {any} parent
+     * @param {any} start
+     * @param {any} end
+     */
+    renderBetween(vnode_id, parent, start, end) {
+        wasm.wasmrue_renderBetween(this.__wbg_ptr, addHeapObject(vnode_id), addHeapObject(parent), addHeapObject(start), addHeapObject(end));
+    }
+    /**
+     * 读取当前 DOM 适配器（从全局 __rue_dom）
+     * @returns {any}
+     */
+    getDOMAdapter() {
+        const ret = wasm.wasmrue_getDOMAdapter(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @param {any} f
+     */
+    onBeforeMount(f) {
+        wasm.wasmrue_onBeforeMount(this.__wbg_ptr, addHeapObject(f));
+    }
+    /**
+     * 设置 DOM 适配器（JsDomAdapter），用于后续渲染与元素操作
+     * @param {any} adapter
+     */
+    setDOMAdapter(adapter) {
+        wasm.wasmrue_setDOMAdapter(this.__wbg_ptr, addHeapObject(adapter));
+    }
+    /**
+     * @param {any} f
+     */
+    onBeforeCreate(f) {
+        wasm.wasmrue_onBeforeCreate(this.__wbg_ptr, addHeapObject(f));
+    }
+    /**
+     * @param {any} f
+     */
+    onBeforeUpdate(f) {
+        wasm.wasmrue_onBeforeUpdate(this.__wbg_ptr, addHeapObject(f));
+    }
+    /**
+     * @param {any} f
+     */
+    onBeforeUnmount(f) {
+        wasm.wasmrue_onBeforeUnmount(this.__wbg_ptr, addHeapObject(f));
+    }
+    /**
+     * 获取 DOM 适配器的“可变”接口（同只读返回，兼容 JS 侧命名）
+     * @returns {any}
+     */
+    getDOMAdapterMut() {
+        const ret = wasm.wasmrue_getDOMAdapterMut(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * JSX/h 入口：与 createElement 行为一致，聚合到同一实现
+     * @param {any} type_tag
+     * @param {any} props
+     * @param {any} children
+     * @returns {any}
+     */
+    h(type_tag, props, children) {
+        const ret = wasm.wasmrue_createElement(this.__wbg_ptr, addHeapObject(type_tag), addHeapObject(props), addHeapObject(children));
+        return takeObject(ret);
+    }
+    /**
+     * 获取当前容器：优先返回最近一次渲染或挂载设置的容器
+     * @returns {any}
+     */
+    getCurrentContainer() {
+        const ret = wasm.wasmrue_getCurrentContainer(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * 挂载入口：预刷新延迟任务 → 调用 app → 回退到空片段
+     * @param {any} app
+     * @param {any} container
+     */
+    mount(app, container) {
+        wasm.wasmrue_mount(this.__wbg_ptr, addHeapObject(app), addHeapObject(container));
+    }
+    /**
+     * 返回 Vapor/VaporWithSetup 的注册表对象
+     *
+     * - 若传入 setup 函数：构建 VaporWithSetup，并尝试立即调用以填充 el
+     * - 若 el 为片段：收集其子节点并写入 __fragNodes
+     * - 否则构建普通 Vapor VNode
+     * @param {any} setup
+     * @returns {any}
+     */
+    vapor(setup) {
+        const ret = wasm.wasmrue_vapor(this.__wbg_ptr, addHeapObject(setup));
+        return takeObject(ret);
+    }
+    /**
+     * 渲染入口：接受 id/对象/vaporElement，解析为 VNode 并异步提交
+     * @param {any} vnode_id
+     * @param {any} container
+     */
+    render(vnode_id, container) {
+        wasm.wasmrue_render(this.__wbg_ptr, addHeapObject(vnode_id), addHeapObject(container));
+    }
+    /**
+     * 返回一个 JS 回调函数，用于在组件内部发射事件
+     *
+     * - 根据 props 构建事件发射器 emitter(name, args)
+     * - 回调参数 args 若为数组，将其拆解为 Vec<JsValue> 传入
+     * @param {any} props
+     * @returns {any}
+     */
+    emitted(props) {
+        const ret = wasm.wasmrue_emitted(this.__wbg_ptr, addHeapObject(props));
+        return takeObject(ret);
+    }
+    /**
+     * 卸载入口：清空容器 innerHTML，并解除 container_map 绑定
+     * @param {any} container
+     */
+    unmount(container) {
+        wasm.wasmrue_unmount(this.__wbg_ptr, addHeapObject(container));
+    }
+    /**
+     * @param {any} f
+     */
+    onError(f) {
+        wasm.wasmrue_onError(this.__wbg_ptr, addHeapObject(f));
+    }
+}
+if (Symbol.dispose) WasmRue.prototype[Symbol.dispose] = WasmRue.prototype.free;
+
+/**
+ * 批量更新：在回调期间抑制副作用的即时触发，统一在结束后刷新
+ *
+ * 用法与示例（JavaScript）：
+ * ```js
+ * const { createSignal, createEffect, batch } = wasmModule
+ *
+ * // 示例一：同一信号多次 set，仅在批量结束后重跑一次
+ * const count = createSignal(0)
+ * createEffect(() => {
+ *   console.log('[batch-demo] count =', count.get())
+ * })
+ * batch(() => {
+ *   count.set(1)
+ *   count.set(2)
+ *   count.set(3)
+ *   // 在批量范围内不会立即触发副作用
+ * })
+ * // 批量结束后只触发一次副作用，打印最新值 3
+ *
+ * // 示例二：一次性更新多个信号，副作用只合并重跑一次
+ * const a = createSignal(0)
+ * const b = createSignal(0)
+ * createEffect(() => {
+ *   console.log('[batch-demo] sum =', a.get() + b.get())
+ * })
+ * batch(() => {
+ *   a.set(10)
+ *   b.set(20)
+ * }) // 仅一次重跑，输出 sum = 30
+ * ```
+ * @param {Function} cb
+ */
+export function batch(cb) {
+    wasm.batch(addHeapObject(cb));
+}
+
+/**
+ * @param {any} arg
+ * @param {boolean | null} [force_global]
+ * @returns {SignalHandle}
+ */
+export function computed(arg, force_global) {
+    const ret = wasm.computed(addHeapObject(arg), isLikeNone(force_global) ? 0xFFFFFF : force_global ? 1 : 0);
+    return SignalHandle.__wrap(ret);
+}
+
+/**
+ * 创建计算属性
+ * - 参数：可为函数 `() => any`，或对象 `{ get: () => any }`
+ * 返回：一个只读信号句柄（通过 get/peek 读取，内部通过 effect 驱动更新）
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, createComputed, createEffect } = wasmModule;
+ * const count = createSignal(1);
+ * const double = createComputed(() => count.get() * 2);
+ *
+ * createEffect(() => {
+ *   console.log('double =', double.get());
+ * });
+ *
+ * count.set(2); // double 将变为 4 并触发订阅者
+ * ```
+ * 更多用法示例：
+ *
+ * 1) 对象参数（只读 getter）：
+ * ```javascript
+ * const { createSignal, createComputed, createEffect } = wasmModule;
+ * const first = createSignal('John');
+ * const last = createSignal('Doe');
+ * const fullName = createComputed({
+ *   get: () => first.get() + ' ' + last.get()
+ * });
+ * createEffect(() => {
+ *   console.log('fullName =', fullName.get()); // John Doe
+ * });
+ * ```
+ *
+ * 2) 通过更新源信号实现“可写效果”（模拟 Vue3 的 setter 行为）：
+ * ```javascript
+ * const setFullName = (nv) => {
+ *   const [f, l] = nv.split(' ');
+ *   first.set(f);
+ *   last.set(l);
+ * };
+ * setFullName('David Smith'); // fullName 将变为 "David Smith"
+ * ```
+ *
+ * 3) 直接使用 `{ get, set }` 创建“可写 computed”，支持 `.set(value)`：
+ * ```javascript
+ * const fullName = createComputed({
+ *   get: () => first.get() + ' ' + last.get(),
+ *   set: (nv) => {
+ *     const [f, l] = nv.split(' ');
+ *     first.set(f);
+ *     last.set(l);
+ *   }
+ * });
+ * fullName.set('David Smith'); // 将调用你的 set 更新源信号，并重算派生值
+ * ```
+ * @param {any} arg
+ * @returns {SignalHandle}
+ */
+export function createComputed(arg) {
+    const ret = wasm.createComputed(addHeapObject(arg));
+    return SignalHandle.__wrap(ret);
+}
+
+/**
+ * 创建副作用（立即运行一次），并返回句柄
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, createEffect, onCleanup, untrack, batch } = wasmModule;
+ * const s = createSignal(0);
+ *
+ * // 基本副作用：读取信号并打印
+ * createEffect(() => {
+ *   console.log('value:', s.get());
+ * });
+ * s.set(1);
+ *
+ * // 清理示例：注册定时器并在下一次运行前清理
+ * createEffect(() => {
+ *   const id = setInterval(() => console.log('tick'), 1000);
+ *   onCleanup(() => clearInterval(id));
+ * });
+ *
+ * // 断开依赖收集：不会订阅 other 信号
+ * createEffect(() => {
+ *   const v = untrack(() => s.get());
+ *   console.log('untracked:', v);
+ * });
+ *
+ * 创建副作用（支持自定义调度器与懒执行）
+ * options:
+ * - scheduler: Function( run: Function )，用于自定义何时调用 run
+ * - lazy: bool，true 时不在创建时立即运行
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createEffect } = wasmModule;
+ * const scheduler = (run) => queueMicrotask(run); // 或者使用 requestAnimationFrame
+ * createEffect(() => {
+ *   // ...effect body
+ * }, { scheduler, lazy: false });
+ * ```
+ * @param {Function} cb
+ * @param {any | null} [options]
+ * @returns {EffectHandle}
+ */
+export function createEffect(cb, options) {
+    const ret = wasm.createEffect(addHeapObject(cb), isLikeNone(options) ? 0 : addHeapObject(options));
+    return EffectHandle.__wrap(ret);
+}
+
+/**
+ * 创建 Reactive：返回一个对象/数组的响应式代理（深/浅、只读可选）
+ *
+ * 用法（JavaScript / TypeScript）：
+ * ```ts
+ * // 基础对象：读取与写入都响应式
+ * const state = createReactive({ user: { name: 'A' }, items: ['x'] })
+ * console.log(state.user.name)     // 'A'
+ * state.user.name = 'B'            // 写入嵌套字段，触发订阅者
+ * state.items.push('y')            // 数组写入也可触发（通过路径写入实现不可变更新）
+ *
+ * // 在 Vapor JSX 中使用（自动 DOM 更新）
+ * // <span>{state.user.name}</span>
+ * // <input value={state.user.name} onInput={e => state.user.name = e.target.value} />
+ *
+ * // 只读代理：禁止写入
+ * const ro = createReactive({ a: 1 }, { readonly: true })
+ * // ro.a = 2 // 将被忽略或导致失败（只读）
+ *
+ * // 浅代理：仅对顶层对象进行代理，子对象不递归代理
+ * const sh = createReactive({ nested: { a: 1 } }, { shallow: true })
+ * // sh.nested 仍为普通对象（非代理）
+ *
+ * // 原始类型：普通值会自动包裹为 { value } 并返回其代理
+ * const num = createReactive(0)
+ * console.log(num.value)       // 0
+ * num.value = 1               // 写入 value 字段触发订阅者
+ * const str = createReactive('A')
+ * str.value = 'B'             // 原始类型统一通过 value 字段读写
+ *
+ * // 自定义等值比较：用于控制触发频率
+ * const eq = (prev: any, next: any) => _.isEqual(prev, next)
+ * const obj = createReactive({ a: 1 }, { equals: eq })
+ * obj.a = 1 // 不触发（相等）
+ * ```
+ * @param {any} initial
+ * @param {any | null} [options]
+ * @returns {any}
+ */
+export function createReactive(initial, options) {
+    const ret = wasm.createReactive(addHeapObject(initial), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+
+/**
+ * 创建 Ref：返回一个带有 `value` 字段的响应式代理对象
+ *
+ * 用法（JavaScript / TypeScript）：
+ * ```ts
+ * // 基本使用：读写 value，自动依赖收集
+ * const r = createRef(0)
+ * console.log(r.value)        // 0
+ * r.value = 1                 // 触发订阅者
+ *
+ * // 与 watchEffect 配合（依赖自动收集）
+ * const stop = watchEffect(() => {
+ *   console.log('ref value =', r.value)
+ * })
+ * r.value = 2                 // 触发前面的 watchEffect
+ * stop()                      // 停止响应
+ *
+ * // peek：查看当前值，不收集依赖（不会订阅当前副作用）
+ * const cur = r.peek()        // 仅返回值，不产生订阅
+ *
+ * // update：基于当前值计算并写回
+ * r.update(prev => prev + 1)  // 等价于 r.value = (prev + 1)
+ *
+ * // 自定义等值比较：避免无意义的触发
+ * const r2 = createRef({ a: 1 }, { equals: (p, n) => _.isEqual(p?.value, n?.value) })
+ * r2.value = { a: 1 }         // 不触发（相等）
+ *
+ * // 与组件/DOM 结合（Vapor 模式下自动更新）
+ * // <span>{r.value}</span> 会被编译为原生 DOM + 响应式更新
+ * ```
+ * @param {any} initial
+ * @param {any | null} [options]
+ * @returns {any}
+ */
+export function createRef(initial, options) {
+    const ret = wasm.createRef(addHeapObject(initial), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+
+/**
+ * 创建资源：根据 `src` 信号的值调用 `fetcher`（返回 Promise），
+ * 并提供 `{ data, error, loading }` 三个信号以反映异步状态。
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, createResource, createEffect } = wasmModule;
+ * const key = createSignal('https://api.example.com/data');
+ * const res = createResource(key, async (k) => {
+ *   const r = await fetch(k);
+ *   if (!r.ok) throw new Error('network error');
+ *   return r.json();
+ * });
+ *
+ * createEffect(() => {
+ *   console.log('loading:', res.loading.get());
+ *   console.log('data:', res.data.get());
+ *   console.log('error:', res.error.get());
+ * });
+ *
+ * key.set('https://api.example.com/data2');
+ * ```
+ * @param {SignalHandle} src
+ * @param {Function} fetcher
+ * @returns {any}
+ */
+export function createResource(src, fetcher) {
+    _assertClass(src, SignalHandle);
+    const ret = wasm.createResource(src.__wbg_ptr, addHeapObject(fetcher));
+    return takeObject(ret);
+}
+
+/**
+ * 创建 WasmRue 实例（可选设置 DOM 适配器）
+ *
+ * - 若传入 adapter（JS 对象），则设置为 DomAdapter，并在全局挂载 __rue_dom
+ * - 初始化内部 Rue，构造渲染队列与上次容器记录
+ * @param {any} adapter
+ * @returns {WasmRue}
+ */
+export function createRue(adapter) {
+    const ret = wasm.createRue(addHeapObject(adapter));
+    return WasmRue.__wrap(ret);
+}
+
+/**
+ * 创建带选项的信号
+ * options.equals: Function(prev, next) -> bool，返回 true 表示值相等（不触发）
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, createEffect } = wasmModule;
+ * const count = createSignal(0);
+ * createEffect(() => {
+ *   console.log('count =', count.get());
+ * });
+ * count.set(1); // 触发 effect
+ *
+ * const eq = (prev, next) => prev === next;
+ * const s = createSignal(0, { equals: eq });
+ * s.set(0); // 不触发，因为 equals 返回 true（相等）
+ * s.set(2); // 触发订阅者
+ * ```
+ * @param {any} initial
+ * @param {any | null} [options]
+ * @returns {SignalHandle}
+ */
+export function createSignal(initial, options) {
+    const ret = wasm.createSignal(addHeapObject(initial), isLikeNone(options) ? 0 : addHeapObject(options));
+    return SignalHandle.__wrap(ret);
+}
+
+/**
+ * 获取当前实例；若未设置则返回空值（null/undefined），不再构造默认根实例
+ * 用法（JavaScript）：
+ * ```javascript
+ * const { setCurrentInstance, getCurrentInstance, withHookSlot } = wasmModule;
+ *
+ * // 设置并获取当前实例
+ * setCurrentInstance({ name: 'A' });
+ * const inst = getCurrentInstance(); // { name: 'A', ... }
+ *
+ * // 清空当前实例后，获取为空（undefined 或 null）
+ * setCurrentInstance(undefined);
+ * const none = getCurrentInstance(); // undefined（或 null）
+ *
+ * // 在有当前实例时，withHookSlot 为该实例分配/复用一个 Hook 插槽
+ * setCurrentInstance({});
+ * const state = withHookSlot(() => ({ count: 0 })); // 首次创建并缓存到 __hooks.states
+ * ```
+ * @returns {any}
+ */
+export function getCurrentInstance() {
+    const ret = wasm.getCurrentInstance();
+    return takeObject(ret);
+}
+
+/**
+ * @param {any} obj
+ * @returns {boolean}
+ */
+export function isReactive(obj) {
+    const ret = wasm.isReactive(addHeapObject(obj));
+    return ret !== 0;
+}
+
+/**
+ * 在当前运行的副作用上注册清理函数
+ * 清理函数会在下一次该副作用执行之前被调用
+ * 用法与示例（JavaScript）：
+ * ```js
+ * // 需求：每次依赖变化时重建一个定时器，并在下一次运行前清理上一次的定时器
+ * const s = createSignal(0)
+ * const eh = createEffect(() => {
+ *   const v = s.get() // 建立订阅
+ *   const id = setInterval(() => console.log('[onCleanup-demo] tick v=', v), 500)
+ *   onCleanup(() => clearInterval(id)) // 下次运行前清理上一次的定时器
+ * })
+ * s.set(1) // 触发重跑：先清理旧定时器，再创建新定时器（只保留一个）
+ * s.set(2) // 同理
+ * eh.dispose() // 停止后续运行，并执行最后一次已注册的清理（定时器不再 tick）
+ * ```
+ * @param {Function} cb
+ */
+export function onCleanup(cb) {
+    wasm.onCleanup(addHeapObject(cb));
+}
+
+/**
+ * @param {any} initial
+ * @param {boolean | null} [force_global]
+ * @returns {any}
+ */
+export function propsReactive(initial, force_global) {
+    const ret = wasm.propsReactive(addHeapObject(initial), isLikeNone(force_global) ? 0xFFFFFF : force_global ? 1 : 0);
+    return takeObject(ret);
+}
+
+/**
+ * @param {any} initial
+ * @param {any | null} [options]
+ * @param {boolean | null} [force_global]
+ * @returns {any}
+ */
+export function reactive(initial, options, force_global) {
+    const ret = wasm.reactive(addHeapObject(initial), isLikeNone(options) ? 0 : addHeapObject(options), isLikeNone(force_global) ? 0xFFFFFF : force_global ? 1 : 0);
+    return takeObject(ret);
+}
+
+/**
+ * @param {any} initial
+ * @param {boolean | null} [force_global]
+ * @returns {any}
+ */
+export function readonly(initial, force_global) {
+    const ret = wasm.readonly(addHeapObject(initial), isLikeNone(force_global) ? 0xFFFFFF : force_global ? 1 : 0);
+    return takeObject(ret);
+}
+
+/**
+ * @param {any} initial
+ * @param {any | null} [options]
+ * @param {boolean | null} [force_global]
+ * @returns {any}
+ */
+export function ref(initial, options, force_global) {
+    const ret = wasm.ref(addHeapObject(initial), isLikeNone(options) ? 0 : addHeapObject(options), isLikeNone(force_global) ? 0xFFFFFF : force_global ? 1 : 0);
+    return takeObject(ret);
+}
+
+/**
+ * 设置当前实例
+ * 传入 `null/undefined` 表示清空；否则记录为 Some(instance)
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { setCurrentInstance, getCurrentInstance, withHookSlot, createSignal } = wasmModule;
+ * const inst = { name: 'MyComponent' };
+ * setCurrentInstance(inst);
+ *
+ * // 在实例上分配一个 Hook 插槽，用于存储状态对象
+ * const state = withHookSlot(() => ({ count: createSignal(0) }));
+ * console.log(getCurrentInstance()); // 当前实例或根实例
+ * ```
+ * @param {any} i
+ */
+export function setCurrentInstance(i) {
+    wasm.setCurrentInstance(addHeapObject(i));
+}
+
+/**
+ * 设置调度模式
+ * - mode="sync"：信号变更时尽可能同步触发副作用
+ * - 其他值：采用默认微任务合并调度
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { setReactiveScheduling } = wasmModule;
+ * setReactiveScheduling('sync'); // 适合少量、快速的更新
+ * // setReactiveScheduling('microtask'); // 使用默认微任务合并（传非 "sync" 即可）
+ * ```
+ * @param {string} mode
+ */
+export function setReactiveScheduling(mode) {
+    const ptr0 = passStringToWasm0(mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.setReactiveScheduling(ptr0, len0);
+}
+
+/**
+ * @param {any} initial
+ * @param {any | null} [options]
+ * @param {boolean | null} [force_global]
+ * @returns {any}
+ */
+export function shallowReactive(initial, options, force_global) {
+    const ret = wasm.shallowReactive(addHeapObject(initial), isLikeNone(options) ? 0 : addHeapObject(options), isLikeNone(force_global) ? 0xFFFFFF : force_global ? 1 : 0);
+    return takeObject(ret);
+}
+
+/**
+ * @param {any} initial
+ * @param {boolean | null} [force_global]
+ * @returns {any}
+ */
+export function shallowReadonly(initial, force_global) {
+    const ret = wasm.shallowReadonly(addHeapObject(initial), isLikeNone(force_global) ? 0xFFFFFF : force_global ? 1 : 0);
+    return takeObject(ret);
+}
+
+/**
+ * @param {any} initial
+ * @param {any | null} [options]
+ * @param {boolean | null} [force_global]
+ * @returns {SignalHandle}
+ */
+export function signal(initial, options, force_global) {
+    const ret = wasm.signal(addHeapObject(initial), isLikeNone(options) ? 0 : addHeapObject(options), isLikeNone(force_global) ? 0xFFFFFF : force_global ? 1 : 0);
+    return SignalHandle.__wrap(ret);
+}
+
+/**
+ * @param {any} obj
+ * @returns {any}
+ */
+export function toRaw(obj) {
+    const ret = wasm.toRaw(addHeapObject(obj));
+    return takeObject(ret);
+}
+
+/**
+ * 通用取值转换
+ * 支持以下输入：
+ * - 函数：调用并返回其结果
+ * - 对象：优先读取 `value` 字段，其次尝试调用 `get()` 方法
+ * - 其他：直接返回原值
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { toValue } = wasmModule;
+ * toValue(() => 1); // 1
+ * toValue({ value: 2 }); // 2
+ * toValue({ get() { return 3; } }); // 3
+ * toValue('hello'); // 'hello'
+ * ```
+ * @param {any} x
+ * @returns {any}
+ */
+export function toValue(x) {
+    const ret = wasm.toValue(addHeapObject(x));
+    return takeObject(ret);
+}
+
+/**
+ * @param {any} obj
+ * @returns {any}
+ */
+export function unref(obj) {
+    const ret = wasm.unref(addHeapObject(obj));
+    return takeObject(ret);
+}
+
+/**
+ * 断开依赖收集地执行回调（不记录对 Signal 的订阅）
+ *
+ * 用途与示例（JavaScript）：
+ * - 在同一个副作用中，订阅主依赖 `a`，但临时读取 `b` 并且不希望 `b` 的变化触发该副作用。
+ * - `untrack(fn)` 会在执行 `fn` 时临时关闭依赖收集，`fn` 内部对信号的读取不会把当前副作用订阅到这些信号上。
+ *
+ * ```js
+ * const a = createSignal(0)
+ * const b = createSignal(0)
+ * createEffect(() => {
+ *   const av = a.get()                // 订阅 a：a 变化会使该副作用重跑
+ *   const bv = untrack(() => b.get()) // 断开依赖读取 b：b 变化不会触发该副作用
+ *   console.log('[untrack-demo] run av=', av, 'bv=', bv)
+ * })
+ * b.set(1)  // 不触发副作用（因为对 b 的读取发生在 untrack 内）
+ * b.set(2)  // 不触发副作用
+ * a.set(10) // 触发副作用（因为对 a 进行了正常订阅）
+ * ```
+ *
+ * 说明：若仅需“不订阅地读取”某个信号，也可使用 `peek()`（例如 `const v = sig.peek()`）。
+ * @param {Function} cb
+ * @returns {any}
+ */
+export function untrack(cb) {
+    const ret = wasm.untrack(addHeapObject(cb));
+    return takeObject(ret);
+}
+
+/**
+ * @param {Function} func
+ * @param {any} deps
+ * @returns {Function}
+ */
+export function useCallback(func, deps) {
+    const ret = wasm.useCallback(addHeapObject(func), addHeapObject(deps));
+    return takeObject(ret);
+}
+
+/**
+ * @param {Function} effect
+ * @param {any | null} [deps]
+ * @param {any | null} [options]
+ */
+export function useEffect(effect, deps, options) {
+    wasm.useEffect(addHeapObject(effect), isLikeNone(deps) ? 0 : addHeapObject(deps), isLikeNone(options) ? 0 : addHeapObject(options));
+}
+
+/**
+ * @param {Function} factory
+ * @param {any} deps
+ * @returns {any}
+ */
+export function useMemo(factory, deps) {
+    const ret = wasm.useMemo(addHeapObject(factory), addHeapObject(deps));
+    return takeObject(ret);
+}
+
+/**
+ * @param {any} initial
+ * @returns {any}
+ */
+export function useRef(initial) {
+    const ret = wasm.useRef(addHeapObject(initial));
+    return takeObject(ret);
+}
+
+/**
+ * @param {Function} factory
+ * @returns {any}
+ */
+export function useSetup(factory) {
+    const ret = wasm.useSetup(addHeapObject(factory));
+    return takeObject(ret);
+}
+
+/**
+ * useSignal：等价于 `useState(initial, { kind: 'signal', ...options })`
+ *
+ * 用途：
+ * - 以“底层信号句柄”的形式管理状态，适合需要精细控制 `get/set/update/setPath/peek` 的场景
+ * - 支持 `equals(prev, next)` 自定义等值比较，返回 `true` 表示不触发订阅者
+ *
+ * 示例：
+ * const [sig, setSig] = useSignal({ a: 1 })
+ * console.log(sig.get())       // { a: 1 }
+ * setSig({ a: 2 })             // 触发订阅者
+ * setSig(h => ({ a: h.peek().a + 1 })) // { a: 3 }
+ * sig.setPath('a', 4)
+ * console.log(sig.get())       // { a: 4 }
+ * @param {any} initial
+ * @param {any | null} [options]
+ * @returns {any}
+ */
+export function useSignal(initial, options) {
+    const ret = wasm.useSignal(addHeapObject(initial), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+
+/**
+ * useState 钩子：统一的轻量状态容器（支持 reactive/ref/signal 三种形态）
+ *
+ * 设计概览：
+ * - 默认形态为 `reactive`：当初始值为对象/数组时直接返回其响应式代理；当为原始类型时自动包裹为 `{ value }` 并返回其代理。
+ * - 可选 `kind`：
+ *   - `'reactive'`：对象/数组的响应式代理；原始类型将自动包裹为 `{ value }`
+ *   - `'ref'`：总是返回 `{ value }` 的响应式代理，便于统一读写
+ *   - `'signal'`：返回底层 `SignalHandle`，适合需要精细控制 get/set/update/path 的场景
+ * - 等值比较：通过 `options.equals(prev, next)` 自定义比较逻辑，返回 `true` 表示值相等，不触发订阅者。
+ *
+ * 使用示例（JavaScript / TypeScript）：
+ * // reactive（默认）
+ * const [state, setState] = useState({ user: { name: 'A' }, items: ['x'] })
+ * state.user.name = 'B'        // 响应式写入
+ * setState({ user: { name: 'C' }, items: ['y'] })  // 整体替换
+ * setState(prev => ({ ...prev, user: { ...prev.user, name: 'D' } })) // 基于回调更新
+ *
+ * // ref（原始类型亦可统一为 { value }）
+ * const [count, setCount] = useState(0, { kind: 'ref' })
+ * console.log(count.value)     // 0
+ * setCount(1)                  // 触发订阅者
+ * setCount(ref => { ref.value += 1 }) // 2
+ *
+ * // signal（底层句柄）
+ * const [sig, setSig] = useState({ a: 1 }, { kind: 'signal' })
+ * console.log(sig.get())       // { a: 1 }
+ * sig.set({ a: 2 })            // 触发订阅者
+ * setSig(handle => ({ a: handle.peek().a + 1 })) // { a: 3 }
+ * sig.setPath('a', 4)          // 路径写入
+ * console.log(sig.get())       // { a: 4 }
+ *
+ * // 自定义等值比较（默认使用 shallowEqual）
+ * const [state2, setState2] = useState({ a: 1, b: 2 }, { kind: 'reactive', equals: (prev, next) => prev.a === next.a })
+ * setState2({ a: 1, b: 3 })   // 不触发订阅者，因为 a 未改变
+ * setState2({ a: 2, b: 4 })   // 触发订阅者，因为 a 改变
+ * @param {any} initial
+ * @param {any | null} [options]
+ * @returns {any}
+ */
+export function useState(initial, options) {
+    const ret = wasm.useState(addHeapObject(initial), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+
+/**
+ * 按 Hook 唯一 id 绑定插槽索引并运行回调
+ * - 行为：在当前实例的 `__hooks.__idMap` 中为 `id` 分配稳定索引，并通过设置 `__forcedIndex` 强制 `withHookSlot` 使用该索引
+ * - 若此前不存在该 id，则使用 `states.length` 作为新索引
+ * - 运行 `runner()`，并在结束后清除 `__forcedIndex`
+ * @param {any} id
+ * @param {Function} runner
+ * @returns {any}
+ */
+export function vaporWithHookId(id, runner) {
+    const ret = wasm.vaporWithHookId(addHeapObject(id), addHeapObject(runner));
+    return takeObject(ret);
+}
+
+/**
+ * 统一侦听入口：接受函数、信号句柄对象（含 `get` 方法）或来源数组
+ *
+ * 用法（JavaScript）：
+ * ```js
+ * // 1) 侦听函数源（等价 watchFn）
+ * const stop1 = watch(() => state.count, (n, o) => { console.log(n, o) }, { immediate: true })
+ *
+ * // 2) 侦听信号句柄对象（含 get 方法）
+ * const s = createSignal(0)
+ * const stop2 = watch(s, (n, o) => { console.log(n, o) })
+ * s.set(1)
+ *
+ * // 3) 侦听来源数组：函数 / 信号句柄 / 常量混合
+ * const s1 = createSignal(0)
+ * const s2 = createSignal(10)
+ * const stop3 = watch([() => s1.get(), s2, 'x'], ([n1, n2, c], [o1, o2, oc]) => { console.log(n1, n2, c, o1, o2, oc) })
+ * s1.set(1); s2.set(11)
+ *
+ * // 自定义比较：覆盖默认逐项浅比较
+ * watch([s1, s2], (n, o) => {}, { equals: (prev, next) => _.isEqual(prev, next) })
+ * ```
+ * @param {any} source
+ * @param {Function} handler
+ * @param {any | null} [options_raw]
+ * @returns {EffectHandle}
+ */
+export function watch(source, handler, options_raw) {
+    const ret = wasm.watch(addHeapObject(source), addHeapObject(handler), isLikeNone(options_raw) ? 0 : addHeapObject(options_raw));
+    return EffectHandle.__wrap(ret);
+}
+
+/**
+ * 深度侦听：当对象/数组任意子项变化时触发
+ *
+ * 用法（JavaScript）：
+ * ```js
+ * const s = createSignal({ user: { name: 'A' }, items: ['x'] })
+ * const stop = watchDeepSignal(s, (newv, oldv) => {
+ *   console.log('deep changed', oldv, '->', newv)
+ * }, { immediate: true })
+ * s.setPath(['user','name'], 'B')
+ * s.setPath(['items', 0], 'y')
+ * stop.dispose() // 取消侦听
+ * ```
+ * @param {SignalHandle} src
+ * @param {Function} handler
+ * @param {any | null} [options]
+ * @returns {EffectHandle}
+ */
+export function watchDeepSignal(src, handler, options) {
+    _assertClass(src, SignalHandle);
+    const ret = wasm.watchDeepSignal(src.__wbg_ptr, addHeapObject(handler), isLikeNone(options) ? 0 : addHeapObject(options));
+    return EffectHandle.__wrap(ret);
+}
+
+/**
+ * 侦听副作用：在副作用体内自行读取信号，依赖会自动收集
+ * 类似 Vue 的 `watchEffect`
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, watchEffect } = wasmModule;
+ * const s = createSignal(0);
+ * watchEffect(() => {
+ *   console.log('value:', s.get());
+ * }, {
+ *     //可选 scheduler
+ * });
+ * s.set(1);
+ * ```
+ * @param {Function} cb
+ * @param {any | null} [options]
+ * @returns {EffectHandle}
+ */
+export function watchEffect(cb, options) {
+    const ret = wasm.watchEffect(addHeapObject(cb), isLikeNone(options) ? 0 : addHeapObject(options));
+    return EffectHandle.__wrap(ret);
+}
+
+/**
+ * 侦听任意 getter 函数的结果变化
+ * options: { immediate?: bool, scheduler?: Function, equals?: Function }
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { watchFn } = wasmModule;
+ * const obj = { value: 0 };
+ * const stop = watchFn(
+ *   () => obj.value,
+ *   (newv, oldv) => console.log('changed:', oldv, '->', newv),
+ *   { immediate: true }
+ * );
+ * obj.value = 1; // 当 getter 读取到新值时触发 handler
+ * ```
+ * @param {Function} getter
+ * @param {Function} handler
+ * @param {any | null} [options]
+ * @returns {EffectHandle}
+ */
+export function watchFn(getter, handler, options) {
+    const ret = wasm.watchFn(addHeapObject(getter), addHeapObject(handler), isLikeNone(options) ? 0 : addHeapObject(options));
+    return EffectHandle.__wrap(ret);
+}
+
+/**
+ * 侦听指定路径的值变化：`path` 支持 JS 数组或以 `.` 分隔的字符串
+ *
+ * 用法（JavaScript）：
+ * ```js
+ * const s = createSignal({ user: { profile: { name: 'A' } } })
+ * // 数组路径
+ * watchPath(s, ['user','profile','name'], (n, o) => {
+ *   console.log('name changed:', o, '->', n)
+ * }, { immediate: true })
+ * // 字符串路径（数字段会自动转为数组索引）
+ * watchPath(s, 'user.profile.name', (n, o) => {
+ *   console.log('name changed:', o, '->', n)
+ * }, { immediate: true })
+ * s.setPath(['user','profile','name'], 'B')
+ * s.setPath('user.profile.name', 'B')
+ * ```
+ * @param {SignalHandle} src
+ * @param {any} path
+ * @param {Function} handler
+ * @param {any | null} [options]
+ * @returns {EffectHandle}
+ */
+export function watchPath(src, path, handler, options) {
+    _assertClass(src, SignalHandle);
+    const ret = wasm.watchPath(src.__wbg_ptr, addHeapObject(path), addHeapObject(handler), isLikeNone(options) ? 0 : addHeapObject(options));
+    return EffectHandle.__wrap(ret);
+}
+
+/**
+ * 侦听单个信号的变化并在变化时触发处理器
+ * options: { immediate?: bool, scheduler?: Function, equals?: Function }
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { createSignal, watchSignal } = wasmModule;
+ * const s = createSignal(0);
+ * watchSignal(s, (newv, oldv) => {
+ *   console.log('signal changed:', oldv, '->', newv);
+ * }, { immediate: true });
+ * s.set(1);
+ * ```
+ * @param {SignalHandle} src
+ * @param {Function} handler
+ * @param {any | null} [options]
+ * @returns {EffectHandle}
+ */
+export function watchSignal(src, handler, options) {
+    _assertClass(src, SignalHandle);
+    const ret = wasm.watchSignal(src.__wbg_ptr, addHeapObject(handler), isLikeNone(options) ? 0 : addHeapObject(options));
+    return EffectHandle.__wrap(ret);
+}
+
+/**
+ * 在当前实例上为 Hook 分配/复用一个插槽
+ * - 若无当前实例，则直接执行 factory 返回对象
+ * - 有实例时，依据 `__hooks.index` 或 `__forcedIndex` 计算插槽序号
+ * 示例（JavaScript）：
+ * ```javascript
+ * const { setCurrentInstance, withHookSlot } = wasmModule;
+ * setCurrentInstance({});
+ * const a = withHookSlot(() => ({ id: 1 }));
+ * const b = withHookSlot(() => ({ id: 2 }));
+ * // 若再次调用 withHookSlot（且未强制索引），将分配下一个插槽
+ * ```
+ * @param {Function} factory
+ * @returns {any}
+ */
+export function withHookSlot(factory) {
+    const ret = wasm.withHookSlot(addHeapObject(factory));
+    return takeObject(ret);
+}
+
+export function __wbg___wbindgen_boolean_get_dea25b33882b895b(arg0) {
+    const v = getObject(arg0);
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+};
+
+export function __wbg___wbindgen_debug_string_adfb662ae34724b6(arg0, arg1) {
+    const ret = debugString(getObject(arg1));
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+export function __wbg___wbindgen_is_function_8d400b8b1af978cd(arg0) {
+    const ret = typeof(getObject(arg0)) === 'function';
+    return ret;
+};
+
+export function __wbg___wbindgen_is_null_dfda7d66506c95b5(arg0) {
+    const ret = getObject(arg0) === null;
+    return ret;
+};
+
+export function __wbg___wbindgen_is_object_ce774f3490692386(arg0) {
+    const val = getObject(arg0);
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+export function __wbg___wbindgen_is_string_704ef9c8fc131030(arg0) {
+    const ret = typeof(getObject(arg0)) === 'string';
+    return ret;
+};
+
+export function __wbg___wbindgen_is_undefined_f6b95eab589e0269(arg0) {
+    const ret = getObject(arg0) === undefined;
+    return ret;
+};
+
+export function __wbg___wbindgen_jsval_eq_b6101cc9cef1fe36(arg0, arg1) {
+    const ret = getObject(arg0) === getObject(arg1);
+    return ret;
+};
+
+export function __wbg___wbindgen_number_get_9619185a74197f95(arg0, arg1) {
+    const obj = getObject(arg1);
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+};
+
+export function __wbg___wbindgen_rethrow_78714972834ecdf1(arg0) {
+    throw takeObject(arg0);
+};
+
+export function __wbg___wbindgen_string_get_a2a31e16edf96e42(arg0, arg1) {
+    const obj = getObject(arg1);
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+export function __wbg___wbindgen_throw_dd24417ed36fc46e(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbg__wbg_cb_unref_87dfb5aaa0cbcea7(arg0) {
+    getObject(arg0)._wbg_cb_unref();
+};
+
+export function __wbg_apply_52e9ae668d017009() { return handleError(function (arg0, arg1, arg2) {
+    const ret = getObject(arg0).apply(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_call_3020136f7a2d6e44() { return handleError(function (arg0, arg1, arg2) {
+    const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_call_78f94eb02ec7f9b2() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_call_abb4ff46ce38be40() { return handleError(function (arg0, arg1) {
+    const ret = getObject(arg0).call(getObject(arg1));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_call_c8baa5c5e72d274e() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_catch_b9db41d97d42bd02(arg0, arg1) {
+    const ret = getObject(arg0).catch(getObject(arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_defineProperty_c4fadd16974ffa92(arg0, arg1, arg2) {
+    const ret = Object.defineProperty(getObject(arg0), getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+};
+
+export function __wbg_deleteProperty_da180bf2624d16d6() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.deleteProperty(getObject(arg0), getObject(arg1));
+    return ret;
+}, arguments) };
+
+export function __wbg_from_29a8414a7a7cd19d(arg0) {
+    const ret = Array.from(getObject(arg0));
+    return addHeapObject(ret);
+};
+
+export function __wbg_getOwnPropertyDescriptor_b6aa5a2fa50d52c7(arg0, arg1) {
+    const ret = Object.getOwnPropertyDescriptor(getObject(arg0), getObject(arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_get_6b7bd52aca3f9671(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+};
+
+export function __wbg_get_af9dab7e9603ea93() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(getObject(arg0), getObject(arg1));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_get_cbf36dc54869cf03(arg0, arg1) {
+    const ret = getObject(arg0).get(getObject(arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_has_0e670569d65d3a45() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.has(getObject(arg0), getObject(arg1));
+    return ret;
+}, arguments) };
+
+export function __wbg_instanceof_Promise_eca6c43a2610558d(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof Promise;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+export function __wbg_isArray_51fd9e6422c0a395(arg0) {
+    const ret = Array.isArray(getObject(arg0));
+    return ret;
+};
+
+export function __wbg_is_928aa29d71e75457(arg0, arg1) {
+    const ret = Object.is(getObject(arg0), getObject(arg1));
+    return ret;
+};
+
+export function __wbg_keys_f5c6002ff150fc6c(arg0) {
+    const ret = Object.keys(getObject(arg0));
+    return addHeapObject(ret);
+};
+
+export function __wbg_length_d45040a40c570362(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+};
+
+export function __wbg_new_0_23cedd11d9b40c9d() {
+    const ret = new Date();
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_1ba21ce319a06297() {
+    const ret = new Object();
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_25f239778d6112b9() {
+    const ret = new Array();
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_b546ae120718850e() {
+    const ret = new Map();
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_df1173567d5ff028(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_no_args_cb138f77cf6151ee(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_with_args_df9e7125ffe55248(arg0, arg1, arg2, arg3) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+    return addHeapObject(ret);
+};
+
+export function __wbg_ownKeys_f06fcde184cdc8e0() { return handleError(function (arg0) {
+    const ret = Reflect.ownKeys(getObject(arg0));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_push_7d9be8f38fc13975(arg0, arg1) {
+    const ret = getObject(arg0).push(getObject(arg1));
+    return ret;
+};
+
+export function __wbg_resolve_fd5bfbaa4ce36e1e(arg0) {
+    const ret = Promise.resolve(getObject(arg0));
+    return addHeapObject(ret);
+};
+
+export function __wbg_set_781438a03c0c3c81() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+    return ret;
+}, arguments) };
+
+export function __wbg_set_7df433eea03a5c14(arg0, arg1, arg2) {
+    getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+};
+
+export function __wbg_set_efaaf145b9377369(arg0, arg1, arg2) {
+    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+};
+
+export function __wbg_set_length_a5425f40fdfb1bb5(arg0, arg1) {
+    getObject(arg0).length = arg1 >>> 0;
+};
+
+export function __wbg_signalhandle_new(arg0) {
+    const ret = SignalHandle.__wrap(arg0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_GLOBAL_769e6b65d6557335() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_SELF_08f5a74c69739274() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_WINDOW_a8924b26aa92d024() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_stringify_655a6390e1f5eb6b() { return handleError(function (arg0) {
+    const ret = JSON.stringify(getObject(arg0));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_then_4f95312d68691235(arg0, arg1) {
+    const ret = getObject(arg0).then(getObject(arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_toISOString_eca15cbe422eeea5(arg0) {
+    const ret = getObject(arg0).toISOString();
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_04cabf735c12b7a5(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [Externref, Externref, Externref, Externref], shim_idx: 9, ret: Externref, inner_ret: Some(Externref) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_63, __wasm_bindgen_func_elem_184);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_32bc49bfb4050e32(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [Externref], shim_idx: 2, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_63, __wasm_bindgen_func_elem_179);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_3ad2e43c28aac9a2(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [Externref, Externref], shim_idx: 3, ret: Boolean, inner_ret: Some(Boolean) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_63, __wasm_bindgen_func_elem_182);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_3e0f7cd5ff36de98(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 5, function: Function { arguments: [], shim_idx: 6, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_71, __wasm_bindgen_func_elem_178);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_5b3a20861c90b46d(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [Externref, Externref], shim_idx: 179, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_63, __wasm_bindgen_func_elem_1099);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_6cbf5a2ede8f72df(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [], shim_idx: 4, ret: Externref, inner_ret: Some(Externref) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_63, __wasm_bindgen_func_elem_177);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_8c2759bbf891ca0f(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [Externref], shim_idx: 8, ret: Externref, inner_ret: Some(Externref) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_63, __wasm_bindgen_func_elem_180);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_bd8c2fef27b60e6e(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [Externref, Externref, Externref], shim_idx: 10, ret: Externref, inner_ret: Some(Externref) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_63, __wasm_bindgen_func_elem_183);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_d4089fe2ead6559a(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [Externref, Externref], shim_idx: 7, ret: Externref, inner_ret: Some(Externref) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_63, __wasm_bindgen_func_elem_181);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_object_clone_ref(arg0) {
+    const ret = getObject(arg0);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+};
+
+export function __wbindgen_object_is_undefined(arg0) {
+    const ret = getObject(arg0) === undefined;
+    return ret;
+};