@ifc-lite/wasm 1.2.1 → 1.5.0

package/pkg/ifc-lite.js

@@ -13,71 +13,6 @@ 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;
@@ -150,7 +85,7 @@ function handleError(f, args) {
     try {
         return f.apply(this, args);
     } catch (e) {
-        wasm.__wbindgen_export3(addHeapObject(e));
+        wasm.__wbindgen_export(addHeapObject(e));
     }
 }
 
@@ -263,16 +198,16 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_393(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_393(arg0, arg1);
+function __wasm_bindgen_func_elem_474(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_474(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_725(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_725(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_921(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_921(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_756(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_756(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_952(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_952(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const GeoReferenceJsFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -331,6 +266,18 @@ const RtcOffsetJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rtcoffsetjs_free(ptr >>> 0, 1));
 
+const SymbolicCircleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_symboliccircle_free(ptr >>> 0, 1));
+
+const SymbolicPolylineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_symbolicpolyline_free(ptr >>> 0, 1));
+
+const SymbolicRepresentationCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_symbolicrepresentationcollection_free(ptr >>> 0, 1));
+
 const ZeroCopyMeshFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_zerocopymesh_free(ptr >>> 0, 1));
@@ -460,7 +407,7 @@ export class GeoReferenceJs {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayF64FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            wasm.__wbindgen_export2(r0, r1 * 8, 8);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -480,7 +427,7 @@ export class GeoReferenceJs {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayF64FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            wasm.__wbindgen_export2(r0, r1 * 8, 8);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -499,7 +446,7 @@ export class GeoReferenceJs {
             let v1;
             if (r0 !== 0) {
                 v1 = getStringFromWasm0(r0, r1).slice();
-                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+                wasm.__wbindgen_export2(r0, r1 * 1, 1);
             }
             return v1;
         } finally {
@@ -525,7 +472,7 @@ export class GeoReferenceJs {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayF64FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            wasm.__wbindgen_export2(r0, r1 * 8, 8);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -586,6 +533,47 @@ export class GpuGeometry {
         const ret = wasm.gpugeometry_indicesPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Get X component of RTC offset
+     * @returns {number}
+     */
+    get rtcOffsetX() {
+        const ret = wasm.gpugeometry_rtcOffsetX(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get Y component of RTC offset
+     * @returns {number}
+     */
+    get rtcOffsetY() {
+        const ret = wasm.gpugeometry_rtcOffsetY(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get Z component of RTC offset
+     * @returns {number}
+     */
+    get rtcOffsetZ() {
+        const ret = wasm.gpugeometry_rtcOffsetZ(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Check if RTC offset is active (non-zero)
+     * @returns {boolean}
+     */
+    get hasRtcOffset() {
+        const ret = wasm.gpugeometry_hasRtcOffset(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Set the RTC (Relative To Center) offset applied to coordinates
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    set_rtc_offset(x, y, z) {
+        wasm.gpugeometry_set_rtc_offset(this.__wbg_ptr, x, y, z);
+    }
     /**
      * Get length of vertex data array (in f32 elements, not bytes)
      * @returns {number}
@@ -619,7 +607,7 @@ export class GpuGeometry {
             let v1;
             if (r0 !== 0) {
                 v1 = getStringFromWasm0(r0, r1).slice();
-                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+                wasm.__wbindgen_export2(r0, r1 * 1, 1);
             }
             return v1;
         } finally {
@@ -766,7 +754,7 @@ export class GpuInstancedGeometry {
      * @returns {number}
      */
     get vertexDataPtr() {
-        const ret = wasm.gpugeometry_indicesPtr(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_vertexDataPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1061,7 +1049,7 @@ export class GpuMeshMetadata {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayF32FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            wasm.__wbindgen_export2(r0, r1 * 4, 4);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -1111,7 +1099,7 @@ export class IfcAPI {
      * @returns {MeshCollection}
      */
     parseMeshes(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_parseMeshes(this.__wbg_ptr, ptr0, len0);
         return MeshCollection.__wrap(ret);
@@ -1132,7 +1120,7 @@ export class IfcAPI {
      * @returns {Promise<any>}
      */
     parseStreaming(content, callback) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_parseStreaming(this.__wbg_ptr, ptr0, len0, addHeapObject(callback));
         return takeObject(ret);
@@ -1161,7 +1149,7 @@ export class IfcAPI {
      * @returns {ZeroCopyMesh}
      */
     parseZeroCopy(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_parseZeroCopy(this.__wbg_ptr, ptr0, len0);
         return ZeroCopyMesh.__wrap(ret);
@@ -1183,7 +1171,7 @@ export class IfcAPI {
      * @returns {GeoReferenceJs | undefined}
      */
     getGeoReference(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_getGeoReference(this.__wbg_ptr, ptr0, len0);
         return ret === 0 ? undefined : GeoReferenceJs.__wrap(ret);
@@ -1192,13 +1180,25 @@ export class IfcAPI {
      * Parse IFC file with streaming mesh batches for progressive rendering
      * Calls the callback with batches of meshes, yielding to browser between batches
      *
+     * Options:
+     * - `batchSize`: Number of meshes per batch (default: 25)
+     * - `onBatch(meshes, progress)`: Called for each batch of meshes
+     * - `onRtcOffset({x, y, z, hasRtc})`: Called early with RTC offset for camera/world setup
+     * - `onColorUpdate(Map<id, color>)`: Called with style updates after initial render
+     * - `onComplete(stats)`: Called when parsing completes with stats including rtcOffset
+     *
      * Example:
      * ```javascript
      * const api = new IfcAPI();
      * await api.parseMeshesAsync(ifcData, {
      *   batchSize: 100,
+     *   onRtcOffset: (rtc) => {
+     *     if (rtc.hasRtc) {
+     *       // Model uses large coordinates - adjust camera/world origin
+     *       viewer.setWorldOffset(rtc.x, rtc.y, rtc.z);
+     *     }
+     *   },
      *   onBatch: (meshes, progress) => {
-     *     // Add meshes to scene
      *     for (const mesh of meshes) {
      *       scene.add(createThreeMesh(mesh));
      *     }
@@ -1206,6 +1206,7 @@ export class IfcAPI {
      *   },
      *   onComplete: (stats) => {
      *     console.log(`Done! ${stats.totalMeshes} meshes`);
+     *     // stats.rtcOffset also available here: {x, y, z, hasRtc}
      *   }
      * });
      * ```
@@ -1214,7 +1215,7 @@ export class IfcAPI {
      * @returns {Promise<any>}
      */
     parseMeshesAsync(content, options) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_parseMeshesAsync(this.__wbg_ptr, ptr0, len0, addHeapObject(options));
         return takeObject(ret);
@@ -1227,7 +1228,7 @@ export class IfcAPI {
      * @returns {any}
      */
     scanEntitiesFast(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_scanEntitiesFast(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
@@ -1252,7 +1253,7 @@ export class IfcAPI {
      * @returns {MeshCollectionWithRtc}
      */
     parseMeshesWithRtc(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_parseMeshesWithRtc(this.__wbg_ptr, ptr0, len0);
         return MeshCollectionWithRtc.__wrap(ret);
@@ -1296,7 +1297,7 @@ export class IfcAPI {
      * @returns {GpuGeometry}
      */
     parseToGpuGeometry(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_parseToGpuGeometry(this.__wbg_ptr, ptr0, len0);
         return GpuGeometry.__wrap(ret);
@@ -1324,7 +1325,7 @@ export class IfcAPI {
      * @returns {InstancedMeshCollection}
      */
     parseMeshesInstanced(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_parseMeshesInstanced(this.__wbg_ptr, ptr0, len0);
         return InstancedMeshCollection.__wrap(ret);
@@ -1339,7 +1340,7 @@ export class IfcAPI {
         let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
             const len0 = WASM_VECTOR_LEN;
             wasm.ifcapi_debugProcessEntity953(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -1349,7 +1350,7 @@ export class IfcAPI {
             return getStringFromWasm0(r0, r1);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+            wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
         }
     }
     /**
@@ -1362,7 +1363,7 @@ export class IfcAPI {
         let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
             const len0 = WASM_VECTOR_LEN;
             wasm.ifcapi_debugProcessFirstWall(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
@@ -1372,7 +1373,7 @@ export class IfcAPI {
             return getStringFromWasm0(r0, r1);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+            wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
         }
     }
     /**
@@ -1412,7 +1413,7 @@ export class IfcAPI {
      * @returns {Promise<any>}
      */
     parseToGpuGeometryAsync(content, options) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_parseToGpuGeometryAsync(this.__wbg_ptr, ptr0, len0, addHeapObject(options));
         return takeObject(ret);
@@ -1426,7 +1427,7 @@ export class IfcAPI {
      * @returns {any}
      */
     scanGeometryEntitiesFast(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_scanGeometryEntitiesFast(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
@@ -1456,11 +1457,34 @@ export class IfcAPI {
      * @returns {Promise<any>}
      */
     parseMeshesInstancedAsync(content, options) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_parseMeshesInstancedAsync(this.__wbg_ptr, ptr0, len0, addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * Parse IFC file and extract symbolic representations (Plan, Annotation, FootPrint)
+     * These are 2D curves used for architectural drawings instead of sectioning 3D geometry
+     *
+     * Example:
+     * ```javascript
+     * const api = new IfcAPI();
+     * const symbols = api.parseSymbolicRepresentations(ifcData);
+     * console.log('Found', symbols.totalCount, 'symbolic items');
+     * for (let i = 0; i < symbols.polylineCount; i++) {
+     *   const polyline = symbols.getPolyline(i);
+     *   console.log('Polyline for', polyline.ifcType, ':', polyline.points);
+     * }
+     * ```
+     * @param {string} content
+     * @returns {SymbolicRepresentationCollection}
+     */
+    parseSymbolicRepresentations(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseSymbolicRepresentations(this.__wbg_ptr, ptr0, len0);
+        return SymbolicRepresentationCollection.__wrap(ret);
+    }
     /**
      * Parse IFC file to GPU-ready instanced geometry for zero-copy upload
      *
@@ -1470,7 +1494,7 @@ export class IfcAPI {
      * @returns {GpuInstancedGeometryCollection}
      */
     parseToGpuInstancedGeometry(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_parseToGpuInstancedGeometry(this.__wbg_ptr, ptr0, len0);
         return GpuInstancedGeometryCollection.__wrap(ret);
@@ -1497,7 +1521,7 @@ export class IfcAPI {
      * @returns {Promise<any>}
      */
     parse(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.ifcapi_parse(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
@@ -1519,7 +1543,7 @@ export class IfcAPI {
             return getStringFromWasm0(r0, r1);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+            wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
@@ -1571,7 +1595,7 @@ export class InstanceData {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayF32FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            wasm.__wbindgen_export2(r0, r1 * 4, 4);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -1728,6 +1752,60 @@ export class MeshCollection {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_meshcollection_free(ptr, 0);
     }
+    /**
+     * Get RTC offset X (for converting local coords back to world coords)
+     * Add this to local X coordinates to get world X coordinates
+     * @returns {number}
+     */
+    get rtcOffsetX() {
+        const ret = wasm.gpugeometry_rtcOffsetZ(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get RTC offset Y
+     * @returns {number}
+     */
+    get rtcOffsetY() {
+        const ret = wasm.meshcollection_rtcOffsetY(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get RTC offset Z
+     * @returns {number}
+     */
+    get rtcOffsetZ() {
+        const ret = wasm.meshcollection_rtcOffsetZ(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Check if RTC offset is significant (>10km)
+     * @returns {boolean}
+     */
+    hasRtcOffset() {
+        const ret = wasm.meshcollection_hasRtcOffset(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Convert local coordinates to world coordinates
+     * Use this to convert mesh positions back to original IFC coordinates
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {Float64Array}
+     */
+    localToWorld(x, y, z) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshcollection_localToWorld(retptr, this.__wbg_ptr, x, y, z);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export2(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Get total vertex count across all meshes
      * @returns {number}
@@ -1744,6 +1822,22 @@ export class MeshCollection {
         const ret = wasm.meshcollection_totalTriangles(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Get building rotation angle in radians (from IfcSite placement)
+     * Returns None if no rotation was detected
+     * @returns {number | undefined}
+     */
+    get buildingRotation() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshcollection_buildingRotation(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Get mesh at index
      * @param {number} index
@@ -1807,7 +1901,7 @@ export class MeshCollectionWithRtc {
      * @returns {number}
      */
     get length() {
-        const ret = wasm.meshcollectionwithrtc_length(this.__wbg_ptr);
+        const ret = wasm.meshcollection_length(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1855,7 +1949,7 @@ export class MeshDataJs {
      * @returns {number}
      */
     get vertexCount() {
-        const ret = wasm.gpugeometry_totalTriangleCount(this.__wbg_ptr);
+        const ret = wasm.meshdatajs_vertexCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1877,7 +1971,7 @@ export class MeshDataJs {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayF32FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            wasm.__wbindgen_export2(r0, r1 * 4, 4);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -1916,7 +2010,7 @@ export class MeshDataJs {
             return getStringFromWasm0(r0, r1);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+            wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
@@ -2018,7 +2112,7 @@ export class RtcOffsetJs {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayF64FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            wasm.__wbindgen_export2(r0, r1 * 8, 8);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -2027,6 +2121,306 @@ export class RtcOffsetJs {
 }
 if (Symbol.dispose) RtcOffsetJs.prototype[Symbol.dispose] = RtcOffsetJs.prototype.free;
 
+/**
+ * A 2D circle/arc for symbolic representations
+ */
+export class SymbolicCircle {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SymbolicCircle.prototype);
+        obj.__wbg_ptr = ptr;
+        SymbolicCircleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SymbolicCircleFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_symboliccircle_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get expressId() {
+        const ret = wasm.gpumeshmetadata_vertexCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get startAngle() {
+        const ret = wasm.symboliccircle_startAngle(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Check if this is a full circle
+     * @returns {boolean}
+     */
+    get isFullCircle() {
+        const ret = wasm.symboliccircle_isFullCircle(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    get repIdentifier() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.symboliccircle_repIdentifier(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_export2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get radius() {
+        const ret = wasm.symboliccircle_radius(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get centerX() {
+        const ret = wasm.symboliccircle_centerX(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get centerY() {
+        const ret = wasm.symboliccircle_centerY(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get ifcType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.symboliccircle_ifcType(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_export2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get endAngle() {
+        const ret = wasm.symboliccircle_endAngle(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) SymbolicCircle.prototype[Symbol.dispose] = SymbolicCircle.prototype.free;
+
+/**
+ * A single 2D polyline for symbolic representations (Plan, Annotation, FootPrint)
+ * Points are stored as [x1, y1, x2, y2, ...] in 2D coordinates
+ */
+export class SymbolicPolyline {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SymbolicPolyline.prototype);
+        obj.__wbg_ptr = ptr;
+        SymbolicPolylineFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SymbolicPolylineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_symbolicpolyline_free(ptr, 0);
+    }
+    /**
+     * Get express ID of the parent element
+     * @returns {number}
+     */
+    get expressId() {
+        const ret = wasm.symbolicpolyline_expressId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get number of points
+     * @returns {number}
+     */
+    get pointCount() {
+        const ret = wasm.symbolicpolyline_pointCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get representation identifier ("Plan", "Annotation", "FootPrint", "Axis")
+     * @returns {string}
+     */
+    get repIdentifier() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.symbolicpolyline_repIdentifier(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_export2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get 2D points as Float32Array [x1, y1, x2, y2, ...]
+     * @returns {Float32Array}
+     */
+    get points() {
+        const ret = wasm.symbolicpolyline_points(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get IFC type name (e.g., "IfcDoor", "IfcWindow")
+     * @returns {string}
+     */
+    get ifcType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.symbolicpolyline_ifcType(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_export2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Check if this is a closed loop
+     * @returns {boolean}
+     */
+    get isClosed() {
+        const ret = wasm.symbolicpolyline_isClosed(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) SymbolicPolyline.prototype[Symbol.dispose] = SymbolicPolyline.prototype.free;
+
+/**
+ * Collection of symbolic representations for an IFC model
+ */
+export class SymbolicRepresentationCollection {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SymbolicRepresentationCollection.prototype);
+        obj.__wbg_ptr = ptr;
+        SymbolicRepresentationCollectionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SymbolicRepresentationCollectionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_symbolicrepresentationcollection_free(ptr, 0);
+    }
+    /**
+     * Get circle at index
+     * @param {number} index
+     * @returns {SymbolicCircle | undefined}
+     */
+    getCircle(index) {
+        const ret = wasm.symbolicrepresentationcollection_getCircle(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : SymbolicCircle.__wrap(ret);
+    }
+    /**
+     * Get total count of all symbolic items
+     * @returns {number}
+     */
+    get totalCount() {
+        const ret = wasm.symbolicrepresentationcollection_totalCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get number of circles/arcs
+     * @returns {number}
+     */
+    get circleCount() {
+        const ret = wasm.symbolicrepresentationcollection_circleCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get polyline at index
+     * @param {number} index
+     * @returns {SymbolicPolyline | undefined}
+     */
+    getPolyline(index) {
+        const ret = wasm.symbolicrepresentationcollection_getPolyline(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : SymbolicPolyline.__wrap(ret);
+    }
+    /**
+     * Get number of polylines
+     * @returns {number}
+     */
+    get polylineCount() {
+        const ret = wasm.symbolicrepresentationcollection_polylineCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get all express IDs that have symbolic representations
+     * @returns {Uint32Array}
+     */
+    getExpressIds() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.symbolicrepresentationcollection_getExpressIds(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export2(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Check if collection is empty
+     * @returns {boolean}
+     */
+    get isEmpty() {
+        const ret = wasm.symbolicrepresentationcollection_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) SymbolicRepresentationCollection.prototype[Symbol.dispose] = SymbolicRepresentationCollection.prototype.free;
+
 /**
  * Zero-copy mesh that exposes pointers to WASM memory
  */
@@ -2059,7 +2453,7 @@ export class ZeroCopyMesh {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayF32FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            wasm.__wbindgen_export2(r0, r1 * 4, 4);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -2076,7 +2470,7 @@ export class ZeroCopyMesh {
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v1 = getArrayF32FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            wasm.__wbindgen_export2(r0, r1 * 4, 4);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
@@ -2103,7 +2497,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get normals_len() {
-        const ret = wasm.gpugeometry_indicesLen(this.__wbg_ptr);
+        const ret = wasm.zerocopymesh_normals_len(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2111,7 +2505,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get normals_ptr() {
-        const ret = wasm.gpugeometry_indicesPtr(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_vertexDataPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2127,7 +2521,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get positions_len() {
-        const ret = wasm.gpugeometry_vertexDataLen(this.__wbg_ptr);
+        const ret = wasm.zerocopymesh_positions_len(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2136,7 +2530,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get positions_ptr() {
-        const ret = wasm.gpugeometry_vertexDataPtr(this.__wbg_ptr);
+        const ret = wasm.zerocopymesh_positions_ptr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2161,7 +2555,7 @@ export class ZeroCopyMesh {
      * @returns {boolean}
      */
     get is_empty() {
-        const ret = wasm.gpugeometry_isEmpty(this.__wbg_ptr);
+        const ret = wasm.zerocopymesh_is_empty(this.__wbg_ptr);
         return ret !== 0;
     }
 }
@@ -2213,7 +2607,7 @@ export function version() {
         return getStringFromWasm0(r0, r1);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
     }
 }
 
@@ -2256,13 +2650,6 @@ function __wbg_get_imports() {
         const ret = Error(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(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);
-    };
     imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
         const ret = typeof(getObject(arg0)) === 'function';
         return ret;
@@ -2311,7 +2698,7 @@ function __wbg_get_imports() {
             deferred0_1 = arg1;
             console.error(getStringFromWasm0(arg0, arg1));
         } finally {
-            wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
+            wasm.__wbindgen_export2(deferred0_0, deferred0_1, 1);
         }
     };
     imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
@@ -2326,6 +2713,10 @@ function __wbg_get_imports() {
         const ret = InstancedGeometry.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_length_86ce4877baf913bb = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
     imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;
@@ -2357,7 +2748,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_756(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_952(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -2380,6 +2771,9 @@ function __wbg_get_imports() {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_prototypesetcall_96cc7097487b926d = function(arg0, arg1, arg2) {
+        Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), getObject(arg2));
+    };
     imports.wbg.__wbg_push_7d9be8f38fc13975 = function(arg0, arg1) {
         const ret = getObject(arg0).push(getObject(arg1));
         return ret;
@@ -2419,7 +2813,7 @@ function __wbg_get_imports() {
     };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
         const ret = getObject(arg1).stack;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
         const len1 = WASM_VECTOR_LEN;
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -2444,29 +2838,32 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).then(getObject(arg1));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_warn_6e567d0d926ff881 = function(arg0) {
+        console.warn(getObject(arg0));
+    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_2ead27b74a7138e7 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 48, function: Function { arguments: [], shim_idx: 49, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_389, __wasm_bindgen_func_elem_393);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
         // Cast intrinsic for `U64 -> Externref`.
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_7f089052c998c143 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 105, function: Function { arguments: [Externref], shim_idx: 106, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_919, __wasm_bindgen_func_elem_921);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
         // Cast intrinsic for `F64 -> Externref`.
         const ret = arg0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_f2cc0f2a96e2ef5b = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 115, function: Function { arguments: [Externref], shim_idx: 116, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_720, __wasm_bindgen_func_elem_725);
+    imports.wbg.__wbindgen_cast_fa504d1cec41bd0d = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 45, function: Function { arguments: [], shim_idx: 46, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_472, __wasm_bindgen_func_elem_474);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_object_clone_ref = function(arg0) {