@nika-js/onlymap 0.5.12 → 0.6.1

package/dist/ifc-Dc-TdSJr.js

@@ -0,0 +1,877 @@
+import { p as kt, g as Bt, b as Ht } from "./crs-Ciu7Xs7a.js";
+const _t = "0.0.68", Rt = `https://unpkg.com/web-ifc@${_t}/`;
+let Tt = Rt;
+function Pe(t) {
+  t.wasmPath && (Tt = t.wasmPath.endsWith("/") ? t.wasmPath : `${t.wasmPath}/`);
+}
+const Et = "", Wt = 3242617779, Xt = 2655215786, qt = 4186316022, Kt = 4097777520, Yt = 3057273783, Jt = 3448662350, Zt = 160246688, Qt = 781010003, te = 919958153, ee = 1307041759, ne = 103090709;
+let St = null;
+function oe(t) {
+  let e = "";
+  for (let n = 0; n < t.length; n += 32768) e += String.fromCharCode(...t.subarray(n, n + 32768));
+  return btoa(e);
+}
+const se = {
+  "web-ifc-api.js": "377cf933e274bf812be67752c87694f33d25778a427665a8770709493bb4920c",
+  "web-ifc.wasm": "012cc124216024de72cc6562cdc0235f7757ca45bcf29cee7b8947fe77f12135",
+  "web-ifc-mt.wasm": "961fff06dae99c318cb6ecc1136f2f32be0573a33537ec85999aced6fe69484f",
+  // Byte-identical to web-ifc.wasm at 0.0.68 (verified, not assumed) — kept
+  // as its own entry so a future version where the two diverge cannot
+  // silently fall through the check.
+  "web-ifc-node.wasm": "012cc124216024de72cc6562cdc0235f7757ca45bcf29cee7b8947fe77f12135"
+};
+function ce(t) {
+  if (!t.startsWith(Rt)) return null;
+  const e = t.slice(Rt.length).split(/[?#]/)[0];
+  return se[e] ?? null;
+}
+const ae = async (t) => [...new Uint8Array(await crypto.subtle.digest("SHA-256", t))].map((e) => e.toString(16).padStart(2, "0")).join("");
+async function Ct(t, e, o) {
+  if (typeof crypto > "u" || !crypto.subtle) return t;
+  const n = await t.arrayBuffer(), s = await ae(n);
+  if (s !== e)
+    throw new Error(
+      `[onlymap] integrity check failed for ${o}: expected sha256 ${e}, got ${s}. Refusing to execute or cache these bytes. If you intend to run a different web-ifc build, self-host it and point the loader at it with configureIfc({ wasmPath }) — integrity is only enforced for the default CDN.`
+    );
+  return new Response(n, { status: 200, headers: t.headers });
+}
+const Ft = "onlymapjs-web-ifc", $t = `${Ft}-${_t}`;
+let Ot = !1;
+async function re() {
+  if (!Ot) {
+    Ot = !0;
+    try {
+      for (const t of await caches.keys())
+        t.startsWith(Ft) && t !== $t && await caches.delete(t);
+    } catch {
+    }
+  }
+}
+async function Lt(t, e = fetch) {
+  const o = ce(t);
+  if (typeof caches > "u") {
+    const f = await e(t);
+    return o && f.ok ? Ct(f, o, t) : f;
+  }
+  await re();
+  const n = await caches.open($t), s = await n.match(t);
+  if (s) {
+    if (!o) return s;
+    try {
+      return await Ct(s, o, t);
+    } catch (f) {
+      try {
+        await n.delete(t);
+      } catch {
+      }
+      throw f;
+    }
+  }
+  const r = await e(t);
+  if (!r.ok) return r;
+  const c = o ? await Ct(r, o, t) : r;
+  try {
+    await n.put(t, c.clone());
+  } catch {
+  }
+  return c;
+}
+const ie = /\bweb-ifc(?:-mt|-node)?\.wasm(?:[?#]|$)/;
+async function le() {
+  return St ??= (async () => {
+    const t = `${Tt}web-ifc-api.js`, e = await (await Lt(t)).text(), o = URL.createObjectURL(new Blob([e], { type: "text/javascript" }));
+    let n;
+    try {
+      n = await import(
+        /* @vite-ignore */
+        o
+      );
+    } catch {
+      n = await import(`data:text/javascript;base64,${oe(new TextEncoder().encode(e))}`);
+    } finally {
+      URL.revokeObjectURL(o);
+    }
+    const s = new n.IfcAPI();
+    s.SetWasmPath(Tt, !0);
+    const r = typeof caches < "u" ? globalThis.fetch : null;
+    r && (globalThis.fetch = ((c, f) => {
+      const d = typeof c == "string" ? c : c instanceof URL ? c.href : c.url;
+      return ie.test(d) ? Lt(d, r) : r(c, f);
+    }));
+    try {
+      await s.Init();
+    } finally {
+      r && (globalThis.fetch = r);
+    }
+    return s;
+  })().catch((t) => {
+    throw St = null, t;
+  }), St;
+}
+const B = (t) => t && typeof t == "object" && "value" in t ? String(t.value ?? "") : t == null ? "" : String(t);
+function Pt(t) {
+  const e = t && typeof t == "object" && "value" in t ? t.value : t;
+  if (!Array.isArray(e) || e.length < 2) return null;
+  const o = e.map((m) => Number(m && typeof m == "object" && "value" in m ? m.value : m) || 0), n = o.some((m) => m < 0), [s = 0, r = 0, c = 0, f = 0] = o.map(Math.abs), d = s + r / 60 + c / 3600 + f / 36e8;
+  return n ? -d : d;
+}
+function ft(t) {
+  const e = t && typeof t == "object" && "value" in t ? t.value : t;
+  if (e == null || e === "") return null;
+  const o = Number(e);
+  return Number.isFinite(o) ? o : null;
+}
+function fe(t, e, o) {
+  const n = Math.hypot(t.xAxisAbscissa, t.xAxisOrdinate), s = n ? t.xAxisAbscissa / n : 1, r = n ? t.xAxisOrdinate / n : 0;
+  return [
+    t.eastings + t.scale * (e * s - o * r),
+    t.northings + t.scale * (e * r + o * s)
+  ];
+}
+function ue(t) {
+  return {
+    code: t.epsg,
+    eastings: t.eastings,
+    northings: t.northings,
+    orthogonalHeight: t.orthogonalHeight,
+    xAxisAbscissa: t.xAxisAbscissa,
+    xAxisOrdinate: t.xAxisOrdinate,
+    scale: 1
+  };
+}
+function he(t, e) {
+  return t + e;
+}
+const de = {
+  EXA: 1e18,
+  PETA: 1e15,
+  TERA: 1e12,
+  GIGA: 1e9,
+  MEGA: 1e6,
+  KILO: 1e3,
+  HECTO: 100,
+  DECA: 10,
+  DECI: 0.1,
+  CENTI: 0.01,
+  MILLI: 1e-3,
+  MICRO: 1e-6,
+  NANO: 1e-9,
+  PICO: 1e-12,
+  FEMTO: 1e-15,
+  ATTO: 1e-18
+}, At = 6378137, Nt = 1 / 298.257223563, Z = Nt * (2 - Nt), Ut = 0.9996, Mt = Z / (1 - Z);
+function Dt(t, e, o, n) {
+  const s = t - 5e5, c = (n ? e - 1e7 : e) / Ut / (At * (1 - Z / 4 - 3 * Z ** 2 / 64 - 5 * Z ** 3 / 256)), f = (1 - Math.sqrt(1 - Z)) / (1 + Math.sqrt(1 - Z)), d = c + (3 * f / 2 - 27 * f ** 3 / 32) * Math.sin(2 * c) + (21 * f ** 2 / 16 - 55 * f ** 4 / 32) * Math.sin(4 * c) + 151 * f ** 3 / 96 * Math.sin(6 * c) + 1097 * f ** 4 / 512 * Math.sin(8 * c), m = Mt * Math.cos(d) ** 2, y = Math.tan(d) ** 2, l = Math.sin(d), i = At / Math.sqrt(1 - Z * l * l), h = At * (1 - Z) / (1 - Z * l * l) ** 1.5, g = s / (i * Ut), w = d - i * Math.tan(d) / h * (g ** 2 / 2 - (5 + 3 * y + 10 * m - 4 * m ** 2 - 9 * Mt) * g ** 4 / 24 + (61 + 90 * y + 298 * m + 45 * y ** 2 - 252 * Mt - 3 * m ** 2) * g ** 6 / 720);
+  return [(o - 1) * 6 - 180 + 3 + (g - (1 + 2 * y + m) * g ** 3 / 6 + (5 - 2 * m + 28 * y - 3 * m ** 2 + 8 * Mt + 24 * y ** 2) * g ** 5 / 120) / Math.cos(d) * (180 / Math.PI), w * 180 / Math.PI];
+}
+function jt(t) {
+  const e = /(?:EPSG:?)\s*(326|327)(\d{2})/i.exec(t);
+  if (!e) return null;
+  const o = Number(e[2]);
+  return o < 1 || o > 60 ? null : { zone: o, south: e[1] === "327" };
+}
+const pe = (t) => (t - 1) * 6 - 180 + 3;
+function ge(t, e, o) {
+  const n = (t - pe(o)) * Math.PI / 180, s = e * Math.PI / 180;
+  return Math.atan(Math.tan(n) * Math.sin(s)) * 180 / Math.PI;
+}
+async function me(t, e, o) {
+  if (t.code == null) return null;
+  const [n, s] = fe(t, e, o), r = jt(`EPSG:${t.code}`);
+  return r ? Dt(n, s, r.zone, r.south) : kt(t.code, n, s);
+}
+async function ye(t, e, o) {
+  let n = o, s = !1;
+  try {
+    const l = t.GetLineIDsWithType(e, Kt);
+    for (let i = 0; i < l.size(); i++) {
+      const h = t.GetLine(e, l.get(i), !0), g = Pt(h.RefLatitude), w = Pt(h.RefLongitude);
+      if (g != null && w != null && (g || w)) {
+        n = [w, g], s = !0;
+        break;
+      }
+    }
+  } catch {
+  }
+  let r = 0, c = 1, f = "assumed", d = s ? "ifc-site" : "fallback", m = null, y = !1;
+  try {
+    const l = t.GetLineIDsWithType(e, Yt);
+    for (let i = 0; i < l.size(); i++) {
+      const h = t.GetLine(e, l.get(i), !0), g = ft(h.XAxisAbscissa), w = ft(h.XAxisOrdinate);
+      g != null && w != null && (g || w) && (r = -(Math.atan2(w, g) * 180) / Math.PI, f = "map-conversion");
+      const I = `${B(h.TargetCRS?.Name)} ${B(h.TargetCRS?.Description)}`, R = ft(h.Eastings), L = ft(h.Northings);
+      if (R == null || L == null) break;
+      const O = B(h.TargetCRS?.MapUnit?.Name).toUpperCase();
+      h.TargetCRS?.MapUnit != null && O !== "METRE" && console.warn(
+        `[onlymap] IfcMapConversion's TargetCRS declares a map unit that is not IfcSIUnit.METRE (read as "${O || "unknown"}") — eastings/northings/OrthogonalHeight are being treated as metres regardless, which is wrong for a non-metric unit (e.g. US survey feet) and will misplace the model.`
+      );
+      const k = de[B(h.TargetCRS?.MapUnit?.Prefix).toUpperCase()] ?? 1, T = R * k, U = L * k, $ = jt(I), D = /EPSG:?\s*(\d{4,6})/i.exec(I);
+      let a = $ ? Dt(T, U, $.zone, $.south) : null, u = null;
+      if (a && $)
+        u = ge(a[0], a[1], $.zone);
+      else if (!a && D) {
+        const A = Number(D[1]);
+        a = await kt(A, T, U), a && (u = await Bt(A, T, U));
+      }
+      const p = ft(h.OrthogonalHeight);
+      y = p != null, m = ue({
+        epsg: D ? Number(D[1]) : null,
+        eastings: T,
+        northings: U,
+        orthogonalHeight: (p ?? 0) * k,
+        xAxisAbscissa: g ?? 1,
+        xAxisOrdinate: w ?? 0
+      }), a ? (n = a, s = !0, d = "map-conversion", u != null && (r += u)) : console.warn(
+        `[onlymap] IFC declares an IfcMapConversion into "${I.trim()}", which is neither a WGS84 UTM zone nor one of the bundled coordinate systems (EPSG ${Ht().join(", ")}) — its eastings/northings cannot be un-projected, so the position falls back to IfcSite. Set the layer's site-origin to place it.`
+      );
+      break;
+    }
+  } catch {
+  }
+  if (f === "assumed")
+    try {
+      const l = t.GetLineIDsWithType(e, Jt);
+      for (let i = 0; i < l.size(); i++) {
+        const h = t.GetLine(e, l.get(i), !0), g = h.ContextType, w = g && typeof g == "object" && "value" in g ? g.value : g;
+        if (String(w ?? "") !== "Model") continue;
+        const I = h.TrueNorth?.DirectionRatios;
+        if (!Array.isArray(I) || I.length < 2) continue;
+        const R = ft(I[0]), L = ft(I[1]);
+        if (!(R == null || L == null || !R && !L)) {
+          r = Math.atan2(L, R) * 180 / Math.PI - 90, f = "true-north";
+          break;
+        }
+      }
+    } catch {
+    }
+  return r = (r % 360 + 360) % 360, r > 180 && (r -= 360), r = Math.round(r * 1e4) / 1e4, { lonLat: n, georeferenced: s, heading: r, scale: c, headingSource: f, originSource: d, affine: m, hasOrthogonalHeight: y };
+}
+function be(t, e) {
+  const o = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), y = (a) => {
+    if (m.has(a)) return m.get(a);
+    let u = null;
+    try {
+      u = t.GetLine(e, a, !1);
+    } catch {
+      u = null;
+    }
+    return m.set(a, u), u;
+  }, l = (a) => Number(a?.value ?? a?.expressID ?? -1), i = (a) => {
+    const u = l(a);
+    return u < 0 ? "" : B(y(u)?.Name);
+  }, h = (a, u) => {
+    let p;
+    try {
+      p = t.GetLineIDsWithType(e, a);
+    } catch {
+      return;
+    }
+    for (let A = 0; A < p.size(); A++)
+      try {
+        const S = y(p.get(A));
+        S && u(S);
+      } catch {
+      }
+  }, g = /* @__PURE__ */ new Map();
+  h(Zt, (a) => {
+    const u = l(a.RelatingObject);
+    for (const p of a.RelatedObjects ?? []) g.set(l(p), u);
+  });
+  const w = /* @__PURE__ */ new Map(), I = (a) => {
+    const u = w.get(a);
+    if (u !== void 0) return u;
+    let p = B(y(a)?.Name);
+    if (!p)
+      try {
+        p = t.GetNameFromTypeCode(t.GetLineType(e, a));
+      } catch {
+        p = "";
+      }
+    return w.set(a, p), p;
+  }, R = /* @__PURE__ */ new Map(), L = (a) => {
+    if (a < 0) return "";
+    const u = R.get(a);
+    if (u !== void 0) return u;
+    const p = [], A = /* @__PURE__ */ new Set();
+    for (let C = a; C >= 0 && !A.has(C); C = g.get(C) ?? -1) {
+      A.add(C);
+      let M = -1;
+      try {
+        M = t.GetLineType(e, C);
+      } catch {
+      }
+      if (M === ne) break;
+      const E = I(C);
+      E && p.unshift(E);
+    }
+    const S = p.join(Et);
+    return R.set(a, S), S;
+  };
+  h(Wt, (a) => {
+    const u = l(a.RelatingStructure), p = i(a.RelatingStructure), A = L(u);
+    for (const S of a.RelatedElements ?? []) {
+      const C = l(S);
+      o.set(C, p), n.set(C, A);
+    }
+  }), h(Qt, (a) => {
+    const u = l(a.RelatingType);
+    if (u < 0) return;
+    let p = "";
+    try {
+      p = t.GetNameFromTypeCode(t.GetLineType(e, u));
+    } catch {
+    }
+    const A = [p, I(u)].filter(Boolean).join(Et);
+    if (A)
+      for (const S of a.RelatedObjects ?? []) s.set(l(S), A);
+  }), h(ee, (a) => {
+    const u = l(a.RelatingGroup);
+    if (u < 0) return;
+    const p = L(u) || I(u);
+    if (p)
+      for (const A of a.RelatedObjects ?? []) r.set(l(A), p);
+  });
+  const O = /* @__PURE__ */ new Map(), k = (a) => {
+    const u = O.get(a);
+    if (u !== void 0) return u;
+    const p = [], A = /* @__PURE__ */ new Set();
+    for (let C = a; C >= 0 && !A.has(C); ) {
+      A.add(C);
+      const M = y(C);
+      if (!M) break;
+      const E = B(M.Identification) || B(M.ItemReference), V = B(M.Name), Q = [E, V].filter(Boolean).join(" ");
+      Q && p.unshift(Q), C = l(M.ReferencedSource);
+    }
+    const S = p.join(Et);
+    return O.set(a, S), S;
+  };
+  h(te, (a) => {
+    const u = k(l(a.RelatingClassification));
+    if (u)
+      for (const p of a.RelatedObjects ?? []) c.set(l(p), u);
+  });
+  const T = /* @__PURE__ */ new Map(), U = (a) => {
+    const u = l(a);
+    if (u < 0) return "";
+    const p = T.get(u);
+    if (p !== void 0) return p;
+    const A = y(u);
+    let S = B(A?.Name);
+    if (!S && A)
+      for (const C of ["ForLayerSet", "MaterialLayers", "Materials", "MaterialConstituents", "MaterialProfiles"]) {
+        const M = A[C], E = Array.isArray(M) ? M[0] : M;
+        if (!E) continue;
+        const V = y(l(E));
+        if (S = B(V?.Name) || B(V?.LayerSetName) || i(V?.Material), S) break;
+      }
+    return T.set(u, S), S;
+  };
+  h(Xt, (a) => {
+    const u = U(a.RelatingMaterial);
+    for (const p of a.RelatedObjects ?? []) f.set(l(p), u);
+  });
+  const $ = /* @__PURE__ */ new Map(), D = (a) => {
+    const u = l(a);
+    if (u < 0) return 0;
+    const p = $.get(u);
+    if (p !== void 0) return p;
+    const A = y(u);
+    let S = 0;
+    for (const C of A?.Quantities ?? []) {
+      const M = y(l(C));
+      if (B(M?.Name) === "NetVolume") {
+        S = Number(B(M?.VolumeValue)) || 0;
+        break;
+      }
+    }
+    return $.set(u, S), S;
+  };
+  return h(qt, (a) => {
+    const u = D(a.RelatingPropertyDefinition);
+    if (u)
+      for (const p of a.RelatedObjects ?? []) d.set(l(p), u);
+  }), { container: o, spatialPath: n, typePath: s, systemPath: r, classificationPath: c, material: f, volume: d };
+}
+const vt = 30, we = 5e3, Ie = 15e4;
+function Me(t, e) {
+  return `${Math.floor(t / vt)},${Math.floor(e / vt)}`;
+}
+function Ae(t, e) {
+  const o = /* @__PURE__ */ new Map(), n = (c, f, d) => `${Math.round(c * 1e4) / 1e4},${Math.round(f * 1e4) / 1e4},${Math.round(d * 1e4) / 1e4}`;
+  for (const c of t.values()) {
+    const { positions: f, indices: d, featureIds: m } = c;
+    for (let y = 0; y < d.length; y += 3) {
+      const l = d[y], i = d[y + 1], h = d[y + 2], g = f[l * 3], w = f[l * 3 + 1], I = f[l * 3 + 2], R = f[i * 3], L = f[i * 3 + 1], O = f[i * 3 + 2], k = f[h * 3], T = f[h * 3 + 1], U = f[h * 3 + 2], $ = R - g, D = L - w, a = O - I, u = k - g, p = T - w, A = U - I, S = D * A - a * p, C = a * u - $ * A, M = $ * p - D * u, E = Math.hypot(S, C, M);
+      if (!E) continue;
+      const V = [S / E, C / E, M / E], Q = m[l];
+      let tt = o.get(Q);
+      tt || o.set(Q, tt = /* @__PURE__ */ new Map());
+      const K = n(g, w, I), ot = n(R, L, O), st = n(k, T, U), Y = [[K, ot], [ot, st], [st, K]];
+      for (const [H, rt] of Y) {
+        const lt = H < rt ? `${H}|${rt}` : `${rt}|${H}`, et = tt.get(lt);
+        et ? et.push(V) : tt.set(lt, [V]);
+      }
+    }
+  }
+  const s = Math.cos(e * Math.PI / 180), r = [];
+  for (const [c, f] of o) {
+    const d = [];
+    for (const [l, i] of f)
+      if (i.length === 1) d.push(l);
+      else if (i.length >= 2) {
+        const [h, g] = i;
+        Math.abs(h[0] * g[0] + h[1] * g[1] + h[2] * g[2]) < s && d.push(l);
+      }
+    const m = /* @__PURE__ */ new Map();
+    for (const l of d) {
+      const [i, h] = l.split("|");
+      (m.get(i) ?? m.set(i, []).get(i)).push(h), (m.get(h) ?? m.set(h, []).get(h)).push(i);
+    }
+    const y = new Set(d);
+    for (; y.size; ) {
+      const l = y.values().next().value;
+      y.delete(l);
+      const i = l.split("|");
+      for (const h of [!0, !1])
+        for (; ; ) {
+          const g = h ? i[0] : i[i.length - 1];
+          let w = null;
+          for (const I of m.get(g) ?? []) {
+            const R = g < I ? `${g}|${I}` : `${I}|${g}`;
+            if (y.has(R)) {
+              y.delete(R), w = I;
+              break;
+            }
+          }
+          if (!w) break;
+          h ? i.unshift(w) : i.push(w);
+        }
+      r.push([c, i.map((h) => h.split(",").map(Number))]);
+    }
+  }
+  return r;
+}
+class Vt {
+  parts = [];
+  offset = 0;
+  bufferViews = [];
+  accessors = [];
+  view(e, o) {
+    const n = (4 - this.offset % 4) % 4;
+    n && (this.parts.push(new Uint8Array(n)), this.offset += n);
+    const s = this.bufferViews.length;
+    return this.bufferViews.push({ buffer: 0, byteOffset: this.offset, byteLength: e.byteLength, ...o ? { target: o } : {} }), this.parts.push(e), this.offset += e.byteLength, s;
+  }
+  floats(e, o) {
+    const n = Float32Array.from(e), r = {
+      bufferView: this.view(new Uint8Array(n.buffer), 34962),
+      componentType: 5126,
+      count: n.length / o,
+      type: o === 3 ? "VEC3" : "SCALAR"
+    };
+    if (o === 3) {
+      const c = [1 / 0, 1 / 0, 1 / 0], f = [-1 / 0, -1 / 0, -1 / 0];
+      for (let d = 0; d < n.length; d += 3)
+        for (let m = 0; m < 3; m++)
+          n[d + m] < c[m] && (c[m] = n[d + m]), n[d + m] > f[m] && (f[m] = n[d + m]);
+      r.min = c, r.max = f;
+    }
+    return this.accessors.push(r), this.accessors.length - 1;
+  }
+  indices(e) {
+    const o = Uint32Array.from(e), n = this.view(new Uint8Array(o.buffer), 34963);
+    return this.accessors.push({ bufferView: n, componentType: 5125, count: o.length, type: "SCALAR" }), this.accessors.length - 1;
+  }
+  raw(e) {
+    return this.view(e);
+  }
+  binary() {
+    const e = this.parts.reduce((s, r) => s + r.byteLength, 0), o = new Uint8Array(e);
+    let n = 0;
+    for (const s of this.parts)
+      o.set(s, n), n += s.byteLength;
+    return o;
+  }
+}
+function xe(t) {
+  const e = new TextEncoder(), o = t.map((c) => e.encode(c ?? "")), n = new Uint8Array(o.reduce((c, f) => c + f.length, 0)), s = new Uint32Array(t.length + 1);
+  let r = 0;
+  return o.forEach((c, f) => {
+    s[f] = r, n.set(c, r), r += c.length;
+  }), s[t.length] = r, { blob: n, offsets: new Uint8Array(s.buffer) };
+}
+function Gt(t, e, o) {
+  const n = new Vt(), s = [], r = [];
+  for (const i of e.values()) {
+    const h = n.floats(i.positions, 3), g = n.floats(i.normals, 3), w = n.floats(i.featureIds, 1), I = n.indices(i.indices), [R, L, O, k] = i.colour;
+    s.push({
+      name: i.label,
+      doubleSided: !0,
+      ...k < 1 ? { alphaMode: "BLEND" } : {},
+      pbrMetallicRoughness: { baseColorFactor: [R, L, O, k], metallicFactor: 0, roughnessFactor: 0.85 }
+    }), r.push({
+      name: i.label,
+      primitives: [
+        {
+          attributes: { POSITION: h, NORMAL: g, _FEATURE_ID_0: w },
+          indices: I,
+          material: s.length - 1,
+          mode: 4,
+          extensions: { EXT_mesh_features: { featureIds: [{ attribute: 0, propertyTable: 0 }] } }
+        }
+      ]
+    });
+  }
+  const c = {}, f = {}, m = ["spatialPath", "typePath", "systemPath", "classificationPath"].filter((i) => t.some((h) => h[i]));
+  for (const i of ["ifcClass", "name", "material", "container", ...m]) {
+    const { blob: h, offsets: g } = xe(t.map((w) => w[i]));
+    f[i] = { values: n.raw(h), stringOffsets: n.raw(g) }, c[i] = { name: i, type: "STRING" };
+  }
+  const y = Float32Array.from(t.map((i) => i.netVolume || 0));
+  return f.netVolume = { values: n.raw(new Uint8Array(y.buffer)) }, c.netVolume = { name: "netVolume", type: "SCALAR", componentType: "FLOAT32" }, ["bboxMinE", "bboxMinN", "bboxMinU", "bboxMaxE", "bboxMaxN", "bboxMaxU"].forEach((i, h) => {
+    const g = Float32Array.from(t.map((w, I) => {
+      const R = o[I]?.[h];
+      return Number.isFinite(R) ? R : 0;
+    }));
+    f[i] = { values: n.raw(new Uint8Array(g.buffer)) }, c[i] = { name: i, type: "SCALAR", componentType: "FLOAT32" };
+  }), zt(n, r, s, {
+    extensionsUsed: ["EXT_mesh_features", "EXT_structural_metadata"],
+    extensions: {
+      EXT_structural_metadata: {
+        schema: { id: "ifcSchema", classes: { ifcElement: { name: "IFC element", properties: c } } },
+        propertyTables: [{ name: "elements", class: "ifcElement", count: t.length, properties: f }]
+      }
+    }
+  });
+}
+function zt(t, e, o, n = {}) {
+  const s = t.binary(), r = {
+    asset: { version: "2.0", generator: "onlymapjs web-ifc loader" },
+    ...n,
+    scene: 0,
+    scenes: [{ nodes: e.map((w, I) => I) }],
+    nodes: e.map((w, I) => ({ mesh: I, name: w.name })),
+    meshes: e,
+    materials: o,
+    accessors: t.accessors,
+    bufferViews: t.bufferViews,
+    buffers: [{ byteLength: s.byteLength }]
+  }, c = new TextEncoder().encode(JSON.stringify(r)), f = (w, I, R) => {
+    const L = (4 - I.byteLength % 4) % 4, O = new Uint8Array(8), k = new DataView(O.buffer);
+    return k.setUint32(0, I.byteLength + L, !0), k.setUint32(4, w, !0), [O, I, new Uint8Array(L).fill(R)];
+  }, d = f(1313821514, c, 32), m = f(5130562, s, 0), y = new Uint8Array(12), l = new DataView(y.buffer);
+  l.setUint32(0, 1179937895, !0), l.setUint32(4, 2, !0);
+  const i = 12 + [...d, ...m].reduce((w, I) => w + I.byteLength, 0);
+  l.setUint32(8, i, !0);
+  const h = new Uint8Array(i);
+  let g = 0;
+  for (const w of [y, ...d, ...m])
+    h.set(w, g), g += w.byteLength;
+  return h;
+}
+async function Ee(t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const s of t.values()) {
+    const r = s.colour.join(",");
+    let c = e.get(r);
+    c || e.set(r, c = { vertexCount: 0, indexCount: 0, colour: s.colour }), c.vertexCount += s.positions.length / 3, c.indexCount += s.indices.length;
+  }
+  const o = /* @__PURE__ */ new Map();
+  for (const [s, r] of e)
+    o.set(s, {
+      positions: new Float32Array(r.vertexCount * 3),
+      indices: new Uint32Array(r.indexCount),
+      colour: r.colour,
+      vertexOffset: 0,
+      indexOffset: 0
+    });
+  let n = 0;
+  for (const s of t.values()) {
+    n++, n % 50 === 0 && await new Promise((d) => setTimeout(d));
+    const r = s.colour.join(","), c = o.get(r), f = c.vertexOffset;
+    c.positions.set(s.positions, f * 3);
+    for (let d = 0; d < s.indices.length; d++) c.indices[c.indexOffset + d] = s.indices[d] + f;
+    c.vertexOffset += s.positions.length / 3, c.indexOffset += s.indices.length;
+  }
+  return o;
+}
+const Se = vt * 3, Ce = 8, Re = 900, Te = 0.93;
+async function ve(t, e) {
+  const { MeshoptSimplifier: o } = await import("./meshopt_simplifier-Co6uRDDA.js");
+  await o.ready;
+  const n = await Ee(t), s = [...n.values()].reduce((l, i) => l + i.indices.length / 3, 0), r = new Vt(), c = [], f = [];
+  let d = 0;
+  const m = n.size;
+  for (const l of n.values()) {
+    d++, e(`Building coarse level of detail… ${d}/${m}`), await new Promise((M) => setTimeout(M));
+    const i = l.indices.length / 3;
+    if (!i) continue;
+    const h = s ? i / s : 0, g = Math.max(1, Math.round(Ie * h)), w = Math.min(l.indices.length, g * 3), I = l.positions, R = l.indices, [L] = o.simplify(R, I, 3, w, 0.2, ["Prune"]), O = [...new Set(L)], k = new Map(O.map((M, E) => [M, E])), T = new Float32Array(O.length * 3);
+    for (let M = 0; M < O.length; M++) {
+      const E = O[M];
+      T[M * 3] = I[E * 3], T[M * 3 + 1] = I[E * 3 + 1], T[M * 3 + 2] = I[E * 3 + 2];
+    }
+    const U = Uint32Array.from(L, (M) => k.get(M)), $ = new Float32Array(T.length);
+    for (let M = 0; M < U.length; M += 3) {
+      const [E, V, Q] = [U[M], U[M + 1], U[M + 2]], tt = (et) => [T[et * 3], T[et * 3 + 1], T[et * 3 + 2]], [K, ot, st] = [tt(E), tt(V), tt(Q)], Y = [ot[0] - K[0], ot[1] - K[1], ot[2] - K[2]], H = [st[0] - K[0], st[1] - K[1], st[2] - K[2]], rt = [Y[1] * H[2] - Y[2] * H[1], Y[2] * H[0] - Y[0] * H[2], Y[0] * H[1] - Y[1] * H[0]], lt = Math.hypot(...rt) || 1;
+      for (const et of [E, V, Q]) for (let b = 0; b < 3; b++) $[et * 3 + b] = rt[b] / lt;
+    }
+    const D = r.floats(Array.from(T), 3), a = r.floats(Array.from($), 3), u = r.indices(Array.from(U)), [p, A, S, C] = l.colour;
+    c.push({
+      name: `lod-${c.length}`,
+      doubleSided: !0,
+      ...C < 1 ? { alphaMode: "BLEND" } : {},
+      pbrMetallicRoughness: { baseColorFactor: [p, A, S, C], metallicFactor: 0, roughnessFactor: 0.85 }
+    }), f.push({
+      name: `lod-${f.length}`,
+      primitives: [{ attributes: { POSITION: D, NORMAL: a }, indices: u, material: c.length - 1, mode: 4 }]
+    });
+  }
+  const y = Ce * Se * Te / Re;
+  return { glb: zt(r, f, c), geometricError: y };
+}
+function Oe(t, e) {
+  const o = t * Math.PI / 180, n = e * Math.PI / 180, [s, r, c, f] = [Math.sin(o), Math.cos(o), Math.sin(n), Math.cos(n)], d = At / Math.sqrt(1 - Z * c * c);
+  return {
+    east: [-s, r, 0],
+    north: [-c * r, -c * s, f],
+    up: [f * r, f * s, c],
+    origin: [d * f * r, d * f * s, d * (1 - Z) * c]
+  };
+}
+async function Ne(t, e = {}) {
+  const { onProgress: o = () => {
+  }, fallbackLonLat: n = [-122.41, 37.8], edges: s = !0, creaseDegrees: r = 25 } = e, c = t instanceof Blob ? await t.arrayBuffer() : t, f = c instanceof Uint8Array ? c : new Uint8Array(c), d = {};
+  let m = performance.now();
+  const y = (h) => {
+    d[h] = Math.round(performance.now() - m), m = performance.now();
+  };
+  o("Starting web-ifc…");
+  const l = await le();
+  y("boot");
+  const i = l.OpenModel(f, { COORDINATE_TO_ORIGIN: !1 });
+  try {
+    y("open"), o("Indexing relationships…");
+    const h = be(l, i);
+    y("relationships");
+    const g = await ye(l, i, n), { georeferenced: w, heading: I, scale: R, headingSource: L, affine: O, hasOrthogonalHeight: k } = g;
+    let T = g.lonLat, U = g.originSource;
+    o("Reading geometry…");
+    const $ = l.LoadAllGeometry(i);
+    y("loadAllGeometry");
+    const D = [];
+    for (let b = 0; b < $.size(); b++) {
+      const x = $.get(b), _ = [];
+      for (let G = 0; G < x.geometries.size(); G++) {
+        const W = x.geometries.get(G);
+        _.push({
+          id: W.geometryExpressID,
+          colour: [W.color.x, W.color.y, W.color.z, W.color.w],
+          matrix: Array.from(W.flatTransformation)
+        });
+      }
+      D.push({ expressID: x.expressID, placed: _ });
+    }
+    const a = [], u = /* @__PURE__ */ new Map(), p = [1 / 0, 1 / 0, 1 / 0], A = [-1 / 0, -1 / 0, -1 / 0], S = [];
+    let C = 0;
+    const M = D.length > we;
+    for (let b = 0; b < D.length; b++) {
+      const x = D[b], _ = a.length;
+      let G = "IfcProduct", W = "";
+      try {
+        G = l.GetNameFromTypeCode(l.GetLineType(i, x.expressID)) || G, W = B(l.GetLine(i, x.expressID, !1).Name);
+      } catch {
+      }
+      a.push({
+        ifcClass: G,
+        name: W,
+        material: h.material.get(x.expressID) ?? "",
+        container: h.container.get(x.expressID) ?? "",
+        spatialPath: h.spatialPath.get(x.expressID) ?? "",
+        typePath: h.typePath.get(x.expressID) ?? "",
+        systemPath: h.systemPath.get(x.expressID) ?? "",
+        classificationPath: h.classificationPath.get(x.expressID) ?? "",
+        netVolume: h.volume.get(x.expressID) ?? 0
+      }), S.push([1 / 0, 1 / 0, 1 / 0, -1 / 0, -1 / 0, -1 / 0]);
+      const it = x.placed[0]?.matrix, J = M && it ? Me(it[12], -it[14]) : "";
+      for (const X of x.placed) {
+        const q = l.GetGeometry(i, X.id), ct = l.GetVertexArray(q.GetVertexData(), q.GetVertexDataSize()), mt = l.GetIndexArray(q.GetIndexData(), q.GetIndexDataSize()), v = X.matrix, ut = X.colour.map((z) => Math.round(z * 1e3) / 1e3).join(","), nt = M ? `${J} ${ut}` : ut;
+        let j = u.get(nt);
+        j || (j = { positions: [], normals: [], featureIds: [], indices: [], colour: X.colour, label: `colour-${u.size}`, cellKey: J }, u.set(nt, j));
+        const xt = j.featureIds.length;
+        for (let z = 0; z < ct.length; z += 6) {
+          const [ht, dt, pt] = [ct[z], ct[z + 1], ct[z + 2]], yt = v[0] * ht + v[4] * dt + v[8] * pt + v[12], bt = v[1] * ht + v[5] * dt + v[9] * pt + v[13], wt = v[2] * ht + v[6] * dt + v[10] * pt + v[14], [gt, P, N] = [ct[z + 3], ct[z + 4], ct[z + 5]];
+          j.positions.push(yt, bt, wt), j.normals.push(v[0] * gt + v[4] * P + v[8] * N, v[1] * gt + v[5] * P + v[9] * N, v[2] * gt + v[6] * P + v[10] * N), j.featureIds.push(_);
+          const at = [yt, -wt, bt], It = S[_];
+          for (let F = 0; F < 3; F++)
+            at[F] < p[F] && (p[F] = at[F]), at[F] > A[F] && (A[F] = at[F]), at[F] < It[F] && (It[F] = at[F]), at[F] > It[F + 3] && (It[F + 3] = at[F]);
+        }
+        for (let z = 0; z < mt.length; z++) j.indices.push(xt + mt[z]);
+        C += ct.length / 6, q.delete();
+      }
+      (b + 1) % 250 === 0 && (o(`Reading geometry… ${b + 1}/${D.length} elements`), await new Promise((X) => setTimeout(X)));
+    }
+    if (y("meshes"), !a.length) throw new Error("no geometry found in this IFC");
+    if (!C)
+      throw new Error(`parsed ${a.length} elements but web-ifc returned no vertices for any of them`);
+    const E = e.origin ?? [(p[0] + A[0]) / 2, (p[1] + A[1]) / 2, p[2]];
+    for (const b of u.values()) {
+      const x = b.positions;
+      for (let _ = 0; _ < x.length; _ += 3)
+        x[_] -= E[0], x[_ + 1] -= E[2], x[_ + 2] += E[1];
+    }
+    for (const b of S)
+      for (let x = 0; x < 3; x++)
+        b[x] -= E[x], b[x + 3] -= E[x];
+    for (let b = 0; b < 3; b++)
+      p[b] -= E[b], A[b] -= E[b];
+    if (O?.code != null) {
+      const b = await me(O, E[0], E[1]);
+      b ? T = b : U === "map-conversion" && (U = "ifc-site", console.warn(
+        `[onlymap] IfcMapConversion into EPSG:${O.code} was read but its anchor could not be re-projected at the model centre — the position may be off by the model's origin-to-centre distance. Placement is flagged approximate; set the layer's site-origin to correct it.`
+      ));
+    }
+    const V = Oe(T[0], T[1]), Q = [...V.east, 0, ...V.north, 0, ...V.up, 0, ...V.origin, 1];
+    o("Building tiles…");
+    const tt = [];
+    let K = 0;
+    const ot = (b, x) => {
+      K += b.byteLength;
+      const _ = `${URL.createObjectURL(new Blob([b], { type: "model/gltf-binary" }))}#${x}`;
+      return tt.push(_), _;
+    }, st = Math.max(...[0, 1, 2].map((b) => A[b] - p[b])) * 0.75 || 25, Y = [0, 0, 0, st, 0, 0, 0, st, 0, 0, 0, st];
+    let H;
+    if (M) {
+      const { glb: b, geometricError: x } = await ve(u, o), _ = ot(b, "lod-root.glb");
+      y("lodRoot");
+      const G = /* @__PURE__ */ new Map();
+      for (const [J, X] of u) {
+        let q = G.get(X.cellKey);
+        q || G.set(X.cellKey, q = /* @__PURE__ */ new Map()), q.set(J, X);
+      }
+      const W = [], it = [...G.values()];
+      for (let J = 0; J < it.length; J++) {
+        o(`Building spatial tiles… ${J + 1}/${it.length}`), await new Promise((P) => setTimeout(P));
+        const X = it[J], q = [...new Set([...X.values()].flatMap((P) => P.featureIds))].sort((P, N) => P - N), ct = new Map(q.map((P, N) => [P, N])), mt = q.map((P) => a[P]), v = q.map((P) => S[P]), ut = /* @__PURE__ */ new Map();
+        for (const [P, N] of X)
+          ut.set(P, { ...N, featureIds: N.featureIds.map((at) => ct.get(at)) });
+        const nt = [1 / 0, 1 / 0, 1 / 0], j = [-1 / 0, -1 / 0, -1 / 0];
+        for (const P of v)
+          for (let N = 0; N < 3; N++)
+            P[N] < nt[N] && (nt[N] = P[N]), P[N + 3] > j[N] && (j[N] = P[N + 3]);
+        const xt = (nt[0] + j[0]) / 2, z = (nt[1] + j[1]) / 2, ht = (nt[2] + j[2]) / 2, dt = Math.max((j[0] - nt[0]) / 2, 0.5), pt = Math.max((j[1] - nt[1]) / 2, 0.5), yt = Math.max((j[2] - nt[2]) / 2, 0.5), bt = [xt, z, ht, dt, 0, 0, 0, pt, 0, 0, 0, yt], wt = Gt(mt, ut, v), gt = ot(wt, `cell-${J}.glb`);
+        W.push({ boundingVolume: { box: bt }, geometricError: 0, content: { uri: gt } });
+      }
+      y("glb"), H = {
+        asset: { version: "1.1" },
+        geometricError: x,
+        root: {
+          boundingVolume: { box: Y },
+          geometricError: x,
+          refine: "REPLACE",
+          transform: Q,
+          content: { uri: _ },
+          children: W
+        }
+      };
+    } else {
+      const b = Gt(a, u, S);
+      y("glb");
+      const x = ot(b, "model.glb");
+      H = {
+        asset: { version: "1.1" },
+        geometricError: 512,
+        root: {
+          boundingVolume: { box: Y },
+          geometricError: 512,
+          refine: "ADD",
+          transform: Q,
+          // Absolute blob URL on purpose: a relative content path has no
+          // meaning resolved against a blob: base.
+          children: [{ boundingVolume: { box: Y }, geometricError: 0, content: { uri: x } }]
+        }
+      };
+    }
+    const rt = `${URL.createObjectURL(new Blob([JSON.stringify(H)], { type: "application/json" }))}#tileset.json`;
+    let lt = null, et = 0;
+    if (s) {
+      o("Tracing outlines…"), await new Promise((x) => setTimeout(x));
+      const b = Ae(u, r).map(([x, _]) => {
+        const G = a[x];
+        return {
+          // Local east/north/up METRES from the model's own anchor, NOT
+          // lon/lat. Geographic coordinates would nail the outlines to
+          // whatever position the file was parsed at, so `site-origin` and
+          // `site-heading` could move the mesh and leave its edges behind.
+          // METER_OFFSETS places these from the layer's `site-origin`, the
+          // same point the tileset is anchored at. Buckets are glTF Y-up —
+          // (east, up, -north) — hence the shuffle. Millimetre rounding is
+          // finer than any IFC tolerance and meaningfully cheaper to
+          // stringify across a six-figure point count.
+          path: _.map(([W, it, J]) => [
+            // Bucket positions were shifted by `origin` before the GLB was
+            // built, so they are ALREADY tile-local — subtracting again here
+            // would move the outlines off the mesh by exactly one origin.
+            Math.round(W * 1e3) / 1e3,
+            Math.round(-J * 1e3) / 1e3,
+            Math.round(it * 1e3) / 1e3
+          ]),
+          // The same category fields the mesh filters on, so one visible-value
+          // set can drive both the mesh and its outline overlay.
+          ifcClass: G.ifcClass,
+          material: G.material,
+          container: G.container,
+          spatialPath: G.spatialPath,
+          typePath: G.typePath,
+          systemPath: G.systemPath,
+          classificationPath: G.classificationPath
+        };
+      });
+      et = b.length, lt = URL.createObjectURL(new Blob([JSON.stringify(b)], { type: "application/json" })), y("edges");
+    }
+    return {
+      tilesetUrl: rt,
+      edgesUrl: lt,
+      loadOptions: { "3d-tiles": { isTileset: !0 }, gltf: { loadBuffers: !0 } },
+      features: a,
+      lonLat: T,
+      georeferenced: w,
+      origin: E,
+      heading: I,
+      scale: R,
+      headingSource: L,
+      originSource: U,
+      // See correctOrthogonalHeightForRecentring's doc comment. `centre[2]`
+      // is still the model's ORIGINAL, pre-recentre local height at the
+      // point that becomes the tile origin — never mutated, only `lo`/`hi`
+      // are.
+      orthogonalHeight: k ? he(O.orthogonalHeight, E[2]) : void 0,
+      stats: { elements: a.length, primitives: u.size, polylines: et, bytes: K },
+      timings: d,
+      bounds: { lo: p, hi: A, centre: E },
+      revoke() {
+        for (const b of [...tt, rt, lt])
+          b && URL.revokeObjectURL(b.split("#")[0]);
+      }
+    };
+  } finally {
+    l.CloseModel(i);
+  }
+}
+export {
+  we as GRID_TILING_THRESHOLD,
+  Et as SPATIAL_SEPARATOR,
+  ue as buildMapConversionAffine,
+  Pt as compoundAngleToDegrees,
+  Pe as configureIfc,
+  he as correctOrthogonalHeightForRecentring,
+  Me as gridCellKey,
+  Ne as loadIfc,
+  fe as mapConversionApply,
+  jt as parseUtmCrs,
+  ce as pinnedWebIfcSha256,
+  ye as readGeoreference,
+  me as reanchorMapConversion,
+  ge as utmGridConvergence,
+  Dt as utmToLonLat
+};