@ifc-lite/wasm 1.18.0 → 1.19.1

package/package.json

@@ -5,7 +5,7 @@
     "IFC-Lite Contributors"
   ],
   "description": "WebAssembly bindings for IFC-Lite",
-  "version": "1.18.0",
+  "version": "1.19.1",
   "license": "MPL-2.0",
   "repository": {
     "type": "git",
@@ -35,7 +35,7 @@
     "aec"
   ],
   "scripts": {
-    "build": "bash ../../scripts/build-wasm.sh",
+    "build": "node ../../scripts/run-build-wasm.mjs",
     "test": "node --test test/*.test.mjs"
   }
 }

package/pkg/ifc-lite.d.ts

@@ -932,12 +932,45 @@ export class SymbolicCircle {
   readonly isFullCircle: boolean;
   readonly repIdentifier: string;
   readonly radius: number;
+  /**
+   * World-Y elevation captured from the placement chain.
+   */
+  readonly worldY: number;
   readonly centerX: number;
   readonly centerY: number;
   readonly ifcType: string;
   readonly endAngle: number;
 }
 
+export class SymbolicFillArea {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly expressId: number;
+  readonly holeCount: number;
+  readonly hatchAngle: number;
+  readonly pointCount: number;
+  readonly hasHatching: boolean;
+  readonly hatchSpacing: number;
+  /**
+   * Vertex indices marking the start of each hole. Empty = no holes.
+   */
+  readonly holesOffsets: Uint32Array;
+  readonly repIdentifier: string;
+  readonly hatchLineWidth: number;
+  readonly hatchAngleSecondary: number;
+  readonly fillA: number;
+  readonly fillB: number;
+  readonly fillG: number;
+  readonly fillR: number;
+  /**
+   * Flattened ring vertices.
+   */
+  readonly points: Float32Array;
+  readonly worldY: number;
+  readonly ifcType: string;
+}
+
 export class SymbolicPolyline {
   private constructor();
   free(): void;
@@ -958,6 +991,11 @@ export class SymbolicPolyline {
    * Get 2D points as Float32Array [x1, y1, x2, y2, ...]
    */
   readonly points: Float32Array;
+  /**
+   * World-Y elevation captured from the placement chain (or first 3D
+   * point's Z component). JS uses this as the canonical bucket key.
+   */
+  readonly worldY: number;
   /**
    * Get IFC type name (e.g., "IfcDoor", "IfcWindow")
    */
@@ -984,6 +1022,22 @@ export class SymbolicRepresentationCollection {
    * Get all express IDs that have symbolic representations
    */
   getExpressIds(): Uint32Array;
+  /**
+   * Get fill area at index.
+   */
+  getFill(index: number): SymbolicFillArea | undefined;
+  /**
+   * Get text annotation at index.
+   */
+  getText(index: number): SymbolicText | undefined;
+  /**
+   * Get number of fill areas
+   */
+  readonly fillCount: number;
+  /**
+   * Get number of text annotations
+   */
+  readonly textCount: number;
   /**
    * Get total count of all symbolic items
    */
@@ -1002,6 +1056,28 @@ export class SymbolicRepresentationCollection {
   readonly isEmpty: boolean;
 }
 
+export class SymbolicText {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly expressId: number;
+  readonly repIdentifier: string;
+  readonly x: number;
+  readonly y: number;
+  readonly dirX: number;
+  readonly dirY: number;
+  readonly height: number;
+  readonly colorA: number;
+  readonly colorB: number;
+  readonly colorG: number;
+  readonly colorR: number;
+  readonly content: string;
+  readonly worldY: number;
+  readonly ifcType: string;
+  readonly alignment: string;
+  readonly targetPx: number;
+}
+
 export class ZeroCopyMesh {
   free(): void;
   [Symbol.dispose](): void;
@@ -1116,8 +1192,10 @@ export interface InitOutput {
   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_symbolicfillarea_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_symbolictext_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;
@@ -1253,19 +1331,44 @@ export interface InitOutput {
   readonly symboliccircle_radius: (a: number) => number;
   readonly symboliccircle_repIdentifier: (a: number, b: number) => void;
   readonly symboliccircle_startAngle: (a: number) => number;
+  readonly symboliccircle_worldY: (a: number) => number;
+  readonly symbolicfillarea_fillA: (a: number) => number;
+  readonly symbolicfillarea_fillB: (a: number) => number;
+  readonly symbolicfillarea_fillG: (a: number) => number;
+  readonly symbolicfillarea_fillR: (a: number) => number;
+  readonly symbolicfillarea_hasHatching: (a: number) => number;
+  readonly symbolicfillarea_hatchAngle: (a: number) => number;
+  readonly symbolicfillarea_hatchAngleSecondary: (a: number) => number;
+  readonly symbolicfillarea_hatchLineWidth: (a: number) => number;
+  readonly symbolicfillarea_hatchSpacing: (a: number) => number;
+  readonly symbolicfillarea_holesOffsets: (a: number) => number;
+  readonly symbolicfillarea_ifcType: (a: number, b: number) => void;
+  readonly symbolicfillarea_pointCount: (a: number) => number;
+  readonly symbolicfillarea_points: (a: number) => number;
+  readonly symbolicfillarea_repIdentifier: (a: number, b: number) => void;
+  readonly symbolicfillarea_worldY: (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_fillCount: (a: number) => number;
   readonly symbolicrepresentationcollection_getCircle: (a: number, b: number) => number;
   readonly symbolicrepresentationcollection_getExpressIds: (a: number, b: number) => void;
+  readonly symbolicrepresentationcollection_getFill: (a: number, b: number) => number;
   readonly symbolicrepresentationcollection_getPolyline: (a: number, b: number) => number;
+  readonly symbolicrepresentationcollection_getText: (a: number, b: number) => number;
   readonly symbolicrepresentationcollection_isEmpty: (a: number) => number;
   readonly symbolicrepresentationcollection_polylineCount: (a: number) => number;
+  readonly symbolicrepresentationcollection_textCount: (a: number) => number;
   readonly symbolicrepresentationcollection_totalCount: (a: number) => number;
+  readonly symbolictext_alignment: (a: number, b: number) => void;
+  readonly symbolictext_colorA: (a: number) => number;
+  readonly symbolictext_content: (a: number, b: number) => void;
+  readonly symbolictext_ifcType: (a: number, b: number) => void;
+  readonly symbolictext_repIdentifier: (a: number, b: number) => void;
+  readonly symbolictext_targetPx: (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;
@@ -1283,7 +1386,9 @@ export interface InitOutput {
   readonly instancedmeshcollection_length: (a: number) => number;
   readonly instancedmeshcollection_totalGeometries: (a: number) => number;
   readonly meshcollectionwithrtc_length: (a: number) => number;
+  readonly symbolicfillarea_holeCount: (a: number) => number;
   readonly zerocopymesh_indices_len: (a: number) => number;
+  readonly symbolicpolyline_pointCount: (a: number) => number;
   readonly __wbg_set_rtcoffsetjs_x: (a: number, b: number) => void;
   readonly __wbg_set_rtcoffsetjs_y: (a: number, b: number) => void;
   readonly __wbg_set_rtcoffsetjs_z: (a: number, b: number) => void;
@@ -1306,10 +1411,22 @@ export interface InitOutput {
   readonly instancedgeometry_geometryId: (a: number) => bigint;
   readonly meshcollection_rtcOffsetX: (a: number) => number;
   readonly symboliccircle_expressId: (a: number) => number;
+  readonly symbolicfillarea_expressId: (a: number) => number;
+  readonly symbolicpolyline_worldY: (a: number) => number;
+  readonly symbolictext_colorB: (a: number) => number;
+  readonly symbolictext_colorG: (a: number) => number;
+  readonly symbolictext_colorR: (a: number) => number;
+  readonly symbolictext_dirX: (a: number) => number;
+  readonly symbolictext_dirY: (a: number) => number;
+  readonly symbolictext_expressId: (a: number) => number;
+  readonly symbolictext_height: (a: number) => number;
+  readonly symbolictext_worldY: (a: number) => number;
+  readonly symbolictext_x: (a: number) => number;
+  readonly symbolictext_y: (a: number) => number;
   readonly __wbg_gpuinstancedgeometryref_free: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_1484: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_1483: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_1524: (a: number, b: number, c: number, d: number) => void;
+  readonly __wasm_bindgen_func_elem_1533: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_1532: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_1573: (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

@@ -220,12 +220,12 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_1484(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_1484(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_1533(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_1533(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_1524(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1524(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_1573(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1573(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const GeoReferenceJsFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -296,6 +296,10 @@ const SymbolicCircleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_symboliccircle_free(ptr >>> 0, 1));
 
+const SymbolicFillAreaFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_symbolicfillarea_free(ptr >>> 0, 1));
+
 const SymbolicPolylineFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_symbolicpolyline_free(ptr >>> 0, 1));
@@ -304,6 +308,10 @@ const SymbolicRepresentationCollectionFinalization = (typeof FinalizationRegistr
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_symbolicrepresentationcollection_free(ptr >>> 0, 1));
 
+const SymbolicTextFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_symbolictext_free(ptr >>> 0, 1));
+
 const ZeroCopyMeshFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_zerocopymesh_free(ptr >>> 0, 1));
@@ -2729,6 +2737,14 @@ export class SymbolicCircle {
         const ret = wasm.symboliccircle_radius(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * World-Y elevation captured from the placement chain.
+     * @returns {number}
+     */
+    get worldY() {
+        const ret = wasm.symboliccircle_worldY(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {number}
      */
@@ -2772,6 +2788,187 @@ export class SymbolicCircle {
 }
 if (Symbol.dispose) SymbolicCircle.prototype[Symbol.dispose] = SymbolicCircle.prototype.free;
 
+/**
+ * A 2D filled region (IfcAnnotationFillArea / IfcAnnotationFillAreaOccurrence).
+ *
+ * Stores one outer ring of 2D points plus an offset table indexing inner
+ * rings (holes). Both rings are stored flat in `points` so the JS side can
+ * view the buffer as one Float32Array. The optional `hatch_*` fields encode
+ * IfcFillAreaStyleHatching (line spacing, primary/secondary angles, line
+ * width) when the IfcStyledItem chain resolves to a hatching style; absent
+ * styles render as a solid fill.
+ *
+ * `holes_offsets` is an inclusive-prefix array describing where each hole
+ * begins. The outer ring is implicitly at `points[0..holes_offsets[0]]`
+ * (or all points if `holes_offsets` is empty). Each `holes_offsets[i]` is a
+ * vertex index, not a byte offset.
+ */
+export class SymbolicFillArea {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SymbolicFillArea.prototype);
+        obj.__wbg_ptr = ptr;
+        SymbolicFillAreaFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SymbolicFillAreaFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_symbolicfillarea_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get expressId() {
+        const ret = wasm.profileentryjs_expressId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get holeCount() {
+        const ret = wasm.gpuinstancedgeometry_indicesLen(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get hatchAngle() {
+        const ret = wasm.symbolicfillarea_hatchAngle(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get pointCount() {
+        const ret = wasm.symbolicfillarea_pointCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get hasHatching() {
+        const ret = wasm.symbolicfillarea_hasHatching(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get hatchSpacing() {
+        const ret = wasm.symbolicfillarea_hatchSpacing(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Vertex indices marking the start of each hole. Empty = no holes.
+     * @returns {Uint32Array}
+     */
+    get holesOffsets() {
+        const ret = wasm.symbolicfillarea_holesOffsets(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get repIdentifier() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.symbolicfillarea_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 hatchLineWidth() {
+        const ret = wasm.symbolicfillarea_hatchLineWidth(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get hatchAngleSecondary() {
+        const ret = wasm.symbolicfillarea_hatchAngleSecondary(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get fillA() {
+        const ret = wasm.symbolicfillarea_fillA(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get fillB() {
+        const ret = wasm.symbolicfillarea_fillB(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get fillG() {
+        const ret = wasm.symbolicfillarea_fillG(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get fillR() {
+        const ret = wasm.symbolicfillarea_fillR(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Flattened ring vertices.
+     * @returns {Float32Array}
+     */
+    get points() {
+        const ret = wasm.symbolicfillarea_points(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get worldY() {
+        const ret = wasm.symbolicfillarea_worldY(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.symbolicfillarea_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);
+        }
+    }
+}
+if (Symbol.dispose) SymbolicFillArea.prototype[Symbol.dispose] = SymbolicFillArea.prototype.free;
+
 /**
  * A single 2D polyline for symbolic representations (Plan, Annotation, FootPrint)
  * Points are stored as [x1, y1, x2, y2, ...] in 2D coordinates
@@ -2807,7 +3004,7 @@ export class SymbolicPolyline {
      * @returns {number}
      */
     get pointCount() {
-        const ret = wasm.symbolicpolyline_pointCount(this.__wbg_ptr);
+        const ret = wasm.symbolicfillarea_pointCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2838,6 +3035,15 @@ export class SymbolicPolyline {
         const ret = wasm.symbolicpolyline_points(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * World-Y elevation captured from the placement chain (or first 3D
+     * point's Z component). JS uses this as the canonical bucket key.
+     * @returns {number}
+     */
+    get worldY() {
+        const ret = wasm.symboliccircle_worldY(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Get IFC type name (e.g., "IfcDoor", "IfcWindow")
      * @returns {string}
@@ -2890,6 +3096,14 @@ export class SymbolicRepresentationCollection {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_symbolicrepresentationcollection_free(ptr, 0);
     }
+    /**
+     * Get number of fill areas
+     * @returns {number}
+     */
+    get fillCount() {
+        const ret = wasm.symbolicrepresentationcollection_fillCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Get circle at index
      * @param {number} index
@@ -2899,6 +3113,14 @@ export class SymbolicRepresentationCollection {
         const ret = wasm.symbolicrepresentationcollection_getCircle(this.__wbg_ptr, index);
         return ret === 0 ? undefined : SymbolicCircle.__wrap(ret);
     }
+    /**
+     * Get number of text annotations
+     * @returns {number}
+     */
+    get textCount() {
+        const ret = wasm.symbolicrepresentationcollection_textCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Get total count of all symbolic items
      * @returns {number}
@@ -2949,6 +3171,24 @@ export class SymbolicRepresentationCollection {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Get fill area at index.
+     * @param {number} index
+     * @returns {SymbolicFillArea | undefined}
+     */
+    getFill(index) {
+        const ret = wasm.symbolicrepresentationcollection_getFill(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : SymbolicFillArea.__wrap(ret);
+    }
+    /**
+     * Get text annotation at index.
+     * @param {number} index
+     * @returns {SymbolicText | undefined}
+     */
+    getText(index) {
+        const ret = wasm.symbolicrepresentationcollection_getText(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : SymbolicText.__wrap(ret);
+    }
     /**
      * Check if collection is empty
      * @returns {boolean}
@@ -2960,6 +3200,198 @@ export class SymbolicRepresentationCollection {
 }
 if (Symbol.dispose) SymbolicRepresentationCollection.prototype[Symbol.dispose] = SymbolicRepresentationCollection.prototype.free;
 
+/**
+ * A 2D text annotation (IfcTextLiteral / IfcTextLiteralWithExtent).
+ *
+ * Position is in the same 2D coordinate space as `SymbolicPolyline` (i.e. the
+ * floor-plan / annotation overlay's local frame after applying placement +
+ * RTC). The text-orientation pair `(cos, sin)` rotates the baseline from the
+ * `+x` axis. Height is the IFC font height in model units, scaled by the
+ * project's length-unit factor so the renderer can convert directly to world
+ * units. Alignment is the IFC `BoxAlignment` string verbatim
+ * (`top-left`, `center`, `bottom-right`, …) — the renderer can interpret it.
+ */
+export class SymbolicText {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SymbolicText.prototype);
+        obj.__wbg_ptr = ptr;
+        SymbolicTextFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SymbolicTextFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_symbolictext_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get expressId() {
+        const ret = wasm.profileentryjs_expressId(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.symbolictext_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 x() {
+        const ret = wasm.symbolicfillarea_fillR(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get y() {
+        const ret = wasm.symbolicfillarea_fillG(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get dirX() {
+        const ret = wasm.symbolicfillarea_fillB(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get dirY() {
+        const ret = wasm.symbolicfillarea_fillA(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.symbolicfillarea_hatchSpacing(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get colorA() {
+        const ret = wasm.symbolictext_colorA(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get colorB() {
+        const ret = wasm.symbolicfillarea_worldY(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get colorG() {
+        const ret = wasm.symbolicfillarea_hatchLineWidth(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get colorR() {
+        const ret = wasm.symbolicfillarea_hatchAngleSecondary(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get content() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.symbolictext_content(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 worldY() {
+        const ret = wasm.symbolicfillarea_hatchAngle(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.symbolictext_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 {string}
+     */
+    get alignment() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.symbolictext_alignment(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 targetPx() {
+        const ret = wasm.symbolictext_targetPx(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) SymbolicText.prototype[Symbol.dispose] = SymbolicText.prototype.free;
+
 /**
  * Zero-copy mesh that exposes pointers to WASM memory
  */
@@ -3254,10 +3686,6 @@ 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;
@@ -3285,7 +3713,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_1524(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_1573(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -3320,9 +3748,6 @@ function __wbg_get_imports() {
         const ret = new Uint8Array(arg0 >>> 0);
         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;
@@ -3397,9 +3822,9 @@ function __wbg_get_imports() {
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_73cbb7b49382c492 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 179, function: Function { arguments: [Externref], shim_idx: 180, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1483, __wasm_bindgen_func_elem_1484);
+    imports.wbg.__wbindgen_cast_56b148ee1abaedad = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 180, function: Function { arguments: [Externref], shim_idx: 181, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1532, __wasm_bindgen_func_elem_1533);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {