@ifc-lite/export 3.0.0 → 3.1.0

package/dist/subset-entity-reader.js

@@ -0,0 +1,102 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+import { getAttributeNamesAcrossSchemas, resolveEntityNameAlias } from '@ifc-lite/parser';
+import { ENTITIES_IFC2X3, ENTITIES_IFC4, ENTITIES_IFC4X3 } from '@ifc-lite/data';
+import { createSourceRefReader, decodeRange } from './source-ref-bounds.js';
+import { splitTopLevelArgs } from './step-argument-parser.js';
+/**
+ * Read entity `id`'s STEP record out of `store`'s source and split it into
+ * its type token and top-level argument list. Returns `null` when the id has
+ * no entry in `index`, or when `index`'s byte range cannot actually be read
+ * out of `store.source` (`createSourceRefReader` — the same gate
+ * `step-pass-builder.ts`'s `isReadableSourceRef` applies), or when the bytes
+ * at that range do not parse as a single `#N=TYPE(...);` record.
+ *
+ * Only reads SOURCE-backed records. An overlay-created entity (no bytes to
+ * decode) is out of scope for this module: `anonymize-placement.ts` and
+ * `anonymize-scrub.ts` only ever walk/mutate the entities a freshly-parsed
+ * source model contains, never ones the private `MutablePropertyView` they
+ * build has itself just created.
+ */
+export function readEntityArgs(store, index, id) {
+    const ref = index.get(id);
+    if (!ref)
+        return null;
+    const isReadable = createSourceRefReader(store.source);
+    if (!isReadable(ref))
+        return null;
+    const line = decodeRange(store.source, ref.byteOffset, ref.byteOffset + ref.byteLength);
+    const match = line.match(/^#\d+\s*=\s*(\w+)\(([\s\S]*)\)\s*;\s*$/);
+    if (!match)
+        return null;
+    const [, type, argsText] = match;
+    return { type: type.toUpperCase(), args: splitTopLevelArgs(argsText) };
+}
+const ATTRIBUTE_NAMES_BY_SCHEMA = {
+    IFC2X3: attributeTableByUpperName(ENTITIES_IFC2X3),
+    IFC4: attributeTableByUpperName(ENTITIES_IFC4),
+    IFC4X3: attributeTableByUpperName(ENTITIES_IFC4X3),
+};
+function attributeTableByUpperName(table) {
+    const map = new Map();
+    for (const entity of table)
+        map.set(entity.name.toUpperCase(), entity.attributes);
+    return map;
+}
+/**
+ * Narrow an `IfcDataStore.schemaVersion` to a {@link SourceStepSchema}
+ * `attrIndex` can resolve against, or `undefined` for anything that isn't
+ * one of the three bundled STEP schemas (`IFC5`, or an absent/unrecognized
+ * value) — callers pass that straight through to `attrIndex`, which then
+ * falls back to the pinned-first cross-schema union exactly as it always did.
+ */
+export function stepSourceSchema(schemaVersion) {
+    return schemaVersion === 'IFC2X3' || schemaVersion === 'IFC4' || schemaVersion === 'IFC4X3'
+        ? schemaVersion
+        : undefined;
+}
+/**
+ * Zero-based positional index of attribute `name` on `type`, or `-1` when
+ * `type` declares no such attribute (an unknown type, or a genuine typo).
+ *
+ * When `schema` is given (the exported model's OWN schema, via
+ * {@link stepSourceSchema}), resolves against THAT schema's table first: the
+ * three bundled schemas do not always agree on a class's attribute order —
+ * e.g. IFC2X3's `IfcApprovalRelationship` puts `Name` at slot 3, IFC4 puts it
+ * at slot 0 — so a caller walking an arbitrary, non-fixed type (anything
+ * `pseudonymizeAllNames` reaches in `anonymize-scrub.ts`) has to resolve
+ * against the source model's actual schema or it silently reads/writes the
+ * wrong slot on every class the schemas disagree about. Falls back to
+ * `getAttributeNamesAcrossSchemas` — the pinned-IFC4-first cross-schema
+ * union this function always used before schema-aware resolution existed —
+ * when `schema` is omitted, or when `schema`'s own table doesn't know `type`
+ * (e.g. an IFC4X3-only class read out of an `IFC4` store).
+ *
+ * A caller that resolves a slot declared on a FIXED, verified-stable type —
+ * `IfcRoot.GlobalId` (slot 0 on every bundled schema), or a literal type
+ * token whose declared order was checked directly against all three
+ * `ENTITIES_*` tables — may omit `schema`: the union answers identically to
+ * a schema-specific lookup for those, and several call sites in
+ * `anonymize-placement.ts` and `anonymize-scrub.ts` do exactly that, each
+ * noting at the call site why its type is fixed rather than caller-supplied.
+ *
+ * WRITE-SIDE PITFALL a caller resolving a slot via this function must not
+ * fall into: `MutablePropertyView.setAttribute(id, name, value)` re-resolves
+ * `name` to a slot by ITS OWN lookup at STEP-serialize time
+ * (`step-attribute-mutations.ts`'s `applyAttributeMutations`), which is not
+ * schema-aware — so an edit queued that way can still land on the wrong slot
+ * even after reading the right one here. Write with
+ * `MutablePropertyView.setPositionalAttribute(id, index, value)` and this
+ * function's resolved `index` instead; `anonymize-scrub.ts` does exactly
+ * that for every slot it resolves through a `schema` argument (#3309).
+ */
+export function attrIndex(type, name, schema) {
+    if (schema) {
+        const names = ATTRIBUTE_NAMES_BY_SCHEMA[schema].get(resolveEntityNameAlias(type).toUpperCase());
+        if (names)
+            return names.indexOf(name);
+    }
+    return getAttributeNamesAcrossSchemas(type).indexOf(name);
+}
+//# sourceMappingURL=subset-entity-reader.js.map

package/dist/subset-entity-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subset-entity-reader.js","sourceRoot":"","sources":["../src/subset-entity-reader.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAmB/D,OAAO,EAAE,8BAA8B,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,eAAe,EAAsB,MAAM,gBAAgB,CAAC;AACrG,OAAO,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAiB9D;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,cAAc,CAC5B,KAA0C,EAC1C,KAA2B,EAC3B,EAAU;IAEV,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC1B,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,CAAC;IACtB,MAAM,UAAU,GAAG,qBAAqB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACvD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAElC,MAAM,IAAI,GAAG,WAAW,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC;IACxF,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC;IACnE,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,MAAM,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,GAAG,KAAK,CAAC;IACjC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,IAAI,EAAE,iBAAiB,CAAC,QAAQ,CAAC,EAAE,CAAC;AACzE,CAAC;AAWD,MAAM,yBAAyB,GAA+E;IAC5G,MAAM,EAAE,yBAAyB,CAAC,eAAe,CAAC;IAClD,IAAI,EAAE,yBAAyB,CAAC,aAAa,CAAC;IAC9C,MAAM,EAAE,yBAAyB,CAAC,eAAe,CAAC;CACnD,CAAC;AAEF,SAAS,yBAAyB,CAAC,KAA+B;IAChE,MAAM,GAAG,GAAG,IAAI,GAAG,EAA6B,CAAC;IACjD,KAAK,MAAM,MAAM,IAAI,KAAK;QAAE,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;IAClF,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,aAAiC;IAChE,OAAO,aAAa,KAAK,QAAQ,IAAI,aAAa,KAAK,MAAM,IAAI,aAAa,KAAK,QAAQ;QACzF,CAAC,CAAC,aAAa;QACf,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY,EAAE,IAAY,EAAE,MAAyB;IAC7E,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,KAAK,GAAG,yBAAyB,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;QAChG,IAAI,KAAK;YAAE,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,8BAA8B,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAC5D,CAAC"}

package/dist/subset-roots.d.ts

@@ -0,0 +1,58 @@
+import type { EffectiveEntityIndex } from './effective-index.js';
+/**
+ * Every `IfcRoot` descendant across the three bundled schemas (IFC2X3, IFC4,
+ * IFC4X3), UPPERCASE — the set of types a subset export ever needs to
+ * classify as "included" or "excluded". `IfcRoot` itself is abstract and
+ * never instantiated, so it is not a member (same convention as
+ * `PRODUCT_TYPES` not containing `IFCPRODUCT`).
+ *
+ * Derived from the generated schema tables via `collectDescendantNames`
+ * rather than hand-listed, for the same reason `PRODUCT_TYPES` is: a
+ * hand-written list silently stops matching the schema the day it changes,
+ * and a subset export that fails to classify a genuinely-rooted entity type
+ * would either leak it (never excluded) or drop it (never includable) with
+ * no error.
+ */
+export declare const IFC_ROOT_TYPES: ReadonlySet<string>;
+/**
+ * Entity types that identify the SOURCE model or its authoring context
+ * rather than the geometry a bug reproduction needs — addresses and
+ * georeferencing. None of these are `IfcRoot` descendants (they carry no
+ * `GlobalId`), so `IFC_ROOT_TYPES` alone would never exclude them; a subset
+ * export must name them separately or a caller's included wall still drags
+ * its `IfcSite`'s `IfcPostalAddress` / `IfcMapConversion` chain along for the
+ * ride purely because nothing else in the closure competes for that #id.
+ *
+ * `IFCACTORROLE` is here for the same reason, one level removed: it hangs
+ * off `IfcPerson`/`IfcOrganization` (owner history), not off a spatial
+ * entity, but it is exactly as identifying — a role like "Structural
+ * Engineer, ACME Consulting" — and equally unreachable through
+ * `IFC_ROOT_TYPES`.
+ */
+export declare const IDENTIFYING_TYPES: ReadonlySet<string>;
+/** What a `subsetEntityIds` export needs from `step-collection.ts`'s closure tail. */
+export interface SubsetEntityIds {
+    /** Seed set for `collectReferencedEntityIds`: infrastructure plus every
+     *  caller-included id that actually exists in `index`. */
+    readonly roots: Set<number>;
+    /** Every `IfcRoot`/`IDENTIFYING_TYPES` id NOT in `includedIds` — passed as
+     *  `pass.hiddenProductIds` so the existing `visibleOnly` dangling-ref
+     *  protection (`evaluateOmissionPredicates` +
+     *  `filterHiddenRefsFromRelationshipLine`) covers a subset export too. */
+    readonly excludedIds: Set<number>;
+}
+/**
+ * Classify every entity in `index` for a `subsetEntityIds` export: a root
+ * (infrastructure, always; or a caller-included id), an excluded id (an
+ * `IfcRoot`/identifying-type id the caller did NOT include), or neither (left
+ * to the forward closure walk to decide, same as `visibleOnly`'s "all other
+ * entity types" fallthrough).
+ *
+ * Runs over the EFFECTIVE index — `pass.effective`, not `dataStore` — for the
+ * same reason `getVisibleEntityIds` does: an overlay-created entity has no
+ * source record for a dataStore-only scan to find, a retyped entity must be
+ * classified by its new class, and a tombstoned one must not appear at all
+ * (`EffectiveEntityIndex` iteration already skips it).
+ */
+export declare function getSubsetEntityIds(index: EffectiveEntityIndex, includedIds: ReadonlySet<number>): SubsetEntityIds;
+//# sourceMappingURL=subset-roots.d.ts.map

package/dist/subset-roots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subset-roots.d.ts","sourceRoot":"","sources":["../src/subset-roots.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAGjE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,CAAoB,CAAC;AAUpE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAQhD,CAAC;AAEH,sFAAsF;AACtF,MAAM,WAAW,eAAe;IAC9B;8DAC0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B;;;8EAG0E;IAC1E,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACnC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,oBAAoB,EAC3B,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAC/B,eAAe,CA2BjB"}

package/dist/subset-roots.js

@@ -0,0 +1,103 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+/**
+ * The root classification for a `subsetEntityIds` STEP export (#2934, the
+ * "anonymized isolated export" feature): which entities the caller's
+ * `includedIds` selection may legally seed, and which entities must be
+ * excluded outright regardless of whether the closure walk would otherwise
+ * reach them.
+ *
+ * Mirrors `reference-collector.ts`'s `getVisibleEntityIds` in shape — both
+ * produce a `{ roots, excludeIds }` pair `step-collection.ts` feeds to the
+ * same `collectReferencedEntityIds` + `collectStyleEntities` tail — but the
+ * classification rule is the opposite of `visibleOnly`'s. `visibleOnly`
+ * starts from "everything is a root unless hidden"; a subset export starts
+ * from "nothing is a root unless named", because the caller is picking a
+ * handful of entities out of a whole model, not hiding a handful out of it.
+ */
+import { ENTITIES_IFC2X3, ENTITIES_IFC4, ENTITIES_IFC4X3, } from '@ifc-lite/data';
+import { INFRASTRUCTURE_TYPES, collectDescendantNames } from './reference-collector.js';
+/**
+ * Every `IfcRoot` descendant across the three bundled schemas (IFC2X3, IFC4,
+ * IFC4X3), UPPERCASE — the set of types a subset export ever needs to
+ * classify as "included" or "excluded". `IfcRoot` itself is abstract and
+ * never instantiated, so it is not a member (same convention as
+ * `PRODUCT_TYPES` not containing `IFCPRODUCT`).
+ *
+ * Derived from the generated schema tables via `collectDescendantNames`
+ * rather than hand-listed, for the same reason `PRODUCT_TYPES` is: a
+ * hand-written list silently stops matching the schema the day it changes,
+ * and a subset export that fails to classify a genuinely-rooted entity type
+ * would either leak it (never excluded) or drop it (never includable) with
+ * no error.
+ */
+export const IFC_ROOT_TYPES = buildRootTypes();
+function buildRootTypes() {
+    const roots = new Set();
+    for (const table of [ENTITIES_IFC2X3, ENTITIES_IFC4, ENTITIES_IFC4X3]) {
+        collectDescendantNames(table, 'IfcRoot', roots);
+    }
+    return roots;
+}
+/**
+ * Entity types that identify the SOURCE model or its authoring context
+ * rather than the geometry a bug reproduction needs — addresses and
+ * georeferencing. None of these are `IfcRoot` descendants (they carry no
+ * `GlobalId`), so `IFC_ROOT_TYPES` alone would never exclude them; a subset
+ * export must name them separately or a caller's included wall still drags
+ * its `IfcSite`'s `IfcPostalAddress` / `IfcMapConversion` chain along for the
+ * ride purely because nothing else in the closure competes for that #id.
+ *
+ * `IFCACTORROLE` is here for the same reason, one level removed: it hangs
+ * off `IfcPerson`/`IfcOrganization` (owner history), not off a spatial
+ * entity, but it is exactly as identifying — a role like "Structural
+ * Engineer, ACME Consulting" — and equally unreachable through
+ * `IFC_ROOT_TYPES`.
+ */
+export const IDENTIFYING_TYPES = new Set([
+    'IFCPOSTALADDRESS',
+    'IFCTELECOMADDRESS',
+    'IFCMAPCONVERSION',
+    'IFCMAPCONVERSIONSCALED',
+    'IFCPROJECTEDCRS',
+    'IFCGEOGRAPHICCRS',
+    'IFCACTORROLE',
+]);
+/**
+ * Classify every entity in `index` for a `subsetEntityIds` export: a root
+ * (infrastructure, always; or a caller-included id), an excluded id (an
+ * `IfcRoot`/identifying-type id the caller did NOT include), or neither (left
+ * to the forward closure walk to decide, same as `visibleOnly`'s "all other
+ * entity types" fallthrough).
+ *
+ * Runs over the EFFECTIVE index — `pass.effective`, not `dataStore` — for the
+ * same reason `getVisibleEntityIds` does: an overlay-created entity has no
+ * source record for a dataStore-only scan to find, a retyped entity must be
+ * classified by its new class, and a tombstoned one must not appear at all
+ * (`EffectiveEntityIndex` iteration already skips it).
+ */
+export function getSubsetEntityIds(index, includedIds) {
+    const roots = new Set();
+    const excludedIds = new Set();
+    for (const [expressId, entityRef] of index) {
+        const typeUpper = index.effectiveType(expressId, entityRef.type);
+        if (INFRASTRUCTURE_TYPES.has(typeUpper)) {
+            roots.add(expressId);
+            continue;
+        }
+        if (includedIds.has(expressId)) {
+            roots.add(expressId);
+            continue;
+        }
+        if (IFC_ROOT_TYPES.has(typeUpper) || IDENTIFYING_TYPES.has(typeUpper)) {
+            excludedIds.add(expressId);
+        }
+        // Everything else (geometry, relationships, property atoms, materials,
+        // …) is neither a root nor excluded here — the forward closure walk from
+        // `roots` decides whether it survives, exactly as `visibleOnly`'s
+        // fallthrough does.
+    }
+    return { roots, excludedIds };
+}
+//# sourceMappingURL=subset-roots.js.map

package/dist/subset-roots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subset-roots.js","sourceRoot":"","sources":["../src/subset-roots.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,eAAe,EACf,aAAa,EACb,eAAe,GAChB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAExF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,cAAc,GAAwB,cAAc,EAAE,CAAC;AAEpE,SAAS,cAAc;IACrB,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAChC,KAAK,MAAM,KAAK,IAAI,CAAC,eAAe,EAAE,aAAa,EAAE,eAAe,CAAC,EAAE,CAAC;QACtE,sBAAsB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAwB,IAAI,GAAG,CAAC;IAC5D,kBAAkB;IAClB,mBAAmB;IACnB,kBAAkB;IAClB,wBAAwB;IACxB,iBAAiB;IACjB,kBAAkB;IAClB,cAAc;CACf,CAAC,CAAC;AAcH;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAA2B,EAC3B,WAAgC;IAEhC,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAChC,MAAM,WAAW,GAAG,IAAI,GAAG,EAAU,CAAC;IAEtC,KAAK,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,IAAI,KAAK,EAAE,CAAC;QAC3C,MAAM,SAAS,GAAG,KAAK,CAAC,aAAa,CAAC,SAAS,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QAEjE,IAAI,oBAAoB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YACxC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACrB,SAAS;QACX,CAAC;QAED,IAAI,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/B,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACrB,SAAS;QACX,CAAC;QAED,IAAI,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,iBAAiB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YACtE,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC7B,CAAC;QACD,uEAAuE;QACvE,yEAAyE;QACzE,kEAAkE;QAClE,oBAAoB;IACtB,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;AAChC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ifc-lite/export",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Export formats for IFC-Lite",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,16 +16,16 @@
     "parquet-wasm": "^0.7.2",
     "apache-arrow": "^21.2.0",
     "jszip": "^3.10.0",
-    "@ifc-lite/geometry": "^4.0.0",
-    "@ifc-lite/data": "^3.4.1",
+    "@ifc-lite/geometry": "^4.1.0",
     "@ifc-lite/encoding": "^2.1.0",
-    "@ifc-lite/parser": "^4.3.0",
-    "@ifc-lite/mutations": "^1.27.0"
+    "@ifc-lite/parser": "^4.3.2",
+    "@ifc-lite/mutations": "^1.27.0",
+    "@ifc-lite/data": "^3.5.1"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
-    "vitest": "^4.1.10",
-    "@ifc-lite/ifcx": "^3.0.0"
+    "vitest": "^4.1.11",
+    "@ifc-lite/ifcx": "^3.0.1"
   },
   "license": "MPL-2.0",
   "author": "Louis True",