@gui-chat-plugin/present3d 0.0.1

package/dist/vue.js

@@ -0,0 +1,794 @@
+import { c as N, d as Z, s as ft, p as bt } from "./toThreeJS-EXFMlO7B.js";
+import { a as he, e as le } from "./toThreeJS-EXFMlO7B.js";
+import { defineComponent as tt, ref as R, computed as et, onMounted as it, nextTick as q, onUnmounted as st, watch as O, createElementBlock as K, openBlock as H, createElementVNode as _, createCommentVNode as gt, toDisplayString as k, createTextVNode as j, withDirectives as yt, vModelText as wt } from "vue";
+import * as g from "three";
+import { Controls as Pt, Vector3 as E, MOUSE as C, TOUCH as x, Quaternion as B, Spherical as Q, Vector2 as P, Ray as Et, Plane as St, MathUtils as Dt } from "three";
+const $ = { type: "change" }, F = { type: "start" }, ot = { type: "end" }, z = new Et(), J = new St(), Tt = Math.cos(70 * Dt.DEG2RAD), d = new E(), f = 2 * Math.PI, l = {
+  NONE: -1,
+  ROTATE: 0,
+  DOLLY: 1,
+  PAN: 2,
+  TOUCH_ROTATE: 3,
+  TOUCH_PAN: 4,
+  TOUCH_DOLLY_PAN: 5,
+  TOUCH_DOLLY_ROTATE: 6
+}, Y = 1e-6;
+class vt extends Pt {
+  constructor(t, e = null) {
+    super(t, e), this.state = l.NONE, this.enabled = !0, this.target = new E(), this.cursor = new E(), this.minDistance = 0, this.maxDistance = 1 / 0, this.minZoom = 0, this.maxZoom = 1 / 0, this.minTargetRadius = 0, this.maxTargetRadius = 1 / 0, this.minPolarAngle = 0, this.maxPolarAngle = Math.PI, this.minAzimuthAngle = -1 / 0, this.maxAzimuthAngle = 1 / 0, this.enableDamping = !1, this.dampingFactor = 0.05, this.enableZoom = !0, this.zoomSpeed = 1, this.enableRotate = !0, this.rotateSpeed = 1, this.keyRotateSpeed = 1, this.enablePan = !0, this.panSpeed = 1, this.screenSpacePanning = !0, this.keyPanSpeed = 7, this.zoomToCursor = !1, this.autoRotate = !1, this.autoRotateSpeed = 2, this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" }, this.mouseButtons = { LEFT: C.ROTATE, MIDDLE: C.DOLLY, RIGHT: C.PAN }, this.touches = { ONE: x.ROTATE, TWO: x.DOLLY_PAN }, this.target0 = this.target.clone(), this.position0 = this.object.position.clone(), this.zoom0 = this.object.zoom, this._domElementKeyEvents = null, this._lastPosition = new E(), this._lastQuaternion = new B(), this._lastTargetPosition = new E(), this._quat = new B().setFromUnitVectors(t.up, new E(0, 1, 0)), this._quatInverse = this._quat.clone().invert(), this._spherical = new Q(), this._sphericalDelta = new Q(), this._scale = 1, this._panOffset = new E(), this._rotateStart = new P(), this._rotateEnd = new P(), this._rotateDelta = new P(), this._panStart = new P(), this._panEnd = new P(), this._panDelta = new P(), this._dollyStart = new P(), this._dollyEnd = new P(), this._dollyDelta = new P(), this._dollyDirection = new E(), this._mouse = new P(), this._performCursorZoom = !1, this._pointers = [], this._pointerPositions = {}, this._controlActive = !1, this._onPointerMove = Rt.bind(this), this._onPointerDown = Mt.bind(this), this._onPointerUp = Ot.bind(this), this._onContextMenu = zt.bind(this), this._onMouseWheel = Lt.bind(this), this._onKeyDown = At.bind(this), this._onTouchStart = kt.bind(this), this._onTouchMove = jt.bind(this), this._onMouseDown = xt.bind(this), this._onMouseMove = Ct.bind(this), this._interceptControlDown = Nt.bind(this), this._interceptControlUp = It.bind(this), this.domElement !== null && this.connect(), this.update();
+  }
+  connect() {
+    this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointercancel", this._onPointerUp), this.domElement.addEventListener("contextmenu", this._onContextMenu), this.domElement.addEventListener("wheel", this._onMouseWheel, { passive: !1 }), this.domElement.getRootNode().addEventListener("keydown", this._interceptControlDown, { passive: !0, capture: !0 }), this.domElement.style.touchAction = "none";
+  }
+  disconnect() {
+    this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.domElement.removeEventListener("pointercancel", this._onPointerUp), this.domElement.removeEventListener("wheel", this._onMouseWheel), this.domElement.removeEventListener("contextmenu", this._onContextMenu), this.stopListenToKeyEvents(), this.domElement.getRootNode().removeEventListener("keydown", this._interceptControlDown, { capture: !0 }), this.domElement.style.touchAction = "auto";
+  }
+  dispose() {
+    this.disconnect();
+  }
+  getPolarAngle() {
+    return this._spherical.phi;
+  }
+  getAzimuthalAngle() {
+    return this._spherical.theta;
+  }
+  getDistance() {
+    return this.object.position.distanceTo(this.target);
+  }
+  listenToKeyEvents(t) {
+    t.addEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = t;
+  }
+  stopListenToKeyEvents() {
+    this._domElementKeyEvents !== null && (this._domElementKeyEvents.removeEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = null);
+  }
+  saveState() {
+    this.target0.copy(this.target), this.position0.copy(this.object.position), this.zoom0 = this.object.zoom;
+  }
+  reset() {
+    this.target.copy(this.target0), this.object.position.copy(this.position0), this.object.zoom = this.zoom0, this.object.updateProjectionMatrix(), this.dispatchEvent($), this.update(), this.state = l.NONE;
+  }
+  update(t = null) {
+    const e = this.object.position;
+    d.copy(e).sub(this.target), d.applyQuaternion(this._quat), this._spherical.setFromVector3(d), this.autoRotate && this.state === l.NONE && this._rotateLeft(this._getAutoRotationAngle(t)), this.enableDamping ? (this._spherical.theta += this._sphericalDelta.theta * this.dampingFactor, this._spherical.phi += this._sphericalDelta.phi * this.dampingFactor) : (this._spherical.theta += this._sphericalDelta.theta, this._spherical.phi += this._sphericalDelta.phi);
+    let s = this.minAzimuthAngle, o = this.maxAzimuthAngle;
+    isFinite(s) && isFinite(o) && (s < -Math.PI ? s += f : s > Math.PI && (s -= f), o < -Math.PI ? o += f : o > Math.PI && (o -= f), s <= o ? this._spherical.theta = Math.max(s, Math.min(o, this._spherical.theta)) : this._spherical.theta = this._spherical.theta > (s + o) / 2 ? Math.max(s, this._spherical.theta) : Math.min(o, this._spherical.theta)), this._spherical.phi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, this._spherical.phi)), this._spherical.makeSafe(), this.enableDamping === !0 ? this.target.addScaledVector(this._panOffset, this.dampingFactor) : this.target.add(this._panOffset), this.target.sub(this.cursor), this.target.clampLength(this.minTargetRadius, this.maxTargetRadius), this.target.add(this.cursor);
+    let n = !1;
+    if (this.zoomToCursor && this._performCursorZoom || this.object.isOrthographicCamera)
+      this._spherical.radius = this._clampDistance(this._spherical.radius);
+    else {
+      const c = this._spherical.radius;
+      this._spherical.radius = this._clampDistance(this._spherical.radius * this._scale), n = c != this._spherical.radius;
+    }
+    if (d.setFromSpherical(this._spherical), d.applyQuaternion(this._quatInverse), e.copy(this.target).add(d), this.object.lookAt(this.target), this.enableDamping === !0 ? (this._sphericalDelta.theta *= 1 - this.dampingFactor, this._sphericalDelta.phi *= 1 - this.dampingFactor, this._panOffset.multiplyScalar(1 - this.dampingFactor)) : (this._sphericalDelta.set(0, 0, 0), this._panOffset.set(0, 0, 0)), this.zoomToCursor && this._performCursorZoom) {
+      let c = null;
+      if (this.object.isPerspectiveCamera) {
+        const p = d.length();
+        c = this._clampDistance(p * this._scale);
+        const u = p - c;
+        this.object.position.addScaledVector(this._dollyDirection, u), this.object.updateMatrixWorld(), n = !!u;
+      } else if (this.object.isOrthographicCamera) {
+        const p = new E(this._mouse.x, this._mouse.y, 0);
+        p.unproject(this.object);
+        const u = this.object.zoom;
+        this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), this.object.updateProjectionMatrix(), n = u !== this.object.zoom;
+        const v = new E(this._mouse.x, this._mouse.y, 0);
+        v.unproject(this.object), this.object.position.sub(v).add(p), this.object.updateMatrixWorld(), c = d.length();
+      } else
+        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled."), this.zoomToCursor = !1;
+      c !== null && (this.screenSpacePanning ? this.target.set(0, 0, -1).transformDirection(this.object.matrix).multiplyScalar(c).add(this.object.position) : (z.origin.copy(this.object.position), z.direction.set(0, 0, -1).transformDirection(this.object.matrix), Math.abs(this.object.up.dot(z.direction)) < Tt ? this.object.lookAt(this.target) : (J.setFromNormalAndCoplanarPoint(this.object.up, this.target), z.intersectPlane(J, this.target))));
+    } else if (this.object.isOrthographicCamera) {
+      const c = this.object.zoom;
+      this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), c !== this.object.zoom && (this.object.updateProjectionMatrix(), n = !0);
+    }
+    return this._scale = 1, this._performCursorZoom = !1, n || this._lastPosition.distanceToSquared(this.object.position) > Y || 8 * (1 - this._lastQuaternion.dot(this.object.quaternion)) > Y || this._lastTargetPosition.distanceToSquared(this.target) > Y ? (this.dispatchEvent($), this._lastPosition.copy(this.object.position), this._lastQuaternion.copy(this.object.quaternion), this._lastTargetPosition.copy(this.target), !0) : !1;
+  }
+  _getAutoRotationAngle(t) {
+    return t !== null ? f / 60 * this.autoRotateSpeed * t : f / 60 / 60 * this.autoRotateSpeed;
+  }
+  _getZoomScale(t) {
+    const e = Math.abs(t * 0.01);
+    return Math.pow(0.95, this.zoomSpeed * e);
+  }
+  _rotateLeft(t) {
+    this._sphericalDelta.theta -= t;
+  }
+  _rotateUp(t) {
+    this._sphericalDelta.phi -= t;
+  }
+  _panLeft(t, e) {
+    d.setFromMatrixColumn(e, 0), d.multiplyScalar(-t), this._panOffset.add(d);
+  }
+  _panUp(t, e) {
+    this.screenSpacePanning === !0 ? d.setFromMatrixColumn(e, 1) : (d.setFromMatrixColumn(e, 0), d.crossVectors(this.object.up, d)), d.multiplyScalar(t), this._panOffset.add(d);
+  }
+  // deltaX and deltaY are in pixels; right and down are positive
+  _pan(t, e) {
+    const s = this.domElement;
+    if (this.object.isPerspectiveCamera) {
+      const o = this.object.position;
+      d.copy(o).sub(this.target);
+      let n = d.length();
+      n *= Math.tan(this.object.fov / 2 * Math.PI / 180), this._panLeft(2 * t * n / s.clientHeight, this.object.matrix), this._panUp(2 * e * n / s.clientHeight, this.object.matrix);
+    } else this.object.isOrthographicCamera ? (this._panLeft(t * (this.object.right - this.object.left) / this.object.zoom / s.clientWidth, this.object.matrix), this._panUp(e * (this.object.top - this.object.bottom) / this.object.zoom / s.clientHeight, this.object.matrix)) : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."), this.enablePan = !1);
+  }
+  _dollyOut(t) {
+    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale /= t : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
+  }
+  _dollyIn(t) {
+    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale *= t : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
+  }
+  _updateZoomParameters(t, e) {
+    if (!this.zoomToCursor)
+      return;
+    this._performCursorZoom = !0;
+    const s = this.domElement.getBoundingClientRect(), o = t - s.left, n = e - s.top, c = s.width, p = s.height;
+    this._mouse.x = o / c * 2 - 1, this._mouse.y = -(n / p) * 2 + 1, this._dollyDirection.set(this._mouse.x, this._mouse.y, 1).unproject(this.object).sub(this.object.position).normalize();
+  }
+  _clampDistance(t) {
+    return Math.max(this.minDistance, Math.min(this.maxDistance, t));
+  }
+  //
+  // event callbacks - update the object state
+  //
+  _handleMouseDownRotate(t) {
+    this._rotateStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseDownDolly(t) {
+    this._updateZoomParameters(t.clientX, t.clientX), this._dollyStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseDownPan(t) {
+    this._panStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseMoveRotate(t) {
+    this._rotateEnd.set(t.clientX, t.clientY), this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const e = this.domElement;
+    this._rotateLeft(f * this._rotateDelta.x / e.clientHeight), this._rotateUp(f * this._rotateDelta.y / e.clientHeight), this._rotateStart.copy(this._rotateEnd), this.update();
+  }
+  _handleMouseMoveDolly(t) {
+    this._dollyEnd.set(t.clientX, t.clientY), this._dollyDelta.subVectors(this._dollyEnd, this._dollyStart), this._dollyDelta.y > 0 ? this._dollyOut(this._getZoomScale(this._dollyDelta.y)) : this._dollyDelta.y < 0 && this._dollyIn(this._getZoomScale(this._dollyDelta.y)), this._dollyStart.copy(this._dollyEnd), this.update();
+  }
+  _handleMouseMovePan(t) {
+    this._panEnd.set(t.clientX, t.clientY), this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed), this._pan(this._panDelta.x, this._panDelta.y), this._panStart.copy(this._panEnd), this.update();
+  }
+  _handleMouseWheel(t) {
+    this._updateZoomParameters(t.clientX, t.clientY), t.deltaY < 0 ? this._dollyIn(this._getZoomScale(t.deltaY)) : t.deltaY > 0 && this._dollyOut(this._getZoomScale(t.deltaY)), this.update();
+  }
+  _handleKeyDown(t) {
+    let e = !1;
+    switch (t.code) {
+      case this.keys.UP:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateUp(f * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(0, this.keyPanSpeed), e = !0;
+        break;
+      case this.keys.BOTTOM:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateUp(-f * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(0, -this.keyPanSpeed), e = !0;
+        break;
+      case this.keys.LEFT:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateLeft(f * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(this.keyPanSpeed, 0), e = !0;
+        break;
+      case this.keys.RIGHT:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateLeft(-f * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(-this.keyPanSpeed, 0), e = !0;
+        break;
+    }
+    e && (t.preventDefault(), this.update());
+  }
+  _handleTouchStartRotate(t) {
+    if (this._pointers.length === 1)
+      this._rotateStart.set(t.pageX, t.pageY);
+    else {
+      const e = this._getSecondPointerPosition(t), s = 0.5 * (t.pageX + e.x), o = 0.5 * (t.pageY + e.y);
+      this._rotateStart.set(s, o);
+    }
+  }
+  _handleTouchStartPan(t) {
+    if (this._pointers.length === 1)
+      this._panStart.set(t.pageX, t.pageY);
+    else {
+      const e = this._getSecondPointerPosition(t), s = 0.5 * (t.pageX + e.x), o = 0.5 * (t.pageY + e.y);
+      this._panStart.set(s, o);
+    }
+  }
+  _handleTouchStartDolly(t) {
+    const e = this._getSecondPointerPosition(t), s = t.pageX - e.x, o = t.pageY - e.y, n = Math.sqrt(s * s + o * o);
+    this._dollyStart.set(0, n);
+  }
+  _handleTouchStartDollyPan(t) {
+    this.enableZoom && this._handleTouchStartDolly(t), this.enablePan && this._handleTouchStartPan(t);
+  }
+  _handleTouchStartDollyRotate(t) {
+    this.enableZoom && this._handleTouchStartDolly(t), this.enableRotate && this._handleTouchStartRotate(t);
+  }
+  _handleTouchMoveRotate(t) {
+    if (this._pointers.length == 1)
+      this._rotateEnd.set(t.pageX, t.pageY);
+    else {
+      const s = this._getSecondPointerPosition(t), o = 0.5 * (t.pageX + s.x), n = 0.5 * (t.pageY + s.y);
+      this._rotateEnd.set(o, n);
+    }
+    this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const e = this.domElement;
+    this._rotateLeft(f * this._rotateDelta.x / e.clientHeight), this._rotateUp(f * this._rotateDelta.y / e.clientHeight), this._rotateStart.copy(this._rotateEnd);
+  }
+  _handleTouchMovePan(t) {
+    if (this._pointers.length === 1)
+      this._panEnd.set(t.pageX, t.pageY);
+    else {
+      const e = this._getSecondPointerPosition(t), s = 0.5 * (t.pageX + e.x), o = 0.5 * (t.pageY + e.y);
+      this._panEnd.set(s, o);
+    }
+    this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed), this._pan(this._panDelta.x, this._panDelta.y), this._panStart.copy(this._panEnd);
+  }
+  _handleTouchMoveDolly(t) {
+    const e = this._getSecondPointerPosition(t), s = t.pageX - e.x, o = t.pageY - e.y, n = Math.sqrt(s * s + o * o);
+    this._dollyEnd.set(0, n), this._dollyDelta.set(0, Math.pow(this._dollyEnd.y / this._dollyStart.y, this.zoomSpeed)), this._dollyOut(this._dollyDelta.y), this._dollyStart.copy(this._dollyEnd);
+    const c = (t.pageX + e.x) * 0.5, p = (t.pageY + e.y) * 0.5;
+    this._updateZoomParameters(c, p);
+  }
+  _handleTouchMoveDollyPan(t) {
+    this.enableZoom && this._handleTouchMoveDolly(t), this.enablePan && this._handleTouchMovePan(t);
+  }
+  _handleTouchMoveDollyRotate(t) {
+    this.enableZoom && this._handleTouchMoveDolly(t), this.enableRotate && this._handleTouchMoveRotate(t);
+  }
+  // pointers
+  _addPointer(t) {
+    this._pointers.push(t.pointerId);
+  }
+  _removePointer(t) {
+    delete this._pointerPositions[t.pointerId];
+    for (let e = 0; e < this._pointers.length; e++)
+      if (this._pointers[e] == t.pointerId) {
+        this._pointers.splice(e, 1);
+        return;
+      }
+  }
+  _isTrackingPointer(t) {
+    for (let e = 0; e < this._pointers.length; e++)
+      if (this._pointers[e] == t.pointerId) return !0;
+    return !1;
+  }
+  _trackPointer(t) {
+    let e = this._pointerPositions[t.pointerId];
+    e === void 0 && (e = new P(), this._pointerPositions[t.pointerId] = e), e.set(t.pageX, t.pageY);
+  }
+  _getSecondPointerPosition(t) {
+    const e = t.pointerId === this._pointers[0] ? this._pointers[1] : this._pointers[0];
+    return this._pointerPositions[e];
+  }
+  //
+  _customWheelEvent(t) {
+    const e = t.deltaMode, s = {
+      clientX: t.clientX,
+      clientY: t.clientY,
+      deltaY: t.deltaY
+    };
+    switch (e) {
+      case 1:
+        s.deltaY *= 16;
+        break;
+      case 2:
+        s.deltaY *= 100;
+        break;
+    }
+    return t.ctrlKey && !this._controlActive && (s.deltaY *= 10), s;
+  }
+}
+function Mt(i) {
+  this.enabled !== !1 && (this._pointers.length === 0 && (this.domElement.setPointerCapture(i.pointerId), this.domElement.addEventListener("pointermove", this._onPointerMove), this.domElement.addEventListener("pointerup", this._onPointerUp)), !this._isTrackingPointer(i) && (this._addPointer(i), i.pointerType === "touch" ? this._onTouchStart(i) : this._onMouseDown(i)));
+}
+function Rt(i) {
+  this.enabled !== !1 && (i.pointerType === "touch" ? this._onTouchMove(i) : this._onMouseMove(i));
+}
+function Ot(i) {
+  switch (this._removePointer(i), this._pointers.length) {
+    case 0:
+      this.domElement.releasePointerCapture(i.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.dispatchEvent(ot), this.state = l.NONE;
+      break;
+    case 1:
+      const t = this._pointers[0], e = this._pointerPositions[t];
+      this._onTouchStart({ pointerId: t, pageX: e.x, pageY: e.y });
+      break;
+  }
+}
+function xt(i) {
+  let t;
+  switch (i.button) {
+    case 0:
+      t = this.mouseButtons.LEFT;
+      break;
+    case 1:
+      t = this.mouseButtons.MIDDLE;
+      break;
+    case 2:
+      t = this.mouseButtons.RIGHT;
+      break;
+    default:
+      t = -1;
+  }
+  switch (t) {
+    case C.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseDownDolly(i), this.state = l.DOLLY;
+      break;
+    case C.ROTATE:
+      if (i.ctrlKey || i.metaKey || i.shiftKey) {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(i), this.state = l.PAN;
+      } else {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(i), this.state = l.ROTATE;
+      }
+      break;
+    case C.PAN:
+      if (i.ctrlKey || i.metaKey || i.shiftKey) {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(i), this.state = l.ROTATE;
+      } else {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(i), this.state = l.PAN;
+      }
+      break;
+    default:
+      this.state = l.NONE;
+  }
+  this.state !== l.NONE && this.dispatchEvent(F);
+}
+function Ct(i) {
+  switch (this.state) {
+    case l.ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleMouseMoveRotate(i);
+      break;
+    case l.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseMoveDolly(i);
+      break;
+    case l.PAN:
+      if (this.enablePan === !1) return;
+      this._handleMouseMovePan(i);
+      break;
+  }
+}
+function Lt(i) {
+  this.enabled === !1 || this.enableZoom === !1 || this.state !== l.NONE || (i.preventDefault(), this.dispatchEvent(F), this._handleMouseWheel(this._customWheelEvent(i)), this.dispatchEvent(ot));
+}
+function At(i) {
+  this.enabled !== !1 && this._handleKeyDown(i);
+}
+function kt(i) {
+  switch (this._trackPointer(i), this._pointers.length) {
+    case 1:
+      switch (this.touches.ONE) {
+        case x.ROTATE:
+          if (this.enableRotate === !1) return;
+          this._handleTouchStartRotate(i), this.state = l.TOUCH_ROTATE;
+          break;
+        case x.PAN:
+          if (this.enablePan === !1) return;
+          this._handleTouchStartPan(i), this.state = l.TOUCH_PAN;
+          break;
+        default:
+          this.state = l.NONE;
+      }
+      break;
+    case 2:
+      switch (this.touches.TWO) {
+        case x.DOLLY_PAN:
+          if (this.enableZoom === !1 && this.enablePan === !1) return;
+          this._handleTouchStartDollyPan(i), this.state = l.TOUCH_DOLLY_PAN;
+          break;
+        case x.DOLLY_ROTATE:
+          if (this.enableZoom === !1 && this.enableRotate === !1) return;
+          this._handleTouchStartDollyRotate(i), this.state = l.TOUCH_DOLLY_ROTATE;
+          break;
+        default:
+          this.state = l.NONE;
+      }
+      break;
+    default:
+      this.state = l.NONE;
+  }
+  this.state !== l.NONE && this.dispatchEvent(F);
+}
+function jt(i) {
+  switch (this._trackPointer(i), this.state) {
+    case l.TOUCH_ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleTouchMoveRotate(i), this.update();
+      break;
+    case l.TOUCH_PAN:
+      if (this.enablePan === !1) return;
+      this._handleTouchMovePan(i), this.update();
+      break;
+    case l.TOUCH_DOLLY_PAN:
+      if (this.enableZoom === !1 && this.enablePan === !1) return;
+      this._handleTouchMoveDollyPan(i), this.update();
+      break;
+    case l.TOUCH_DOLLY_ROTATE:
+      if (this.enableZoom === !1 && this.enableRotate === !1) return;
+      this._handleTouchMoveDollyRotate(i), this.update();
+      break;
+    default:
+      this.state = l.NONE;
+  }
+}
+function zt(i) {
+  this.enabled !== !1 && i.preventDefault();
+}
+function Nt(i) {
+  i.key === "Control" && (this._controlActive = !0, this.domElement.getRootNode().addEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+function It(i) {
+  i.key === "Control" && (this._controlActive = !1, this.domElement.getRootNode().removeEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+const Ut = { class: "present3d-container" }, Yt = { class: "header" }, Zt = { class: "controls" }, Kt = { class: "material-icons" }, Ht = { class: "material-icons" }, Ft = {
+  key: 0,
+  class: "error"
+}, Wt = { class: "script-source" }, Vt = ["disabled"], Xt = /* @__PURE__ */ tt({
+  __name: "View",
+  props: {
+    selectedResult: {}
+  },
+  emits: ["updateResult"],
+  setup(i, { emit: t }) {
+    var G;
+    const e = i, s = t, o = R(((G = e.selectedResult.data) == null ? void 0 : G.script) ?? ""), n = R(null), c = R(null), p = R(!1), u = R(!0), v = et(() => {
+      var a;
+      return o.value !== ((a = e.selectedResult.data) == null ? void 0 : a.script);
+    });
+    let y, m, w, r, b, S, L = [], D = null, M = null;
+    it(() => {
+      nt(), U(), W(), q(() => {
+        V();
+      });
+    }), st(() => {
+      dt();
+    }), O(
+      () => {
+        var a;
+        return (a = e.selectedResult.data) == null ? void 0 : a.script;
+      },
+      () => {
+        U();
+      }
+    ), O(p, () => {
+      U();
+    }), O(u, (a) => {
+      S && (S.visible = a);
+    });
+    function nt() {
+      if (!n.value) return;
+      y = new g.Scene(), y.background = new g.Color(1710618);
+      const a = n.value.clientWidth, h = n.value.clientHeight;
+      m = new g.PerspectiveCamera(50, a / h, 0.1, 1e3), m.position.set(5, 5, 10), m.lookAt(0, 0, 0), w = new g.WebGLRenderer({ antialias: !0 }), w.setSize(a, h), w.setPixelRatio(window.devicePixelRatio), n.value.appendChild(w.domElement), r = new vt(m, w.domElement), r.enableDamping = !0, r.dampingFactor = 0.05, r.addEventListener("change", X);
+      const T = new g.AmbientLight(16777215, 0.6);
+      y.add(T);
+      const A = new g.DirectionalLight(16777215, 0.8);
+      A.position.set(10, 10, 10), y.add(A), S = new g.GridHelper(20, 20, 4473924, 2236962), S.visible = u.value, y.add(S), window.addEventListener("resize", I), M = new ResizeObserver(() => {
+        I();
+      }), M.observe(n.value);
+    }
+    function I() {
+      if (!n.value) return;
+      const a = n.value.clientWidth, h = n.value.clientHeight;
+      m.aspect = a / h, m.updateProjectionMatrix(), w.setSize(a, h);
+    }
+    function U() {
+      var a;
+      try {
+        L.forEach((_t) => y.remove(_t)), L = [];
+        const h = (a = e.selectedResult.data) == null ? void 0 : a.script;
+        if (!h) return;
+        const T = N(h), A = Z(T, { wireframe: p.value });
+        y.add(A), L.push(A), c.value = null;
+      } catch (h) {
+        c.value = h instanceof Error ? h.message : "Unknown error", console.error("ShapeScript parse error:", h);
+      }
+    }
+    function W() {
+      b = requestAnimationFrame(W), r.update(), w.render(y, m);
+    }
+    function rt() {
+      m.position.set(5, 5, 10), m.lookAt(0, 0, 0), r.reset();
+    }
+    function V() {
+      var h, T;
+      if (!m || !r || !((T = (h = e.selectedResult) == null ? void 0 : h.viewState) != null && T.cameraState))
+        return;
+      const a = e.selectedResult.viewState.cameraState;
+      a.position && m.position.set(a.position.x, a.position.y, a.position.z), a.target && r.target.set(a.target.x, a.target.y, a.target.z), m.updateProjectionMatrix(), r.update();
+    }
+    function ht() {
+      return {
+        position: {
+          x: m.position.x,
+          y: m.position.y,
+          z: m.position.z
+        },
+        target: {
+          x: r.target.x,
+          y: r.target.y,
+          z: r.target.z
+        }
+      };
+    }
+    function X() {
+      D !== null && clearTimeout(D), D = window.setTimeout(() => {
+        lt();
+      }, 500);
+    }
+    function lt() {
+      const a = {
+        ...e.selectedResult,
+        viewState: {
+          cameraState: ht()
+        }
+      };
+      s("updateResult", a);
+    }
+    function ct() {
+      p.value = !p.value;
+    }
+    function pt() {
+      u.value = !u.value;
+    }
+    function dt() {
+      D !== null && clearTimeout(D), b && cancelAnimationFrame(b), w && w.dispose(), r && (r.removeEventListener("change", X), r.dispose()), M && M.disconnect(), window.removeEventListener("resize", I);
+    }
+    function ut() {
+    }
+    function mt() {
+      try {
+        N(o.value);
+        const a = {
+          ...e.selectedResult,
+          data: {
+            script: o.value
+          }
+        };
+        s("updateResult", a);
+      } catch (a) {
+        c.value = a instanceof Error ? a.message : "Invalid ShapeScript", console.error("Script validation failed:", a);
+      }
+    }
+    return O(
+      () => {
+        var a;
+        return (a = e.selectedResult.data) == null ? void 0 : a.script;
+      },
+      (a) => {
+        a && (o.value = a);
+      }
+    ), O(
+      () => e.selectedResult,
+      () => {
+        q(() => {
+          V();
+        });
+      }
+    ), (a, h) => (H(), K("div", Ut, [
+      _("div", Yt, [
+        _("h1", null, k(i.selectedResult.title || "3D Visualization"), 1),
+        _("div", Zt, [
+          _("button", {
+            onClick: rt,
+            class: "control-btn"
+          }, [...h[1] || (h[1] = [
+            _("span", { class: "material-icons" }, "refresh", -1),
+            j(" Reset Camera ", -1)
+          ])]),
+          _("button", {
+            onClick: ct,
+            class: "control-btn"
+          }, [
+            _("span", Kt, k(p.value ? "grid_off" : "grid_on"), 1),
+            h[2] || (h[2] = j(" Wireframe ", -1))
+          ]),
+          _("button", {
+            onClick: pt,
+            class: "control-btn"
+          }, [
+            _("span", Ht, k(u.value ? "visibility_off" : "visibility"), 1),
+            h[3] || (h[3] = j(" Grid ", -1))
+          ])
+        ])
+      ]),
+      c.value ? (H(), K("div", Ft, [
+        h[4] || (h[4] = _("strong", null, "Parse Error:", -1)),
+        j(" " + k(c.value), 1)
+      ])) : gt("", !0),
+      _("div", {
+        class: "viewport",
+        ref_key: "viewport",
+        ref: n
+      }, null, 512),
+      _("details", Wt, [
+        h[5] || (h[5] = _("summary", null, "Edit ShapeScript Source", -1)),
+        yt(_("textarea", {
+          "onUpdate:modelValue": h[0] || (h[0] = (T) => o.value = T),
+          onInput: ut,
+          class: "script-editor",
+          spellcheck: "false"
+        }, null, 544), [
+          [wt, o.value]
+        ]),
+        _("button", {
+          onClick: mt,
+          class: "apply-btn",
+          disabled: !v.value
+        }, " Apply Changes ", 8, Vt)
+      ])
+    ]));
+  }
+}), at = (i, t) => {
+  const e = i.__vccOpts || i;
+  for (const [s, o] of t)
+    e[s] = o;
+  return e;
+}, Gt = /* @__PURE__ */ at(Xt, [["__scopeId", "data-v-daa337a0"]]), qt = { class: "preview-container" }, Bt = { class: "preview-title" }, Qt = /* @__PURE__ */ tt({
+  __name: "Preview",
+  props: {
+    result: {}
+  },
+  setup(i) {
+    const t = i, e = et(() => t.result.title || "3D Visualization"), s = R(null);
+    let o, n, c, p, u = null;
+    it(() => {
+      v();
+    }), st(() => {
+      w();
+    }), O(
+      () => {
+        var r;
+        return (r = t.result.data) == null ? void 0 : r.script;
+      },
+      () => {
+        m();
+      }
+    );
+    function v() {
+      var r;
+      if (s.value)
+        try {
+          o = new g.Scene(), o.background = new g.Color(2763322);
+          const b = s.value.clientWidth || 200, S = s.value.clientHeight || 150;
+          n = new g.PerspectiveCamera(50, b / S, 0.1, 1e3), n.position.set(4, 4, 8), n.lookAt(0, 0, 0), c = new g.WebGLRenderer({ antialias: !0, alpha: !1 }), c.setSize(b, S), c.setPixelRatio(Math.min(window.devicePixelRatio, 2)), s.value.appendChild(c.domElement);
+          const L = new g.AmbientLight(16777215, 0.6);
+          o.add(L);
+          const D = new g.DirectionalLight(16777215, 0.8);
+          if (D.position.set(5, 5, 5), o.add(D), !((r = t.result.data) != null && r.script)) return;
+          const M = N(t.result.data.script);
+          u = Z(M, { wireframe: !1 }), o.add(u), y();
+        } catch (b) {
+          console.error("Preview render error:", b);
+        }
+    }
+    function y() {
+      p = requestAnimationFrame(y);
+      const r = Date.now() * 5e-4;
+      n.position.x = Math.cos(r) * 8, n.position.z = Math.sin(r) * 8, n.lookAt(0, 0, 0), c.render(o, n);
+    }
+    function m() {
+      var r;
+      if (!(!o || !((r = t.result.data) != null && r.script)))
+        try {
+          u && o.remove(u);
+          const b = N(t.result.data.script);
+          u = Z(b, { wireframe: !1 }), o.add(u);
+        } catch (b) {
+          console.error("Preview reload error:", b);
+        }
+    }
+    function w() {
+      p && cancelAnimationFrame(p), c && c.dispose();
+    }
+    return (r, b) => (H(), K("div", qt, [
+      _("div", {
+        ref_key: "previewViewport",
+        ref: s,
+        class: "preview-viewport"
+      }, null, 512),
+      _("div", Bt, k(e.value), 1)
+    ]));
+  }
+}), $t = /* @__PURE__ */ at(Qt, [["__scopeId", "data-v-75941188"]]), Jt = "present3D", te = `Use the ${Jt} tool to create interactive 3D visualizations when the user requests:
+- 3D models or shapes
+- Mathematical visualizations (surfaces, functions, geometric patterns)
+- Molecular or atomic structures
+- Data visualization in 3D (scatter plots, surface plots)
+- Architectural layouts
+- Game boards or 3D game states
+- Any spatial or geometric concepts
+
+## ShapeScript Language Features (FULL SUPPORT):
+
+### Variables & Expressions:
+- Define variables: define radius 2, define spacing 1.5
+- Use expressions: position (i * 2) 0 0, size (radius * 1.5)
+- Math operators: +, -, *, /, % with proper precedence
+- Parentheses for grouping: (2 + 3) * 4
+
+### Control Flow:
+
+For loops with variables (use loop variable in calculations):
+for i in 1 to 5 {
+    cube { position (i * 2 - 6) 0 0 size 1 }
+}
+
+For loops with step:
+for i in 0 to 10 step 2 {
+    sphere { position 0 i 0 }
+}
+
+If/else conditionals:
+if x > 0 {
+    sphere
+} else {
+    cube
+}
+
+Switch statements for multiple cases
+
+### Built-in Functions:
+- Math: round, floor, ceil, abs, sign, sqrt, pow, min, max
+- Trig: sin, cos, tan, asin, acos, atan, atan2 (radians!)
+- Vector: dot, cross, length, normalize, sum
+
+CRITICAL: Function calls require NO space between name and (
+- sin(x) ✓ correct
+- sin (x) ✗ wrong - this is NOT a function call!
+
+### Best Practices:
+1. Use variables for repeated values
+2. Use loop variables (i) for positioning and calculations
+3. Use trig functions for circular/spiral patterns
+4. Use conditionals for parametric designs
+5. Keep code readable with meaningful variable names
+
+### Common Patterns:
+
+Linear arrangement:
+for i in 1 to 5 {
+    cube { position (i * 2) 0 0 }
+}
+
+Circular pattern:
+define count 12
+for i in 1 to count {
+    define angle ((i / count) * 6.283)
+    cube { position (cos(angle) * 3) 0 (sin(angle) * 3) }
+}
+
+Parametric surface:
+for x in -5 to 5 {
+    for z in -5 to 5 {
+        define y (sin(x * 0.5) * cos(z * 0.5))
+        cube { position (x * 0.3) y (z * 0.3) size 0.2 }
+    }
+}
+
+### Primitives & CSG:
+Shapes: cube, sphere, cylinder, cone, torus
+CSG: union, difference, intersection, xor, stencil
+Properties: position, rotation, size, color, opacity
+
+Keep visualizations clear, well-organized, and leverage the full power of expressions and control flow.`, ee = {
+  ...bt,
+  viewComponent: Gt,
+  previewComponent: $t,
+  samples: ft,
+  systemPrompt: te
+}, ae = { plugin: ee };
+export {
+  $t as Preview,
+  te as SYSTEM_PROMPT,
+  he as TOOL_DEFINITION,
+  Jt as TOOL_NAME,
+  Gt as View,
+  Z as astToThreeJS,
+  ae as default,
+  le as executePresent3D,
+  N as parseShapeScript,
+  ee as plugin,
+  bt as pluginCore,
+  ft as samples
+};