minerender 2.1.0-alpha.1 → 2.1.0-alpha.3

package/dist/bundle.js

@@ -82665,24 +82665,54 @@ return ${compiler2.callType("value", tagType)}
       this.stats = new SceneStats();
       this.instanceManager = new InstanceManager();
       this.dirty = true;
+      this.observedObjects = /* @__PURE__ */ new Set();
+      this.onObjectChange = (event) => {
+        if (event.target?.parent === this) {
+          this.dirty = true;
+        }
+      };
       this.options = (0, import_ts_deepmerge9.default)({}, _MineRenderScene.DEFAULT_OPTIONS, options ?? {});
     }
-    add(...object) {
-      this.dirty = true;
-      this.stats.objectCount += object.length;
-      for (let obj of object) {
-        if (isSceneObject(obj)) {
-          this.stats.sceneObjectCount++;
+    add(...objects) {
+      for (const object of objects) {
+        this.dirty = true;
+        try {
+          super.add(object);
+        } finally {
+          if (object?.isObject3D && object !== this) {
+            this.updateObjectRegistration(object, object.parent === this);
+          }
         }
-        obj.addEventListener("change", (event) => {
-          this.dirty = true;
-        });
       }
-      return super.add(...object);
+      return this;
     }
-    remove(...object) {
-      this.dirty = true;
-      return super.remove(...object);
+    remove(...objects) {
+      for (const object of objects) {
+        if (!this.children.includes(object)) continue;
+        this.dirty = true;
+        this.updateObjectRegistration(object, false);
+        try {
+          super.remove(object);
+        } finally {
+          this.updateObjectRegistration(object, object.parent === this);
+        }
+      }
+      return this;
+    }
+    updateObjectRegistration(object, attached) {
+      if (this.observedObjects.has(object) === attached) return;
+      if (attached) {
+        this.observedObjects.add(object);
+        object.addEventListener("change", this.onObjectChange);
+      } else {
+        this.observedObjects.delete(object);
+        object.removeEventListener("change", this.onObjectChange);
+      }
+      const change = attached ? 1 : -1;
+      this.stats.objectCount += change;
+      if (isSceneObject(object)) {
+        this.stats.sceneObjectCount += change;
+      }
     }
     async initAndAdd(...object) {
       this.dirty = true;
@@ -84513,1068 +84543,1162 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
     return lerp2(a4, b4, 1 - 0.125);
   }
 
-  // src/renderer/Renderer.ts
-  var _Renderer = class _Renderer {
-    constructor(options) {
-      this._dirty = true;
-      this._animationTimer = void 0;
-      this._animationFrame = void 0;
-      this._resizeListener = void 0;
-      this.options = (0, import_ts_deepmerge10.default)({}, _Renderer.DEFAULT_OPTIONS, options ?? {});
-      this._animationLoop = this.animate.bind(this);
-      this._fpsTimer = this.options.render.fpsLimit > 0 ? 1e3 / this.options.render.fpsLimit : void 0;
-      this._scene = this.createScene();
-      this._camera = this.createCamera();
-      this._renderer = this.createRenderer();
-      this._composer = this.createComposer();
-      if (this.options.render.stats) {
-        this._stats = new import_stats.default();
-        document.body.appendChild(this._stats.dom);
+  // src/three/OrbitControls.js
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  var _changeEvent = { type: "change" };
+  var _startEvent = { type: "start" };
+  var _endEvent = { type: "end" };
+  var OrbitControls = class extends EventDispatcher {
+    constructor(object, domElement) {
+      super();
+      if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
+      if (domElement === document) console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.');
+      this.object = object;
+      this.domElement = domElement;
+      this.domElement.style.touchAction = "none";
+      this.enabled = true;
+      this.target = new Vector3();
+      this.minDistance = 0;
+      this.maxDistance = Infinity;
+      this.minZoom = 0;
+      this.maxZoom = Infinity;
+      this.minPolarAngle = 0;
+      this.maxPolarAngle = Math.PI;
+      this.minAzimuthAngle = -Infinity;
+      this.maxAzimuthAngle = Infinity;
+      this.enableDamping = false;
+      this.dampingFactor = 0.05;
+      this.enableZoom = true;
+      this.zoomSpeed = 1;
+      this.enableRotate = true;
+      this.rotateSpeed = 1;
+      this.enablePan = true;
+      this.panSpeed = 1;
+      this.screenSpacePanning = true;
+      this.keyPanSpeed = 7;
+      this.autoRotate = false;
+      this.autoRotateSpeed = 2;
+      this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
+      this.mouseButtons = { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.PAN };
+      this.touches = { ONE: TOUCH.ROTATE, TWO: TOUCH.DOLLY_PAN };
+      this.target0 = this.target.clone();
+      this.position0 = this.object.position.clone();
+      this.zoom0 = this.object.zoom;
+      this._domElementKeyEvents = null;
+      this.getPolarAngle = function() {
+        return spherical.phi;
+      };
+      this.getAzimuthalAngle = function() {
+        return spherical.theta;
+      };
+      this.getDistance = function() {
+        return this.object.position.distanceTo(this.target);
+      };
+      this.saveState = function() {
+        scope.target0.copy(scope.target);
+        scope.position0.copy(scope.object.position);
+        scope.zoom0 = scope.object.zoom;
+      };
+      this.reset = function() {
+        scope.target.copy(scope.target0);
+        scope.object.position.copy(scope.position0);
+        scope.object.zoom = scope.zoom0;
+        scope.object.updateProjectionMatrix();
+        scope.dispatchEvent(_changeEvent);
+        scope.update();
+        state = STATE.NONE;
+      };
+      this.update = function() {
+        const offset = new Vector3();
+        const quat = new Quaternion().setFromUnitVectors(object.up, new Vector3(0, 1, 0));
+        const quatInverse = quat.clone().invert();
+        const lastPosition = new Vector3();
+        const lastQuaternion = new Quaternion();
+        const twoPI = 2 * Math.PI;
+        return function update() {
+          const position = scope.object.position;
+          offset.copy(position).sub(scope.target);
+          offset.applyQuaternion(quat);
+          spherical.setFromVector3(offset);
+          if (scope.autoRotate && state === STATE.NONE) {
+            rotateLeft(getAutoRotationAngle());
+          }
+          if (scope.enableDamping) {
+            spherical.theta += sphericalDelta.theta * scope.dampingFactor;
+            spherical.phi += sphericalDelta.phi * scope.dampingFactor;
+          } else {
+            spherical.theta += sphericalDelta.theta;
+            spherical.phi += sphericalDelta.phi;
+          }
+          let min = scope.minAzimuthAngle;
+          let max = scope.maxAzimuthAngle;
+          if (isFinite(min) && isFinite(max)) {
+            if (min < -Math.PI) min += twoPI;
+            else if (min > Math.PI) min -= twoPI;
+            if (max < -Math.PI) max += twoPI;
+            else if (max > Math.PI) max -= twoPI;
+            if (min <= max) {
+              spherical.theta = Math.max(min, Math.min(max, spherical.theta));
+            } else {
+              spherical.theta = spherical.theta > (min + max) / 2 ? Math.max(min, spherical.theta) : Math.min(max, spherical.theta);
+            }
+          }
+          spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi));
+          spherical.makeSafe();
+          spherical.radius *= scale;
+          spherical.radius = Math.max(scope.minDistance, Math.min(scope.maxDistance, spherical.radius));
+          if (scope.enableDamping === true) {
+            scope.target.addScaledVector(panOffset, scope.dampingFactor);
+          } else {
+            scope.target.add(panOffset);
+          }
+          offset.setFromSpherical(spherical);
+          offset.applyQuaternion(quatInverse);
+          position.copy(scope.target).add(offset);
+          scope.object.lookAt(scope.target);
+          if (scope.enableDamping === true) {
+            sphericalDelta.theta *= 1 - scope.dampingFactor;
+            sphericalDelta.phi *= 1 - scope.dampingFactor;
+            panOffset.multiplyScalar(1 - scope.dampingFactor);
+          } else {
+            sphericalDelta.set(0, 0, 0);
+            panOffset.set(0, 0, 0);
+          }
+          scale = 1;
+          if (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) {
+            scope.dispatchEvent(_changeEvent);
+            lastPosition.copy(scope.object.position);
+            lastQuaternion.copy(scope.object.quaternion);
+            zoomChanged = false;
+            return true;
+          }
+          return false;
+        };
+      }();
+      this.dispose = function() {
+        scope.domElement.removeEventListener("contextmenu", onContextMenu);
+        scope.domElement.removeEventListener("pointerdown", onPointerDown);
+        scope.domElement.removeEventListener("pointercancel", onPointerCancel);
+        scope.domElement.removeEventListener("wheel", onMouseWheel);
+        scope.domElement.removeEventListener("pointermove", onPointerMove);
+        scope.domElement.removeEventListener("pointerup", onPointerUp);
+        if (scope._domElementKeyEvents !== null) {
+          scope._domElementKeyEvents.removeEventListener("keydown", onKeyDown);
+        }
+      };
+      const scope = this;
+      const STATE = {
+        NONE: -1,
+        ROTATE: 0,
+        DOLLY: 1,
+        PAN: 2,
+        TOUCH_ROTATE: 3,
+        TOUCH_PAN: 4,
+        TOUCH_DOLLY_PAN: 5,
+        TOUCH_DOLLY_ROTATE: 6
+      };
+      let state = STATE.NONE;
+      const EPS = 1e-6;
+      const spherical = new Spherical();
+      const sphericalDelta = new Spherical();
+      let scale = 1;
+      const panOffset = new Vector3();
+      let zoomChanged = false;
+      const rotateStart = new Vector2();
+      const rotateEnd = new Vector2();
+      const rotateDelta = new Vector2();
+      const panStart = new Vector2();
+      const panEnd = new Vector2();
+      const panDelta = new Vector2();
+      const dollyStart = new Vector2();
+      const dollyEnd = new Vector2();
+      const dollyDelta = new Vector2();
+      const pointers = [];
+      const pointerPositions = {};
+      function getAutoRotationAngle() {
+        return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
       }
-      this.init();
-    }
-    //<editor-fold desc="INIT">
-    createScene() {
-      return new MineRenderScene();
-    }
-    createCamera() {
-      switch (this.options.camera.type) {
-        case "perspective":
-        default:
-          return new PerspectiveCamera(
-            this.options.camera.perspective.fov,
-            this.options.camera.perspective.aspect ?? this.viewWidth / this.viewHeight,
-            this.options.camera.near,
-            this.options.camera.far
-          );
-        case "orthographic":
-          return new OrthographicCamera(
-            this.options.camera.orthographic.left ?? this.viewWidth / -2,
-            this.options.camera.orthographic.right ?? this.viewWidth / 2,
-            this.options.camera.orthographic.top ?? this.viewHeight / 2,
-            this.options.camera.orthographic.bottom ?? this.viewHeight / -2,
-            this.options.camera.near,
-            this.options.camera.far
-          );
+      function getZoomScale() {
+        return Math.pow(0.95, scope.zoomSpeed);
       }
-    }
-    createRenderer() {
-      const renderer = new WebGLRenderer({
-        antialias: this.options.render.antialias,
-        alpha: true,
-        powerPreference: "high-performance",
-        depth: true
-      });
-      renderer.setClearColor(0, 0);
-      renderer.shadowMap.enabled = true;
-      renderer.shadowMap.type = PCFSoftShadowMap;
-      renderer.outputEncoding = LinearEncoding;
-      renderer.setSize(this.viewWidth, this.viewHeight);
-      return renderer;
-    }
-    createComposer() {
-      const composer = new EffectComposer(this.renderer);
-      if (!this.options.composer.enabled) return composer;
-      composer.setSize(this.viewWidth, this.viewHeight);
-      composer.addPass(new RenderPass(this.scene, this.camera));
-      return composer;
-    }
-    //</editor-fold>
-    init() {
-      if (typeof window["__THREE_DEVTOOLS__"] !== "undefined") {
-        window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
+      function rotateLeft(angle) {
+        sphericalDelta.theta -= angle;
       }
-      if (this.options.debug.grid) {
-        const gridHelper = new GridHelper(128, 16);
-        this.scene.add(gridHelper);
-        const gridHelper2 = new GridHelper(128, 16);
-        gridHelper2.rotation.x = 90 * (Math.PI / 180);
-        this.scene.add(gridHelper2);
-        const gridHelper3 = new GridHelper(128, 16);
-        gridHelper3.rotation.z = 90 * (Math.PI / 180);
-        this.scene.add(gridHelper3);
+      function rotateUp(angle) {
+        sphericalDelta.phi -= angle;
       }
-      if (this.options.debug.axes) {
-        const axesHelper = new AxesHelper(64);
-        this.scene.add(axesHelper);
+      const panLeft = function() {
+        const v5 = new Vector3();
+        return function panLeft2(distance, objectMatrix) {
+          v5.setFromMatrixColumn(objectMatrix, 0);
+          v5.multiplyScalar(-distance);
+          panOffset.add(v5);
+        };
+      }();
+      const panUp = function() {
+        const v5 = new Vector3();
+        return function panUp2(distance, objectMatrix) {
+          if (scope.screenSpacePanning === true) {
+            v5.setFromMatrixColumn(objectMatrix, 1);
+          } else {
+            v5.setFromMatrixColumn(objectMatrix, 0);
+            v5.crossVectors(scope.object.up, v5);
+          }
+          v5.multiplyScalar(distance);
+          panOffset.add(v5);
+        };
+      }();
+      const pan = function() {
+        const offset = new Vector3();
+        return function pan2(deltaX, deltaY) {
+          const element = scope.domElement;
+          if (scope.object.isPerspectiveCamera) {
+            const position = scope.object.position;
+            offset.copy(position).sub(scope.target);
+            let targetDistance = offset.length();
+            targetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180);
+            panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);
+            panUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix);
+          } else if (scope.object.isOrthographicCamera) {
+            panLeft(deltaX * (scope.object.right - scope.object.left) / scope.object.zoom / element.clientWidth, scope.object.matrix);
+            panUp(deltaY * (scope.object.top - scope.object.bottom) / scope.object.zoom / element.clientHeight, scope.object.matrix);
+          } else {
+            console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.");
+            scope.enablePan = false;
+          }
+        };
+      }();
+      function dollyOut(dollyScale) {
+        if (scope.object.isPerspectiveCamera) {
+          scale /= dollyScale;
+        } else if (scope.object.isOrthographicCamera) {
+          scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom * dollyScale));
+          scope.object.updateProjectionMatrix();
+          zoomChanged = true;
+        } else {
+          console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
+          scope.enableZoom = false;
+        }
       }
-      if (this.options.camera.position) {
-        if (isVector3(this.options.camera.position)) {
-          this.camera.position.set(this.options.camera.position.x, this.options.camera.position.y, this.options.camera.position.z);
-        } else if (isTripleArray(this.options.camera.position)) {
-          this.camera.position.set(this.options.camera.position[0], this.options.camera.position[1], this.options.camera.position[2]);
+      function dollyIn(dollyScale) {
+        if (scope.object.isPerspectiveCamera) {
+          scale *= dollyScale;
+        } else if (scope.object.isOrthographicCamera) {
+          scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / dollyScale));
+          scope.object.updateProjectionMatrix();
+          zoomChanged = true;
+        } else {
+          console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
+          scope.enableZoom = false;
         }
       }
-      if (this.options.camera.lookingAt) {
-        if (isVector3(this.options.camera.lookingAt)) {
-          this.camera.lookAt(this.options.camera.lookingAt);
-        } else if (isTripleArray(this.options.camera.lookingAt)) {
-          this.camera.lookAt(this.options.camera.lookingAt[0], this.options.camera.lookingAt[1], this.options.camera.lookingAt[2]);
+      function handleMouseDownRotate(event) {
+        rotateStart.set(event.clientX, event.clientY);
+      }
+      function handleMouseDownDolly(event) {
+        dollyStart.set(event.clientX, event.clientY);
+      }
+      function handleMouseDownPan(event) {
+        panStart.set(event.clientX, event.clientY);
+      }
+      function handleMouseMoveRotate(event) {
+        rotateEnd.set(event.clientX, event.clientY);
+        rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
+        const element = scope.domElement;
+        rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
+        rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
+        rotateStart.copy(rotateEnd);
+        scope.update();
+      }
+      function handleMouseMoveDolly(event) {
+        dollyEnd.set(event.clientX, event.clientY);
+        dollyDelta.subVectors(dollyEnd, dollyStart);
+        if (dollyDelta.y > 0) {
+          dollyOut(getZoomScale());
+        } else if (dollyDelta.y < 0) {
+          dollyIn(getZoomScale());
         }
+        dollyStart.copy(dollyEnd);
+        scope.update();
       }
-      if (this.options.render.autoResize) {
-        this._resizeListener = () => {
-          this.resize(this.viewWidth, this.viewHeight);
-        };
-        window.addEventListener("resize", this._resizeListener);
+      function handleMouseMovePan(event) {
+        panEnd.set(event.clientX, event.clientY);
+        panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
+        pan(panDelta.x, panDelta.y);
+        panStart.copy(panEnd);
+        scope.update();
       }
-    }
-    get element() {
-      return this._element;
-    }
-    appendTo(element) {
-      this._element = element;
-      this._element.appendChild(this.renderer.domElement);
-      if (this.viewWidth == 0) {
-        console.warn("0 element width");
+      function handleMouseUp() {
       }
-      if (this.viewHeight == 0) {
-        console.warn("0 element height");
+      function handleMouseWheel(event) {
+        if (event.deltaY < 0) {
+          dollyIn(getZoomScale());
+        } else if (event.deltaY > 0) {
+          dollyOut(getZoomScale());
+        }
+        scope.update();
       }
-      this.resize(this.viewWidth, this.viewHeight);
-    }
-    /**
-     * Register an EventDispatcher which may update the scene or renderer in order to redraw the scene
-     */
-    registerEventDispatcher(dispatcher, changeEvent2 = "change") {
-      dispatcher.addEventListener(changeEvent2, (event) => {
-        this._dirty = true;
-      });
-    }
-    resize(width, height) {
-      if (isPerspectiveCamera(this.camera)) {
-        this.camera.aspect = width / height;
-        this.camera.updateProjectionMatrix();
-      } else if (isOrthographicCamera(this.camera)) {
-        this.camera.left = width / -2;
-        this.camera.right = width / 2;
-        this.camera.top = height / 2;
-        this.camera.bottom = height / -2;
-        this.camera.updateProjectionMatrix();
+      function handleKeyDown(event) {
+        let needsUpdate = false;
+        switch (event.code) {
+          case scope.keys.UP:
+            pan(0, scope.keyPanSpeed);
+            needsUpdate = true;
+            break;
+          case scope.keys.BOTTOM:
+            pan(0, -scope.keyPanSpeed);
+            needsUpdate = true;
+            break;
+          case scope.keys.LEFT:
+            pan(scope.keyPanSpeed, 0);
+            needsUpdate = true;
+            break;
+          case scope.keys.RIGHT:
+            pan(-scope.keyPanSpeed, 0);
+            needsUpdate = true;
+            break;
+        }
+        if (needsUpdate) {
+          event.preventDefault();
+          scope.update();
+        }
       }
-      this.renderer.setSize(width, height);
-      this.composer.setSize(width, height);
-    }
-    //<editor-fold desc="RENDER">
-    get dirty() {
-      return this._dirty || this.scene.dirty;
-    }
-    set dirty(dirty) {
-      this._dirty = dirty;
-      this.scene.dirty = dirty;
-    }
-    start() {
-      stop();
-      this.renderer.setAnimationLoop(this._animationLoop);
-    }
-    stop() {
-      this.renderer.setAnimationLoop(null);
-      if (this._animationTimer)
-        clearTimeout(this._animationTimer);
-      this._animationTimer = void 0;
-      if (this._animationFrame)
-        cancelAnimationFrame(this._animationFrame);
-      this._animationFrame = void 0;
-    }
-    animate(t5) {
-      if (this._stats) {
-        this._stats.begin();
+      function handleTouchStartRotate() {
+        if (pointers.length === 1) {
+          rotateStart.set(pointers[0].pageX, pointers[0].pageY);
+        } else {
+          const x4 = 0.5 * (pointers[0].pageX + pointers[1].pageX);
+          const y5 = 0.5 * (pointers[0].pageY + pointers[1].pageY);
+          rotateStart.set(x4, y5);
+        }
       }
-      if (this.dirty || this.options.render.renderAlways) {
-        if (this.options.composer.enabled) {
-          this.composer.render();
+      function handleTouchStartPan() {
+        if (pointers.length === 1) {
+          panStart.set(pointers[0].pageX, pointers[0].pageY);
         } else {
-          this.renderer.render(this.scene, this.camera);
+          const x4 = 0.5 * (pointers[0].pageX + pointers[1].pageX);
+          const y5 = 0.5 * (pointers[0].pageY + pointers[1].pageY);
+          panStart.set(x4, y5);
         }
       }
-      this.dirty = false;
-      if (this._stats) {
-        this._stats.end();
+      function handleTouchStartDolly() {
+        const dx = pointers[0].pageX - pointers[1].pageX;
+        const dy = pointers[0].pageY - pointers[1].pageY;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        dollyStart.set(0, distance);
       }
-    }
-    //</editor-fold>
-    toImage() {
-      return this.renderer.domElement.toDataURL();
-    }
-    ///
-    get attachedToBody() {
-      return this.element === document.body;
-    }
-    get viewWidth() {
-      return this.attachedToBody ? window.innerWidth : this.element?.offsetWidth || 0;
-    }
-    get viewHeight() {
-      return this.attachedToBody ? window.innerHeight : this.element?.offsetHeight || 0;
-    }
-    get scene() {
-      return this._scene;
-    }
-    get camera() {
-      return this._camera;
-    }
-    get renderer() {
-      return this._renderer;
-    }
-    get composer() {
-      return this._composer;
-    }
-    ///
-  };
-  _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge10.default)({}, {
-    camera: {
-      type: "perspective",
-      near: 1,
-      far: 5e3,
-      perspective: {
-        aspect: void 0,
-        fov: 50
-      },
-      orthographic: {
-        left: void 0,
-        right: void 0,
-        top: void 0,
-        bottom: void 0
-      },
-      position: new Vector3(50, 50, 50),
-      lookingAt: new Vector3(0, 0, 0)
-    },
-    render: {
-      fpsLimit: 60,
-      stats: false,
-      antialias: true,
-      shade: true,
-      autoResize: true,
-      renderAlways: false
-    },
-    composer: {
-      enabled: true
-    },
-    debug: {
-      grid: false,
-      axes: false
-    }
-  });
-  var Renderer = _Renderer;
-
-  // src/renderer/SceneObjectOptions.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-
-  // src/skin/index.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-
-  // src/skin/Skins.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  var Skins = class {
-    //<editor-fold desc="Skins">
-    static async fromUuidOrUsername(uuidOrUsername) {
-      if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
-        return this.fromUuid(uuidOrUsername);
+      function handleTouchStartDollyPan() {
+        if (scope.enableZoom) handleTouchStartDolly();
+        if (scope.enablePan) handleTouchStartPan();
       }
-      return this.fromUsername(uuidOrUsername);
-    }
-    static async fromUuid(uuid) {
-      return this.getSkinProxySkinUrl(uuid);
-    }
-    static async fromUsername(username) {
-      return this.usernameToUuid(username).then((uuid) => {
-        if (uuid) {
-          return this.fromUuid(uuid);
-        }
-        return void 0;
-      });
-    }
-    static async fromMineSkin(mineskinId) {
-      return this.getMineSkin(mineskinId).then((mineskin) => {
-        if (mineskin) {
-          return mineskin["data"]["texture"]["value"]["urls"]["skins"];
+      function handleTouchStartDollyRotate() {
+        if (scope.enableZoom) handleTouchStartDolly();
+        if (scope.enableRotate) handleTouchStartRotate();
+      }
+      function handleTouchMoveRotate(event) {
+        if (pointers.length == 1) {
+          rotateEnd.set(event.pageX, event.pageY);
+        } else {
+          const position = getSecondPointerPosition(event);
+          const x4 = 0.5 * (event.pageX + position.x);
+          const y5 = 0.5 * (event.pageY + position.y);
+          rotateEnd.set(x4, y5);
         }
-        return void 0;
-      });
-    }
-    //</editor-fold>
-    //<editor-fold desc="Capes">
-    static async capeFromUuidOrUsername(uuidOrUsername) {
-      if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
-        return this.capeFromUuid(uuidOrUsername);
+        rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
+        const element = scope.domElement;
+        rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
+        rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
+        rotateStart.copy(rotateEnd);
       }
-      return this.capeFromUsername(uuidOrUsername);
-    }
-    static async capeFromUuid(uuid) {
-      return this.getSkinProxyCapeUrl(uuid);
-    }
-    static async capeFromUsername(username) {
-      return this.usernameToUuid(username).then((uuid) => {
-        if (uuid) {
-          return this.capeFromUuid(uuid);
+      function handleTouchMovePan(event) {
+        if (pointers.length === 1) {
+          panEnd.set(event.pageX, event.pageY);
+        } else {
+          const position = getSecondPointerPosition(event);
+          const x4 = 0.5 * (event.pageX + position.x);
+          const y5 = 0.5 * (event.pageY + position.y);
+          panEnd.set(x4, y5);
         }
-        return void 0;
-      });
-    }
-    static async capeFromCapesDev(uuid, capeType = "minecraft") {
-      return this.getCapesDev(uuid, capeType).then((cape) => {
-        if (cape) {
-          return cape?.stillImageUrl;
+        panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
+        pan(panDelta.x, panDelta.y);
+        panStart.copy(panEnd);
+      }
+      function handleTouchMoveDolly(event) {
+        const position = getSecondPointerPosition(event);
+        const dx = event.pageX - position.x;
+        const dy = event.pageY - position.y;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        dollyEnd.set(0, distance);
+        dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed));
+        dollyOut(dollyDelta.y);
+        dollyStart.copy(dollyEnd);
+      }
+      function handleTouchMoveDollyPan(event) {
+        if (scope.enableZoom) handleTouchMoveDolly(event);
+        if (scope.enablePan) handleTouchMovePan(event);
+      }
+      function handleTouchMoveDollyRotate(event) {
+        if (scope.enableZoom) handleTouchMoveDolly(event);
+        if (scope.enableRotate) handleTouchMoveRotate(event);
+      }
+      function handleTouchEnd() {
+      }
+      function onPointerDown(event) {
+        if (scope.enabled === false) return;
+        if (pointers.length === 0) {
+          scope.domElement.setPointerCapture(event.pointerId);
+          scope.domElement.addEventListener("pointermove", onPointerMove);
+          scope.domElement.addEventListener("pointerup", onPointerUp);
         }
-        return void 0;
-      });
-    }
-    //</editor-fold>
-    //<editor-fold desc="Helpers">
-    static async usernameToUuid(username) {
-      return this.usernameToUuidSkinProxy(username);
-    }
-    static async usernameToUuidSkinProxy(username) {
-      return Requests.genericRequest({
-        baseURL: "https://minecraft-skin-proxy.inventive.workers.dev",
-        url: "/uuid/" + username
-      }).then((res) => {
-        if (res.status === 200) {
-          return res.data["id"];
+        addPointer(event);
+        if (event.pointerType === "touch") {
+          onTouchStart(event);
+        } else {
+          onMouseDown(event);
         }
-        return void 0;
-      }).catch((err) => {
-        console.warn(err);
-        return void 0;
-      });
-    }
-    static async usernameToUuidMineTools(username) {
-      return Requests.genericRequest({
-        baseURL: "https://api.minetools.eu",
-        url: "/uuid/" + username
-      }).then((res) => {
-        if (res.status === 200) {
-          return res.data["id"];
+      }
+      function onPointerMove(event) {
+        if (scope.enabled === false) return;
+        if (event.pointerType === "touch") {
+          onTouchMove(event);
+        } else {
+          onMouseMove(event);
         }
-        return void 0;
-      }).catch((err) => {
-        console.warn(err);
-        return void 0;
-      });
-    }
-    static async getProfileFromMinetools(uuid) {
-      return Requests.genericRequest({
-        baseURL: "https://api.minetools.eu",
-        url: "/profile/" + uuid
-      }).then((res) => {
-        if (res.status === 200) {
-          return res.data;
+      }
+      function onPointerUp(event) {
+        if (scope.enabled === false) return;
+        if (event.pointerType === "touch") {
+          onTouchEnd();
+        } else {
+          onMouseUp(event);
         }
-      });
-    }
-    static async getMineSkin(mineskinId) {
-      return Requests.genericRequest({
-        baseURL: "https://api.mineskin.org",
-        url: "/get/uuid/" + mineskinId
-      }).then((res) => {
-        if (res.status === 200) {
-          return res.data;
+        removePointer(event);
+        if (pointers.length === 0) {
+          scope.domElement.releasePointerCapture(event.pointerId);
+          scope.domElement.removeEventListener("pointermove", onPointerMove);
+          scope.domElement.removeEventListener("pointerup", onPointerUp);
         }
-        return void 0;
-      }).catch((err) => {
-        console.warn(err);
-        return void 0;
-      });
-    }
-    static async getCapesDev(uuid, type = "all") {
-      return Requests.genericRequest({
-        baseURL: "https://api.capes.dev",
-        url: "/load/" + uuid + "/" + type
-      }).then((res) => {
-        if (res.status === 200) {
-          return res.data;
+      }
+      function onPointerCancel(event) {
+        removePointer(event);
+      }
+      function onMouseDown(event) {
+        let mouseAction;
+        switch (event.button) {
+          case 0:
+            mouseAction = scope.mouseButtons.LEFT;
+            break;
+          case 1:
+            mouseAction = scope.mouseButtons.MIDDLE;
+            break;
+          case 2:
+            mouseAction = scope.mouseButtons.RIGHT;
+            break;
+          default:
+            mouseAction = -1;
         }
-        return void 0;
-      }).catch((err) => {
-        console.warn(err);
-        return void 0;
-      });
-    }
-    static getCrafatarSkinUrl(uuid) {
-      return "https://crafatar.com/skins/" + uuid;
-    }
-    static getCrafatarCapeUrl(uuid) {
-      return "https://crafatar.com/capes/" + uuid;
-    }
-    static getMcHeadsSkinUrl(uuid) {
-      return "https://mc-heads.net/skin/" + uuid;
-    }
-    static getMineSkinPlayerSkinUrl(uuid) {
-      return "https://mineskin.org/skin/player/" + uuid;
-    }
-    static getSkinProxySkinUrl(uuid) {
-      return "https://minecraft-skin-proxy.inventive.workers.dev/skin/" + uuid;
-    }
-    static getSkinProxyCapeUrl(uuid) {
-      return "https://minecraft-skin-proxy.inventive.workers.dev/cape/" + uuid;
-    }
-    //</editor-fold>
-  };
-
-  // src/skin/scene/index.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-
-  // src/texture/index.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-
-  // src/three/index.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-
-  // src/three/OrbitControls.js
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  var _changeEvent = { type: "change" };
-  var _startEvent = { type: "start" };
-  var _endEvent = { type: "end" };
-  var OrbitControls = class extends EventDispatcher {
-    constructor(object, domElement) {
-      super();
-      if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
-      if (domElement === document) console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.');
-      this.object = object;
-      this.domElement = domElement;
-      this.domElement.style.touchAction = "none";
-      this.enabled = true;
-      this.target = new Vector3();
-      this.minDistance = 0;
-      this.maxDistance = Infinity;
-      this.minZoom = 0;
-      this.maxZoom = Infinity;
-      this.minPolarAngle = 0;
-      this.maxPolarAngle = Math.PI;
-      this.minAzimuthAngle = -Infinity;
-      this.maxAzimuthAngle = Infinity;
-      this.enableDamping = false;
-      this.dampingFactor = 0.05;
-      this.enableZoom = true;
-      this.zoomSpeed = 1;
-      this.enableRotate = true;
-      this.rotateSpeed = 1;
-      this.enablePan = true;
-      this.panSpeed = 1;
-      this.screenSpacePanning = true;
-      this.keyPanSpeed = 7;
-      this.autoRotate = false;
-      this.autoRotateSpeed = 2;
-      this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-      this.mouseButtons = { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.PAN };
-      this.touches = { ONE: TOUCH.ROTATE, TWO: TOUCH.DOLLY_PAN };
-      this.target0 = this.target.clone();
-      this.position0 = this.object.position.clone();
-      this.zoom0 = this.object.zoom;
-      this._domElementKeyEvents = null;
-      this.getPolarAngle = function() {
-        return spherical.phi;
-      };
-      this.getAzimuthalAngle = function() {
-        return spherical.theta;
-      };
-      this.getDistance = function() {
-        return this.object.position.distanceTo(this.target);
-      };
-      this.saveState = function() {
-        scope.target0.copy(scope.target);
-        scope.position0.copy(scope.object.position);
-        scope.zoom0 = scope.object.zoom;
-      };
-      this.reset = function() {
-        scope.target.copy(scope.target0);
-        scope.object.position.copy(scope.position0);
-        scope.object.zoom = scope.zoom0;
-        scope.object.updateProjectionMatrix();
-        scope.dispatchEvent(_changeEvent);
-        scope.update();
-        state = STATE.NONE;
-      };
-      this.update = function() {
-        const offset = new Vector3();
-        const quat = new Quaternion().setFromUnitVectors(object.up, new Vector3(0, 1, 0));
-        const quatInverse = quat.clone().invert();
-        const lastPosition = new Vector3();
-        const lastQuaternion = new Quaternion();
-        const twoPI = 2 * Math.PI;
-        return function update() {
-          const position = scope.object.position;
-          offset.copy(position).sub(scope.target);
-          offset.applyQuaternion(quat);
-          spherical.setFromVector3(offset);
-          if (scope.autoRotate && state === STATE.NONE) {
-            rotateLeft(getAutoRotationAngle());
-          }
-          if (scope.enableDamping) {
-            spherical.theta += sphericalDelta.theta * scope.dampingFactor;
-            spherical.phi += sphericalDelta.phi * scope.dampingFactor;
-          } else {
-            spherical.theta += sphericalDelta.theta;
-            spherical.phi += sphericalDelta.phi;
-          }
-          let min = scope.minAzimuthAngle;
-          let max = scope.maxAzimuthAngle;
-          if (isFinite(min) && isFinite(max)) {
-            if (min < -Math.PI) min += twoPI;
-            else if (min > Math.PI) min -= twoPI;
-            if (max < -Math.PI) max += twoPI;
-            else if (max > Math.PI) max -= twoPI;
-            if (min <= max) {
-              spherical.theta = Math.max(min, Math.min(max, spherical.theta));
+        switch (mouseAction) {
+          case MOUSE.DOLLY:
+            if (scope.enableZoom === false) return;
+            handleMouseDownDolly(event);
+            state = STATE.DOLLY;
+            break;
+          case MOUSE.ROTATE:
+            if (event.ctrlKey || event.metaKey || event.shiftKey) {
+              if (scope.enablePan === false) return;
+              handleMouseDownPan(event);
+              state = STATE.PAN;
             } else {
-              spherical.theta = spherical.theta > (min + max) / 2 ? Math.max(min, spherical.theta) : Math.min(max, spherical.theta);
+              if (scope.enableRotate === false) return;
+              handleMouseDownRotate(event);
+              state = STATE.ROTATE;
             }
-          }
-          spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi));
-          spherical.makeSafe();
-          spherical.radius *= scale;
-          spherical.radius = Math.max(scope.minDistance, Math.min(scope.maxDistance, spherical.radius));
-          if (scope.enableDamping === true) {
-            scope.target.addScaledVector(panOffset, scope.dampingFactor);
-          } else {
-            scope.target.add(panOffset);
-          }
-          offset.setFromSpherical(spherical);
-          offset.applyQuaternion(quatInverse);
-          position.copy(scope.target).add(offset);
-          scope.object.lookAt(scope.target);
-          if (scope.enableDamping === true) {
-            sphericalDelta.theta *= 1 - scope.dampingFactor;
-            sphericalDelta.phi *= 1 - scope.dampingFactor;
-            panOffset.multiplyScalar(1 - scope.dampingFactor);
-          } else {
-            sphericalDelta.set(0, 0, 0);
-            panOffset.set(0, 0, 0);
-          }
-          scale = 1;
-          if (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) {
-            scope.dispatchEvent(_changeEvent);
-            lastPosition.copy(scope.object.position);
-            lastQuaternion.copy(scope.object.quaternion);
-            zoomChanged = false;
-            return true;
-          }
-          return false;
-        };
-      }();
-      this.dispose = function() {
-        scope.domElement.removeEventListener("contextmenu", onContextMenu);
-        scope.domElement.removeEventListener("pointerdown", onPointerDown);
-        scope.domElement.removeEventListener("pointercancel", onPointerCancel);
-        scope.domElement.removeEventListener("wheel", onMouseWheel);
-        scope.domElement.removeEventListener("pointermove", onPointerMove);
-        scope.domElement.removeEventListener("pointerup", onPointerUp);
-        if (scope._domElementKeyEvents !== null) {
-          scope._domElementKeyEvents.removeEventListener("keydown", onKeyDown);
+            break;
+          case MOUSE.PAN:
+            if (event.ctrlKey || event.metaKey || event.shiftKey) {
+              if (scope.enableRotate === false) return;
+              handleMouseDownRotate(event);
+              state = STATE.ROTATE;
+            } else {
+              if (scope.enablePan === false) return;
+              handleMouseDownPan(event);
+              state = STATE.PAN;
+            }
+            break;
+          default:
+            state = STATE.NONE;
         }
-      };
-      const scope = this;
-      const STATE = {
-        NONE: -1,
-        ROTATE: 0,
-        DOLLY: 1,
-        PAN: 2,
-        TOUCH_ROTATE: 3,
-        TOUCH_PAN: 4,
-        TOUCH_DOLLY_PAN: 5,
-        TOUCH_DOLLY_ROTATE: 6
-      };
-      let state = STATE.NONE;
-      const EPS = 1e-6;
-      const spherical = new Spherical();
-      const sphericalDelta = new Spherical();
-      let scale = 1;
-      const panOffset = new Vector3();
-      let zoomChanged = false;
-      const rotateStart = new Vector2();
-      const rotateEnd = new Vector2();
-      const rotateDelta = new Vector2();
-      const panStart = new Vector2();
-      const panEnd = new Vector2();
-      const panDelta = new Vector2();
-      const dollyStart = new Vector2();
-      const dollyEnd = new Vector2();
-      const dollyDelta = new Vector2();
-      const pointers = [];
-      const pointerPositions = {};
-      function getAutoRotationAngle() {
-        return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
-      }
-      function getZoomScale() {
-        return Math.pow(0.95, scope.zoomSpeed);
-      }
-      function rotateLeft(angle) {
-        sphericalDelta.theta -= angle;
-      }
-      function rotateUp(angle) {
-        sphericalDelta.phi -= angle;
-      }
-      const panLeft = function() {
-        const v5 = new Vector3();
-        return function panLeft2(distance, objectMatrix) {
-          v5.setFromMatrixColumn(objectMatrix, 0);
-          v5.multiplyScalar(-distance);
-          panOffset.add(v5);
-        };
-      }();
-      const panUp = function() {
-        const v5 = new Vector3();
-        return function panUp2(distance, objectMatrix) {
-          if (scope.screenSpacePanning === true) {
-            v5.setFromMatrixColumn(objectMatrix, 1);
-          } else {
-            v5.setFromMatrixColumn(objectMatrix, 0);
-            v5.crossVectors(scope.object.up, v5);
-          }
-          v5.multiplyScalar(distance);
-          panOffset.add(v5);
-        };
-      }();
-      const pan = function() {
-        const offset = new Vector3();
-        return function pan2(deltaX, deltaY) {
-          const element = scope.domElement;
-          if (scope.object.isPerspectiveCamera) {
-            const position = scope.object.position;
-            offset.copy(position).sub(scope.target);
-            let targetDistance = offset.length();
-            targetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180);
-            panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);
-            panUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix);
-          } else if (scope.object.isOrthographicCamera) {
-            panLeft(deltaX * (scope.object.right - scope.object.left) / scope.object.zoom / element.clientWidth, scope.object.matrix);
-            panUp(deltaY * (scope.object.top - scope.object.bottom) / scope.object.zoom / element.clientHeight, scope.object.matrix);
-          } else {
-            console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.");
-            scope.enablePan = false;
-          }
-        };
-      }();
-      function dollyOut(dollyScale) {
-        if (scope.object.isPerspectiveCamera) {
-          scale /= dollyScale;
-        } else if (scope.object.isOrthographicCamera) {
-          scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom * dollyScale));
-          scope.object.updateProjectionMatrix();
-          zoomChanged = true;
-        } else {
-          console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
-          scope.enableZoom = false;
+        if (state !== STATE.NONE) {
+          scope.dispatchEvent(_startEvent);
         }
       }
-      function dollyIn(dollyScale) {
-        if (scope.object.isPerspectiveCamera) {
-          scale *= dollyScale;
-        } else if (scope.object.isOrthographicCamera) {
-          scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / dollyScale));
-          scope.object.updateProjectionMatrix();
-          zoomChanged = true;
-        } else {
-          console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
-          scope.enableZoom = false;
+      function onMouseMove(event) {
+        if (scope.enabled === false) return;
+        switch (state) {
+          case STATE.ROTATE:
+            if (scope.enableRotate === false) return;
+            handleMouseMoveRotate(event);
+            break;
+          case STATE.DOLLY:
+            if (scope.enableZoom === false) return;
+            handleMouseMoveDolly(event);
+            break;
+          case STATE.PAN:
+            if (scope.enablePan === false) return;
+            handleMouseMovePan(event);
+            break;
         }
       }
-      function handleMouseDownRotate(event) {
-        rotateStart.set(event.clientX, event.clientY);
-      }
-      function handleMouseDownDolly(event) {
-        dollyStart.set(event.clientX, event.clientY);
+      function onMouseUp(event) {
+        handleMouseUp(event);
+        scope.dispatchEvent(_endEvent);
+        state = STATE.NONE;
       }
-      function handleMouseDownPan(event) {
-        panStart.set(event.clientX, event.clientY);
+      function onMouseWheel(event) {
+        if (scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE) return;
+        event.preventDefault();
+        scope.dispatchEvent(_startEvent);
+        handleMouseWheel(event);
+        scope.dispatchEvent(_endEvent);
       }
-      function handleMouseMoveRotate(event) {
-        rotateEnd.set(event.clientX, event.clientY);
-        rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
-        const element = scope.domElement;
-        rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
-        rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
-        rotateStart.copy(rotateEnd);
-        scope.update();
+      function onKeyDown(event) {
+        if (scope.enabled === false || scope.enablePan === false) return;
+        handleKeyDown(event);
       }
-      function handleMouseMoveDolly(event) {
-        dollyEnd.set(event.clientX, event.clientY);
-        dollyDelta.subVectors(dollyEnd, dollyStart);
-        if (dollyDelta.y > 0) {
-          dollyOut(getZoomScale());
-        } else if (dollyDelta.y < 0) {
-          dollyIn(getZoomScale());
+      function onTouchStart(event) {
+        trackPointer(event);
+        switch (pointers.length) {
+          case 1:
+            switch (scope.touches.ONE) {
+              case TOUCH.ROTATE:
+                if (scope.enableRotate === false) return;
+                handleTouchStartRotate();
+                state = STATE.TOUCH_ROTATE;
+                break;
+              case TOUCH.PAN:
+                if (scope.enablePan === false) return;
+                handleTouchStartPan();
+                state = STATE.TOUCH_PAN;
+                break;
+              default:
+                state = STATE.NONE;
+            }
+            break;
+          case 2:
+            switch (scope.touches.TWO) {
+              case TOUCH.DOLLY_PAN:
+                if (scope.enableZoom === false && scope.enablePan === false) return;
+                handleTouchStartDollyPan();
+                state = STATE.TOUCH_DOLLY_PAN;
+                break;
+              case TOUCH.DOLLY_ROTATE:
+                if (scope.enableZoom === false && scope.enableRotate === false) return;
+                handleTouchStartDollyRotate();
+                state = STATE.TOUCH_DOLLY_ROTATE;
+                break;
+              default:
+                state = STATE.NONE;
+            }
+            break;
+          default:
+            state = STATE.NONE;
         }
-        dollyStart.copy(dollyEnd);
-        scope.update();
-      }
-      function handleMouseMovePan(event) {
-        panEnd.set(event.clientX, event.clientY);
-        panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
-        pan(panDelta.x, panDelta.y);
-        panStart.copy(panEnd);
-        scope.update();
-      }
-      function handleMouseUp() {
-      }
-      function handleMouseWheel(event) {
-        if (event.deltaY < 0) {
-          dollyIn(getZoomScale());
-        } else if (event.deltaY > 0) {
-          dollyOut(getZoomScale());
+        if (state !== STATE.NONE) {
+          scope.dispatchEvent(_startEvent);
         }
-        scope.update();
       }
-      function handleKeyDown(event) {
-        let needsUpdate = false;
-        switch (event.code) {
-          case scope.keys.UP:
-            pan(0, scope.keyPanSpeed);
-            needsUpdate = true;
+      function onTouchMove(event) {
+        trackPointer(event);
+        switch (state) {
+          case STATE.TOUCH_ROTATE:
+            if (scope.enableRotate === false) return;
+            handleTouchMoveRotate(event);
+            scope.update();
             break;
-          case scope.keys.BOTTOM:
-            pan(0, -scope.keyPanSpeed);
-            needsUpdate = true;
+          case STATE.TOUCH_PAN:
+            if (scope.enablePan === false) return;
+            handleTouchMovePan(event);
+            scope.update();
             break;
-          case scope.keys.LEFT:
-            pan(scope.keyPanSpeed, 0);
-            needsUpdate = true;
+          case STATE.TOUCH_DOLLY_PAN:
+            if (scope.enableZoom === false && scope.enablePan === false) return;
+            handleTouchMoveDollyPan(event);
+            scope.update();
             break;
-          case scope.keys.RIGHT:
-            pan(-scope.keyPanSpeed, 0);
-            needsUpdate = true;
+          case STATE.TOUCH_DOLLY_ROTATE:
+            if (scope.enableZoom === false && scope.enableRotate === false) return;
+            handleTouchMoveDollyRotate(event);
+            scope.update();
             break;
-        }
-        if (needsUpdate) {
-          event.preventDefault();
-          scope.update();
-        }
-      }
-      function handleTouchStartRotate() {
-        if (pointers.length === 1) {
-          rotateStart.set(pointers[0].pageX, pointers[0].pageY);
-        } else {
-          const x4 = 0.5 * (pointers[0].pageX + pointers[1].pageX);
-          const y5 = 0.5 * (pointers[0].pageY + pointers[1].pageY);
-          rotateStart.set(x4, y5);
-        }
-      }
-      function handleTouchStartPan() {
-        if (pointers.length === 1) {
-          panStart.set(pointers[0].pageX, pointers[0].pageY);
-        } else {
-          const x4 = 0.5 * (pointers[0].pageX + pointers[1].pageX);
-          const y5 = 0.5 * (pointers[0].pageY + pointers[1].pageY);
-          panStart.set(x4, y5);
+          default:
+            state = STATE.NONE;
         }
       }
-      function handleTouchStartDolly() {
-        const dx = pointers[0].pageX - pointers[1].pageX;
-        const dy = pointers[0].pageY - pointers[1].pageY;
-        const distance = Math.sqrt(dx * dx + dy * dy);
-        dollyStart.set(0, distance);
+      function onTouchEnd(event) {
+        handleTouchEnd(event);
+        scope.dispatchEvent(_endEvent);
+        state = STATE.NONE;
       }
-      function handleTouchStartDollyPan() {
-        if (scope.enableZoom) handleTouchStartDolly();
-        if (scope.enablePan) handleTouchStartPan();
+      function onContextMenu(event) {
+        if (scope.enabled === false) return;
+        event.preventDefault();
       }
-      function handleTouchStartDollyRotate() {
-        if (scope.enableZoom) handleTouchStartDolly();
-        if (scope.enableRotate) handleTouchStartRotate();
+      function addPointer(event) {
+        pointers.push(event);
       }
-      function handleTouchMoveRotate(event) {
-        if (pointers.length == 1) {
-          rotateEnd.set(event.pageX, event.pageY);
-        } else {
-          const position = getSecondPointerPosition(event);
-          const x4 = 0.5 * (event.pageX + position.x);
-          const y5 = 0.5 * (event.pageY + position.y);
-          rotateEnd.set(x4, y5);
+      function removePointer(event) {
+        delete pointerPositions[event.pointerId];
+        for (let i4 = 0; i4 < pointers.length; i4++) {
+          if (pointers[i4].pointerId == event.pointerId) {
+            pointers.splice(i4, 1);
+            return;
+          }
         }
-        rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
-        const element = scope.domElement;
-        rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
-        rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
-        rotateStart.copy(rotateEnd);
       }
-      function handleTouchMovePan(event) {
-        if (pointers.length === 1) {
-          panEnd.set(event.pageX, event.pageY);
-        } else {
-          const position = getSecondPointerPosition(event);
-          const x4 = 0.5 * (event.pageX + position.x);
-          const y5 = 0.5 * (event.pageY + position.y);
-          panEnd.set(x4, y5);
+      function trackPointer(event) {
+        let position = pointerPositions[event.pointerId];
+        if (position === void 0) {
+          position = new Vector2();
+          pointerPositions[event.pointerId] = position;
         }
-        panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
-        pan(panDelta.x, panDelta.y);
-        panStart.copy(panEnd);
-      }
-      function handleTouchMoveDolly(event) {
-        const position = getSecondPointerPosition(event);
-        const dx = event.pageX - position.x;
-        const dy = event.pageY - position.y;
-        const distance = Math.sqrt(dx * dx + dy * dy);
-        dollyEnd.set(0, distance);
-        dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed));
-        dollyOut(dollyDelta.y);
-        dollyStart.copy(dollyEnd);
-      }
-      function handleTouchMoveDollyPan(event) {
-        if (scope.enableZoom) handleTouchMoveDolly(event);
-        if (scope.enablePan) handleTouchMovePan(event);
+        position.set(event.pageX, event.pageY);
       }
-      function handleTouchMoveDollyRotate(event) {
-        if (scope.enableZoom) handleTouchMoveDolly(event);
-        if (scope.enableRotate) handleTouchMoveRotate(event);
+      function getSecondPointerPosition(event) {
+        const pointer = event.pointerId === pointers[0].pointerId ? pointers[1] : pointers[0];
+        return pointerPositions[pointer.pointerId];
       }
-      function handleTouchEnd() {
+      scope.domElement.addEventListener("contextmenu", onContextMenu);
+      scope.domElement.addEventListener("pointerdown", onPointerDown);
+      scope.domElement.addEventListener("pointercancel", onPointerCancel);
+      scope.domElement.addEventListener("wheel", onMouseWheel, { passive: false });
+      this.update();
+    }
+  };
+  var MapControls = class extends OrbitControls {
+    constructor(object, domElement) {
+      super(object, domElement);
+      this.screenSpacePanning = false;
+      this.mouseButtons.LEFT = MOUSE.PAN;
+      this.mouseButtons.RIGHT = MOUSE.ROTATE;
+      this.touches.ONE = TOUCH.PAN;
+      this.touches.TWO = TOUCH.DOLLY_ROTATE;
+    }
+  };
+
+  // src/renderer/Renderer.ts
+  var _Renderer = class _Renderer {
+    constructor(options) {
+      this._dirty = true;
+      this._animationTimer = void 0;
+      this._animationFrame = void 0;
+      this._resizeListener = void 0;
+      this._disposed = false;
+      this._debugHelpers = [];
+      this._eventDispatchers = /* @__PURE__ */ new Map();
+      this._changeListener = () => {
+        this._dirty = true;
+      };
+      this.options = (0, import_ts_deepmerge10.default)({}, _Renderer.DEFAULT_OPTIONS, options ?? {});
+      this._animationLoop = this.animate.bind(this);
+      this._fpsTimer = this.options.render.fpsLimit > 0 ? 1e3 / this.options.render.fpsLimit : void 0;
+      this._scene = this.createScene();
+      this._camera = this.createCamera();
+      this._renderer = this.createRenderer();
+      this._composer = this.createComposer();
+      if (this.options.render.stats) {
+        this._stats = new import_stats.default();
+        document.body.appendChild(this._stats.dom);
       }
-      function onPointerDown(event) {
-        if (scope.enabled === false) return;
-        if (pointers.length === 0) {
-          scope.domElement.setPointerCapture(event.pointerId);
-          scope.domElement.addEventListener("pointermove", onPointerMove);
-          scope.domElement.addEventListener("pointerup", onPointerUp);
-        }
-        addPointer(event);
-        if (event.pointerType === "touch") {
-          onTouchStart(event);
-        } else {
-          onMouseDown(event);
-        }
+      this.init();
+      this._controls = this.createControls();
+    }
+    //<editor-fold desc="INIT">
+    createScene() {
+      return new MineRenderScene();
+    }
+    createCamera() {
+      switch (this.options.camera.type) {
+        case "perspective":
+        default:
+          return new PerspectiveCamera(
+            this.options.camera.perspective.fov,
+            this.options.camera.perspective.aspect ?? this.viewWidth / this.viewHeight,
+            this.options.camera.near,
+            this.options.camera.far
+          );
+        case "orthographic":
+          return new OrthographicCamera(
+            this.options.camera.orthographic.left ?? this.viewWidth / -2,
+            this.options.camera.orthographic.right ?? this.viewWidth / 2,
+            this.options.camera.orthographic.top ?? this.viewHeight / 2,
+            this.options.camera.orthographic.bottom ?? this.viewHeight / -2,
+            this.options.camera.near,
+            this.options.camera.far
+          );
       }
-      function onPointerMove(event) {
-        if (scope.enabled === false) return;
-        if (event.pointerType === "touch") {
-          onTouchMove(event);
-        } else {
-          onMouseMove(event);
-        }
+    }
+    createRenderer() {
+      const renderer = new WebGLRenderer({
+        antialias: this.options.render.antialias,
+        alpha: true,
+        powerPreference: "high-performance",
+        depth: true
+      });
+      renderer.setClearColor(0, 0);
+      renderer.shadowMap.enabled = true;
+      renderer.shadowMap.type = PCFSoftShadowMap;
+      renderer.outputEncoding = LinearEncoding;
+      renderer.setSize(this.viewWidth, this.viewHeight);
+      return renderer;
+    }
+    createComposer() {
+      const composer = new EffectComposer(this.renderer);
+      if (!this.options.composer.enabled) return composer;
+      composer.setSize(this.viewWidth, this.viewHeight);
+      composer.addPass(new RenderPass(this.scene, this.camera));
+      return composer;
+    }
+    createControls() {
+      if (!this.options.controls?.enabled) return void 0;
+      const position = this.camera.position.clone();
+      const controls = new OrbitControls(this.camera, this.renderer.domElement);
+      this.camera.position.copy(position);
+      const target = this.options.camera.lookingAt;
+      if (isVector3(target)) {
+        controls.target.copy(target);
+      } else if (isTripleArray(target)) {
+        controls.target.set(target[0], target[1], target[2]);
+      }
+      controls.update();
+      controls.saveState();
+      this.registerEventDispatcher(controls);
+      return controls;
+    }
+    //</editor-fold>
+    init() {
+      if (this._disposed) return;
+      if (typeof window["__THREE_DEVTOOLS__"] !== "undefined") {
+        window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
       }
-      function onPointerUp(event) {
-        if (scope.enabled === false) return;
-        if (event.pointerType === "touch") {
-          onTouchEnd();
-        } else {
-          onMouseUp(event);
-        }
-        removePointer(event);
-        if (pointers.length === 0) {
-          scope.domElement.releasePointerCapture(event.pointerId);
-          scope.domElement.removeEventListener("pointermove", onPointerMove);
-          scope.domElement.removeEventListener("pointerup", onPointerUp);
-        }
+      if (this.options.debug.grid) {
+        const gridHelper = new GridHelper(128, 16);
+        this._debugHelpers.push(gridHelper);
+        this.scene.add(gridHelper);
+        const gridHelper2 = new GridHelper(128, 16);
+        this._debugHelpers.push(gridHelper2);
+        gridHelper2.rotation.x = 90 * (Math.PI / 180);
+        this.scene.add(gridHelper2);
+        const gridHelper3 = new GridHelper(128, 16);
+        this._debugHelpers.push(gridHelper3);
+        gridHelper3.rotation.z = 90 * (Math.PI / 180);
+        this.scene.add(gridHelper3);
       }
-      function onPointerCancel(event) {
-        removePointer(event);
+      if (this.options.debug.axes) {
+        const axesHelper = new AxesHelper(64);
+        this._debugHelpers.push(axesHelper);
+        this.scene.add(axesHelper);
       }
-      function onMouseDown(event) {
-        let mouseAction;
-        switch (event.button) {
-          case 0:
-            mouseAction = scope.mouseButtons.LEFT;
-            break;
-          case 1:
-            mouseAction = scope.mouseButtons.MIDDLE;
-            break;
-          case 2:
-            mouseAction = scope.mouseButtons.RIGHT;
-            break;
-          default:
-            mouseAction = -1;
-        }
-        switch (mouseAction) {
-          case MOUSE.DOLLY:
-            if (scope.enableZoom === false) return;
-            handleMouseDownDolly(event);
-            state = STATE.DOLLY;
-            break;
-          case MOUSE.ROTATE:
-            if (event.ctrlKey || event.metaKey || event.shiftKey) {
-              if (scope.enablePan === false) return;
-              handleMouseDownPan(event);
-              state = STATE.PAN;
-            } else {
-              if (scope.enableRotate === false) return;
-              handleMouseDownRotate(event);
-              state = STATE.ROTATE;
-            }
-            break;
-          case MOUSE.PAN:
-            if (event.ctrlKey || event.metaKey || event.shiftKey) {
-              if (scope.enableRotate === false) return;
-              handleMouseDownRotate(event);
-              state = STATE.ROTATE;
-            } else {
-              if (scope.enablePan === false) return;
-              handleMouseDownPan(event);
-              state = STATE.PAN;
-            }
-            break;
-          default:
-            state = STATE.NONE;
-        }
-        if (state !== STATE.NONE) {
-          scope.dispatchEvent(_startEvent);
+      if (this.options.camera.position) {
+        if (isVector3(this.options.camera.position)) {
+          this.camera.position.set(this.options.camera.position.x, this.options.camera.position.y, this.options.camera.position.z);
+        } else if (isTripleArray(this.options.camera.position)) {
+          this.camera.position.set(this.options.camera.position[0], this.options.camera.position[1], this.options.camera.position[2]);
         }
       }
-      function onMouseMove(event) {
-        if (scope.enabled === false) return;
-        switch (state) {
-          case STATE.ROTATE:
-            if (scope.enableRotate === false) return;
-            handleMouseMoveRotate(event);
-            break;
-          case STATE.DOLLY:
-            if (scope.enableZoom === false) return;
-            handleMouseMoveDolly(event);
-            break;
-          case STATE.PAN:
-            if (scope.enablePan === false) return;
-            handleMouseMovePan(event);
-            break;
+      if (this.options.camera.lookingAt) {
+        if (isVector3(this.options.camera.lookingAt)) {
+          this.camera.lookAt(this.options.camera.lookingAt);
+        } else if (isTripleArray(this.options.camera.lookingAt)) {
+          this.camera.lookAt(this.options.camera.lookingAt[0], this.options.camera.lookingAt[1], this.options.camera.lookingAt[2]);
         }
       }
-      function onMouseUp(event) {
-        handleMouseUp(event);
-        scope.dispatchEvent(_endEvent);
-        state = STATE.NONE;
+      if (this.options.render.autoResize && !this._resizeListener) {
+        this._resizeListener = () => {
+          this.resize(this.viewWidth, this.viewHeight);
+        };
+        window.addEventListener("resize", this._resizeListener);
       }
-      function onMouseWheel(event) {
-        if (scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE) return;
-        event.preventDefault();
-        scope.dispatchEvent(_startEvent);
-        handleMouseWheel(event);
-        scope.dispatchEvent(_endEvent);
+    }
+    get element() {
+      return this._element;
+    }
+    appendTo(element) {
+      if (this._disposed) return;
+      this._element = element;
+      this._element.appendChild(this.renderer.domElement);
+      if (this.viewWidth == 0) {
+        console.warn("0 element width");
       }
-      function onKeyDown(event) {
-        if (scope.enabled === false || scope.enablePan === false) return;
-        handleKeyDown(event);
+      if (this.viewHeight == 0) {
+        console.warn("0 element height");
+      }
+      this.resize(this.viewWidth, this.viewHeight);
+    }
+    /**
+     * Redraws when the dispatcher emits the selected event. Registering the same pair twice has no effect.
+     * The renderer removes its listener on disposal; the caller retains ownership of the dispatcher.
+     */
+    registerEventDispatcher(dispatcher, changeEvent2 = "change") {
+      if (this._disposed) return;
+      let events = this._eventDispatchers.get(dispatcher);
+      if (!events) {
+        events = /* @__PURE__ */ new Set();
+        this._eventDispatchers.set(dispatcher, events);
+      }
+      if (events.has(changeEvent2)) return;
+      events.add(changeEvent2);
+      dispatcher.addEventListener(changeEvent2, this._changeListener);
+    }
+    resize(width, height) {
+      if (this._disposed) return;
+      if (isPerspectiveCamera(this.camera)) {
+        this.camera.aspect = width / height;
+        this.camera.updateProjectionMatrix();
+      } else if (isOrthographicCamera(this.camera)) {
+        this.camera.left = width / -2;
+        this.camera.right = width / 2;
+        this.camera.top = height / 2;
+        this.camera.bottom = height / -2;
+        this.camera.updateProjectionMatrix();
+      }
+      this.renderer.setSize(width, height);
+      this.composer.setSize(width, height);
+      this._dirty = true;
+    }
+    //<editor-fold desc="RENDER">
+    get dirty() {
+      return this._dirty || this.scene.dirty;
+    }
+    set dirty(dirty) {
+      this._dirty = dirty;
+      this.scene.dirty = dirty;
+    }
+    start() {
+      if (this._disposed) return;
+      this.stop();
+      this.renderer.setAnimationLoop(this._animationLoop);
+    }
+    stop() {
+      if (this._disposed) return;
+      this.renderer.setAnimationLoop(null);
+      if (this._animationTimer)
+        clearTimeout(this._animationTimer);
+      this._animationTimer = void 0;
+      if (this._animationFrame)
+        cancelAnimationFrame(this._animationFrame);
+      this._animationFrame = void 0;
+    }
+    /**
+     * Stops rendering and releases owned resources. Repeated calls have no effect, and a disposed
+     * renderer cannot be restarted. Scene objects are detached; shared assets and caller-owned
+     * controls must be managed by their owners.
+     */
+    dispose() {
+      if (this._disposed) return;
+      this.stop();
+      this._disposed = true;
+      if (this._resizeListener) {
+        window.removeEventListener("resize", this._resizeListener);
+        this._resizeListener = void 0;
+      }
+      for (const [dispatcher, events] of this._eventDispatchers) {
+        for (const event of events) {
+          dispatcher.removeEventListener(event, this._changeListener);
+        }
+      }
+      this._eventDispatchers.clear();
+      this._stats?.dom.remove();
+      this._stats = void 0;
+      this.renderer.domElement.remove();
+      this._element = void 0;
+      if (this._controls) {
+        const controls = this._controls;
+        this._controls = void 0;
+        controls.enabled = false;
+        controls.dispose();
+      }
+      this.scene.clear();
+      for (const helper of this._debugHelpers) {
+        helper.geometry.dispose();
+        const materials = Array.isArray(helper.material) ? helper.material : [helper.material];
+        for (const material of materials) {
+          material.dispose();
+        }
+      }
+      this._debugHelpers.length = 0;
+      this.composer.dispose();
+      this.renderer.dispose();
+      this.renderer.forceContextLoss();
+    }
+    animate(t5) {
+      if (this._disposed) return;
+      if (this._stats) {
+        this._stats.begin();
+      }
+      if (this._controls?.enabled) {
+        this._controls.update();
+      }
+      if (this._disposed) return;
+      if (this.dirty || this.options.render.renderAlways) {
+        if (this.options.composer.enabled) {
+          this.composer.render();
+        } else {
+          this.renderer.render(this.scene, this.camera);
+        }
+      }
+      this.dirty = false;
+      if (this._stats) {
+        this._stats.end();
+      }
+    }
+    //</editor-fold>
+    toImage() {
+      return this.renderer.domElement.toDataURL();
+    }
+    ///
+    get attachedToBody() {
+      return this.element === document.body;
+    }
+    get viewWidth() {
+      return this.attachedToBody ? window.innerWidth : this.element?.offsetWidth || 0;
+    }
+    get viewHeight() {
+      return this.attachedToBody ? window.innerHeight : this.element?.offsetHeight || 0;
+    }
+    get scene() {
+      return this._scene;
+    }
+    get camera() {
+      return this._camera;
+    }
+    get renderer() {
+      return this._renderer;
+    }
+    get composer() {
+      return this._composer;
+    }
+    /** Renderer-owned controls, or undefined when disabled at construction or after disposal. */
+    get controls() {
+      return this._controls;
+    }
+    ///
+  };
+  _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge10.default)({}, {
+    camera: {
+      type: "perspective",
+      near: 1,
+      far: 5e3,
+      perspective: {
+        aspect: void 0,
+        fov: 50
+      },
+      orthographic: {
+        left: void 0,
+        right: void 0,
+        top: void 0,
+        bottom: void 0
+      },
+      position: new Vector3(50, 50, 50),
+      lookingAt: new Vector3(0, 0, 0)
+    },
+    render: {
+      fpsLimit: 60,
+      stats: false,
+      antialias: true,
+      shade: true,
+      autoResize: true,
+      renderAlways: false
+    },
+    composer: {
+      enabled: true
+    },
+    controls: {
+      enabled: false
+    },
+    debug: {
+      grid: false,
+      axes: false
+    }
+  });
+  var Renderer = _Renderer;
+
+  // src/renderer/SceneObjectOptions.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
+  // src/skin/index.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
+  // src/skin/Skins.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  var Skins = class {
+    //<editor-fold desc="Skins">
+    static async fromUuidOrUsername(uuidOrUsername) {
+      if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
+        return this.fromUuid(uuidOrUsername);
       }
-      function onTouchStart(event) {
-        trackPointer(event);
-        switch (pointers.length) {
-          case 1:
-            switch (scope.touches.ONE) {
-              case TOUCH.ROTATE:
-                if (scope.enableRotate === false) return;
-                handleTouchStartRotate();
-                state = STATE.TOUCH_ROTATE;
-                break;
-              case TOUCH.PAN:
-                if (scope.enablePan === false) return;
-                handleTouchStartPan();
-                state = STATE.TOUCH_PAN;
-                break;
-              default:
-                state = STATE.NONE;
-            }
-            break;
-          case 2:
-            switch (scope.touches.TWO) {
-              case TOUCH.DOLLY_PAN:
-                if (scope.enableZoom === false && scope.enablePan === false) return;
-                handleTouchStartDollyPan();
-                state = STATE.TOUCH_DOLLY_PAN;
-                break;
-              case TOUCH.DOLLY_ROTATE:
-                if (scope.enableZoom === false && scope.enableRotate === false) return;
-                handleTouchStartDollyRotate();
-                state = STATE.TOUCH_DOLLY_ROTATE;
-                break;
-              default:
-                state = STATE.NONE;
-            }
-            break;
-          default:
-            state = STATE.NONE;
+      return this.fromUsername(uuidOrUsername);
+    }
+    static async fromUuid(uuid) {
+      return this.getSkinProxySkinUrl(uuid);
+    }
+    static async fromUsername(username) {
+      return this.usernameToUuid(username).then((uuid) => {
+        if (uuid) {
+          return this.fromUuid(uuid);
         }
-        if (state !== STATE.NONE) {
-          scope.dispatchEvent(_startEvent);
+        return void 0;
+      });
+    }
+    static async fromMineSkin(mineskinId) {
+      return this.getMineSkin(mineskinId).then((mineskin) => {
+        if (mineskin) {
+          return mineskin["data"]["texture"]["value"]["urls"]["skins"];
         }
+        return void 0;
+      });
+    }
+    //</editor-fold>
+    //<editor-fold desc="Capes">
+    static async capeFromUuidOrUsername(uuidOrUsername) {
+      if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
+        return this.capeFromUuid(uuidOrUsername);
       }
-      function onTouchMove(event) {
-        trackPointer(event);
-        switch (state) {
-          case STATE.TOUCH_ROTATE:
-            if (scope.enableRotate === false) return;
-            handleTouchMoveRotate(event);
-            scope.update();
-            break;
-          case STATE.TOUCH_PAN:
-            if (scope.enablePan === false) return;
-            handleTouchMovePan(event);
-            scope.update();
-            break;
-          case STATE.TOUCH_DOLLY_PAN:
-            if (scope.enableZoom === false && scope.enablePan === false) return;
-            handleTouchMoveDollyPan(event);
-            scope.update();
-            break;
-          case STATE.TOUCH_DOLLY_ROTATE:
-            if (scope.enableZoom === false && scope.enableRotate === false) return;
-            handleTouchMoveDollyRotate(event);
-            scope.update();
-            break;
-          default:
-            state = STATE.NONE;
+      return this.capeFromUsername(uuidOrUsername);
+    }
+    static async capeFromUuid(uuid) {
+      return this.getSkinProxyCapeUrl(uuid);
+    }
+    static async capeFromUsername(username) {
+      return this.usernameToUuid(username).then((uuid) => {
+        if (uuid) {
+          return this.capeFromUuid(uuid);
         }
-      }
-      function onTouchEnd(event) {
-        handleTouchEnd(event);
-        scope.dispatchEvent(_endEvent);
-        state = STATE.NONE;
-      }
-      function onContextMenu(event) {
-        if (scope.enabled === false) return;
-        event.preventDefault();
-      }
-      function addPointer(event) {
-        pointers.push(event);
-      }
-      function removePointer(event) {
-        delete pointerPositions[event.pointerId];
-        for (let i4 = 0; i4 < pointers.length; i4++) {
-          if (pointers[i4].pointerId == event.pointerId) {
-            pointers.splice(i4, 1);
-            return;
-          }
+        return void 0;
+      });
+    }
+    static async capeFromCapesDev(uuid, capeType = "minecraft") {
+      return this.getCapesDev(uuid, capeType).then((cape) => {
+        if (cape) {
+          return cape?.stillImageUrl;
         }
-      }
-      function trackPointer(event) {
-        let position = pointerPositions[event.pointerId];
-        if (position === void 0) {
-          position = new Vector2();
-          pointerPositions[event.pointerId] = position;
+        return void 0;
+      });
+    }
+    //</editor-fold>
+    //<editor-fold desc="Helpers">
+    static async usernameToUuid(username) {
+      return this.usernameToUuidSkinProxy(username);
+    }
+    static async usernameToUuidSkinProxy(username) {
+      return Requests.genericRequest({
+        baseURL: "https://minecraft-skin-proxy.inventive.workers.dev",
+        url: "/uuid/" + username
+      }).then((res) => {
+        if (res.status === 200) {
+          return res.data["id"];
         }
-        position.set(event.pageX, event.pageY);
-      }
-      function getSecondPointerPosition(event) {
-        const pointer = event.pointerId === pointers[0].pointerId ? pointers[1] : pointers[0];
-        return pointerPositions[pointer.pointerId];
-      }
-      scope.domElement.addEventListener("contextmenu", onContextMenu);
-      scope.domElement.addEventListener("pointerdown", onPointerDown);
-      scope.domElement.addEventListener("pointercancel", onPointerCancel);
-      scope.domElement.addEventListener("wheel", onMouseWheel, { passive: false });
-      this.update();
+        return void 0;
+      }).catch((err) => {
+        console.warn(err);
+        return void 0;
+      });
     }
-  };
-  var MapControls = class extends OrbitControls {
-    constructor(object, domElement) {
-      super(object, domElement);
-      this.screenSpacePanning = false;
-      this.mouseButtons.LEFT = MOUSE.PAN;
-      this.mouseButtons.RIGHT = MOUSE.ROTATE;
-      this.touches.ONE = TOUCH.PAN;
-      this.touches.TWO = TOUCH.DOLLY_ROTATE;
+    static async usernameToUuidMineTools(username) {
+      return Requests.genericRequest({
+        baseURL: "https://api.minetools.eu",
+        url: "/uuid/" + username
+      }).then((res) => {
+        if (res.status === 200) {
+          return res.data["id"];
+        }
+        return void 0;
+      }).catch((err) => {
+        console.warn(err);
+        return void 0;
+      });
+    }
+    static async getProfileFromMinetools(uuid) {
+      return Requests.genericRequest({
+        baseURL: "https://api.minetools.eu",
+        url: "/profile/" + uuid
+      }).then((res) => {
+        if (res.status === 200) {
+          return res.data;
+        }
+      });
+    }
+    static async getMineSkin(mineskinId) {
+      return Requests.genericRequest({
+        baseURL: "https://api.mineskin.org",
+        url: "/get/uuid/" + mineskinId
+      }).then((res) => {
+        if (res.status === 200) {
+          return res.data;
+        }
+        return void 0;
+      }).catch((err) => {
+        console.warn(err);
+        return void 0;
+      });
+    }
+    static async getCapesDev(uuid, type = "all") {
+      return Requests.genericRequest({
+        baseURL: "https://api.capes.dev",
+        url: "/load/" + uuid + "/" + type
+      }).then((res) => {
+        if (res.status === 200) {
+          return res.data;
+        }
+        return void 0;
+      }).catch((err) => {
+        console.warn(err);
+        return void 0;
+      });
+    }
+    static getCrafatarSkinUrl(uuid) {
+      return "https://crafatar.com/skins/" + uuid;
+    }
+    static getCrafatarCapeUrl(uuid) {
+      return "https://crafatar.com/capes/" + uuid;
+    }
+    static getMcHeadsSkinUrl(uuid) {
+      return "https://mc-heads.net/skin/" + uuid;
+    }
+    static getMineSkinPlayerSkinUrl(uuid) {
+      return "https://mineskin.org/skin/player/" + uuid;
+    }
+    static getSkinProxySkinUrl(uuid) {
+      return "https://minecraft-skin-proxy.inventive.workers.dev/skin/" + uuid;
+    }
+    static getSkinProxyCapeUrl(uuid) {
+      return "https://minecraft-skin-proxy.inventive.workers.dev/cape/" + uuid;
     }
+    //</editor-fold>
   };
 
+  // src/skin/scene/index.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
+  // src/texture/index.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
+  // src/three/index.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
   // src/world/index.ts
   init_dirname();
   init_buffer2();