goldsrc-bsp-viewer 1.0.0

package/dist/goldsrc-bsp-viewer.js

@@ -0,0 +1,2071 @@
+var St = Object.defineProperty;
+var kt = (y, e, t) => e in y ? St(y, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : y[e] = t;
+var g = (y, e, t) => kt(y, typeof e != "symbol" ? e + "" : e, t);
+import * as l from "three";
+import { Controls as Lt, Vector3 as Ft, Euler as Pt } from "three";
+import Je, { forwardRef as be, useRef as Be, useImperativeHandle as Tt, useEffect as me, createElement as ye, useState as ve } from "react";
+const J = new Pt(0, 0, 0, "YXZ"), Z = new Ft(), At = { type: "change" }, It = { type: "lock" }, Ut = { type: "unlock" }, $e = Math.PI / 2;
+class Ot extends Lt {
+  constructor(e, t = null) {
+    super(e, t), this.isLocked = !1, this.minPolarAngle = 0, this.maxPolarAngle = Math.PI, this.pointerSpeed = 1, this._onMouseMove = jt.bind(this), this._onPointerlockChange = Vt.bind(this), this._onPointerlockError = Dt.bind(this), this.domElement !== null && this.connect();
+  }
+  connect() {
+    this.domElement.ownerDocument.addEventListener("mousemove", this._onMouseMove), this.domElement.ownerDocument.addEventListener("pointerlockchange", this._onPointerlockChange), this.domElement.ownerDocument.addEventListener("pointerlockerror", this._onPointerlockError);
+  }
+  disconnect() {
+    this.domElement.ownerDocument.removeEventListener("mousemove", this._onMouseMove), this.domElement.ownerDocument.removeEventListener("pointerlockchange", this._onPointerlockChange), this.domElement.ownerDocument.removeEventListener("pointerlockerror", this._onPointerlockError);
+  }
+  dispose() {
+    this.disconnect();
+  }
+  getObject() {
+    return console.warn("THREE.PointerLockControls: getObject() has been deprecated. Use controls.object instead."), this.object;
+  }
+  getDirection(e) {
+    return e.set(0, 0, -1).applyQuaternion(this.object.quaternion);
+  }
+  moveForward(e) {
+    if (this.enabled === !1) return;
+    const t = this.object;
+    Z.setFromMatrixColumn(t.matrix, 0), Z.crossVectors(t.up, Z), t.position.addScaledVector(Z, e);
+  }
+  moveRight(e) {
+    if (this.enabled === !1) return;
+    const t = this.object;
+    Z.setFromMatrixColumn(t.matrix, 0), t.position.addScaledVector(Z, e);
+  }
+  lock() {
+    this.domElement.requestPointerLock();
+  }
+  unlock() {
+    this.domElement.ownerDocument.exitPointerLock();
+  }
+}
+function jt(y) {
+  if (this.enabled === !1 || this.isLocked === !1) return;
+  const e = this.object;
+  J.setFromQuaternion(e.quaternion), J.y -= y.movementX * 2e-3 * this.pointerSpeed, J.x -= y.movementY * 2e-3 * this.pointerSpeed, J.x = Math.max($e - this.maxPolarAngle, Math.min($e - this.minPolarAngle, J.x)), e.quaternion.setFromEuler(J), this.dispatchEvent(At);
+}
+function Vt() {
+  this.domElement.ownerDocument.pointerLockElement === this.domElement ? (this.dispatchEvent(It), this.isLocked = !0) : (this.dispatchEvent(Ut), this.isLocked = !1);
+}
+function Dt() {
+  console.error("THREE.PointerLockControls: Unable to use Pointer Lock API");
+}
+const Nt = 0, Gt = 1, zt = 2, Wt = 3, Bt = 4, $t = 5, Ht = 6, Yt = 7, Kt = 8, qt = 9, Xt = 10, Jt = 11, Zt = 12, Qt = 13, es = 14, ts = 15;
+class ss {
+  constructor(e) {
+    g(this, "view");
+    this.view = new DataView(e);
+  }
+  parse() {
+    const e = this.view.getInt32(0, !0);
+    e !== 30 && console.warn(`Unsupported BSP version: ${e}. Expected 30.`);
+    const t = [];
+    for (let w = 0; w < ts; w++)
+      t.push({
+        offset: this.view.getInt32(4 + w * 8, !0),
+        length: this.view.getInt32(8 + w * 8, !0)
+      });
+    const n = this.parseEntities(t[Nt]), r = this.parseVertices(t[Wt]), i = this.parseEdges(t[Zt]), a = this.parseSurfEdges(t[Qt]), c = this.parseFaces(t[Yt]), o = this.parseTexInfos(t[Ht]), u = this.parsePlanes(t[Gt]), f = this.parseTextures(t[zt]), d = this.parseLighting(t[Kt]), v = this.parseVisibility(t[Bt]), E = this.parseModels(t[es]), m = this.parseNodes(t[$t]), M = this.parseLeaves(t[Xt]), R = this.parseMarkSurfaces(t[Jt]), x = this.parseClipNodes(t[qt]);
+    return {
+      version: e,
+      entities: n,
+      vertices: r,
+      edges: i,
+      surfEdges: a,
+      faces: c,
+      texInfos: o,
+      planes: u,
+      textures: f,
+      lighting: d,
+      visibility: v,
+      models: E,
+      nodes: m,
+      leaves: M,
+      markSurfaces: R,
+      clipNodes: x
+    };
+  }
+  parseEntities(e) {
+    const t = new TextDecoder().decode(new Uint8Array(this.view.buffer, e.offset, e.length)), n = [];
+    let r = null;
+    const i = t.split(`
+`);
+    for (let a of i)
+      if (a = a.trim(), a === "{")
+        r = { classname: "" };
+      else if (a === "}")
+        r && r.classname && n.push(r), r = null;
+      else if (r) {
+        const c = a.match(/"(.*)"\s+"(.*)"/);
+        if (c) {
+          const o = c[1], u = c[2];
+          o === "classname" ? r.classname = u : r[o] = u;
+        }
+      }
+    return n;
+  }
+  parseVertices(e) {
+    const t = e.length / 12, n = [];
+    for (let r = 0; r < t; r++)
+      n.push({
+        x: this.view.getFloat32(e.offset + r * 12, !0),
+        y: this.view.getFloat32(e.offset + r * 12 + 4, !0),
+        z: this.view.getFloat32(e.offset + r * 12 + 8, !0)
+      });
+    return n;
+  }
+  parseEdges(e) {
+    const t = e.length / 4, n = [];
+    for (let r = 0; r < t; r++)
+      n.push({
+        v: [
+          this.view.getUint16(e.offset + r * 4, !0),
+          this.view.getUint16(e.offset + r * 4 + 2, !0)
+        ]
+      });
+    return n;
+  }
+  parseSurfEdges(e) {
+    const t = e.length / 4, n = [];
+    for (let r = 0; r < t; r++)
+      n.push(this.view.getInt32(e.offset + r * 4, !0));
+    return n;
+  }
+  parseFaces(e) {
+    const t = e.length / 20, n = [];
+    for (let r = 0; r < t; r++) {
+      const i = e.offset + r * 20;
+      n.push({
+        plane: this.view.getUint16(i, !0),
+        planeSide: this.view.getUint16(i + 2, !0),
+        firstEdge: this.view.getInt32(i + 4, !0),
+        numEdges: this.view.getUint16(i + 8, !0),
+        texInfo: this.view.getUint16(i + 10, !0),
+        styles: [
+          this.view.getUint8(i + 12),
+          this.view.getUint8(i + 13),
+          this.view.getUint8(i + 14),
+          this.view.getUint8(i + 15)
+        ],
+        lightmapOffset: this.view.getInt32(i + 16, !0)
+      });
+    }
+    return n;
+  }
+  parseTexInfos(e) {
+    const t = e.length / 40, n = [];
+    for (let r = 0; r < t; r++) {
+      const i = e.offset + r * 40;
+      n.push({
+        s: { x: this.view.getFloat32(i, !0), y: this.view.getFloat32(i + 4, !0), z: this.view.getFloat32(i + 8, !0) },
+        shiftS: this.view.getFloat32(i + 12, !0),
+        t: { x: this.view.getFloat32(i + 16, !0), y: this.view.getFloat32(i + 20, !0), z: this.view.getFloat32(i + 24, !0) },
+        shiftT: this.view.getFloat32(i + 28, !0),
+        miptex: this.view.getInt32(i + 32, !0),
+        flags: this.view.getInt32(i + 36, !0)
+      });
+    }
+    return n;
+  }
+  parsePlanes(e) {
+    const t = e.length / 20, n = [];
+    for (let r = 0; r < t; r++) {
+      const i = e.offset + r * 20;
+      n.push({
+        normal: { x: this.view.getFloat32(i, !0), y: this.view.getFloat32(i + 4, !0), z: this.view.getFloat32(i + 8, !0) },
+        dist: this.view.getFloat32(i + 12, !0),
+        type: this.view.getInt32(i + 16, !0)
+      });
+    }
+    return n;
+  }
+  parseTextures(e) {
+    if (e.length === 0) return [];
+    const t = this.view.getInt32(e.offset, !0), n = [];
+    for (let r = 0; r < t; r++) {
+      const i = this.view.getInt32(e.offset + 4 + r * 4, !0);
+      if (i === -1) continue;
+      const a = e.offset + i;
+      let c = "";
+      for (let v = 0; v < 16; v++) {
+        const E = this.view.getUint8(a + v);
+        if (E === 0) break;
+        c += String.fromCharCode(E);
+      }
+      const o = this.view.getUint32(a + 16, !0), u = this.view.getUint32(a + 20, !0), f = [
+        this.view.getUint32(a + 24, !0),
+        this.view.getUint32(a + 28, !0),
+        this.view.getUint32(a + 32, !0),
+        this.view.getUint32(a + 36, !0)
+      ], d = { name: c, width: o, height: u, offsets: f };
+      if (f[0] !== 0) {
+        const v = Math.floor(o * u * 85 / 64) + 2 + 768;
+        d.data = new Uint8Array(this.view.buffer, a, v);
+      }
+      n.push(d);
+    }
+    return n;
+  }
+  parseLighting(e) {
+    return new Uint8Array(this.view.buffer, e.offset, e.length);
+  }
+  parseVisibility(e) {
+    return new Uint8Array(this.view.buffer, e.offset, e.length);
+  }
+  parseModels(e) {
+    const t = e.length / 64, n = [];
+    for (let r = 0; r < t; r++) {
+      const i = e.offset + r * 64;
+      n.push({
+        mins: { x: this.view.getFloat32(i, !0), y: this.view.getFloat32(i + 4, !0), z: this.view.getFloat32(i + 8, !0) },
+        maxs: { x: this.view.getFloat32(i + 12, !0), y: this.view.getFloat32(i + 16, !0), z: this.view.getFloat32(i + 20, !0) },
+        origin: { x: this.view.getFloat32(i + 24, !0), y: this.view.getFloat32(i + 28, !0), z: this.view.getFloat32(i + 32, !0) },
+        headNodes: [
+          this.view.getInt32(i + 36, !0),
+          this.view.getInt32(i + 40, !0),
+          this.view.getInt32(i + 44, !0),
+          this.view.getInt32(i + 48, !0)
+        ],
+        visLeafs: this.view.getInt32(i + 52, !0),
+        firstFace: this.view.getInt32(i + 56, !0),
+        numFaces: this.view.getInt32(i + 60, !0)
+      });
+    }
+    return n;
+  }
+  parseNodes(e) {
+    const t = e.length / 24, n = [];
+    for (let r = 0; r < t; r++) {
+      const i = e.offset + r * 24;
+      n.push({
+        plane: this.view.getInt32(i, !0),
+        children: [this.view.getInt16(i + 4, !0), this.view.getInt16(i + 6, !0)],
+        mins: [this.view.getInt16(i + 8, !0), this.view.getInt16(i + 10, !0), this.view.getInt16(i + 12, !0)],
+        maxs: [this.view.getInt16(i + 14, !0), this.view.getInt16(i + 16, !0), this.view.getInt16(i + 18, !0)],
+        firstFace: this.view.getUint16(i + 20, !0),
+        numFaces: this.view.getUint16(i + 22, !0)
+      });
+    }
+    return n;
+  }
+  parseLeaves(e) {
+    const t = e.length / 24, n = [];
+    for (let r = 0; r < t; r++) {
+      const i = e.offset + r * 24;
+      n.push({
+        contents: this.view.getInt32(i, !0),
+        visOffset: this.view.getInt32(i + 4, !0),
+        mins: [this.view.getInt16(i + 8, !0), this.view.getInt16(i + 10, !0), this.view.getInt16(i + 12, !0)],
+        maxs: [this.view.getInt16(i + 14, !0), this.view.getInt16(i + 16, !0), this.view.getInt16(i + 18, !0)],
+        firstMarkSurface: this.view.getUint16(i + 20, !0),
+        numMarkSurfaces: this.view.getUint16(i + 22, !0),
+        ambientLevels: [
+          this.view.getUint8(i + 24),
+          this.view.getUint8(i + 25),
+          this.view.getUint8(i + 26),
+          this.view.getUint8(i + 27)
+        ]
+      });
+    }
+    return n;
+  }
+  parseMarkSurfaces(e) {
+    const t = e.length / 2, n = [];
+    for (let r = 0; r < t; r++)
+      n.push(this.view.getUint16(e.offset + r * 2, !0));
+    return n;
+  }
+  parseClipNodes(e) {
+    const t = e.length / 8, n = [];
+    for (let r = 0; r < t; r++) {
+      const i = e.offset + r * 8;
+      n.push({
+        plane: this.view.getInt32(i, !0),
+        children: [this.view.getInt16(i + 4, !0), this.view.getInt16(i + 6, !0)]
+      });
+    }
+    return n;
+  }
+}
+class is {
+  constructor(e) {
+    g(this, "view");
+    this.view = new DataView(e);
+  }
+  parse() {
+    const e = String.fromCharCode(
+      this.view.getUint8(0),
+      this.view.getUint8(1),
+      this.view.getUint8(2),
+      this.view.getUint8(3)
+    );
+    if (e !== "WAD3")
+      throw new Error(`Not a WAD3 file: ${e}`);
+    const t = this.view.getInt32(4, !0), n = this.view.getInt32(8, !0);
+    console.log(`[WadParser] Parsing WAD with ${t} entries`);
+    const r = /* @__PURE__ */ new Map();
+    for (let i = 0; i < t; i++) {
+      const a = n + i * 32, c = this.view.getInt32(a, !0), o = this.view.getUint8(a + 12);
+      let u = "";
+      for (let f = 0; f < 16; f++) {
+        const d = this.view.getUint8(a + 16 + f);
+        if (d === 0) break;
+        u += String.fromCharCode(d);
+      }
+      if (o === 67)
+        try {
+          const f = this.parseMiptex(c, u);
+          r.set(u.toLowerCase(), f);
+        } catch (f) {
+          console.error(`[WadParser] Failed to parse texture ${u}:`, f);
+        }
+    }
+    return console.log(`[WadParser] Successfully loaded ${r.size} textures`), r;
+  }
+  parseMiptex(e, t) {
+    const n = this.view.getUint32(e + 16, !0), r = this.view.getUint32(e + 20, !0), i = [
+      this.view.getUint32(e + 24, !0),
+      this.view.getUint32(e + 28, !0),
+      this.view.getUint32(e + 32, !0),
+      this.view.getUint32(e + 36, !0)
+    ], a = n / 8 * (r / 8), c = e + i[3] + a, o = new Uint8Array(this.view.buffer, c + 2, 768), u = n * r, f = new Uint8Array(this.view.buffer, e + i[0], u);
+    return {
+      name: t,
+      width: n,
+      height: r,
+      data: new Uint8Array(f),
+      palette: new Uint8Array(o)
+    };
+  }
+}
+function Q(y) {
+  return new l.Vector3(-y.y, y.z, -y.x);
+}
+function He(y, e, t) {
+  const n = y.faces[e];
+  if (!n) return null;
+  const r = y.texInfos[n.texInfo];
+  if (!r) return null;
+  const i = y.textures[r.miptex];
+  if (!i) return null;
+  const a = n.firstEdge, c = n.numEdges;
+  if (c < 3) return null;
+  const o = [];
+  for (let R = 0; R < c; R++) {
+    const x = y.surfEdges[a + R], w = y.edges[Math.abs(x)], k = x >= 0 ? w.v[0] : w.v[1];
+    o.push(Q(y.vertices[k]));
+  }
+  const f = (c - 2) * 3, d = new Float32Array(f * 3), v = new Float32Array(f * 2), E = new Float32Array(f * 2);
+  t && o.forEach((R) => {
+    const x = -R.z, w = -R.x, k = R.y;
+    x * r.s.x + w * r.s.y + k * r.s.z + r.shiftS, x * r.t.x + w * r.t.y + k * r.t.z + r.shiftT;
+  });
+  let m = 0, M = 0;
+  for (let R = 1; R < o.length - 1; R++) {
+    const x = o[0], w = o[R], k = o[R + 1], O = [x, k, w];
+    for (const I of O) {
+      d[m++] = I.x, d[m++] = I.y, d[m++] = I.z;
+      const $ = -I.z, z = -I.x, T = I.y, H = $ * r.s.x + z * r.s.y + T * r.s.z + r.shiftS, D = $ * r.t.x + z * r.t.y + T * r.t.z + r.shiftT;
+      if (v[M] = H / (i.width || 1), v[M + 1] = D / (i.height || 1), t) {
+        const W = H / t.step - t.minU_step + 0.5, j = D / t.step - t.minV_step + 0.5;
+        E[M] = (t.x + 1 + W) / t.atlasWidth, E[M + 1] = (t.y + 1 + j) / t.atlasHeight;
+      }
+      M += 2;
+    }
+  }
+  return { positions: d, uvs: v, lightUvs: E };
+}
+const Ye = {
+  vertexShader: `
+        attribute vec2 lightUv;
+        varying vec2 vUv;
+        varying vec2 vLightUv;
+        varying vec3 vNormal;
+        varying vec3 vViewPosition;
+
+        void main() {
+            vUv = uv;
+            vLightUv = lightUv;
+            vNormal = normalize(normalMatrix * normal);
+            vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+            vViewPosition = -mvPosition.xyz;
+            gl_Position = projectionMatrix * mvPosition;
+        }
+    `,
+  fragmentShader: `
+        uniform sampler2D diffuseMap;
+        uniform sampler2D lightmapAtlas;
+        uniform bool hasLightmap;
+        uniform float opacity;
+        varying vec2 vUv;
+        varying vec2 vLightUv;
+        varying vec3 vNormal;
+        varying vec3 vViewPosition;
+
+        void main() {
+            // Sample diffuse
+            vec4 diffuseColor = texture2D(diffuseMap, vUv);
+
+            // Handle transparency from texture ({ textures)
+            if (diffuseColor.a < 0.1) discard;
+
+            vec3 finalColor;
+            if (hasLightmap) {
+                vec3 lightColor = texture2D(lightmapAtlas, vLightUv).rgb;
+                finalColor = diffuseColor.rgb * lightColor;
+                float gamma = 1.6;
+                finalColor = pow(finalColor, vec3(1.0/gamma));
+            } else {
+                // Better fallback lighting
+                vec3 normal = normalize(vNormal);
+                vec3 lightDir = normalize(vec3(0.5, 1.0, 0.5));
+                float dotNL = max(dot(normal, lightDir), 0.3);
+                finalColor = diffuseColor.rgb * dotNL;
+            }
+
+            gl_FragColor = vec4(finalColor, opacity);
+        }
+    `
+};
+class rs {
+  parse(e) {
+    const t = /* @__PURE__ */ new Map(), n = /@(\w+Class).*?=\s*(\w+)/g;
+    let r;
+    for (; (r = n.exec(e)) !== null; ) {
+      const i = r[1], a = r[2], c = r.index, o = e.indexOf("=", c), f = e.substring(c, o).match(/color\((\d+)\s+(\d+)\s+(\d+)\)/), d = f ? [parseInt(f[1]), parseInt(f[2]), parseInt(f[3])] : void 0;
+      t.set(a, { name: a, type: i, color: d });
+    }
+    return t;
+  }
+}
+class ns {
+  constructor(e) {
+    g(this, "scene");
+    g(this, "fgd", /* @__PURE__ */ new Map());
+    this.scene = e;
+  }
+  async loadFgd(e) {
+    const t = new rs();
+    this.fgd = t.parse(e);
+  }
+  renderEntities(e) {
+    const t = new l.Group();
+    return t.name = "entities", e.forEach((n) => {
+      if (!n.origin) return;
+      const r = n.origin.split(" ").map(Number), i = n.classname, a = this.fgd.get(i), c = a != null && a.color ? new l.Color(a.color[0] / 255, a.color[1] / 255, a.color[2] / 255) : new l.Color(8421504), o = new l.Vector3(-r[1], r[2], -r[0]), u = new l.BoxGeometry(8, 8, 8), f = new l.MeshBasicMaterial({
+        color: c,
+        wireframe: !1,
+        transparent: !0,
+        opacity: 0.8
+      }), d = new l.Mesh(u, f);
+      d.position.copy(o), d.userData = { entity: n }, t.add(d);
+      const v = new l.EdgesGeometry(u), E = new l.LineBasicMaterial({ color: 16777215, transparent: !0, opacity: 0.5 }), m = new l.LineSegments(v, E);
+      m.name = "point_helper_wireframe", d.add(m);
+    }), this.scene.add(t), t;
+  }
+}
+class as {
+  constructor(e) {
+    g(this, "bsp");
+    this.bsp = e;
+  }
+  getLeafIndex(e) {
+    return this.findLeaf(e);
+  }
+  getVisibleLeafs(e) {
+    if (e <= 0)
+      return Array.from({ length: this.bsp.leaves.length }, (n, r) => r);
+    const t = this.bsp.leaves[e];
+    return !t || t.visOffset === -1 ? Array.from({ length: this.bsp.leaves.length }, (n, r) => r) : this.decompressVis(t.visOffset);
+  }
+  findLeaf(e) {
+    const t = { x: -e.z, y: -e.x, z: e.y };
+    let n = 0, r = 0;
+    for (; n >= 0 && r < 1e3; ) {
+      r++;
+      const i = this.bsp.nodes[n];
+      if (!i) break;
+      const a = this.bsp.planes[i.plane];
+      t.x * a.normal.x + t.y * a.normal.y + t.z * a.normal.z - a.dist >= 0 ? n = i.children[0] : n = i.children[1];
+    }
+    return n < 0 ? ~n : 0;
+  }
+  decompressVis(e) {
+    const t = [], n = this.bsp.leaves.length;
+    let r = 1, i = e;
+    const a = this.bsp.visibility;
+    for (; r < n; )
+      if (a[i] === 0) {
+        const c = a[i + 1];
+        r += c * 8, i += 2;
+      } else {
+        for (let c = 0; c < 8; c++)
+          a[i] & 1 << c && t.push(r), r++;
+        i++;
+      }
+    return t;
+  }
+}
+class os {
+  constructor(e, t) {
+    g(this, "scene");
+    g(this, "bsp", null);
+    g(this, "textures", /* @__PURE__ */ new Map());
+    g(this, "entityRenderer");
+    g(this, "entitiesGroup", null);
+    g(this, "brushEntitiesGroup", null);
+    g(this, "pvsManager", null);
+    g(this, "worldGroup", null);
+    g(this, "leafToMaterials", /* @__PURE__ */ new Map());
+    g(this, "materialMeshes", /* @__PURE__ */ new Map());
+    g(this, "lightmapAtlas", null);
+    g(this, "materialCache", /* @__PURE__ */ new Map());
+    g(this, "atlasWidth", 2048);
+    g(this, "atlasHeight", 2048);
+    g(this, "faceLightmapInfo", /* @__PURE__ */ new Map());
+    g(this, "currentLeafIdx", -1);
+    g(this, "pvsEnabled", !1);
+    g(this, "highlightGroup", null);
+    g(this, "connectionsGroup", null);
+    g(this, "brushWireframesVisible", !0);
+    g(this, "axesVisible", !0);
+    g(this, "aaaTriggerOpacity", 0.5);
+    g(this, "entityConnectionsMode", "none");
+    g(this, "entityCenters", /* @__PURE__ */ new Map());
+    g(this, "selectedEntity", null);
+    g(this, "onProgress");
+    g(this, "connectionMaterials", {
+      yellow: new l.LineBasicMaterial({ color: 16776960, depthTest: !0 }),
+      green: new l.LineBasicMaterial({ color: 65280, depthTest: !0 })
+    });
+    this.scene = e, this.entityRenderer = new ns(e), this.onProgress = t;
+  }
+  dispose() {
+    this.cleanup();
+  }
+  cleanup() {
+    this.clearHighlight(), this.clearConnections(), this.worldGroup && (this.worldGroup.traverse((t) => {
+      t instanceof l.Mesh && t.geometry.dispose();
+    }), this.scene.remove(this.worldGroup), this.worldGroup = null), this.brushEntitiesGroup && (this.brushEntitiesGroup.traverse((t) => {
+      t instanceof l.Mesh && t.geometry.dispose();
+    }), this.scene.remove(this.brushEntitiesGroup), this.brushEntitiesGroup = null);
+    const e = this.scene.getObjectByName("origin_axes");
+    e && (e.traverse((t) => {
+      t.geometry && t.geometry.dispose(), t.material && (Array.isArray(t.material) ? t.material.forEach((n) => n.dispose()) : t.material.dispose());
+    }), this.scene.remove(e)), this.materialCache.forEach((t) => {
+      t.uniforms.diffuseMap.value && t.uniforms.diffuseMap.value.dispose(), t.dispose();
+    }), this.materialCache.clear(), this.textures.forEach((t) => t.dispose()), this.textures.clear(), this.lightmapAtlas && (this.lightmapAtlas.dispose(), this.lightmapAtlas = null), this.leafToMaterials.clear(), this.faceLightmapInfo.clear(), this.entityCenters.clear();
+  }
+  async loadMap(e, t, n) {
+    var i, a, c, o, u, f, d, v;
+    this.cleanup(), (i = this.onProgress) == null || i.call(this, 10, "Parsing BSP...");
+    const r = new ss(e);
+    this.bsp = r.parse(), this.pvsManager = new as(this.bsp), n && ((a = this.onProgress) == null || a.call(this, 20, "Parsing FGD..."), await this.entityRenderer.loadFgd(n)), (c = this.onProgress) == null || c.call(this, 30, "Parsing WADs...");
+    for (let E = 0; E < t.length; E++) {
+      const m = t[E];
+      try {
+        new is(m).parse().forEach((x, w) => {
+          const k = this.createThreeTexture(x);
+          this.textures.set(w.toLowerCase(), k);
+        });
+      } catch (M) {
+        console.error("[MapRenderer] Failed to parse WAD", M);
+      }
+      (o = this.onProgress) == null || o.call(this, 30 + E / t.length * 20, `Loading textures... (${E + 1}/${t.length})`);
+    }
+    console.log(`[MapRenderer] Total textures registered: ${this.textures.size}`), (u = this.onProgress) == null || u.call(this, 60, "Generating Lightmaps..."), this.generateLightmapAtlas(), (f = this.onProgress) == null || f.call(this, 70, "Building World Geometry..."), this.renderWorld(), (d = this.onProgress) == null || d.call(this, 90, "Rendering Entities..."), this.entitiesGroup = this.entityRenderer.renderEntities(this.bsp.entities), this.calculateEntityCenters(), this.drawOriginAxes(), this.renderConnections(), (v = this.onProgress) == null || v.call(this, 100, "Ready");
+  }
+  calculateEntityCenters() {
+    this.bsp && (this.entityCenters.clear(), this.bsp.entities.forEach((e) => {
+      if (e.model && e.model.startsWith("*")) {
+        const t = parseInt(e.model.substring(1)), n = this.bsp.models[t];
+        if (n) {
+          const r = new l.Vector3(1 / 0, 1 / 0, 1 / 0), i = new l.Vector3(-1 / 0, -1 / 0, -1 / 0);
+          for (let c = 0; c < n.numFaces; c++) {
+            const o = this.bsp.faces[n.firstFace + c];
+            for (let u = 0; u < o.numEdges; u++) {
+              const f = this.bsp.surfEdges[o.firstEdge + u], d = this.bsp.edges[Math.abs(f)], v = f >= 0 ? d.v[0] : d.v[1], E = this.bsp.vertices[v], m = Q(E);
+              r.min(m), i.max(m);
+            }
+          }
+          const a = new l.Vector3().addVectors(r, i).multiplyScalar(0.5);
+          if (e.origin) {
+            const c = e.origin.split(" ").map(Number);
+            c.length === 3 && a.add(Q({ x: c[0], y: c[1], z: c[2] }));
+          }
+          this.entityCenters.set(e, a);
+        }
+      } else if (e.origin) {
+        const t = e.origin.split(" ").map(Number);
+        t.length === 3 && this.entityCenters.set(e, Q({ x: t[0], y: t[1], z: t[2] }));
+      }
+    }));
+  }
+  drawOriginAxes() {
+    const t = new l.Vector3(0, 0, 0), n = new l.Vector3(0, 0, -1), r = new l.Vector3(-1, 0, 0), i = new l.Vector3(0, 1, 0), a = new l.Group();
+    a.name = "origin_axes";
+    const c = new l.ArrowHelper(n, t, 128, 16711680), o = new l.ArrowHelper(r, t, 128, 65280), u = new l.ArrowHelper(i, t, 128, 255);
+    a.add(c), a.add(o), a.add(u);
+    const f = (d, v, E) => {
+      const m = document.createElement("canvas");
+      m.width = 64, m.height = 64;
+      const M = m.getContext("2d");
+      M && (M.fillStyle = E, M.font = "Bold 48px Arial", M.textAlign = "center", M.fillText(d, 32, 48));
+      const R = new l.CanvasTexture(m), x = new l.SpriteMaterial({ map: R, depthTest: !0 }), w = new l.Sprite(x);
+      return w.position.copy(v), w.scale.set(20, 20, 1), w;
+    };
+    a.add(f("X", n.clone().multiplyScalar(143), "#ff0000")), a.add(f("Y", r.clone().multiplyScalar(143), "#00ff00")), a.add(f("Z", i.clone().multiplyScalar(143), "#0000ff")), a.visible = this.axesVisible, this.scene.add(a);
+  }
+  calcFaceTextureStep(e) {
+    if (!this.bsp) return 16;
+    const t = this.bsp.faces[e], n = this.bsp.texInfos[t.texInfo];
+    return this.bsp.version === 31 ? 8 : n.flags & 2 ? 1 : n.flags & 8 ? 8 : 16;
+  }
+  generateLightmapAtlas() {
+    if (!this.bsp) return;
+    const e = new Uint8Array(this.atlasWidth * this.atlasHeight * 4);
+    let t = 0, n = 0, r = 0;
+    for (let i = 0; i < this.bsp.faces.length; i++) {
+      const a = this.bsp.faces[i];
+      if (!a || a.lightmapOffset === -1) continue;
+      const c = this.bsp.texInfos[a.texInfo];
+      if (!c) continue;
+      const o = this.calcFaceTextureStep(i);
+      let u = 1 / 0, f = -1 / 0, d = 1 / 0, v = -1 / 0;
+      const E = a.firstEdge, m = a.numEdges;
+      for (let T = 0; T < m; T++) {
+        const H = this.bsp.surfEdges[E + T], D = this.bsp.edges[Math.abs(H)], W = H >= 0 ? D.v[0] : D.v[1], j = this.bsp.vertices[W], N = j.x * c.s.x + j.y * c.s.y + j.z * c.s.z + c.shiftS, U = j.x * c.t.x + j.y * c.t.y + j.z * c.t.z + c.shiftT;
+        u = Math.min(u, N), f = Math.max(f, N), d = Math.min(d, U), v = Math.max(v, U);
+      }
+      const M = Math.floor(u / o), R = Math.floor(d / o), x = Math.ceil(f / o), w = Math.ceil(v / o), k = x - M + 1, O = w - R + 1, I = k + 2, $ = O + 2;
+      if (t + I > this.atlasWidth && (t = 0, n += r, r = 0), n + $ > this.atlasHeight) continue;
+      const z = k * O * 3;
+      if (a.lightmapOffset + z <= this.bsp.lighting.length) {
+        const T = this.bsp.lighting.subarray(a.lightmapOffset, a.lightmapOffset + z), H = (D, W) => {
+          const j = Math.max(0, Math.min(k - 1, D)), U = (Math.max(0, Math.min(O - 1, W)) * k + j) * 3;
+          return [T[U], T[U + 1], T[U + 2]];
+        };
+        for (let D = 0; D < $; D++)
+          for (let W = 0; W < I; W++) {
+            const [j, N, U] = H(W - 1, D - 1), Y = ((n + D) * this.atlasWidth + (t + W)) * 4;
+            e[Y + 0] = j, e[Y + 1] = N, e[Y + 2] = U, e[Y + 3] = 255;
+          }
+      }
+      this.faceLightmapInfo.set(i, { x: t, y: n, w: k, h: O, minU_step: M, minV_step: R, step: o }), t += I, r = Math.max(r, $);
+    }
+    this.lightmapAtlas = new l.DataTexture(e, this.atlasWidth, this.atlasHeight, l.RGBAFormat), this.lightmapAtlas.magFilter = l.LinearFilter, this.lightmapAtlas.minFilter = l.LinearFilter, this.lightmapAtlas.generateMipmaps = !1, this.lightmapAtlas.needsUpdate = !0;
+  }
+  getEntityByModelIndex(e) {
+    if (this.bsp)
+      return this.bsp.entities.find((t) => t.model === `*${e}`);
+  }
+  createThreeTexture(e) {
+    const { width: t, height: n, data: r, palette: i } = e;
+    if (!r || !i)
+      return console.warn(`[MapRenderer] Missing data/palette for texture ${e.name}`), new l.DataTexture(new Uint8Array([255, 0, 255, 255]), 1, 1, l.RGBAFormat);
+    const a = new Uint8Array(t * n * 4), c = e.name.startsWith("{");
+    for (let u = 0; u < t * n; u++) {
+      const f = r[u], d = f * 3;
+      a[u * 4 + 0] = i[d + 0], a[u * 4 + 1] = i[d + 1], a[u * 4 + 2] = i[d + 2], a[u * 4 + 3] = c && f === 255 ? 0 : 255;
+    }
+    const o = new l.DataTexture(a, t, n, l.RGBAFormat);
+    return o.wrapS = l.RepeatWrapping, o.wrapT = l.RepeatWrapping, o.minFilter = l.LinearFilter, o.magFilter = l.LinearFilter, o.needsUpdate = !0, o;
+  }
+  getMaterial(e, t, n = 1) {
+    const r = e.name.toLowerCase(), i = `${r}-${t}-${n}`;
+    if (this.materialCache.has(i)) return this.materialCache.get(i);
+    const a = this.textures.get(r);
+    a || console.warn(`[MapRenderer] Texture not found in registry: ${r}`);
+    const c = new l.ShaderMaterial({
+      uniforms: {
+        diffuseMap: { value: a || null },
+        lightmapAtlas: { value: this.lightmapAtlas },
+        hasLightmap: { value: t },
+        opacity: { value: n }
+      },
+      vertexShader: Ye.vertexShader,
+      fragmentShader: Ye.fragmentShader,
+      transparent: e.name.startsWith("{") || n < 1,
+      side: l.FrontSide,
+      depthWrite: n >= 1
+    });
+    return this.materialCache.set(i, c), c;
+  }
+  renderWorld() {
+    if (!this.bsp) return;
+    this.worldGroup = new l.Group(), this.worldGroup.name = "world", this.leafToMaterials.clear(), this.materialMeshes.clear();
+    const t = this.bsp.models.map((i) => {
+      const a = /* @__PURE__ */ new Set();
+      for (let c = 0; c < i.numFaces; c++)
+        a.add(i.firstFace + c);
+      return a;
+    })[0], n = /* @__PURE__ */ new Map(), r = [];
+    for (let i = 0; i < this.bsp.faces.length; i++) {
+      if (!t.has(i)) {
+        r[i] = "";
+        continue;
+      }
+      const a = this.bsp.faces[i], c = this.bsp.texInfos[a.texInfo], o = this.bsp.textures[c.miptex];
+      if (!o) {
+        r[i] = "";
+        continue;
+      }
+      const u = this.faceLightmapInfo.get(i), f = u ? { x: u.x, y: u.y, atlasWidth: this.atlasWidth, atlasHeight: this.atlasHeight, minU_step: u.minU_step, minV_step: u.minV_step, step: u.step } : void 0, d = He(this.bsp, i, f);
+      if (!d) {
+        r[i] = "";
+        continue;
+      }
+      const v = this.getMaterial(o, !!u), E = `${o.name}-${!!u}-1`;
+      r[i] = E, n.has(E) || n.set(E, { pos: [], uv: [], luv: [], mat: v });
+      const m = n.get(E);
+      m.pos.push(...Array.from(d.positions)), m.uv.push(...Array.from(d.uvs)), m.luv.push(...Array.from(d.lightUvs));
+    }
+    this.bsp.leaves.forEach((i, a) => {
+      this.leafToMaterials.has(a) || this.leafToMaterials.set(a, /* @__PURE__ */ new Set());
+      for (let c = 0; c < i.numMarkSurfaces; c++) {
+        const o = this.bsp.markSurfaces[i.firstMarkSurface + c], u = r[o];
+        u && this.leafToMaterials.get(a).add(u);
+      }
+    }), n.forEach((i, a) => {
+      const c = new l.BufferGeometry();
+      c.setAttribute("position", new l.BufferAttribute(new Float32Array(i.pos), 3)), c.setAttribute("uv", new l.BufferAttribute(new Float32Array(i.uv), 2)), c.setAttribute("lightUv", new l.BufferAttribute(new Float32Array(i.luv), 2)), c.computeVertexNormals();
+      const o = new l.Mesh(c, i.mat);
+      o.name = `material_${a}`, this.worldGroup.add(o), this.materialMeshes.set(a, o);
+    }), this.scene.add(this.worldGroup), this.brushEntitiesGroup = new l.Group(), this.brushEntitiesGroup.name = "brush_entities";
+    for (let i = 1; i < this.bsp.models.length; i++) {
+      const a = this.getEntityByModelIndex(i), c = this.bsp.models[i];
+      let o = !1;
+      for (let m = 0; m < c.numFaces; m++) {
+        const M = c.firstFace + m, R = this.bsp.faces[M], x = this.bsp.texInfos[R.texInfo], w = this.bsp.textures[x.miptex];
+        if (w && w.name.toLowerCase() === "aaatrigger") {
+          o = !0;
+          break;
+        }
+      }
+      let u = 1;
+      const f = a ? parseInt(a.rendermode || "0") : 0;
+      o ? u = this.aaaTriggerOpacity : a && f !== 0 && a.renderamt !== void 0 && (u = parseInt(a.renderamt) / 255);
+      const d = new l.Group();
+      if (d.name = `model_${i}`, a) {
+        if (d.userData.entity = a, a.origin) {
+          const m = a.origin.split(" ").map(Number);
+          m.length === 3 && d.position.copy(Q({ x: m[0], y: m[1], z: m[2] }));
+        }
+        if (a.angles) {
+          const m = a.angles.split(" ").map(Number);
+          if (m.length === 3) {
+            const M = l.MathUtils.degToRad(m[0]), R = l.MathUtils.degToRad(m[1]), x = l.MathUtils.degToRad(m[2]);
+            d.rotation.set(M, R, x, "YXZ");
+          }
+        }
+      }
+      const v = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new Set();
+      for (let m = 0; m < c.numFaces; m++) {
+        const M = c.firstFace + m, R = this.bsp.faces[M], x = this.bsp.texInfos[R.texInfo], w = this.bsp.textures[x.miptex], k = this.faceLightmapInfo.get(M), O = k ? { x: k.x, y: k.y, atlasWidth: this.atlasWidth, atlasHeight: this.atlasHeight, minU_step: k.minU_step, minV_step: k.minV_step, step: k.step } : void 0, I = He(this.bsp, M, O);
+        if (!I) continue;
+        const $ = this.getMaterial(w, !!k, u), z = `${w.name}-${!!k}-${u}`;
+        w.name && E.add(w.name), v.has(z) || v.set(z, { pos: [], uv: [], luv: [], mat: $ });
+        const T = v.get(z);
+        T.pos.push(...Array.from(I.positions)), T.uv.push(...Array.from(I.uvs)), T.luv.push(...Array.from(I.lightUvs));
+      }
+      a && (a.info_textures = Array.from(E).join(";")), v.forEach((m) => {
+        const M = new l.BufferGeometry();
+        M.setAttribute("position", new l.BufferAttribute(new Float32Array(m.pos), 3)), M.setAttribute("uv", new l.BufferAttribute(new Float32Array(m.uv), 2)), M.setAttribute("lightUv", new l.BufferAttribute(new Float32Array(m.luv), 2)), M.computeVertexNormals(), M.computeBoundingBox(), M.computeBoundingSphere();
+        const R = new l.Mesh(M, m.mat);
+        R.userData.entity = a;
+        const x = new l.EdgesGeometry(M), w = new l.LineBasicMaterial({ color: 16777215, transparent: !0, opacity: 0.5 }), k = new l.LineSegments(x, w);
+        k.name = "helper_wireframe", k.visible = this.brushWireframesVisible, R.add(k), d.add(R);
+      }), this.brushEntitiesGroup.add(d);
+    }
+    this.scene.add(this.brushEntitiesGroup);
+  }
+  setEntitiesVisible(e) {
+    this.entitiesGroup && (this.entitiesGroup.visible = e);
+  }
+  setBrushEntitiesVisible(e) {
+    this.brushEntitiesGroup && (this.brushEntitiesGroup.visible = e);
+  }
+  setBrushWireframesVisible(e) {
+    this.brushWireframesVisible = e, this.bsp && this.brushEntitiesGroup && (this.brushEntitiesGroup.traverse((t) => {
+      t.name === "helper_wireframe" && (t.visible = e);
+    }), this.selectedEntity && this.highlightEntity(this.selectedEntity));
+  }
+  setAxesVisible(e) {
+    this.axesVisible = e;
+    const t = this.scene.getObjectByName("origin_axes");
+    t && (t.visible = e);
+  }
+  setAaaTriggerOpacity(e) {
+    this.aaaTriggerOpacity = e / 100, this.bsp && (this.materialCache.forEach((t, n) => {
+      n.toLowerCase().startsWith("aaatrigger-") && (t.uniforms.opacity.value = this.aaaTriggerOpacity, t.transparent = this.aaaTriggerOpacity < 1, t.depthWrite = this.aaaTriggerOpacity >= 1, t.needsUpdate = !0);
+    }), this.brushEntitiesGroup && this.brushEntitiesGroup.traverse((t) => {
+      var n;
+      if (t instanceof l.Mesh) {
+        const r = t.userData.entity, i = (n = r == null ? void 0 : r.model) != null && n.startsWith("*") ? parseInt(r.model.substring(1)) : -1;
+        if (i !== -1) {
+          const a = this.bsp.models[i];
+          let c = !1;
+          for (let o = 0; o < a.numFaces; o++) {
+            const u = a.firstFace + o, f = this.bsp.faces[u], d = this.bsp.texInfos[f.texInfo], v = this.bsp.textures[d.miptex];
+            if (v && v.name.toLowerCase() === "aaatrigger") {
+              c = !0;
+              break;
+            }
+          }
+          c && t.material instanceof l.ShaderMaterial && (t.material.uniforms.opacity.value = this.aaaTriggerOpacity, t.material.transparent = this.aaaTriggerOpacity < 1, t.material.depthWrite = this.aaaTriggerOpacity >= 1);
+        }
+      }
+    }));
+  }
+  setEntityConnectionsMode(e) {
+    this.entityConnectionsMode = e, this.bsp && this.renderConnections();
+  }
+  setTextureFiltering(e) {
+    const t = e ? l.LinearFilter : l.NearestFilter;
+    this.textures.forEach((n) => {
+      n.magFilter = t, n.minFilter = t, n.needsUpdate = !0;
+    });
+  }
+  setLightmapFiltering(e) {
+    if (!this.lightmapAtlas) return;
+    const t = e ? l.LinearFilter : l.NearestFilter;
+    this.lightmapAtlas.magFilter = t, this.lightmapAtlas.minFilter = t, this.lightmapAtlas.needsUpdate = !0;
+  }
+  setPvsEnabled(e) {
+    this.pvsEnabled !== e && (this.pvsEnabled = e, e || (this.materialMeshes.forEach((t) => {
+      t.visible = !0;
+    }), this.currentLeafIdx = -1));
+  }
+  highlightEntity(e) {
+    this.clearHighlight(), this.selectedEntity = e, this.highlightGroup = new l.Group(), this.highlightGroup.name = "selection_highlight";
+    const t = [];
+    if (this.scene.traverse((o) => {
+      o instanceof l.Mesh && o.userData.entity === e && t.push(o);
+    }), t.length === 0) return;
+    const n = new l.LineBasicMaterial({ color: 16711680, transparent: !1, depthTest: !1 }), r = new l.PointsMaterial({ color: 16711680, size: 5, sizeAttenuation: !1, depthTest: !1 });
+    t.forEach((o) => {
+      const u = new l.EdgesGeometry(o.geometry), f = new l.LineSegments(u, n);
+      f.renderOrder = 9999, f.position.copy(o.position), f.quaternion.copy(o.quaternion), f.scale.copy(o.scale), o.parent && o.parent !== this.scene && o.parent !== this.brushEntitiesGroup && (f.position.applyMatrix4(o.parent.matrixWorld), f.quaternion.setFromRotationMatrix(o.parent.matrixWorld)), o.children.forEach((d) => {
+        (d.name === "helper_wireframe" || d.name === "point_helper_wireframe") && (d.visible = !1);
+      }), this.highlightGroup.add(f);
+    });
+    let i = new l.Vector3(0, 0, 0);
+    if (e.origin) {
+      const o = e.origin.split(" ").map(Number);
+      o.length === 3 && (i = Q({ x: o[0], y: o[1], z: o[2] }));
+    } else if (e.model && e.model.startsWith("*")) {
+      const o = this.entityCenters.get(e);
+      o && i.copy(o);
+    }
+    const a = new l.BufferGeometry().setAttribute("position", new l.BufferAttribute(new Float32Array([i.x, i.y, i.z]), 3)), c = new l.Points(a, r);
+    c.renderOrder = 1e4, this.highlightGroup.add(c), this.scene.add(this.highlightGroup);
+  }
+  clearHighlight() {
+    this.selectedEntity = null, this.scene.traverse((e) => {
+      e.name === "helper_wireframe" ? e.visible = this.brushWireframesVisible : e.name === "point_helper_wireframe" && (e.visible = !0);
+    }), this.highlightGroup && (this.highlightGroup.traverse((e) => {
+      (e instanceof l.Mesh || e instanceof l.LineSegments || e instanceof l.Points) && e.geometry && e.geometry.dispose();
+    }), this.scene.remove(this.highlightGroup), this.highlightGroup = null);
+  }
+  clearConnections() {
+    this.connectionsGroup && (this.connectionsGroup.traverse((e) => {
+      e.geometry && e.geometry.dispose(), e.material && e.material.dispose();
+    }), this.scene.remove(this.connectionsGroup), this.connectionsGroup = null);
+  }
+  renderConnections() {
+    if (this.clearConnections(), this.entityConnectionsMode === "none" || !this.bsp) return;
+    this.connectionsGroup = new l.Group(), this.connectionsGroup.name = "entity_connections";
+    const e = this.bsp.entities, t = /* @__PURE__ */ new Map();
+    e.forEach((n) => {
+      if (n.targetname) {
+        const r = n.targetname.toLowerCase();
+        t.has(r) || t.set(r, []), t.get(r).push(n);
+      }
+    }), e.forEach((n) => {
+      if (n.target) {
+        const r = n.target.toLowerCase(), i = t.get(r);
+        i && i.forEach((a) => {
+          const c = this.entityCenters.get(n), o = this.entityCenters.get(a);
+          if (c && o) {
+            let u = !1, f = this.connectionMaterials.yellow;
+            if (this.entityConnectionsMode === "all" ? (u = !0, f = this.connectionMaterials.yellow) : this.entityConnectionsMode === "selected" && this.selectedEntity && (n === this.selectedEntity ? (u = !0, f = this.connectionMaterials.yellow) : a === this.selectedEntity && (u = !0, f = this.connectionMaterials.green)), u) {
+              const d = new l.BufferGeometry().setFromPoints([c, o]), v = new l.Line(d, f);
+              this.connectionsGroup.add(v);
+            }
+          }
+        });
+      }
+    }), this.scene.add(this.connectionsGroup);
+  }
+  updateVisibility(e) {
+    if (!this.pvsManager || !this.pvsEnabled) return;
+    const t = this.pvsManager.getLeafIndex(e);
+    if (t === this.currentLeafIdx) return;
+    this.currentLeafIdx = t;
+    const n = this.pvsManager.getVisibleLeafs(t), r = new Set(n), i = /* @__PURE__ */ new Set();
+    r.forEach((a) => {
+      const c = this.leafToMaterials.get(a);
+      c && c.forEach((o) => i.add(o));
+    }), this.materialMeshes.forEach((a, c) => {
+      a.visible = i.has(c);
+    });
+  }
+}
+class cs {
+  constructor(e) {
+    g(this, "camera");
+    g(this, "velocity", new l.Vector3());
+    g(this, "moveForward", !1);
+    g(this, "moveBackward", !1);
+    g(this, "moveLeft", !1);
+    g(this, "moveRight", !1);
+    g(this, "moveUp", !1);
+    g(this, "moveDown", !1);
+    g(this, "isSprinting", !1);
+    g(this, "enabled", !1);
+    g(this, "onKeyDown", (e) => {
+      if (this.enabled)
+        switch (e.code) {
+          case "KeyW":
+            this.moveForward = !0;
+            break;
+          case "KeyS":
+            this.moveBackward = !0;
+            break;
+          case "KeyA":
+            this.moveLeft = !0;
+            break;
+          case "KeyD":
+            this.moveRight = !0;
+            break;
+          case "Space":
+            this.moveUp = !0;
+            break;
+          case "ControlLeft":
+            this.moveDown = !0;
+            break;
+          case "ShiftLeft":
+          case "ShiftRight":
+            this.isSprinting = !0;
+            break;
+        }
+    });
+    g(this, "onKeyUp", (e) => {
+      if (this.enabled)
+        switch (e.code) {
+          case "KeyW":
+            this.moveForward = !1;
+            break;
+          case "KeyS":
+            this.moveBackward = !1;
+            break;
+          case "KeyA":
+            this.moveLeft = !1;
+            break;
+          case "KeyD":
+            this.moveRight = !1;
+            break;
+          case "Space":
+            this.moveUp = !1;
+            break;
+          case "ControlLeft":
+            this.moveDown = !1;
+            break;
+          case "ShiftLeft":
+          case "ShiftRight":
+            this.isSprinting = !1;
+            break;
+        }
+    });
+    this.camera = e, window.addEventListener("keydown", this.onKeyDown), window.addEventListener("keyup", this.onKeyUp);
+  }
+  update(e) {
+    const t = Math.min(e, 0.1), n = 5e3, r = this.isSprinting ? n * 2 : n, i = 15, a = 800, c = this.isSprinting ? a * 2 : a, o = new l.Vector3();
+    o.z = Number(this.moveForward) - Number(this.moveBackward), o.x = Number(this.moveRight) - Number(this.moveLeft), o.y = Number(this.moveUp) - Number(this.moveDown), o.normalize(), (this.moveForward || this.moveBackward) && (this.velocity.z += o.z * r * t), (this.moveLeft || this.moveRight) && (this.velocity.x += o.x * r * t), (this.moveUp || this.moveDown) && (this.velocity.y += o.y * r * t), this.velocity.x -= this.velocity.x * i * t, this.velocity.z -= this.velocity.z * i * t, this.velocity.y -= this.velocity.y * i * t;
+    const u = this.velocity.length();
+    u > c && this.velocity.multiplyScalar(c / u), Math.abs(this.velocity.x) < 1 && (this.velocity.x = 0), Math.abs(this.velocity.y) < 1 && (this.velocity.y = 0), Math.abs(this.velocity.z) < 1 && (this.velocity.z = 0);
+    const f = new l.Vector3(0, 0, -1).applyQuaternion(this.camera.quaternion), d = new l.Vector3(1, 0, 0).applyQuaternion(this.camera.quaternion), v = new l.Vector3(0, 1, 0), E = new l.Vector3();
+    E.addScaledVector(f, this.velocity.z * t), E.addScaledVector(d, this.velocity.x * t), E.addScaledVector(v, this.velocity.y * t), this.camera.position.add(E);
+  }
+  dispose() {
+    window.removeEventListener("keydown", this.onKeyDown), window.removeEventListener("keyup", this.onKeyUp);
+  }
+}
+class ls {
+  constructor(e) {
+    g(this, "container");
+    g(this, "scene");
+    g(this, "camera");
+    g(this, "renderer");
+    g(this, "controls");
+    g(this, "navigator");
+    g(this, "mapRenderer");
+    g(this, "clock");
+    g(this, "requestRef", 0);
+    g(this, "options");
+    g(this, "selectedEntity", null);
+    g(this, "resizeObserver");
+    g(this, "onClickBound");
+    g(this, "eventListeners", /* @__PURE__ */ new Map());
+    this.container = e.container, this.options = {
+      container: e.container,
+      backgroundColor: e.backgroundColor ?? 328965,
+      showAxes: e.showAxes ?? !0,
+      onEntitySelect: e.onEntitySelect ?? (() => {
+      }),
+      onProgress: e.onProgress ?? (() => {
+      }),
+      onLockChange: e.onLockChange ?? (() => {
+      }),
+      pvsEnabled: e.pvsEnabled ?? !1,
+      showPointEntities: e.showPointEntities ?? !0,
+      showBrushEntities: e.showBrushEntities ?? !0,
+      showBrushWireframes: e.showBrushWireframes ?? !0,
+      aaaTriggerOpacity: e.aaaTriggerOpacity ?? 50,
+      entityConnectionsMode: e.entityConnectionsMode ?? "none",
+      textureFiltering: e.textureFiltering ?? !0,
+      lightmapFiltering: e.lightmapFiltering ?? !0,
+      antialias: e.antialias ?? !0
+    }, this.scene = new l.Scene(), this.scene.background = new l.Color(this.options.backgroundColor);
+    const t = this.container.clientWidth / this.container.clientHeight;
+    this.camera = new l.PerspectiveCamera(75, t, 0.1, 1e4), this.camera.position.set(0, 500, 1e3), this.renderer = new l.WebGLRenderer({ antialias: this.options.antialias }), this.renderer.setSize(this.container.clientWidth, this.container.clientHeight), this.renderer.setPixelRatio(window.devicePixelRatio), this.container.appendChild(this.renderer.domElement), this.controls = new Ot(this.camera, this.renderer.domElement), this.navigator = new cs(this.camera);
+    const n = (r, i) => {
+      this.emit("progress", { percent: r, message: i }), this.options.onProgress(r, i);
+    };
+    this.mapRenderer = new os(this.scene, n), this.clock = new l.Clock(), this.onClickBound = this.onClick.bind(this), this.resizeObserver = new ResizeObserver(() => this.onResize()), this.resizeObserver.observe(this.container), this.setupEventListeners(), this.startAnimate(), this.applyOptions(), e.onEntitySelect && this.addEventListener("entitySelect", e.onEntitySelect), e.onLockChange && this.addEventListener("lockChange", e.onLockChange);
+  }
+  setupEventListeners() {
+    this.controls.addEventListener("lock", () => {
+      this.navigator.enabled = !0, this.emit("lockChange", !0);
+    }), this.controls.addEventListener("unlock", () => {
+      this.navigator.enabled = !1, this.emit("lockChange", !1);
+    }), this.container.addEventListener("click", this.onClickBound);
+  }
+  onResize() {
+    const e = this.container.clientWidth, t = this.container.clientHeight;
+    e === 0 || t === 0 || (this.camera.aspect = e / t, this.camera.updateProjectionMatrix(), this.renderer.setSize(e, t));
+  }
+  onClick() {
+    if (this.controls.isLocked)
+      this.handlePicking();
+    else
+      try {
+        this.controls.lock();
+      } catch (e) {
+        console.warn("Pointer lock failed:", e);
+      }
+  }
+  startAnimate() {
+    const e = () => {
+      this.requestRef = requestAnimationFrame(e);
+      const t = this.clock.getDelta();
+      this.navigator.update(t), this.mapRenderer.updateVisibility(this.camera.position), this.renderer.render(this.scene, this.camera);
+    };
+    this.requestRef = requestAnimationFrame(e);
+  }
+  handlePicking() {
+    const e = new l.Raycaster();
+    e.setFromCamera(new l.Vector2(0, 0), this.camera);
+    const t = this.scene.children.filter(
+      (r) => r.name !== "entity_connections" && r.name !== "selection_highlight" && r.name !== "origin_axes"
+    ), n = e.intersectObjects(t, !0);
+    if (n.length > 0) {
+      const r = n[0].object;
+      let i = r, a = !0;
+      for (; i; ) {
+        if (!i.visible) {
+          a = !1;
+          break;
+        }
+        i = i.parent;
+      }
+      if (!a) {
+        this.setSelectedEntity(null);
+        return;
+      }
+      let c = null, o = r;
+      for (; o; ) {
+        if (o.userData.entity) {
+          c = o.userData.entity;
+          break;
+        }
+        o = o.parent;
+      }
+      this.setSelectedEntity(c);
+    } else
+      this.setSelectedEntity(null);
+  }
+  async loadMap(e, t, n) {
+    await this.mapRenderer.loadMap(e, t, n), this.applyOptions(), this.setSelectedEntity(this.selectedEntity);
+  }
+  resetView() {
+    this.camera.position.set(0, 500, 1e3), this.camera.lookAt(0, 0, 0);
+  }
+  destroy() {
+    cancelAnimationFrame(this.requestRef), this.resizeObserver.disconnect(), this.container.removeEventListener("click", this.onClickBound), this.controls.dispose(), this.navigator.dispose(), this.mapRenderer.dispose(), this.renderer.dispose(), this.container.contains(this.renderer.domElement) && this.container.removeChild(this.renderer.domElement), this.eventListeners.clear();
+  }
+  // Alias for compatibility if needed, but destroy is the preferred name now
+  dispose() {
+    this.destroy();
+  }
+  // Event Emitter methods
+  addEventListener(e, t) {
+    this.eventListeners.has(e) || this.eventListeners.set(e, /* @__PURE__ */ new Set()), this.eventListeners.get(e).add(t);
+  }
+  removeEventListener(e, t) {
+    var n;
+    (n = this.eventListeners.get(e)) == null || n.delete(t);
+  }
+  emit(e, ...t) {
+    var n;
+    (n = this.eventListeners.get(e)) == null || n.forEach((r) => r(...t));
+  }
+  setOptions(e) {
+    this.options = { ...this.options, ...e }, this.applyOptions(), e.backgroundColor !== void 0 && (this.scene.background = new l.Color(this.options.backgroundColor));
+  }
+  applyOptions() {
+    this.mapRenderer.setPvsEnabled(this.options.pvsEnabled), this.mapRenderer.setEntitiesVisible(this.options.showPointEntities), this.mapRenderer.setBrushEntitiesVisible(this.options.showBrushEntities), this.mapRenderer.setBrushWireframesVisible(this.options.showBrushWireframes), this.mapRenderer.setAxesVisible(this.options.showAxes), this.mapRenderer.setAaaTriggerOpacity(this.options.aaaTriggerOpacity), this.mapRenderer.setEntityConnectionsMode(this.options.entityConnectionsMode), this.mapRenderer.setTextureFiltering(this.options.textureFiltering), this.mapRenderer.setLightmapFiltering(this.options.lightmapFiltering);
+  }
+  // Proxy methods to MapRenderer (kept for backward compatibility and granular control)
+  setPvsEnabled(e) {
+    this.options.pvsEnabled = e, this.mapRenderer.setPvsEnabled(e);
+  }
+  setPointEntitiesVisible(e) {
+    this.options.showPointEntities = e, this.mapRenderer.setEntitiesVisible(e);
+  }
+  setBrushEntitiesVisible(e) {
+    this.options.showBrushEntities = e, this.mapRenderer.setBrushEntitiesVisible(e);
+  }
+  setBrushWireframesVisible(e) {
+    this.options.showBrushWireframes = e, this.mapRenderer.setBrushWireframesVisible(e);
+  }
+  setAxesVisible(e) {
+    this.options.showAxes = e, this.mapRenderer.setAxesVisible(e);
+  }
+  setAaaTriggerOpacity(e) {
+    this.options.aaaTriggerOpacity = e, this.mapRenderer.setAaaTriggerOpacity(e);
+  }
+  setEntityConnectionsMode(e) {
+    this.options.entityConnectionsMode = e, this.mapRenderer.setEntityConnectionsMode(e);
+  }
+  setTextureFiltering(e) {
+    this.options.textureFiltering = e, this.mapRenderer.setTextureFiltering(e);
+  }
+  setLightmapFiltering(e) {
+    this.options.lightmapFiltering = e, this.mapRenderer.setLightmapFiltering(e);
+  }
+  setSelectedEntity(e) {
+    this.selectedEntity = e, e ? this.mapRenderer.highlightEntity(e) : this.mapRenderer.clearHighlight(), this.options.entityConnectionsMode === "selected" && this.mapRenderer.setEntityConnectionsMode("selected"), this.emit("entitySelect", e);
+  }
+}
+var oe = { exports: {} }, te = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ke;
+function hs() {
+  if (Ke) return te;
+  Ke = 1;
+  var y = Je, e = Symbol.for("react.element"), t = Symbol.for("react.fragment"), n = Object.prototype.hasOwnProperty, r = y.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, i = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function a(c, o, u) {
+    var f, d = {}, v = null, E = null;
+    u !== void 0 && (v = "" + u), o.key !== void 0 && (v = "" + o.key), o.ref !== void 0 && (E = o.ref);
+    for (f in o) n.call(o, f) && !i.hasOwnProperty(f) && (d[f] = o[f]);
+    if (c && c.defaultProps) for (f in o = c.defaultProps, o) d[f] === void 0 && (d[f] = o[f]);
+    return { $$typeof: e, type: c, key: v, ref: E, props: d, _owner: r.current };
+  }
+  return te.Fragment = t, te.jsx = a, te.jsxs = a, te;
+}
+var se = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var qe;
+function us() {
+  return qe || (qe = 1, process.env.NODE_ENV !== "production" && (function() {
+    var y = Je, e = Symbol.for("react.element"), t = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), r = Symbol.for("react.strict_mode"), i = Symbol.for("react.profiler"), a = Symbol.for("react.provider"), c = Symbol.for("react.context"), o = Symbol.for("react.forward_ref"), u = Symbol.for("react.suspense"), f = Symbol.for("react.suspense_list"), d = Symbol.for("react.memo"), v = Symbol.for("react.lazy"), E = Symbol.for("react.offscreen"), m = Symbol.iterator, M = "@@iterator";
+    function R(s) {
+      if (s === null || typeof s != "object")
+        return null;
+      var h = m && s[m] || s[M];
+      return typeof h == "function" ? h : null;
+    }
+    var x = y.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function w(s) {
+      {
+        for (var h = arguments.length, p = new Array(h > 1 ? h - 1 : 0), b = 1; b < h; b++)
+          p[b - 1] = arguments[b];
+        k("error", s, p);
+      }
+    }
+    function k(s, h, p) {
+      {
+        var b = x.ReactDebugCurrentFrame, L = b.getStackAddendum();
+        L !== "" && (h += "%s", p = p.concat([L]));
+        var F = p.map(function(S) {
+          return String(S);
+        });
+        F.unshift("Warning: " + h), Function.prototype.apply.call(console[s], console, F);
+      }
+    }
+    var O = !1, I = !1, $ = !1, z = !1, T = !1, H;
+    H = Symbol.for("react.module.reference");
+    function D(s) {
+      return !!(typeof s == "string" || typeof s == "function" || s === n || s === i || T || s === r || s === u || s === f || z || s === E || O || I || $ || typeof s == "object" && s !== null && (s.$$typeof === v || s.$$typeof === d || s.$$typeof === a || s.$$typeof === c || s.$$typeof === o || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      s.$$typeof === H || s.getModuleId !== void 0));
+    }
+    function W(s, h, p) {
+      var b = s.displayName;
+      if (b)
+        return b;
+      var L = h.displayName || h.name || "";
+      return L !== "" ? p + "(" + L + ")" : p;
+    }
+    function j(s) {
+      return s.displayName || "Context";
+    }
+    function N(s) {
+      if (s == null)
+        return null;
+      if (typeof s.tag == "number" && w("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof s == "function")
+        return s.displayName || s.name || null;
+      if (typeof s == "string")
+        return s;
+      switch (s) {
+        case n:
+          return "Fragment";
+        case t:
+          return "Portal";
+        case i:
+          return "Profiler";
+        case r:
+          return "StrictMode";
+        case u:
+          return "Suspense";
+        case f:
+          return "SuspenseList";
+      }
+      if (typeof s == "object")
+        switch (s.$$typeof) {
+          case c:
+            var h = s;
+            return j(h) + ".Consumer";
+          case a:
+            var p = s;
+            return j(p._context) + ".Provider";
+          case o:
+            return W(s, s.render, "ForwardRef");
+          case d:
+            var b = s.displayName || null;
+            return b !== null ? b : N(s.type) || "Memo";
+          case v: {
+            var L = s, F = L._payload, S = L._init;
+            try {
+              return N(S(F));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var U = Object.assign, Y = 0, xe, Ee, Me, Re, Ce, _e, Se;
+    function ke() {
+    }
+    ke.__reactDisabledLog = !0;
+    function et() {
+      {
+        if (Y === 0) {
+          xe = console.log, Ee = console.info, Me = console.warn, Re = console.error, Ce = console.group, _e = console.groupCollapsed, Se = console.groupEnd;
+          var s = {
+            configurable: !0,
+            enumerable: !0,
+            value: ke,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: s,
+            log: s,
+            warn: s,
+            error: s,
+            group: s,
+            groupCollapsed: s,
+            groupEnd: s
+          });
+        }
+        Y++;
+      }
+    }
+    function tt() {
+      {
+        if (Y--, Y === 0) {
+          var s = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: U({}, s, {
+              value: xe
+            }),
+            info: U({}, s, {
+              value: Ee
+            }),
+            warn: U({}, s, {
+              value: Me
+            }),
+            error: U({}, s, {
+              value: Re
+            }),
+            group: U({}, s, {
+              value: Ce
+            }),
+            groupCollapsed: U({}, s, {
+              value: _e
+            }),
+            groupEnd: U({}, s, {
+              value: Se
+            })
+          });
+        }
+        Y < 0 && w("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var ce = x.ReactCurrentDispatcher, le;
+    function ie(s, h, p) {
+      {
+        if (le === void 0)
+          try {
+            throw Error();
+          } catch (L) {
+            var b = L.stack.trim().match(/\n( *(at )?)/);
+            le = b && b[1] || "";
+          }
+        return `
+` + le + s;
+      }
+    }
+    var he = !1, re;
+    {
+      var st = typeof WeakMap == "function" ? WeakMap : Map;
+      re = new st();
+    }
+    function Le(s, h) {
+      if (!s || he)
+        return "";
+      {
+        var p = re.get(s);
+        if (p !== void 0)
+          return p;
+      }
+      var b;
+      he = !0;
+      var L = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var F;
+      F = ce.current, ce.current = null, et();
+      try {
+        if (h) {
+          var S = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(S.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(S, []);
+            } catch (G) {
+              b = G;
+            }
+            Reflect.construct(s, [], S);
+          } else {
+            try {
+              S.call();
+            } catch (G) {
+              b = G;
+            }
+            s.call(S.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (G) {
+            b = G;
+          }
+          s();
+        }
+      } catch (G) {
+        if (G && b && typeof G.stack == "string") {
+          for (var C = G.stack.split(`
+`), V = b.stack.split(`
+`), P = C.length - 1, A = V.length - 1; P >= 1 && A >= 0 && C[P] !== V[A]; )
+            A--;
+          for (; P >= 1 && A >= 0; P--, A--)
+            if (C[P] !== V[A]) {
+              if (P !== 1 || A !== 1)
+                do
+                  if (P--, A--, A < 0 || C[P] !== V[A]) {
+                    var B = `
+` + C[P].replace(" at new ", " at ");
+                    return s.displayName && B.includes("<anonymous>") && (B = B.replace("<anonymous>", s.displayName)), typeof s == "function" && re.set(s, B), B;
+                  }
+                while (P >= 1 && A >= 0);
+              break;
+            }
+        }
+      } finally {
+        he = !1, ce.current = F, tt(), Error.prepareStackTrace = L;
+      }
+      var X = s ? s.displayName || s.name : "", K = X ? ie(X) : "";
+      return typeof s == "function" && re.set(s, K), K;
+    }
+    function it(s, h, p) {
+      return Le(s, !1);
+    }
+    function rt(s) {
+      var h = s.prototype;
+      return !!(h && h.isReactComponent);
+    }
+    function ne(s, h, p) {
+      if (s == null)
+        return "";
+      if (typeof s == "function")
+        return Le(s, rt(s));
+      if (typeof s == "string")
+        return ie(s);
+      switch (s) {
+        case u:
+          return ie("Suspense");
+        case f:
+          return ie("SuspenseList");
+      }
+      if (typeof s == "object")
+        switch (s.$$typeof) {
+          case o:
+            return it(s.render);
+          case d:
+            return ne(s.type, h, p);
+          case v: {
+            var b = s, L = b._payload, F = b._init;
+            try {
+              return ne(F(L), h, p);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var ee = Object.prototype.hasOwnProperty, Fe = {}, Pe = x.ReactDebugCurrentFrame;
+    function ae(s) {
+      if (s) {
+        var h = s._owner, p = ne(s.type, s._source, h ? h.type : null);
+        Pe.setExtraStackFrame(p);
+      } else
+        Pe.setExtraStackFrame(null);
+    }
+    function nt(s, h, p, b, L) {
+      {
+        var F = Function.call.bind(ee);
+        for (var S in s)
+          if (F(s, S)) {
+            var C = void 0;
+            try {
+              if (typeof s[S] != "function") {
+                var V = Error((b || "React class") + ": " + p + " type `" + S + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof s[S] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw V.name = "Invariant Violation", V;
+              }
+              C = s[S](h, S, b, p, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (P) {
+              C = P;
+            }
+            C && !(C instanceof Error) && (ae(L), w("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", b || "React class", p, S, typeof C), ae(null)), C instanceof Error && !(C.message in Fe) && (Fe[C.message] = !0, ae(L), w("Failed %s type: %s", p, C.message), ae(null));
+          }
+      }
+    }
+    var at = Array.isArray;
+    function ue(s) {
+      return at(s);
+    }
+    function ot(s) {
+      {
+        var h = typeof Symbol == "function" && Symbol.toStringTag, p = h && s[Symbol.toStringTag] || s.constructor.name || "Object";
+        return p;
+      }
+    }
+    function ct(s) {
+      try {
+        return Te(s), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Te(s) {
+      return "" + s;
+    }
+    function Ae(s) {
+      if (ct(s))
+        return w("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", ot(s)), Te(s);
+    }
+    var Ie = x.ReactCurrentOwner, lt = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, Ue, Oe;
+    function ht(s) {
+      if (ee.call(s, "ref")) {
+        var h = Object.getOwnPropertyDescriptor(s, "ref").get;
+        if (h && h.isReactWarning)
+          return !1;
+      }
+      return s.ref !== void 0;
+    }
+    function ut(s) {
+      if (ee.call(s, "key")) {
+        var h = Object.getOwnPropertyDescriptor(s, "key").get;
+        if (h && h.isReactWarning)
+          return !1;
+      }
+      return s.key !== void 0;
+    }
+    function ft(s, h) {
+      typeof s.ref == "string" && Ie.current;
+    }
+    function dt(s, h) {
+      {
+        var p = function() {
+          Ue || (Ue = !0, w("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", h));
+        };
+        p.isReactWarning = !0, Object.defineProperty(s, "key", {
+          get: p,
+          configurable: !0
+        });
+      }
+    }
+    function pt(s, h) {
+      {
+        var p = function() {
+          Oe || (Oe = !0, w("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", h));
+        };
+        p.isReactWarning = !0, Object.defineProperty(s, "ref", {
+          get: p,
+          configurable: !0
+        });
+      }
+    }
+    var gt = function(s, h, p, b, L, F, S) {
+      var C = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: e,
+        // Built-in properties that belong on the element
+        type: s,
+        key: h,
+        ref: p,
+        props: S,
+        // Record the component responsible for creating this element.
+        _owner: F
+      };
+      return C._store = {}, Object.defineProperty(C._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(C, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: b
+      }), Object.defineProperty(C, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: L
+      }), Object.freeze && (Object.freeze(C.props), Object.freeze(C)), C;
+    };
+    function mt(s, h, p, b, L) {
+      {
+        var F, S = {}, C = null, V = null;
+        p !== void 0 && (Ae(p), C = "" + p), ut(h) && (Ae(h.key), C = "" + h.key), ht(h) && (V = h.ref, ft(h, L));
+        for (F in h)
+          ee.call(h, F) && !lt.hasOwnProperty(F) && (S[F] = h[F]);
+        if (s && s.defaultProps) {
+          var P = s.defaultProps;
+          for (F in P)
+            S[F] === void 0 && (S[F] = P[F]);
+        }
+        if (C || V) {
+          var A = typeof s == "function" ? s.displayName || s.name || "Unknown" : s;
+          C && dt(S, A), V && pt(S, A);
+        }
+        return gt(s, C, V, L, b, Ie.current, S);
+      }
+    }
+    var fe = x.ReactCurrentOwner, je = x.ReactDebugCurrentFrame;
+    function q(s) {
+      if (s) {
+        var h = s._owner, p = ne(s.type, s._source, h ? h.type : null);
+        je.setExtraStackFrame(p);
+      } else
+        je.setExtraStackFrame(null);
+    }
+    var de;
+    de = !1;
+    function pe(s) {
+      return typeof s == "object" && s !== null && s.$$typeof === e;
+    }
+    function Ve() {
+      {
+        if (fe.current) {
+          var s = N(fe.current.type);
+          if (s)
+            return `
+
+Check the render method of \`` + s + "`.";
+        }
+        return "";
+      }
+    }
+    function vt(s) {
+      return "";
+    }
+    var De = {};
+    function wt(s) {
+      {
+        var h = Ve();
+        if (!h) {
+          var p = typeof s == "string" ? s : s.displayName || s.name;
+          p && (h = `
+
+Check the top-level render call using <` + p + ">.");
+        }
+        return h;
+      }
+    }
+    function Ne(s, h) {
+      {
+        if (!s._store || s._store.validated || s.key != null)
+          return;
+        s._store.validated = !0;
+        var p = wt(h);
+        if (De[p])
+          return;
+        De[p] = !0;
+        var b = "";
+        s && s._owner && s._owner !== fe.current && (b = " It was passed a child from " + N(s._owner.type) + "."), q(s), w('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', p, b), q(null);
+      }
+    }
+    function Ge(s, h) {
+      {
+        if (typeof s != "object")
+          return;
+        if (ue(s))
+          for (var p = 0; p < s.length; p++) {
+            var b = s[p];
+            pe(b) && Ne(b, h);
+          }
+        else if (pe(s))
+          s._store && (s._store.validated = !0);
+        else if (s) {
+          var L = R(s);
+          if (typeof L == "function" && L !== s.entries)
+            for (var F = L.call(s), S; !(S = F.next()).done; )
+              pe(S.value) && Ne(S.value, h);
+        }
+      }
+    }
+    function yt(s) {
+      {
+        var h = s.type;
+        if (h == null || typeof h == "string")
+          return;
+        var p;
+        if (typeof h == "function")
+          p = h.propTypes;
+        else if (typeof h == "object" && (h.$$typeof === o || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        h.$$typeof === d))
+          p = h.propTypes;
+        else
+          return;
+        if (p) {
+          var b = N(h);
+          nt(p, s.props, "prop", b, s);
+        } else if (h.PropTypes !== void 0 && !de) {
+          de = !0;
+          var L = N(h);
+          w("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", L || "Unknown");
+        }
+        typeof h.getDefaultProps == "function" && !h.getDefaultProps.isReactClassApproved && w("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function bt(s) {
+      {
+        for (var h = Object.keys(s.props), p = 0; p < h.length; p++) {
+          var b = h[p];
+          if (b !== "children" && b !== "key") {
+            q(s), w("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", b), q(null);
+            break;
+          }
+        }
+        s.ref !== null && (q(s), w("Invalid attribute `ref` supplied to `React.Fragment`."), q(null));
+      }
+    }
+    var ze = {};
+    function We(s, h, p, b, L, F) {
+      {
+        var S = D(s);
+        if (!S) {
+          var C = "";
+          (s === void 0 || typeof s == "object" && s !== null && Object.keys(s).length === 0) && (C += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var V = vt();
+          V ? C += V : C += Ve();
+          var P;
+          s === null ? P = "null" : ue(s) ? P = "array" : s !== void 0 && s.$$typeof === e ? (P = "<" + (N(s.type) || "Unknown") + " />", C = " Did you accidentally export a JSX literal instead of a component?") : P = typeof s, w("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", P, C);
+        }
+        var A = mt(s, h, p, L, F);
+        if (A == null)
+          return A;
+        if (S) {
+          var B = h.children;
+          if (B !== void 0)
+            if (b)
+              if (ue(B)) {
+                for (var X = 0; X < B.length; X++)
+                  Ge(B[X], s);
+                Object.freeze && Object.freeze(B);
+              } else
+                w("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              Ge(B, s);
+        }
+        if (ee.call(h, "key")) {
+          var K = N(s), G = Object.keys(h).filter(function(_t) {
+            return _t !== "key";
+          }), ge = G.length > 0 ? "{key: someKey, " + G.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!ze[K + ge]) {
+            var Ct = G.length > 0 ? "{" + G.join(": ..., ") + ": ...}" : "{}";
+            w(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, ge, K, Ct, K), ze[K + ge] = !0;
+          }
+        }
+        return s === n ? bt(A) : yt(A), A;
+      }
+    }
+    function xt(s, h, p) {
+      return We(s, h, p, !0);
+    }
+    function Et(s, h, p) {
+      return We(s, h, p, !1);
+    }
+    var Mt = Et, Rt = xt;
+    se.Fragment = n, se.jsx = Mt, se.jsxs = Rt;
+  })()), se;
+}
+var Xe;
+function fs() {
+  return Xe || (Xe = 1, process.env.NODE_ENV === "production" ? oe.exports = hs() : oe.exports = us()), oe.exports;
+}
+var _ = fs();
+const Es = be(({
+  onEntitySelect: y,
+  onLockChange: e,
+  pvsEnabled: t,
+  showPointEntities: n,
+  showBrushEntities: r,
+  showBrushWireframes: i,
+  showAxes: a,
+  aaaTriggerOpacity: c,
+  entityConnectionsMode: o,
+  textureFiltering: u,
+  lightmapFiltering: f,
+  antialias: d,
+  selectedEntity: v,
+  onProgress: E
+}, m) => {
+  const M = Be(null), R = Be(null);
+  return Tt(m, () => ({
+    loadMap: async (x, w, k) => {
+      if (R.current)
+        try {
+          const O = await x.arrayBuffer(), I = await Promise.all(w.map((T) => T.arrayBuffer())), z = (await Promise.all(k.map((T) => T.text()))).join(`
+`);
+          await R.current.loadMap(O, I, z);
+        } catch (O) {
+          throw console.error("Load failed:", O), O;
+        }
+    },
+    resetView: () => {
+      var x;
+      (x = R.current) == null || x.resetView();
+    },
+    instance: R.current
+  })), me(() => {
+    if (!M.current) return;
+    const x = new ls({
+      container: M.current,
+      onEntitySelect: y,
+      onLockChange: e,
+      onProgress: E,
+      showAxes: a,
+      pvsEnabled: t,
+      showPointEntities: n,
+      showBrushEntities: r,
+      showBrushWireframes: i,
+      aaaTriggerOpacity: c,
+      entityConnectionsMode: o,
+      textureFiltering: u,
+      lightmapFiltering: f,
+      antialias: d
+    });
+    return R.current = x, () => {
+      x.destroy(), R.current = null;
+    };
+  }, [y, e, E]), me(() => {
+    var x;
+    (x = R.current) == null || x.setOptions({
+      pvsEnabled: t,
+      showPointEntities: n,
+      showBrushEntities: r,
+      showBrushWireframes: i,
+      showAxes: a,
+      aaaTriggerOpacity: c,
+      entityConnectionsMode: o,
+      textureFiltering: u,
+      lightmapFiltering: f
+    });
+  }, [
+    t,
+    n,
+    r,
+    i,
+    a,
+    c,
+    o,
+    u,
+    f
+  ]), me(() => {
+    var x;
+    (x = R.current) == null || x.setSelectedEntity(v);
+  }, [v]), /* @__PURE__ */ _.jsx("div", { className: "w-full h-full overflow-hidden", ref: M });
+});
+/**
+ * @license lucide-react v0.474.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const ds = (y) => y.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), Ze = (...y) => y.filter((e, t, n) => !!e && e.trim() !== "" && n.indexOf(e) === t).join(" ").trim();
+/**
+ * @license lucide-react v0.474.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+var ps = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+/**
+ * @license lucide-react v0.474.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const gs = be(
+  ({
+    color: y = "currentColor",
+    size: e = 24,
+    strokeWidth: t = 2,
+    absoluteStrokeWidth: n,
+    className: r = "",
+    children: i,
+    iconNode: a,
+    ...c
+  }, o) => ye(
+    "svg",
+    {
+      ref: o,
+      ...ps,
+      width: e,
+      height: e,
+      stroke: y,
+      strokeWidth: n ? Number(t) * 24 / Number(e) : t,
+      className: Ze("lucide", r),
+      ...c
+    },
+    [
+      ...a.map(([u, f]) => ye(u, f)),
+      ...Array.isArray(i) ? i : [i]
+    ]
+  )
+);
+/**
+ * @license lucide-react v0.474.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Qe = (y, e) => {
+  const t = be(
+    ({ className: n, ...r }, i) => ye(gs, {
+      ref: i,
+      iconNode: e,
+      className: Ze(`lucide-${ds(y)}`, n),
+      ...r
+    })
+  );
+  return t.displayName = `${y}`, t;
+};
+/**
+ * @license lucide-react v0.474.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const ms = [
+  ["circle", { cx: "12", cy: "12", r: "10", key: "1mglay" }],
+  ["path", { d: "m9 12 2 2 4-4", key: "dzmm74" }]
+], vs = Qe("CircleCheck", ms);
+/**
+ * @license lucide-react v0.474.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const ws = [
+  ["path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4", key: "ih7n3h" }],
+  ["polyline", { points: "17 8 12 3 7 8", key: "t8dd8p" }],
+  ["line", { x1: "12", x2: "12", y1: "3", y2: "15", key: "widbto" }]
+], we = Qe("Upload", ws), Ms = ({ onLoad: y, status: e }) => {
+  const [t, n] = ve(null), [r, i] = ve([]), [a, c] = ve([]), o = () => {
+    t && y(t, r, a);
+  };
+  return /* @__PURE__ */ _.jsxs("div", { className: "w-80 bg-zinc-950 border border-white/10 rounded shadow-2xl overflow-hidden flex flex-col font-mono", children: [
+    /* @__PURE__ */ _.jsx("div", { className: "p-3 border-b border-white/10 bg-white/5 flex items-center justify-between", children: /* @__PURE__ */ _.jsx("div", { className: "flex items-center gap-2", children: /* @__PURE__ */ _.jsx("span", { className: "text-[10px] font-bold text-white uppercase tracking-wider", children: "Load Map Resources" }) }) }),
+    /* @__PURE__ */ _.jsxs("div", { className: "p-4 space-y-4", children: [
+      /* @__PURE__ */ _.jsxs("div", { className: "space-y-1.5", children: [
+        /* @__PURE__ */ _.jsxs("label", { className: "text-[9px] font-bold text-zinc-500 uppercase tracking-widest flex items-center gap-1.5", children: [
+          /* @__PURE__ */ _.jsx("div", { className: "w-1 h-1 bg-blue-500 rounded-full" }),
+          "BSP File (Geometry)"
+        ] }),
+        /* @__PURE__ */ _.jsxs("div", { className: "relative group", children: [
+          /* @__PURE__ */ _.jsx(
+            "input",
+            {
+              type: "file",
+              accept: ".bsp",
+              onChange: (u) => {
+                var f;
+                return n(((f = u.target.files) == null ? void 0 : f[0]) || null);
+              },
+              className: "absolute inset-0 w-full h-full opacity-0 cursor-pointer z-10"
+            }
+          ),
+          /* @__PURE__ */ _.jsxs("div", { className: `py-2 px-3 border border-dashed rounded transition-colors flex items-center justify-between ${t ? "border-blue-500/50 bg-blue-500/5" : "border-white/10 group-hover:border-white/20"}`, children: [
+            /* @__PURE__ */ _.jsx("span", { className: `text-[10px] truncate pr-4 ${t ? "text-blue-300" : "text-zinc-500"}`, children: t ? t.name : "Select .bsp file..." }),
+            t ? /* @__PURE__ */ _.jsx(vs, { className: "w-3 h-3 text-blue-500 shrink-0" }) : /* @__PURE__ */ _.jsx(we, { className: "w-3 h-3 text-zinc-600 shrink-0" })
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ _.jsxs("div", { className: "space-y-1.5", children: [
+        /* @__PURE__ */ _.jsxs("label", { className: "text-[9px] font-bold text-zinc-500 uppercase tracking-widest flex items-center gap-1.5", children: [
+          /* @__PURE__ */ _.jsx("div", { className: "w-1 h-1 bg-zinc-500 rounded-full" }),
+          "WAD Files (Textures)"
+        ] }),
+        /* @__PURE__ */ _.jsxs("div", { className: "relative group", children: [
+          /* @__PURE__ */ _.jsx(
+            "input",
+            {
+              type: "file",
+              multiple: !0,
+              accept: ".wad",
+              onChange: (u) => i(Array.from(u.target.files || [])),
+              className: "absolute inset-0 w-full h-full opacity-0 cursor-pointer z-10"
+            }
+          ),
+          /* @__PURE__ */ _.jsxs("div", { className: `py-2 px-3 border border-dashed rounded transition-colors flex items-center justify-between ${r.length > 0 ? "border-zinc-500/50 bg-white/5" : "border-white/10 group-hover:border-white/20"}`, children: [
+            /* @__PURE__ */ _.jsx("span", { className: `text-[10px] truncate pr-4 ${r.length > 0 ? "text-zinc-300" : "text-zinc-500"}`, children: r.length > 0 ? `${r.length} files selected` : "Select .wad files..." }),
+            /* @__PURE__ */ _.jsx(we, { className: "w-3 h-3 text-zinc-600 shrink-0" })
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ _.jsxs("div", { className: "space-y-1.5", children: [
+        /* @__PURE__ */ _.jsxs("label", { className: "text-[9px] font-bold text-zinc-500 uppercase tracking-widest flex items-center gap-1.5", children: [
+          /* @__PURE__ */ _.jsx("div", { className: "w-1 h-1 bg-zinc-500 rounded-full" }),
+          "FGD Files (Entities)"
+        ] }),
+        /* @__PURE__ */ _.jsxs("div", { className: "relative group", children: [
+          /* @__PURE__ */ _.jsx(
+            "input",
+            {
+              type: "file",
+              multiple: !0,
+              accept: ".fgd",
+              onChange: (u) => c(Array.from(u.target.files || [])),
+              className: "absolute inset-0 w-full h-full opacity-0 cursor-pointer z-10"
+            }
+          ),
+          /* @__PURE__ */ _.jsxs("div", { className: `py-2 px-3 border border-dashed rounded transition-colors flex items-center justify-between ${a.length > 0 ? "border-zinc-500/50 bg-white/5" : "border-white/10 group-hover:border-white/20"}`, children: [
+            /* @__PURE__ */ _.jsx("span", { className: `text-[10px] truncate pr-4 ${a.length > 0 ? "text-zinc-300" : "text-zinc-500"}`, children: a.length > 0 ? `${a.length} files selected` : "Select .fgd files..." }),
+            /* @__PURE__ */ _.jsx(we, { className: "w-3 h-3 text-zinc-600 shrink-0" })
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ _.jsxs("div", { className: "pt-2 flex flex-col gap-2", children: [
+        /* @__PURE__ */ _.jsx(
+          "button",
+          {
+            onClick: o,
+            disabled: !t || e === "Loading...",
+            className: `w-full py-2.5 rounded text-[10px] font-bold uppercase tracking-widest transition-all ${t && e !== "Loading..." ? "bg-blue-600 hover:bg-blue-500 text-white shadow-lg shadow-blue-500/20 active:scale-[0.98]" : "bg-zinc-800 text-zinc-500 cursor-not-allowed"}`,
+            children: e === "Loading..." ? "Processing Map..." : "Initialize Engine"
+          }
+        ),
+        e !== "Waiting for map..." && /* @__PURE__ */ _.jsxs("div", { className: "flex items-center justify-center gap-2 py-1", children: [
+          /* @__PURE__ */ _.jsx("div", { className: `w-1.5 h-1.5 rounded-full animate-pulse ${e === "Load Error" ? "bg-red-500" : "bg-green-500"}` }),
+          /* @__PURE__ */ _.jsx("span", { className: "text-[9px] font-bold text-zinc-400 uppercase", children: e })
+        ] })
+      ] })
+    ] })
+  ] });
+};
+export {
+  ss as BspParser,
+  ls as BspViewer,
+  rs as FgdParser,
+  Ms as MapLoader,
+  os as MapRenderer,
+  cs as Navigator,
+  Es as ViewerCanvas,
+  is as WadParser
+};