blockymodel-web 0.1.0

package/dist/blockymodel-web.js

@@ -0,0 +1,2717 @@
+var Wt = Object.defineProperty;
+var Kt = (a, t, e) => t in a ? Wt(a, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[t] = e;
+var r = (a, t, e) => Kt(a, typeof t != "symbol" ? t + "" : t, e);
+import * as l from "three";
+import { Controls as Ht, Vector3 as p, Quaternion as L, Raycaster as $t, Object3D as Mt, MeshBasicMaterial as Nt, LineBasicMaterial as Jt, CylinderGeometry as P, BoxGeometry as S, BufferGeometry as Pt, Float32BufferAttribute as It, Mesh as c, OctahedronGeometry as rt, Line as F, TorusGeometry as W, SphereGeometry as te, Euler as ee, Matrix4 as Ft, PlaneGeometry as ie, DoubleSide as se, MOUSE as G, TOUCH as V, Spherical as Tt, Vector2 as R, Ray as ne, Plane as oe, MathUtils as ae } from "three";
+const re = 4491519, he = 0.3;
+class le {
+  constructor(t) {
+    r(this, "editor");
+    r(this, "raycaster");
+    r(this, "mouse");
+    r(this, "selected", null);
+    r(this, "highlightedMaterials", /* @__PURE__ */ new Map());
+    r(this, "eventListeners", /* @__PURE__ */ new Map());
+    this.editor = t, this.raycaster = new l.Raycaster(), this.mouse = new l.Vector2(), this.handleClick = this.handleClick.bind(this), this.editor.domElement.addEventListener("click", this.handleClick);
+  }
+  /**
+   * Handle click events for selection
+   */
+  handleClick(t) {
+    if (t.target !== this.editor.renderer.domElement)
+      return;
+    const e = this.editor.domElement.getBoundingClientRect();
+    this.mouse.x = (t.clientX - e.left) / e.width * 2 - 1, this.mouse.y = -((t.clientY - e.top) / e.height) * 2 + 1, this.raycaster.setFromCamera(this.mouse, this.editor.camera);
+    const i = this.editor.getModel();
+    if (!i) {
+      this.deselect();
+      return;
+    }
+    const s = [];
+    i.traverse((n) => {
+      n instanceof l.Mesh && n.visible && (this.isTransformControlPart(n) || s.push(n));
+    });
+    const o = this.raycaster.intersectObjects(s, !1);
+    if (o.length > 0) {
+      let n = o[0].object;
+      for (; n.parent && !n.userData.id && n.parent !== i; )
+        n = n.parent;
+      this.select(n);
+    } else
+      this.deselect();
+  }
+  /**
+   * Check if object is part of TransformControls
+   */
+  isTransformControlPart(t) {
+    let e = t;
+    for (; e; ) {
+      if (e.type === "TransformControlsGizmo" || e.type === "TransformControlsPlane")
+        return !0;
+      e = e.parent;
+    }
+    return !1;
+  }
+  /**
+   * Select an object
+   */
+  select(t) {
+    t !== this.selected && (this.removeHighlight(), this.selected = t, t && this.applyHighlight(t), this.emit("selectionChanged", t));
+  }
+  /**
+   * Deselect current object
+   */
+  deselect() {
+    this.select(null);
+  }
+  /**
+   * Get currently selected object
+   */
+  getSelected() {
+    return this.selected;
+  }
+  /**
+   * Apply highlight effect to object
+   */
+  applyHighlight(t) {
+    t.traverse((e) => {
+      if (e instanceof l.Mesh) {
+        const i = e.material;
+        i.emissive && (this.highlightedMaterials.set(e, {
+          emissive: i.emissive.clone(),
+          emissiveIntensity: i.emissiveIntensity
+        }), i.emissive.setHex(re), i.emissiveIntensity = he);
+      }
+    });
+  }
+  /**
+   * Remove highlight effect
+   */
+  removeHighlight() {
+    this.highlightedMaterials.forEach((t, e) => {
+      const i = e.material;
+      i.emissive && (i.emissive.copy(t.emissive), i.emissiveIntensity = t.emissiveIntensity);
+    }), this.highlightedMaterials.clear();
+  }
+  /**
+   * Add event listener
+   */
+  on(t, e) {
+    this.eventListeners.has(t) || this.eventListeners.set(t, /* @__PURE__ */ new Set()), this.eventListeners.get(t).add(e);
+  }
+  /**
+   * Emit event
+   */
+  emit(t, ...e) {
+    var i;
+    (i = this.eventListeners.get(t)) == null || i.forEach((s) => s(e[0]));
+  }
+  /**
+   * Clean up
+   */
+  dispose() {
+    this.editor.domElement.removeEventListener("click", this.handleClick), this.removeHighlight(), this.eventListeners.clear();
+  }
+}
+const U = new $t(), x = new p(), X = new p(), g = new L(), Dt = {
+  X: new p(1, 0, 0),
+  Y: new p(0, 1, 0),
+  Z: new p(0, 0, 1)
+}, gt = { type: "change" }, Ct = { type: "mouseDown", mode: null }, Lt = { type: "mouseUp", mode: null }, zt = { type: "objectChange" };
+class ce extends Ht {
+  constructor(t, e = null) {
+    super(void 0, e);
+    const i = new ye(this);
+    this._root = i;
+    const s = new ge();
+    this._gizmo = s, i.add(s);
+    const o = new be();
+    this._plane = o, i.add(o);
+    const n = this;
+    function h(b, T) {
+      let k = T;
+      Object.defineProperty(n, b, {
+        get: function() {
+          return k !== void 0 ? k : T;
+        },
+        set: function(A) {
+          k !== A && (k = A, o[b] = A, s[b] = A, n.dispatchEvent({ type: b + "-changed", value: A }), n.dispatchEvent(gt));
+        }
+      }), n[b] = T, o[b] = T, s[b] = T;
+    }
+    h("camera", t), h("object", void 0), h("enabled", !0), h("axis", null), h("mode", "translate"), h("translationSnap", null), h("rotationSnap", null), h("scaleSnap", null), h("space", "world"), h("size", 1), h("dragging", !1), h("showX", !0), h("showY", !0), h("showZ", !0), h("minX", -1 / 0), h("maxX", 1 / 0), h("minY", -1 / 0), h("maxY", 1 / 0), h("minZ", -1 / 0), h("maxZ", 1 / 0);
+    const d = new p(), u = new p(), y = new L(), _ = new L(), D = new p(), yt = new L(), B = new p(), z = new p(), O = new p(), M = 0, E = new p();
+    h("worldPosition", d), h("worldPositionStart", u), h("worldQuaternion", y), h("worldQuaternionStart", _), h("cameraPosition", D), h("cameraQuaternion", yt), h("pointStart", B), h("pointEnd", z), h("rotationAxis", O), h("rotationAngle", M), h("eye", E), this._offset = new p(), this._startNorm = new p(), this._endNorm = new p(), this._cameraScale = new p(), this._parentPosition = new p(), this._parentQuaternion = new L(), this._parentQuaternionInv = new L(), this._parentScale = new p(), this._worldScaleStart = new p(), this._worldQuaternionInv = new L(), this._worldScale = new p(), this._positionStart = new p(), this._quaternionStart = new L(), this._scaleStart = new p(), this._getPointer = de.bind(this), this._onPointerDown = ue.bind(this), this._onPointerHover = pe.bind(this), this._onPointerMove = me.bind(this), this._onPointerUp = fe.bind(this), e !== null && this.connect();
+  }
+  connect() {
+    this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointermove", this._onPointerHover), this.domElement.addEventListener("pointerup", this._onPointerUp), this.domElement.style.touchAction = "none";
+  }
+  disconnect() {
+    this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.removeEventListener("pointermove", this._onPointerHover), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.domElement.style.touchAction = "auto";
+  }
+  getHelper() {
+    return this._root;
+  }
+  pointerHover(t) {
+    if (this.object === void 0 || this.dragging === !0) return;
+    t !== null && U.setFromCamera(t, this.camera);
+    const e = bt(this._gizmo.picker[this.mode], U);
+    e ? this.axis = e.object.name : this.axis = null;
+  }
+  pointerDown(t) {
+    if (!(this.object === void 0 || this.dragging === !0 || t != null && t.button !== 0) && this.axis !== null) {
+      t !== null && U.setFromCamera(t, this.camera);
+      const e = bt(this._plane, U, !0);
+      e && (this.object.updateMatrixWorld(), this.object.parent.updateMatrixWorld(), this._positionStart.copy(this.object.position), this._quaternionStart.copy(this.object.quaternion), this._scaleStart.copy(this.object.scale), this.object.matrixWorld.decompose(this.worldPositionStart, this.worldQuaternionStart, this._worldScaleStart), this.pointStart.copy(e.point).sub(this.worldPositionStart)), this.dragging = !0, Ct.mode = this.mode, this.dispatchEvent(Ct);
+    }
+  }
+  pointerMove(t) {
+    const e = this.axis, i = this.mode, s = this.object;
+    let o = this.space;
+    if (i === "scale" ? o = "local" : (e === "E" || e === "XYZE" || e === "XYZ") && (o = "world"), s === void 0 || e === null || this.dragging === !1 || t !== null && t.button !== -1) return;
+    t !== null && U.setFromCamera(t, this.camera);
+    const n = bt(this._plane, U, !0);
+    if (n) {
+      if (this.pointEnd.copy(n.point).sub(this.worldPositionStart), i === "translate")
+        this._offset.copy(this.pointEnd).sub(this.pointStart), o === "local" && e !== "XYZ" && this._offset.applyQuaternion(this._worldQuaternionInv), e.indexOf("X") === -1 && (this._offset.x = 0), e.indexOf("Y") === -1 && (this._offset.y = 0), e.indexOf("Z") === -1 && (this._offset.z = 0), o === "local" && e !== "XYZ" ? this._offset.applyQuaternion(this._quaternionStart).divide(this._parentScale) : this._offset.applyQuaternion(this._parentQuaternionInv).divide(this._parentScale), s.position.copy(this._offset).add(this._positionStart), this.translationSnap && (o === "local" && (s.position.applyQuaternion(g.copy(this._quaternionStart).invert()), e.search("X") !== -1 && (s.position.x = Math.round(s.position.x / this.translationSnap) * this.translationSnap), e.search("Y") !== -1 && (s.position.y = Math.round(s.position.y / this.translationSnap) * this.translationSnap), e.search("Z") !== -1 && (s.position.z = Math.round(s.position.z / this.translationSnap) * this.translationSnap), s.position.applyQuaternion(this._quaternionStart)), o === "world" && (s.parent && s.position.add(x.setFromMatrixPosition(s.parent.matrixWorld)), e.search("X") !== -1 && (s.position.x = Math.round(s.position.x / this.translationSnap) * this.translationSnap), e.search("Y") !== -1 && (s.position.y = Math.round(s.position.y / this.translationSnap) * this.translationSnap), e.search("Z") !== -1 && (s.position.z = Math.round(s.position.z / this.translationSnap) * this.translationSnap), s.parent && s.position.sub(x.setFromMatrixPosition(s.parent.matrixWorld)))), s.position.x = Math.max(this.minX, Math.min(this.maxX, s.position.x)), s.position.y = Math.max(this.minY, Math.min(this.maxY, s.position.y)), s.position.z = Math.max(this.minZ, Math.min(this.maxZ, s.position.z));
+      else if (i === "scale") {
+        if (e.search("XYZ") !== -1) {
+          let h = this.pointEnd.length() / this.pointStart.length();
+          this.pointEnd.dot(this.pointStart) < 0 && (h *= -1), X.set(h, h, h);
+        } else
+          x.copy(this.pointStart), X.copy(this.pointEnd), x.applyQuaternion(this._worldQuaternionInv), X.applyQuaternion(this._worldQuaternionInv), X.divide(x), e.search("X") === -1 && (X.x = 1), e.search("Y") === -1 && (X.y = 1), e.search("Z") === -1 && (X.z = 1);
+        s.scale.copy(this._scaleStart).multiply(X), this.scaleSnap && (e.search("X") !== -1 && (s.scale.x = Math.round(s.scale.x / this.scaleSnap) * this.scaleSnap || this.scaleSnap), e.search("Y") !== -1 && (s.scale.y = Math.round(s.scale.y / this.scaleSnap) * this.scaleSnap || this.scaleSnap), e.search("Z") !== -1 && (s.scale.z = Math.round(s.scale.z / this.scaleSnap) * this.scaleSnap || this.scaleSnap));
+      } else if (i === "rotate") {
+        this._offset.copy(this.pointEnd).sub(this.pointStart);
+        const h = 20 / this.worldPosition.distanceTo(x.setFromMatrixPosition(this.camera.matrixWorld));
+        let d = !1;
+        e === "XYZE" ? (this.rotationAxis.copy(this._offset).cross(this.eye).normalize(), this.rotationAngle = this._offset.dot(x.copy(this.rotationAxis).cross(this.eye)) * h) : (e === "X" || e === "Y" || e === "Z") && (this.rotationAxis.copy(Dt[e]), x.copy(Dt[e]), o === "local" && x.applyQuaternion(this.worldQuaternion), x.cross(this.eye), x.length() === 0 ? d = !0 : this.rotationAngle = this._offset.dot(x.normalize()) * h), (e === "E" || d) && (this.rotationAxis.copy(this.eye), this.rotationAngle = this.pointEnd.angleTo(this.pointStart), this._startNorm.copy(this.pointStart).normalize(), this._endNorm.copy(this.pointEnd).normalize(), this.rotationAngle *= this._endNorm.cross(this._startNorm).dot(this.eye) < 0 ? 1 : -1), this.rotationSnap && (this.rotationAngle = Math.round(this.rotationAngle / this.rotationSnap) * this.rotationSnap), o === "local" && e !== "E" && e !== "XYZE" ? (s.quaternion.copy(this._quaternionStart), s.quaternion.multiply(g.setFromAxisAngle(this.rotationAxis, this.rotationAngle)).normalize()) : (this.rotationAxis.applyQuaternion(this._parentQuaternionInv), s.quaternion.copy(g.setFromAxisAngle(this.rotationAxis, this.rotationAngle)), s.quaternion.multiply(this._quaternionStart).normalize());
+      }
+      this.dispatchEvent(gt), this.dispatchEvent(zt);
+    }
+  }
+  pointerUp(t) {
+    t !== null && t.button !== 0 || (this.dragging && this.axis !== null && (Lt.mode = this.mode, this.dispatchEvent(Lt)), this.dragging = !1, this.axis = null);
+  }
+  dispose() {
+    this.disconnect(), this._root.dispose();
+  }
+  // Set current object
+  attach(t) {
+    return this.object = t, this._root.visible = !0, this;
+  }
+  // Detach from object
+  detach() {
+    return this.object = void 0, this.axis = null, this._root.visible = !1, this;
+  }
+  reset() {
+    this.enabled && this.dragging && (this.object.position.copy(this._positionStart), this.object.quaternion.copy(this._quaternionStart), this.object.scale.copy(this._scaleStart), this.dispatchEvent(gt), this.dispatchEvent(zt), this.pointStart.copy(this.pointEnd));
+  }
+  getRaycaster() {
+    return U;
+  }
+  // TODO: deprecate
+  getMode() {
+    return this.mode;
+  }
+  setMode(t) {
+    this.mode = t;
+  }
+  setTranslationSnap(t) {
+    this.translationSnap = t;
+  }
+  setRotationSnap(t) {
+    this.rotationSnap = t;
+  }
+  setScaleSnap(t) {
+    this.scaleSnap = t;
+  }
+  setSize(t) {
+    this.size = t;
+  }
+  setSpace(t) {
+    this.space = t;
+  }
+}
+function de(a) {
+  if (this.domElement.ownerDocument.pointerLockElement)
+    return {
+      x: 0,
+      y: 0,
+      button: a.button
+    };
+  {
+    const t = this.domElement.getBoundingClientRect();
+    return {
+      x: (a.clientX - t.left) / t.width * 2 - 1,
+      y: -(a.clientY - t.top) / t.height * 2 + 1,
+      button: a.button
+    };
+  }
+}
+function pe(a) {
+  if (this.enabled)
+    switch (a.pointerType) {
+      case "mouse":
+      case "pen":
+        this.pointerHover(this._getPointer(a));
+        break;
+    }
+}
+function ue(a) {
+  this.enabled && (document.pointerLockElement || this.domElement.setPointerCapture(a.pointerId), this.domElement.addEventListener("pointermove", this._onPointerMove), this.pointerHover(this._getPointer(a)), this.pointerDown(this._getPointer(a)));
+}
+function me(a) {
+  this.enabled && this.pointerMove(this._getPointer(a));
+}
+function fe(a) {
+  this.enabled && (this.domElement.releasePointerCapture(a.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.pointerUp(this._getPointer(a)));
+}
+function bt(a, t, e) {
+  const i = t.intersectObject(a, !0);
+  for (let s = 0; s < i.length; s++)
+    if (i[s].object.visible || e)
+      return i[s];
+  return !1;
+}
+const ht = new ee(), f = new p(0, 1, 0), Ot = new p(0, 0, 0), kt = new Ft(), lt = new L(), pt = new L(), Y = new p(), jt = new Ft(), tt = new p(1, 0, 0), Z = new p(0, 1, 0), et = new p(0, 0, 1), ct = new p(), K = new p(), $ = new p();
+class ye extends Mt {
+  constructor(t) {
+    super(), this.isTransformControlsRoot = !0, this.controls = t, this.visible = !1;
+  }
+  // updateMatrixWorld updates key transformation variables
+  updateMatrixWorld(t) {
+    const e = this.controls;
+    e.object !== void 0 && (e.object.updateMatrixWorld(), e.object.parent === null ? console.error("TransformControls: The attached 3D object must be a part of the scene graph.") : e.object.parent.matrixWorld.decompose(e._parentPosition, e._parentQuaternion, e._parentScale), e.object.matrixWorld.decompose(e.worldPosition, e.worldQuaternion, e._worldScale), e._parentQuaternionInv.copy(e._parentQuaternion).invert(), e._worldQuaternionInv.copy(e.worldQuaternion).invert()), e.camera.updateMatrixWorld(), e.camera.matrixWorld.decompose(e.cameraPosition, e.cameraQuaternion, e._cameraScale), e.camera.isOrthographicCamera ? e.camera.getWorldDirection(e.eye).negate() : e.eye.copy(e.cameraPosition).sub(e.worldPosition).normalize(), super.updateMatrixWorld(t);
+  }
+  dispose() {
+    this.traverse(function(t) {
+      t.geometry && t.geometry.dispose(), t.material && t.material.dispose();
+    });
+  }
+}
+class ge extends Mt {
+  constructor() {
+    super(), this.isTransformControlsGizmo = !0, this.type = "TransformControlsGizmo";
+    const t = new Nt({
+      depthTest: !1,
+      depthWrite: !1,
+      fog: !1,
+      toneMapped: !1,
+      transparent: !0
+    }), e = new Jt({
+      depthTest: !1,
+      depthWrite: !1,
+      fog: !1,
+      toneMapped: !1,
+      transparent: !0
+    }), i = t.clone();
+    i.opacity = 0.15;
+    const s = e.clone();
+    s.opacity = 0.5;
+    const o = t.clone();
+    o.color.setHex(16711680);
+    const n = t.clone();
+    n.color.setHex(65280);
+    const h = t.clone();
+    h.color.setHex(255);
+    const d = t.clone();
+    d.color.setHex(16711680), d.opacity = 0.5;
+    const u = t.clone();
+    u.color.setHex(65280), u.opacity = 0.5;
+    const y = t.clone();
+    y.color.setHex(255), y.opacity = 0.5;
+    const _ = t.clone();
+    _.opacity = 0.25;
+    const D = t.clone();
+    D.color.setHex(16776960), D.opacity = 0.25, t.clone().color.setHex(16776960);
+    const B = t.clone();
+    B.color.setHex(7895160);
+    const z = new P(0, 0.04, 0.1, 12);
+    z.translate(0, 0.05, 0);
+    const O = new S(0.08, 0.08, 0.08);
+    O.translate(0, 0.04, 0);
+    const M = new Pt();
+    M.setAttribute("position", new It([0, 0, 0, 1, 0, 0], 3));
+    const E = new P(75e-4, 75e-4, 0.5, 3);
+    E.translate(0, 0.25, 0);
+    function b(C, st) {
+      const j = new W(C, 75e-4, 3, 64, st * Math.PI * 2);
+      return j.rotateY(Math.PI / 2), j.rotateX(Math.PI / 2), j;
+    }
+    function T() {
+      const C = new Pt();
+      return C.setAttribute("position", new It([0, 0, 0, 1, 1, 1], 3)), C;
+    }
+    const k = {
+      X: [
+        [new c(z, o), [0.5, 0, 0], [0, 0, -Math.PI / 2]],
+        [new c(z, o), [-0.5, 0, 0], [0, 0, Math.PI / 2]],
+        [new c(E, o), [0, 0, 0], [0, 0, -Math.PI / 2]]
+      ],
+      Y: [
+        [new c(z, n), [0, 0.5, 0]],
+        [new c(z, n), [0, -0.5, 0], [Math.PI, 0, 0]],
+        [new c(E, n)]
+      ],
+      Z: [
+        [new c(z, h), [0, 0, 0.5], [Math.PI / 2, 0, 0]],
+        [new c(z, h), [0, 0, -0.5], [-Math.PI / 2, 0, 0]],
+        [new c(E, h), null, [Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new c(new rt(0.1, 0), _.clone()), [0, 0, 0]]
+      ],
+      XY: [
+        [new c(new S(0.15, 0.15, 0.01), y.clone()), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new c(new S(0.15, 0.15, 0.01), d.clone()), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new c(new S(0.15, 0.15, 0.01), u.clone()), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ]
+    }, A = {
+      X: [
+        [new c(new P(0.2, 0, 0.6, 4), i), [0.3, 0, 0], [0, 0, -Math.PI / 2]],
+        [new c(new P(0.2, 0, 0.6, 4), i), [-0.3, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new c(new P(0.2, 0, 0.6, 4), i), [0, 0.3, 0]],
+        [new c(new P(0.2, 0, 0.6, 4), i), [0, -0.3, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new c(new P(0.2, 0, 0.6, 4), i), [0, 0, 0.3], [Math.PI / 2, 0, 0]],
+        [new c(new P(0.2, 0, 0.6, 4), i), [0, 0, -0.3], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new c(new rt(0.2, 0), i)]
+      ],
+      XY: [
+        [new c(new S(0.2, 0.2, 0.01), i), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new c(new S(0.2, 0.2, 0.01), i), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new c(new S(0.2, 0.2, 0.01), i), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ]
+    }, it = {
+      START: [
+        [new c(new rt(0.01, 2), s), null, null, null, "helper"]
+      ],
+      END: [
+        [new c(new rt(0.01, 2), s), null, null, null, "helper"]
+      ],
+      DELTA: [
+        [new F(T(), s), null, null, null, "helper"]
+      ],
+      X: [
+        [new F(M, s.clone()), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ],
+      Y: [
+        [new F(M, s.clone()), [0, -1e3, 0], [0, 0, Math.PI / 2], [1e6, 1, 1], "helper"]
+      ],
+      Z: [
+        [new F(M, s.clone()), [0, 0, -1e3], [0, -Math.PI / 2, 0], [1e6, 1, 1], "helper"]
+      ]
+    }, Ut = {
+      XYZE: [
+        [new c(b(0.5, 1), B), null, [0, Math.PI / 2, 0]]
+      ],
+      X: [
+        [new c(b(0.5, 0.5), o)]
+      ],
+      Y: [
+        [new c(b(0.5, 0.5), n), null, [0, 0, -Math.PI / 2]]
+      ],
+      Z: [
+        [new c(b(0.5, 0.5), h), null, [0, Math.PI / 2, 0]]
+      ],
+      E: [
+        [new c(b(0.75, 1), D), null, [0, Math.PI / 2, 0]]
+      ]
+    }, Zt = {
+      AXIS: [
+        [new F(M, s.clone()), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ]
+    }, Bt = {
+      XYZE: [
+        [new c(new te(0.25, 10, 8), i)]
+      ],
+      X: [
+        [new c(new W(0.5, 0.1, 4, 24), i), [0, 0, 0], [0, -Math.PI / 2, -Math.PI / 2]]
+      ],
+      Y: [
+        [new c(new W(0.5, 0.1, 4, 24), i), [0, 0, 0], [Math.PI / 2, 0, 0]]
+      ],
+      Z: [
+        [new c(new W(0.5, 0.1, 4, 24), i), [0, 0, 0], [0, 0, -Math.PI / 2]]
+      ],
+      E: [
+        [new c(new W(0.75, 0.1, 2, 24), i)]
+      ]
+    }, Qt = {
+      X: [
+        [new c(O, o), [0.5, 0, 0], [0, 0, -Math.PI / 2]],
+        [new c(E, o), [0, 0, 0], [0, 0, -Math.PI / 2]],
+        [new c(O, o), [-0.5, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new c(O, n), [0, 0.5, 0]],
+        [new c(E, n)],
+        [new c(O, n), [0, -0.5, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new c(O, h), [0, 0, 0.5], [Math.PI / 2, 0, 0]],
+        [new c(E, h), [0, 0, 0], [Math.PI / 2, 0, 0]],
+        [new c(O, h), [0, 0, -0.5], [-Math.PI / 2, 0, 0]]
+      ],
+      XY: [
+        [new c(new S(0.15, 0.15, 0.01), y), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new c(new S(0.15, 0.15, 0.01), d), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new c(new S(0.15, 0.15, 0.01), u), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new c(new S(0.1, 0.1, 0.1), _.clone())]
+      ]
+    }, Vt = {
+      X: [
+        [new c(new P(0.2, 0, 0.6, 4), i), [0.3, 0, 0], [0, 0, -Math.PI / 2]],
+        [new c(new P(0.2, 0, 0.6, 4), i), [-0.3, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new c(new P(0.2, 0, 0.6, 4), i), [0, 0.3, 0]],
+        [new c(new P(0.2, 0, 0.6, 4), i), [0, -0.3, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new c(new P(0.2, 0, 0.6, 4), i), [0, 0, 0.3], [Math.PI / 2, 0, 0]],
+        [new c(new P(0.2, 0, 0.6, 4), i), [0, 0, -0.3], [-Math.PI / 2, 0, 0]]
+      ],
+      XY: [
+        [new c(new S(0.2, 0.2, 0.01), i), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new c(new S(0.2, 0.2, 0.01), i), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new c(new S(0.2, 0.2, 0.01), i), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new c(new S(0.2, 0.2, 0.2), i), [0, 0, 0]]
+      ]
+    }, Gt = {
+      X: [
+        [new F(M, s.clone()), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ],
+      Y: [
+        [new F(M, s.clone()), [0, -1e3, 0], [0, 0, Math.PI / 2], [1e6, 1, 1], "helper"]
+      ],
+      Z: [
+        [new F(M, s.clone()), [0, 0, -1e3], [0, -Math.PI / 2, 0], [1e6, 1, 1], "helper"]
+      ]
+    };
+    function H(C) {
+      const st = new Mt();
+      for (const j in C)
+        for (let Q = C[j].length; Q--; ) {
+          const v = C[j][Q][0].clone(), nt = C[j][Q][1], ot = C[j][Q][2], at = C[j][Q][3], qt = C[j][Q][4];
+          v.name = j, v.tag = qt, nt && v.position.set(nt[0], nt[1], nt[2]), ot && v.rotation.set(ot[0], ot[1], ot[2]), at && v.scale.set(at[0], at[1], at[2]), v.updateMatrix();
+          const vt = v.geometry.clone();
+          vt.applyMatrix4(v.matrix), v.geometry = vt, v.renderOrder = 1 / 0, v.position.set(0, 0, 0), v.rotation.set(0, 0, 0), v.scale.set(1, 1, 1), st.add(v);
+        }
+      return st;
+    }
+    this.gizmo = {}, this.picker = {}, this.helper = {}, this.add(this.gizmo.translate = H(k)), this.add(this.gizmo.rotate = H(Ut)), this.add(this.gizmo.scale = H(Qt)), this.add(this.picker.translate = H(A)), this.add(this.picker.rotate = H(Bt)), this.add(this.picker.scale = H(Vt)), this.add(this.helper.translate = H(it)), this.add(this.helper.rotate = H(Zt)), this.add(this.helper.scale = H(Gt)), this.picker.translate.visible = !1, this.picker.rotate.visible = !1, this.picker.scale.visible = !1;
+  }
+  // updateMatrixWorld will update transformations and appearance of individual handles
+  updateMatrixWorld(t) {
+    const i = (this.mode === "scale" ? "local" : this.space) === "local" ? this.worldQuaternion : pt;
+    this.gizmo.translate.visible = this.mode === "translate", this.gizmo.rotate.visible = this.mode === "rotate", this.gizmo.scale.visible = this.mode === "scale", this.helper.translate.visible = this.mode === "translate", this.helper.rotate.visible = this.mode === "rotate", this.helper.scale.visible = this.mode === "scale";
+    let s = [];
+    s = s.concat(this.picker[this.mode].children), s = s.concat(this.gizmo[this.mode].children), s = s.concat(this.helper[this.mode].children);
+    for (let o = 0; o < s.length; o++) {
+      const n = s[o];
+      n.visible = !0, n.rotation.set(0, 0, 0), n.position.copy(this.worldPosition);
+      let h;
+      if (this.camera.isOrthographicCamera ? h = (this.camera.top - this.camera.bottom) / this.camera.zoom : h = this.worldPosition.distanceTo(this.cameraPosition) * Math.min(1.9 * Math.tan(Math.PI * this.camera.fov / 360) / this.camera.zoom, 7), n.scale.set(1, 1, 1).multiplyScalar(h * this.size / 4), n.tag === "helper") {
+        n.visible = !1, n.name === "AXIS" ? (n.visible = !!this.axis, this.axis === "X" && (g.setFromEuler(ht.set(0, 0, 0)), n.quaternion.copy(i).multiply(g), Math.abs(f.copy(tt).applyQuaternion(i).dot(this.eye)) > 0.9 && (n.visible = !1)), this.axis === "Y" && (g.setFromEuler(ht.set(0, 0, Math.PI / 2)), n.quaternion.copy(i).multiply(g), Math.abs(f.copy(Z).applyQuaternion(i).dot(this.eye)) > 0.9 && (n.visible = !1)), this.axis === "Z" && (g.setFromEuler(ht.set(0, Math.PI / 2, 0)), n.quaternion.copy(i).multiply(g), Math.abs(f.copy(et).applyQuaternion(i).dot(this.eye)) > 0.9 && (n.visible = !1)), this.axis === "XYZE" && (g.setFromEuler(ht.set(0, Math.PI / 2, 0)), f.copy(this.rotationAxis), n.quaternion.setFromRotationMatrix(kt.lookAt(Ot, f, Z)), n.quaternion.multiply(g), n.visible = this.dragging), this.axis === "E" && (n.visible = !1)) : n.name === "START" ? (n.position.copy(this.worldPositionStart), n.visible = this.dragging) : n.name === "END" ? (n.position.copy(this.worldPosition), n.visible = this.dragging) : n.name === "DELTA" ? (n.position.copy(this.worldPositionStart), n.quaternion.copy(this.worldQuaternionStart), x.set(1e-10, 1e-10, 1e-10).add(this.worldPositionStart).sub(this.worldPosition).multiplyScalar(-1), x.applyQuaternion(this.worldQuaternionStart.clone().invert()), n.scale.copy(x), n.visible = this.dragging) : (n.quaternion.copy(i), this.dragging ? n.position.copy(this.worldPositionStart) : n.position.copy(this.worldPosition), this.axis && (n.visible = this.axis.search(n.name) !== -1));
+        continue;
+      }
+      n.quaternion.copy(i), this.mode === "translate" || this.mode === "scale" ? (n.name === "X" && Math.abs(f.copy(tt).applyQuaternion(i).dot(this.eye)) > 0.99 && (n.scale.set(1e-10, 1e-10, 1e-10), n.visible = !1), n.name === "Y" && Math.abs(f.copy(Z).applyQuaternion(i).dot(this.eye)) > 0.99 && (n.scale.set(1e-10, 1e-10, 1e-10), n.visible = !1), n.name === "Z" && Math.abs(f.copy(et).applyQuaternion(i).dot(this.eye)) > 0.99 && (n.scale.set(1e-10, 1e-10, 1e-10), n.visible = !1), n.name === "XY" && Math.abs(f.copy(et).applyQuaternion(i).dot(this.eye)) < 0.2 && (n.scale.set(1e-10, 1e-10, 1e-10), n.visible = !1), n.name === "YZ" && Math.abs(f.copy(tt).applyQuaternion(i).dot(this.eye)) < 0.2 && (n.scale.set(1e-10, 1e-10, 1e-10), n.visible = !1), n.name === "XZ" && Math.abs(f.copy(Z).applyQuaternion(i).dot(this.eye)) < 0.2 && (n.scale.set(1e-10, 1e-10, 1e-10), n.visible = !1)) : this.mode === "rotate" && (lt.copy(i), f.copy(this.eye).applyQuaternion(g.copy(i).invert()), n.name.search("E") !== -1 && n.quaternion.setFromRotationMatrix(kt.lookAt(this.eye, Ot, Z)), n.name === "X" && (g.setFromAxisAngle(tt, Math.atan2(-f.y, f.z)), g.multiplyQuaternions(lt, g), n.quaternion.copy(g)), n.name === "Y" && (g.setFromAxisAngle(Z, Math.atan2(f.x, f.z)), g.multiplyQuaternions(lt, g), n.quaternion.copy(g)), n.name === "Z" && (g.setFromAxisAngle(et, Math.atan2(f.y, f.x)), g.multiplyQuaternions(lt, g), n.quaternion.copy(g))), n.visible = n.visible && (n.name.indexOf("X") === -1 || this.showX), n.visible = n.visible && (n.name.indexOf("Y") === -1 || this.showY), n.visible = n.visible && (n.name.indexOf("Z") === -1 || this.showZ), n.visible = n.visible && (n.name.indexOf("E") === -1 || this.showX && this.showY && this.showZ), n.material._color = n.material._color || n.material.color.clone(), n.material._opacity = n.material._opacity || n.material.opacity, n.material.color.copy(n.material._color), n.material.opacity = n.material._opacity, this.enabled && this.axis && (n.name === this.axis || this.axis.split("").some(function(d) {
+        return n.name === d;
+      })) && (n.material.color.setHex(16776960), n.material.opacity = 1);
+    }
+    super.updateMatrixWorld(t);
+  }
+}
+class be extends c {
+  constructor() {
+    super(
+      new ie(1e5, 1e5, 2, 2),
+      new Nt({ visible: !1, wireframe: !0, side: se, transparent: !0, opacity: 0.1, toneMapped: !1 })
+    ), this.isTransformControlsPlane = !0, this.type = "TransformControlsPlane";
+  }
+  updateMatrixWorld(t) {
+    let e = this.space;
+    switch (this.position.copy(this.worldPosition), this.mode === "scale" && (e = "local"), ct.copy(tt).applyQuaternion(e === "local" ? this.worldQuaternion : pt), K.copy(Z).applyQuaternion(e === "local" ? this.worldQuaternion : pt), $.copy(et).applyQuaternion(e === "local" ? this.worldQuaternion : pt), f.copy(K), this.mode) {
+      case "translate":
+      case "scale":
+        switch (this.axis) {
+          case "X":
+            f.copy(this.eye).cross(ct), Y.copy(ct).cross(f);
+            break;
+          case "Y":
+            f.copy(this.eye).cross(K), Y.copy(K).cross(f);
+            break;
+          case "Z":
+            f.copy(this.eye).cross($), Y.copy($).cross(f);
+            break;
+          case "XY":
+            Y.copy($);
+            break;
+          case "YZ":
+            Y.copy(ct);
+            break;
+          case "XZ":
+            f.copy($), Y.copy(K);
+            break;
+          case "XYZ":
+          case "E":
+            Y.set(0, 0, 0);
+            break;
+        }
+        break;
+      case "rotate":
+      default:
+        Y.set(0, 0, 0);
+    }
+    Y.length() === 0 ? this.quaternion.copy(this.cameraQuaternion) : (jt.lookAt(x.set(0, 0, 0), Y, f), this.quaternion.setFromRotationMatrix(jt)), super.updateMatrixWorld(t);
+  }
+}
+class q {
+  constructor(t, e = !1) {
+    r(this, "object");
+    r(this, "updatable");
+    r(this, "timestamp");
+    this.object = t, this.updatable = e, this.timestamp = Date.now();
+  }
+}
+class ut extends q {
+  constructor(e, i, s) {
+    super(e, !0);
+    r(this, "type", "SetPosition");
+    r(this, "updatable", !0);
+    r(this, "newPosition");
+    r(this, "oldPosition");
+    this.newPosition = i.clone(), this.oldPosition = s.clone();
+  }
+  execute() {
+    this.object.position.copy(this.newPosition);
+  }
+  undo() {
+    this.object.position.copy(this.oldPosition);
+  }
+  update(e) {
+    e instanceof ut && this.newPosition.copy(e.newPosition);
+  }
+  /**
+   * Get the new position
+   */
+  getNewPosition() {
+    return this.newPosition.clone();
+  }
+  /**
+   * Get the old position
+   */
+  getOldPosition() {
+    return this.oldPosition.clone();
+  }
+}
+class mt extends q {
+  constructor(e, i, s) {
+    super(e, !0);
+    r(this, "type", "SetRotation");
+    r(this, "updatable", !0);
+    r(this, "newRotation");
+    r(this, "oldRotation");
+    this.newRotation = i.clone(), this.oldRotation = s.clone();
+  }
+  execute() {
+    this.object.rotation.copy(this.newRotation);
+  }
+  undo() {
+    this.object.rotation.copy(this.oldRotation);
+  }
+  update(e) {
+    e instanceof mt && this.newRotation.copy(e.newRotation);
+  }
+  /**
+   * Get the new rotation
+   */
+  getNewRotation() {
+    return this.newRotation.clone();
+  }
+  /**
+   * Get the old rotation
+   */
+  getOldRotation() {
+    return this.oldRotation.clone();
+  }
+}
+class ft extends q {
+  constructor(e, i, s) {
+    super(e, !0);
+    r(this, "type", "SetScale");
+    r(this, "updatable", !0);
+    r(this, "newScale");
+    r(this, "oldScale");
+    this.newScale = i.clone(), this.oldScale = s.clone();
+  }
+  execute() {
+    this.object.scale.copy(this.newScale);
+  }
+  undo() {
+    this.object.scale.copy(this.oldScale);
+  }
+  update(e) {
+    e instanceof ft && this.newScale.copy(e.newScale);
+  }
+  /**
+   * Get the new scale
+   */
+  getNewScale() {
+    return this.newScale.clone();
+  }
+  /**
+   * Get the old scale
+   */
+  getOldScale() {
+    return this.oldScale.clone();
+  }
+}
+class we {
+  constructor(t) {
+    r(this, "editor");
+    r(this, "controls");
+    r(this, "mode", "translate");
+    r(this, "eventListeners", /* @__PURE__ */ new Map());
+    // Track transform start state for undo
+    r(this, "transformStartPosition", null);
+    r(this, "transformStartRotation", null);
+    r(this, "transformStartScale", null);
+    r(this, "isTransforming", !1);
+    this.editor = t, this.controls = new ce(
+      this.editor.camera,
+      this.editor.renderer.domElement
+    ), this.controls.setSize(0.75), this.editor.scene.add(this.controls.getHelper()), this.handleDraggingChanged = this.handleDraggingChanged.bind(this), this.handleObjectChange = this.handleObjectChange.bind(this), this.controls.addEventListener("dragging-changed", this.handleDraggingChanged), this.controls.addEventListener("objectChange", this.handleObjectChange), this.handleKeyDown = this.handleKeyDown.bind(this), document.addEventListener("keydown", this.handleKeyDown);
+  }
+  /**
+   * Handle dragging state changes
+   */
+  handleDraggingChanged(t) {
+    const e = t.value;
+    this.editor.controls.enabled = !e, e ? (this.captureStartState(), this.isTransforming = !0) : this.isTransforming && (this.createCommand(), this.isTransforming = !1);
+  }
+  /**
+   * Capture the start state before transform
+   */
+  captureStartState() {
+    const t = this.controls.object;
+    t && (this.transformStartPosition = t.position.clone(), this.transformStartRotation = t.rotation.clone(), this.transformStartScale = t.scale.clone());
+  }
+  /**
+   * Create a command after transform completes
+   */
+  createCommand() {
+    const t = this.controls.object;
+    if (!t) return;
+    let e = null;
+    switch (this.mode) {
+      case "translate":
+        this.transformStartPosition && !t.position.equals(this.transformStartPosition) && (e = new ut(
+          t,
+          t.position.clone(),
+          this.transformStartPosition.clone()
+        ));
+        break;
+      case "rotate":
+        this.transformStartRotation && (t.rotation.x !== this.transformStartRotation.x || t.rotation.y !== this.transformStartRotation.y || t.rotation.z !== this.transformStartRotation.z) && (e = new mt(
+          t,
+          t.rotation.clone(),
+          this.transformStartRotation.clone()
+        ));
+        break;
+      case "scale":
+        this.transformStartScale && !t.scale.equals(this.transformStartScale) && (e = new ft(
+          t,
+          t.scale.clone(),
+          this.transformStartScale.clone()
+        ));
+        break;
+    }
+    e && this.emit("objectChanged", t, e), this.transformStartPosition = null, this.transformStartRotation = null, this.transformStartScale = null;
+  }
+  /**
+   * Handle object change during transform (live updates)
+   */
+  handleObjectChange() {
+    const t = this.controls.object;
+    t && this.emit("objectChanging", t);
+  }
+  /**
+   * Handle keyboard shortcuts
+   */
+  handleKeyDown(t) {
+    if (!(t.target instanceof HTMLInputElement || t.target instanceof HTMLTextAreaElement))
+      switch (t.key.toLowerCase()) {
+        case "g":
+          this.setMode("translate");
+          break;
+        case "r":
+          !t.ctrlKey && !t.metaKey && this.setMode("rotate");
+          break;
+        case "s":
+          !t.ctrlKey && !t.metaKey && this.setMode("scale");
+          break;
+        case "escape":
+          this.isTransforming && this.cancelTransform();
+          break;
+      }
+  }
+  /**
+   * Cancel current transform and restore original state
+   */
+  cancelTransform() {
+    const t = this.controls.object;
+    t && (this.transformStartPosition && t.position.copy(this.transformStartPosition), this.transformStartRotation && t.rotation.copy(this.transformStartRotation), this.transformStartScale && t.scale.copy(this.transformStartScale), this.isTransforming = !1, this.transformStartPosition = null, this.transformStartRotation = null, this.transformStartScale = null);
+  }
+  /**
+   * Attach controls to an object
+   */
+  attach(t) {
+    const e = this.controls.getHelper();
+    t ? (this.controls.attach(t), e.visible = !0) : (this.controls.detach(), e.visible = !1);
+  }
+  /**
+   * Set transform mode
+   */
+  setMode(t) {
+    this.mode = t, this.controls.setMode(t), this.emit("modeChanged", t);
+  }
+  /**
+   * Get current transform mode
+   */
+  getMode() {
+    return this.mode;
+  }
+  /**
+   * Get TransformControls instance
+   */
+  getControls() {
+    return this.controls;
+  }
+  /**
+   * Add event listener
+   */
+  on(t, e) {
+    this.eventListeners.has(t) || this.eventListeners.set(t, /* @__PURE__ */ new Set()), this.eventListeners.get(t).add(e);
+  }
+  /**
+   * Emit event
+   */
+  emit(t, ...e) {
+    var i;
+    (i = this.eventListeners.get(t)) == null || i.forEach((s) => s(...e));
+  }
+  /**
+   * Clean up
+   */
+  dispose() {
+    document.removeEventListener("keydown", this.handleKeyDown), this.controls.removeEventListener("dragging-changed", this.handleDraggingChanged), this.controls.removeEventListener("objectChange", this.handleObjectChange), this.controls.dispose(), this.editor.scene.remove(this.controls.getHelper()), this.eventListeners.clear();
+  }
+}
+const _e = 500;
+class xe {
+  constructor() {
+    r(this, "undoStack", []);
+    r(this, "redoStack", []);
+    r(this, "eventListeners", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Execute a command and add it to history
+   */
+  execute(t) {
+    t.execute();
+    const e = this.undoStack[this.undoStack.length - 1];
+    e && e.updatable && t.updatable && e.type === t.type && e.object === t.object && t.timestamp - e.timestamp < _e ? e.update && e.update(t) : this.undoStack.push(t), this.redoStack = [], this.emit("historyChanged");
+  }
+  /**
+   * Undo the last command
+   */
+  undo() {
+    const t = this.undoStack.pop();
+    t && (t.undo(), this.redoStack.push(t), this.emit("historyChanged"));
+  }
+  /**
+   * Redo the last undone command
+   */
+  redo() {
+    const t = this.redoStack.pop();
+    t && (t.execute(), this.undoStack.push(t), this.emit("historyChanged"));
+  }
+  /**
+   * Check if undo is available
+   */
+  canUndo() {
+    return this.undoStack.length > 0;
+  }
+  /**
+   * Check if redo is available
+   */
+  canRedo() {
+    return this.redoStack.length > 0;
+  }
+  /**
+   * Clear all history
+   */
+  clear() {
+    this.undoStack = [], this.redoStack = [], this.emit("historyChanged");
+  }
+  /**
+   * Get the number of items in undo stack
+   */
+  getUndoCount() {
+    return this.undoStack.length;
+  }
+  /**
+   * Get the number of items in redo stack
+   */
+  getRedoCount() {
+    return this.redoStack.length;
+  }
+  /**
+   * Add event listener
+   */
+  on(t, e) {
+    this.eventListeners.has(t) || this.eventListeners.set(t, /* @__PURE__ */ new Set()), this.eventListeners.get(t).add(e);
+  }
+  /**
+   * Emit event
+   */
+  emit(t) {
+    var e;
+    (e = this.eventListeners.get(t)) == null || e.forEach((i) => i());
+  }
+}
+class Ze {
+  constructor(t) {
+    r(this, "scene");
+    r(this, "camera");
+    r(this, "renderer");
+    r(this, "controls");
+    r(this, "domElement");
+    r(this, "selection");
+    r(this, "transform");
+    r(this, "history");
+    r(this, "currentModel", null);
+    r(this, "eventListeners", /* @__PURE__ */ new Map());
+    this.scene = t.scene, this.camera = t.camera, this.renderer = t.renderer, this.controls = t.controls, this.domElement = t.domElement, this.history = new xe(), this.selection = new le(this), this.transform = new we(this), this.selection.on("selectionChanged", (e) => {
+      this.emit("selectionChanged", e), this.transform.attach(e);
+    }), this.transform.on("objectChanged", (...e) => {
+      const i = e[0], s = e[1];
+      this.history.execute(s), this.emit("objectChanged", i);
+    }), this.history.on("historyChanged", () => {
+      this.emit("historyChanged");
+    }), this.transform.on("modeChanged", (...e) => {
+      const i = e[0];
+      this.emit("modeChanged", i);
+    });
+  }
+  /**
+   * Set the current model being edited
+   */
+  setModel(t) {
+    this.currentModel = t, this.selection.deselect(), this.history.clear(), this.emit("modelLoaded", t);
+  }
+  /**
+   * Get the current model
+   */
+  getModel() {
+    return this.currentModel;
+  }
+  /**
+   * Get the currently selected object
+   */
+  getSelected() {
+    return this.selection.getSelected();
+  }
+  /**
+   * Select an object
+   */
+  select(t) {
+    this.selection.select(t);
+  }
+  /**
+   * Execute a command (adds to history)
+   */
+  execute(t) {
+    this.history.execute(t), this.emit("objectChanged", this.getSelected());
+  }
+  /**
+   * Undo the last command
+   */
+  undo() {
+    this.history.undo(), this.emit("objectChanged", this.getSelected());
+  }
+  /**
+   * Redo the last undone command
+   */
+  redo() {
+    this.history.redo(), this.emit("objectChanged", this.getSelected());
+  }
+  /**
+   * Check if undo is available
+   */
+  canUndo() {
+    return this.history.canUndo();
+  }
+  /**
+   * Check if redo is available
+   */
+  canRedo() {
+    return this.history.canRedo();
+  }
+  /**
+   * Set transform mode
+   */
+  setTransformMode(t) {
+    this.transform.setMode(t);
+  }
+  /**
+   * Get current transform mode
+   */
+  getTransformMode() {
+    return this.transform.getMode();
+  }
+  /**
+   * Add event listener
+   */
+  on(t, e) {
+    this.eventListeners.has(t) || this.eventListeners.set(t, /* @__PURE__ */ new Set()), this.eventListeners.get(t).add(e);
+  }
+  /**
+   * Remove event listener
+   */
+  off(t, e) {
+    var i;
+    (i = this.eventListeners.get(t)) == null || i.delete(e);
+  }
+  /**
+   * Emit an event
+   */
+  emit(t, ...e) {
+    var i;
+    (i = this.eventListeners.get(t)) == null || i.forEach((s) => s(...e));
+  }
+  /**
+   * Clean up resources
+   */
+  dispose() {
+    this.selection.dispose(), this.transform.dispose(), this.eventListeners.clear();
+  }
+}
+function Se() {
+  return `node_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 8)}`;
+}
+class Be {
+  /**
+   * Serialize a Three.js model group to BlockyModel JSON
+   */
+  serialize(t) {
+    const e = {
+      format: t.userData.format || "prop",
+      lod: t.userData.lod || "auto",
+      nodes: []
+    };
+    for (const i of t.children)
+      this.shouldSerialize(i) && e.nodes.push(this.serializeNode(i));
+    return e;
+  }
+  /**
+   * Check if an object should be serialized
+   */
+  shouldSerialize(t) {
+    return !(t.type === "TransformControlsGizmo" || t.type === "TransformControlsPlane" || t.type === "GridHelper" || t.type === "AxesHelper");
+  }
+  /**
+   * Serialize a single node
+   */
+  serializeNode(t) {
+    const e = {
+      id: t.userData.id || t.name || Se(),
+      name: t.name || "Unnamed",
+      position: this.serializePosition(t.position),
+      orientation: this.serializeQuaternion(t.quaternion),
+      shape: this.serializeShape(t),
+      children: []
+    };
+    for (const i of t.children)
+      this.shouldSerialize(i) && e.children.push(this.serializeNode(i));
+    return e;
+  }
+  /**
+   * Serialize position
+   */
+  serializePosition(t) {
+    return {
+      x: parseFloat(t.x.toFixed(4)),
+      y: parseFloat(t.y.toFixed(4)),
+      z: parseFloat(t.z.toFixed(4))
+    };
+  }
+  /**
+   * Serialize quaternion
+   */
+  serializeQuaternion(t) {
+    return {
+      w: parseFloat(t.w.toFixed(6)),
+      x: parseFloat(t.x.toFixed(6)),
+      y: parseFloat(t.y.toFixed(6)),
+      z: parseFloat(t.z.toFixed(6))
+    };
+  }
+  /**
+   * Serialize shape
+   */
+  serializeShape(t) {
+    const e = t.userData.shapeType || "none", i = {
+      type: e,
+      offset: t.userData.offset || { x: 0, y: 0, z: 0 },
+      stretch: t.userData.stretch || { x: 1, y: 1, z: 1 },
+      settings: {
+        size: t.userData.originalSize || { x: 1, y: 1, z: 1 },
+        isPiece: t.userData.isPiece || !1,
+        isStaticBox: t.userData.isStaticBox || !1
+      },
+      textureLayout: t.userData.textureLayout || this.getDefaultTextureLayout(),
+      unwrapMode: t.userData.unwrapMode || "custom",
+      visible: t.visible !== !1,
+      doubleSided: t.userData.doubleSided || !1,
+      shadingMode: t.userData.shadingMode || "standard"
+    };
+    if (t instanceof l.Mesh) {
+      const s = t.geometry;
+      if (s instanceof l.BoxGeometry) {
+        const n = s.parameters;
+        t.userData.originalSize || (i.settings.size = {
+          x: n.width,
+          y: n.height,
+          z: n.depth
+        });
+      }
+      const o = t.material;
+      o && (i.doubleSided = o.side === l.DoubleSide, o.emissiveIntensity > 0.5 ? i.shadingMode = "fullbright" : o.flatShading ? i.shadingMode = "flat" : o.metalness > 0.5 && (i.shadingMode = "reflective"));
+    }
+    return e === "quad" && t.userData.normal && (i.settings.normal = t.userData.normal), i;
+  }
+  /**
+   * Get default texture layout
+   */
+  getDefaultTextureLayout() {
+    const t = {
+      offset: { x: 0, y: 0 },
+      mirror: { x: !1, y: !1 },
+      angle: 0
+    };
+    return {
+      front: { ...t },
+      back: { ...t },
+      left: { ...t },
+      right: { ...t },
+      top: { ...t },
+      bottom: { ...t }
+    };
+  }
+  /**
+   * Export model to JSON string
+   */
+  toJSON(t) {
+    const e = this.serialize(t);
+    return JSON.stringify(e, null, 2);
+  }
+  /**
+   * Download model as .blockymodel file
+   */
+  download(t, e = "model.blockymodel") {
+    const i = this.toJSON(t), s = new Blob([i], { type: "application/json" }), o = URL.createObjectURL(s), n = document.createElement("a");
+    n.href = o, n.download = e.endsWith(".blockymodel") ? e : `${e}.blockymodel`, n.click(), URL.revokeObjectURL(o);
+  }
+}
+class N extends q {
+  constructor(e, i, s, o) {
+    super(e, !0);
+    r(this, "type", "SetProperty");
+    r(this, "updatable", !0);
+    r(this, "propertyPath");
+    r(this, "newValue");
+    r(this, "oldValue");
+    this.propertyPath = i, this.newValue = this.cloneValue(s), this.oldValue = this.cloneValue(o);
+  }
+  /**
+   * Clone a value if it's an object/array
+   */
+  cloneValue(e) {
+    return e == null ? e : typeof e == "object" ? JSON.parse(JSON.stringify(e)) : e;
+  }
+  /**
+   * Get a nested property by path (e.g., "userData.size.x")
+   */
+  getProperty(e, i) {
+    const s = i.split(".");
+    let o = e;
+    for (const n of s) {
+      if (o == null) return;
+      o = o[n];
+    }
+    return o;
+  }
+  /**
+   * Set a nested property by path
+   */
+  setProperty(e, i, s) {
+    const o = i.split(".");
+    let n = e;
+    for (let h = 0; h < o.length - 1; h++)
+      n[o[h]] === void 0 && (n[o[h]] = {}), n = n[o[h]];
+    n[o[o.length - 1]] = s;
+  }
+  execute() {
+    this.setProperty(this.object, this.propertyPath, this.cloneValue(this.newValue));
+  }
+  undo() {
+    this.setProperty(this.object, this.propertyPath, this.cloneValue(this.oldValue));
+  }
+  update(e) {
+    e instanceof N && e.propertyPath === this.propertyPath && (this.newValue = e.newValue);
+  }
+  /**
+   * Get the property path
+   */
+  getPropertyPath() {
+    return this.propertyPath;
+  }
+  /**
+   * Get the new value
+   */
+  getNewValue() {
+    return this.cloneValue(this.newValue);
+  }
+  /**
+   * Get the old value
+   */
+  getOldValue() {
+    return this.cloneValue(this.oldValue);
+  }
+}
+class wt extends q {
+  constructor(e, i, s) {
+    super(e, !1);
+    r(this, "type", "AddNode");
+    r(this, "updatable", !1);
+    r(this, "parent");
+    r(this, "child");
+    r(this, "index");
+    this.parent = e, this.child = i, this.index = s ?? e.children.length;
+  }
+  execute() {
+    if (this.parent.add(this.child), this.index < this.parent.children.length - 1) {
+      const e = this.parent.children;
+      e.splice(e.indexOf(this.child), 1), e.splice(this.index, 0, this.child);
+    }
+  }
+  undo() {
+    this.parent.remove(this.child);
+  }
+  /**
+   * Get the added child
+   */
+  getChild() {
+    return this.child;
+  }
+  /**
+   * Get the parent
+   */
+  getParent() {
+    return this.parent;
+  }
+}
+class Me extends q {
+  constructor(e) {
+    super(e, !1);
+    r(this, "type", "RemoveNode");
+    r(this, "updatable", !1);
+    r(this, "parent");
+    r(this, "child");
+    r(this, "index");
+    if (!e.parent)
+      throw new Error("Cannot remove node without parent");
+    this.parent = e.parent, this.child = e, this.index = this.parent.children.indexOf(e);
+  }
+  execute() {
+    this.parent.remove(this.child);
+  }
+  undo() {
+    if (this.parent.add(this.child), this.index < this.parent.children.length) {
+      const e = this.parent.children;
+      e.splice(e.indexOf(this.child), 1), e.splice(this.index, 0, this.child);
+    }
+  }
+  /**
+   * Get the removed child
+   */
+  getChild() {
+    return this.child;
+  }
+  /**
+   * Get the parent
+   */
+  getParent() {
+    return this.parent;
+  }
+  /**
+   * Get the original index
+   */
+  getIndex() {
+    return this.index;
+  }
+}
+class Qe {
+  constructor(t, e) {
+    r(this, "editor");
+    r(this, "container");
+    r(this, "currentObject", null);
+    r(this, "isUpdating", !1);
+    // Input elements
+    r(this, "nameInput");
+    r(this, "posInputs");
+    r(this, "rotInputs");
+    r(this, "scaleInputs");
+    r(this, "sizeInputs");
+    r(this, "offsetInputs");
+    r(this, "visibleCheckbox");
+    r(this, "doubleSidedCheckbox");
+    r(this, "shadingModeSelect");
+    r(this, "shapeTypeSpan");
+    this.editor = t;
+    const i = document.getElementById(e);
+    if (!i)
+      throw new Error(`Property panel container not found: ${e}`);
+    this.container = i, this.buildUI(), this.setupEventListeners();
+  }
+  /**
+   * Build the property panel UI
+   */
+  buildUI() {
+    this.container.innerHTML = `
+      <div class="property-section" id="properties-transform">
+        <div class="section-header">Transform</div>
+        <div class="property-row">
+          <label>Name</label>
+          <input type="text" id="prop-name" class="prop-input prop-text" />
+        </div>
+        <div class="property-row">
+          <label>Position</label>
+          <div class="vec3-inputs">
+            <input type="number" id="prop-pos-x" class="prop-input" step="0.1" />
+            <input type="number" id="prop-pos-y" class="prop-input" step="0.1" />
+            <input type="number" id="prop-pos-z" class="prop-input" step="0.1" />
+          </div>
+        </div>
+        <div class="property-row">
+          <label>Rotation</label>
+          <div class="vec3-inputs">
+            <input type="number" id="prop-rot-x" class="prop-input" step="1" />
+            <input type="number" id="prop-rot-y" class="prop-input" step="1" />
+            <input type="number" id="prop-rot-z" class="prop-input" step="1" />
+          </div>
+        </div>
+        <div class="property-row">
+          <label>Scale</label>
+          <div class="vec3-inputs">
+            <input type="number" id="prop-scale-x" class="prop-input" step="0.1" min="0.01" />
+            <input type="number" id="prop-scale-y" class="prop-input" step="0.1" min="0.01" />
+            <input type="number" id="prop-scale-z" class="prop-input" step="0.1" min="0.01" />
+          </div>
+        </div>
+      </div>
+
+      <div class="property-section" id="properties-shape">
+        <div class="section-header">Shape</div>
+        <div class="property-row">
+          <label>Type</label>
+          <span id="prop-shape-type" class="prop-readonly">-</span>
+        </div>
+        <div class="property-row">
+          <label>Size</label>
+          <div class="vec3-inputs">
+            <input type="number" id="prop-size-x" class="prop-input" step="1" min="0" />
+            <input type="number" id="prop-size-y" class="prop-input" step="1" min="0" />
+            <input type="number" id="prop-size-z" class="prop-input" step="1" min="0" />
+          </div>
+        </div>
+        <div class="property-row">
+          <label>Offset</label>
+          <div class="vec3-inputs">
+            <input type="number" id="prop-offset-x" class="prop-input" step="0.5" />
+            <input type="number" id="prop-offset-y" class="prop-input" step="0.5" />
+            <input type="number" id="prop-offset-z" class="prop-input" step="0.5" />
+          </div>
+        </div>
+        <div class="property-row">
+          <label>Visible</label>
+          <input type="checkbox" id="prop-visible" class="prop-checkbox" />
+        </div>
+        <div class="property-row">
+          <label>Double Sided</label>
+          <input type="checkbox" id="prop-doublesided" class="prop-checkbox" />
+        </div>
+        <div class="property-row">
+          <label>Shading</label>
+          <select id="prop-shading" class="prop-select">
+            <option value="standard">Standard</option>
+            <option value="flat">Flat</option>
+            <option value="fullbright">Fullbright</option>
+            <option value="reflective">Reflective</option>
+          </select>
+        </div>
+      </div>
+
+      <div class="property-empty" id="properties-empty">
+        <p>Select an object to view properties</p>
+      </div>
+    `, this.nameInput = document.getElementById("prop-name"), this.posInputs = {
+      x: document.getElementById("prop-pos-x"),
+      y: document.getElementById("prop-pos-y"),
+      z: document.getElementById("prop-pos-z")
+    }, this.rotInputs = {
+      x: document.getElementById("prop-rot-x"),
+      y: document.getElementById("prop-rot-y"),
+      z: document.getElementById("prop-rot-z")
+    }, this.scaleInputs = {
+      x: document.getElementById("prop-scale-x"),
+      y: document.getElementById("prop-scale-y"),
+      z: document.getElementById("prop-scale-z")
+    }, this.sizeInputs = {
+      x: document.getElementById("prop-size-x"),
+      y: document.getElementById("prop-size-y"),
+      z: document.getElementById("prop-size-z")
+    }, this.offsetInputs = {
+      x: document.getElementById("prop-offset-x"),
+      y: document.getElementById("prop-offset-y"),
+      z: document.getElementById("prop-offset-z")
+    }, this.visibleCheckbox = document.getElementById("prop-visible"), this.doubleSidedCheckbox = document.getElementById("prop-doublesided"), this.shadingModeSelect = document.getElementById("prop-shading"), this.shapeTypeSpan = document.getElementById("prop-shape-type"), this.showEmpty();
+  }
+  /**
+   * Setup event listeners
+   */
+  setupEventListeners() {
+    this.editor.on("selectionChanged", (t) => {
+      this.setObject(t);
+    }), this.editor.on("objectChanged", () => {
+      this.currentObject && this.updateFromObject();
+    }), this.editor.transform.on("objectChanging", () => {
+      this.currentObject && this.updateFromObject();
+    }), this.nameInput.addEventListener("change", () => {
+      if (this.currentObject && !this.isUpdating) {
+        const t = this.currentObject.name, e = this.nameInput.value;
+        this.editor.execute(new N(this.currentObject, "name", e, t));
+      }
+    }), this.setupVec3Input(this.posInputs, (t) => {
+      if (this.currentObject && !this.isUpdating) {
+        const e = this.currentObject.position.clone();
+        this.editor.execute(new ut(this.currentObject, t, e));
+      }
+    }), this.setupVec3Input(this.rotInputs, (t) => {
+      if (this.currentObject && !this.isUpdating) {
+        const e = this.currentObject.rotation.clone(), i = new l.Euler(
+          l.MathUtils.degToRad(t.x),
+          l.MathUtils.degToRad(t.y),
+          l.MathUtils.degToRad(t.z)
+        );
+        this.editor.execute(new mt(this.currentObject, i, e));
+      }
+    }), this.setupVec3Input(this.scaleInputs, (t) => {
+      if (this.currentObject && !this.isUpdating) {
+        const e = this.currentObject.scale.clone();
+        this.editor.execute(new ft(this.currentObject, t, e));
+      }
+    }), this.setupVec3Input(this.sizeInputs, (t) => {
+      if (this.currentObject && !this.isUpdating) {
+        const e = this.currentObject.userData.originalSize || { x: 1, y: 1, z: 1 };
+        this.editor.execute(
+          new N(this.currentObject, "userData.originalSize", { x: t.x, y: t.y, z: t.z }, e)
+        ), this.rebuildGeometry();
+      }
+    }), this.setupVec3Input(this.offsetInputs, (t) => {
+      if (this.currentObject && !this.isUpdating) {
+        const e = this.currentObject.userData.offset || { x: 0, y: 0, z: 0 };
+        this.editor.execute(
+          new N(this.currentObject, "userData.offset", { x: t.x, y: t.y, z: t.z }, e)
+        ), this.rebuildGeometry();
+      }
+    }), this.visibleCheckbox.addEventListener("change", () => {
+      if (this.currentObject && !this.isUpdating) {
+        const t = this.currentObject.visible, e = this.visibleCheckbox.checked;
+        this.editor.execute(new N(this.currentObject, "visible", e, t));
+      }
+    }), this.doubleSidedCheckbox.addEventListener("change", () => {
+      if (this.currentObject && !this.isUpdating && this.currentObject instanceof l.Mesh) {
+        const t = this.currentObject.material, e = t.side === l.DoubleSide, i = this.doubleSidedCheckbox.checked;
+        t.side = i ? l.DoubleSide : l.FrontSide, this.currentObject.userData.doubleSided = i, this.editor.execute(
+          new N(this.currentObject, "userData.doubleSided", i, e)
+        );
+      }
+    }), this.shadingModeSelect.addEventListener("change", () => {
+      if (this.currentObject && !this.isUpdating) {
+        const t = this.currentObject.userData.shadingMode || "standard", e = this.shadingModeSelect.value;
+        this.currentObject.userData.shadingMode = e, this.editor.execute(
+          new N(this.currentObject, "userData.shadingMode", e, t)
+        );
+      }
+    });
+  }
+  /**
+   * Setup Vec3 input handlers
+   */
+  setupVec3Input(t, e) {
+    const i = () => {
+      const s = new l.Vector3(
+        parseFloat(t.x.value) || 0,
+        parseFloat(t.y.value) || 0,
+        parseFloat(t.z.value) || 0
+      );
+      e(s);
+    };
+    t.x.addEventListener("change", i), t.y.addEventListener("change", i), t.z.addEventListener("change", i);
+  }
+  /**
+   * Set the object to display properties for
+   */
+  setObject(t) {
+    this.currentObject = t, t ? (this.showProperties(), this.updateFromObject()) : this.showEmpty();
+  }
+  /**
+   * Update UI from current object
+   */
+  updateFromObject() {
+    var o, n, h, d, u, y;
+    if (!this.currentObject) return;
+    this.isUpdating = !0;
+    const t = this.currentObject;
+    this.nameInput.value = t.name || "", this.posInputs.x.value = t.position.x.toFixed(2), this.posInputs.y.value = t.position.y.toFixed(2), this.posInputs.z.value = t.position.z.toFixed(2), this.rotInputs.x.value = l.MathUtils.radToDeg(t.rotation.x).toFixed(1), this.rotInputs.y.value = l.MathUtils.radToDeg(t.rotation.y).toFixed(1), this.rotInputs.z.value = l.MathUtils.radToDeg(t.rotation.z).toFixed(1), this.scaleInputs.x.value = t.scale.x.toFixed(2), this.scaleInputs.y.value = t.scale.y.toFixed(2), this.scaleInputs.z.value = t.scale.z.toFixed(2);
+    const e = t.userData.shapeType || "none";
+    this.shapeTypeSpan.textContent = e;
+    const i = t.userData.originalSize || { x: 1, y: 1, z: 1 };
+    this.sizeInputs.x.value = ((o = i.x) == null ? void 0 : o.toString()) || "1", this.sizeInputs.y.value = ((n = i.y) == null ? void 0 : n.toString()) || "1", this.sizeInputs.z.value = ((h = i.z) == null ? void 0 : h.toString()) || "1";
+    const s = t.userData.offset || { x: 0, y: 0, z: 0 };
+    if (this.offsetInputs.x.value = ((d = s.x) == null ? void 0 : d.toString()) || "0", this.offsetInputs.y.value = ((u = s.y) == null ? void 0 : u.toString()) || "0", this.offsetInputs.z.value = ((y = s.z) == null ? void 0 : y.toString()) || "0", this.visibleCheckbox.checked = t.visible, t instanceof l.Mesh) {
+      const _ = t.material;
+      this.doubleSidedCheckbox.checked = _.side === l.DoubleSide;
+    } else
+      this.doubleSidedCheckbox.checked = !1;
+    this.shadingModeSelect.value = t.userData.shadingMode || "standard", this.isUpdating = !1;
+  }
+  /**
+   * Rebuild geometry after size/offset changes
+   */
+  rebuildGeometry() {
+    if (!this.currentObject || !(this.currentObject instanceof l.Mesh)) return;
+    const t = this.currentObject, e = t.userData.originalSize || { x: 1, y: 1, z: 1 }, i = t.userData.offset || { x: 0, y: 0, z: 0 }, s = t.userData.stretch || { x: 1, y: 1, z: 1 }, o = {
+      x: e.x * s.x,
+      y: e.y * s.y,
+      z: e.z * s.z
+    };
+    t.geometry.dispose(), t.userData.shapeType === "box" && (t.geometry = new l.BoxGeometry(o.x, o.y, o.z), t.geometry.translate(i.x, i.y, i.z));
+  }
+  /**
+   * Show property sections
+   */
+  showProperties() {
+    const t = document.getElementById("properties-transform"), e = document.getElementById("properties-shape"), i = document.getElementById("properties-empty");
+    t && (t.style.display = "block"), e && (e.style.display = "block"), i && (i.style.display = "none");
+  }
+  /**
+   * Show empty state
+   */
+  showEmpty() {
+    const t = document.getElementById("properties-transform"), e = document.getElementById("properties-shape"), i = document.getElementById("properties-empty");
+    t && (t.style.display = "none"), e && (e.style.display = "none"), i && (i.style.display = "block");
+  }
+  /**
+   * Cleanup
+   */
+  dispose() {
+    this.container.innerHTML = "";
+  }
+}
+class Ve {
+  constructor(t, e) {
+    r(this, "editor");
+    r(this, "container");
+    r(this, "treeContainer");
+    r(this, "contextMenu", null);
+    r(this, "contextTarget", null);
+    this.editor = t;
+    const i = document.getElementById(e);
+    if (!i)
+      throw new Error(`Hierarchy panel container not found: ${e}`);
+    this.container = i, this.buildUI(), this.setupEventListeners();
+  }
+  /**
+   * Build the hierarchy panel UI
+   */
+  buildUI() {
+    this.container.innerHTML = `
+      <div class="hierarchy-tree" id="hierarchy-tree"></div>
+    `, this.treeContainer = document.getElementById("hierarchy-tree"), this.contextMenu = document.createElement("div"), this.contextMenu.className = "context-menu", this.contextMenu.innerHTML = `
+      <div class="context-menu-item" data-action="add-box">Add Child Box</div>
+      <div class="context-menu-item" data-action="add-group">Add Child Group</div>
+      <div class="context-menu-separator"></div>
+      <div class="context-menu-item" data-action="duplicate">Duplicate</div>
+      <div class="context-menu-separator"></div>
+      <div class="context-menu-item context-menu-danger" data-action="delete">Delete</div>
+    `, this.contextMenu.style.display = "none", document.body.appendChild(this.contextMenu);
+  }
+  /**
+   * Setup event listeners
+   */
+  setupEventListeners() {
+    var t;
+    this.editor.on("modelLoaded", () => {
+      this.refresh();
+    }), this.editor.on("selectionChanged", () => {
+      this.updateSelection();
+    }), this.editor.on("objectChanged", () => {
+      this.refresh();
+    }), (t = this.contextMenu) == null || t.addEventListener("click", (e) => {
+      const s = e.target.dataset.action;
+      s && this.contextTarget && this.handleContextAction(s, this.contextTarget), this.hideContextMenu();
+    }), document.addEventListener("click", (e) => {
+      this.contextMenu && !this.contextMenu.contains(e.target) && this.hideContextMenu();
+    }), document.addEventListener("keydown", (e) => {
+      if (e.key === "Delete" || e.key === "Backspace") {
+        const i = this.editor.getSelected();
+        i && i.parent && !(e.target instanceof HTMLInputElement) && this.deleteNode(i);
+      }
+    });
+  }
+  /**
+   * Refresh the hierarchy tree
+   */
+  refresh() {
+    const t = this.editor.getModel();
+    if (!t) {
+      this.treeContainer.innerHTML = '<p class="hierarchy-empty">No model loaded</p>';
+      return;
+    }
+    this.treeContainer.innerHTML = "", this.buildTree(t, this.treeContainer, 0);
+  }
+  /**
+   * Build tree recursively
+   */
+  buildTree(t, e, i) {
+    const s = document.createElement("div");
+    s.className = "hierarchy-item", s.dataset.objectId = t.uuid;
+    const o = document.createElement("span");
+    o.className = "hierarchy-indent", o.style.width = `${i * 16}px`;
+    const n = document.createElement("span");
+    n.className = "hierarchy-expander", t.children.length > 0 && (n.textContent = "▼", n.addEventListener("click", (u) => {
+      u.stopPropagation(), this.toggleExpand(s);
+    }));
+    const h = document.createElement("span");
+    h.className = "hierarchy-icon", h.textContent = this.getIcon(t);
+    const d = document.createElement("span");
+    if (d.className = "hierarchy-label", d.textContent = t.name || `(${t.type})`, s.appendChild(o), s.appendChild(n), s.appendChild(h), s.appendChild(d), s.addEventListener("click", () => {
+      this.editor.select(t);
+    }), s.addEventListener("contextmenu", (u) => {
+      u.preventDefault(), this.showContextMenu(u, t);
+    }), e.appendChild(s), t.children.length > 0) {
+      const u = document.createElement("div");
+      u.className = "hierarchy-children";
+      for (const y of t.children)
+        y.type === "TransformControlsGizmo" || y.type === "TransformControlsPlane" || this.buildTree(y, u, i + 1);
+      e.appendChild(u);
+    }
+  }
+  /**
+   * Get icon for object type
+   */
+  getIcon(t) {
+    if (t instanceof l.Mesh) {
+      const e = t.userData.shapeType;
+      return e === "box" ? "📦" : e === "quad" ? "▫️" : "🔷";
+    }
+    return t instanceof l.Group ? "📁" : "◯";
+  }
+  /**
+   * Toggle expand/collapse
+   */
+  toggleExpand(t) {
+    const e = t.nextElementSibling;
+    if (e != null && e.classList.contains("hierarchy-children")) {
+      const i = e.classList.toggle("collapsed"), s = t.querySelector(".hierarchy-expander");
+      s && (s.textContent = i ? "▶" : "▼");
+    }
+  }
+  /**
+   * Update selection highlight
+   */
+  updateSelection() {
+    this.treeContainer.querySelectorAll(".hierarchy-item.selected").forEach((e) => {
+      e.classList.remove("selected");
+    });
+    const t = this.editor.getSelected();
+    if (t) {
+      const e = this.treeContainer.querySelector(`[data-object-id="${t.uuid}"]`);
+      e && (e.classList.add("selected"), e.scrollIntoView({ behavior: "smooth", block: "nearest" }));
+    }
+  }
+  /**
+   * Show context menu
+   */
+  showContextMenu(t, e) {
+    if (!this.contextMenu) return;
+    this.contextTarget = e, this.contextMenu.style.display = "block", this.contextMenu.style.left = `${t.clientX}px`, this.contextMenu.style.top = `${t.clientY}px`;
+    const i = this.contextMenu.getBoundingClientRect();
+    i.right > window.innerWidth && (this.contextMenu.style.left = `${window.innerWidth - i.width - 10}px`), i.bottom > window.innerHeight && (this.contextMenu.style.top = `${window.innerHeight - i.height - 10}px`);
+  }
+  /**
+   * Hide context menu
+   */
+  hideContextMenu() {
+    this.contextMenu && (this.contextMenu.style.display = "none"), this.contextTarget = null;
+  }
+  /**
+   * Handle context menu action
+   */
+  handleContextAction(t, e) {
+    switch (t) {
+      case "add-box":
+        this.addChildBox(e);
+        break;
+      case "add-group":
+        this.addChildGroup(e);
+        break;
+      case "duplicate":
+        this.duplicateNode(e);
+        break;
+      case "delete":
+        this.deleteNode(e);
+        break;
+    }
+  }
+  /**
+   * Add a child box
+   */
+  addChildBox(t) {
+    const e = new l.BoxGeometry(10, 10, 10), i = new l.MeshStandardMaterial({ color: 8947848, roughness: 0.7 }), s = new l.Mesh(e, i);
+    s.name = `Box_${Date.now().toString(36)}`, s.userData.id = s.name, s.userData.shapeType = "box", s.userData.originalSize = { x: 10, y: 10, z: 10 }, this.editor.execute(new wt(t, s)), this.editor.select(s);
+  }
+  /**
+   * Add a child group
+   */
+  addChildGroup(t) {
+    const e = new l.Group();
+    e.name = `Group_${Date.now().toString(36)}`, e.userData.id = e.name, e.userData.shapeType = "none", this.editor.execute(new wt(t, e)), this.editor.select(e);
+  }
+  /**
+   * Duplicate a node
+   */
+  duplicateNode(t) {
+    if (!t.parent) return;
+    const e = t.clone(!0);
+    e.name = `${t.name}_copy`, e.userData.id = e.name, e.position.x += 10, this.editor.execute(new wt(t.parent, e)), this.editor.select(e);
+  }
+  /**
+   * Delete a node
+   */
+  deleteNode(t) {
+    if (!t.parent) return;
+    const e = this.editor.getModel();
+    t !== e && (this.editor.execute(new Me(t)), this.editor.select(null));
+  }
+  /**
+   * Cleanup
+   */
+  dispose() {
+    this.contextMenu && document.body.removeChild(this.contextMenu), this.container.innerHTML = "";
+  }
+}
+const J = ["front", "back", "left", "right", "top", "bottom"], Ee = {
+  front: "Front (+Z)",
+  back: "Back (-Z)",
+  left: "Left (-X)",
+  right: "Right (+X)",
+  top: "Top (+Y)",
+  bottom: "Bottom (-Y)"
+}, _t = {
+  offset: { x: 0, y: 0 },
+  mirror: { x: !1, y: !1 },
+  angle: 0
+};
+class Ge {
+  constructor(t, e) {
+    r(this, "editor");
+    r(this, "container");
+    r(this, "currentObject", null);
+    r(this, "isUpdating", !1);
+    r(this, "faceInputs", /* @__PURE__ */ new Map());
+    this.editor = t;
+    const i = document.getElementById(e);
+    if (!i)
+      throw new Error(`UV Editor container not found: ${e}`);
+    this.container = i, this.buildUI(), this.setupEventListeners();
+  }
+  /**
+   * Build the UV editor UI
+   */
+  buildUI() {
+    let t = "";
+    for (const e of J)
+      t += `
+        <div class="uv-face">
+          <div class="uv-face-header">${Ee[e]}</div>
+          <div class="uv-face-row">
+            <label>Offset</label>
+            <input type="number" id="uv-${e}-offset-x" class="uv-input" step="1" placeholder="X" />
+            <input type="number" id="uv-${e}-offset-y" class="uv-input" step="1" placeholder="Y" />
+          </div>
+          <div class="uv-face-row">
+            <label>Mirror</label>
+            <label class="uv-checkbox-label">
+              <input type="checkbox" id="uv-${e}-mirror-x" class="uv-checkbox" /> X
+            </label>
+            <label class="uv-checkbox-label">
+              <input type="checkbox" id="uv-${e}-mirror-y" class="uv-checkbox" /> Y
+            </label>
+          </div>
+          <div class="uv-face-row">
+            <label>Rotation</label>
+            <select id="uv-${e}-angle" class="uv-select">
+              <option value="0">0°</option>
+              <option value="90">90°</option>
+              <option value="180">180°</option>
+              <option value="270">270°</option>
+            </select>
+          </div>
+        </div>
+      `;
+    this.container.innerHTML = `
+      <div class="uv-editor-content" id="uv-editor-content">
+        ${t}
+      </div>
+      <div class="uv-editor-empty" id="uv-editor-empty">
+        <p>Select a box to edit UVs</p>
+      </div>
+    `;
+    for (const e of J)
+      this.faceInputs.set(e, {
+        offsetX: document.getElementById(`uv-${e}-offset-x`),
+        offsetY: document.getElementById(`uv-${e}-offset-y`),
+        mirrorX: document.getElementById(`uv-${e}-mirror-x`),
+        mirrorY: document.getElementById(`uv-${e}-mirror-y`),
+        angle: document.getElementById(`uv-${e}-angle`)
+      });
+    this.showEmpty();
+  }
+  /**
+   * Setup event listeners
+   */
+  setupEventListeners() {
+    this.editor.on("selectionChanged", (t) => {
+      this.setObject(t);
+    }), this.editor.on("objectChanged", () => {
+      this.currentObject && this.updateFromObject();
+    });
+    for (const t of J) {
+      const e = this.faceInputs.get(t);
+      e.offsetX.addEventListener("change", () => {
+        this.handleFaceChange(t);
+      }), e.offsetY.addEventListener("change", () => {
+        this.handleFaceChange(t);
+      }), e.mirrorX.addEventListener("change", () => {
+        this.handleFaceChange(t);
+      }), e.mirrorY.addEventListener("change", () => {
+        this.handleFaceChange(t);
+      }), e.angle.addEventListener("change", () => {
+        this.handleFaceChange(t);
+      });
+    }
+  }
+  /**
+   * Handle face UV change
+   */
+  handleFaceChange(t) {
+    if (!this.currentObject || this.isUpdating) return;
+    const e = this.faceInputs.get(t), i = this.getTextureLayout();
+    i[t] || { ..._t };
+    const s = {
+      offset: {
+        x: parseInt(e.offsetX.value) || 0,
+        y: parseInt(e.offsetY.value) || 0
+      },
+      mirror: {
+        x: e.mirrorX.checked,
+        y: e.mirrorY.checked
+      },
+      angle: parseInt(e.angle.value)
+    }, o = { ...i, [t]: s };
+    this.editor.execute(
+      new N(
+        this.currentObject,
+        "userData.textureLayout",
+        o,
+        i
+      )
+    ), this.applyTextureLayout(o);
+  }
+  /**
+   * Get texture layout from current object
+   */
+  getTextureLayout() {
+    var t;
+    return ((t = this.currentObject) == null ? void 0 : t.userData.textureLayout) || {};
+  }
+  /**
+   * Set the object to edit UVs for
+   */
+  setObject(t) {
+    t && t instanceof l.Mesh && t.userData.shapeType === "box" ? (this.currentObject = t, this.showContent(), this.updateFromObject()) : (this.currentObject = null, this.showEmpty());
+  }
+  /**
+   * Update UI from current object
+   */
+  updateFromObject() {
+    var e, i, s, o, n, h, d;
+    if (!this.currentObject) return;
+    this.isUpdating = !0;
+    const t = this.getTextureLayout();
+    for (const u of J) {
+      const y = this.faceInputs.get(u), _ = t[u] || _t;
+      y.offsetX.value = ((i = (e = _.offset) == null ? void 0 : e.x) == null ? void 0 : i.toString()) || "0", y.offsetY.value = ((o = (s = _.offset) == null ? void 0 : s.y) == null ? void 0 : o.toString()) || "0", y.mirrorX.checked = ((n = _.mirror) == null ? void 0 : n.x) || !1, y.mirrorY.checked = ((h = _.mirror) == null ? void 0 : h.y) || !1, y.angle.value = ((d = _.angle) == null ? void 0 : d.toString()) || "0";
+    }
+    this.isUpdating = !1;
+  }
+  /**
+   * Apply texture layout to geometry UVs
+   * Note: This is a simplified implementation - full UV mapping would require
+   * knowing the texture atlas dimensions
+   */
+  applyTextureLayout(t) {
+    var h, d, u, y;
+    if (!this.currentObject || !(this.currentObject instanceof l.Mesh)) return;
+    const s = this.currentObject.geometry.getAttribute("uv");
+    if (!s) return;
+    const o = {
+      right: 0,
+      left: 1,
+      top: 2,
+      bottom: 3,
+      front: 4,
+      back: 5
+    }, n = s.array;
+    for (const _ of J) {
+      const D = t[_] || _t, B = o[_] * 6, z = (((h = D.offset) == null ? void 0 : h.x) || 0) / 64, O = (((d = D.offset) == null ? void 0 : d.y) || 0) / 64;
+      for (let M = 0; M < 6; M++) {
+        const E = (B + M) * 2;
+        let b = n[E], T = n[E + 1];
+        if ((u = D.mirror) != null && u.x && (b = 1 - b), (y = D.mirror) != null && y.y && (T = 1 - T), D.angle) {
+          const k = D.angle * Math.PI / 180, A = b - 0.5, it = T - 0.5;
+          b = A * Math.cos(k) - it * Math.sin(k) + 0.5, T = A * Math.sin(k) + it * Math.cos(k) + 0.5;
+        }
+        n[E] = b + z, n[E + 1] = T + O;
+      }
+    }
+    s.needsUpdate = !0;
+  }
+  /**
+   * Show content
+   */
+  showContent() {
+    const t = document.getElementById("uv-editor-content"), e = document.getElementById("uv-editor-empty");
+    t && (t.style.display = "block"), e && (e.style.display = "none");
+  }
+  /**
+   * Show empty state
+   */
+  showEmpty() {
+    const t = document.getElementById("uv-editor-content"), e = document.getElementById("uv-editor-empty");
+    t && (t.style.display = "none"), e && (e.style.display = "block");
+  }
+  /**
+   * Cleanup
+   */
+  dispose() {
+    this.container.innerHTML = "", this.faceInputs.clear();
+  }
+}
+const xt = { x: 0, y: 0, z: 0 }, ve = { w: 1, x: 0, y: 0, z: 0 }, Rt = { x: 1, y: 1, z: 1 };
+class Pe extends l.Loader {
+  constructor(t) {
+    super(t);
+  }
+  /**
+   * Load a .blockymodel file from URL
+   */
+  async load(t) {
+    const e = await fetch(t);
+    if (!e.ok)
+      throw new Error(`Failed to load model: ${e.statusText}`);
+    const i = await e.json();
+    return this.parse(i);
+  }
+  /**
+   * Load from File object (for drag-drop / file input)
+   */
+  async loadFromFile(t) {
+    const e = await t.text(), i = JSON.parse(e);
+    return this.parse(i);
+  }
+  /**
+   * Parse BlockyModel JSON into Three.js scene graph
+   */
+  parse(t) {
+    const e = new l.Group();
+    e.name = "BlockyModel", e.userData.format = t.format, e.userData.lod = t.lod;
+    for (const i of t.nodes) {
+      const s = this.parseNode(i);
+      e.add(s);
+    }
+    return e;
+  }
+  /**
+   * Recursively parse a BlockyNode into Three.js Object3D
+   */
+  parseNode(t) {
+    var o, n;
+    const e = this.createNodeObject(t);
+    e.name = t.name, e.userData.id = t.id, e.userData.isPiece = ((n = (o = t.shape) == null ? void 0 : o.settings) == null ? void 0 : n.isPiece) ?? !1;
+    const i = t.position ?? xt;
+    e.position.set(i.x, i.y, i.z);
+    const s = t.orientation ?? ve;
+    e.quaternion.set(s.x, s.y, s.z, s.w);
+    for (const h of t.children ?? []) {
+      const d = this.parseNode(h);
+      e.add(d);
+    }
+    return e;
+  }
+  /**
+   * Create the appropriate Object3D based on shape type
+   */
+  createNodeObject(t) {
+    const e = t.shape;
+    if (!e || e.type === "none" || !e.visible) {
+      const i = new l.Group();
+      return i.userData.shapeType = (e == null ? void 0 : e.type) ?? "none", i;
+    }
+    return e.type === "box" ? this.createBox(e) : e.type === "quad" ? this.createQuad(e) : new l.Group();
+  }
+  /**
+   * Create a box mesh from shape data
+   */
+  createBox(t) {
+    const e = t.settings.size ?? { x: 1, y: 1, z: 1 }, i = t.stretch ?? Rt, s = t.offset ?? xt, o = {
+      x: e.x * i.x,
+      y: e.y * i.y,
+      z: e.z * i.z
+    }, n = new l.BoxGeometry(o.x, o.y, o.z);
+    n.translate(s.x, s.y, s.z);
+    const h = this.createMaterial(t), d = new l.Mesh(n, h);
+    return d.userData.shapeType = "box", d.userData.originalSize = e, d.userData.shadingMode = t.shadingMode, t.doubleSided && (h.side = l.DoubleSide), d;
+  }
+  /**
+   * Create a quad (plane) mesh from shape data
+   */
+  createQuad(t) {
+    const e = t.settings.size ?? { x: 1, y: 1, z: 0 }, i = t.stretch ?? Rt, s = t.offset ?? xt, o = t.settings.normal ?? "+Z";
+    let n, h;
+    switch (o) {
+      case "+X":
+      case "-X":
+        n = e.z * i.z, h = e.y * i.y;
+        break;
+      case "+Y":
+      case "-Y":
+        n = e.x * i.x, h = e.z * i.z;
+        break;
+      case "+Z":
+      case "-Z":
+      default:
+        n = e.x * i.x, h = e.y * i.y;
+        break;
+    }
+    const d = new l.PlaneGeometry(n, h);
+    switch (o) {
+      case "+X":
+        d.rotateY(Math.PI / 2);
+        break;
+      case "-X":
+        d.rotateY(-Math.PI / 2);
+        break;
+      case "+Y":
+        d.rotateX(-Math.PI / 2);
+        break;
+      case "-Y":
+        d.rotateX(Math.PI / 2);
+        break;
+      case "-Z":
+        d.rotateY(Math.PI);
+        break;
+    }
+    d.translate(s.x, s.y, s.z);
+    const u = this.createMaterial(t);
+    u.side = t.doubleSided ? l.DoubleSide : l.FrontSide;
+    const y = new l.Mesh(d, u);
+    return y.userData.shapeType = "quad", y.userData.shadingMode = t.shadingMode, y;
+  }
+  /**
+   * Create material based on shading mode
+   * Phase 1: Basic color material, texture mapping in Phase 2
+   */
+  createMaterial(t) {
+    switch (t.shadingMode) {
+      case "fullbright":
+        return new l.MeshStandardMaterial({
+          color: 8947848,
+          emissive: 8947848,
+          emissiveIntensity: 1,
+          roughness: 1,
+          metalness: 0
+        });
+      case "flat":
+        return new l.MeshStandardMaterial({
+          color: 8947848,
+          flatShading: !0,
+          roughness: 0.9,
+          metalness: 0
+        });
+      case "reflective":
+        return new l.MeshStandardMaterial({
+          color: 8947848,
+          roughness: 0.1,
+          metalness: 0.8
+        });
+      case "standard":
+      default:
+        return new l.MeshStandardMaterial({
+          color: 8947848,
+          roughness: 0.7,
+          metalness: 0
+        });
+    }
+  }
+}
+function Ie(a, t) {
+  t.magFilter = l.NearestFilter, t.minFilter = l.NearestFilter, t.colorSpace = l.SRGBColorSpace, a.traverse((e) => {
+    if (e instanceof l.Mesh) {
+      const i = e.material;
+      i.isMeshStandardMaterial && (i.map = t, i.color.setHex(16777215), i.needsUpdate = !0);
+    }
+  });
+}
+const At = { type: "change" }, Et = { type: "start" }, Xt = { type: "end" }, dt = new ne(), Yt = new oe(), Te = Math.cos(70 * ae.DEG2RAD), w = new p(), I = 2 * Math.PI, m = {
+  NONE: -1,
+  ROTATE: 0,
+  DOLLY: 1,
+  PAN: 2,
+  TOUCH_ROTATE: 3,
+  TOUCH_PAN: 4,
+  TOUCH_DOLLY_PAN: 5,
+  TOUCH_DOLLY_ROTATE: 6
+}, St = 1e-6;
+class De extends Ht {
+  constructor(t, e = null) {
+    super(t, e), this.state = m.NONE, this.enabled = !0, this.target = new p(), this.cursor = new p(), this.minDistance = 0, this.maxDistance = 1 / 0, this.minZoom = 0, this.maxZoom = 1 / 0, this.minTargetRadius = 0, this.maxTargetRadius = 1 / 0, this.minPolarAngle = 0, this.maxPolarAngle = Math.PI, this.minAzimuthAngle = -1 / 0, this.maxAzimuthAngle = 1 / 0, this.enableDamping = !1, this.dampingFactor = 0.05, this.enableZoom = !0, this.zoomSpeed = 1, this.enableRotate = !0, this.rotateSpeed = 1, this.enablePan = !0, this.panSpeed = 1, this.screenSpacePanning = !0, this.keyPanSpeed = 7, this.zoomToCursor = !1, this.autoRotate = !1, this.autoRotateSpeed = 2, this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" }, this.mouseButtons = { LEFT: G.ROTATE, MIDDLE: G.DOLLY, RIGHT: G.PAN }, this.touches = { ONE: V.ROTATE, TWO: V.DOLLY_PAN }, this.target0 = this.target.clone(), this.position0 = this.object.position.clone(), this.zoom0 = this.object.zoom, this._domElementKeyEvents = null, this._lastPosition = new p(), this._lastQuaternion = new L(), this._lastTargetPosition = new p(), this._quat = new L().setFromUnitVectors(t.up, new p(0, 1, 0)), this._quatInverse = this._quat.clone().invert(), this._spherical = new Tt(), this._sphericalDelta = new Tt(), this._scale = 1, this._panOffset = new p(), this._rotateStart = new R(), this._rotateEnd = new R(), this._rotateDelta = new R(), this._panStart = new R(), this._panEnd = new R(), this._panDelta = new R(), this._dollyStart = new R(), this._dollyEnd = new R(), this._dollyDelta = new R(), this._dollyDirection = new p(), this._mouse = new R(), this._performCursorZoom = !1, this._pointers = [], this._pointerPositions = {}, this._controlActive = !1, this._onPointerMove = Le.bind(this), this._onPointerDown = Ce.bind(this), this._onPointerUp = ze.bind(this), this._onContextMenu = He.bind(this), this._onMouseWheel = je.bind(this), this._onKeyDown = Re.bind(this), this._onTouchStart = Ae.bind(this), this._onTouchMove = Ye.bind(this), this._onMouseDown = Oe.bind(this), this._onMouseMove = ke.bind(this), this._interceptControlDown = Ne.bind(this), this._interceptControlUp = Fe.bind(this), this.domElement !== null && this.connect(), this.update();
+  }
+  connect() {
+    this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointercancel", this._onPointerUp), this.domElement.addEventListener("contextmenu", this._onContextMenu), this.domElement.addEventListener("wheel", this._onMouseWheel, { passive: !1 }), this.domElement.getRootNode().addEventListener("keydown", this._interceptControlDown, { passive: !0, capture: !0 }), this.domElement.style.touchAction = "none";
+  }
+  disconnect() {
+    this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.domElement.removeEventListener("pointercancel", this._onPointerUp), this.domElement.removeEventListener("wheel", this._onMouseWheel), this.domElement.removeEventListener("contextmenu", this._onContextMenu), this.stopListenToKeyEvents(), this.domElement.getRootNode().removeEventListener("keydown", this._interceptControlDown, { capture: !0 }), this.domElement.style.touchAction = "auto";
+  }
+  dispose() {
+    this.disconnect();
+  }
+  getPolarAngle() {
+    return this._spherical.phi;
+  }
+  getAzimuthalAngle() {
+    return this._spherical.theta;
+  }
+  getDistance() {
+    return this.object.position.distanceTo(this.target);
+  }
+  listenToKeyEvents(t) {
+    t.addEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = t;
+  }
+  stopListenToKeyEvents() {
+    this._domElementKeyEvents !== null && (this._domElementKeyEvents.removeEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = null);
+  }
+  saveState() {
+    this.target0.copy(this.target), this.position0.copy(this.object.position), this.zoom0 = this.object.zoom;
+  }
+  reset() {
+    this.target.copy(this.target0), this.object.position.copy(this.position0), this.object.zoom = this.zoom0, this.object.updateProjectionMatrix(), this.dispatchEvent(At), this.update(), this.state = m.NONE;
+  }
+  update(t = null) {
+    const e = this.object.position;
+    w.copy(e).sub(this.target), w.applyQuaternion(this._quat), this._spherical.setFromVector3(w), this.autoRotate && this.state === m.NONE && this._rotateLeft(this._getAutoRotationAngle(t)), this.enableDamping ? (this._spherical.theta += this._sphericalDelta.theta * this.dampingFactor, this._spherical.phi += this._sphericalDelta.phi * this.dampingFactor) : (this._spherical.theta += this._sphericalDelta.theta, this._spherical.phi += this._sphericalDelta.phi);
+    let i = this.minAzimuthAngle, s = this.maxAzimuthAngle;
+    isFinite(i) && isFinite(s) && (i < -Math.PI ? i += I : i > Math.PI && (i -= I), s < -Math.PI ? s += I : s > Math.PI && (s -= I), i <= s ? this._spherical.theta = Math.max(i, Math.min(s, this._spherical.theta)) : this._spherical.theta = this._spherical.theta > (i + s) / 2 ? Math.max(i, this._spherical.theta) : Math.min(s, this._spherical.theta)), this._spherical.phi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, this._spherical.phi)), this._spherical.makeSafe(), this.enableDamping === !0 ? this.target.addScaledVector(this._panOffset, this.dampingFactor) : this.target.add(this._panOffset), this.target.sub(this.cursor), this.target.clampLength(this.minTargetRadius, this.maxTargetRadius), this.target.add(this.cursor);
+    let o = !1;
+    if (this.zoomToCursor && this._performCursorZoom || this.object.isOrthographicCamera)
+      this._spherical.radius = this._clampDistance(this._spherical.radius);
+    else {
+      const n = this._spherical.radius;
+      this._spherical.radius = this._clampDistance(this._spherical.radius * this._scale), o = n != this._spherical.radius;
+    }
+    if (w.setFromSpherical(this._spherical), w.applyQuaternion(this._quatInverse), e.copy(this.target).add(w), this.object.lookAt(this.target), this.enableDamping === !0 ? (this._sphericalDelta.theta *= 1 - this.dampingFactor, this._sphericalDelta.phi *= 1 - this.dampingFactor, this._panOffset.multiplyScalar(1 - this.dampingFactor)) : (this._sphericalDelta.set(0, 0, 0), this._panOffset.set(0, 0, 0)), this.zoomToCursor && this._performCursorZoom) {
+      let n = null;
+      if (this.object.isPerspectiveCamera) {
+        const h = w.length();
+        n = this._clampDistance(h * this._scale);
+        const d = h - n;
+        this.object.position.addScaledVector(this._dollyDirection, d), this.object.updateMatrixWorld(), o = !!d;
+      } else if (this.object.isOrthographicCamera) {
+        const h = new p(this._mouse.x, this._mouse.y, 0);
+        h.unproject(this.object);
+        const d = this.object.zoom;
+        this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), this.object.updateProjectionMatrix(), o = d !== this.object.zoom;
+        const u = new p(this._mouse.x, this._mouse.y, 0);
+        u.unproject(this.object), this.object.position.sub(u).add(h), this.object.updateMatrixWorld(), n = w.length();
+      } else
+        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled."), this.zoomToCursor = !1;
+      n !== null && (this.screenSpacePanning ? this.target.set(0, 0, -1).transformDirection(this.object.matrix).multiplyScalar(n).add(this.object.position) : (dt.origin.copy(this.object.position), dt.direction.set(0, 0, -1).transformDirection(this.object.matrix), Math.abs(this.object.up.dot(dt.direction)) < Te ? this.object.lookAt(this.target) : (Yt.setFromNormalAndCoplanarPoint(this.object.up, this.target), dt.intersectPlane(Yt, this.target))));
+    } else if (this.object.isOrthographicCamera) {
+      const n = this.object.zoom;
+      this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), n !== this.object.zoom && (this.object.updateProjectionMatrix(), o = !0);
+    }
+    return this._scale = 1, this._performCursorZoom = !1, o || this._lastPosition.distanceToSquared(this.object.position) > St || 8 * (1 - this._lastQuaternion.dot(this.object.quaternion)) > St || this._lastTargetPosition.distanceToSquared(this.target) > St ? (this.dispatchEvent(At), this._lastPosition.copy(this.object.position), this._lastQuaternion.copy(this.object.quaternion), this._lastTargetPosition.copy(this.target), !0) : !1;
+  }
+  _getAutoRotationAngle(t) {
+    return t !== null ? I / 60 * this.autoRotateSpeed * t : I / 60 / 60 * this.autoRotateSpeed;
+  }
+  _getZoomScale(t) {
+    const e = Math.abs(t * 0.01);
+    return Math.pow(0.95, this.zoomSpeed * e);
+  }
+  _rotateLeft(t) {
+    this._sphericalDelta.theta -= t;
+  }
+  _rotateUp(t) {
+    this._sphericalDelta.phi -= t;
+  }
+  _panLeft(t, e) {
+    w.setFromMatrixColumn(e, 0), w.multiplyScalar(-t), this._panOffset.add(w);
+  }
+  _panUp(t, e) {
+    this.screenSpacePanning === !0 ? w.setFromMatrixColumn(e, 1) : (w.setFromMatrixColumn(e, 0), w.crossVectors(this.object.up, w)), w.multiplyScalar(t), this._panOffset.add(w);
+  }
+  // deltaX and deltaY are in pixels; right and down are positive
+  _pan(t, e) {
+    const i = this.domElement;
+    if (this.object.isPerspectiveCamera) {
+      const s = this.object.position;
+      w.copy(s).sub(this.target);
+      let o = w.length();
+      o *= Math.tan(this.object.fov / 2 * Math.PI / 180), this._panLeft(2 * t * o / i.clientHeight, this.object.matrix), this._panUp(2 * e * o / i.clientHeight, this.object.matrix);
+    } else this.object.isOrthographicCamera ? (this._panLeft(t * (this.object.right - this.object.left) / this.object.zoom / i.clientWidth, this.object.matrix), this._panUp(e * (this.object.top - this.object.bottom) / this.object.zoom / i.clientHeight, this.object.matrix)) : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."), this.enablePan = !1);
+  }
+  _dollyOut(t) {
+    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale /= t : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
+  }
+  _dollyIn(t) {
+    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale *= t : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
+  }
+  _updateZoomParameters(t, e) {
+    if (!this.zoomToCursor)
+      return;
+    this._performCursorZoom = !0;
+    const i = this.domElement.getBoundingClientRect(), s = t - i.left, o = e - i.top, n = i.width, h = i.height;
+    this._mouse.x = s / n * 2 - 1, this._mouse.y = -(o / h) * 2 + 1, this._dollyDirection.set(this._mouse.x, this._mouse.y, 1).unproject(this.object).sub(this.object.position).normalize();
+  }
+  _clampDistance(t) {
+    return Math.max(this.minDistance, Math.min(this.maxDistance, t));
+  }
+  //
+  // event callbacks - update the object state
+  //
+  _handleMouseDownRotate(t) {
+    this._rotateStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseDownDolly(t) {
+    this._updateZoomParameters(t.clientX, t.clientX), this._dollyStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseDownPan(t) {
+    this._panStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseMoveRotate(t) {
+    this._rotateEnd.set(t.clientX, t.clientY), this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const e = this.domElement;
+    this._rotateLeft(I * this._rotateDelta.x / e.clientHeight), this._rotateUp(I * this._rotateDelta.y / e.clientHeight), this._rotateStart.copy(this._rotateEnd), this.update();
+  }
+  _handleMouseMoveDolly(t) {
+    this._dollyEnd.set(t.clientX, t.clientY), this._dollyDelta.subVectors(this._dollyEnd, this._dollyStart), this._dollyDelta.y > 0 ? this._dollyOut(this._getZoomScale(this._dollyDelta.y)) : this._dollyDelta.y < 0 && this._dollyIn(this._getZoomScale(this._dollyDelta.y)), this._dollyStart.copy(this._dollyEnd), this.update();
+  }
+  _handleMouseMovePan(t) {
+    this._panEnd.set(t.clientX, t.clientY), this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed), this._pan(this._panDelta.x, this._panDelta.y), this._panStart.copy(this._panEnd), this.update();
+  }
+  _handleMouseWheel(t) {
+    this._updateZoomParameters(t.clientX, t.clientY), t.deltaY < 0 ? this._dollyIn(this._getZoomScale(t.deltaY)) : t.deltaY > 0 && this._dollyOut(this._getZoomScale(t.deltaY)), this.update();
+  }
+  _handleKeyDown(t) {
+    let e = !1;
+    switch (t.code) {
+      case this.keys.UP:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this._rotateUp(I * this.rotateSpeed / this.domElement.clientHeight) : this._pan(0, this.keyPanSpeed), e = !0;
+        break;
+      case this.keys.BOTTOM:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this._rotateUp(-I * this.rotateSpeed / this.domElement.clientHeight) : this._pan(0, -this.keyPanSpeed), e = !0;
+        break;
+      case this.keys.LEFT:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this._rotateLeft(I * this.rotateSpeed / this.domElement.clientHeight) : this._pan(this.keyPanSpeed, 0), e = !0;
+        break;
+      case this.keys.RIGHT:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this._rotateLeft(-I * this.rotateSpeed / this.domElement.clientHeight) : this._pan(-this.keyPanSpeed, 0), e = !0;
+        break;
+    }
+    e && (t.preventDefault(), this.update());
+  }
+  _handleTouchStartRotate(t) {
+    if (this._pointers.length === 1)
+      this._rotateStart.set(t.pageX, t.pageY);
+    else {
+      const e = this._getSecondPointerPosition(t), i = 0.5 * (t.pageX + e.x), s = 0.5 * (t.pageY + e.y);
+      this._rotateStart.set(i, s);
+    }
+  }
+  _handleTouchStartPan(t) {
+    if (this._pointers.length === 1)
+      this._panStart.set(t.pageX, t.pageY);
+    else {
+      const e = this._getSecondPointerPosition(t), i = 0.5 * (t.pageX + e.x), s = 0.5 * (t.pageY + e.y);
+      this._panStart.set(i, s);
+    }
+  }
+  _handleTouchStartDolly(t) {
+    const e = this._getSecondPointerPosition(t), i = t.pageX - e.x, s = t.pageY - e.y, o = Math.sqrt(i * i + s * s);
+    this._dollyStart.set(0, o);
+  }
+  _handleTouchStartDollyPan(t) {
+    this.enableZoom && this._handleTouchStartDolly(t), this.enablePan && this._handleTouchStartPan(t);
+  }
+  _handleTouchStartDollyRotate(t) {
+    this.enableZoom && this._handleTouchStartDolly(t), this.enableRotate && this._handleTouchStartRotate(t);
+  }
+  _handleTouchMoveRotate(t) {
+    if (this._pointers.length == 1)
+      this._rotateEnd.set(t.pageX, t.pageY);
+    else {
+      const i = this._getSecondPointerPosition(t), s = 0.5 * (t.pageX + i.x), o = 0.5 * (t.pageY + i.y);
+      this._rotateEnd.set(s, o);
+    }
+    this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const e = this.domElement;
+    this._rotateLeft(I * this._rotateDelta.x / e.clientHeight), this._rotateUp(I * this._rotateDelta.y / e.clientHeight), this._rotateStart.copy(this._rotateEnd);
+  }
+  _handleTouchMovePan(t) {
+    if (this._pointers.length === 1)
+      this._panEnd.set(t.pageX, t.pageY);
+    else {
+      const e = this._getSecondPointerPosition(t), i = 0.5 * (t.pageX + e.x), s = 0.5 * (t.pageY + e.y);
+      this._panEnd.set(i, s);
+    }
+    this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed), this._pan(this._panDelta.x, this._panDelta.y), this._panStart.copy(this._panEnd);
+  }
+  _handleTouchMoveDolly(t) {
+    const e = this._getSecondPointerPosition(t), i = t.pageX - e.x, s = t.pageY - e.y, o = Math.sqrt(i * i + s * s);
+    this._dollyEnd.set(0, o), this._dollyDelta.set(0, Math.pow(this._dollyEnd.y / this._dollyStart.y, this.zoomSpeed)), this._dollyOut(this._dollyDelta.y), this._dollyStart.copy(this._dollyEnd);
+    const n = (t.pageX + e.x) * 0.5, h = (t.pageY + e.y) * 0.5;
+    this._updateZoomParameters(n, h);
+  }
+  _handleTouchMoveDollyPan(t) {
+    this.enableZoom && this._handleTouchMoveDolly(t), this.enablePan && this._handleTouchMovePan(t);
+  }
+  _handleTouchMoveDollyRotate(t) {
+    this.enableZoom && this._handleTouchMoveDolly(t), this.enableRotate && this._handleTouchMoveRotate(t);
+  }
+  // pointers
+  _addPointer(t) {
+    this._pointers.push(t.pointerId);
+  }
+  _removePointer(t) {
+    delete this._pointerPositions[t.pointerId];
+    for (let e = 0; e < this._pointers.length; e++)
+      if (this._pointers[e] == t.pointerId) {
+        this._pointers.splice(e, 1);
+        return;
+      }
+  }
+  _isTrackingPointer(t) {
+    for (let e = 0; e < this._pointers.length; e++)
+      if (this._pointers[e] == t.pointerId) return !0;
+    return !1;
+  }
+  _trackPointer(t) {
+    let e = this._pointerPositions[t.pointerId];
+    e === void 0 && (e = new R(), this._pointerPositions[t.pointerId] = e), e.set(t.pageX, t.pageY);
+  }
+  _getSecondPointerPosition(t) {
+    const e = t.pointerId === this._pointers[0] ? this._pointers[1] : this._pointers[0];
+    return this._pointerPositions[e];
+  }
+  //
+  _customWheelEvent(t) {
+    const e = t.deltaMode, i = {
+      clientX: t.clientX,
+      clientY: t.clientY,
+      deltaY: t.deltaY
+    };
+    switch (e) {
+      case 1:
+        i.deltaY *= 16;
+        break;
+      case 2:
+        i.deltaY *= 100;
+        break;
+    }
+    return t.ctrlKey && !this._controlActive && (i.deltaY *= 10), i;
+  }
+}
+function Ce(a) {
+  this.enabled !== !1 && (this._pointers.length === 0 && (this.domElement.setPointerCapture(a.pointerId), this.domElement.addEventListener("pointermove", this._onPointerMove), this.domElement.addEventListener("pointerup", this._onPointerUp)), !this._isTrackingPointer(a) && (this._addPointer(a), a.pointerType === "touch" ? this._onTouchStart(a) : this._onMouseDown(a)));
+}
+function Le(a) {
+  this.enabled !== !1 && (a.pointerType === "touch" ? this._onTouchMove(a) : this._onMouseMove(a));
+}
+function ze(a) {
+  switch (this._removePointer(a), this._pointers.length) {
+    case 0:
+      this.domElement.releasePointerCapture(a.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.dispatchEvent(Xt), this.state = m.NONE;
+      break;
+    case 1:
+      const t = this._pointers[0], e = this._pointerPositions[t];
+      this._onTouchStart({ pointerId: t, pageX: e.x, pageY: e.y });
+      break;
+  }
+}
+function Oe(a) {
+  let t;
+  switch (a.button) {
+    case 0:
+      t = this.mouseButtons.LEFT;
+      break;
+    case 1:
+      t = this.mouseButtons.MIDDLE;
+      break;
+    case 2:
+      t = this.mouseButtons.RIGHT;
+      break;
+    default:
+      t = -1;
+  }
+  switch (t) {
+    case G.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseDownDolly(a), this.state = m.DOLLY;
+      break;
+    case G.ROTATE:
+      if (a.ctrlKey || a.metaKey || a.shiftKey) {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(a), this.state = m.PAN;
+      } else {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(a), this.state = m.ROTATE;
+      }
+      break;
+    case G.PAN:
+      if (a.ctrlKey || a.metaKey || a.shiftKey) {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(a), this.state = m.ROTATE;
+      } else {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(a), this.state = m.PAN;
+      }
+      break;
+    default:
+      this.state = m.NONE;
+  }
+  this.state !== m.NONE && this.dispatchEvent(Et);
+}
+function ke(a) {
+  switch (this.state) {
+    case m.ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleMouseMoveRotate(a);
+      break;
+    case m.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseMoveDolly(a);
+      break;
+    case m.PAN:
+      if (this.enablePan === !1) return;
+      this._handleMouseMovePan(a);
+      break;
+  }
+}
+function je(a) {
+  this.enabled === !1 || this.enableZoom === !1 || this.state !== m.NONE || (a.preventDefault(), this.dispatchEvent(Et), this._handleMouseWheel(this._customWheelEvent(a)), this.dispatchEvent(Xt));
+}
+function Re(a) {
+  this.enabled === !1 || this.enablePan === !1 || this._handleKeyDown(a);
+}
+function Ae(a) {
+  switch (this._trackPointer(a), this._pointers.length) {
+    case 1:
+      switch (this.touches.ONE) {
+        case V.ROTATE:
+          if (this.enableRotate === !1) return;
+          this._handleTouchStartRotate(a), this.state = m.TOUCH_ROTATE;
+          break;
+        case V.PAN:
+          if (this.enablePan === !1) return;
+          this._handleTouchStartPan(a), this.state = m.TOUCH_PAN;
+          break;
+        default:
+          this.state = m.NONE;
+      }
+      break;
+    case 2:
+      switch (this.touches.TWO) {
+        case V.DOLLY_PAN:
+          if (this.enableZoom === !1 && this.enablePan === !1) return;
+          this._handleTouchStartDollyPan(a), this.state = m.TOUCH_DOLLY_PAN;
+          break;
+        case V.DOLLY_ROTATE:
+          if (this.enableZoom === !1 && this.enableRotate === !1) return;
+          this._handleTouchStartDollyRotate(a), this.state = m.TOUCH_DOLLY_ROTATE;
+          break;
+        default:
+          this.state = m.NONE;
+      }
+      break;
+    default:
+      this.state = m.NONE;
+  }
+  this.state !== m.NONE && this.dispatchEvent(Et);
+}
+function Ye(a) {
+  switch (this._trackPointer(a), this.state) {
+    case m.TOUCH_ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleTouchMoveRotate(a), this.update();
+      break;
+    case m.TOUCH_PAN:
+      if (this.enablePan === !1) return;
+      this._handleTouchMovePan(a), this.update();
+      break;
+    case m.TOUCH_DOLLY_PAN:
+      if (this.enableZoom === !1 && this.enablePan === !1) return;
+      this._handleTouchMoveDollyPan(a), this.update();
+      break;
+    case m.TOUCH_DOLLY_ROTATE:
+      if (this.enableZoom === !1 && this.enableRotate === !1) return;
+      this._handleTouchMoveDollyRotate(a), this.update();
+      break;
+    default:
+      this.state = m.NONE;
+  }
+}
+function He(a) {
+  this.enabled !== !1 && a.preventDefault();
+}
+function Ne(a) {
+  a.key === "Control" && (this._controlActive = !0, this.domElement.getRootNode().addEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+function Fe(a) {
+  a.key === "Control" && (this._controlActive = !1, this.domElement.getRootNode().removeEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+class qe {
+  constructor(t) {
+    r(this, "scene");
+    r(this, "camera");
+    r(this, "renderer");
+    r(this, "controls");
+    r(this, "domElement");
+    r(this, "loader");
+    r(this, "textureLoader");
+    r(this, "currentModel", null);
+    r(this, "animationId", null);
+    r(this, "animate", () => {
+      this.animationId = requestAnimationFrame(this.animate), this.controls.update(), this.renderer.render(this.scene, this.camera);
+    });
+    const { container: e, backgroundColor: i = 1710638 } = t;
+    this.domElement = e, this.scene = new l.Scene(), this.scene.background = new l.Color(i);
+    const s = e.clientWidth / e.clientHeight;
+    this.camera = new l.PerspectiveCamera(50, s, 0.1, 1e3), this.camera.position.set(50, 50, 100), this.renderer = new l.WebGLRenderer({
+      antialias: !0,
+      alpha: !0
+    }), this.renderer.setSize(e.clientWidth, e.clientHeight), this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2)), this.renderer.shadowMap.enabled = !0, this.renderer.shadowMap.type = l.PCFSoftShadowMap, e.appendChild(this.renderer.domElement), this.controls = new De(this.camera, this.renderer.domElement), this.controls.enableDamping = !0, this.controls.dampingFactor = 0.1, this.controls.minDistance = 10, this.controls.maxDistance = 500, this.loader = new Pe(), this.textureLoader = new l.TextureLoader(), this.setupLighting(), this.setupHelpers(), window.addEventListener("resize", () => this.handleResize(e)), this.animate();
+  }
+  setupLighting() {
+    const t = new l.AmbientLight(16777215, 0.4);
+    this.scene.add(t);
+    const e = new l.DirectionalLight(16777215, 0.8);
+    e.position.set(50, 100, 50), e.castShadow = !0, e.shadow.mapSize.width = 2048, e.shadow.mapSize.height = 2048, this.scene.add(e);
+    const i = new l.DirectionalLight(16777215, 0.3);
+    i.position.set(-50, 50, -50), this.scene.add(i);
+    const s = new l.DirectionalLight(8965375, 0.2);
+    s.position.set(0, -50, -100), this.scene.add(s);
+  }
+  setupHelpers() {
+    const t = new l.GridHelper(200, 20, 4473924, 3355443);
+    t.position.y = -0.1, this.scene.add(t);
+    const e = new l.AxesHelper(20);
+    this.scene.add(e);
+  }
+  handleResize(t) {
+    const e = t.clientWidth, i = t.clientHeight;
+    this.camera.aspect = e / i, this.camera.updateProjectionMatrix(), this.renderer.setSize(e, i);
+  }
+  /**
+   * Load a .blockymodel file
+   */
+  async loadModel(t) {
+    this.currentModel && (this.scene.remove(this.currentModel), this.disposeModel(this.currentModel), this.currentModel = null);
+    try {
+      return this.currentModel = await this.loader.loadFromFile(t), this.scene.add(this.currentModel), this.fitCameraToModel(), console.log(`Loaded model with ${this.countMeshes(this.currentModel)} meshes`), this.currentModel;
+    } catch (e) {
+      throw console.error("Failed to load model:", e), e;
+    }
+  }
+  /**
+   * Get the currently loaded model
+   */
+  getModel() {
+    return this.currentModel;
+  }
+  /**
+   * Load a texture and apply to current model
+   */
+  async loadTexture(t) {
+    if (!this.currentModel) {
+      console.warn("No model loaded to apply texture to");
+      return;
+    }
+    const e = URL.createObjectURL(t);
+    try {
+      const i = await new Promise((s, o) => {
+        this.textureLoader.load(e, s, void 0, o);
+      });
+      Ie(this.currentModel, i), console.log("Texture applied");
+    } finally {
+      URL.revokeObjectURL(e);
+    }
+  }
+  /**
+   * Fit camera to view the entire model
+   */
+  fitCameraToModel() {
+    if (!this.currentModel) return;
+    const t = new l.Box3().setFromObject(this.currentModel), e = t.getCenter(new l.Vector3()), i = t.getSize(new l.Vector3()), s = Math.max(i.x, i.y, i.z), o = this.camera.fov * (Math.PI / 180), n = s / (2 * Math.tan(o / 2)) * 1.5;
+    this.camera.position.set(
+      e.x + n * 0.5,
+      e.y + n * 0.5,
+      e.z + n
+    ), this.controls.target.copy(e), this.controls.update();
+  }
+  /**
+   * Reset camera to default position
+   */
+  resetCamera() {
+    this.currentModel ? this.fitCameraToModel() : (this.camera.position.set(50, 50, 100), this.controls.target.set(0, 0, 0), this.controls.update());
+  }
+  /**
+   * Set background color
+   */
+  setBackgroundColor(t) {
+    this.scene.background = new l.Color(t);
+  }
+  /**
+   * Toggle wireframe mode on all meshes
+   */
+  toggleWireframe(t) {
+    var e;
+    (e = this.currentModel) == null || e.traverse((i) => {
+      if (i instanceof l.Mesh) {
+        const s = i.material;
+        s.wireframe = t;
+      }
+    });
+  }
+  /**
+   * Get model hierarchy for debugging
+   */
+  getModelHierarchy() {
+    if (!this.currentModel) return null;
+    const t = (e) => ({
+      name: e.name,
+      type: e.type,
+      userData: e.userData,
+      children: e.children.map(t)
+    });
+    return t(this.currentModel);
+  }
+  /**
+   * Count meshes in model
+   */
+  countMeshes(t) {
+    let e = 0;
+    return t.traverse((i) => {
+      i instanceof l.Mesh && e++;
+    }), e;
+  }
+  /**
+   * Dispose of model resources
+   */
+  disposeModel(t) {
+    t.traverse((e) => {
+      e instanceof l.Mesh && (e.geometry.dispose(), Array.isArray(e.material) ? e.material.forEach((i) => i.dispose()) : e.material.dispose());
+    });
+  }
+  /**
+   * Clean up all resources
+   */
+  dispose() {
+    this.animationId !== null && cancelAnimationFrame(this.animationId), this.currentModel && this.disposeModel(this.currentModel), this.controls.dispose(), this.renderer.dispose();
+  }
+}
+export {
+  wt as AddNodeCommand,
+  q as BaseCommand,
+  Pe as BlockyModelLoader,
+  ve as DEFAULT_ORIENTATION,
+  xt as DEFAULT_POSITION,
+  Rt as DEFAULT_STRETCH,
+  Ze as Editor,
+  Ve as HierarchyPanel,
+  xe as History,
+  Qe as PropertyPanel,
+  Me as RemoveNodeCommand,
+  le as SelectionManager,
+  Be as Serializer,
+  ut as SetPositionCommand,
+  N as SetPropertyCommand,
+  mt as SetRotationCommand,
+  ft as SetScaleCommand,
+  we as TransformManager,
+  Ge as UVEditor,
+  qe as ViewerController
+};
+//# sourceMappingURL=blockymodel-web.js.map