@ifc-lite/wasm 2.1.6 → 2.3.0

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -35,6 +35,50 @@ export class ClashSession {
   runRule(group_a: Uint32Array, group_b: Uint32Array, mode: number, tolerance: number, clearance: number, report_touch: boolean): ClashRunResult;
 }
 
+export class GridAxisCollection {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get the axis at `index`. Returns `undefined` for out-of-bounds index.
+   */
+  getAxis(index: number): GridAxisJs | undefined;
+  /**
+   * Number of grid axes.
+   */
+  readonly length: number;
+  /**
+   * Whether the collection is empty.
+   */
+  readonly isEmpty: boolean;
+}
+
+export class GridAxisJs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * End endpoint `[x, y, z]` in renderer Y-up world space (metres).
+   */
+  readonly end: Float32Array;
+  /**
+   * Axis tag (e.g. `"A"`, `"1"`); empty string when unauthored.
+   */
+  readonly tag: string;
+  /**
+   * Start endpoint `[x, y, z]` in renderer Y-up world space (metres).
+   */
+  readonly start: Float32Array;
+  /**
+   * Express ID of the `IfcGridAxis`.
+   */
+  readonly axisId: number;
+  /**
+   * Express ID of the owning `IfcGrid`.
+   */
+  readonly gridId: number;
+}
+
 export class IfcAPI {
   free(): void;
   [Symbol.dispose](): void;
@@ -82,6 +126,22 @@ export class IfcAPI {
    *   `{ type: "complete", totalJobs }`
    */
   buildPrePassStreaming(data: Uint8Array, on_event: Function, chunk_size: number): any;
+  /**
+   * Parse the file and return structured per-axis data (tag + endpoints) in
+   * the renderer's Y-up world space (RTC-subtracted, metres). Use this when
+   * you also need the axis tags (to render grid bubbles / labels).
+   */
+  parseGridAxes(content: string): GridAxisCollection;
+  /**
+   * Parse the file and return every `IfcGridAxis` as a flat `Float32Array`
+   * of 3D line-list vertices `[x0,y0,z0, x1,y1,z1, …]` (one segment per
+   * axis) in the renderer's Y-up world space (RTC-subtracted, metres). Feed
+   * straight to a line pipeline (e.g. `uploadAnnotationLines3D`).
+   *
+   * Returns an empty array when the file has no grids, so the caller can
+   * clear the overlay cheaply.
+   */
+  parseGridLines(content: string): Float32Array;
   /**
    * Parse the file and return every `IfcAlignment` directrix as a flat
    * `Float32Array` of 3D line-list vertices `[x0,y0,z0, x1,y1,z1, …]` in
@@ -168,6 +228,17 @@ export class IfcAPI {
    * fail fast.
    */
   clearPrePassCache(): void;
+  /**
+   * Enable or disable per-entity geometry fingerprinting in
+   * `processGeometryBatch`, used by the viewer's revision-diff feature.
+   *
+   * Pass a positive `tolerance` (metres) to enable — it is the quantization
+   * grid the hash snaps positions to (larger = more tolerant of float noise,
+   * smaller = catches finer edits; the `f32` precision floor of model-local
+   * coordinates means values below ~1 mm mostly hash noise). Pass `null`/
+   * `undefined` (or a non-positive value) to disable. Default: disabled.
+   */
+  setComputeGeometryHashes(tolerance?: number | null): void;
   /**
    * Create and initialize the IFC API
    */
@@ -290,6 +361,23 @@ export class MeshCollection {
    * Returns None if no rotation was detected
    */
   readonly buildingRotation: number | undefined;
+  /**
+   * Express ids for the per-entity geometry fingerprints, parallel to
+   * [`Self::geometry_hash_values`]. Empty unless geometry hashing was
+   * enabled via `IfcAPI.setComputeGeometryHashes`.
+   */
+  readonly geometryHashIds: Uint32Array;
+  /**
+   * Number of per-entity geometry fingerprints recorded.
+   */
+  readonly geometryHashCount: number;
+  /**
+   * Per-entity geometry fingerprints as a `BigUint64Array`, parallel to
+   * [`Self::geometry_hash_ids`]. `u64` is exposed (not hex strings) so JS
+   * can compare with `===` and key maps without allocation. Empty unless
+   * geometry hashing was enabled.
+   */
+  readonly geometryHashValues: BigUint64Array;
   /**
    * Get number of meshes
    */
@@ -304,6 +392,14 @@ export class MeshDataJs {
    * Get express ID
    */
   readonly expressId: number;
+  /**
+   * True when this mesh carries a surface texture (#961).
+   */
+  readonly hasTexture: boolean;
+  /**
+   * Decoded RGBA8 texture bytes (`width*height*4`). Empty when untextured.
+   */
+  readonly textureRgba: Uint8Array;
   /**
    * Get vertex count
    */
@@ -314,10 +410,25 @@ export class MeshDataJs {
    * `undefined` when absent (most files).
    */
   readonly shadingColor: Float32Array | undefined;
+  readonly textureWidth: number;
+  readonly textureHeight: number;
   /**
    * Get triangle count
    */
   readonly triangleCount: number;
+  /**
+   * Sampler wrap for the S axis (`IfcSurfaceTexture.RepeatS`): true = repeat.
+   */
+  readonly textureRepeatS: boolean;
+  /**
+   * Sampler wrap for the T axis (`IfcSurfaceTexture.RepeatT`): true = repeat.
+   */
+  readonly textureRepeatT: boolean;
+  /**
+   * Per-vertex texture coordinates as Float32Array (u, v pairs). Empty when
+   * the mesh is untextured.
+   */
+  readonly uvs: Float32Array;
   /**
    * Get color as [r, g, b, a] array
    */
@@ -589,6 +700,8 @@ export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly __wbg_clashrunresult_free: (a: number, b: number) => void;
   readonly __wbg_clashsession_free: (a: number, b: number) => void;
+  readonly __wbg_gridaxiscollection_free: (a: number, b: number) => void;
+  readonly __wbg_gridaxisjs_free: (a: number, b: number) => void;
   readonly __wbg_ifcapi_free: (a: number, b: number) => void;
   readonly __wbg_meshcollection_free: (a: number, b: number) => void;
   readonly __wbg_meshdatajs_free: (a: number, b: number) => void;
@@ -608,6 +721,14 @@ export interface InitOutput {
   readonly clashsession_ingest: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
   readonly clashsession_new: () => number;
   readonly clashsession_runRule: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
+  readonly gridaxiscollection_getAxis: (a: number, b: number) => number;
+  readonly gridaxiscollection_isEmpty: (a: number) => number;
+  readonly gridaxiscollection_length: (a: number) => number;
+  readonly gridaxisjs_axisId: (a: number) => number;
+  readonly gridaxisjs_end: (a: number) => number;
+  readonly gridaxisjs_gridId: (a: number) => number;
+  readonly gridaxisjs_start: (a: number) => number;
+  readonly gridaxisjs_tag: (a: number, b: number) => void;
   readonly ifcapi_buildPrePassFast: (a: number, b: number, c: number) => number;
   readonly ifcapi_buildPrePassOnce: (a: number, b: number, c: number) => number;
   readonly ifcapi_buildPrePassStreaming: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
@@ -618,6 +739,8 @@ export interface InitOutput {
   readonly ifcapi_new: () => number;
   readonly ifcapi_parse: (a: number, b: number, c: number) => number;
   readonly ifcapi_parseAlignmentLines: (a: number, b: number, c: number) => number;
+  readonly ifcapi_parseGridAxes: (a: number, b: number, c: number) => number;
+  readonly ifcapi_parseGridLines: (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_processGeometryBatch: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number) => number;
@@ -625,10 +748,14 @@ export interface InitOutput {
   readonly ifcapi_scanEntitiesFastBytes: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanGeometryEntitiesFast: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanRelevantEntitiesFastBytes: (a: number, b: number, c: number) => number;
+  readonly ifcapi_setComputeGeometryHashes: (a: number, b: number, c: number) => void;
   readonly ifcapi_setEntityIndex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
   readonly ifcapi_setMergeLayers: (a: number, b: number) => void;
   readonly ifcapi_version: (a: number, b: number) => void;
   readonly meshcollection_buildingRotation: (a: number, b: number) => void;
+  readonly meshcollection_geometryHashCount: (a: number) => number;
+  readonly meshcollection_geometryHashIds: (a: number) => number;
+  readonly meshcollection_geometryHashValues: (a: number) => number;
   readonly meshcollection_get: (a: number, b: number) => number;
   readonly meshcollection_hasRtcOffset: (a: number) => number;
   readonly meshcollection_length: (a: number) => number;
@@ -640,12 +767,19 @@ export interface InitOutput {
   readonly meshcollection_totalVertices: (a: number) => number;
   readonly meshdatajs_color: (a: number, b: number) => void;
   readonly meshdatajs_expressId: (a: number) => number;
+  readonly meshdatajs_hasTexture: (a: number) => number;
   readonly meshdatajs_ifcType: (a: number, b: number) => void;
   readonly meshdatajs_indices: (a: number) => number;
   readonly meshdatajs_normals: (a: number) => number;
   readonly meshdatajs_positions: (a: number) => number;
   readonly meshdatajs_shadingColor: (a: number, b: number) => void;
+  readonly meshdatajs_textureHeight: (a: number) => number;
+  readonly meshdatajs_textureRepeatS: (a: number) => number;
+  readonly meshdatajs_textureRepeatT: (a: number) => number;
+  readonly meshdatajs_textureRgba: (a: number) => number;
+  readonly meshdatajs_textureWidth: (a: number) => number;
   readonly meshdatajs_triangleCount: (a: number) => number;
+  readonly meshdatajs_uvs: (a: number) => number;
   readonly meshdatajs_vertexCount: (a: number) => number;
   readonly profilecollection_get: (a: number, b: number) => number;
   readonly profilecollection_length: (a: number) => number;
@@ -722,9 +856,9 @@ export interface InitOutput {
   readonly symbolictext_worldY: (a: number) => number;
   readonly symbolictext_x: (a: number) => number;
   readonly symbolictext_y: (a: number) => number;
-  readonly __wasm_bindgen_func_elem_610: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_609: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_644: (a: number, b: number, c: number, d: number) => void;
+  readonly __wasm_bindgen_func_elem_666: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_665: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_700: (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

@@ -40,11 +40,24 @@ function getArrayU32FromWasm0(ptr, len) {
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 
+function getArrayU64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getBigUint64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+let cachedBigUint64ArrayMemory0 = null;
+function getBigUint64ArrayMemory0() {
+    if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
+        cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
+    }
+    return cachedBigUint64ArrayMemory0;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -232,12 +245,12 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_610(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_610(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_666(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_666(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_644(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_644(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_700(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_700(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const ClashRunResultFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -248,6 +261,14 @@ const ClashSessionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_clashsession_free(ptr >>> 0, 1));
 
+const GridAxisCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gridaxiscollection_free(ptr >>> 0, 1));
+
+const GridAxisJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gridaxisjs_free(ptr >>> 0, 1));
+
 const IfcAPIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ifcapi_free(ptr >>> 0, 1));
@@ -479,6 +500,131 @@ export class ClashSession {
 }
 if (Symbol.dispose) ClashSession.prototype[Symbol.dispose] = ClashSession.prototype.free;
 
+/**
+ * A collection of resolved grid axes.
+ */
+export class GridAxisCollection {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GridAxisCollection.prototype);
+        obj.__wbg_ptr = ptr;
+        GridAxisCollectionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GridAxisCollectionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_gridaxiscollection_free(ptr, 0);
+    }
+    /**
+     * Number of grid axes.
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.gridaxiscollection_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the axis at `index`. Returns `undefined` for out-of-bounds index.
+     * @param {number} index
+     * @returns {GridAxisJs | undefined}
+     */
+    getAxis(index) {
+        const ret = wasm.gridaxiscollection_getAxis(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : GridAxisJs.__wrap(ret);
+    }
+    /**
+     * Whether the collection is empty.
+     * @returns {boolean}
+     */
+    get isEmpty() {
+        const ret = wasm.gridaxiscollection_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) GridAxisCollection.prototype[Symbol.dispose] = GridAxisCollection.prototype.free;
+
+/**
+ * One grid axis: tag + endpoints in renderer Y-up world space (metres).
+ */
+export class GridAxisJs {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GridAxisJs.prototype);
+        obj.__wbg_ptr = ptr;
+        GridAxisJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GridAxisJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_gridaxisjs_free(ptr, 0);
+    }
+    /**
+     * End endpoint `[x, y, z]` in renderer Y-up world space (metres).
+     * @returns {Float32Array}
+     */
+    get end() {
+        const ret = wasm.gridaxisjs_end(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Axis tag (e.g. `"A"`, `"1"`); empty string when unauthored.
+     * @returns {string}
+     */
+    get tag() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.gridaxisjs_tag(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);
+        }
+    }
+    /**
+     * Start endpoint `[x, y, z]` in renderer Y-up world space (metres).
+     * @returns {Float32Array}
+     */
+    get start() {
+        const ret = wasm.gridaxisjs_start(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Express ID of the `IfcGridAxis`.
+     * @returns {number}
+     */
+    get axisId() {
+        const ret = wasm.gridaxisjs_axisId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Express ID of the owning `IfcGrid`.
+     * @returns {number}
+     */
+    get gridId() {
+        const ret = wasm.gridaxisjs_gridId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) GridAxisJs.prototype[Symbol.dispose] = GridAxisJs.prototype.free;
+
 /**
  * Main IFC-Lite API
  */
@@ -602,6 +748,36 @@ export class IfcAPI {
             heap[stack_pointer++] = undefined;
         }
     }
+    /**
+     * Parse the file and return structured per-axis data (tag + endpoints) in
+     * the renderer's Y-up world space (RTC-subtracted, metres). Use this when
+     * you also need the axis tags (to render grid bubbles / labels).
+     * @param {string} content
+     * @returns {GridAxisCollection}
+     */
+    parseGridAxes(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseGridAxes(this.__wbg_ptr, ptr0, len0);
+        return GridAxisCollection.__wrap(ret);
+    }
+    /**
+     * Parse the file and return every `IfcGridAxis` as a flat `Float32Array`
+     * of 3D line-list vertices `[x0,y0,z0, x1,y1,z1, …]` (one segment per
+     * axis) in the renderer's Y-up world space (RTC-subtracted, metres). Feed
+     * straight to a line pipeline (e.g. `uploadAnnotationLines3D`).
+     *
+     * Returns an empty array when the file has no grids, so the caller can
+     * clear the overlay cheaply.
+     * @param {string} content
+     * @returns {Float32Array}
+     */
+    parseGridLines(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseGridLines(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * Parse the file and return every `IfcAlignment` directrix as a flat
      * `Float32Array` of 3D line-list vertices `[x0,y0,z0, x1,y1,z1, …]` in
@@ -723,6 +899,20 @@ export class IfcAPI {
     clearPrePassCache() {
         wasm.ifcapi_clearPrePassCache(this.__wbg_ptr);
     }
+    /**
+     * Enable or disable per-entity geometry fingerprinting in
+     * `processGeometryBatch`, used by the viewer's revision-diff feature.
+     *
+     * Pass a positive `tolerance` (metres) to enable — it is the quantization
+     * grid the hash snaps positions to (larger = more tolerant of float noise,
+     * smaller = catches finer edits; the `f32` precision floor of model-local
+     * coordinates means values below ~1 mm mostly hash noise). Pass `null`/
+     * `undefined` (or a non-positive value) to disable. Default: disabled.
+     * @param {number | null} [tolerance]
+     */
+    setComputeGeometryHashes(tolerance) {
+        wasm.ifcapi_setComputeGeometryHashes(this.__wbg_ptr, !isLikeNone(tolerance), isLikeNone(tolerance) ? 0 : tolerance);
+    }
     /**
      * Create and initialize the IFC API
      */
@@ -985,6 +1175,35 @@ export class MeshCollection {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Express ids for the per-entity geometry fingerprints, parallel to
+     * [`Self::geometry_hash_values`]. Empty unless geometry hashing was
+     * enabled via `IfcAPI.setComputeGeometryHashes`.
+     * @returns {Uint32Array}
+     */
+    get geometryHashIds() {
+        const ret = wasm.meshcollection_geometryHashIds(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Number of per-entity geometry fingerprints recorded.
+     * @returns {number}
+     */
+    get geometryHashCount() {
+        const ret = wasm.meshcollection_geometryHashCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Per-entity geometry fingerprints as a `BigUint64Array`, parallel to
+     * [`Self::geometry_hash_ids`]. `u64` is exposed (not hex strings) so JS
+     * can compare with `===` and key maps without allocation. Empty unless
+     * geometry hashing was enabled.
+     * @returns {BigUint64Array}
+     */
+    get geometryHashValues() {
+        const ret = wasm.meshcollection_geometryHashValues(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * Get mesh at index
      * @param {number} index
@@ -1034,6 +1253,22 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_expressId(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * True when this mesh carries a surface texture (#961).
+     * @returns {boolean}
+     */
+    get hasTexture() {
+        const ret = wasm.meshdatajs_hasTexture(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Decoded RGBA8 texture bytes (`width*height*4`). Empty when untextured.
+     * @returns {Uint8Array}
+     */
+    get textureRgba() {
+        const ret = wasm.meshdatajs_textureRgba(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * Get vertex count
      * @returns {number}
@@ -1064,6 +1299,20 @@ export class MeshDataJs {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @returns {number}
+     */
+    get textureWidth() {
+        const ret = wasm.meshdatajs_textureWidth(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get textureHeight() {
+        const ret = wasm.meshdatajs_textureHeight(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Get triangle count
      * @returns {number}
@@ -1072,6 +1321,31 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_triangleCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Sampler wrap for the S axis (`IfcSurfaceTexture.RepeatS`): true = repeat.
+     * @returns {boolean}
+     */
+    get textureRepeatS() {
+        const ret = wasm.meshdatajs_textureRepeatS(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Sampler wrap for the T axis (`IfcSurfaceTexture.RepeatT`): true = repeat.
+     * @returns {boolean}
+     */
+    get textureRepeatT() {
+        const ret = wasm.meshdatajs_textureRepeatT(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Per-vertex texture coordinates as Float32Array (u, v pairs). Empty when
+     * the mesh is untextured.
+     * @returns {Float32Array}
+     */
+    get uvs() {
+        const ret = wasm.meshdatajs_uvs(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * Get color as [r, g, b, a] array
      * @returns {Float32Array}
@@ -2161,7 +2435,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_644(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_700(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -2176,10 +2450,18 @@ function __wbg_get_imports() {
         const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_new_from_slice_883d10a76ca46292 = function(arg0, arg1) {
+        const ret = new BigUint64Array(getArrayU64FromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_from_slice_db0691b69e9d3891 = function(arg0, arg1) {
         const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_new_from_slice_f9c22b9153b26992 = function(arg0, arg1) {
+        const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
@@ -2256,16 +2538,16 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_warn_6e567d0d926ff881 = function(arg0) {
         console.warn(getObject(arg0));
     };
+    imports.wbg.__wbindgen_cast_0093e2d96a856a3b = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 61, function: Function { arguments: [Externref], shim_idx: 62, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_665, __wasm_bindgen_func_elem_666);
+        return addHeapObject(ret);
+    };
     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_257c51b8abf9285e = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 57, function: Function { arguments: [Externref], shim_idx: 58, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_609, __wasm_bindgen_func_elem_610);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
         // Cast intrinsic for `U64 -> Externref`.
         const ret = BigInt.asUintN(64, arg0);
@@ -2290,6 +2572,7 @@ function __wbg_get_imports() {
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
+    cachedBigUint64ArrayMemory0 = null;
     cachedDataViewMemory0 = null;
     cachedFloat32ArrayMemory0 = null;
     cachedFloat64ArrayMemory0 = null;