@ifc-lite/viewer 1.19.0 → 1.21.0

package/dist/assets/ids-B7AXEv7h.js

@@ -0,0 +1,4067 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/exporters-u0sz2Upj.js","assets/bcf-4K724hw0.js","assets/zip-DBEtpeu6.js","assets/cesium-DUOzBlqv.js","assets/arrow-CZ5kQ26f.js","assets/cesium-ADbP7waU.css"])))=>i.map(i=>d[i]);
+import { i as $, g as fe, f as J, a as ye, b as he, c as ve, d as Ee, R as Te, _ as Ie, e as be, E as ge, h as Se, j as Ae, k as A, l as N, m as xe, n as Ce, o as Re, p as Me, __tla as __tla_0 } from "./exporters-u0sz2Upj.js";
+let g, ua, oa, ca, Ne, la;
+let __tla = Promise.all([
+    (()=>{
+        try {
+            return __tla_0;
+        } catch  {}
+    })()
+]).then(async ()=>{
+    const O = "http://www.w3.org/2001/XMLSchema";
+    g = class extends Error {
+        constructor(t, a){
+            super(t), this.details = a, this.name = "IDSParseError";
+        }
+    };
+    let V = typeof globalThis < "u" && typeof globalThis.DOMParser == "function" ? globalThis.DOMParser : null;
+    V || (V = (await import("@xmldom/xmldom").then(async (m)=>{
+        await m.__tla;
+        return m;
+    })).DOMParser);
+    Ne = function(e) {
+        let t = typeof e == "string" ? e : new TextDecoder().decode(e);
+        if (t.charCodeAt(0) === 65279 && (t = t.slice(1)), !V) throw new g("No DOMParser implementation available", "Neither globalThis.DOMParser nor @xmldom/xmldom could be loaded.");
+        const a = new V;
+        let i;
+        try {
+            i = a.parseFromString(t, "text/xml");
+        } catch (s) {
+            throw new g("Failed to parse IDS XML", s instanceof Error ? s.message : String(s));
+        }
+        const n = typeof i.querySelector == "function" ? i.querySelector("parsererror") : null;
+        if (n) throw new g("Invalid XML format", n.textContent || void 0);
+        const r = i.documentElement;
+        if (!r) throw new g("Failed to parse IDS XML", "Parser returned a document with no root element.");
+        if (r.localName !== "ids") throw new g(`Invalid root element: expected "ids", got "${r.localName}"`);
+        return {
+            info: _e(r),
+            specifications: Pe(r),
+            schemaLocation: r.getAttribute("xsi:schemaLocation") || r.getAttributeNS("http://www.w3.org/2001/XMLSchema-instance", "schemaLocation") || void 0
+        };
+    };
+    function _e(e) {
+        const t = h(e, "info");
+        return t ? {
+            title: C(t, "title") || "Untitled IDS",
+            copyright: C(t, "copyright"),
+            version: C(t, "version"),
+            author: C(t, "author"),
+            date: C(t, "date"),
+            purpose: C(t, "purpose"),
+            milestone: C(t, "milestone"),
+            description: C(t, "description")
+        } : {
+            title: "Untitled IDS"
+        };
+    }
+    function Pe(e) {
+        const t = h(e, "specifications");
+        return t ? U(t, "specification").map((i, n)=>$e(i, n)) : [];
+    }
+    function $e(e, t) {
+        const a = e.getAttribute("name") || `Specification ${t + 1}`, n = (e.getAttribute("ifcVersion") || "IFC4").split(/\s+/).map((m)=>we(m)).filter((m)=>m !== null), r = h(e, "applicability"), s = {
+            facets: r ? Fe(r) : [],
+            cardinality: r?.getAttribute("cardinality") ?? void 0
+        }, l = (r ? r.getAttribute("minOccurs") : null) ?? e.getAttribute("minOccurs"), o = (r ? r.getAttribute("maxOccurs") : null) ?? e.getAttribute("maxOccurs");
+        let u;
+        if (l !== null) {
+            const m = parseInt(l, 10);
+            Number.isFinite(m) && (u = m);
+        }
+        let c;
+        if (o !== null) {
+            const m = parseInt(o, 10);
+            o === "unbounded" ? c = "unbounded" : Number.isFinite(m) && (c = m);
+        }
+        u === void 0 && (r || c !== void 0) && (u = 1);
+        const f = h(e, "requirements"), d = f ? qe(f) : [];
+        return {
+            id: e.getAttribute("identifier") || `spec-${t}`,
+            name: a,
+            description: e.getAttribute("description") || void 0,
+            instructions: e.getAttribute("instructions") || void 0,
+            identifier: e.getAttribute("identifier") || void 0,
+            ifcVersions: n.length > 0 ? n : [
+                "IFC4"
+            ],
+            ifcVersionRaw: e.getAttribute("ifcVersion") || void 0,
+            applicability: s,
+            requirements: d,
+            minOccurs: u,
+            maxOccurs: c
+        };
+    }
+    function we(e) {
+        const t = e.toUpperCase().replace(/[^A-Z0-9]/g, "");
+        switch(t){
+            case "IFC2X3":
+                return "IFC2X3";
+            case "IFC4":
+                return "IFC4";
+            case "IFC4X3":
+            case "IFC4X3ADD2":
+                return "IFC4X3";
+            default:
+                return t.startsWith("IFC4X3") ? "IFC4X3" : t.startsWith("IFC4") ? "IFC4" : t.startsWith("IFC2X3") ? "IFC2X3" : null;
+        }
+    }
+    function Fe(e) {
+        const t = [];
+        for (const a of Array.from(e.children)){
+            const i = Z(a);
+            i && t.push(i);
+        }
+        return t;
+    }
+    function Z(e) {
+        switch(e.localName.toLowerCase()){
+            case "entity":
+                return ee(e);
+            case "attribute":
+                return Oe(e);
+            case "property":
+                return Le(e);
+            case "classification":
+                return Ve(e);
+            case "material":
+                return De(e);
+            case "partof":
+                return Ue(e);
+            default:
+                return null;
+        }
+    }
+    function ee(e) {
+        const t = h(e, "name"), a = h(e, "predefinedType");
+        if (!t) throw new g("Entity facet must have a name element");
+        return {
+            type: "entity",
+            name: T(t),
+            predefinedType: a ? T(a) : void 0
+        };
+    }
+    function Oe(e) {
+        const t = h(e, "name"), a = h(e, "value");
+        if (!t) throw new g("Attribute facet must have a name element");
+        return {
+            type: "attribute",
+            name: T(t),
+            value: a ? T(a) : void 0
+        };
+    }
+    function Le(e) {
+        const t = h(e, "propertySet"), a = h(e, "baseName"), i = e.getAttribute("dataType"), n = h(e, "dataType"), r = h(e, "value");
+        if (!t) throw new g("Property facet must have a propertySet element");
+        if (!a) throw new g("Property facet must have a baseName element");
+        let s;
+        return i ? s = {
+            type: "simpleValue",
+            value: i
+        } : n && (s = T(n)), {
+            type: "property",
+            propertySet: T(t),
+            baseName: T(a),
+            dataType: s,
+            value: r ? T(r) : void 0
+        };
+    }
+    function Ve(e) {
+        const t = h(e, "system"), a = h(e, "value");
+        return {
+            type: "classification",
+            system: t ? T(t) : void 0,
+            value: a ? T(a) : void 0
+        };
+    }
+    function De(e) {
+        const t = h(e, "value");
+        return {
+            type: "material",
+            value: t ? T(t) : void 0
+        };
+    }
+    function Ue(e) {
+        const t = e.getAttribute("relation"), a = t || "IfcRelContainedInSpatialStructure", i = h(e, "entity"), n = Be(a), r = ke(a), s = {
+            type: "partOf",
+            relation: n,
+            entity: i ? ee(i) : void 0
+        };
+        return !r && t && (s.rawRelation = t), s;
+    }
+    function ke(e) {
+        switch(e){
+            case "IfcRelAggregates":
+            case "IfcRelContainedInSpatialStructure":
+            case "IfcRelNests":
+            case "IfcRelVoidsElement":
+            case "IfcRelFillsElement":
+            case "IfcRelAssignsToGroup":
+                return !0;
+            default:
+                return !1;
+        }
+    }
+    function Be(e) {
+        const t = e.toUpperCase();
+        return t.includes("ASSIGNSTOGROUP") || t.includes("GROUP") ? "IfcRelAssignsToGroup" : t.includes("AGGREGATE") ? "IfcRelAggregates" : t.includes("CONTAINED") || t.includes("SPATIAL") ? "IfcRelContainedInSpatialStructure" : t.includes("NEST") ? "IfcRelNests" : t.includes("VOID") ? "IfcRelVoidsElement" : t.includes("FILL") ? "IfcRelFillsElement" : "IfcRelContainedInSpatialStructure";
+    }
+    function qe(e) {
+        const t = [];
+        let a = 0;
+        for (const i of Array.from(e.children)){
+            const n = Z(i);
+            if (n) {
+                const r = i.getAttribute("cardinality"), s = i.getAttribute("minOccurs"), l = i.getAttribute("maxOccurs");
+                let o = "required", u;
+                if (r !== null) if (r === "required" || r === "optional" || r === "prohibited") o = r;
+                else {
+                    const c = r.toLowerCase();
+                    (c === "required" || c === "optional" || c === "prohibited") && (o = c), u = r;
+                }
+                else s === "0" && l === "0" ? o = "prohibited" : s === "0" && (o = "optional");
+                t.push({
+                    id: `req-${a++}`,
+                    facet: n,
+                    optionality: o,
+                    cardinalityRaw: u,
+                    description: i.getAttribute("description") || void 0,
+                    instructions: i.getAttribute("instructions") || void 0
+                });
+            }
+        }
+        return t;
+    }
+    function T(e) {
+        const t = h(e, "simpleValue");
+        if (t) return {
+            type: "simpleValue",
+            value: t.textContent?.trim() || ""
+        };
+        const a = te(e, "restriction", O) || h(e, "restriction");
+        if (a) return Ye(a);
+        const i = e.textContent?.trim();
+        return i ? {
+            type: "simpleValue",
+            value: i
+        } : {
+            type: "simpleValue",
+            value: ""
+        };
+    }
+    function Ye(e) {
+        const t = e.getAttribute("base") || void 0, a = (()=>{
+            const s = q(e, "pattern", O);
+            return s.length > 0 ? s : U(e, "pattern");
+        })();
+        if (a.length > 0) {
+            const s = a.map((o)=>o.getAttribute("value") || o.textContent || "").filter((o)=>o.length > 0);
+            return {
+                type: "pattern",
+                pattern: s.length === 1 ? s[0] : s.map((o)=>`(?:${o})`).join("|"),
+                base: t
+            };
+        }
+        const i = q(e, "enumeration", O);
+        if (i.length === 0) {
+            const s = U(e, "enumeration");
+            if (s.length > 0) return {
+                type: "enumeration",
+                values: s.map((l)=>l.getAttribute("value") || l.textContent || ""),
+                base: t
+            };
+        } else return {
+            type: "enumeration",
+            values: i.map((s)=>s.getAttribute("value") || s.textContent || ""),
+            base: t
+        };
+        const n = {};
+        for (const s of [
+            "minInclusive",
+            "maxInclusive",
+            "minExclusive",
+            "maxExclusive",
+            "length",
+            "minLength",
+            "maxLength"
+        ])n[s] = te(e, s, O) || h(e, s);
+        if (Object.values(n).some((s)=>s !== null)) {
+            const s = {
+                type: "bounds",
+                base: t
+            }, l = (u)=>{
+                if (!u) return;
+                const c = parseFloat(u.getAttribute("value") || u.textContent || "");
+                return Number.isFinite(c) ? c : void 0;
+            }, o = (u)=>{
+                if (!u) return;
+                const c = parseInt(u.getAttribute("value") || u.textContent || "", 10);
+                return Number.isFinite(c) && c >= 0 ? c : void 0;
+            };
+            return s.minInclusive = l(n.minInclusive), s.maxInclusive = l(n.maxInclusive), s.minExclusive = l(n.minExclusive), s.maxExclusive = l(n.maxExclusive), s.length = o(n.length), s.minLength = o(n.minLength), s.maxLength = o(n.maxLength), s;
+        }
+        const r = e.textContent?.trim() || "";
+        return t && r === "" ? {
+            type: "enumeration",
+            values: [],
+            base: t
+        } : r ? {
+            type: "simpleValue",
+            value: r
+        } : {
+            type: "enumeration",
+            values: [],
+            base: t
+        };
+    }
+    function h(e, t) {
+        for (const a of Array.from(e.children))if (a.localName.toLowerCase() === t.toLowerCase()) return a;
+        return null;
+    }
+    function U(e, t) {
+        const a = [];
+        for (const i of Array.from(e.children))i.localName.toLowerCase() === t.toLowerCase() && a.push(i);
+        return a;
+    }
+    function te(e, t, a) {
+        for (const i of Array.from(e.children))if (i.localName.toLowerCase() === t.toLowerCase() && i.namespaceURI === a) return i;
+        return null;
+    }
+    function q(e, t, a) {
+        const i = [];
+        for (const n of Array.from(e.children))n.localName.toLowerCase() === t.toLowerCase() && n.namespaceURI === a && i.push(n);
+        return i;
+    }
+    function C(e, t) {
+        return h(e, t)?.textContent?.trim() || void 0;
+    }
+    const Y = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/, He = 1e-6;
+    function Xe(e, t) {
+        const a = He * (1 + Math.abs(e)), i = 16 * Number.EPSILON * Math.max(Math.abs(e), typeof t == "number" ? Math.abs(t) : 0);
+        return a + i;
+    }
+    function ie(e, t) {
+        const a = String(t), i = Y.test(e), n = typeof t == "number" || Y.test(a);
+        if (!i || !n) return;
+        const r = parseFloat(e), s = typeof t == "number" ? t : parseFloat(a);
+        if (!(Number.isNaN(r) || Number.isNaN(s))) return Math.abs(r - s) <= Xe(r, s);
+    }
+    function ae(e, t) {
+        if (!(e !== "true" && e !== "false")) return typeof t == "boolean" ? e === "true" ? t === !0 : t === !1 : t === "true" || t === "false" ? t === e : !1;
+    }
+    function ne(e, t, a) {
+        const i = String(t);
+        if (i === e || a && i.toUpperCase() === e.toUpperCase()) return !0;
+    }
+    function v(e, t, a) {
+        if (t == null) return !1;
+        const i = a?.caseInsensitive ?? !1;
+        switch(e.type){
+            case "simpleValue":
+                return Ge(e, t, i);
+            case "pattern":
+                return je(e, t, i);
+            case "enumeration":
+                return ze(e, t, i);
+            case "bounds":
+                return Ke(e, t);
+            default:
+                return !1;
+        }
+    }
+    function Ge(e, t, a) {
+        const i = e.value, n = ne(i, t, a);
+        if (n !== void 0) return n;
+        const r = ie(i, t);
+        if (r !== void 0) return r;
+        const s = ae(i, t);
+        return s !== void 0 ? s : !1;
+    }
+    function je(e, t, a = !1) {
+        if (typeof t == "number" || typeof t == "boolean") return !1;
+        const i = String(t);
+        try {
+            const n = We(e.pattern), r = a ? "i" : "";
+            return new RegExp(`^${n}$`, r).test(i);
+        } catch  {
+            return !1;
+        }
+    }
+    function We(e) {
+        return e.replace(/\\i/g, "[A-Za-z_:]").replace(/\\c/g, "[A-Za-z0-9._:-]").replace(/\\p\{[^}]+\}/g, ".").replace(/\[([^\]]+)-\[[^\]]+\]\]/g, "[$1]");
+    }
+    function ze(e, t, a) {
+        return e.values.some((i)=>{
+            const n = ne(i, t, a);
+            if (n !== void 0) return n;
+            const r = ie(i, t);
+            if (r !== void 0) return r;
+            const s = ae(i, t);
+            return s !== void 0 ? s : !1;
+        });
+    }
+    function Ke(e, t) {
+        if (e.length !== void 0 || e.minLength !== void 0 || e.maxLength !== void 0) {
+            const i = String(t);
+            if (e.length !== void 0 && i.length !== e.length || e.minLength !== void 0 && i.length < e.minLength || e.maxLength !== void 0 && i.length > e.maxLength) return !1;
+            if (e.minInclusive === void 0 && e.maxInclusive === void 0 && e.minExclusive === void 0 && e.maxExclusive === void 0) return !0;
+        }
+        const a = typeof t == "number" ? t : parseFloat(String(t));
+        return !(isNaN(a) || e.minInclusive !== void 0 && a < e.minInclusive || e.maxInclusive !== void 0 && a > e.maxInclusive || e.minExclusive !== void 0 && a <= e.minExclusive || e.maxExclusive !== void 0 && a >= e.maxExclusive);
+    }
+    function p(e) {
+        switch(e.type){
+            case "simpleValue":
+                return `"${e.value}"`;
+            case "pattern":
+                return `pattern "${e.pattern}"`;
+            case "enumeration":
+                return e.values.length === 1 ? `"${e.values[0]}"` : `one of [${e.values.map((t)=>`"${t}"`).join(", ")}]`;
+            case "bounds":
+                return Qe(e);
+            default:
+                return "unknown";
+        }
+    }
+    function Qe(e) {
+        const t = [];
+        return e.minInclusive !== void 0 && e.maxInclusive !== void 0 ? `between ${e.minInclusive} and ${e.maxInclusive}` : (e.minInclusive !== void 0 && t.push(`>= ${e.minInclusive}`), e.maxInclusive !== void 0 && t.push(`<= ${e.maxInclusive}`), e.minExclusive !== void 0 && t.push(`> ${e.minExclusive}`), e.maxExclusive !== void 0 && t.push(`< ${e.maxExclusive}`), t.join(" and ") || "any value");
+    }
+    const Je = {
+        caseInsensitive: !0
+    };
+    function Ze(e, t, a) {
+        const i = a.getEntityType(t);
+        if (!i) return {
+            passed: !1,
+            actualValue: void 0,
+            expectedValue: p(e.name),
+            failure: {
+                type: "ENTITY_TYPE_MISMATCH",
+                field: "entityType",
+                actual: "unknown",
+                expected: p(e.name)
+            }
+        };
+        if (e.name.type === "simpleValue" && e.name.value !== e.name.value.toUpperCase()) return {
+            passed: !1,
+            actualValue: i,
+            expectedValue: p(e.name),
+            failure: {
+                type: "ENTITY_TYPE_MISMATCH",
+                field: "entityType",
+                actual: i,
+                expected: p(e.name)
+            }
+        };
+        if (!v(e.name, i, Je)) return {
+            passed: !1,
+            actualValue: i,
+            expectedValue: p(e.name),
+            failure: {
+                type: "ENTITY_TYPE_MISMATCH",
+                field: "entityType",
+                actual: i,
+                expected: p(e.name)
+            }
+        };
+        if (e.predefinedType) {
+            const n = a.getPredefinedTypeRaw?.(t), r = a.getObjectType(t);
+            if (!n && !r) return {
+                passed: !1,
+                actualValue: i,
+                expectedValue: `${p(e.name)} with predefinedType ${p(e.predefinedType)}`,
+                failure: {
+                    type: "PREDEFINED_TYPE_MISSING",
+                    field: "predefinedType",
+                    expected: p(e.predefinedType)
+                }
+            };
+            let s = !1;
+            if ((n && v(e.predefinedType, n) || n === "USERDEFINED" && r && r !== n && v(e.predefinedType, r) || !n && r && v(e.predefinedType, r)) && (s = !0), !s) {
+                const l = r || n || "(none)";
+                return {
+                    passed: !1,
+                    actualValue: `${i}[${l}]`,
+                    expectedValue: `${p(e.name)} with predefinedType ${p(e.predefinedType)}`,
+                    failure: {
+                        type: "PREDEFINED_TYPE_MISMATCH",
+                        field: "predefinedType",
+                        actual: l,
+                        expected: p(e.predefinedType)
+                    }
+                };
+            }
+        }
+        return {
+            passed: !0,
+            actualValue: e.predefinedType ? `${i}[${a.getObjectType(t) || ""}]` : i,
+            expectedValue: p(e.name)
+        };
+    }
+    function et(e, t) {
+        const a = e.name;
+        if (a.type === "simpleValue") return t.getEntitiesByType(a.value);
+        if (a.type === "enumeration") {
+            const i = [];
+            for (const n of a.values)i.push(...t.getEntitiesByType(n));
+            return i;
+        }
+    }
+    const tt = /^[+-]?\d+$/, it = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/, at = /^\d{4}-\d{2}-\d{2}(Z|[+-]\d{2}:\d{2})?$/, nt = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?$/, rt = /^-?P(?:\d+Y)?(?:\d+M)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+(?:\.\d+)?S)?)?$/;
+    function re(e, t) {
+        return !t || t.length === 0 ? !0 : t.some((a)=>st(e, a));
+    }
+    function st(e, t) {
+        switch(t){
+            case "xs:integer":
+                return tt.test(e);
+            case "xs:double":
+                return it.test(e);
+            case "xs:boolean":
+                return e === "true" || e === "false";
+            case "xs:date":
+                return at.test(e);
+            case "xs:dateTime":
+                return nt.test(e);
+            case "xs:duration":
+                return rt.test(e);
+            case "xs:string":
+                return !0;
+            default:
+                return !0;
+        }
+    }
+    function lt(e) {
+        if (!e) return [];
+        const t = e.toUpperCase();
+        return t === "IFCINTEGER" || t === "IFCCOUNTMEASURE" ? [
+            "xs:integer"
+        ] : t === "IFCBOOLEAN" ? [
+            "xs:boolean"
+        ] : t === "IFCLOGICAL" ? [
+            "xs:boolean",
+            "xs:string"
+        ] : t === "IFCDATE" ? [
+            "xs:date"
+        ] : t === "IFCDATETIME" ? [
+            "xs:dateTime"
+        ] : t === "IFCDURATION" || t === "IFCTIMESTAMP" ? [
+            "xs:duration"
+        ] : t === "IFCREAL" || t.endsWith("MEASURE") || t.endsWith("RATIO") ? [
+            "xs:double"
+        ] : t === "IFCLABEL" || t === "IFCTEXT" || t === "IFCIDENTIFIER" || t === "IFCSTRING" ? [
+            "xs:string"
+        ] : [];
+    }
+    const ot = {
+        caseInsensitive: !0
+    }, ut = [
+        "Name",
+        "Description",
+        "ObjectType",
+        "Tag",
+        "GlobalId",
+        "LongName"
+    ];
+    function ct(e, t, a) {
+        const i = e.name;
+        let n;
+        if (i.type === "simpleValue") n = [
+            i.value
+        ];
+        else {
+            const s = a.getAttributeNames?.(t);
+            if (n = (s && s.length > 0 ? s : ut).filter((o)=>v(i, o, ot)), n.length === 0) return {
+                passed: !1,
+                expectedValue: e.value ? p(e.value) : `attribute matching ${p(i)} to exist`,
+                failure: {
+                    type: "ATTRIBUTE_MISSING",
+                    field: p(i),
+                    expected: p(i)
+                }
+            };
+        }
+        let r;
+        for (const s of n){
+            const l = pt(e, s, t, a);
+            if (l.passed) return l;
+            (!r || l.failure?.type !== "ATTRIBUTE_MISSING" && r.failure?.type === "ATTRIBUTE_MISSING") && (r = l);
+        }
+        return r;
+    }
+    function pt(e, t, a, i) {
+        const n = dt(t, a, i);
+        if (n == null) return {
+            passed: !1,
+            actualValue: void 0,
+            expectedValue: e.value ? p(e.value) : `attribute "${t}" to exist`,
+            failure: {
+                type: "ATTRIBUTE_MISSING",
+                field: t,
+                expected: e.value ? p(e.value) : "any value"
+            }
+        };
+        if (n === "") return {
+            passed: !1,
+            actualValue: "(empty)",
+            expectedValue: e.value ? p(e.value) : `attribute "${t}" must have a non-empty value`,
+            failure: {
+                type: "ATTRIBUTE_VALUE_MISMATCH",
+                field: t,
+                actual: "(empty)",
+                expected: e.value ? p(e.value) : "a non-empty value"
+            }
+        };
+        if (!e.value) return {
+            passed: !0,
+            actualValue: String(n),
+            expectedValue: `attribute "${t}" to exist`
+        };
+        if (e.value.type === "simpleValue") {
+            const r = i.getAttributeXsdTypes?.(a, t);
+            if (r && !re(e.value.value, r)) return {
+                passed: !1,
+                actualValue: String(n),
+                expectedValue: p(e.value),
+                failure: {
+                    type: "ATTRIBUTE_VALUE_MISMATCH",
+                    field: t,
+                    actual: String(n),
+                    expected: p(e.value)
+                }
+            };
+        }
+        return v(e.value, n) ? {
+            passed: !0,
+            actualValue: String(n),
+            expectedValue: p(e.value)
+        } : {
+            passed: !1,
+            actualValue: String(n),
+            expectedValue: p(e.value),
+            failure: {
+                type: e.value.type === "pattern" ? "ATTRIBUTE_PATTERN_MISMATCH" : "ATTRIBUTE_VALUE_MISMATCH",
+                field: t,
+                actual: String(n),
+                expected: p(e.value)
+            }
+        };
+    }
+    function dt(e, t, a) {
+        switch(e.toLowerCase()){
+            case "name":
+                return a.getEntityName(t);
+            case "description":
+                return a.getDescription(t);
+            case "objecttype":
+                return a.getObjectType(t);
+            case "globalid":
+                return a.getGlobalId(t);
+            default:
+                return a.getAttribute(t, e);
+        }
+    }
+    const mt = {
+        caseInsensitive: !0
+    };
+    function ft(e, t, a) {
+        const i = a.getPropertySets(t);
+        if (i.length === 0) return {
+            passed: !1,
+            expectedValue: `property "${p(e.baseName)}" in "${p(e.propertySet)}"`,
+            failure: {
+                type: "PSET_MISSING",
+                field: p(e.propertySet),
+                expected: p(e.propertySet)
+            }
+        };
+        const n = i.filter((u)=>v(e.propertySet, u.name));
+        if (n.length === 0) {
+            const u = i.map((c)=>c.name).join(", ");
+            return {
+                passed: !1,
+                actualValue: u || "(none)",
+                expectedValue: p(e.propertySet),
+                failure: {
+                    type: "PSET_MISSING",
+                    field: "propertySet",
+                    actual: u,
+                    expected: p(e.propertySet),
+                    context: {
+                        availablePsets: u
+                    }
+                }
+            };
+        }
+        let r, s;
+        for (const u of n){
+            const c = yt(e, u);
+            if (c.passed) {
+                r = c;
+                continue;
+            }
+            s ? s.failure?.type === "PROPERTY_MISSING" && c.failure?.type !== "PROPERTY_MISSING" && (s = c) : s = c;
+        }
+        if (s) {
+            if (s.failure?.type !== "PROPERTY_MISSING" || r) return s;
+        } else if (r) return r;
+        const l = n.map((u)=>u.name).join(", "), o = n.flatMap((u)=>u.properties.map((c)=>`${u.name}.${c.name}`)).join(", ");
+        return {
+            passed: !1,
+            actualValue: o || "(none)",
+            expectedValue: `${p(e.propertySet)}.${p(e.baseName)}`,
+            failure: {
+                type: "PROPERTY_MISSING",
+                field: p(e.baseName),
+                expected: p(e.baseName),
+                context: {
+                    propertySet: l,
+                    availableProperties: o
+                }
+            }
+        };
+    }
+    function yt(e, t) {
+        const a = t.properties.filter((r)=>v(e.baseName, r.name));
+        if (a.length === 0) return {
+            passed: !1,
+            failure: {
+                type: "PROPERTY_MISSING",
+                field: p(e.baseName),
+                expected: p(e.baseName),
+                context: {
+                    propertySet: t.name,
+                    availableProperties: t.properties.map((r)=>r.name).join(", ")
+                }
+            }
+        };
+        let i, n;
+        for (const r of a){
+            const s = ht(e, t, r);
+            if (s.passed) {
+                i = s;
+                continue;
+            }
+            n ? n.failure?.type === "PROPERTY_MISSING" && s.failure?.type !== "PROPERTY_MISSING" && (n = s) : n = s;
+        }
+        return n || i;
+    }
+    function ht(e, t, a) {
+        if (a.value === null || a.value === void 0 || a.value === "") return {
+            passed: !1,
+            actualValue: "(empty)",
+            expectedValue: e.value ? p(e.value) : `property "${t.name}.${a.name}" must have a value`,
+            failure: {
+                type: "PROPERTY_VALUE_MISMATCH",
+                field: `${t.name}.${a.name}`,
+                actual: "(empty)",
+                expected: e.value ? p(e.value) : "a non-empty value"
+            }
+        };
+        if (e.dataType && a.dataType && !v(e.dataType, a.dataType, mt)) return {
+            passed: !1,
+            actualValue: `${t.name}.${a.name} (${a.dataType})`,
+            expectedValue: `dataType ${p(e.dataType)}`,
+            failure: {
+                type: "PROPERTY_DATATYPE_MISMATCH",
+                field: `${t.name}.${a.name}`,
+                actual: a.dataType,
+                expected: p(e.dataType)
+            }
+        };
+        if (e.value) {
+            const i = a.value;
+            if (i == null || i === "") return {
+                passed: !1,
+                actualValue: "(empty)",
+                expectedValue: p(e.value),
+                failure: {
+                    type: "PROPERTY_VALUE_MISMATCH",
+                    field: `${t.name}.${a.name}`,
+                    actual: "(empty)",
+                    expected: p(e.value)
+                }
+            };
+            if (e.value.type === "simpleValue") {
+                const s = lt(a.dataType);
+                if (s.length > 0 && !re(e.value.value, s)) return {
+                    passed: !1,
+                    actualValue: String(i),
+                    expectedValue: p(e.value),
+                    failure: {
+                        type: "PROPERTY_VALUE_MISMATCH",
+                        field: `${t.name}.${a.name}`,
+                        actual: String(i),
+                        expected: p(e.value)
+                    }
+                };
+            }
+            if (!(a.values && a.values.length > 0 ? a.values : [
+                i
+            ]).some((s)=>v(e.value, s))) {
+                const s = e.value.type === "bounds" ? "PROPERTY_OUT_OF_BOUNDS" : "PROPERTY_VALUE_MISMATCH", l = a.values && a.values.length > 0 ? a.values.join(", ") : String(i);
+                return {
+                    passed: !1,
+                    actualValue: l,
+                    expectedValue: p(e.value),
+                    failure: {
+                        type: s,
+                        field: `${t.name}.${a.name}`,
+                        actual: l,
+                        expected: p(e.value)
+                    }
+                };
+            }
+        }
+        return {
+            passed: !0,
+            actualValue: `${t.name}.${a.name} = ${a.value}`,
+            expectedValue: e.value ? p(e.value) : "property exists"
+        };
+    }
+    function vt(e, t, a) {
+        const i = a.getClassifications(t), n = i.length > 0;
+        if (!e.system && !e.value) return n ? {
+            passed: !0,
+            actualValue: i.map((s)=>`${s.system}:${s.value}`).join(", "),
+            expectedValue: "any classification"
+        } : {
+            passed: !1,
+            actualValue: "(none)",
+            expectedValue: "any classification",
+            failure: {
+                type: "CLASSIFICATION_MISSING",
+                expected: "any classification"
+            }
+        };
+        if (!n) {
+            const s = e.system && e.value ? `${p(e.system)}:${p(e.value)}` : e.system ? p(e.system) : p(e.value);
+            return {
+                passed: !1,
+                actualValue: "(none)",
+                expectedValue: s,
+                failure: {
+                    type: "CLASSIFICATION_MISSING",
+                    expected: s
+                }
+            };
+        }
+        let r = i;
+        if (e.system && (r = i.filter((s)=>v(e.system, s.system)), r.length === 0)) {
+            const s = [
+                ...new Set(i.map((l)=>l.system))
+            ].join(", ");
+            return {
+                passed: !1,
+                actualValue: s,
+                expectedValue: p(e.system),
+                failure: {
+                    type: "CLASSIFICATION_SYSTEM_MISMATCH",
+                    field: "system",
+                    actual: s,
+                    expected: p(e.system),
+                    context: {
+                        availableSystems: s
+                    }
+                }
+            };
+        }
+        if (e.value) {
+            const s = r.filter((l)=>v(e.value, l.value));
+            if (s.length === 0) {
+                const l = r.map((o)=>o.value).join(", ");
+                return {
+                    passed: !1,
+                    actualValue: l || "(none)",
+                    expectedValue: p(e.value),
+                    failure: {
+                        type: "CLASSIFICATION_VALUE_MISMATCH",
+                        field: "value",
+                        actual: l,
+                        expected: p(e.value),
+                        context: {
+                            system: e.system ? p(e.system) : "any",
+                            availableValues: l
+                        }
+                    }
+                };
+            }
+            return {
+                passed: !0,
+                actualValue: s.map((l)=>`${l.system}:${l.value}`).join(", "),
+                expectedValue: e.system ? `${p(e.system)}:${p(e.value)}` : p(e.value)
+            };
+        }
+        return {
+            passed: !0,
+            actualValue: r.map((s)=>`${s.system}:${s.value}`).join(", "),
+            expectedValue: p(e.system)
+        };
+    }
+    function Et(e, t, a) {
+        const i = a.getMaterials(t);
+        if (!e.value) return i.length === 0 ? {
+            passed: !1,
+            actualValue: "(none)",
+            expectedValue: "any material",
+            failure: {
+                type: "MATERIAL_MISSING",
+                expected: "any material"
+            }
+        } : {
+            passed: !0,
+            actualValue: i.map((r)=>r.name).join(", "),
+            expectedValue: "any material"
+        };
+        const n = i.filter((r)=>v(e.value, r.name) || r.category && v(e.value, r.category));
+        if (n.length === 0) {
+            if (i.length === 0) return {
+                passed: !1,
+                actualValue: "(none)",
+                expectedValue: p(e.value),
+                failure: {
+                    type: "MATERIAL_MISSING",
+                    expected: p(e.value)
+                }
+            };
+            const r = i.map((s)=>s.name).join(", ");
+            return {
+                passed: !1,
+                actualValue: r,
+                expectedValue: p(e.value),
+                failure: {
+                    type: "MATERIAL_VALUE_MISMATCH",
+                    field: "material",
+                    actual: r,
+                    expected: p(e.value),
+                    context: {
+                        availableMaterials: r
+                    }
+                }
+            };
+        }
+        return {
+            passed: !0,
+            actualValue: n.map((r)=>r.name).join(", "),
+            expectedValue: p(e.value)
+        };
+    }
+    const H = {
+        caseInsensitive: !0
+    }, L = {
+        IfcRelAggregates: "aggregated in",
+        IfcRelAssignsToGroup: "grouped in",
+        IfcRelContainedInSpatialStructure: "contained in",
+        IfcRelNests: "nested in",
+        IfcRelVoidsElement: "voiding",
+        IfcRelFillsElement: "filling"
+    };
+    function Tt(e, t, a) {
+        const i = a.getAncestors ? a.getAncestors(t, e.relation) : [];
+        if (i.length === 0) {
+            const r = a.getParent(t, e.relation);
+            r && i.push(r);
+        }
+        if (i.length === 0) {
+            const r = L[e.relation] || e.relation, s = e.entity ? p(e.entity.name) : "any entity";
+            return {
+                passed: !1,
+                actualValue: "(no parent)",
+                expectedValue: `${r} ${s}`,
+                failure: {
+                    type: "PARTOF_RELATION_MISSING",
+                    field: e.relation,
+                    expected: `${r} ${s}`,
+                    context: {
+                        relation: e.relation
+                    }
+                }
+            };
+        }
+        let n;
+        for (const r of i){
+            const s = It(e, r);
+            if (s.passed) return s;
+            (!n || s.failure?.type !== "PARTOF_ENTITY_MISMATCH" && n.failure?.type === "PARTOF_ENTITY_MISMATCH") && (n = s);
+        }
+        return n;
+    }
+    function It(e, t) {
+        if (!e.entity) {
+            const n = L[e.relation] || e.relation;
+            return {
+                passed: !0,
+                actualValue: `${n} ${t.entityType}`,
+                expectedValue: `${n} any entity`
+            };
+        }
+        if (!v(e.entity.name, t.entityType, H)) {
+            const n = L[e.relation] || e.relation;
+            return {
+                passed: !1,
+                actualValue: `${n} ${t.entityType}`,
+                expectedValue: `${n} ${p(e.entity.name)}`,
+                failure: {
+                    type: "PARTOF_ENTITY_MISMATCH",
+                    field: "entity",
+                    actual: t.entityType,
+                    expected: p(e.entity.name),
+                    context: {
+                        relation: e.relation,
+                        parentId: String(t.expressId)
+                    }
+                }
+            };
+        }
+        if (e.entity.predefinedType) {
+            if (!t.predefinedType) return {
+                passed: !1,
+                actualValue: `${t.entityType} (no predefinedType)`,
+                expectedValue: `${p(e.entity.name)} with predefinedType ${p(e.entity.predefinedType)}`,
+                failure: {
+                    type: "PARTOF_PREDEFINED_TYPE_MISSING",
+                    field: "predefinedType",
+                    expected: p(e.entity.predefinedType),
+                    context: {
+                        relation: e.relation,
+                        parentType: t.entityType
+                    }
+                }
+            };
+            if (!v(e.entity.predefinedType, t.predefinedType, H)) return {
+                passed: !1,
+                actualValue: `${t.entityType}[${t.predefinedType}]`,
+                expectedValue: `${p(e.entity.name)}[${p(e.entity.predefinedType)}]`,
+                failure: {
+                    type: "PARTOF_PREDEFINED_TYPE_MISMATCH",
+                    field: "predefinedType",
+                    actual: t.predefinedType,
+                    expected: p(e.entity.predefinedType),
+                    context: {
+                        relation: e.relation,
+                        parentType: t.entityType
+                    }
+                }
+            };
+        }
+        const a = L[e.relation] || e.relation, i = t.predefinedType ? `${t.entityType}[${t.predefinedType}]` : t.entityType;
+        return {
+            passed: !0,
+            actualValue: `${a} ${i}`,
+            expectedValue: `${a} ${p(e.entity.name)}`
+        };
+    }
+    function se(e, t, a) {
+        switch(e.type){
+            case "entity":
+                return Ze(e, t, a);
+            case "attribute":
+                return ct(e, t, a);
+            case "property":
+                return ft(e, t, a);
+            case "classification":
+                return vt(e, t, a);
+            case "material":
+                return Et(e, t, a);
+            case "partOf":
+                return Tt(e, t, a);
+            default:
+                return {
+                    passed: !1,
+                    failure: {
+                        type: "ENTITY_TYPE_MISMATCH",
+                        expected: "known facet type",
+                        actual: e.type
+                    }
+                };
+        }
+    }
+    function bt(e, t) {
+        switch(e.type){
+            case "entity":
+                return et(e, t);
+            default:
+                return;
+        }
+    }
+    la = async function(e, t, a, i = {}) {
+        const { translator: n, onProgress: r, includePassingEntities: s = !0 } = i, l = [], o = e.specifications.length;
+        for(let c = 0; c < o; c++){
+            const f = e.specifications[c];
+            r && r({
+                phase: "filtering",
+                specificationIndex: c,
+                totalSpecifications: o,
+                entitiesProcessed: 0,
+                totalEntities: 0,
+                percentage: Math.floor(c / o * 100)
+            });
+            const d = await gt(f, t, a, i, (m)=>{
+                r && r({
+                    ...m,
+                    specificationIndex: c,
+                    totalSpecifications: o,
+                    percentage: Math.floor((c + m.entitiesProcessed / Math.max(m.totalEntities, 1)) / o * 100)
+                });
+            });
+            l.push(d);
+        }
+        r && r({
+            phase: "complete",
+            specificationIndex: o,
+            totalSpecifications: o,
+            entitiesProcessed: 0,
+            totalEntities: 0,
+            percentage: 100
+        });
+        const u = Rt(l);
+        return {
+            document: e,
+            modelInfo: a,
+            timestamp: new Date,
+            summary: u,
+            specificationResults: l
+        };
+    };
+    async function gt(e, t, a, i, n) {
+        const { translator: r, maxEntities: s, includePassingEntities: l = !0 } = i, o = a.modelId, u = St(e, t), c = s ? u.slice(0, s) : u, f = [], d = c.length;
+        for(let I = 0; I < d; I++){
+            const b = c[I];
+            n && I % 100 === 0 && n({
+                phase: "validating",
+                entitiesProcessed: I,
+                totalEntities: d
+            });
+            const P = At(e, b, o, t, r);
+            (l || !P.passed) && f.push(P);
+        }
+        let m = 0, y = 0;
+        for (const I of f)I.passed ? m++ : y++;
+        l || (m = d - y);
+        const M = Ct(e, u.length);
+        let x = "pass";
+        u.length === 0 ? M?.passed === !1 ? x = "fail" : M?.passed === !0 ? x = "pass" : x = "not_applicable" : (y > 0 || M?.passed === !1) && (x = "fail");
+        const _ = d > 0 ? Math.floor(m / d * 100) : 100;
+        return {
+            specification: e,
+            status: x,
+            applicableCount: u.length,
+            passedCount: m,
+            failedCount: y,
+            passRate: _,
+            entityResults: f,
+            cardinalityResult: M
+        };
+    }
+    function St(e, t) {
+        const a = e.applicability.facets;
+        if (a.length === 0) return t.getAllEntityIds();
+        let i;
+        for (const r of a){
+            const s = bt(r, t);
+            if (s !== void 0) {
+                i = s;
+                break;
+            }
+        }
+        i === void 0 && (i = t.getAllEntityIds());
+        const n = [];
+        for (const r of i){
+            let s = !0;
+            for (const l of a)if (!se(l, r, t).passed) {
+                s = !1;
+                break;
+            }
+            s && n.push(r);
+        }
+        return n;
+    }
+    function At(e, t, a, i, n) {
+        const r = [];
+        let s = !0;
+        for (const l of e.requirements){
+            const o = xt(l, t, i, n);
+            r.push(o), o.status === "fail" && (s = !1);
+        }
+        return {
+            expressId: t,
+            modelId: a,
+            entityType: i.getEntityType(t) || "Unknown",
+            entityName: i.getEntityName(t),
+            globalId: i.getGlobalId(t),
+            passed: s,
+            requirementResults: r
+        };
+    }
+    function xt(e, t, a, i) {
+        const n = se(e.facet, t, a);
+        let r, s;
+        switch(e.optionality){
+            case "required":
+                r = n.passed ? "pass" : "fail", n.passed || (s = i ? i.describeFailure({
+                    requirement: e,
+                    status: "fail",
+                    facetType: e.facet.type,
+                    checkedDescription: "",
+                    actualValue: n.actualValue,
+                    expectedValue: n.expectedValue,
+                    failure: n.failure
+                }) : X(n));
+                break;
+            case "optional":
+                if (n.passed) r = "pass";
+                else {
+                    const o = new Set([
+                        "ATTRIBUTE_MISSING",
+                        "PROPERTY_MISSING",
+                        "PSET_MISSING",
+                        "CLASSIFICATION_MISSING",
+                        "MATERIAL_MISSING",
+                        "PARTOF_RELATION_MISSING"
+                    ]);
+                    n.failure?.type && o.has(n.failure.type) ? r = "pass" : (r = "fail", s = i ? i.describeFailure({
+                        requirement: e,
+                        status: "fail",
+                        facetType: e.facet.type,
+                        checkedDescription: "",
+                        actualValue: n.actualValue,
+                        expectedValue: n.expectedValue,
+                        failure: n.failure
+                    }) : X(n));
+                }
+                break;
+            case "prohibited":
+                r = n.passed ? "fail" : "pass", r === "fail" && (s = i ? i.t("failures.prohibited", {
+                    field: n.actualValue || "value"
+                }) : `Prohibited: found ${n.actualValue}`);
+                break;
+            default:
+                r = n.passed ? "pass" : "fail";
+        }
+        const l = i ? i.describeRequirement(e) : Mt(e);
+        return {
+            requirement: e,
+            status: r,
+            facetType: e.facet.type,
+            checkedDescription: l,
+            failureReason: s,
+            actualValue: n.actualValue,
+            expectedValue: n.expectedValue,
+            failure: n.failure
+        };
+    }
+    function Ct(e, t) {
+        if (e.minOccurs === void 0 && e.maxOccurs === void 0) return;
+        const a = e.minOccurs ?? 0, i = e.maxOccurs;
+        let n = !0;
+        const r = [];
+        return t < a && (n = !1, r.push(`Expected at least ${a}, found ${t}`)), i !== "unbounded" && i !== void 0 && t > i && (n = !1, r.push(`Expected at most ${i}, found ${t}`)), {
+            passed: n,
+            actualCount: t,
+            minExpected: e.minOccurs,
+            maxExpected: e.maxOccurs,
+            message: r.length > 0 ? r.join("; ") : "Cardinality satisfied"
+        };
+    }
+    function Rt(e) {
+        let t = e.length, a = 0, i = 0, n = 0, r = 0, s = 0;
+        for (const o of e)o.status === "pass" ? a++ : o.status === "fail" && i++, n += o.applicableCount, r += o.passedCount, s += o.failedCount;
+        const l = n > 0 ? Math.floor(r / n * 100) : 100;
+        return {
+            totalSpecifications: t,
+            passedSpecifications: a,
+            failedSpecifications: i,
+            totalEntitiesChecked: n,
+            totalEntitiesPassed: r,
+            totalEntitiesFailed: s,
+            overallPassRate: l
+        };
+    }
+    function X(e) {
+        if (!e.failure) return `Expected ${e.expectedValue}, got ${e.actualValue}`;
+        const { type: t, field: a, actual: i, expected: n } = e.failure;
+        switch(t){
+            case "ENTITY_TYPE_MISMATCH":
+                return `Entity type "${i}" does not match expected ${n}`;
+            case "PREDEFINED_TYPE_MISMATCH":
+                return `Predefined type "${i}" does not match expected ${n}`;
+            case "PREDEFINED_TYPE_MISSING":
+                return `Predefined type is missing, expected ${n}`;
+            case "ATTRIBUTE_MISSING":
+                return `Attribute "${a}" is missing`;
+            case "ATTRIBUTE_VALUE_MISMATCH":
+                return `Attribute "${a}" value "${i}" does not match expected ${n}`;
+            case "ATTRIBUTE_PATTERN_MISMATCH":
+                return `Attribute "${a}" value "${i}" does not match pattern ${n}`;
+            case "PSET_MISSING":
+                return `Property set "${a || n}" not found`;
+            case "PROPERTY_MISSING":
+                return `Property "${a}" not found`;
+            case "PROPERTY_VALUE_MISMATCH":
+                return `Property "${a}" value "${i}" does not match expected ${n}`;
+            case "PROPERTY_DATATYPE_MISMATCH":
+                return `Property "${a}" type "${i}" does not match expected ${n}`;
+            case "PROPERTY_OUT_OF_BOUNDS":
+                return `Property "${a}" value ${i} is out of bounds ${n}`;
+            case "CLASSIFICATION_MISSING":
+                return "No classification found";
+            case "CLASSIFICATION_SYSTEM_MISMATCH":
+                return `Classification system "${i}" does not match expected ${n}`;
+            case "CLASSIFICATION_VALUE_MISMATCH":
+                return `Classification value "${i}" does not match expected ${n}`;
+            case "MATERIAL_MISSING":
+                return "No material assigned";
+            case "MATERIAL_VALUE_MISMATCH":
+                return `Material "${i}" does not match expected ${n}`;
+            case "PARTOF_RELATION_MISSING":
+                return `Not ${a} any entity`;
+            case "PARTOF_ENTITY_MISMATCH":
+                return `Parent entity "${i}" does not match expected ${n}`;
+            case "PARTOF_PREDEFINED_TYPE_MISSING":
+                return `Parent entity predefined type is missing, expected ${n}`;
+            case "PARTOF_PREDEFINED_TYPE_MISMATCH":
+                return `Parent entity predefined type "${i}" does not match expected ${n}`;
+            default:
+                return `Validation failed: ${t}`;
+        }
+    }
+    function Mt(e) {
+        const t = e.facet, a = e.optionality;
+        let i;
+        switch(t.type){
+            case "entity":
+                i = `Must be ${p(t.name)}`, t.predefinedType && (i += ` with predefinedType ${p(t.predefinedType)}`);
+                break;
+            case "attribute":
+                t.value ? i = `Attribute "${p(t.name)}" must equal ${p(t.value)}` : i = `Attribute "${p(t.name)}" must exist`;
+                break;
+            case "property":
+                t.value ? i = `Property "${p(t.propertySet)}.${p(t.baseName)}" must equal ${p(t.value)}` : i = `Property "${p(t.propertySet)}.${p(t.baseName)}" must exist`;
+                break;
+            case "classification":
+                t.system && t.value ? i = `Must have classification ${p(t.value)} in ${p(t.system)}` : t.system ? i = `Must be classified in ${p(t.system)}` : t.value ? i = `Must have classification ${p(t.value)}` : i = "Must have a classification";
+                break;
+            case "material":
+                t.value ? i = `Must have material ${p(t.value)}` : i = "Must have a material assigned";
+                break;
+            case "partOf":
+                {
+                    const n = t.relation.replace("IfcRel", "").toLowerCase();
+                    t.entity ? i = `Must be ${n} ${p(t.entity.name)}` : i = `Must be ${n} some entity`;
+                    break;
+                }
+            default:
+                i = "Unknown requirement";
+        }
+        return a === "prohibited" ? i = i.replace("Must", "Must NOT").replace("must", "must NOT") : a === "optional" && (i = i.replace("Must", "Should").replace("must", "should")), i;
+    }
+    function Nt(e) {
+        if (/\[[^\]]*-\[/.test(e)) return {
+            pattern: e,
+            supported: !1,
+            reason: "XSD character-class subtraction is not supported in JS regex"
+        };
+        let t = "", a = 0;
+        for(; a < e.length;){
+            const i = e.charAt(a);
+            if (i === "\\" && a + 1 < e.length) {
+                const n = e.charAt(a + 1), r = _t(n);
+                if (r) {
+                    t += r, a += 2;
+                    continue;
+                }
+                t += i + n, a += 2;
+                continue;
+            }
+            t += i, a++;
+        }
+        return {
+            pattern: t,
+            supported: !0,
+            reason: ""
+        };
+    }
+    function _t(e) {
+        switch(e){
+            case "i":
+                return "[\\p{L}_:]";
+            case "I":
+                return "[^\\p{L}_:]";
+            case "c":
+                return "[\\p{L}\\p{Nd}_:.\\-\\u00B7\\u0300-\\u036F\\u203F-\\u2040]";
+            case "C":
+                return "[^\\p{L}\\p{Nd}_:.\\-\\u00B7\\u0300-\\u036F\\u203F-\\u2040]";
+            case "d":
+                return "\\p{Nd}";
+            case "D":
+                return "\\P{Nd}";
+            case "w":
+                return "[\\p{L}\\p{Nd}]";
+            case "W":
+                return "[^\\p{L}\\p{Nd}]";
+            default:
+                return;
+        }
+    }
+    function Pt(e) {
+        if (e === "") return {
+            ok: !1,
+            severity: "error",
+            reason: "pattern is empty"
+        };
+        const t = Nt(e);
+        if (!t.supported) return {
+            ok: !1,
+            severity: "warning",
+            reason: t.reason
+        };
+        try {
+            return new RegExp(t.pattern, "u"), {
+                ok: !0,
+                jsPattern: t.pattern
+            };
+        } catch (a) {
+            return {
+                ok: !1,
+                severity: "error",
+                reason: a instanceof Error ? a.message : String(a)
+            };
+        }
+    }
+    function $t(e) {
+        const t = [];
+        return e.specifications.forEach((a, i)=>{
+            wt(a, `specifications[${i}]`, t);
+        }), t;
+    }
+    function wt(e, t, a) {
+        const i = e.minOccurs, n = e.maxOccurs;
+        i !== void 0 && (!Number.isInteger(i) || i < 0) && a.push({
+            severity: "error",
+            code: "E_CARDINALITY_INVALID",
+            message: `minOccurs must be a non-negative integer; got ${i}`,
+            path: `${t}.minOccurs`,
+            detail: {
+                value: String(i)
+            }
+        }), n !== void 0 && n !== "unbounded" && (!Number.isInteger(n) || n < 0) && a.push({
+            severity: "error",
+            code: "E_CARDINALITY_INVALID",
+            message: `maxOccurs must be a non-negative integer or "unbounded"; got ${n}`,
+            path: `${t}.maxOccurs`,
+            detail: {
+                value: String(n)
+            }
+        }), typeof i == "number" && typeof n == "number" && i > n && a.push({
+            severity: "error",
+            code: "E_CARDINALITY_INVALID",
+            message: `minOccurs (${i}) is greater than maxOccurs (${n})`,
+            path: `${t}.minOccurs`,
+            detail: {
+                min: i,
+                max: n
+            }
+        }), e.applicability.cardinality && a.push({
+            severity: "warning",
+            code: "W_CARDINALITY_PROHIBITED_APPLICABILITY",
+            message: `cardinality="${e.applicability.cardinality}" has no effect on <applicability>`,
+            path: `${t}.applicability.cardinality`
+        }), e.applicability.facets.forEach((r, s)=>{
+            k(r, `${t}.applicability.facets[${s}]`, a);
+        }), e.requirements.forEach((r, s)=>{
+            k(r.facet, `${t}.requirements[${s}]`, a), Ft(r, `${t}.requirements[${s}]`, a);
+        });
+    }
+    function Ft(e, t, a) {
+        switch(e.cardinalityRaw !== void 0 && a.push({
+            severity: "error",
+            code: "E_CARDINALITY_INVALID",
+            message: `@cardinality="${e.cardinalityRaw}" is not a valid value; expected one of {required, optional, prohibited}`,
+            path: `${t}.cardinality`,
+            facetType: e.facet.type,
+            detail: {
+                value: e.cardinalityRaw
+            }
+        }), e.facet.type){
+            case "property":
+                {
+                    const i = e.facet.dataType !== void 0;
+                    e.optionality === "optional" && !i && a.push({
+                        severity: "error",
+                        code: "E_CARDINALITY_INVALID",
+                        message: "optional <property> requirement requires @dataType to be specified",
+                        path: `${t}.cardinality`,
+                        facetType: "property"
+                    }), e.optionality === "prohibited" && i && a.push({
+                        severity: "error",
+                        code: "E_CARDINALITY_INVALID",
+                        message: "prohibited <property> requirement is incompatible with @dataType",
+                        path: `${t}.cardinality`,
+                        facetType: "property"
+                    });
+                    break;
+                }
+            case "material":
+                {
+                    e.optionality === "optional" && (e.facet.value !== void 0 && !D(e.facet.value) || a.push({
+                        severity: "error",
+                        code: "E_CARDINALITY_INVALID",
+                        message: "optional <material> requirement must specify a non-empty <value> constraint",
+                        path: `${t}.cardinality`,
+                        facetType: "material"
+                    }));
+                    break;
+                }
+            case "classification":
+                {
+                    if (e.optionality === "optional") {
+                        const i = e.facet.system !== void 0 && !D(e.facet.system), n = e.facet.value !== void 0 && !D(e.facet.value);
+                        !i && !n && a.push({
+                            severity: "error",
+                            code: "E_CARDINALITY_INVALID",
+                            message: "optional <classification> requirement must specify <system> or <value>",
+                            path: `${t}.cardinality`,
+                            facetType: "classification"
+                        });
+                    }
+                    break;
+                }
+        }
+    }
+    function D(e) {
+        switch(e.type){
+            case "simpleValue":
+                return e.value === "" || e.value == null;
+            case "enumeration":
+                return e.values.length === 0;
+            case "pattern":
+                return e.pattern === "";
+            case "bounds":
+                return e.minInclusive === void 0 && e.maxInclusive === void 0 && e.minExclusive === void 0 && e.maxExclusive === void 0 && e.length === void 0 && e.minLength === void 0 && e.maxLength === void 0;
+        }
+    }
+    function k(e, t, a) {
+        switch(e.type){
+            case "entity":
+                E(e.name, `${t}.name`, a, e.type), e.predefinedType && E(e.predefinedType, `${t}.predefinedType`, a, e.type);
+                break;
+            case "attribute":
+                E(e.name, `${t}.name`, a, e.type), e.value && E(e.value, `${t}.value`, a, e.type);
+                break;
+            case "property":
+                E(e.propertySet, `${t}.propertySet`, a, e.type), E(e.baseName, `${t}.baseName`, a, e.type), e.dataType && E(e.dataType, `${t}.dataType`, a, e.type), e.value && E(e.value, `${t}.value`, a, e.type);
+                break;
+            case "classification":
+                e.system && E(e.system, `${t}.system`, a, e.type), e.value && E(e.value, `${t}.value`, a, e.type);
+                break;
+            case "material":
+                e.value && E(e.value, `${t}.value`, a, e.type);
+                break;
+            case "partOf":
+                e.entity && k(e.entity, `${t}.entity`, a);
+                break;
+        }
+    }
+    function E(e, t, a, i) {
+        switch(e.type){
+            case "enumeration":
+                if (e.values.length === 0 ? a.push({
+                    severity: "error",
+                    code: "E_RESTRICTION_EMPTY",
+                    message: "xs:enumeration must have at least one value",
+                    path: t,
+                    facetType: i
+                }) : e.values.some((n)=>n === "" || n == null) && a.push({
+                    severity: "warning",
+                    code: "E_RESTRICTION_EMPTY",
+                    message: "xs:enumeration has an empty entry",
+                    path: t,
+                    facetType: i
+                }), e.base) for (const n of e.values)n == null || n === "" || Dt(n, e.base) || a.push({
+                    severity: "error",
+                    code: "E_RESTRICTION_VALUE_MISMATCH",
+                    message: `xs:enumeration value "${n}" is not valid for xs:restriction @base="${e.base}"`,
+                    path: t,
+                    facetType: i,
+                    detail: {
+                        value: n,
+                        base: e.base
+                    }
+                });
+                break;
+            case "bounds":
+                Ot(e, t, a, i);
+                break;
+            case "pattern":
+                Lt(e.pattern, t, a, i);
+                break;
+        }
+    }
+    function Ot(e, t, a, i) {
+        const n = e.minInclusive ?? e.minExclusive, r = e.maxInclusive ?? e.maxExclusive;
+        typeof n == "number" && typeof r == "number" && n > r && a.push({
+            severity: "error",
+            code: "E_RESTRICTION_RANGE",
+            message: `xs:restriction bounds inverted: lower (${n}) > upper (${r})`,
+            path: t,
+            facetType: i,
+            detail: {
+                min: n,
+                max: r
+            }
+        }), typeof e.minLength == "number" && typeof e.maxLength == "number" && e.minLength > e.maxLength && a.push({
+            severity: "error",
+            code: "E_RESTRICTION_RANGE",
+            message: `xs:restriction lengths inverted: minLength (${e.minLength}) > maxLength (${e.maxLength})`,
+            path: t,
+            facetType: i,
+            detail: {
+                min: e.minLength,
+                max: e.maxLength
+            }
+        }), typeof e.length == "number" && (typeof e.minLength == "number" || typeof e.maxLength == "number") && a.push({
+            severity: "warning",
+            code: "E_RESTRICTION_RANGE",
+            message: "xs:length is mutually exclusive with xs:minLength/xs:maxLength",
+            path: t,
+            facetType: i
+        }), e.minInclusive === void 0 && e.minExclusive === void 0 && e.maxInclusive === void 0 && e.maxExclusive === void 0 && e.length === void 0 && e.minLength === void 0 && e.maxLength === void 0 && a.push({
+            severity: "error",
+            code: "E_RESTRICTION_EMPTY",
+            message: "xs:restriction has no min/max bounds or length facets",
+            path: t,
+            facetType: i
+        });
+    }
+    function Lt(e, t, a, i) {
+        const n = Pt(e);
+        if (!n.ok) {
+            if (n.severity === "error") {
+                a.push({
+                    severity: "error",
+                    code: "E_RESTRICTION_EMPTY",
+                    message: e === "" ? "xs:pattern @value is empty" : `xs:pattern is not a valid regular expression: ${n.reason}`,
+                    path: t,
+                    facetType: i,
+                    detail: e === "" ? void 0 : {
+                        pattern: e
+                    }
+                });
+                return;
+            }
+            a.push({
+                severity: "warning",
+                code: "W_REGEX_UNVERIFIED",
+                message: `xs:pattern uses XSD-specific syntax not verifiable in JS: ${n.reason}`,
+                path: t,
+                facetType: i,
+                detail: {
+                    pattern: e
+                }
+            });
+        }
+    }
+    const Vt = {
+        "xs:integer": /^[+-]?(\d+)$/,
+        "xs:double": /^([-+]?[0-9]*\.?[0-9]*([eE][-+]?[0-9]+)?|NaN|\+INF|-INF)$/,
+        "xs:float": /^([-+]?[0-9]*\.?[0-9]*([eE][-+]?[0-9]+)?|NaN|\+INF|-INF)$/,
+        "xs:decimal": /^([-+]?[0-9]*\.?[0-9]*([eE][-+]?[0-9]+)?|NaN|\+INF|-INF)$/,
+        "xs:boolean": /^(true|false|0|1)$/,
+        "xs:date": /^\d{4}-\d{2}-\d{2}(Z|([+-]\d{2}:\d{2}))?$/,
+        "xs:dateTime": /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|([+-]\d{2}:\d{2}))?$/,
+        "xs:time": /^\d{2}:\d{2}:\d{2}(\.\d+)?(Z|([+-]\d{2}:\d{2}))?$/,
+        "xs:duration": /^[-+]?P(\d+Y)?(\d+M)?(\d+D)?(T(\d+H)?(\d+M)?(\d+S)?)?$/
+    };
+    function Dt(e, t) {
+        const a = Vt[t];
+        return a ? (t === "xs:double" || t === "xs:float" || t === "xs:decimal") && !/[0-9]/.test(e) ? !1 : a.test(e) : !0;
+    }
+    async function Ut(e, t) {
+        const a = [];
+        for(let i = 0; i < e.specifications.length; i++){
+            const n = e.specifications[i], r = kt(n, t.ifcVersion);
+            if (r.length === 0) continue;
+            const s = new Set;
+            for (const l of r){
+                const o = [];
+                await Bt(n, l, `specifications[${i}]`, o);
+                for (const u of o){
+                    const c = `${u.code}|${u.path}|${u.message}`;
+                    s.has(c) || (s.add(c), a.push(u));
+                }
+            }
+        }
+        return a;
+    }
+    function kt(e, t) {
+        if (t) {
+            const n = G(t);
+            return n ? [
+                n
+            ] : [];
+        }
+        const a = [], i = new Set;
+        for (const n of e.ifcVersions){
+            const r = G(n);
+            r && !i.has(r) && (i.add(r), a.push(r));
+        }
+        return a;
+    }
+    function G(e) {
+        switch(e){
+            case "IFC2X3":
+            case "IFC4":
+            case "IFC4X3":
+            case "IFC4X3_ADD2":
+                return e;
+            default:
+                return;
+        }
+    }
+    async function Bt(e, t, a, i) {
+        const n = e.applicability.facets.find((r)=>r.type === "entity");
+        for(let r = 0; r < e.applicability.facets.length; r++){
+            const s = e.applicability.facets[r];
+            await j(s, t, `${a}.applicability.facets[${r}]`, n, i);
+        }
+        for(let r = 0; r < e.requirements.length; r++){
+            const s = e.requirements[r];
+            await j(s.facet, t, `${a}.requirements[${r}]`, n, i);
+        }
+    }
+    async function j(e, t, a, i, n) {
+        switch(e.type){
+            case "entity":
+                await Ht(e, t, a, n);
+                break;
+            case "property":
+                await Gt(e, t, a, i, n);
+                break;
+            case "attribute":
+                await Zt(e, t, a, i, n);
+                break;
+            case "partOf":
+                await ti(e, t, a, i, n);
+                break;
+            case "classification":
+                await qt(t, i, a, n);
+                break;
+            case "material":
+                await Yt(t, i, a, n);
+                break;
+        }
+    }
+    async function qt(e, t, a, i) {
+        if (!t || t.name.type !== "simpleValue") return;
+        const n = t.name.value;
+        if (!n) return;
+        const r = e === "IFC2X3" ? "IfcRoot" : "IfcObjectDefinition";
+        await $(e, n, r) || i.push({
+            severity: "error",
+            code: "E_IFC_PARTOF_ENTITY",
+            message: `applicability entity "${n}" cannot be classified in ${e} (must be a subtype of ${r})`,
+            path: a,
+            facetType: "classification",
+            detail: {
+                value: n,
+                required: r,
+                version: e
+            }
+        });
+    }
+    async function Yt(e, t, a, i) {
+        if (!t || t.name.type !== "simpleValue") return;
+        const n = t.name.value;
+        if (!n) return;
+        const r = e === "IFC2X3" ? "IfcRoot" : "IfcObjectDefinition";
+        await $(e, n, r) || i.push({
+            severity: "error",
+            code: "E_IFC_PARTOF_ENTITY",
+            message: `applicability entity "${n}" cannot have a material in ${e} (must be a subtype of ${r})`,
+            path: a,
+            facetType: "material",
+            detail: {
+                value: n,
+                required: r,
+                version: e
+            }
+        });
+    }
+    async function Ht(e, t, a, i) {
+        if (e.name.type !== "simpleValue") return;
+        const n = e.name.value;
+        if (!n) return;
+        const r = await J(t, n);
+        if (!r) {
+            i.push({
+                severity: "error",
+                code: "E_IFC_ENTITY_UNKNOWN",
+                message: `entity name "${n}" is not a known IFC entity for ${t}`,
+                path: `${a}.name`,
+                facetType: "entity",
+                detail: {
+                    value: n,
+                    version: t
+                }
+            });
+            return;
+        }
+        e.predefinedType && r.predefinedTypes.length > 0 && Xt(e.predefinedType, r, t, `${a}.predefinedType`, i);
+    }
+    function Xt(e, t, a, i, n) {
+        const r = (s)=>t.predefinedTypes.includes(s.toUpperCase());
+        switch(e.type){
+            case "simpleValue":
+                {
+                    const s = e.value;
+                    s && !r(s) && n.push({
+                        severity: "error",
+                        code: "E_IFC_PREDEF_TYPE_INVALID",
+                        message: `predefined type "${s}" is not valid for ${t.name} (${a})`,
+                        path: i,
+                        facetType: "entity",
+                        detail: {
+                            value: s,
+                            entity: t.name,
+                            version: a
+                        }
+                    });
+                    break;
+                }
+            case "enumeration":
+                {
+                    for (const s of e.values)s && !r(s) && n.push({
+                        severity: "error",
+                        code: "E_IFC_PREDEF_TYPE_INVALID",
+                        message: `predefined type enumeration value "${s}" is not valid for ${t.name} (${a})`,
+                        path: i,
+                        facetType: "entity",
+                        detail: {
+                            value: s,
+                            entity: t.name,
+                            version: a
+                        }
+                    });
+                    break;
+                }
+            case "pattern":
+                {
+                    try {
+                        const s = new RegExp(`^${e.pattern}$`);
+                        t.predefinedTypes.some((o)=>s.test(o)) || n.push({
+                            severity: "error",
+                            code: "E_IFC_PREDEF_TYPE_INVALID",
+                            message: `predefined type pattern "${e.pattern}" matches no value for ${t.name} (${a})`,
+                            path: i,
+                            facetType: "entity",
+                            detail: {
+                                pattern: e.pattern,
+                                entity: t.name,
+                                version: a
+                            }
+                        });
+                    } catch  {}
+                    break;
+                }
+        }
+    }
+    async function Gt(e, t, a, i, n) {
+        if (e.dataType && e.dataType.type === "simpleValue") {
+            const o = e.dataType.value;
+            if (o) {
+                const u = await ve(t, o);
+                u ? e.value && Wt(e.value, u.backingType, o, `${a}.value`, n) : n.push({
+                    severity: "error",
+                    code: "E_IFC_DATATYPE_UNKNOWN",
+                    message: `dataType "${o}" is not a known IFC measure/type for ${t}`,
+                    path: `${a}.dataType`,
+                    facetType: "property",
+                    detail: {
+                        value: o,
+                        version: t
+                    }
+                });
+            }
+        }
+        if (e.propertySet.type !== "simpleValue") return;
+        const r = e.propertySet.value;
+        if (!r) return;
+        const s = await Ee(t, r), l = Te.some((o)=>r.startsWith(o));
+        if (!s) {
+            l && n.push({
+                severity: "warning",
+                code: "W_IFC_PSET_RESERVED_PREFIX",
+                message: `property set "${r}" uses a reserved buildingSMART prefix but is not a known standard ${r.startsWith("Qto_") ? "quantity set" : "pset"} for ${t}`,
+                path: `${a}.propertySet`,
+                facetType: "property",
+                detail: {
+                    value: r,
+                    version: t
+                }
+            });
+            return;
+        }
+        if (i && s.applicableEntities.length > 0) {
+            const o = await Jt(i, t);
+            if (o.length > 0 && !(await Promise.all(o.map((c)=>Qt(t, c, s.applicableEntities)))).some(Boolean)) {
+                const c = o.length === 1 ? o[0] : `{${o.join(", ")}}`;
+                n.push({
+                    severity: "error",
+                    code: "E_IFC_PROP_NOT_IN_PSET",
+                    message: `${s.name} is not applicable to ${c} in ${t}`,
+                    path: `${a}.propertySet`,
+                    facetType: "property",
+                    detail: {
+                        pset: s.name,
+                        entity: c,
+                        version: t
+                    }
+                });
+            }
+        }
+        if (e.baseName.type === "simpleValue") {
+            const o = e.baseName.value;
+            if (o) {
+                const u = s.properties.find((c)=>c.name === o);
+                u ? e.dataType && e.dataType.type === "simpleValue" && e.dataType.value && jt(u, e.dataType.value, a, s.name, o, n) : n.push({
+                    severity: "error",
+                    code: "E_IFC_PROP_NOT_IN_PSET",
+                    message: `property "${o}" is not part of ${s.name} (${t})`,
+                    path: `${a}.baseName`,
+                    facetType: "property",
+                    detail: {
+                        property: o,
+                        pset: s.name,
+                        version: t
+                    }
+                });
+            }
+        }
+    }
+    function jt(e, t, a, i, n, r) {
+        const s = t.toUpperCase();
+        if (e.dataType && e.dataType.toUpperCase() === s) return;
+        const l = Kt(e.kind);
+        l && s === l || r.push({
+            severity: "error",
+            code: "W_IFC_DATATYPE_MISMATCH",
+            message: `${i}.${n} is typed ${e.dataType ?? e.kind} in the standard, not ${t}`,
+            path: `${a}.dataType`,
+            facetType: "property",
+            detail: {
+                expected: e.dataType ?? e.kind,
+                actual: t,
+                property: n
+            }
+        });
+    }
+    function Wt(e, t, a, i, n) {
+        if (e.type === "simpleValue") return;
+        const r = e.type === "pattern" || e.type === "enumeration" || e.type === "bounds" ? e.base : void 0;
+        let s;
+        if (r) s = r;
+        else switch(e.type){
+            case "pattern":
+            case "enumeration":
+                s = "xs:string";
+                break;
+            case "bounds":
+                typeof e.length == "number" || typeof e.minLength == "number" || typeof e.maxLength == "number" ? s = "xs:string" : s = "xs:double";
+                break;
+        }
+        s && (zt(s, t) || n.push({
+            severity: "error",
+            code: "E_RESTRICTION_BASE_MISMATCH",
+            message: `xs:restriction base (${s}) is not compatible with dataType "${a}" (backing ${t})`,
+            path: i,
+            facetType: "property",
+            detail: {
+                inferred: s,
+                expected: t,
+                dataType: a
+            }
+        }));
+    }
+    function zt(e, t) {
+        if (e === t) return !0;
+        const a = new Set([
+            "xs:double",
+            "xs:decimal",
+            "xs:float"
+        ]);
+        return !!(a.has(e) && a.has(t));
+    }
+    function Kt(e) {
+        switch(e){
+            case "single":
+                return "IFCPROPERTYSINGLEVALUE";
+            case "enumeration":
+                return "IFCPROPERTYENUMERATEDVALUE";
+            case "list":
+                return "IFCPROPERTYLISTVALUE";
+            case "bounded":
+                return "IFCPROPERTYBOUNDEDVALUE";
+            case "reference":
+                return "IFCPROPERTYREFERENCEVALUE";
+            default:
+                return;
+        }
+    }
+    async function Qt(e, t, a) {
+        for (const i of a)if (await $(e, t, i)) return !0;
+        return !1;
+    }
+    async function Jt(e, t) {
+        switch(e.name.type){
+            case "simpleValue":
+                return e.name.value ? [
+                    e.name.value
+                ] : [];
+            case "enumeration":
+                return e.name.values.filter((a)=>!!a);
+            case "pattern":
+                try {
+                    const a = new RegExp(`^${e.name.pattern}$`), { getEntities: i } = await Ie(async ()=>{
+                        const { getEntities: r } = await import("./exporters-u0sz2Upj.js").then(async (m)=>{
+                            await m.__tla;
+                            return m;
+                        }).then((s)=>s.ao);
+                        return {
+                            getEntities: r
+                        };
+                    }, __vite__mapDeps([0,1,2,3,4,5]));
+                    return (await i(t)).filter((r)=>a.test(r.name.toUpperCase()) || a.test(r.name)).map((r)=>r.name);
+                } catch  {
+                    return [];
+                }
+            default:
+                return [];
+        }
+    }
+    async function Zt(e, t, a, i, n) {
+        if (!i || i.name.type !== "simpleValue" || e.name.type !== "simpleValue") return;
+        const r = i.name.value, s = e.name.value;
+        if (!r || !s) return;
+        const l = await ye(t, r);
+        if (l.length === 0) return;
+        if (!ei(l, s)) {
+            n.push({
+                severity: "error",
+                code: "E_IFC_ATTR_UNKNOWN_FOR_ENTITY",
+                message: `attribute "${s}" is not defined on ${l[0].name} (${t})`,
+                path: `${a}.name`,
+                facetType: "attribute",
+                detail: {
+                    attribute: s,
+                    entity: l[0].name,
+                    version: t
+                }
+            });
+            return;
+        }
+        if (e.value === void 0) return;
+        const o = await he(t, s);
+        if (!o) return;
+        const u = l[0].name.toUpperCase(), c = l.map((m)=>m.name.toUpperCase()), f = c.some((m)=>o.simpleValueEntities.includes(m)), d = c.some((m)=>o.complexEntities.includes(m));
+        !f && d && n.push({
+            severity: "error",
+            code: "E_IFC_ATTR_UNKNOWN_FOR_ENTITY",
+            message: `attribute "${s}" on ${u} is a complex/entity-typed attribute and cannot carry a simple <value> constraint (${t})`,
+            path: `${a}.value`,
+            facetType: "attribute",
+            detail: {
+                attribute: s,
+                entity: u,
+                version: t
+            }
+        });
+    }
+    function ei(e, t) {
+        const a = t.toLowerCase();
+        for (const i of e)for (const n of i.attributes)if (n.toLowerCase() === a) return !0;
+        return !1;
+    }
+    async function ti(e, t, a, i, n) {
+        const r = await fe(t), s = e.rawRelation ?? e.relation, l = s.toUpperCase(), o = r.find((u)=>u.relation === l);
+        if (!o) {
+            n.push({
+                severity: "error",
+                code: "E_IFC_PARTOF_RELATION",
+                message: `partOf relation "${s}" is not valid for ${t}`,
+                path: `${a}.relation`,
+                facetType: "partOf",
+                detail: {
+                    value: s,
+                    version: t
+                }
+            });
+            return;
+        }
+        if (e.entity && e.entity.name.type === "simpleValue" && e.entity.name.value) {
+            const u = e.entity.name.value, c = await J(t, u);
+            if (!c) {
+                n.push({
+                    severity: "error",
+                    code: "E_IFC_PARTOF_ENTITY",
+                    message: `partOf entity "${u}" is not a known IFC entity for ${t}`,
+                    path: `${a}.entity.name`,
+                    facetType: "partOf",
+                    detail: {
+                        value: u,
+                        version: t
+                    }
+                });
+                return;
+            }
+            const f = o.owner;
+            await $(t, c.name, f) || n.push({
+                severity: "error",
+                code: "E_IFC_PARTOF_ENTITY",
+                message: `partOf @entity "${c.name}" is not a subtype of "${f}" required by ${e.relation} (${t})`,
+                path: `${a}.entity.name`,
+                facetType: "partOf",
+                detail: {
+                    value: c.name,
+                    required: f,
+                    relation: e.relation,
+                    version: t
+                }
+            });
+        }
+        if (i && i.name.type === "simpleValue" && i.name.value) {
+            const u = i.name.value;
+            await $(t, u, o.member) || n.push({
+                severity: "error",
+                code: "E_IFC_PARTOF_ENTITY",
+                message: `applicability entity "${u}" cannot be the member of ${e.relation}; ${e.relation} requires the member to be a subtype of "${o.member}" (${t})`,
+                path: `${a}.relation`,
+                facetType: "partOf",
+                detail: {
+                    applicability: u,
+                    required: o.member,
+                    relation: e.relation,
+                    version: t
+                }
+            });
+        }
+    }
+    function ii(e) {
+        try {
+            return {
+                document: Ne(e),
+                issues: []
+            };
+        } catch (t) {
+            return {
+                issues: [
+                    ai(t)
+                ]
+            };
+        }
+    }
+    function ai(e) {
+        if (e instanceof g) {
+            const t = e.details ? `${e.message}: ${e.details}` : e.message;
+            let a = "E_PARSE_UNKNOWN";
+            return e.message.includes("Failed to parse IDS XML") || e.message.includes("Invalid XML format") || e.message.includes("No DOMParser") ? a = "E_PARSE_XML" : e.message.includes("Invalid root element") ? a = "E_PARSE_ROOT" : e.message.includes("facet") && (a = "E_PARSE_FACET"), {
+                severity: "error",
+                code: a,
+                message: t,
+                path: ""
+            };
+        }
+        return {
+            severity: "error",
+            code: "E_PARSE_UNKNOWN",
+            message: e instanceof Error ? e.message : String(e),
+            path: ""
+        };
+    }
+    const le = "http://www.w3.org/2001/XMLSchema", oe = new Set([
+        "xmlns",
+        "xsi",
+        "xml"
+    ]), ni = {
+        attrs: [],
+        children: [
+            "info",
+            "specifications"
+        ]
+    }, ri = {
+        attrs: [],
+        children: [
+            "title",
+            "copyright",
+            "version",
+            "description",
+            "author",
+            "date",
+            "purpose",
+            "milestone"
+        ]
+    }, si = {
+        attrs: [],
+        children: [
+            "specification"
+        ]
+    }, li = {
+        attrs: [
+            "name",
+            "ifcVersion",
+            "identifier",
+            "description",
+            "instructions"
+        ],
+        requiredAttrs: [
+            "name",
+            "ifcVersion"
+        ],
+        children: [
+            "applicability",
+            "requirements"
+        ]
+    }, oi = {
+        attrs: [
+            "minOccurs",
+            "maxOccurs"
+        ],
+        children: [
+            "entity",
+            "partOf",
+            "classification",
+            "attribute",
+            "property",
+            "material"
+        ]
+    }, ui = {
+        attrs: [
+            "description"
+        ],
+        children: [
+            "entity",
+            "partOf",
+            "classification",
+            "attribute",
+            "property",
+            "material"
+        ]
+    }, ci = {
+        attrs: [],
+        children: [
+            "name",
+            "predefinedType"
+        ]
+    }, pi = {
+        attrs: [],
+        children: [
+            "name",
+            "value"
+        ]
+    }, di = {
+        attrs: [],
+        children: [
+            "value",
+            "system"
+        ]
+    }, mi = {
+        attrs: [
+            "relation"
+        ],
+        children: [
+            "entity"
+        ]
+    }, fi = {
+        attrs: [
+            "dataType"
+        ],
+        children: [
+            "propertySet",
+            "baseName",
+            "value"
+        ]
+    }, yi = {
+        attrs: [],
+        children: [
+            "value"
+        ]
+    };
+    function hi(e) {
+        const t = ue(e);
+        switch(e.toLowerCase()){
+            case "entity":
+                return {
+                    ...t,
+                    attrs: [
+                        ...t.attrs,
+                        "instructions"
+                    ]
+                };
+            case "partof":
+                return {
+                    ...t,
+                    attrs: [
+                        ...t.attrs,
+                        "cardinality",
+                        "instructions"
+                    ]
+                };
+            case "attribute":
+                return {
+                    ...t,
+                    attrs: [
+                        ...t.attrs,
+                        "cardinality",
+                        "instructions"
+                    ]
+                };
+            case "classification":
+            case "property":
+            case "material":
+                return {
+                    ...t,
+                    attrs: [
+                        ...t.attrs,
+                        "cardinality",
+                        "instructions",
+                        "uri"
+                    ]
+                };
+            default:
+                return t;
+        }
+    }
+    function ue(e) {
+        switch(e.toLowerCase()){
+            case "entity":
+                return ci;
+            case "attribute":
+                return pi;
+            case "classification":
+                return di;
+            case "partof":
+                return mi;
+            case "property":
+                return fi;
+            case "material":
+                return yi;
+            default:
+                return {
+                    attrs: [],
+                    children: []
+                };
+        }
+    }
+    const vi = {
+        attrs: [],
+        children: [
+            "simpleValue"
+        ],
+        xsChildren: [
+            "restriction"
+        ]
+    }, Ei = {
+        attrs: [],
+        children: [],
+        textOnly: !0
+    }, ce = [
+        "enumeration",
+        "pattern",
+        "minInclusive",
+        "maxInclusive",
+        "minExclusive",
+        "maxExclusive",
+        "length",
+        "minLength",
+        "maxLength",
+        "totalDigits",
+        "fractionDigits",
+        "whiteSpace"
+    ], Ti = {
+        attrs: [
+            "base"
+        ],
+        children: [],
+        xsChildren: ce
+    }, Ii = {
+        attrs: [
+            "value"
+        ],
+        children: [],
+        textOnly: !0
+    };
+    async function bi(e) {
+        const t = [], a = typeof e == "string" ? e : new TextDecoder().decode(e), i = a.charCodeAt(0) === 65279 ? a.slice(1) : a, n = await gi();
+        let r;
+        try {
+            r = n.parseFromString(i, "text/xml");
+        } catch  {
+            return t;
+        }
+        const s = r.documentElement;
+        return !s || (s.localName ?? "").toLowerCase() !== "ids" || Si(s, t), t;
+    }
+    let w;
+    function gi() {
+        return w || (w = (async ()=>{
+            const e = globalThis.DOMParser;
+            if (typeof e == "function") return new e;
+            const a = await import("@xmldom/xmldom").then(async (m)=>{
+                await m.__tla;
+                return m;
+            });
+            return new a.DOMParser;
+        })(), w);
+    }
+    function Si(e, t) {
+        S(e, ni, "ids", t);
+        for (const a of R(e)){
+            const i = (a.localName ?? "").toLowerCase();
+            i === "info" ? Ai(a, "ids.info", t) : i === "specifications" && xi(a, "ids.specifications", t);
+        }
+    }
+    function Ai(e, t, a) {
+        S(e, ri, t, a);
+    }
+    function xi(e, t, a) {
+        S(e, si, t, a);
+        let i = 0;
+        for (const n of R(e))(n.localName ?? "").toLowerCase() === "specification" && Ci(n, `${t}.specification[${i++}]`, a);
+    }
+    function Ci(e, t, a) {
+        S(e, li, t, a);
+        for (const i of R(e)){
+            const n = (i.localName ?? "").toLowerCase();
+            n === "applicability" ? W(i, `${t}.applicability`, !1, a) : n === "requirements" && W(i, `${t}.requirements`, !0, a);
+        }
+    }
+    function W(e, t, a, i) {
+        S(e, a ? ui : oi, t, i);
+        let n = 0;
+        for (const r of R(e)){
+            const s = (r.localName ?? "").toLowerCase();
+            pe(r, s, `${t}.facets[${n++}]`, a, i);
+        }
+    }
+    function pe(e, t, a, i, n) {
+        const r = i ? hi(t) : ue(t);
+        S(e, r, a, n);
+        for (const s of R(e)){
+            const l = (s.localName ?? "").toLowerCase();
+            Ri(s, l, `${a}.${l}`, i, n);
+        }
+    }
+    function Ri(e, t, a, i, n) {
+        switch(t){
+            case "entity":
+                pe(e, "entity", a, !1, n);
+                return;
+            case "name":
+            case "value":
+            case "baseName":
+            case "propertySet":
+            case "system":
+            case "predefinedType":
+                Mi(e, a, n);
+                return;
+            default:
+                return;
+        }
+    }
+    function Mi(e, t, a) {
+        S(e, vi, t, a);
+        for (const i of R(e)){
+            const n = (i.localName ?? "").toLowerCase();
+            n === "simpleValue" ? S(i, Ei, `${t}.simpleValue`, a) : n === "restriction" && (i.namespaceURI === le || i.namespaceURI === null) && Ni(i, `${t}.restriction`, a);
+        }
+    }
+    function Ni(e, t, a) {
+        S(e, Ti, t, a);
+        for (const i of R(e)){
+            const n = (i.localName ?? "").toLowerCase();
+            ce.includes(n) && S(i, Ii, `${t}.${n}`, a);
+        }
+    }
+    function S(e, t, a, i) {
+        const n = new Set(t.attrs.map((l)=>l.toLowerCase()));
+        for (const l of Array.from(e.attributes ?? [])){
+            if (wi(l)) continue;
+            const o = l.nodeName ?? "";
+            if (Pi(o)) continue;
+            const u = l.localName ?? l.nodeName ?? "", c = u.indexOf(":"), f = c === -1 ? u.toLowerCase() : u.slice(c + 1).toLowerCase(), d = c === -1 ? "" : u.slice(0, c).toLowerCase();
+            !f || f === "xmlns" || d === "xmlns" || oe.has(d) || n.has(f) || i.push({
+                severity: "error",
+                code: "E_XSD_STRUCTURE",
+                message: `unexpected attribute "${u}" on <${e.localName}>`,
+                path: a,
+                detail: {
+                    attribute: u,
+                    element: e.localName ?? ""
+                }
+            });
+        }
+        if (t.requiredAttrs) for (const l of t.requiredAttrs)_i(e, l) || i.push({
+            severity: "error",
+            code: "E_XSD_REQUIRED_ATTR",
+            message: `<${e.localName}> is missing required @${l}`,
+            path: a,
+            detail: {
+                attribute: l,
+                element: e.localName ?? ""
+            }
+        });
+        const r = new Set(t.children.map((l)=>l.toLowerCase())), s = new Set((t.xsChildren ?? []).map((l)=>l.toLowerCase()));
+        for (const l of R(e)){
+            const o = (l.localName ?? "").toLowerCase();
+            if (l.namespaceURI === le) {
+                s.has(o) || i.push({
+                    severity: "error",
+                    code: "E_XSD_STRUCTURE",
+                    message: `unexpected XSD child <xs:${o}> in <${e.localName}>`,
+                    path: a,
+                    detail: {
+                        child: `xs:${o}`,
+                        parent: e.localName ?? ""
+                    }
+                });
+                continue;
+            }
+            r.has(o) || i.push({
+                severity: "error",
+                code: "E_XSD_STRUCTURE",
+                message: `unexpected child <${l.localName}> in <${e.localName}>`,
+                path: a,
+                detail: {
+                    child: l.localName ?? "",
+                    parent: e.localName ?? ""
+                }
+            });
+        }
+        t.textOnly;
+    }
+    function _i(e, t) {
+        if (typeof e.hasAttribute == "function" && e.hasAttribute(t)) return !0;
+        for (const a of Array.from(e.attributes ?? []))if ((a.localName ?? a.nodeName ?? "").toLowerCase() === t.toLowerCase()) return !0;
+        return !1;
+    }
+    function Pi(e) {
+        if (!e) return !1;
+        if (e === "xmlns") return !0;
+        const t = e.indexOf(":");
+        return t === -1 ? !1 : oe.has(e.slice(0, t));
+    }
+    const $i = new Set([
+        "http://www.w3.org/2000/xmlns/",
+        "http://www.w3.org/XML/1998/namespace",
+        "http://www.w3.org/2001/XMLSchema-instance"
+    ]);
+    function wi(e) {
+        return e.namespaceURI !== null && $i.has(e.namespaceURI);
+    }
+    function R(e) {
+        if (e.children && e.children.length !== void 0) return Array.from(e.children);
+        const t = [], a = e.childNodes ?? [];
+        for(let i = 0; i < a.length; i++){
+            const n = a[i];
+            n && n.nodeType === 1 && t.push(n);
+        }
+        return t;
+    }
+    const Fi = [
+        "IFC2X3",
+        "IFC4",
+        "IFC4X3_ADD2",
+        "IFC4X3"
+    ], Oi = new Set([
+        "IFC2X3",
+        "IFC4",
+        "IFC4X3",
+        "IFC4X3_ADD2"
+    ]);
+    function Li(e) {
+        return Oi.has(e.toUpperCase().replace(/[^A-Z0-9_]/g, ""));
+    }
+    const Vi = new Set([
+        "entity",
+        "attribute",
+        "classification",
+        "material",
+        "partOf",
+        "property"
+    ]), Di = [
+        "http://standards.buildingsmart.org/IDS/1.0/ids.xsd",
+        "http://standards.buildingsmart.org/IDS/0.9.7/ids.xsd",
+        "http://standards.buildingsmart.org/IDS/0.9.6/ids.xsd",
+        "http://standards.buildingsmart.org/IDS/ids.xsd"
+    ];
+    function Ui(e) {
+        const t = [];
+        if (e.schemaLocation) {
+            const a = e.schemaLocation.split(/\s+/).filter((i)=>i.length > 0);
+            for(let i = 0; i + 1 < a.length; i += 2){
+                const n = a[i], r = a[i + 1];
+                n === "http://standards.buildingsmart.org/IDS" && (Di.includes(r) || t.push({
+                    severity: "error",
+                    code: "E_XSD_SCHEMA_LOCATION",
+                    message: `xsi:schemaLocation references "${r}", not a recognised IDS XSD`,
+                    path: "schemaLocation",
+                    detail: {
+                        url: r
+                    }
+                }));
+            }
+        }
+        return (!e.info.title || e.info.title.trim() === "" || e.info.title === "Untitled IDS") && t.push({
+            severity: "warning",
+            code: "E_XSD_REQUIRED_ATTR",
+            message: "IDS document is missing a non-empty <info><title> element",
+            path: "info.title"
+        }), e.specifications.forEach((a, i)=>ki(a, i, t)), t;
+    }
+    function ki(e, t, a) {
+        const i = `specifications[${t}]`;
+        if ((!e.name || e.name.trim() === "" || /^Specification \d+$/.test(e.name)) && a.push({
+            severity: "error",
+            code: "E_XSD_REQUIRED_ATTR",
+            message: "specification is missing a non-empty @name attribute",
+            path: `${i}.name`
+        }), !e.ifcVersions || e.ifcVersions.length === 0) a.push({
+            severity: "error",
+            code: "E_XSD_REQUIRED_ATTR",
+            message: "specification is missing the @ifcVersion attribute",
+            path: `${i}.ifcVersion`
+        });
+        else for (const n of e.ifcVersions)Fi.includes(n) || a.push({
+            severity: "error",
+            code: "E_XSD_ENUM",
+            message: `@ifcVersion "${n}" is not in {IFC2X3, IFC4, IFC4X3_ADD2}`,
+            path: `${i}.ifcVersion`,
+            detail: {
+                value: n
+            }
+        });
+        if (e.ifcVersionRaw) {
+            const n = e.ifcVersionRaw.split(/\s+/).filter((r)=>r.length > 0);
+            for (const r of n)Li(r) || a.push({
+                severity: "error",
+                code: "E_XSD_ENUM",
+                message: `@ifcVersion token "${r}" is not in {IFC2X3, IFC4, IFC4X3_ADD2}`,
+                path: `${i}.ifcVersion`,
+                detail: {
+                    value: r
+                }
+            });
+        }
+        e.applicability.facets.length === 0 && a.push({
+            severity: "error",
+            code: "E_XSD_STRUCTURE",
+            message: "specification has an empty <applicability> — at least one facet is required",
+            path: `${i}.applicability`
+        }), e.applicability.facets.forEach((n, r)=>{
+            z(n, `${i}.applicability.facets[${r}]`, a);
+        }), e.requirements.length === 0 && a.push({
+            severity: "warning",
+            code: "E_XSD_STRUCTURE",
+            message: "specification has no <requirements>; matched entities will not be checked",
+            path: `${i}.requirements`
+        }), e.requirements.forEach((n, r)=>{
+            z(n.facet, `${i}.requirements[${r}]`, a);
+        });
+    }
+    function z(e, t, a) {
+        if (!Vi.has(e.type)) {
+            a.push({
+                severity: "error",
+                code: "E_XSD_STRUCTURE",
+                message: `unknown facet type "${e.type}"`,
+                path: t,
+                facetType: e.type
+            });
+            return;
+        }
+        switch(e.type){
+            case "entity":
+                F(e.name, `${t}.name`, "entity.name", a, e.type);
+                break;
+            case "attribute":
+                F(e.name, `${t}.name`, "attribute.name", a, e.type);
+                break;
+            case "property":
+                F(e.propertySet, `${t}.propertySet`, "property.propertySet", a, e.type), F(e.baseName, `${t}.baseName`, "property.baseName", a, e.type);
+                break;
+        }
+    }
+    function F(e, t, a, i, n) {
+        if (!e) {
+            i.push({
+                severity: "error",
+                code: "E_XSD_REQUIRED_ATTR",
+                message: `${a} is required`,
+                path: t,
+                facetType: n
+            });
+            return;
+        }
+        e.type === "simpleValue" && (!e.value || e.value.trim() === "") && i.push({
+            severity: "error",
+            code: "E_XSD_REQUIRED_ATTR",
+            message: `${a} must have a non-empty value`,
+            path: t,
+            facetType: n
+        });
+    }
+    oa = async function(e, t = {}) {
+        const { document: a, issues: i } = ii(e);
+        if (!a) return B(i);
+        const n = t.xsdValidation === !1 ? [] : await bi(e), r = await Bi(a, t);
+        return B([
+            ...i,
+            ...n,
+            ...r.issues
+        ], a);
+    };
+    async function Bi(e, t = {}) {
+        const a = t.xsdValidation !== !1, i = t.ifcSchemaChecks !== !1, n = t.coherenceChecks !== !1, r = [];
+        return a && r.push(...Ui(e)), n && r.push(...$t(e)), i && r.push(...await Ut(e, {
+            ifcVersion: t.ifcVersion
+        })), B(r, e);
+    }
+    function B(e, t) {
+        let a = "valid";
+        for (const i of e){
+            if (i.severity === "error") {
+                a = "error";
+                break;
+            }
+            (i.severity === "warning" || i.severity === "info") && (a = "warning");
+        }
+        return {
+            status: a,
+            issues: e,
+            parsedDocument: t
+        };
+    }
+    const qi = {
+        status: {
+            pass: "PASS",
+            fail: "FAIL",
+            not_applicable: "NOT APPLICABLE"
+        },
+        optionality: {
+            required: "Required",
+            optional: "Optional",
+            prohibited: "Prohibited"
+        },
+        cardinality: {
+            satisfied: "Cardinality satisfied",
+            atLeast: "Expected at least {min}, found {count}",
+            atMost: "Expected at most {max}, found {count}",
+            between: "Expected between {min} and {max}, found {count}",
+            exactly: "Expected exactly {count}"
+        },
+        relations: {
+            IfcRelAggregates: "part of",
+            IfcRelAssignsToGroup: "grouped in",
+            IfcRelContainedInSpatialStructure: "contained in",
+            IfcRelNests: "nested in",
+            IfcRelVoidsElement: "voiding",
+            IfcRelFillsElement: "filling"
+        },
+        constraints: {
+            simpleValue: '"{value}"',
+            pattern: 'matching pattern "{pattern}"',
+            enumeration: {
+                single: '"{value}"',
+                multiple: "one of [{values}]"
+            },
+            bounds: {
+                between: "between {min} and {max}",
+                atLeast: "at least {min}",
+                atMost: "at most {max}",
+                greaterThan: "greater than {min}",
+                lessThan: "less than {max}"
+            }
+        },
+        applicability: {
+            entity: {
+                simple: "Elements of type {entityType}",
+                withPredefined: "{entityType} elements with predefined type {predefinedType}",
+                pattern: "Elements with type matching {pattern}"
+            },
+            attribute: {
+                exists: 'Elements where attribute "{name}" exists',
+                equals: 'Elements where "{name}" equals {value}',
+                pattern: 'Elements where "{name}" matches {pattern}'
+            },
+            property: {
+                exists: 'Elements with property "{property}" in "{pset}"',
+                equals: 'Elements where "{pset}.{property}" equals {value}',
+                pattern: 'Elements where "{pset}.{property}" matches {pattern}',
+                bounded: 'Elements where "{pset}.{property}" is {bounds}'
+            },
+            classification: {
+                any: "Elements with any classification",
+                system: 'Elements classified in "{system}"',
+                value: 'Elements with classification "{value}"',
+                systemAndValue: 'Elements classified as "{value}" in "{system}"'
+            },
+            material: {
+                any: "Elements with any material assigned",
+                value: 'Elements with material "{value}"',
+                pattern: "Elements with material matching {pattern}"
+            },
+            partOf: {
+                simple: "Elements that are {relation} another element",
+                withEntity: "Elements that are {relation} a {entity}",
+                withEntityAndType: "Elements that are {relation} a {entity} with type {predefinedType}"
+            }
+        },
+        requirements: {
+            entity: {
+                mustBe: "Must be of type {entityType}",
+                mustHavePredefined: "Must have predefined type {predefinedType}",
+                mustBeWithPredefined: "Must be {entityType} with predefined type {predefinedType}"
+            },
+            attribute: {
+                mustExist: 'Attribute "{name}" must exist',
+                mustEqual: 'Attribute "{name}" must equal {value}',
+                mustMatch: 'Attribute "{name}" must match {pattern}',
+                mustNotExist: 'Attribute "{name}" must not exist',
+                mustNotEqual: 'Attribute "{name}" must not equal {value}'
+            },
+            property: {
+                mustExist: 'Property "{pset}.{property}" must exist',
+                mustEqual: 'Property "{pset}.{property}" must equal {value}',
+                mustMatch: 'Property "{pset}.{property}" must match {pattern}',
+                mustBeBounded: 'Property "{pset}.{property}" must be {bounds}',
+                mustHaveType: 'Property "{pset}.{property}" must be of type {dataType}',
+                mustNotExist: 'Property "{pset}.{property}" must not exist'
+            },
+            classification: {
+                mustHave: "Must have a classification",
+                mustBeInSystem: 'Must be classified in "{system}"',
+                mustHaveValue: 'Must have classification "{value}"',
+                mustBeInSystemWithValue: 'Must be classified as "{value}" in "{system}"',
+                mustNotHave: "Must not have any classification",
+                mustNotBeInSystem: 'Must not be classified in "{system}"'
+            },
+            material: {
+                mustHave: "Must have a material assigned",
+                mustBe: 'Must have material "{value}"',
+                mustMatch: "Must have material matching {pattern}",
+                mustNotHave: "Must not have any material assigned"
+            },
+            partOf: {
+                mustBe: "Must be {relation} a {entity}",
+                mustBeSimple: "Must be {relation} another element",
+                mustNotBe: "Must not be {relation} any element"
+            }
+        },
+        failures: {
+            entityTypeMismatch: 'Entity type is "{actual}", expected {expected}',
+            predefinedTypeMismatch: 'Predefined type is "{actual}", expected {expected}',
+            predefinedTypeMissing: "Predefined type is not set, expected {expected}",
+            attributeMissing: 'Attribute "{name}" does not exist',
+            attributeEmpty: 'Attribute "{name}" is empty',
+            attributeValueMismatch: 'Attribute "{name}" is "{actual}", expected {expected}',
+            attributePatternMismatch: 'Attribute "{name}" value "{actual}" does not match pattern {expected}',
+            attributeProhibited: 'Prohibited attribute "{name}" exists with value "{actual}"',
+            psetMissing: 'Property set "{pset}" not found',
+            psetMissingAvailable: 'Property set "{pset}" not found. Available: {available}',
+            propertyMissing: 'Property "{property}" not found in "{pset}"',
+            propertyMissingAvailable: 'Property "{property}" not found in "{pset}". Available: {available}',
+            propertyEmpty: 'Property "{pset}.{property}" has no value',
+            propertyValueMismatch: 'Property "{pset}.{property}" is "{actual}", expected {expected}',
+            propertyPatternMismatch: 'Property "{pset}.{property}" value "{actual}" does not match {expected}',
+            propertyDatatypeMismatch: 'Property "{pset}.{property}" data type is "{actual}", expected {expected}',
+            propertyOutOfBounds: 'Property "{pset}.{property}" value {actual} is out of range {expected}',
+            propertyProhibited: 'Prohibited property "{pset}.{property}" exists with value "{actual}"',
+            classificationMissing: "No classification assigned",
+            classificationSystemMismatch: 'Classification system "{actual}" does not match expected "{expected}"',
+            classificationSystemMissingAvailable: 'Classification system "{expected}" not found. Available: {available}',
+            classificationValueMismatch: 'Classification code "{actual}" does not match expected {expected}',
+            classificationValueMissingAvailable: "Classification code {expected} not found. Available: {available}",
+            classificationProhibited: 'Prohibited classification "{actual}" exists in system "{system}"',
+            materialMissing: "No material assigned",
+            materialValueMismatch: 'Material "{actual}" does not match expected {expected}',
+            materialValueMissingAvailable: "Material {expected} not found. Available: {available}",
+            materialProhibited: 'Prohibited material "{actual}" is assigned',
+            partOfMissing: "Element is not {relation} any {entity}",
+            partOfMissingSimple: "Element is not {relation} any element",
+            partOfEntityMismatch: "Parent element is {actual}, expected {expected}",
+            partOfPredefinedMismatch: 'Parent predefined type is "{actual}", expected {expected}',
+            partOfProhibited: "Element is {relation} {actual}, which is prohibited",
+            prohibited: 'Prohibited {field} found: "{actual}"',
+            unknown: "Validation failed: {reason}"
+        },
+        summary: {
+            title: "IDS Validation Report",
+            specifications: "{passed}/{total} specifications passed",
+            entities: "{passed}/{total} entities compliant ({percent}%)",
+            overallPass: "Model meets all requirements",
+            overallFail: "Model has {count} failing specifications",
+            noApplicable: "No applicable entities found"
+        },
+        ui: {
+            specification: "Specification",
+            specifications: "Specifications",
+            requirement: "Requirement",
+            requirements: "Requirements",
+            applicability: "Applies to",
+            entity: "Entity",
+            entities: "Entities",
+            passed: "Passed",
+            failed: "Failed",
+            passRate: "Pass rate",
+            actualValue: "Actual",
+            expectedValue: "Expected",
+            failureReason: "Reason",
+            showAll: "Show all",
+            showFailed: "Show failed only",
+            isolateFailed: "Isolate failed",
+            isolatePassed: "Isolate passed",
+            exportJson: "Export JSON",
+            exportBcf: "Export BCF",
+            loadIds: "Load IDS file",
+            runValidation: "Run validation",
+            clearResults: "Clear results"
+        }
+    }, Yi = {
+        status: {
+            pass: "BESTANDEN",
+            fail: "FEHLGESCHLAGEN",
+            not_applicable: "NICHT ANWENDBAR"
+        },
+        optionality: {
+            required: "Erforderlich",
+            optional: "Optional",
+            prohibited: "Verboten"
+        },
+        cardinality: {
+            satisfied: "Kardinalität erfüllt",
+            atLeast: "Mindestens {min} erwartet, {count} gefunden",
+            atMost: "Maximal {max} erwartet, {count} gefunden",
+            between: "Zwischen {min} und {max} erwartet, {count} gefunden",
+            exactly: "Genau {count} erwartet"
+        },
+        relations: {
+            IfcRelAggregates: "Teil von",
+            IfcRelAssignsToGroup: "gruppiert in",
+            IfcRelContainedInSpatialStructure: "enthalten in",
+            IfcRelNests: "verschachtelt in",
+            IfcRelVoidsElement: "durchbrechend",
+            IfcRelFillsElement: "ausfüllend"
+        },
+        constraints: {
+            simpleValue: '"{value}"',
+            pattern: 'entsprechend Muster "{pattern}"',
+            enumeration: {
+                single: '"{value}"',
+                multiple: "eines von [{values}]"
+            },
+            bounds: {
+                between: "zwischen {min} und {max}",
+                atLeast: "mindestens {min}",
+                atMost: "höchstens {max}",
+                greaterThan: "größer als {min}",
+                lessThan: "kleiner als {max}"
+            }
+        },
+        applicability: {
+            entity: {
+                simple: "Elemente vom Typ {entityType}",
+                withPredefined: "{entityType}-Elemente mit vordefiniertem Typ {predefinedType}",
+                pattern: "Elemente mit Typ entsprechend {pattern}"
+            },
+            attribute: {
+                exists: 'Elemente bei denen Attribut "{name}" existiert',
+                equals: 'Elemente bei denen "{name}" gleich {value} ist',
+                pattern: 'Elemente bei denen "{name}" dem Muster {pattern} entspricht'
+            },
+            property: {
+                exists: 'Elemente mit Eigenschaft "{property}" in "{pset}"',
+                equals: 'Elemente bei denen "{pset}.{property}" gleich {value} ist',
+                pattern: 'Elemente bei denen "{pset}.{property}" dem Muster {pattern} entspricht',
+                bounded: 'Elemente bei denen "{pset}.{property}" {bounds} ist'
+            },
+            classification: {
+                any: "Elemente mit beliebiger Klassifizierung",
+                system: 'Elemente klassifiziert in "{system}"',
+                value: 'Elemente mit Klassifizierung "{value}"',
+                systemAndValue: 'Elemente klassifiziert als "{value}" in "{system}"'
+            },
+            material: {
+                any: "Elemente mit zugewiesenem Material",
+                value: 'Elemente mit Material "{value}"',
+                pattern: "Elemente mit Material entsprechend {pattern}"
+            },
+            partOf: {
+                simple: "Elemente die {relation} einem anderen Element sind",
+                withEntity: "Elemente die {relation} einem/einer {entity} sind",
+                withEntityAndType: "Elemente die {relation} einem/einer {entity} mit Typ {predefinedType} sind"
+            }
+        },
+        requirements: {
+            entity: {
+                mustBe: "Muss vom Typ {entityType} sein",
+                mustHavePredefined: "Muss vordefinierten Typ {predefinedType} haben",
+                mustBeWithPredefined: "Muss {entityType} mit vordefiniertem Typ {predefinedType} sein"
+            },
+            attribute: {
+                mustExist: 'Attribut "{name}" muss existieren',
+                mustEqual: 'Attribut "{name}" muss {value} entsprechen',
+                mustMatch: 'Attribut "{name}" muss dem Muster {pattern} entsprechen',
+                mustNotExist: 'Attribut "{name}" darf nicht existieren',
+                mustNotEqual: 'Attribut "{name}" darf nicht {value} sein'
+            },
+            property: {
+                mustExist: 'Eigenschaft "{pset}.{property}" muss existieren',
+                mustEqual: 'Eigenschaft "{pset}.{property}" muss {value} sein',
+                mustMatch: 'Eigenschaft "{pset}.{property}" muss dem Muster {pattern} entsprechen',
+                mustBeBounded: 'Eigenschaft "{pset}.{property}" muss {bounds} sein',
+                mustHaveType: 'Eigenschaft "{pset}.{property}" muss vom Datentyp {dataType} sein',
+                mustNotExist: 'Eigenschaft "{pset}.{property}" darf nicht existieren'
+            },
+            classification: {
+                mustHave: "Muss eine Klassifizierung haben",
+                mustBeInSystem: 'Muss in "{system}" klassifiziert sein',
+                mustHaveValue: 'Muss Klassifizierung "{value}" haben',
+                mustBeInSystemWithValue: 'Muss als "{value}" in "{system}" klassifiziert sein',
+                mustNotHave: "Darf keine Klassifizierung haben",
+                mustNotBeInSystem: 'Darf nicht in "{system}" klassifiziert sein'
+            },
+            material: {
+                mustHave: "Muss ein Material zugewiesen haben",
+                mustBe: 'Muss Material "{value}" haben',
+                mustMatch: "Muss Material entsprechend {pattern} haben",
+                mustNotHave: "Darf kein Material zugewiesen haben"
+            },
+            partOf: {
+                mustBe: "Muss {relation} einem/einer {entity} sein",
+                mustBeSimple: "Muss {relation} einem anderen Element sein",
+                mustNotBe: "Darf nicht {relation} einem Element sein"
+            }
+        },
+        failures: {
+            entityTypeMismatch: 'Elementtyp ist "{actual}", erwartet {expected}',
+            predefinedTypeMismatch: 'Vordefinierter Typ ist "{actual}", erwartet {expected}',
+            predefinedTypeMissing: "Vordefinierter Typ ist nicht gesetzt, erwartet {expected}",
+            attributeMissing: 'Attribut "{name}" existiert nicht',
+            attributeEmpty: 'Attribut "{name}" ist leer',
+            attributeValueMismatch: 'Attribut "{name}" ist "{actual}", erwartet {expected}',
+            attributePatternMismatch: 'Attribut "{name}" Wert "{actual}" entspricht nicht dem Muster {expected}',
+            attributeProhibited: 'Verbotenes Attribut "{name}" existiert mit Wert "{actual}"',
+            psetMissing: 'PropertySet "{pset}" nicht gefunden',
+            psetMissingAvailable: 'PropertySet "{pset}" nicht gefunden. Verfügbar: {available}',
+            propertyMissing: 'Eigenschaft "{property}" nicht in "{pset}" gefunden',
+            propertyMissingAvailable: 'Eigenschaft "{property}" nicht in "{pset}" gefunden. Verfügbar: {available}',
+            propertyEmpty: 'Eigenschaft "{pset}.{property}" hat keinen Wert',
+            propertyValueMismatch: 'Eigenschaft "{pset}.{property}" ist "{actual}", erwartet {expected}',
+            propertyPatternMismatch: 'Eigenschaft "{pset}.{property}" Wert "{actual}" entspricht nicht {expected}',
+            propertyDatatypeMismatch: 'Eigenschaft "{pset}.{property}" Datentyp ist "{actual}", erwartet {expected}',
+            propertyOutOfBounds: 'Eigenschaft "{pset}.{property}" Wert {actual} liegt außerhalb des Bereichs {expected}',
+            propertyProhibited: 'Verbotene Eigenschaft "{pset}.{property}" existiert mit Wert "{actual}"',
+            classificationMissing: "Keine Klassifizierung zugewiesen",
+            classificationSystemMismatch: 'Klassifizierungssystem "{actual}" entspricht nicht dem erwarteten "{expected}"',
+            classificationSystemMissingAvailable: 'Klassifizierungssystem "{expected}" nicht gefunden. Verfügbar: {available}',
+            classificationValueMismatch: 'Klassifizierungscode "{actual}" entspricht nicht dem erwarteten {expected}',
+            classificationValueMissingAvailable: "Klassifizierungscode {expected} nicht gefunden. Verfügbar: {available}",
+            classificationProhibited: 'Verbotene Klassifizierung "{actual}" existiert im System "{system}"',
+            materialMissing: "Kein Material zugewiesen",
+            materialValueMismatch: 'Material "{actual}" entspricht nicht dem erwarteten {expected}',
+            materialValueMissingAvailable: "Material {expected} nicht gefunden. Verfügbar: {available}",
+            materialProhibited: 'Verbotenes Material "{actual}" ist zugewiesen',
+            partOfMissing: "Element ist nicht {relation} einem/einer {entity}",
+            partOfMissingSimple: "Element ist nicht {relation} einem anderen Element",
+            partOfEntityMismatch: "Übergeordnetes Element ist {actual}, erwartet {expected}",
+            partOfPredefinedMismatch: 'Vordefinierter Typ des übergeordneten Elements ist "{actual}", erwartet {expected}',
+            partOfProhibited: "Element ist {relation} {actual}, was verboten ist",
+            prohibited: 'Verbotenes {field} gefunden: "{actual}"',
+            unknown: "Validierung fehlgeschlagen: {reason}"
+        },
+        summary: {
+            title: "IDS-Validierungsbericht",
+            specifications: "{passed}/{total} Spezifikationen bestanden",
+            entities: "{passed}/{total} Elemente konform ({percent}%)",
+            overallPass: "Modell erfüllt alle Anforderungen",
+            overallFail: "Modell hat {count} fehlgeschlagene Spezifikationen",
+            noApplicable: "Keine anwendbaren Elemente gefunden"
+        },
+        ui: {
+            specification: "Spezifikation",
+            specifications: "Spezifikationen",
+            requirement: "Anforderung",
+            requirements: "Anforderungen",
+            applicability: "Gilt für",
+            entity: "Element",
+            entities: "Elemente",
+            passed: "Bestanden",
+            failed: "Fehlgeschlagen",
+            passRate: "Erfolgsquote",
+            actualValue: "Tatsächlich",
+            expectedValue: "Erwartet",
+            failureReason: "Grund",
+            showAll: "Alle anzeigen",
+            showFailed: "Nur fehlgeschlagene",
+            isolateFailed: "Fehlgeschlagene isolieren",
+            isolatePassed: "Bestandene isolieren",
+            exportJson: "JSON exportieren",
+            exportBcf: "BCF exportieren",
+            loadIds: "IDS-Datei laden",
+            runValidation: "Validierung starten",
+            clearResults: "Ergebnisse löschen"
+        }
+    }, Hi = {
+        status: {
+            pass: "CONFORME",
+            fail: "NON CONFORME",
+            not_applicable: "NON APPLICABLE"
+        },
+        optionality: {
+            required: "Obligatoire",
+            optional: "Optionnel",
+            prohibited: "Interdit"
+        },
+        cardinality: {
+            satisfied: "Cardinalité respectée",
+            atLeast: "Au moins {min} attendu(s), {count} trouvé(s)",
+            atMost: "Au maximum {max} attendu(s), {count} trouvé(s)",
+            between: "Entre {min} et {max} attendu(s), {count} trouvé(s)",
+            exactly: "Exactement {count} attendu(s)"
+        },
+        relations: {
+            IfcRelAggregates: "agrégé dans",
+            IfcRelAssignsToGroup: "groupé dans",
+            IfcRelContainedInSpatialStructure: "contenu dans",
+            IfcRelNests: "imbriqué dans",
+            IfcRelVoidsElement: "perçant",
+            IfcRelFillsElement: "remplissant"
+        },
+        constraints: {
+            simpleValue: '"{value}"',
+            pattern: 'correspondant au motif "{pattern}"',
+            enumeration: {
+                single: '"{value}"',
+                multiple: "l'un de [{values}]"
+            },
+            bounds: {
+                between: "entre {min} et {max}",
+                atLeast: "au moins {min}",
+                atMost: "au plus {max}",
+                greaterThan: "supérieur à {min}",
+                lessThan: "inférieur à {max}"
+            }
+        },
+        applicability: {
+            entity: {
+                simple: "Éléments de type {entityType}",
+                withPredefined: "Éléments {entityType} avec type prédéfini {predefinedType}",
+                pattern: "Éléments avec type correspondant à {pattern}"
+            },
+            attribute: {
+                exists: `Éléments où l'attribut "{name}" existe`,
+                equals: 'Éléments où "{name}" est égal à {value}',
+                pattern: 'Éléments où "{name}" correspond au motif {pattern}'
+            },
+            property: {
+                exists: 'Éléments avec propriété "{property}" dans "{pset}"',
+                equals: 'Éléments où "{pset}.{property}" est égal à {value}',
+                pattern: 'Éléments où "{pset}.{property}" correspond au motif {pattern}',
+                bounded: 'Éléments où "{pset}.{property}" est {bounds}'
+            },
+            classification: {
+                any: "Éléments avec une classification quelconque",
+                system: 'Éléments classifiés dans "{system}"',
+                value: 'Éléments avec classification "{value}"',
+                systemAndValue: 'Éléments classifiés comme "{value}" dans "{system}"'
+            },
+            material: {
+                any: "Éléments avec un matériau attribué",
+                value: 'Éléments avec matériau "{value}"',
+                pattern: "Éléments avec matériau correspondant à {pattern}"
+            },
+            partOf: {
+                simple: "Éléments qui sont {relation} un autre élément",
+                withEntity: "Éléments qui sont {relation} un(e) {entity}",
+                withEntityAndType: "Éléments qui sont {relation} un(e) {entity} de type {predefinedType}"
+            }
+        },
+        requirements: {
+            entity: {
+                mustBe: "Doit être de type {entityType}",
+                mustHavePredefined: "Doit avoir le type prédéfini {predefinedType}",
+                mustBeWithPredefined: "Doit être {entityType} avec type prédéfini {predefinedType}"
+            },
+            attribute: {
+                mustExist: `L'attribut "{name}" doit exister`,
+                mustEqual: `L'attribut "{name}" doit être égal à {value}`,
+                mustMatch: `L'attribut "{name}" doit correspondre au motif {pattern}`,
+                mustNotExist: `L'attribut "{name}" ne doit pas exister`,
+                mustNotEqual: `L'attribut "{name}" ne doit pas être {value}`
+            },
+            property: {
+                mustExist: 'La propriété "{pset}.{property}" doit exister',
+                mustEqual: 'La propriété "{pset}.{property}" doit être égale à {value}',
+                mustMatch: 'La propriété "{pset}.{property}" doit correspondre au motif {pattern}',
+                mustBeBounded: 'La propriété "{pset}.{property}" doit être {bounds}',
+                mustHaveType: 'La propriété "{pset}.{property}" doit être de type {dataType}',
+                mustNotExist: 'La propriété "{pset}.{property}" ne doit pas exister'
+            },
+            classification: {
+                mustHave: "Doit avoir une classification",
+                mustBeInSystem: 'Doit être classifié dans "{system}"',
+                mustHaveValue: 'Doit avoir la classification "{value}"',
+                mustBeInSystemWithValue: 'Doit être classifié comme "{value}" dans "{system}"',
+                mustNotHave: "Ne doit pas avoir de classification",
+                mustNotBeInSystem: 'Ne doit pas être classifié dans "{system}"'
+            },
+            material: {
+                mustHave: "Doit avoir un matériau attribué",
+                mustBe: 'Doit avoir le matériau "{value}"',
+                mustMatch: "Doit avoir un matériau correspondant à {pattern}",
+                mustNotHave: "Ne doit pas avoir de matériau attribué"
+            },
+            partOf: {
+                mustBe: "Doit être {relation} un(e) {entity}",
+                mustBeSimple: "Doit être {relation} un autre élément",
+                mustNotBe: "Ne doit pas être {relation} un élément"
+            }
+        },
+        failures: {
+            entityTypeMismatch: `Le type d'élément est "{actual}", attendu {expected}`,
+            predefinedTypeMismatch: 'Le type prédéfini est "{actual}", attendu {expected}',
+            predefinedTypeMissing: "Le type prédéfini n'est pas défini, attendu {expected}",
+            attributeMissing: `L'attribut "{name}" n'existe pas`,
+            attributeEmpty: `L'attribut "{name}" est vide`,
+            attributeValueMismatch: `L'attribut "{name}" est "{actual}", attendu {expected}`,
+            attributePatternMismatch: `La valeur de l'attribut "{name}" "{actual}" ne correspond pas au motif {expected}`,
+            attributeProhibited: `L'attribut interdit "{name}" existe avec la valeur "{actual}"`,
+            psetMissing: `L'ensemble de propriétés "{pset}" n'a pas été trouvé`,
+            psetMissingAvailable: `L'ensemble de propriétés "{pset}" n'a pas été trouvé. Disponibles : {available}`,
+            propertyMissing: `La propriété "{property}" n'a pas été trouvée dans "{pset}"`,
+            propertyMissingAvailable: `La propriété "{property}" n'a pas été trouvée dans "{pset}". Disponibles : {available}`,
+            propertyEmpty: `La propriété "{pset}.{property}" n'a pas de valeur`,
+            propertyValueMismatch: 'La propriété "{pset}.{property}" est "{actual}", attendu {expected}',
+            propertyPatternMismatch: 'La valeur de la propriété "{pset}.{property}" "{actual}" ne correspond pas à {expected}',
+            propertyDatatypeMismatch: 'Le type de données de la propriété "{pset}.{property}" est "{actual}", attendu {expected}',
+            propertyOutOfBounds: 'La valeur de la propriété "{pset}.{property}" {actual} est hors de la plage {expected}',
+            propertyProhibited: 'La propriété interdite "{pset}.{property}" existe avec la valeur "{actual}"',
+            classificationMissing: "Aucune classification attribuée",
+            classificationSystemMismatch: 'Le système de classification "{actual}" ne correspond pas à "{expected}" attendu',
+            classificationSystemMissingAvailable: `Le système de classification "{expected}" n'a pas été trouvé. Disponibles : {available}`,
+            classificationValueMismatch: 'Le code de classification "{actual}" ne correspond pas à {expected} attendu',
+            classificationValueMissingAvailable: "Le code de classification {expected} n'a pas été trouvé. Disponibles : {available}",
+            classificationProhibited: 'La classification interdite "{actual}" existe dans le système "{system}"',
+            materialMissing: "Aucun matériau attribué",
+            materialValueMismatch: 'Le matériau "{actual}" ne correspond pas à {expected} attendu',
+            materialValueMissingAvailable: "Le matériau {expected} n'a pas été trouvé. Disponibles : {available}",
+            materialProhibited: 'Le matériau interdit "{actual}" est attribué',
+            partOfMissing: "L'élément n'est pas {relation} un(e) {entity}",
+            partOfMissingSimple: "L'élément n'est pas {relation} un autre élément",
+            partOfEntityMismatch: "L'élément parent est {actual}, attendu {expected}",
+            partOfPredefinedMismatch: `Le type prédéfini de l'élément parent est "{actual}", attendu {expected}`,
+            partOfProhibited: "L'élément est {relation} {actual}, ce qui est interdit",
+            prohibited: '{field} interdit trouvé : "{actual}"',
+            unknown: "Validation échouée : {reason}"
+        },
+        summary: {
+            title: "Rapport de validation IDS",
+            specifications: "{passed}/{total} spécifications conformes",
+            entities: "{passed}/{total} éléments conformes ({percent}%)",
+            overallPass: "Le modèle respecte toutes les exigences",
+            overallFail: "Le modèle a {count} spécifications non conformes",
+            noApplicable: "Aucun élément applicable trouvé"
+        },
+        ui: {
+            specification: "Spécification",
+            specifications: "Spécifications",
+            requirement: "Exigence",
+            requirements: "Exigences",
+            applicability: "S'applique à",
+            entity: "Élément",
+            entities: "Éléments",
+            passed: "Conforme",
+            failed: "Non conforme",
+            passRate: "Taux de conformité",
+            actualValue: "Réel",
+            expectedValue: "Attendu",
+            failureReason: "Raison",
+            showAll: "Afficher tout",
+            showFailed: "Afficher non conformes",
+            isolateFailed: "Isoler non conformes",
+            isolatePassed: "Isoler conformes",
+            exportJson: "Exporter JSON",
+            exportBcf: "Exporter BCF",
+            loadIds: "Charger fichier IDS",
+            runValidation: "Lancer la validation",
+            clearResults: "Effacer les résultats"
+        }
+    }, K = {
+        en: qi,
+        de: Yi,
+        fr: Hi
+    };
+    ua = function(e = "en") {
+        return new Xi(e);
+    };
+    class Xi {
+        locale;
+        translations;
+        constructor(t){
+            this.locale = t, this.translations = K[t] || K.en;
+        }
+        t(t, a) {
+            const i = t.split(".");
+            let n = this.translations;
+            for (const r of i)if (n && typeof n == "object" && r in n) n = n[r];
+            else return t;
+            return typeof n != "string" ? t : a ? this.interpolate(n, a) : n;
+        }
+        interpolate(t, a) {
+            return t.replace(/\{(\w+)\}/g, (i, n)=>n in a ? String(a[n]) : i);
+        }
+        describeFacet(t, a) {
+            switch(this.translations, t.type){
+                case "entity":
+                    return this.describeEntityFacet(t, a);
+                case "attribute":
+                    return this.describeAttributeFacet(t, a);
+                case "property":
+                    return this.describePropertyFacet(t, a);
+                case "classification":
+                    return this.describeClassificationFacet(t, a);
+                case "material":
+                    return this.describeMaterialFacet(t, a);
+                case "partOf":
+                    return this.describePartOfFacet(t, a);
+                default:
+                    return "Unknown facet";
+            }
+        }
+        describeEntityFacet(t, a) {
+            const i = this.translations, n = this.describeConstraint(t.name);
+            return a === "applicability" ? t.predefinedType ? this.interpolate(i.applicability.entity.withPredefined, {
+                entityType: n,
+                predefinedType: this.describeConstraint(t.predefinedType)
+            }) : this.interpolate(i.applicability.entity.simple, {
+                entityType: n
+            }) : t.predefinedType ? this.interpolate(i.requirements.entity.mustBeWithPredefined, {
+                entityType: n,
+                predefinedType: this.describeConstraint(t.predefinedType)
+            }) : this.interpolate(i.requirements.entity.mustBe, {
+                entityType: n
+            });
+        }
+        describeAttributeFacet(t, a) {
+            const i = this.translations, n = this.describeConstraint(t.name);
+            return a === "applicability" ? t.value ? t.value.type === "pattern" ? this.interpolate(i.applicability.attribute.pattern, {
+                name: n,
+                pattern: this.describeConstraint(t.value)
+            }) : this.interpolate(i.applicability.attribute.equals, {
+                name: n,
+                value: this.describeConstraint(t.value)
+            }) : this.interpolate(i.applicability.attribute.exists, {
+                name: n
+            }) : t.value ? t.value.type === "pattern" ? this.interpolate(i.requirements.attribute.mustMatch, {
+                name: n,
+                pattern: this.describeConstraint(t.value)
+            }) : this.interpolate(i.requirements.attribute.mustEqual, {
+                name: n,
+                value: this.describeConstraint(t.value)
+            }) : this.interpolate(i.requirements.attribute.mustExist, {
+                name: n
+            });
+        }
+        describePropertyFacet(t, a) {
+            const i = this.translations, n = this.describeConstraint(t.propertySet), r = this.describeConstraint(t.baseName);
+            return a === "applicability" ? t.value ? t.value.type === "pattern" ? this.interpolate(i.applicability.property.pattern, {
+                pset: n,
+                property: r,
+                pattern: this.describeConstraint(t.value)
+            }) : t.value.type === "bounds" ? this.interpolate(i.applicability.property.bounded, {
+                pset: n,
+                property: r,
+                bounds: this.describeConstraint(t.value)
+            }) : this.interpolate(i.applicability.property.equals, {
+                pset: n,
+                property: r,
+                value: this.describeConstraint(t.value)
+            }) : this.interpolate(i.applicability.property.exists, {
+                pset: n,
+                property: r
+            }) : t.value ? t.value.type === "pattern" ? this.interpolate(i.requirements.property.mustMatch, {
+                pset: n,
+                property: r,
+                pattern: this.describeConstraint(t.value)
+            }) : t.value.type === "bounds" ? this.interpolate(i.requirements.property.mustBeBounded, {
+                pset: n,
+                property: r,
+                bounds: this.describeConstraint(t.value)
+            }) : this.interpolate(i.requirements.property.mustEqual, {
+                pset: n,
+                property: r,
+                value: this.describeConstraint(t.value)
+            }) : this.interpolate(i.requirements.property.mustExist, {
+                pset: n,
+                property: r
+            });
+        }
+        describeClassificationFacet(t, a) {
+            const i = this.translations;
+            return a === "applicability" ? t.system && t.value ? this.interpolate(i.applicability.classification.systemAndValue, {
+                system: this.describeConstraint(t.system),
+                value: this.describeConstraint(t.value)
+            }) : t.system ? this.interpolate(i.applicability.classification.system, {
+                system: this.describeConstraint(t.system)
+            }) : t.value ? this.interpolate(i.applicability.classification.value, {
+                value: this.describeConstraint(t.value)
+            }) : i.applicability.classification.any : t.system && t.value ? this.interpolate(i.requirements.classification.mustBeInSystemWithValue, {
+                system: this.describeConstraint(t.system),
+                value: this.describeConstraint(t.value)
+            }) : t.system ? this.interpolate(i.requirements.classification.mustBeInSystem, {
+                system: this.describeConstraint(t.system)
+            }) : t.value ? this.interpolate(i.requirements.classification.mustHaveValue, {
+                value: this.describeConstraint(t.value)
+            }) : i.requirements.classification.mustHave;
+        }
+        describeMaterialFacet(t, a) {
+            const i = this.translations;
+            return a === "applicability" ? t.value ? t.value.type === "pattern" ? this.interpolate(i.applicability.material.pattern, {
+                pattern: this.describeConstraint(t.value)
+            }) : this.interpolate(i.applicability.material.value, {
+                value: this.describeConstraint(t.value)
+            }) : i.applicability.material.any : t.value ? t.value.type === "pattern" ? this.interpolate(i.requirements.material.mustMatch, {
+                pattern: this.describeConstraint(t.value)
+            }) : this.interpolate(i.requirements.material.mustBe, {
+                value: this.describeConstraint(t.value)
+            }) : i.requirements.material.mustHave;
+        }
+        describePartOfFacet(t, a) {
+            const i = this.translations, n = this.getRelationDescription(t.relation);
+            return a === "applicability" ? t.entity ? t.entity.predefinedType ? this.interpolate(i.applicability.partOf.withEntityAndType, {
+                relation: n,
+                entity: this.describeConstraint(t.entity.name),
+                predefinedType: this.describeConstraint(t.entity.predefinedType)
+            }) : this.interpolate(i.applicability.partOf.withEntity, {
+                relation: n,
+                entity: this.describeConstraint(t.entity.name)
+            }) : this.interpolate(i.applicability.partOf.simple, {
+                relation: n
+            }) : t.entity ? this.interpolate(i.requirements.partOf.mustBe, {
+                relation: n,
+                entity: this.describeConstraint(t.entity.name)
+            }) : this.interpolate(i.requirements.partOf.mustBeSimple, {
+                relation: n
+            });
+        }
+        describeConstraint(t) {
+            const a = this.translations;
+            switch(t.type){
+                case "simpleValue":
+                    return this.interpolate(a.constraints.simpleValue, {
+                        value: t.value
+                    });
+                case "pattern":
+                    return this.interpolate(a.constraints.pattern, {
+                        pattern: t.pattern
+                    });
+                case "enumeration":
+                    return t.values.length === 1 ? this.interpolate(a.constraints.enumeration.single, {
+                        value: t.values[0]
+                    }) : this.interpolate(a.constraints.enumeration.multiple, {
+                        values: t.values.map((i)=>`"${i}"`).join(", ")
+                    });
+                case "bounds":
+                    return this.describeBounds(t);
+                default:
+                    return "unknown constraint";
+            }
+        }
+        describeBounds(t) {
+            const a = this.translations.constraints.bounds;
+            return t.minInclusive !== void 0 && t.maxInclusive !== void 0 ? this.interpolate(a.between, {
+                min: t.minInclusive,
+                max: t.maxInclusive
+            }) : t.minInclusive !== void 0 ? this.interpolate(a.atLeast, {
+                min: t.minInclusive
+            }) : t.maxInclusive !== void 0 ? this.interpolate(a.atMost, {
+                max: t.maxInclusive
+            }) : t.minExclusive !== void 0 ? this.interpolate(a.greaterThan, {
+                min: t.minExclusive
+            }) : t.maxExclusive !== void 0 ? this.interpolate(a.lessThan, {
+                max: t.maxExclusive
+            }) : "any value";
+        }
+        describeFailure(t) {
+            const a = this.translations.failures;
+            if (!t.failure) return t.actualValue && t.expectedValue ? `${t.actualValue} ≠ ${t.expectedValue}` : a.unknown.replace("{reason}", "no details");
+            const { type: i, field: n, actual: r, expected: s, context: l } = t.failure;
+            switch(i){
+                case "ENTITY_TYPE_MISMATCH":
+                    return this.interpolate(a.entityTypeMismatch, {
+                        actual: r || "?",
+                        expected: s || "?"
+                    });
+                case "PREDEFINED_TYPE_MISMATCH":
+                    return this.interpolate(a.predefinedTypeMismatch, {
+                        actual: r || "?",
+                        expected: s || "?"
+                    });
+                case "PREDEFINED_TYPE_MISSING":
+                    return this.interpolate(a.predefinedTypeMissing, {
+                        expected: s || "?"
+                    });
+                case "ATTRIBUTE_MISSING":
+                    return this.interpolate(a.attributeMissing, {
+                        name: n || "?"
+                    });
+                case "ATTRIBUTE_VALUE_MISMATCH":
+                    return this.interpolate(a.attributeValueMismatch, {
+                        name: n || "?",
+                        actual: r || "?",
+                        expected: s || "?"
+                    });
+                case "ATTRIBUTE_PATTERN_MISMATCH":
+                    return this.interpolate(a.attributePatternMismatch, {
+                        name: n || "?",
+                        actual: r || "?",
+                        expected: s || "?"
+                    });
+                case "PSET_MISSING":
+                    return l?.availablePsets ? this.interpolate(a.psetMissingAvailable, {
+                        pset: n || s || "?",
+                        available: l.availablePsets
+                    }) : this.interpolate(a.psetMissing, {
+                        pset: n || s || "?"
+                    });
+                case "PROPERTY_MISSING":
+                    return l?.availableProperties ? this.interpolate(a.propertyMissingAvailable, {
+                        property: n || "?",
+                        pset: l.propertySet || "?",
+                        available: l.availableProperties
+                    }) : this.interpolate(a.propertyMissing, {
+                        property: n || "?",
+                        pset: l?.propertySet || "?"
+                    });
+                case "PROPERTY_VALUE_MISMATCH":
+                    return this.interpolate(a.propertyValueMismatch, {
+                        pset: this.extractPsetFromField(n),
+                        property: this.extractPropertyFromField(n),
+                        actual: r || "?",
+                        expected: s || "?"
+                    });
+                case "PROPERTY_DATATYPE_MISMATCH":
+                    return this.interpolate(a.propertyDatatypeMismatch, {
+                        pset: this.extractPsetFromField(n),
+                        property: this.extractPropertyFromField(n),
+                        actual: r || "?",
+                        expected: s || "?"
+                    });
+                case "PROPERTY_OUT_OF_BOUNDS":
+                    return this.interpolate(a.propertyOutOfBounds, {
+                        pset: this.extractPsetFromField(n),
+                        property: this.extractPropertyFromField(n),
+                        actual: r || "?",
+                        expected: s || "?"
+                    });
+                case "CLASSIFICATION_MISSING":
+                    return a.classificationMissing;
+                case "CLASSIFICATION_SYSTEM_MISMATCH":
+                    return l?.availableSystems ? this.interpolate(a.classificationSystemMissingAvailable, {
+                        expected: s || "?",
+                        available: l.availableSystems
+                    }) : this.interpolate(a.classificationSystemMismatch, {
+                        actual: r || "?",
+                        expected: s || "?"
+                    });
+                case "CLASSIFICATION_VALUE_MISMATCH":
+                    return l?.availableValues ? this.interpolate(a.classificationValueMissingAvailable, {
+                        expected: s || "?",
+                        available: l.availableValues
+                    }) : this.interpolate(a.classificationValueMismatch, {
+                        actual: r || "?",
+                        expected: s || "?"
+                    });
+                case "MATERIAL_MISSING":
+                    return a.materialMissing;
+                case "MATERIAL_VALUE_MISMATCH":
+                    return l?.availableMaterials ? this.interpolate(a.materialValueMissingAvailable, {
+                        expected: s || "?",
+                        available: l.availableMaterials
+                    }) : this.interpolate(a.materialValueMismatch, {
+                        actual: r || "?",
+                        expected: s || "?"
+                    });
+                case "PARTOF_RELATION_MISSING":
+                    return l?.entity ? this.interpolate(a.partOfMissing, {
+                        relation: this.getRelationDescription(n || "IfcRelContainedInSpatialStructure"),
+                        entity: l.entity
+                    }) : this.interpolate(a.partOfMissingSimple, {
+                        relation: this.getRelationDescription(n || "IfcRelContainedInSpatialStructure")
+                    });
+                case "PARTOF_ENTITY_MISMATCH":
+                    return this.interpolate(a.partOfEntityMismatch, {
+                        actual: r || "?",
+                        expected: s || "?"
+                    });
+                case "PROHIBITED_ATTRIBUTE_EXISTS":
+                case "PROHIBITED_PROPERTY_EXISTS":
+                case "PROHIBITED_CLASSIFICATION_EXISTS":
+                case "PROHIBITED_MATERIAL_EXISTS":
+                    return this.interpolate(a.prohibited, {
+                        field: n || "value",
+                        actual: r || "?"
+                    });
+                default:
+                    return this.interpolate(a.unknown, {
+                        reason: i
+                    });
+            }
+        }
+        extractPsetFromField(t) {
+            if (!t) return "?";
+            const a = t.split(".");
+            return a.length > 1 ? a[0] : "?";
+        }
+        extractPropertyFromField(t) {
+            if (!t) return "?";
+            const a = t.split(".");
+            return a.length > 1 ? a.slice(1).join(".") : t;
+        }
+        describeRequirement(t) {
+            let a = this.describeFacet(t.facet, "requirement");
+            return t.optionality === "prohibited" ? a = this.applyProhibited(a) : t.optionality === "optional" && (a = this.applyOptional(a)), a;
+        }
+        applyProhibited(t) {
+            return t.replace(/^Must be/i, "Must NOT be").replace(/^Must have/i, "Must NOT have").replace(/^Muss/i, "Darf nicht").replace(/^Doit être/i, "Ne doit pas être").replace(/^Doit avoir/i, "Ne doit pas avoir");
+        }
+        applyOptional(t) {
+            return t.replace(/^Must/i, "Should").replace(/^Muss/i, "Sollte").replace(/^Doit/i, "Devrait");
+        }
+        getStatusText(t) {
+            return this.translations.status[t];
+        }
+        getOptionalityText(t) {
+            return this.translations.optionality[t];
+        }
+        getRelationDescription(t) {
+            return this.translations.relations[t] || t.replace("IfcRel", "").toLowerCase();
+        }
+    }
+    function Gi(e) {
+        if (!e) return [];
+        const t = [], a = (i, n)=>{
+            i && t.push({
+                name: i,
+                category: n
+            });
+        };
+        switch(e.type){
+            case "Material":
+                a(e.name, e.category), e.category && a(e.category, e.category);
+                break;
+            case "MaterialList":
+                for (const i of e.materials || [])typeof i == "string" ? a(i) : i && typeof i == "object" && (a(i.name, i.category), i.category && a(i.category, i.category));
+                break;
+            case "MaterialLayerSet":
+                a(e.name);
+                for (const i of e.layers || [])a(i.materialName, i.category), a(i.name, i.category), i.materialCategory && a(i.materialCategory, i.materialCategory);
+                break;
+            case "MaterialConstituentSet":
+                a(e.name);
+                for (const i of e.constituents || [])a(i.materialName, i.category), a(i.name, i.category), i.materialCategory && a(i.materialCategory, i.materialCategory);
+                break;
+            case "MaterialProfileSet":
+                a(e.name);
+                for (const i of e.profiles || [])a(i.materialName, i.category), a(i.name, i.category), i.materialCategory && a(i.materialCategory, i.materialCategory);
+                break;
+        }
+        return t;
+    }
+    function ji(e, t) {
+        const a = [
+            ...be(e, t) || []
+        ];
+        Wi(e, t, a);
+        const i = [];
+        for (const n of a){
+            const r = n.system || "", s = n.identification || n.name || "";
+            if (i.push({
+                system: r,
+                value: s,
+                name: n.name
+            }), Array.isArray(n.path)) for (const l of n.path)l && l !== s && i.push({
+                system: r,
+                value: l,
+                name: n.name
+            });
+        }
+        return i;
+    }
+    function Wi(e, t, a) {
+        const i = e.entityIndex?.byType?.get?.("IFCEXTERNALREFERENCERELATIONSHIP") || [];
+        if (i.length === 0 || !e.source?.length) return;
+        const n = new ge(e.source);
+        for (const r of i){
+            const s = e.entityIndex.byId.get(r);
+            if (!s) continue;
+            const l = n.extractEntity(s);
+            if (!l) continue;
+            const o = l.attributes?.[2], u = l.attributes?.[3];
+            if (typeof o != "number" || !Array.isArray(u) || !u.includes(t)) continue;
+            const c = e.entityIndex.byId.get(o);
+            if (!c) continue;
+            const f = n.extractEntity(c);
+            if (!f || f.type.toUpperCase() !== "IFCCLASSIFICATIONREFERENCE") continue;
+            const d = f.attributes || [], m = {
+                identification: typeof d[1] == "string" ? d[1] : void 0,
+                name: typeof d[2] == "string" ? d[2] : void 0,
+                path: []
+            };
+            let y = typeof d[3] == "number" ? d[3] : void 0;
+            const M = new Set;
+            for(; y !== void 0 && !M.has(y);){
+                M.add(y);
+                const x = e.entityIndex.byId.get(y);
+                if (!x) break;
+                const _ = n.extractEntity(x);
+                if (!_) break;
+                const I = _.type.toUpperCase(), b = _.attributes || [];
+                if (I === "IFCCLASSIFICATION") {
+                    m.system = typeof b[3] == "string" ? b[3] : void 0;
+                    break;
+                }
+                if (I === "IFCCLASSIFICATIONREFERENCE") {
+                    const P = typeof b[1] == "string" ? b[1] : typeof b[2] == "string" ? b[2] : void 0;
+                    P && m.path.unshift(P), y = typeof b[3] == "number" ? b[3] : void 0;
+                    continue;
+                }
+                break;
+            }
+            a.push(m);
+        }
+    }
+    function de(e) {
+        if (typeof e == "string") return e.startsWith("IFC") || e.startsWith("Ifc") ? e.toUpperCase() : "IFCLABEL";
+        switch(e){
+            case 0:
+                return "IFCLABEL";
+            case 1:
+                return "IFCREAL";
+            case 2:
+                return "IFCINTEGER";
+            case 3:
+                return "IFCBOOLEAN";
+            case 4:
+                return "IFCLOGICAL";
+            case 5:
+                return "IFCLABEL";
+            case 6:
+                return "IFCIDENTIFIER";
+            case 7:
+                return "IFCTEXT";
+            case 8:
+                return "IFCLABEL";
+            case 9:
+                return "IFCIDENTIFIER";
+            case 10:
+                return "IFCLABEL";
+            default:
+                return "IFCLABEL";
+        }
+    }
+    function zi(e) {
+        switch(e){
+            case 0:
+                return "IFCLENGTHMEASURE";
+            case 1:
+                return "IFCAREAMEASURE";
+            case 2:
+                return "IFCVOLUMEMEASURE";
+            case 3:
+                return "IFCCOUNTMEASURE";
+            case 4:
+                return "IFCMASSMEASURE";
+            case 5:
+                return "IFCTIMEMEASURE";
+            default:
+                return "IFCLABEL";
+        }
+    }
+    function Ki(e, t, a, i) {
+        if (!i || i === 1) return {
+            value: e,
+            values: t
+        };
+        const n = a ? a.toUpperCase() : "", r = n === "IFCLENGTHMEASURE" || n === "IFCPOSITIVELENGTHMEASURE", s = !a && Array.isArray(t) && t.length > 0;
+        if (!r && !s) return {
+            value: e,
+            values: t
+        };
+        const l = (u)=>{
+            const c = typeof u == "number" ? u : parseFloat(String(u));
+            return Number.isFinite(c) ? c * i : null;
+        };
+        if (r) {
+            const u = (()=>{
+                const f = l(e);
+                return f ?? e;
+            })(), c = Array.isArray(t) ? t.map((f)=>{
+                const d = l(f);
+                return d == null ? String(f) : String(d);
+            }) : t;
+            return {
+                value: u,
+                values: c
+            };
+        }
+        const o = [];
+        for (const u of t){
+            o.push(String(u));
+            const c = l(u);
+            c != null && String(c) !== String(u) && o.push(String(c));
+        }
+        return {
+            value: e,
+            values: o
+        };
+    }
+    function Q(e, t) {
+        const a = [], i = e.lengthUnitScale;
+        return Qi(e, t, i, a), Ji(e, t, a), Zi(e, t, a), ea(e, t, i, a), a.length === 0 && ta(e, t, a), a;
+    }
+    function Qi(e, t, a, i) {
+        let n = e.properties?.getForEntity?.(t);
+        if ((!n || n.length === 0) && (n = Se(e, t)), !(!n || n.length === 0)) for (const r of n)i.push({
+            name: r.name,
+            properties: (r.properties || []).map((s)=>me(s, a))
+        });
+    }
+    function Ji(e, t, a) {
+        let i = e.quantities?.getForEntity?.(t);
+        if ((!i || i.length === 0) && (i = Ae(e, t)), !(!i || i.length === 0)) for (const n of i)a.push({
+            name: n.name,
+            properties: (n.quantities || []).map((r)=>({
+                    name: r.name,
+                    value: r.value,
+                    dataType: zi(r.type)
+                }))
+        });
+    }
+    function Zi(e, t, a) {
+        const i = e.relationships?.getRelated?.(t, A.DefinesByProperties, "inverse") || [];
+        for (const n of i){
+            const r = e.entityIndex?.byId?.get?.(n);
+            if (!r) continue;
+            const s = String(r.type).toUpperCase();
+            if (s === "IFCPROPERTYSET" || s === "IFCELEMENTQUANTITY" || !s.endsWith("PROPERTIES")) continue;
+            const l = N(e, n), o = l.find((c)=>c.name === "Name")?.value;
+            if (typeof o != "string" || !o || a.some((c)=>c.name === o)) continue;
+            const u = l.filter((c)=>c.name !== "GlobalId" && c.name !== "Name" && c.name !== "Description" && c.value !== void 0 && c.value !== "").map((c)=>({
+                    name: c.name,
+                    value: c.value,
+                    dataType: ""
+                }));
+            u.length > 0 && a.push({
+                name: o,
+                properties: u
+            });
+        }
+    }
+    function ea(e, t, a, i) {
+        const n = xe(e, t);
+        if (!n || !n.properties || n.properties.length === 0) return;
+        const r = new Set(i.map((s)=>s.name));
+        for (const s of n.properties)r.has(s.name) || i.push({
+            name: s.name,
+            properties: (s.properties || []).map((l)=>me(l, a))
+        });
+    }
+    function ta(e, t, a) {
+        const i = Ce(e, t);
+        if (i.length !== 0) for (const n of i)a.push({
+            name: n.name,
+            properties: (n.properties || []).map((r)=>({
+                    name: r.name,
+                    value: Array.isArray(r.value) ? JSON.stringify(r.value) : r.value,
+                    dataType: de(r.type),
+                    ...Array.isArray(r.values) && r.values.length > 0 ? {
+                        values: r.values
+                    } : {}
+                }))
+        });
+    }
+    function me(e, t) {
+        const a = Array.isArray(e.values) && e.values.length > 0, i = e.dataType ?? (a ? void 0 : de(e.type)), n = Array.isArray(e.value) ? JSON.stringify(e.value) : e.value, r = a ? e.values : void 0, s = Ki(n, r, i, t);
+        return {
+            name: e.name,
+            value: s.value,
+            dataType: i ?? "",
+            ...s.values ? {
+                values: s.values
+            } : {}
+        };
+    }
+    function ia(e, t) {
+        const i = N(e, t).find((s)=>s.name === "PredefinedType"), n = typeof i?.value == "string" && i.value ? i.value : void 0;
+        if (n && n !== "NOTDEFINED") return n;
+        const r = e.relationships?.getRelated?.(t, A.DefinesByType, "inverse") || [];
+        for (const s of r){
+            const o = N(e, s).find((c)=>c.name === "PredefinedType"), u = typeof o?.value == "string" && o.value ? o.value : void 0;
+            if (u && u !== "NOTDEFINED") return u;
+        }
+        return n;
+    }
+    function aa(e, t, a) {
+        const i = N(e, t), r = i.find((u)=>u.name === "PredefinedType")?.value;
+        if (typeof r == "string" && r && r !== "NOTDEFINED" && r !== "USERDEFINED") return r;
+        const s = i.find((u)=>u.name === "ElementType") || i.find((u)=>u.name === "ObjectType") || i.find((u)=>u.name === "ProcessType") || i.find((u)=>u.name === "ResourceType");
+        if (s && typeof s.value == "string" && s.value) return s.value;
+        const l = e.relationships?.getRelated?.(t, A.DefinesByType, "inverse") || [];
+        for (const u of l){
+            const c = N(e, u), d = c.find((y)=>y.name === "PredefinedType")?.value;
+            if (typeof d == "string" && d && d !== "NOTDEFINED" && d !== "USERDEFINED") return d;
+            const m = c.find((y)=>y.name === "ElementType") || c.find((y)=>y.name === "ObjectType") || c.find((y)=>y.name === "ProcessType") || c.find((y)=>y.name === "ResourceType");
+            if (m && typeof m.value == "string" && m.value) return m.value;
+        }
+        const o = a();
+        return o || (typeof r == "string" && r ? r : void 0);
+    }
+    function na(e) {
+        switch((e || "").toUpperCase()){
+            case "IFC2X3":
+                return "IFC2X3";
+            case "IFC4":
+                return "IFC4";
+            case "IFC4X3":
+            case "IFC4X3_ADD2":
+            case "IFC5":
+                return "IFC4X3";
+            default:
+                return "IFC4";
+        }
+    }
+    const ra = {
+        IfcRelAggregates: A.Aggregates,
+        IfcRelAssignsToGroup: A.AssignsToGroup,
+        IfcRelContainedInSpatialStructure: A.ContainsElements,
+        IfcRelNests: A.Aggregates,
+        IfcRelVoidsElement: A.VoidsElement,
+        IfcRelFillsElement: A.FillsElement
+    };
+    ca = function(e) {
+        function t(i, n) {
+            const r = n.toLowerCase(), s = N(e, i);
+            for (const l of s)if (l.name.toLowerCase() === r) return l.value;
+        }
+        const a = {
+            getEntityType (i) {
+                const n = e.entities?.getTypeName?.(i);
+                if (n && n !== "Unknown") return n;
+                const r = e.entityIndex?.byId;
+                if (!r) return;
+                const s = r.get(i);
+                if (s) return typeof s == "object" && "type" in s ? String(s.type) : void 0;
+            },
+            getEntityName (i) {
+                const n = t(i, "Name");
+                return n !== void 0 && typeof n == "string" ? n : e.entities?.getName?.(i) || void 0;
+            },
+            getGlobalId (i) {
+                const n = t(i, "GlobalId");
+                return n !== void 0 && typeof n == "string" ? n : e.entities?.getGlobalId?.(i) || void 0;
+            },
+            getDescription (i) {
+                const n = t(i, "Description");
+                return n !== void 0 && typeof n == "string" ? n : e.entities?.getDescription?.(i) || void 0;
+            },
+            getAttributeNames (i) {
+                return N(e, i).map((n)=>n.name);
+            },
+            getAttributeXsdTypes (i, n) {
+                const r = a.getEntityType(i);
+                if (r) return Me(na(e.schemaVersion), r, n);
+            },
+            getPredefinedTypeRaw (i) {
+                return ia(e, i);
+            },
+            getObjectType (i) {
+                return aa(e, i, ()=>e.entities?.getObjectType?.(i));
+            },
+            getEntitiesByType (i) {
+                const n = e.entityIndex?.byType?.get(i.toUpperCase());
+                return n ? Array.from(n) : [];
+            },
+            getAllEntityIds () {
+                const i = e.entityIndex?.byId;
+                return i ? Array.from(i.keys()) : [];
+            },
+            getPropertyValue (i, n, r) {
+                const s = n.toLowerCase(), l = r.toLowerCase(), o = Q(e, i);
+                for (const u of o)if (u.name.toLowerCase() === s) {
+                    for (const c of u.properties || [])if (c.name.toLowerCase() === l) return {
+                        value: c.value,
+                        dataType: c.dataType,
+                        propertySetName: u.name,
+                        propertyName: c.name
+                    };
+                }
+            },
+            getPropertySets (i) {
+                return Q(e, i);
+            },
+            getClassifications (i) {
+                return ji(e, i);
+            },
+            getMaterials (i) {
+                return Gi(Re(e, i));
+            },
+            getParent (i, n) {
+                const r = a.getAncestors(i, n);
+                return r.length > 0 ? r[0] : void 0;
+            },
+            getAncestors (i, n) {
+                const r = e.relationships;
+                if (!r?.getRelated) return [];
+                const s = ra[n];
+                if (s === void 0) return [];
+                const l = [], o = new Set([
+                    i
+                ]), u = [
+                    i
+                ];
+                for(; u.length > 0;){
+                    const c = u.shift(), f = r.getRelated(c, s, "inverse");
+                    for (const d of f || [])o.has(d) || (o.add(d), l.push({
+                        expressId: d,
+                        entityType: a.getEntityType(d) || "Unknown",
+                        predefinedType: a.getObjectType(d)
+                    }), u.push(d));
+                }
+                return l;
+            },
+            getAttribute (i, n) {
+                switch(n.toLowerCase()){
+                    case "name":
+                        return a.getEntityName(i);
+                    case "description":
+                        return a.getDescription(i);
+                    case "globalid":
+                        return a.getGlobalId(i);
+                    case "objecttype":
+                    case "predefinedtype":
+                        return a.getObjectType(i);
+                    default:
+                        {
+                            const s = t(i, n);
+                            if (s !== void 0) return s;
+                            const l = e.entities;
+                            return l?.getAttribute ? l.getAttribute(i, n) : void 0;
+                        }
+                }
+            }
+        };
+        return a;
+    };
+});
+export { g as I, ua as a, oa as b, ca as c, Ne as p, la as v, __tla };