@shopware-ag/dive 2.2.24 → 2.2.26

package/build/plugins/toolbox/index.mjs

@@ -1,105 +1,1183 @@
-var i = Object.defineProperty;
-var s = (t, e, o) => e in t ? i(t, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : t[e] = o;
-var n = (t, e, o) => s(t, typeof e != "symbol" ? e + "" : e, o);
-import { D as l } from "../../chunks/SelectTool-CP-RUr3R.mjs";
-import { a as m, c as T, i as d, b as _ } from "../../chunks/SelectTool-CP-RUr3R.mjs";
-class r {
-  constructor(e, o) {
-    n(this, "_scene");
-    n(this, "_controller");
-    n(this, "_activeTool");
-    n(this, "_selectTool");
-    this._scene = e, this._controller = o, this._selectTool = null, this._activeTool = null;
-  }
-  get selectTool() {
-    return this._selectTool || (this._selectTool = new l(
-      this._scene,
-      this._controller
-    )), this._selectTool;
+var Xt = Object.defineProperty;
+var Yt = (h, t, e) => t in h ? Xt(h, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : h[t] = e;
+var o = (h, t, e) => Yt(h, typeof t != "symbol" ? t + "" : t, e);
+import { Object3D as lt, Vector3 as l, Quaternion as E, Raycaster as ot, MeshBasicMaterial as Dt, LineBasicMaterial as jt, CylinderGeometry as w, BoxGeometry as f, BufferGeometry as dt, Float32BufferAttribute as pt, Mesh as r, OctahedronGeometry as tt, Line as A, TorusGeometry as Q, SphereGeometry as kt, Euler as Qt, Matrix4 as Et, PlaneGeometry as Ot, DoubleSide as Rt, Vector2 as F, Layers as _t } from "three";
+import "../../chunks/FileTypes-3cvLT4Y_.mjs";
+import { P as G, U as W } from "../../chunks/PerspectiveCamera-BFzE2TQU.mjs";
+import { f as B, i as O } from "../../chunks/findInterface-DbJ5qzbc.mjs";
+import { A as ut, a as gt, b as ft } from "../../chunks/AxisHelperColors-JLBHYQDi.mjs";
+class Zt {
+  constructor() {
+    o(this, "_selected", null);
+    o(this, "_listeners", /* @__PURE__ */ new Set());
   }
+  /**
+   * Currently selected object, or null if nothing is selected.
+   */
+  get selected() {
+    return this._selected;
+  }
+  /**
+   * Select an object. Deselects any previously selected object.
+   * Calls onSelect on the new object and onDeselect on the previous.
+   */
+  select(t) {
+    var e, i, n;
+    this._selected !== t && (this._selected && ((i = (e = this._selected).onDeselect) == null || i.call(e)), this._selected = t, (n = t.onSelect) == null || n.call(t), this.notifyListeners());
+  }
+  /**
+   * Deselect the currently selected object.
+   * Calls onDeselect on the object.
+   */
+  deselect() {
+    var t, e;
+    this._selected && ((e = (t = this._selected).onDeselect) == null || e.call(t), this._selected = null, this.notifyListeners());
+  }
+  /**
+   * Register a callback to be notified when selection changes.
+   */
+  onChange(t) {
+    this._listeners.add(t);
+  }
+  /**
+   * Unregister a previously registered callback.
+   */
+  offChange(t) {
+    this._listeners.delete(t);
+  }
+  /**
+   * Dispose of the selection state and clear all listeners.
+   */
   dispose() {
-    this.removeEventListeners();
+    this._selected = null, this._listeners.clear();
+  }
+  notifyListeners() {
+    for (const t of this._listeners)
+      t(this._selected);
+  }
+}
+class Gt {
+  constructor() {
+    o(this, "name", "hover");
+    o(this, "priority", 20);
+    o(this, "_hovered", null);
+  }
+  /**
+   * Currently hovered object, or null if nothing is hovered.
+   */
+  get hovered() {
+    return this._hovered;
+  }
+  onActivate() {
+    this._hovered = null;
+  }
+  onDeactivate() {
+    var t, e;
+    this._hovered && ((e = (t = this._hovered).onPointerLeave) == null || e.call(t), this._hovered = null);
+  }
+  onPointerMove(t) {
+    var n, a, s, c, u, P, M;
+    const e = t.modelIntersects[0], i = B(
+      e == null ? void 0 : e.object,
+      "isHoverable"
+    );
+    if (e && i) {
+      if (!this._hovered) {
+        (n = i.onPointerEnter) == null || n.call(i, e), this._hovered = i;
+        return;
+      }
+      if (this._hovered.uuid !== i.uuid) {
+        (s = (a = this._hovered).onPointerLeave) == null || s.call(a), (c = i.onPointerEnter) == null || c.call(i, e), this._hovered = i;
+        return;
+      }
+      (u = i.onPointerOver) == null || u.call(i, e);
+      return;
+    }
+    this._hovered && ((M = (P = this._hovered).onPointerLeave) == null || M.call(P), this._hovered = null);
+  }
+}
+const he = (h) => h.name === "select";
+class Wt {
+  constructor(t) {
+    o(this, "name", "select");
+    o(this, "priority", 30);
+    o(this, "_selectionState");
+    this._selectionState = t;
+  }
+  /**
+   * Get the currently selected object.
+   */
+  get selected() {
+    return this._selectionState.selected;
+  }
+  onActivate() {
+  }
+  onDeactivate() {
+  }
+  onClick(t) {
+    const e = t.modelIntersects[0], i = B(
+      e == null ? void 0 : e.object,
+      "isSelectable"
+    );
+    if (!e || !i) {
+      this._selectionState.deselect();
+      return;
+    }
+    const n = this._selectionState.selected;
+    n && n.uuid === i.uuid || this._selectionState.select(i);
+  }
+  /**
+   * Programmatically select an object.
+   */
+  select(t) {
+    this._selectionState.select(t);
+  }
+  /**
+   * Programmatically deselect the current selection.
+   */
+  deselect() {
+    this._selectionState.deselect();
+  }
+}
+const L = new ot(), _ = new l(), C = new l(), p = new E(), mt = {
+  X: new l(1, 0, 0),
+  Y: new l(0, 1, 0),
+  Z: new l(0, 0, 1)
+}, rt = { type: "change" }, wt = { type: "mouseDown" }, yt = { type: "mouseUp", mode: null }, bt = { type: "objectChange" };
+class qt extends lt {
+  constructor(t, e) {
+    super(), e === void 0 && (console.warn('THREE.TransformControls: The second parameter "domElement" is now mandatory.'), e = document), this.isTransformControls = !0, this.visible = !1, this.domElement = e, this.domElement.style.touchAction = "none";
+    const i = new Kt();
+    this._gizmo = i, this.add(i);
+    const n = new $t();
+    this._plane = n, this.add(n);
+    const a = this;
+    function s(g, b) {
+      let X = b;
+      Object.defineProperty(a, g, {
+        get: function() {
+          return X !== void 0 ? X : b;
+        },
+        set: function(z) {
+          X !== z && (X = z, n[g] = z, i[g] = z, a.dispatchEvent({ type: g + "-changed", value: z }), a.dispatchEvent(rt));
+        }
+      }), a[g] = b, n[g] = b, i[g] = b;
+    }
+    s("camera", t), s("object", void 0), s("enabled", !0), s("axis", null), s("mode", "translate"), s("translationSnap", null), s("rotationSnap", null), s("scaleSnap", null), s("space", "world"), s("size", 1), s("dragging", !1), s("showX", !0), s("showY", !0), s("showZ", !0);
+    const c = new l(), u = new l(), P = new E(), M = new E(), j = new l(), k = new E(), ht = new l(), V = new l(), x = new l(), I = 0, S = new l();
+    s("worldPosition", c), s("worldPositionStart", u), s("worldQuaternion", P), s("worldQuaternionStart", M), s("cameraPosition", j), s("cameraQuaternion", k), s("pointStart", ht), s("pointEnd", V), s("rotationAxis", x), s("rotationAngle", I), s("eye", S), this._offset = new l(), this._startNorm = new l(), this._endNorm = new l(), this._cameraScale = new l(), this._parentPosition = new l(), this._parentQuaternion = new E(), this._parentQuaternionInv = new E(), this._parentScale = new l(), this._worldScaleStart = new l(), this._worldQuaternionInv = new E(), this._worldScale = new l(), this._positionStart = new l(), this._quaternionStart = new E(), this._scaleStart = new l(), this._getPointer = Ut.bind(this), this._onPointerDown = Bt.bind(this), this._onPointerHover = Ft.bind(this), this._onPointerMove = Vt.bind(this), this._onPointerUp = Nt.bind(this), this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointermove", this._onPointerHover), this.domElement.addEventListener("pointerup", this._onPointerUp);
+  }
+  // updateMatrixWorld updates key transformation variables
+  updateMatrixWorld(t) {
+    this.object !== void 0 && (this.object.updateMatrixWorld(), this.object.parent === null ? console.error("TransformControls: The attached 3D object must be a part of the scene graph.") : this.object.parent.matrixWorld.decompose(this._parentPosition, this._parentQuaternion, this._parentScale), this.object.matrixWorld.decompose(this.worldPosition, this.worldQuaternion, this._worldScale), this._parentQuaternionInv.copy(this._parentQuaternion).invert(), this._worldQuaternionInv.copy(this.worldQuaternion).invert()), this.camera.updateMatrixWorld(), this.camera.matrixWorld.decompose(this.cameraPosition, this.cameraQuaternion, this._cameraScale), this.camera.isOrthographicCamera ? this.camera.getWorldDirection(this.eye).negate() : this.eye.copy(this.cameraPosition).sub(this.worldPosition).normalize(), super.updateMatrixWorld(t);
+  }
+  pointerHover(t) {
+    if (this.object === void 0 || this.dragging === !0) return;
+    t !== null && L.setFromCamera(t, this.camera);
+    const e = at(this._gizmo.picker[this.mode], L);
+    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 && L.setFromCamera(t, this.camera);
+      const e = at(this._plane, L, !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, wt.mode = this.mode, this.dispatchEvent(wt);
+    }
+  }
+  pointerMove(t) {
+    const e = this.axis, i = this.mode, n = this.object;
+    let a = this.space;
+    if (i === "scale" ? a = "local" : (e === "E" || e === "XYZE" || e === "XYZ") && (a = "world"), n === void 0 || e === null || this.dragging === !1 || t !== null && t.button !== -1) return;
+    t !== null && L.setFromCamera(t, this.camera);
+    const s = at(this._plane, L, !0);
+    if (s) {
+      if (this.pointEnd.copy(s.point).sub(this.worldPositionStart), i === "translate")
+        this._offset.copy(this.pointEnd).sub(this.pointStart), a === "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), a === "local" && e !== "XYZ" ? this._offset.applyQuaternion(this._quaternionStart).divide(this._parentScale) : this._offset.applyQuaternion(this._parentQuaternionInv).divide(this._parentScale), n.position.copy(this._offset).add(this._positionStart), this.translationSnap && (a === "local" && (n.position.applyQuaternion(p.copy(this._quaternionStart).invert()), e.search("X") !== -1 && (n.position.x = Math.round(n.position.x / this.translationSnap) * this.translationSnap), e.search("Y") !== -1 && (n.position.y = Math.round(n.position.y / this.translationSnap) * this.translationSnap), e.search("Z") !== -1 && (n.position.z = Math.round(n.position.z / this.translationSnap) * this.translationSnap), n.position.applyQuaternion(this._quaternionStart)), a === "world" && (n.parent && n.position.add(_.setFromMatrixPosition(n.parent.matrixWorld)), e.search("X") !== -1 && (n.position.x = Math.round(n.position.x / this.translationSnap) * this.translationSnap), e.search("Y") !== -1 && (n.position.y = Math.round(n.position.y / this.translationSnap) * this.translationSnap), e.search("Z") !== -1 && (n.position.z = Math.round(n.position.z / this.translationSnap) * this.translationSnap), n.parent && n.position.sub(_.setFromMatrixPosition(n.parent.matrixWorld))));
+      else if (i === "scale") {
+        if (e.search("XYZ") !== -1) {
+          let c = this.pointEnd.length() / this.pointStart.length();
+          this.pointEnd.dot(this.pointStart) < 0 && (c *= -1), C.set(c, c, c);
+        } else
+          _.copy(this.pointStart), C.copy(this.pointEnd), _.applyQuaternion(this._worldQuaternionInv), C.applyQuaternion(this._worldQuaternionInv), C.divide(_), e.search("X") === -1 && (C.x = 1), e.search("Y") === -1 && (C.y = 1), e.search("Z") === -1 && (C.z = 1);
+        n.scale.copy(this._scaleStart).multiply(C), this.scaleSnap && (e.search("X") !== -1 && (n.scale.x = Math.round(n.scale.x / this.scaleSnap) * this.scaleSnap || this.scaleSnap), e.search("Y") !== -1 && (n.scale.y = Math.round(n.scale.y / this.scaleSnap) * this.scaleSnap || this.scaleSnap), e.search("Z") !== -1 && (n.scale.z = Math.round(n.scale.z / this.scaleSnap) * this.scaleSnap || this.scaleSnap));
+      } else if (i === "rotate") {
+        this._offset.copy(this.pointEnd).sub(this.pointStart);
+        const c = 20 / this.worldPosition.distanceTo(_.setFromMatrixPosition(this.camera.matrixWorld));
+        let u = !1;
+        e === "XYZE" ? (this.rotationAxis.copy(this._offset).cross(this.eye).normalize(), this.rotationAngle = this._offset.dot(_.copy(this.rotationAxis).cross(this.eye)) * c) : (e === "X" || e === "Y" || e === "Z") && (this.rotationAxis.copy(mt[e]), _.copy(mt[e]), a === "local" && _.applyQuaternion(this.worldQuaternion), _.cross(this.eye), _.length() === 0 ? u = !0 : this.rotationAngle = this._offset.dot(_.normalize()) * c), (e === "E" || u) && (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), a === "local" && e !== "E" && e !== "XYZE" ? (n.quaternion.copy(this._quaternionStart), n.quaternion.multiply(p.setFromAxisAngle(this.rotationAxis, this.rotationAngle)).normalize()) : (this.rotationAxis.applyQuaternion(this._parentQuaternionInv), n.quaternion.copy(p.setFromAxisAngle(this.rotationAxis, this.rotationAngle)), n.quaternion.multiply(this._quaternionStart).normalize());
+      }
+      this.dispatchEvent(rt), this.dispatchEvent(bt);
+    }
+  }
+  pointerUp(t) {
+    t !== null && t.button !== 0 || (this.dragging && this.axis !== null && (yt.mode = this.mode, this.dispatchEvent(yt)), this.dragging = !1, this.axis = null);
+  }
+  dispose() {
+    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.traverse(function(t) {
+      t.geometry && t.geometry.dispose(), t.material && t.material.dispose();
+    });
+  }
+  // Set current object
+  attach(t) {
+    return this.object = t, this.visible = !0, this;
+  }
+  // Detach from object
+  detach() {
+    return this.object = void 0, this.visible = !1, this.axis = null, 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(rt), this.dispatchEvent(bt), this.pointStart.copy(this.pointEnd));
+  }
+  getRaycaster() {
+    return L;
+  }
+  // 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 Ut(h) {
+  if (this.domElement.ownerDocument.pointerLockElement)
+    return {
+      x: 0,
+      y: 0,
+      button: h.button
+    };
+  {
+    const t = this.domElement.getBoundingClientRect();
+    return {
+      x: (h.clientX - t.left) / t.width * 2 - 1,
+      y: -(h.clientY - t.top) / t.height * 2 + 1,
+      button: h.button
+    };
+  }
+}
+function Ft(h) {
+  if (this.enabled)
+    switch (h.pointerType) {
+      case "mouse":
+      case "pen":
+        this.pointerHover(this._getPointer(h));
+        break;
+    }
+}
+function Bt(h) {
+  this.enabled && (document.pointerLockElement || this.domElement.setPointerCapture(h.pointerId), this.domElement.addEventListener("pointermove", this._onPointerMove), this.pointerHover(this._getPointer(h)), this.pointerDown(this._getPointer(h)));
+}
+function Vt(h) {
+  this.enabled && this.pointerMove(this._getPointer(h));
+}
+function Nt(h) {
+  this.enabled && (this.domElement.releasePointerCapture(h.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.pointerUp(this._getPointer(h)));
+}
+function at(h, t, e) {
+  const i = t.intersectObject(h, !0);
+  for (let n = 0; n < i.length; n++)
+    if (i[n].object.visible || e)
+      return i[n];
+  return !1;
+}
+const et = new Qt(), d = new l(0, 1, 0), vt = new l(0, 0, 0), Pt = new Et(), it = new E(), nt = new E(), D = new l(), St = new Et(), q = new l(1, 0, 0), H = new l(0, 1, 0), U = new l(0, 0, 1), st = new l(), R = new l(), Z = new l();
+class Kt extends lt {
+  constructor() {
+    super(), this.isTransformControlsGizmo = !0, this.type = "TransformControlsGizmo";
+    const t = new Dt({
+      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 n = e.clone();
+    n.opacity = 0.5;
+    const a = t.clone();
+    a.color.setHex(16711680);
+    const s = t.clone();
+    s.color.setHex(65280);
+    const c = t.clone();
+    c.color.setHex(255);
+    const u = t.clone();
+    u.color.setHex(16711680), u.opacity = 0.5;
+    const P = t.clone();
+    P.color.setHex(65280), P.opacity = 0.5;
+    const M = t.clone();
+    M.color.setHex(255), M.opacity = 0.5;
+    const j = t.clone();
+    j.opacity = 0.25;
+    const k = t.clone();
+    k.color.setHex(16776960), k.opacity = 0.25, t.clone().color.setHex(16776960);
+    const V = t.clone();
+    V.color.setHex(7895160);
+    const x = new w(0, 0.04, 0.1, 12);
+    x.translate(0, 0.05, 0);
+    const I = new f(0.08, 0.08, 0.08);
+    I.translate(0, 0.04, 0);
+    const S = new dt();
+    S.setAttribute("position", new pt([0, 0, 0, 1, 0, 0], 3));
+    const g = new w(75e-4, 75e-4, 0.5, 3);
+    g.translate(0, 0.25, 0);
+    function b(y, N) {
+      const v = new Q(y, 75e-4, 3, 64, N * Math.PI * 2);
+      return v.rotateY(Math.PI / 2), v.rotateX(Math.PI / 2), v;
+    }
+    function X() {
+      const y = new dt();
+      return y.setAttribute("position", new pt([0, 0, 0, 1, 1, 1], 3)), y;
+    }
+    const z = {
+      X: [
+        [new r(x, a), [0.5, 0, 0], [0, 0, -Math.PI / 2]],
+        [new r(x, a), [-0.5, 0, 0], [0, 0, Math.PI / 2]],
+        [new r(g, a), [0, 0, 0], [0, 0, -Math.PI / 2]]
+      ],
+      Y: [
+        [new r(x, s), [0, 0.5, 0]],
+        [new r(x, s), [0, -0.5, 0], [Math.PI, 0, 0]],
+        [new r(g, s)]
+      ],
+      Z: [
+        [new r(x, c), [0, 0, 0.5], [Math.PI / 2, 0, 0]],
+        [new r(x, c), [0, 0, -0.5], [-Math.PI / 2, 0, 0]],
+        [new r(g, c), null, [Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new r(new tt(0.1, 0), j.clone()), [0, 0, 0]]
+      ],
+      XY: [
+        [new r(new f(0.15, 0.15, 0.01), M.clone()), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new r(new f(0.15, 0.15, 0.01), u.clone()), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new r(new f(0.15, 0.15, 0.01), P.clone()), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ]
+    }, Mt = {
+      X: [
+        [new r(new w(0.2, 0, 0.6, 4), i), [0.3, 0, 0], [0, 0, -Math.PI / 2]],
+        [new r(new w(0.2, 0, 0.6, 4), i), [-0.3, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new r(new w(0.2, 0, 0.6, 4), i), [0, 0.3, 0]],
+        [new r(new w(0.2, 0, 0.6, 4), i), [0, -0.3, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new r(new w(0.2, 0, 0.6, 4), i), [0, 0, 0.3], [Math.PI / 2, 0, 0]],
+        [new r(new w(0.2, 0, 0.6, 4), i), [0, 0, -0.3], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new r(new tt(0.2, 0), i)]
+      ],
+      XY: [
+        [new r(new f(0.2, 0.2, 0.01), i), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new r(new f(0.2, 0.2, 0.01), i), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new r(new f(0.2, 0.2, 0.01), i), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ]
+    }, xt = {
+      START: [
+        [new r(new tt(0.01, 2), n), null, null, null, "helper"]
+      ],
+      END: [
+        [new r(new tt(0.01, 2), n), null, null, null, "helper"]
+      ],
+      DELTA: [
+        [new A(X(), n), null, null, null, "helper"]
+      ],
+      X: [
+        [new A(S, n.clone()), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ],
+      Y: [
+        [new A(S, n.clone()), [0, -1e3, 0], [0, 0, Math.PI / 2], [1e6, 1, 1], "helper"]
+      ],
+      Z: [
+        [new A(S, n.clone()), [0, 0, -1e3], [0, -Math.PI / 2, 0], [1e6, 1, 1], "helper"]
+      ]
+    }, It = {
+      XYZE: [
+        [new r(b(0.5, 1), V), null, [0, Math.PI / 2, 0]]
+      ],
+      X: [
+        [new r(b(0.5, 0.5), a)]
+      ],
+      Y: [
+        [new r(b(0.5, 0.5), s), null, [0, 0, -Math.PI / 2]]
+      ],
+      Z: [
+        [new r(b(0.5, 0.5), c), null, [0, Math.PI / 2, 0]]
+      ],
+      E: [
+        [new r(b(0.75, 1), k), null, [0, Math.PI / 2, 0]]
+      ]
+    }, Tt = {
+      AXIS: [
+        [new A(S, n.clone()), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ]
+    }, At = {
+      XYZE: [
+        [new r(new kt(0.25, 10, 8), i)]
+      ],
+      X: [
+        [new r(new Q(0.5, 0.1, 4, 24), i), [0, 0, 0], [0, -Math.PI / 2, -Math.PI / 2]]
+      ],
+      Y: [
+        [new r(new Q(0.5, 0.1, 4, 24), i), [0, 0, 0], [Math.PI / 2, 0, 0]]
+      ],
+      Z: [
+        [new r(new Q(0.5, 0.1, 4, 24), i), [0, 0, 0], [0, 0, -Math.PI / 2]]
+      ],
+      E: [
+        [new r(new Q(0.75, 0.1, 2, 24), i)]
+      ]
+    }, Ct = {
+      X: [
+        [new r(I, a), [0.5, 0, 0], [0, 0, -Math.PI / 2]],
+        [new r(g, a), [0, 0, 0], [0, 0, -Math.PI / 2]],
+        [new r(I, a), [-0.5, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new r(I, s), [0, 0.5, 0]],
+        [new r(g, s)],
+        [new r(I, s), [0, -0.5, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new r(I, c), [0, 0, 0.5], [Math.PI / 2, 0, 0]],
+        [new r(g, c), [0, 0, 0], [Math.PI / 2, 0, 0]],
+        [new r(I, c), [0, 0, -0.5], [-Math.PI / 2, 0, 0]]
+      ],
+      XY: [
+        [new r(new f(0.15, 0.15, 0.01), M), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new r(new f(0.15, 0.15, 0.01), u), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new r(new f(0.15, 0.15, 0.01), P), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new r(new f(0.1, 0.1, 0.1), j.clone())]
+      ]
+    }, zt = {
+      X: [
+        [new r(new w(0.2, 0, 0.6, 4), i), [0.3, 0, 0], [0, 0, -Math.PI / 2]],
+        [new r(new w(0.2, 0, 0.6, 4), i), [-0.3, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new r(new w(0.2, 0, 0.6, 4), i), [0, 0.3, 0]],
+        [new r(new w(0.2, 0, 0.6, 4), i), [0, -0.3, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new r(new w(0.2, 0, 0.6, 4), i), [0, 0, 0.3], [Math.PI / 2, 0, 0]],
+        [new r(new w(0.2, 0, 0.6, 4), i), [0, 0, -0.3], [-Math.PI / 2, 0, 0]]
+      ],
+      XY: [
+        [new r(new f(0.2, 0.2, 0.01), i), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new r(new f(0.2, 0.2, 0.01), i), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new r(new f(0.2, 0.2, 0.01), i), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new r(new f(0.2, 0.2, 0.2), i), [0, 0, 0]]
+      ]
+    }, Lt = {
+      X: [
+        [new A(S, n.clone()), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ],
+      Y: [
+        [new A(S, n.clone()), [0, -1e3, 0], [0, 0, Math.PI / 2], [1e6, 1, 1], "helper"]
+      ],
+      Z: [
+        [new A(S, n.clone()), [0, 0, -1e3], [0, -Math.PI / 2, 0], [1e6, 1, 1], "helper"]
+      ]
+    };
+    function T(y) {
+      const N = new lt();
+      for (const v in y)
+        for (let Y = y[v].length; Y--; ) {
+          const m = y[v][Y][0].clone(), K = y[v][Y][1], $ = y[v][Y][2], J = y[v][Y][3], Ht = y[v][Y][4];
+          m.name = v, m.tag = Ht, K && m.position.set(K[0], K[1], K[2]), $ && m.rotation.set($[0], $[1], $[2]), J && m.scale.set(J[0], J[1], J[2]), m.updateMatrix();
+          const ct = m.geometry.clone();
+          ct.applyMatrix4(m.matrix), m.geometry = ct, m.renderOrder = 1 / 0, m.position.set(0, 0, 0), m.rotation.set(0, 0, 0), m.scale.set(1, 1, 1), N.add(m);
+        }
+      return N;
+    }
+    this.gizmo = {}, this.picker = {}, this.helper = {}, this.add(this.gizmo.translate = T(z)), this.add(this.gizmo.rotate = T(It)), this.add(this.gizmo.scale = T(Ct)), this.add(this.picker.translate = T(Mt)), this.add(this.picker.rotate = T(At)), this.add(this.picker.scale = T(zt)), this.add(this.helper.translate = T(xt)), this.add(this.helper.rotate = T(Tt)), this.add(this.helper.scale = T(Lt)), 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 : nt;
+    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 n = [];
+    n = n.concat(this.picker[this.mode].children), n = n.concat(this.gizmo[this.mode].children), n = n.concat(this.helper[this.mode].children);
+    for (let a = 0; a < n.length; a++) {
+      const s = n[a];
+      s.visible = !0, s.rotation.set(0, 0, 0), s.position.copy(this.worldPosition);
+      let c;
+      if (this.camera.isOrthographicCamera ? c = (this.camera.top - this.camera.bottom) / this.camera.zoom : c = this.worldPosition.distanceTo(this.cameraPosition) * Math.min(1.9 * Math.tan(Math.PI * this.camera.fov / 360) / this.camera.zoom, 7), s.scale.set(1, 1, 1).multiplyScalar(c * this.size / 4), s.tag === "helper") {
+        s.visible = !1, s.name === "AXIS" ? (s.visible = !!this.axis, this.axis === "X" && (p.setFromEuler(et.set(0, 0, 0)), s.quaternion.copy(i).multiply(p), Math.abs(d.copy(q).applyQuaternion(i).dot(this.eye)) > 0.9 && (s.visible = !1)), this.axis === "Y" && (p.setFromEuler(et.set(0, 0, Math.PI / 2)), s.quaternion.copy(i).multiply(p), Math.abs(d.copy(H).applyQuaternion(i).dot(this.eye)) > 0.9 && (s.visible = !1)), this.axis === "Z" && (p.setFromEuler(et.set(0, Math.PI / 2, 0)), s.quaternion.copy(i).multiply(p), Math.abs(d.copy(U).applyQuaternion(i).dot(this.eye)) > 0.9 && (s.visible = !1)), this.axis === "XYZE" && (p.setFromEuler(et.set(0, Math.PI / 2, 0)), d.copy(this.rotationAxis), s.quaternion.setFromRotationMatrix(Pt.lookAt(vt, d, H)), s.quaternion.multiply(p), s.visible = this.dragging), this.axis === "E" && (s.visible = !1)) : s.name === "START" ? (s.position.copy(this.worldPositionStart), s.visible = this.dragging) : s.name === "END" ? (s.position.copy(this.worldPosition), s.visible = this.dragging) : s.name === "DELTA" ? (s.position.copy(this.worldPositionStart), s.quaternion.copy(this.worldQuaternionStart), _.set(1e-10, 1e-10, 1e-10).add(this.worldPositionStart).sub(this.worldPosition).multiplyScalar(-1), _.applyQuaternion(this.worldQuaternionStart.clone().invert()), s.scale.copy(_), s.visible = this.dragging) : (s.quaternion.copy(i), this.dragging ? s.position.copy(this.worldPositionStart) : s.position.copy(this.worldPosition), this.axis && (s.visible = this.axis.search(s.name) !== -1));
+        continue;
+      }
+      s.quaternion.copy(i), this.mode === "translate" || this.mode === "scale" ? (s.name === "X" && Math.abs(d.copy(q).applyQuaternion(i).dot(this.eye)) > 0.99 && (s.scale.set(1e-10, 1e-10, 1e-10), s.visible = !1), s.name === "Y" && Math.abs(d.copy(H).applyQuaternion(i).dot(this.eye)) > 0.99 && (s.scale.set(1e-10, 1e-10, 1e-10), s.visible = !1), s.name === "Z" && Math.abs(d.copy(U).applyQuaternion(i).dot(this.eye)) > 0.99 && (s.scale.set(1e-10, 1e-10, 1e-10), s.visible = !1), s.name === "XY" && Math.abs(d.copy(U).applyQuaternion(i).dot(this.eye)) < 0.2 && (s.scale.set(1e-10, 1e-10, 1e-10), s.visible = !1), s.name === "YZ" && Math.abs(d.copy(q).applyQuaternion(i).dot(this.eye)) < 0.2 && (s.scale.set(1e-10, 1e-10, 1e-10), s.visible = !1), s.name === "XZ" && Math.abs(d.copy(H).applyQuaternion(i).dot(this.eye)) < 0.2 && (s.scale.set(1e-10, 1e-10, 1e-10), s.visible = !1)) : this.mode === "rotate" && (it.copy(i), d.copy(this.eye).applyQuaternion(p.copy(i).invert()), s.name.search("E") !== -1 && s.quaternion.setFromRotationMatrix(Pt.lookAt(this.eye, vt, H)), s.name === "X" && (p.setFromAxisAngle(q, Math.atan2(-d.y, d.z)), p.multiplyQuaternions(it, p), s.quaternion.copy(p)), s.name === "Y" && (p.setFromAxisAngle(H, Math.atan2(d.x, d.z)), p.multiplyQuaternions(it, p), s.quaternion.copy(p)), s.name === "Z" && (p.setFromAxisAngle(U, Math.atan2(d.y, d.x)), p.multiplyQuaternions(it, p), s.quaternion.copy(p))), s.visible = s.visible && (s.name.indexOf("X") === -1 || this.showX), s.visible = s.visible && (s.name.indexOf("Y") === -1 || this.showY), s.visible = s.visible && (s.name.indexOf("Z") === -1 || this.showZ), s.visible = s.visible && (s.name.indexOf("E") === -1 || this.showX && this.showY && this.showZ), s.material._color = s.material._color || s.material.color.clone(), s.material._opacity = s.material._opacity || s.material.opacity, s.material.color.copy(s.material._color), s.material.opacity = s.material._opacity, this.enabled && this.axis && (s.name === this.axis || this.axis.split("").some(function(u) {
+        return s.name === u;
+      })) && (s.material.color.setHex(16776960), s.material.opacity = 1);
+    }
+    super.updateMatrixWorld(t);
+  }
+}
+class $t extends r {
+  constructor() {
+    super(
+      new Ot(1e5, 1e5, 2, 2),
+      new Dt({ visible: !1, wireframe: !0, side: Rt, 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"), st.copy(q).applyQuaternion(e === "local" ? this.worldQuaternion : nt), R.copy(H).applyQuaternion(e === "local" ? this.worldQuaternion : nt), Z.copy(U).applyQuaternion(e === "local" ? this.worldQuaternion : nt), d.copy(R), this.mode) {
+      case "translate":
+      case "scale":
+        switch (this.axis) {
+          case "X":
+            d.copy(this.eye).cross(st), D.copy(st).cross(d);
+            break;
+          case "Y":
+            d.copy(this.eye).cross(R), D.copy(R).cross(d);
+            break;
+          case "Z":
+            d.copy(this.eye).cross(Z), D.copy(Z).cross(d);
+            break;
+          case "XY":
+            D.copy(Z);
+            break;
+          case "YZ":
+            D.copy(st);
+            break;
+          case "XZ":
+            d.copy(Z), D.copy(R);
+            break;
+          case "XYZ":
+          case "E":
+            D.set(0, 0, 0);
+            break;
+        }
+        break;
+      case "rotate":
+      default:
+        D.set(0, 0, 0);
+    }
+    D.length() === 0 ? this.quaternion.copy(this.cameraQuaternion) : (St.lookAt(_.set(0, 0, 0), D, d), this.quaternion.setFromRotationMatrix(St)), super.updateMatrixWorld(t);
+  }
+}
+const ce = (h) => h.name === "transform";
+class Jt {
+  constructor(t, e, i) {
+    o(this, "name", "transform");
+    o(this, "priority", 5);
+    o(this, "_scene");
+    o(this, "_controller");
+    o(this, "_selectionState");
+    o(this, "_gizmo");
+    o(this, "_scaleLinked", !1);
+    o(this, "_gizmoVisible", !0);
+    o(this, "_selectionChangeHandler");
+    this._scene = t, this._controller = e, this._selectionState = i, this._gizmo = this.initGizmo(), this._scene.add(this._gizmo), this._selectionChangeHandler = this.onSelectionChange.bind(this);
+  }
+  /**
+   * Get the TransformControls gizmo.
+   */
+  get gizmo() {
+    return this._gizmo;
+  }
+  /**
+   * Whether a drag operation is currently in progress.
+   */
+  get isDragging() {
+    return this._gizmo.dragging;
+  }
+  onActivate() {
+    this._selectionState.onChange(this._selectionChangeHandler);
+    const t = this._selectionState.selected;
+    t && this.attachGizmo(t);
+  }
+  onDeactivate() {
+    this._selectionState.offChange(this._selectionChangeHandler), this._gizmo.detach();
+  }
+  onPointerMove(t) {
+    if (this._gizmo.dragging || t.uiIntersects.length > 0 && t.uiIntersects.some(
+      (i) => this.isGizmoChild(i.object)
+    ))
+      return !0;
+  }
+  /**
+   * Set the gizmo transformation mode.
+   */
+  setGizmoMode(t) {
+    this._gizmo.mode = t;
   }
+  /**
+   * Set whether the gizmo is visible.
+   */
+  setGizmoVisible(t) {
+    this._gizmoVisible = t;
+    const e = this._scene.children.includes(this._gizmo);
+    t && !e ? (this._scene.add(this._gizmo), this._gizmo.getRaycaster().layers.enableAll()) : !t && e && (this._scene.remove(this._gizmo), this._gizmo.getRaycaster().layers.disableAll());
+  }
+  /**
+   * Set whether scale operations are linked (uniform scaling).
+   */
+  setGizmoScaleLinked(t) {
+    this._scaleLinked = t;
+  }
+  /**
+   * Dispose of the tool and clean up resources.
+   */
+  dispose() {
+    this._selectionState.offChange(this._selectionChangeHandler), this._gizmo.detach(), this._scene.remove(this._gizmo), this._gizmo.dispose();
+  }
+  // ============ Private Methods ============
+  onSelectionChange(t) {
+    t && O(t, "isMovable") ? this.attachGizmo(t) : this._gizmo.detach();
+  }
+  attachGizmo(t) {
+    O(t, "isMovable") && (this._gizmo.attach(t), this.setGizmoVisible(t.visible && this._gizmoVisible));
+  }
+  isGizmoChild(t) {
+    let e = t;
+    for (; e; ) {
+      if (e === this._gizmo) return !0;
+      e = e.parent;
+    }
+    return !1;
+  }
+  initGizmo() {
+    const t = new qt(
+      this._controller.object,
+      this._controller.domElement
+    );
+    return t.mode = "translate", t.traverse((e) => {
+      if (!("isMesh" in e)) return;
+      const i = e.material;
+      e.name === "X" && i.color.set(ut), e.name === "Y" && i.color.set(gt), e.name === "Z" && i.color.set(ft), e.name === "XY" && i.color.set(ft), e.name === "YZ" && i.color.set(ut), e.name === "XZ" && i.color.set(gt);
+    }), t.addEventListener("mouseDown", () => {
+      var e, i;
+      this._controller.enabled = !1, O(t.object, "isMovable") && ((i = (e = t.object).onMoveStart) == null || i.call(e));
+    }), t.addEventListener("objectChange", () => {
+      var e, i;
+      if (O(t.object, "isMovable") && ((i = (e = t.object).onMove) == null || i.call(e), this._scaleLinked && t.object)) {
+        const n = t.object.scale, a = (n.x + n.y + n.z) / 3;
+        t.object.scale.set(a, a, a);
+      }
+    }), t.addEventListener("mouseUp", () => {
+      var e, i;
+      this._controller.enabled = !0, O(t.object, "isMovable") && ((i = (e = t.object).onMoveEnd) == null || i.call(e));
+    }), t;
+  }
+}
+const te = 1e-3;
+class ee {
+  constructor(t) {
+    o(this, "name", "drag");
+    o(this, "priority", 10);
+    o(this, "_controller");
+    o(this, "_raycaster");
+    // Drag state
+    o(this, "_dragging", !1);
+    o(this, "_draggable", null);
+    o(this, "_dragStart", new l());
+    o(this, "_dragCurrent", new l());
+    o(this, "_dragEnd", new l());
+    o(this, "_dragDelta", new l());
+    // Custom raycast targets for drag plane
+    o(this, "_dragRaycastTargets", null);
+    this._controller = t, this._raycaster = new ot();
+  }
+  /**
+   * Whether a drag operation is currently in progress.
+   */
+  get isDragging() {
+    return this._dragging;
+  }
+  /**
+   * The object currently being dragged, or null.
+   */
+  get draggable() {
+    return this._draggable;
+  }
+  onActivate() {
+    this.resetDragState();
+  }
+  onDeactivate() {
+    this._dragging && this._draggable && this.endDrag(), this.resetDragState();
+  }
+  onPointerDown(t) {
+    var e;
+    t.pointerPrimaryDown && (this._draggable = B(
+      (e = t.intersects[0]) == null ? void 0 : e.object,
+      "isDraggable"
+    ) || null);
+  }
+  onPointerMove(t) {
+    if (t.pointerPrimaryDown && this._draggable && (this._raycaster.setFromCamera(t.pointer, this._controller.object), this._dragging || t.lastPointerDown.distanceTo(t.pointer) > te && this.startDrag(t), this._dragging))
+      return this.updateDrag(t), !0;
+  }
+  onPointerUp(t) {
+    this._dragging && (this._raycaster.setFromCamera(t.pointer, this._controller.object), this.endDrag()), this._draggable = null;
+  }
+  /**
+   * Set custom objects to raycast against during drag.
+   * Useful for constraining drag to a floor plane.
+   *
+   * @param targets Objects to raycast against, or null to use scene objects
+   */
+  setDragRaycastTargets(t) {
+    this._dragRaycastTargets = t;
+  }
+  // ============ Private Methods ============
+  startDrag(t) {
+    var i, n;
+    const e = this.getDragIntersect(t);
+    e && (this._dragStart.copy(e.point), this._dragCurrent.copy(e.point), this._dragEnd.copy(e.point), this._dragDelta.set(0, 0, 0), (n = (i = this._draggable) == null ? void 0 : i.onDragStart) == null || n.call(i, this.createDragEvent()), this._dragging = !0, this._controller.enabled = !1);
+  }
+  updateDrag(t) {
+    var i, n;
+    const e = this.getDragIntersect(t);
+    e && (this._dragCurrent.copy(e.point), this._dragEnd.copy(e.point), this._dragDelta.subVectors(this._dragCurrent, this._dragStart), (n = (i = this._draggable) == null ? void 0 : i.onDrag) == null || n.call(i, this.createDragEvent()));
+  }
+  endDrag() {
+    var e, i;
+    const t = this.createDragEvent();
+    (i = (e = this._draggable) == null ? void 0 : e.onDragEnd) == null || i.call(e, t), this._dragging = !1, this._controller.enabled = !0, this.resetDragState();
+  }
+  getDragIntersect(t) {
+    return this._dragRaycastTargets ? this._raycaster.intersectObjects(
+      this._dragRaycastTargets,
+      !0
+    )[0] || null : t.intersects[0] || null;
+  }
+  createDragEvent() {
+    return {
+      dragStart: this._dragStart.clone(),
+      dragCurrent: this._dragCurrent.clone(),
+      dragEnd: this._dragEnd.clone(),
+      dragDelta: this._dragDelta.clone()
+    };
+  }
+  resetDragState() {
+    this._dragStart.set(0, 0, 0), this._dragCurrent.set(0, 0, 0), this._dragEnd.set(0, 0, 0), this._dragDelta.set(0, 0, 0);
+  }
+}
+const ie = 1e-3;
+class de {
+  constructor(t, e) {
+    o(this, "_scene");
+    o(this, "_controller");
+    o(this, "_canvas");
+    // Tool management
+    o(this, "_tools");
+    o(this, "_activeTools", /* @__PURE__ */ new Map());
+    o(this, "_sortedActiveTools", []);
+    // Shared selection state
+    o(this, "_selectionState");
+    // Raycasting (shared, computed once per event)
+    o(this, "_raycaster");
+    o(this, "_pointer");
+    o(this, "_productLayerMask");
+    o(this, "_uiLayerMask");
+    // Pointer state
+    o(this, "_pointerPrimaryDown", !1);
+    o(this, "_pointerMiddleDown", !1);
+    o(this, "_pointerSecondaryDown", !1);
+    o(this, "_lastPointerDown");
+    // Bound event handlers (for cleanup)
+    o(this, "_boundPointerMove");
+    o(this, "_boundPointerDown");
+    o(this, "_boundPointerUp");
+    o(this, "_boundWheel");
+    this._scene = t, this._controller = e, this._canvas = e.domElement, this._selectionState = new Zt(), this._raycaster = new ot(), this._pointer = new F(), this._lastPointerDown = new F(), this._productLayerMask = new _t(), this._productLayerMask.set(Math.log2(G)), this._uiLayerMask = new _t(), this._uiLayerMask.set(Math.log2(W)), this._tools = /* @__PURE__ */ new Map([
+      [
+        "hover",
+        new Gt()
+      ],
+      [
+        "select",
+        new Wt(this._selectionState)
+      ],
+      [
+        "transform",
+        new Jt(t, e, this._selectionState)
+      ],
+      [
+        "drag",
+        new ee(e)
+      ]
+    ]), this._boundPointerMove = this.onPointerMove.bind(this), this._boundPointerDown = this.onPointerDown.bind(this), this._boundPointerUp = this.onPointerUp.bind(this), this._boundWheel = this.onWheel.bind(this), this._canvas.addEventListener("pointermove", this._boundPointerMove), this._canvas.addEventListener("pointerdown", this._boundPointerDown), this._canvas.addEventListener("pointerup", this._boundPointerUp), this._canvas.addEventListener("wheel", this._boundWheel);
+  }
+  get selectionState() {
+    return this._selectionState;
+  }
+  /**
+   * Enable a tool by type.
+   */
+  enableTool(t) {
+    var i;
+    const e = this._tools.get(t);
+    e && (this._activeTools.has(t) || (this._activeTools.set(t, e), this.updateSortedTools(), (i = e.onActivate) == null || i.call(e)));
+  }
+  /**
+   * Disable an active tool by type.
+   */
+  disableTool(t) {
+    var i;
+    const e = this._activeTools.get(t);
+    e && ((i = e.onDeactivate) == null || i.call(e), this._activeTools.delete(t), this.updateSortedTools());
+  }
+  /**
+   * Check if a tool is currently enabled.
+   */
+  isToolEnabled(t) {
+    return this._activeTools.has(t);
+  }
+  /**
+   * Get a tool by type.
+   */
+  getTool(t) {
+    return this._tools.get(t);
+  }
+  /**
+   * Get all currently active tools.
+   */
+  getActiveTools() {
+    return [...this._sortedActiveTools];
+  }
+  /**
+   * Dispose of the toolbox and clean up resources.
+   */
+  dispose() {
+    var t;
+    for (const e of this._activeTools.values())
+      (t = e.onDeactivate) == null || t.call(e);
+    this._activeTools.clear(), this._tools.clear(), this._sortedActiveTools = [], this._canvas.removeEventListener("pointermove", this._boundPointerMove), this._canvas.removeEventListener("pointerdown", this._boundPointerDown), this._canvas.removeEventListener("pointerup", this._boundPointerUp), this._canvas.removeEventListener("wheel", this._boundWheel), this._selectionState.dispose();
+  }
+  // ============ Event Handlers ============
+  onPointerMove(t) {
+    var i;
+    this.updatePointer(t);
+    const e = this.createPointerContext(t);
+    for (const n of this._sortedActiveTools)
+      if ((i = n.onPointerMove) == null ? void 0 : i.call(n, e)) break;
+  }
+  onPointerDown(t) {
+    var i;
+    this.updatePointerState(t, !0), this.updatePointer(t), this._lastPointerDown.copy(this._pointer);
+    const e = this.createPointerContext(t);
+    for (const n of this._sortedActiveTools)
+      if ((i = n.onPointerDown) == null ? void 0 : i.call(n, e)) break;
+  }
+  onPointerUp(t) {
+    var n, a;
+    this.updatePointer(t);
+    const e = this.createPointerContext(t), i = !this.pointerWasDragged();
+    for (const s of this._sortedActiveTools)
+      if ((n = s.onPointerUp) == null ? void 0 : n.call(s, e)) break;
+    if (i) {
+      for (const s of this._sortedActiveTools)
+        if ((a = s.onClick) == null ? void 0 : a.call(s, e)) break;
+    }
+    this.updatePointerState(t, !1);
+  }
+  onWheel(t) {
+    var i;
+    const e = this.createWheelContext(t);
+    for (const n of this._sortedActiveTools)
+      if ((i = n.onWheel) == null ? void 0 : i.call(n, e)) break;
+  }
+  // ============ Context Creation ============
+  createPointerContext(t) {
+    const e = this.raycast();
+    return {
+      event: t,
+      pointer: this._pointer.clone(),
+      intersects: e,
+      modelIntersects: this.filterIntersectsByLayer(
+        e,
+        G
+      ),
+      uiIntersects: this.filterIntersectsByLayer(
+        e,
+        W
+      ),
+      pointerPrimaryDown: this._pointerPrimaryDown,
+      pointerMiddleDown: this._pointerMiddleDown,
+      pointerSecondaryDown: this._pointerSecondaryDown,
+      lastPointerDown: this._lastPointerDown.clone()
+    };
+  }
+  createWheelContext(t) {
+    const e = this.raycast();
+    return {
+      event: t,
+      pointer: this._pointer.clone(),
+      intersects: e,
+      modelIntersects: this.filterIntersectsByLayer(
+        e,
+        G
+      ),
+      uiIntersects: this.filterIntersectsByLayer(
+        e,
+        W
+      )
+    };
+  }
+  // ============ Helper Methods ============
+  updatePointer(t) {
+    this._pointer.x = t.offsetX / this._canvas.clientWidth * 2 - 1, this._pointer.y = -(t.offsetY / this._canvas.clientHeight) * 2 + 1, this._raycaster.setFromCamera(this._pointer, this._controller.object);
+  }
+  updatePointerState(t, e) {
+    switch (t.button) {
+      case 0:
+        this._pointerPrimaryDown = e;
+        break;
+      case 1:
+        this._pointerMiddleDown = e;
+        break;
+      case 2:
+        this._pointerSecondaryDown = e;
+        break;
+    }
+  }
+  raycast() {
+    this._raycaster.layers.mask = G | W;
+    const t = this._scene.children.filter(
+      (e) => e.visible && "isMesh" in e && e.isMesh
+    );
+    return this._raycaster.intersectObjects(t, !0);
+  }
+  filterIntersectsByLayer(t, e) {
+    return t.filter(
+      (i) => (i.object.layers.mask & e) !== 0
+    );
+  }
+  updateSortedTools() {
+    this._sortedActiveTools = [...this._activeTools.values()].sort(
+      (t, e) => t.priority - e.priority
+    );
+  }
+  pointerWasDragged() {
+    return this._lastPointerDown.distanceTo(this._pointer) > ie;
+  }
+  // ============ Legacy API Compatibility ============
+  /**
+   * @deprecated Use enableTool/disableTool instead.
+   * Enable or disable a tool by type.
+   */
+  useTool(t) {
+    const e = [
+      "hover",
+      "select",
+      "transform",
+      "drag"
+    ];
+    for (const i of e)
+      (i === t || t === "select") && this.enableTool(i);
+  }
+  /**
+   * @deprecated Use getActiveTools instead.
+   * Get the first active tool (for legacy compatibility).
+   */
   getActiveTool() {
-    return this._activeTool;
+    return this._sortedActiveTools[0] || null;
+  }
+}
+class pe {
+  constructor(t, e) {
+    o(this, "POINTER_DRAG_THRESHOLD", 1e-3);
+    o(this, "name");
+    o(this, "_canvas");
+    o(this, "_scene");
+    o(this, "_controller");
+    // general pointer members
+    o(this, "_pointer");
+    o(this, "_pointerPrimaryDown");
+    o(this, "_pointerMiddleDown");
+    o(this, "_pointerSecondaryDown");
+    o(this, "_lastPointerDown");
+    o(this, "_lastPointerUp");
+    // raycast members
+    o(this, "_raycaster");
+    o(this, "_intersects");
+    // hovering members
+    o(this, "_hovered");
+    // dragging members
+    o(this, "_dragging");
+    o(this, "_dragStart");
+    o(this, "_dragCurrent");
+    o(this, "_dragEnd");
+    o(this, "_dragDelta");
+    o(this, "_draggable");
+    o(this, "_dragRaycastOnObjects");
+    this.name = "BaseTool", this._canvas = e.domElement, this._scene = t, this._controller = e, this._pointer = new F(), this._pointerPrimaryDown = !1, this._pointerMiddleDown = !1, this._pointerSecondaryDown = !1, this._lastPointerDown = new F(), this._lastPointerUp = new F(), this._raycaster = new ot(), this._raycaster.layers.mask = G | W, this._intersects = [], this._hovered = null, this._dragging = !1, this._dragStart = new l(), this._dragCurrent = new l(), this._dragEnd = new l(), this._dragDelta = new l(), this._draggable = null, this._dragRaycastOnObjects = null;
   }
-  useTool(e) {
-    var o;
-    switch ((o = this._activeTool) == null || o.deactivate(), e) {
-      case "select": {
-        this.addEventListeners(), this.selectTool.activate(), this._activeTool = this.selectTool;
+  get _pointerAnyDown() {
+    return this._pointerPrimaryDown || this._pointerMiddleDown || this._pointerSecondaryDown;
+  }
+  activate() {
+  }
+  deactivate() {
+  }
+  onPointerDown(t) {
+    var e;
+    switch (t.button) {
+      case 0: {
+        this._pointerPrimaryDown = !0;
+        break;
+      }
+      case 1: {
+        this._pointerMiddleDown = !0;
         break;
       }
-      case "none": {
-        this.removeEventListeners(), this._activeTool = null;
+      case 2: {
+        this._pointerSecondaryDown = !0;
         break;
       }
       default:
-        console.warn(`DIVEToolBox.useTool: Unknown tool: ${e}`);
-    }
-  }
-  setGizmoMode(e) {
-    this.selectTool.setGizmoMode(e);
-  }
-  setGizmoVisible(e) {
-    this.selectTool.setGizmoVisible(e);
-  }
-  setGizmoScaleLinked(e) {
-    this.selectTool.setGizmoScaleLinked(e);
-  }
-  onPointerMove(e) {
-    var o;
-    (o = this._activeTool) == null || o.onPointerMove(e);
-  }
-  onPointerDown(e) {
-    var o;
-    (o = this._activeTool) == null || o.onPointerDown(e);
-  }
-  onPointerUp(e) {
-    var o;
-    (o = this._activeTool) == null || o.onPointerUp(e);
-  }
-  onWheel(e) {
-    var o;
-    (o = this._activeTool) == null || o.onWheel(e);
-  }
-  addEventListeners() {
-    this._controller.domElement.addEventListener(
-      "pointermove",
-      (e) => this.onPointerMove(e)
-    ), this._controller.domElement.addEventListener(
-      "pointerdown",
-      (e) => this.onPointerDown(e)
-    ), this._controller.domElement.addEventListener(
-      "pointerup",
-      (e) => this.onPointerUp(e)
-    ), this._controller.domElement.addEventListener(
-      "wheel",
-      (e) => this.onWheel(e)
+        console.warn(
+          "DIVEBaseTool.onPointerDown: Unknown button: " + t.button
+        );
+    }
+    this._lastPointerDown.copy(this._pointer), this._draggable = B(
+      (e = this._intersects[0]) == null ? void 0 : e.object,
+      "isDraggable"
+    ) || null;
+  }
+  onDragStart(t) {
+    this._draggable && (this._dragRaycastOnObjects !== null && (this._intersects = this._raycaster.intersectObjects(
+      this._dragRaycastOnObjects,
+      !0
+    )), this._intersects.length !== 0 && (this._dragStart.copy(this._intersects[0].point.clone()), this._dragCurrent.copy(this._intersects[0].point.clone()), this._dragEnd.copy(this._dragStart.clone()), this._dragDelta.set(0, 0, 0), this._draggable && this._draggable.onDragStart && (this._draggable.onDragStart({
+      dragStart: this._dragStart,
+      dragCurrent: this._dragCurrent,
+      dragEnd: this._dragEnd,
+      dragDelta: this._dragDelta
+    }), this._dragging = !0, this._controller.enabled = !1)));
+  }
+  onPointerMove(t) {
+    var i;
+    this._pointer.x = t.offsetX / this._canvas.clientWidth * 2 - 1, this._pointer.y = -(t.offsetY / this._canvas.clientHeight) * 2 + 1, this._raycaster.setFromCamera(this._pointer, this._controller.object), this._intersects = this.raycast(this._scene.children);
+    const e = B(
+      (i = this._intersects[0]) == null ? void 0 : i.object,
+      "isHoverable"
     );
+    if (this._intersects[0] && e) {
+      if (!this._hovered) {
+        e.onPointerEnter && e.onPointerEnter(this._intersects[0]), this._hovered = e;
+        return;
+      }
+      if (this._hovered.uuid !== e.uuid) {
+        this._hovered.onPointerLeave && this._hovered.onPointerLeave(), e.onPointerEnter && e.onPointerEnter(this._intersects[0]), this._hovered = e;
+        return;
+      }
+      e.onPointerOver && e.onPointerOver(this._intersects[0]), this._hovered = e;
+    } else
+      this._hovered && this._hovered.onPointerLeave && this._hovered.onPointerLeave(), this._hovered = null;
+    this._pointerAnyDown && (this._dragging || this.onDragStart(t), this.onDrag(t));
   }
-  removeEventListeners() {
-    this._controller.domElement.removeEventListener(
-      "pointermove",
-      (e) => this.onPointerMove(e)
-    ), this._controller.domElement.removeEventListener(
-      "pointerdown",
-      (e) => this.onPointerDown(e)
-    ), this._controller.domElement.removeEventListener(
-      "pointerup",
-      (e) => this.onPointerUp(e)
-    ), this._controller.domElement.removeEventListener(
-      "wheel",
-      (e) => this.onWheel(e)
+  onDrag(t) {
+    this._dragRaycastOnObjects !== null && (this._intersects = this._raycaster.intersectObjects(
+      this._dragRaycastOnObjects,
+      !0
+    ));
+    const e = this._intersects[0];
+    e && (this._dragCurrent.copy(e.point.clone()), this._dragEnd.copy(e.point.clone()), this._dragDelta.subVectors(
+      this._dragCurrent.clone(),
+      this._dragStart.clone()
+    ), this._draggable && this._draggable.onDrag && this._draggable.onDrag({
+      dragStart: this._dragStart,
+      dragCurrent: this._dragCurrent,
+      dragEnd: this._dragEnd,
+      dragDelta: this._dragDelta
+    }));
+  }
+  onPointerUp(t) {
+    switch (this.pointerWasDragged() || this._dragging ? this._draggable && this.onDragEnd(t) : this.onClick(t), t.button) {
+      case 0:
+        this._pointerPrimaryDown = !1;
+        break;
+      case 1:
+        this._pointerMiddleDown = !1;
+        break;
+      case 2:
+        this._pointerSecondaryDown = !1;
+        break;
+    }
+    this._lastPointerUp.copy(this._pointer);
+  }
+  onClick(t) {
+  }
+  onDragEnd(t) {
+    const e = this._intersects[0];
+    e && (this._dragEnd.copy(e.point.clone()), this._dragCurrent.copy(e.point.clone()), this._dragDelta.subVectors(
+      this._dragCurrent.clone(),
+      this._dragStart.clone()
+    )), this._draggable && this._draggable.onDragEnd && this._draggable.onDragEnd({
+      dragStart: this._dragStart,
+      dragCurrent: this._dragCurrent,
+      dragEnd: this._dragEnd,
+      dragDelta: this._dragDelta
+    }), this._draggable = null, this._dragging = !1, this._dragStart.set(0, 0, 0), this._dragCurrent.set(0, 0, 0), this._dragEnd.set(0, 0, 0), this._dragDelta.set(0, 0, 0), this._controller.enabled = !0;
+  }
+  onWheel(t) {
+  }
+  raycast(t) {
+    const i = (t || this._scene.children).filter(
+      (n) => n.visible && "isMesh" in n && n.isMesh
     );
+    return this._raycaster.intersectObjects(i, !0);
+  }
+  pointerWasDragged() {
+    return this._lastPointerDown.distanceTo(this._pointer) > this.POINTER_DRAG_THRESHOLD;
   }
 }
-n(r, "DefaultTool", "select");
 export {
-  m as DIVEBaseTool,
-  l as DIVESelectTool,
-  T as DIVETransformTool,
-  r as Toolbox,
-  d as isSelectTool,
-  _ as isTransformTool
+  pe as DIVEBaseTool,
+  Wt as DIVESelectTool,
+  Jt as DIVETransformTool,
+  ee as DragTool,
+  Gt as HoverTool,
+  Wt as SelectTool,
+  Zt as SelectionState,
+  de as Toolbox,
+  Jt as TransformTool,
+  he as isSelectTool,
+  ce as isTransformTool
 };