@realsee/dnalogel 2.1.2-alpha.1 → 2.1.2-alpha.10

package/dist/Object3DHelperPlugin/index..js

@@ -0,0 +1,1414 @@
+var de = Object.defineProperty;
+var ie = Object.getOwnPropertySymbols;
+var ue = Object.prototype.hasOwnProperty, fe = Object.prototype.propertyIsEnumerable;
+var Q = (o, s, e) => s in o ? de(o, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[s] = e, v = (o, s) => {
+  for (var e in s || (s = {}))
+    ue.call(s, e) && Q(o, e, s[e]);
+  if (ie)
+    for (var e of ie(s))
+      fe.call(s, e) && Q(o, e, s[e]);
+  return o;
+};
+var l = (o, s, e) => (Q(o, typeof s != "symbol" ? s + "" : s, e), e);
+var R = (o, s, e) => new Promise((t, n) => {
+  var r = (c) => {
+    try {
+      a(e.next(c));
+    } catch (p) {
+      n(p);
+    }
+  }, i = (c) => {
+    try {
+      a(e.throw(c));
+    } catch (p) {
+      n(p);
+    }
+  }, a = (c) => c.done ? t(c.value) : Promise.resolve(c.value).then(r, i);
+  a((e = e.apply(o, s)).next());
+});
+import { Controller as ge } from "../chunks/es/BasePlugin.813e25f7.es.js";
+import * as h from "three";
+import { Object3D as be, Vector3 as y } from "three";
+import { CSS3DObject as ye } from "three/examples/jsm/renderers/CSS3DRenderer";
+import { CSS3DRender as me, CSS3DObjectPlus as ve } from "../chunks/es/CSS3DRender.5652510e.es.js";
+import { Subscribe as ae } from "../chunks/es/Subscribe.c73e0f91.es.js";
+import { notNil as we } from "../chunks/es/isNil.212842d9.es.js";
+class W extends be {
+  constructor(e, t) {
+    var n;
+    super();
+    l(this, "originObject3D");
+    l(this, "onRender");
+    this.originObject3D = e, this.onRender = (n = t == null ? void 0 : t.onRender) != null ? n : () => {
+    };
+  }
+  get helperObject() {
+    return this;
+  }
+  render() {
+    this.onRender();
+  }
+  show() {
+    this.visible = !0, this.render();
+  }
+  hide() {
+    this.visible = !1, this.render();
+  }
+  updatePosition() {
+    this.position.copy(this.originObject3D.position);
+  }
+  updateQuaternion() {
+    this.quaternion.copy(this.originObject3D.quaternion);
+  }
+  applyHelperScaleMatrix4(e, t) {
+    this.scale.applyMatrix4(e);
+  }
+  applyHelperQuaternion(e, t) {
+    this.applyQuaternion(e);
+  }
+}
+class xe extends W {
+}
+class De extends W {
+}
+class Ce extends W {
+}
+class Ee extends Ce {
+}
+class je extends h.Group {
+  constructor(e) {
+    super();
+    l(this, "direction");
+    this.direction = e || "x";
+  }
+}
+class re extends h.Mesh {
+  constructor(e, t, n) {
+    super(e, t);
+    l(this, "direction");
+    this.direction = n || "x";
+  }
+}
+function He(o, s) {
+  const { offsetWidth: e, offsetHeight: t } = s, { top: n, left: r } = s.getBoundingClientRect();
+  return Object.assign(new h.Vector2(), {
+    x: (o.x - r) / e * 2 - 1,
+    y: -(o.y - n) / t * 2 + 1
+  });
+}
+function Z(o, s, e) {
+  if (!s || !e || !o)
+    return;
+  const t = He(s, e);
+  if (Math.abs(t.x) === 1 || Math.abs(t.y) === 1)
+    return;
+  const n = new h.Raycaster();
+  return n.setFromCamera(t, o), n;
+}
+function Oe(o, s) {
+  return !(Math.abs(o.x - s.x) > 1e-5 || Math.abs(o.y - s.y) > 1e-5 || Math.abs(o.z - s.z) > 1e-5);
+}
+class G extends je {
+  constructor(e) {
+    var u;
+    super(e.direction);
+    l(this, "line");
+    l(this, "arrow");
+    l(this, "lineHeight", 0.4);
+    l(this, "arrowHeight", 0.1);
+    this.name = "ArrowGroup";
+    const t = new h.Color((u = e.color) != null ? u : 16214315), n = new h.MeshBasicMaterial({
+      color: t,
+      depthTest: !1,
+      opacity: 1,
+      transparent: !0,
+      side: h.DoubleSide
+    }), r = new h.ConeGeometry(0.04, 0.1, 32), i = new re(r, n.clone(), e.direction);
+    i.name = `arrow-${e.direction}`, this.arrow = i;
+    const a = 4e-3, c = new h.CylinderGeometry(a, a, 0.4, 32), p = new re(c, n.clone(), e.direction);
+    p.name = `line-${e.direction}`, this.line = p, this.formatArrow(), this.formatLine(), this.add(this.arrow, this.line);
+  }
+  formatArrow() {
+    this.arrow.geometry.translate(0, this.lineHeight + this.arrowHeight / 2, 0), this.direction === "x" ? (this.arrow.geometry.rotateX(Math.PI / 2), this.arrow.geometry.rotateY(Math.PI / 2)) : this.direction === "z" && this.arrow.geometry.rotateX(Math.PI / 2);
+  }
+  formatLine() {
+    this.line.geometry.translate(0, this.lineHeight / 2, 0), this.direction === "x" ? (this.line.geometry.rotateX(Math.PI / 2), this.line.geometry.rotateY(Math.PI / 2)) : this.direction === "z" && this.line.geometry.rotateX(Math.PI / 2);
+  }
+}
+const F = {
+  X: 15618642,
+  Y: 4765519,
+  Z: 4227839
+};
+class j {
+  static get X() {
+    return new h.Color(F.X).convertSRGBToLinear().clone();
+  }
+  static get Y() {
+    return new h.Color(F.Y).convertSRGBToLinear().clone();
+  }
+  static get Z() {
+    return new h.Color(F.Z).convertSRGBToLinear().clone();
+  }
+}
+class _e extends xe {
+  constructor(e) {
+    super(e);
+    l(this, "xArrow", new G({ direction: "x", color: j.X }));
+    l(this, "yArrow", new G({ direction: "y", color: j.Y }));
+    l(this, "zArrow", new G({ direction: "z", color: j.Z }));
+    this.add(this.xArrow), this.add(this.yArrow), this.add(this.zArrow);
+  }
+  show() {
+    super.show(), this.xArrow.visible = !0, this.yArrow.visible = !0, this.zArrow.visible = !0;
+  }
+  showDraggingHelper(e) {
+    this.xArrow.visible = e.includes("x"), this.yArrow.visible = e.includes("y"), this.zArrow.visible = e.includes("z");
+  }
+  dispose() {
+    this.remove(this.xArrow, this.yArrow, this.zArrow);
+  }
+}
+function A(o, s) {
+  return Me(document.createElement(s != null ? s : "div"), o);
+}
+function Me(o, s) {
+  if (!s)
+    return o;
+  for (const e in s)
+    e && s[e] && (o.style[e] = s[e]);
+  return o;
+}
+function Se(o) {
+  const s = A(v({
+    position: "absolute",
+    display: "block",
+    borderRadius: "4px",
+    paddingTop: "1px",
+    paddingBottom: "1px",
+    paddingLeft: "4px",
+    paddingRight: "4px",
+    pointerEvents: "none",
+    userSelect: "none",
+    zIndex: "9999",
+    backgroundColor: "rgba(0,0,0,0.7)",
+    fontSize: "12px",
+    color: "#fff",
+    letterSpacing: "0",
+    lineHeight: "18px"
+  }, o)), e = () => {
+    s.style.display !== "block" && (!s.style.top || !s.style.left || (s.style.display = "block"));
+  };
+  return { element: s, show: e, hide: () => {
+    s.style.display = "none", s.style.top = "", s.style.left = "";
+  }, setLeftTop: (r, i) => {
+    s.style.left = r, s.style.top = i, e();
+  } };
+}
+class Ie extends De {
+  constructor(e, t) {
+    var n;
+    super(e);
+    l(this, "yzCircle", new q({ direction: "x", color: j.X }));
+    l(this, "xzCircle", new q({ direction: "y", color: j.Y }));
+    l(this, "xyCircle", new q({ direction: "z", color: j.Z }));
+    l(this, "xRingHelper", new U({ direction: "x" }));
+    l(this, "yRingHelper", new U({ direction: "y" }));
+    l(this, "zRingHelper", new U({ direction: "z" }));
+    l(this, "xAngleHelper", new X({ direction: "x", color: j.X }));
+    l(this, "yAngleHelper", new X({ direction: "y", color: j.Y }));
+    l(this, "zAngleHelper", new X({ direction: "z", color: j.Z }));
+    l(this, "angleTips");
+    l(this, "container");
+    t && (this.container = t == null ? void 0 : t.container, this.angleTips = Se({ display: "none" }), (n = this.container) == null || n.appendChild(this.angleTips.element)), this.show();
+  }
+  updateAngleHelperQuaternion() {
+    this.xAngleHelper.quaternion.copy(this.yzCircle.quaternion), this.yAngleHelper.quaternion.copy(this.xzCircle.quaternion), this.zAngleHelper.quaternion.copy(this.xyCircle.quaternion), this.xRingHelper.quaternion.copy(this.yzCircle.quaternion), this.yRingHelper.quaternion.copy(this.xzCircle.quaternion), this.zRingHelper.quaternion.copy(this.xyCircle.quaternion);
+  }
+  applyHelperQuaternion(e, t) {
+    this.yzCircle.applyQuaternion(e), this.xzCircle.applyQuaternion(e), this.xyCircle.applyQuaternion(e), this.xAngleHelper.baseAxes.applyQuaternion(e), this.yAngleHelper.baseAxes.applyQuaternion(e), this.zAngleHelper.baseAxes.applyQuaternion(e);
+  }
+  hide() {
+    this.remove(
+      this.yzCircle,
+      this.xzCircle,
+      this.xyCircle,
+      this.xRingHelper,
+      this.yRingHelper,
+      this.zRingHelper,
+      this.xAngleHelper,
+      this.yAngleHelper,
+      this.zAngleHelper
+    );
+  }
+  show() {
+    var e;
+    this.add(this.xyCircle, this.xzCircle, this.yzCircle), this.remove(this.xRingHelper, this.yRingHelper, this.zRingHelper, this.xAngleHelper, this.yAngleHelper, this.zAngleHelper), (e = this.angleTips) == null || e.hide();
+  }
+  showDraggingHelper(e) {
+    var t;
+    this.hide(), this.add(...this.filterRingHelper(e)), this.add(...this.filterAngleHelper(e)), (t = this.angleTips) == null || t.show();
+  }
+  dispose() {
+    var e, t;
+    this.remove(
+      this.yzCircle,
+      this.xzCircle,
+      this.xyCircle,
+      this.xRingHelper,
+      this.yRingHelper,
+      this.zRingHelper,
+      this.xAngleHelper,
+      this.yAngleHelper,
+      this.zAngleHelper
+    ), (e = this.angleTips) != null && e.element && ((t = this.container) == null || t.removeChild(this.angleTips.element));
+  }
+  filterRingHelper(e) {
+    return [this.xRingHelper, this.yRingHelper, this.zRingHelper].filter((t) => e.includes(t.direction));
+  }
+  filterAngleHelper(e) {
+    return [this.xAngleHelper, this.yAngleHelper, this.zAngleHelper].filter((t) => e.includes(t.direction));
+  }
+}
+class q extends h.Mesh {
+  constructor(e) {
+    var t;
+    super();
+    l(this, "direction");
+    l(this, "gapAngle", 0.02);
+    l(this, "geometry", new h.RingGeometry(0.25, 0.3, 20, 8, this.gapAngle, Math.PI / 2 - this.gapAngle * 2));
+    this.material = new h.MeshBasicMaterial({
+      opacity: 0.6,
+      color: (t = e.color) != null ? t : 16777215,
+      transparent: !0,
+      side: h.DoubleSide,
+      depthTest: !1
+    }), this.direction = e.direction, this.geometry.name = `RotateHelperCircleGeometry-${this.direction}`, this.direction === "y" ? this.rotateX(Math.PI / 2) : this.direction === "x" && this.rotateY(-Math.PI / 2);
+  }
+}
+class U extends h.Group {
+  constructor(e) {
+    super();
+    l(this, "direction");
+    this.direction = e.direction;
+    const t = 0.015, n = new Array(8).fill(null).map((r, i) => {
+      const a = new h.RingGeometry(0.25, 0.3, 20, 8, Math.PI / 4 * i + t, Math.PI / 4 - t * 2), c = new h.MeshBasicMaterial({
+        opacity: 1,
+        color: 16777215,
+        depthTest: !1,
+        transparent: !0,
+        side: h.DoubleSide
+      }), p = new h.Mesh(a, c);
+      return p.name = `AxesDashedRing-${this.direction}-${i}`, p;
+    });
+    this.add(...n), this.direction === "y" ? this.rotateX(Math.PI / 2) : this.direction === "x" && this.rotateY(-Math.PI / 2);
+  }
+}
+class X extends h.Mesh {
+  constructor(e) {
+    var n;
+    super();
+    l(this, "direction");
+    l(this, "baseAxes");
+    switch (e.direction) {
+      case "x":
+        this.baseAxes = new h.Vector3(0, 0, 1);
+        break;
+      case "y":
+        this.baseAxes = new h.Vector3(1, 0, 0);
+        break;
+      case "z":
+        this.baseAxes = new h.Vector3(1, 0, 0);
+        break;
+    }
+    const t = 0.3 + 5e-4;
+    this.geometry = new h.CircleGeometry(t, 48, 0, 1e-4), this.material = new h.MeshBasicMaterial({
+      opacity: 0.4,
+      color: (n = e.color) != null ? n : 16777215,
+      depthTest: !1,
+      transparent: !0,
+      side: h.DoubleSide
+    }), this.direction = e.direction, this.direction === "y" ? this.rotateX(Math.PI / 2) : this.direction === "x" && this.rotateY(-Math.PI / 2);
+  }
+}
+function Pe() {
+  const o = A({
+    width: "100%",
+    height: "100%",
+    left: "0",
+    top: "0",
+    position: "absolute",
+    pointerEvents: "none"
+  }), s = A({
+    boxSizing: "border-box",
+    width: "100%",
+    height: "100%",
+    left: "0",
+    top: "0",
+    position: "relative",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center"
+  }), e = A({
+    boxSizing: "border-box",
+    width: "100%",
+    height: "100%",
+    left: "0",
+    top: "0",
+    position: "absolute",
+    border: "1px solid rgba(255,255,255,0.4)"
+  });
+  o.appendChild(s), s.appendChild(e);
+  const t = "-4px", n = { direction: "nesw", element: O({ cursor: "nesw-resize", left: t, bottom: t }) }, r = { direction: "ns", element: O({ cursor: "ns-resize", bottom: t }) }, i = { direction: "nwse", element: O({ cursor: "nwse-resize", right: t, bottom: t }) }, a = { direction: "ew", element: O({ cursor: "ew-resize", right: t }) }, c = { direction: "nesw", element: O({ cursor: "nesw-resize", right: t, top: t }) }, p = { direction: "ns", element: O({ cursor: "ns-resize", top: t }) }, u = { direction: "nwse", element: O({ cursor: "nwse-resize", left: t, top: t }) }, g = { direction: "ew", element: O({ cursor: "ew-resize", left: t }) };
+  return new Array(r, a, p, g, n, i, c, u).forEach((m) => s.appendChild(m.element)), { container: o, squares: [
+    n,
+    r,
+    i,
+    a,
+    c,
+    p,
+    u,
+    g
+  ] };
+}
+function O(o) {
+  const s = A(v({
+    background: "#FFFFFF",
+    width: "9px",
+    height: "9px",
+    position: "absolute",
+    pointerEvents: "none"
+  }, o)), e = A({
+    width: "15px",
+    height: "15px",
+    position: "absolute",
+    left: "50%",
+    top: "50%",
+    transform: "translate(-50%, -50%)",
+    pointerEvents: "none"
+  }), t = A({
+    width: "15px",
+    height: "15px",
+    cursor: o == null ? void 0 : o.cursor,
+    pointerEvents: "auto",
+    background: "transparent"
+  });
+  return t.draggable = !0, e.appendChild(t), s.appendChild(e), s;
+}
+class Ae extends Ee {
+  constructor(e, t, n, r) {
+    super(e);
+    l(this, "points", []);
+    l(this, "cornerPositions", []);
+    l(this, "css3DInstance");
+    l(this, "plane");
+    l(this, "css3DRenderer", new me());
+    l(this, "camera");
+    l(this, "scene");
+    l(this, "container");
+    l(this, "enabled", !1);
+    this.camera = n, this.scene = r, this.container = t, this.initRectangleScaleHelper();
+  }
+  get helperObject() {
+    var e;
+    if (!((e = this.css3DInstance) != null && e.css3DObject))
+      throw new Error("css3DInstance is not initialized");
+    return this.css3DInstance.css3DObject;
+  }
+  updatePosition() {
+    var e;
+    this.helperObject.position.copy(this.originObject3D.position), (e = this.plane) == null || e.position.copy(this.originObject3D.position);
+  }
+  updateQuaternion() {
+    var e;
+    (e = this.plane) == null || e.quaternion.copy(this.originObject3D.quaternion);
+  }
+  applyMatrix4(e) {
+    var t;
+    super.applyMatrix4(e), this.helperObject.applyMatrix4(e), (t = this.plane) == null || t.applyMatrix4(e), this.cornerPositions.forEach((n) => n.applyMatrix4(e));
+  }
+  showDraggingHelper() {
+  }
+  applyHelperScaleMatrix4(e, t) {
+    var n;
+    (n = this.plane) == null || n.scale.applyMatrix4(e), this.helperObject.applyScaleMatrix4(e);
+  }
+  updatePoints() {
+    const e = this.calculatePointPosition(this.cornerPositions);
+    this.points.forEach((t, n) => {
+      t.position.copy(e[n]);
+    });
+  }
+  applyHelperQuaternion(e, t) {
+    var r;
+    const n = (r = this.css3DInstance) == null ? void 0 : r.css3DObject;
+    if (n) {
+      const i = new h.Vector3().subVectors(n.position, t).applyQuaternion(e).add(t);
+      n.position.copy(i), n.applyQuaternion(e);
+    }
+    if (this.plane) {
+      const i = new h.Vector3().subVectors(this.plane.position, t).applyQuaternion(e).add(t);
+      this.plane.position.copy(i), this.plane.applyQuaternion(e);
+    }
+    this.cornerPositions.forEach((i) => {
+      const a = new h.Vector3().subVectors(i, t).applyQuaternion(e).add(t);
+      i.copy(a);
+    });
+  }
+  enable() {
+    var e;
+    this.enabled || (this.enabled = !0, (e = this.css3DInstance) == null || e.enable(), this.plane && this.scene.add(this.plane));
+  }
+  disable() {
+    var e;
+    !this.enabled || (this.enabled = !1, (e = this.css3DInstance) == null || e.disable(), this.plane && this.scene.remove(this.plane));
+  }
+  show() {
+    var e;
+    (e = this.css3DInstance) == null || e.show(), this.plane && (this.plane.visible = !0);
+  }
+  hide() {
+    var e;
+    (e = this.css3DInstance) == null || e.hide(), this.plane && (this.plane.visible = !1);
+  }
+  dispose() {
+    this.disable(), this.css3DRenderer.dispose();
+  }
+  initRectangleScaleHelper() {
+    var u;
+    const e = this.getCornerPositions();
+    if (!e)
+      return;
+    this.cornerPositions = e;
+    const t = this.css3DRenderer.create3DElement(this.camera, e, { ratio: 3e-3 });
+    if (!t)
+      return;
+    this.css3DInstance = t, t.appendToElement(this.container);
+    const n = t.css3DObject.container, { container: r, squares: i } = Pe();
+    this.points = i.map((g, d) => ({
+      direction: g.direction,
+      point: g.element,
+      position: this.calculatePointPosition(e)[d]
+    })), n.insertBefore(r, (u = n.children[0]) != null ? u : null);
+    const a = new h.PlaneGeometry(t.css3DObject.width, t.css3DObject.height), c = new h.MeshBasicMaterial({
+      color: 0,
+      opacity: 0.15,
+      transparent: !0,
+      side: h.DoubleSide
+    }), p = new h.Mesh(a, c);
+    this.scene.add(p), this.updatePosition();
+  }
+  getCornerPositions() {
+    const { originObject3D: e } = this;
+    if (e instanceof ye) {
+      if (e.isCSS3DObjectPlus)
+        return e.cornerPoints;
+      console.error("\u6682\u65F6\u53EA\u652F\u6301 CSS3DRenderPlugin \u751F\u6210\u7684\u7269\u4F53");
+    } else
+      console.error("\u5F53\u524D\u7269\u4F53\u6682\u65F6\u4E0D\u652F\u6301 ScaleHelper");
+  }
+  calculatePointPosition(e) {
+    return [
+      e[0].clone(),
+      e[0].clone().add(e[1]).divideScalar(2),
+      e[1].clone(),
+      e[1].clone().add(e[2]).divideScalar(2),
+      e[2].clone(),
+      e[2].clone().add(e[3]).divideScalar(2),
+      e[3].clone(),
+      e[3].clone().add(e[0]).divideScalar(2)
+    ];
+  }
+}
+new h.Vector3();
+function f(o, s) {
+  this._camera = o || null, this._domElement = s || document, this._raycaster = new h.Raycaster(), this._selected = null, this._boundObjs = {};
+  var e = this;
+  this._$onClick = function() {
+    e._onClick.apply(e, arguments);
+  }, this._$onDblClick = function() {
+    e._onDblClick.apply(e, arguments);
+  }, this._$onMouseMove = function() {
+    e._onMouseMove.apply(e, arguments);
+  }, this._$onMouseDown = function() {
+    e._onMouseDown.apply(e, arguments);
+  }, this._$onMouseUp = function() {
+    e._onMouseUp.apply(e, arguments);
+  }, this._$onTouchMove = function() {
+    e._onTouchMove.apply(e, arguments);
+  }, this._$onTouchStart = function() {
+    e._onTouchStart.apply(e, arguments);
+  }, this._$onTouchEnd = function() {
+    e._onTouchEnd.apply(e, arguments);
+  }, this._$onContextmenu = function() {
+    e._onContextmenu.apply(e, arguments);
+  }, this._domElement.addEventListener("click", this._$onClick, !1), this._domElement.addEventListener("dblclick", this._$onDblClick, !1), this._domElement.addEventListener("mousemove", this._$onMouseMove, !1), this._domElement.addEventListener("mousedown", this._$onMouseDown, !1), this._domElement.addEventListener("mouseup", this._$onMouseUp, !1), this._domElement.addEventListener("touchmove", this._$onTouchMove, !1), this._domElement.addEventListener("touchstart", this._$onTouchStart, !1), this._domElement.addEventListener("touchend", this._$onTouchEnd, !1), this._domElement.addEventListener("contextmenu", this._$onContextmenu, !1);
+}
+f.prototype.destroy = function() {
+  this._domElement.removeEventListener("click", this._$onClick, !1), this._domElement.removeEventListener("dblclick", this._$onDblClick, !1), this._domElement.removeEventListener("mousemove", this._$onMouseMove, !1), this._domElement.removeEventListener("mousedown", this._$onMouseDown, !1), this._domElement.removeEventListener("mouseup", this._$onMouseUp, !1), this._domElement.removeEventListener("touchmove", this._$onTouchMove, !1), this._domElement.removeEventListener("touchstart", this._$onTouchStart, !1), this._domElement.removeEventListener("touchend", this._$onTouchEnd, !1), this._domElement.removeEventListener("contextmenu", this._$onContextmenu, !1);
+};
+f.eventNames = [
+  "click",
+  "dblclick",
+  "mouseover",
+  "mouseout",
+  "mousemove",
+  "mousedown",
+  "mouseup",
+  "contextmenu",
+  "touchstart",
+  "touchend"
+];
+f.prototype._getRelativeMouseXY = function(o) {
+  var s = o.target || o.srcElement;
+  s.nodeType === 3 && (s = s.parentNode);
+  var e = { x: 0, y: 0 }, t = s, n = getComputedStyle(t, null);
+  e.y += parseInt(n.getPropertyValue("padding-top"), 10), e.x += parseInt(n.getPropertyValue("padding-left"), 10);
+  do
+    e.x += t.offsetLeft, e.y += t.offsetTop, n = getComputedStyle(t, null), e.x += parseInt(n.getPropertyValue("border-left-width"), 10), e.y += parseInt(n.getPropertyValue("border-top-width"), 10);
+  while (t = t.offsetParent);
+  var r = {
+    width: s === window ? window.innerWidth : s.offsetWidth,
+    height: s === window ? window.innerHeight : s.offsetHeight
+  };
+  return {
+    x: Number((o.pageX - e.x) / r.width) * 2 - 1,
+    y: -((o.pageY - e.y) / r.height) * 2 + 1
+  };
+};
+f.prototype._objectCtxInit = function(o) {
+  o._3xDomEvent = {};
+};
+f.prototype._objectCtxDeinit = function(o) {
+  delete o._3xDomEvent;
+};
+f.prototype._objectCtxIsInit = function(o) {
+  return !!o._3xDomEvent;
+};
+f.prototype._objectCtxGet = function(o) {
+  return o._3xDomEvent;
+};
+f.prototype.camera = function(o) {
+  return o && (this._camera = o), this._camera;
+};
+f.prototype.bind = function(o, s, e, t) {
+  console.assert(f.eventNames.indexOf(s) !== -1, "not available events:" + s), this._objectCtxIsInit(o) || this._objectCtxInit(o);
+  var n = this._objectCtxGet(o);
+  n[s + "Handlers"] || (n[s + "Handlers"] = []), n[s + "Handlers"].push({
+    callback: e,
+    useCapture: t
+  }), this._boundObjs[s] === void 0 && (this._boundObjs[s] = []), this._boundObjs[s].push(o);
+};
+f.prototype.addEventListener = f.prototype.bind;
+f.prototype.unbind = function(o, s, e, t) {
+  console.assert(f.eventNames.indexOf(s) !== -1, "not available events:" + s), this._objectCtxIsInit(o) || this._objectCtxInit(o);
+  var n = this._objectCtxGet(o);
+  n[s + "Handlers"] || (n[s + "Handlers"] = []);
+  for (var r = n[s + "Handlers"], i = 0; i < r.length; i++) {
+    var a = r[i];
+    if (e == a.callback && t == a.useCapture) {
+      r.splice(i, 1);
+      break;
+    }
+  }
+  var c = this._boundObjs[s].indexOf(o);
+  console.assert(c !== -1), this._boundObjs[s].splice(c, 1);
+};
+f.prototype.removeEventListener = f.prototype.unbind;
+f.prototype._bound = function(o, s) {
+  var e = this._objectCtxGet(s);
+  return e ? !!e[o + "Handlers"] : !1;
+};
+f.prototype._onMove = function(o, s, e, t) {
+  var n = this._boundObjs[o];
+  if (!(n === void 0 || n.length === 0)) {
+    var r = new h.Vector2();
+    r.set(s, e), this._raycaster.setFromCamera(r, this._camera);
+    var i = this._raycaster.intersectObjects(n), a = this._selected;
+    if (i.length > 0) {
+      var c, p, u, g = i[0], d = g.object;
+      this._selected = d, u = this._bound("mousemove", d), a != d && (c = this._bound("mouseover", d), p = a && this._bound("mouseout", a));
+    } else
+      p = a && this._bound("mouseout", a), this._selected = null;
+    u && this._notify("mousemove", d, t, g), c && this._notify("mouseover", d, t, g), p && this._notify("mouseout", a, t, g);
+  }
+};
+f.prototype._onEvent = function(o, s, e, t) {
+  var n = this._boundObjs[o];
+  if (!(n === void 0 || n.length === 0)) {
+    var r = new h.Vector2();
+    r.set(s, e), this._raycaster.setFromCamera(r, this._camera);
+    var i = this._raycaster.intersectObjects(n, !0);
+    if (i.length !== 0) {
+      for (var a = i[0], c = a.object, p = this._objectCtxGet(c), u = c.parent; typeof p == "undefined" && u; )
+        p = this._objectCtxGet(u), u = u.parent;
+      !p || this._notify(o, c, t, a);
+    }
+  }
+};
+f.prototype._notify = function(o, s, e, t) {
+  var n = this._objectCtxGet(s), r = n ? n[o + "Handlers"] : null;
+  if (console.assert(arguments.length === 4), !n || !r || r.length === 0) {
+    s.parent && this._notify(o, s.parent, e, t);
+    return;
+  }
+  for (var r = n[o + "Handlers"], i = 0; i < r.length; i++) {
+    var a = r[i], c = !0;
+    a.callback({
+      type: o,
+      target: s,
+      origDomEvent: e,
+      intersect: t,
+      stopPropagation: function() {
+        c = !1;
+      }
+    }), !!c && a.useCapture === !1 && s.parent && this._notify(o, s.parent, e, t);
+  }
+};
+f.prototype._onMouseDown = function(o) {
+  return this._onMouseEvent("mousedown", o);
+};
+f.prototype._onMouseUp = function(o) {
+  return this._onMouseEvent("mouseup", o);
+};
+f.prototype._onMouseEvent = function(o, s) {
+  var e = this._getRelativeMouseXY(s);
+  this._onEvent(o, e.x, e.y, s);
+};
+f.prototype._onMouseMove = function(o) {
+  var s = this._getRelativeMouseXY(o);
+  this._onMove("mousemove", s.x, s.y, o), this._onMove("mouseover", s.x, s.y, o), this._onMove("mouseout", s.x, s.y, o);
+};
+f.prototype._onClick = function(o) {
+  this._onMouseEvent("click", o);
+};
+f.prototype._onDblClick = function(o) {
+  this._onMouseEvent("dblclick", o);
+};
+f.prototype._onContextmenu = function(o) {
+  this._onMouseEvent("contextmenu", o);
+};
+f.prototype._onTouchStart = function(o) {
+  return this._onTouchEvent("touchstart", o);
+};
+f.prototype._onTouchEnd = function(o) {
+  return this._onTouchEvent("touchend", o);
+};
+f.prototype._onTouchMove = function(o) {
+  if (o.touches.length == 1) {
+    o.preventDefault();
+    var s = Number(o.touches[0].pageX / window.innerWidth) * 2 - 1, e = -(o.touches[0].pageY / window.innerHeight) * 2 + 1;
+    this._onMove("mousemove", s, e, o), this._onMove("mouseover", s, e, o), this._onMove("mouseout", s, e, o);
+  }
+};
+f.prototype._onTouchEvent = function(o, s) {
+  if (s.touches.length == 1) {
+    s.preventDefault();
+    var e = Number(s.touches[0].pageX / window.innerWidth) * 2 - 1, t = -(s.touches[0].pageY / window.innerHeight) * 2 + 1;
+    this._onEvent(o, e, t, s);
+  }
+};
+let P = null;
+class N {
+  constructor(s, e, t, n, r, i, a) {
+    l(this, "hooks", new ae());
+    l(this, "helperObject3D");
+    l(this, "originObject3D");
+    l(this, "camera");
+    l(this, "model");
+    l(this, "scene");
+    l(this, "container");
+    l(this, "domEvents");
+    l(this, "isDragging", !1);
+    l(this, "onRender");
+    l(this, "enabled", !1);
+    l(this, "onWantsTapGesture", (s) => {
+      if (this.getIntersectObject(s))
+        return !1;
+    });
+    this.camera = s, this.model = e, this.originObject3D = t, this.helperObject3D = n, this.container = r, this.scene = i, this.domEvents = new f(s, r), this.onRender = a != null ? a : () => {
+    }, this.initialHelperPosition(), this.initialHelperQuaternion(), this.enable();
+  }
+  initialHelperPosition() {
+    this.helperObject3D.updatePosition();
+  }
+  initialHelperQuaternion() {
+    this.helperObject3D.updateQuaternion();
+  }
+  enable() {
+    this.enabled || (this.enabled = !0, this.scene.add(this.helperObject3D), this.render());
+  }
+  disable() {
+    !this.enabled || (this.enabled = !1, this.scene.remove(this.helperObject3D), this.render());
+  }
+  show() {
+    this.helperObject3D.show(), this.render();
+  }
+  hide() {
+    this.helperObject3D.hide(), this.render();
+  }
+  dispose() {
+    this.helperObject3D.dispose(), this.scene.remove(this.helperObject3D), this.render();
+  }
+  setOpacity(s) {
+    this.setOriginOpacityProperty();
+    const e = this.originObject3D;
+    if (e instanceof h.Mesh && (e.material.opacity = s), e.isCSS3DObjectPlus) {
+      const t = e;
+      t.container.style.opacity = s.toString();
+    }
+    this.render();
+  }
+  restoreOpacity() {
+    if (P === null)
+      return;
+    const s = this.originObject3D;
+    if (s instanceof h.Mesh && (s.material.opacity = P.opacity), s.isCSS3DObjectPlus) {
+      const e = s;
+      e.container.style.opacity = P.opacity.toString();
+    }
+    this.render();
+  }
+  setOriginOpacityProperty() {
+    var s, e;
+    if (P === null) {
+      const t = this.originObject3D;
+      t instanceof h.Mesh && (P = {
+        opacity: t.material.opacity
+      }), t instanceof ve && (P = {
+        opacity: (s = t.container.style.opacity) != null ? s : 1
+      }), t.isCSS3DObjectPlus && (P = {
+        opacity: Number((e = t.container.style.opacity) != null ? e : 1)
+      });
+    }
+  }
+  updateHelperPosition() {
+    this.helperObject3D.updatePosition();
+  }
+  updateHelperQuaternion() {
+    this.helperObject3D.updateQuaternion();
+  }
+  applyHelperMatrix4(s) {
+    this.helperObject3D.applyMatrix4(s);
+  }
+  applyHelperQuaternion(s, e) {
+    this.helperObject3D.applyHelperQuaternion(s, e);
+  }
+  applyHelperScaleMatrix4(s, e) {
+    this.helperObject3D.applyHelperScaleMatrix4(s, e);
+  }
+  onWantsGesture(s, e, t) {
+    if (this.isDragging)
+      return !1;
+  }
+  render() {
+    this.onRender();
+  }
+  hoverListener(s, e = 16777215, t = 1) {
+    const n = (Array.isArray(s) ? s : [s]).filter(we), r = [];
+    for (const i of n)
+      if (i instanceof h.Mesh || i instanceof h.Group) {
+        const a = i instanceof h.Group ? i.children.filter((d) => d instanceof h.Mesh) : [i];
+        a.forEach((d) => {
+          d.__originalColor__ = d.material.color.clone(), d.__originalOpacity__ = d.material.opacity;
+        });
+        const c = () => {
+          a.forEach((d) => {
+            d.material.color.set(e), d.material.opacity = t;
+          }), this.render();
+        }, p = () => {
+          a.forEach((d) => {
+            d.material.color.copy(d.__originalColor__), d.material.opacity = d.__originalOpacity__;
+          }), this.render();
+        }, u = () => {
+          this.isDragging || c();
+        }, g = () => {
+          this.isDragging || p();
+        };
+        for (const d of a)
+          this.domEvents.addEventListener(d, "mouseover", u), this.domEvents.addEventListener(d, "mouseout", g), this.hooks.on("moveStart", c), this.hooks.on("moveEnd", p), this.hooks.on("rotateEnd", p), r.push(() => {
+            this.domEvents.removeEventListener(d, "mouseover", u), this.domEvents.removeEventListener(d, "mouseout", g), this.hooks.off("moveStart", c), this.hooks.off("moveEnd", p), this.hooks.off("rotateEnd", p);
+          });
+      }
+    return () => r.forEach((i) => i == null ? void 0 : i());
+  }
+  getIntersectObject(s) {
+    const e = this.camera.position, t = this.helperObject3D;
+    if (!t)
+      return;
+    let n;
+    const r = s.intersectObject(t, !0)[0];
+    if (!!r && (n = r, n.object = t, !!n)) {
+      if (this.model.intersectRaycaster) {
+        const i = this.model.intersectRaycaster(s)[0];
+        if (i && i.point.distanceTo(e) < n.point.distanceTo(e))
+          return;
+      }
+      return n.object;
+    }
+  }
+}
+class Re extends N {
+  constructor(...e) {
+    super(...e);
+    l(this, "startInfo");
+    const t = this.helperObject3D;
+    this.hoverListener([t.xArrow, t.yArrow, t.zArrow]);
+    const n = this.dragStart.bind(this), r = this.dragging.bind(this), i = this.dragEnd.bind(this);
+    this.domEvents.addEventListener(this.helperObject3D, "mousedown", n), document.addEventListener("mousemove", r), document.addEventListener("mouseup", i);
+  }
+  dragStart(e) {
+    if (this.isDragging)
+      return;
+    const t = e == null ? void 0 : e.intersect;
+    if (!t)
+      return this.dragEnd();
+    const n = (t == null ? void 0 : t.object).direction;
+    if (!n)
+      return this.dragEnd();
+    const r = new h.Vector3(1, 0, 0).applyQuaternion(this.helperObject3D.quaternion), i = new h.Vector3(0, 1, 0).applyQuaternion(this.helperObject3D.quaternion), a = new h.Vector3(0, 0, 1).applyQuaternion(this.helperObject3D.quaternion), c = (() => {
+      switch (n) {
+        case "x":
+          return r;
+        case "y":
+          return i;
+        case "z":
+          return a;
+      }
+    })(), p = (() => {
+      switch (n) {
+        case "x":
+        case "y":
+          return a;
+        case "z":
+          return r;
+      }
+    })(), u = t.point.clone(), g = new h.Plane();
+    g.setFromNormalAndCoplanarPoint(p, u), this.startInfo = { startVectorProject: u.clone().projectOnVector(c), directionVector: c, plane: g }, this.helperObject3D.showDraggingHelper([n]), this.hooks.emit("moveStart"), this.isDragging = !0, console.log("%c MoveController dragStart", "color: #e5af2e");
+  }
+  dragging(e) {
+    if (!this.isDragging || !this.startInfo)
+      return;
+    const t = Z(this.camera, e, this.container);
+    return t ? (console.log("%c RotateController dragging", "color: #49de1b"), this.move(t), !1) : this.dragEnd();
+  }
+  move(e) {
+    if (!this.startInfo)
+      return this.dragEnd();
+    const { plane: t, directionVector: n, startVectorProject: r } = this.startInfo, i = this.originObject3D, a = e.ray.intersectPlane(t, new h.Vector3());
+    if (!a)
+      return;
+    const c = a.clone().projectOnVector(n), p = c.clone().sub(r), u = new h.Matrix4();
+    u.setPosition(p), i.applyMatrix4(u), this.helperObject3D.applyMatrix4(u), r.copy(c), this.hooks.emit("positionUpdate", { matrix4: u });
+  }
+  dragEnd() {
+    !this.isDragging || (console.log("%c MoveController dragEnd", "color: #e94e4e"), this.startInfo = void 0, this.isDragging = !1, this.helperObject3D.show(), this.hooks.emit("moveEnd"));
+  }
+}
+class Y {
+  constructor(s, e, t, n) {
+    l(this, "helperController");
+    l(this, "five");
+    l(this, "onFiveWantsTapGesture", (s) => {
+      if (!this.helperController)
+        return;
+      const e = this.helperController.onWantsTapGesture(s);
+      return this.five.needsRender = !0, e;
+    });
+    l(this, "onFiveWantsGesture", (...s) => {
+      if (!this.helperController)
+        return;
+      const e = this.helperController.onWantsGesture(...s);
+      return this.five.needsRender = !0, e;
+    });
+    const { camera: r, model: i, scene: a } = s, c = s.getElement();
+    if (this.five = s, !r || !i || !c || !a)
+      return;
+    const p = () => {
+      s.needsRender = !0;
+    };
+    this.helperController = new e(r, i, t, n, c, a, p), s.on("wantsTapGesture", this.onFiveWantsTapGesture), s.on("wantsGesture", this.onFiveWantsGesture);
+  }
+}
+const ke = "v1.0.1", Le = "Object3DHelper", J = `${Le}@${ke}`, ze = () => {
+  console.error(`${J} is disposed`);
+}, Ve = () => {
+  console.warn(`${J} is disabled`);
+}, Te = () => {
+  console.error(`${J} is disabled`);
+};
+class $e {
+  constructor(s, e) {
+    l(this, "controllers", {});
+    l(this, "state", {
+      visible: !0,
+      enabled: !0,
+      disposed: !1
+    });
+    l(this, "hooks", new ae());
+    l(this, "helpers");
+    l(this, "eventListener", {});
+    l(this, "handlePositionUpdate", (s, ...e) => {
+      var r, i, a, c;
+      const [t] = e, n = t == null ? void 0 : t.matrix4;
+      n && (s !== this.controllers.moveController && ((r = this.controllers.moveController) == null || r.applyHelperMatrix4(n)), s !== this.controllers.rotateController && ((i = this.controllers.rotateController) == null || i.applyHelperMatrix4(n)), s !== this.controllers.scaleController && ((a = this.controllers.scaleController) == null || a.applyHelperMatrix4(n)), (c = this.helpers.outlineHelper) == null || c.applyMatrix4(n));
+    });
+    l(this, "handleScaleUpdate", (s, ...e) => {
+      var r, i;
+      const [t] = e, n = t == null ? void 0 : t.matrix4;
+      n && ((r = this.controllers.scaleController) == null || r.applyHelperScaleMatrix4(n, t), (i = this.helpers.outlineHelper) == null || i.scale.applyMatrix4(n));
+    });
+    l(this, "handleRotateUpdate", (s, ...e) => {
+      var n, r, i, a;
+      const [t] = e;
+      if (t) {
+        const { quaternion: c, origin: p } = t;
+        c && (s !== this.controllers.moveController && ((n = this.controllers.moveController) == null || n.applyHelperQuaternion(c, p)), s !== this.controllers.rotateController && ((r = this.controllers.rotateController) == null || r.applyHelperQuaternion(c, p)), s !== this.controllers.scaleController && ((i = this.controllers.scaleController) == null || i.applyHelperQuaternion(c, p)), (a = this.helpers.outlineHelper) == null || a.applyQuaternion(c));
+      }
+    });
+    s && this.addControllers(s), this.helpers = e != null ? e : {}, this.setState(this.state);
+  }
+  show(s) {
+    return R(this, null, function* () {
+      this.setState({ visible: !0 }, s);
+    });
+  }
+  hide(s) {
+    return R(this, null, function* () {
+      this.setState({ visible: !1 }, s);
+    });
+  }
+  enable(s) {
+    this.setState({ enabled: !0 }, s);
+  }
+  disable(s) {
+    this.setState({ enabled: !1 }, s);
+  }
+  dispose() {
+    this.setState({ disposed: !0 });
+  }
+  setState(s, e) {
+    if (this.state.disposed)
+      return ze();
+    if (!this.state.enabled && s.enabled !== !0 && s.disposed !== !0)
+      return Te();
+    const t = v({}, this.state);
+    this.state = v(v({}, this.state), s), s.disposed !== void 0 && s.disposed !== t.disposed && s.disposed && this.handleDispose(), s.visible !== void 0 && this.handleVisible(s.visible), s.enabled !== void 0 && this.handleEnable(s.enabled), this.hooks.emit("stateChange", { state: this.state, prevState: t });
+  }
+  addControllers(s) {
+    this.controllers = v(v({}, this.controllers), s), this.addEventListener(), this.setState(this.state);
+  }
+  addHelpers(s) {
+    this.helpers = v(v({}, this.helpers), s);
+  }
+  getCurrentState() {
+    return this.state;
+  }
+  addEventListener() {
+    for (const s in this.controllers) {
+      if (!s)
+        continue;
+      const e = s;
+      this.eventListener[e] || (this.eventListener[e] = (() => {
+        const t = this.controllers[e];
+        if (!t)
+          return;
+        const n = () => this.handleStart(t), r = () => this.handleEnd(t), i = (...p) => this.handlePositionUpdate(t, ...p), a = (...p) => this.handleRotateUpdate(t, ...p), c = (...p) => this.handleScaleUpdate(t, ...p);
+        return t.hooks.on("moveStart", n), t.hooks.on("rotateStart", n), t.hooks.on("scaleStart", n), t.hooks.on("positionUpdate", i), t.hooks.on("rotateUpdate", a), t.hooks.on("scaleUpdate", c), t.hooks.on("moveEnd", r), t.hooks.on("rotateEnd", r), t.hooks.on("scaleEnd", r), () => {
+          t.hooks.off("moveStart", n), t.hooks.off("rotateStart", n), t.hooks.off("scaleStart", n), t.hooks.off("positionUpdate", i), t.hooks.off("rotateUpdate", a), t.hooks.off("scaleUpdate", c), t.hooks.off("moveEnd", r), t.hooks.off("rotateEnd", r), t.hooks.off("scaleEnd", r);
+        };
+      })());
+    }
+  }
+  handleEnd(s) {
+    s && this.setOtherHelpersVisible(!0, s);
+  }
+  handleStart(s) {
+    s && this.setOtherHelpersVisible(!1, s);
+  }
+  setOtherHelpersVisible(s, e) {
+    var t, n, r, i;
+    s ? ((r = this.controllers.moveController) == null || r.helperObject3D.show(), (i = this.controllers.rotateController) == null || i.helperObject3D.show()) : (e !== this.controllers.moveController && ((t = this.controllers.moveController) == null || t.helperObject3D.hide()), e !== this.controllers.rotateController && ((n = this.controllers.rotateController) == null || n.helperObject3D.hide()));
+  }
+  handleEnable(s, e = !0) {
+    s ? (this.everyControllerDo((t) => {
+      t.enable();
+    }), this.hooks.emit("enable", { userAction: e })) : (this.everyControllerDo((t) => {
+      t.disable(), t.restoreOpacity();
+    }), this.hooks.emit("disable", { userAction: e })), this.state.enabled = s;
+  }
+  handleVisible(s, e = !0) {
+    s ? (this.everyControllerDo((t) => {
+      t.show();
+    }), this.actionIfStateIsEnabled(() => this.hooks.emit("show", { userAction: e }))) : (this.everyControllerDo((t) => {
+      t.hide(), t.restoreOpacity();
+    }), this.actionIfStateIsEnabled(() => this.hooks.emit("hide", { userAction: e }))), this.state.visible = s;
+  }
+  everyControllerDo(s) {
+    Object.values(this.controllers).forEach((e) => {
+      e && s(e);
+    });
+  }
+  handleDispose() {
+    var s, e;
+    Object.values(this.controllers).forEach((t) => {
+      t == null || t.dispose(), t == null || t.restoreOpacity();
+    });
+    for (const t in this.controllers) {
+      if (!t)
+        continue;
+      const n = t;
+      (e = (s = this.eventListener)[n]) == null || e.call(s);
+    }
+  }
+  actionIfStateIsEnabled(s, e) {
+    if (this.state.enabled)
+      return s();
+    e != null && e.warnLog && Ve();
+  }
+}
+class Qe extends N {
+  constructor(...e) {
+    super(...e);
+    l(this, "startInfo");
+    l(this, "lastRotation");
+    l(this, "rotations", []);
+    l(this, "helperObject3DQuaternion", this.originObject3D.quaternion.clone());
+    const t = this.helperObject3D;
+    this.hoverListener([t.xyCircle, t.xzCircle, t.yzCircle]);
+    const n = this.dragStart.bind(this), r = this.dragging.bind(this), i = this.dragEnd.bind(this);
+    this.domEvents.addEventListener(this.helperObject3D, "mousedown", n), document.addEventListener("mousemove", r), document.addEventListener("mouseup", i);
+  }
+  initialHelperQuaternion() {
+    this.helperObject3D.updateAngleHelperQuaternion(), this.helperObject3D.applyHelperQuaternion(this.originObject3D.quaternion);
+  }
+  dragStart(e) {
+    if (this.isDragging)
+      return;
+    const t = e == null ? void 0 : e.intersect;
+    if (!t)
+      return this.dragEnd();
+    const n = (t == null ? void 0 : t.object).direction;
+    if (!n)
+      return this.dragEnd();
+    this.helperObject3D.updateAngleHelperQuaternion();
+    const r = t.point, i = this.originObject3D.position.clone(), a = this.getAngleHelper(n);
+    this.setTipsAngle(0);
+    const c = r.clone();
+    c.y += 0.2, this.setTipsPosition(c);
+    const p = new h.Vector3(1, 0, 0).applyQuaternion(this.helperObject3DQuaternion), u = new h.Vector3(0, 1, 0).applyQuaternion(this.helperObject3DQuaternion), g = new h.Vector3(0, 0, 1).applyQuaternion(this.helperObject3DQuaternion), d = (() => {
+      switch (n) {
+        case "x":
+          return p;
+        case "y":
+          return u;
+        case "z":
+          return g;
+      }
+    })(), m = new h.Plane().setFromNormalAndCoplanarPoint(d, r), D = new h.Vector3();
+    m.projectPoint(r.clone(), D);
+    const w = D.clone().sub(i), _ = w.clone(), x = w.angleTo(a.baseAxes);
+    this.setAngleHelperStart(n, x), this.setAngleHelperLength(n, 0), this.rotations.push({ vector: w.clone(), direction: !0 }), this.startInfo = { direction: n, startVector: w, staticStartVector: _, plane: m, angleHelper: a }, this.helperObject3D.showDraggingHelper([n]), this.hooks.emit("rotateStart"), this.isDragging = !0, console.log(`%c RotateController dragStart ${n}`, "color: #e5af2e");
+  }
+  dragging(e) {
+    var n;
+    if (!this.isDragging)
+      return;
+    const t = Z(this.camera, e, this.container);
+    return t ? (console.log(`%c RotateController dragging ${(n = this.startInfo) == null ? void 0 : n.direction}`, "color: #49de1b"), this.rotate(t), !1) : this.dragEnd();
+  }
+  rotate(e) {
+    if (!this.startInfo)
+      return this.dragEnd();
+    const { startVector: t, plane: n, angleHelper: r, staticStartVector: i, direction: a } = this.startInfo, c = this.originObject3D, p = e.ray.intersectPlane(n, new h.Vector3());
+    if (!p)
+      return;
+    const u = c.position.clone(), g = new h.Vector3();
+    n.projectPoint(p.clone(), g);
+    const d = g.clone().sub(u);
+    if (t.angleTo(d) === 0 || (this.lastRotation === void 0 && (this.lastRotation = { angle: 0 }), this.rotations.length === 0))
+      return;
+    const m = (() => {
+      if (this.rotations.length === 1)
+        return d.angleTo(r.baseAxes) > i.angleTo(r.baseAxes);
+      {
+        const w = this.rotations[this.rotations.length - 1], _ = this.rotations[this.rotations.length - 2], x = d.angleTo(_.vector), M = d.angleTo(w.vector), S = w.vector.angleTo(_.vector);
+        if (S === 0 || M === 0 || x === 0)
+          return;
+        if (x > M && x > S)
+          return w.direction;
+        if (x < S && M < S || x < M && M > S)
+          return !w.direction;
+      }
+    })();
+    if (m === void 0)
+      return console.warn("rotationDirection is undefined");
+    this.rotations.push({ vector: d, direction: m }), this.rotations = this.rotations.slice(-2), this.lastRotation.angle = this.lastRotation.angle + d.angleTo(t) * (m ? 1 : -1), this.setAngleHelperLength(a, this.lastRotation.angle), this.setTipsAngle(this.lastRotation.angle / Math.PI * 180);
+    const D = new h.Quaternion().setFromUnitVectors(t.clone().normalize(), d.clone().normalize());
+    c.applyQuaternion(D), this.helperObject3D.applyHelperQuaternion(D), this.helperObject3DQuaternion.premultiply(D), this.hooks.emit("rotateUpdate", { quaternion: D, origin: u }), this.startInfo.startVector = d;
+  }
+  dragEnd() {
+    !this.isDragging || (console.log("%c RotateController dragEnd", "color: #e94e4e"), this.startInfo = void 0, this.isDragging = !1, this.lastRotation = void 0, this.rotations = [], this.helperObject3D.show(), this.hooks.emit("rotateEnd"));
+  }
+  getAngleHelper(e) {
+    switch (e) {
+      case "x":
+        return this.helperObject3D.xAngleHelper;
+      case "y":
+        return this.helperObject3D.yAngleHelper;
+      case "z":
+        return this.helperObject3D.zAngleHelper;
+    }
+  }
+  setAngleHelperStart(e, t) {
+    const n = this.getAngleHelper(e);
+    if (n instanceof h.Mesh && n.geometry instanceof h.CircleGeometry) {
+      const { radius: r, segments: i, thetaLength: a } = n.geometry.parameters;
+      n.geometry = new h.CircleGeometry(r, i, t, a);
+    } else
+      console.warn("only support THREE.CircleGeometry");
+  }
+  setAngleHelperLength(e, t) {
+    const r = t >= 0 ? Math.max(t, 1e-3) : Math.min(t, -1e-3), i = this.getAngleHelper(e);
+    if (i instanceof h.Mesh && i.geometry instanceof h.CircleGeometry) {
+      const { radius: a, thetaStart: c } = i.geometry.parameters, p = Math.ceil(Math.abs(r) * (40 / (2 * Math.PI)));
+      i.geometry = new h.CircleGeometry(a, p, c, r);
+    } else
+      console.warn("only support THREE.CircleGeometry");
+  }
+  setTipsAngle(e) {
+    var n;
+    const t = (n = this.helperObject3D.angleTips) == null ? void 0 : n.element;
+    !t || (t.innerText = `${e.toFixed(0)}\xB0`);
+  }
+  setTipsPosition(e) {
+    const t = this.helperObject3D.angleTips;
+    if (!t)
+      return;
+    const n = e.project(this.camera), { x: r, y: i, z: a } = n;
+    if (a > 1)
+      return;
+    const c = (r + 1) / 2 * 100 + "%", p = (-i + 1) / 2 * 100 + "%";
+    t.setLeftTop(c, p);
+  }
+}
+class Ge extends N {
+  constructor(...e) {
+    super(...e);
+    l(this, "startInfo");
+  }
+  enable() {
+    this.helperObject3D.enable(), super.enable();
+  }
+  disable() {
+    this.helperObject3D.disable(), super.disable();
+  }
+  show() {
+    this.helperObject3D.show(), super.show();
+  }
+  hide() {
+    this.helperObject3D.hide(), super.hide();
+  }
+  getDragPlane() {
+    const e = new h.Plane(), t = this.helperObject3D.cornerPositions;
+    if (t.length !== 0)
+      return t.length < 3 ? e.setFromNormalAndCoplanarPoint(this.originObject3D.getWorldDirection(new y()), t[0]) : e.setFromCoplanarPoints(t[0], t[1], t[2]), e;
+  }
+  dragStart(e, t) {
+    var r, i;
+    (i = (r = this.helperObject3D).updatePoints) == null || i.call(r);
+    const n = this.getDragPlane();
+    if (!n)
+      return this.dragEnd();
+    this.startInfo = { startPoint: { position: t.position.clone(), direction: t.direction }, plane: n }, this.hooks.emit("scaleStart"), this.render(), this.isDragging = !0, console.log("%c RectangleScaleController dragStart", "color: #e5af2e");
+  }
+  dragging(e) {
+    if (!this.isDragging)
+      return;
+    const t = Z(this.camera, e, this.container);
+    if (!t)
+      return this.dragEnd();
+    this.scale(t), console.log("%c RectangleScaleController dragging", "color: #49de1b");
+  }
+  scale(e) {
+    var ee, te;
+    if (!this.startInfo)
+      return;
+    const t = this.originObject3D, { startPoint: n, plane: r } = this.startInfo, i = this.helperObject3D.cornerPositions;
+    if (i.length < 4)
+      return this.dragEnd();
+    const a = e.ray.intersectPlane(r, new y());
+    if (!a || Oe(a, this.camera.position))
+      return;
+    const c = new y().addVectors(i[0], i[2]).divideScalar(2), { position: p, direction: u } = n, g = new y().subVectors(i[1], i[0]), d = new y().subVectors(i[3], i[0]), m = (C) => {
+      const E = new y(0, 0, 0);
+      if (!this.startInfo)
+        return E;
+      const b = (C === "ew" ? g : d).clone(), H = p.clone().projectOnVector(b), L = a.clone().projectOnVector(b), se = c.clone().projectOnVector(b);
+      if (L.equals(H))
+        return E;
+      if (C === "ns" && typeof this.startInfo.dragPointInCenterBottom != "boolean") {
+        const I = new y().subVectors(L, se), V = I.x < 0 && b.x >= 0, T = I.y < 0 && b.y >= 0, $ = I.z < 0 && b.z >= 0;
+        this.startInfo.dragPointInCenterBottom = V || T || $;
+      }
+      if (C === "ew" && typeof this.startInfo.dragPointInCenterLeft != "boolean") {
+        const I = new y().subVectors(L, se), V = I.x < 0 && b.x >= 0, T = I.y < 0 && b.y >= 0, $ = I.z < 0 && b.z >= 0;
+        this.startInfo.dragPointInCenterLeft = V || T || $;
+      }
+      const ne = new y().subVectors(L, H), oe = ne.length();
+      return oe > 0.3 ? (console.warn("offset.length() > 0.3, skipped", oe), E) : ne;
+    }, D = m("ew"), w = m("ns"), _ = () => {
+      const C = D;
+      this.helperObject3D.cornerPositions.forEach((E, b) => {
+        var H;
+        (H = this.startInfo) != null && H.dragPointInCenterLeft ? (b === 0 || b === 3) && E.add(C) : (b === 1 || b === 2) && E.add(C);
+      });
+    }, x = () => {
+      const C = w;
+      this.helperObject3D.cornerPositions.forEach((E, b) => {
+        var H;
+        (H = this.startInfo) != null && H.dragPointInCenterBottom ? (b === 0 || b === 1) && E.add(C) : (b === 2 || b === 3) && E.add(C);
+      });
+    };
+    switch (u) {
+      case "ew":
+        _();
+        break;
+      case "ns":
+        x();
+        break;
+      case "nesw":
+      case "nwse":
+        _(), x();
+    }
+    const M = new y().subVectors(i[1], i[0]).length() / g.length(), S = new y().subVectors(i[3], i[0]).length() / d.length(), ce = new y(M, S, 1), z = new h.Matrix4().scale(ce);
+    t.isCSS3DObjectPlus ? t.applyScaleMatrix4(z) : t.scale.applyMatrix4(z), n.position.copy(a);
+    const he = new y().addVectors(i[0], i[2]).divideScalar(2), pe = new y().subVectors(he, c), k = new h.Matrix4().setPosition(pe);
+    t.applyMatrix4(k), (ee = this.helperObject3D.css3DInstance) == null || ee.css3DObject.applyMatrix4(k), (te = this.helperObject3D.plane) == null || te.applyMatrix4(k), this.hooks.emit("scaleUpdate", { matrix4: z, helperOrigin: c }), this.hooks.emit("positionUpdate", { matrix4: k }), this.render();
+  }
+  dragEnd() {
+    !this.isDragging || (this.startInfo = void 0, this.isDragging = !1, this.hooks.emit("scaleEnd"), this.render(), console.log("%c RectangleScaleController dragEnd", "color: #e94e4e"));
+  }
+}
+class Fe extends Ge {
+  constructor(...s) {
+    super(...s), this.addHTMLEventListener();
+  }
+  addHTMLEventListener() {
+    this.helperObject3D.points.forEach((s) => {
+      if (!s)
+        return;
+      const e = s.point, t = (i) => this.dragStart(i, s), n = this.dragging.bind(this), r = this.dragEnd.bind(this);
+      e.addEventListener("dragstart", t), e.addEventListener("drag", n), e.addEventListener("dragend", r);
+    });
+  }
+}
+const le = "v1.0.0", B = "Object3DHelperPlugin", K = `${B}@${le}`, qe = () => {
+  console.error(`${K} is disposed`);
+}, Ue = () => {
+  console.warn(`${K} is disabled`);
+}, Xe = () => {
+  console.error(`${K} is disabled`);
+};
+class Ye extends ge {
+  constructor(e) {
+    super(e);
+    l(this, "version", le);
+    l(this, "name", B);
+    l(this, "state", {
+      visible: !0,
+      enabled: !0,
+      disposed: !1
+    });
+    l(this, "objectHelperMap", /* @__PURE__ */ new Map());
+    this.five = e, console.warn("Object3DHelper: \u4F7F\u7528\u6B64\u63D2\u4EF6\u9700\u8981\u5728\u521D\u59CB\u5316five\u65F6\uFF0C\u8BBE\u7F6Efive\u53C2\u6570: { backgroundAlpha: 0, backgroundColor: 0x000000 }"), Object.assign(window, { [`__${B.toUpperCase()}_DEBUG__`]: this });
+  }
+  show(e) {
+    return R(this, null, function* () {
+      this.setState({ visible: !0 }, e);
+    });
+  }
+  hide(e) {
+    return R(this, null, function* () {
+      this.setState({ visible: !1 }, e);
+    });
+  }
+  enable(e) {
+    this.setState({ enabled: !0 }, e);
+  }
+  disable(e) {
+    this.setState({ enabled: !1 }, e);
+  }
+  dispose() {
+    this.setState({ disposed: !0 });
+  }
+  setState(e, t) {
+    if (this.state.disposed)
+      return qe();
+    if (!this.state.enabled && e.enabled !== !0 && e.disposed !== !0)
+      return Xe();
+    const n = v({}, this.state);
+    this.state = v(v({}, this.state), e), e.disposed !== void 0 && e.disposed !== n.disposed && e.disposed && this.handleDispose(), e.visible !== void 0 && e.visible !== n.visible && this.handleVisible(e.visible), e.enabled !== void 0 && e.enabled !== n.enabled && this.handleEnable(e.enabled), this.hooks.emit("stateChange", { state: this.state, prevState: n });
+  }
+  getObject3DHelper(e) {
+    return this.objectHelperMap.get(e);
+  }
+  addObject3DHelper(e, t = {}) {
+    var u;
+    if (!e)
+      return console.error("Object3D is undefined");
+    if (this.objectHelperMap.has(e)) {
+      console.warn(`Object3DHelperPlugin: object3D ${e.name} is already has helper`);
+      return;
+    }
+    const n = new $e();
+    this.objectHelperMap.set(e, n);
+    const r = (u = this.five.getElement()) == null ? void 0 : u.parentElement, i = this.five.camera, { moveHelper: a = !0, rotateHelper: c = !0, scaleHelper: p = !0 } = t;
+    if (a) {
+      const g = new _e(e), d = new Y(this.five, Re, e, g);
+      n.addControllers({ moveController: d.helperController });
+    }
+    if (c) {
+      let g;
+      r && i && (g = { container: r });
+      const d = new Ie(e, g), m = new Y(this.five, Qe, e, d);
+      n.addControllers({ rotateController: m.helperController });
+    }
+    if (p && r) {
+      const g = new Ae(e, r, i, this.five.scene), d = new Y(this.five, Fe, e, g);
+      n.addControllers({ scaleController: d.helperController });
+    }
+    e.isCSS3DObjectPlus && e.changeMode("behind", this.five.scene);
+  }
+  removeObject3DHelper(e) {
+    const t = this.objectHelperMap.get(e);
+    !t || (e.isCSS3DObjectPlus && e.changeMode("front"), this.objectHelperMap.delete(e), t.dispose());
+  }
+  handleEnable(e, t = !0) {
+    e ? (this.everyHelperDo((n) => n.enable()), this.hooks.emit("enable", { userAction: t })) : (this.everyHelperDo((n) => n.disable()), this.hooks.emit("disable", { userAction: t })), this.state.enabled = e;
+  }
+  handleVisible(e, t = !0) {
+    e ? (this.everyHelperDo((n) => n.show()), this.actionIfStateIsEnabled(() => this.hooks.emit("show", { userAction: t }))) : (this.everyHelperDo((n) => n.hide()), this.actionIfStateIsEnabled(() => this.hooks.emit("hide", { userAction: t }))), this.state.visible = e;
+  }
+  handleDispose() {
+    this.everyHelperDo((e) => e.dispose());
+  }
+  everyHelperDo(e) {
+    this.objectHelperMap.forEach((t) => {
+      t && e(t);
+    });
+  }
+  actionIfStateIsEnabled(e, t) {
+    if (this.state.enabled)
+      return e();
+    t != null && t.warnLog && Ue();
+  }
+}
+const tt = (o) => new Ye(o);
+export {
+  Ye as Object3DHelperController,
+  tt as Object3DHelperPlugin,
+  K as PLUGIN,
+  le as VERSION,
+  tt as default
+};