@ifc-lite/parser 5.2.0 → 6.2.1

package/dist/wasm-init-retry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wasm-init-retry.d.ts","sourceRoot":"","sources":["../src/wasm-init-retry.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAOjE;AA6CD,MAAM,WAAW,oBAAoB;IACnC,qEAAqE;IACrE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,oDAAoD;IACpD,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,sCAAsC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAKD;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EAC5B,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CAgBf"}
+{"version":3,"file":"wasm-init-retry.d.ts","sourceRoot":"","sources":["../src/wasm-init-retry.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,OAAO,EACL,iBAAiB,EACjB,wBAAwB,EACxB,KAAK,oBAAoB,GAC1B,MAAM,0BAA0B,CAAC"}

package/dist/wasm-init-retry.js

@@ -2,105 +2,12 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 /**
- * Resilient one-shot retry around wasm-bindgen's `init()`.
+ * Re-export of the shared WASM load-retry classification (issue #4247).
  *
- * wasm-bindgen's streaming loader rethrows on a non-OK HTTP status or a failed
- * fetch of `ifc-lite_bg.wasm` (it only falls back to `arrayBuffer`+`instantiate`
- * for the wrong-MIME case), surfacing as `TypeError: Failed to execute
- * 'compile' on 'WebAssembly': HTTP status code is not ok`. A transient blip — a
- * cold CDN edge, a mid-deploy race, a flaky proxy/antivirus — can produce a
- * one-off failure that a second attempt recovers.
- *
- * Extracted from the worker so it is unit-testable without a real wasm bundle.
- */
-/**
- * True when `message` looks like a transient transport/download failure of the
- * engine binary (worth one retry) rather than a genuine corrupt-module or
- * validation error (which must propagate immediately so real bugs aren't
- * masked).
- *
- * Per the WebAssembly Web API, the streaming loader validates the HTTP response
- * (status, MIME, CORS) and rejects with a `TypeError` BEFORE compiling, so only
- * those transport failures are retry-worthy. Invalid bytes (corrupt module,
- * wrong magic header) reject with a `CompileError` — retrying just refetches
- * the same bad bytes, so those fail fast.
- */
-export function isTransientWasmLoadError(message) {
-    // Fail fast on genuine module-validation errors even if a transport-ish word
-    // somehow appears in the message.
-    if (/compileerror|validation error|magic (?:word|number)|invalid (?:wasm|module)/i.test(message)) {
-        return false;
-    }
-    return /HTTP status code is not ok|failed to fetch|network ?error|load failed/i.test(message);
-}
-/**
- * A message that already names the thing that failed to load, so re-throwing it
- * with an attribution prefix would only add noise. Deliberately includes
- * `WebAssembly` (the `'compile' on 'WebAssembly'` phrasings) — those are exactly
- * the signatures `isWasmAssetUnavailableError` (wasm-asset-error.ts) matches to
- * drive the #1363 stale-deploy reload, and they must reach it byte-for-byte.
- */
-const SELF_IDENTIFYING = /wasm|webassembly/i;
-/**
- * A failed *module* load already carries its own specifier. Prefixing one with
- * `ifc-lite_bg.wasm` would make it look to that same #1363 matcher like a
- * rotated ENGINE BINARY (`/\.wasm/` + "dynamically imported module") and
- * trigger a spurious page reload, so those are passed through untouched.
- */
-const MODULE_LOAD_FAILURE = /dynamically imported module|module script/i;
-/**
- * Name the engine binary in a transport failure that names nothing (issue #1903).
- *
- * wasm-bindgen's generated loader `await`s the `fetch()` it starts, so a
- * network-level rejection propagates RAW: WebKit words it `TypeError: Load
- * failed`, Chromium `TypeError: Failed to fetch`, and because the rejection
- * originates inside the fetch rather than in our frames it carries an EMPTY
- * stack. Two words and no frames is unattributable by construction — the toast,
- * `classifyLoadError` in the viewer, and error tracking all see a bare
- * `TypeError` that could have come from anywhere in the load.
- *
- * So when the final failure identifies nothing, re-throw it naming the binary
- * and the call site, preserving the original as `.cause`. Anything that already
- * identifies itself is returned unchanged.
- */
-function attributeEngineLoadFailure(error, label) {
-    if (!(error instanceof Error))
-        return error;
-    const msg = error.message;
-    if (!isTransientWasmLoadError(msg))
-        return error;
-    if (SELF_IDENTIFYING.test(msg) || MODULE_LOAD_FAILURE.test(msg))
-        return error;
-    return new Error(`Failed to load the WASM engine binary (ifc-lite_bg.wasm) in ${label}: ${msg}`, { cause: error });
-}
-const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-/**
- * Run `init` once; on a transient-looking failure, wait and retry exactly once.
- * Non-transient failures propagate without a retry. The second failure (if any)
- * propagates to the caller — attributed to the engine binary when the browser's
- * own wording identifies nothing (see {@link attributeEngineLoadFailure}).
- *
- * @param init Thunk that performs the actual `init(...)` call (so callers can
- *   bind their own wasm URL / arguments).
+ * The real implementation lives in `@ifc-lite/wasm-lifecycle` so
+ * `@ifc-lite/geometry` and `@ifc-lite/parser` share exactly one copy of the
+ * transient-vs-fatal WASM load-failure logic instead of maintaining two
+ * independently-editable "twin" files.
  */
-export async function initWasmWithRetry(init, options = {}) {
-    const { retryDelayMs = 300, sleep = defaultSleep, warn = console.warn, label = 'wasm' } = options;
-    try {
-        await init();
-        return;
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (!isTransientWasmLoadError(msg))
-            throw err;
-        warn(`[${label}] WASM engine load failed (${msg}); retrying once`);
-        await sleep(retryDelayMs);
-        try {
-            await init();
-        }
-        catch (retryErr) {
-            throw attributeEngineLoadFailure(retryErr, label);
-        }
-    }
-}
+export { initWasmWithRetry, isTransientWasmLoadError, } from '@ifc-lite/wasm-lifecycle';
 //# sourceMappingURL=wasm-init-retry.js.map

package/dist/wasm-init-retry.js.map

@@ -1 +1 @@
-{"version":3,"file":"wasm-init-retry.js","sourceRoot":"","sources":["../src/wasm-init-retry.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAe;IACtD,6EAA6E;IAC7E,kCAAkC;IAClC,IAAI,8EAA8E,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACjG,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,wEAAwE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAChG,CAAC;AAED;;;;;;GAMG;AACH,MAAM,gBAAgB,GAAG,mBAAmB,CAAC;AAE7C;;;;;GAKG;AACH,MAAM,mBAAmB,GAAG,4CAA4C,CAAC;AAEzE;;;;;;;;;;;;;;GAcG;AACH,SAAS,0BAA0B,CAAC,KAAc,EAAE,KAAa;IAC/D,IAAI,CAAC,CAAC,KAAK,YAAY,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC5C,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC;IAC1B,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IACjD,IAAI,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IAC9E,OAAO,IAAI,KAAK,CACd,+DAA+D,KAAK,KAAK,GAAG,EAAE,EAC9E,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAC;AACJ,CAAC;AAaD,MAAM,YAAY,GAAG,CAAC,EAAU,EAAiB,EAAE,CACjD,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AAEpD;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,IAA4B,EAC5B,UAAgC,EAAE;IAElC,MAAM,EAAE,YAAY,GAAG,GAAG,EAAE,KAAK,GAAG,YAAY,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC;IAClG,IAAI,CAAC;QACH,MAAM,IAAI,EAAE,CAAC;QACb,OAAO;IACT,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,GAAG,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC7D,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC;YAAE,MAAM,GAAG,CAAC;QAC9C,IAAI,CAAC,IAAI,KAAK,8BAA8B,GAAG,kBAAkB,CAAC,CAAC;QACnE,MAAM,KAAK,CAAC,YAAY,CAAC,CAAC;QAC1B,IAAI,CAAC;YACH,MAAM,IAAI,EAAE,CAAC;QACf,CAAC;QAAC,OAAO,QAAQ,EAAE,CAAC;YAClB,MAAM,0BAA0B,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;AACH,CAAC"}
+{"version":3,"file":"wasm-init-retry.js","sourceRoot":"","sources":["../src/wasm-init-retry.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;GAOG;AACH,OAAO,EACL,iBAAiB,EACjB,wBAAwB,GAEzB,MAAM,0BAA0B,CAAC"}

package/dist/wasm-panic-forward.d.ts

@@ -1,67 +1,11 @@
 /**
- * Forward a worker realm's wasm panic-location stash to the main thread
- * (#2527 follow-up).
+ * Re-export of the shared worker-to-main-thread wasm panic-location forwarder
+ * (issue #4247).
  *
- * The Rust panic hook (`rust/wasm-bindings/src/utils.rs`) stashes
- * `{ location, at }` on whichever realm's JS global it runs in — `self` in a
- * worker, `window` on the main thread. #2527 taught the main thread to read
- * its OWN global's stash and attach it to a trap's exception event
- * (`apps/viewer/src/lib/analytics-scrub.ts`'s `attachWasmPanicLocation`), but
- * a worker-realm trap leaves that stash stranded in the worker's global,
- * which the main thread can never see across the realm boundary.
- *
- * `takeWasmPanicStash` reads + consumes the stash worker-side so it can ride
- * the worker's own `{type:'error'}` message; `restashWasmPanicLocation`
- * re-plants it on the main thread's global so the EXISTING #2527 gate (same
- * key, same TTL, same consume-once semantics) picks it up unmodified.
- *
- * Location only, never the panic's message — the message can embed
- * model-derived text (see `utils.rs`'s privacy contract); the location alone
- * travels on the error message and through this module.
- *
- * NOTE: this file is intentionally byte-identical to
- * `packages/geometry/src/wasm-panic-forward.ts` — both `@ifc-lite/geometry`
- * and `@ifc-lite/parser` need the exact same realm-forwarding contract, and
- * neither package depends on the other (nor is `@ifc-lite/wasm`, the one
- * package both DO depend on, a safe home: it ships only the wasm-pack build
- * output, with no TypeScript build step of its own, and `test`/`typecheck`
- * for either consumer already runs its build via turbo's `^build` — adding a
- * hand-written TS module there would make every geometry/parser test run
- * gate on a full Rust→wasm rebuild). Keep any change to one copy in lockstep
- * with the other; `wasm-panic-forward.test.ts` is duplicated the same way.
- */
-/** Kept in lockstep with `PANIC_STASH_KEY` in `rust/wasm-bindings/src/utils.rs`,
- *  `WASM_PANIC_STASH_KEY` in `apps/viewer/src/lib/analytics-scrub.ts`, and this
- *  module's twin at `packages/geometry/src/wasm-panic-forward.ts`. */
-export declare const WASM_PANIC_STASH_KEY = "__ifclite_wasm_panic";
-export interface WasmPanicStash {
-    location: string;
-    at: number;
-}
-/**
- * Worker-side: read and CONSUME this realm's panic stash so it can be
- * forwarded on the worker's own error message. Consume-once regardless of
- * shape validity — an unconsumed malformed stash must not linger to
- * mislabel a later trap, mirroring the main-thread gate's own rule.
- */
-export declare function takeWasmPanicStash(realm: object): WasmPanicStash | undefined;
-/**
- * Main-side: re-plant a worker-forwarded stash on this realm's global so the
- * existing #2527 `attachWasmPanicLocation` gate consumes it unmodified.
- *
- * Gated on `errorMessage` looking like a wasm trap: the worker forwards
- * `wasmPanicLocation`/`wasmPanicAt` on ANY `{type:'error'}` message (a stale
- * stash from an earlier suppressed panic can ride out on an ordinary,
- * non-trap worker error), and re-planting unconditionally would let that
- * stale location sit on `globalThis` until an unrelated trap-shaped
- * exception consumed it — mislabeling that trap. Only a message that itself
- * looks like a wasm trap is allowed to re-plant.
- *
- * Never clobbers an existing, unconsumed stash — a genuine main-thread trap
- * that hasn't been captured yet must win over a worker trap that merely
- * arrived first (the older-looking stash, if stale, is simply dropped later
- * by the TTL check at attach time; this function never overwrites either
- * way).
+ * The real implementation lives in `@ifc-lite/wasm-lifecycle` so
+ * `@ifc-lite/geometry` and `@ifc-lite/parser` share exactly one copy of the
+ * #2527 realm-forwarding contract instead of maintaining two
+ * independently-editable "twin" files.
  */
-export declare function restashWasmPanicLocation(realm: object, location: unknown, at: unknown, errorMessage: string): void;
+export { WASM_PANIC_STASH_KEY, takeWasmPanicStash, restashWasmPanicLocation, type WasmPanicStash, } from '@ifc-lite/wasm-lifecycle';
 //# sourceMappingURL=wasm-panic-forward.d.ts.map

package/dist/wasm-panic-forward.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wasm-panic-forward.d.ts","sourceRoot":"","sources":["../src/wasm-panic-forward.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;sEAEsE;AACtE,eAAO,MAAM,oBAAoB,yBAAyB,CAAC;AAgB3D,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ;AAeD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAK5E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,OAAO,EACjB,EAAE,EAAE,OAAO,EACX,YAAY,EAAE,MAAM,GACnB,IAAI,CAON"}
+{"version":3,"file":"wasm-panic-forward.d.ts","sourceRoot":"","sources":["../src/wasm-panic-forward.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,wBAAwB,EACxB,KAAK,cAAc,GACpB,MAAM,0BAA0B,CAAC"}

package/dist/wasm-panic-forward.js

@@ -2,106 +2,13 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 /**
- * Forward a worker realm's wasm panic-location stash to the main thread
- * (#2527 follow-up).
+ * Re-export of the shared worker-to-main-thread wasm panic-location forwarder
+ * (issue #4247).
  *
- * The Rust panic hook (`rust/wasm-bindings/src/utils.rs`) stashes
- * `{ location, at }` on whichever realm's JS global it runs in — `self` in a
- * worker, `window` on the main thread. #2527 taught the main thread to read
- * its OWN global's stash and attach it to a trap's exception event
- * (`apps/viewer/src/lib/analytics-scrub.ts`'s `attachWasmPanicLocation`), but
- * a worker-realm trap leaves that stash stranded in the worker's global,
- * which the main thread can never see across the realm boundary.
- *
- * `takeWasmPanicStash` reads + consumes the stash worker-side so it can ride
- * the worker's own `{type:'error'}` message; `restashWasmPanicLocation`
- * re-plants it on the main thread's global so the EXISTING #2527 gate (same
- * key, same TTL, same consume-once semantics) picks it up unmodified.
- *
- * Location only, never the panic's message — the message can embed
- * model-derived text (see `utils.rs`'s privacy contract); the location alone
- * travels on the error message and through this module.
- *
- * NOTE: this file is intentionally byte-identical to
- * `packages/geometry/src/wasm-panic-forward.ts` — both `@ifc-lite/geometry`
- * and `@ifc-lite/parser` need the exact same realm-forwarding contract, and
- * neither package depends on the other (nor is `@ifc-lite/wasm`, the one
- * package both DO depend on, a safe home: it ships only the wasm-pack build
- * output, with no TypeScript build step of its own, and `test`/`typecheck`
- * for either consumer already runs its build via turbo's `^build` — adding a
- * hand-written TS module there would make every geometry/parser test run
- * gate on a full Rust→wasm rebuild). Keep any change to one copy in lockstep
- * with the other; `wasm-panic-forward.test.ts` is duplicated the same way.
- */
-/** Kept in lockstep with `PANIC_STASH_KEY` in `rust/wasm-bindings/src/utils.rs`,
- *  `WASM_PANIC_STASH_KEY` in `apps/viewer/src/lib/analytics-scrub.ts`, and this
- *  module's twin at `packages/geometry/src/wasm-panic-forward.ts`. */
-export const WASM_PANIC_STASH_KEY = '__ifclite_wasm_panic';
-/**
- * Trap-shape text match, kept in lockstep with `WASM_TRAP_TEXT` in
- * `apps/viewer/src/lib/analytics-scrub.ts` and this module's twin at
- * `packages/geometry/src/wasm-panic-forward.ts`. Deliberately excludes bare
- * "unreachable" inside network-failure phrasing ("network is unreachable",
- * "host unreachable") — those are not wasm traps.
- */
-const WASM_TRAP_TEXT = /(?<!network is |host |destination |address )\bunreachable\b|\bRuntimeError\b|memory access out of bounds|index out of bounds|indirect call to null|integer (?:overflow|divide by zero)|call stack exhausted/i;
-function looksLikeWasmTrap(message) {
-    return WASM_TRAP_TEXT.test(message);
-}
-/** Validate + narrow an unknown stash value read off a realm global. */
-function readStashShape(value) {
-    if (typeof value !== 'object' || value === null)
-        return undefined;
-    const { location, at } = value;
-    if (typeof location !== 'string' || location === '')
-        return undefined;
-    // Reject non-finite (`NaN`/`Infinity`) and future timestamps — both pass
-    // the analytics TTL gate's `Date.now() - at <= TTL` check trivially
-    // (`Infinity` makes the delta `-Infinity`; a future `at` makes it
-    // negative), which would let a malformed stash label a later trap.
-    if (typeof at !== 'number' || !Number.isFinite(at) || at > Date.now())
-        return undefined;
-    return { location, at };
-}
-/**
- * Worker-side: read and CONSUME this realm's panic stash so it can be
- * forwarded on the worker's own error message. Consume-once regardless of
- * shape validity — an unconsumed malformed stash must not linger to
- * mislabel a later trap, mirroring the main-thread gate's own rule.
- */
-export function takeWasmPanicStash(realm) {
-    const g = realm;
-    const raw = g[WASM_PANIC_STASH_KEY];
-    delete g[WASM_PANIC_STASH_KEY];
-    return readStashShape(raw);
-}
-/**
- * Main-side: re-plant a worker-forwarded stash on this realm's global so the
- * existing #2527 `attachWasmPanicLocation` gate consumes it unmodified.
- *
- * Gated on `errorMessage` looking like a wasm trap: the worker forwards
- * `wasmPanicLocation`/`wasmPanicAt` on ANY `{type:'error'}` message (a stale
- * stash from an earlier suppressed panic can ride out on an ordinary,
- * non-trap worker error), and re-planting unconditionally would let that
- * stale location sit on `globalThis` until an unrelated trap-shaped
- * exception consumed it — mislabeling that trap. Only a message that itself
- * looks like a wasm trap is allowed to re-plant.
- *
- * Never clobbers an existing, unconsumed stash — a genuine main-thread trap
- * that hasn't been captured yet must win over a worker trap that merely
- * arrived first (the older-looking stash, if stale, is simply dropped later
- * by the TTL check at attach time; this function never overwrites either
- * way).
+ * The real implementation lives in `@ifc-lite/wasm-lifecycle` so
+ * `@ifc-lite/geometry` and `@ifc-lite/parser` share exactly one copy of the
+ * #2527 realm-forwarding contract instead of maintaining two
+ * independently-editable "twin" files.
  */
-export function restashWasmPanicLocation(realm, location, at, errorMessage) {
-    const stash = readStashShape({ location, at });
-    if (!stash)
-        return;
-    if (!looksLikeWasmTrap(errorMessage))
-        return;
-    const g = realm;
-    if (g[WASM_PANIC_STASH_KEY] !== undefined)
-        return;
-    g[WASM_PANIC_STASH_KEY] = stash;
-}
+export { WASM_PANIC_STASH_KEY, takeWasmPanicStash, restashWasmPanicLocation, } from '@ifc-lite/wasm-lifecycle';
 //# sourceMappingURL=wasm-panic-forward.js.map

package/dist/wasm-panic-forward.js.map

@@ -1 +1 @@
-{"version":3,"file":"wasm-panic-forward.js","sourceRoot":"","sources":["../src/wasm-panic-forward.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;sEAEsE;AACtE,MAAM,CAAC,MAAM,oBAAoB,GAAG,sBAAsB,CAAC;AAE3D;;;;;;GAMG;AACH,MAAM,cAAc,GAClB,8MAA8M,CAAC;AAEjN,SAAS,iBAAiB,CAAC,OAAe;IACxC,OAAO,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACtC,CAAC;AAOD,wEAAwE;AACxE,SAAS,cAAc,CAAC,KAAc;IACpC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IAClE,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,KAA6C,CAAC;IACvE,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,EAAE;QAAE,OAAO,SAAS,CAAC;IACtE,yEAAyE;IACzE,oEAAoE;IACpE,kEAAkE;IAClE,mEAAmE;IACnE,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE;QAAE,OAAO,SAAS,CAAC;IACxF,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,MAAM,CAAC,GAAG,KAAgC,CAAC;IAC3C,MAAM,GAAG,GAAG,CAAC,CAAC,oBAAoB,CAAC,CAAC;IACpC,OAAO,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC/B,OAAO,cAAc,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,wBAAwB,CACtC,KAAa,EACb,QAAiB,EACjB,EAAW,EACX,YAAoB;IAEpB,MAAM,KAAK,GAAG,cAAc,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/C,IAAI,CAAC,KAAK;QAAE,OAAO;IACnB,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC;QAAE,OAAO;IAC7C,MAAM,CAAC,GAAG,KAAgC,CAAC;IAC3C,IAAI,CAAC,CAAC,oBAAoB,CAAC,KAAK,SAAS;QAAE,OAAO;IAClD,CAAC,CAAC,oBAAoB,CAAC,GAAG,KAAK,CAAC;AAClC,CAAC"}
+{"version":3,"file":"wasm-panic-forward.js","sourceRoot":"","sources":["../src/wasm-panic-forward.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;GAQG;AACH,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,wBAAwB,GAEzB,MAAM,0BAA0B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ifc-lite/parser",
-  "version": "5.2.0",
+  "version": "6.2.1",
   "description": "IFC/STEP parser for IFC-Lite",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,10 +19,11 @@
   "dependencies": {
     "fflate": "^0.8.3",
     "jszip": "^3.10.0",
-    "@ifc-lite/data": "^4.0.0",
+    "@ifc-lite/data": "^4.2.1",
     "@ifc-lite/encoding": "^2.2.0",
-    "@ifc-lite/ifcx": "^4.0.0",
-    "@ifc-lite/wasm": "^6.4.0"
+    "@ifc-lite/wasm": "^8.0.1",
+    "@ifc-lite/wasm-lifecycle": "^0.2.0",
+    "@ifc-lite/ifcx": "^4.1.1"
   },
   "devDependencies": {
     "typescript": "^6.0.3",