@ccpc/canvas 0.1.3

package/index.js

@@ -0,0 +1,1976 @@
+import { Controls as Ht, Vector3 as d, MOUSE as z, TOUCH as A, Quaternion as lt, Spherical as ct, Vector2 as w, Ray as Gt, Plane as Ft, MathUtils as Et, InstancedBufferGeometry as Vt, Float32BufferAttribute as x, InstancedInterleavedBuffer as tt, InterleavedBufferAttribute as R, WireframeGeometry as Xt, Box3 as it, Sphere as St, ShaderMaterial as Zt, ShaderLib as N, UniformsUtils as Mt, UniformsLib as Y, Mesh as st, Vector4 as k, Line3 as qt, Matrix4 as vt, Group as H, BufferGeometry as G, PointsMaterial as xt, Points as Tt, BufferAttribute as Dt, MeshBasicMaterial as Pt, WebGLRenderer as Qt, SRGBColorSpace as $t, Scene as dt, OrthographicCamera as Jt, Raycaster as ut } from "three";
+import { RenderGroup as te, RenderPoint as Lt, RenderEdge as Ot, RenderMesh as Ct, RenderText as Ut, EN_AnchorX as At, EN_AnchorY as Rt, RenderNodeUtil as ee, IRender as ie, DisplayObjectMgr as pt } from "@ccpc/core";
+import { Vec3 as X, Vec2 as j, Ln3 as se, CONST as zt, Plane as ne, alg as oe } from "@ccpc/math";
+import { Text as jt } from "troika-three-text";
+var y = /* @__PURE__ */ ((n) => (n.MOUSE_DOWN = "mousedown", n.MOUSE_MOVE = "mousemove", n.MOUSE_UP = "mouseup", n.WHEEL = "wheel", n.CONTEXT_MENU = "contextmenu", n.MOUSE_LEAVE = "mouseleave", n.MOUSE_ENTER = "mouseenter", n))(y || {}), P = /* @__PURE__ */ ((n) => (n.KEY_DOWN = "keydown", n.KEY_UP = "keyup", n.KEY_PRESS = "keypress", n))(P || {}), h = /* @__PURE__ */ ((n) => (n.MOUSE_MOVE = "move", n.L_BUTTON_DOWN = "l_down", n.L_BUTTON_UP = "l_up", n.R_BUTTON_DOWN = "r_down", n.R_BUTTON_UP = "r_up", n.M_BUTTON_DOWN = "m_down", n.M_BUTTON_UP = "m_up", n.WHEEL_FORWARD = "wheel+", n.WHEEL_BACKWARD = "wheel-", n.WHEEL_START = "wheel_start", n.WHEEL_END = "wheel_end", n.R_CLICK = "r_clk", n.CLICK = "clk", n.SGL_CLICK = "sgl_clk", n.DBL_CLICK = "db_clk", n.MOUSE_LEAVE = "mouse_leave", n.MOUSE_ENTER = "mouse_enter", n))(h || {}), L = /* @__PURE__ */ ((n) => (n.KEY_DOWN = "down", n.KEY_UP = "up", n.KEY_PRESS = "press", n))(L || {});
+const U = {
+  common: {
+    /**鼠标从mousedown到mouseup的移动容差: 4px*/
+    click_to_tolerance: 4,
+    /**两次点击触发dbclick的间隔: 0.3s*/
+    dbl_click_interval: 0.3 * 1e3,
+    /**背景色*/
+    color_background: 0
+  }
+}, _t = { type: "change" }, nt = { type: "start" }, kt = { type: "end" }, B = new Gt(), ft = new Ft(), re = Math.cos(70 * Et.DEG2RAD), u = new d(), g = 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
+}, q = 1e-6;
+class ae extends Ht {
+  /**
+   * Constructs a new controls instance.
+   *
+   * @param {Object3D} object - The object that is managed by the controls.
+   * @param {?HTMLElement} domElement - The HTML element used for event listeners.
+   */
+  constructor(t, e = null) {
+    super(t, e), this.state = l.NONE, this.target = new d(), this.cursor = new d(), 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: z.ROTATE, MIDDLE: z.DOLLY, RIGHT: z.PAN }, this.touches = { ONE: A.ROTATE, TWO: A.DOLLY_PAN }, this.target0 = this.target.clone(), this.position0 = this.object.position.clone(), this.zoom0 = this.object.zoom, this._domElementKeyEvents = null, this._lastPosition = new d(), this._lastQuaternion = new lt(), this._lastTargetPosition = new d(), this._quat = new lt().setFromUnitVectors(t.up, new d(0, 1, 0)), this._quatInverse = this._quat.clone().invert(), this._spherical = new ct(), this._sphericalDelta = new ct(), this._scale = 1, this._panOffset = new d(), this._rotateStart = new w(), this._rotateEnd = new w(), this._rotateDelta = new w(), this._panStart = new w(), this._panEnd = new w(), this._panDelta = new w(), this._dollyStart = new w(), this._dollyEnd = new w(), this._dollyDelta = new w(), this._dollyDirection = new d(), this._mouse = new w(), this._performCursorZoom = !1, this._pointers = [], this._pointerPositions = {}, this._controlActive = !1, this._onPointerMove = le.bind(this), this._onPointerDown = he.bind(this), this._onPointerUp = ce.bind(this), this._onContextMenu = ye.bind(this), this._onMouseWheel = pe.bind(this), this._onKeyDown = _e.bind(this), this._onTouchStart = fe.bind(this), this._onTouchMove = me.bind(this), this._onMouseDown = de.bind(this), this._onMouseMove = ue.bind(this), this._interceptControlDown = ge.bind(this), this._interceptControlUp = we.bind(this), this.domElement !== null && this.connect(this.domElement), this.update();
+  }
+  connect(t) {
+    super.connect(t), 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();
+  }
+  /**
+   * Get the current vertical rotation, in radians.
+   *
+   * @return {number} The current vertical rotation, in radians.
+   */
+  getPolarAngle() {
+    return this._spherical.phi;
+  }
+  /**
+   * Get the current horizontal rotation, in radians.
+   *
+   * @return {number} The current horizontal rotation, in radians.
+   */
+  getAzimuthalAngle() {
+    return this._spherical.theta;
+  }
+  /**
+   * Returns the distance from the camera to the target.
+   *
+   * @return {number} The distance from the camera to the target.
+   */
+  getDistance() {
+    return this.object.position.distanceTo(this.target);
+  }
+  /**
+   * Adds key event listeners to the given DOM element.
+   * `window` is a recommended argument for using this method.
+   *
+   * @param {HTMLElement} domElement - The DOM element
+   */
+  listenToKeyEvents(t) {
+    t.addEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = t;
+  }
+  /**
+   * Removes the key event listener previously defined with `listenToKeyEvents()`.
+   */
+  stopListenToKeyEvents() {
+    this._domElementKeyEvents !== null && (this._domElementKeyEvents.removeEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = null);
+  }
+  /**
+   * Save the current state of the controls. This can later be recovered with `reset()`.
+   */
+  saveState() {
+    this.target0.copy(this.target), this.position0.copy(this.object.position), this.zoom0 = this.object.zoom;
+  }
+  /**
+   * Reset the controls to their state from either the last time the `saveState()`
+   * was called, or the initial state.
+   */
+  reset() {
+    this.target.copy(this.target0), this.object.position.copy(this.position0), this.object.zoom = this.zoom0, this.object.updateProjectionMatrix(), this.dispatchEvent(_t), this.update(), this.state = l.NONE;
+  }
+  update(t = null) {
+    const e = this.object.position;
+    u.copy(e).sub(this.target), u.applyQuaternion(this._quat), this._spherical.setFromVector3(u), 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, i = this.maxAzimuthAngle;
+    isFinite(s) && isFinite(i) && (s < -Math.PI ? s += g : s > Math.PI && (s -= g), i < -Math.PI ? i += g : i > Math.PI && (i -= g), s <= i ? this._spherical.theta = Math.max(s, Math.min(i, this._spherical.theta)) : this._spherical.theta = this._spherical.theta > (s + i) / 2 ? Math.max(s, this._spherical.theta) : Math.min(i, 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 o = !1;
+    if (this.zoomToCursor && this._performCursorZoom || this.object.isOrthographicCamera)
+      this._spherical.radius = this._clampDistance(this._spherical.radius);
+    else {
+      const r = this._spherical.radius;
+      this._spherical.radius = this._clampDistance(this._spherical.radius * this._scale), o = r != this._spherical.radius;
+    }
+    if (u.setFromSpherical(this._spherical), u.applyQuaternion(this._quatInverse), e.copy(this.target).add(u), 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 r = null;
+      if (this.object.isPerspectiveCamera) {
+        const a = u.length();
+        r = this._clampDistance(a * this._scale);
+        const c = a - r;
+        this.object.position.addScaledVector(this._dollyDirection, c), this.object.updateMatrixWorld(), o = !!c;
+      } else if (this.object.isOrthographicCamera) {
+        const a = new d(this._mouse.x, this._mouse.y, 0);
+        a.unproject(this.object);
+        const c = this.object.zoom;
+        this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), this.object.updateProjectionMatrix(), o = c !== this.object.zoom;
+        const p = new d(this._mouse.x, this._mouse.y, 0);
+        p.unproject(this.object), this.object.position.sub(p).add(a), this.object.updateMatrixWorld(), r = u.length();
+      } else
+        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled."), this.zoomToCursor = !1;
+      r !== null && (this.screenSpacePanning ? this.target.set(0, 0, -1).transformDirection(this.object.matrix).multiplyScalar(r).add(this.object.position) : (B.origin.copy(this.object.position), B.direction.set(0, 0, -1).transformDirection(this.object.matrix), Math.abs(this.object.up.dot(B.direction)) < re ? this.object.lookAt(this.target) : (ft.setFromNormalAndCoplanarPoint(this.object.up, this.target), B.intersectPlane(ft, this.target))));
+    } else if (this.object.isOrthographicCamera) {
+      const r = this.object.zoom;
+      this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), r !== this.object.zoom && (this.object.updateProjectionMatrix(), o = !0);
+    }
+    return this._scale = 1, this._performCursorZoom = !1, o || this._lastPosition.distanceToSquared(this.object.position) > q || 8 * (1 - this._lastQuaternion.dot(this.object.quaternion)) > q || this._lastTargetPosition.distanceToSquared(this.target) > q ? (this.dispatchEvent(_t), this._lastPosition.copy(this.object.position), this._lastQuaternion.copy(this.object.quaternion), this._lastTargetPosition.copy(this.target), !0) : !1;
+  }
+  _getAutoRotationAngle(t) {
+    return t !== null ? g / 60 * this.autoRotateSpeed * t : g / 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) {
+    u.setFromMatrixColumn(e, 0), u.multiplyScalar(-t), this._panOffset.add(u);
+  }
+  _panUp(t, e) {
+    this.screenSpacePanning === !0 ? u.setFromMatrixColumn(e, 1) : (u.setFromMatrixColumn(e, 0), u.crossVectors(this.object.up, u)), u.multiplyScalar(t), this._panOffset.add(u);
+  }
+  // deltaX and deltaY are in pixels; right and down are positive
+  _pan(t, e) {
+    const s = this.domElement;
+    if (this.object.isPerspectiveCamera) {
+      const i = this.object.position;
+      u.copy(i).sub(this.target);
+      let o = u.length();
+      o *= Math.tan(this.object.fov / 2 * Math.PI / 180), this._panLeft(2 * t * o / s.clientHeight, this.object.matrix), this._panUp(2 * e * o / 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(), i = t - s.left, o = e - s.top, r = s.width, a = s.height;
+    this._mouse.x = i / r * 2 - 1, this._mouse.y = -(o / a) * 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(g * this._rotateDelta.x / e.clientHeight), this._rotateUp(g * 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(g * 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(-g * 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(g * 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(-g * 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), i = 0.5 * (t.pageY + e.y);
+      this._rotateStart.set(s, i);
+    }
+  }
+  _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), i = 0.5 * (t.pageY + e.y);
+      this._panStart.set(s, i);
+    }
+  }
+  _handleTouchStartDolly(t) {
+    const e = this._getSecondPointerPosition(t), s = t.pageX - e.x, i = t.pageY - e.y, o = Math.sqrt(s * s + i * i);
+    this._dollyStart.set(0, o);
+  }
+  _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), i = 0.5 * (t.pageX + s.x), o = 0.5 * (t.pageY + s.y);
+      this._rotateEnd.set(i, o);
+    }
+    this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const e = this.domElement;
+    this._rotateLeft(g * this._rotateDelta.x / e.clientHeight), this._rotateUp(g * 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), i = 0.5 * (t.pageY + e.y);
+      this._panEnd.set(s, i);
+    }
+    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, i = t.pageY - e.y, o = Math.sqrt(s * s + i * i);
+    this._dollyEnd.set(0, o), 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 r = (t.pageX + e.x) * 0.5, a = (t.pageY + e.y) * 0.5;
+    this._updateZoomParameters(r, a);
+  }
+  _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 w(), 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 he(n) {
+  this.enabled !== !1 && (this._pointers.length === 0 && (this.domElement.setPointerCapture(n.pointerId), this.domElement.addEventListener("pointermove", this._onPointerMove), this.domElement.addEventListener("pointerup", this._onPointerUp)), !this._isTrackingPointer(n) && (this._addPointer(n), n.pointerType === "touch" ? this._onTouchStart(n) : this._onMouseDown(n)));
+}
+function le(n) {
+  this.enabled !== !1 && (n.pointerType === "touch" ? this._onTouchMove(n) : this._onMouseMove(n));
+}
+function ce(n) {
+  switch (this._removePointer(n), this._pointers.length) {
+    case 0:
+      this.domElement.releasePointerCapture(n.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.dispatchEvent(kt), 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 de(n) {
+  let t;
+  switch (n.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 z.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseDownDolly(n), this.state = l.DOLLY;
+      break;
+    case z.ROTATE:
+      if (n.ctrlKey || n.metaKey || n.shiftKey) {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(n), this.state = l.PAN;
+      } else {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(n), this.state = l.ROTATE;
+      }
+      break;
+    case z.PAN:
+      if (n.ctrlKey || n.metaKey || n.shiftKey) {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(n), this.state = l.ROTATE;
+      } else {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(n), this.state = l.PAN;
+      }
+      break;
+    default:
+      this.state = l.NONE;
+  }
+  this.state !== l.NONE && this.dispatchEvent(nt);
+}
+function ue(n) {
+  switch (this.state) {
+    case l.ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleMouseMoveRotate(n);
+      break;
+    case l.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseMoveDolly(n);
+      break;
+    case l.PAN:
+      if (this.enablePan === !1) return;
+      this._handleMouseMovePan(n);
+      break;
+  }
+}
+function pe(n) {
+  this.enabled === !1 || this.enableZoom === !1 || this.state !== l.NONE || (n.preventDefault(), this.dispatchEvent(nt), this._handleMouseWheel(this._customWheelEvent(n)), this.dispatchEvent(kt));
+}
+function _e(n) {
+  this.enabled !== !1 && this._handleKeyDown(n);
+}
+function fe(n) {
+  switch (this._trackPointer(n), this._pointers.length) {
+    case 1:
+      switch (this.touches.ONE) {
+        case A.ROTATE:
+          if (this.enableRotate === !1) return;
+          this._handleTouchStartRotate(n), this.state = l.TOUCH_ROTATE;
+          break;
+        case A.PAN:
+          if (this.enablePan === !1) return;
+          this._handleTouchStartPan(n), this.state = l.TOUCH_PAN;
+          break;
+        default:
+          this.state = l.NONE;
+      }
+      break;
+    case 2:
+      switch (this.touches.TWO) {
+        case A.DOLLY_PAN:
+          if (this.enableZoom === !1 && this.enablePan === !1) return;
+          this._handleTouchStartDollyPan(n), this.state = l.TOUCH_DOLLY_PAN;
+          break;
+        case A.DOLLY_ROTATE:
+          if (this.enableZoom === !1 && this.enableRotate === !1) return;
+          this._handleTouchStartDollyRotate(n), this.state = l.TOUCH_DOLLY_ROTATE;
+          break;
+        default:
+          this.state = l.NONE;
+      }
+      break;
+    default:
+      this.state = l.NONE;
+  }
+  this.state !== l.NONE && this.dispatchEvent(nt);
+}
+function me(n) {
+  switch (this._trackPointer(n), this.state) {
+    case l.TOUCH_ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleTouchMoveRotate(n), this.update();
+      break;
+    case l.TOUCH_PAN:
+      if (this.enablePan === !1) return;
+      this._handleTouchMovePan(n), this.update();
+      break;
+    case l.TOUCH_DOLLY_PAN:
+      if (this.enableZoom === !1 && this.enablePan === !1) return;
+      this._handleTouchMoveDollyPan(n), this.update();
+      break;
+    case l.TOUCH_DOLLY_ROTATE:
+      if (this.enableZoom === !1 && this.enableRotate === !1) return;
+      this._handleTouchMoveDollyRotate(n), this.update();
+      break;
+    default:
+      this.state = l.NONE;
+  }
+}
+function ye(n) {
+  this.enabled !== !1 && n.preventDefault();
+}
+function ge(n) {
+  n.key === "Control" && (this._controlActive = !0, this.domElement.getRootNode().addEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+function we(n) {
+  n.key === "Control" && (this._controlActive = !1, this.domElement.getRootNode().removeEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+const mt = new it(), K = new d();
+class Bt extends Vt {
+  /**
+   * Constructs a new line segments geometry.
+   */
+  constructor() {
+    super(), this.isLineSegmentsGeometry = !0, this.type = "LineSegmentsGeometry";
+    const t = [-1, 2, 0, 1, 2, 0, -1, 1, 0, 1, 1, 0, -1, 0, 0, 1, 0, 0, -1, -1, 0, 1, -1, 0], e = [-1, 2, 1, 2, -1, 1, 1, 1, -1, -1, 1, -1, -1, -2, 1, -2], s = [0, 2, 1, 2, 3, 1, 2, 4, 3, 4, 5, 3, 4, 6, 5, 6, 7, 5];
+    this.setIndex(s), this.setAttribute("position", new x(t, 3)), this.setAttribute("uv", new x(e, 2));
+  }
+  /**
+   * Applies the given 4x4 transformation matrix to the geometry.
+   *
+   * @param {Matrix4} matrix - The matrix to apply.
+   * @return {LineSegmentsGeometry} A reference to this instance.
+   */
+  applyMatrix4(t) {
+    const e = this.attributes.instanceStart, s = this.attributes.instanceEnd;
+    return e !== void 0 && (e.applyMatrix4(t), s.applyMatrix4(t), e.needsUpdate = !0), this.boundingBox !== null && this.computeBoundingBox(), this.boundingSphere !== null && this.computeBoundingSphere(), this;
+  }
+  /**
+   * Sets the given line positions for this geometry. The length must be a multiple of six since
+   * each line segment is defined by a start end vertex in the pattern `(xyz xyz)`.
+   *
+   * @param {Float32Array|Array<number>} array - The position data to set.
+   * @return {LineSegmentsGeometry} A reference to this geometry.
+   */
+  setPositions(t) {
+    let e;
+    t instanceof Float32Array ? e = t : Array.isArray(t) && (e = new Float32Array(t));
+    const s = new tt(e, 6, 1);
+    return this.setAttribute("instanceStart", new R(s, 3, 0)), this.setAttribute("instanceEnd", new R(s, 3, 3)), this.instanceCount = this.attributes.instanceStart.count, this.computeBoundingBox(), this.computeBoundingSphere(), this;
+  }
+  /**
+   * Sets the given line colors for this geometry. The length must be a multiple of six since
+   * each line segment is defined by a start end color in the pattern `(rgb rgb)`.
+   *
+   * @param {Float32Array|Array<number>} array - The position data to set.
+   * @return {LineSegmentsGeometry} A reference to this geometry.
+   */
+  setColors(t) {
+    let e;
+    t instanceof Float32Array ? e = t : Array.isArray(t) && (e = new Float32Array(t));
+    const s = new tt(e, 6, 1);
+    return this.setAttribute("instanceColorStart", new R(s, 3, 0)), this.setAttribute("instanceColorEnd", new R(s, 3, 3)), this;
+  }
+  /**
+   * Setups this line segments geometry from the given wireframe geometry.
+   *
+   * @param {WireframeGeometry} geometry - The geometry that should be used as a data source for this geometry.
+   * @return {LineSegmentsGeometry} A reference to this geometry.
+   */
+  fromWireframeGeometry(t) {
+    return this.setPositions(t.attributes.position.array), this;
+  }
+  /**
+   * Setups this line segments geometry from the given edges geometry.
+   *
+   * @param {EdgesGeometry} geometry - The geometry that should be used as a data source for this geometry.
+   * @return {LineSegmentsGeometry} A reference to this geometry.
+   */
+  fromEdgesGeometry(t) {
+    return this.setPositions(t.attributes.position.array), this;
+  }
+  /**
+   * Setups this line segments geometry from the given mesh.
+   *
+   * @param {Mesh} mesh - The mesh geometry that should be used as a data source for this geometry.
+   * @return {LineSegmentsGeometry} A reference to this geometry.
+   */
+  fromMesh(t) {
+    return this.fromWireframeGeometry(new Xt(t.geometry)), this;
+  }
+  /**
+   * Setups this line segments geometry from the given line segments.
+   *
+   * @param {LineSegments} lineSegments - The line segments that should be used as a data source for this geometry.
+   * Assumes the source geometry is not using indices.
+   * @return {LineSegmentsGeometry} A reference to this geometry.
+   */
+  fromLineSegments(t) {
+    const e = t.geometry;
+    return this.setPositions(e.attributes.position.array), this;
+  }
+  computeBoundingBox() {
+    this.boundingBox === null && (this.boundingBox = new it());
+    const t = this.attributes.instanceStart, e = this.attributes.instanceEnd;
+    t !== void 0 && e !== void 0 && (this.boundingBox.setFromBufferAttribute(t), mt.setFromBufferAttribute(e), this.boundingBox.union(mt));
+  }
+  computeBoundingSphere() {
+    this.boundingSphere === null && (this.boundingSphere = new St()), this.boundingBox === null && this.computeBoundingBox();
+    const t = this.attributes.instanceStart, e = this.attributes.instanceEnd;
+    if (t !== void 0 && e !== void 0) {
+      const s = this.boundingSphere.center;
+      this.boundingBox.getCenter(s);
+      let i = 0;
+      for (let o = 0, r = t.count; o < r; o++)
+        K.fromBufferAttribute(t, o), i = Math.max(i, s.distanceToSquared(K)), K.fromBufferAttribute(e, o), i = Math.max(i, s.distanceToSquared(K));
+      this.boundingSphere.radius = Math.sqrt(i), isNaN(this.boundingSphere.radius) && console.error("THREE.LineSegmentsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.", this);
+    }
+  }
+  toJSON() {
+  }
+}
+Y.line = {
+  worldUnits: { value: 1 },
+  linewidth: { value: 1 },
+  resolution: { value: new w(1, 1) },
+  dashOffset: { value: 0 },
+  dashScale: { value: 1 },
+  dashSize: { value: 1 },
+  gapSize: { value: 1 }
+  // todo FIX - maybe change to totalSize
+};
+N.line = {
+  uniforms: Mt.merge([
+    Y.common,
+    Y.fog,
+    Y.line
+  ]),
+  vertexShader: (
+    /* glsl */
+    `
+		#include <common>
+		#include <color_pars_vertex>
+		#include <fog_pars_vertex>
+		#include <logdepthbuf_pars_vertex>
+		#include <clipping_planes_pars_vertex>
+
+		uniform float linewidth;
+		uniform vec2 resolution;
+
+		attribute vec3 instanceStart;
+		attribute vec3 instanceEnd;
+
+		attribute vec3 instanceColorStart;
+		attribute vec3 instanceColorEnd;
+
+		#ifdef WORLD_UNITS
+
+			varying vec4 worldPos;
+			varying vec3 worldStart;
+			varying vec3 worldEnd;
+
+			#ifdef USE_DASH
+
+				varying vec2 vUv;
+
+			#endif
+
+		#else
+
+			varying vec2 vUv;
+
+		#endif
+
+		#ifdef USE_DASH
+
+			uniform float dashScale;
+			attribute float instanceDistanceStart;
+			attribute float instanceDistanceEnd;
+			varying float vLineDistance;
+
+		#endif
+
+		void trimSegment( const in vec4 start, inout vec4 end ) {
+
+			// trim end segment so it terminates between the camera plane and the near plane
+
+			// conservative estimate of the near plane
+			float a = projectionMatrix[ 2 ][ 2 ]; // 3nd entry in 3th column
+			float b = projectionMatrix[ 3 ][ 2 ]; // 3nd entry in 4th column
+			float nearEstimate = - 0.5 * b / a;
+
+			float alpha = ( nearEstimate - start.z ) / ( end.z - start.z );
+
+			end.xyz = mix( start.xyz, end.xyz, alpha );
+
+		}
+
+		void main() {
+
+			#ifdef USE_COLOR
+
+				vColor.xyz = ( position.y < 0.5 ) ? instanceColorStart : instanceColorEnd;
+
+			#endif
+
+			#ifdef USE_DASH
+
+				vLineDistance = ( position.y < 0.5 ) ? dashScale * instanceDistanceStart : dashScale * instanceDistanceEnd;
+				vUv = uv;
+
+			#endif
+
+			float aspect = resolution.x / resolution.y;
+
+			// camera space
+			vec4 start = modelViewMatrix * vec4( instanceStart, 1.0 );
+			vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 );
+
+			#ifdef WORLD_UNITS
+
+				worldStart = start.xyz;
+				worldEnd = end.xyz;
+
+			#else
+
+				vUv = uv;
+
+			#endif
+
+			// special case for perspective projection, and segments that terminate either in, or behind, the camera plane
+			// clearly the gpu firmware has a way of addressing this issue when projecting into ndc space
+			// but we need to perform ndc-space calculations in the shader, so we must address this issue directly
+			// perhaps there is a more elegant solution -- WestLangley
+
+			bool perspective = ( projectionMatrix[ 2 ][ 3 ] == - 1.0 ); // 4th entry in the 3rd column
+
+			if ( perspective ) {
+
+				if ( start.z < 0.0 && end.z >= 0.0 ) {
+
+					trimSegment( start, end );
+
+				} else if ( end.z < 0.0 && start.z >= 0.0 ) {
+
+					trimSegment( end, start );
+
+				}
+
+			}
+
+			// clip space
+			vec4 clipStart = projectionMatrix * start;
+			vec4 clipEnd = projectionMatrix * end;
+
+			// ndc space
+			vec3 ndcStart = clipStart.xyz / clipStart.w;
+			vec3 ndcEnd = clipEnd.xyz / clipEnd.w;
+
+			// direction
+			vec2 dir = ndcEnd.xy - ndcStart.xy;
+
+			// account for clip-space aspect ratio
+			dir.x *= aspect;
+			dir = normalize( dir );
+
+			#ifdef WORLD_UNITS
+
+				vec3 worldDir = normalize( end.xyz - start.xyz );
+				vec3 tmpFwd = normalize( mix( start.xyz, end.xyz, 0.5 ) );
+				vec3 worldUp = normalize( cross( worldDir, tmpFwd ) );
+				vec3 worldFwd = cross( worldDir, worldUp );
+				worldPos = position.y < 0.5 ? start: end;
+
+				// height offset
+				float hw = linewidth * 0.5;
+				worldPos.xyz += position.x < 0.0 ? hw * worldUp : - hw * worldUp;
+
+				// don't extend the line if we're rendering dashes because we
+				// won't be rendering the endcaps
+				#ifndef USE_DASH
+
+					// cap extension
+					worldPos.xyz += position.y < 0.5 ? - hw * worldDir : hw * worldDir;
+
+					// add width to the box
+					worldPos.xyz += worldFwd * hw;
+
+					// endcaps
+					if ( position.y > 1.0 || position.y < 0.0 ) {
+
+						worldPos.xyz -= worldFwd * 2.0 * hw;
+
+					}
+
+				#endif
+
+				// project the worldpos
+				vec4 clip = projectionMatrix * worldPos;
+
+				// shift the depth of the projected points so the line
+				// segments overlap neatly
+				vec3 clipPose = ( position.y < 0.5 ) ? ndcStart : ndcEnd;
+				clip.z = clipPose.z * clip.w;
+
+			#else
+
+				vec2 offset = vec2( dir.y, - dir.x );
+				// undo aspect ratio adjustment
+				dir.x /= aspect;
+				offset.x /= aspect;
+
+				// sign flip
+				if ( position.x < 0.0 ) offset *= - 1.0;
+
+				// endcaps
+				if ( position.y < 0.0 ) {
+
+					offset += - dir;
+
+				} else if ( position.y > 1.0 ) {
+
+					offset += dir;
+
+				}
+
+				// adjust for linewidth
+				offset *= linewidth;
+
+				// adjust for clip-space to screen-space conversion // maybe resolution should be based on viewport ...
+				offset /= resolution.y;
+
+				// select end
+				vec4 clip = ( position.y < 0.5 ) ? clipStart : clipEnd;
+
+				// back to clip space
+				offset *= clip.w;
+
+				clip.xy += offset;
+
+			#endif
+
+			gl_Position = clip;
+
+			vec4 mvPosition = ( position.y < 0.5 ) ? start : end; // this is an approximation
+
+			#include <logdepthbuf_vertex>
+			#include <clipping_planes_vertex>
+			#include <fog_vertex>
+
+		}
+		`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+		uniform vec3 diffuse;
+		uniform float opacity;
+		uniform float linewidth;
+
+		#ifdef USE_DASH
+
+			uniform float dashOffset;
+			uniform float dashSize;
+			uniform float gapSize;
+
+		#endif
+
+		varying float vLineDistance;
+
+		#ifdef WORLD_UNITS
+
+			varying vec4 worldPos;
+			varying vec3 worldStart;
+			varying vec3 worldEnd;
+
+			#ifdef USE_DASH
+
+				varying vec2 vUv;
+
+			#endif
+
+		#else
+
+			varying vec2 vUv;
+
+		#endif
+
+		#include <common>
+		#include <color_pars_fragment>
+		#include <fog_pars_fragment>
+		#include <logdepthbuf_pars_fragment>
+		#include <clipping_planes_pars_fragment>
+
+		vec2 closestLineToLine(vec3 p1, vec3 p2, vec3 p3, vec3 p4) {
+
+			float mua;
+			float mub;
+
+			vec3 p13 = p1 - p3;
+			vec3 p43 = p4 - p3;
+
+			vec3 p21 = p2 - p1;
+
+			float d1343 = dot( p13, p43 );
+			float d4321 = dot( p43, p21 );
+			float d1321 = dot( p13, p21 );
+			float d4343 = dot( p43, p43 );
+			float d2121 = dot( p21, p21 );
+
+			float denom = d2121 * d4343 - d4321 * d4321;
+
+			float numer = d1343 * d4321 - d1321 * d4343;
+
+			mua = numer / denom;
+			mua = clamp( mua, 0.0, 1.0 );
+			mub = ( d1343 + d4321 * ( mua ) ) / d4343;
+			mub = clamp( mub, 0.0, 1.0 );
+
+			return vec2( mua, mub );
+
+		}
+
+		void main() {
+
+			float alpha = opacity;
+			vec4 diffuseColor = vec4( diffuse, alpha );
+
+			#include <clipping_planes_fragment>
+
+			#ifdef USE_DASH
+
+				if ( vUv.y < - 1.0 || vUv.y > 1.0 ) discard; // discard endcaps
+
+				if ( mod( vLineDistance + dashOffset, dashSize + gapSize ) > dashSize ) discard; // todo - FIX
+
+			#endif
+
+			#ifdef WORLD_UNITS
+
+				// Find the closest points on the view ray and the line segment
+				vec3 rayEnd = normalize( worldPos.xyz ) * 1e5;
+				vec3 lineDir = worldEnd - worldStart;
+				vec2 params = closestLineToLine( worldStart, worldEnd, vec3( 0.0, 0.0, 0.0 ), rayEnd );
+
+				vec3 p1 = worldStart + lineDir * params.x;
+				vec3 p2 = rayEnd * params.y;
+				vec3 delta = p1 - p2;
+				float len = length( delta );
+				float norm = len / linewidth;
+
+				#ifndef USE_DASH
+
+					#ifdef USE_ALPHA_TO_COVERAGE
+
+						float dnorm = fwidth( norm );
+						alpha = 1.0 - smoothstep( 0.5 - dnorm, 0.5 + dnorm, norm );
+
+					#else
+
+						if ( norm > 0.5 ) {
+
+							discard;
+
+						}
+
+					#endif
+
+				#endif
+
+			#else
+
+				#ifdef USE_ALPHA_TO_COVERAGE
+
+					// artifacts appear on some hardware if a derivative is taken within a conditional
+					float a = vUv.x;
+					float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
+					float len2 = a * a + b * b;
+					float dlen = fwidth( len2 );
+
+					if ( abs( vUv.y ) > 1.0 ) {
+
+						alpha = 1.0 - smoothstep( 1.0 - dlen, 1.0 + dlen, len2 );
+
+					}
+
+				#else
+
+					if ( abs( vUv.y ) > 1.0 ) {
+
+						float a = vUv.x;
+						float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
+						float len2 = a * a + b * b;
+
+						if ( len2 > 1.0 ) discard;
+
+					}
+
+				#endif
+
+			#endif
+
+			#include <logdepthbuf_fragment>
+			#include <color_fragment>
+
+			gl_FragColor = vec4( diffuseColor.rgb, alpha );
+
+			#include <tonemapping_fragment>
+			#include <colorspace_fragment>
+			#include <fog_fragment>
+			#include <premultiplied_alpha_fragment>
+
+		}
+		`
+  )
+};
+class Z extends Zt {
+  /**
+   * Constructs a new line segments geometry.
+   *
+   * @param {Object} [parameters] - An object with one or more properties
+   * defining the material's appearance. Any property of the material
+   * (including any property from inherited materials) can be passed
+   * in here. Color values can be passed any type of value accepted
+   * by {@link Color#set}.
+   */
+  constructor(t) {
+    super({
+      type: "LineMaterial",
+      uniforms: Mt.clone(N.line.uniforms),
+      vertexShader: N.line.vertexShader,
+      fragmentShader: N.line.fragmentShader,
+      clipping: !0
+      // required for clipping support
+    }), this.isLineMaterial = !0, this.setValues(t);
+  }
+  /**
+   * The material's color.
+   *
+   * @type {Color}
+   * @default (1,1,1)
+   */
+  get color() {
+    return this.uniforms.diffuse.value;
+  }
+  set color(t) {
+    this.uniforms.diffuse.value = t;
+  }
+  /**
+   * Whether the material's sizes (width, dash gaps) are in world units.
+   *
+   * @type {boolean}
+   * @default false
+   */
+  get worldUnits() {
+    return "WORLD_UNITS" in this.defines;
+  }
+  set worldUnits(t) {
+    t === !0 ? this.defines.WORLD_UNITS = "" : delete this.defines.WORLD_UNITS;
+  }
+  /**
+   * Controls line thickness in CSS pixel units when `worldUnits` is `false` (default),
+   * or in world units when `worldUnits` is `true`.
+   *
+   * @type {number}
+   * @default 1
+   */
+  get linewidth() {
+    return this.uniforms.linewidth.value;
+  }
+  set linewidth(t) {
+    this.uniforms.linewidth && (this.uniforms.linewidth.value = t);
+  }
+  /**
+   * Whether the line is dashed, or solid.
+   *
+   * @type {boolean}
+   * @default false
+   */
+  get dashed() {
+    return "USE_DASH" in this.defines;
+  }
+  set dashed(t) {
+    t === !0 !== this.dashed && (this.needsUpdate = !0), t === !0 ? this.defines.USE_DASH = "" : delete this.defines.USE_DASH;
+  }
+  /**
+   * The scale of the dashes and gaps.
+   *
+   * @type {number}
+   * @default 1
+   */
+  get dashScale() {
+    return this.uniforms.dashScale.value;
+  }
+  set dashScale(t) {
+    this.uniforms.dashScale.value = t;
+  }
+  /**
+   * The size of the dash.
+   *
+   * @type {number}
+   * @default 1
+   */
+  get dashSize() {
+    return this.uniforms.dashSize.value;
+  }
+  set dashSize(t) {
+    this.uniforms.dashSize.value = t;
+  }
+  /**
+   * Where in the dash cycle the dash starts.
+   *
+   * @type {number}
+   * @default 0
+   */
+  get dashOffset() {
+    return this.uniforms.dashOffset.value;
+  }
+  set dashOffset(t) {
+    this.uniforms.dashOffset.value = t;
+  }
+  /**
+   * The size of the gap.
+   *
+   * @type {number}
+   * @default 0
+   */
+  get gapSize() {
+    return this.uniforms.gapSize.value;
+  }
+  set gapSize(t) {
+    this.uniforms.gapSize.value = t;
+  }
+  /**
+   * The opacity.
+   *
+   * @type {number}
+   * @default 1
+   */
+  get opacity() {
+    return this.uniforms.opacity.value;
+  }
+  set opacity(t) {
+    this.uniforms && (this.uniforms.opacity.value = t);
+  }
+  /**
+   * The size of the viewport, in screen pixels. This must be kept updated to make
+   * screen-space rendering accurate.The `LineSegments2.onBeforeRender` callback
+   * performs the update for visible objects.
+   *
+   * @type {Vector2}
+   */
+  get resolution() {
+    return this.uniforms.resolution.value;
+  }
+  set resolution(t) {
+    this.uniforms.resolution.value.copy(t);
+  }
+  /**
+   * Whether to use alphaToCoverage or not. When enabled, this can improve the
+   * anti-aliasing of line edges when using MSAA.
+   *
+   * @type {boolean}
+   */
+  get alphaToCoverage() {
+    return "USE_ALPHA_TO_COVERAGE" in this.defines;
+  }
+  set alphaToCoverage(t) {
+    this.defines && (t === !0 !== this.alphaToCoverage && (this.needsUpdate = !0), t === !0 ? this.defines.USE_ALPHA_TO_COVERAGE = "" : delete this.defines.USE_ALPHA_TO_COVERAGE);
+  }
+}
+const Q = new k(), yt = new d(), gt = new d(), _ = new k(), f = new k(), S = new k(), $ = new d(), J = new vt(), m = new qt(), wt = new d(), W = new it(), I = new St(), M = new k();
+let v, O;
+function bt(n, t, e) {
+  return M.set(0, 0, -t, 1).applyMatrix4(n.projectionMatrix), M.multiplyScalar(1 / M.w), M.x = O / e.width, M.y = O / e.height, M.applyMatrix4(n.projectionMatrixInverse), M.multiplyScalar(1 / M.w), Math.abs(Math.max(M.x, M.y));
+}
+function be(n, t) {
+  const e = n.matrixWorld, s = n.geometry, i = s.attributes.instanceStart, o = s.attributes.instanceEnd, r = Math.min(s.instanceCount, i.count);
+  for (let a = 0, c = r; a < c; a++) {
+    m.start.fromBufferAttribute(i, a), m.end.fromBufferAttribute(o, a), m.applyMatrix4(e);
+    const p = new d(), E = new d();
+    v.distanceSqToSegment(m.start, m.end, E, p), E.distanceTo(p) < O * 0.5 && t.push({
+      point: E,
+      pointOnLine: p,
+      distance: v.origin.distanceTo(E),
+      object: n,
+      face: null,
+      faceIndex: a,
+      uv: null,
+      uv1: null
+    });
+  }
+}
+function Ee(n, t, e) {
+  const s = t.projectionMatrix, o = n.material.resolution, r = n.matrixWorld, a = n.geometry, c = a.attributes.instanceStart, p = a.attributes.instanceEnd, E = Math.min(a.instanceCount, c.count), b = -t.near;
+  v.at(1, S), S.w = 1, S.applyMatrix4(t.matrixWorldInverse), S.applyMatrix4(s), S.multiplyScalar(1 / S.w), S.x *= o.x / 2, S.y *= o.y / 2, S.z = 0, $.copy(S), J.multiplyMatrices(t.matrixWorldInverse, r);
+  for (let T = 0, It = E; T < It; T++) {
+    if (_.fromBufferAttribute(c, T), f.fromBufferAttribute(p, T), _.w = 1, f.w = 1, _.applyMatrix4(J), f.applyMatrix4(J), _.z > b && f.z > b)
+      continue;
+    if (_.z > b) {
+      const C = _.z - f.z, D = (_.z - b) / C;
+      _.lerp(f, D);
+    } else if (f.z > b) {
+      const C = f.z - _.z, D = (f.z - b) / C;
+      f.lerp(_, D);
+    }
+    _.applyMatrix4(s), f.applyMatrix4(s), _.multiplyScalar(1 / _.w), f.multiplyScalar(1 / f.w), _.x *= o.x / 2, _.y *= o.y / 2, f.x *= o.x / 2, f.y *= o.y / 2, m.start.copy(_), m.start.z = 0, m.end.copy(f), m.end.z = 0;
+    const at = m.closestPointToPointParameter($, !0);
+    m.at(at, wt);
+    const ht = Et.lerp(_.z, f.z, at), Nt = ht >= -1 && ht <= 1, Yt = $.distanceTo(wt) < O * 0.5;
+    if (Nt && Yt) {
+      m.start.fromBufferAttribute(c, T), m.end.fromBufferAttribute(p, T), m.start.applyMatrix4(r), m.end.applyMatrix4(r);
+      const C = new d(), D = new d();
+      v.distanceSqToSegment(m.start, m.end, D, C), e.push({
+        point: D,
+        pointOnLine: C,
+        distance: v.origin.distanceTo(D),
+        object: n,
+        face: null,
+        faceIndex: T,
+        uv: null,
+        uv1: null
+      });
+    }
+  }
+}
+class Se extends st {
+  /**
+   * Constructs a new wide line.
+   *
+   * @param {LineSegmentsGeometry} [geometry] - The line geometry.
+   * @param {LineMaterial} [material] - The line material.
+   */
+  constructor(t = new Bt(), e = new Z({ color: Math.random() * 16777215 })) {
+    super(t, e), this.isLineSegments2 = !0, this.type = "LineSegments2";
+  }
+  /**
+   * Computes an array of distance values which are necessary for rendering dashed lines.
+   * For each vertex in the geometry, the method calculates the cumulative length from the
+   * current point to the very beginning of the line.
+   *
+   * @return {LineSegments2} A reference to this instance.
+   */
+  computeLineDistances() {
+    const t = this.geometry, e = t.attributes.instanceStart, s = t.attributes.instanceEnd, i = new Float32Array(2 * e.count);
+    for (let r = 0, a = 0, c = e.count; r < c; r++, a += 2)
+      yt.fromBufferAttribute(e, r), gt.fromBufferAttribute(s, r), i[a] = a === 0 ? 0 : i[a - 1], i[a + 1] = i[a] + yt.distanceTo(gt);
+    const o = new tt(i, 2, 1);
+    return t.setAttribute("instanceDistanceStart", new R(o, 1, 0)), t.setAttribute("instanceDistanceEnd", new R(o, 1, 1)), this;
+  }
+  /**
+   * Computes intersection points between a casted ray and this instance.
+   *
+   * @param {Raycaster} raycaster - The raycaster.
+   * @param {Array<Object>} intersects - The target array that holds the intersection points.
+   */
+  raycast(t, e) {
+    const s = this.material.worldUnits, i = t.camera;
+    i === null && !s && console.error('LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2 while worldUnits is set to false.');
+    const o = t.params.Line2 !== void 0 && t.params.Line2.threshold || 0;
+    v = t.ray;
+    const r = this.matrixWorld, a = this.geometry, c = this.material;
+    O = c.linewidth + o, a.boundingSphere === null && a.computeBoundingSphere(), I.copy(a.boundingSphere).applyMatrix4(r);
+    let p;
+    if (s)
+      p = O * 0.5;
+    else {
+      const b = Math.max(i.near, I.distanceToPoint(v.origin));
+      p = bt(i, b, c.resolution);
+    }
+    if (I.radius += p, v.intersectsSphere(I) === !1)
+      return;
+    a.boundingBox === null && a.computeBoundingBox(), W.copy(a.boundingBox).applyMatrix4(r);
+    let E;
+    if (s)
+      E = O * 0.5;
+    else {
+      const b = Math.max(i.near, W.distanceToPoint(v.origin));
+      E = bt(i, b, c.resolution);
+    }
+    W.expandByScalar(E), v.intersectsBox(W) !== !1 && (s ? be(this, e) : Ee(this, i, e));
+  }
+  onBeforeRender(t) {
+    const e = this.material.uniforms;
+    e && e.resolution && (t.getViewport(Q), this.material.uniforms.resolution.value.set(Q.z, Q.w));
+  }
+}
+class ot extends Bt {
+  /**
+   * Constructs a new line geometry.
+   */
+  constructor() {
+    super(), this.isLineGeometry = !0, this.type = "LineGeometry";
+  }
+  /**
+   * Sets the given line positions for this geometry.
+   *
+   * @param {Float32Array|Array<number>} array - The position data to set.
+   * @return {LineGeometry} A reference to this geometry.
+   */
+  setPositions(t) {
+    const e = t.length - 3, s = new Float32Array(2 * e);
+    for (let i = 0; i < e; i += 3)
+      s[2 * i] = t[i], s[2 * i + 1] = t[i + 1], s[2 * i + 2] = t[i + 2], s[2 * i + 3] = t[i + 3], s[2 * i + 4] = t[i + 4], s[2 * i + 5] = t[i + 5];
+    return super.setPositions(s), this;
+  }
+  /**
+   * Sets the given line colors for this geometry.
+   *
+   * @param {Float32Array|Array<number>} array - The position data to set.
+   * @return {LineGeometry} A reference to this geometry.
+   */
+  setColors(t) {
+    const e = t.length - 3, s = new Float32Array(2 * e);
+    for (let i = 0; i < e; i += 3)
+      s[2 * i] = t[i], s[2 * i + 1] = t[i + 1], s[2 * i + 2] = t[i + 2], s[2 * i + 3] = t[i + 3], s[2 * i + 4] = t[i + 4], s[2 * i + 5] = t[i + 5];
+    return super.setColors(s), this;
+  }
+  /**
+   * Setups this line segments geometry from the given sequence of points.
+   *
+   * @param {Array<Vector3|Vector2>} points - An array of points in 2D or 3D space.
+   * @return {LineGeometry} A reference to this geometry.
+   */
+  setFromPoints(t) {
+    const e = t.length - 1, s = new Float32Array(6 * e);
+    for (let i = 0; i < e; i++)
+      s[6 * i] = t[i].x, s[6 * i + 1] = t[i].y, s[6 * i + 2] = t[i].z || 0, s[6 * i + 3] = t[i + 1].x, s[6 * i + 4] = t[i + 1].y, s[6 * i + 5] = t[i + 1].z || 0;
+    return super.setPositions(s), this;
+  }
+  /**
+   * Setups this line segments geometry from the given line.
+   *
+   * @param {Line} line - The line that should be used as a data source for this geometry.
+   * @return {LineGeometry} A reference to this geometry.
+   */
+  fromLine(t) {
+    const e = t.geometry;
+    return this.setPositions(e.attributes.position.array), this;
+  }
+}
+class Kt extends Se {
+  /**
+   * Constructs a new wide line.
+   *
+   * @param {LineGeometry} [geometry] - The line geometry.
+   * @param {LineMaterial} [material] - The line material.
+   */
+  constructor(t = new ot(), e = new Z({ color: Math.random() * 16777215 })) {
+    super(t, e), this.isLine2 = !0, this.type = "Line2";
+  }
+}
+class F {
+  static mathMatrix4toThreeMatrix4(t) {
+    const [e, s, i, o] = t.data;
+    return new vt().set(
+      e[0],
+      s[0],
+      i[0],
+      o[0],
+      e[1],
+      s[1],
+      i[1],
+      o[1],
+      e[2],
+      s[2],
+      i[2],
+      o[2],
+      e[3],
+      s[3],
+      i[3],
+      o[3]
+    );
+  }
+}
+class Me {
+  constructor() {
+    this._objectGNodeMap = /* @__PURE__ */ new WeakMap();
+  }
+  /**
+   * 添加GRep
+   */
+  addGrep(t) {
+    const e = t.toRenderNode(), s = this._flatLeafRNodes(e), i = new H();
+    for (const o of s) {
+      const r = this._buildLeafObject3d(o);
+      r && (i.add(r), this._objectGNodeMap.set(r, o.gnode));
+    }
+    return i;
+  }
+  /**
+   * 移除GRep
+   */
+  removeGRep(t) {
+  }
+  /**
+   * 根据渲染对象查GNode
+   */
+  getGNodesByObject3d(t) {
+    let e = t;
+    for (; e; ) {
+      const s = this._objectGNodeMap.get(e);
+      if (s) return s;
+      e = e.parent;
+    }
+  }
+  /**
+   * 叶子节点拍平
+   */
+  _flatLeafRNodes(t) {
+    const e = [];
+    return t instanceof te ? (t.children.forEach((s) => {
+      e.push(...this._flatLeafRNodes(s));
+    }), e) : (e.push(t), e);
+  }
+  /**
+   * 根据叶子 RenderNode 构建对应的 three Object3D
+   */
+  // TODO 拆成两步, 单独创建几何和材质
+  _buildLeafObject3d(t) {
+    if (t instanceof Lt) {
+      const e = new X(t.point);
+      t.globalMatrix && e.transform(t.globalMatrix);
+      const s = new G();
+      s.setAttribute("position", new x([e.x, e.y, e.z], 3));
+      const i = t.style.point, o = new xt({
+        color: i?.color ?? 16777215,
+        size: i?.size ?? 8,
+        sizeAttenuation: !1,
+        opacity: i?.opacity ?? 1
+      });
+      return o.opacity < 1 && (o.transparent = !0), new Tt(s, o);
+    }
+    if (t instanceof Ot) {
+      const e = [];
+      for (const r of t.points) {
+        const a = r.clone();
+        t.globalMatrix && a.transform(t.globalMatrix), e.push(a.x, a.y, a.z);
+      }
+      const s = new ot();
+      s.setPositions(e);
+      const i = t.style.line, o = new Z({
+        color: i?.color ?? 16777215,
+        linewidth: i?.width ?? 2,
+        opacity: i?.opacity ?? 1
+      });
+      return o.opacity < 1 && (o.transparent = !0), new Kt(s, o);
+    }
+    if (t instanceof Ct) {
+      const e = new G(), s = t.getVerts(), i = t.getIndices(), o = t.getNormals();
+      e.setAttribute("position", new x(s, 3)), e.setAttribute("normal", new x(o, 3)), e.setIndex(new Dt(i, 1));
+      const r = t.globalMatrix;
+      r && e.applyMatrix4(F.mathMatrix4toThreeMatrix4(r));
+      const a = t.style.face, c = new Pt({
+        color: a?.color ?? 16777215,
+        opacity: a?.opacity ?? 1
+      });
+      return c.opacity < 1 && (c.transparent = !0), new st(e, c);
+    }
+    if (t instanceof Ut) {
+      const e = new jt();
+      e.position.set(t.position.x, t.position.y, t.position.z), e.text = t.text;
+      const s = t.style.text;
+      return e.fontSize = s?.fontSize ?? 16, e.color = s?.color ?? 16777215, e.anchorX = s?.anchorX ?? At.Center, e.anchorY = s?.anchorY ?? Rt.Middle, t.globalMatrix && e.applyMatrix4(F.mathMatrix4toThreeMatrix4(t.globalMatrix)), e.sync(), e;
+    }
+    return null;
+  }
+}
+class ve {
+  constructor(t) {
+    this._activeGroup = new H(), this._selectionGroup = new H(), t.add(this._activeGroup), t.add(this._selectionGroup);
+  }
+  clearActive() {
+    this._clearGroup(this._activeGroup);
+  }
+  clearSelection() {
+    this._clearGroup(this._selectionGroup);
+  }
+  drawActives(t) {
+    this.clearActive(), t.forEach((e) => {
+      const s = this._buildOverlayGroup(e);
+      s.children.length && this._activeGroup.add(s);
+    });
+  }
+  drawSelections(t) {
+    this.clearSelection(), t.forEach((e) => {
+      const s = this._buildOverlayGroup(e);
+      s.children.length && this._selectionGroup.add(s);
+    });
+  }
+  /**
+   * GRep转为可渲染Group
+   */
+  _buildOverlayGroup(t) {
+    const e = new H(), s = t.toRenderNode();
+    return ee.flatLeafRNodes(s).forEach((o) => {
+      const r = this._buildLeafObject(o);
+      r && e.add(r);
+    }), e;
+  }
+  /**
+   * 根据RenderNode构建渲染对象
+   */
+  _buildLeafObject(t) {
+    if (t instanceof Lt) {
+      const e = new X(t.point);
+      t.globalMatrix && e.transform(t.globalMatrix);
+      const s = new G();
+      s.setAttribute("position", new x([e.x, e.y, e.z], 3));
+      const i = t.style.point, o = new xt({
+        color: i?.color ?? 16777215,
+        size: i?.size ?? 8,
+        sizeAttenuation: !1,
+        opacity: i?.opacity ?? 1
+      });
+      return o.opacity < 1 && (o.transparent = !0), new Tt(s, o);
+    }
+    if (t instanceof Ot) {
+      const e = [];
+      for (const r of t.points) {
+        const a = r.clone();
+        t.globalMatrix && a.transform(t.globalMatrix), e.push(a.x, a.y, a.z);
+      }
+      const s = new ot();
+      s.setPositions(e);
+      const i = t.style.line, o = new Z({
+        color: i?.color ?? 16777215,
+        linewidth: i?.width ?? 2,
+        opacity: i?.opacity ?? 1
+      });
+      return o.opacity < 1 && (o.transparent = !0), new Kt(s, o);
+    }
+    if (t instanceof Ct) {
+      const e = new G();
+      e.setAttribute("position", new x(t.getVerts(), 3)), e.setAttribute("normal", new x(t.getNormals(), 3)), e.setIndex(new Dt(t.getIndices(), 1)), t.globalMatrix && e.applyMatrix4(F.mathMatrix4toThreeMatrix4(t.globalMatrix));
+      const s = t.style.face, i = new Pt({
+        color: s?.color ?? 16777215,
+        opacity: s?.opacity ?? 1
+      });
+      return i.opacity < 1 && (i.transparent = !0), new st(e, i);
+    }
+    if (t instanceof Ut) {
+      const e = new jt();
+      e.position.set(t.position.x, t.position.y, t.position.z), e.text = t.text;
+      const s = t.style.text;
+      return e.fontSize = s?.fontSize ?? 16, e.color = s?.color ?? 16777215, e.anchorX = s?.anchorX ?? At.Center, e.anchorY = s?.anchorY ?? Rt.Middle, t.globalMatrix && e.applyMatrix4(F.mathMatrix4toThreeMatrix4(t.globalMatrix)), e.sync(), e;
+    }
+    return null;
+  }
+  /**
+   * 清空渲染组
+   */
+  _clearGroup(t) {
+    for (; t.children.length; )
+      t.children.pop()?.removeFromParent();
+  }
+}
+const V = class V extends ie {
+  constructor(t) {
+    super(), this._didToObject = /* @__PURE__ */ new Map(), this.render = () => {
+      requestAnimationFrame(this.render);
+      const { update: o, remove: r } = pt.instance().onBeforeRender();
+      r.forEach((a) => {
+        this._removeGrepByDisplayId(a);
+      }), o.forEach((a) => {
+        this._updateDisplayByRenderData(a);
+      }), this._cameraControls.update(), this._renderer.clear(), this._renderer.render(this._scene, this._camera), this._renderer.clearDepth(), this._renderer.render(this._activeScene, this._camera);
+    }, this._container = t, this._width = this._container.clientWidth, this._height = this._container.clientHeight, this._renderer = new Qt({
+      antialias: !0
+    }), this._renderer.autoClear = !1, this._renderer.setPixelRatio(window.devicePixelRatio), this._renderer.setClearColor(U.common.color_background), this._renderer.outputColorSpace = $t, this._renderer.setSize(this._width, this._height), this._container.appendChild(this._renderer.domElement), this._resizeObserver = new ResizeObserver(() => {
+      this._onResize();
+    }), this._resizeObserver.observe(this._container), this._scene = new dt(), this._activeScene = new dt();
+    const e = this._width / this._height, s = 500, i = s * e;
+    this._camera = new Jt(-i / 2, i / 2, s / 2, -s / 2, 0.1, 100), this._camera.position.set(0, 0, 20), this._cameraControls = new ae(this._camera, this._renderer.domElement), this._cameraControls.enableRotate = !1, this._cameraControls.enablePan = !0, this._renderHub = new Me(), this._activeSelectionOp = new ve(this._activeScene), this.render();
+  }
+  /**
+   * 修改完场景后,调update才会真正刷新
+   */
+  updateView() {
+  }
+  updateImmediately() {
+  }
+  /**
+   * 根据渲染数据更新显示对象
+   */
+  _updateDisplayByRenderData(t) {
+    const { id: e, gRep: s } = t, i = pt.instance().getDisplay(e);
+    i && s && (this._didToObject.get(i.id) ? (this._removeGrepByDisplayId(e), this._addGrepByDisplay(i, s)) : this._addGrepByDisplay(i, s));
+  }
+  /**
+   * 根据显示对象添加GRep
+   */
+  _addGrepByDisplay(t, e) {
+    const s = t.id, i = this._renderHub.addGrep(e);
+    this._scene.add(i), this._didToObject.set(s, i), i.visible = t.testVisible();
+  }
+  /**
+   * 根据显示对象移除GRep
+   */
+  _removeGrepByDisplayId(t) {
+    const e = this._didToObject.get(t);
+    if (!e) return !1;
+    this._didToObject.delete(t), e.removeFromParent();
+  }
+  /**
+   * NDC转屏幕坐标
+   */
+  NDCToScreen(t, e) {
+    const s = new j();
+    return s.x = this._width * (t + 1) / 2, s.y = this._height * (1 - e) / 2, s;
+  }
+  /**
+   * 屏幕坐标转NDC
+   */
+  screenToNDC(t) {
+    const e = new j();
+    return e.x = t.x / this._width * 2 - 1, e.y = -(t.y / this._height) * 2 + 1, e;
+  }
+  /**
+   * NDC坐标转世界坐标
+   */
+  NDCToWorld(t, e) {
+    const i = new d(t, e, 0).unproject(this._camera);
+    return new X(i);
+  }
+  /**
+   * 世界坐标转NDC坐标
+   */
+  worldToNDC(t) {
+    const e = new d(t.x, t.y, 0).project(this._camera);
+    return new j(e.x, e.y);
+  }
+  /**
+   * 生成相机射线
+   */
+  generateCameraRay(t) {
+    const e = new ut(), s = this.screenToNDC(t), i = new w(s.x, s.y);
+    e.setFromCamera(i, this._camera);
+    const { ray: o } = e, r = new se(o.origin, o.direction, [0, 1]);
+    return r.extend(zt.MODEL_MAX_LENGTH * 100, !0), r;
+  }
+  /**
+   * 根据屏幕坐标拾取
+   */
+  pick(t, e) {
+    const s = new ut(), i = this.screenToNDC(new j(t, e));
+    s.setFromCamera(new w(i.x, i.y), this._camera), s.params.Line2 = { threshold: V.PICK_TOLERANCE };
+    const o = s.intersectObjects(this._scene.children, !0), r = [], a = /* @__PURE__ */ new Set();
+    for (const c of o) {
+      const p = this._renderHub.getGNodesByObject3d(c.object);
+      p && (a.has(p.globalID) || (a.add(p.globalID), r.push(p)));
+    }
+    return r;
+  }
+  clearActive() {
+    this._activeSelectionOp.clearActive();
+  }
+  clearSelection() {
+    this._activeSelectionOp.clearSelection();
+  }
+  drawSelections(t) {
+    this._activeSelectionOp.drawSelections(t);
+  }
+  drawActives(t) {
+    this._activeSelectionOp.drawActives(t);
+  }
+  /**
+   * 监听画布大小变化
+   */
+  // TODO 需要重构
+  _onResize() {
+    this._width = this._container.clientWidth, this._height = this._container.clientHeight, this._renderer.setSize(this._width, this._height);
+    const t = this._width / this._height, e = 1e3, s = e * t;
+    this._camera.left = -s / 2, this._camera.right = s / 2, this._camera.top = e / 2, this._camera.bottom = -e / 2, this._camera.updateProjectionMatrix();
+  }
+  // TODO 补充完整
+  destroy() {
+    this._resizeObserver.disconnect(), this._renderer.dispose(), this._renderer.domElement.remove();
+  }
+};
+V.PICK_TOLERANCE = 16;
+let et = V;
+class Wt {
+  constructor(t) {
+    this._ctrlKey = t.ctrlKey, this._altKey = t.altKey, this._shiftKey = t.shiftKey, this._metaKey = t.metaKey;
+  }
+  get ctrlKey() {
+    return this._ctrlKey;
+  }
+  get altKey() {
+    return this._altKey;
+  }
+  get shiftKey() {
+    return this._shiftKey;
+  }
+  get metaKey() {
+    return this._metaKey;
+  }
+}
+class xe {
+  constructor(t, e, s) {
+    this._mouseControllers = [], this._mouseDown = !1, this._wheeling = !1, this._onMouseDown = (i) => {
+      const o = this._getScreenPos(i);
+      this._mouseDown = !0;
+      let r = !1;
+      i.button === 0 ? (this._lMouseDownPos = o.clone(), r = this._processMouseEvent(h.L_BUTTON_DOWN, i)) : i.button === 1 ? (this._mMouseDownPos = o.clone(), r = this._processMouseEvent(h.M_BUTTON_DOWN, i)) : i.button === 2 && (this._rMouseDownPos = o.clone(), r = this._processMouseEvent(h.R_BUTTON_DOWN, i)), r && i.stopPropagation();
+    }, this._onMouseMove = (i) => {
+      let o = !1;
+      o = this._processMouseEvent(h.MOUSE_MOVE, i), o && i.stopPropagation();
+    }, this._onMouseUp = (i) => {
+      const o = this._getScreenPos(i);
+      this._mouseDown = !1;
+      let r = !1;
+      i.button === 0 ? (this._lMouseDownPos && this._lMouseDownPos.sqDistanceTo(o) < U.common.click_to_tolerance && this._processMouseEvent(h.CLICK, i), this._dblClickTimeout ? (window.clearTimeout(this._dblClickTimeout), this._lastLMouseUpPos && this._lastLMouseUpPos.sqDistanceTo(o) < U.common.click_to_tolerance ? (delete this._dblClickTimeout, this._processMouseEvent(h.DBL_CLICK, i)) : this._dblClickTimeout = window.setTimeout(() => {
+        delete this._dblClickTimeout, this._processMouseEvent(h.SGL_CLICK, i);
+      }, U.common.dbl_click_interval)) : this._dblClickTimeout = window.setTimeout(() => {
+        delete this._dblClickTimeout, this._processMouseEvent(h.SGL_CLICK, i);
+      }, U.common.dbl_click_interval), this._lastLMouseUpPos = o.clone(), r = this._processMouseEvent(h.L_BUTTON_UP, i), delete this._lMouseDownPos) : i.button === 1 ? (delete this._mMouseDownPos, r = this._processMouseEvent(h.M_BUTTON_UP, i)) : i.button === 2 && (r = this._processMouseEvent(h.R_BUTTON_UP, i), !r && this._rMouseDownPos && this._rMouseDownPos.sqDistanceTo(o) < U.common.click_to_tolerance && (r = this._processMouseEvent(h.R_CLICK, i), delete this._rMouseDownPos)), r && i.stopPropagation();
+    }, this._onMouseWheel = (i) => {
+      const o = () => {
+        this._wheeling === !0 && (this._wheeling = !1, delete this._wheelTimer, this._processMouseEvent(h.WHEEL_END, i));
+      };
+      this._wheelTimer !== void 0 && window.clearTimeout(this._wheelTimer), this._wheeling || (this._wheeling = !0, this._processMouseEvent(h.WHEEL_START, i)), this._wheelTimer = window.setTimeout(o, 500), this._processMouseEvent(
+        i.deltaY < 0 ? h.WHEEL_FORWARD : h.WHEEL_BACKWARD,
+        i
+      ) && i.stopPropagation();
+    }, this._onContextMenu = (i) => {
+      i.preventDefault();
+    }, this._onMouseLeave = (i) => {
+      this._processMouseEvent(h.MOUSE_LEAVE, i), delete this._lMouseDownPos;
+    }, this._onMouseEnter = (i) => {
+      this._processMouseEvent(h.MOUSE_ENTER, i);
+    }, this._canvas = t, this._container = e, this._mouseControllers = s;
+  }
+  startListening() {
+    this._container.addEventListener(y.MOUSE_DOWN, this._onMouseDown), this._container.addEventListener(y.MOUSE_MOVE, this._onMouseMove), this._container.addEventListener(y.MOUSE_UP, this._onMouseUp), this._container.addEventListener(y.WHEEL, this._onMouseWheel), this._container.addEventListener(y.CONTEXT_MENU, this._onContextMenu), this._container.addEventListener(y.MOUSE_LEAVE, this._onMouseLeave), this._container.addEventListener(y.MOUSE_ENTER, this._onMouseEnter);
+  }
+  stopListening() {
+    this._container.removeEventListener(y.MOUSE_DOWN, this._onMouseDown), this._container.removeEventListener(y.MOUSE_MOVE, this._onMouseMove), this._container.removeEventListener(y.MOUSE_UP, this._onMouseUp), this._container.removeEventListener(y.WHEEL, this._onMouseWheel), this._container.removeEventListener(y.CONTEXT_MENU, this._onContextMenu), this._container.removeEventListener(y.MOUSE_LEAVE, this._onMouseLeave), this._container.removeEventListener(y.MOUSE_ENTER, this._onMouseEnter);
+  }
+  _processMouseEvent(t, e) {
+    let s = !1;
+    const i = new Wt(e);
+    for (let o = 0; o < this._mouseControllers.length && (s = this._mouseControllers[o].processMouseEvent({
+      type: t,
+      domEvent: e,
+      pos: this._getScreenPos(e),
+      fnKey: i
+    }), !s); o++)
+      ;
+    return s;
+  }
+  /**
+   * 获取相对于canvas的屏幕坐标
+   */
+  _getScreenPos(t) {
+    const e = this._container.getBoundingClientRect(), s = t.clientX - e.left, i = t.clientY - e.top;
+    return new j(s, i);
+  }
+}
+class rt {
+  constructor(t) {
+    const e = t || ne.XOY();
+    this._plane = e;
+  }
+  get plane() {
+    return this._plane;
+  }
+  set plane(t) {
+    this._plane = t;
+  }
+  clone() {
+    const t = new rt();
+    return t.plane = this._plane.clone(), t;
+  }
+}
+class Te {
+  constructor(t) {
+    this._mouseControllers = [], this._onKeyDown = (e) => {
+      this._processKeyboardEvent(L.KEY_DOWN, e);
+    }, this._onKeyUp = (e) => {
+      this._processKeyboardEvent(L.KEY_UP, e);
+    }, this._onKeyPress = (e) => {
+      this._processKeyboardEvent(L.KEY_PRESS, e);
+    }, this._mouseControllers = t;
+  }
+  startListening() {
+    window.addEventListener(P.KEY_DOWN, this._onKeyDown), window.addEventListener(P.KEY_UP, this._onKeyUp), window.addEventListener(P.KEY_DOWN, this._onKeyPress);
+  }
+  stopListening() {
+    window.removeEventListener(P.KEY_DOWN, this._onKeyDown), window.removeEventListener(P.KEY_UP, this._onKeyUp), window.removeEventListener(P.KEY_DOWN, this._onKeyPress);
+  }
+  _processKeyboardEvent(t, e) {
+    let s = !1;
+    const i = new Wt(e);
+    for (let o = 0; o < this._mouseControllers.length && (s = this._mouseControllers[o].processKeyboardEvent({
+      type: t,
+      domEvent: e,
+      fnKey: i
+    }), !s); o++)
+      ;
+    return s;
+  }
+}
+class Ue {
+  constructor(t, e) {
+    this._container = t, this._mouseInteractor = new xe(this, this._container, e), this._keyboardInteractor = new Te(e), this._renderer = new et(this._container);
+  }
+  get container() {
+    return this._container;
+  }
+  /**
+   * 开启事件监听
+   */
+  startListening() {
+    this._mouseInteractor.startListening(), this._keyboardInteractor.startListening();
+  }
+  /**
+   * 停止监听
+   */
+  stopListening() {
+    this._mouseInteractor.stopListening(), this._keyboardInteractor.stopListening();
+  }
+  /**
+   * 给模型层视图绑定渲染器实例
+   */
+  resetModelView(t) {
+    t.iRender = this._renderer;
+  }
+  /**
+   * 获取当前工作平面
+   */
+  getWorkPlane() {
+    return new rt();
+  }
+  /**
+   * NDC转屏幕坐标
+   */
+  NDCToScreen(t, e) {
+    return this._renderer.NDCToScreen(t, e);
+  }
+  /**
+   * 屏幕坐标转NDC
+   */
+  screenToNDC(t) {
+    return this._renderer.screenToNDC(t);
+  }
+  /**
+   * 屏幕坐标投影到世界坐标系中的指定平面上
+   * @param screenPos 屏幕坐标
+   * @param plane 世界坐标系下的平面
+   */
+  screenToWorldPlane(t, e) {
+    const s = this._renderer.generateCameraRay(t);
+    s.extendDouble(zt.MODEL_MAX_LENGTH);
+    const i = oe.X.curveSurface(s, e);
+    return i.length ? i[0] : X.O();
+  }
+  /**
+   * 屏幕坐标转当前工作平面下的世界坐标
+   */
+  screenToWorkPlane(t) {
+    const { plane: e } = this.getWorkPlane();
+    return this.screenToWorldPlane(t, e);
+  }
+  /**
+   * 世界坐标转屏幕坐标
+   */
+  worldToScreen(t) {
+    const e = this._renderer.worldToNDC(t);
+    return this.NDCToScreen(e.x, e.y);
+  }
+  /**
+   * 屏幕坐标转换为指定平面下的二维局部坐标
+   * @param screenPos 屏幕坐标
+   * @param plane 目标平面
+   */
+  screenToPlaneLocal(t, e) {
+    const s = this.screenToWorldPlane(t, e);
+    return e.getUVAt(s);
+  }
+  /**
+   * 屏幕坐标转换为当前工作平面下的二维局部坐标
+   * @param screenPos 屏幕坐标
+   */
+  screenToWorkPlaneLocal(t) {
+    const { plane: e } = this.getWorkPlane();
+    return this.screenToPlaneLocal(t, e);
+  }
+  /**
+   * 获取当前工作平面下，1世界单位对应多少像素
+   */
+  pixelsPerUnit() {
+    const { plane: t } = this.getWorkPlane(), e = t.getPtAt({ x: 0, y: 0 }), s = t.getPtAt({ x: 1, y: 0 }), i = this.worldToScreen(e), o = this.worldToScreen(s);
+    return i.distanceTo(o);
+  }
+  /**
+   * 生成相机射线
+   */
+  generateCameraRay(t) {
+    return this._renderer.generateCameraRay(t);
+  }
+  pick(t, e) {
+    return this._renderer.pick(t, e);
+  }
+  // TODO 补充完整
+  destroy() {
+    this.stopListening();
+  }
+}
+class Ae {
+  processKeyboardEvent(t) {
+    switch (t.type) {
+      case L.KEY_DOWN:
+        return this.onKeyDown(t);
+      case L.KEY_UP:
+        return this.onKeyUp(t);
+      case L.KEY_PRESS:
+        return this.onKeyPress(t);
+      default:
+        return !1;
+    }
+  }
+  processMouseEvent(t) {
+    switch (t.type) {
+      case h.MOUSE_ENTER:
+        return this.onMouseEnter(t);
+      case h.MOUSE_MOVE:
+        return this.onMouseMove(t);
+      case h.MOUSE_LEAVE:
+        return this.onMouseLeave(t);
+      case h.L_BUTTON_DOWN:
+        return this.onLButtonDown(t);
+      case h.L_BUTTON_UP:
+        return this.onLButtonUp(t);
+      case h.R_BUTTON_DOWN:
+        return this.onRButtonDown(t);
+      case h.R_BUTTON_UP:
+        return this.onRButtonUp(t);
+      case h.M_BUTTON_DOWN:
+        return this.onMButtonDown(t);
+      case h.M_BUTTON_UP:
+        return this.onMButtonUp(t);
+      case h.WHEEL_FORWARD:
+        return this.onWheelForward(t);
+      case h.WHEEL_BACKWARD:
+        return this.onWheelBackward(t);
+      case h.CLICK:
+        return this.onClick(t);
+      case h.SGL_CLICK:
+        return this.onSglClick(t);
+      case h.DBL_CLICK:
+        return this.onDblClick(t);
+      case h.R_CLICK:
+        return this.onRClick(t);
+      default:
+        return !1;
+    }
+  }
+  onMouseEnter(t) {
+    return !1;
+  }
+  onMouseMove(t) {
+    return !1;
+  }
+  onLButtonDown(t) {
+    return !1;
+  }
+  onLButtonUp(t) {
+    return !1;
+  }
+  onRClick(t) {
+    return !1;
+  }
+  onRButtonDown(t) {
+    return !1;
+  }
+  onRButtonUp(t) {
+    return !1;
+  }
+  onMButtonDown(t) {
+    return !1;
+  }
+  onMButtonUp(t) {
+    return !1;
+  }
+  onWheelForward(t) {
+    return !1;
+  }
+  onWheelBackward(t) {
+    return !1;
+  }
+  onClick(t) {
+    return !1;
+  }
+  onSglClick(t) {
+    return !1;
+  }
+  onDblClick(t) {
+    return !1;
+  }
+  onMouseLeave(t) {
+    return !1;
+  }
+  onKeyDown(t) {
+    return !1;
+  }
+  onKeyUp(t) {
+    return !1;
+  }
+  onKeyPress(t) {
+    return !1;
+  }
+}
+export {
+  Ue as CCanvas,
+  Ae as DefaultController,
+  L as EN_KeyboardEvent,
+  h as EN_MouseEvent,
+  P as EN_NativeKeyboardEvent,
+  y as EN_NativeMouseEvent,
+  Wt as FnKey,
+  Te as KeyboardInteractor,
+  xe as MouseInteractor,
+  U as canvasConfig
+};