@bldrs-ai/conway 1.330.1053 → 1.331.1060

package/compiled/src/compat/web-ifc/ifc_api.js

@@ -0,0 +1,544 @@
+import { ConwayGeometry, } from "../../index.js";
+import { versionString } from "../../version/version.js";
+import Logger from "../../logging/logger.js";
+import Environment from "../../utilities/environment.js";
+import * as glmatrix from "gl-matrix";
+import { IfcApiModelPassthroughFactory } from "./ifc_api_model_passthrough_factory.js";
+import { Properties } from "./properties.js";
+export * from "./ifc2x4.js";
+export const UNKNOWN = 0;
+export const STRING = 1;
+export const LABEL = 2;
+export const ENUM = 3;
+export const REAL = 4;
+export const REF = 5;
+export const EMPTY = 6;
+export const SET_BEGIN = 7;
+export const SET_END = 8;
+export const LINE_END = 9;
+/**
+ * @return {number} current time in ms
+ */
+export function ms() {
+    return new Date().getTime();
+}
+/**
+ * IfcAPI - Web-IFC API Shim Implementation for full read functionality
+ */
+export class IfcAPI {
+    constructor() {
+        this.wasmModule = undefined;
+        this.fs = undefined;
+        this.wasmPath = "";
+        this.isWasmPathAbsolute = false;
+        this.globalModelIDCounter = 0;
+        this.models = new Map();
+        this.conwaywasm = new ConwayGeometry();
+        this._isCoordinated = false;
+        this.linearScalingFactor = 1;
+        this.identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+        // Initialize the matrix using an array
+        this.NormalizeMat = glmatrix.mat4.fromValues(1, 0, 0, 0, // First column
+        0, 0, -1, 0, // Second column
+        0, 1, 0, 0, // Third column
+        0, 0, 0, 1);
+        this.properties = new Properties(this);
+    }
+    /**
+     * Get the passthrough for a particular model id.
+     *
+     * @param modelID
+     * @return {IfcApiModelPassthrough | undefined}
+     */
+    getPassthrough(modelID) {
+        return this.models.get(modelID);
+    }
+    /**
+     * Initializes the WASM module (WebIFCWasm), required before using any other functionality.
+     *
+     * @param customLocateFileHandler An optional locateFile function that let's
+     * you override the path from which the wasm module is loaded.
+     */
+    async Init(customLocateFileHandler) {
+        Environment.checkEnvironment();
+        Logger.initializeWasmCallbacks();
+        Logger.info(versionString);
+        const locateFileHandler = (path, prefix) => {
+            // when the wasm module requests the wasm file, we redirect to include the user specified path
+            if (path.endsWith(".wasm")) {
+                if (this.isWasmPathAbsolute) {
+                    return this.wasmPath + path;
+                }
+                return prefix + this.wasmPath + path;
+            }
+            // otherwise use the default path
+            return prefix + path;
+        };
+        // @ts-ignore
+        const initializationStatus = await this.conwaywasm.initialize((customLocateFileHandler !== void 0) ?
+            customLocateFileHandler : locateFileHandler);
+        if (!initializationStatus) {
+            Logger.error("Could not initialize Conway Wasm");
+            return;
+        }
+        this.wasmModule = this.conwaywasm.wasmModule;
+    }
+    /**
+     * Opens a model and returns a modelID number
+     *
+     * @param data containing IFC data (bytes)
+     * @param settings settings for loading the model
+     * @return {number} model ID
+     */
+    OpenModel(data, settings) {
+        const modelIdResult = this.globalModelIDCounter;
+        const result = IfcApiModelPassthroughFactory.from(modelIdResult, data, this.wasmModule, settings);
+        if (result === void 0) {
+            return -1;
+        }
+        this.globalModelIDCounter++;
+        this.models.set(modelIdResult, result);
+        return modelIdResult;
+    }
+    /**
+     * Creates a new model and returns a modelID number (unimplemented)
+     *
+     * @param settings settings for generating data the model
+     * @return {number} model ID
+     */
+    CreateModel(settings) {
+        Logger.warning("[CreateModel]: Shim - Unimplemented");
+        return 0;
+    }
+    /**
+     *
+     * @param modelID
+     * @return {Uint8Array} unimplemented
+     */
+    ExportFileAsIFC(modelID) {
+        Logger.warning(`[ExportFileAsIFC]: Model ${modelID}: Shim - Unimplemented`);
+        const emptyArray = new Uint8Array(1);
+        return emptyArray;
+    }
+    /**
+     * Opens a model and returns a modelID number
+     *
+     * @param modelID handle retrieved by OpenModel, model must not be closed
+     * @param geometryExpressID containing IFC data (bytes)
+     * @return {IfcGeometry}
+     */
+    GetGeometry(modelID, geometryExpressID) {
+        const result = this.models.get(modelID);
+        if (result !== void 0) {
+            return result.getGeometry(geometryExpressID);
+        }
+        else {
+            Logger.error("[GetGeometry]: model === undefined");
+        }
+        Logger.error("[GetGeometry]: Error - returning dummyGeometry object");
+        const dummyGeometry = (new (this.wasmModule.IfcGeometry)());
+        return dummyGeometry;
+    }
+    /**
+     *
+     * @param modelID
+     * @param expressID
+     * @param flatten
+     * @return {any} line data
+     */
+    GetLine(modelID, expressID, flatten = false) {
+        const result = this.models.get(modelID);
+        if (result === void 0) {
+            Logger.error("[GetLine]: model === undefined");
+            return;
+        }
+        return result.getLine(expressID, flatten);
+    }
+    /**
+     *
+     * @param modelID
+     * @return {Vector<LoaderError>}
+     */
+    GetAndClearErrors(modelID) {
+        Logger.warning("[GetAndClearErrors]: Shim - Unimplemented");
+        const wasmErrorsDummy = {
+            get(index) {
+                // Implementation here
+                return { type: "", message: "", expressID: 0, ifcType: 0 };
+            },
+            size() {
+                // Implementation here
+                return 0;
+            },
+            push() {
+                // eslint-disable-next-line no-useless-return
+                return;
+            },
+        };
+        return wasmErrorsDummy;
+    }
+    /**
+     *
+     * @param modelID
+     * @param lineObject
+     */
+    WriteLine(modelID, lineObject) {
+        Logger.warning("[WriteLine]: Shim - Unimplemented");
+    }
+    /**
+     *
+     * @param modelID
+     * @param line
+     * @return {string | undefined}
+     */
+    FlattenLine(modelID, line) {
+        const result = this.models.get(modelID);
+        if (result === void 0) {
+            Logger.error("[FlattenLine]: model === undefined");
+            return;
+        }
+        return result.flattenLine(line);
+    }
+    /**
+     *
+     * @param modelID
+     * @param expressID
+     * @return {RawLineData}
+     */
+    GetRawLineData(modelID, expressID) {
+        const result = this.models.get(modelID);
+        if (result === void 0) {
+            Logger.error("[GetRawLineData]: model === undefined");
+            return {
+                ID: expressID,
+                type: -1,
+                arguments: ["invalid"],
+            };
+        }
+        return result.getRawLineData(expressID);
+    }
+    /**
+     * Get all line ids with the matching type
+     *
+     * @param modelID
+     * @param type
+     * @return {Vector<number>} The matching express IDs
+     */
+    GetLineIDsWithType(modelID, type) {
+        const result = this.models.get(modelID);
+        if (result === void 0) {
+            Logger.error("[GetLineIDsWithType]: model === undefined");
+            const vectorArray = [];
+            return {
+                get(index) {
+                    // Your implementation here
+                    if (index >= vectorArray.length) {
+                        return -1;
+                    }
+                    return vectorArray[index];
+                },
+                size() {
+                    // Your implementation here
+                    return vectorArray.length;
+                },
+                push(parameter) {
+                    vectorArray.push(parameter);
+                },
+            };
+        }
+        return result.getLineIDsWithType(type);
+    }
+    /**
+     *
+     * @param modelID
+     * @return {Vector<number>}
+     */
+    GetAllLines(modelID) {
+        const result = this.models.get(modelID);
+        if (result === void 0) {
+            Logger.error("[GetAllLines]: model === undefined");
+            const vectorArray = [];
+            return {
+                get(index) {
+                    // Your implementation here
+                    if (index >= vectorArray.length) {
+                        return -1;
+                    }
+                    return vectorArray[index];
+                },
+                size() {
+                    // Your implementation here
+                    return vectorArray.length;
+                },
+                push(parameter) {
+                    vectorArray.push(parameter);
+                },
+            };
+        }
+        return result.getAllLines();
+    }
+    /**
+     *
+     * @param modelID
+     * @param transformationMatrix
+     */
+    setGeometryTransformation(modelID, transformationMatrix) {
+        /* if (transformationMatrix.length != 16) {
+                Logger.error(`Bad transformation matrix size: ${transformationMatrix.length}`)
+                return
+            }
+            this.wasmModule.setGeometryTransformation(modelID, transformationMatrix)*/
+        Logger.warning("[setGeometryTransformation]: Shim - Unimplemented");
+    }
+    /**
+     *
+     * @param modelID
+     * @return {Array<number>}
+     */
+    GetCoordinationMatrix(modelID) {
+        const result = this.models.get(modelID);
+        if (result !== void 0) {
+            return result.getCoordinationMatrix();
+        }
+        const coordinationMatrix = glmatrix.mat4.create();
+        return Array.from(coordinationMatrix);
+    }
+    /**
+     *
+     * @param ptr
+     * @param size
+     * @return {Float32Array}
+     */
+    GetVertexArray(ptr, size) {
+        return this.getSubArray(this.wasmModule.HEAPF32, ptr, size);
+    }
+    /**
+     *
+     * @param ptr
+     * @param size
+     * @return {Uint32Array}
+     */
+    GetIndexArray(ptr, size) {
+        return this.getSubArray(this.wasmModule.HEAPU32, ptr, size);
+    }
+    /**
+     *
+     * @param heap
+     * @param startPtr
+     * @param sizeBytes
+     * @return {Float32Array | Uint32Array}
+     */
+    getSubArray(heap, startPtr, sizeBytes) {
+        // eslint-disable-next-line no-magic-numbers, no-mixed-operators
+        return heap.subarray(startPtr / 4, startPtr / 4 + sizeBytes).slice(0);
+    }
+    /**
+     * Closes a model and frees all related memory
+     *
+     * @param modelID Model handle retrieved by OpenModel, model must not be closed
+     */
+    CloseModel(modelID) {
+        if (this.models.has(modelID) === false) {
+            Logger.error(`[CloseModel]: Model ${modelID} not found`);
+            return;
+        }
+        Logger.info(`[CloseModel]: Closing model ${modelID}`);
+        this.models.delete(modelID);
+        this.conwaywasm.destroy();
+    }
+    /**
+     *
+     * @param modelID
+     * @param meshCallback
+     */
+    StreamAllMeshes(modelID, meshCallback) {
+        const result = this.models.get(modelID);
+        if (result !== void 0) {
+            result.streamAllMeshes(meshCallback);
+        }
+        Logger.displayLogs();
+        Logger.clearLogs();
+        Logger.printStatistics(modelID);
+    }
+    /**
+     *
+     * @param modelID
+     * @param types
+     * @param meshCallback
+     */
+    StreamAllMeshesWithTypes(modelID, types, meshCallback) {
+        const result = this.models.get(modelID);
+        if (result !== void 0) {
+            result.streamAllMeshesWithTypes(types, meshCallback);
+        }
+    }
+    /**
+     * Checks if a specific model ID is open or closed
+     *
+     * @param modelID handle retrieved by OpenModel
+     * @return {boolean}
+     */
+    IsModelOpen(modelID) {
+        if (this.models.has(modelID)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Load all geometry in a model
+     *
+     * @param modelID handle retrieved by OpenModel
+     * @return {Vector<FlatMesh>}
+     */
+    LoadAllGeometry(modelID) {
+        const result = this.models.get(modelID);
+        if (result !== void 0) {
+            return result.loadAllGeometry();
+        }
+        // dummy vars
+        const dummyColor = {
+            x: 0,
+            y: 0,
+            z: 0,
+            w: 0,
+        };
+        // Single PlacedGeometry variable
+        const singlePlacedGeometry = {
+            color: dummyColor,
+            geometryExpressID: 0,
+            flatTransformation: this.identity,
+        };
+        // eslint-disable-next-line no-array-constructor
+        const placedGeometryArray = new Array();
+        // Vector of PlacedGeometry
+        const vectorOfPlacedGeometry = {
+            get(index) {
+                if (index >= placedGeometryArray.length) {
+                    return singlePlacedGeometry;
+                }
+                return placedGeometryArray[index];
+            },
+            size() {
+                return placedGeometryArray.length;
+            },
+            push(parameter) {
+                placedGeometryArray.push(parameter);
+            },
+        };
+        // eslint-disable-next-line no-array-constructor
+        const flatMeshArray = new Array();
+        const flatMeshDummy = {
+            geometries: vectorOfPlacedGeometry,
+            expressID: 0, // replace with actual expressID
+        };
+        // Vector of FlatMesh
+        const vectorOfFlatMesh = {
+            get(index) {
+                if (index >= placedGeometryArray.length) {
+                    return flatMeshDummy;
+                }
+                return flatMeshArray[index];
+            },
+            size() {
+                // Your implementation here
+                return flatMeshArray.length;
+            },
+            push(parameter) {
+                flatMeshArray.push(parameter);
+            },
+        };
+        return vectorOfFlatMesh;
+    }
+    /**
+     * Load geometry for a single element
+     *
+     * @param modelID handle retrieved by OpenModel
+     * @param expressID express ID of flat mesh
+     * @return {FlatMesh}
+     */
+    GetFlatMesh(modelID, expressID) {
+        const result = this.models.get(modelID);
+        if (result !== void 0) {
+            return result.getFlatMesh(expressID);
+        }
+        // Single PlacedGeometry variable
+        const dummyColor = {
+            x: 0,
+            y: 0,
+            z: 0,
+            w: 0,
+        };
+        const singlePlacedGeometry = {
+            color: dummyColor,
+            geometryExpressID: 0,
+            flatTransformation: [ /* your array of numbers here */],
+        };
+        // Vector of PlacedGeometry
+        const vectorOfPlacedGeometry = {
+            get(index) {
+                // Your implementation here
+                return singlePlacedGeometry; // Dummy return, replace with actual implementation
+            },
+            size() {
+                // Your implementation here
+                return 1; // Dummy return, replace with actual implementation
+            },
+            push() {
+                // eslint-disable-next-line no-useless-return
+                return;
+            },
+        };
+        const flatMeshDummy = {
+            geometries: vectorOfPlacedGeometry,
+            expressID: 0, // replace with actual expressID
+        };
+        return flatMeshDummy;
+    }
+    /**
+     * Creates a map between element ExpressIDs and GlobalIDs.
+     * Each element has two entries, (ExpressID -> GlobalID) and (GlobalID -> ExpressID).
+     *
+     * @param modelID handle retrieved by OpenModel
+     */
+    CreateIfcGuidToExpressIdMapping(modelID) {
+        /* const map = new Map<string | number, string | number>()
+    
+            for (let x = 0; x < IfcElements.length; x++) {
+    
+                const type = IfcElements[x]
+                const lines = this.GetLineIDsWithType(modelID, type)
+                const size = lines.size()
+    
+                for (let y = 0; y < size; y++) {
+    
+                    const expressID = lines.get(y)
+                    const info = this.GetLine(modelID, expressID)
+                    const globalID = info.GlobalId.value
+    
+                    map.set(expressID, globalID)
+                    map.set(globalID, expressID)
+                }
+            }
+    
+            this.ifcGuidMap.push(modelID, map)*/
+        Logger.warning(`[CreateIfcGuidToExpressIdMapping]: Model ${modelID}: Shim - Unimplemented`);
+    }
+    /**
+     *
+     * @param path new wasm path
+     * @param absolute is the path absolute?
+     */
+    SetWasmPath(path, absolute = false) {
+        this.wasmPath = path;
+        this.isWasmPathAbsolute = absolute;
+    }
+    // Non web-ifc methods
+    /** The conway version string like "0.23.940-WebMT" */
+    getConwayVersion() {
+        return versionString;
+    }
+    /** @see https://bldrs-ai.github.io/conway/classes/statistics_statistics.Statistics.html */
+    getStatistics(modelID) {
+        return Logger.getStatistics(modelID);
+    }
+}

package/compiled/src/compat/web-ifc/ifc_api.smoke.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ifc_api.smoke.test.d.ts.map

package/compiled/src/compat/web-ifc/ifc_api.smoke.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifc_api.smoke.test.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api.smoke.test.ts"],"names":[],"mappings":""}

package/compiled/src/compat/web-ifc/ifc_api.smoke.test.js

@@ -0,0 +1,88 @@
+/* eslint-disable */
+// Smoke test for the vendored web-ifc compat surface (`IfcAPI`).
+//
+// CI's IFC regression exercises Conway's *native* parse path, never the
+// compat `IfcAPI` shim. This proves the shim actually works end-to-end —
+// open a model, stream geometry, read properties — for the formats Bldrs
+// Share drives through it (IFC + STEP/AP214), and that the AP203→AP214
+// routing added to the passthrough factory is reachable.
+//
+// Boots the wasm the same way src/ifc/ifc_geometry_extraction.test.ts
+// does (no SetWasmPath → default locate handler resolves the conway-geom
+// wasm from the dist). See design/new/web-ifc-compat-surface.md.
+//
+// NOTE: the models are intentionally NOT closed between tests.
+// `IfcAPI.CloseModel` calls `conwaywasm.destroy()` on the single shared
+// ConwayGeometry created in beforeAll, which would tear down the wasm the
+// remaining tests reuse. One wasm lives for the whole file; Jest reaps it
+// when the worker exits.
+import fs from "fs";
+import { describe, expect, test, beforeAll, jest } from "@jest/globals";
+import { IfcAPI } from "./ifc_api.js";
+import Logger from "../../logging/logger.js";
+const SETTINGS = { COORDINATE_TO_ORIGIN: true, USE_FAST_BOOLS: true };
+let api;
+beforeAll(async () => {
+    api = new IfcAPI();
+    await api.Init();
+}, 120000);
+describe("web-ifc compat IfcAPI", () => {
+    test("opens an IFC model, streams geometry, reads properties", async () => {
+        const buffer = new Uint8Array(fs.readFileSync("data/index.ifc"));
+        const modelID = api.OpenModel(buffer, SETTINGS);
+        expect(modelID).toBeGreaterThanOrEqual(0);
+        // Geometry: StreamAllMeshes must emit at least one FlatMesh carrying
+        // at least one PlacedGeometry.
+        let meshCount = 0;
+        let placedGeometryCount = 0;
+        api.StreamAllMeshes(modelID, (mesh) => {
+            meshCount++;
+            placedGeometryCount += mesh.geometries.size();
+        });
+        expect(meshCount).toBeGreaterThan(0);
+        expect(placedGeometryCount).toBeGreaterThan(0);
+        // Properties: the spatial structure resolves to a real IfcProject-rooted
+        // tree (numeric expressID, non-empty children), and item properties for
+        // the root round-trip the same expressID back.
+        const tree = await api.properties.getSpatialStructure(modelID);
+        // getSpatialStructure returns `Node | undefined` (the passthrough is
+        // optional-chained). Narrow it — undefined here is itself a failure.
+        if (tree === undefined) {
+            throw new Error("getSpatialStructure returned undefined for the IFC model");
+        }
+        expect(typeof tree.expressID).toBe("number");
+        expect(Array.isArray(tree.children)).toBe(true);
+        expect(tree.children.length).toBeGreaterThan(0);
+        const rootProps = await api.properties.getItemProperties(modelID, tree.expressID);
+        expect(rootProps.expressID).toBe(tree.expressID);
+    }, 120000);
+    test("opens a STEP (AP214) model and streams geometry", async () => {
+        const buffer = new Uint8Array(fs.readFileSync("data/create-a-tube.step"));
+        const modelID = api.OpenModel(buffer, SETTINGS);
+        expect(modelID).toBeGreaterThanOrEqual(0);
+        let placedGeometryCount = 0;
+        api.StreamAllMeshes(modelID, (mesh) => {
+            placedGeometryCount += mesh.geometries.size();
+        });
+        expect(placedGeometryCount).toBeGreaterThan(0);
+    }, 120000);
+    test("routes an AP203 (CONFIG_CONTROL_DESIGN) model through the AP214 loader", () => {
+        // Validates the AP203→AP214 fall-through added to the passthrough
+        // factory (the standalone adapter had no AP203 case and errored).
+        // OpenModel catches construction errors internally and returns -1, so
+        // it never throws — asserting "doesn't throw" proves nothing. Instead
+        // assert the AP203 branch was actually entered, by spying on the
+        // factory's `Logger.warning('AP203 Step Detected, using AP214 loader')`.
+        // AP203-via-AP214 parse correctness is tracked separately
+        // (step-support.md Phase 4).
+        const buffer = new Uint8Array(fs.readFileSync("data/config-control-design-min.step"));
+        const warnSpy = jest.spyOn(Logger, "warning").mockImplementation(() => { });
+        try {
+            api.OpenModel(buffer, SETTINGS);
+            expect(warnSpy).toHaveBeenCalledWith("AP203 Step Detected, using AP214 loader");
+        }
+        finally {
+            warnSpy.mockRestore();
+        }
+    }, 120000);
+});

package/compiled/src/compat/web-ifc/ifc_api_model_passthrough.d.ts

@@ -0,0 +1,17 @@
+import { FlatMesh, IfcGeometry, RawLineData, Vector } from "./ifc_api.js";
+import { PropertiesPassthrough } from "./properties_passthrough.js";
+export interface IfcApiModelPassthrough {
+    properties: PropertiesPassthrough;
+    getFlatMesh(expressID: number): FlatMesh;
+    loadAllGeometry(): Vector<FlatMesh>;
+    streamAllMeshesWithTypes(types: number[], meshCallback: (mesh: FlatMesh) => void): void;
+    streamAllMeshes(meshCallback: (mesh: FlatMesh) => void): void;
+    getCoordinationMatrix(): number[];
+    getAllLines(): Vector<number>;
+    getLineIDsWithType(type: number): Vector<number>;
+    getRawLineData(expressID: number): RawLineData;
+    flattenLine(line: any): void;
+    getLine(expressID: number, flatten?: boolean): string | void;
+    getGeometry(geometryExpressID: number): IfcGeometry;
+}
+//# sourceMappingURL=ifc_api_model_passthrough.d.ts.map

package/compiled/src/compat/web-ifc/ifc_api_model_passthrough.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifc_api_model_passthrough.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api_model_passthrough.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAA;AAGhE,MAAM,WAAW,sBAAsB;IAErC,UAAU,EAAE,qBAAqB,CAAA;IAEjC,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAA;IACxC,eAAe,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAA;IACnC,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI,CAAA;IACvF,eAAe,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI,CAAA;IAC7D,qBAAqB,IAAI,MAAM,EAAE,CAAA;IACjC,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAAA;IAC7B,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;IAChD,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,CAAA;IAC9C,WAAW,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAAA;IAC5B,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAAA;IAC5D,WAAW,CAAC,iBAAiB,EAAE,MAAM,GAAG,WAAW,CAAA;CACpD"}

package/compiled/src/compat/web-ifc/ifc_api_model_passthrough.js

@@ -0,0 +1 @@
+export {};

package/compiled/src/compat/web-ifc/ifc_api_model_passthrough_factory.d.ts

@@ -0,0 +1,17 @@
+import { Loadersettings } from "./ifc_api.js";
+import { IfcApiModelPassthrough } from "./ifc_api_model_passthrough.js";
+/**
+ * The factory to construct models.
+ */
+export declare class IfcApiModelPassthroughFactory {
+    /**
+     *
+     * @param modelID
+     * @param data
+     * @param wasmModule
+     * @param settings
+     * @return {IfcApiModelPassthrough | undefined}
+     */
+    static from(modelID: number, data: Uint8Array, wasmModule: any, settings?: Loadersettings): IfcApiModelPassthrough | undefined;
+}
+//# sourceMappingURL=ifc_api_model_passthrough_factory.d.ts.map

package/compiled/src/compat/web-ifc/ifc_api_model_passthrough_factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifc_api_model_passthrough_factory.d.ts","sourceRoot":"","sources":["../../../../src/compat/web-ifc/ifc_api_model_passthrough_factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AAKpE;;GAEG;AACH,qBAAa,6BAA6B;IAExC;;;;;;;OAOG;WACW,IAAI,CACd,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,GAAG,EACf,QAAQ,CAAC,EAAE,cAAc,GAAI,sBAAsB,GAAG,SAAS;CA+DpE"}