@nebula-spatial/cad-loader 0.1.0

package/dist/index.js

@@ -0,0 +1,4435 @@
+var Zn = Object.defineProperty;
+var Lt = (t) => {
+  throw TypeError(t);
+};
+var Jn = (t, n, e) => n in t ? Zn(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
+var m = (t, n, e) => Jn(t, typeof n != "symbol" ? n + "" : n, e), Ke = (t, n, e) => n.has(t) || Lt("Cannot " + e);
+var p = (t, n, e) => (Ke(t, n, "read from private field"), e ? e.call(t) : n.get(t)), B = (t, n, e) => n.has(t) ? Lt("Cannot add the same private member more than once") : n instanceof WeakSet ? n.add(t) : n.set(t, e), k = (t, n, e, r) => (Ke(t, n, "write to private field"), r ? r.call(t, e) : n.set(t, e), e), R = (t, n, e) => (Ke(t, n, "access private method"), e);
+import { CadPackError as A, normalizeGeometrySegments as er, normalizeViewportRect as yt, cloneViewportRect as _e, mergeViewportRects as Le, readGroup as tr, transformBBoxByInstance as nr, parseBinStreaming as mt, isStrictTextRoundtripEnabled as rr, assertStrictTextRoundtrip as ir, computeViewportRectFromPositions as Me, expandViewportRect as ar, viewportRectEquals as sr, viewportRectIntersects as or, viewportRectContains as lr, transformViewportRect as cr, parseBinPayload as ur, parseBinBounds as dr, readExternalAnnotationManifest as yn, readExternalBlockAnnotations as mn, readExternalVariantDependencyPlan as xn, readExternalVariantManifest as hr, readSceneAnnotationSidecar as fr } from "./core/index.js";
+import { readBlockAnnotationSidecar as Ts } from "./core/index.js";
+import { BufferAttribute as U, RawShaderMaterial as yr, Color as pn, Vector2 as gn, DoubleSide as st, BufferGeometry as xt, LineSegments as pt, InstancedInterleavedBuffer as Mt, InstancedBufferGeometry as bn, Float32BufferAttribute as Cn, InterleavedBufferAttribute as Te, Mesh as gt, Vector3 as Ye, Box3 as mr, Sphere as xr, Object3D as In, InstancedBufferAttribute as ce, Points as wn, Group as j, PointsMaterial as Dt, LineBasicMaterial as Ft, MeshBasicMaterial as Ot } from "three";
+import { BatchedText as Gt, Text as pr } from "troika-three-text";
+import gr from "rbush";
+const bt = 16.7, Ct = 6, It = 128 * 1024 * 1024, wt = 64 * 1024 * 1024, vt = 2, Rt = 1, br = 3e5, Cr = 22e4, _t = 2;
+function te(t, n = "CAD load aborted") {
+  if (t instanceof Error && t.name === "AbortError") return t;
+  const e = typeof t == "string" && t.length > 0 ? t : n, r = new Error(e, t === void 0 ? void 0 : { cause: t });
+  return r.name = "AbortError", r;
+}
+function zt(t, n) {
+  if (!t) return () => {
+  };
+  if (t.aborted)
+    return n.abort(t.reason), () => {
+    };
+  const e = () => n.abort(t.reason);
+  return t.addEventListener("abort", e, { once: !0 }), () => t.removeEventListener("abort", e);
+}
+function Ir(t, n, e = "CAD load aborted") {
+  return n.aborted ? Promise.reject(te(n.reason, e)) : new Promise((r, i) => {
+    const a = () => {
+      s(), i(te(n.reason, e));
+    }, s = () => n.removeEventListener("abort", a);
+    n.addEventListener("abort", a, { once: !0 }), t.then(
+      (o) => {
+        s(), r(o);
+      },
+      (o) => {
+        s(), i(o);
+      }
+    );
+  });
+}
+function Ne(t) {
+  return typeof t == "object" && t !== null;
+}
+function Ut(t) {
+  return Ne(t) && typeof t.arrayBuffer == "function";
+}
+function wr(t) {
+  return typeof URL == "function" && t instanceof URL;
+}
+function vr(t) {
+  return Ne(t) && typeof t.aborted == "boolean" && typeof t.addEventListener == "function" && typeof t.removeEventListener == "function";
+}
+function Bt(t, n) {
+  if (t instanceof ArrayBuffer)
+    return { source: { kind: "buffer", buffer: t } };
+  if (typeof t == "string" || wr(t)) {
+    const r = String(t);
+    if (r.trim().length === 0)
+      throw new A("E_SOURCE", "URL source must include a non-empty URL");
+    return { source: { kind: "url", url: r, signal: n } };
+  }
+  if (Ut(t) && !("kind" in t))
+    return { source: { kind: "packFile", file: t } };
+  if (!Ne(t))
+    throw new A("E_SOURCE", "CAD load source must be an ArrayBuffer, File, URL, or source object");
+  const e = t;
+  switch (e.kind) {
+    case "buffer":
+      if (!(e.buffer instanceof ArrayBuffer))
+        throw new A("E_SOURCE", "Buffer source must include an ArrayBuffer");
+      return { source: { kind: "buffer", buffer: e.buffer } };
+    case "packFile":
+      if (!Ut(e.file))
+        throw new A("E_SOURCE", "Pack file source must include a File-like object");
+      return { source: { kind: "packFile", file: e.file } };
+    case "url": {
+      if (typeof e.url != "string" || e.url.trim().length === 0)
+        throw new A("E_SOURCE", "URL source must include a non-empty URL");
+      const r = vr(e.signal) ? e.signal : void 0;
+      return {
+        source: { kind: "url", url: e.url, signal: n },
+        sourceSignal: r
+      };
+    }
+    default:
+      throw new A("E_SOURCE", `Unsupported CAD load source kind: ${String(e.kind)}`);
+  }
+}
+function Rr(t) {
+  if (!Ne(t) || typeof t.kind != "string")
+    throw new A("E_SOURCE", "Geo source must be an object");
+  Bt(t, new AbortController().signal);
+}
+function ot() {
+  return typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+}
+function Br(t) {
+  if (typeof queueMicrotask == "function") {
+    queueMicrotask(t);
+    return;
+  }
+  Promise.resolve().then(t);
+}
+class vn {
+  constructor(n) {
+    m(this, "highWatermarkBytes");
+    m(this, "lowWatermarkBytes");
+    m(this, "initialGeometryCredits");
+    m(this, "initialTextCredits");
+    m(this, "queuedBytes", 0);
+    m(this, "paused", !1);
+    m(this, "initialGranted", !1);
+    this.highWatermarkBytes = Math.max(0, n.highWatermarkBytes), this.lowWatermarkBytes = Math.max(0, Math.min(n.lowWatermarkBytes, this.highWatermarkBytes)), this.initialGeometryCredits = Math.max(0, n.initialGeometryCredits), this.initialTextCredits = Math.max(0, n.initialTextCredits);
+  }
+  takeInitialGrant() {
+    return this.initialGranted ? { geometryCredits: 0, textCredits: 0 } : (this.initialGranted = !0, {
+      geometryCredits: this.initialGeometryCredits,
+      textCredits: this.initialTextCredits
+    });
+  }
+  onQueued(n, e) {
+    this.queuedBytes += Math.max(0, e), this.queuedBytes > this.highWatermarkBytes && (this.paused = !0);
+  }
+  onConsumed(n, e) {
+    return this.queuedBytes = Math.max(0, this.queuedBytes - Math.max(0, e)), this.paused && this.shouldStayPaused() ? { geometryCredits: 0, textCredits: 0, paused: !0 } : this.paused ? (this.paused = !1, {
+      geometryCredits: n === "geometry" ? 1 : 0,
+      textCredits: n === "text" ? 1 : 0,
+      paused: !1
+    }) : {
+      geometryCredits: n === "geometry" ? 1 : 0,
+      textCredits: n === "text" ? 1 : 0,
+      paused: !1
+    };
+  }
+  getQueuedBytes() {
+    return this.queuedBytes;
+  }
+  shouldStayPaused() {
+    return this.lowWatermarkBytes === 0 ? this.queuedBytes > 0 : this.queuedBytes >= this.lowWatermarkBytes;
+  }
+}
+async function Rn(t) {
+  const n = Nt(), e = t.fetchImpl ?? fetch, r = new Map(
+    t.entries.map((l) => [l.id, l])
+  ), i = Array.from(new Set(t.requiredVariantIds)).sort((l, u) => l - u), a = /* @__PURE__ */ new Map(), s = Sr(t.concurrency);
+  let o = 0;
+  async function c() {
+    for (; o < i.length; ) {
+      const l = i[o++], u = r.get(l);
+      if (!u)
+        throw new Error(`External block ${l} is missing from manifest`);
+      const d = new URL(u.href, t.baseUrl).href, h = await e(d, { signal: t.signal });
+      if (!h.ok) {
+        const b = "status" in h ? h.status : void 0, g = "statusText" in h ? h.statusText : void 0, C = [b, g].filter((v) => v !== void 0 && v !== "").join(" ");
+        throw new Error(`External block ${l} fetch failed${C ? `: ${C}` : ""}`);
+      }
+      const f = await h.arrayBuffer();
+      if (f.byteLength !== u.raw_size)
+        throw new Error(
+          `External block ${l} raw_size mismatch: manifest=${u.raw_size}, response=${f.byteLength}`
+        );
+      a.set(l, f);
+    }
+  }
+  return await Promise.all(Array.from({ length: Math.min(s, i.length) }, c)), { buffers: a, fetchMs: Nt() - n };
+}
+function Sr(t) {
+  const n = Math.floor(t ?? 3);
+  return Number.isFinite(n) ? Math.max(1, Math.min(n, 8)) : 3;
+}
+function Nt() {
+  var t, n;
+  return ((n = (t = globalThis.performance) == null ? void 0 : t.now) == null ? void 0 : n.call(t)) ?? Date.now();
+}
+var Z;
+class Er {
+  constructor() {
+    B(this, Z, /* @__PURE__ */ new Map());
+  }
+  get size() {
+    return p(this, Z).size;
+  }
+  append(n) {
+    let e = 0;
+    for (const r of n) {
+      if (r.count <= 0) continue;
+      const i = lt(r.layerIndex, r.lineweightPx);
+      let a = p(this, Z).get(i), s = r.pos, o = r.positionItemSize;
+      const c = r.linePositionKind ?? null;
+      a ? a.positionItemSize !== o && (Ht(a), o !== 3 && (s = Sn(s, r.count, o)), a.positionItemSize = 3, o = 3, a.linePositionKind = null) : (a = {
+        layerIndex: r.layerIndex,
+        ...r.lineweightPx === void 0 ? {} : { lineweightPx: r.lineweightPx },
+        posParts: [],
+        positionItemSize: o,
+        colParts: [],
+        colorRunParts: [],
+        linePositionKind: c,
+        count: 0,
+        bbox: null
+      }, p(this, Z).set(i, a));
+      const l = a.count > 0;
+      a.posParts.push(s), a.colParts.push(r.col);
+      const u = Mr(
+        r.colorRuns ?? Dr(r.col),
+        a.count
+      );
+      a.colorRunParts.push(u), a.linePositionKind !== c && (a.linePositionKind = null), a.positionItemSize === 2 && a.linePositionKind === null && Ht(a), a.count += r.count, a.bbox = l && a.bbox === null ? null : kr(a.bbox, r.bbox), e += r.count;
+    }
+    return e;
+  }
+  drain() {
+    const n = [];
+    for (const e of p(this, Z).values()) {
+      if (e.count <= 0) continue;
+      const r = e.posParts.length === 1 ? e.posParts[0] : Pr(e.posParts, e.count * e.positionItemSize), i = e.colParts.length === 1 ? e.colParts[0] : Lr(e.colParts, e.count * 3), a = En(e.colorRunParts.flat()), s = {
+        layerIndex: e.layerIndex,
+        pos: r,
+        positionItemSize: e.positionItemSize,
+        col: i,
+        count: e.count,
+        bbox: yt(e.bbox),
+        colorRuns: a
+      };
+      e.lineweightPx !== void 0 && (s.lineweightPx = e.lineweightPx), e.linePositionKind && (s.linePositionKind = e.linePositionKind), n.push(s);
+    }
+    return p(this, Z).clear(), n;
+  }
+}
+Z = new WeakMap();
+function Xe() {
+  return new Er();
+}
+function Vr() {
+  return {
+    line: Xe(),
+    fill: Xe(),
+    dot: Xe()
+  };
+}
+function kr(t, n) {
+  const e = yt(n);
+  return t ? e ? {
+    minX: Math.min(t.minX, e.minX),
+    minY: Math.min(t.minY, e.minY),
+    maxX: Math.max(t.maxX, e.maxX),
+    maxY: Math.max(t.maxY, e.maxY)
+  } : null : e;
+}
+function de(t, n = {}) {
+  if (t.count <= 0) return [];
+  const e = er(t), r = [], i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), o = n.markLinePositionXy === !0 || n.splitLineweight === !0;
+  for (const g of e) {
+    if (g.vertexCount <= 0) continue;
+    const C = g.layerIndex, v = o ? g.lineweightPx : void 0, x = lt(C, v), I = i.get(x);
+    I === void 0 ? (i.set(x, g.vertexCount), a.set(x, C), s.set(x, v), r.push(x)) : i.set(x, I + g.vertexCount);
+  }
+  const c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Set(), h = n.markLinePositionXy === !0 ? "xy-zero-z" : void 0, f = h ? 2 : 3;
+  for (const g of r) {
+    const C = a.get(g), v = s.get(g), x = i.get(g) ?? 0, I = {
+      layerIndex: C,
+      ...v === void 0 ? {} : { lineweightPx: v },
+      pos: new Float32Array(x * f),
+      positionItemSize: f,
+      col: new Uint8Array(x * 3),
+      count: x,
+      bbox: null,
+      colorRuns: []
+    };
+    h && (I.linePositionKind = h), c.set(g, I), l.set(g, 0), u.set(g, null);
+  }
+  for (const g of e) {
+    if (g.vertexCount <= 0) continue;
+    const C = g.layerIndex, v = o ? g.lineweightPx : void 0, x = lt(C, v), I = c.get(x), V = l.get(x), M = V, Q = g.color[0], q = g.color[1], W = g.color[2];
+    for (let N = 0; N < g.vertexCount; N += 1) {
+      const G = g.startVertex + N, $ = V + N, H = $ * f, ae = $ * 3, se = G * 2, F = t.pos[se], _ = t.pos[se + 1];
+      I.pos[H] = F, I.pos[H + 1] = _, f === 3 && (I.pos[H + 2] = 0), I.col[ae] = Q, I.col[ae + 1] = q, I.col[ae + 2] = W;
+      const D = u.get(x);
+      !Number.isFinite(F) || !Number.isFinite(_) ? d.add(x) : D ? (F < D.minX && (D.minX = F), _ < D.minY && (D.minY = _), F > D.maxX && (D.maxX = F), _ > D.maxY && (D.maxY = _)) : u.set(x, { minX: F, minY: _, maxX: F, maxY: _ });
+    }
+    I.colorRuns.push({
+      startVertex: M,
+      vertexCount: g.vertexCount,
+      color: [Q, q, W]
+    }), l.set(x, V + g.vertexCount);
+  }
+  const b = [];
+  for (const g of r) {
+    const C = c.get(g);
+    C && (C.bbox = d.has(g) ? null : yt(u.get(g) ?? null), C.colorRuns = En(C.colorRuns ?? []), b.push(C));
+  }
+  return b;
+}
+function lt(t, n) {
+  return n === void 0 ? `${t}:` : `${t}:${n}`;
+}
+function Ar(t, n) {
+  return t.append(n);
+}
+function Tr(t) {
+  return t.drain();
+}
+function Bn(t) {
+  return t.reduce((n, e) => n + e.pos.byteLength + e.col.byteLength, 0);
+}
+function Pr(t, n) {
+  const e = new Float32Array(n);
+  let r = 0;
+  for (const i of t)
+    e.set(i, r), r += i.length;
+  return e;
+}
+function Sn(t, n, e) {
+  if (e === 3) return t;
+  const r = new Float32Array(n * 3);
+  for (let i = 0; i < n; i += 1) {
+    const a = i * 2, s = i * 3;
+    r[s] = t[a] ?? 0, r[s + 1] = t[a + 1] ?? 0, r[s + 2] = 0;
+  }
+  return r;
+}
+function Ht(t) {
+  if (t.positionItemSize === 3) return;
+  const n = t.positionItemSize;
+  t.posParts = t.posParts.map((e) => Sn(e, e.length / n, n)), t.positionItemSize = 3, t.linePositionKind = null;
+}
+function Lr(t, n) {
+  const e = new Uint8Array(n);
+  let r = 0;
+  for (const i of t)
+    e.set(i, r), r += i.length;
+  return e;
+}
+function Mr(t, n) {
+  return t.map((e) => ({
+    startVertex: e.startVertex + n,
+    vertexCount: e.vertexCount,
+    color: [e.color[0], e.color[1], e.color[2]]
+  }));
+}
+function En(t) {
+  const n = [];
+  for (const e of t) {
+    const r = n[n.length - 1];
+    if (r && r.startVertex + r.vertexCount === e.startVertex && r.color[0] === e.color[0] && r.color[1] === e.color[1] && r.color[2] === e.color[2]) {
+      n[n.length - 1] = {
+        ...r,
+        vertexCount: r.vertexCount + e.vertexCount
+      };
+      continue;
+    }
+    n.push({
+      startVertex: e.startVertex,
+      vertexCount: e.vertexCount,
+      color: [e.color[0], e.color[1], e.color[2]]
+    });
+  }
+  return n;
+}
+function Dr(t) {
+  const n = Math.floor(t.length / 3), e = [];
+  let r = 0;
+  for (; r < n; ) {
+    const i = r * 3, a = t[i] ?? 0, s = t[i + 1] ?? 0, o = t[i + 2] ?? 0;
+    let c = r + 1;
+    for (; c < n; ) {
+      const l = c * 3;
+      if (t[l] !== a || t[l + 1] !== s || t[l + 2] !== o) break;
+      c += 1;
+    }
+    e.push({ startVertex: r, vertexCount: c - r, color: [a, s, o] }), r = c;
+  }
+  return e;
+}
+function Fr(t, n, e = "u8") {
+  if (n <= 0 && t.byteLength === 0)
+    return { pos: new Float32Array(0), count: 0, segments: [] };
+  const { buffer: r, startOffset: i, endOffset: a } = zr(t), s = new DataView(r), o = tr(r, s, i, n, a, e);
+  if (o.offset !== a)
+    throw new A(
+      "E_GROUP_RANGE",
+      `Insert runtime geometry chunk has trailing bytes: offset=${o.offset - i}, length=${t.byteLength}`
+    );
+  return o.chunk;
+}
+function Or(t) {
+  const n = (e) => {
+    const r = t[e], i = Fr(
+      r.raw,
+      r.count,
+      r.groupLayerEncoding
+    ), a = de(i, { splitLineweight: e === "line" }), s = /* @__PURE__ */ new Map();
+    for (const o of a)
+      s.set(Gr(o.layerIndex, o.lineweightPx), {
+        layerIndex: o.layerIndex,
+        ...o.lineweightPx === void 0 ? {} : { lineweightPx: o.lineweightPx },
+        pos: o.pos,
+        col: o.col,
+        count: o.count,
+        bbox: _e(o.bbox)
+      });
+    return s;
+  };
+  return {
+    line: n("line"),
+    fill: n("fill"),
+    dot: n("dot")
+  };
+}
+function Gr(t, n) {
+  return n === void 0 ? `${t}:` : `${t}:${n}`;
+}
+function _r(t, n) {
+  let e = n ? _e(n) : null;
+  for (const r of ["line", "fill", "dot"])
+    for (const i of t[r].values())
+      e = Le(e, i.bbox);
+  return e;
+}
+function zr(t) {
+  if (t.buffer instanceof ArrayBuffer)
+    return {
+      buffer: t.buffer,
+      startOffset: t.byteOffset,
+      endOffset: t.byteOffset + t.byteLength
+    };
+  const n = Uint8Array.from(t);
+  return {
+    buffer: n.buffer,
+    startOffset: n.byteOffset,
+    endOffset: n.byteOffset + n.byteLength
+  };
+}
+function Ur(t) {
+  const n = t.insertRuntime;
+  if (!n || n.instances.length === 0) return null;
+  const e = [], r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set();
+  for (const c of n.variants) {
+    const l = Or(c), u = Qe(l.line), d = Qe(l.fill), h = Qe(l.dot), f = u.length > 0 || d.length > 0 || h.length > 0;
+    r.set(c.id, f ? _r(l, null) : null), f && (i.add(c.id), e.push({
+      variantId: c.id,
+      line: u,
+      fill: d,
+      dot: h
+    }));
+  }
+  const a = n.instances.filter((c) => i.has(c.variantId));
+  if (a.length === 0) return null;
+  const s = Hr(a, r), o = Yr(e, s);
+  return {
+    variants: e,
+    instances: s,
+    bytes: o,
+    cost: s.count
+  };
+}
+function Qe(t) {
+  const n = [];
+  for (const e of t.values())
+    e.count <= 0 || n.push(Nr(e));
+  return n;
+}
+function Nr(t) {
+  return {
+    pos: t.pos,
+    col: t.col,
+    count: t.count,
+    layerIndex: t.layerIndex,
+    ...t.lineweightPx === void 0 ? {} : { lineweightPx: t.lineweightPx },
+    bbox: t.bbox
+  };
+}
+function Hr(t, n) {
+  const e = t.length, r = new Uint32Array(e * 3), i = new Float32Array(e * 6), a = new Float32Array(e * 4);
+  for (let s = 0; s < e; s += 1) {
+    const o = t[s], c = s * 3;
+    r[c] = o.instanceId, r[c + 1] = o.variantId, r[c + 2] = o.insLayerIdx;
+    const l = s * 6;
+    i[l] = o.matA, i[l + 1] = o.matB, i[l + 2] = o.matC, i[l + 3] = o.matD, i[l + 4] = o.tx, i[l + 5] = o.ty;
+    const u = nr(n.get(o.variantId) ?? null, o);
+    Kr(a, s * 4, u);
+  }
+  return { meta: r, mats: i, bboxes: a, count: e };
+}
+function Kr(t, n, e) {
+  if (!e) {
+    t[n] = Number.POSITIVE_INFINITY, t[n + 1] = Number.POSITIVE_INFINITY, t[n + 2] = Number.NEGATIVE_INFINITY, t[n + 3] = Number.NEGATIVE_INFINITY;
+    return;
+  }
+  t[n] = e.minX, t[n + 1] = e.minY, t[n + 2] = e.maxX, t[n + 3] = e.maxY;
+}
+function Yr(t, n) {
+  let e = n.meta.byteLength + n.mats.byteLength + n.bboxes.byteLength;
+  for (const r of t)
+    e += qe(r.line), e += qe(r.fill), e += qe(r.dot);
+  return e;
+}
+function qe(t) {
+  return t.reduce((n, e) => n + e.pos.byteLength + e.col.byteLength, 0);
+}
+const Kt = 262144, Xr = Number.MAX_SAFE_INTEGER, Yt = 524288, Qr = Number.MAX_SAFE_INTEGER, qr = 5e6, Wr = 64;
+function $r(t) {
+  return t.lineCount + t.fillCount + t.dotCount;
+}
+function jr(t, n) {
+  return $r(t) >= qr ? {
+    initial: Yt,
+    steady: n ? Yt : Qr
+  } : {
+    initial: Kt,
+    steady: n ? Kt : Xr
+  };
+}
+function Zr(t) {
+  const n = !!(t.hiddenInstanceIds && t.hiddenInstanceIds.size > 0), e = t.keepTextsForHiddenInstances === !0, r = t.loadBlocks !== !1, i = t.suppressExpandedInsertGeometry === !0, a = t.maxExpandedInstanceVertices, s = typeof a == "number" && Number.isFinite(a) && a >= 0, o = !!(t.externalVariantBuffers && t.externalVariantBuffers.size > 0), c = t.requiredExternalVariantIds !== void 0, l = t.externalVariantDeltaOnly === !0;
+  if (!n && !e && r && !i && !s && !o && !c && !l)
+    return;
+  const u = {};
+  return n && (u.hiddenInstanceIds = t.hiddenInstanceIds), e && (u.keepTextsForHiddenInstances = !0), r || (u.loadBlocks = !1), i && (u.suppressExpandedInsertGeometry = !0), s && (u.maxExpandedInstanceVertices = a), o && (u.externalVariantBuffers = t.externalVariantBuffers), c && (u.requiredExternalVariantIds = t.requiredExternalVariantIds), l && (u.externalVariantDeltaOnly = !0), u;
+}
+async function Jr(t) {
+  if (!t.externalVariantFetchSource || !t.externalVariantGeometryFetchIds || t.externalVariantGeometryFetchIds.size === 0)
+    return t;
+  const n = Array.from(t.externalVariantGeometryFetchIds).filter((i) => {
+    var a;
+    return !((a = t.externalVariantBuffers) != null && a.has(i));
+  }).sort((i, a) => i - a);
+  if (n.length === 0)
+    return t;
+  const e = await Rn({
+    baseUrl: t.externalVariantFetchSource.baseUrl,
+    entries: t.externalVariantFetchSource.entries,
+    requiredVariantIds: n
+  }), r = new Map(t.externalVariantBuffers ?? []);
+  for (const [i, a] of e.buffers)
+    r.set(i, a);
+  return {
+    ...t,
+    externalVariantBuffers: r
+  };
+}
+function ei(t) {
+  return t.reduce((n, e) => n + e.t.length * 2 + 128, 0);
+}
+async function We(t, n, e, r) {
+  if (r()) return 0;
+  const i = Tr(n);
+  if (!i.length || r()) return 0;
+  const a = i.reduce((s, o) => s + o.count, 0);
+  return await e({
+    type: "geometry",
+    kind: t,
+    layers: i,
+    cost: a,
+    bytes: Bn(i)
+  }), a;
+}
+async function ti(t, n, e) {
+  return await We("line", t.line, n, e) + await We("fill", t.fill, n, e) + await We("dot", t.dot, n, e);
+}
+async function Xt(t, n, e) {
+  if (!t.length || e()) return 0;
+  const r = t.slice();
+  return t.length = 0, await n({
+    type: "text",
+    texts: r,
+    cost: r.length,
+    bytes: ei(r)
+  }), r.length;
+}
+function St() {
+  return {
+    start(t, n) {
+      let e = !1;
+      const r = () => e;
+      return {
+        completion: Promise.resolve().then(async () => {
+          if (await Promise.resolve(), r()) return;
+          const a = Vr(), s = [];
+          let o = 0, c = !1;
+          if (r()) return;
+          const l = await Jr(t);
+          if (r()) return;
+          const u = mt(l.buffer, Zr(l)), d = jr(
+            u.header,
+            t.externalVariantDeltaOnly === !0
+          );
+          if (r()) return;
+          await n({ type: "header", header: u.header });
+          const h = async () => {
+            const g = await ti(a, n, r);
+            return o = 0, g > 0 && (c = !0), g;
+          };
+          try {
+            for (const g of u.chunks) {
+              if (r()) return;
+              if (g.kind === "text") {
+                if (o > 0 && await h(), r()) return;
+                s.push(g.payload), s.length >= Wr && await Xt(s, n, r);
+                continue;
+              }
+              const C = de(g.payload, {
+                markLinePositionXy: g.kind === "line"
+              });
+              o += Ar(a[g.kind], C);
+              const v = c ? d.steady : d.initial;
+              o >= v && await h();
+            }
+          } catch (g) {
+            throw await h(), g;
+          }
+          await h(), await Xt(s, n, r), r() || await n({ type: "done" });
+          const f = ot(), b = Ur(u.header);
+          b && !r() && await n({
+            type: "insertModel",
+            variants: b.variants,
+            instances: b.instances,
+            bytes: b.bytes,
+            planMs: ot() - f
+          });
+        }),
+        cancel() {
+          e = !0;
+        },
+        dispose() {
+        }
+      };
+    }
+  };
+}
+function ni(t) {
+  return t.reduce((n, e) => n + e.t.length * 2 + 128, 0);
+}
+function ri(t) {
+  const n = {
+    type: "parse",
+    buffer: t.buffer
+  };
+  return t.hiddenInstanceIds && t.hiddenInstanceIds.size > 0 && (n.hiddenInstanceIds = Array.from(t.hiddenInstanceIds)), t.keepTextsForHiddenInstances === !0 && (n.keepTextsForHiddenInstances = !0), t.loadBlocks === !1 && (n.loadBlocks = !1), t.suppressExpandedInsertGeometry === !0 && (n.suppressExpandedInsertGeometry = !0), typeof t.maxExpandedInstanceVertices == "number" && Number.isFinite(t.maxExpandedInstanceVertices) && t.maxExpandedInstanceVertices >= 0 && (n.maxExpandedInstanceVertices = t.maxExpandedInstanceVertices), t.externalVariantFetchSource && (n.externalVariantFetchSource = t.externalVariantFetchSource), t.externalVariantBuffers && t.externalVariantBuffers.size > 0 && (n.externalVariantBuffers = Array.from(t.externalVariantBuffers, ([e, r]) => ({
+    variantId: e,
+    buffer: r
+  }))), t.requiredExternalVariantIds !== void 0 && (n.requiredExternalVariantIds = Array.from(t.requiredExternalVariantIds)), t.externalVariantGeometryFetchIds !== void 0 && (n.externalVariantGeometryFetchIds = Array.from(t.externalVariantGeometryFetchIds)), t.externalVariantDeltaOnly === !0 && (n.externalVariantDeltaOnly = !0), n;
+}
+function ii(t) {
+  const n = [t.buffer];
+  if (t.externalVariantBuffers && t.externalVariantBuffers.size > 0)
+    for (const e of t.externalVariantBuffers.values())
+      n.push(e);
+  return n;
+}
+function ai(t) {
+  const n = new Error(t.message);
+  return typeof t.code == "string" && (n.code = t.code), n;
+}
+function si(t) {
+  return t instanceof Error ? t : new Error(String(t));
+}
+function Et(t) {
+  return typeof t == "function" || typeof Worker == "function" && typeof globalThis.document < "u";
+}
+function Vt(t = {}) {
+  return {
+    start(n, e) {
+      var v;
+      const r = ((v = t.workerFactory) == null ? void 0 : v.call(t)) ?? (t.workerUrl ? new Worker(t.workerUrl, { type: "module" }) : new Worker(new URL(
+        /* @vite-ignore */
+        "" + new URL("workers/geo-prepare.worker.js", import.meta.url).href,
+        import.meta.url
+      ), { type: "module" }));
+      let i = !1, a = !1, s = Promise.resolve(), o, c, l, u;
+      const d = new Promise((x, I) => {
+        o = x, c = I;
+      }), h = new Promise((x, I) => {
+        l = x, u = I;
+      });
+      h.catch(() => {
+      });
+      const f = () => {
+        i || (i = !0, o());
+      }, b = () => {
+        a || (a = !0, l());
+      }, g = (x) => {
+        const I = si(x);
+        i || (i = !0, c(I)), a || (a = !0, u(I));
+      }, C = async (x) => {
+        if (!a) {
+          if (x.type === "error")
+            throw ai(x);
+          if (x.type === "complete") {
+            f(), b();
+            return;
+          }
+          if (x.type === "header") {
+            await e({ type: "header", header: x.header });
+            return;
+          }
+          if (x.type === "geometry") {
+            await e({
+              type: "geometry",
+              kind: x.kind,
+              layers: x.layers,
+              cost: x.cost,
+              bytes: Bn(x.layers)
+            });
+            return;
+          }
+          if (x.type === "insertModel") {
+            await e({
+              type: "insertModel",
+              variants: x.variants,
+              instances: x.instances,
+              bytes: x.bytes,
+              planMs: x.planMs
+            });
+            return;
+          }
+          if (x.type === "text") {
+            await e({
+              type: "text",
+              texts: x.texts,
+              cost: x.cost,
+              bytes: ni(x.texts)
+            });
+            return;
+          }
+          await e({ type: "done" }), f();
+        }
+      };
+      return r.addEventListener("message", (x) => {
+        s = s.then(() => C(x.data)), s.catch((I) => {
+          g(I);
+        });
+      }), r.addEventListener("error", (x) => {
+        g(new Error(x.message || "Geo prepare worker failed"));
+      }), r.addEventListener("messageerror", () => {
+        g(new Error("Geo prepare worker message decode failed"));
+      }), r.postMessage(ri(n), ii(n)), {
+        completion: d,
+        backgroundCompletion: h,
+        grant(x) {
+          a || r.postMessage({ type: "grant", ...x });
+        },
+        cancel() {
+          a || (b(), r.postMessage({ type: "cancel" }));
+        },
+        dispose() {
+          b(), r.terminate();
+        }
+      };
+    }
+  };
+}
+async function oi(t) {
+  if (!t.ok)
+    throw new A("E_PACK_HTTP", t.statusText || `Pack request failed with HTTP ${t.status}`);
+  return t.arrayBuffer();
+}
+async function Vn(t) {
+  var n;
+  switch (t.kind) {
+    case "buffer":
+      return t.buffer;
+    case "packFile":
+      return t.file.arrayBuffer();
+    case "url":
+      try {
+        return await oi(await fetch(t.url, { signal: t.signal }));
+      } catch (e) {
+        throw e instanceof A || e instanceof Error && e.name === "AbortError" ? e : (n = t.signal) != null && n.aborted ? te(t.signal.reason, "CAD pack request aborted") : new A("E_PACK_NETWORK", `Pack request failed: ${e.message}`);
+      }
+    default: {
+      const e = t;
+      throw new A("E_SOURCE", `Unsupported geo source: ${String(e)}`);
+    }
+  }
+}
+var he, re, fe, ie;
+class li {
+  constructor(n) {
+    B(this, he, []);
+    B(this, re, []);
+    B(this, fe);
+    B(this, ie, !1);
+    k(this, fe, n);
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  next() {
+    const n = p(this, he).shift();
+    return n ? (p(this, fe).call(this, n), Promise.resolve({ done: !1, value: n.event })) : p(this, ie) ? Promise.resolve({ done: !0, value: void 0 }) : new Promise((e) => {
+      p(this, re).push({ resolve: e });
+    });
+  }
+  push(n) {
+    if (p(this, ie)) return;
+    const e = p(this, re).shift();
+    if (e) {
+      p(this, fe).call(this, n), e.resolve({ done: !1, value: n.event });
+      return;
+    }
+    p(this, he).push(n);
+  }
+  close() {
+    if (!p(this, ie))
+      for (k(this, ie, !0); p(this, re).length > 0; )
+        p(this, re).shift().resolve({ done: !0, value: void 0 });
+  }
+  clear() {
+    p(this, he).length = 0, this.close();
+  }
+}
+he = new WeakMap(), re = new WeakMap(), fe = new WeakMap(), ie = new WeakMap();
+function Qt() {
+  let t, n;
+  return { promise: new Promise((r, i) => {
+    t = r, n = i;
+  }), resolve: t, reject: n };
+}
+function ci(t) {
+  return t instanceof Error ? t : new Error(String(t));
+}
+function $e(t) {
+  return t === void 0 ? void 0 : new Set(t);
+}
+function ui(t) {
+  return {
+    highWatermarkBytes: (t == null ? void 0 : t.highWatermarkBytes) ?? It,
+    lowWatermarkBytes: (t == null ? void 0 : t.lowWatermarkBytes) ?? wt,
+    initialGeometryCredits: (t == null ? void 0 : t.initialGeometryCredits) ?? vt,
+    initialTextCredits: (t == null ? void 0 : t.initialTextCredits) ?? Rt
+  };
+}
+function di(t) {
+  if (t.positionItemSize === 2) return t.pos;
+  const n = new Float32Array(t.count * 2);
+  for (let e = 0; e < t.count; e += 1)
+    n[e * 2] = t.pos[e * 3] ?? 0, n[e * 2 + 1] = t.pos[e * 3 + 1] ?? 0;
+  return n;
+}
+function hi(t) {
+  return (t.colorRuns ?? fi(t)).map((e) => ({
+    startVertex: e.startVertex,
+    vertexCount: e.vertexCount,
+    color: [e.color[0], e.color[1], e.color[2]],
+    layerIndex: t.layerIndex,
+    ...t.lineweightPx === void 0 ? {} : { lineweightPx: t.lineweightPx }
+  }));
+}
+function fi(t) {
+  return t.count <= 0 ? [] : [{
+    startVertex: 0,
+    vertexCount: t.count,
+    color: [t.col[0] ?? 0, t.col[1] ?? 0, t.col[2] ?? 0]
+  }];
+}
+function yi(t) {
+  const n = t.layerIndex <= 255 ? new Uint8Array(t.count).fill(t.layerIndex) : new Uint16Array(t.count).fill(t.layerIndex);
+  return {
+    pos: di(t),
+    col: t.col,
+    lay: n,
+    count: t.count,
+    segments: hi(t)
+  };
+}
+function mi(t) {
+  const n = [];
+  for (let e = 0; e < t.count; e += 1) {
+    const r = e * 3, i = e * 6;
+    n.push({
+      instanceId: t.meta[r] ?? 0,
+      variantId: t.meta[r + 1] ?? 0,
+      insLayerIdx: t.meta[r + 2] ?? 0,
+      matA: t.mats[i] ?? 0,
+      matB: t.mats[i + 1] ?? 0,
+      matC: t.mats[i + 2] ?? 0,
+      matD: t.mats[i + 3] ?? 0,
+      tx: t.mats[i + 4] ?? 0,
+      ty: t.mats[i + 5] ?? 0
+    });
+  }
+  return n;
+}
+function je(t) {
+  return {
+    pos: t.pos,
+    col: t.col,
+    count: t.count,
+    ...t.layerIndex === void 0 ? {} : { layerIndex: t.layerIndex },
+    ...t.lineweightPx === void 0 ? {} : { lineweightPx: t.lineweightPx },
+    ...t.bbox === void 0 ? {} : { bounds: t.bbox }
+  };
+}
+function xi(t) {
+  return {
+    variantId: t.variantId,
+    line: t.line.map(je),
+    fill: t.fill.map(je),
+    dot: t.dot.map(je)
+  };
+}
+var E, we, ve, Re, ye, J, L, me, ee, xe, Be, z, pe, Se, Ee, T, Ve, ke, w, kn, An, Tn, ue, ct, Pn, Ce, ut, De, Fe, Oe;
+class pi {
+  constructor(n, e) {
+    B(this, w);
+    m(this, "events");
+    m(this, "ready");
+    B(this, E);
+    B(this, we);
+    B(this, ve);
+    B(this, Re, new AbortController());
+    B(this, ye, Qt());
+    B(this, J, Qt());
+    B(this, L);
+    B(this, me, []);
+    B(this, ee);
+    B(this, xe, /* @__PURE__ */ new Set());
+    B(this, Be, []);
+    B(this, z, null);
+    B(this, pe, null);
+    B(this, Se, 0);
+    B(this, Ee, !1);
+    B(this, T, !1);
+    B(this, Ve, !1);
+    B(this, ke, ot());
+    k(this, E, e);
+    const r = Bt(n, p(this, Re).signal);
+    k(this, we, r.source), k(this, ve, r.sourceSignal), k(this, ee, new vn(ui(e.flowControl))), k(this, L, new li((i) => R(this, w, Pn).call(this, i))), this.events = p(this, L), this.ready = p(this, ye).promise, this.ready.catch(() => {
+    }), p(this, J).promise.catch(() => {
+    }), R(this, w, ut).call(this, e.signal), R(this, w, ut).call(this, p(this, ve)), p(this, T) || R(this, w, kn).call(this);
+  }
+  abort(n) {
+    p(this, T) || R(this, w, De).call(this, te(n, "CAD load session aborted"));
+  }
+  dispose() {
+    var n;
+    if (!p(this, Ve)) {
+      if (k(this, Ve, !0), !p(this, T)) {
+        R(this, w, De).call(this, te("CAD load session disposed"));
+        return;
+      }
+      (n = p(this, z)) == null || n.dispose(), p(this, L).clear(), R(this, w, Oe).call(this);
+    }
+  }
+}
+E = new WeakMap(), we = new WeakMap(), ve = new WeakMap(), Re = new WeakMap(), ye = new WeakMap(), J = new WeakMap(), L = new WeakMap(), me = new WeakMap(), ee = new WeakMap(), xe = new WeakMap(), Be = new WeakMap(), z = new WeakMap(), pe = new WeakMap(), Se = new WeakMap(), Ee = new WeakMap(), T = new WeakMap(), Ve = new WeakMap(), ke = new WeakMap(), w = new WeakSet(), kn = async function() {
+  var n, e;
+  try {
+    const r = await Promise.race([
+      Vn(p(this, we)),
+      p(this, J).promise
+    ]);
+    if (p(this, T)) return;
+    k(this, Se, r.byteLength);
+    const a = R(this, w, An).call(this).start({
+      buffer: r,
+      hiddenInstanceIds: $e(p(this, E).hiddenInstanceIds),
+      keepTextsForHiddenInstances: p(this, E).keepTextsForHiddenInstances || void 0,
+      loadBlocks: p(this, E).loadBlocks,
+      suppressExpandedInsertGeometry: p(this, E).loadBlocks !== !1,
+      maxExpandedInstanceVertices: p(this, E).maxExpandedInstanceVertices,
+      externalVariantFetchSource: p(this, E).externalVariantFetchSource,
+      externalVariantBuffers: p(this, E).externalVariantBuffers,
+      requiredExternalVariantIds: $e(p(this, E).requiredExternalVariantIds),
+      externalVariantGeometryFetchIds: $e(p(this, E).externalVariantGeometryFetchIds)
+    }, (o) => R(this, w, Tn).call(this, o));
+    if (k(this, z, a), a.completion.catch(() => {
+    }), (n = a.backgroundCompletion) == null || n.catch(() => {
+    }), R(this, w, Ce).call(this, p(this, ee).takeInitialGrant()), await Promise.race([a.completion, p(this, J).promise]), a.backgroundCompletion && await Promise.race([a.backgroundCompletion, p(this, J).promise]), p(this, T)) return;
+    if (!p(this, Ee))
+      throw new Error("CAD loader adapter completed without a done event");
+    if (!p(this, pe))
+      throw new Error("CAD loader adapter completed without metadata");
+    const s = {
+      header: p(this, pe),
+      chunks: p(this, me),
+      rawBytes: p(this, Se)
+    };
+    k(this, T, !0), p(this, L).push({ event: { type: "ready", document: s } }), p(this, L).close(), p(this, ye).resolve(s), R(this, w, Oe).call(this);
+  } catch (r) {
+    p(this, T) || R(this, w, De).call(this, ci(r));
+  } finally {
+    (e = p(this, z)) == null || e.dispose(), R(this, w, Fe).call(this);
+  }
+}, An = function() {
+  return p(this, E).preferWorker !== !1 && Et(p(this, E).workerFactory) ? Vt({
+    workerUrl: p(this, E).workerUrl,
+    workerFactory: p(this, E).workerFactory
+  }) : St();
+}, Tn = async function(n) {
+  if (!p(this, T)) {
+    if (n.type === "header") {
+      k(this, pe, n.header), p(this, L).push({
+        event: { type: "meta", meta: n.header, header: n.header }
+      }), await R(this, w, ue).call(this);
+      return;
+    }
+    if (n.type === "geometry") {
+      const e = n.layers.map((r) => {
+        const i = yi(r);
+        return p(this, me).push({ kind: n.kind, payload: i }), {
+          event: {
+            type: "geometry",
+            kind: n.kind,
+            chunk: i,
+            layerIndex: r.layerIndex,
+            ...r.lineweightPx === void 0 ? {} : { lineweightPx: r.lineweightPx },
+            bounds: r.bbox
+          }
+        };
+      });
+      await R(this, w, ct).call(this, e, "geometry", n.bytes), await R(this, w, ue).call(this);
+      return;
+    }
+    if (n.type === "text") {
+      const e = n.texts.map((r) => (p(this, me).push({ kind: "text", payload: r }), { event: { type: "text", chunk: r } }));
+      await R(this, w, ct).call(this, e, "text", n.bytes), await R(this, w, ue).call(this);
+      return;
+    }
+    if (n.type === "insertModel") {
+      p(this, L).push({
+        event: {
+          type: "insert",
+          instances: mi(n.instances),
+          variants: n.variants.map(xi)
+        }
+      }), await R(this, w, ue).call(this);
+      return;
+    }
+    k(this, Ee, !0), await R(this, w, ue).call(this);
+  }
+}, ue = async function() {
+  const n = Math.max(0, (p(this, E).frameBudgetMs ?? bt) - (p(this, E).frameReserveMs ?? Ct));
+  typeof performance > "u" || typeof performance.now != "function" || performance.now() - p(this, ke) < n || (await new Promise((e) => {
+    typeof globalThis.requestAnimationFrame == "function" ? globalThis.requestAnimationFrame(() => e()) : setTimeout(e, 0);
+  }), k(this, ke, performance.now()));
+}, ct = function(n, e, r) {
+  if (n.length === 0) {
+    R(this, w, Ce).call(this, e === "geometry" ? { geometryCredits: 1, textCredits: 0 } : { geometryCredits: 0, textCredits: 1 });
+    return;
+  }
+  const i = { kind: e, bytes: Math.max(0, r), creditReplaced: !1 };
+  p(this, ee).onQueued(e, i.bytes);
+  const a = p(this, ee).onConsumed(e, 0);
+  if (i.creditReplaced = R(this, w, Ce).call(this, a), n.forEach((s, o) => {
+    p(this, L).push({
+      ...s,
+      batch: i,
+      accountsBatch: o === n.length - 1
+    });
+  }), !!a.paused)
+    return new Promise((s) => {
+      p(this, xe).add(s);
+    });
+}, Pn = function(n) {
+  if (!n.batch || !n.accountsBatch) return;
+  const e = p(this, ee).onConsumed(n.batch.kind, n.batch.bytes);
+  n.batch.creditReplaced || (n.batch.creditReplaced = R(this, w, Ce).call(this, e)), e.paused || R(this, w, Fe).call(this);
+}, Ce = function(n) {
+  var e;
+  return !((e = p(this, z)) != null && e.grant) || p(this, T) || n.geometryCredits <= 0 && n.textCredits <= 0 ? !1 : (p(this, z).grant({
+    geometryCredits: n.geometryCredits,
+    textCredits: n.textCredits
+  }), !0);
+}, ut = function(n) {
+  if (!n) return;
+  if (n.aborted) {
+    this.abort(n.reason);
+    return;
+  }
+  const e = () => this.abort(n.reason);
+  n.addEventListener("abort", e, { once: !0 }), p(this, Be).push(() => n.removeEventListener("abort", e));
+}, De = function(n) {
+  var e, r, i;
+  p(this, T) || (k(this, T, !0), p(this, Re).abort(n), (r = (e = p(this, z)) == null ? void 0 : e.cancel) == null || r.call(e), (i = p(this, z)) == null || i.dispose(), p(this, J).reject(n), p(this, ye).reject(n), p(this, L).push({ event: { type: "error", error: n } }), p(this, L).close(), R(this, w, Fe).call(this), R(this, w, Oe).call(this));
+}, Fe = function() {
+  for (const n of p(this, xe)) n();
+  p(this, xe).clear();
+}, Oe = function() {
+  for (const n of p(this, Be).splice(0)) n();
+};
+function fs(t, n = {}) {
+  return new pi(t, n);
+}
+class gi {
+  constructor(n) {
+    m(this, "queue", []);
+    m(this, "budgetMs");
+    m(this, "now");
+    this.budgetMs = Math.max(0, n.frameBudgetMs - n.reserveMs), this.now = n.now ?? (() => performance.now());
+  }
+  enqueue(n) {
+    this.queue.push(n);
+  }
+  hasPending() {
+    return this.queue.length > 0;
+  }
+  size() {
+    return this.queue.length;
+  }
+  async runFrame() {
+    const n = this.now();
+    let e = 0;
+    for (; this.queue.length > 0; ) {
+      const r = this.queue.shift();
+      if (!r)
+        break;
+      if (await r(), e += 1, this.queue.length > 0 && this.now() - n >= this.budgetMs)
+        return {
+          executed: e,
+          remaining: this.queue.length,
+          exhausted: !0
+        };
+    }
+    return {
+      executed: e,
+      remaining: this.queue.length,
+      exhausted: !1
+    };
+  }
+}
+function bi(t) {
+  return t.lineCount + t.fillCount + t.dotCount;
+}
+function Ci(t) {
+  return t instanceof Error ? t : new Error(String(t));
+}
+class Ii {
+  constructor(n) {
+    m(this, "headerSeen", !1);
+    m(this, "headerTexts", []);
+    this.node = n;
+  }
+  initFromHeader(n) {
+    this.node._initFromHeader(n), this.node.updateAutoQualityContext({
+      visibleVertexCount: bi(n),
+      zoom: 1
+    }), this.headerSeen = !0, this.headerTexts = n.texts;
+  }
+  appendGeometry(n, e) {
+    this.node._appendPreparedGeometryChunk(n, e);
+  }
+  appendText(n) {
+    this.node._appendTextChunks(n);
+  }
+  installInsertModel(n) {
+    this.node._installInsertModel(n);
+  }
+  appendInsertModel(n) {
+    this.node._appendInsertModel(n);
+  }
+  async finalize(n) {
+    try {
+      if (!this.headerSeen)
+        throw new Error("Geo loader pipeline completed without header");
+      rr() && ir("Boundary-3:header->node", this.headerTexts, this.node._collectTextUserDataForDebug()), await this.node._finalizeIncrementally(n);
+    } catch (e) {
+      const r = Ci(e);
+      throw this.fail(r), r;
+    }
+  }
+  fail(n) {
+    this.node._fail(n);
+  }
+}
+function qt(t) {
+  return t instanceof Error ? t : new Error(String(t));
+}
+function wi() {
+  return typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+}
+function vi(t) {
+  return {
+    frameBudgetMs: (t == null ? void 0 : t.frameBudgetMs) ?? bt,
+    reserveMs: (t == null ? void 0 : t.reserveMs) ?? Ct,
+    now: (t == null ? void 0 : t.now) ?? wi
+  };
+}
+function Ri(t) {
+  return {
+    highWatermarkBytes: (t == null ? void 0 : t.highWatermarkBytes) ?? It,
+    lowWatermarkBytes: (t == null ? void 0 : t.lowWatermarkBytes) ?? wt,
+    initialGeometryCredits: (t == null ? void 0 : t.initialGeometryCredits) ?? vt,
+    initialTextCredits: (t == null ? void 0 : t.initialTextCredits) ?? Rt
+  };
+}
+function Bi() {
+  return new Promise((t) => {
+    if (typeof globalThis.requestAnimationFrame == "function") {
+      globalThis.requestAnimationFrame(() => t());
+      return;
+    }
+    setTimeout(t, 0);
+  });
+}
+async function Ze(t) {
+  await Bi(), await (t == null ? void 0 : t());
+}
+async function Ln(t) {
+  var D, Tt;
+  const { node: n } = t, e = new Ii(n), r = t.appendExternalVariantDelta === !0, i = new gi(vi(t.scheduler));
+  let a = null, s = !0, o = null, c = !1, l = !1, u = !1, d = null, h = !1, f = null, b = null, g = null;
+  const C = [], v = /* @__PURE__ */ new Set(), x = /* @__PURE__ */ new Set(), I = new Promise((y, S) => {
+    f = S;
+  });
+  I.catch(() => {
+  });
+  const V = (y) => {
+    var oe;
+    const S = qt(y);
+    if (!u) {
+      u = !0, (oe = a == null ? void 0 : a.cancel) == null || oe.call(a);
+      for (const K of v)
+        G(K, S);
+      r || e.fail(S), n.ready.catch(() => {
+      }), f == null || f(S);
+    }
+    return S;
+  }, M = (y) => (x.add(y), y.then(
+    () => {
+      x.delete(y);
+    },
+    () => {
+      x.delete(y);
+    }
+  ), y.catch(() => {
+  }), y), Q = (y) => ({
+    geometryCredits: y.geometryCredits,
+    textCredits: y.textCredits
+  }), q = (y, S) => {
+    u || !(a != null && a.grant) || S && y.geometryCredits <= 0 && y.textCredits <= 0 || a.grant(Q(y));
+  }, W = (y) => {
+    !o || y.flowQueued || (o.onQueued(y.kind, y.bytes), y.flowQueued = !0);
+  }, N = () => {
+    for (const y of v)
+      W(y);
+  }, G = (y, S) => {
+    if (!y.settled) {
+      if (y.settled = !0, v.delete(y), S) {
+        y.reject(S);
+        return;
+      }
+      y.resolve();
+    }
+  }, $ = () => (h = !0, d || (d = Promise.resolve().then(async () => {
+    for (; !u; ) {
+      for (h = !1; !u && i.hasPending(); ) {
+        const y = await i.runFrame();
+        !u && y.exhausted && await Ze(t.onYield);
+      }
+      if (!h && !i.hasPending())
+        break;
+    }
+  }).catch((y) => {
+    throw V(y);
+  }).finally(() => {
+    d = null, !u && h && i.hasPending() && $();
+  }), d.catch(() => {
+  }), d)), H = (y, S, oe) => {
+    let K = null, Pt = null;
+    const le = new Promise((Ae, He) => {
+      K = Ae, Pt = He;
+    }), Y = {
+      kind: y,
+      bytes: S,
+      append: oe,
+      flowQueued: !1,
+      settled: !1,
+      resolve: K,
+      reject: Pt
+    };
+    return v.add(Y), x.add(le), le.then(
+      () => {
+        x.delete(le);
+      },
+      () => {
+        x.delete(le);
+      }
+    ), le.catch(() => {
+    }), W(Y), i.enqueue(() => {
+      if (u) {
+        G(Y, V(new Error("Geo loader pipeline failed before append task ran")));
+        return;
+      }
+      try {
+        Y.append(), o && Y.flowQueued && q(o.onConsumed(Y.kind, Y.bytes), !0), G(Y);
+      } catch (Ae) {
+        const He = qt(Ae);
+        throw G(Y, He), V(Ae);
+      }
+    }), $(), le;
+  }, ae = (y) => {
+    if (y.type === "geometry") {
+      e.appendGeometry(y.kind, y.layers);
+      return;
+    }
+    if (y.type === "text") {
+      e.appendText(y.texts);
+      return;
+    }
+    if (y.type === "insertModel") {
+      e.appendInsertModel({
+        variants: y.variants,
+        instances: y.instances,
+        planMs: y.planMs
+      });
+      return;
+    }
+  }, se = (y) => H(y.type === "text" ? "text" : "geometry", y.bytes, () => {
+    if (l) {
+      ae(y);
+      return;
+    }
+    C.push(y);
+  }), F = (y, S) => {
+    const oe = Promise.resolve().then(async () => {
+      var K;
+      await ((K = t.beforeTextAppend) == null ? void 0 : K.call(t, y)), await S();
+    }).catch((K) => {
+      throw V(K);
+    });
+    return M(oe);
+  }, _ = (y) => {
+    if (!u) {
+      if (y.type === "header") {
+        if (r) {
+          g = y.header;
+          return;
+        }
+        e.initFromHeader(y.header);
+        return;
+      }
+      if (y.type === "geometry")
+        return r ? se({
+          type: "geometry",
+          kind: y.kind,
+          layers: y.layers,
+          bytes: y.bytes
+        }) : H("geometry", y.bytes, () => {
+          e.appendGeometry(y.kind, y.layers);
+        });
+      if (y.type === "text")
+        return r ? F(y.texts, () => se({
+          type: "text",
+          texts: y.texts,
+          bytes: y.bytes
+        })) : F(y.texts, () => H("text", y.bytes, () => {
+          e.appendText(y.texts);
+        }));
+      if (y.type === "insertModel")
+        return r ? se({
+          type: "insertModel",
+          variants: y.variants,
+          instances: y.instances,
+          bytes: y.bytes,
+          planMs: y.planMs
+        }) : H("geometry", y.bytes, () => {
+          e.installInsertModel({
+            variants: y.variants,
+            instances: y.instances,
+            planMs: y.planMs
+          });
+        });
+      c = !0;
+    }
+  };
+  try {
+    if ((D = t.signal) != null && D.aborted)
+      throw te(t.signal.reason);
+    if (a = t.adapter.start(
+      {
+        buffer: t.buffer,
+        hiddenInstanceIds: t.hiddenInstanceIds,
+        keepTextsForHiddenInstances: t.keepTextsForHiddenInstances,
+        loadBlocks: t.loadBlocks,
+        suppressExpandedInsertGeometry: t.suppressExpandedInsertGeometry,
+        maxExpandedInstanceVertices: t.maxExpandedInstanceVertices,
+        externalVariantFetchSource: t.externalVariantFetchSource,
+        externalVariantBuffers: t.externalVariantBuffers,
+        requiredExternalVariantIds: t.requiredExternalVariantIds,
+        externalVariantGeometryFetchIds: t.externalVariantGeometryFetchIds,
+        externalVariantDeltaOnly: t.externalVariantDeltaOnly
+      },
+      _
+    ), a.completion.catch(() => {
+    }), t.signal) {
+      const y = t.signal, S = () => {
+        V(te(y.reason));
+      };
+      y.addEventListener("abort", S, { once: !0 }), b = () => y.removeEventListener("abort", S), y.aborted && S();
+    }
+    if (a.grant && (o = new vn(Ri(t.flowControl)), N(), q(o.takeInitialGrant(), !1)), await Promise.race([a.completion, I]), a.backgroundCompletion && await Promise.race([a.backgroundCompletion, I]), await $(), await Promise.all(Array.from(x)), !c)
+      throw new Error("Geo loader pipeline completed without done event");
+    if (await ((Tt = t.beforeFinalize) == null ? void 0 : Tt.call(t)), r) {
+      if (!g)
+        throw new Error("Geo loader pipeline completed without delta header");
+      n.appendExternalVariantDeltaHeader(g);
+      for (const y of C)
+        H(y.type === "text" ? "text" : "geometry", y.bytes, () => {
+          ae(y);
+        });
+      await $(), await Promise.all(Array.from(x)), await n._finalizeIncrementally(() => Ze(t.onYield));
+    } else
+      await e.finalize(() => Ze(t.onYield));
+    if (l = !0, a.backgroundCompletion) {
+      const y = a;
+      s = !1, a.backgroundCompletion.then(async () => {
+        await $(), await Promise.all(Array.from(x));
+      }).catch(() => {
+      }).finally(() => {
+        y.dispose();
+      });
+    }
+  } catch (y) {
+    throw V(y);
+  } finally {
+    b == null || b(), s && (a == null || a.dispose());
+  }
+}
+function Mn(t) {
+  return t instanceof Error ? t : new Error(String(t));
+}
+function Si(t) {
+  if (!t || t.size === 0)
+    return t;
+  const n = /* @__PURE__ */ new Map();
+  for (const [e, r] of t)
+    n.set(e, r.slice(0));
+  return n;
+}
+function Ei() {
+  return typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+}
+function Dn(t = {}) {
+  var s, o, c, l, u, d, h;
+  const n = t.hiddenInstanceIds ? new Set(t.hiddenInstanceIds) : /* @__PURE__ */ new Set(), e = t.requiredExternalVariantIds !== void 0, r = e ? new Set(t.requiredExternalVariantIds) : /* @__PURE__ */ new Set(), i = t.externalVariantGeometryFetchIds !== void 0, a = i ? new Set(t.externalVariantGeometryFetchIds) : /* @__PURE__ */ new Set();
+  return {
+    scheduler: {
+      frameBudgetMs: ((s = t.scheduler) == null ? void 0 : s.frameBudgetMs) ?? bt,
+      reserveMs: ((o = t.scheduler) == null ? void 0 : o.reserveMs) ?? Ct,
+      now: ((c = t.scheduler) == null ? void 0 : c.now) ?? Ei
+    },
+    flowControl: {
+      highWatermarkBytes: ((l = t.flowControl) == null ? void 0 : l.highWatermarkBytes) ?? It,
+      lowWatermarkBytes: ((u = t.flowControl) == null ? void 0 : u.lowWatermarkBytes) ?? wt,
+      initialGeometryCredits: ((d = t.flowControl) == null ? void 0 : d.initialGeometryCredits) ?? vt,
+      initialTextCredits: ((h = t.flowControl) == null ? void 0 : h.initialTextCredits) ?? Rt
+    },
+    beforeTextAppend: t.beforeTextAppend,
+    beforeFinalize: t.beforeFinalize,
+    signal: t.signal,
+    hiddenInstanceIds: n.size > 0 ? n : void 0,
+    preferWorker: t.preferWorker !== !1,
+    workerUrl: t.workerUrl,
+    workerFactory: t.workerFactory,
+    keepTextsForHiddenInstances: t.keepTextsForHiddenInstances === !0,
+    loadBlocks: t.loadBlocks !== !1,
+    suppressExpandedInsertGeometry: t.loadBlocks !== !1,
+    maxExpandedInstanceVertices: typeof t.maxExpandedInstanceVertices == "number" && Number.isFinite(t.maxExpandedInstanceVertices) && t.maxExpandedInstanceVertices >= 0 ? t.maxExpandedInstanceVertices : void 0,
+    externalVariantFetchSource: t.externalVariantFetchSource,
+    externalVariantBuffers: t.externalVariantBuffers,
+    requiredExternalVariantIds: e ? r : void 0,
+    externalVariantGeometryFetchIds: i ? a : void 0,
+    externalVariantDeltaOnly: t.externalVariantDeltaOnly === !0
+  };
+}
+async function Vi(t, n, e, r = {}) {
+  const i = Dn(r), a = i.hiddenInstanceIds ?? /* @__PURE__ */ new Set(), s = i.preferWorker && Et(i.workerFactory) ? Vt({
+    workerUrl: i.workerUrl,
+    workerFactory: i.workerFactory
+  }) : St();
+  try {
+    await Ln({
+      node: t,
+      buffer: n,
+      adapter: s,
+      scheduler: i.scheduler,
+      flowControl: i.flowControl,
+      beforeTextAppend: i.beforeTextAppend,
+      beforeFinalize: i.beforeFinalize,
+      signal: i.signal,
+      onYield: e,
+      hiddenInstanceIds: a.size > 0 ? a : void 0,
+      keepTextsForHiddenInstances: i.keepTextsForHiddenInstances || void 0,
+      loadBlocks: i.loadBlocks,
+      suppressExpandedInsertGeometry: i.suppressExpandedInsertGeometry,
+      maxExpandedInstanceVertices: i.maxExpandedInstanceVertices,
+      externalVariantFetchSource: i.externalVariantFetchSource,
+      externalVariantBuffers: i.externalVariantBuffers,
+      requiredExternalVariantIds: i.requiredExternalVariantIds,
+      externalVariantGeometryFetchIds: i.externalVariantGeometryFetchIds,
+      externalVariantDeltaOnly: i.externalVariantDeltaOnly
+    });
+  } catch (o) {
+    const c = Mn(o);
+    throw t.ready.catch(() => {
+    }), c;
+  }
+}
+async function ki(t, n, e, r = {}) {
+  const i = Dn({
+    ...r,
+    externalVariantDeltaOnly: !0
+  }), a = i.hiddenInstanceIds ?? /* @__PURE__ */ new Set(), s = i.preferWorker && Et(i.workerFactory), o = s ? Vt({
+    workerUrl: i.workerUrl,
+    workerFactory: i.workerFactory
+  }) : St(), c = s ? n.slice(0) : n, l = s ? Si(i.externalVariantBuffers) : i.externalVariantBuffers;
+  try {
+    await Ln({
+      node: t,
+      buffer: c,
+      adapter: o,
+      scheduler: i.scheduler,
+      flowControl: i.flowControl,
+      beforeTextAppend: i.beforeTextAppend,
+      signal: i.signal,
+      onYield: e,
+      hiddenInstanceIds: a.size > 0 ? a : void 0,
+      keepTextsForHiddenInstances: i.keepTextsForHiddenInstances || void 0,
+      loadBlocks: i.loadBlocks,
+      suppressExpandedInsertGeometry: i.suppressExpandedInsertGeometry,
+      maxExpandedInstanceVertices: i.maxExpandedInstanceVertices,
+      externalVariantFetchSource: i.externalVariantFetchSource,
+      externalVariantBuffers: l,
+      requiredExternalVariantIds: i.requiredExternalVariantIds,
+      externalVariantGeometryFetchIds: i.externalVariantGeometryFetchIds,
+      externalVariantDeltaOnly: !0,
+      appendExternalVariantDelta: !0
+    });
+  } catch (u) {
+    throw Mn(u);
+  }
+}
+const Ai = "?", Ti = {
+  "℄": "CL",
+  "∅": "Ø",
+  "⌀": "Ø"
+};
+function Pi(t) {
+  return t >= 0 && t <= 8 || t >= 11 && t <= 31 || t >= 127 && t <= 159 || t >= 65024 && t <= 65039 || t >= 917760 && t <= 917999;
+}
+function Li(t) {
+  return t >= 13312 && t <= 19903 || t >= 131072 && t <= 173791 || t >= 173824 && t <= 177983 || t >= 177984 && t <= 178207 || t >= 178208 && t <= 183983 || t >= 183984 && t <= 191471 || t >= 191472 && t <= 192095 || t >= 196608 && t <= 201551 || t >= 201552 && t <= 205743 || t >= 194560 && t <= 195103;
+}
+function Mi(t) {
+  let n = !1, e = "";
+  for (const r of t) {
+    const i = r.codePointAt(0);
+    if (i === void 0) continue;
+    const a = Ti[r];
+    if (a !== void 0) {
+      e += a, n = !0;
+      continue;
+    }
+    if (Pi(i)) {
+      n = !0;
+      continue;
+    }
+    if (Li(i)) {
+      e += Ai, n = !0;
+      continue;
+    }
+    e += r;
+  }
+  return { text: e, replacedUnsupported: n };
+}
+function Di(t) {
+  return Mi(t);
+}
+function Wt(t) {
+  if (!Number.isFinite(t)) return 0;
+  const n = Math.round(t);
+  return n < 0 ? 0 : n > 255 ? 255 : n;
+}
+function Fn(t) {
+  return Number.isFinite(t) ? t >= 0 && t <= 1 ? Wt(t * 255) : Wt(t) : 0;
+}
+function On(t) {
+  if (t instanceof Uint8Array)
+    return t;
+  const n = new Uint8Array(t.length);
+  for (let e = 0; e < t.length; e += 1)
+    n[e] = Fn(t[e] ?? 0);
+  return n;
+}
+function Fi(t) {
+  const n = new Float32Array(t.length);
+  for (let e = 0; e < t.length; e += 1)
+    n[e] = (t[e] ?? 0) / 255;
+  return n;
+}
+function $t(t) {
+  return new U(t, 3, !0);
+}
+function Oi(t) {
+  const n = t.array;
+  if (n instanceof Uint8Array)
+    return n;
+  if (n instanceof Float32Array)
+    return On(n);
+  const e = new Uint8Array(n.length);
+  for (let r = 0; r < n.length; r += 1)
+    e[r] = Fn(Number(n[r] ?? 0));
+  return e;
+}
+function ze(t, n) {
+  if (!Number.isInteger(t) || t < 0)
+    return !1;
+  let e = 0;
+  for (const r of n)
+    if (!Number.isInteger(r.startVertex) || !Number.isInteger(r.vertexCount) || r.vertexCount <= 0 || r.startVertex !== e || (e += r.vertexCount, e > t))
+      return !1;
+  return e === t;
+}
+function Gi(t, n) {
+  if (!ze(t, n))
+    throw new Error("Source color runs must be positive, contiguous, and cover the vertex count exactly.");
+}
+function Gn(t, n, e) {
+  return (t & 255) << 16 | (n & 255) << 8 | e & 255;
+}
+function _i(t, n) {
+  const e = new Uint8Array(t.length), r = Math.floor(t.length / 3), i = /* @__PURE__ */ new Map();
+  let a = -1, s = [0, 0, 0], o = 0, c = 0, l = 0;
+  for (let u = 0; u < r; u += 1) {
+    const d = u * 3, h = t[d] ?? 0, f = t[d + 1] ?? 0, b = t[d + 2] ?? 0, g = Gn(h, f, b);
+    let C;
+    if (g === a)
+      C = s, l += 1;
+    else {
+      o += 1;
+      const v = i.get(g);
+      if (v)
+        C = v, c += 1;
+      else {
+        const x = n([h, f, b]);
+        C = [x[0], x[1], x[2]], i.set(g, C);
+      }
+      a = g, s = C;
+    }
+    e[d] = C[0], e[d + 1] = C[1], e[d + 2] = C[2];
+  }
+  return {
+    color: e,
+    stats: {
+      vertexCount: r,
+      runCount: o,
+      uniqueColorCount: i.size,
+      cacheHitCount: c,
+      repeatedRunVertexCount: l
+    }
+  };
+}
+function jt(t, n, e) {
+  const r = new Uint8Array(t * 3), i = dt(r, t, n, e);
+  return {
+    color: r,
+    stats: i
+  };
+}
+function zi(t, n, e) {
+  const r = new Float32Array(t * 3), i = Ui(r, t, n, e);
+  return {
+    color: r,
+    stats: i
+  };
+}
+function dt(t, n, e, r) {
+  return _n(t, n, e, r, 1);
+}
+function Ui(t, n, e, r) {
+  return _n(t, n, e, r, 1 / 255);
+}
+function _n(t, n, e, r, i) {
+  Gi(n, e);
+  const a = n * 3;
+  if (t.length !== a)
+    throw new Error("Display color target must cover the vertex count exactly.");
+  const s = /* @__PURE__ */ new Map();
+  let o = 0, c = 0;
+  for (const l of e) {
+    if (l.vertexCount <= 0) continue;
+    const u = l.color[0] ?? 0, d = l.color[1] ?? 0, h = l.color[2] ?? 0, f = Gn(u, d, h);
+    let b = s.get(f);
+    if (b)
+      o += 1;
+    else {
+      const C = r([u, d, h]);
+      b = [C[0], C[1], C[2]], s.set(f, b);
+    }
+    c += Math.max(0, l.vertexCount - 1);
+    const g = Math.min(n, l.startVertex + l.vertexCount);
+    for (let C = l.startVertex; C < g; C += 1) {
+      const v = C * 3;
+      t[v] = b[0] * i, t[v + 1] = b[1] * i, t[v + 2] = b[2] * i;
+    }
+  }
+  return {
+    vertexCount: n,
+    runCount: e.filter((l) => l.vertexCount > 0).length,
+    uniqueColorCount: s.size,
+    cacheHitCount: o,
+    repeatedRunVertexCount: c
+  };
+}
+const Ni = {
+  dark: {
+    background: [12, 12, 20],
+    foreground: [242, 244, 248],
+    defaultLine: [200, 200, 200],
+    defaultText: [232, 235, 242],
+    hover: [105, 160, 255],
+    selected: [64, 255, 118],
+    lockedOpacity: 0.42,
+    xrefOpacity: 0.35,
+    hatchOpacity: 0.5
+  },
+  light: {
+    background: [247, 248, 251],
+    foreground: [32, 41, 56],
+    defaultLine: [48, 57, 74],
+    defaultText: [24, 32, 44],
+    hover: [42, 104, 218],
+    selected: [31, 160, 82],
+    lockedOpacity: 0.38,
+    xrefOpacity: 0.32,
+    hatchOpacity: 0.28
+  }
+}, Hi = {
+  1: [255, 0, 0],
+  2: [255, 255, 0],
+  3: [0, 255, 0],
+  4: [0, 255, 255],
+  5: [0, 0, 255],
+  6: [255, 0, 255],
+  8: [128, 128, 128],
+  9: [192, 192, 192]
+}, Ki = 8;
+function zn(t) {
+  return Ni[t];
+}
+function Zt(t, n) {
+  const e = zn(n.theme), r = n.elementKind ?? "line", i = n.state ?? "normal", a = Ge(t, n, 0);
+  let s = qi(a, e, r), o = a.kind === "aci" && Un(a.index) === 7;
+  if (n.enhanceContrast) {
+    const l = Yi(s, {
+      theme: n.theme,
+      elementKind: r
+    });
+    o || (o = !$i(s, l)), s = l;
+  }
+  let c = r === "hatch" ? e.hatchOpacity : 1;
+  return i === "hidden" && (c = 0), i === "locked" && (c *= e.lockedOpacity), i === "xrefFaded" && (c *= e.xrefOpacity), i === "hover" && (s = e.hover, o = !0), i === "selected" && (s = e.selected, o = !0), {
+    rgb: s,
+    opacity: c,
+    raw: t,
+    resolvedRaw: a,
+    adapted: o
+  };
+}
+function Yi(t, n) {
+  const e = zn(n.theme), r = n.elementKind === "text" ? 4.5 : n.elementKind === "hatch" ? 1.6 : 2.2;
+  return Nn(t, e.background) >= r ? ge(t) : ji(t, e.background, r, n.theme);
+}
+function Ge(t, n, e = 0) {
+  return e > Ki ? n.fallbackColor ?? { kind: "aci", index: 7 } : t.kind === "bylayer" ? Ge(n.layerColor ?? n.fallbackColor ?? { kind: "aci", index: 7 }, n, e + 1) : t.kind === "byblock" ? Ge(
+    n.byBlockColor ?? n.parentByBlockColor ?? n.fallbackColor ?? { kind: "aci", index: 7 },
+    {
+      ...n,
+      byBlockColor: n.parentByBlockColor ?? null
+    },
+    e + 1
+  ) : t.kind === "none" ? Ge(n.fallbackColor ?? { kind: "aci", index: 7 }, n, e + 1) : t;
+}
+function Xi(t) {
+  return kt(t);
+}
+function kt(t) {
+  return Math.abs(t[0] - 200) <= 2 && Math.abs(t[1] - 200) <= 2 && Math.abs(t[2] - 200) <= 2;
+}
+function Qi(t, n = {}) {
+  return n.treatLegacyForegroundAsAci7 && Xi(t) ? { kind: "aci", index: 7 } : { kind: "truecolor", rgb: ge(t) };
+}
+function qi(t, n, e) {
+  return t.kind === "truecolor" ? ge(t.rgb) : t.kind === "aci" ? Wi(t.index, n) : (t.kind === "none", e === "text" ? n.defaultText : n.defaultLine);
+}
+function Wi(t, n) {
+  const e = Un(t);
+  return ge(e === 7 || e === 0 || e === 256 ? n.foreground : Hi[e] ?? n.defaultLine);
+}
+function Un(t) {
+  return Number.isFinite(t) ? Math.abs(Math.trunc(t)) : 7;
+}
+function ge(t) {
+  return [O(t[0]), O(t[1]), O(t[2])];
+}
+function $i(t, n) {
+  return t[0] === n[0] && t[1] === n[1] && t[2] === n[2];
+}
+function O(t) {
+  return Number.isFinite(t) ? Math.max(0, Math.min(255, Math.round(t))) : 0;
+}
+function Jt(t) {
+  const [n, e, r] = t.map((i) => {
+    const a = O(i) / 255;
+    return a <= 0.03928 ? a / 12.92 : ((a + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * (n ?? 0) + 0.7152 * (e ?? 0) + 0.0722 * (r ?? 0);
+}
+function Nn(t, n) {
+  const e = Jt(t), r = Jt(n), i = Math.max(e, r), a = Math.min(e, r);
+  return (i + 0.05) / (a + 0.05);
+}
+function ji(t, n, e, r) {
+  const i = Zi(t);
+  let a = 0, s = 1, o = ge(t);
+  for (let c = 0; c < 16; c += 1) {
+    const l = (a + s) / 2, u = r === "light" ? i.l * (1 - l) : i.l + (1 - i.l) * l, d = Ji(i.h, i.s, u);
+    Nn(d, n) >= e ? (o = d, s = l) : a = l;
+  }
+  return o;
+}
+function Zi(t) {
+  const n = O(t[0]) / 255, e = O(t[1]) / 255, r = O(t[2]) / 255, i = Math.max(n, e, r), a = Math.min(n, e, r), s = (i + a) / 2;
+  if (i === a) return { h: 0, s: 0, l: s };
+  const o = i - a, c = s > 0.5 ? o / (2 - i - a) : o / (i + a);
+  let l = 0;
+  return i === n ? l = (e - r) / o + (e < r ? 6 : 0) : i === e ? l = (r - n) / o + 2 : l = (n - e) / o + 4, l /= 6, { h: l, s: c, l: s };
+}
+function Ji(t, n, e) {
+  if (n === 0) {
+    const s = O(e * 255);
+    return [s, s, s];
+  }
+  const r = (s, o, c) => {
+    let l = c;
+    return l < 0 && (l += 1), l > 1 && (l -= 1), l < 1 / 6 ? s + (o - s) * 6 * l : l < 1 / 2 ? o : l < 2 / 3 ? s + (o - s) * (2 / 3 - l) * 6 : s;
+  }, i = e < 0.5 ? e * (1 + n) : e + n - e * n, a = 2 * e - i;
+  return [
+    O(r(a, i, t + 1 / 3) * 255),
+    O(r(a, i, t) * 255),
+    O(r(a, i, t - 1 / 3) * 255)
+  ];
+}
+const ea = "dark", ta = `
+precision highp float;
+
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform vec2 uResolution;
+uniform float uLineWidthPx;
+uniform float uUseLayerColor;
+uniform vec3 uLayerColor;
+
+attribute vec3 position;
+
+#ifdef CAD_LINE_FAT
+attribute vec3 instanceStart;
+attribute vec3 instanceEnd;
+attribute vec3 instanceColorStart;
+attribute vec3 instanceColorEnd;
+#else
+attribute vec3 color;
+#endif
+
+varying vec3 vColor;
+
+vec2 safeNormalize2(vec2 value) {
+  float lenSq = dot(value, value);
+  vec2 normalized = value * inversesqrt(max(lenSq, 0.000000000001));
+  return mix(vec2(1.0, 0.0), normalized, step(0.000000000001, lenSq));
+}
+
+void main() {
+#ifdef CAD_LINE_FAT
+  vec4 clipStart = projectionMatrix * modelViewMatrix * vec4(instanceStart, 1.0);
+  vec4 clipEnd = projectionMatrix * modelViewMatrix * vec4(instanceEnd, 1.0);
+  vec2 ndcStart = clipStart.xy / clipStart.w;
+  vec2 ndcEnd = clipEnd.xy / clipEnd.w;
+  vec2 dir = safeNormalize2(ndcEnd - ndcStart);
+  vec2 normal = vec2(-dir.y, dir.x);
+  float side = position.x;
+  float endpoint = position.y;
+  float cap = position.z;
+  vec2 offsetPx = normal * side * uLineWidthPx * 0.5 + dir * cap * uLineWidthPx * 0.5;
+  vec4 clip = mix(clipStart, clipEnd, endpoint);
+  clip.xy += (offsetPx / uResolution) * 2.0 * clip.w;
+  gl_Position = clip;
+  vec3 sourceColor = mix(instanceColorStart, instanceColorEnd, endpoint);
+#else
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  vec3 sourceColor = color;
+#endif
+  vColor = mix(sourceColor, uLayerColor, uUseLayerColor);
+}
+`, na = `
+precision highp float;
+
+uniform float uOpacity;
+varying vec3 vColor;
+
+vec3 linearToOutputSrgb(vec3 value) {
+  vec3 linear = max(value, vec3(0.0));
+  vec3 lower = linear * 12.92;
+  vec3 higher = 1.055 * pow(linear, vec3(1.0 / 2.4)) - 0.055;
+  vec3 useHigher = step(vec3(0.0031308), linear);
+  return clamp(mix(lower, higher, useHigher), 0.0, 1.0);
+}
+
+void main() {
+  gl_FragColor = vec4(linearToOutputSrgb(vColor), uOpacity);
+}
+`;
+class Hn extends yr {
+  constructor(e) {
+    var s, o;
+    const r = new pn(16777215), i = new gn(1, 1), a = e.variant === "fat";
+    super({
+      glslVersion: null,
+      defines: a ? { CAD_LINE_FAT: 1 } : {},
+      ...a ? { side: st } : {},
+      uniforms: {
+        uResolution: { value: i },
+        uLineWidthPx: { value: 1 },
+        uUseLayerColor: { value: 0 },
+        uLayerColor: { value: r },
+        uOpacity: { value: 1 }
+      },
+      vertexShader: ta,
+      fragmentShader: na,
+      vertexColors: !0
+    });
+    m(this, "color");
+    m(this, "resolution");
+    this.color = r, this.resolution = i, this.linewidthPx = e.linewidthPx ?? 1, this.updateResolution(((s = e.resolution) == null ? void 0 : s.x) ?? 1, ((o = e.resolution) == null ? void 0 : o.y) ?? 1);
+  }
+  get vertexColors() {
+    return this.uniforms.uUseLayerColor.value === 0;
+  }
+  set vertexColors(e) {
+    var r;
+    (r = this.uniforms) != null && r.uUseLayerColor && (this.uniforms.uUseLayerColor.value = e ? 0 : 1);
+  }
+  get opacity() {
+    return this.uniforms.uOpacity.value;
+  }
+  set opacity(e) {
+    var r;
+    (r = this.uniforms) != null && r.uOpacity && (this.uniforms.uOpacity.value = e, this.transparent = e < 1);
+  }
+  get linewidthPx() {
+    return this.uniforms.uLineWidthPx.value;
+  }
+  set linewidthPx(e) {
+    this.uniforms.uLineWidthPx.value = Math.max(1, e);
+  }
+  updateResolution(e, r) {
+    this.uniforms.uResolution.value.set(Math.max(1, e), Math.max(1, r));
+  }
+}
+const ra = new Float32Array([
+  -1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  0,
+  1,
+  1,
+  0,
+  -1,
+  0,
+  0,
+  1,
+  0,
+  0,
+  -1,
+  0,
+  -1,
+  1,
+  0,
+  -1
+]), ia = [
+  0,
+  2,
+  1,
+  2,
+  3,
+  1,
+  2,
+  4,
+  3,
+  4,
+  5,
+  3,
+  4,
+  6,
+  5,
+  6,
+  7,
+  5
+];
+function aa(t) {
+  const n = new Ye(t.minX, t.minY, 0), e = new Ye(t.maxX, t.maxY, 0), r = new mr(n, e), i = new Ye((t.minX + t.maxX) / 2, (t.minY + t.maxY) / 2, 0), a = Math.hypot(t.maxX - t.minX, t.maxY - t.minY) / 2;
+  return { box: r, sphere: new xr(i, a) };
+}
+function Kn(t, n) {
+  const e = aa(n);
+  t.boundingBox = e.box, t.boundingSphere = e.sphere;
+}
+function sa(t) {
+  const n = new xt();
+  n.setAttribute("position", new U(t.position, t.positionItemSize)), n.setAttribute("color", new U(t.color, 3, !0)), Kn(n, t.bbox);
+  const e = new Hn({ variant: "thin" }), r = new pt(n, e);
+  return r.name = "cad-thin-line", r.renderOrder = 1, r.userData.kind = "line", r.userData.mode = "thin", r.userData.vertexCount = t.vertexCount, r.userData.bbox = t.bbox, r;
+}
+function oa(t) {
+  const n = Math.floor(t.vertexCount / 2), e = t.positionItemSize * 2, r = new Mt(t.position, e, 1), i = new Mt(t.color, 6, 1), a = new bn();
+  a.setIndex(ia), a.setAttribute("position", new Cn(ra.slice(), 3)), a.setAttribute("instanceStart", new Te(r, t.positionItemSize, 0)), a.setAttribute("instanceEnd", new Te(r, t.positionItemSize, t.positionItemSize)), a.setAttribute("instanceColorStart", new Te(i, 3, 0, !0)), a.setAttribute("instanceColorEnd", new Te(i, 3, 3, !0)), a.instanceCount = n, Kn(a, t.bbox);
+  const s = new Hn({
+    variant: "fat",
+    linewidthPx: t.linewidthPx,
+    resolution: t.resolution
+  }), o = new gt(a, s);
+  return o.name = "cad-fat-line", o.renderOrder = 1, o.userData.kind = "line", o.userData.mode = "fat", o.userData.vertexCount = t.vertexCount, o.userData.bbox = t.bbox, o;
+}
+function Je(t) {
+  const n = t.getAttribute("color");
+  n && (n.needsUpdate = !0);
+  const e = t.getAttribute("instanceColorStart"), r = t.getAttribute("instanceColorEnd");
+  e && (e.needsUpdate = !0), r && (r.needsUpdate = !0);
+}
+const la = 65536;
+class ca {
+  constructor(n) {
+    this.variants = n;
+  }
+  getVariant(n) {
+    return this.variants.get(n);
+  }
+  variantIds() {
+    return this.variants.keys();
+  }
+  appendVariants(n) {
+    const e = [];
+    for (const r of n) {
+      const i = Xn(r);
+      if (!i) continue;
+      const a = this.variants.get(i.variantId);
+      a && en(a), this.variants.set(i.variantId, i), e.push(i);
+    }
+    return e;
+  }
+  dispose() {
+    for (const n of this.variants.values())
+      en(n);
+    this.variants.clear();
+  }
+}
+function et(t, n) {
+  const e = [];
+  for (const r of n) {
+    if (r.count <= 0) continue;
+    const i = r.bbox !== void 0 ? ha(r.bbox) : Me(r.pos, r.count, 3), a = ua(t);
+    for (let s = 0; s < r.count; ) {
+      const o = da(s, r.count, a, Yn(t)), c = new xt(), l = r.pos.subarray(s * 3, o * 3), u = r.col.subarray(s * 3, o * 3), d = o - s;
+      c.setAttribute("position", new U(l, 3)), c.setAttribute("color", new U(u, 3, !0)), e.push({
+        geometry: c,
+        vertexCount: d,
+        layerIndex: r.layerIndex ?? 0,
+        ...r.lineweightPx === void 0 ? {} : { lineweightPx: r.lineweightPx },
+        bbox: i
+      }), s = o;
+    }
+  }
+  return e;
+}
+function Yn(t) {
+  return t === "line" ? 2 : t === "fill" ? 3 : 1;
+}
+function ua(t) {
+  const n = Yn(t);
+  return Math.max(n, Math.floor(la / n) * n);
+}
+function da(t, n, e, r) {
+  let i = Math.min(n, t + e);
+  if (i < n) {
+    const a = t + Math.floor((i - t) / r) * r;
+    a > t && (i = a);
+  }
+  return i > t ? i : n;
+}
+function ha(t) {
+  return t ? { minX: t.minX, minY: t.minY, maxX: t.maxX, maxY: t.maxY } : null;
+}
+function fa(t) {
+  const n = /* @__PURE__ */ new Map();
+  for (const e of t) {
+    const r = Xn(e);
+    r && n.set(r.variantId, r);
+  }
+  return new ca(n);
+}
+function Xn(t) {
+  const n = /* @__PURE__ */ new Map(), e = et("line", t.line);
+  e.length > 0 && n.set("line", e);
+  const r = et("fill", t.fill);
+  r.length > 0 && n.set("fill", r);
+  const i = et("dot", t.dot);
+  return i.length > 0 && n.set("dot", i), n.size > 0 ? { variantId: t.variantId, byKind: n } : null;
+}
+function en(t) {
+  for (const n of t.byKind.values())
+    for (const e of n)
+      e.geometry.dispose();
+}
+class ya {
+  constructor(n, e) {
+    m(this, "mutableRecords");
+    m(this, "indexByRecordKey", /* @__PURE__ */ new Map());
+    this.tree = e, this.mutableRecords = [...n];
+    for (let r = 0; r < this.mutableRecords.length; r += 1)
+      this.indexByRecordKey.set(tt(this.mutableRecords[r]), r);
+  }
+  get records() {
+    return this.mutableRecords;
+  }
+  appendRecords(n) {
+    if (n.length === 0) return;
+    const e = new Array(n.length), r = this.mutableRecords.length;
+    for (let i = 0; i < n.length; i += 1) {
+      const a = n[i];
+      this.mutableRecords.push(a), this.indexByRecordKey.set(tt(a), r + i), e[i] = {
+        minX: a.bbox.minX,
+        minY: a.bbox.minY,
+        maxX: a.bbox.maxX,
+        maxY: a.bbox.maxY,
+        index: r + i
+      };
+    }
+    this.tree.load(e);
+  }
+  replaceRecord(n) {
+    const e = this.indexByRecordKey.get(tt(n));
+    if (e === void 0) return !1;
+    const r = this.mutableRecords[e];
+    return this.tree.remove(ht(r, e), (i, a) => i.index === a.index), this.mutableRecords[e] = n, this.tree.insert(ht(n, e)), !0;
+  }
+  queryInRect(n) {
+    const e = this.tree.search({
+      minX: n.minX,
+      minY: n.minY,
+      maxX: n.maxX,
+      maxY: n.maxY
+    }), r = new Array(e.length);
+    for (let i = 0; i < e.length; i++)
+      r[i] = this.records[e[i].index];
+    return r;
+  }
+  size() {
+    return this.mutableRecords.length;
+  }
+  variantHistogram() {
+    const n = /* @__PURE__ */ new Map();
+    for (const e of this.mutableRecords)
+      n.set(e.variantId, (n.get(e.variantId) ?? 0) + 1);
+    return n;
+  }
+}
+function tt(t) {
+  return t.recordKey ?? String(t.instanceId);
+}
+function ht(t, n) {
+  return {
+    minX: t.bbox.minX,
+    minY: t.bbox.minY,
+    maxX: t.bbox.maxX,
+    maxY: t.bbox.maxY,
+    index: n
+  };
+}
+function ma(t) {
+  const n = new gr();
+  if (t.length > 0) {
+    const e = new Array(t.length);
+    for (let r = 0; r < t.length; r++)
+      e[r] = ht(t[r], r);
+    n.load(e);
+  }
+  return new ya(t, n);
+}
+class xa {
+  constructor(n) {
+    m(this, "slots", []);
+    m(this, "group", new In());
+    m(this, "marginRatio");
+    m(this, "table");
+    m(this, "materialFactory");
+    m(this, "initialCapacity");
+    m(this, "attachedParent", null);
+    m(this, "lastQueryAll", !1);
+    m(this, "lastQueryRect", null);
+    m(this, "lastQueryHits", []);
+    m(this, "lastFilteredQueryRect", null);
+    m(this, "lastFilteredQueryAll", !1);
+    m(this, "lastLayerVersion", -1);
+    m(this, "lastUserHiddenCacheKey", "");
+    m(this, "cacheValid", !1);
+    m(this, "visibleVertexCount", 0);
+    this.table = n.table, this.marginRatio = n.marginRatio, this.materialFactory = n.materialFactory, this.initialCapacity = Math.max(1, n.initialCapacity);
+    for (const e of n.registry.variantIds()) {
+      const r = n.registry.getVariant(e);
+      r && this.appendVariant(r);
+    }
+  }
+  appendVariant(n) {
+    this.removeVariantSlots(n.variantId);
+    for (const [e, r] of n.byKind)
+      for (const i of r) {
+        const a = this.initialCapacity, s = new bn(), o = i.geometry.getAttribute("position"), c = i.geometry.getAttribute("color");
+        o && s.setAttribute("position", o), c && s.setAttribute("color", c), s.instanceCount = 0;
+        const l = new ce(new Float32Array(a * 4), 4), u = new ce(new Float32Array(a * 4), 4), d = new ce(new Float32Array(a), 1);
+        s.setAttribute("promotedInstMatRow0", l), s.setAttribute("promotedInstMatRow1", u), s.setAttribute("promotedInstVisible", d);
+        const h = ga(e, s, this.materialFactory(e));
+        h.visible = !1, h.frustumCulled = !1, h.userData.kind = e, h.userData.variantId = n.variantId, h.userData.insertPresenterMesh = !0, h.userData.vertexCount = 0, this.slots.push({
+          variantId: n.variantId,
+          kind: e,
+          geometryLayerIndex: i.layerIndex,
+          perVertexCount: i.vertexCount,
+          localBBox: i.bbox,
+          mesh: h,
+          matRow0Attr: l,
+          matRow1Attr: u,
+          visibleAttr: d,
+          capacity: a
+        }), this.group.add(h);
+      }
+    this.invalidateFilteredQueryCache();
+  }
+  attach(n) {
+    this.attachedParent !== n && (this.detach(), n.add(this.group), this.attachedParent = n);
+  }
+  detach() {
+    this.attachedParent && (this.attachedParent.remove(this.group), this.attachedParent = null);
+  }
+  invalidateQueryCache() {
+    this.lastQueryAll = !1, this.lastQueryRect = null, this.lastQueryHits = [], this.invalidateFilteredQueryCache();
+  }
+  refresh(n, e, r, i) {
+    const a = n ? ar(n, this.marginRatio) : null, s = !a, o = i === void 0 ? `signature:${pa(r)}` : `revision:${i}`;
+    if (this.cacheValid && this.lastLayerVersion === e.version && this.lastUserHiddenCacheKey === o && this.lastFilteredQueryAll === s && sr(this.lastFilteredQueryRect, a))
+      return;
+    const c = this.resolveQueryHits(a), l = /* @__PURE__ */ new Map();
+    for (const d of c) {
+      if (a && !or(a, d.bbox) || r.has(d.instanceId)) continue;
+      let h = l.get(d.variantId);
+      h || (h = [], l.set(d.variantId, h)), h.push(d);
+    }
+    let u = 0;
+    for (const d of this.slots) {
+      const h = l.get(d.variantId), f = h == null ? void 0 : h.filter((b) => this.slotVisibleForRecord(d, b, e));
+      if (!f || f.length === 0) {
+        tn(d.mesh, 0), d.mesh.userData.vertexCount = 0, d.mesh.visible = !1;
+        continue;
+      }
+      this.ensureCapacity(d, f.length), this.writeMatRows(d, f), tn(d.mesh, f.length), d.mesh.userData.vertexCount = f.length * d.perVertexCount, d.mesh.visible = !0, u += f.length * d.perVertexCount;
+    }
+    this.visibleVertexCount = u, this.lastLayerVersion = e.version, this.lastUserHiddenCacheKey = o, this.lastFilteredQueryAll = s, this.lastFilteredQueryRect = a ? {
+      minX: a.minX,
+      minY: a.minY,
+      maxX: a.maxX,
+      maxY: a.maxY
+    } : null, this.cacheValid = !0;
+  }
+  currentVisibleVertexCount() {
+    return this.visibleVertexCount;
+  }
+  resolveQueryHits(n) {
+    if (!n)
+      return this.lastQueryAll || (this.lastQueryAll = !0, this.lastQueryRect = null, this.lastQueryHits = this.table.records), this.lastQueryHits;
+    if (!this.lastQueryAll && this.lastQueryRect && lr(this.lastQueryRect, n))
+      return this.lastQueryHits;
+    const e = this.table.queryInRect(n);
+    return this.lastQueryAll = !1, this.lastQueryRect = n, this.lastQueryHits = e, e;
+  }
+  removeVariantSlots(n) {
+    let e = !1;
+    for (let r = this.slots.length - 1; r >= 0; r -= 1) {
+      const i = this.slots[r];
+      i.variantId === n && (this.group.remove(i.mesh), i.mesh.geometry.dispose(), nn(i.mesh.material), this.slots.splice(r, 1), e = !0);
+    }
+    e && this.invalidateFilteredQueryCache();
+  }
+  invalidateFilteredQueryCache() {
+    this.lastFilteredQueryRect = null, this.lastFilteredQueryAll = !1, this.lastLayerVersion = -1, this.lastUserHiddenCacheKey = "", this.cacheValid = !1;
+  }
+  dispose() {
+    this.detach();
+    for (const n of this.slots)
+      this.group.remove(n.mesh), n.mesh.geometry.dispose(), nn(n.mesh.material);
+    this.slots.length = 0, this.invalidateQueryCache(), this.visibleVertexCount = 0;
+  }
+  _debugSlots() {
+    return this.slots;
+  }
+  ensureCapacity(n, e) {
+    if (n.capacity >= e) return;
+    const r = Math.max(e, n.capacity * 2);
+    n.matRow0Attr = new ce(new Float32Array(r * 4), 4), n.matRow1Attr = new ce(new Float32Array(r * 4), 4), n.visibleAttr = new ce(new Float32Array(r), 1), n.mesh.geometry.setAttribute("promotedInstMatRow0", n.matRow0Attr), n.mesh.geometry.setAttribute("promotedInstMatRow1", n.matRow1Attr), n.mesh.geometry.setAttribute("promotedInstVisible", n.visibleAttr), n.capacity = r;
+  }
+  writeMatRows(n, e) {
+    const r = n.matRow0Attr.array, i = n.matRow1Attr.array, a = n.visibleAttr.array;
+    for (let o = 0; o < e.length; o += 1) {
+      const c = e[o], l = o * 4;
+      r[l] = c.matA, r[l + 1] = c.matC, r[l + 2] = c.tx, r[l + 3] = 0, i[l] = c.matB, i[l + 1] = c.matD, i[l + 2] = c.ty, i[l + 3] = 0, a[o] = 1;
+    }
+    const s = e.length * 4;
+    n.matRow0Attr.clearUpdateRanges(), n.matRow1Attr.clearUpdateRanges(), n.visibleAttr.clearUpdateRanges(), n.matRow0Attr.addUpdateRange(0, s), n.matRow1Attr.addUpdateRange(0, s), n.visibleAttr.addUpdateRange(0, e.length), n.matRow0Attr.needsUpdate = !0, n.matRow1Attr.needsUpdate = !0, n.visibleAttr.needsUpdate = !0;
+  }
+  slotVisibleForRecord(n, e, r) {
+    const i = n.geometryLayerIndex === 0 ? e.layerIdx : n.geometryLayerIndex;
+    return r.isVisible(i);
+  }
+}
+function pa(t) {
+  return t.size === 0 ? "0:" : `${t.size}:${Array.from(t).sort((n, e) => n - e).join(",")}`;
+}
+function ga(t, n, e) {
+  const r = t === "line" ? new pt(n, e) : t === "fill" ? new gt(n, e) : new wn(n, e);
+  return r.count = 0, r;
+}
+function tn(t, n) {
+  t.geometry.instanceCount = n, t.count = n;
+}
+function nn(t) {
+  if (Array.isArray(t)) {
+    for (const n of t) n.dispose();
+    return;
+  }
+  t.dispose();
+}
+const Qn = 64, qn = 8;
+function ba() {
+  return typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+}
+async function Ca(t, n = {}) {
+  const e = Math.max(1, Math.floor(n.opsPerPass ?? Qn) || 1), r = Math.max(0, n.frameBudgetMs ?? qn), i = n.now ?? ba, a = i();
+  let s = a, o = 0, c = 0, l = 0, u = 0;
+  for (let d = 0; d < t.length; d += 1) {
+    const h = t[d];
+    c += 1, h.run() && (l += 1, o += 1), n.onYield && d < t.length - 1 && (o >= e || i() - s >= r) && (await n.onYield(), u += 1, s = i(), o = 0);
+  }
+  return {
+    visited: c,
+    compacted: l,
+    yielded: u,
+    elapsedMs: i() - a
+  };
+}
+function Ia(t, n) {
+  return n.zoom, t === "full" && n.visibleVertexCount >= br ? "stress" : t === "stress" && n.visibleVertexCount <= Cr ? "full" : t;
+}
+function wa(t, n, e) {
+  return t === "full" || t === "stress" ? t : Ia(n, e);
+}
+const va = 1e-6;
+function Ra(t, n) {
+  let e = !0;
+  for (let i = 0; i < n; i += 1) {
+    const a = t[i * 3 + 2] ?? 0;
+    if (Math.abs(a) > va) {
+      e = !1;
+      break;
+    }
+  }
+  if (!e)
+    return { kind: "xyz", xyz: t.slice(0, n * 3) };
+  const r = new Float32Array(n * 2);
+  for (let i = 0; i < n; i += 1)
+    r[i * 2] = t[i * 3] ?? 0, r[i * 2 + 1] = t[i * 3 + 1] ?? 0;
+  return { kind: "xy", xy: r };
+}
+function Ba(t, n, e = 3) {
+  if (e === 2) {
+    const i = n * 2;
+    if (t.length === i)
+      return { kind: "xy", xy: t };
+    if (t.length > i)
+      return { kind: "xy", xy: t.slice(0, i) };
+    const a = new Float32Array(i);
+    return a.set(t), { kind: "xy", xy: a };
+  }
+  const r = new Float32Array(n * 2);
+  for (let i = 0; i < n; i += 1)
+    r[i * 2] = t[i * 3] ?? 0, r[i * 2 + 1] = t[i * 3 + 1] ?? 0;
+  return { kind: "xy", xy: r };
+}
+function Sa(t, n, e, r) {
+  const i = r * 3;
+  if (t.kind === "xyz") {
+    e.set(t.xyz.subarray(0, n * 3), i);
+    return;
+  }
+  for (let a = 0; a < n; a += 1) {
+    const s = a * 2, o = i + a * 3;
+    e[o] = t.xy[s] ?? 0, e[o + 1] = t.xy[s + 1] ?? 0, e[o + 2] = 0;
+  }
+}
+function Ea(t, n, e, r, i) {
+  if (i === 3) {
+    Sa(t, n, e, r);
+    return;
+  }
+  const a = r * 2;
+  if (t.kind === "xy") {
+    e.set(t.xy.subarray(0, n * 2), a);
+    return;
+  }
+  for (let s = 0; s < n; s += 1) {
+    const o = s * 3, c = a + s * 2;
+    e[c] = t.xyz[o] ?? 0, e[c + 1] = t.xyz[o + 1] ?? 0;
+  }
+}
+function Va(t, n, e) {
+  const r = t.kind === "xy" ? e * 2 * Float32Array.BYTES_PER_ELEMENT : e * 3 * Float32Array.BYTES_PER_ELEMENT, i = Math.min(n.byteLength, e * 3);
+  return {
+    recordCount: 1,
+    vertexCount: e,
+    xyRecordCount: t.kind === "xy" ? 1 : 0,
+    xyzRecordCount: t.kind === "xyz" ? 1 : 0,
+    xyVertexCount: t.kind === "xy" ? e : 0,
+    xyzVertexCount: t.kind === "xyz" ? e : 0,
+    positionBytes: r,
+    colorBytes: i,
+    totalBytes: r + i
+  };
+}
+function rn() {
+  return {
+    recordCount: 0,
+    vertexCount: 0,
+    xyRecordCount: 0,
+    xyzRecordCount: 0,
+    xyVertexCount: 0,
+    xyzVertexCount: 0,
+    positionBytes: 0,
+    colorBytes: 0,
+    totalBytes: 0
+  };
+}
+function ka(t, n) {
+  return {
+    recordCount: t.recordCount + n.recordCount,
+    vertexCount: t.vertexCount + n.vertexCount,
+    xyRecordCount: t.xyRecordCount + n.xyRecordCount,
+    xyzRecordCount: t.xyzRecordCount + n.xyzRecordCount,
+    xyVertexCount: t.xyVertexCount + n.xyVertexCount,
+    xyzVertexCount: t.xyzVertexCount + n.xyzVertexCount,
+    positionBytes: t.positionBytes + n.positionBytes,
+    colorBytes: t.colorBytes + n.colorBytes,
+    totalBytes: t.totalBytes + n.totalBytes
+  };
+}
+function Aa(t, n) {
+  return {
+    recordCount: X(t.recordCount, n.recordCount, "recordCount"),
+    vertexCount: X(t.vertexCount, n.vertexCount, "vertexCount"),
+    xyRecordCount: X(t.xyRecordCount, n.xyRecordCount, "xyRecordCount"),
+    xyzRecordCount: X(t.xyzRecordCount, n.xyzRecordCount, "xyzRecordCount"),
+    xyVertexCount: X(t.xyVertexCount, n.xyVertexCount, "xyVertexCount"),
+    xyzVertexCount: X(t.xyzVertexCount, n.xyzVertexCount, "xyzVertexCount"),
+    positionBytes: X(t.positionBytes, n.positionBytes, "positionBytes"),
+    colorBytes: X(t.colorBytes, n.colorBytes, "colorBytes"),
+    totalBytes: X(t.totalBytes, n.totalBytes, "totalBytes")
+  };
+}
+function X(t, n, e) {
+  const r = t - n;
+  if (r < 0)
+    throw new Error(`Line canonical memory stat ${String(e)} became negative: ${t} - ${n}`);
+  return Object.is(r, -0) ? 0 : r;
+}
+const Ta = {
+  visibleVertexCount: 0,
+  zoom: 1
+}, Pa = /* @__PURE__ */ new Set(), La = Object.freeze({ kind: "structure" }), ys = Object.freeze({ kind: "visual" });
+function an(t) {
+  return Number.isFinite(t.minX) && Number.isFinite(t.minY) && Number.isFinite(t.maxX) && Number.isFinite(t.maxY);
+}
+function Wn(t, n, e) {
+  return `${t}:${n}:${e}`;
+}
+function Ma(t) {
+  return t.recordKey ?? Wn(t.instanceId, t.variantId, 0);
+}
+const nt = "geo-node:promoted-instanced-v1", sn = "geo-node:text-batch-static-bounds-v1", Pe = "geo-node:text-batch-bounds-dirty-v1", on = 1.5, Da = 1, ln = "geo-node:world-sized-points-v1", $n = "geo-node:world-sized-points-uniforms", Fa = 16777216, Oa = 25, Ga = 28, _a = 29;
+function za() {
+  return {
+    activeThinCount: 0,
+    activeFatCount: 0,
+    cachedThinCount: 0,
+    cachedFatCount: 0
+  };
+}
+function be(t) {
+  return [t[0], t[1], t[2], t[3]];
+}
+function Ua(t, n) {
+  return [Math.min(t[0], n[0]), Math.min(t[1], n[1]), Math.max(t[2], n[2]), Math.max(t[3], n[3])];
+}
+function P(t) {
+  return [t[0], t[1], t[2]];
+}
+function Na(t, n) {
+  return t[0] === n[0] && t[1] === n[1] && t[2] === n[2];
+}
+function cn(t, n, e) {
+  for (const r of n)
+    r.vertexCount <= 0 || t.push({
+      startVertex: r.startVertex + e,
+      vertexCount: r.vertexCount,
+      color: P(r.color)
+    });
+}
+function ft(t) {
+  const n = [];
+  for (const e of t) {
+    if (e.vertexCount <= 0) continue;
+    const r = {
+      startVertex: e.startVertex,
+      vertexCount: e.vertexCount,
+      color: P(e.color)
+    }, i = n[n.length - 1];
+    if (i && i.startVertex + i.vertexCount === r.startVertex && Na(i.color, r.color)) {
+      n[n.length - 1] = {
+        ...i,
+        vertexCount: i.vertexCount + r.vertexCount
+      };
+      continue;
+    }
+    n.push(r);
+  }
+  return n;
+}
+function un(t, n) {
+  if (!t || t.length === 0 || !ze(n, t))
+    return;
+  const e = ft(t);
+  return e.length <= Math.ceil(n / 2) ? e : void 0;
+}
+function Ha(t, n) {
+  if (!n || n.size === 0) return t;
+  const e = /* @__PURE__ */ new Map();
+  for (const [r, i] of t)
+    e.set(r, [...i]);
+  for (const [r, i] of n)
+    e.set(r, Ka(e.get(r) ?? [], i));
+  return e;
+}
+function Ka(t, n) {
+  const e = /* @__PURE__ */ new Map();
+  for (const r of t)
+    e.set(r.variantId, {
+      ...r,
+      bboxes: [...r.bboxes],
+      inserts: [...r.inserts]
+    });
+  for (const r of n) {
+    const i = e.get(r.variantId);
+    if (!i) {
+      e.set(r.variantId, {
+        ...r,
+        bboxes: [...r.bboxes],
+        inserts: [...r.inserts]
+      });
+      continue;
+    }
+    const a = new Map(i.inserts.map((o) => [o.instanceId, o]));
+    for (const o of r.inserts)
+      a.set(o.instanceId, o);
+    const s = Array.from(a.values()).sort((o, c) => o.instanceId - c.instanceId);
+    e.set(r.variantId, {
+      ...i,
+      blockName: r.blockName || i.blockName,
+      instanceCount: s.length || Math.max(i.instanceCount, r.instanceCount),
+      bboxes: s.map((o) => o.bbox).filter((o) => !!o),
+      inserts: s
+    });
+  }
+  return Array.from(e.values()).sort((r, i) => i.instanceCount - r.instanceCount);
+}
+function Ya(t) {
+  return t.line.count > 0 || t.fill.count > 0 || t.dot.count > 0 || t.line.raw.byteLength > 0 || t.fill.raw.byteLength > 0 || t.dot.raw.byteLength > 0;
+}
+function dn(t, n) {
+  if (n === 0) return t;
+  const e = /* @__PURE__ */ new Map();
+  for (const [r, i] of t)
+    e.set(
+      r,
+      i.map((a) => a + n)
+    );
+  return e;
+}
+function Xa(t, n, e) {
+  if (!n) return t;
+  if (!t)
+    return {
+      ...n,
+      textIndexesByInstanceId: dn(n.textIndexesByInstanceId, e),
+      ownerInstanceIdByVariantOrdinal: n.ownerInstanceIdByVariantOrdinal ? new Map(n.ownerInstanceIdByVariantOrdinal) : void 0
+    };
+  const r = t.variants.slice();
+  for (const a of n.variants)
+    (!r[a.id] || Ya(a)) && (r[a.id] = a);
+  const i = /* @__PURE__ */ new Map();
+  for (const [a, s] of t.textIndexesByInstanceId)
+    i.set(a, [...s]);
+  for (const [a, s] of dn(n.textIndexesByInstanceId, e))
+    i.set(a, [...i.get(a) ?? [], ...s]);
+  return {
+    layer0Index: t.layer0Index,
+    variants: r,
+    instances: [...t.instances, ...n.instances],
+    textIndexesByInstanceId: i,
+    ownerInstanceIdByVariantOrdinal: new Map([
+      ...t.ownerInstanceIdByVariantOrdinal ?? /* @__PURE__ */ new Map(),
+      ...n.ownerInstanceIdByVariantOrdinal ?? /* @__PURE__ */ new Map()
+    ])
+  };
+}
+function Qa(t) {
+  return {
+    index: t.index,
+    name: t.name,
+    color: P(t.color),
+    lw_px: t.lw_px,
+    visible: t.visible
+  };
+}
+function qa(t) {
+  const n = t >>> 0;
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function Wa(t) {
+  return t[0] << 16 | t[1] << 8 | t[2];
+}
+function rt(t) {
+  if (!Number.isFinite(t)) return 0;
+  const n = Math.round(t);
+  return n < 0 ? 0 : n > 255 ? 255 : n;
+}
+function $a(t) {
+  switch (t) {
+    case "fill":
+      return 1;
+    case "dot":
+      return 2;
+    case "text":
+      return 3;
+    case "hatch":
+      return 4;
+    case "overlay":
+      return 5;
+    case "line":
+    default:
+      return 0;
+  }
+}
+function ja(t, n, e, r, i) {
+  return (n !== null && kt(t) ? Fa : rt(t[0]) << 16 | rt(t[1]) << 8 | rt(t[2])) | $a(e) << Oa | (r === "light" ? 1 : 0) << Ga | (i ? 1 : 0) << _a;
+}
+function it(t) {
+  return "color" in t && t.color instanceof pn;
+}
+function at(t) {
+  const n = /* @__PURE__ */ new Set();
+  t.traverse((e) => {
+    var a;
+    const r = e.geometry;
+    r == null || r.dispose();
+    const i = e.material;
+    if (Array.isArray(i)) {
+      for (const s of i)
+        n.has(s) || (n.add(s), s.dispose());
+      return;
+    }
+    i && !n.has(i) && (n.add(i), i.dispose()), e !== t && ((a = e.dispose) == null || a.call(e));
+  });
+}
+function Za(t) {
+  var i;
+  const n = t.userData;
+  if (n[nt] === !0)
+    return;
+  const e = t.onBeforeCompile;
+  t.onBeforeCompile = (a, s) => {
+    e == null || e(a, s), a.vertexShader.includes("attribute vec4 promotedInstMatRow0;") || (a.vertexShader = a.vertexShader.replace(
+      "#include <common>",
+      [
+        "#include <common>",
+        "attribute vec4 promotedInstMatRow0;",
+        "attribute vec4 promotedInstMatRow1;",
+        "attribute float promotedInstVisible;"
+      ].join(`
+`)
+    ).replace(
+      "#include <begin_vertex>",
+      [
+        "vec3 transformed = vec3(position);",
+        "transformed = vec3(",
+        "  promotedInstMatRow0.x * transformed.x + promotedInstMatRow0.y * transformed.y + promotedInstMatRow0.z,",
+        "  promotedInstMatRow1.x * transformed.x + promotedInstMatRow1.y * transformed.y + promotedInstMatRow1.z,",
+        "  transformed.z",
+        ");"
+      ].join(`
+`)
+    ).replace(
+      "#include <project_vertex>",
+      [
+        "#include <project_vertex>",
+        "if (promotedInstVisible < 0.5) {",
+        "  gl_Position = vec4(2.0, 2.0, 2.0, 1.0);",
+        "}"
+      ].join(`
+`)
+    ));
+  };
+  const r = (i = t.customProgramCacheKey) == null ? void 0 : i.bind(t);
+  t.customProgramCacheKey = () => `${r ? r() : ""}|${nt}`, n[nt] = !0, t.needsUpdate = !0;
+}
+function Ja(t) {
+  const n = t.userData[$n];
+  return n && typeof n == "object" ? n : null;
+}
+function es(t, n) {
+  var o;
+  const e = t.userData, r = Ja(t);
+  if (r)
+    return r.uGeoPointWorldSize.value = n.pointWorldSize, r.uGeoPointViewportHeight.value = Math.max(1, Math.floor(n.viewportHeight) || 1), r.uGeoPointMinVisiblePixelSize.value = on, r;
+  const i = {
+    uGeoPointWorldSize: { value: n.pointWorldSize },
+    uGeoPointViewportHeight: { value: Math.max(1, Math.floor(n.viewportHeight) || 1) },
+    uGeoPointMinVisiblePixelSize: { value: on }
+  };
+  e[$n] = i;
+  const a = t.onBeforeCompile;
+  t.onBeforeCompile = (c, l) => {
+    a == null || a(c, l), c.uniforms.uGeoPointWorldSize = i.uGeoPointWorldSize, c.uniforms.uGeoPointViewportHeight = i.uGeoPointViewportHeight, c.uniforms.uGeoPointMinVisiblePixelSize = i.uGeoPointMinVisiblePixelSize, c.vertexShader.includes("uGeoPointWorldSize") || (c.vertexShader = c.vertexShader.replace(
+      "#include <common>",
+      [
+        "#include <common>",
+        "uniform float uGeoPointWorldSize;",
+        "uniform float uGeoPointViewportHeight;",
+        "uniform float uGeoPointMinVisiblePixelSize;"
+      ].join(`
+`)
+    ).replace(
+      "gl_PointSize = size;",
+      [
+        "float geoPointSize = abs(uGeoPointWorldSize * projectionMatrix[ 1 ][ 1 ] * 0.5 * uGeoPointViewportHeight);",
+        "bool geoPointUsesPerspectiveDepth = isPerspectiveMatrix( projectionMatrix );",
+        "if (geoPointUsesPerspectiveDepth) {",
+        "  geoPointSize /= max(1e-6, -mvPosition.z);",
+        "}",
+        "if (geoPointSize < uGeoPointMinVisiblePixelSize) {",
+        "  gl_Position = vec4(2.0, 2.0, 2.0, 1.0);",
+        "}",
+        "gl_PointSize = geoPointSize;"
+      ].join(`
+`)
+    ));
+  };
+  const s = (o = t.customProgramCacheKey) == null ? void 0 : o.bind(t);
+  return t.customProgramCacheKey = () => `${s ? s() : ""}|${ln}`, e[ln] = !0, t.needsUpdate = !0, i;
+}
+const Ue = /* @__PURE__ */ new WeakMap();
+function hn(t, n) {
+  n ? Ue.set(t, n) : Ue.delete(t);
+}
+class Ie extends j {
+  constructor(e = {}) {
+    super();
+    m(this, "meta", {
+      bounds: [0, 0, 0, 0],
+      entityCount: 0,
+      lineCount: 0,
+      fillCount: 0,
+      dotCount: 0,
+      textCount: 0
+    });
+    m(this, "layerOrder", []);
+    m(this, "layerStatesByIndex", /* @__PURE__ */ new Map());
+    m(this, "bounds", [0, 0, 0, 0]);
+    m(this, "originalLayerColorsByIndex", /* @__PURE__ */ new Map());
+    m(this, "colorOverridesByIndex", /* @__PURE__ */ new Map());
+    m(this, "displayThemeName", ea);
+    m(this, "displayContrastEnhancement", !0);
+    m(this, "displayHexMemo", /* @__PURE__ */ new Map());
+    m(this, "layerStateRevision", 0);
+    m(this, "metaRevision", 0);
+    m(this, "renderDebugRevision", 0);
+    m(this, "layersSnapshotCache", null);
+    m(this, "metaSnapshotCache", null);
+    m(this, "boundsSnapshotCache", null);
+    m(this, "layerGroupsByIndex", /* @__PURE__ */ new Map());
+    m(this, "textUserDataByAppendOrder", []);
+    m(this, "textBatchByLayerIndex", /* @__PURE__ */ new Map());
+    m(this, "textRenderablesByLayerIndex", /* @__PURE__ */ new Map());
+    m(this, "textRenderablesByAppendOrder", []);
+    m(this, "annotationOverlayGroupsByLayerIndex", /* @__PURE__ */ new Map());
+    m(this, "annotationTextBatchByLayerIndex", /* @__PURE__ */ new Map());
+    m(this, "annotationTextRenderablesByLayerIndex", /* @__PURE__ */ new Map());
+    m(this, "annotationTextRecordsByOwnerKey", /* @__PURE__ */ new Map());
+    m(this, "annotationTextRecordsByLayerIndex", /* @__PURE__ */ new Map());
+    m(this, "pendingTextBatchSync", /* @__PURE__ */ new Set());
+    m(this, "textBatchSyncScheduled", !1);
+    m(this, "insertRuntime", null);
+    m(this, "insertRuntimeInstancesById", /* @__PURE__ */ new Map());
+    m(this, "blockGeometryRegistry", null);
+    m(this, "insertPresenterVariantInputs", /* @__PURE__ */ new Map());
+    m(this, "insertPresenterRecordsByKey", /* @__PURE__ */ new Map());
+    m(this, "insertPresenterRecordKeysByInstanceId", /* @__PURE__ */ new Map());
+    m(this, "insertInstanceTable", null);
+    m(this, "viewportInstancePresenter", null);
+    m(this, "insertPresenterExternallyManaged", !1);
+    m(this, "renderQualityMode", "auto");
+    m(this, "effectiveRenderQuality", "full");
+    m(this, "interactionRenderQualityOverride", null);
+    m(this, "lineModeSwitchingEnabled", !1);
+    m(this, "autoQualityContext", { ...Ta });
+    m(this, "lineChunkRecords", []);
+    m(this, "lineCanonicalMemoryStats", rn());
+    m(this, "nonLineChunkStats", []);
+    m(this, "worldSizedPointUniforms", /* @__PURE__ */ new Set());
+    m(this, "lineResolution", { width: 1, height: 1 });
+    m(this, "internalChangeHook", null);
+    m(this, "disposed", !1);
+    m(this, "readySettled", !1);
+    m(this, "layerBlockUsages", /* @__PURE__ */ new Map());
+    m(this, "colorRefreshStats", {
+      displayRefreshVertexTotal: 0,
+      displayRefreshRunTotal: 0,
+      displayRefreshUniqueColorTotal: 0,
+      displayRefreshCacheHitTotal: 0,
+      displayRefreshRepeatedRunVertexTotal: 0
+    });
+    m(this, "contentGeneration", 0);
+    m(this, "annotationOverlayVisible", !0);
+    m(this, "readyPromise");
+    m(this, "resolveReady");
+    m(this, "rejectReady");
+    m(this, "resolveTextFont");
+    this.name = "GeoNode", this.resolveTextFont = e.resolveTextFont ?? Di, this.startReadyCycle();
+  }
+  get ready() {
+    return this.readyPromise;
+  }
+  setLayerVisible(e, r) {
+    var o;
+    const i = this.layerStatesByIndex.get(e), a = this.layerGroupsByIndex.get(e);
+    if (!i) return;
+    const s = i.visible !== r;
+    s && (this.layerStateRevision += 1, (o = this.viewportInstancePresenter) == null || o.invalidateQueryCache()), i.visible = r, a && (a.visible = r), this.refreshAnnotationTextVisibilityForLayer(e), s && this.refreshDefaultInsertPresenterIfUnmanaged();
+  }
+  setAnnotationOverlayVisible(e) {
+    if (this.annotationOverlayVisible !== e) {
+      this.annotationOverlayVisible = e;
+      for (const r of this.annotationOverlayGroupsByLayerIndex.values())
+        this.applyAnnotationOverlayVisibility(r);
+      this.notifyInternalChange();
+    }
+  }
+  setDisplayTheme(e, r = {}) {
+    const i = r.enhanceContrast ?? this.displayContrastEnhancement, a = this.displayThemeName === e && this.displayContrastEnhancement === i;
+    this.displayThemeName = e, this.displayContrastEnhancement = i, !a && (this.displayHexMemo.clear(), this.refreshDisplayColors(), this.notifyInternalChange());
+  }
+  setLayerColor(e, r) {
+    const i = this.layerStatesByIndex.get(e), a = this.layerGroupsByIndex.get(e), s = this.originalLayerColorsByIndex.get(e);
+    if (!i || !a || !s) return;
+    const o = r === null ? null : qa(r);
+    o ? this.colorOverridesByIndex.set(e, P(o)) : this.colorOverridesByIndex.delete(e), this.displayHexMemo.clear(), i.color = P(o ?? s), this.layerStateRevision += 1, a.traverse((c) => {
+      var h;
+      const l = (h = c.userData) == null ? void 0 : h.kind;
+      if (l === "text" || l === "text-batch") return;
+      const u = c.material, d = Array.isArray(u) ? u : u ? [u] : [];
+      for (const f of d)
+        it(f) && (this.applyLayerColorState(f, o, this.displayElementKindForObject(c)), f.needsUpdate = !0);
+    }), this.applyCachedLineChunkColors(e, o), this.applyLayerTextColors(e, o);
+  }
+  setRenderQuality(e) {
+    this.renderQualityMode = e, this.applyEffectiveRenderQuality(this.resolveCurrentEffectiveRenderQuality());
+  }
+  setLineModeSwitchingEnabled(e) {
+    this.lineModeSwitchingEnabled !== e && (this.lineModeSwitchingEnabled = e, this.applyEffectiveRenderQuality(this.resolveCurrentEffectiveRenderQuality(), { forceLineRebuild: !0 }));
+  }
+  updateAutoQualityContext(e) {
+    this.autoQualityContext = { ...e }, this.lineModeSwitchingEnabled && (this.renderQualityMode !== "auto" && !this.interactionRenderQualityOverride || this.applyEffectiveRenderQuality(this.resolveCurrentEffectiveRenderQuality()));
+  }
+  setInteractionRenderQualityOverride(e) {
+    this.interactionRenderQualityOverride !== e && (this.interactionRenderQualityOverride = e, this.applyEffectiveRenderQuality(this.resolveCurrentEffectiveRenderQuality()));
+  }
+  getMeta() {
+    var r;
+    if (((r = this.metaSnapshotCache) == null ? void 0 : r.revision) === this.metaRevision)
+      return this.metaSnapshotCache.value;
+    const e = Object.freeze({
+      bounds: be(this.meta.bounds),
+      entityCount: this.meta.entityCount,
+      lineCount: this.meta.lineCount,
+      fillCount: this.meta.fillCount,
+      dotCount: this.meta.dotCount,
+      textCount: this.meta.textCount
+    });
+    return this.metaSnapshotCache = { revision: this.metaRevision, value: e }, e;
+  }
+  getLayers() {
+    var r;
+    if (((r = this.layersSnapshotCache) == null ? void 0 : r.revision) === this.layerStateRevision)
+      return this.layersSnapshotCache.value;
+    const e = Object.freeze(
+      this.layerOrder.map((i) => this.layerStatesByIndex.get(i)).filter((i) => i !== void 0).map((i) => Object.freeze(Qa(i)))
+    );
+    return this.layersSnapshotCache = { revision: this.layerStateRevision, value: e }, e;
+  }
+  getLayerVisibility() {
+    const e = this.layerStateRevision, r = /* @__PURE__ */ new Map();
+    for (const [i, a] of this.layerStatesByIndex)
+      r.set(i, a.visible);
+    return {
+      version: e,
+      isVisible: (i) => r.get(i) ?? !0
+    };
+  }
+  refreshInsertPresenter(e, r, i, a = 0) {
+    var s;
+    this.insertPresenterExternallyManaged = !0, (s = this.viewportInstancePresenter) == null || s.refresh(e, r, i, a);
+  }
+  getInsertPresenterVisibleVertexCount() {
+    var e;
+    return ((e = this.viewportInstancePresenter) == null ? void 0 : e.currentVisibleVertexCount()) ?? 0;
+  }
+  invalidateInsertPresenterQueryCache() {
+    var e;
+    (e = this.viewportInstancePresenter) == null || e.invalidateQueryCache();
+  }
+  getLayerBlockUsages(e) {
+    return this.layerBlockUsages.get(e) ?? [];
+  }
+  getBlockLayerStatsRevision() {
+    return this.layerStateRevision * 1e6 + this.metaRevision;
+  }
+  getRenderDebugRevision() {
+    return this.renderDebugRevision;
+  }
+  getBounds() {
+    var r;
+    if (((r = this.boundsSnapshotCache) == null ? void 0 : r.revision) === this.metaRevision)
+      return this.boundsSnapshotCache.value;
+    const e = Object.freeze(be(this.bounds));
+    return this.boundsSnapshotCache = { revision: this.metaRevision, value: e }, e;
+  }
+  getGeometryChunkStats() {
+    const e = this.lineChunkRecords.map((i) => ({
+      layerIndex: i.layerIndex,
+      vertexCount: i.vertexCount,
+      bbox: _e(i.bbox)
+    })), r = this.nonLineChunkStats.map((i) => ({
+      layerIndex: i.layerIndex,
+      vertexCount: i.vertexCount,
+      bbox: _e(i.bbox)
+    }));
+    return [...e, ...r];
+  }
+  _collectTextUserDataForDebug() {
+    return this.textUserDataByAppendOrder.map((e) => ({ ...e, c: P(e.c) }));
+  }
+  getTextEntries() {
+    return this.textUserDataByAppendOrder;
+  }
+  getInsertInstanceBaseTransform(e, r) {
+    const i = this.resolveInsertRuntimeInstance(e, r);
+    if (!i) return null;
+    const a = Math.hypot(i.matA, i.matB), s = Math.hypot(i.matC, i.matD), o = Math.atan2(i.matB, i.matA);
+    return {
+      tx: i.tx,
+      ty: i.ty,
+      rotation: o * 180 / Math.PI,
+      scaleX: a,
+      scaleY: s
+    };
+  }
+  getInsertVariantGeometry(e) {
+    var r;
+    return ((r = this.blockGeometryRegistry) == null ? void 0 : r.getVariant(e)) ?? null;
+  }
+  getInsertInstanceMatrix(e, r) {
+    const i = this.resolveInsertRuntimeInstance(e, r);
+    return i ? {
+      matA: i.matA,
+      matB: i.matB,
+      matC: i.matC,
+      matD: i.matD,
+      tx: i.tx,
+      ty: i.ty
+    } : null;
+  }
+  getInsertPreviewRecordsForInstance(e) {
+    const r = this.insertPresenterRecordKeysByInstanceId.get(e);
+    if (!r || r.size === 0) return [];
+    const i = [];
+    for (const a of r) {
+      const s = this.insertPresenterRecordsByKey.get(a);
+      s && i.push(s);
+    }
+    return i;
+  }
+  getEffectiveLayerColorHex(e) {
+    const r = this.colorOverridesByIndex.get(e);
+    return r ? this.resolveDisplayHexForRgb(r, null, "line") : null;
+  }
+  resolveInsertRuntimeInstance(e, r) {
+    var i;
+    return r === void 0 ? this.insertRuntimeInstancesById.get(e) ?? null : ((i = this.insertRuntime) == null ? void 0 : i.instances.find(
+      (a) => a.instanceId === e && a.variantId === r
+    )) ?? null;
+  }
+  updateTextEntry(e, r) {
+    if (e < 0 || e >= this.textRenderablesByAppendOrder.length) return !1;
+    const i = this.textRenderablesByAppendOrder[e], a = this.textUserDataByAppendOrder[e];
+    if (!i || !a) return !1;
+    let s = !1;
+    return r.content !== void 0 && (i.text = r.content, a.t = r.content), r.x !== void 0 && (i.position.x = r.x, a.x = r.x, s = !0), r.y !== void 0 && (i.position.y = r.y, a.y = r.y, s = !0), r.rotation !== void 0 && (i.rotation.z = r.rotation * Math.PI / 180, a.r = r.rotation, s = !0), s && (this.commitTroikaTextTransform(i), this.markTextBatchBoundsDirty(this.textBatchByLayerIndex.get(a.li)), this.markTextBatchBoundsDirty(this.annotationTextBatchByLayerIndex.get(a.li))), i.sync(), this.notifyInternalChange(), !0;
+  }
+  updateInsertInstanceTransform(e, r) {
+    var f;
+    if (!this.insertInstanceTable) return !1;
+    const i = this.insertPresenterRecordKeysByInstanceId.get(e);
+    if (!i || i.size === 0) return !1;
+    const a = r.rotation * Math.PI / 180, s = Math.cos(a), o = Math.sin(a), c = r.scaleX * s, l = r.scaleX * o, u = -r.scaleY * o, d = r.scaleY * s;
+    let h = !0;
+    for (const b of i) {
+      const g = this.insertPresenterRecordsByKey.get(b);
+      if (!g) continue;
+      const C = {
+        ...g,
+        matA: c,
+        matB: l,
+        matC: u,
+        matD: d,
+        tx: r.tx,
+        ty: r.ty,
+        bbox: this.computeInsertPresenterWorldBBox(g.variantId, {
+          matA: c,
+          matB: l,
+          matC: u,
+          matD: d,
+          tx: r.tx,
+          ty: r.ty
+        }) ?? g.bbox
+      };
+      this.insertPresenterRecordsByKey.set(b, C), this.insertInstanceTable.replaceRecord(C) || (h = !1);
+    }
+    return h ? (f = this.viewportInstancePresenter) == null || f.invalidateQueryCache() : this.rebuildViewportInsertPresenter([...this.insertPresenterRecordsByKey.values()]), this.refreshDefaultInsertPresenterIfUnmanaged(), this.notifyInternalChange(), !0;
+  }
+  getEffectiveRenderQuality() {
+    return this.effectiveRenderQuality;
+  }
+  getLineRenderMode() {
+    return this.lineModeSwitchingEnabled ? this.effectiveRenderQuality : "width";
+  }
+  getLineModeSwitchingEnabled() {
+    return this.lineModeSwitchingEnabled;
+  }
+  getRenderQualityModeForDebug() {
+    return this.renderQualityMode;
+  }
+  getLineMemoryStats() {
+    const e = this.rebuildLineVariantStats();
+    return Object.freeze({
+      canonical: Object.freeze({ ...this.lineCanonicalMemoryStats }),
+      variants: Object.freeze({ ...e })
+    });
+  }
+  getColorPipelineStats() {
+    let e = 0, r = 0, i = 0, a = 0;
+    return this.traverse((s) => {
+      const o = s.geometry;
+      if (!o) return;
+      const c = o.userData.cadDisplaySourceColor, l = o.userData.cadDisplayColorRuns;
+      c instanceof Uint8Array ? (e += 1, r += c.byteLength) : l && l.length > 0 && (e += 1);
+      const u = o.getAttribute("color");
+      u instanceof U && ArrayBuffer.isView(u.array) && (i += u.array.byteLength, u.array instanceof Float32Array && (a += u.array.byteLength));
+    }), Object.freeze({
+      geometryCount: e,
+      sourceRgbBytes: r,
+      displayRgbBytes: i,
+      displayRgbFloat32Bytes: a,
+      ...this.colorRefreshStats
+    });
+  }
+  getInsertRuntime() {
+    return this.insertRuntime;
+  }
+  getTextRenderablesByAppendOrder() {
+    return [...this.textRenderablesByAppendOrder];
+  }
+  getSupplementalTextRenderablesByInstanceId() {
+    var i;
+    const e = (i = this.insertRuntime) == null ? void 0 : i.ownerInstanceIdByVariantOrdinal;
+    if (!e || this.annotationTextRecordsByOwnerKey.size === 0)
+      return /* @__PURE__ */ new Map();
+    const r = /* @__PURE__ */ new Map();
+    for (const [a, s] of this.annotationTextRecordsByOwnerKey) {
+      const o = e.get(a);
+      if (o === void 0) continue;
+      const c = r.get(o), l = s.map((u) => this.createInsertVisibilityHandleForAnnotationText(u));
+      c ? c.push(...l) : r.set(o, [...l]);
+    }
+    return r;
+  }
+  rebuildInsertRuntimeInstanceIndex() {
+    var e;
+    this.insertRuntimeInstancesById.clear();
+    for (const r of ((e = this.insertRuntime) == null ? void 0 : e.instances) ?? [])
+      this.insertRuntimeInstancesById.has(r.instanceId) || this.insertRuntimeInstancesById.set(r.instanceId, r);
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = !0;
+    const e = Ue.get(this);
+    Ue.delete(this), e == null || e(), this.resetContent(), this.rejectReadyOnce(new A("E_DISPOSED", "GeoNode disposed before completion"));
+  }
+  _initFromHeader(e) {
+    if (!this.disposed) {
+      this.readySettled && this.startReadyCycle(), this.resetContent(), this.bounds = be(e.bounds), this.meta = {
+        bounds: be(e.bounds),
+        entityCount: e.entityCount,
+        lineCount: e.lineCount,
+        fillCount: e.fillCount,
+        dotCount: e.dotCount,
+        textCount: e.textCount
+      }, this.metaRevision += 1, this.layerStateRevision += 1, this.layerBlockUsages = e.layerBlockUsages ?? /* @__PURE__ */ new Map(), this.insertRuntime = e.insertRuntime ?? null, this.rebuildInsertRuntimeInstanceIndex();
+      for (const r of e.layers) {
+        const i = r.index, a = {
+          ...r,
+          visible: r.visible ?? !0,
+          color: P(r.color)
+        };
+        this.layerOrder.push(i), this.layerStatesByIndex.set(i, a), this.originalLayerColorsByIndex.set(i, P(a.color));
+        const s = this.ensureLayerGroup(i, a.name, a.visible);
+        s.name = a.name, s.visible = a.visible;
+      }
+      this.notifyInternalChange();
+    }
+  }
+  _appendChunk(e) {
+    if (!this.disposed) {
+      if (e.kind === "text") {
+        this._appendTextChunks([e.payload]);
+        return;
+      }
+      this._appendPreparedGeometryChunk(
+        e.kind,
+        de(e.payload, {
+          markLinePositionXy: e.kind === "line"
+        })
+      );
+    }
+  }
+  _appendPreparedGeometryChunk(e, r) {
+    if (!(this.disposed || r.length === 0)) {
+      for (const i of r) {
+        if (i.count <= 0) continue;
+        const a = this.getOrCreateKindGroup(i.layerIndex, e), s = e === "line" ? this.createRenderableLineChunk(
+          a,
+          i.layerIndex,
+          i.pos,
+          i.col,
+          i.count,
+          i.bbox,
+          i.linePositionKind,
+          i.colorRuns,
+          i.positionItemSize,
+          i.lineweightPx
+        ) : this.createRenderableChunk(
+          e,
+          i.layerIndex,
+          i.pos,
+          i.col,
+          i.count,
+          i.bbox,
+          i.colorRuns
+        );
+        a.add(s);
+      }
+      this.notifyInternalChange();
+    }
+  }
+  _appendTextChunks(e) {
+    if (!(this.disposed || e.length === 0)) {
+      for (const r of e)
+        this.appendTextChunk(r);
+      this.notifyInternalChange();
+    }
+  }
+  _installInsertModel(e) {
+    this.disposed || (this.clearViewportInsertPresenter(), this.mergeInsertModelPayload(e), this.rebuildViewportInsertPresenterFromAccumulatedModel(), this.readySettled && this.refreshDefaultInsertPresenterIfUnmanaged(), this.notifyInternalChange());
+  }
+  _appendInsertModel(e) {
+    if (this.disposed) return;
+    const r = this.mergeInsertModelPayload(e);
+    if (!this.blockGeometryRegistry || !this.insertInstanceTable || !this.viewportInstancePresenter || r.replacedRecord)
+      this.rebuildViewportInsertPresenterFromAccumulatedModel();
+    else {
+      const i = this.blockGeometryRegistry.appendVariants(r.variantInputs);
+      for (const a of i)
+        this.viewportInstancePresenter.appendVariant(a);
+      this.insertInstanceTable.appendRecords(r.records), (i.length > 0 || r.records.length > 0 || r.replacedVariant) && this.viewportInstancePresenter.invalidateQueryCache();
+    }
+    this.readySettled && this.refreshDefaultInsertPresenterIfUnmanaged(), this.notifyInternalChange();
+  }
+  mergeInsertModelPayload(e) {
+    const r = [], i = this.createInsertInstanceRecords(e.instances);
+    let a = !1, s = !1;
+    for (const o of e.variants) {
+      const c = this.createVariantGeometryInput(o);
+      this.insertPresenterVariantInputs.has(o.variantId) && (a = !0), this.insertPresenterVariantInputs.set(o.variantId, c), r.push(c);
+    }
+    for (const o of i) {
+      const c = Ma(o);
+      this.insertPresenterRecordsByKey.has(c) && (s = !0), this.insertPresenterRecordsByKey.set(c, o);
+      let l = this.insertPresenterRecordKeysByInstanceId.get(o.instanceId);
+      l || (l = /* @__PURE__ */ new Set(), this.insertPresenterRecordKeysByInstanceId.set(o.instanceId, l)), l.add(c);
+    }
+    return { variantInputs: r, records: i, replacedVariant: a, replacedRecord: s };
+  }
+  createVariantGeometryInput(e) {
+    return {
+      variantId: e.variantId,
+      line: e.line.map((r) => ({
+        pos: r.pos,
+        col: r.col,
+        count: r.count,
+        layerIndex: r.layerIndex,
+        ...r.lineweightPx === void 0 ? {} : { lineweightPx: r.lineweightPx },
+        bbox: r.bbox
+      })),
+      fill: e.fill.map((r) => ({
+        pos: r.pos,
+        col: r.col,
+        count: r.count,
+        layerIndex: r.layerIndex,
+        bbox: r.bbox
+      })),
+      dot: e.dot.map((r) => ({
+        pos: r.pos,
+        col: r.col,
+        count: r.count,
+        layerIndex: r.layerIndex,
+        bbox: r.bbox
+      }))
+    };
+  }
+  rebuildViewportInsertPresenterFromAccumulatedModel() {
+    var e, r;
+    (e = this.viewportInstancePresenter) == null || e.dispose(), this.viewportInstancePresenter = null, this.insertInstanceTable = null, (r = this.blockGeometryRegistry) == null || r.dispose(), this.blockGeometryRegistry = fa([...this.insertPresenterVariantInputs.values()]), this.rebuildViewportInsertPresenter([...this.insertPresenterRecordsByKey.values()]);
+  }
+  rebuildViewportInsertPresenter(e) {
+    var r;
+    this.blockGeometryRegistry && (this.insertInstanceTable = ma(e), (r = this.viewportInstancePresenter) == null || r.dispose(), this.viewportInstancePresenter = new xa({
+      registry: this.blockGeometryRegistry,
+      table: this.insertInstanceTable,
+      materialFactory: (i) => this.createInsertPresenterMaterial(i),
+      initialCapacity: 1024,
+      marginRatio: 0.2
+    }), this.viewportInstancePresenter.attach(this));
+  }
+  computeInsertPresenterWorldBBox(e, r) {
+    var o;
+    const i = (o = this.blockGeometryRegistry) == null ? void 0 : o.getVariant(e);
+    if (!i) return null;
+    let a = null;
+    for (const c of i.byKind.values())
+      for (const l of c)
+        a = Le(a, l.bbox);
+    if (!a) return null;
+    const s = cr(a, r);
+    return an(s) ? s : null;
+  }
+  _debugHasInsertPresenter() {
+    return this.viewportInstancePresenter !== null;
+  }
+  _debugInsertInstanceTableSize() {
+    var e;
+    return ((e = this.insertInstanceTable) == null ? void 0 : e.size()) ?? 0;
+  }
+  appendAnnotationOverlay(e) {
+    this.disposed || (this.appendAnnotationPreparedGeometryChunk(
+      "line",
+      de(e.line, {
+        markLinePositionXy: !0
+      })
+    ), this.appendAnnotationPreparedGeometryChunk("fill", de(e.fill)), this.appendAnnotationPreparedGeometryChunk("dot", de(e.dot)), this.appendAnnotationTextChunks(e.texts), this.notifyInternalChange());
+  }
+  appendExternalVariantDelta(e) {
+    if (!this.disposed) {
+      this.appendExternalVariantDeltaHeader(e.header);
+      for (const r of e.chunks)
+        this._appendChunk(r);
+      this.notifyInternalChange();
+    }
+  }
+  appendExternalVariantDeltaHeader(e) {
+    if (this.disposed) return;
+    const r = this.meta.textCount, i = Ua(this.bounds, e.bounds);
+    this.bounds = i, this.meta = {
+      bounds: be(i),
+      entityCount: this.meta.entityCount + e.entityCount,
+      lineCount: this.meta.lineCount + e.lineCount,
+      fillCount: this.meta.fillCount + e.fillCount,
+      dotCount: this.meta.dotCount + e.dotCount,
+      textCount: this.meta.textCount + e.textCount
+    }, this.metaRevision += 1, this.layerBlockUsages = Ha(this.layerBlockUsages, e.layerBlockUsages), this.insertRuntime = Xa(this.insertRuntime, e.insertRuntime, r), this.rebuildInsertRuntimeInstanceIndex(), this.updateAutoQualityContext({
+      visibleVertexCount: this.meta.lineCount + this.meta.fillCount + this.meta.dotCount,
+      zoom: this.autoQualityContext.zoom
+    }), this.notifyInternalChange();
+  }
+  _finalize() {
+    if (this.disposed) {
+      this.rejectReadyOnce(new A("E_DISPOSED", "GeoNode disposed before completion"));
+      return;
+    }
+    this.compactGeometryByLayer(), this.refreshDefaultInsertPresenterIfUnmanaged(), this.resolveReadyOnce();
+  }
+  async _finalizeIncrementally(e, r = Qn, i = {}) {
+    if (this.disposed) {
+      this.rejectReadyOnce(new A("E_DISPOSED", "GeoNode disposed before completion"));
+      return;
+    }
+    const a = this.contentGeneration;
+    await this.compactGeometryByLayerIncrementally(r, e), !(this.disposed || a !== this.contentGeneration) && (this.refreshDefaultInsertPresenterIfUnmanaged(), this.resolveReadyOnce());
+  }
+  _fail(e) {
+    if (this.disposed) {
+      this.rejectReadyOnce(new A("E_DISPOSED", "GeoNode disposed before completion"));
+      return;
+    }
+    this.rejectReadyOnce(e);
+  }
+  _setInternalChangeHook(e) {
+    this.internalChangeHook = e;
+  }
+  _setViewportSize(e, r) {
+    var i;
+    this.lineResolution = {
+      width: Math.max(1, Math.floor(e) || 1),
+      height: Math.max(1, Math.floor(r) || 1)
+    };
+    for (const a of this.lineChunkRecords)
+      (i = a.fatMaterial) == null || i.updateResolution(this.lineResolution.width, this.lineResolution.height);
+    for (const a of this.worldSizedPointUniforms)
+      a.uGeoPointViewportHeight.value = this.lineResolution.height;
+  }
+  createPointMaterial(e, r, i) {
+    var u;
+    const a = ((u = this.layerStatesByIndex.get(e)) == null ? void 0 : u.lw_px) ?? 1, s = this.resolvePointWorldSize(Math.max(a * 1.5, 3)), o = new Dt({
+      vertexColors: !0,
+      size: 1,
+      sizeAttenuation: !1,
+      depthTest: !1,
+      depthWrite: !1
+    }), c = es(o, {
+      pointWorldSize: s,
+      viewportHeight: this.lineResolution.height
+    });
+    this.worldSizedPointUniforms.add(c);
+    const l = o.dispose.bind(o);
+    return o.dispose = () => {
+      this.worldSizedPointUniforms.delete(c), l();
+    }, this.applyLayerColorState(o, r, i), o;
+  }
+  resolvePointWorldSize(e) {
+    return !Number.isFinite(e) || e <= 0 ? 1 : e * Da;
+  }
+  appendTextChunk(e) {
+    const r = this.getOrCreateTextBatch(e.li), i = this.createRenderableTextChunk(e);
+    this.applyColorToTextRenderable(i, this.colorOverridesByIndex.get(e.li) ?? null), r.add(i), this.markTextBatchBoundsDirty(r);
+    const a = this.textRenderablesByLayerIndex.get(e.li) ?? [];
+    a.push(i), this.textRenderablesByLayerIndex.set(e.li, a), this.textRenderablesByAppendOrder.push(i);
+    const s = Number(r.userData.textCount || 0);
+    r.userData.textCount = s + 1, this.textUserDataByAppendOrder.push({ ...i.userData.text, c: P(i.userData.text.c) }), typeof globalThis.self < "u" && this.scheduleTextBatchSync(r);
+  }
+  appendAnnotationTextChunks(e) {
+    if (!(this.disposed || e.length === 0))
+      for (const r of e)
+        this.appendAnnotationTextChunk(r);
+  }
+  appendAnnotationTextChunk(e) {
+    const r = this.getOrCreateAnnotationTextBatch(e.li), i = this.createRenderableTextChunk(e);
+    i.userData.annotationOverlay = !0, i.visible = this.annotationOverlayVisible, this.applyColorToTextRenderable(i, this.colorOverridesByIndex.get(e.li) ?? null), r.add(i), this.markTextBatchBoundsDirty(r);
+    const a = this.annotationTextRenderablesByLayerIndex.get(e.li) ?? [];
+    a.push(i), this.annotationTextRenderablesByLayerIndex.set(e.li, a);
+    const s = Ie.getTextOwnerKey(e), o = {
+      renderable: i,
+      layerIndex: e.li,
+      ownerKey: s,
+      insertVisible: !0
+    }, c = this.annotationTextRecordsByLayerIndex.get(e.li) ?? [];
+    if (c.push(o), this.annotationTextRecordsByLayerIndex.set(e.li, c), s) {
+      const u = this.annotationTextRecordsByOwnerKey.get(s) ?? [];
+      u.push(o), this.annotationTextRecordsByOwnerKey.set(s, u);
+    }
+    this.applyAnnotationTextRenderableVisibility(o);
+    const l = Number(r.userData.textCount || 0);
+    r.userData.textCount = l + 1, this.textUserDataByAppendOrder.push({ ...i.userData.text, c: P(i.userData.text.c) }), typeof globalThis.self < "u" && this.scheduleTextBatchSync(r);
+  }
+  getOrCreateTextBatch(e) {
+    const r = this.textBatchByLayerIndex.get(e);
+    if (r) return r;
+    const i = Gt, a = new i();
+    return this.configureTextBatchForStaticBounds(a), a.name = "text-batch", a.renderOrder = 3, a.depthOffset = -0.1, a.userData.kind = "text-batch", a.userData.layerIndex = e, a.userData.textCount = 0, typeof globalThis.self < "u" && a.addEventListener("synccomplete", () => {
+      this.markTextBatchBoundsClean(a), this.notifyInternalChange();
+    }), this.getOrCreateKindGroup(e, "text").add(a), this.textBatchByLayerIndex.set(e, a), a;
+  }
+  getOrCreateAnnotationTextBatch(e) {
+    const r = this.annotationTextBatchByLayerIndex.get(e);
+    if (r) return r;
+    const i = Gt, a = new i();
+    return this.configureTextBatchForStaticBounds(a), a.name = "annotation-text-batch", a.renderOrder = 4, a.depthOffset = -0.2, a.visible = this.annotationOverlayVisible && this.isLayerVisible(e), a.userData.kind = "text-batch", a.userData.layerIndex = e, a.userData.textCount = 0, a.userData.annotationOverlay = !0, typeof globalThis.self < "u" && a.addEventListener("synccomplete", () => {
+      this.markTextBatchBoundsClean(a), this.notifyInternalChange();
+    }), this.getOrCreateAnnotationKindGroup(e, "text").add(a), this.annotationTextBatchByLayerIndex.set(e, a), a;
+  }
+  configureTextBatchForStaticBounds(e) {
+    const r = e.userData;
+    r[sn] !== !0 && (e.matrixAutoUpdate = !1, e.updateMatrix(), e.updateMatrixWorld = function(a) {
+      var s;
+      In.prototype.updateMatrixWorld.call(this, a), this.userData[Pe] === !0 && ((s = this.updateBounds) == null || s.call(this), this.userData[Pe] = !1);
+    }, r[sn] = !0, this.markTextBatchBoundsClean(e));
+  }
+  markTextBatchBoundsDirty(e) {
+    e && (e.userData[Pe] = !0);
+  }
+  markTextBatchBoundsClean(e) {
+    e && (e.userData[Pe] = !1);
+  }
+  scheduleTextBatchSync(e) {
+    this.pendingTextBatchSync.add(e), !this.textBatchSyncScheduled && (this.textBatchSyncScheduled = !0, Br(() => {
+      if (this.textBatchSyncScheduled = !1, this.disposed) {
+        this.pendingTextBatchSync.clear();
+        return;
+      }
+      const r = Array.from(this.pendingTextBatchSync);
+      this.pendingTextBatchSync.clear();
+      for (const i of r)
+        i.parent && i.sync();
+    }));
+  }
+  createRenderableChunk(e, r, i, a, s, o, c) {
+    const l = new xt();
+    l.setAttribute("position", new Cn(i, 3)), this.registerGeometryDisplayColors(
+      l,
+      a,
+      r,
+      e === "fill" ? "fill" : e === "dot" ? "dot" : "line",
+      c
+    );
+    const u = this.colorOverridesByIndex.get(r) ?? null;
+    let d;
+    if (e === "line") {
+      const f = new Ft({ vertexColors: !0 });
+      this.applyLayerColorState(f, u, e);
+      const b = new pt(l, f);
+      b.renderOrder = 1, d = b;
+    } else if (e === "fill") {
+      const f = new Ot({
+        vertexColors: !0,
+        side: st,
+        depthWrite: !1
+      });
+      this.applyLayerColorState(f, u, e);
+      const b = new gt(l, f);
+      b.renderOrder = 0, d = b;
+    } else {
+      const f = this.createPointMaterial(r, u, e), b = new wn(l, f);
+      b.renderOrder = 2, d = b;
+    }
+    d.name = `${e}-chunk`, d.userData.kind = e, d.userData.layerIndex = r, d.userData.vertexCount = s;
+    const h = o === void 0 ? Me(i, Math.floor(i.length / 3), 3) : o;
+    return d.userData.bbox = h, this.nonLineChunkStats.push({ layerIndex: r, vertexCount: s, bbox: h }), d;
+  }
+  createRenderableLineChunk(e, r, i, a, s, o, c, l, u = 3, d) {
+    const h = this.makeLineChunkRecord(
+      e,
+      r,
+      i,
+      a,
+      s,
+      o,
+      c,
+      l,
+      u,
+      d
+    );
+    return this.registerLineChunkRecord(h), h.renderable;
+  }
+  makeLineChunkRecord(e, r, i, a, s, o, c, l, u = 3, d) {
+    const h = this.resolveLineweightPx(r, d), f = s < 2 || s % 2 !== 0 || h <= 1, b = un(l, s), g = c === "xy-zero-z" || u === 2 ? Ba(i, s, u) : Ra(i, s), C = o === void 0 ? Me(i, s, u) : o, v = this.resolveInitialLineChunkVariant(r, s, f, d), x = this.buildLineRenderableViews(
+      r,
+      g,
+      a,
+      s,
+      f,
+      C,
+      b,
+      d
+    ), I = v === "fat" && x.fatRenderable ? x.fatRenderable : x.thinRenderable, V = {
+      layerIndex: r,
+      ...d === void 0 ? {} : { lineweightPx: d },
+      parent: e,
+      position: g,
+      canonicalMemoryStats: Va(g, a, s),
+      col: a,
+      colorRuns: b,
+      vertexCount: s,
+      bbox: C,
+      forceThin: f,
+      activeVariant: v,
+      renderable: I,
+      thinRenderable: x.thinRenderable,
+      fatRenderable: x.fatRenderable,
+      thinMaterial: x.thinMaterial,
+      fatMaterial: x.fatMaterial
+    };
+    return this.installSharedLineColorTargetMarkers(V), this.applyInitialLineDisplayColors(V), V;
+  }
+  registerLineChunkRecord(e) {
+    this.lineChunkRecords.push(e), this.addLineCanonicalStats(e);
+  }
+  addLineCanonicalStats(e) {
+    this.lineCanonicalMemoryStats = ka(
+      this.lineCanonicalMemoryStats,
+      e.canonicalMemoryStats
+    );
+  }
+  subtractLineCanonicalStats(e) {
+    this.lineCanonicalMemoryStats = Aa(
+      this.lineCanonicalMemoryStats,
+      e.canonicalMemoryStats
+    );
+  }
+  rebuildLineVariantStats() {
+    const e = za();
+    for (const r of this.lineChunkRecords)
+      r.activeVariant === "thin" && (e.activeThinCount += 1), r.activeVariant === "fat" && (e.activeFatCount += 1), r.thinRenderable && r.thinRenderable !== r.renderable && (e.cachedThinCount += 1), r.fatRenderable && r.fatRenderable !== r.renderable && (e.cachedFatCount += 1);
+    return e;
+  }
+  resolveLineChunkVariant(e) {
+    const r = this.resolveLineweightPx(e.layerIndex, e.lineweightPx);
+    return this.shouldUseThinLineVariant(r, e.vertexCount, e.forceThin) ? "thin" : "fat";
+  }
+  resolveInitialLineChunkVariant(e, r, i, a) {
+    const s = this.resolveLineweightPx(e, a);
+    return this.shouldUseThinLineVariant(s, r, i) ? "thin" : "fat";
+  }
+  resolveLineweightPx(e, r) {
+    var i;
+    return r ?? ((i = this.layerStatesByIndex.get(e)) == null ? void 0 : i.lw_px) ?? 1;
+  }
+  shouldUseThinLineVariant(e, r, i) {
+    return i || r < 2 || r % 2 !== 0 ? !0 : this.lineModeSwitchingEnabled ? this.effectiveRenderQuality === "stress" && e < _t : e < _t;
+  }
+  buildLineRenderableViews(e, r, i, a, s, o, c, l) {
+    const u = this.resolveLineweightPx(e, l), d = r.kind === "xy" ? r.xy : r.xyz, h = r.kind === "xy" ? 2 : 3, f = o ?? Me(d, a, h) ?? {
+      minX: 0,
+      minY: 0,
+      maxX: 0,
+      maxY: 0
+    }, b = i.slice(), g = sa({
+      position: d,
+      positionItemSize: h,
+      color: i,
+      vertexCount: a,
+      bbox: f
+    });
+    this.finalizeCadLineRenderable(g, e, a, f, i, b, c);
+    let C = null;
+    return !s && a >= 2 && a % 2 === 0 && (C = oa({
+      position: d,
+      positionItemSize: h,
+      color: i,
+      vertexCount: a,
+      linewidthPx: u,
+      resolution: new gn(this.lineResolution.width, this.lineResolution.height),
+      bbox: f
+    }), this.finalizeCadLineRenderable(C, e, a, f, i, b, c)), {
+      thinRenderable: g,
+      fatRenderable: C,
+      thinMaterial: g.material,
+      fatMaterial: (C == null ? void 0 : C.material) ?? null
+    };
+  }
+  finalizeCadLineRenderable(e, r, i, a, s, o, c) {
+    e.name = "line-chunk", e.renderOrder = 1, e.userData.kind = "line", e.userData.layerIndex = r, e.userData.vertexCount = i, e.userData.bbox = a;
+    const l = e.geometry;
+    l.userData.cadDisplayColorTarget = {
+      array: s,
+      markNeedsUpdate: () => Je(l)
+    }, this.installGeometryDisplayColorMetadata(l, o, r, "line", c);
+    const u = this.colorOverridesByIndex.get(r) ?? null;
+    this.applyLayerColorState(e.material, u, "line"), e.material.needsUpdate = !0;
+  }
+  installSharedLineColorTargetMarkers(e) {
+    const r = () => {
+      Je(e.thinRenderable.geometry), e.fatRenderable && Je(e.fatRenderable.geometry);
+    }, i = (a) => {
+      if (!a) return;
+      const s = a.geometry;
+      s.userData.cadDisplayColorTarget = {
+        array: e.col,
+        markNeedsUpdate: r
+      };
+    };
+    i(e.thinRenderable), i(e.fatRenderable);
+  }
+  applyInitialLineDisplayColors(e) {
+    const r = e.renderable;
+    this.applyDisplayColorsToGeometry(r.geometry);
+  }
+  createRenderableTextChunk(e) {
+    const r = pr, i = this.resolveTextFont(e.t), a = new r();
+    a.text = i.text, a.fontSize = e.h, a.position.set(e.x, e.y, 0), a.rotation.z = (e.r || 0) * Math.PI / 180, a.color = this.resolveDisplayHexForRgb(e.c, e.li, "text"), a.anchorX = Ie.resolveTextAnchorX(e.ha), a.anchorY = Ie.resolveTextAnchorY(e.va), i.fontUrl && (a.font = i.fontUrl), e.w && (a.maxWidth = e.w), e.lh && (a.lineHeight = e.lh);
+    const s = e.wf || 1;
+    return a.scale.x = (e.mx ? -1 : 1) * s, e.my && (a.scale.y = -1), this.commitTroikaTextTransform(a), a.name = "text-chunk", a.userData.kind = "text", a.userData.layerIndex = e.li, a.userData.text = { ...e, c: P(e.c) }, a.userData.renderedText = i.text, a.userData.fontKind = i.kind ?? "default", a.userData.replacedUnsupportedText = i.replacedUnsupported === !0, a;
+  }
+  commitTroikaTextTransform(e) {
+    e.matrixAutoUpdate = !1, e.updateMatrix();
+  }
+  getOrCreateKindGroup(e, r) {
+    const i = this.ensureLayerGroup(e), a = i.children.find((o) => o instanceof j && o.name === r);
+    if (a) return a;
+    const s = new j();
+    return s.name = r, i.add(s), s;
+  }
+  appendAnnotationPreparedGeometryChunk(e, r) {
+    if (!(this.disposed || r.length === 0))
+      for (const i of r) {
+        if (i.count <= 0) continue;
+        const a = this.getOrCreateAnnotationKindGroup(i.layerIndex, e), s = e === "line" ? this.createRenderableLineChunk(
+          a,
+          i.layerIndex,
+          i.pos,
+          i.col,
+          i.count,
+          i.bbox,
+          i.linePositionKind,
+          i.colorRuns,
+          i.positionItemSize,
+          i.lineweightPx
+        ) : this.createRenderableChunk(
+          e,
+          i.layerIndex,
+          i.pos,
+          i.col,
+          i.count,
+          i.bbox,
+          i.colorRuns
+        );
+        s.userData.annotationOverlay = !0, s.visible = this.annotationOverlayVisible, a.add(s);
+      }
+  }
+  getOrCreateAnnotationKindGroup(e, r) {
+    const i = this.getOrCreateAnnotationOverlayGroup(e), a = r === "text" ? "annotation-text" : `annotation-${r}`, s = i.children.find(
+      (c) => c instanceof j && c.name === a
+    );
+    if (s) return s;
+    const o = new j();
+    return o.name = a, o.visible = this.annotationOverlayVisible && this.isLayerVisible(e), o.userData.annotationOverlay = !0, o.userData.kind = r, i.add(o), o;
+  }
+  getOrCreateAnnotationOverlayGroup(e) {
+    const r = this.annotationOverlayGroupsByLayerIndex.get(e);
+    if (r) return r;
+    const i = this.ensureLayerGroup(e), a = new j();
+    return a.name = "annotation-overlay", a.visible = this.annotationOverlayVisible && this.isLayerVisible(e), a.userData.annotationOverlay = !0, a.userData.layerIndex = e, this.annotationOverlayGroupsByLayerIndex.set(e, a), i.add(a), a;
+  }
+  applyAnnotationOverlayVisibility(e) {
+    e.traverse((r) => {
+      const i = Number(r.userData.layerIndex ?? e.userData.layerIndex), a = Number.isInteger(i) ? this.isLayerVisible(i) : !0;
+      r.visible = this.annotationOverlayVisible && a;
+    });
+    for (const r of this.annotationTextRecordsByLayerIndex.values())
+      for (const i of r)
+        this.applyAnnotationTextRenderableVisibility(i);
+  }
+  createInsertVisibilityHandleForAnnotationText(e) {
+    const r = this;
+    return {
+      get visible() {
+        return e.insertVisible;
+      },
+      set visible(i) {
+        e.insertVisible = i, r.applyAnnotationTextRenderableVisibility(e);
+      }
+    };
+  }
+  applyAnnotationTextRenderableVisibility(e) {
+    e.renderable.visible = this.annotationOverlayVisible && this.isLayerVisible(e.layerIndex) && e.insertVisible;
+  }
+  refreshAnnotationTextVisibilityForLayer(e) {
+    for (const i of this.annotationTextRecordsByLayerIndex.get(e) ?? [])
+      this.applyAnnotationTextRenderableVisibility(i);
+    const r = this.annotationOverlayGroupsByLayerIndex.get(e);
+    r && this.applyAnnotationOverlayVisibility(r);
+  }
+  isLayerVisible(e) {
+    var r;
+    return ((r = this.layerStatesByIndex.get(e)) == null ? void 0 : r.visible) ?? !0;
+  }
+  ensureLayerGroup(e, r, i = !0) {
+    var o;
+    const a = this.layerGroupsByIndex.get(e);
+    if (a) return a;
+    const s = new j();
+    if (s.name = r ?? `Layer ${e}`, s.visible = ((o = this.layerStatesByIndex.get(e)) == null ? void 0 : o.visible) ?? i, s.userData.layerIndex = e, this.layerGroupsByIndex.set(e, s), this.add(s), !this.layerStatesByIndex.has(e)) {
+      this.layerOrder.push(e);
+      const c = [255, 255, 255];
+      this.layerStatesByIndex.set(e, {
+        index: e,
+        name: s.name,
+        color: P(c),
+        lw_px: 1,
+        visible: i
+      }), this.originalLayerColorsByIndex.set(e, P(c)), this.layerStateRevision += 1;
+    }
+    return s;
+  }
+  compactGeometryByLayer() {
+    this.compactLineChunksPerLayer(), this.compactNonLineChunksPerLayer("fill"), this.compactNonLineChunksPerLayer("dot"), this.rebuildNonLineChunkStats(), this.notifyInternalChange();
+  }
+  async compactGeometryByLayerIncrementally(e, r) {
+    const i = [];
+    for (const a of this.layerOrder)
+      i.push(
+        {
+          label: `line:${a}`,
+          run: () => this.compactLineChunksForSingleLayer(a)
+        },
+        {
+          label: `fill:${a}`,
+          run: () => this.compactNonLineChunksForSingleLayer(a, "fill")
+        },
+        {
+          label: `dot:${a}`,
+          run: () => this.compactNonLineChunksForSingleLayer(a, "dot")
+        }
+      );
+    await Ca(i, {
+      opsPerPass: e,
+      frameBudgetMs: qn,
+      onYield: r
+    }), this.rebuildNonLineChunkStats(), this.notifyInternalChange();
+  }
+  compactLineChunksPerLayer() {
+    for (const e of this.layerOrder)
+      this.compactLineChunksForSingleLayer(e);
+  }
+  compactLineChunksForSingleLayer(e) {
+    const r = this.buildLineCompactionGroups(e);
+    if (r.length === 0)
+      return !1;
+    const i = /* @__PURE__ */ new Set(), a = [];
+    for (const o of r) {
+      let c = 0, l = null;
+      for (const x of o.records)
+        c += x.vertexCount, l = Le(l, x.bbox);
+      const u = o.canonicalKind === "xy" ? 2 : 3, d = new Float32Array(c * u), h = new Uint8Array(c * 3), f = [];
+      let b = !0, g = 0;
+      for (const x of o.records)
+        Ea(
+          x.position,
+          x.vertexCount,
+          d,
+          g,
+          u
+        ), h.set(x.col, g * 3), x.colorRuns && x.colorRuns.length > 0 ? cn(f, x.colorRuns, g) : b = !1, g += x.vertexCount;
+      for (const x of o.records)
+        i.add(x), this.subtractLineCanonicalStats(x), this.disposeLineChunkRecord(x);
+      const C = b ? ft(f) : void 0, v = this.makeLineChunkRecord(
+        o.parent,
+        e,
+        d,
+        h,
+        c,
+        l,
+        u === 2 ? "xy-zero-z" : void 0,
+        C,
+        u,
+        o.lineweightPx
+      );
+      o.parent.add(v.renderable), this.addLineCanonicalStats(v), a.push(v);
+    }
+    const s = this.lineChunkRecords.filter((o) => !i.has(o));
+    return this.lineChunkRecords.length = 0, this.lineChunkRecords.push(...s, ...a), !0;
+  }
+  buildLineCompactionGroups(e) {
+    const r = /* @__PURE__ */ new Map();
+    for (const i of this.lineChunkRecords) {
+      if (i.layerIndex !== e) continue;
+      const a = `${i.parent.id}:${i.position.kind}:${i.lineweightPx ?? ""}`;
+      let s = r.get(a);
+      s || (s = {
+        layerIndex: e,
+        ...i.lineweightPx === void 0 ? {} : { lineweightPx: i.lineweightPx },
+        parent: i.parent,
+        canonicalKind: i.position.kind,
+        records: []
+      }, r.set(a, s)), s.records.push(i);
+    }
+    return [...r.values()].filter((i) => i.records.length > 1);
+  }
+  compactNonLineChunksPerLayer(e) {
+    for (const r of this.layerOrder)
+      this.compactNonLineChunksForSingleLayer(r, e);
+  }
+  compactNonLineChunksForSingleLayer(e, r) {
+    var v, x;
+    const i = this.findKindGroup(e, r);
+    if (!i || i.children.length <= 1)
+      return !1;
+    const a = [...i.children];
+    if (a.length <= 1)
+      return !1;
+    let s = 0, o = null;
+    const c = [], l = [], u = [];
+    let d = !0;
+    for (const I of a) {
+      const M = I.geometry;
+      if (!M) continue;
+      const Q = M.getAttribute("position"), q = M.getAttribute("color");
+      if (!(Q instanceof U) || !(q instanceof U) || !(Q.array instanceof Float32Array)) continue;
+      const W = Number(((v = I.userData) == null ? void 0 : v.vertexCount) || 0);
+      if (W <= 0) continue;
+      const N = M.userData.cadDisplaySourceColor, G = M.userData.cadDisplayColorRuns;
+      G && G.length > 0 ? cn(u, G, s) : d = !1, s += W, c.push(Q.array), l.push(N instanceof Uint8Array ? N : Oi(q)), o = Le(o, ((x = I.userData) == null ? void 0 : x.bbox) ?? null);
+    }
+    for (const I of a)
+      i.remove(I), at(I);
+    if (s <= 0)
+      return !1;
+    const h = new Float32Array(s * 3), f = new Uint8Array(s * 3);
+    let b = 0;
+    for (let I = 0; I < c.length; I += 1) {
+      const V = Math.floor(c[I].length / 3), M = b * 3;
+      h.set(c[I], M), f.set(l[I], M), b += V;
+    }
+    const g = d ? ft(u) : void 0, C = this.createRenderableChunk(
+      r,
+      e,
+      h,
+      f,
+      s,
+      o,
+      g
+    );
+    return i.add(C), !0;
+  }
+  rebuildNonLineChunkStats() {
+    var r, i;
+    this.nonLineChunkStats.length = 0;
+    const e = ["fill", "dot"];
+    for (const a of e)
+      for (const s of this.layerOrder) {
+        const o = this.findKindGroup(s, a);
+        if (o)
+          for (const c of o.children) {
+            const l = Number(((r = c.userData) == null ? void 0 : r.vertexCount) || 0), u = ((i = c.userData) == null ? void 0 : i.bbox) ?? null;
+            this.nonLineChunkStats.push({ layerIndex: s, vertexCount: l, bbox: u });
+          }
+      }
+  }
+  findKindGroup(e, r) {
+    const i = this.layerGroupsByIndex.get(e);
+    return i ? i.children.find((s) => s instanceof j && s.name === r) ?? null : null;
+  }
+  disposeLineChunkRecord(e) {
+    const r = [e.renderable, e.thinRenderable, e.fatRenderable], i = /* @__PURE__ */ new Set();
+    for (const a of r)
+      !a || i.has(a) || (i.add(a), a.parent && a.parent.remove(a), at(a));
+    e.fatRenderable = null, e.fatMaterial = null;
+  }
+  applyLayerColorState(e, r, i = "line") {
+    r ? (e.vertexColors = !1, e.color.setHex(this.resolveDisplayHexForRgb(r, null, i))) : (e.vertexColors = !0, e.color.setHex(16777215));
+    const a = Zt(
+      { kind: "none" },
+      {
+        theme: this.displayThemeName,
+        elementKind: i,
+        enhanceContrast: this.displayContrastEnhancement
+      }
+    ).opacity;
+    e.opacity = a, e.transparent = a < 1;
+  }
+  refreshDisplayColors() {
+    this.traverse((e) => {
+      var u, d;
+      const r = (u = e.userData) == null ? void 0 : u.kind;
+      if (r === "text" || r === "text-batch") return;
+      const i = e.geometry;
+      i && this.applyDisplayColorsToGeometry(i);
+      const a = e.material, s = Number.isInteger((d = e.userData) == null ? void 0 : d.layerIndex) ? Number(e.userData.layerIndex) : null, o = s === null ? null : this.colorOverridesByIndex.get(s) ?? null, c = this.displayElementKindForObject(e), l = Array.isArray(a) ? a : a ? [a] : [];
+      for (const h of l)
+        it(h) && (this.applyLayerColorState(h, o, c), h.needsUpdate = !0);
+    });
+    for (const e of this.layerOrder)
+      this.applyLayerTextColors(e, this.colorOverridesByIndex.get(e) ?? null);
+  }
+  registerGeometryDisplayColors(e, r, i, a, s) {
+    const o = this.installGeometryDisplayColorMetadata(
+      e,
+      r,
+      i,
+      a,
+      s
+    );
+    this.applyDisplayColorsToGeometry(o);
+  }
+  installGeometryDisplayColorMetadata(e, r, i, a, s) {
+    const o = e, c = Math.floor(r.length / 3), l = un(s, c);
+    return l ? (delete o.userData.cadDisplaySourceColor, o.userData.cadDisplayColorRuns = l) : (o.userData.cadDisplaySourceColor = On(r).slice(), delete o.userData.cadDisplayColorRuns), o.userData.cadDisplayVertexCount = c, o.userData.cadDisplayLayerIndex = i, o.userData.cadDisplayElementKind = a, o;
+  }
+  applyDisplayColorsToGeometry(e) {
+    const r = e, i = r.userData.cadDisplaySourceColor, a = r.userData.cadDisplayColorRuns, s = Number(r.userData.cadDisplayVertexCount ?? 0), o = Number(r.userData.cadDisplayLayerIndex ?? 0), c = r.userData.cadDisplayElementKind ?? "line", l = a && a.length > 0 && ze(s, a), u = r.userData.cadDisplayColorTarget;
+    if (u) {
+      if (l) {
+        const f = s * 3;
+        if (u.array.length !== f)
+          throw new Error(
+            `CAD display color target length mismatch: expected ${f}, received ${u.array.length}`
+          );
+        const b = dt(
+          u.array,
+          s,
+          a,
+          (g) => this.resolveDisplayRgbForLegacyRgb(g, o, c)
+        );
+        this.recordDisplayColorBuildStats(b), u.markNeedsUpdate();
+        return;
+      }
+      if (i instanceof Uint8Array && i.length > 0) {
+        if (u.array.length !== i.length)
+          throw new Error(
+            `CAD display color target length mismatch: expected ${i.length}, received ${u.array.length}`
+          );
+        const f = this.buildDisplayColorBytes(i, o, c);
+        u.array.set(f), u.markNeedsUpdate();
+        return;
+      }
+      return;
+    }
+    if (l && typeof r.setColors == "function") {
+      const f = zi(
+        s,
+        a,
+        (b) => this.resolveDisplayRgbForLegacyRgb(b, o, c)
+      );
+      this.recordDisplayColorBuildStats(f.stats), r.setColors(f.color), r.getAttribute("instanceColorStart") && (r.getAttribute("instanceColorStart").needsUpdate = !0), r.getAttribute("instanceColorEnd") && (r.getAttribute("instanceColorEnd").needsUpdate = !0);
+      return;
+    }
+    if (l) {
+      const f = r.getAttribute("color");
+      if (f instanceof U && f.array instanceof Uint8Array && f.array.length === s * 3) {
+        const g = dt(
+          f.array,
+          s,
+          a,
+          (C) => this.resolveDisplayRgbForLegacyRgb(C, o, c)
+        );
+        this.recordDisplayColorBuildStats(g), f.normalized = !0, f.needsUpdate = !0;
+        return;
+      }
+      const b = jt(
+        s,
+        a,
+        (g) => this.resolveDisplayRgbForLegacyRgb(g, o, c)
+      );
+      this.recordDisplayColorBuildStats(b.stats), r.setAttribute("color", $t(b.color));
+      return;
+    }
+    if (!(i instanceof Uint8Array) || i.length === 0) return;
+    const d = this.buildDisplayColorBytes(i, o, c);
+    if (typeof r.setColors == "function") {
+      r.setColors(Fi(d)), r.getAttribute("instanceColorStart") && (r.getAttribute("instanceColorStart").needsUpdate = !0), r.getAttribute("instanceColorEnd") && (r.getAttribute("instanceColorEnd").needsUpdate = !0);
+      return;
+    }
+    const h = r.getAttribute("color");
+    if (h instanceof U && h.array instanceof Uint8Array && h.array.length === d.length) {
+      h.array.set(d), h.normalized = !0, h.needsUpdate = !0;
+      return;
+    }
+    r.setAttribute("color", $t(d));
+  }
+  buildDisplayColorBytes(e, r, i, a, s) {
+    const c = a && a.length > 0 && typeof s == "number" && ze(s, a) ? jt(
+      s,
+      a,
+      (l) => this.resolveDisplayRgbForLegacyRgb(l, r, i)
+    ) : _i(
+      e,
+      (l) => this.resolveDisplayRgbForLegacyRgb(l, r, i)
+    );
+    return this.recordDisplayColorBuildStats(c.stats), c.color;
+  }
+  recordDisplayColorBuildStats(e) {
+    this.colorRefreshStats.displayRefreshVertexTotal += e.vertexCount, this.colorRefreshStats.displayRefreshRunTotal += e.runCount, this.colorRefreshStats.displayRefreshUniqueColorTotal += e.uniqueColorCount, this.colorRefreshStats.displayRefreshCacheHitTotal += e.cacheHitCount, this.colorRefreshStats.displayRefreshRepeatedRunVertexTotal += e.repeatedRunVertexCount;
+  }
+  resolveDisplayHexForRgb(e, r, i) {
+    const a = ja(e, r, i, this.displayThemeName, this.displayContrastEnhancement), s = this.displayHexMemo.get(a);
+    if (s !== void 0) return s;
+    const o = Wa(this.resolveDisplayRgbForLegacyRgb(e, r, i));
+    return this.displayHexMemo.set(a, o), o;
+  }
+  resolveDisplayRgbForLegacyRgb(e, r, i) {
+    const a = r !== null && kt(e), s = Qi(e, { treatLegacyForegroundAsAci7: a });
+    return Zt(s, {
+      theme: this.displayThemeName,
+      elementKind: i,
+      enhanceContrast: this.displayContrastEnhancement
+    }).rgb;
+  }
+  displayElementKindForObject(e) {
+    var i;
+    const r = (i = e.userData) == null ? void 0 : i.kind;
+    return r === "text-batch" ? "text" : r === "fill" || r === "dot" || r === "text" || r === "hatch" || r === "overlay" ? r : "line";
+  }
+  createInsertInstanceRecords(e) {
+    const r = [], { meta: i, mats: a, bboxes: s, count: o } = e, c = /* @__PURE__ */ new Map();
+    for (let l = 0; l < o; l += 1) {
+      const u = i[l * 3], d = i[l * 3 + 1], h = `${u}:${d}`, f = c.get(h) ?? 0;
+      c.set(h, f + 1);
+      const b = {
+        minX: s[l * 4],
+        minY: s[l * 4 + 1],
+        maxX: s[l * 4 + 2],
+        maxY: s[l * 4 + 3]
+      };
+      an(b) && r.push({
+        recordKey: Wn(u, d, f),
+        instanceId: u,
+        variantId: d,
+        layerIdx: i[l * 3 + 2],
+        matA: a[l * 6],
+        matB: a[l * 6 + 1],
+        matC: a[l * 6 + 2],
+        matD: a[l * 6 + 3],
+        tx: a[l * 6 + 4],
+        ty: a[l * 6 + 5],
+        bbox: b
+      });
+    }
+    return r;
+  }
+  createInsertPresenterMaterial(e) {
+    let r;
+    return e === "line" ? r = new Ft({ vertexColors: !0 }) : e === "fill" ? r = new Ot({
+      vertexColors: !0,
+      side: st,
+      depthWrite: !1
+    }) : r = new Dt({
+      vertexColors: !0,
+      size: 2,
+      sizeAttenuation: !1
+    }), Za(r), r;
+  }
+  clearViewportInsertPresenter() {
+    var e, r;
+    (e = this.viewportInstancePresenter) == null || e.dispose(), this.viewportInstancePresenter = null, this.insertInstanceTable = null, (r = this.blockGeometryRegistry) == null || r.dispose(), this.blockGeometryRegistry = null, this.insertPresenterVariantInputs.clear(), this.insertPresenterRecordsByKey.clear(), this.insertPresenterRecordKeysByInstanceId.clear();
+  }
+  refreshDefaultInsertPresenterIfUnmanaged() {
+    var e;
+    this.insertPresenterExternallyManaged || (e = this.viewportInstancePresenter) == null || e.refresh(
+      null,
+      this.getLayerVisibility(),
+      Pa,
+      0
+    );
+  }
+  resetContent() {
+    this.contentGeneration += 1, this.insertPresenterExternallyManaged = !1, this.clearViewportInsertPresenter();
+    for (const e of this.lineChunkRecords)
+      this.disposeLineChunkRecord(e);
+    at(this);
+    for (const e of [...this.children])
+      this.remove(e);
+    this.layerOrder.length = 0, this.layerStatesByIndex.clear(), this.layerGroupsByIndex.clear(), this.layersSnapshotCache = null, this.metaSnapshotCache = null, this.boundsSnapshotCache = null, this.originalLayerColorsByIndex.clear(), this.colorOverridesByIndex.clear(), this.displayHexMemo.clear(), this.lineCanonicalMemoryStats = rn(), this.lineChunkRecords.length = 0, this.nonLineChunkStats.length = 0, this.worldSizedPointUniforms.clear(), this.textUserDataByAppendOrder.length = 0, this.textBatchByLayerIndex.clear(), this.textRenderablesByLayerIndex.clear(), this.textRenderablesByAppendOrder.length = 0, this.annotationOverlayGroupsByLayerIndex.clear(), this.annotationTextBatchByLayerIndex.clear(), this.annotationTextRenderablesByLayerIndex.clear(), this.annotationTextRecordsByOwnerKey.clear(), this.annotationTextRecordsByLayerIndex.clear(), this.pendingTextBatchSync.clear(), this.textBatchSyncScheduled = !1, this.insertRuntime = null, this.insertRuntimeInstancesById.clear(), this.colorRefreshStats = {
+      displayRefreshVertexTotal: 0,
+      displayRefreshRunTotal: 0,
+      displayRefreshUniqueColorTotal: 0,
+      displayRefreshCacheHitTotal: 0,
+      displayRefreshRepeatedRunVertexTotal: 0
+    };
+  }
+  rebuildLineChunks() {
+    for (const e of this.lineChunkRecords) {
+      const r = this.resolveLineChunkVariant(e);
+      if (e.activeVariant === r && e.renderable) continue;
+      const i = e.renderable, a = r === "fat" && e.fatRenderable ? e.fatRenderable : e.thinRenderable;
+      a.visible = e.parent.visible, e.parent.add(a), i.parent && i.parent.remove(i), e.activeVariant = a === e.fatRenderable ? "fat" : "thin", e.renderable = a;
+    }
+  }
+  applyCachedLineChunkColors(e, r) {
+    for (const i of this.lineChunkRecords)
+      i.layerIndex === e && (this.applyColorToRenderable(i.thinRenderable, r), this.applyColorToRenderable(i.fatRenderable, r));
+  }
+  applyColorToRenderable(e, r) {
+    if (!e) return;
+    const i = e.material, a = Array.isArray(i) ? i : i ? [i] : [];
+    for (const s of a)
+      it(s) && (this.applyLayerColorState(s, r, this.displayElementKindForObject(e)), s.needsUpdate = !0);
+  }
+  applyLayerTextColors(e, r) {
+    const i = [
+      ...this.textRenderablesByLayerIndex.get(e) ?? [],
+      ...this.annotationTextRenderablesByLayerIndex.get(e) ?? []
+    ];
+    if (i.length === 0) return;
+    for (const o of i)
+      this.applyColorToTextRenderable(o, r);
+    const a = this.textBatchByLayerIndex.get(e), s = this.annotationTextBatchByLayerIndex.get(e);
+    a && this.invalidateTextBatchDisplayState(a), s && this.invalidateTextBatchDisplayState(s), !(typeof globalThis.self > "u") && (a && this.scheduleTextBatchSync(a), s && this.scheduleTextBatchSync(s));
+  }
+  invalidateTextBatchDisplayState(e) {
+    var a;
+    const r = e._dataTextures;
+    if (r) {
+      for (const s of Object.values(r))
+        (a = s == null ? void 0 : s.dispose) == null || a.call(s);
+      e._dataTextures = {};
+    }
+    const i = Array.isArray(e.material) ? e.material : e.material ? [e.material] : [];
+    for (const s of i)
+      s.needsUpdate = !0;
+  }
+  applyColorToTextRenderable(e, r) {
+    const i = e.userData.text, a = r ?? (i == null ? void 0 : i.c) ?? [255, 255, 255];
+    e.color = this.resolveDisplayHexForRgb(a, (i == null ? void 0 : i.li) ?? null, "text");
+  }
+  applyEffectiveRenderQuality(e, r = {}) {
+    e === this.effectiveRenderQuality && !r.forceLineRebuild || (this.effectiveRenderQuality = e, this.rebuildLineChunks(), this.notifyInternalChange());
+  }
+  resolveCurrentEffectiveRenderQuality() {
+    return this.interactionRenderQualityOverride ?? wa(this.renderQualityMode, this.effectiveRenderQuality, this.autoQualityContext);
+  }
+  notifyInternalChange(e = La) {
+    var r;
+    this.renderDebugRevision += 1, (r = this.internalChangeHook) == null || r.call(this, e);
+  }
+  static getTextOwnerKey(e) {
+    return !Number.isInteger(e.iv) || !Number.isInteger(e.io) ? null : `${e.iv}:${e.io}`;
+  }
+  static resolveTextAnchorX(e) {
+    return e === "center" || e === "right" ? e : "left";
+  }
+  static resolveTextAnchorY(e) {
+    return e === "top" || e === "middle" || e === "bottom" ? e : "bottom-baseline";
+  }
+  startReadyCycle() {
+    this.readySettled = !1, this.readyPromise = new Promise((e, r) => {
+      this.resolveReady = e, this.rejectReady = r;
+    });
+  }
+  resolveReadyOnce() {
+    this.readySettled || (this.readySettled = !0, this.resolveReady());
+  }
+  rejectReadyOnce(e) {
+    this.readySettled || (this.readySettled = !0, this.rejectReady(e));
+  }
+}
+async function ms(t, n, e) {
+  if (!e.externalVariantBuffers && !e.externalVariantFetchSource)
+    throw new Error("External variant delta requires buffers or fetch source");
+  await ki(t, n, void 0, {
+    hiddenInstanceIds: At(e.hiddenInstanceIds),
+    externalVariantFetchSource: e.externalVariantFetchSource,
+    externalVariantBuffers: e.externalVariantBuffers,
+    requiredExternalVariantIds: ne(e.requiredExternalVariantIds),
+    externalVariantGeometryFetchIds: ne(e.externalVariantGeometryFetchIds),
+    beforeTextAppend: e.beforeTextAppend,
+    externalVariantDeltaOnly: !0
+  });
+}
+function xs(t) {
+  return ur(t);
+}
+function ps(t) {
+  return mt(t).header;
+}
+function gs(t) {
+  return dr(t);
+}
+function bs(t) {
+  return hr(t);
+}
+function Cs(t, n) {
+  return xn(t, n);
+}
+function Is(t) {
+  return yn(t);
+}
+function ws(t, n) {
+  return mn(t, n);
+}
+function vs(t, n) {
+  if (!n.externalVariantBuffers && !n.externalVariantFetchSource)
+    throw new Error("External variant delta requires buffers or fetch source");
+  const e = mt(t, {
+    hiddenInstanceIds: At(n.hiddenInstanceIds),
+    externalVariantBuffers: n.externalVariantBuffers,
+    requiredExternalVariantIds: ne(n.requiredExternalVariantIds),
+    externalVariantDeltaOnly: !0
+  });
+  return {
+    header: e.header,
+    chunks: Array.from(e.chunks)
+  };
+}
+function Rs(t) {
+  Rr(t);
+}
+function ts(t) {
+  return t instanceof Error ? t : typeof t == "string" ? new Error(t) : new Error(`Unknown geo load error: ${String(t)}`);
+}
+function At(t) {
+  if (!(!t || t.length === 0))
+    return new Set(t);
+}
+function ne(t) {
+  if (t !== void 0)
+    return new Set(t);
+}
+function ns(t) {
+  if (t.kind !== "url") return null;
+  try {
+    const n = typeof document > "u" ? void 0 : document.baseURI;
+    return new URL(t.url, n).href;
+  } catch {
+    return null;
+  }
+}
+function fn(t) {
+  return !!(t && (t.line.count > 0 || t.fill.count > 0 || t.dot.count > 0 || t.texts.length > 0));
+}
+async function rs(t, n, e) {
+  if (!n) return null;
+  const r = new URL(n.href, t).href, i = await fetch(r, { signal: e });
+  if (!i.ok) {
+    const o = [i.status, i.statusText].filter(Boolean).join(" ");
+    throw new Error(`Scene annotation fetch failed${o ? `: ${o}` : ""}`);
+  }
+  const a = await i.arrayBuffer();
+  if (a.byteLength !== n.raw_size)
+    throw new Error(
+      `Scene annotation raw_size mismatch: manifest=${n.raw_size}, response=${a.byteLength}`
+    );
+  const s = fr(a);
+  if (s.line.count !== n.line_count || s.fill.count !== n.fill_count || s.dot.count !== n.dot_count || s.texts.length !== n.text_count)
+    throw new Error(`Scene annotation count mismatch for ${r}`);
+  return s;
+}
+async function is(t, n, e, r, i) {
+  if (e.externalVariantFetchSource !== void 0 || e.externalVariantBuffers !== void 0 || e.requiredExternalVariantIds !== void 0 || e.externalVariantGeometryFetchIds !== void 0)
+    return { annotations: [] };
+  const a = ns(t);
+  if (!a) return { annotations: [] };
+  const s = xn(n, {
+    hiddenInstanceIds: r,
+    loadBlocks: e.loadBlocks
+  }), o = s.requiredVariantIds.length > 0 ? Rn({
+    baseUrl: a,
+    entries: s.manifest,
+    requiredVariantIds: s.requiredVariantIds,
+    signal: i
+  }) : Promise.resolve({ buffers: /* @__PURE__ */ new Map(), fetchMs: 0 }), c = e.loadAnnotations === !1 ? null : yn(n), [l, u] = await Promise.all([
+    o,
+    c != null && c.scene ? rs(a, c.scene, i) : Promise.resolve(null)
+  ]), d = [];
+  if (fn(u) && d.push(u), e.loadAnnotations !== !1 && e.loadBlocks !== !1) {
+    const h = mn(n, {
+      externalVariantBuffers: l.buffers,
+      hiddenInstanceIds: r
+    });
+    fn(h) && d.push(h);
+  }
+  return {
+    externalVariantBuffers: l.buffers,
+    requiredExternalVariantIds: s.requiredVariantIds,
+    externalVariantGeometryFetchIds: s.requiredVariantIds,
+    annotations: d
+  };
+}
+function Bs(t, n = {}) {
+  const e = new AbortController(), r = Bt(t, e.signal), i = new Ie({ resolveTextFont: n.resolveTextFont }), a = [
+    zt(n.signal, e),
+    zt(r.sourceSignal, e)
+  ];
+  hn(i, () => {
+    e.abort(te("GeoNode disposed during CAD load"));
+  });
+  const s = At(n.hiddenInstanceIds), o = ne(n.requiredExternalVariantIds), c = ne(n.externalVariantGeometryFetchIds);
+  return (async () => {
+    var l;
+    try {
+      const u = await Ir(
+        Vn(r.source),
+        e.signal,
+        "CAD load aborted before decoding"
+      ), d = await is(
+        r.source,
+        u,
+        n,
+        s,
+        e.signal
+      ), h = {
+        signal: e.signal,
+        hiddenInstanceIds: s,
+        requiredExternalVariantIds: o ?? ne(d.requiredExternalVariantIds),
+        externalVariantGeometryFetchIds: c ?? ne(d.externalVariantGeometryFetchIds),
+        beforeTextAppend: n.beforeTextAppend,
+        beforeFinalize: async () => {
+          var f;
+          for (const b of d.annotations)
+            await ((f = n.beforeTextAppend) == null ? void 0 : f.call(n, b.texts)), i.appendAnnotationOverlay(b);
+        }
+      };
+      n.loadBlocks === !1 && (h.loadBlocks = !1), typeof n.maxExpandedInstanceVertices == "number" && Number.isFinite(n.maxExpandedInstanceVertices) && n.maxExpandedInstanceVertices >= 0 && (h.maxExpandedInstanceVertices = n.maxExpandedInstanceVertices), n.preferWorker === !1 && (h.preferWorker = !1), n.workerUrl !== void 0 && (h.workerUrl = n.workerUrl), n.workerFactory && (h.workerFactory = n.workerFactory), n.externalVariantFetchSource && (h.externalVariantFetchSource = n.externalVariantFetchSource), n.externalVariantBuffers && n.externalVariantBuffers.size > 0 ? h.externalVariantBuffers = n.externalVariantBuffers : (l = d.externalVariantBuffers) != null && l.size && (h.externalVariantBuffers = d.externalVariantBuffers), await Vi(i, u, void 0, {
+        ...h
+      });
+    } catch (u) {
+      i._fail(ts(u));
+    } finally {
+      for (const u of a) u();
+      hn(i, null);
+    }
+  })(), i;
+}
+const as = 40;
+function jn(t) {
+  return !!(t && Number.isFinite(t.minX) && Number.isFinite(t.minY) && Number.isFinite(t.maxX) && Number.isFinite(t.maxY) && t.maxX >= t.minX && t.maxY >= t.minY);
+}
+function ss(t, n, e) {
+  return n.x >= t.minX - e && n.x <= t.maxX + e && n.y >= t.minY - e && n.y <= t.maxY + e;
+}
+function os(t, n) {
+  return n.minX >= t.minX && n.maxX <= t.maxX && n.minY >= t.minY && n.maxY <= t.maxY;
+}
+function Ss(t, n) {
+  return t.layerIndex === n.layerIndex && t.variantId === n.variantId && t.instanceId === n.instanceId;
+}
+function Es(t, n, e = {}) {
+  var s;
+  if (!Number.isFinite(n.x) || !Number.isFinite(n.y)) return null;
+  const r = Math.max(0, e.padding ?? as), i = t.getLayers();
+  let a = null;
+  for (let o = i.length - 1; o >= 0; o -= 1) {
+    const c = i[o];
+    if (!c || !c.visible) continue;
+    const l = t.getLayerBlockUsages(c.index);
+    for (let u = l.length - 1; u >= 0; u -= 1) {
+      const d = l[u];
+      for (let h = d.inserts.length - 1; h >= 0; h -= 1) {
+        const f = d.inserts[h];
+        if (!f.canHighlight || !jn(f.bbox) || ((s = e.isInstanceVisible) == null ? void 0 : s.call(e, f.instanceId)) === !1 || !ss(f.bbox, n, r)) continue;
+        const b = {
+          kind: "insert",
+          layerIndex: c.index,
+          variantId: d.variantId,
+          instanceId: f.instanceId
+        };
+        if (a || (a = b), !e.viewport || os(e.viewport, f.bbox)) return b;
+      }
+    }
+  }
+  return a;
+}
+function Vs(t, n) {
+  const e = t.getLayerBlockUsages(n.layerIndex).find((s) => s.variantId === n.variantId), r = e == null ? void 0 : e.inserts.find((s) => s.instanceId === n.instanceId);
+  if (!e || !r || !jn(r.bbox)) return null;
+  const i = t.getLayers().find((s) => s.index === n.layerIndex), a = t.getInsertInstanceBaseTransform(n.instanceId, n.variantId);
+  return {
+    id: { ...n },
+    label: r.label,
+    blockName: e.blockName || `block#${n.variantId}`,
+    layerName: (i == null ? void 0 : i.name) ?? `layer#${n.layerIndex}`,
+    layerIndex: n.layerIndex,
+    tx: (a == null ? void 0 : a.tx) ?? r.tx,
+    ty: (a == null ? void 0 : a.ty) ?? r.ty,
+    rotation: (a == null ? void 0 : a.rotation) ?? null,
+    scaleX: (a == null ? void 0 : a.scaleX) ?? null,
+    scaleY: (a == null ? void 0 : a.scaleY) ?? null,
+    bbox: Object.freeze({ ...r.bbox })
+  };
+}
+export {
+  La as GEO_NODE_STRUCTURE_CHANGE,
+  ys as GEO_NODE_VISUAL_CHANGE,
+  A as GeoLoaderError,
+  Ie as GeoNode,
+  ms as appendExternalVariantDeltaToGeoNode,
+  Rs as assertValidSourceOrThrow,
+  Ss as cadInsertSelectionEquals,
+  fs as createLoadSession,
+  ar as expandViewportRect,
+  vs as loadExternalVariantDeltaFromBuffer,
+  Bs as loadGeo,
+  Le as mergeViewportRects,
+  ts as normalizeGeoError,
+  xs as parseBuffer,
+  gs as parseBufferBounds,
+  ps as parseBufferHeader,
+  Es as pickCadInsertAtPoint,
+  Ts as readBlockAnnotationSidecar,
+  Is as readBufferExternalAnnotationManifest,
+  ws as readBufferExternalBlockAnnotations,
+  Cs as readBufferExternalVariantDependencyPlan,
+  bs as readBufferExternalVariantManifest,
+  fr as readSceneAnnotationSidecar,
+  Vs as resolveCadInsertDetails,
+  nr as transformBBoxByInstance,
+  lr as viewportRectContains,
+  or as viewportRectIntersects
+};