@realsee/dnalogel 3.81.13 → 4.0.0-webgpu.3

package/dist/internal/Controller-Csut_kcH.js

@@ -0,0 +1,2498 @@
+import { t as e } from "./Subscribe-DLlAl88n.js";
+import { r as t } from "./CSS3DObject-C9ck81UX.js";
+import { t as n } from "./fiveModelLoad-mg-TnpnM.js";
+import { t as r } from "./util-vGeVT4oo.js";
+import { n as i, t as a } from "./getNormal-BatLuzsS.js";
+import { t as o } from "./formatRad-kChZaf0k.js";
+import { n as s, t as c } from "./isNil-CQNA0Sbe.js";
+import { t as l } from "./rayOnLine-CrCXTByv.js";
+import { a as u, n as d, t as f } from "./boundingBox-DvCor5Hd.js";
+import { t as p } from "./CSS3DRender-BKWjq-Mo.js";
+import { t as m } from "./BasePlugin-CT5K8m36.js";
+import { t as h } from "./rad2Deg-DutG55Wb.js";
+import { t as g } from "./vectorIsEqual-BXdJrP0J.js";
+import * as _ from "three/webgpu";
+import { Vector3 as v } from "three/webgpu";
+//#region src/shared-utils/Object3DHelper/utils/setObjectQuaternion.ts
+function y(e, t, n) {
+	if (n) {
+		let r = new _.Vector3().subVectors(e.position, n).applyQuaternion(e.quaternion.clone().invert()).applyQuaternion(t).add(n);
+		e.position.copy(r);
+	}
+	e.quaternion.copy(t);
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/Base/BaseHelper.ts
+var b = class extends i {
+	originObject3D;
+	onRender;
+	positionFrom;
+	get helperObject() {
+		return this;
+	}
+	constructor(e, t) {
+		super(), this.originObject3D = e, this.onRender = t?.onRender ?? (() => {}), this.positionFrom = t?.positionFrom ?? "objectPosition";
+	}
+	render() {
+		this.onRender();
+	}
+	enable() {
+		this.parent.children.includes(this) || this.parent.add(this);
+	}
+	disable() {
+		this.removeFromParent();
+	}
+	show() {
+		this.visible = !0, this.render();
+	}
+	hide() {
+		this.visible = !1, this.render();
+	}
+	raycasterIntersectObject(e, t = []) {
+		return e.intersectObject(this, !0, t);
+	}
+	initialPosition(e) {
+		this.positionFrom === "objectPosition" ? this.position.copy(this.originObject3D.position) : this.positionFrom === "boundingBox" ? this.position.copy(f(this.originObject3D)?.getCenter(new _.Vector3()).applyMatrix4(this.originObject3D.matrixWorld)) : this.positionFrom === "boundingSphere" ? this.position.copy(d(this.originObject3D)?.center.clone().applyMatrix4(this.originObject3D.matrixWorld)) : this.positionFrom instanceof v ? this.position.copy(this.positionFrom) : this.positionFrom instanceof Function && this.position.copy(this.positionFrom(this.originObject3D)), e && this.position.add(e);
+	}
+	setScaleByCamera(e) {}
+	initQuaternion(e) {
+		if (this.quaternion.copy(this.originObject3D.quaternion), e && (e.xAxis || e.yAxis || e.zAxis)) {
+			let t = e.xAxis instanceof Function ? e.xAxis() : e.xAxis, n = e.yAxis instanceof Function ? e.yAxis() : e.yAxis, r = e.zAxis instanceof Function ? e.zAxis() : e.zAxis, i = t?.clone(), a = n?.clone(), o = r?.clone();
+			if (i && !a && !a) {
+				let e = new _.Quaternion().setFromUnitVectors(new _.Vector3(1, 0, 0), i.normalize());
+				this.applyQuaternion(e);
+			}
+			if (a && !i && !o) {
+				let e = new _.Quaternion().setFromUnitVectors(new _.Vector3(0, 1, 0), a.normalize());
+				this.applyQuaternion(e);
+			}
+			if (o && !i && !a) {
+				let e = new _.Quaternion().setFromUnitVectors(new _.Vector3(0, 0, 1), o.normalize());
+				this.applyQuaternion(e);
+			}
+			if ([
+				i,
+				a,
+				o
+			].filter(s).length >= 2) {
+				i ||= new _.Vector3().crossVectors(a, o).normalize(), a ||= new _.Vector3().crossVectors(i, o).normalize(), o ||= new _.Vector3().crossVectors(i, a).normalize(), i.applyQuaternion(this.quaternion), a.applyQuaternion(this.quaternion), o.applyQuaternion(this.quaternion);
+				let e = new _.Matrix4().makeBasis(i, a, o), t = new _.Quaternion().setFromRotationMatrix(e);
+				this.quaternion.copy(t);
+			}
+		}
+	}
+	applyHelperScaleMatrix4(e, t) {
+		this.scale.applyMatrix4(e);
+	}
+	setHelperQuaternion(e, t) {
+		this.initQuaternion(), y(this, this.quaternion.clone().premultiply(e), t);
+	}
+	applyHelperQuaternion(e, t) {
+		if (t) {
+			let n = new v().subVectors(this.position, t).applyQuaternion(e).add(t);
+			this.position.copy(n);
+		}
+		this.applyQuaternion(e);
+	}
+	dispose() {
+		this.removeFromParent();
+	}
+}, x = class extends b {}, S = class extends b {}, C = class extends b {}, w = class extends b {}, T = class extends b {}, E = class extends _.Group {
+	direction;
+	constructor(e) {
+		super(), this.direction = e || "x";
+	}
+};
+_.Line;
+var D = class extends _.Mesh {
+	direction;
+	constructor(e, t, n) {
+		super(e, t), this.direction = n || "x";
+	}
+};
+//#endregion
+//#region src/shared-utils/Object3DHelper/utils/calculateThreeMouse.ts
+function ee(e, t) {
+	let { offsetWidth: n, offsetHeight: r } = t, { top: i, left: a } = t.getBoundingClientRect();
+	return Object.assign(new _.Vector2(), {
+		x: (e.x - a) / n * 2 - 1,
+		y: -(e.y - i) / r * 2 + 1
+	});
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/utils/getMouseRaycaster.ts
+function O(e, t, n) {
+	if (!t || !n || !e) return;
+	let r = ee(t, n);
+	if (Math.abs(r.x) === 1 || Math.abs(r.y) === 1) return;
+	let i = new _.Raycaster();
+	return i.setFromCamera(r, e), i.params.Points.threshold = .1, i;
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/Constants/RenderOrder.ts
+var k = {
+	ROTATE_HELPER: 9992,
+	MOVE_HELPER: 9993,
+	SCALE_HELPER_LINE: 9994,
+	SCALE_HELPER_SPHERE: 9995,
+	MOVE_HELPER_ARROW: 10001,
+	MOVE_HELPER_CENTER: 10002,
+	DRAG_GUIDE_LINE: 10003,
+	DRAG_FACE_PATCH: 10004
+}, A = class extends E {
+	line;
+	arrow;
+	lineHeight = .4;
+	arrowHeight = .1;
+	name = "ArrowGroup";
+	constructor(e) {
+		super(e.direction);
+		let t = new _.Color(e.color ?? 16214315), n = new _.MeshBasicMaterial({
+			color: t,
+			transparent: !0,
+			opacity: 1,
+			depthTest: !1,
+			depthWrite: !1
+		}), r = new D(new _.ConeGeometry(.04, .1, 32), n.clone(), e.direction);
+		r.name = `arrow-${e.direction}`, r.renderOrder = k.MOVE_HELPER_ARROW, this.arrow = r;
+		let i = .004, a = new D(new _.CylinderGeometry(i, i, .4, 32), n.clone(), e.direction);
+		a.name = `line-${e.direction}`, a.renderOrder = k.MOVE_HELPER_ARROW, this.line = a, 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);
+	}
+}, j = class extends E {
+	cube;
+	name = "CenterHandle";
+	faceMaterials;
+	baseColor;
+	faceNormals = [
+		new _.Vector3(1, 0, 0),
+		new _.Vector3(-1, 0, 0),
+		new _.Vector3(0, 1, 0),
+		new _.Vector3(0, -1, 0),
+		new _.Vector3(0, 0, 1),
+		new _.Vector3(0, 0, -1)
+	];
+	constructor(e) {
+		super("plane"), this.baseColor = new _.Color(e?.color ?? 16419862);
+		let t = e?.size ?? .05, n = new _.Color(16755008);
+		this.faceMaterials = Array.from({ length: 6 }, () => new _.MeshBasicMaterial({
+			color: n,
+			transparent: !0,
+			opacity: 1,
+			depthTest: !1,
+			depthWrite: !1,
+			side: _.FrontSide
+		}));
+		let r = new _.BoxGeometry(t, t, t), i = new _.Mesh(r, this.faceMaterials);
+		i.direction = "plane", i.renderOrder = k.MOVE_HELPER_CENTER, i.name = "center-plane-handle", this.cube = i, this.add(this.cube);
+	}
+	update(e) {
+		let t = new _.Vector3().subVectors(e.position, this.cube.getWorldPosition(new _.Vector3())).normalize(), n = this.cube.getWorldQuaternion(new _.Quaternion()), r = this.faceNormals.map((e, r) => {
+			let i = e.clone().applyQuaternion(n).dot(t);
+			return {
+				index: r,
+				angle: Math.acos(Math.abs(i))
+			};
+		});
+		r.sort((e, t) => e.angle - t.angle);
+		let i = [
+			new _.Color(16755008),
+			new _.Color(16419862),
+			new _.Color(13921032)
+		];
+		r.forEach((e, t) => {
+			let n = Math.floor(t / 2);
+			this.faceMaterials[e.index].color.copy(i[n]);
+		});
+	}
+}, M = {
+	X: 16730698,
+	Y: 54927,
+	Z: 3368703
+}, N = class {
+	static get X() {
+		return new _.Color(M.X);
+	}
+	static get Y() {
+		return new _.Color(M.Y);
+	}
+	static get Z() {
+		return new _.Color(M.Z);
+	}
+};
+//#endregion
+//#region src/shared-utils/Object3DHelper/utils/calculateScaleByCamera.ts
+function P(e, t, n) {
+	let r = e.position.distanceTo(t), i = e.fov, a = e.distance || 3, o = r / 3, s = i / 90, c = a / 3, l = o * s * c, u = n?.min || .6, d = n?.max;
+	return u && l < u ? u : d && l > d ? d : l;
+}
+//#endregion
+//#region src/shared-utils/clamp.ts
+function F(e, t, n) {
+	return e < t ? t : e > n ? n : e;
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/utils/getPoseFromCamera.ts
+function te(e) {
+	let t = e.pose.latitude, n = e.pose.longitude;
+	if (c(t) || c(n)) {
+		let r = e.matrix.elements;
+		t = Math.asin(F(r[9], -1, 1)), n = Math.abs(r[9]) < .9999999 ? o(Math.atan2(r[8], r[10])) : o(Math.atan2(-r[2], r[0]));
+	}
+	return {
+		latitude: t,
+		longitude: n
+	};
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/utils/getOrthographicCameraDirection.ts
+function ne(e) {
+	let { latitude: t, longitude: n } = e, r = new _.Vector3();
+	return I - t < .03 ? r.set(0, 1, 0) : L(0, n) ? r.set(0, 0, 1) : L(Math.PI, n) ? r.set(0, 0, -1) : L(I, n) ? r.set(1, 0, 0) : r.set(-1, 0, 0), r;
+}
+var I = Number((Math.PI / 2).toFixed(5));
+function L(e, t) {
+	return typeof e != "number" || typeof t != "number" ? !1 : Math.abs(e - t) < .001;
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/Helper/MoveHelper.ts
+var R = class extends x {
+	name = "MoveHelper";
+	xArrow;
+	yArrow;
+	zArrow;
+	centerHandle;
+	constructor(e, t) {
+		super(e, t), t.xArrowEnable !== !1 && (this.xArrow = new A({
+			direction: "x",
+			color: N.X
+		})), t.yArrowEnable !== !1 && (this.yArrow = new A({
+			direction: "y",
+			color: N.Y
+		})), t.zArrowEnable !== !1 && (this.zArrow = new A({
+			direction: "z",
+			color: N.Z
+		})), t.centerHandleEnable !== !1 && (this.centerHandle = new j()), this.add(...[
+			this.xArrow,
+			this.yArrow,
+			this.zArrow,
+			this.centerHandle
+		].filter(Boolean));
+	}
+	update(e) {
+		this.xArrow && (this.xArrow.visible = !0), this.yArrow && (this.yArrow.visible = !0), this.zArrow && (this.zArrow.visible = !0), this.centerHandle && this.centerHandle.update(e);
+		let t = this.helperObject.position.clone().sub(e.position).normalize(), n = new _.Vector3(1, 0, 0).applyQuaternion(this.quaternion), r = new _.Vector3(0, 1, 0).applyQuaternion(this.quaternion), i = new _.Vector3(0, 0, 1).applyQuaternion(this.quaternion);
+		if (e.type === "OrthographicCamera") {
+			let t = ne(te(e)), a = .0872665;
+			Math.abs(n.angleTo(t) - 0) < a || Math.abs(n.angleTo(t) - Math.PI) < a ? this.xArrow && (this.xArrow.visible = !1) : Math.abs(r.angleTo(t) - 0) < a || Math.abs(r.angleTo(t) - Math.PI) < a ? this.yArrow && (this.yArrow.visible = !1) : (Math.abs(i.angleTo(t) - 0) < a || Math.abs(i.angleTo(t) - Math.PI) < a) && this.zArrow && (this.zArrow.visible = !1);
+		}
+		if (e.type !== "OrthographicCamera") {
+			let e = t.angleTo(n), a = t.angleTo(r), o = t.angleTo(i), s = Math.PI / 2, c = a < s, l = o < s, u = e < s;
+			this.xArrow && (u ? (this.xArrow.scale.x = -1, this.xArrow.scale.y = 1, this.xArrow.scale.z = 1) : (this.xArrow.scale.x = 1, this.xArrow.scale.y = 1, this.xArrow.scale.z = 1)), this.yArrow && (c ? (this.yArrow.scale.x = 1, this.yArrow.scale.y = -1, this.yArrow.scale.z = 1) : (this.yArrow.scale.x = 1, this.yArrow.scale.y = 1, this.yArrow.scale.z = 1)), this.zArrow && (l ? (this.zArrow.scale.x = 1, this.zArrow.scale.y = 1, this.zArrow.scale.z = -1) : (this.zArrow.scale.x = 1, this.zArrow.scale.y = 1, this.zArrow.scale.z = 1));
+		}
+	}
+	show() {
+		super.show(), this.xArrow && this.add(this.xArrow), this.yArrow && this.add(this.yArrow), this.zArrow && this.add(this.zArrow), this.centerHandle && this.add(this.centerHandle);
+	}
+	setScaleByCamera(e) {
+		this.scale.setScalar(P(e, this.position));
+	}
+	showDraggingHelper(e) {
+		this.xArrow && (e.includes("x") ? this.add(this.xArrow) : this.remove(this.xArrow)), this.yArrow && (e.includes("y") ? this.add(this.yArrow) : this.remove(this.yArrow)), this.zArrow && (e.includes("z") ? this.add(this.zArrow) : this.remove(this.zArrow)), this.centerHandle && (e.includes("plane") ? this.add(this.centerHandle) : this.remove(this.centerHandle));
+	}
+	dispose() {
+		this.remove(...[
+			this.xArrow,
+			this.yArrow,
+			this.zArrow,
+			this.centerHandle
+		].filter(Boolean)), super.dispose();
+	}
+};
+//#endregion
+//#region src/shared-utils/Object3DHelper/Helper/HTML/utils/createElement.ts
+function z(e, t) {
+	return re(document.createElement(t ?? "div"), e);
+}
+function re(e, t) {
+	if (!t) return e;
+	for (let n in t) n && t[n] && (e.style[n] = t[n]);
+	return e;
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/Helper/HTML/tipsDom.ts
+function ie(e) {
+	let t = z({
+		position: "absolute",
+		display: "block",
+		borderRadius: "4px",
+		paddingTop: "1px",
+		paddingBottom: "1px",
+		paddingLeft: "4px",
+		paddingRight: "4px",
+		pointerEvents: "none",
+		userSelect: "none",
+		zIndex: "99999",
+		backgroundColor: "rgba(0,0,0,0.7)",
+		fontSize: "12px",
+		color: "#fff",
+		letterSpacing: "0",
+		lineHeight: "18px",
+		...e
+	}), n = () => {
+		t.style.display !== "block" && t.style.top && t.style.left && (t.style.display = "block");
+	};
+	return {
+		element: t,
+		show: n,
+		hide: () => {
+			t.style.display = "none", t.style.top = "", t.style.left = "";
+		},
+		setLeftTop: (e, r) => {
+			t.style.left = e, t.style.top = r, n();
+		}
+	};
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/Helper/RotateHelper.ts
+var ae = class extends C {
+	name = "RotateHelper";
+	xCircle;
+	yCircle;
+	zCircle;
+	children = [];
+	angleTips;
+	container;
+	constructor(e, t) {
+		super(e, t), t?.yzCircleEnable !== !1 && (this.xCircle = new B({
+			direction: "x",
+			color: N.X
+		})), t?.xzCircleEnable !== !1 && (this.yCircle = new B({
+			direction: "y",
+			color: N.Y
+		})), t?.xyCircleEnable !== !1 && (this.zCircle = new B({
+			direction: "z",
+			color: N.Z
+		})), t?.container && t?.angleTipsEnable !== !1 && (this.container = t?.container, this.angleTips = ie({ display: "none" }), this.container.appendChild(this.angleTips.element)), this.add(...[
+			this.xCircle,
+			this.yCircle,
+			this.zCircle
+		].filter(Boolean)), this.show();
+	}
+	hide() {
+		this.children.forEach((e) => e.hide());
+	}
+	show() {
+		this.children.forEach((e) => e.showCircle()), this.angleTips?.hide();
+	}
+	setScaleByCamera(e) {
+		this.scale.setScalar(P(e, this.position));
+	}
+	update(e) {
+		if (e.type === "OrthographicCamera") return;
+		let t = this.helperObject.position.clone().sub(e.position).normalize(), n = new _.Vector3(1, 0, 0).applyQuaternion(this.quaternion), r = new _.Vector3(0, 1, 0).applyQuaternion(this.quaternion), i = new _.Vector3(0, 0, 1).applyQuaternion(this.quaternion), a = t.angleTo(n), o = t.angleTo(r), s = t.angleTo(i), c = Math.PI / 2, l = o >= c, u = s >= c, d = a >= c;
+		if (this.xCircle) {
+			let e = this.xCircle.circle.gapAngle;
+			l && u ? this.xCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, e, Math.PI / 2 - e * 2) : l && !u ? this.xCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, Math.PI / 2 + e, Math.PI / 2 - e * 2) : !l && u ? this.xCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, Math.PI / 2 * 3 + e, Math.PI / 2 - e * 2) : !l && !u && (this.xCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, Math.PI + e, Math.PI / 2 - e * 2)), this.xCircle.angleSector && (this.xCircle.angleSector.offsetAngle = (e) => e, l && u || l && !u ? this.xCircle.angleSector.baseAxes = new _.Vector3(0, 0, 1) : !l && u ? (this.xCircle.angleSector.baseAxes = new _.Vector3(0, -1, 0), this.xCircle.angleSector.offsetAngle = (e) => e - Math.PI / 2) : !l && !u && (this.xCircle.angleSector.baseAxes = new _.Vector3(0, 0, -1), this.xCircle.angleSector.offsetAngle = (e) => e - Math.PI));
+		}
+		if (this.yCircle) {
+			this.yCircle.angleSector.offsetAngle = (e) => e;
+			let e = this.yCircle.circle.gapAngle;
+			d && u ? this.yCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, e, Math.PI / 2 - e * 2) : d && !u ? this.yCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, Math.PI / 2 * 3 + e, Math.PI / 2 - e * 2) : !d && u ? this.yCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, Math.PI / 2 + e, Math.PI / 2 - e * 2) : !d && !u && (this.yCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, Math.PI + e, Math.PI / 2 - e * 2)), d && u ? this.yCircle.angleSector.baseAxes = new _.Vector3(1, 0, 0) : d && !u ? (this.yCircle.angleSector.baseAxes = new _.Vector3(0, 0, -1), this.yCircle.angleSector.offsetAngle = (e) => e - Math.PI / 2) : !d && u ? (this.yCircle.angleSector.baseAxes = new _.Vector3(0, 0, 1), this.yCircle.angleSector.offsetAngle = (e) => e + Math.PI / 2) : !d && !u && (this.yCircle.angleSector.baseAxes = new _.Vector3(-1, 0, 0), this.yCircle.angleSector.offsetAngle = (e) => e + Math.PI);
+		}
+		if (this.zCircle) {
+			this.zCircle.angleSector.offsetAngle = (e) => e;
+			let e = this.zCircle.circle.gapAngle;
+			d && l ? this.zCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, e, Math.PI / 2 - e * 2) : d && !l ? this.zCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, Math.PI / 2 * 3 + e, Math.PI / 2 - e * 2) : !d && l ? this.zCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, Math.PI / 2 + e, Math.PI / 2 - e * 2) : !d && !l && (this.zCircle.circle.geometry = new _.RingGeometry(.25, .3, 20, 8, Math.PI + e, Math.PI / 2 - e * 2)), this.zCircle.angleSector && (d && l ? this.zCircle.angleSector.baseAxes = new _.Vector3(1, 0, 0) : d && !l ? (this.zCircle.angleSector.baseAxes = new _.Vector3(0, -1, 0), this.zCircle.angleSector.offsetAngle = (e) => e - Math.PI / 2) : !d && l ? (this.zCircle.angleSector.baseAxes = new _.Vector3(0, 1, 0), this.zCircle.angleSector.offsetAngle = (e) => e + Math.PI / 2) : !d && !l && (this.zCircle.angleSector.baseAxes = new _.Vector3(-1, 0, 0), this.zCircle.angleSector.offsetAngle = (e) => e + Math.PI));
+		}
+	}
+	showDraggingHelper(e) {
+		this.hide(), this.children.filter((t) => e.includes(t.direction)).forEach((e) => e.showRing()), this.angleTips?.show();
+	}
+	dispose() {
+		this.removeFromParent(), this.angleTips?.element?.remove();
+	}
+}, B = class extends _.Group {
+	direction;
+	circle;
+	ring;
+	angleSector;
+	constructor(e) {
+		super(), this.direction = e.direction, this.circle = new oe(e), this.ring = new se(e), this.angleSector = new ce(e), this.add(this.circle, this.ring, this.angleSector), this.direction === "y" ? this.rotation.x = Math.PI / 2 : this.direction === "x" && (this.rotation.y = -Math.PI / 2);
+	}
+	showCircle() {
+		this.add(this.circle), this.remove(this.ring, this.angleSector);
+	}
+	showRing() {
+		this.add(this.ring, this.angleSector), this.remove(this.circle);
+	}
+	hide() {
+		this.remove(this.ring, this.angleSector, this.circle);
+	}
+}, oe = class extends _.Mesh {
+	direction;
+	gapAngle = .02;
+	geometry = new _.RingGeometry(.25, .3, 20, 8, this.gapAngle, Math.PI / 2 - this.gapAngle * 2);
+	constructor(e) {
+		super(), this.material = new _.MeshBasicMaterial({
+			opacity: .6,
+			transparent: !0,
+			color: e.color ?? 16777215,
+			side: _.DoubleSide,
+			depthTest: !1
+		}), this.direction = e.direction, this.renderOrder = k.ROTATE_HELPER, this.geometry.name = `RotateHelperCircleGeometry-${this.direction}`;
+	}
+}, se = class extends _.Group {
+	direction;
+	constructor(e) {
+		super(), this.direction = e.direction;
+		let t = .015, n = Array(8).fill(null).map((e, n) => {
+			let r = new _.RingGeometry(.25, .3, 20, 8, Math.PI / 4 * n + t, Math.PI / 4 - t * 2), i = new _.MeshBasicMaterial({
+				opacity: 1,
+				color: 16777215,
+				depthTest: !1,
+				depthWrite: !1,
+				transparent: !0,
+				side: _.DoubleSide
+			}), a = new _.Mesh(r, i);
+			return a.name = `AxesDashedRing-${this.direction}-${n}`, a;
+		});
+		this.add(...n);
+	}
+}, ce = class extends _.Mesh {
+	direction;
+	baseAxes;
+	offsetAngle = (e) => e;
+	angleDirection;
+	constructor(e) {
+		switch (super(), e.direction) {
+			case "x":
+				this.baseAxes = new _.Vector3(0, 0, 1);
+				break;
+			case "y":
+				this.baseAxes = new _.Vector3(1, 0, 0);
+				break;
+			case "z": this.baseAxes = new _.Vector3(1, 0, 0);
+		}
+		this.geometry = new _.CircleGeometry(.3005, 48, 0, 1e-4), this.material = new _.MeshBasicMaterial({
+			opacity: .4,
+			color: e.color ?? 16777215,
+			depthTest: !1,
+			depthWrite: !1,
+			transparent: !0,
+			side: _.DoubleSide
+		}), this.direction = e.direction, this.angleDirection = this.direction === "z" ? 1 : -1;
+	}
+	setClockwiseDirection() {
+		this.angleDirection = -1;
+	}
+	setCounterClockwiseDirection() {
+		this.angleDirection = 1;
+	}
+	toggleDirection() {
+		this.angleDirection = this.angleDirection === 1 ? -1 : 1;
+	}
+	setBaseAxes(e) {
+		this.baseAxes = e.clone().normalize();
+	}
+	getDirection() {
+		return this.angleDirection === -1 ? "clockwise" : "counterclockwise";
+	}
+};
+//#endregion
+//#region src/shared-utils/Object3DHelper/Helper/HTML/rectangleScaleDom.ts
+function le() {
+	let e = z({
+		width: "100%",
+		height: "100%",
+		left: "0",
+		top: "0",
+		position: "absolute",
+		pointerEvents: "none"
+	}), t = z({
+		boxSizing: "border-box",
+		width: "100%",
+		height: "100%",
+		left: "0",
+		top: "0",
+		position: "relative",
+		display: "flex",
+		alignItems: "center",
+		justifyContent: "center"
+	}), n = z({
+		boxSizing: "border-box",
+		width: "100%",
+		height: "100%",
+		left: "0",
+		top: "0",
+		position: "absolute",
+		border: "1px solid rgba(255,255,255,0.4)"
+	});
+	e.appendChild(t), t.appendChild(n);
+	let r = "-4px", i = {
+		direction: "nesw",
+		element: V({
+			cursor: "nesw-resize",
+			left: r,
+			bottom: r
+		})
+	}, a = {
+		direction: "ns",
+		element: V({
+			cursor: "ns-resize",
+			bottom: r
+		})
+	}, o = {
+		direction: "nwse",
+		element: V({
+			cursor: "nwse-resize",
+			right: r,
+			bottom: r
+		})
+	}, s = {
+		direction: "ew",
+		element: V({
+			cursor: "ew-resize",
+			right: r
+		})
+	}, c = {
+		direction: "nesw",
+		element: V({
+			cursor: "nesw-resize",
+			right: r,
+			top: r
+		})
+	}, l = {
+		direction: "ns",
+		element: V({
+			cursor: "ns-resize",
+			top: r
+		})
+	}, u = {
+		direction: "nwse",
+		element: V({
+			cursor: "nwse-resize",
+			left: r,
+			top: r
+		})
+	}, d = {
+		direction: "ew",
+		element: V({
+			cursor: "ew-resize",
+			left: r
+		})
+	};
+	return [
+		a,
+		s,
+		l,
+		d,
+		i,
+		o,
+		c,
+		u
+	].forEach((e) => t.appendChild(e.element)), {
+		container: e,
+		spheres: [
+			i,
+			a,
+			o,
+			s,
+			c,
+			l,
+			u,
+			d
+		]
+	};
+}
+function V(e) {
+	let t = z({
+		background: "#FFFF00",
+		width: "9px",
+		height: "9px",
+		position: "absolute",
+		pointerEvents: "none",
+		borderRadius: "50%",
+		...e
+	}), n = z({
+		width: "15px",
+		height: "15px",
+		position: "absolute",
+		left: "50%",
+		top: "50%",
+		transform: "translate(-50%, -50%)",
+		pointerEvents: "none"
+	}), r = z({
+		width: "15px",
+		height: "15px",
+		cursor: e?.cursor,
+		pointerEvents: "auto",
+		background: "transparent"
+	});
+	return r.draggable = !0, n.appendChild(r), t.appendChild(n), t;
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/utils/cameraHooks.ts
+var H = /* @__PURE__ */ new Map();
+function U(t) {
+	if (H.has(t)) return H.get(t).hooks;
+	let n = new e(), r = null, i, a = () => {
+		r = requestAnimationFrame(a);
+		let e = t.projectionMatrix.toArray().join(",") + t.matrixWorld.toArray().join(",");
+		e !== i && (i = e, n.emit("cameraUpdate"));
+	};
+	return a(), H.set(t, {
+		hooks: n,
+		dispose: () => {
+			H.delete(t), cancelAnimationFrame(r);
+		}
+	}), n;
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/Helper/CSS3DScaleHelper.ts
+var ue = class extends T {
+	name = "CSS3DScaleHelper";
+	points = [];
+	cornerPositions = [];
+	css3DInstance;
+	get helperObject() {
+		if (!this.css3DInstance?.css3DObject) throw Error("css3DInstance is not initialized");
+		return this.css3DInstance.css3DObject;
+	}
+	plane;
+	css3DRenderer = new p();
+	camera;
+	scene;
+	container;
+	enabled = !1;
+	initialScale;
+	constructor(e, t, n, r) {
+		super(e), this.camera = n, this.scene = r, this.container = t, this.initRectangleScaleHelper();
+	}
+	initQuaternion() {
+		this.quaternion.copy(this.originObject3D.quaternion);
+	}
+	applyMatrix4(e) {
+		super.applyMatrix4(e), this.helperObject.applyMatrix4(e), this.plane?.applyMatrix4(e), this.cornerPositions.forEach((t) => t.applyMatrix4(e));
+	}
+	showDraggingHelper() {}
+	applyHelperScaleMatrix4(e, t) {
+		this.plane?.scale.applyMatrix4(e), this.helperObject.applyScaleMatrix4(e), setTimeout(() => {
+			this.updateSphereCorrection();
+		}, 0);
+	}
+	updatePoints() {
+		let e = this.calculatePointPosition(this.cornerPositions);
+		this.points.forEach((t, n) => {
+			t.position.copy(e[n]);
+		});
+	}
+	update(e) {
+		this.css3DInstance?.css3DObject && this.helperObject.position.copy(this.originObject3D.position), this.plane && this.plane.position.copy(this.originObject3D.position), this.updatePoints(), this.css3DInstance && this.css3DInstance.show(), this.plane && (this.plane.visible = !0);
+	}
+	applyHelperQuaternion(e, t) {
+		let n = this.css3DInstance?.css3DObject;
+		if (n) {
+			let r = new _.Vector3().subVectors(n.position, t).applyQuaternion(e).add(t);
+			n.position.copy(r), n.applyQuaternion(e);
+		}
+		if (this.plane) {
+			let n = new _.Vector3().subVectors(this.plane.position, t).applyQuaternion(e).add(t);
+			this.plane.position.copy(n), this.plane.applyQuaternion(e);
+		}
+		this.cornerPositions.forEach((n) => {
+			let r = new _.Vector3().subVectors(n, t).applyQuaternion(e).add(t);
+			n.copy(r);
+		});
+	}
+	enable() {
+		this.enabled || (this.enabled = !0, this.css3DInstance?.enable(), this.plane && this.scene.add(this.plane));
+	}
+	disable() {
+		this.enabled && (this.enabled = !1, this.css3DInstance?.disable(), this.plane && this.scene.remove(this.plane));
+	}
+	show() {
+		this.css3DInstance?.show(), this.plane && (this.plane.visible = !0);
+	}
+	hide() {
+		this.css3DInstance?.hide(), this.plane && (this.plane.visible = !1);
+	}
+	dispose() {
+		this.disable(), this.css3DRenderer.dispose();
+	}
+	onScaleEnd() {
+		U(this.camera).emit("cameraUpdate");
+	}
+	updateSphereCorrection() {
+		if (!this.css3DInstance) return;
+		this.initialScale ||= {
+			x: this.originObject3D.scale.x,
+			y: this.originObject3D.scale.y
+		};
+		let e = this.originObject3D.scale, t = e.x / this.initialScale.x, n = e.y / this.initialScale.y, r = this.css3DInstance.css3DObject.container;
+		r.style.setProperty("--parent-scaleX", t.toString()), r.style.setProperty("--parent-scaleY", n.toString());
+	}
+	initRectangleScaleHelper() {
+		let e = this.getCornerPositions();
+		if (!e) return;
+		this.cornerPositions = e;
+		let t = this.css3DRenderer.create3DElement(this.camera, e, { ratio: .003 });
+		if (!t) return;
+		this.css3DInstance = t, t.appendToElement(this.container);
+		let n = t.css3DObject.container, { container: r, spheres: i } = le();
+		this.points = i.map((t, n) => ({
+			direction: t.direction,
+			point: t.element,
+			position: this.calculatePointPosition(e)[n]
+		})), n.insertBefore(r, n.children[0] ?? null), this.helperObject.position.copy(this.originObject3D.position), this.plane?.position.copy(this.originObject3D.position);
+	}
+	getCornerPositions() {
+		let { originObject3D: e } = this;
+		if (e.isCSS3DObject && e.cornerPoints) return e.cornerPoints;
+		console.error("当前物体暂时不支持 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)
+		];
+	}
+}, de = class extends S {
+	name = "BoundingBoxHelper";
+	box;
+	outline;
+	positionAttribute;
+	constructor(e) {
+		super(e), this.positionAttribute = new _.BufferAttribute(/* @__PURE__ */ new Float32Array(24), 3), this.box = this.createBox(), this.outline = this.createOutline(), this.add(this.box, this.outline), this.update();
+	}
+	initQuaternion() {
+		this.quaternion.copy(this.originObject3D.quaternion);
+	}
+	setHelperQuaternion(e, t) {
+		y(this, e, t);
+	}
+	raycasterIntersectObject(e, t) {
+		return e.intersectObject(this, !1, t);
+	}
+	raycast(e, t) {
+		this.box.raycast(e, t);
+	}
+	update() {
+		let e = f(this.originObject3D);
+		if (!e) return;
+		let { min: t, max: n } = e;
+		this.positionAttribute.setXYZ(0, n.x, n.y, n.z), this.positionAttribute.setXYZ(1, t.x, n.y, n.z), this.positionAttribute.setXYZ(2, t.x, t.y, n.z), this.positionAttribute.setXYZ(3, n.x, t.y, n.z), this.positionAttribute.setXYZ(4, n.x, n.y, t.z), this.positionAttribute.setXYZ(5, t.x, n.y, t.z), this.positionAttribute.setXYZ(6, t.x, t.y, t.z), this.positionAttribute.setXYZ(7, n.x, t.y, t.z), this.positionAttribute.needsUpdate = !0;
+	}
+	createOutline() {
+		let e = new Uint16Array([
+			0,
+			1,
+			1,
+			2,
+			2,
+			3,
+			3,
+			0,
+			4,
+			5,
+			5,
+			6,
+			6,
+			7,
+			7,
+			4,
+			0,
+			4,
+			1,
+			5,
+			2,
+			6,
+			3,
+			7
+		]), t = new _.BufferGeometry();
+		t.setIndex(new _.BufferAttribute(e, 1)), t.setAttribute("position", this.positionAttribute);
+		let n = new _.LineBasicMaterial({
+			color: 64767,
+			linewidth: 1,
+			opacity: 1,
+			toneMapped: !1
+		}), r = new _.LineSegments(t, n);
+		return r.matrixAutoUpdate = !1, r;
+	}
+	createBox() {
+		let e = new Uint16Array([
+			0,
+			1,
+			2,
+			0,
+			2,
+			3,
+			0,
+			3,
+			7,
+			0,
+			7,
+			4,
+			0,
+			4,
+			5,
+			0,
+			5,
+			1,
+			6,
+			1,
+			5,
+			6,
+			2,
+			1,
+			6,
+			5,
+			4,
+			6,
+			4,
+			7,
+			6,
+			3,
+			2,
+			6,
+			7,
+			3
+		]), t = new _.BufferGeometry();
+		t.setIndex(new _.BufferAttribute(e, 1)), t.setAttribute("position", this.positionAttribute);
+		let n = new _.MeshBasicMaterial({
+			color: 64767,
+			opacity: .1,
+			depthTest: !1,
+			transparent: !0
+		});
+		return new _.Mesh(t, n);
+	}
+}, W = class {
+	originObject3D;
+	hooks;
+	preventTapDefaultEvent = !1;
+	internalHooks;
+	disposers = [];
+	helperObject3D;
+	camera;
+	model;
+	scene;
+	container;
+	domEvents;
+	isDragging = !1;
+	enabled = !1;
+	name = "BaseController";
+	boundingBox;
+	config;
+	onRender;
+	cameraHooks;
+	otherControllers;
+	updateOtherControllers(e) {
+		this.otherControllers = e;
+	}
+	getIsDragging() {
+		return this.isDragging;
+	}
+	constructor(t, n) {
+		this.hooks = t.sharedHooks ?? new e(), this.internalHooks = t.sharedInternalHooks ?? new e(), this.camera = t.camera, this.model = t.model, this.originObject3D = t.originObject3D, this.helperObject3D = t.helperObject3D, this.container = t.container, this.scene = t.scene, this.domEvents = t.domEvents, this.onRender = t.onRender ?? (() => {}), this.config = n ?? {}, this.otherControllers = t.otherControllers, this.initialHelperPosition(), this.initialHelperQuaternion(), this.updateHelperScale(), this.cameraHooks = U(this.camera), this.enable();
+		let r = this.onSetOriginObjectScale.bind(this), i = this.onSetOriginObjectRotate.bind(this), a = this.onSetOriginObjectPosition.bind(this), o = this.onApplyOriginObjectScale.bind(this), s = this.onApplyOriginObjectRotate.bind(this), c = this.onApplyOriginObjectPosition.bind(this), l = this.initialHelperPosition.bind(this);
+		this.cameraHooks.on("cameraUpdate", this.updateHelperScale), this.internalHooks.on("initialHelperPosition", l), this.internalHooks.on("setObjectScale", r), this.internalHooks.on("setObjectRotate", i), this.internalHooks.on("setObjectPosition", a), this.internalHooks.on("applyObjectPosition", c), this.internalHooks.on("applyObjectRotate", s), this.internalHooks.on("applyObjectScale", o), this.hooks.on("moveEnd", this.updateHelperScale), this.internalHooks.on("setObjectPosition", this.updateHelperScale), this.internalHooks.on("initialHelperPosition", this.updateHelperScale), this.disposers.push(() => {
+			this.cameraHooks.off("cameraUpdate", this.updateHelperScale), this.internalHooks.off("initialHelperPosition", l), this.internalHooks.off("setObjectScale", r), this.internalHooks.off("setObjectRotate", i), this.internalHooks.off("setObjectPosition", a), this.internalHooks.off("applyObjectPosition", c), this.internalHooks.off("applyObjectRotate", s), this.internalHooks.off("applyObjectScale", o), this.hooks.off("moveEnd", this.updateHelperScale), this.internalHooks.off("setObjectPosition", this.updateHelperScale), this.internalHooks.off("initialHelperPosition", this.updateHelperScale);
+		});
+	}
+	initialHelperPosition() {
+		this.helperObject3D.initialPosition(this.calculateOffset(this.config.offset));
+	}
+	initialHelperQuaternion() {
+		this.helperObject3D.initQuaternion(this.config);
+	}
+	enable() {
+		this.enabled || (this.enabled = !0, this.scene.add(this.helperObject3D), this.helperObject3D.enable(), this.render());
+	}
+	disable() {
+		this.enabled && (this.enabled = !1, this.helperObject3D.disable(), this.render());
+	}
+	show() {
+		this.helperObject3D.show(), this.render();
+	}
+	hide() {
+		this.helperObject3D.hide(), this.render();
+	}
+	dispose() {
+		this.disposers?.forEach((e) => e?.()), this.helperObject3D.dispose(), this.render();
+	}
+	applyHelperMatrix4(e) {
+		this.helperObject3D.applyMatrix4(e);
+	}
+	applyHelperQuaternion(e, t) {
+		this.helperObject3D.applyHelperQuaternion(e, t);
+	}
+	applyHelperScaleMatrix4(e, t) {
+		this.helperObject3D.applyHelperScaleMatrix4(e, t);
+	}
+	onWantsTapGesture = (e) => {
+		if (this.getIntersectObject(e)) return !1;
+	};
+	updateHelperScale = () => {
+		"update" in this.helperObject3D && typeof this.helperObject3D.update == "function" && this.helperObject3D.update(this.camera), this.helperObject3D.setScaleByCamera(this.camera);
+	};
+	onWantsGesture(e, t, n) {
+		if (this.isDragging) return !1;
+	}
+	onIntersectionOnModelUpdate(e) {}
+	onApplyOriginObjectScale(e) {
+		this.applyHelperScaleMatrix4(e.matrix, e.origin);
+	}
+	onApplyOriginObjectRotate(e) {
+		this.applyHelperQuaternion(e.quaternion, e.origin);
+	}
+	onApplyOriginObjectPosition(e) {
+		this.applyHelperMatrix4(e.matrix);
+	}
+	onSetOriginObjectScale(e) {
+		this.helperObject3D.scale.copy(e), this.updateOffsetByScale(e);
+	}
+	onSetOriginObjectRotate(e, t) {
+		this.helperObject3D.setHelperQuaternion(e, t);
+	}
+	onSetOriginObjectPosition(e) {
+		this.helperObject3D.position.copy(e.clone().add(this.calculateOffset(this.config.offset)));
+	}
+	render() {
+		this.onRender();
+	}
+	updateOffsetByScale(e) {
+		if (this.boundingBox && this.config.offset) {
+			let t = this.originObject3D.position, n = new _.Vector3().subVectors(this.boundingBox.max, t).multiply(e).add(t), r = new _.Vector3().subVectors(this.boundingBox.min, t).multiply(e).add(t), i = this.calculateOffset(this.config.offset, {
+				min: r,
+				max: n
+			});
+			this.helperObject3D.initialPosition(i);
+		}
+	}
+	hoverListener(e, t = 16777215, n = 1) {
+		let i = r(e).filter(s), a = [];
+		for (let e of i) if (e.material || e instanceof _.Group) {
+			let r = e instanceof _.Group ? e.children.filter((e) => e instanceof _.Mesh) : [e];
+			r.forEach((e) => {
+				Array.isArray(e.material) ? (e.__originalColor__ = e.__originalColor__ ?? e.material.map((e) => e.color.clone()), e.__originalOpacity__ = e.__originalOpacity__ ?? e.material.map((e) => e.opacity)) : (e.__originalColor__ = e.__originalColor__ ?? e.material.color.clone(), e.__originalOpacity__ = e.__originalOpacity__ ?? e.material.opacity);
+			});
+			let i = () => {
+				r.forEach((e) => {
+					e.name === "ScaleHelperTransparentGroup" ? e.children[0] && (e.children[0].material.color.set(t), e.children[0].material.opacity = n) : Array.isArray(e.material) ? e.material.forEach((e) => {
+						e.color.set(t), e.opacity = n;
+					}) : (e.material.color.set(t), e.material.opacity = n);
+				}), this.render();
+			}, o = () => {
+				r.forEach((e) => {
+					if (e.name === "ScaleHelperTransparentGroup") e.children[0] && (e.children[0].material.color.set(16776960), e.children[0].material.opacity = 1);
+					else if (Array.isArray(e.material)) {
+						let t = e.__originalColor__, n = e.__originalOpacity__;
+						e.material.forEach((e, r) => {
+							t && t[r] && e.color.copy(t[r]), n && n[r] !== void 0 && (e.opacity = n[r]);
+						});
+					} else e.material.color.copy(e.__originalColor__), e.material.opacity = e.__originalOpacity__;
+				}), this.render();
+			}, s = (e) => {
+				this.isDragging || i();
+			}, c = (e) => {
+				this.isDragging || o();
+			};
+			for (let e of r) this.domEvents.addEventListener(e, "mouseover", s), this.domEvents.addEventListener(e, "mouseout", c), this.hooks.on("moveStart", i), this.hooks.on("moveEnd", o), this.hooks.on("rotateEnd", o), this.hooks.on("scaleEnd", o), a.push(() => {
+				this.domEvents.removeEventListener(e, "mouseover", s), this.domEvents.removeEventListener(e, "mouseout", c), this.hooks.off("moveStart", i), this.hooks.off("moveEnd", o), this.hooks.off("rotateEnd", o), this.hooks.off("scaleEnd", o);
+			});
+		}
+		return () => a.forEach((e) => e?.());
+	}
+	getIntersectObject(e) {
+		let t = this.camera.position, n = this.helperObject3D;
+		if (!n) return;
+		let r = this.helperObject3D.raycasterIntersectObject(e)[0];
+		if (!r) return;
+		let i = r;
+		if (i.object = n, this.model.intersectRaycaster) {
+			let n = this.model.intersectRaycaster(e)[0];
+			if (n && n.point.distanceTo(t) < i.point.distanceTo(t)) return;
+		}
+		return i.object;
+	}
+	getBox = () => (this.boundingBox ||= f(this.originObject3D), this.boundingBox);
+	calculateOffset(e, t) {
+		let n = new _.Vector3(0, 0, 0);
+		if (!e) return n;
+		let r = () => t || this.getBox();
+		if (typeof e.x == "number") n.setX(e.x);
+		else if (typeof e.x == "object") {
+			let t = r();
+			n.setX((t.max.x - t.min.x) * e.x.percents);
+		}
+		if (typeof e.y == "number") n.setY(e.y);
+		else if (typeof e.y == "object") {
+			let t = r();
+			n.setY((t.max.y - t.min.y) * e.y.percents);
+		}
+		if (typeof e.z == "number") n.setZ(e.z);
+		else if (typeof e.z == "object") {
+			let t = r();
+			n.setZ((t.max.z - t.min.z) * e.z.percents);
+		}
+		return n;
+	}
+};
+//#endregion
+//#region src/shared-utils/Object3DHelper/utils/solidGuide.ts
+function fe(e, t) {
+	let n = 10, r = 10, i = e.isPerspectiveCamera, a = e.isOrthographicCamera;
+	if (i) {
+		let i = e, a = i.position.distanceTo(t), o = i.fov * Math.PI / 180;
+		r = 2 * Math.tan(o / 2) * a, n = r * i.aspect;
+	} else if (a) {
+		let t = e;
+		n = Math.abs(t.right - t.left), r = Math.abs(t.top - t.bottom);
+	}
+	let o = Math.sqrt(n * n + r * r), s = o * .8, c = Math.min(n, r) * .25, l = o * 1.2;
+	return Math.max(c, Math.min(s, l));
+}
+var G = class {
+	camera;
+	container;
+	defaults;
+	constructor(e, t, n) {
+		this.camera = e, this.container = t, this.defaults = { ...n || {} };
+	}
+	createSolidLine(e, t, n) {
+		let r = {
+			color: 16777215,
+			renderOrder: k.DRAG_GUIDE_LINE,
+			...this.defaults,
+			...n || {}
+		}, i = t.clone().normalize(), a = this.computeInfiniteLineLength(e), o = e.clone().add(i.clone().multiplyScalar(-a)), s = e.clone().add(i.clone().multiplyScalar(a)), c = new Float32Array([
+			o.x,
+			o.y,
+			o.z,
+			s.x,
+			s.y,
+			s.z
+		]), l = new _.BufferGeometry();
+		l.setAttribute("position", new _.BufferAttribute(c, 3));
+		let u = new _.LineBasicMaterial({
+			color: r.color,
+			depthTest: !1,
+			depthWrite: !1,
+			transparent: !0,
+			opacity: .65
+		}), d = new _.Line(l, u);
+		return d.renderOrder = r.renderOrder, d;
+	}
+	updateSolidLine(e, t, n, r) {
+		let i = n.clone().normalize(), a = this.computeInfiniteLineLength(t), o = t.clone().add(i.clone().multiplyScalar(-a)), s = t.clone().add(i.clone().multiplyScalar(a)), c = new Float32Array([
+			o.x,
+			o.y,
+			o.z,
+			s.x,
+			s.y,
+			s.z
+		]), l = e.geometry, u = l.getAttribute("position");
+		u && u.itemSize === 3 && u.array.length === c.length ? (u.array.set(c), u.needsUpdate = !0) : l.setAttribute("position", new _.BufferAttribute(c, 3)), r?.color !== void 0 && e.material.color.setHex(r.color);
+	}
+	computeInfiniteLineLength(e) {
+		return fe(this.camera, e) * 10;
+	}
+	dispose(e) {
+		if (!e) return;
+		e.geometry.dispose();
+		let t = e.material;
+		Array.isArray(t) ? t.forEach((e) => e.dispose()) : t.dispose();
+	}
+	updateDefaults(e) {
+		this.defaults = {
+			...this.defaults,
+			...e
+		};
+	}
+}, pe = class extends W {
+	get moveByMouseEnable() {
+		return this._moveByMouse.enabled;
+	}
+	name = "MoveController";
+	startInfo;
+	dragGuideLine;
+	solidGuide = new G(this.camera, this.container, this.config?.solidGuide ?? {});
+	_moveByMouse = { enabled: !1 };
+	mouseInfo;
+	mousedownEventListenerDisposer;
+	constructor(...e) {
+		super(...e);
+		let t = this.helperObject3D;
+		if (this.hoverListener([
+			t.xArrow,
+			t.yArrow,
+			t.zArrow
+		]), t.centerHandle && t.centerHandle instanceof j) {
+			let e = t.centerHandle, n = e.cube;
+			this.domEvents.addEventListener(n, "mouseover", () => {
+				this.isDragging || (Array.isArray(n.material) && n.material.forEach((e) => {
+					e.color.set(16777215);
+				}), this.render());
+			}), this.domEvents.addEventListener(n, "mouseout", () => {
+				this.isDragging || (e.update(this.camera), this.render());
+			});
+		}
+		let n = this.show.bind(this), r = this.hide.bind(this), i = () => {
+			this.helperObject3D.update(this.camera), this.isDragging && this.updateDragGuideLineScale(), this.render();
+		};
+		i(), this.domEvents.addEventListener(this.helperObject3D, "mousedown", this.dragStart), document.addEventListener("mousemove", this.dragging), document.addEventListener("mouseup", this.dragEnd), this.domEvents.addEventListener(this.helperObject3D, "touchstart", this.dragStart), document.addEventListener("touchmove", this.dragging), document.addEventListener("touchend", this.dragEnd), this.hooks.on("rotateStart", r), this.hooks.on("rotateEnd", n), this.hooks.on("scaleStart", r), this.hooks.on("scaleEnd", n), this.hooks.on("moveByMouseEnable", r), this.hooks.on("moveByMouseDisable", n), this.hooks.on("updateOtherHelpers", (e) => {
+			this.helperObject3D.update(e.camera), this.render();
+		}), this.cameraHooks.on("cameraUpdate", i), this.disposers.push(() => {
+			this.domEvents.removeEventListener(this.helperObject3D, "mousedown", this.dragStart), document.removeEventListener("mousemove", this.dragging), document.removeEventListener("mouseup", this.dragEnd), this.domEvents.removeEventListener(this.helperObject3D, "touchstart", this.dragStart), document.removeEventListener("touchmove", this.dragging), document.removeEventListener("touchend", this.dragEnd), this.hooks.off("rotateStart", r), this.hooks.off("rotateEnd", n), this.hooks.off("scaleStart", r), this.hooks.off("scaleEnd", n), this.hooks.off("moveByMouseEnable", r), this.hooks.off("moveByMouseDisable", n), this.hooks.off("updateOtherHelpers"), this.cameraHooks.off("cameraUpdate", i);
+		}), this.moveByMouseEnable && this.moveByMouse();
+	}
+	dispose() {
+		super.dispose(), this.disposers?.forEach((e) => e?.());
+	}
+	moveByMouse(e) {
+		this._moveByMouse = {
+			enabled: !0,
+			useFaceNormal: e?.useFaceNormal
+		}, this.preventTapDefaultEvent = !0;
+		let t = this.handleMouseDown.bind(this), n = this.handleMouseUp.bind(this);
+		this.hooks.emit("moveByMouseEnable"), setTimeout(() => {
+			this.container.addEventListener("mousedown", t), this.container.addEventListener("mouseup", n);
+		}), this.mousedownEventListenerDisposer = () => {
+			this.container.removeEventListener("mousedown", t), this.container.removeEventListener("mouseup", n);
+		};
+	}
+	disableMoveByMouse() {
+		this._moveByMouse = { enabled: !1 }, this.preventTapDefaultEvent = !1, this.hooks.emit("moveByMouseDisable"), this.mousedownEventListenerDisposer?.();
+	}
+	onIntersectionOnModelUpdate(e) {
+		if (!this.moveByMouseEnable) return;
+		let { point: t, face: n } = e;
+		if (!this.hooks.emit("wantToMove", t)) {
+			if (this.originObject3D.position.copy(t), (this._moveByMouse.useFaceNormal === !0 || typeof this._moveByMouse.useFaceNormal == "object" && this._moveByMouse.useFaceNormal.enable !== !1) && n?.normal) {
+				let e = typeof this._moveByMouse.useFaceNormal == "object" && this._moveByMouse.useFaceNormal.alignmentVector ? this._moveByMouse.useFaceNormal.alignmentVector : {
+					x: 0,
+					y: 1,
+					z: 0
+				}, t = new _.Vector3(e.x ?? 0, e.y ?? 0, e.z ?? 0), r = typeof this._moveByMouse.useFaceNormal == "object" && this._moveByMouse.useFaceNormal.fixedFaceNormal ? this._moveByMouse.useFaceNormal.fixedFaceNormal(n.normal) : n.normal;
+				this.originObject3D.quaternion.setFromUnitVectors(t, r), this.internalHooks.emit("setObjectRotate", this.originObject3D.quaternion.clone());
+			}
+			this.internalHooks.emit("setObjectPosition", t), this.hooks.emit("move", t);
+		}
+	}
+	handleMouseDown(e) {
+		let { x: t, y: n } = e;
+		this.mouseInfo = {
+			x: t,
+			y: n,
+			mouseDownTimestamp: Date.now()
+		};
+	}
+	handleMouseUp(e) {
+		if (!this.mouseInfo) return;
+		let { x: t, y: n } = e;
+		this.mouseInfo.x === t && this.mouseInfo.y === n && Date.now() - this.mouseInfo.mouseDownTimestamp < 500 && (this.disableMoveByMouse(), this.mouseInfo = void 0);
+	}
+	dragStart = (e) => {
+		if (this.moveByMouseEnable || this.isDragging) return;
+		let t = e?.intersect;
+		if (!t) return this.dragEnd();
+		let n = (t?.object).direction;
+		if (!n) return this.dragEnd();
+		let r = new _.Vector3(1, 0, 0).applyQuaternion(this.helperObject3D.quaternion), i = new _.Vector3(0, 1, 0).applyQuaternion(this.helperObject3D.quaternion), a = new _.Vector3(0, 0, 1).applyQuaternion(this.helperObject3D.quaternion), o = (() => {
+			switch (n) {
+				case "x": return r;
+				case "y": return i;
+				case "z": return a;
+				case "plane": return;
+			}
+		})(), s = t.point.clone();
+		if (n === "plane") {
+			let e = this.camera.position.clone(), t = s.clone(), r = t.clone().sub(e).normalize(), i = new _.Plane().setFromNormalAndCoplanarPoint(r, t), a = t.clone();
+			this.startInfo = {
+				draggingDirection: n,
+				startVectorProject: a,
+				line: new _.Line3(a.clone(), a.clone()),
+				plane: i
+			};
+		} else {
+			let e = new _.Line3(s.clone().sub(o.normalize()), s.clone().add(o.normalize()));
+			this.startInfo = {
+				draggingDirection: n,
+				startVectorProject: s,
+				line: e
+			};
+			try {
+				let e = o.clone().normalize(), t = this.helperObject3D.getWorldPosition(new _.Vector3()), n = this.solidGuide.createSolidLine(t, e, {
+					color: 16777215,
+					renderOrder: k.DRAG_GUIDE_LINE
+				});
+				this.scene.add(n), this.dragGuideLine = n;
+			} catch {}
+		}
+		let c = n === "plane" ? [] : [n];
+		this.helperObject3D.showDraggingHelper(c), this.hooks.emit("moveStart", n), this.isDragging = !0;
+	};
+	dragging = (e) => {
+		if (!this.isDragging || !this.startInfo) return;
+		let t = "touches" in e ? e.touches[0].clientX : e.x, n = "touches" in e ? e.touches[0].clientY : e.y, r = O(this.camera, {
+			x: t,
+			y: n
+		}, this.container);
+		return r ? (this.move(r), !1) : this.dragEnd();
+	};
+	updateDragGuideLineScale() {
+		if (!this.dragGuideLine || !this.startInfo) return;
+		let { line: e } = this.startInfo, t = e.end.clone().sub(e.start).normalize();
+		if (t.lengthSq() < 1e-6) return;
+		let n = this.helperObject3D.getWorldPosition(new _.Vector3());
+		this.solidGuide.updateSolidLine(this.dragGuideLine, n, t);
+	}
+	move(e) {
+		if (!this.startInfo) return this.dragEnd();
+		let { line: t, startVectorProject: n } = this.startInfo, r = this.originObject3D, i = this.startInfo.draggingDirection === "plane", a;
+		if (i) {
+			let t = this.startInfo.plane;
+			if (!t) return;
+			let n = new _.Vector3(), r = t.normal.dot(e.ray.direction);
+			if (Math.abs(r) < 1e-6) return;
+			let i = -(t.normal.dot(e.ray.origin) + t.constant) / r;
+			if (i < 0) return;
+			n.copy(e.ray.origin.clone().add(e.ray.direction.clone().multiplyScalar(i))), a = n;
+		} else a = l({
+			raycaster: e,
+			line: t,
+			clampToLine: !1
+		});
+		let o = r.position.clone(), s = a.clone().sub(n), c = new _.Matrix4();
+		c.setPosition(s);
+		let u = r.position.clone().applyMatrix4(c);
+		if (this.hooks.emit("wantToMove", u)) return;
+		let d = this.hooks.emitWithResult("moveBefore", u) ?? u, f = new _.Matrix4();
+		f.setPosition(d.clone().sub(o)), r.position.copy(d), n.copy(a), this.internalHooks.emit("applyObjectPosition", { matrix: f }), this.hooks.emit("move", d);
+	}
+	dragEnd = () => {
+		if (this.isDragging) {
+			if (this.startInfo = void 0, this.isDragging = !1, this.dragGuideLine) {
+				this.scene.remove(this.dragGuideLine), this.dragGuideLine.geometry.dispose();
+				let e = this.dragGuideLine.material;
+				Array.isArray(e) ? e.forEach((e) => e.dispose()) : e.dispose(), this.dragGuideLine = void 0;
+			}
+			this.helperObject3D.show(), this.hooks.emit("moveEnd");
+		}
+	};
+}, K = class {
+	helperController;
+	five;
+	constructor(e, t, n, r, i, a, o, s, c) {
+		let { camera: l, model: u, scene: d } = e, f = e.getElement();
+		if (this.five = e, !l || !u || !f || !d) return;
+		let p = () => {
+			e.needsRender = !0;
+		};
+		this.helperController = new n({
+			camera: l,
+			model: u,
+			domEvents: t,
+			originObject3D: r,
+			helperObject3D: i,
+			container: f,
+			scene: d,
+			onRender: p,
+			sharedHooks: o,
+			sharedInternalHooks: s,
+			otherControllers: c
+		}, a), e.on("wantsTapGesture", this.onFiveWantsTapGesture), e.on("wantsGesture", this.onFiveWantsGesture), e.on("intersectionOnModelUpdate", this.onFiveIntersectionOnModelUpdate);
+	}
+	dispose() {
+		this.five.off("wantsTapGesture", this.onFiveWantsTapGesture), this.five.off("wantsGesture", this.onFiveWantsGesture), this.five.off("intersectionOnModelUpdate", this.onFiveIntersectionOnModelUpdate), this.helperController?.dispose();
+	}
+	onFiveWantsTapGesture = (e) => {
+		if (!this.helperController) return;
+		if (this.helperController.preventTapDefaultEvent) return !1;
+		let t = this.helperController.onWantsTapGesture(e);
+		return this.five.needsRender = !0, t;
+	};
+	onFiveWantsGesture = (...e) => {
+		if (!this.helperController) return;
+		let t = this.helperController.onWantsGesture(...e);
+		return this.five.needsRender = !0, t;
+	};
+	onFiveIntersectionOnModelUpdate = (...e) => {
+		this.helperController && this.helperController.onIntersectionOnModelUpdate(...e);
+	};
+}, q = "Object3DHelper@v1.0.1", me = () => {
+	console.error(`${q} is disposed`);
+}, he = () => {
+	console.warn(`${q} is disabled`);
+}, ge = () => {
+	console.error(`${q} is disabled`);
+}, _e = class {
+	controllers = {};
+	state = {
+		visible: !0,
+		enabled: !0,
+		disposed: !1
+	};
+	hooks = new e();
+	eventListener = {};
+	constructor(e) {
+		e && this.addControllers(e), this.setState(this.state);
+	}
+	async show(e) {
+		this.setState({ visible: !0 }, e);
+	}
+	async hide(e) {
+		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 me();
+		if (!this.state.enabled && e.enabled !== !0 && e.disposed !== !0) return ge();
+		let n = { ...this.state };
+		this.state = {
+			...this.state,
+			...e
+		}, e.disposed !== void 0 && e.disposed !== n.disposed && e.disposed && this.handleDispose(), e.visible !== void 0 && this.handleVisible(e.visible), e.enabled !== void 0 && this.handleEnable(e.enabled), this.hooks.emit("stateChange", {
+			state: this.state,
+			prevState: n
+		});
+	}
+	addControllers(e) {
+		this.controllers = {
+			...this.controllers,
+			...e
+		}, this.setState(this.state);
+	}
+	initialHelperMatrix() {
+		this.everyControllerDo((e) => {
+			e.initialHelperPosition(), e.initialHelperQuaternion();
+		});
+	}
+	getCurrentState() {
+		return this.state;
+	}
+	handleEnable(e, t = !0) {
+		e ? (this.everyControllerDo((e) => {
+			e.enable();
+		}), this.hooks.emit("enable", { userAction: t })) : (this.everyControllerDo((e) => {
+			e.disable();
+		}), this.hooks.emit("disable", { userAction: t })), this.state.enabled = e;
+	}
+	handleVisible(e, t = !0) {
+		e ? (this.everyControllerDo((e) => {
+			e.show();
+		}), this.actionIfStateIsEnabled(() => this.hooks.emit("show", { userAction: t }))) : (this.everyControllerDo((e) => {
+			e.hide();
+		}), this.actionIfStateIsEnabled(() => this.hooks.emit("hide", { userAction: t }))), this.state.visible = e;
+	}
+	everyControllerDo(e) {
+		Object.values(this.controllers).forEach((t) => {
+			t && e(t);
+		});
+	}
+	handleDispose() {
+		Object.values(this.controllers).forEach((e) => {
+			e?.dispose();
+		});
+		for (let e in this.controllers) {
+			if (!e) continue;
+			let t = e;
+			this.eventListener[t]?.();
+		}
+	}
+	actionIfStateIsEnabled(e, t) {
+		if (this.state.enabled) return e();
+		t?.warnLog && he();
+	}
+};
+//#endregion
+//#region src/shared-utils/math/deg2Rad.ts
+function J(e) {
+	return e * Math.PI / 180;
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/Controller/RotateController.ts
+var Y = new _.Quaternion(), ve = class extends W {
+	name = "RotateController";
+	get rotateCenter() {
+		return this.helperObject3D.position.clone();
+	}
+	startInfo;
+	removeListener;
+	constructor(...e) {
+		super(...e);
+		let t = this.helperObject3D;
+		this.hoverListener([
+			t.xCircle?.circle,
+			t.yCircle?.circle,
+			t.zCircle?.circle
+		].filter(Boolean));
+		let n = this.dragStart.bind(this), r = this.dragging.bind(this), i = this.dragEnd.bind(this), a = this.show.bind(this), o = this.hide.bind(this), s = () => {
+			this.helperObject3D.update(this.camera), this.render();
+		};
+		s(), this.domEvents.addEventListener(this.helperObject3D, "mousedown", n), document.addEventListener("mousemove", r), document.addEventListener("mouseup", i), this.domEvents.addEventListener(this.helperObject3D, "touchstart", n), document.addEventListener("touchmove", r), document.addEventListener("touchend", i), this.hooks.on("moveStart", o), this.hooks.on("moveEnd", a), this.hooks.on("scaleStart", o), this.hooks.on("scaleEnd", a), this.hooks.on("moveByMouseEnable", o), this.hooks.on("moveByMouseDisable", a), this.hooks.on("updateOtherHelpers", (e) => {
+			this.helperObject3D.update(e.camera), this.render();
+		}), this.cameraHooks.on("cameraUpdate", s), this.disposers.push(() => {
+			this.domEvents.removeEventListener(this.helperObject3D, "mousedown", n), document.removeEventListener("mousemove", r), document.removeEventListener("mouseup", i), this.domEvents.removeEventListener(this.helperObject3D, "touchstart", n), document.removeEventListener("touchmove", r), document.removeEventListener("touchend", i), this.hooks.off("moveStart", o), this.hooks.off("moveEnd", a), this.hooks.off("scaleStart", o), this.hooks.off("scaleEnd", a), this.hooks.off("moveByMouseEnable", o), this.hooks.off("moveByMouseDisable", a), this.hooks.off("updateOtherHelpers"), this.cameraHooks.off("cameraUpdate", s);
+		});
+	}
+	setRotateAngle(e) {
+		let { x: t = 0, y: n = 0, z: r = 0 } = e, i = new _.Euler(J(t), J(n), J(r)), a = new _.Quaternion().setFromEuler(i);
+		if (this.hooks.emit("wantToRotate", a)) return;
+		let { originObject3D: o, rotateCenter: s } = this;
+		y(o, a, s), this.internalHooks.emit("setObjectRotate", a, s), this.hooks.emit("rotate", a), this.render();
+	}
+	getEulerAngle(e, t) {
+		let { originObject3D: n } = this, r = new _.Euler().setFromQuaternion(n.quaternion), i = {
+			x: h(r.x),
+			y: h(r.y),
+			z: h(r.z)
+		}, a = {
+			x: e === "x" ? t : i.x,
+			y: e === "y" ? t : i.y,
+			z: e === "z" ? t : i.z
+		}, o = new _.Euler(J(a.x), J(a.y), J(a.z));
+		return new _.Quaternion().setFromEuler(o);
+	}
+	onApplyOriginObjectRotate(e) {
+		this.isDragging || super.onApplyOriginObjectRotate(e);
+	}
+	onApplyOriginObjectScale(e) {}
+	dragStart(e) {
+		if (this.isDragging) return;
+		this.helperObject3D.update(this.camera);
+		let t = e?.intersect;
+		if (!t) return this.dragEnd();
+		let n = (t?.object).direction;
+		if (!n) return this.dragEnd();
+		let r = t.point, i = this.getAngleHelper(n);
+		this.setTipsAngle(0);
+		let a = r.clone();
+		a.y += .2, this.setTipsPosition(a);
+		let o = this.helperObject3D.quaternion.clone(), s = (() => {
+			if (n === "x") return new _.Vector3(1, 0, 0).applyQuaternion(o);
+			if (n === "y") return new _.Vector3(0, 1, 0).applyQuaternion(o);
+			if (n === "z") return new _.Vector3(0, 0, 1).applyQuaternion(o);
+		})(), c = new _.Plane().setFromNormalAndCoplanarPoint(s, r), l = c.projectPoint(r.clone(), new _.Vector3()).clone().sub(this.rotateCenter), u = l.angleTo(i.baseAxes.clone().applyQuaternion(o)), d = i.offsetAngle(u);
+		this.setAngleHelperStart(n, d), this.setAngleHelperLength(n, 0), this.startInfo = {
+			direction: n,
+			startVector: l,
+			directionVector: s,
+			plane: c,
+			angleHelper: i,
+			angle: 0,
+			helperQuaternion: o.clone()
+		}, Y = new _.Quaternion(), this.helperObject3D.showDraggingHelper([n]), this.hooks.emit("rotateStart", n), this.isDragging = !0;
+	}
+	getMatrix() {
+		return this.originObject3D?.ext?.matrix;
+	}
+	getMatrixAngle(e, t) {
+		let n;
+		if (e && e.isMatrix4) {
+			n = new _.Quaternion(), e.decompose(new _.Vector3(), n, new _.Vector3());
+			let r = new _.Euler().setFromQuaternion(n);
+			if (t === "x") return Math.round(h(r.z));
+			if (t === "y") return Math.round(h(r.y));
+			if (t === "z") return Math.round(h(r.x));
+		}
+	}
+	parseAngleByDirection(e) {
+		let t = this.originObject3D?.ext?.matrix, n;
+		if (t && t.isMatrix4) {
+			n = new _.Quaternion(), t.decompose(new _.Vector3(), n, new _.Vector3());
+			let r = new _.Euler().setFromQuaternion(n);
+			if (e === "x") return Math.round(h(r.z));
+			if (e === "y") return Math.round(h(r.y));
+			if (e === "z") return Math.round(h(r.x));
+		}
+	}
+	dragging(e) {
+		if (!this.isDragging) return;
+		let t = "touches" in e ? e.touches[0].clientX : e.x, n = "touches" in e ? e.touches[0].clientY : e.y, r = O(this.camera, {
+			x: t,
+			y: n
+		}, this.container);
+		return r ? (this.rotate(r), !1) : this.dragEnd();
+	}
+	rotate(e) {
+		if (!this.startInfo) return this.dragEnd();
+		let { startVector: t, plane: n, angleHelper: r, direction: i, helperQuaternion: a } = this.startInfo, { originObject3D: o } = this, s = e.ray.intersectPlane(n, new _.Vector3());
+		if (!s) return;
+		let c = this.rotateCenter.clone(), l = n.projectPoint(s.clone(), new _.Vector3()).clone().sub(c), u = this.startInfo.directionVector.clone().normalize();
+		l = l.clone().projectOnPlane(u).normalize().multiplyScalar(l.length());
+		let d = new _.Quaternion().setFromUnitVectors(t.clone().normalize(), l.clone().normalize()), f = o.quaternion.clone().premultiply(d);
+		if (t.angleTo(l) === 0 || this.hooks.emit("wantToRotate", f)) return;
+		let p = new _.Euler().setFromQuaternion(new _.Quaternion().setFromUnitVectors(t.clone().normalize().applyQuaternion(a.clone().invert()), l.clone().normalize().applyQuaternion(a.clone().invert())), `${i.toUpperCase()}${"XZY".replace(i.toUpperCase(), "")}`)[i] * r.angleDirection;
+		if (this.startInfo.angle += p, this.setAngleHelperLength(i, this.startInfo.angle), this.setTipsAngle(h(this.startInfo.angle)), c) {
+			let e = new _.Vector3().subVectors(o.position, c).applyQuaternion(d).add(c);
+			o.position.copy(e);
+		}
+		o.applyQuaternion(d), Y.premultiply(d), this.internalHooks.emit("applyObjectRotate", {
+			quaternion: d,
+			origin: c
+		}), this.hooks.emit("rotate", o.quaternion), this.startInfo.startVector = l;
+	}
+	dragEnd() {
+		this.isDragging && (this.applyHelperQuaternion(Y, this.rotateCenter), this.startInfo?.lineMeshes && this.startInfo.lineMeshes.forEach((e) => {
+			this.scene.remove(e), e.geometry.dispose(), e.material instanceof _.Material && e.material.dispose();
+		}), this.startInfo = void 0, this.isDragging = !1, this.helperObject3D.show(), this.updateOtherHelpers(), this.hooks.emit("rotateEnd"));
+	}
+	updateOtherHelpers() {
+		this.hooks.emit("updateOtherHelpers", { camera: this.camera });
+	}
+	getAngleHelper(e) {
+		switch (e) {
+			case "x": return this.helperObject3D.xCircle?.angleSector;
+			case "y": return this.helperObject3D.yCircle?.angleSector;
+			case "z": return this.helperObject3D.zCircle?.angleSector;
+		}
+	}
+	setAngleHelperStart(e, t) {
+		let n = this.getAngleHelper(e);
+		if (!n) console.warn("angleHelper is undefined");
+		else if (n instanceof _.Mesh && n.geometry instanceof _.CircleGeometry) {
+			let { radius: e, segments: r, thetaLength: i } = n.geometry.parameters;
+			n.geometry = new _.CircleGeometry(e, r, t, i);
+		} else console.warn("only support THREE.CircleGeometry");
+	}
+	setAngleHelperLength(e, t) {
+		let n = t >= 0 ? Math.max(t, .001) : Math.min(t, -.001), r = this.getAngleHelper(e);
+		if (r instanceof _.Mesh && r.geometry instanceof _.CircleGeometry) {
+			let { radius: e, thetaStart: t } = r.geometry.parameters, i = Math.ceil(40 / (2 * Math.PI) * Math.abs(n));
+			r.geometry = new _.CircleGeometry(e, i, t, n);
+		} else console.warn("only support THREE.CircleGeometry");
+	}
+	setTipsAngle(e) {
+		let t = this.helperObject3D.angleTips?.element;
+		t && (t.innerText = `${e.toFixed(0)}°`);
+	}
+	setTipsPosition(e) {
+		let t = this.helperObject3D.angleTips;
+		if (!t) return;
+		let { x: n, y: r, z: i } = e.project(this.camera);
+		if (i > 1) return;
+		let a = (n + 1) / 2 * 100 + "%", o = (-r + 1) / 2 * 100 + "%";
+		t.setLeftTop(a, o);
+	}
+}, ye = class extends W {
+	startInfo;
+	name = "RectangleScaleController";
+	constructor(...e) {
+		super(...e);
+	}
+	enable() {
+		this.helperObject3D.enable(), super.enable();
+	}
+	disable() {
+		this.helperObject3D.disable(), super.disable();
+	}
+	show() {
+		this.helperObject3D.show(), super.show();
+	}
+	hide() {
+		this.helperObject3D.hide(), super.hide();
+	}
+	onApplyOriginObjectPosition(e) {
+		this.isDragging || super.onApplyOriginObjectPosition(e);
+	}
+	onApplyOriginObjectScale(e) {
+		this.helperObject3D.applyHelperScaleMatrix4(e.matrix, e.origin);
+	}
+	getDragPlane() {
+		let e = new _.Plane(), t = this.helperObject3D.cornerPositions;
+		if (t.length !== 0) return t.length < 3 ? e.setFromNormalAndCoplanarPoint(this.originObject3D.getWorldDirection(new v()), t[0]) : e.setFromCoplanarPoints(t[0], t[1], t[2]), e;
+	}
+	dragStart(e, t) {
+		this.helperObject3D.updatePoints?.();
+		let n = this.getDragPlane();
+		if (!n) return this.dragEnd();
+		this.startInfo = {
+			startPoint: {
+				position: t.position.clone(),
+				direction: t.direction
+			},
+			plane: n
+		}, this.hooks.emit("scaleStart", t.direction), this.render(), this.isDragging = !0;
+	}
+	dragging(e) {
+		if (!this.isDragging) return;
+		let t = O(this.camera, e, this.container);
+		if (!t) return this.dragEnd();
+		this.scale(t);
+	}
+	scale(e) {
+		if (!this.startInfo) return;
+		let t = this.originObject3D, { startPoint: n, plane: r } = this.startInfo, i = this.helperObject3D.cornerPositions;
+		if (i.length < 4) return this.dragEnd();
+		let a = e.ray.intersectPlane(r, new v());
+		if (!a || g(a, this.camera.position)) return;
+		let o = new v().addVectors(i[0], i[2]).divideScalar(2), { position: s, direction: c } = n, l = new v().subVectors(i[1], i[0]), u = new v().subVectors(i[3], i[0]), d = (e) => {
+			let t = new v(0, 0, 0);
+			if (!this.startInfo) return t;
+			let n = (e === "ew" ? l : u).clone(), r = s.clone().projectOnVector(n), i = a.clone().projectOnVector(n), c = o.clone().projectOnVector(n);
+			if (i.equals(r)) return t;
+			if (e === "ns" && typeof this.startInfo.dragPointInCenterBottom != "boolean") {
+				let e = new v().subVectors(i, c), t = e.x < 0 && n.x >= 0, r = e.y < 0 && n.y >= 0, a = e.z < 0 && n.z >= 0;
+				this.startInfo.dragPointInCenterBottom = t || r || a;
+			}
+			if (e === "ew" && typeof this.startInfo.dragPointInCenterLeft != "boolean") {
+				let e = new v().subVectors(i, c), t = e.x < 0 && n.x >= 0, r = e.y < 0 && n.y >= 0, a = e.z < 0 && n.z >= 0;
+				this.startInfo.dragPointInCenterLeft = t || r || a;
+			}
+			let d = new v().subVectors(i, r), f = d.length();
+			return f > .3 ? (console.warn("offset.length() > 0.3, skipped", f), t) : d;
+		}, f = d("ew"), p = d("ns"), m = () => {
+			let e = f;
+			this.helperObject3D.cornerPositions.forEach((t, n) => {
+				this.startInfo?.dragPointInCenterLeft ? (n === 0 || n === 3) && t.add(e) : (n === 1 || n === 2) && t.add(e);
+			});
+		}, h = () => {
+			let e = p;
+			this.helperObject3D.cornerPositions.forEach((t, n) => {
+				this.startInfo?.dragPointInCenterBottom ? (n === 0 || n === 1) && t.add(e) : (n === 2 || n === 3) && t.add(e);
+			});
+		};
+		switch (c) {
+			case "ew":
+				m();
+				break;
+			case "ns":
+				h();
+				break;
+			case "nesw":
+			case "nwse": m(), h();
+		}
+		let y = new v().subVectors(i[1], i[0]).length() / l.length(), b = new v().subVectors(i[3], i[0]).length() / u.length(), x = new v(y, b, 1), S = new _.Matrix4().scale(x);
+		t.isCSS3DObjectPlus && t.applyScaleMatrix4 ? t.applyScaleMatrix4(S) : t.scale.applyMatrix4(S), n.position.copy(a);
+		let C = new v().addVectors(i[0], i[2]).divideScalar(2), w = new v().subVectors(C, o), T = new _.Matrix4().setPosition(w);
+		t.applyMatrix4(T), this.helperObject3D.css3DInstance?.css3DObject.applyMatrix4(T), this.helperObject3D.plane?.applyMatrix4(T), this.internalHooks.emit("applyObjectScale", { matrix: S }), this.internalHooks.emit("applyObjectPosition", { matrix: T }), this.render();
+	}
+	dragEnd() {
+		this.isDragging && (this.startInfo = void 0, this.isDragging = !1, "onScaleEnd" in this.helperObject3D && typeof this.helperObject3D.onScaleEnd == "function" && this.helperObject3D.onScaleEnd(), this.hooks.emit("scaleEnd"), this.render());
+	}
+}, be = class extends ye {
+	name = "CSS3DScaleController";
+	constructor(...e) {
+		super(...e), this.addHTMLEventListener();
+	}
+	addHTMLEventListener() {
+		this.helperObject3D.points.forEach((e) => {
+			if (!e) return;
+			let t = e.point, n = (t) => this.dragStart(t, e), r = this.dragging.bind(this), i = this.dragEnd.bind(this);
+			t.addEventListener("dragstart", n), t.addEventListener("drag", r), t.addEventListener("dragend", i);
+		});
+	}
+}, xe = class extends W {
+	name = "BoundingBoxController";
+	constructor(...e) {
+		super(...e);
+	}
+}, Se = class extends w {
+	name = "ScaleHelper";
+	scaleMeshes = [];
+	lineConnections = [];
+	positions = [];
+	container;
+	needsInitialScaling = !1;
+	lastCamera = null;
+	isInitializing = !1;
+	constructor(e, t) {
+		super(e, t), t && (this.positions = t.positions, this.container = t.container), this.raycast = () => {};
+	}
+	initQuaternion() {
+		this.quaternion.copy(this.originObject3D.quaternion);
+	}
+	initialPosition(e) {
+		if (this.isInitializing) console.warn("ScaleHelper: initialPosition called while already initializing, skipping");
+		else {
+			this.isInitializing = !0;
+			try {
+				this.position.copy(this.originObject3D.position);
+				let e = typeof this.positions == "function" ? this.positions() : this.positions;
+				if (!e) {
+					this.isInitializing = !1;
+					return;
+				}
+				this.clearAllSpheres(), this.scaleMeshes = e.map((e, t) => {
+					let n = Ce();
+					return n.position.copy(e.handlePosition), n.scalePosition = e, n.children.forEach((t) => {
+						t.scalePosition = e;
+					}), this.add(n), n;
+				}), this.createLineConnections(), this.needsInitialScaling = !0, this.lastCamera && (this.applySphereScaling(this.lastCamera), this.applyLineScaling(this.lastCamera), this.needsInitialScaling = !1);
+			} finally {
+				this.isInitializing = !1;
+			}
+		}
+	}
+	clearAllSpheres() {
+		this.scaleMeshes.forEach((e) => {
+			this.remove(e);
+		}), this.scaleMeshes = [];
+		let e = this.children.filter((e) => e.name === "ScaleHelperSphere");
+		e.length > 0 && e.forEach((e) => {
+			this.remove(e);
+		});
+	}
+	createLineConnections() {
+		this.lineConnections.forEach((e) => {
+			this.remove(e.line);
+		}), this.lineConnections = [];
+		let e = {
+			top: "bottom",
+			bottom: "top",
+			left: "right",
+			right: "left",
+			front: "back",
+			back: "front"
+		}, t = /* @__PURE__ */ new Set();
+		for (let n of this.scaleMeshes) {
+			let r = n.scalePosition.id;
+			if (!r || t.has(r)) continue;
+			let i = e[r];
+			if (!i) continue;
+			let a = this.scaleMeshes.find((e) => e.scalePosition.id === i);
+			if (!a) continue;
+			let o = X(n.position.clone(), a.position.clone());
+			this.add(o), this.lineConnections.push({
+				line: o,
+				mesh1: n,
+				mesh2: a
+			}), t.add(r), t.add(i);
+		}
+	}
+	updateHandlePositions() {
+		let e = typeof this.positions == "function" ? this.positions() : this.positions;
+		e && (e.forEach((e) => {
+			let t = this.scaleMeshes.find((t) => t.scalePosition.id === e.id);
+			t && (t.position.copy(e.handlePosition), t.scalePosition = e);
+		}), this.updateLineConnections(), this.lastCamera && this.applySphereScaling(this.lastCamera));
+	}
+	update(e) {
+		let t = e.type === "OrthographicCamera", n = e.position.clone(), r = this.originObject3D.getWorldPosition(new _.Vector3()), i = n.sub(r).normalize(), a = {
+			front: new _.Vector3(0, 0, 1).applyQuaternion(this.originObject3D.getWorldQuaternion(new _.Quaternion())),
+			back: new _.Vector3(0, 0, -1).applyQuaternion(this.originObject3D.getWorldQuaternion(new _.Quaternion())),
+			left: new _.Vector3(-1, 0, 0).applyQuaternion(this.originObject3D.getWorldQuaternion(new _.Quaternion())),
+			right: new _.Vector3(1, 0, 0).applyQuaternion(this.originObject3D.getWorldQuaternion(new _.Quaternion())),
+			top: new _.Vector3(0, 1, 0).applyQuaternion(this.originObject3D.getWorldQuaternion(new _.Quaternion())),
+			bottom: new _.Vector3(0, -1, 0).applyQuaternion(this.originObject3D.getWorldQuaternion(new _.Quaternion()))
+		}, o = -1, s = "";
+		Object.entries(a).forEach(([e, t]) => {
+			let n = i.dot(t);
+			n > o && (o = n, s = e);
+		});
+		let c = {
+			top: "bottom",
+			bottom: "top",
+			left: "right",
+			right: "left",
+			front: "back",
+			back: "front"
+		};
+		this.scaleMeshes.forEach((e) => {
+			if (!t) {
+				e.visible = !0;
+				return;
+			}
+			let n = e.scalePosition.id, r = c[s];
+			e.visible = n !== s && n !== r;
+		}), this.updateLineConnections(), this.lastCamera && (this.applySphereScaling(this.lastCamera), this.applyLineScaling(this.lastCamera));
+	}
+	applySphereScaling(e) {
+		this.updateMatrixWorld(!0), this.scaleMeshes.forEach((t) => {
+			t.scale.setScalar(P(e, t.scalePosition.handlePosition.clone().applyMatrix4(this.matrixWorld)));
+		});
+	}
+	applyLineScaling(e) {}
+	showLineConnections() {
+		this.lineConnections.forEach((e) => {
+			let t = e.mesh1.visible && e.mesh2.visible;
+			e.line.visible = t;
+		});
+	}
+	hideLineConnections() {
+		this.lineConnections.forEach((e) => {
+			e.line.visible = !1;
+		});
+	}
+	updateLineConnections() {
+		this.lineConnections.forEach((e) => {
+			e.line.scale.set(1, 1, 1), e.line.position.set(0, 0, 0), e.line.rotation.set(0, 0, 0);
+			let t = e.line.geometry.attributes.position;
+			t.setXYZ(0, e.mesh1.position.x, e.mesh1.position.y, e.mesh1.position.z), t.setXYZ(1, e.mesh2.position.x, e.mesh2.position.y, e.mesh2.position.z), t.needsUpdate = !0;
+			let n = e.mesh1.visible && e.mesh2.visible;
+			e.line.visible = n;
+		});
+	}
+	setScaleByCamera(e) {
+		this.lastCamera = e, this.applySphereScaling(e), this.applyLineScaling(e), this.needsInitialScaling && requestAnimationFrame(() => {
+			this.applySphereScaling(e), this.applyLineScaling(e);
+		}), this.needsInitialScaling = !1;
+	}
+};
+function Ce() {
+	let e = new _.SphereGeometry(.03, 16, 16), t = new _.MeshBasicMaterial({
+		color: 16776960,
+		side: _.DoubleSide,
+		transparent: !0,
+		opacity: 1,
+		depthTest: !1,
+		depthWrite: !1
+	}), n = new _.Mesh(e, t);
+	n.name = "ScaleHelperSphere", n.renderOrder = k.SCALE_HELPER_SPHERE;
+	let r = new _.SphereGeometry(.12, 16, 16), i = new _.MeshBasicMaterial({
+		transparent: !0,
+		opacity: 0,
+		side: _.DoubleSide,
+		depthTest: !1,
+		depthWrite: !1
+	}), a = new _.Mesh(r, i);
+	return a.name = "ScaleHelperTransparentGroup", a.renderOrder = k.SCALE_HELPER_SPHERE, a.add(n), a;
+}
+function X(e, t) {
+	let n = new _.BufferGeometry(), r = [e, t];
+	n.setFromPoints(r);
+	let i = new _.LineBasicMaterial({
+		color: 16776960,
+		opacity: .75,
+		transparent: !0,
+		depthTest: !1,
+		depthWrite: !1
+	}), a = new _.Line(n, i);
+	return a.name = "ScaleHelperSolidLine", a.renderOrder = k.SCALE_HELPER_LINE, a.raycast = () => {}, a;
+}
+//#endregion
+//#region src/shared-utils/Object3DHelper/Controller/ScaleController.ts
+var we = class extends W {
+	name = "ScaleController";
+	dragGuideLine;
+	currentFacePatch;
+	solidGuide = new G(this.camera, this.container, this.config?.solidGuide ?? {});
+	startInfo;
+	constructor(...e) {
+		super(...e);
+		let t = this.show.bind(this), n = this.hide.bind(this), r = () => {
+			"update" in this.helperObject3D && typeof this.helperObject3D.update == "function" && this.helperObject3D.update(this.camera), this.isDragging && this.updateDragGuideLineScale(), this.render();
+		};
+		r(), this.domEvents.addEventListener(this.helperObject3D, "mousedown", this.dragStart), document.addEventListener("mousemove", this.dragging), document.addEventListener("mouseup", this.dragEnd), this.domEvents.addEventListener(this.helperObject3D, "touchstart", this.dragStart), document.addEventListener("touchmove", this.dragging), document.addEventListener("touchend", this.dragEnd), this.hooks.on("rotateStart", n), this.hooks.on("rotateEnd", t), this.hooks.on("moveStart", () => {
+			n(), this.removeFaceMesh();
+		}), this.hooks.on("moveEnd", t), this.hooks.on("moveByMouseEnable", n), this.hooks.on("moveByMouseDisable", t), this.hooks.on("updateOtherHelpers", (e) => {
+			"update" in this.helperObject3D && typeof this.helperObject3D.update == "function" && this.helperObject3D.update(e.camera), this.isDragging && this.updateDragGuideLineScale(), this.render();
+		}), this.cameraHooks.on("cameraUpdate", r), this.disposers.push(() => {
+			if (this.domEvents.removeEventListener(this.helperObject3D, "mousedown", this.dragStart), document.removeEventListener("mousemove", this.dragging), document.removeEventListener("mouseup", this.dragEnd), this.domEvents.removeEventListener(this.helperObject3D, "touchstart", this.dragStart), document.removeEventListener("touchmove", this.dragging), document.removeEventListener("touchend", this.dragEnd), this.hooks.off("rotateStart", n), this.hooks.off("rotateEnd", t), this.hooks.off("moveStart", n), this.hooks.off("moveEnd", t), this.hooks.off("moveByMouseEnable", n), this.hooks.off("moveByMouseDisable", t), this.hooks.off("updateOtherHelpers"), this.cameraHooks.off("cameraUpdate", r), this.currentFacePatch) {
+				this.scene.remove(this.currentFacePatch), this.currentFacePatch.geometry.dispose();
+				let e = this.currentFacePatch.material;
+				Array.isArray(e) ? e.forEach((e) => e.dispose()) : e.dispose(), this.currentFacePatch = void 0;
+			}
+		});
+	}
+	initialHelperPosition() {
+		this.helperObject3D.initialPosition();
+		let e = this;
+		e.offHoverListener && e.offHoverListener(), e.offHoverListener = this.hoverListener(this.helperObject3D.scaleMeshes);
+	}
+	dragStart = (e) => {
+		if (this.isDragging) return;
+		this.isDragging = !0;
+		let { intersect: t } = e, n = this.camera.position, r = new Set(this.helperObject3D.scaleMeshes.map((e) => e.uuid)), i = t.object;
+		for (; i.parent && !r.has(i.uuid);) i = i.parent;
+		let a = i, o = a.scalePosition.basePosition.clone(), s = a.scalePosition.handlePosition.clone(), c = s.clone().sub(o).clone(), u = new _.Line3(o, o.clone().add(c.normalize().multiplyScalar(5)));
+		u.applyMatrix4(this.helperObject3D.matrixWorld);
+		let d = new _.Raycaster(n, t.point.clone().sub(n)), f = l({
+			raycaster: d,
+			line: u
+		});
+		this.startInfo = {
+			line: u,
+			scaleStartPoint: f,
+			draggingObject: a
+		}, this.helperObject3D.scaleMeshes.forEach((e) => {
+			e.uuid !== a.uuid && (e.visible = !1);
+		}), "hideLineConnections" in this.helperObject3D && typeof this.helperObject3D.hideLineConnections == "function" && this.helperObject3D.hideLineConnections();
+		try {
+			this.originObject3D.updateMatrixWorld(!0), this.helperObject3D.updateMatrixWorld(!0);
+			let e = this.getObjectWorldCenter(), t = s.clone().applyMatrix4(this.helperObject3D.matrixWorld).clone().sub(e).normalize(), n = e, r = this.solidGuide.createSolidLine(n, t, {
+				color: 16777215,
+				renderOrder: k.DRAG_GUIDE_LINE
+			});
+			this.isRectangleWithEdgeMesh() || this.scene.add(r), this.dragGuideLine = r, this.addFaceMesh();
+		} catch {}
+		a.visible = !0, this.hooks.emit("scaleStart");
+	};
+	getObjectWorldCenter() {
+		if ("worldCenter" in this.originObject3D && typeof this.originObject3D.worldCenter == "object") return this.originObject3D.worldCenter.clone();
+		let e = u(this.originObject3D);
+		return e ? e.getCenter(new _.Vector3()) : this.originObject3D.getWorldPosition(new _.Vector3());
+	}
+	getMoveMeshes() {
+		let e = [], t = this.helperObject3D.parent?.children?.find((e) => e.name === "MoveHelper")?.children ?? [];
+		for (let n of t) n.name === "ArrowGroup" ? e.push(...n.children) : n.name === "center-plane-handle" && e.push(n);
+		return e;
+	}
+	addHoverFaceMesh(e) {
+		if (this.isMoveControllerDragging() || (this.removeFaceMesh(), !this.originObject3D.parent?.getWorldFacesGeometry)) return;
+		let t = this.originObject3D.parent?.getWorldFacesGeometry(), n = this.helperObject3D.scaleMeshes, r = this.getMoveMeshes();
+		if (e.intersectObjects(r, !1), e.intersectObjects(r, !1).length > 0) return;
+		let i = null, a = null;
+		for (let t of n) {
+			if (!t.visible) continue;
+			let n = e.intersectObject(t, !1);
+			if (n && n.length > 0) {
+				i = t, a = n[0].point.clone();
+				break;
+			}
+		}
+		if (i && a && Array.isArray(t) && t.length > 0) {
+			let e = null, n = Infinity;
+			for (let r of t) {
+				if (!r.vertices || r.vertices.length < 3) continue;
+				let t = new _.Vector3();
+				for (let e of r.vertices) t.add(e);
+				t.divideScalar(r.vertices.length);
+				let i = a.distanceTo(t);
+				i < n && (n = i, e = r);
+			}
+			e && this.addFacePatch(e);
+		}
+	}
+	addFaceMesh() {
+		if (this.isMoveControllerDragging()) return;
+		let e = this.startInfo?.draggingObject;
+		if (!e || !this.originObject3D.parent?.getWorldFacesGeometry) return;
+		let t = this.originObject3D.parent?.getWorldFacesGeometry();
+		if (t && t.length > 0) {
+			let n = e.getWorldPosition(new _.Vector3()), r = Infinity, i = t[0];
+			for (let e of t) {
+				let t = e.center, a;
+				if (t instanceof _.Vector3) a = t;
+				else if (Array.isArray(t) && t.length === 3) a = new _.Vector3(t[0], t[1], t[2]);
+				else continue;
+				let o = a.distanceTo(n);
+				o < r && (r = o, i = e);
+			}
+			this.addFacePatch(i);
+		}
+	}
+	removeFaceMesh() {
+		if (this.currentFacePatch) {
+			this.scene.remove(this.currentFacePatch), this.currentFacePatch.geometry.dispose();
+			let e = this.currentFacePatch.material;
+			Array.isArray(e) ? e.forEach((e) => e.dispose()) : e.dispose(), this.currentFacePatch = void 0;
+		}
+	}
+	dragging = (e) => {
+		let t = "touches" in e ? e.touches[0].clientX : e.x, n = "touches" in e ? e.touches[0].clientY : e.y, r = O(this.camera, {
+			x: t,
+			y: n
+		}, this.container), i = this.isMoveControllerDragging();
+		if (!this.isDragging && !i && r) this.addHoverFaceMesh(r);
+		else if (this.startInfo) return r ? (this.scale(r), this.updateDragGuideLineDirection(), this.removeFaceMesh(), this.addFaceMesh(), !1) : this.dragEnd();
+	};
+	setScale(e) {
+		let t = 1, n = 1, r = 1;
+		typeof e == "number" ? (t = e, n = e, r = e) : typeof e == "object" && (t = e.x ?? 1, n = e.y ?? 1, r = e.z ?? 1);
+		let i = new _.Vector3(t, n, r);
+		this.hooks.emit("wantToScale", i) || (this.originObject3D.scale.copy(i), this.internalHooks.emit("setObjectScale", i), this.hooks.emit("scale", i), this.render());
+	}
+	isRectangleWithEdgeMesh = () => this.originObject3D.name === "RectangleWithEdgeMesh" && [
+		"topleft",
+		"topright",
+		"bottomleft",
+		"bottomright"
+	].includes(this.startInfo.draggingObject.scalePosition.id);
+	scale = (e) => {
+		if (!this.startInfo) return;
+		let { line: t, scaleStartPoint: n, draggingObject: r } = this.startInfo, { scalePosition: i } = r;
+		if (this.isRectangleWithEdgeMesh()) {
+			let o = this.originObject3D, s = o.geometry.attributes.position;
+			if (!s) return [];
+			let c = [], u = s.count;
+			for (let e = 0; e < u; e++) {
+				let t = new _.Vector3().fromBufferAttribute(s, e);
+				o.updateMatrixWorld(!0), t.applyMatrix4(o.matrixWorld), c.push(t);
+			}
+			let d = c.slice(0, 4);
+			if (!d || d.length < 4) return;
+			let f = a(d).normalize(), p = new _.Plane().setFromNormalAndCoplanarPoint(f, d[0]), m = Math.abs(e.ray.direction.dot(f)) < .1, h;
+			if (m) h = l({
+				raycaster: e,
+				line: t,
+				clampToLine: !1
+			}).applyMatrix4(new _.Matrix4().copy(this.helperObject3D.matrixWorld.clone().invert()));
+			else {
+				let t = new _.Vector3();
+				if (e.ray.intersectPlane(p, t), !t) return;
+				let n = new _.Matrix4().copy(this.helperObject3D.matrixWorld).invert();
+				h = t.clone().applyMatrix4(n);
+			}
+			let g = n.clone().applyMatrix4(new _.Matrix4().copy(this.helperObject3D.matrixWorld).invert());
+			this.config?.scaleCallback?.({
+				intersectPoint: h,
+				scalePosition: i,
+				offset: h.clone().sub(g),
+				updateHandlePositions: () => this.helperObject3D.updateHandlePositions()
+			}) !== !1 && r.position.copy(h), this.hooks.emit("scale", new _.Vector3(1, 1, 1));
+			return;
+		}
+		let o = l({
+			raycaster: e,
+			line: t,
+			clampToLine: !1
+		});
+		o.applyMatrix4(new _.Matrix4().copy(this.helperObject3D.matrixWorld.clone().invert())), this.config?.scaleCallback?.({
+			intersectPoint: o,
+			scalePosition: i,
+			offset: o.clone().sub(n),
+			updateHandlePositions: () => this.helperObject3D.updateHandlePositions()
+		}) !== !1 && r.position.copy(o.clone()), this.hooks.emit("scale", new _.Vector3(1, 1, 1));
+	};
+	dragEnd = () => {
+		if (this.isDragging) {
+			if (this.startInfo = void 0, this.isDragging = !1, this.helperObject3D.scaleMeshes.forEach((e) => {
+				e.visible = !0;
+			}), "showLineConnections" in this.helperObject3D && typeof this.helperObject3D.showLineConnections == "function" && this.helperObject3D.showLineConnections(), this.dragGuideLine) {
+				this.scene.remove(this.dragGuideLine), this.dragGuideLine.geometry.dispose();
+				let e = this.dragGuideLine.material;
+				Array.isArray(e) ? e.forEach((e) => e.dispose()) : e.dispose(), this.dragGuideLine = void 0;
+			}
+			this.removeFaceMesh(), this.internalHooks.emit("initialHelperPosition"), this.hooks.emit("scaleEnd");
+		}
+	};
+	updateDragGuideLineDirection() {
+		if (!this.dragGuideLine || !this.startInfo) return;
+		this.originObject3D.updateMatrixWorld(!0), this.helperObject3D.updateMatrixWorld(!0);
+		let e = this.startInfo.line.delta(new _.Vector3()).normalize(), t = this.getObjectWorldCenter();
+		this.solidGuide.updateSolidLine(this.dragGuideLine, t, e);
+	}
+	updateDragGuideLineScale() {
+		if (!this.dragGuideLine || !this.startInfo) return;
+		let { scalePosition: e } = this.startInfo.draggingObject, t = e.handlePosition.clone().applyMatrix4(this.helperObject3D.matrixWorld), n = e.basePosition.clone().applyMatrix4(this.helperObject3D.matrixWorld), r = t, i = t.clone().sub(n).normalize();
+		this.solidGuide.updateSolidLine(this.dragGuideLine, r, i);
+	}
+	isMoveControllerDragging() {
+		return this.otherControllers?.moveController?.getIsDragging() ?? !1;
+	}
+	addFacePatch(e) {
+		if (this.currentFacePatch) {
+			this.scene.remove(this.currentFacePatch), this.currentFacePatch.geometry.dispose();
+			let e = this.currentFacePatch.material;
+			Array.isArray(e) ? e.forEach((e) => e.dispose()) : e.dispose(), this.currentFacePatch = void 0;
+		}
+		if (!e.vertices || e.vertices.length < 3) {
+			console.warn("Face has no vertices, cannot create patch");
+			return;
+		}
+		let t = new _.BufferGeometry();
+		if (e.vertices.length === 4) {
+			let n = new Float32Array([
+				e.vertices[0].x,
+				e.vertices[0].y,
+				e.vertices[0].z,
+				e.vertices[1].x,
+				e.vertices[1].y,
+				e.vertices[1].z,
+				e.vertices[2].x,
+				e.vertices[2].y,
+				e.vertices[2].z,
+				e.vertices[0].x,
+				e.vertices[0].y,
+				e.vertices[0].z,
+				e.vertices[2].x,
+				e.vertices[2].y,
+				e.vertices[2].z,
+				e.vertices[3].x,
+				e.vertices[3].y,
+				e.vertices[3].z
+			]);
+			t.setAttribute("position", new _.BufferAttribute(n, 3)), t.setIndex([
+				0,
+				1,
+				2,
+				3,
+				4,
+				5
+			]);
+		} else {
+			let n = new Float32Array(e.vertices.length * 3), r = new Uint16Array(e.vertices.length);
+			e.vertices.forEach((e, t) => {
+				n[t * 3] = e.x, n[t * 3 + 1] = e.y, n[t * 3 + 2] = e.z, r[t] = t;
+			}), t.setAttribute("position", new _.BufferAttribute(n, 3)), t.setIndex(new _.BufferAttribute(r, 1));
+		}
+		t.computeVertexNormals();
+		let n = new _.MeshBasicMaterial({
+			color: 16777215,
+			side: _.DoubleSide,
+			depthTest: !1,
+			depthWrite: !1,
+			transparent: !0,
+			opacity: .45
+		}), r = new _.Mesh(t, n);
+		return r.renderOrder = k.DRAG_FACE_PATCH, this.scene.add(r), this.currentFacePatch = r, this.render(), r;
+	}
+};
+//#endregion
+//#region src/shared-utils/threex/domevents/index.js
+function Z(e, t) {
+	this._camera = e || null, this._domElement = t || document, this._raycaster = new _.Raycaster(), this._selected = null, this._boundObjs = {};
+	var n = this;
+	this._$onClick = function() {
+		n._onClick.apply(n, arguments);
+	}, this._$onDblClick = function() {
+		n._onDblClick.apply(n, arguments);
+	}, this._$onMouseMove = function() {
+		n._onMouseMove.apply(n, arguments);
+	}, this._$onMouseDown = function() {
+		n._onMouseDown.apply(n, arguments);
+	}, this._$onMouseUp = function() {
+		n._onMouseUp.apply(n, arguments);
+	}, this._$onTouchMove = function() {
+		n._onTouchMove.apply(n, arguments);
+	}, this._$onTouchStart = function() {
+		n._onTouchStart.apply(n, arguments);
+	}, this._$onTouchEnd = function() {
+		n._onTouchEnd.apply(n, arguments);
+	}, this._$onContextmenu = function() {
+		n._onContextmenu.apply(n, 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);
+}
+Z.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);
+}, Z.eventNames = [
+	"click",
+	"dblclick",
+	"mouseover",
+	"mouseout",
+	"mousemove",
+	"mousedown",
+	"mouseup",
+	"contextmenu",
+	"touchstart",
+	"touchend"
+], Z.prototype._getRelativeMouseXY = function(e) {
+	var t = e.target || e.srcElement;
+	t.nodeType === 3 && (t = t.parentNode);
+	var n = {
+		x: 0,
+		y: 0
+	}, r = t, i = getComputedStyle(r, null);
+	n.y += parseInt(i.getPropertyValue("padding-top"), 10), n.x += parseInt(i.getPropertyValue("padding-left"), 10);
+	do
+		n.x += r.offsetLeft, n.y += r.offsetTop, i = getComputedStyle(r, null), n.x += parseInt(i.getPropertyValue("border-left-width"), 10), n.y += parseInt(i.getPropertyValue("border-top-width"), 10);
+	while (r = r.offsetParent);
+	var a = {
+		width: t === window ? window.innerWidth : t.offsetWidth,
+		height: t === window ? window.innerHeight : t.offsetHeight
+	};
+	return {
+		x: Number((e.pageX - n.x) / a.width) * 2 - 1,
+		y: -((e.pageY - n.y) / a.height) * 2 + 1
+	};
+}, Z.prototype._objectCtxInit = function(e) {
+	e._3xDomEvent = {};
+}, Z.prototype._objectCtxDeinit = function(e) {
+	delete e._3xDomEvent;
+}, Z.prototype._objectCtxIsInit = function(e) {
+	return !!e._3xDomEvent;
+}, Z.prototype._objectCtxGet = function(e) {
+	return e._3xDomEvent;
+}, Z.prototype.camera = function(e) {
+	return e && (this._camera = e), this._camera;
+}, Z.prototype.bind = function(e, t, n, r) {
+	console.assert(Z.eventNames.indexOf(t) !== -1, "not available events:" + t), this._objectCtxIsInit(e) || this._objectCtxInit(e);
+	var i = this._objectCtxGet(e);
+	i[t + "Handlers"] || (i[t + "Handlers"] = []), i[t + "Handlers"].push({
+		callback: n,
+		useCapture: r
+	}), this._boundObjs[t] === void 0 && (this._boundObjs[t] = []), this._boundObjs[t].push(e);
+}, Z.prototype.addEventListener = Z.prototype.bind, Z.prototype.unbind = function(e, t, n, r) {
+	console.assert(Z.eventNames.indexOf(t) !== -1, "not available events:" + t), this._objectCtxIsInit(e) || this._objectCtxInit(e);
+	var i = this._objectCtxGet(e);
+	i[t + "Handlers"] || (i[t + "Handlers"] = []);
+	for (var a = i[t + "Handlers"], o = 0; o < a.length; o++) {
+		var s = a[o];
+		if (n == s.callback && r == s.useCapture) {
+			a.splice(o, 1);
+			break;
+		}
+	}
+	var c = this._boundObjs[t].indexOf(e);
+	this._boundObjs[t].splice(c, 1);
+}, Z.prototype.removeEventListener = Z.prototype.unbind, Z.prototype._bound = function(e, t) {
+	var n = this._objectCtxGet(t);
+	return n ? !!n[e + "Handlers"] : !1;
+}, Z.prototype._isObjectVisible = function(e) {
+	for (var t = e; t;) {
+		if (t.visible === !1) return !1;
+		t = t.parent;
+	}
+	return !0;
+}, Z.prototype._filterVisibleObjects = function(e) {
+	var t = this;
+	return e.filter(function(e) {
+		return t._isObjectVisible(e);
+	});
+}, Z.prototype._onMove = function(e, t, n, r) {
+	var i = this._boundObjs[e];
+	if (i !== void 0 && i.length !== 0) {
+		var a = this._filterVisibleObjects(i);
+		if (a.length !== 0) {
+			var o = new _.Vector2();
+			o.set(t, n), this._raycaster.setFromCamera(o, this._camera);
+			var s = this._raycaster.intersectObjects(a), c = this;
+			s = s.filter(function(e) {
+				return c._isObjectVisible(e.object);
+			}), s.sort(function(e, t) {
+				var n = e.object.renderOrder || 0, r = t.object.renderOrder || 0;
+				return n === r ? e.distance - t.distance : r - n;
+			});
+			var l = this._selected;
+			if (s.length > 0) {
+				var u, d, f, p = s[0], m = p.object;
+				this._selected = m, f = this._bound("mousemove", m), l != m && (u = this._bound("mouseover", m), d = l && this._bound("mouseout", l));
+			} else d = l && this._bound("mouseout", l), this._selected = null;
+			f && this._notify("mousemove", m, r, p), u && this._notify("mouseover", m, r, p), d && this._notify("mouseout", l, r, p);
+		}
+	}
+}, Z.prototype._onEvent = function(e, t, n, r) {
+	var i = this._boundObjs[e];
+	if (i !== void 0 && i.length !== 0) {
+		var a = this._filterVisibleObjects(i);
+		if (a.length !== 0) {
+			var o = new _.Vector2();
+			o.set(t, n), this._raycaster.setFromCamera(o, this._camera);
+			var s = this._raycaster.intersectObjects(a, !0), c = this;
+			if (s = s.filter(function(e) {
+				return c._isObjectVisible(e.object);
+			}), s.sort(function(e, t) {
+				var n = e.object.renderOrder || 0, r = t.object.renderOrder || 0;
+				return n === r ? e.distance - t.distance : r - n;
+			}), s.length !== 0) {
+				for (var l = s[0], u = l.object, d = this._objectCtxGet(u), f = u.parent; d === void 0 && f;) d = this._objectCtxGet(f), f = f.parent;
+				d && this._notify(e, u, r, l);
+			}
+		}
+	}
+}, Z.prototype._notify = function(e, t, n, r) {
+	var i = this._objectCtxGet(t), a = i ? i[e + "Handlers"] : null;
+	if (!i || !a || a.length === 0) t.parent && this._notify(e, t.parent, n, r);
+	else for (var a = i[e + "Handlers"], o = 0; o < a.length; o++) {
+		var s = a[o], c = !0;
+		s.callback({
+			type: e,
+			target: t,
+			origDomEvent: n,
+			intersect: r,
+			stopPropagation: function() {
+				c = !1;
+			}
+		}), c && s.useCapture === !1 && t.parent && this._notify(e, t.parent, n, r);
+	}
+}, Z.prototype._onMouseDown = function(e) {
+	return this._onMouseEvent("mousedown", e);
+}, Z.prototype._onMouseUp = function(e) {
+	return this._onMouseEvent("mouseup", e);
+}, Z.prototype._onMouseEvent = function(e, t) {
+	var n = this._getRelativeMouseXY(t);
+	this._onEvent(e, n.x, n.y, t);
+}, Z.prototype._onMouseMove = function(e) {
+	var t = this._getRelativeMouseXY(e);
+	this._onMove("mousemove", t.x, t.y, e), this._onMove("mouseover", t.x, t.y, e), this._onMove("mouseout", t.x, t.y, e);
+}, Z.prototype._onClick = function(e) {
+	this._onMouseEvent("click", e);
+}, Z.prototype._onDblClick = function(e) {
+	this._onMouseEvent("dblclick", e);
+}, Z.prototype._onContextmenu = function(e) {
+	this._onMouseEvent("contextmenu", e);
+}, Z.prototype._onTouchStart = function(e) {
+	return this._onTouchEvent("touchstart", e);
+}, Z.prototype._onTouchEnd = function(e) {
+	return this._onTouchEvent("touchend", e);
+}, Z.prototype._onTouchMove = function(e) {
+	if (e.touches.length == 1) {
+		var t = Number(e.touches[0].pageX / window.innerWidth) * 2 - 1, n = -(e.touches[0].pageY / window.innerHeight) * 2 + 1;
+		this._onMove("mousemove", t, n, e), this._onMove("mouseover", t, n, e), this._onMove("mouseout", t, n, e);
+	}
+}, Z.prototype._onTouchEvent = function(e, t) {
+	var n = t.touches;
+	if (n.length == 0 && (n = t.changedTouches), n.length == 1) {
+		var r = Number(n[0].pageX / window.innerWidth) * 2 - 1, i = -(n[0].pageY / window.innerHeight) * 2 + 1;
+		this._onEvent(e, r, i, t);
+	}
+};
+//#endregion
+//#region src/Object3DHelperPlugin/Controller.ts
+var Q = "Object3DHelperPlugin", $ = Q, Te = () => {
+	console.error(`${$} is disposed`);
+}, Ee = () => {
+	console.warn(`${$} is disabled`);
+}, De = () => {
+	console.error(`${$} is disabled`);
+}, Oe = class extends m {
+	name = Q;
+	state = {
+		visible: !0,
+		enabled: !0,
+		disposed: !1
+	};
+	objectHelperMap = /* @__PURE__ */ new Map();
+	css3DObjectParentMap = /* @__PURE__ */ new Map();
+	css3DObjectModeMap = /* @__PURE__ */ new Map();
+	css3DRender;
+	constructor(e) {
+		super(e), this.five = e, this.css3DRender = new p(this.five.scene);
+	}
+	async show(e) {
+		this.setState({ visible: !0 }, e);
+	}
+	async hide(e) {
+		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 Te();
+		if (!this.state.enabled && e.enabled !== !0 && e.disposed !== !0) return De();
+		let n = { ...this.state };
+		this.state = {
+			...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(r, i = {}) {
+		if (!r) {
+			console.error("Object3D is undefined");
+			return;
+		}
+		if (this.objectHelperMap.has(r)) {
+			console.warn(`Object3DHelperPlugin: object3D ${r.name} is already has helper`);
+			return;
+		}
+		let a = new _e(), o = [], s = this.five.getElement()?.parentElement, c = this.five.camera, l = {
+			moveHelper: !0,
+			rotateHelper: !0,
+			scaleHelper: !0,
+			boundingBoxHelper: !1,
+			positionFrom: "objectPosition",
+			...i
+		}, { moveHelper: u, rotateHelper: d, scaleHelper: f, boundingBoxHelper: p } = l, m = a.hooks, h = new e(), g = new Z(this.five.camera, this.five.getElement()), _ = (e) => {
+			if (e) return typeof e == "boolean" ? e : e.enable;
+		}, v = {};
+		if (_(u)) {
+			let e = {
+				...this.getConfig(l.moveHelper),
+				...l
+			}, t = new R(r, { ...e }), n = new K(this.five, g, pe, r, t, e, m, h);
+			v.moveController = n.helperController, o.push(() => n.dispose());
+		}
+		if (_(d)) {
+			let e = {
+				...this.getConfig(l.rotateHelper),
+				...l
+			}, t = new ae(r, {
+				container: s,
+				...e
+			}), n = new K(this.five, g, ve, r, t, e, m, h);
+			v.rotateController = n.helperController, o.push(() => n.dispose());
+		}
+		if (_(p)) {
+			let e = new de(r), t = new K(this.five, g, xe, r, e, void 0, m, h);
+			v.boundingBoxController = t.helperController, o.push(() => t.dispose());
+		}
+		if (_(f)) {
+			if (r.isCSS3DObject && s) {
+				let e = new ue(r, s, c, this.five.scene), i = new K(this.five, g, be, r, e, void 0, m, h);
+				v.scaleController = i.helperController, o.push(() => i.dispose()), n(this.five).then(() => {
+					if (r.isCSS3DObjectPlus) {
+						let e = r;
+						if (!e || e.mode !== "front") return;
+						let n = this.css3DRender.behindModeCSS3DRenderer.wrapper ?? t(this.five);
+						n && (this.css3DObjectParentMap.set(e, e.parent), e.removeFromParent(), this.css3DRender.behindModeCSS3DRenderer.setWrapper(n), this.css3DRender.getBehindCSS3DObjectGroup()?.add(e), this.css3DRender.render(this.five.camera));
+					} else r.isCSS3DObject && (this.css3DObjectModeMap.set(r, r.mode), r.mode = "behind");
+				});
+			} else {
+				let e = {
+					...this.getConfig(l.scaleHelper),
+					...l
+				}, t = new Se(r, e), n = new K(this.five, g, we, r, t, e, m, h);
+				v.scaleController = n.helperController, o.push(() => n.dispose());
+			}
+		}
+		return Object.values(v).forEach((e) => {
+			e && typeof e.updateOtherControllers == "function" && e.updateOtherControllers(v);
+		}), a.addControllers(v), this.objectHelperMap.set(r, {
+			helper: a,
+			disposers: o
+		}), a.controllers;
+	}
+	removeObject3DHelper(e) {
+		if (!this.objectHelperMap.has(e)) return;
+		let { helper: t, disposers: n } = this.objectHelperMap.get(e);
+		if (t) {
+			if (e.isCSS3DObjectPlus) {
+				let t = e, n = this.css3DObjectParentMap.get(t);
+				n && n.add(t), this.css3DRender.render(this.five.camera);
+			} else e.isCSS3DObject && (e.mode = this.css3DObjectModeMap.get(e));
+			this.objectHelperMap.delete(e), t.dispose(), n?.forEach((e) => e?.());
+		}
+	}
+	handleEnable(e, t = !0) {
+		e ? (this.everyHelperDo((e) => e.enable()), this.hooks.emit("enable", { userAction: t })) : (this.everyHelperDo((e) => e.disable()), this.hooks.emit("disable", { userAction: t })), this.state.enabled = e;
+	}
+	handleVisible(e, t = !0) {
+		e ? (this.everyHelperDo((e) => e.show()), this.actionIfStateIsEnabled(() => this.hooks.emit("show", { userAction: t }))) : (this.everyHelperDo((e) => e.hide()), this.actionIfStateIsEnabled(() => this.hooks.emit("hide", { userAction: t }))), this.state.visible = e;
+	}
+	handleDispose() {
+		this.everyHelperDo((e, t) => {
+			e.dispose(), t?.forEach((e) => e?.());
+		});
+	}
+	everyHelperDo(e) {
+		this.objectHelperMap.forEach(({ helper: t, disposers: n }) => {
+			t && e(t, n);
+		});
+	}
+	actionIfStateIsEnabled(e, t) {
+		if (this.state.enabled) return e();
+		t?.warnLog && Ee();
+	}
+	getConfig(e) {
+		if (e && typeof e != "boolean" && e.enable) return e;
+	}
+};
+//#endregion
+export { Oe as t };
+
+//# sourceMappingURL=Controller-Csut_kcH.js.map