@realsee/dnalogel 2.1.2-alpha.2 → 2.1.2-alpha.3

package/esm/shared-utils/Object3DHelper/Base/BaseHelper.js

@@ -0,0 +1,51 @@
+var o = Object.defineProperty;
+var p = (t, s, e) => s in t ? o(t, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[s] = e;
+var i = (t, s, e) => (p(t, typeof s != "symbol" ? s + "" : s, e), e);
+import { Object3D as l } from "three";
+class a extends l {
+  constructor(e, r) {
+    var n;
+    super();
+    i(this, "originObject3D");
+    i(this, "onRender");
+    this.originObject3D = e, this.onRender = (n = r == null ? void 0 : r.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, r) {
+    this.scale.applyMatrix4(e);
+  }
+  applyHelperQuaternion(e, r) {
+    this.applyQuaternion(e);
+  }
+}
+class b extends a {
+}
+class u extends a {
+}
+class c extends a {
+}
+class x extends c {
+}
+export {
+  b as M,
+  x as R,
+  u as a
+};

package/esm/shared-utils/Object3DHelper/Constants/color.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+declare const AXES_COLOR: {
+    X: number;
+    Y: number;
+    Z: number;
+};
+declare class AXES_THREE_COLOR {
+    static get X(): THREE.Color;
+    static get Y(): THREE.Color;
+    static get Z(): THREE.Color;
+}
+export { AXES_COLOR, AXES_THREE_COLOR };

package/esm/shared-utils/Object3DHelper/Constants/color.js

@@ -0,0 +1,20 @@
+import * as e from "three";
+const o = {
+  X: 15618642,
+  Y: 4765519,
+  Z: 4227839
+};
+class t {
+  static get X() {
+    return new e.Color(o.X).convertSRGBToLinear().clone();
+  }
+  static get Y() {
+    return new e.Color(o.Y).convertSRGBToLinear().clone();
+  }
+  static get Z() {
+    return new e.Color(o.Z).convertSRGBToLinear().clone();
+  }
+}
+export {
+  t as A
+};

package/esm/shared-utils/Object3DHelper/Controller/CSS3DScaleController.d.ts

@@ -0,0 +1,6 @@
+import type { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import { RectangleScaleController } from './RectangleScaleController';
+export declare class CSS3DScaleController extends RectangleScaleController<CSS3DObject, HTMLElement> {
+    constructor(...params: ConstructorParameters<typeof RectangleScaleController<CSS3DObject, HTMLElement>>);
+    private addHTMLEventListener;
+}

package/esm/shared-utils/Object3DHelper/Controller/CSS3DScaleController.js

@@ -0,0 +1,18 @@
+import { R as a } from "./RectangleScaleController.js";
+import "three";
+class c extends a {
+  constructor(...t) {
+    super(...t), this.addHTMLEventListener();
+  }
+  addHTMLEventListener() {
+    this.helperObject3D.points.forEach((t) => {
+      if (!t)
+        return;
+      const e = t.point, r = (s) => this.dragStart(s, t), n = this.dragging.bind(this), d = this.dragEnd.bind(this);
+      e.addEventListener("dragstart", r), e.addEventListener("drag", n), e.addEventListener("dragend", d);
+    });
+  }
+}
+export {
+  c as C
+};

package/esm/shared-utils/Object3DHelper/Controller/MoveController.d.ts

@@ -0,0 +1,13 @@
+import { BaseController } from '../Base/BaseController';
+import type { MoveHelperAbstract } from '../Helper';
+export declare class MoveController<T extends MoveHelperAbstract = MoveHelperAbstract> extends BaseController<T> {
+    private startInfo?;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    /**
+     * @description: 拖动开始，找出拖的Direction
+     */
+    private dragStart;
+    private dragging;
+    private move;
+    private dragEnd;
+}

package/esm/shared-utils/Object3DHelper/Controller/MoveController.js

@@ -0,0 +1,66 @@
+var p = Object.defineProperty;
+var f = (i, r, t) => r in i ? p(i, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[r] = t;
+var u = (i, r, t) => (f(i, typeof r != "symbol" ? r + "" : r, t), t);
+import { B as m } from "../Base/BaseController.js";
+import * as c from "three";
+import { g as b } from "../utils/getMouseRaycaster.js";
+class v extends m {
+  constructor(...t) {
+    super(...t);
+    u(this, "startInfo");
+    const e = this.helperObject3D;
+    this.hoverListener([e.xArrow, e.yArrow, e.zArrow]);
+    const o = this.dragStart.bind(this), n = this.dragging.bind(this), a = this.dragEnd.bind(this);
+    this.domEvents.addEventListener(this.helperObject3D, "mousedown", o), document.addEventListener("mousemove", n), document.addEventListener("mouseup", a);
+  }
+  dragStart(t) {
+    if (this.isDragging)
+      return;
+    const e = t == null ? void 0 : t.intersect;
+    if (!e)
+      return this.dragEnd();
+    const o = (e == null ? void 0 : e.object).direction;
+    if (!o)
+      return this.dragEnd();
+    const n = new c.Vector3(1, 0, 0).applyQuaternion(this.helperObject3D.quaternion), a = new c.Vector3(0, 1, 0).applyQuaternion(this.helperObject3D.quaternion), h = new c.Vector3(0, 0, 1).applyQuaternion(this.helperObject3D.quaternion), g = (() => {
+      switch (o) {
+        case "x":
+          return n;
+        case "y":
+          return a;
+        case "z":
+          return h;
+      }
+    })(), d = (() => {
+      switch (o) {
+        case "x":
+        case "y":
+          return h;
+        case "z":
+          return n;
+      }
+    })(), s = e.point.clone(), l = new c.Plane();
+    l.setFromNormalAndCoplanarPoint(d, s), this.startInfo = { startVectorProject: s.clone().projectOnVector(g), directionVector: g, plane: l }, this.helperObject3D.showDraggingHelper([o]), this.hooks.emit("moveStart"), this.isDragging = !0, console.log("%c MoveController dragStart", "color: #e5af2e");
+  }
+  dragging(t) {
+    if (!this.isDragging || !this.startInfo)
+      return;
+    const e = b(this.camera, t, this.container);
+    return e ? (console.log("%c RotateController dragging", "color: #49de1b"), this.move(e), !1) : this.dragEnd();
+  }
+  move(t) {
+    if (!this.startInfo)
+      return this.dragEnd();
+    const { plane: e, directionVector: o, startVectorProject: n } = this.startInfo, a = this.originObject3D, h = t.ray.intersectPlane(e, new c.Vector3());
+    if (!h)
+      return;
+    const g = h.clone().projectOnVector(o), d = g.clone().sub(n), s = new c.Matrix4();
+    s.setPosition(d), a.applyMatrix4(s), this.helperObject3D.applyMatrix4(s), n.copy(g), this.hooks.emit("positionUpdate", { matrix4: s });
+  }
+  dragEnd() {
+    !this.isDragging || (console.log("%c MoveController dragEnd", "color: #e94e4e"), this.startInfo = void 0, this.isDragging = !1, this.helperObject3D.show(), this.hooks.emit("moveEnd"));
+  }
+}
+export {
+  v as M
+};

package/esm/shared-utils/Object3DHelper/Controller/RectangleScaleController.d.ts

@@ -0,0 +1,37 @@
+import { BaseController } from '../Base/BaseController';
+import type { RectangleScaleHelperAbstract } from '../Helper';
+import * as THREE from 'three';
+import type { Direction4 } from '../typings';
+import { Vector3 } from 'three';
+interface StartInfo {
+    startPoint: {
+        position: Vector3;
+        direction: Direction4;
+    };
+    dragPointInCenterBottom?: boolean | null;
+    dragPointInCenterLeft?: boolean | null;
+    plane: THREE.Plane;
+}
+export declare abstract class RectangleScaleController<OriginObject3D extends THREE.Object3D, PointType extends THREE.Object3D | HTMLElement> extends BaseController<RectangleScaleHelperAbstract<OriginObject3D, PointType>> {
+    protected startInfo?: StartInfo;
+    constructor(...params: ConstructorParameters<typeof BaseController<RectangleScaleHelperAbstract<OriginObject3D, PointType>>>);
+    enable(): void;
+    disable(): void;
+    show(): void;
+    hide(): void;
+    protected getDragPlane(): THREE.Plane;
+    protected dragStart(mousePoint: {
+        x: number;
+        y: number;
+    }, point: {
+        position: THREE.Vector3;
+        direction: Direction4;
+    }): void;
+    protected dragging(point: {
+        x: number;
+        y: number;
+    }): false | void;
+    protected scale(raycaster: THREE.Raycaster): void;
+    protected dragEnd(): void;
+}
+export {};

package/esm/shared-utils/Object3DHelper/Controller/RectangleScaleController.js

@@ -0,0 +1,109 @@
+var X = Object.defineProperty;
+var Y = (h, a, s) => a in h ? X(h, a, { enumerable: !0, configurable: !0, writable: !0, value: s }) : h[a] = s;
+var N = (h, a, s) => (Y(h, typeof a != "symbol" ? a + "" : a, s), s);
+import { B as A } from "../Base/BaseController.js";
+import * as D from "three";
+import { Vector3 as n } from "three";
+import { g as H } from "../utils/getMouseRaycaster.js";
+import { v as T } from "../utils/vectorIsEqual.js";
+class _ extends A {
+  constructor(...s) {
+    super(...s);
+    N(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 s = new D.Plane(), e = this.helperObject3D.cornerPositions;
+    if (e.length !== 0)
+      return e.length < 3 ? s.setFromNormalAndCoplanarPoint(this.originObject3D.getWorldDirection(new n()), e[0]) : s.setFromCoplanarPoints(e[0], e[1], e[2]), s;
+  }
+  dragStart(s, e) {
+    var g, o;
+    (o = (g = this.helperObject3D).updatePoints) == null || o.call(g);
+    const f = this.getDragPlane();
+    if (!f)
+      return this.dragEnd();
+    this.startInfo = { startPoint: { position: e.position.clone(), direction: e.direction }, plane: f }, this.hooks.emit("scaleStart"), this.render(), this.isDragging = !0, console.log("%c RectangleScaleController dragStart", "color: #e5af2e");
+  }
+  dragging(s) {
+    if (!this.isDragging)
+      return;
+    const e = H(this.camera, s, this.container);
+    if (!e)
+      return this.dragEnd();
+    this.scale(e), console.log("%c RectangleScaleController dragging", "color: #49de1b");
+  }
+  scale(s) {
+    var S, x;
+    if (!this.startInfo)
+      return;
+    const e = this.originObject3D, { startPoint: f, plane: g } = this.startInfo, o = this.helperObject3D.cornerPositions;
+    if (o.length < 4)
+      return this.dragEnd();
+    const p = s.ray.intersectPlane(g, new n());
+    if (!p || T(p, this.camera.position))
+      return;
+    const u = new n().addVectors(o[0], o[2]).divideScalar(2), { position: k, direction: R } = f, j = new n().subVectors(o[1], o[0]), O = new n().subVectors(o[3], o[0]), V = (r) => {
+      const i = new n(0, 0, 0);
+      if (!this.startInfo)
+        return i;
+      const t = (r === "ew" ? j : O).clone(), c = k.clone().projectOnVector(t), b = p.clone().projectOnVector(t), E = u.clone().projectOnVector(t);
+      if (b.equals(c))
+        return i;
+      if (r === "ns" && typeof this.startInfo.dragPointInCenterBottom != "boolean") {
+        const l = new n().subVectors(b, E), P = l.x < 0 && t.x >= 0, I = l.y < 0 && t.y >= 0, m = l.z < 0 && t.z >= 0;
+        this.startInfo.dragPointInCenterBottom = P || I || m;
+      }
+      if (r === "ew" && typeof this.startInfo.dragPointInCenterLeft != "boolean") {
+        const l = new n().subVectors(b, E), P = l.x < 0 && t.x >= 0, I = l.y < 0 && t.y >= 0, m = l.z < 0 && t.z >= 0;
+        this.startInfo.dragPointInCenterLeft = P || I || m;
+      }
+      const v = new n().subVectors(b, c), M = v.length();
+      return M > 0.3 ? (console.warn("offset.length() > 0.3, skipped", M), i) : v;
+    }, z = V("ew"), B = V("ns"), y = () => {
+      const r = z;
+      this.helperObject3D.cornerPositions.forEach((i, t) => {
+        var c;
+        (c = this.startInfo) != null && c.dragPointInCenterLeft ? (t === 0 || t === 3) && i.add(r) : (t === 1 || t === 2) && i.add(r);
+      });
+    }, C = () => {
+      const r = B;
+      this.helperObject3D.cornerPositions.forEach((i, t) => {
+        var c;
+        (c = this.startInfo) != null && c.dragPointInCenterBottom ? (t === 0 || t === 1) && i.add(r) : (t === 2 || t === 3) && i.add(r);
+      });
+    };
+    switch (R) {
+      case "ew":
+        y();
+        break;
+      case "ns":
+        C();
+        break;
+      case "nesw":
+      case "nwse":
+        y(), C();
+    }
+    const L = new n().subVectors(o[1], o[0]).length() / j.length(), q = new n().subVectors(o[3], o[0]).length() / O.length(), F = new n(L, q, 1), w = new D.Matrix4().scale(F);
+    e.isCSS3DObjectPlus ? e.applyScaleMatrix4(w) : e.scale.applyMatrix4(w), f.position.copy(p);
+    const U = new n().addVectors(o[0], o[2]).divideScalar(2), W = new n().subVectors(U, u), d = new D.Matrix4().setPosition(W);
+    e.applyMatrix4(d), (S = this.helperObject3D.css3DInstance) == null || S.css3DObject.applyMatrix4(d), (x = this.helperObject3D.plane) == null || x.applyMatrix4(d), this.hooks.emit("scaleUpdate", { matrix4: w, helperOrigin: u }), this.hooks.emit("positionUpdate", { matrix4: d }), 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"));
+  }
+}
+export {
+  _ as R
+};

package/esm/shared-utils/Object3DHelper/Controller/RotateController.d.ts

@@ -0,0 +1,22 @@
+import { BaseController } from '../Base/BaseController';
+import type { RotateHelperAbstract } from '../Helper';
+export declare class RotateController<T extends RotateHelperAbstract = RotateHelperAbstract> extends BaseController<T> {
+    private startInfo?;
+    private lastRotation?;
+    private rotations;
+    private helperObject3DQuaternion;
+    constructor(...params: ConstructorParameters<typeof BaseController<T>>);
+    initialHelperQuaternion(): void;
+    /**
+     * @description: 拖动开始，找出拖的Direction
+     */
+    private dragStart;
+    private dragging;
+    private rotate;
+    private dragEnd;
+    private getAngleHelper;
+    private setAngleHelperStart;
+    private setAngleHelperLength;
+    private setTipsAngle;
+    private setTipsPosition;
+}

package/esm/shared-utils/Object3DHelper/Controller/RotateController.js

@@ -0,0 +1,134 @@
+var T = Object.defineProperty;
+var A = (d, h, n) => h in d ? T(d, h, { enumerable: !0, configurable: !0, writable: !0, value: n }) : d[h] = n;
+var y = (d, h, n) => (A(d, typeof h != "symbol" ? h + "" : h, n), n);
+import { B as O } from "../Base/BaseController.js";
+import * as i from "three";
+import { g as R } from "../utils/getMouseRaycaster.js";
+class C extends O {
+  constructor(...n) {
+    super(...n);
+    y(this, "startInfo");
+    y(this, "lastRotation");
+    y(this, "rotations", []);
+    y(this, "helperObject3DQuaternion", this.originObject3D.quaternion.clone());
+    const t = this.helperObject3D;
+    this.hoverListener([t.xyCircle, t.xzCircle, t.yzCircle]);
+    const e = this.dragStart.bind(this), r = this.dragging.bind(this), o = this.dragEnd.bind(this);
+    this.domEvents.addEventListener(this.helperObject3D, "mousedown", e), document.addEventListener("mousemove", r), document.addEventListener("mouseup", o);
+  }
+  initialHelperQuaternion() {
+    this.helperObject3D.updateAngleHelperQuaternion(), this.helperObject3D.applyHelperQuaternion(this.originObject3D.quaternion);
+  }
+  dragStart(n) {
+    if (this.isDragging)
+      return;
+    const t = n == null ? void 0 : n.intersect;
+    if (!t)
+      return this.dragEnd();
+    const e = (t == null ? void 0 : t.object).direction;
+    if (!e)
+      return this.dragEnd();
+    this.helperObject3D.updateAngleHelperQuaternion();
+    const r = t.point, o = this.originObject3D.position.clone(), s = this.getAngleHelper(e);
+    this.setTipsAngle(0);
+    const l = r.clone();
+    l.y += 0.2, this.setTipsPosition(l);
+    const g = new i.Vector3(1, 0, 0).applyQuaternion(this.helperObject3DQuaternion), j = new i.Vector3(0, 1, 0).applyQuaternion(this.helperObject3DQuaternion), D = new i.Vector3(0, 0, 1).applyQuaternion(this.helperObject3DQuaternion), a = (() => {
+      switch (e) {
+        case "x":
+          return g;
+        case "y":
+          return j;
+        case "z":
+          return D;
+      }
+    })(), m = new i.Plane().setFromNormalAndCoplanarPoint(a, r), p = new i.Vector3();
+    m.projectPoint(r.clone(), p);
+    const c = p.clone().sub(o), H = c.clone(), u = c.angleTo(s.baseAxes);
+    this.setAngleHelperStart(e, u), this.setAngleHelperLength(e, 0), this.rotations.push({ vector: c.clone(), direction: !0 }), this.startInfo = { direction: e, startVector: c, staticStartVector: H, plane: m, angleHelper: s }, this.helperObject3D.showDraggingHelper([e]), this.hooks.emit("rotateStart"), this.isDragging = !0, console.log(`%c RotateController dragStart ${e}`, "color: #e5af2e");
+  }
+  dragging(n) {
+    var e;
+    if (!this.isDragging)
+      return;
+    const t = R(this.camera, n, this.container);
+    return t ? (console.log(`%c RotateController dragging ${(e = this.startInfo) == null ? void 0 : e.direction}`, "color: #49de1b"), this.rotate(t), !1) : this.dragEnd();
+  }
+  rotate(n) {
+    if (!this.startInfo)
+      return this.dragEnd();
+    const { startVector: t, plane: e, angleHelper: r, staticStartVector: o, direction: s } = this.startInfo, l = this.originObject3D, g = n.ray.intersectPlane(e, new i.Vector3());
+    if (!g)
+      return;
+    const j = l.position.clone(), D = new i.Vector3();
+    e.projectPoint(g.clone(), D);
+    const a = D.clone().sub(j);
+    if (t.angleTo(a) === 0 || (this.lastRotation === void 0 && (this.lastRotation = { angle: 0 }), this.rotations.length === 0))
+      return;
+    const m = (() => {
+      if (this.rotations.length === 1)
+        return a.angleTo(r.baseAxes) > o.angleTo(r.baseAxes);
+      {
+        const c = this.rotations[this.rotations.length - 1], H = this.rotations[this.rotations.length - 2], u = a.angleTo(H.vector), f = a.angleTo(c.vector), b = c.vector.angleTo(H.vector);
+        if (b === 0 || f === 0 || u === 0)
+          return;
+        if (u > f && u > b)
+          return c.direction;
+        if (u < b && f < b || u < f && f > b)
+          return !c.direction;
+      }
+    })();
+    if (m === void 0)
+      return console.warn("rotationDirection is undefined");
+    this.rotations.push({ vector: a, direction: m }), this.rotations = this.rotations.slice(-2), this.lastRotation.angle = this.lastRotation.angle + a.angleTo(t) * (m ? 1 : -1), this.setAngleHelperLength(s, this.lastRotation.angle), this.setTipsAngle(this.lastRotation.angle / Math.PI * 180);
+    const p = new i.Quaternion().setFromUnitVectors(t.clone().normalize(), a.clone().normalize());
+    l.applyQuaternion(p), this.helperObject3D.applyHelperQuaternion(p), this.helperObject3DQuaternion.premultiply(p), this.hooks.emit("rotateUpdate", { quaternion: p, origin: j }), this.startInfo.startVector = a;
+  }
+  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(n) {
+    switch (n) {
+      case "x":
+        return this.helperObject3D.xAngleHelper;
+      case "y":
+        return this.helperObject3D.yAngleHelper;
+      case "z":
+        return this.helperObject3D.zAngleHelper;
+    }
+  }
+  setAngleHelperStart(n, t) {
+    const e = this.getAngleHelper(n);
+    if (e instanceof i.Mesh && e.geometry instanceof i.CircleGeometry) {
+      const { radius: r, segments: o, thetaLength: s } = e.geometry.parameters;
+      e.geometry = new i.CircleGeometry(r, o, t, s);
+    } else
+      console.warn("only support THREE.CircleGeometry");
+  }
+  setAngleHelperLength(n, t) {
+    const r = t >= 0 ? Math.max(t, 1e-3) : Math.min(t, -1e-3), o = this.getAngleHelper(n);
+    if (o instanceof i.Mesh && o.geometry instanceof i.CircleGeometry) {
+      const { radius: s, thetaStart: l } = o.geometry.parameters, g = Math.ceil(Math.abs(r) * (40 / (2 * Math.PI)));
+      o.geometry = new i.CircleGeometry(s, g, l, r);
+    } else
+      console.warn("only support THREE.CircleGeometry");
+  }
+  setTipsAngle(n) {
+    var e;
+    const t = (e = this.helperObject3D.angleTips) == null ? void 0 : e.element;
+    !t || (t.innerText = `${n.toFixed(0)}\xB0`);
+  }
+  setTipsPosition(n) {
+    const t = this.helperObject3D.angleTips;
+    if (!t)
+      return;
+    const e = n.project(this.camera), { x: r, y: o, z: s } = e;
+    if (s > 1)
+      return;
+    const l = (r + 1) / 2 * 100 + "%", g = (-o + 1) / 2 * 100 + "%";
+    t.setLeftTop(l, g);
+  }
+}
+export {
+  C as R
+};

package/esm/shared-utils/Object3DHelper/Helper/HTML/rectangleScaleDom.d.ts

@@ -0,0 +1,11 @@
+import type { Direction4 } from '../../typings';
+interface Square {
+    element: HTMLElement;
+    direction: Direction4;
+}
+export declare function rectangleScaleDom(): {
+    container: HTMLElement;
+    squares: [Square, Square, Square, Square, Square, Square, Square, Square];
+};
+export declare function backgroundDom(): HTMLElement;
+export {};

package/esm/shared-utils/Object3DHelper/Helper/HTML/rectangleScaleDom.js

@@ -0,0 +1,79 @@
+var f = Object.defineProperty;
+var g = Object.getOwnPropertySymbols;
+var q = Object.prototype.hasOwnProperty, x = Object.prototype.propertyIsEnumerable;
+var w = (t, e, r) => e in t ? f(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, b = (t, e) => {
+  for (var r in e || (e = {}))
+    q.call(e, r) && w(t, r, e[r]);
+  if (g)
+    for (var r of g(e))
+      x.call(e, r) && w(t, r, e[r]);
+  return t;
+};
+import { c as s } from "./utils/createElement.js";
+function F() {
+  const t = s({
+    width: "100%",
+    height: "100%",
+    left: "0",
+    top: "0",
+    position: "absolute",
+    pointerEvents: "none"
+  }), e = s({
+    boxSizing: "border-box",
+    width: "100%",
+    height: "100%",
+    left: "0",
+    top: "0",
+    position: "relative",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center"
+  }), r = s({
+    boxSizing: "border-box",
+    width: "100%",
+    height: "100%",
+    left: "0",
+    top: "0",
+    position: "absolute",
+    border: "1px solid rgba(255,255,255,0.4)"
+  });
+  t.appendChild(e), e.appendChild(r);
+  const n = "-4px", i = { direction: "nesw", element: o({ cursor: "nesw-resize", left: n, bottom: n }) }, a = { direction: "ns", element: o({ cursor: "ns-resize", bottom: n }) }, c = { direction: "nwse", element: o({ cursor: "nwse-resize", right: n, bottom: n }) }, p = { direction: "ew", element: o({ cursor: "ew-resize", right: n }) }, u = { direction: "nesw", element: o({ cursor: "nesw-resize", right: n, top: n }) }, d = { direction: "ns", element: o({ cursor: "ns-resize", top: n }) }, l = { direction: "nwse", element: o({ cursor: "nwse-resize", left: n, top: n }) }, h = { direction: "ew", element: o({ cursor: "ew-resize", left: n }) };
+  return new Array(a, p, d, h, i, c, u, l).forEach((m) => e.appendChild(m.element)), { container: t, squares: [
+    i,
+    a,
+    c,
+    p,
+    u,
+    d,
+    l,
+    h
+  ] };
+}
+function o(t) {
+  const e = s(b({
+    background: "#FFFFFF",
+    width: "9px",
+    height: "9px",
+    position: "absolute",
+    pointerEvents: "none"
+  }, t)), r = s({
+    width: "15px",
+    height: "15px",
+    position: "absolute",
+    left: "50%",
+    top: "50%",
+    transform: "translate(-50%, -50%)",
+    pointerEvents: "none"
+  }), n = s({
+    width: "15px",
+    height: "15px",
+    cursor: t == null ? void 0 : t.cursor,
+    pointerEvents: "auto",
+    background: "transparent"
+  });
+  return n.draggable = !0, r.appendChild(n), e.appendChild(r), e;
+}
+export {
+  F as r
+};

package/esm/shared-utils/Object3DHelper/Helper/HTML/tipsDom.d.ts

@@ -0,0 +1,6 @@
+export declare function tipsDom(style?: Partial<CSSStyleDeclaration>): {
+    element: HTMLElement;
+    show: () => void;
+    hide: () => void;
+    setLeftTop: (left: string, top: string) => void;
+};

package/esm/shared-utils/Object3DHelper/Helper/HTML/tipsDom.js

@@ -0,0 +1,41 @@
+var r = Object.defineProperty;
+var n = Object.getOwnPropertySymbols;
+var d = Object.prototype.hasOwnProperty, a = Object.prototype.propertyIsEnumerable;
+var s = (o, t, e) => t in o ? r(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e, l = (o, t) => {
+  for (var e in t || (t = {}))
+    d.call(t, e) && s(o, e, t[e]);
+  if (n)
+    for (var e of n(t))
+      a.call(t, e) && s(o, e, t[e]);
+  return o;
+};
+import { c as f } from "./utils/createElement.js";
+function x(o) {
+  const t = f(l({
+    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 = () => {
+    t.style.display !== "block" && (!t.style.top || !t.style.left || (t.style.display = "block"));
+  };
+  return { element: t, show: e, hide: () => {
+    t.style.display = "none", t.style.top = "", t.style.left = "";
+  }, setLeftTop: (p, i) => {
+    t.style.left = p, t.style.top = i, e();
+  } };
+}
+export {
+  x as t
+};

package/esm/shared-utils/Object3DHelper/Helper/HTML/utils/createElement.d.ts

@@ -0,0 +1,2 @@
+export declare function createElement(style?: Partial<CSSStyleDeclaration>, tagName?: string): HTMLElement;
+export declare function setStyle(element: HTMLElement, style?: Partial<CSSStyleDeclaration>): HTMLElement;

package/esm/shared-utils/Object3DHelper/Helper/HTML/utils/createElement.js

@@ -0,0 +1,13 @@
+function o(r, n) {
+  return i(document.createElement(n != null ? n : "div"), r);
+}
+function i(r, n) {
+  if (!n)
+    return r;
+  for (const c in n)
+    c && n[c] && (r.style[c] = n[c]);
+  return r;
+}
+export {
+  o as c
+};

package/esm/shared-utils/Object3DHelper/Helper/MoveHelper.d.ts

@@ -0,0 +1,13 @@
+import type { Object3D } from 'three';
+import type { Direction } from '../typings';
+import { MoveHelperAbstract } from '.';
+import { ArrowGroup } from './Objects/ArrowGroup';
+export declare class MoveHelper extends MoveHelperAbstract {
+    xArrow: ArrowGroup;
+    yArrow: ArrowGroup;
+    zArrow: ArrowGroup;
+    constructor(originObject3D: Object3D);
+    show(): void;
+    showDraggingHelper(directions: Direction[]): void;
+    dispose(): void;
+}