@bitbybit-dev/ifc 0.0.0-stage → 1.5.0-rc.0

package/lib/geometry/swept-solids.js

@@ -0,0 +1,243 @@
+import { axesToMatrix, vectorToWorld } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { pathTangents, roundedPath3, sweepMatrices, transportedAxes } from "@bitbybit-dev/base/lib/api/services/helpers/paths";
+import { cross3, dot3, length3, scale3, subtract3 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import { PARALLEL_TOLERANCE } from "../build/constants";
+import { axisPlacementFrame, directionOf, pointOf } from "../build/placement";
+import { radiansPerUnit } from "../build/project";
+import { isReference } from "../step/values";
+import { arcSegments } from "./curves";
+import { UnsupportedGeometryError } from "./errors";
+import { profileRegion } from "./profiles";
+import { profileNode, regionSolid } from "./regions";
+import { FULL_TURN, IDENTITY_MATRIX, PARAMETER_RATIO, PYRAMID_TRIANGLES, TURN_SLACK, Y_TO_Z } from "./swept-solids.constants";
+const Z_AXIS = [0, 0, 1];
+const NO_AXIS = [0, 0, 0];
+function squared(vector, to) {
+    const across = subtract3(vector, scale3(to, dot3(vector, to)));
+    const length = length3(across);
+    return length > PARALLEL_TOLERANCE ? scale3(across, 1 / length) : undefined;
+}
+function moved(offset) {
+    return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, offset[0], offset[1], offset[2], 1];
+}
+export class SweptSolids {
+    constructor(model, builder, curves) {
+        this.model = model;
+        this.builder = builder;
+        this.curves = curves;
+    }
+    revolved(item) {
+        const region = this.region(item, "SweptArea");
+        const axis = this.model.attribute(item, "Axis");
+        if (!isReference(axis)) {
+            throw new UnsupportedGeometryError(`#${item} has no axis`);
+        }
+        const origin = pointOf(this.model, this.model.attribute(axis.ref, "Location"));
+        const direction = directionOf(this.model, this.model.attribute(axis.ref, "Axis"), Z_AXIS);
+        const length = length3(direction);
+        if (!(length > 0) || Math.abs(direction[2]) > PARALLEL_TOLERANCE * length || Math.abs(origin[2]) > PARALLEL_TOLERANCE * Math.max(1, length3(origin))) {
+            throw new UnsupportedGeometryError(`#${item} turns about an axis outside its profile's plane`);
+        }
+        const turn = this.number(item, "Angle") * radiansPerUnit(this.model);
+        const sign = Math.sign(turn);
+        const angle = Math.min(Math.abs(turn), FULL_TURN);
+        if (!(angle > 0) || Math.abs(turn) > FULL_TURN * (1 + TURN_SLACK)) {
+            throw new UnsupportedGeometryError(`#${item} turns by an angle that is not above zero and at most a whole turn`);
+        }
+        const solid = regionSolid(this.builder, region, this.flat(item, (profile) => this.builder.node({
+            op: "revolve", profile, origin: [origin[0], origin[1]], direction: [sign * direction[0], sign * direction[1]], angle,
+        })));
+        return this.placed(item, solid);
+    }
+    tapered(item) {
+        const start = this.region(item, "SweptArea");
+        const end = this.region(item, "EndSweptArea");
+        const depth = this.number(item, "Depth");
+        if (depth === 0) {
+            throw new UnsupportedGeometryError(`#${item} has no depth`);
+        }
+        const direction = directionOf(this.model, this.model.attribute(item, "ExtrudedDirection"), Z_AXIS);
+        const along = scale3(direction, depth / length3(direction));
+        if (!(Math.abs(along[2]) > PARALLEL_TOLERANCE * Math.abs(depth))) {
+            throw new UnsupportedGeometryError(`#${item} tapers along its profile's plane`);
+        }
+        const frames = this.builder.numbers([...IDENTITY_MATRIX, ...moved(along)]);
+        const loft = (first, second) => this.builder.node({ op: "loft", profiles: [first, second], frames });
+        return this.placed(item, this.taperBetween(item, start, end, loft));
+    }
+    sweptDisk(item, polygonal) {
+        const radius = this.number(item, "Radius");
+        const inner = this.model.attribute(item, "InnerRadius") === null ? 0 : this.number(item, "InnerRadius");
+        if (!(radius > 0) || !(inner >= 0) || !(inner < radius)) {
+            throw new UnsupportedGeometryError(`#${item} has a radius that is not above zero or an inner radius not inside it`);
+        }
+        let points = this.sweptPath(item);
+        const fillet = polygonal && this.model.attribute(item, "FilletRadius") !== null ? this.number(item, "FilletRadius") : 0;
+        if (fillet > 0) {
+            points = roundedPath3(points, fillet, arcSegments);
+        }
+        const tangents = pathTangents(points, ...this.endsOf(item));
+        const frames = this.builder.numbers(sweepMatrices(points, tangents, transportedAxes(points, tangents, NO_AXIS)).flat());
+        const loft = (size) => this.builder.node({ op: "loft", profiles: [this.builder.node({ op: "circle", center: [0, 0], radius: size })], frames });
+        const solid = loft(radius);
+        return inner > 0 ? this.builder.node({ op: "difference", of: solid, tools: [loft(inner)] }) : solid;
+    }
+    areaSweep(item, fixed) {
+        const region = this.region(item, "SweptArea");
+        const points = this.sweptPath(item);
+        const tangents = pathTangents(points, ...this.endsOf(item));
+        const axes = fixed ? this.fixedAxes(item, tangents) : this.surfaceAxes(item, points, tangents, region);
+        const frames = this.builder.numbers(sweepMatrices(points, tangents, axes).flat());
+        const solid = regionSolid(this.builder, region, this.flat(item, (profile) => this.builder.node({ op: "loft", profiles: [profile], frames })));
+        return this.placed(item, solid);
+    }
+    primitive(item, type) {
+        switch (type) {
+            case "IfcBlock": {
+                const [x, y, z] = [this.number(item, "XLength"), this.number(item, "YLength"), this.number(item, "ZLength")];
+                const profile = this.builder.node({ op: "polygon", points: this.builder.numbers([0, 0, x, 0, x, y, 0, y]), holes: [] });
+                return this.placed(item, this.builder.node({ op: "extrude", profile, direction: Z_AXIS, depth: z }));
+            }
+            case "IfcRightCircularCylinder": {
+                const profile = this.builder.node({ op: "circle", center: [0, 0], radius: this.number(item, "Radius") });
+                return this.placed(item, this.builder.node({ op: "extrude", profile, direction: Z_AXIS, depth: this.number(item, "Height") }));
+            }
+            case "IfcRightCircularCone": {
+                const [radius, height] = [this.number(item, "BottomRadius"), this.number(item, "Height")];
+                const profile = this.builder.node({ op: "polygon", points: this.builder.numbers([0, 0, radius, 0, 0, height]), holes: [] });
+                const cone = this.builder.node({ op: "revolve", profile, origin: [0, 0], direction: [0, 1], angle: FULL_TURN });
+                return this.placed(item, this.builder.node({ op: "transform", of: cone, matrix: Y_TO_Z }));
+            }
+            case "IfcSphere": {
+                const radius = this.number(item, "Radius");
+                const segments = arcSegments(Math.PI);
+                const half = Array.from({ length: segments + 1 }, (_, at) => {
+                    const angle = -Math.PI / 2 + (Math.PI * at) / segments;
+                    return [radius * Math.cos(angle), radius * Math.sin(angle)];
+                }).flat();
+                const profile = this.builder.node({ op: "polygon", points: this.builder.numbers(half), holes: [] });
+                return this.placed(item, this.builder.node({ op: "revolve", profile, origin: [0, 0], direction: [0, 1], angle: FULL_TURN }));
+            }
+            default:
+                return this.placed(item, this.pyramid(item));
+        }
+    }
+    pyramid(item) {
+        const [x, y, height] = [this.number(item, "XLength"), this.number(item, "YLength"), this.number(item, "Height")];
+        const positions = [0, 0, 0, x, 0, 0, x, y, 0, 0, y, 0, x / 2, y / 2, height];
+        return this.builder.node({ op: "triangles", positions: this.builder.numbers(positions), indices: this.builder.indices(PYRAMID_TRIANGLES) });
+    }
+    taperBetween(item, start, end, loft) {
+        if (start.kind === "circle" && end.kind === "circle") {
+            const outer = loft(profileNode(this.builder, start), profileNode(this.builder, end));
+            if (!(start.innerRadius > 0) && !(end.innerRadius > 0)) {
+                return outer;
+            }
+            if (!(start.innerRadius > 0) || !(end.innerRadius > 0)) {
+                throw new UnsupportedGeometryError(`#${item} tapers between a hollow and a solid circle`);
+            }
+            const inner = loft(profileNode(this.builder, start, start.innerRadius), profileNode(this.builder, end, end.innerRadius));
+            return this.builder.node({ op: "difference", of: outer, tools: [inner] });
+        }
+        if (start.kind !== "polygon" || end.kind !== "polygon" || start.plane !== undefined || end.plane !== undefined) {
+            throw new UnsupportedGeometryError(`#${item} tapers between profiles of different kinds, which is not supported yet`);
+        }
+        return loft(profileNode(this.builder, start), profileNode(this.builder, end));
+    }
+    fixedAxes(item, tangents) {
+        const reference = directionOf(this.model, this.model.attribute(item, "FixedReference"), [1, 0, 0]);
+        return tangents.map((tangent) => {
+            const axis = squared(reference, tangent);
+            if (axis === undefined) {
+                throw new UnsupportedGeometryError(`#${item} has a fixed reference along its directrix`);
+            }
+            return axis;
+        });
+    }
+    surfaceAxes(item, points, tangents, region) {
+        const surface = this.model.attribute(item, "ReferenceSurface");
+        const type = isReference(surface) ? this.model.entity(surface.ref).type : "";
+        const normalAt = this.surfaceNormal(isReference(surface) ? surface.ref : 0, type);
+        if (normalAt === undefined) {
+            if (region.kind === "circle" && region.center[0] === 0 && region.center[1] === 0) {
+                return transportedAxes(points, tangents, NO_AXIS);
+            }
+            throw new UnsupportedGeometryError(`A sweep on an ${type || "unnamed"} reference surface is not supported yet`);
+        }
+        return tangents.map((tangent) => {
+            const axis = squared(normalAt(tangent), tangent);
+            if (axis === undefined) {
+                throw new UnsupportedGeometryError(`#${item}'s directrix runs along the normal of its reference surface`);
+            }
+            return axis;
+        });
+    }
+    surfaceNormal(surface, type) {
+        const position = surface === 0 ? null : this.model.attribute(surface, "Position");
+        const frame = isReference(position) ? axisPlacementFrame(this.model, position.ref) : undefined;
+        if (type === "IfcPlane" && frame) {
+            return () => frame.z;
+        }
+        if (type !== "IfcSurfaceOfLinearExtrusion") {
+            return undefined;
+        }
+        const direction = directionOf(this.model, this.model.attribute(surface, "ExtrudedDirection"), Z_AXIS);
+        const extruded = frame ? vectorToWorld(frame, direction) : direction;
+        return (tangent) => cross3(tangent, extruded);
+    }
+    endsOf(item) {
+        const directrix = this.model.attribute(item, "Directrix");
+        return isReference(directrix) ? this.curves.endTangents(directrix.ref) : [undefined, undefined];
+    }
+    sweptPath(item) {
+        const directrix = this.model.attribute(item, "Directrix");
+        if (!isReference(directrix)) {
+            throw new UnsupportedGeometryError(`#${item} has no directrix`);
+        }
+        const points = this.curves.path(directrix.ref);
+        if (points.length < 2) {
+            throw new UnsupportedGeometryError(`#${item} sweeps along a directrix of no length`);
+        }
+        const start = this.model.attribute(item, "StartParam");
+        const end = this.model.attribute(item, "EndParam");
+        if (start === null && end === null) {
+            return points;
+        }
+        const span = this.curves.parameterSpan(directrix.ref);
+        const from = typeof start === "number" ? start : 0;
+        const to = typeof end === "number" ? end : span;
+        if (span !== undefined && to !== undefined && Math.abs(to - from - span) <= PARAMETER_RATIO * Math.max(1, span)) {
+            return points;
+        }
+        throw new UnsupportedGeometryError(`#${item} sweeps along part of its directrix, which is not supported yet`);
+    }
+    flat(item, make) {
+        return (profile, part) => {
+            if (part.kind === "polygon" && part.plane !== undefined) {
+                throw new UnsupportedGeometryError(`#${item} sweeps a profile written off its own plane`);
+            }
+            return make(profile);
+        };
+    }
+    region(item, name) {
+        const area = this.model.attribute(item, name);
+        if (!isReference(area)) {
+            throw new UnsupportedGeometryError(`#${item} has no ${name}`);
+        }
+        return profileRegion(this.model, area.ref, this.curves);
+    }
+    number(item, name) {
+        const value = this.model.attribute(item, name);
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+            throw new UnsupportedGeometryError(`#${item} has no finite ${name}`);
+        }
+        return value;
+    }
+    placed(item, solid) {
+        const position = this.model.attribute(item, "Position");
+        if (!isReference(position)) {
+            return solid;
+        }
+        return this.builder.node({ op: "transform", of: solid, matrix: axesToMatrix(axisPlacementFrame(this.model, position.ref)) });
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./api/inputs";
+export * from "./api/ifc-service";
+export * from "./api/services";
+export * from "./api/dto-registry";
+export * as Resolved from "./api/resolved-inputs";
+export * from "./model";

package/lib/index.js

@@ -0,0 +1,6 @@
+export * from "./api/inputs";
+export * from "./api/ifc-service";
+export * from "./api/services";
+export * from "./api/dto-registry";
+export * as Resolved from "./api/resolved-inputs";
+export * from "./model";

package/lib/model/constants.d.ts

@@ -0,0 +1,30 @@
+export declare const GUID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_$";
+export declare const GUID_BYTES = 16;
+export declare const BYTE_RANGE = 256;
+export declare const FIRST_BYTE_DIGITS = 2;
+export declare const THREE_BYTE_DIGITS = 4;
+export declare const BYTES_PER_GROUP = 3;
+export declare const HASH_BYTES_USED = 6;
+export declare const VERSION_BYTE = 6;
+export declare const VERSION_MASK = 15;
+export declare const VERSION_BITS = 64;
+export declare const VARIANT_BYTE = 8;
+export declare const VARIANT_MASK = 63;
+export declare const VARIANT_BITS = 128;
+export declare const KEY_DOMAIN = "key";
+export declare const AUTOMATIC_DOMAIN = "automatic";
+export declare const STRUCTURE_DOMAIN = "structure";
+export declare const PROJECT_KEY = "project";
+export declare const TRIE_BITS = 5;
+export declare const TRIE_WIDTH: number;
+export declare const TRIE_MASK: number;
+export declare const TRIE_LEVELS = 7;
+export declare const PRUNABLE_TYPES: readonly ["IfcRepresentation", "IfcRepresentationItem", "IfcProductRepresentation", "IfcObjectPlacement", "IfcProfileDef", "IfcMaterialUsageDefinition", "IfcRepresentationMap", "IfcPropertySetDefinition", "IfcProperty", "IfcPhysicalQuantity"];
+export declare const LONGEST_STRING: number;
+export declare const TEXT_PER_CHUNK: number;
+export declare const LINE_BREAK = "\n";
+export declare const WINDOWS_LINE_BREAK = "\r\n";
+export declare const LINE_FEED = 10;
+export declare const CARRIAGE_RETURN = 13;
+export declare const IFC_EXTENSION = ".ifc";
+export declare const ARCHIVE_RESOURCE_FOLDER = "__MACOSX/";

package/lib/model/constants.js

@@ -0,0 +1,30 @@
+export const GUID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_$";
+export const GUID_BYTES = 16;
+export const BYTE_RANGE = 256;
+export const FIRST_BYTE_DIGITS = 2;
+export const THREE_BYTE_DIGITS = 4;
+export const BYTES_PER_GROUP = 3;
+export const HASH_BYTES_USED = 6;
+export const VERSION_BYTE = 6;
+export const VERSION_MASK = 0x0f;
+export const VERSION_BITS = 0x40;
+export const VARIANT_BYTE = 8;
+export const VARIANT_MASK = 0x3f;
+export const VARIANT_BITS = 0x80;
+export const KEY_DOMAIN = "key";
+export const AUTOMATIC_DOMAIN = "automatic";
+export const STRUCTURE_DOMAIN = "structure";
+export const PROJECT_KEY = "project";
+export const TRIE_BITS = 5;
+export const TRIE_WIDTH = Math.pow(2, TRIE_BITS);
+export const TRIE_MASK = TRIE_WIDTH - 1;
+export const TRIE_LEVELS = 7;
+export const PRUNABLE_TYPES = ["IfcRepresentation", "IfcRepresentationItem", "IfcProductRepresentation", "IfcObjectPlacement", "IfcProfileDef", "IfcMaterialUsageDefinition", "IfcRepresentationMap", "IfcPropertySetDefinition", "IfcProperty", "IfcPhysicalQuantity"];
+export const LONGEST_STRING = Math.pow(2, 29) - 24;
+export const TEXT_PER_CHUNK = Math.pow(2, 24);
+export const LINE_BREAK = "\n";
+export const WINDOWS_LINE_BREAK = "\r\n";
+export const LINE_FEED = 0x0a;
+export const CARRIAGE_RETURN = 0x0d;
+export const IFC_EXTENSION = ".ifc";
+export const ARCHIVE_RESOURCE_FOLDER = "__MACOSX/";

package/lib/model/entity-lookup.d.ts

@@ -0,0 +1,9 @@
+import type { IfcSchema } from "../schema/schema";
+import type { IfcEntity, IfcValue } from "../step/step-types";
+export declare abstract class EntityLookup {
+    abstract readonly schema: IfcSchema;
+    abstract get(id: number): IfcEntity | undefined;
+    entity(id: number): IfcEntity;
+    attribute(id: number, name: string): IfcValue;
+    valueOf(entity: IfcEntity, name: string): IfcValue;
+}

package/lib/model/entity-lookup.js

@@ -0,0 +1,20 @@
+export class EntityLookup {
+    entity(id) {
+        const entity = this.get(id);
+        if (!entity) {
+            throw new Error(`The model has no entity #${id}`);
+        }
+        return entity;
+    }
+    attribute(id, name) {
+        return this.valueOf(this.entity(id), name);
+    }
+    valueOf(entity, name) {
+        var _a;
+        const position = this.schema.entity(entity.type).positions.get(name);
+        if (position === undefined) {
+            throw new Error(`${entity.type} has no attribute ${name}`);
+        }
+        return (_a = entity.args[position]) !== null && _a !== void 0 ? _a : null;
+    }
+}

package/lib/model/guid.d.ts

@@ -0,0 +1,7 @@
+export declare function isGlobalId(text: string): boolean;
+export declare function compressBytes(bytes: Uint8Array): string;
+export declare function randomGlobalId(): string;
+export declare function projectGlobalId(seed: string): string;
+export declare function keyGlobalId(seed: string, key: string): string;
+export declare function automaticGlobalId(seed: string, counter: string): string;
+export declare function structureGlobalId(seed: string, name: string): string;

package/lib/model/guid.js

@@ -0,0 +1,60 @@
+import { hashOfText } from "@bitbybit-dev/base";
+import { GLOBAL_ID_PATTERN } from "../schema/constants";
+import { AUTOMATIC_DOMAIN, BYTES_PER_GROUP, BYTE_RANGE, FIRST_BYTE_DIGITS, GUID_ALPHABET, GUID_BYTES, HASH_BYTES_USED, KEY_DOMAIN, PROJECT_KEY, STRUCTURE_DOMAIN, THREE_BYTE_DIGITS, VARIANT_BITS, VARIANT_BYTE, VARIANT_MASK, VERSION_BITS, VERSION_BYTE, VERSION_MASK, } from "./constants";
+const RADIX = GUID_ALPHABET.length;
+function digits(value, count) {
+    let out = "";
+    let rest = value;
+    for (let index = 0; index < count; index++) {
+        out = GUID_ALPHABET[rest % RADIX] + out;
+        rest = Math.floor(rest / RADIX);
+    }
+    return out;
+}
+function stamped(bytes) {
+    const out = Uint8Array.from(bytes);
+    out[VERSION_BYTE] = (out[VERSION_BYTE] & VERSION_MASK) | VERSION_BITS;
+    out[VARIANT_BYTE] = (out[VARIANT_BYTE] & VARIANT_MASK) | VARIANT_BITS;
+    return out;
+}
+function seeded(seed, key) {
+    const bytes = new Uint8Array(GUID_BYTES);
+    for (let part = 0, at = 0; at < GUID_BYTES; part++) {
+        let hash = hashOfText(`${seed}\u0000${key}\u0000${part}`);
+        for (let index = 0; index < HASH_BYTES_USED && at < GUID_BYTES; index++, at++) {
+            bytes[at] = hash % BYTE_RANGE;
+            hash = Math.floor(hash / BYTE_RANGE);
+        }
+    }
+    return compressBytes(stamped(bytes));
+}
+export function isGlobalId(text) {
+    return GLOBAL_ID_PATTERN.test(text);
+}
+export function compressBytes(bytes) {
+    if (bytes.length !== GUID_BYTES) {
+        throw new RangeError(`A GlobalId holds ${GUID_BYTES} bytes, got ${bytes.length}`);
+    }
+    let out = digits(bytes[0], FIRST_BYTE_DIGITS);
+    for (let index = 1; index < GUID_BYTES; index += BYTES_PER_GROUP) {
+        out += digits(bytes[index] * BYTE_RANGE * BYTE_RANGE + bytes[index + 1] * BYTE_RANGE + bytes[index + 2], THREE_BYTE_DIGITS);
+    }
+    return out;
+}
+export function randomGlobalId() {
+    const bytes = new Uint8Array(GUID_BYTES);
+    globalThis.crypto.getRandomValues(bytes);
+    return compressBytes(stamped(bytes));
+}
+export function projectGlobalId(seed) {
+    return seeded(seed, PROJECT_KEY);
+}
+export function keyGlobalId(seed, key) {
+    return seeded(seed, `${KEY_DOMAIN}\u0000${key}`);
+}
+export function automaticGlobalId(seed, counter) {
+    return seeded(seed, `${AUTOMATIC_DOMAIN}\u0000${counter}`);
+}
+export function structureGlobalId(seed, name) {
+    return seeded(seed, `${STRUCTURE_DOMAIN}\u0000${name}`);
+}

package/lib/model/id-map.d.ts

@@ -0,0 +1,10 @@
+export declare class IdMap<V> {
+    readonly size: number;
+    private readonly root;
+    private constructor();
+    static empty<V>(): IdMap<V>;
+    get(id: number): V | undefined;
+    has(id: number): boolean;
+    withChanges(changes: Iterable<readonly [number, V | undefined]>): IdMap<V>;
+    forEach(each: (value: V, id: number) => void): void;
+}

package/lib/model/id-map.js

@@ -0,0 +1,80 @@
+import { TRIE_LEVELS, TRIE_MASK, TRIE_WIDTH } from "./constants";
+function slotAt(id, level) {
+    return Math.floor(id / Math.pow(TRIE_WIDTH, level)) & TRIE_MASK;
+}
+function writable(node, level, owner) {
+    if ((node === null || node === void 0 ? void 0 : node.owner) === owner) {
+        return node;
+    }
+    if (!node) {
+        return level === 0 ? { owner, children: [], values: new Array(TRIE_WIDTH) } : { owner, children: new Array(TRIE_WIDTH), values: [] };
+    }
+    return { owner, children: level === 0 ? node.children : node.children.slice(), values: level === 0 ? node.values.slice() : node.values };
+}
+function valueAt(root, id) {
+    let node = root;
+    for (let level = TRIE_LEVELS - 1; level > 0 && node; level--) {
+        node = node.children[slotAt(id, level)];
+    }
+    return node === null || node === void 0 ? void 0 : node.values[id & TRIE_MASK];
+}
+function visit(node, level, prefix, each) {
+    for (let slot = 0; slot < TRIE_WIDTH; slot++) {
+        const id = prefix * TRIE_WIDTH + slot;
+        if (level === 0) {
+            const value = node.values[slot];
+            if (value !== undefined) {
+                each(value, id);
+            }
+        }
+        else {
+            const child = node.children[slot];
+            if (child) {
+                visit(child, level - 1, id, each);
+            }
+        }
+    }
+}
+export class IdMap {
+    constructor(root, size) {
+        this.root = root;
+        this.size = size;
+    }
+    static empty() {
+        return new IdMap(undefined, 0);
+    }
+    get(id) {
+        return valueAt(this.root, id);
+    }
+    has(id) {
+        return this.get(id) !== undefined;
+    }
+    withChanges(changes) {
+        const owner = {};
+        let root = this.root;
+        let size = this.size;
+        for (const [id, value] of changes) {
+            if (value === undefined && valueAt(root, id) === undefined) {
+                continue;
+            }
+            root = writable(root, TRIE_LEVELS - 1, owner);
+            let node = root;
+            for (let level = TRIE_LEVELS - 1; level > 0; level--) {
+                const slot = slotAt(id, level);
+                const child = writable(node.children[slot], level - 1, owner);
+                node.children[slot] = child;
+                node = child;
+            }
+            const slot = id & TRIE_MASK;
+            const before = node.values[slot];
+            node.values[slot] = value;
+            size += (value === undefined ? 0 : 1) - (before === undefined ? 0 : 1);
+        }
+        return root === this.root ? this : new IdMap(root, size);
+    }
+    forEach(each) {
+        if (this.root) {
+            visit(this.root, TRIE_LEVELS - 1, 0, each);
+        }
+    }
+}

package/lib/model/index.d.ts

@@ -0,0 +1,4 @@
+export type { IfcModel } from "./model-types";
+export type { IfcEntity, IfcValue, IfcReference, IfcEnumerationValue, IfcTypedValue, IfcBinaryValue, IfcDerivedValue, IfcFileHeader } from "../step/step-types";
+export { StepSyntaxError, IfcValueError } from "../step/errors";
+export { isIfcModel } from "./is-model";

package/lib/model/index.js

@@ -0,0 +1,2 @@
+export { StepSyntaxError, IfcValueError } from "../step/errors";
+export { isIfcModel } from "./is-model";

package/lib/model/io.d.ts

@@ -0,0 +1,6 @@
+import type { IfcFileHeader } from "../step/step-types";
+import { ModelSnapshot } from "./snapshot";
+export declare function readModel(input: Uint8Array | ArrayBuffer | string): ModelSnapshot;
+export declare function emptyModel(schemaName: string, header: IfcFileHeader): ModelSnapshot;
+export declare function writeModel(model: ModelSnapshot, header?: IfcFileHeader, longest?: number): string;
+export declare function writeModelBytes(model: ModelSnapshot, header?: IfcFileHeader, textPerChunk?: number): Uint8Array;