@bldrs-ai/conway 0.13.802 → 0.15.836

package/compiled/src/ifc/ifc_regression_batch_main.js

@@ -5,36 +5,63 @@ import childProcess from 'child_process';
 import { promisify } from 'util';
 import path from 'path';
 import crypto from 'crypto';
+import os from 'os';
+import pLimit from 'p-limit';
 const errorCSVHeader = 'message,count,expressids,file';
 const exec = promisify(childProcess.exec);
+/* eslint-disable require-await */
 /**
- * Safe execute a process command
+ * Safe execute a process command with cancellation support.
  *
- * @param command The command to run
- * @return {ExecException | { type: 'Success', stdout: string, stderr: string }}
+ * @param command The command to run.
+ * @param timeoutMs Number of milliseconds to wait before timing out.
+ * @return {Promise<RunErrorResults | { type: 'Success', stdout: string, stderr: string }>}
  */
-async function safeExec(command) {
-    try {
-        const result = await exec(command, { maxBuffer: STD_OUT_ERR_MAX_BUFFER });
-        return {
-            type: 'Success',
-            stdout: result.stdout,
-            stderr: result.stderr,
-        };
-    }
-    catch (err) {
-        const errResult = err;
-        return {
-            type: 'Failed',
-            name: errResult.name,
-            message: errResult.message,
-            code: errResult.code,
-            cmd: errResult.cmd,
-            signal: errResult.signal,
-            killed: errResult.killed,
-        };
-    }
+async function safeExecWithCancellation(command, timeoutMs) {
+    return new Promise((resolve) => {
+        // Start the child process using childProcess.exec
+        const child = childProcess.exec(command, { maxBuffer: STD_OUT_ERR_MAX_BUFFER }, (err, stdout, stderr) => {
+            // If the process finishes before the timeout, clear the timer...
+            clearTimeout(timeoutHandle);
+            if (err) {
+                const errResult = err;
+                resolve({
+                    type: 'Failed',
+                    name: errResult.name,
+                    message: errResult.message,
+                    code: errResult.code,
+                    cmd: errResult.cmd,
+                    signal: errResult.signal,
+                    killed: errResult.killed,
+                });
+            }
+            else {
+                resolve({
+                    type: 'Success',
+                    stdout,
+                    stderr,
+                });
+            }
+        });
+        // Set up the timeout promise.
+        const timeoutHandle = setTimeout(() => {
+            // Timeout occurred: kill the child process.
+            child.kill();
+            resolve({
+                type: 'Failed',
+                name: 'TimeoutError',
+                message: 'Execution timed out',
+                cmd: command,
+                killed: true,
+            });
+        }, timeoutMs);
+        // When the child exits naturally, clear the timeout.
+        child.on('exit', () => {
+            clearTimeout(timeoutHandle);
+        });
+    });
 }
+/* eslint-enable require-await */
 const SKIP_PARAMS = 2;
 // eslint-disable-next-line no-magic-numbers
 const STD_OUT_ERR_MAX_BUFFER = 64 * 1024 * 1024;
@@ -76,40 +103,43 @@ function csvSafeStringFileNames(from) {
 /**
  * Run the git diff
  *
- * @param outputFolder
- * @param target
- * @param diffOutputPath
- * @param isDryRun
+ * @param ifcFolder    The folder we want to `cd` into before running git
+ * @param outputFolder The folder containing outputs that we compare
+ * @param target       The Git diff target (branch, commit, etc.)
+ * @param diffOutputPath Where we store the CSV diff results (no extension)
+ * @param isDryRun     If true, reverts changes via git checkout after diff
  */
-async function runDiff(outputFolder, target, diffOutputPath, isDryRun) {
+async function runDiff(ifcFolder, outputFolder, target, diffOutputPath, isDryRun) {
     const diffOutputFolder = path.dirname(path.resolve(diffOutputPath));
     await fsPromises.mkdir(diffOutputFolder, { recursive: true });
-    const process = await exec(`git diff -r --numstat --minimal ${target} -- ${outputFolder}`, { maxBuffer: STD_OUT_ERR_MAX_BUFFER });
-    const csvDiff = `Added,Removed,File\n${process.stdout.split('\n').map((line) => line.split('\t').map(csvSafeStringFileNames).join(',')).join('\n')}`;
+    console.log(`ifcFolder: ${ifcFolder}`);
+    // 1) Change `cwd` to `ifcFolder`, so we "cd ifcFolder" before running git
+    const processResult = await exec(`git diff -r --numstat --minimal ${target} -- ${outputFolder}`, {
+        maxBuffer: STD_OUT_ERR_MAX_BUFFER,
+        cwd: ifcFolder, // <-- This causes the exec to run in ifcFolder
+    });
+    const csvDiff = `Added,Removed,File\n${processResult.stdout
+        .split('\n')
+        .map((line) => line.split('\t').map(csvSafeStringFileNames).join(','))
+        .join('\n')}`;
     await fsPromises.writeFile(`${diffOutputPath}.csv`, csvDiff);
     if (isDryRun) {
-        await exec(`git checkout -- "${outputFolder}"`);
+        // 2) Also run the checkout in the same `cwd` context
+        await exec(`git checkout -- "${outputFolder}"`, { cwd: ifcFolder });
     }
 }
 let totalTime = 0; // To keep track of the running total time
 /**
  * Run a regression test digest for a file.
  */
-async function runForFile(filePath, outputPath) {
-    const MAX_TIMEOUT_MS = 180000; // 3 minutes
+async function runForFile(filePath, outputPath, maxTimeout) {
+    const MAX_TIMEOUT_MS = maxTimeout;
     const startTime = Date.now(); // Start time
     // eslint-disable-next-line max-len
     const safeExecCommand = `node --experimental-specifier-resolution=node ./compiled/src/ifc/ifc_regression_main.js -d "${filePath}" "${outputPath}"`;
     console.log(`Current File: ${filePath}`);
-    const processPromise = safeExec(safeExecCommand);
-    const timeoutPromise = new Promise((resolve) => setTimeout(() => {
-        resolve({
-            type: 'Failed',
-            message: 'Execution timed out',
-            name: '',
-        });
-    }, MAX_TIMEOUT_MS));
-    const process = await Promise.race([processPromise, timeoutPromise]);
+    // Use safeExecWithCancellation, will kill the process if it takes longer than MAX_TIMEOUT_MS.
+    const process = await safeExecWithCancellation(safeExecCommand, MAX_TIMEOUT_MS);
     totalTime += Date.now() - startTime;
     console.log(`totalTime: ${totalTime}`);
     if (process.type === 'Failed') {
@@ -144,8 +174,122 @@ async function runForFile(filePath, outputPath) {
         hash: fileHash,
     };
 }
-const args = // eslint-disable-line no-unused-vars
- yargs(process.argv.slice(SKIP_PARAMS))
+/**
+ * Recursively collect all IFC file paths (instead of processing them immediately).
+ */
+async function collectIFCFiles(parentPath, excludeRegex) {
+    const ifcFiles = [];
+    /**
+     * Recursively walk ifc files
+     */
+    // eslint-disable-next-line no-shadow, require-jsdoc
+    async function recursiveWalk(currentPath) {
+        const items = await fsPromises.readdir(currentPath, { withFileTypes: true });
+        items.sort((a, b) => (a.name > b.name ? 1 : -1));
+        for (const item of items) {
+            const resolved = path.join(currentPath, item.name);
+            if (excludeRegex && excludeRegex.test(resolved)) {
+                continue;
+            }
+            if (item.isDirectory()) {
+                await recursiveWalk(resolved);
+            }
+            else if (path.extname(resolved).toLowerCase() === '.ifc') {
+                ifcFiles.push(resolved);
+            }
+        }
+    }
+    await recursiveWalk(parentPath);
+    return ifcFiles;
+}
+/**
+ * @return {number} percentage of memory used on machine
+ */
+function getSystemMemoryUsagePercent() {
+    const total = os.totalmem(); // total system memory in bytes
+    const free = os.freemem(); // free system memory in bytes
+    const used = total - free;
+    /* eslint-disable no-magic-numbers */
+    console.log(`total: ${total / 1000 / 1000 / 1000} GB - ` +
+        `used: ${used / 1000 / 1000 / 1000} GB - ` +
+        `free: ${free / 1000 / 1000 / 1000} GB`);
+    return (used / total) * 100;
+    /* eslint-enable no-magic-numbers */
+}
+/**
+ * Parallel processing, using p-limit to limit concurrency to number of CPU cores.
+ */
+async function processIFCFilesInParallel(ifcFiles, outputPath, errorLines, fileLines, failedLines, memUtilization, maxTimeout) {
+    const concurrencyLimit = os.cpus().length;
+    console.log(`Concurrency: ${concurrencyLimit} threads - Max Timeout: ${maxTimeout} ms`);
+    const limit = pLimit(concurrencyLimit);
+    const taskTimeout = 2000;
+    let activeTasks = 0;
+    // Create an array of task promises using map (without awaiting immediately)
+    const tasks = ifcFiles.map((ifcPath) => limit(async () => {
+        // Wait if system memory usage is above 95%
+        while (getSystemMemoryUsagePercent() > memUtilization) {
+            console.log(`Memory usage > ${memUtilization}%, waiting 2s...`);
+            await new Promise((resolve) => setTimeout(resolve, taskTimeout));
+        }
+        activeTasks++;
+        console.log(`Starting task for "${path.basename(ifcPath)}". Active tasks: ${activeTasks}`);
+        const fileResults = await runForFile(ifcPath, path.join(outputPath, path.basename(ifcPath, '.ifc')), maxTimeout);
+        activeTasks--;
+        console.log(`Completed task for "${path.basename(ifcPath)}". Active tasks: ${activeTasks}`);
+        return { ifcPath, fileResults };
+    }));
+    // Wait for all tasks to complete in parallel
+    const results = await Promise.all(tasks);
+    // Aggregate results
+    for (const { ifcPath, fileResults } of results) {
+        if (fileResults.type === 'Run') {
+            if (fileResults.errorLines) {
+                errorLines.push(...fileResults.errorLines);
+            }
+            fileLines.push(`${csvSafeString(path.basename(ifcPath))},` +
+                `${csvSafeString(fileResults.hash ?? '')},` +
+                `${fileResults.errorLines?.length ?? 0}\n`);
+        }
+        else {
+            // it's 'Failed'
+            failedLines.push(`${csvSafeString(path.basename(ifcPath))},` +
+                `${csvSafeString(fileResults.code?.toString() ?? '')},` +
+                `${csvSafeString(fileResults.signal ?? '')}\n`);
+        }
+    }
+}
+// The original recursive approach (unchanged, except it won't be used if -parallel is set)
+/**
+ *
+ */
+async function recursiveWalk(parentPath, excludeRegex, outputPath, errorLines, fileLines, failedLines, maxTimeout) {
+    const items = await fsPromises.readdir(parentPath, { withFileTypes: true });
+    items.sort((a, b) => (a.name > b.name ? 1 : -1));
+    for (const item of items) {
+        const resolved = path.join(parentPath, item.name);
+        if (excludeRegex && excludeRegex.test(resolved)) {
+            continue;
+        }
+        if (item.isDirectory()) {
+            await recursiveWalk(resolved, excludeRegex, outputPath, errorLines, fileLines, failedLines, maxTimeout);
+        }
+        else if (path.extname(resolved).toLowerCase() === '.ifc') {
+            const fileResults = await runForFile(resolved, path.join(outputPath, path.basename(resolved, '.ifc')), maxTimeout);
+            if (fileResults.type === 'Run') {
+                if (fileResults.errorLines !== void 0) {
+                    errorLines.push(...fileResults.errorLines);
+                }
+                fileLines.push(`${csvSafeString(path.basename(resolved))},${csvSafeString(fileResults.hash ?? '')},${fileResults.errorLines?.length ?? 0}\n`);
+            }
+            else {
+                failedLines.push(`${csvSafeString(path.basename(resolved))},${csvSafeString(fileResults.code?.toString() ?? '')},${csvSafeString(fileResults.signal ?? '')}\n`);
+            }
+        }
+    }
+}
+// eslint-disable-next-line no-unused-vars
+const args = yargs(process.argv.slice(SKIP_PARAMS))
     .command('$0 <model_folder> <output_folder>', 'Regression test', (yargs2) => {
     yargs2.option('target', {
         describe: 'Git diff target',
@@ -160,34 +304,70 @@ const args = // eslint-disable-line no-unused-vars
         default: false,
     });
     yargs2.option('changes', {
-        describe: 'Custom output location for the diff output (filepath, should include ' +
-            'file name but not extension, the folder will be created if it doesn\'t exist',
+        describe: 
+        // eslint-disable-next-line max-len
+        'Custom output location for the diff output (filepath, should include file name but not extension, the folder will be created if it doesn\'t exist)',
         type: 'string',
         alias: 'c',
         default: '',
     });
     yargs2.option('exclude', {
-        describe: 'An file-path exclusion regex filter (javascript syntax)',
+        describe: 'A file-path exclusion regex filter (javascript syntax)',
         type: 'string',
         alias: 'e',
         default: '',
     });
+    yargs2.option('parallel', {
+        describe: 'Process IFC files in parallel (limited by CPU cores)',
+        type: 'boolean',
+        alias: 'p',
+        default: false,
+    });
+    // only relevant if parallel is enabled
+    yargs2.option('mem-utilization', {
+        // eslint-disable-next-line max-len
+        describe: 'Memory utilization threshold percentage for parallel processing (1-100, default: 95)',
+        type: 'number',
+        alias: 'm',
+        default: 95,
+    });
+    // Validate mem-utilization only if parallel mode is active
+    yargs2.check((argv) => {
+        if (argv.parallel) {
+            const memUtil = argv['mem-utilization'];
+            // eslint-disable-next-line no-magic-numbers
+            if (typeof memUtil !== 'number' || memUtil < 1 || memUtil > 100) {
+                throw new Error('mem-utilization must be a number between 1 and 100');
+            }
+        }
+        return true;
+    });
+    yargs2.option('timeout', {
+        describe: 'IFC per-file loading timeout in ms (default: 150000)',
+        type: 'number',
+        alias: 'timeout',
+        default: 150000,
+    });
     yargs2.positional('model_folder', {
-        describe: 'The folder containing IFC files, which will be walked recursively',
-        type: 'string'
+        describe: 'Folder containing IFC files, recursively walked',
+        type: 'string',
     });
     yargs2.positional('output_folder', {
-        // eslint-disable-next-line max-len
-        describe: 'The folder is where manifests and output artefacts, with the potential exception of changes/diff output',
-        type: 'string'
+        describe: 'Folder for manifests/output artifacts (diff CSV goes here unless overridden)',
+        type: 'string',
     });
 }, async (argv) => {
+    // ---- New: record overall start time
+    const overallStart = Date.now();
     const ifcFolder = argv['model_folder'];
     const outputPath = argv['output_folder'];
     let changes = argv['changes'] ?? '';
     const target = argv['target'] ?? '';
     const dryRun = argv['dryrun'] ?? false;
     const excludeFilter = argv['exclude'] ?? '';
+    const doParallel = argv['parallel'] ?? false; // <--- read the parallel flag
+    const memUtilization = argv['mem-utilization'];
+    const maxTimeout = argv['timeout'];
     if (changes.length === 0) {
         changes = path.join(outputPath, 'changes');
     }
@@ -198,53 +378,30 @@ const args = // eslint-disable-line no-unused-vars
     const errorLines = [];
     const fileLines = [];
     const failedLines = [];
-    const excludeRegex = excludeFilter.length > 0 ? new RegExp(excludeFilter) : void 0;
-    const isExcluded = excludeRegex !== void 0 ?
-        ((testPath) => excludeRegex?.test(testPath)) :
-        (testPath) => false;
-    const recursiveWalk = async (parentPath) => {
-        const items = await fsPromises.readdir(parentPath, { withFileTypes: true });
-        items.sort((a, b) => a.name > b.name ? 1 : -1);
-        for (const item of items) {
-            const relativePath = path.join(parentPath, item.name);
-            if (isExcluded(relativePath)) {
-                continue;
-            }
-            const resolved = path.resolve(parentPath, item.name);
-            if (item.isDirectory()) {
-                await recursiveWalk(resolved);
-            }
-            else if (path.extname(resolved) === '.ifc') {
-                const fileResults = await runForFile(resolved, path.join(outputPath, path.basename(resolved, '.ifc')));
-                if (fileResults.type === 'Run') {
-                    if (fileResults.errorLines !== void 0) {
-                        errorLines.push(...fileResults.errorLines);
-                    }
-                    // eslint-disable-next-line max-len
-                    fileLines.push(`${csvSafeString(path.basename(resolved))},${csvSafeString(fileResults.hash ?? '')},${errorLines.length}\n`);
-                }
-                else {
-                    // eslint-disable-next-line max-len
-                    failedLines.push(`${csvSafeString(path.basename(resolved))},${csvSafeString(fileResults.code?.toString() ?? '')},${csvSafeString(fileResults.signal ?? '')}\n`);
-                }
-            }
-        }
-    };
-    await recursiveWalk(ifcFolder);
-    const manifestFile = await fsPromises.open(mainPath, 'w');
-    await manifestFile.writeFile('file,hash,errors\n');
-    await manifestFile.writeFile(fileLines);
-    await manifestFile.close();
-    const errorFile = await fsPromises.open(errorPath, 'w');
-    await errorFile.writeFile(`${errorCSVHeader}\n`);
-    await errorFile.writeFile(errorLines);
-    await errorFile.close();
-    const failedFile = await fsPromises.open(failedPath, 'w');
-    await failedFile.writeFile('file,code,signal\n');
-    await failedFile.writeFile(failedLines);
-    await failedFile.close();
-    await runDiff(outputPath, target, changes, dryRun);
-    // TODO(@nickcastel50) - figure out why this hangs at the end sometimes
-    process.exit(0);
+    const excludeRegex = excludeFilter.length > 0 ? new RegExp(excludeFilter) : undefined;
+    if (doParallel) {
+        console.log('Processing in parallel mode...');
+        // 1) Collect all IFC files first
+        const allIFCFiles = await collectIFCFiles(ifcFolder, excludeRegex);
+        // 2) Process them in parallel
+        await processIFCFilesInParallel(allIFCFiles, outputPath, errorLines, fileLines, failedLines, memUtilization, maxTimeout);
+    }
+    else {
+        console.log('Processing in serial mode...');
+        // eslint-disable-next-line max-len
+        await recursiveWalk(ifcFolder, excludeRegex, outputPath, errorLines, fileLines, failedLines, maxTimeout);
+    }
+    // Write out results
+    await fsPromises.writeFile(mainPath, `file,hash,errors\n${fileLines.join('')}`);
+    await fsPromises.writeFile(errorPath, `${errorCSVHeader}\n${errorLines.join('')}`);
+    await fsPromises.writeFile(failedPath, `file,code,signal\n${failedLines.join('')}`);
+    // If user wants a git diff
+    await runDiff(ifcFolder, outputPath, target, changes, dryRun);
+    // ---- New: log total runtime
+    const divisor = 1000;
+    const fixedPoint = 2;
+    const overallEnd = Date.now();
+    const totalSec = ((overallEnd - overallStart) / divisor).toFixed(fixedPoint);
+    console.log(`\nAll tasks completed. Total runtime: ${totalSec} seconds.`);
 })
     .help().argv;

package/compiled/src/ifc/ifc_step_model.d.ts

@@ -25,7 +25,6 @@ export default class IfcStepModel extends StepModelBase<EntityTypesIfc> {
      * Construct this model given a buffer containing the data and the parsed data index on that,
      * adding the typeIndex on top of that.
      *
-     * @param wasmModule
      * @param buffer The buffer to values from.
      * @param elementIndex The parsed index to elements in the STEP.
      */

package/compiled/src/ifc/ifc_step_model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ifc_step_model.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_model.ts"],"names":[],"mappings":"AAAA,OAAO,cAAqC,MAAM,iCAAiC,CAAA;AACnF,OAAO,aAAa,MAAM,yBAAyB,CAAA;AAEnD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAA;AAE1D,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,sBAAsB,MAAM,6BAA6B,CAAA;AAChE,OAAO,cAAc,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAKvD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,aAAa,CAAE,cAAc,CAAE;IAEvE,SAAgB,SAAS,EAAE,aAAa,CAAE,cAAc,CAAE,CAAA;IAC1D,SAAgB,mBAAmB,gCAAyB;IAC5D,SAAgB,QAAQ,mBAA+B;IACvD,SAAgB,YAAY,mBAAqC;IACjE,SAAgB,QAAQ,kBAA4B;IACpD,SAAgB,MAAM,iBAA2B;IACjD,SAAgB,aAAa,iBAAuB;IACpD,SAAgB,SAAS,mBAA+B;IACxD,SAAgB,aAAa,mBAAqC;IAElE;;;;;;;OAOG;gBAEC,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,cAAc,CAAE,cAAc,CAAE,EAAE;CAKrD"}
+{"version":3,"file":"ifc_step_model.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_model.ts"],"names":[],"mappings":"AAAA,OAAO,cAAqC,MAAM,iCAAiC,CAAA;AACnF,OAAO,aAAa,MAAM,yBAAyB,CAAA;AAEnD,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAA;AAE1D,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,sBAAsB,MAAM,6BAA6B,CAAA;AAChE,OAAO,cAAc,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAKvD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,aAAa,CAAE,cAAc,CAAE;IAEvE,SAAgB,SAAS,EAAE,aAAa,CAAE,cAAc,CAAE,CAAA;IAC1D,SAAgB,mBAAmB,gCAAyB;IAC5D,SAAgB,QAAQ,mBAA+B;IACvD,SAAgB,YAAY,mBAAqC;IACjE,SAAgB,QAAQ,kBAA4B;IACpD,SAAgB,MAAM,iBAA2B;IACjD,SAAgB,aAAa,iBAAuB;IACpD,SAAgB,SAAS,mBAA+B;IACxD,SAAgB,aAAa,mBAAqC;IAElE;;;;;;OAMG;gBAEC,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,cAAc,CAAE,cAAc,CAAE,EAAE;CAKrD"}

package/compiled/src/ifc/ifc_step_model.js

@@ -17,7 +17,6 @@ export default class IfcStepModel extends StepModelBase {
      * Construct this model given a buffer containing the data and the parsed data index on that,
      * adding the typeIndex on top of that.
      *
-     * @param wasmModule
      * @param buffer The buffer to values from.
      * @param elementIndex The parsed index to elements in the STEP.
      */

package/compiled/src/ifc/ifc_step_parser.d.ts

@@ -20,7 +20,6 @@ export default class IfcStepParser extends StepParser<EntityTypesIfc> {
     /**
      * Parse data to the model
      *
-     * @param wasmModule A conway-geom wasm module environnment for this.
      * @param input The parsing buffer, set to user data, to read.
      * @return {[ParseResult, IfcStepModel | undefined]} The parse result as well as the model,
      * if it can be extracted.

package/compiled/src/ifc/ifc_step_parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ifc_step_parser.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_parser.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,2BAA2B,CAAA;AACrD,OAAO,UAAU,EAAE,EAAC,WAAW,EAAC,MAAM,6BAA6B,CAAA;AACnE,OAAO,cAAc,MAAM,iCAAiC,CAAA;AAE5D,OAAO,YAAY,MAAM,kBAAkB,CAAA;AAE3C;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU,CAAE,cAAc,CAAE;IACrE;;OAEG;;IAKH;;;;;OAKG;IACH,gBAAuB,QAAQ,gBAAsB;IAErD;;;;;;;OAOG;IACI,gBAAgB,CACnB,KAAK,EAAE,aAAa,GAAI,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC;CAKpE"}
+{"version":3,"file":"ifc_step_parser.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_step_parser.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,2BAA2B,CAAA;AACrD,OAAO,UAAU,EAAE,EAAC,WAAW,EAAC,MAAM,6BAA6B,CAAA;AACnE,OAAO,cAAc,MAAM,iCAAiC,CAAA;AAE5D,OAAO,YAAY,MAAM,kBAAkB,CAAA;AAE3C;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU,CAAE,cAAc,CAAE;IACrE;;OAEG;;IAKH;;;;;OAKG;IACH,gBAAuB,QAAQ,gBAAsB;IAErD;;;;;;OAMG;IACI,gBAAgB,CACnB,KAAK,EAAE,aAAa,GAAI,CAAC,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC;CAKpE"}

package/compiled/src/ifc/ifc_step_parser.js

@@ -14,7 +14,6 @@ export default class IfcStepParser extends StepParser {
     /**
      * Parse data to the model
      *
-     * @param wasmModule A conway-geom wasm module environnment for this.
      * @param input The parsing buffer, set to user data, to read.
      * @return {[ParseResult, IfcStepModel | undefined]} The parse result as well as the model,
      * if it can be extracted.

package/compiled/src/version/version.js

@@ -1,2 +1,2 @@
-const versionString = 'Conway Web-Ifc Shim v0.13.802';
+const versionString = 'Conway Web-Ifc Shim v0.15.836';
 export { versionString };