@ifc-lite/wasm 1.3.0 → 1.5.0

package/package.json

@@ -5,7 +5,7 @@
     "IFC-Lite Contributors"
   ],
   "description": "WebAssembly bindings for IFC-Lite",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "license": "MPL-2.0",
   "repository": {
     "type": "git",

package/pkg/ifc-lite.d.ts

@@ -461,6 +461,22 @@ export class IfcAPI {
    * ```
    */
   parseMeshesInstancedAsync(content: string, options: any): Promise<any>;
+  /**
+   * 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);
+   * }
+   * ```
+   */
+  parseSymbolicRepresentations(content: string): SymbolicRepresentationCollection;
   /**
    * Parse IFC file to GPU-ready instanced geometry for zero-copy upload
    *
@@ -562,6 +578,11 @@ export class MeshCollection {
    * Get total triangle count across all meshes
    */
   readonly totalTriangles: number;
+  /**
+   * Get building rotation angle in radians (from IfcSite placement)
+   * Returns None if no rotation was detected
+   */
+  readonly buildingRotation: number | undefined;
   /**
    * Get number of meshes
    */
@@ -654,6 +675,88 @@ export class RtcOffsetJs {
   z: number;
 }
 
+export class SymbolicCircle {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly expressId: number;
+  readonly startAngle: number;
+  /**
+   * Check if this is a full circle
+   */
+  readonly isFullCircle: boolean;
+  readonly repIdentifier: string;
+  readonly radius: number;
+  readonly centerX: number;
+  readonly centerY: number;
+  readonly ifcType: string;
+  readonly endAngle: number;
+}
+
+export class SymbolicPolyline {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get express ID of the parent element
+   */
+  readonly expressId: number;
+  /**
+   * Get number of points
+   */
+  readonly pointCount: number;
+  /**
+   * Get representation identifier ("Plan", "Annotation", "FootPrint", "Axis")
+   */
+  readonly repIdentifier: string;
+  /**
+   * Get 2D points as Float32Array [x1, y1, x2, y2, ...]
+   */
+  readonly points: Float32Array;
+  /**
+   * Get IFC type name (e.g., "IfcDoor", "IfcWindow")
+   */
+  readonly ifcType: string;
+  /**
+   * Check if this is a closed loop
+   */
+  readonly isClosed: boolean;
+}
+
+export class SymbolicRepresentationCollection {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get circle at index
+   */
+  getCircle(index: number): SymbolicCircle | undefined;
+  /**
+   * Get polyline at index
+   */
+  getPolyline(index: number): SymbolicPolyline | undefined;
+  /**
+   * Get all express IDs that have symbolic representations
+   */
+  getExpressIds(): Uint32Array;
+  /**
+   * Get total count of all symbolic items
+   */
+  readonly totalCount: number;
+  /**
+   * Get number of circles/arcs
+   */
+  readonly circleCount: number;
+  /**
+   * Get number of polylines
+   */
+  readonly polylineCount: number;
+  /**
+   * Check if collection is empty
+   */
+  readonly isEmpty: boolean;
+}
+
 export class ZeroCopyMesh {
   free(): void;
   [Symbol.dispose](): void;
@@ -766,6 +869,9 @@ export interface InitOutput {
   readonly __wbg_set_georeferencejs_scale: (a: number, b: number) => void;
   readonly __wbg_set_georeferencejs_x_axis_abscissa: (a: number, b: number) => void;
   readonly __wbg_set_georeferencejs_x_axis_ordinate: (a: number, b: number) => void;
+  readonly __wbg_symboliccircle_free: (a: number, b: number) => void;
+  readonly __wbg_symbolicpolyline_free: (a: number, b: number) => void;
+  readonly __wbg_symbolicrepresentationcollection_free: (a: number, b: number) => void;
   readonly __wbg_zerocopymesh_free: (a: number, b: number) => void;
   readonly georeferencejs_crsName: (a: number, b: number) => void;
   readonly georeferencejs_localToMap: (a: number, b: number, c: number, d: number, e: number) => void;
@@ -841,6 +947,7 @@ export interface InitOutput {
   readonly ifcapi_parseMeshesInstancedAsync: (a: number, b: number, c: number, d: number) => number;
   readonly ifcapi_parseMeshesWithRtc: (a: number, b: number, c: number) => number;
   readonly ifcapi_parseStreaming: (a: number, b: number, c: number, d: number) => number;
+  readonly ifcapi_parseSymbolicRepresentations: (a: number, b: number, c: number) => number;
   readonly ifcapi_parseToGpuGeometry: (a: number, b: number, c: number) => number;
   readonly ifcapi_parseToGpuGeometryAsync: (a: number, b: number, c: number, d: number) => number;
   readonly ifcapi_parseToGpuInstancedGeometry: (a: number, b: number, c: number) => number;
@@ -858,14 +965,16 @@ export interface InitOutput {
   readonly instancedgeometry_positions: (a: number) => number;
   readonly instancedmeshcollection_get: (a: number, b: number) => number;
   readonly instancedmeshcollection_totalInstances: (a: number) => number;
+  readonly meshcollection_buildingRotation: (a: number, b: number) => void;
   readonly meshcollection_get: (a: number, b: number) => number;
   readonly meshcollection_hasRtcOffset: (a: number) => number;
   readonly meshcollection_length: (a: number) => number;
   readonly meshcollection_localToWorld: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly meshcollection_rtcOffsetY: (a: number) => number;
+  readonly meshcollection_rtcOffsetZ: (a: number) => number;
   readonly meshcollection_totalTriangles: (a: number) => number;
   readonly meshcollection_totalVertices: (a: number) => number;
   readonly meshcollectionwithrtc_get: (a: number, b: number) => number;
-  readonly meshcollectionwithrtc_length: (a: number) => number;
   readonly meshcollectionwithrtc_meshes: (a: number) => number;
   readonly meshcollectionwithrtc_rtcOffset: (a: number) => number;
   readonly meshdatajs_color: (a: number, b: number) => void;
@@ -876,7 +985,29 @@ export interface InitOutput {
   readonly meshdatajs_positions: (a: number) => number;
   readonly meshdatajs_triangleCount: (a: number) => number;
   readonly meshdatajs_vertexCount: (a: number) => number;
+  readonly rtcoffsetjs_isSignificant: (a: number) => number;
   readonly rtcoffsetjs_toWorld: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly symboliccircle_centerX: (a: number) => number;
+  readonly symboliccircle_centerY: (a: number) => number;
+  readonly symboliccircle_endAngle: (a: number) => number;
+  readonly symboliccircle_ifcType: (a: number, b: number) => void;
+  readonly symboliccircle_isFullCircle: (a: number) => number;
+  readonly symboliccircle_radius: (a: number) => number;
+  readonly symboliccircle_repIdentifier: (a: number, b: number) => void;
+  readonly symboliccircle_startAngle: (a: number) => number;
+  readonly symbolicpolyline_expressId: (a: number) => number;
+  readonly symbolicpolyline_ifcType: (a: number, b: number) => void;
+  readonly symbolicpolyline_isClosed: (a: number) => number;
+  readonly symbolicpolyline_pointCount: (a: number) => number;
+  readonly symbolicpolyline_points: (a: number) => number;
+  readonly symbolicpolyline_repIdentifier: (a: number, b: number) => void;
+  readonly symbolicrepresentationcollection_circleCount: (a: number) => number;
+  readonly symbolicrepresentationcollection_getCircle: (a: number, b: number) => number;
+  readonly symbolicrepresentationcollection_getExpressIds: (a: number, b: number) => void;
+  readonly symbolicrepresentationcollection_getPolyline: (a: number, b: number) => number;
+  readonly symbolicrepresentationcollection_isEmpty: (a: number) => number;
+  readonly symbolicrepresentationcollection_polylineCount: (a: number) => number;
+  readonly symbolicrepresentationcollection_totalCount: (a: number) => number;
   readonly version: (a: number) => void;
   readonly zerocopymesh_bounds_max: (a: number, b: number) => void;
   readonly zerocopymesh_bounds_min: (a: number, b: number) => void;
@@ -889,6 +1020,7 @@ export interface InitOutput {
   readonly init: () => void;
   readonly instancedmeshcollection_length: (a: number) => number;
   readonly instancedmeshcollection_totalGeometries: (a: number) => number;
+  readonly meshcollectionwithrtc_length: (a: number) => number;
   readonly zerocopymesh_indices_len: (a: number) => number;
   readonly __wbg_set_rtcoffsetjs_x: (a: number, b: number) => void;
   readonly __wbg_set_rtcoffsetjs_y: (a: number, b: number) => void;
@@ -897,19 +1029,17 @@ export interface InitOutput {
   readonly get_memory: () => number;
   readonly zerocopymesh_indices_ptr: (a: number) => number;
   readonly zerocopymesh_normals_ptr: (a: number) => number;
-  readonly rtcoffsetjs_isSignificant: (a: number) => number;
   readonly __wbg_get_rtcoffsetjs_x: (a: number) => number;
   readonly __wbg_get_rtcoffsetjs_y: (a: number) => number;
   readonly __wbg_get_rtcoffsetjs_z: (a: number) => number;
   readonly instancedgeometry_geometryId: (a: number) => bigint;
   readonly meshcollection_rtcOffsetX: (a: number) => number;
-  readonly meshcollection_rtcOffsetY: (a: number) => number;
-  readonly meshcollection_rtcOffsetZ: (a: number) => number;
-  readonly __wasm_bindgen_func_elem_847: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_845: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_408: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_406: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_878: (a: number, b: number, c: number, d: number) => void;
+  readonly symboliccircle_expressId: (a: number) => number;
+  readonly __wasm_bindgen_func_elem_474: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_472: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_921: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_919: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_952: (a: number, b: number, c: number, d: number) => void;
   readonly __wbindgen_export: (a: number) => void;
   readonly __wbindgen_export2: (a: number, b: number, c: number) => void;
   readonly __wbindgen_export3: (a: number, b: number) => number;

package/pkg/ifc-lite.js

@@ -198,16 +198,16 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_847(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_847(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_474(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_474(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_408(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_408(arg0, arg1);
+function __wasm_bindgen_func_elem_921(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_921(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_878(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_878(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')
@@ -266,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));
@@ -1450,6 +1462,29 @@ export class IfcAPI {
         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
      *
@@ -1723,7 +1758,7 @@ export class MeshCollection {
      * @returns {number}
      */
     get rtcOffsetX() {
-        const ret = wasm.gpugeometry_rtcOffsetX(this.__wbg_ptr);
+        const ret = wasm.gpugeometry_rtcOffsetZ(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -1731,7 +1766,7 @@ export class MeshCollection {
      * @returns {number}
      */
     get rtcOffsetY() {
-        const ret = wasm.gpugeometry_rtcOffsetY(this.__wbg_ptr);
+        const ret = wasm.meshcollection_rtcOffsetY(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -1739,7 +1774,7 @@ export class MeshCollection {
      * @returns {number}
      */
     get rtcOffsetZ() {
-        const ret = wasm.gpugeometry_rtcOffsetZ(this.__wbg_ptr);
+        const ret = wasm.meshcollection_rtcOffsetZ(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -1787,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
@@ -1850,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;
     }
     /**
@@ -2044,7 +2095,7 @@ export class RtcOffsetJs {
      * @returns {boolean}
      */
     isSignificant() {
-        const ret = wasm.meshcollection_hasRtcOffset(this.__wbg_ptr);
+        const ret = wasm.rtcoffsetjs_isSignificant(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -2070,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
  */
@@ -2362,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;
@@ -2393,7 +2748,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_878(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_952(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -2416,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;
@@ -2495,7 +2853,7 @@ function __wbg_get_imports() {
     };
     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_845, __wasm_bindgen_func_elem_847);
+        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) {
@@ -2505,7 +2863,7 @@ function __wbg_get_imports() {
     };
     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_406, __wasm_bindgen_func_elem_408);
+        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) {