@cereusdb/standard 0.3.0 → 0.4.0

package/dist/storage.js

@@ -0,0 +1,211 @@
+function splitPath(path) {
+    return path.split('/').filter((segment) => segment.length > 0);
+}
+function isNotFound(error) {
+    const name = error?.name;
+    return name === 'NotFoundError' || name === 'TypeMismatchError';
+}
+/**
+ * Keeps files in memory. Useful for tests, Node.js, and environments without
+ * OPFS. Share one instance between CereusDB instances to simulate a reload.
+ */
+export class MemoryStorageBackend {
+    constructor() {
+        this.files = new Map();
+        this.locks = new Set();
+    }
+    async readFile(path) {
+        const data = this.files.get(splitPath(path).join('/'));
+        return data ? data.slice() : null;
+    }
+    async writeFile(path, data) {
+        this.files.set(splitPath(path).join('/'), data.slice());
+    }
+    async remove(path) {
+        const key = splitPath(path).join('/');
+        for (const existing of [...this.files.keys()]) {
+            if (key === '' || existing === key || existing.startsWith(`${key}/`)) {
+                this.files.delete(existing);
+            }
+        }
+    }
+    async list(path) {
+        const prefix = splitPath(path).join('/');
+        const entries = new Set();
+        for (const key of this.files.keys()) {
+            if (prefix !== '' && !key.startsWith(`${prefix}/`)) {
+                continue;
+            }
+            const rest = prefix === '' ? key : key.slice(prefix.length + 1);
+            const [head, ...tail] = rest.split('/');
+            entries.add(tail.length > 0 ? `${head}/` : head);
+        }
+        return [...entries].sort();
+    }
+    async lock(name) {
+        if (this.locks.has(name)) {
+            throw new Error('it is already open in another CereusDB instance');
+        }
+        this.locks.add(name);
+    }
+    async unlock(name) {
+        this.locks.delete(name);
+    }
+    /** All stored file paths (for inspection and tests). */
+    paths() {
+        return [...this.files.keys()].sort();
+    }
+}
+/**
+ * Stores databases in the Origin Private File System (OPFS). Used for
+ * `opfs://` locations by default when the browser supports OPFS.
+ *
+ * Opening a database takes a Web Lock, so a database can be open in only one
+ * tab or worker at a time.
+ */
+export class OPFSStorageBackend {
+    constructor(options = {}) {
+        this.releases = new Map();
+        this.directory = options.directory ?? 'cereusdb';
+    }
+    /** Whether OPFS is available in the current environment. */
+    static isSupported() {
+        return (typeof navigator !== 'undefined' &&
+            typeof navigator.storage?.getDirectory === 'function');
+    }
+    root() {
+        this.rootPromise ?? (this.rootPromise = navigator.storage
+            .getDirectory()
+            .then((root) => root.getDirectoryHandle(this.directory, { create: true })));
+        return this.rootPromise;
+    }
+    async directoryHandle(segments, create) {
+        let directory = await this.root();
+        for (const segment of segments) {
+            try {
+                directory = await directory.getDirectoryHandle(segment, { create });
+            }
+            catch (error) {
+                if (isNotFound(error)) {
+                    return null;
+                }
+                throw error;
+            }
+        }
+        return directory;
+    }
+    async readFile(path) {
+        const segments = splitPath(path);
+        const name = segments.pop();
+        if (name === undefined) {
+            return null;
+        }
+        const directory = await this.directoryHandle(segments, false);
+        if (directory === null) {
+            return null;
+        }
+        try {
+            const file = await (await directory.getFileHandle(name)).getFile();
+            return new Uint8Array(await file.arrayBuffer());
+        }
+        catch (error) {
+            if (isNotFound(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async writeFile(path, data) {
+        const segments = splitPath(path);
+        const name = segments.pop();
+        if (name === undefined) {
+            throw new Error('writeFile requires a file path');
+        }
+        const directory = await this.directoryHandle(segments, true);
+        if (directory === null) {
+            throw new Error(`cannot create directory for ${path}`);
+        }
+        const handle = await directory.getFileHandle(name, { create: true });
+        if (typeof handle.createWritable === 'function') {
+            // Writes go to a swap file that replaces the original on close().
+            const writable = await handle.createWritable();
+            try {
+                await writable.write(data);
+                await writable.close();
+            }
+            catch (error) {
+                await writable.abort().catch(() => undefined);
+                throw error;
+            }
+            return;
+        }
+        // Older Safari only supports synchronous access handles (in workers).
+        const createSyncAccessHandle = handle.createSyncAccessHandle;
+        if (typeof createSyncAccessHandle !== 'function') {
+            throw new Error('this browser cannot write OPFS files outside a worker');
+        }
+        const access = await createSyncAccessHandle.call(handle);
+        try {
+            access.truncate(0);
+            access.write(data, { at: 0 });
+            access.flush();
+        }
+        finally {
+            access.close();
+        }
+    }
+    async remove(path) {
+        const segments = splitPath(path);
+        const name = segments.pop();
+        if (name === undefined) {
+            throw new Error('remove requires a path');
+        }
+        const directory = await this.directoryHandle(segments, false);
+        if (directory === null) {
+            return;
+        }
+        try {
+            await directory.removeEntry(name, { recursive: true });
+        }
+        catch (error) {
+            if (!isNotFound(error)) {
+                throw error;
+            }
+        }
+    }
+    async list(path) {
+        const directory = await this.directoryHandle(splitPath(path), false);
+        if (directory === null) {
+            return [];
+        }
+        const entries = [];
+        const iterable = directory;
+        for await (const [name, handle] of iterable.entries()) {
+            entries.push(handle.kind === 'directory' ? `${name}/` : name);
+        }
+        return entries.sort();
+    }
+    async lock(name) {
+        if (typeof navigator === 'undefined' || navigator.locks === undefined) {
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            navigator.locks
+                .request(name, { ifAvailable: true }, (lock) => {
+                if (lock === null) {
+                    reject(new Error('it is open in another tab or worker'));
+                    return undefined;
+                }
+                resolve();
+                // Hold the lock until unlock() resolves this promise.
+                return new Promise((release) => this.releases.set(name, release));
+            })
+                .catch(reject);
+        });
+    }
+    async unlock(name) {
+        const release = this.releases.get(name);
+        this.releases.delete(name);
+        release?.();
+    }
+}

package/dist/wasm/cereusdb-external.d.ts

@@ -9,15 +9,65 @@ export class CereusDB {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Create (`create = true`) or attach a persistent database. Returns the
+     * database (catalog) name.
+     */
+    attach_database(location: string, name: string | null | undefined, create: boolean, if_not_exists: boolean): Promise<string>;
+    /**
+     * Describe all databases, schemas, tables and views as a JSON string.
+     */
+    catalog_json(): Promise<string>;
+    /**
+     * Rewrite every table of a persistent database into a single segment.
+     */
+    compact_database(name: string): Promise<void>;
     /**
      * Create a new CereusDB instance.
      * Initializes DataFusion context and registers all spatial functions.
      */
     static create(): CereusDB;
     /**
-     * Drop a registered table.
+     * Detach a persistent database after writing pending changes.
+     */
+    detach_database(name: string, if_exists: boolean): Promise<void>;
+    /**
+     * Drop a database by name or location URL. Persistent databases are
+     * deleted from storage.
+     */
+    drop_database(target: string, if_exists: boolean): Promise<void>;
+    /**
+     * Drop a registered table. Call `flush()` to write the change when the
+     * table belongs to a persistent database.
      */
     drop_table(table_name: string): void;
+    /**
+     * Run a query and encode the result as GeoParquet. `options` may set
+     * `compression` and `rowGroupSize`.
+     */
+    export_geoparquet(query: string, options: any): Promise<Uint8Array>;
+    /**
+     * Write all pending changes of attached persistent databases.
+     */
+    flush(): Promise<void>;
+    /**
+     * Insert Arrow IPC data (stream or file format) into a table, matching
+     * columns by name. Returns the number of inserted rows.
+     */
+    insert_arrow(table_name: string, data: Uint8Array): Promise<number>;
+    /**
+     * Database locations stored in the backend for `scheme`, attached or not.
+     */
+    list_database_locations(scheme: string): Promise<any>;
+    /**
+     * List all tables and views as `catalog.schema.table`.
+     */
+    qualified_tables(): any;
+    /**
+     * Set the function `(filename, bytes, mimeType)` that receives files
+     * written by `COPY ... TO`. `null` removes it.
+     */
+    register_export_handler(handler: any): void;
     /**
      * Register a GeoJSON string as a named table.
      */
@@ -51,6 +101,11 @@ export class CereusDB {
      * The server must support CORS.
      */
     register_remote_parquet(table_name: string, url: string): Promise<void>;
+    /**
+     * Register the storage backend used for database locations with the given
+     * URL scheme (for example `opfs`).
+     */
+    register_storage_backend(scheme: string, backend: any): void;
     /**
      * Execute a SQL query.
      * Returns results as Arrow IPC bytes (Uint8Array).
@@ -88,8 +143,19 @@ export interface InitOutput {
     readonly malloc: (a: number) => number;
     readonly __wbg_cereusdb_free: (a: number, b: number) => void;
     readonly _abort_js: () => void;
+    readonly cereusdb_attach_database: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+    readonly cereusdb_catalog_json: (a: number) => any;
+    readonly cereusdb_compact_database: (a: number, b: number, c: number) => any;
     readonly cereusdb_create: () => [number, number, number];
+    readonly cereusdb_detach_database: (a: number, b: number, c: number, d: number) => any;
+    readonly cereusdb_drop_database: (a: number, b: number, c: number, d: number) => any;
     readonly cereusdb_drop_table: (a: number, b: number, c: number) => [number, number];
+    readonly cereusdb_export_geoparquet: (a: number, b: number, c: number, d: any) => any;
+    readonly cereusdb_flush: (a: number) => any;
+    readonly cereusdb_insert_arrow: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly cereusdb_list_database_locations: (a: number, b: number, c: number) => any;
+    readonly cereusdb_qualified_tables: (a: number) => [number, number, number];
+    readonly cereusdb_register_export_handler: (a: number, b: any) => [number, number];
     readonly cereusdb_register_geojson: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly cereusdb_register_geotiff_buffer: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly cereusdb_register_object_stores: (a: number, b: any) => [number, number];
@@ -97,6 +163,7 @@ export interface InitOutput {
     readonly cereusdb_register_parquet_table: (a: number, b: number, c: number, d: number, e: number, f: any) => any;
     readonly cereusdb_register_raster_buffer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly cereusdb_register_remote_parquet: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly cereusdb_register_storage_backend: (a: number, b: number, c: number, d: any) => [number, number];
     readonly cereusdb_sql: (a: number, b: number, c: number) => any;
     readonly cereusdb_sql_json: (a: number, b: number, c: number) => any;
     readonly cereusdb_tables: (a: number) => [number, number, number];

package/dist/wasm/cereusdb-external.js

@@ -2,7 +2,7 @@ import { createEnvImports, createWasiImports, setMemory } from "./env_shim.js?v=
 const __env = createEnvImports();
 const __wasi = createWasiImports();
 /* @ts-self-types="./cereusdb.d.ts" */
-import { cereusdbFetch, cereusdbSetFetchConcurrency } from './snippets/cereusdb-object-store-0da8c74e50551289/inline0.js';
+import { cereusdbFetch, cereusdbSetFetchConcurrency } from './snippets/cereusdb-object-store-6ee0e8370430462c/inline0.js';
 
 /**
  * Main CereusDB instance for browser use.
@@ -32,6 +32,60 @@ export class CereusDB {
         }
 
     }
+    /**
+     * Create (`create = true`) or attach a persistent database. Returns the
+     * database (catalog) name.
+     * @param {string} location
+     * @param {string | null | undefined} name
+     * @param {boolean} create
+     * @param {boolean} if_not_exists
+     * @returns {Promise<string>}
+     */
+    attach_database(location, name, create, if_not_exists) {
+        const ptr0 = passStringToWasm0(location, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(name) ? 0 : passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_attach_database(this.__wbg_ptr, ptr0, len0, ptr1, len1, create, if_not_exists);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        return ret;
+    }
+    /**
+     * Describe all databases, schemas, tables and views as a JSON string.
+     * @returns {Promise<string>}
+     */
+    catalog_json() {
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_catalog_json(this.__wbg_ptr);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        return ret;
+    }
+    /**
+     * Rewrite every table of a persistent database into a single segment.
+     * @param {string} name
+     * @returns {Promise<void>}
+     */
+    compact_database(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_compact_database(this.__wbg_ptr, ptr0, len0);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        return ret;
+    }
     /**
      * Create a new CereusDB instance.
      * Initializes DataFusion context and registers all spatial functions.
@@ -51,7 +105,45 @@ export class CereusDB {
         return CereusDB.__wrap(ret[0]);
     }
     /**
-     * Drop a registered table.
+     * Detach a persistent database after writing pending changes.
+     * @param {string} name
+     * @param {boolean} if_exists
+     * @returns {Promise<void>}
+     */
+    detach_database(name, if_exists) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_detach_database(this.__wbg_ptr, ptr0, len0, if_exists);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        return ret;
+    }
+    /**
+     * Drop a database by name or location URL. Persistent databases are
+     * deleted from storage.
+     * @param {string} target
+     * @param {boolean} if_exists
+     * @returns {Promise<void>}
+     */
+    drop_database(target, if_exists) {
+        const ptr0 = passStringToWasm0(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_drop_database(this.__wbg_ptr, ptr0, len0, if_exists);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        return ret;
+    }
+    /**
+     * Drop a registered table. Call `flush()` to write the change when the
+     * table belongs to a persistent database.
      * @param {string} table_name
      */
     drop_table(table_name) {
@@ -68,6 +160,111 @@ export class CereusDB {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Run a query and encode the result as GeoParquet. `options` may set
+     * `compression` and `rowGroupSize`.
+     * @param {string} query
+     * @param {any} options
+     * @returns {Promise<Uint8Array>}
+     */
+    export_geoparquet(query, options) {
+        const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_export_geoparquet(this.__wbg_ptr, ptr0, len0, options);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        return ret;
+    }
+    /**
+     * Write all pending changes of attached persistent databases.
+     * @returns {Promise<void>}
+     */
+    flush() {
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_flush(this.__wbg_ptr);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        return ret;
+    }
+    /**
+     * Insert Arrow IPC data (stream or file format) into a table, matching
+     * columns by name. Returns the number of inserted rows.
+     * @param {string} table_name
+     * @param {Uint8Array} data
+     * @returns {Promise<number>}
+     */
+    insert_arrow(table_name, data) {
+        const ptr0 = passStringToWasm0(table_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_insert_arrow(this.__wbg_ptr, ptr0, len0, ptr1, len1);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        return ret;
+    }
+    /**
+     * Database locations stored in the backend for `scheme`, attached or not.
+     * @param {string} scheme
+     * @returns {Promise<any>}
+     */
+    list_database_locations(scheme) {
+        const ptr0 = passStringToWasm0(scheme, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_list_database_locations(this.__wbg_ptr, ptr0, len0);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        return ret;
+    }
+    /**
+     * List all tables and views as `catalog.schema.table`.
+     * @returns {any}
+     */
+    qualified_tables() {
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_qualified_tables(this.__wbg_ptr);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Set the function `(filename, bytes, mimeType)` that receives files
+     * written by `COPY ... TO`. `null` removes it.
+     * @param {any} handler
+     */
+    register_export_handler(handler) {
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_register_export_handler(this.__wbg_ptr, handler);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Register a GeoJSON string as a named table.
      * @param {string} table_name
@@ -216,6 +413,26 @@ export class CereusDB {
         }
         return ret;
     }
+    /**
+     * Register the storage backend used for database locations with the given
+     * URL scheme (for example `opfs`).
+     * @param {string} scheme
+     * @param {any} backend
+     */
+    register_storage_backend(scheme, backend) {
+        const ptr0 = passStringToWasm0(scheme, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ret;
+        __wbg_termination_guard();
+        try {
+            ret = wasm.cereusdb_register_storage_backend(this.__wbg_ptr, ptr0, len0, backend);;
+        } catch(e) {
+            __wbg_handle_catch(e);
+        }
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Execute a SQL query.
      * Returns results as Arrow IPC bytes (Uint8Array).
@@ -439,6 +656,10 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_6b5b6b8576d35cb1: function(arg0) {
             arg0._wbg_cb_unref();
         },
+        __wbg_apply_ac9afb97ca32f169: function(arg0, arg1, arg2) {
+            const ret = arg0.apply(arg1, arg2);
+            return ret;
+        },
         __wbg_arrayBuffer_eb8e9ca620af2a19: function(arg0) {
             const ret = arg0.arrayBuffer();
             return ret;
@@ -451,11 +672,15 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1);
             return ret;
         },
-        __wbg_cereusdbFetch_ef03c6e2e53e5d27: function(arg0) {
+        __wbg_call_f858478a02f9600f: function(arg0, arg1, arg2, arg3, arg4) {
+            const ret = arg0.call(arg1, arg2, arg3, arg4);
+            return ret;
+        },
+        __wbg_cereusdbFetch_34b005651b79ffa9: function(arg0) {
             const ret = cereusdbFetch(arg0);
             return ret;
         },
-        __wbg_cereusdbSetFetchConcurrency_5dba4b72020a565e: function(arg0) {
+        __wbg_cereusdbSetFetchConcurrency_77cbd1646887d235: function(arg0) {
             cereusdbSetFetchConcurrency(arg0 >>> 0);
         },
         __wbg_done_08ce71ee07e3bd17: function(arg0) {
@@ -490,6 +715,10 @@ function __wbg_get_imports() {
             const ret = arg0.fetch(arg1);
             return ret;
         },
+        __wbg_from_4bdf88943703fd48: function(arg0) {
+            const ret = Array.from(arg0);
+            return ret;
+        },
         __wbg_getRandomValues_3f44b700395062e5: function(arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         },
@@ -504,6 +733,10 @@ function __wbg_get_imports() {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         },
+        __wbg_get_3ef1eba1850ade27: function(arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        },
         __wbg_get_a8ee5c45dabc1b3b: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
@@ -609,6 +842,10 @@ function __wbg_get_imports() {
             const ret = new Object();
             return ret;
         },
+        __wbg_new_from_slice_22da9388ac046e50: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return ret;
+        },
         __wbg_new_typed_aaaeaf29cf802876: function(arg0, arg1) {
             try {
                 var state0 = {a: arg0, b: arg1};
@@ -627,6 +864,10 @@ function __wbg_get_imports() {
                 state0.a = state0.b = 0;
             }
         },
+        __wbg_new_typed_bccac67128ed885a: function() {
+            const ret = new Array();
+            return ret;
+        },
         __wbg_new_with_length_825018a1616e9e55: function(arg0) {
             const ret = new Uint8Array(arg0 >>> 0);
             return ret;
@@ -658,6 +899,10 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_d62e5099504357e6: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
+        __wbg_push_e87b0e732085a946: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
         __wbg_queueMicrotask_0c399741342fb10f: function(arg0) {
             const ret = arg0.queueMicrotask;
             return ret;
@@ -727,8 +972,11 @@ function __wbg_get_imports() {
             const ret = arg0.value;
             return ret;
         },
+        __wbg_warn_69424c2d92a2fa73: function(arg0) {
+            console.warn(arg0);
+        },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 7619, function: Function { arguments: [Externref], shim_idx: 24967, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 7940, function: Function { arguments: [Externref], shim_idx: 25507, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h8db467765ce434ac, wasm_bindgen__convert__closures_____invoke__h7573a8a64f443504);
             return ret;
         },