minerender 2.1.0-alpha.70 → 2.1.0-alpha.74

package/dist/bundle.js

@@ -498,7 +498,7 @@ var MineRender = (() => {
     Buffer2.isBuffer = function isBuffer2(b4) {
       return b4 != null && b4._isBuffer === true && b4 !== Buffer2.prototype;
     };
-    Buffer2.compare = function compare(a4, b4) {
+    Buffer2.compare = function compare2(a4, b4) {
       if (isInstance(a4, Uint8Array)) a4 = Buffer2.from(a4, a4.offset, a4.byteLength);
       if (isInstance(b4, Uint8Array)) b4 = Buffer2.from(b4, b4.offset, b4.byteLength);
       if (!Buffer2.isBuffer(a4) || !Buffer2.isBuffer(b4)) {
@@ -720,7 +720,7 @@ var MineRender = (() => {
     if (customInspectSymbol) {
       Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
     }
-    Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+    Buffer2.prototype.compare = function compare2(target, start, end, thisStart, thisEnd) {
       if (isInstance(target, Uint8Array)) {
         target = Buffer2.from(target, target.offset, target.byteLength);
       }
@@ -4473,7 +4473,7 @@ var MineRender = (() => {
     }
     return true;
   }
-  function checkIntersection$1(object, material, raycaster, ray, pA, pB, pC, point) {
+  function checkIntersection$1(object2, material, raycaster, ray, pA, pB, pC, point) {
     let intersect2;
     if (material.side === BackSide) {
       intersect2 = ray.intersectTriangle(pC, pB, pA, true, point);
@@ -4482,20 +4482,20 @@ var MineRender = (() => {
     }
     if (intersect2 === null) return null;
     _intersectionPointWorld.copy(point);
-    _intersectionPointWorld.applyMatrix4(object.matrixWorld);
+    _intersectionPointWorld.applyMatrix4(object2.matrixWorld);
     const distance = raycaster.ray.origin.distanceTo(_intersectionPointWorld);
     if (distance < raycaster.near || distance > raycaster.far) return null;
     return {
       distance,
       point: _intersectionPointWorld.clone(),
-      object
+      object: object2
     };
   }
-  function checkGeometryIntersection(object, material, raycaster, ray, uv, uv1, normal, a4, b4, c4) {
-    object.getVertexPosition(a4, _vA);
-    object.getVertexPosition(b4, _vB);
-    object.getVertexPosition(c4, _vC);
-    const intersection = checkIntersection$1(object, material, raycaster, ray, _vA, _vB, _vC, _intersectionPoint);
+  function checkGeometryIntersection(object2, material, raycaster, ray, uv, uv1, normal, a4, b4, c4) {
+    object2.getVertexPosition(a4, _vA);
+    object2.getVertexPosition(b4, _vB);
+    object2.getVertexPosition(c4, _vC);
+    const intersection = checkIntersection$1(object2, material, raycaster, ray, _vA, _vB, _vC, _intersectionPoint);
     if (intersection) {
       const barycoord = new Vector3();
       Triangle.getBarycoord(_intersectionPoint, _vA, _vB, _vC, barycoord);
@@ -4524,25 +4524,25 @@ var MineRender = (() => {
     }
     return intersection;
   }
-  function checkIntersection(object, raycaster, ray, thresholdSq, a4, b4, i4) {
-    const positionAttribute = object.geometry.attributes.position;
+  function checkIntersection(object2, raycaster, ray, thresholdSq, a4, b4, i4) {
+    const positionAttribute = object2.geometry.attributes.position;
     _vStart.fromBufferAttribute(positionAttribute, a4);
     _vEnd.fromBufferAttribute(positionAttribute, b4);
     const distSq = ray.distanceSqToSegment(_vStart, _vEnd, _intersectPointOnRay, _intersectPointOnSegment);
     if (distSq > thresholdSq) return;
-    _intersectPointOnRay.applyMatrix4(object.matrixWorld);
+    _intersectPointOnRay.applyMatrix4(object2.matrixWorld);
     const distance = raycaster.ray.origin.distanceTo(_intersectPointOnRay);
     if (distance < raycaster.near || distance > raycaster.far) return;
     return {
       distance,
       // What do we want? intersection point on the ray or on the segment??
       // point: raycaster.ray.at( distance ),
-      point: _intersectPointOnSegment.clone().applyMatrix4(object.matrixWorld),
+      point: _intersectPointOnSegment.clone().applyMatrix4(object2.matrixWorld),
       index: i4,
       face: null,
       faceIndex: null,
       barycoord: null,
-      object
+      object: object2
     };
   }
   function cloneUniforms(src) {
@@ -4642,22 +4642,22 @@ var MineRender = (() => {
   function ascSort(a4, b4) {
     return a4.distance - b4.distance;
   }
-  function intersect(object, raycaster, intersects, recursive) {
+  function intersect(object2, raycaster, intersects, recursive) {
     let propagate = true;
-    if (object.layers.test(raycaster.layers)) {
-      const result = object.raycast(raycaster, intersects);
+    if (object2.layers.test(raycaster.layers)) {
+      const result = object2.raycast(raycaster, intersects);
       if (result === false) propagate = false;
     }
     if (propagate === true && recursive === true) {
-      const children = object.children;
+      const children = object2.children;
       for (let i4 = 0, l4 = children.length; i4 < l4; i4++) {
         intersect(children[i4], raycaster, intersects, true);
       }
     }
   }
-  function getByteLength(width, height, format2, type) {
+  function getByteLength(width, height, format3, type) {
     const typeByteLength = getTextureTypeByteLength(type);
-    switch (format2) {
+    switch (format3) {
       // https://registry.khronos.org/OpenGL-Refpages/es3.0/html/glTexImage2D.xhtml
       case AlphaFormat:
         return width * height;
@@ -4742,7 +4742,7 @@ var MineRender = (() => {
         return Math.ceil(width / 4) * Math.ceil(height / 4) * 16;
     }
     throw new Error(
-      `Unable to determine texture byte length for ${format2} format.`
+      `Unable to determine texture byte length for ${format3} format.`
     );
   }
   function getTextureTypeByteLength(type) {
@@ -8076,7 +8076,7 @@ var MineRender = (() => {
          * @param {number} [anisotropy=Texture.DEFAULT_ANISOTROPY] - The anisotropy value.
          * @param {string} [colorSpace=NoColorSpace] - The color space.
          */
-        constructor(image = _Texture.DEFAULT_IMAGE, mapping = _Texture.DEFAULT_MAPPING, wrapS = ClampToEdgeWrapping, wrapT = ClampToEdgeWrapping, magFilter = LinearFilter, minFilter = LinearMipmapLinearFilter, format2 = RGBAFormat, type = UnsignedByteType, anisotropy = _Texture.DEFAULT_ANISOTROPY, colorSpace = NoColorSpace) {
+        constructor(image = _Texture.DEFAULT_IMAGE, mapping = _Texture.DEFAULT_MAPPING, wrapS = ClampToEdgeWrapping, wrapT = ClampToEdgeWrapping, magFilter = LinearFilter, minFilter = LinearMipmapLinearFilter, format3 = RGBAFormat, type = UnsignedByteType, anisotropy = _Texture.DEFAULT_ANISOTROPY, colorSpace = NoColorSpace) {
           super();
           this.isTexture = true;
           Object.defineProperty(this, "id", { value: _textureId++ });
@@ -8091,7 +8091,7 @@ var MineRender = (() => {
           this.magFilter = magFilter;
           this.minFilter = minFilter;
           this.anisotropy = anisotropy;
-          this.format = format2;
+          this.format = format3;
           this.internalFormat = null;
           this.type = type;
           this.offset = new Vector2(0, 0);
@@ -11302,27 +11302,27 @@ var MineRender = (() => {
          * @param {Object3D} object - The 3D object to add.
          * @return {Object3D} A reference to this instance.
          */
-        add(object) {
+        add(object2) {
           if (arguments.length > 1) {
             for (let i4 = 0; i4 < arguments.length; i4++) {
               this.add(arguments[i4]);
             }
             return this;
           }
-          if (object === this) {
-            error("Object3D.add: object can't be added as a child of itself.", object);
+          if (object2 === this) {
+            error("Object3D.add: object can't be added as a child of itself.", object2);
             return this;
           }
-          if (object && object.isObject3D) {
-            object.removeFromParent();
-            object.parent = this;
-            this.children.push(object);
-            object.dispatchEvent(_addedEvent);
-            _childaddedEvent.child = object;
+          if (object2 && object2.isObject3D) {
+            object2.removeFromParent();
+            object2.parent = this;
+            this.children.push(object2);
+            object2.dispatchEvent(_addedEvent);
+            _childaddedEvent.child = object2;
             this.dispatchEvent(_childaddedEvent);
             _childaddedEvent.child = null;
           } else {
-            error("Object3D.add: object not an instance of THREE.Object3D.", object);
+            error("Object3D.add: object not an instance of THREE.Object3D.", object2);
           }
           return this;
         }
@@ -11335,19 +11335,19 @@ var MineRender = (() => {
          * @param {Object3D} object - The 3D object to remove.
          * @return {Object3D} A reference to this instance.
          */
-        remove(object) {
+        remove(object2) {
           if (arguments.length > 1) {
             for (let i4 = 0; i4 < arguments.length; i4++) {
               this.remove(arguments[i4]);
             }
             return this;
           }
-          const index = this.children.indexOf(object);
+          const index = this.children.indexOf(object2);
           if (index !== -1) {
-            object.parent = null;
+            object2.parent = null;
             this.children.splice(index, 1);
-            object.dispatchEvent(_removedEvent);
-            _childremovedEvent.child = object;
+            object2.dispatchEvent(_removedEvent);
+            _childremovedEvent.child = object2;
             this.dispatchEvent(_childremovedEvent);
             _childremovedEvent.child = null;
           }
@@ -11386,20 +11386,20 @@ var MineRender = (() => {
          * @param {Object3D} object - The 3D object to attach.
          * @return {Object3D} A reference to this instance.
          */
-        attach(object) {
+        attach(object2) {
           this.updateWorldMatrix(true, false);
           _m1$1.copy(this.matrixWorld).invert();
-          if (object.parent !== null) {
-            object.parent.updateWorldMatrix(true, false);
-            _m1$1.multiply(object.parent.matrixWorld);
-          }
-          object.applyMatrix4(_m1$1);
-          object.removeFromParent();
-          object.parent = this;
-          this.children.push(object);
-          object.updateWorldMatrix(false, true);
-          object.dispatchEvent(_addedEvent);
-          _childaddedEvent.child = object;
+          if (object2.parent !== null) {
+            object2.parent.updateWorldMatrix(true, false);
+            _m1$1.multiply(object2.parent.matrixWorld);
+          }
+          object2.applyMatrix4(_m1$1);
+          object2.removeFromParent();
+          object2.parent = this;
+          this.children.push(object2);
+          object2.updateWorldMatrix(false, true);
+          object2.dispatchEvent(_addedEvent);
+          _childaddedEvent.child = object2;
           this.dispatchEvent(_childaddedEvent);
           _childaddedEvent.child = null;
           return this;
@@ -11436,9 +11436,9 @@ var MineRender = (() => {
           if (this[name2] === value) return this;
           for (let i4 = 0, l4 = this.children.length; i4 < l4; i4++) {
             const child = this.children[i4];
-            const object = child.getObjectByProperty(name2, value);
-            if (object !== void 0) {
-              return object;
+            const object2 = child.getObjectByProperty(name2, value);
+            if (object2 !== void 0) {
+              return object2;
             }
           }
           return void 0;
@@ -11676,61 +11676,61 @@ var MineRender = (() => {
               generator: "Object3D.toJSON"
             };
           }
-          const object = {};
-          object.uuid = this.uuid;
-          object.type = this.type;
-          object.name = this.name;
-          object.castShadow = this.castShadow;
-          object.receiveShadow = this.receiveShadow;
-          object.visible = this.visible;
-          object.frustumCulled = this.frustumCulled;
-          object.renderOrder = this.renderOrder;
-          object.static = this.static;
-          object.matrixAutoUpdate = this.matrixAutoUpdate;
-          if (Object.keys(this.userData).length > 0) object.userData = this.userData;
-          object.layers = this.layers.mask;
-          object.matrix = this.matrix.toArray();
-          object.up = this.up.toArray();
-          if (this.pivot !== null) object.pivot = this.pivot.toArray();
-          if (this.morphTargetDictionary !== void 0) object.morphTargetDictionary = Object.assign({}, this.morphTargetDictionary);
-          if (this.morphTargetInfluences !== void 0) object.morphTargetInfluences = this.morphTargetInfluences.slice();
+          const object2 = {};
+          object2.uuid = this.uuid;
+          object2.type = this.type;
+          object2.name = this.name;
+          object2.castShadow = this.castShadow;
+          object2.receiveShadow = this.receiveShadow;
+          object2.visible = this.visible;
+          object2.frustumCulled = this.frustumCulled;
+          object2.renderOrder = this.renderOrder;
+          object2.static = this.static;
+          object2.matrixAutoUpdate = this.matrixAutoUpdate;
+          if (Object.keys(this.userData).length > 0) object2.userData = this.userData;
+          object2.layers = this.layers.mask;
+          object2.matrix = this.matrix.toArray();
+          object2.up = this.up.toArray();
+          if (this.pivot !== null) object2.pivot = this.pivot.toArray();
+          if (this.morphTargetDictionary !== void 0) object2.morphTargetDictionary = Object.assign({}, this.morphTargetDictionary);
+          if (this.morphTargetInfluences !== void 0) object2.morphTargetInfluences = this.morphTargetInfluences.slice();
           if (this.isInstancedMesh) {
-            object.type = "InstancedMesh";
-            object.count = this.count;
-            object.instanceMatrix = this.instanceMatrix.toJSON();
-            if (this.instanceColor !== null) object.instanceColor = this.instanceColor.toJSON();
+            object2.type = "InstancedMesh";
+            object2.count = this.count;
+            object2.instanceMatrix = this.instanceMatrix.toJSON();
+            if (this.instanceColor !== null) object2.instanceColor = this.instanceColor.toJSON();
           }
           if (this.isBatchedMesh) {
-            object.type = "BatchedMesh";
-            object.perObjectFrustumCulled = this.perObjectFrustumCulled;
-            object.sortObjects = this.sortObjects;
-            object.drawRanges = this._drawRanges;
-            object.reservedRanges = this._reservedRanges;
-            object.geometryInfo = this._geometryInfo.map((info) => ({
+            object2.type = "BatchedMesh";
+            object2.perObjectFrustumCulled = this.perObjectFrustumCulled;
+            object2.sortObjects = this.sortObjects;
+            object2.drawRanges = this._drawRanges;
+            object2.reservedRanges = this._reservedRanges;
+            object2.geometryInfo = this._geometryInfo.map((info) => ({
               ...info,
               boundingBox: info.boundingBox ? info.boundingBox.toJSON() : void 0,
               boundingSphere: info.boundingSphere ? info.boundingSphere.toJSON() : void 0
             }));
-            object.instanceInfo = this._instanceInfo.map((info) => ({ ...info }));
-            object.availableInstanceIds = this._availableInstanceIds.slice();
-            object.availableGeometryIds = this._availableGeometryIds.slice();
-            object.nextIndexStart = this._nextIndexStart;
-            object.nextVertexStart = this._nextVertexStart;
-            object.geometryCount = this._geometryCount;
-            object.maxInstanceCount = this._maxInstanceCount;
-            object.maxVertexCount = this._maxVertexCount;
-            object.maxIndexCount = this._maxIndexCount;
-            object.geometryInitialized = this._geometryInitialized;
-            object.matricesTexture = this._matricesTexture.toJSON(meta);
-            object.indirectTexture = this._indirectTexture.toJSON(meta);
+            object2.instanceInfo = this._instanceInfo.map((info) => ({ ...info }));
+            object2.availableInstanceIds = this._availableInstanceIds.slice();
+            object2.availableGeometryIds = this._availableGeometryIds.slice();
+            object2.nextIndexStart = this._nextIndexStart;
+            object2.nextVertexStart = this._nextVertexStart;
+            object2.geometryCount = this._geometryCount;
+            object2.maxInstanceCount = this._maxInstanceCount;
+            object2.maxVertexCount = this._maxVertexCount;
+            object2.maxIndexCount = this._maxIndexCount;
+            object2.geometryInitialized = this._geometryInitialized;
+            object2.matricesTexture = this._matricesTexture.toJSON(meta);
+            object2.indirectTexture = this._indirectTexture.toJSON(meta);
             if (this._colorsTexture !== null) {
-              object.colorsTexture = this._colorsTexture.toJSON(meta);
+              object2.colorsTexture = this._colorsTexture.toJSON(meta);
             }
             if (this.boundingSphere !== null) {
-              object.boundingSphere = this.boundingSphere.toJSON();
+              object2.boundingSphere = this.boundingSphere.toJSON();
             }
             if (this.boundingBox !== null) {
-              object.boundingBox = this.boundingBox.toJSON();
+              object2.boundingBox = this.boundingBox.toJSON();
             }
           }
           function serialize(library, element) {
@@ -11742,16 +11742,16 @@ var MineRender = (() => {
           if (this.isScene) {
             if (this.background) {
               if (this.background.isColor) {
-                object.background = this.background.toJSON();
+                object2.background = this.background.toJSON();
               } else if (this.background.isTexture) {
-                object.background = this.background.toJSON(meta).uuid;
+                object2.background = this.background.toJSON(meta).uuid;
               }
             }
             if (this.environment && this.environment.isTexture && this.environment.isRenderTargetTexture !== true) {
-              object.environment = this.environment.toJSON(meta).uuid;
+              object2.environment = this.environment.toJSON(meta).uuid;
             }
           } else if (this.isMesh || this.isLine || this.isPoints) {
-            object.geometry = serialize(meta.geometries, this.geometry);
+            object2.geometry = serialize(meta.geometries, this.geometry);
             const parameters = this.geometry.parameters;
             if (parameters !== void 0 && parameters.shapes !== void 0) {
               const shapes = parameters.shapes;
@@ -11766,11 +11766,11 @@ var MineRender = (() => {
             }
           }
           if (this.isSkinnedMesh) {
-            object.bindMode = this.bindMode;
-            object.bindMatrix = this.bindMatrix.toArray();
+            object2.bindMode = this.bindMode;
+            object2.bindMatrix = this.bindMatrix.toArray();
             if (this.skeleton !== void 0) {
               serialize(meta.skeletons, this.skeleton);
-              object.skeleton = this.skeleton.uuid;
+              object2.skeleton = this.skeleton.uuid;
             }
           }
           if (this.material !== void 0) {
@@ -11779,22 +11779,22 @@ var MineRender = (() => {
               for (let i4 = 0, l4 = this.material.length; i4 < l4; i4++) {
                 uuids.push(serialize(meta.materials, this.material[i4]));
               }
-              object.material = uuids;
+              object2.material = uuids;
             } else {
-              object.material = serialize(meta.materials, this.material);
+              object2.material = serialize(meta.materials, this.material);
             }
           }
           if (this.children.length > 0) {
-            object.children = [];
+            object2.children = [];
             for (let i4 = 0; i4 < this.children.length; i4++) {
-              object.children.push(this.children[i4].toJSON(meta).object);
+              object2.children.push(this.children[i4].toJSON(meta).object);
             }
           }
           if (this.animations.length > 0) {
-            object.animations = [];
+            object2.animations = [];
             for (let i4 = 0; i4 < this.animations.length; i4++) {
               const animation = this.animations[i4];
-              object.animations.push(serialize(meta.animations, animation));
+              object2.animations.push(serialize(meta.animations, animation));
             }
           }
           if (isRootObject) {
@@ -11815,7 +11815,7 @@ var MineRender = (() => {
             if (animations.length > 0) output.animations = animations;
             if (nodes.length > 0) output.nodes = nodes;
           }
-          output.object = object;
+          output.object = object2;
           return output;
           function extractFromCache(cache) {
             const values = [];
@@ -13407,9 +13407,9 @@ var MineRender = (() => {
          * world-axis-aligned bounding box at the expense of more computation.
          * @return {Box3} A reference to this bounding box.
          */
-        setFromObject(object, precise = false) {
+        setFromObject(object2, precise = false) {
           this.makeEmpty();
-          return this.expandByObject(object, precise);
+          return this.expandByObject(object2, precise);
         }
         /**
          * Returns a new box with copied values from this instance.
@@ -13517,38 +13517,38 @@ var MineRender = (() => {
          * as little as necessary at the expense of more computation.
          * @return {Box3} A reference to this bounding box.
          */
-        expandByObject(object, precise = false) {
-          object.updateWorldMatrix(false, false);
-          const geometry = object.geometry;
+        expandByObject(object2, precise = false) {
+          object2.updateWorldMatrix(false, false);
+          const geometry = object2.geometry;
           if (geometry !== void 0) {
             const positionAttribute = geometry.getAttribute("position");
-            if (precise === true && positionAttribute !== void 0 && object.isInstancedMesh !== true) {
+            if (precise === true && positionAttribute !== void 0 && object2.isInstancedMesh !== true) {
               for (let i4 = 0, l4 = positionAttribute.count; i4 < l4; i4++) {
-                if (object.isMesh === true) {
-                  object.getVertexPosition(i4, _vector$b);
+                if (object2.isMesh === true) {
+                  object2.getVertexPosition(i4, _vector$b);
                 } else {
                   _vector$b.fromBufferAttribute(positionAttribute, i4);
                 }
-                _vector$b.applyMatrix4(object.matrixWorld);
+                _vector$b.applyMatrix4(object2.matrixWorld);
                 this.expandByPoint(_vector$b);
               }
             } else {
-              if (object.boundingBox !== void 0) {
-                if (object.boundingBox === null) {
-                  object.computeBoundingBox();
+              if (object2.boundingBox !== void 0) {
+                if (object2.boundingBox === null) {
+                  object2.computeBoundingBox();
                 }
-                _box$4.copy(object.boundingBox);
+                _box$4.copy(object2.boundingBox);
               } else {
                 if (geometry.boundingBox === null) {
                   geometry.computeBoundingBox();
                 }
                 _box$4.copy(geometry.boundingBox);
               }
-              _box$4.applyMatrix4(object.matrixWorld);
+              _box$4.applyMatrix4(object2.matrixWorld);
               this.union(_box$4);
             }
           }
-          const children = object.children;
+          const children = object2.children;
           for (let i4 = 0, l4 = children.length; i4 < l4; i4++) {
             this.expandByObject(children[i4], precise);
           }
@@ -17419,8 +17419,8 @@ var MineRender = (() => {
          * @param {number} [anisotropy=Texture.DEFAULT_ANISOTROPY] - The anisotropy value.
          * @param {string} [colorSpace=NoColorSpace] - The color space.
          */
-        constructor(data = null, width = 1, height = 1, format2, type, mapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, colorSpace) {
-          super(null, mapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy, colorSpace);
+        constructor(data = null, width = 1, height = 1, format3, type, mapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, colorSpace) {
+          super(null, mapping, wrapS, wrapT, magFilter, minFilter, format3, type, anisotropy, colorSpace);
           this.isDataTexture = true;
           this.image = { data, width, height };
           this.generateMipmaps = false;
@@ -17564,8 +17564,8 @@ var MineRender = (() => {
          * @param {number} index - The instance index.
          * @param {Mesh} object - The target object that is used to store the method's result.
          */
-        getMorphAt(index, object) {
-          const objectInfluences = object.morphTargetInfluences;
+        getMorphAt(index, object2) {
+          const objectInfluences = object2.morphTargetInfluences;
           const array = this.morphTexture.source.data.data;
           const len = objectInfluences.length + 1;
           const dataIndex = index * len + 1;
@@ -17633,8 +17633,8 @@ var MineRender = (() => {
          * of a single instance.
          * @return {InstancedMesh} A reference to this instanced mesh.
          */
-        setMorphAt(index, object) {
-          const objectInfluences = object.morphTargetInfluences;
+        setMorphAt(index, object2) {
+          const objectInfluences = object2.morphTargetInfluences;
           const len = objectInfluences.length + 1;
           if (this.morphTexture === null) {
             this.morphTexture = new DataTexture(new Float32Array(len * this.count), len, this.count, RedFormat, FloatType);
@@ -17757,14 +17757,14 @@ var MineRender = (() => {
          * @param {Object3D} object - The 3D object to test.
          * @return {boolean} Whether the 3D object's bounding sphere is intersecting this frustum or not.
          */
-        intersectsObject(object) {
-          if (object.boundingSphere !== void 0) {
-            if (object.boundingSphere === null) object.computeBoundingSphere();
-            _sphere$3.copy(object.boundingSphere).applyMatrix4(object.matrixWorld);
+        intersectsObject(object2) {
+          if (object2.boundingSphere !== void 0) {
+            if (object2.boundingSphere === null) object2.computeBoundingSphere();
+            _sphere$3.copy(object2.boundingSphere).applyMatrix4(object2.matrixWorld);
           } else {
-            const geometry = object.geometry;
+            const geometry = object2.geometry;
             if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
-            _sphere$3.copy(geometry.boundingSphere).applyMatrix4(object.matrixWorld);
+            _sphere$3.copy(geometry.boundingSphere).applyMatrix4(object2.matrixWorld);
           }
           return this.intersectsSphere(_sphere$3);
         }
@@ -18079,8 +18079,8 @@ var MineRender = (() => {
          * @param {number} [anisotropy=Texture.DEFAULT_ANISOTROPY] - The anisotropy value.
          * @param {string} [colorSpace=NoColorSpace] - The color space.
          */
-        constructor(mipmaps, width, height, format2, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, colorSpace) {
-          super(null, mapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy, colorSpace);
+        constructor(mipmaps, width, height, format3, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, colorSpace) {
+          super(null, mapping, wrapS, wrapT, magFilter, minFilter, format3, type, anisotropy, colorSpace);
           this.isCompressedTexture = true;
           this.image = { width, height };
           this.mipmaps = mipmaps;
@@ -18103,8 +18103,8 @@ var MineRender = (() => {
          * @param {number} [anisotropy=Texture.DEFAULT_ANISOTROPY] - The anisotropy value.
          * @param {string} [colorSpace=NoColorSpace] - The color space value.
          */
-        constructor(images = [], mapping = CubeReflectionMapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy, colorSpace) {
-          super(images, mapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy, colorSpace);
+        constructor(images = [], mapping = CubeReflectionMapping, wrapS, wrapT, magFilter, minFilter, format3, type, anisotropy, colorSpace) {
+          super(images, mapping, wrapS, wrapT, magFilter, minFilter, format3, type, anisotropy, colorSpace);
           this.isCubeTexture = true;
           this.flipY = false;
         }
@@ -18134,8 +18134,8 @@ var MineRender = (() => {
          * @param {number} [type=UnsignedByteType] - The texture type.
          * @param {number} [anisotropy=Texture.DEFAULT_ANISOTROPY] - The anisotropy value.
          */
-        constructor(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy) {
-          super(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy);
+        constructor(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format3, type, anisotropy) {
+          super(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format3, type, anisotropy);
           this.isCanvasTexture = true;
           this.needsUpdate = true;
         }
@@ -18156,12 +18156,12 @@ var MineRender = (() => {
          * @param {number} [format=DepthFormat] - The texture format.
          * @param {number} [depth=1] - The depth of the texture.
          */
-        constructor(width, height, type = UnsignedIntType, mapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, format2 = DepthFormat, depth = 1) {
-          if (format2 !== DepthFormat && format2 !== DepthStencilFormat) {
+        constructor(width, height, type = UnsignedIntType, mapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, format3 = DepthFormat, depth = 1) {
+          if (format3 !== DepthFormat && format3 !== DepthStencilFormat) {
             throw new Error("THREE.DepthTexture: format must be either THREE.DepthFormat or THREE.DepthStencilFormat");
           }
           const image = { width, height, depth };
-          super(image, mapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy);
+          super(image, mapping, wrapS, wrapT, magFilter, minFilter, format3, type, anisotropy);
           this.isDepthTexture = true;
           this.flipY = false;
           this.generateMipmaps = false;
@@ -18193,10 +18193,10 @@ var MineRender = (() => {
          * @param {number} [anisotropy=Texture.DEFAULT_ANISOTROPY] - The anisotropy value.
          * @param {number} [format=DepthFormat] - The texture format.
          */
-        constructor(size, type = UnsignedIntType, mapping = CubeReflectionMapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, format2 = DepthFormat) {
+        constructor(size, type = UnsignedIntType, mapping = CubeReflectionMapping, wrapS, wrapT, magFilter = NearestFilter, minFilter = NearestFilter, anisotropy, format3 = DepthFormat) {
           const image = { width: size, height: size, depth: 1 };
           const images = [image, image, image, image, image, image];
-          super(size, size, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format2);
+          super(size, size, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format3);
           this.image = images;
           this.isCubeDepthTexture = true;
           this.isCubeTexture = true;
@@ -20926,8 +20926,8 @@ var MineRender = (() => {
          * @param {Array<Raycaster~Intersection>} [intersects=[]] The target array that holds the result of the method.
          * @return {Array<Raycaster~Intersection>} An array holding the intersection points.
          */
-        intersectObject(object, recursive = true, intersects = []) {
-          intersect(object, this, intersects, recursive);
+        intersectObject(object2, recursive = true, intersects = []) {
+          intersect(object2, this, intersects, recursive);
           intersects.sort(ascSort);
           return intersects;
         }
@@ -21836,21 +21836,21 @@ var MineRender = (() => {
     const defaultState = createBindingState(null);
     let currentState = defaultState;
     let forceUpdate = false;
-    function setup(object, material, program, geometry, index) {
+    function setup(object2, material, program, geometry, index) {
       let updateBuffers = false;
-      const state = getBindingState(object, geometry, program, material);
+      const state = getBindingState(object2, geometry, program, material);
       if (currentState !== state) {
         currentState = state;
         bindVertexArrayObject(currentState.object);
       }
-      updateBuffers = needsUpdate(object, geometry, program, index);
-      if (updateBuffers) saveCache(object, geometry, program, index);
+      updateBuffers = needsUpdate(object2, geometry, program, index);
+      if (updateBuffers) saveCache(object2, geometry, program, index);
       if (index !== null) {
         attributes.update(index, gl.ELEMENT_ARRAY_BUFFER);
       }
       if (updateBuffers || forceUpdate) {
         forceUpdate = false;
-        setupVertexAttributes(object, material, program, geometry);
+        setupVertexAttributes(object2, material, program, geometry);
         if (index !== null) {
           gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, attributes.get(index).buffer);
         }
@@ -21865,14 +21865,14 @@ var MineRender = (() => {
     function deleteVertexArrayObject(vao) {
       return gl.deleteVertexArray(vao);
     }
-    function getBindingState(object, geometry, program, material) {
+    function getBindingState(object2, geometry, program, material) {
       const wireframe = material.wireframe === true;
       let objectMap = bindingStates[geometry.id];
       if (objectMap === void 0) {
         objectMap = {};
         bindingStates[geometry.id] = objectMap;
       }
-      const objectId = object.isInstancedMesh === true ? object.id : 0;
+      const objectId = object2.isInstancedMesh === true ? object2.id : 0;
       let programMap = objectMap[objectId];
       if (programMap === void 0) {
         programMap = {};
@@ -21912,7 +21912,7 @@ var MineRender = (() => {
         index: null
       };
     }
-    function needsUpdate(object, geometry, program, index) {
+    function needsUpdate(object2, geometry, program, index) {
       const cachedAttributes = currentState.attributes;
       const geometryAttributes = geometry.attributes;
       let attributesNum = 0;
@@ -21923,8 +21923,8 @@ var MineRender = (() => {
           const cachedAttribute = cachedAttributes[name2];
           let geometryAttribute = geometryAttributes[name2];
           if (geometryAttribute === void 0) {
-            if (name2 === "instanceMatrix" && object.instanceMatrix) geometryAttribute = object.instanceMatrix;
-            if (name2 === "instanceColor" && object.instanceColor) geometryAttribute = object.instanceColor;
+            if (name2 === "instanceMatrix" && object2.instanceMatrix) geometryAttribute = object2.instanceMatrix;
+            if (name2 === "instanceColor" && object2.instanceColor) geometryAttribute = object2.instanceColor;
           }
           if (cachedAttribute === void 0) return true;
           if (cachedAttribute.attribute !== geometryAttribute) return true;
@@ -21936,7 +21936,7 @@ var MineRender = (() => {
       if (currentState.index !== index) return true;
       return false;
     }
-    function saveCache(object, geometry, program, index) {
+    function saveCache(object2, geometry, program, index) {
       const cache = {};
       const attributes2 = geometry.attributes;
       let attributesNum = 0;
@@ -21946,8 +21946,8 @@ var MineRender = (() => {
         if (programAttribute.location >= 0) {
           let attribute = attributes2[name2];
           if (attribute === void 0) {
-            if (name2 === "instanceMatrix" && object.instanceMatrix) attribute = object.instanceMatrix;
-            if (name2 === "instanceColor" && object.instanceColor) attribute = object.instanceColor;
+            if (name2 === "instanceMatrix" && object2.instanceMatrix) attribute = object2.instanceMatrix;
+            if (name2 === "instanceColor" && object2.instanceColor) attribute = object2.instanceColor;
           }
           const data = {};
           data.attribute = attribute;
@@ -21995,14 +21995,14 @@ var MineRender = (() => {
         }
       }
     }
-    function vertexAttribPointer(index, size, type, normalized, stride, offset, integer) {
-      if (integer === true) {
+    function vertexAttribPointer(index, size, type, normalized, stride, offset, integer2) {
+      if (integer2 === true) {
         gl.vertexAttribIPointer(index, size, type, stride, offset);
       } else {
         gl.vertexAttribPointer(index, size, type, normalized, stride, offset);
       }
     }
-    function setupVertexAttributes(object, material, program, geometry) {
+    function setupVertexAttributes(object2, material, program, geometry) {
       initAttributes();
       const geometryAttributes = geometry.attributes;
       const programAttributes = program.getAttributes();
@@ -22012,8 +22012,8 @@ var MineRender = (() => {
         if (programAttribute.location >= 0) {
           let geometryAttribute = geometryAttributes[name2];
           if (geometryAttribute === void 0) {
-            if (name2 === "instanceMatrix" && object.instanceMatrix) geometryAttribute = object.instanceMatrix;
-            if (name2 === "instanceColor" && object.instanceColor) geometryAttribute = object.instanceColor;
+            if (name2 === "instanceMatrix" && object2.instanceMatrix) geometryAttribute = object2.instanceMatrix;
+            if (name2 === "instanceColor" && object2.instanceColor) geometryAttribute = object2.instanceColor;
           }
           if (geometryAttribute !== void 0) {
             const normalized = geometryAttribute.normalized;
@@ -22023,7 +22023,7 @@ var MineRender = (() => {
             const buffer2 = attribute.buffer;
             const type = attribute.type;
             const bytesPerElement = attribute.bytesPerElement;
-            const integer = type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType;
+            const integer2 = type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === IntType;
             if (geometryAttribute.isInterleavedBufferAttribute) {
               const data = geometryAttribute.data;
               const stride = data.stride;
@@ -22032,7 +22032,7 @@ var MineRender = (() => {
                 for (let i4 = 0; i4 < programAttribute.locationSize; i4++) {
                   enableAttributeAndDivisor(programAttribute.location + i4, data.meshPerAttribute);
                 }
-                if (object.isInstancedMesh !== true && geometry._maxInstanceCount === void 0) {
+                if (object2.isInstancedMesh !== true && geometry._maxInstanceCount === void 0) {
                   geometry._maxInstanceCount = data.meshPerAttribute * data.count;
                 }
               } else {
@@ -22049,7 +22049,7 @@ var MineRender = (() => {
                   normalized,
                   stride * bytesPerElement,
                   (offset + size / programAttribute.locationSize * i4) * bytesPerElement,
-                  integer
+                  integer2
                 );
               }
             } else {
@@ -22057,7 +22057,7 @@ var MineRender = (() => {
                 for (let i4 = 0; i4 < programAttribute.locationSize; i4++) {
                   enableAttributeAndDivisor(programAttribute.location + i4, geometryAttribute.meshPerAttribute);
                 }
-                if (object.isInstancedMesh !== true && geometry._maxInstanceCount === void 0) {
+                if (object2.isInstancedMesh !== true && geometry._maxInstanceCount === void 0) {
                   geometry._maxInstanceCount = geometryAttribute.meshPerAttribute * geometryAttribute.count;
                 }
               } else {
@@ -22074,7 +22074,7 @@ var MineRender = (() => {
                   normalized,
                   size * bytesPerElement,
                   size / programAttribute.locationSize * i4 * bytesPerElement,
-                  integer
+                  integer2
                 );
               }
             }
@@ -22149,10 +22149,10 @@ var MineRender = (() => {
         }
       }
     }
-    function releaseStatesOfObject(object) {
+    function releaseStatesOfObject(object2) {
       for (const geometryId in bindingStates) {
         const objectMap = bindingStates[geometryId];
-        const objectId = object.isInstancedMesh === true ? object.id : 0;
+        const objectId = object2.isInstancedMesh === true ? object2.id : 0;
         const programMap = objectMap[objectId];
         if (programMap === void 0) continue;
         for (const programId in programMap) {
@@ -22940,7 +22940,7 @@ var MineRender = (() => {
       }
       info.memory.geometries--;
     }
-    function get(object, geometry) {
+    function get(object2, geometry) {
       if (geometries[geometry.id] === true) return geometry;
       geometry.addEventListener("dispose", onGeometryDispose);
       geometries[geometry.id] = true;
@@ -23094,8 +23094,8 @@ var MineRender = (() => {
   function WebGLMorphtargets(gl, capabilities, textures) {
     const morphTextures = /* @__PURE__ */ new WeakMap();
     const morph = new Vector4();
-    function update(object, geometry, program) {
-      const objectInfluences = object.morphTargetInfluences;
+    function update(object2, geometry, program) {
+      const objectInfluences = object2.morphTargetInfluences;
       const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
       const morphTargetsCount = morphAttribute !== void 0 ? morphAttribute.length : 0;
       let entry = morphTextures.get(geometry);
@@ -23165,8 +23165,8 @@ var MineRender = (() => {
         morphTextures.set(geometry, entry);
         geometry.addEventListener("dispose", disposeTexture);
       }
-      if (object.isInstancedMesh === true && object.morphTexture !== null) {
-        program.getUniforms().setValue(gl, "morphTexture", object.morphTexture, textures);
+      if (object2.isInstancedMesh === true && object2.morphTexture !== null) {
+        program.getUniforms().setValue(gl, "morphTexture", object2.morphTexture, textures);
       } else {
         let morphInfluencesSum = 0;
         for (let i4 = 0; i4 < objectInfluences.length; i4++) {
@@ -23185,28 +23185,28 @@ var MineRender = (() => {
   }
   function WebGLObjects(gl, geometries, attributes, bindingStates, info) {
     let updateMap = /* @__PURE__ */ new WeakMap();
-    function update(object) {
+    function update(object2) {
       const frame = info.render.frame;
-      const geometry = object.geometry;
-      const buffergeometry = geometries.get(object, geometry);
+      const geometry = object2.geometry;
+      const buffergeometry = geometries.get(object2, geometry);
       if (updateMap.get(buffergeometry) !== frame) {
         geometries.update(buffergeometry);
         updateMap.set(buffergeometry, frame);
       }
-      if (object.isInstancedMesh) {
-        if (object.hasEventListener("dispose", onInstancedMeshDispose) === false) {
-          object.addEventListener("dispose", onInstancedMeshDispose);
+      if (object2.isInstancedMesh) {
+        if (object2.hasEventListener("dispose", onInstancedMeshDispose) === false) {
+          object2.addEventListener("dispose", onInstancedMeshDispose);
         }
-        if (updateMap.get(object) !== frame) {
-          attributes.update(object.instanceMatrix, gl.ARRAY_BUFFER);
-          if (object.instanceColor !== null) {
-            attributes.update(object.instanceColor, gl.ARRAY_BUFFER);
+        if (updateMap.get(object2) !== frame) {
+          attributes.update(object2.instanceMatrix, gl.ARRAY_BUFFER);
+          if (object2.instanceColor !== null) {
+            attributes.update(object2.instanceColor, gl.ARRAY_BUFFER);
           }
-          updateMap.set(object, frame);
+          updateMap.set(object2, frame);
         }
       }
-      if (object.isSkinnedMesh) {
-        const skeleton = object.skeleton;
+      if (object2.isSkinnedMesh) {
+        const skeleton = object2.skeleton;
         if (updateMap.get(skeleton) !== frame) {
           skeleton.update();
           updateMap.set(skeleton, frame);
@@ -24557,8 +24557,8 @@ var MineRender = (() => {
     this.fragmentShader = glFragmentShader;
     return this;
   }
-  function isPackedRGFormat(format2) {
-    return format2 === RGFormat || format2 === RG11_EAC_Format || format2 === RED_GREEN_RGTC2_Format;
+  function isPackedRGFormat(format3) {
+    return format3 === RGFormat || format3 === RG11_EAC_Format || format3 === RED_GREEN_RGTC2_Format;
   }
   function WebGLPrograms(renderer, environments, extensions, capabilities, bindingStates, clipping) {
     const _programLayers = new Layers();
@@ -24590,9 +24590,9 @@ var MineRender = (() => {
       if (value === 0) return "uv";
       return `uv${value}`;
     }
-    function getParameters(material, lights, shadows, scene, object, lightProbeGrids) {
+    function getParameters(material, lights, shadows, scene, object2, lightProbeGrids) {
       const fog = scene.fog;
-      const geometry = object.geometry;
+      const geometry = object2.geometry;
       const environment = material.isMeshStandardMaterial || material.isMeshLambertMaterial || material.isMeshPhongMaterial ? scene.environment : null;
       const usePMREM = material.isMeshStandardMaterial || material.isMeshLambertMaterial && !material.envMap || material.isMeshPhongMaterial && !material.envMap;
       const envMap = environments.get(material.envMap || environment, usePMREM);
@@ -24627,8 +24627,8 @@ var MineRender = (() => {
       }
       const currentRenderTarget = renderer.getRenderTarget();
       const reversedDepthBuffer = renderer.state.buffers.depth.getReversed();
-      const IS_INSTANCEDMESH = object.isInstancedMesh === true;
-      const IS_BATCHEDMESH = object.isBatchedMesh === true;
+      const IS_INSTANCEDMESH = object2.isInstancedMesh === true;
+      const IS_BATCHEDMESH = object2.isBatchedMesh === true;
       const HAS_MAP = !!material.map;
       const HAS_MATCAP = !!material.matcap;
       const HAS_ENVMAP = !!envMap;
@@ -24684,10 +24684,10 @@ var MineRender = (() => {
         glslVersion: material.glslVersion,
         precision,
         batching: IS_BATCHEDMESH,
-        batchingColor: IS_BATCHEDMESH && object._colorsTexture !== null,
+        batchingColor: IS_BATCHEDMESH && object2._colorsTexture !== null,
         instancing: IS_INSTANCEDMESH,
-        instancingColor: IS_INSTANCEDMESH && object.instanceColor !== null,
-        instancingMorph: IS_INSTANCEDMESH && object.morphTexture !== null,
+        instancingColor: IS_INSTANCEDMESH && object2.instanceColor !== null,
+        instancingMorph: IS_INSTANCEDMESH && object2.morphTexture !== null,
         outputColorSpace: currentRenderTarget === null ? renderer.outputColorSpace : currentRenderTarget.isXRRenderTarget === true ? currentRenderTarget.texture.colorSpace : ColorManagement.workingColorSpace,
         alphaToCoverage: !!material.alphaToCoverage,
         map: HAS_MAP,
@@ -24761,7 +24761,7 @@ var MineRender = (() => {
         vertexNormals: !!geometry.attributes.normal,
         vertexColors: material.vertexColors,
         vertexAlphas: material.vertexColors === true && !!geometry.attributes.color && geometry.attributes.color.itemSize === 4,
-        pointsUvs: object.isPoints === true && !!geometry.attributes.uv && (HAS_MAP || HAS_ALPHAMAP),
+        pointsUvs: object2.isPoints === true && !!geometry.attributes.uv && (HAS_MAP || HAS_ALPHAMAP),
         fog: !!fog,
         useFog: material.fog === true,
         fogExp2: !!fog && fog.isFogExp2,
@@ -24769,7 +24769,7 @@ var MineRender = (() => {
         sizeAttenuation: material.sizeAttenuation === true,
         logarithmicDepthBuffer,
         reversedDepthBuffer,
-        skinning: object.isSkinnedMesh === true,
+        skinning: object2.isSkinnedMesh === true,
         hasPositionAttribute: geometry.attributes.position !== void 0,
         morphTargets: geometry.morphAttributes.position !== void 0,
         morphNormals: geometry.morphAttributes.normal !== void 0,
@@ -25044,22 +25044,22 @@ var MineRender = (() => {
   }
   function WebGLProperties() {
     let properties = /* @__PURE__ */ new WeakMap();
-    function has(object) {
-      return properties.has(object);
+    function has(object2) {
+      return properties.has(object2);
     }
-    function get(object) {
-      let map = properties.get(object);
+    function get(object2) {
+      let map = properties.get(object2);
       if (map === void 0) {
         map = {};
-        properties.set(object, map);
+        properties.set(object2, map);
       }
       return map;
     }
-    function remove(object) {
-      properties.delete(object);
+    function remove(object2) {
+      properties.delete(object2);
     }
-    function update(object, key, value) {
-      properties.get(object)[key] = value;
+    function update(object2, key, value) {
+      properties.get(object2)[key] = value;
     }
     function dispose() {
       properties = /* @__PURE__ */ new WeakMap();
@@ -25110,44 +25110,44 @@ var MineRender = (() => {
       transmissive.length = 0;
       transparent.length = 0;
     }
-    function materialVariant(object) {
+    function materialVariant(object2) {
       let variant = 0;
-      if (object.isInstancedMesh) variant += 2;
-      if (object.isSkinnedMesh) variant += 1;
+      if (object2.isInstancedMesh) variant += 2;
+      if (object2.isSkinnedMesh) variant += 1;
       return variant;
     }
-    function getNextRenderItem(object, geometry, material, groupOrder, z4, group) {
+    function getNextRenderItem(object2, geometry, material, groupOrder, z4, group) {
       let renderItem = renderItems[renderItemsIndex];
       if (renderItem === void 0) {
         renderItem = {
-          id: object.id,
-          object,
+          id: object2.id,
+          object: object2,
           geometry,
           material,
-          materialVariant: materialVariant(object),
+          materialVariant: materialVariant(object2),
           groupOrder,
-          renderOrder: object.renderOrder,
+          renderOrder: object2.renderOrder,
           z: z4,
           group
         };
         renderItems[renderItemsIndex] = renderItem;
       } else {
-        renderItem.id = object.id;
-        renderItem.object = object;
+        renderItem.id = object2.id;
+        renderItem.object = object2;
         renderItem.geometry = geometry;
         renderItem.material = material;
-        renderItem.materialVariant = materialVariant(object);
+        renderItem.materialVariant = materialVariant(object2);
         renderItem.groupOrder = groupOrder;
-        renderItem.renderOrder = object.renderOrder;
+        renderItem.renderOrder = object2.renderOrder;
         renderItem.z = z4;
         renderItem.group = group;
       }
       renderItemsIndex++;
       return renderItem;
     }
-    function push(object, geometry, material, groupOrder, z4, group, camera) {
+    function push(object2, geometry, material, groupOrder, z4, group, camera) {
       if (camera.reversedDepth === true) z4 = -z4;
-      const renderItem = getNextRenderItem(object, geometry, material, groupOrder, z4, group);
+      const renderItem = getNextRenderItem(object2, geometry, material, groupOrder, z4, group);
       if (material.transmission > 0) {
         transmissive.push(renderItem);
       } else if (material.transparent === true) {
@@ -25156,8 +25156,8 @@ var MineRender = (() => {
         opaque.push(renderItem);
       }
     }
-    function unshift(object, geometry, material, groupOrder, z4, group) {
-      const renderItem = getNextRenderItem(object, geometry, material, groupOrder, z4, group);
+    function unshift(object2, geometry, material, groupOrder, z4, group) {
+      const renderItem = getNextRenderItem(object2, geometry, material, groupOrder, z4, group);
       if (material.transmission > 0) {
         transmissive.unshift(renderItem);
       } else if (material.transparent === true) {
@@ -25760,12 +25760,12 @@ var MineRender = (() => {
       _state.setScissorTest(false);
       const typeChanged = _previousType !== this.type;
       if (typeChanged) {
-        scene.traverse(function(object) {
-          if (object.material) {
-            if (Array.isArray(object.material)) {
-              object.material.forEach((mat) => mat.needsUpdate = true);
+        scene.traverse(function(object2) {
+          if (object2.material) {
+            if (Array.isArray(object2.material)) {
+              object2.material.forEach((mat) => mat.needsUpdate = true);
             } else {
-              object.material.needsUpdate = true;
+              object2.material.needsUpdate = true;
             }
           }
         });
@@ -25929,9 +25929,9 @@ var MineRender = (() => {
       renderer.clear();
       renderer.renderBufferDirect(camera, null, geometry, shadowMaterialHorizontal, fullScreenMesh, null);
     }
-    function getDepthMaterial(object, material, light, type) {
+    function getDepthMaterial(object2, material, light, type) {
       let result = null;
-      const customMaterial = light.isPointLight === true ? object.customDistanceMaterial : object.customDepthMaterial;
+      const customMaterial = light.isPointLight === true ? object2.customDistanceMaterial : object2.customDepthMaterial;
       if (customMaterial !== void 0) {
         result = customMaterial;
       } else {
@@ -25976,35 +25976,35 @@ var MineRender = (() => {
       }
       return result;
     }
-    function renderObject(object, camera, shadowCamera, light, type) {
-      if (object.visible === false) return;
-      const visible = object.layers.test(camera.layers);
-      if (visible && (object.isMesh || object.isLine || object.isPoints)) {
-        if ((object.castShadow || object.receiveShadow && type === VSMShadowMap) && (!object.frustumCulled || object.intersectsFrustum(_frustum))) {
-          object.modelViewMatrix.multiplyMatrices(shadowCamera.matrixWorldInverse, object.matrixWorld);
-          const geometry = objects.update(object);
-          const material = object.material;
+    function renderObject(object2, camera, shadowCamera, light, type) {
+      if (object2.visible === false) return;
+      const visible = object2.layers.test(camera.layers);
+      if (visible && (object2.isMesh || object2.isLine || object2.isPoints)) {
+        if ((object2.castShadow || object2.receiveShadow && type === VSMShadowMap) && (!object2.frustumCulled || object2.intersectsFrustum(_frustum))) {
+          object2.modelViewMatrix.multiplyMatrices(shadowCamera.matrixWorldInverse, object2.matrixWorld);
+          const geometry = objects.update(object2);
+          const material = object2.material;
           if (Array.isArray(material)) {
             const groups = geometry.groups;
             for (let k4 = 0, kl = groups.length; k4 < kl; k4++) {
               const group = groups[k4];
               const groupMaterial = material[group.materialIndex];
               if (groupMaterial && groupMaterial.visible) {
-                const depthMaterial = getDepthMaterial(object, groupMaterial, light, type);
-                object.onBeforeShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, group);
-                renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, group);
-                object.onAfterShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, group);
+                const depthMaterial = getDepthMaterial(object2, groupMaterial, light, type);
+                object2.onBeforeShadow(renderer, object2, camera, shadowCamera, geometry, depthMaterial, group);
+                renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object2, group);
+                object2.onAfterShadow(renderer, object2, camera, shadowCamera, geometry, depthMaterial, group);
               }
             }
           } else if (material.visible) {
-            const depthMaterial = getDepthMaterial(object, material, light, type);
-            object.onBeforeShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, null);
-            renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, null);
-            object.onAfterShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, null);
+            const depthMaterial = getDepthMaterial(object2, material, light, type);
+            object2.onBeforeShadow(renderer, object2, camera, shadowCamera, geometry, depthMaterial, null);
+            renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object2, null);
+            object2.onAfterShadow(renderer, object2, camera, shadowCamera, geometry, depthMaterial, null);
           }
         }
       }
-      const children = object.children;
+      const children = object2.children;
       for (let i4 = 0, l4 = children.length; i4 < l4; i4++) {
         renderObject(children[i4], camera, shadowCamera, light, type);
       }
@@ -28060,12 +28060,12 @@ var MineRender = (() => {
     }
     function verifyColorSpace(texture, image) {
       const colorSpace = texture.colorSpace;
-      const format2 = texture.format;
+      const format3 = texture.format;
       const type = texture.type;
       if (texture.isCompressedTexture === true || texture.isVideoTexture === true) return image;
       if (colorSpace !== LinearSRGBColorSpace && colorSpace !== NoColorSpace) {
         if (ColorManagement.getTransfer(colorSpace) === SRGBTransfer) {
-          if (format2 !== RGBAFormat || type !== UnsignedByteType) {
+          if (format3 !== RGBAFormat || type !== UnsignedByteType) {
             warn("WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType.");
           }
         } else {
@@ -30096,8 +30096,8 @@ var MineRender = (() => {
           const u4 = this.map[name2];
           if (u4 !== void 0) u4.setValue(gl, value, textures);
         }
-        setOptional(gl, object, name2) {
-          const v5 = object[name2];
+        setOptional(gl, object2, name2) {
+          const v5 = object2[name2];
           if (v5 !== void 0) this.setValue(gl, name2, v5);
         }
         static upload(gl, seq, values, textures) {
@@ -31798,10 +31798,10 @@ void main() {
               }
             }
           }
-          this.renderBufferDirect = function(camera, scene, geometry, material, object, group) {
+          this.renderBufferDirect = function(camera, scene, geometry, material, object2, group) {
             if (scene === null) scene = _emptyScene;
-            const frontFaceCW = object.isMesh && object.matrixWorld.determinantAffine() < 0;
-            const program = setProgram(camera, scene, geometry, material, object);
+            const frontFaceCW = object2.isMesh && object2.matrixWorld.determinantAffine() < 0;
+            const program = setProgram(camera, scene, geometry, material, object2);
             state.setMaterial(material, frontFaceCW);
             let index = geometry.index;
             let rangeFactor = 1;
@@ -31827,7 +31827,7 @@ void main() {
             }
             const drawCount = drawEnd - drawStart;
             if (drawCount < 0 || drawCount === Infinity) return;
-            bindingStates.setup(object, material, program, geometry, index);
+            bindingStates.setup(object2, material, program, geometry, index);
             let attribute;
             let renderer = bufferRenderer;
             if (index !== null) {
@@ -31835,34 +31835,34 @@ void main() {
               renderer = indexedBufferRenderer;
               renderer.setIndex(attribute);
             }
-            if (object.isMesh) {
+            if (object2.isMesh) {
               if (material.wireframe === true) {
                 state.setLineWidth(material.wireframeLinewidth * getTargetPixelRatio());
                 renderer.setMode(_gl.LINES);
               } else {
                 renderer.setMode(_gl.TRIANGLES);
               }
-            } else if (object.isLine) {
+            } else if (object2.isLine) {
               let lineWidth = material.linewidth;
               if (lineWidth === void 0) lineWidth = 1;
               state.setLineWidth(lineWidth * getTargetPixelRatio());
-              if (object.isLineSegments) {
+              if (object2.isLineSegments) {
                 renderer.setMode(_gl.LINES);
-              } else if (object.isLineLoop) {
+              } else if (object2.isLineLoop) {
                 renderer.setMode(_gl.LINE_LOOP);
               } else {
                 renderer.setMode(_gl.LINE_STRIP);
               }
-            } else if (object.isPoints) {
+            } else if (object2.isPoints) {
               renderer.setMode(_gl.POINTS);
-            } else if (object.isSprite) {
+            } else if (object2.isSprite) {
               renderer.setMode(_gl.TRIANGLES);
             }
-            if (object.isBatchedMesh) {
+            if (object2.isBatchedMesh) {
               if (!extensions.get("WEBGL_multi_draw")) {
-                const starts = object._multiDrawStarts;
-                const counts = object._multiDrawCounts;
-                const drawCount2 = object._multiDrawCount;
+                const starts = object2._multiDrawStarts;
+                const counts = object2._multiDrawCounts;
+                const drawCount2 = object2._multiDrawCount;
                 const bytesPerElement = index ? attributes.get(index).bytesPerElement : 1;
                 const uniforms = properties.get(material).currentProgram.getUniforms();
                 for (let i4 = 0; i4 < drawCount2; i4++) {
@@ -31870,10 +31870,10 @@ void main() {
                   renderer.render(starts[i4] / bytesPerElement, counts[i4]);
                 }
               } else {
-                renderer.renderMultiDraw(object._multiDrawStarts, object._multiDrawCounts, object._multiDrawCount);
+                renderer.renderMultiDraw(object2._multiDrawStarts, object2._multiDrawCounts, object2._multiDrawCount);
               }
-            } else if (object.isInstancedMesh) {
-              renderer.renderInstances(drawStart, drawCount, object.count);
+            } else if (object2.isInstancedMesh) {
+              renderer.renderInstances(drawStart, drawCount, object2.count);
             } else if (geometry.isInstancedBufferGeometry) {
               const maxInstanceCount = geometry._maxInstanceCount !== void 0 ? geometry._maxInstanceCount : Infinity;
               const instanceCount = Math.min(geometry.instanceCount, maxInstanceCount);
@@ -31882,19 +31882,19 @@ void main() {
               renderer.render(drawStart, drawCount);
             }
           };
-          function prepareMaterial(material, scene, camera, object) {
-            if (_nodesHandler !== null && material.isNodeMaterial) _nodesHandler.setObject(object, material);
+          function prepareMaterial(material, scene, camera, object2) {
+            if (_nodesHandler !== null && material.isNodeMaterial) _nodesHandler.setObject(object2, material);
             if (_clippingEnabled === true) clipping.setState(material, camera, false);
             if (material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false) {
               material.side = BackSide;
               material.needsUpdate = true;
-              getProgram(material, scene, object);
+              getProgram(material, scene, object2);
               material.side = FrontSide;
               material.needsUpdate = true;
-              getProgram(material, scene, object);
+              getProgram(material, scene, object2);
               material.side = DoubleSide;
             } else {
-              getProgram(material, scene, object);
+              getProgram(material, scene, object2);
             }
           }
           this.compile = function(scene, camera, targetScene = null) {
@@ -31903,20 +31903,20 @@ void main() {
             currentRenderState = renderStates.get(targetScene);
             currentRenderState.init(camera);
             renderStateStack.push(currentRenderState);
-            targetScene.traverseVisible(function(object) {
-              if (object.isLight && object.layers.test(camera.layers)) {
-                currentRenderState.pushLight(object);
-                if (object.castShadow) {
-                  currentRenderState.pushShadow(object);
+            targetScene.traverseVisible(function(object2) {
+              if (object2.isLight && object2.layers.test(camera.layers)) {
+                currentRenderState.pushLight(object2);
+                if (object2.castShadow) {
+                  currentRenderState.pushShadow(object2);
                 }
               }
             });
             if (scene !== targetScene) {
-              scene.traverseVisible(function(object) {
-                if (object.isLight && object.layers.test(camera.layers)) {
-                  currentRenderState.pushLight(object);
-                  if (object.castShadow) {
-                    currentRenderState.pushShadow(object);
+              scene.traverseVisible(function(object2) {
+                if (object2.isLight && object2.layers.test(camera.layers)) {
+                  currentRenderState.pushLight(object2);
+                  if (object2.castShadow) {
+                    currentRenderState.pushShadow(object2);
                   }
                 }
               });
@@ -31928,20 +31928,20 @@ void main() {
             if (_clippingEnabled === true) clipping.setGlobalState(this.clippingPlanes, camera);
             if (_nodesHandler !== null) shadowMap.render(currentRenderState.state.shadowsArray, targetScene, camera);
             const materials2 = /* @__PURE__ */ new Set();
-            scene.traverse(function(object) {
-              if (!(object.isMesh || object.isPoints || object.isLine || object.isSprite)) {
+            scene.traverse(function(object2) {
+              if (!(object2.isMesh || object2.isPoints || object2.isLine || object2.isSprite)) {
                 return;
               }
-              const material = object.material;
+              const material = object2.material;
               if (material) {
                 if (Array.isArray(material)) {
                   for (let i4 = 0; i4 < material.length; i4++) {
                     const material2 = material[i4];
-                    prepareMaterial(material2, targetScene, camera, object);
+                    prepareMaterial(material2, targetScene, camera, object2);
                     materials2.add(material2);
                   }
                 } else {
-                  prepareMaterial(material, targetScene, camera, object);
+                  prepareMaterial(material, targetScene, camera, object2);
                   materials2.add(material);
                 }
               }
@@ -32098,45 +32098,45 @@ void main() {
               _nodesHandler.renderEnd();
             }
           };
-          function projectObject(object, camera, groupOrder, sortObjects) {
-            if (object.visible === false) return;
-            const visible = object.layers.test(camera.layers);
+          function projectObject(object2, camera, groupOrder, sortObjects) {
+            if (object2.visible === false) return;
+            const visible = object2.layers.test(camera.layers);
             if (visible) {
-              if (object.isGroup) {
-                groupOrder = object.renderOrder;
-              } else if (object.isLOD) {
-                if (object.autoUpdate === true) object.update(camera);
-              } else if (object.isLightProbeGrid) {
-                currentRenderState.pushLightProbeGrid(object);
-              } else if (object.isLight) {
-                currentRenderState.pushLight(object);
-                if (object.castShadow) {
-                  currentRenderState.pushShadow(object);
+              if (object2.isGroup) {
+                groupOrder = object2.renderOrder;
+              } else if (object2.isLOD) {
+                if (object2.autoUpdate === true) object2.update(camera);
+              } else if (object2.isLightProbeGrid) {
+                currentRenderState.pushLightProbeGrid(object2);
+              } else if (object2.isLight) {
+                currentRenderState.pushLight(object2);
+                if (object2.castShadow) {
+                  currentRenderState.pushShadow(object2);
                 }
-              } else if (object.isSprite) {
-                if (!object.frustumCulled || object.intersectsFrustum(_frustum)) {
+              } else if (object2.isSprite) {
+                if (!object2.frustumCulled || object2.intersectsFrustum(_frustum)) {
                   if (sortObjects) {
-                    _vector4.setFromMatrixPosition(object.matrixWorld).applyMatrix4(_projScreenMatrix2);
+                    _vector4.setFromMatrixPosition(object2.matrixWorld).applyMatrix4(_projScreenMatrix2);
                   }
-                  const geometry = objects.update(object);
-                  const material = object.material;
+                  const geometry = objects.update(object2);
+                  const material = object2.material;
                   if (material.visible) {
-                    currentRenderList.push(object, geometry, material, groupOrder, _vector4.z, null, camera);
+                    currentRenderList.push(object2, geometry, material, groupOrder, _vector4.z, null, camera);
                   }
                 }
-              } else if (object.isMesh || object.isLine || object.isPoints) {
-                if (!object.frustumCulled || object.intersectsFrustum(_frustum)) {
-                  const geometry = objects.update(object);
-                  const material = object.material;
+              } else if (object2.isMesh || object2.isLine || object2.isPoints) {
+                if (!object2.frustumCulled || object2.intersectsFrustum(_frustum)) {
+                  const geometry = objects.update(object2);
+                  const material = object2.material;
                   if (sortObjects) {
-                    if (object.boundingSphere !== void 0) {
-                      if (object.boundingSphere === null) object.computeBoundingSphere();
-                      _vector4.copy(object.boundingSphere.center);
+                    if (object2.boundingSphere !== void 0) {
+                      if (object2.boundingSphere === null) object2.computeBoundingSphere();
+                      _vector4.copy(object2.boundingSphere.center);
                     } else {
                       if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
                       _vector4.copy(geometry.boundingSphere.center);
                     }
-                    _vector4.applyMatrix4(object.matrixWorld).applyMatrix4(_projScreenMatrix2);
+                    _vector4.applyMatrix4(object2.matrixWorld).applyMatrix4(_projScreenMatrix2);
                   }
                   if (Array.isArray(material)) {
                     const groups = geometry.groups;
@@ -32144,16 +32144,16 @@ void main() {
                       const group = groups[i4];
                       const groupMaterial = material[group.materialIndex];
                       if (groupMaterial && groupMaterial.visible) {
-                        currentRenderList.push(object, geometry, groupMaterial, groupOrder, _vector4.z, group, camera);
+                        currentRenderList.push(object2, geometry, groupMaterial, groupOrder, _vector4.z, group, camera);
                       }
                     }
                   } else if (material.visible) {
-                    currentRenderList.push(object, geometry, material, groupOrder, _vector4.z, null, camera);
+                    currentRenderList.push(object2, geometry, material, groupOrder, _vector4.z, null, camera);
                   }
                 }
               }
             }
-            const children = object.children;
+            const children = object2.children;
             for (let i4 = 0, l4 = children.length; i4 < l4; i4++) {
               projectObject(children[i4], camera, groupOrder, sortObjects);
             }
@@ -32217,12 +32217,12 @@ void main() {
               let renderTargetNeedsUpdate = false;
               for (let i4 = 0, l4 = transmissiveObjects.length; i4 < l4; i4++) {
                 const renderItem = transmissiveObjects[i4];
-                const { object, geometry, material, group } = renderItem;
-                if (material.side === DoubleSide && object.layers.test(camera.layers)) {
+                const { object: object2, geometry, material, group } = renderItem;
+                if (material.side === DoubleSide && object2.layers.test(camera.layers)) {
                   const currentSide = material.side;
                   material.side = BackSide;
                   material.needsUpdate = true;
-                  renderObject(object, scene, camera, geometry, material, group);
+                  renderObject(object2, scene, camera, geometry, material, group);
                   material.side = currentSide;
                   material.needsUpdate = true;
                   renderTargetNeedsUpdate = true;
@@ -32242,42 +32242,42 @@ void main() {
             const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;
             for (let i4 = 0, l4 = renderList.length; i4 < l4; i4++) {
               const renderItem = renderList[i4];
-              const { object, geometry, group } = renderItem;
+              const { object: object2, geometry, group } = renderItem;
               let material = renderItem.material;
               if (material.allowOverride === true && overrideMaterial !== null) {
                 material = overrideMaterial;
               }
-              if (object.layers.test(camera.layers)) {
-                renderObject(object, scene, camera, geometry, material, group);
+              if (object2.layers.test(camera.layers)) {
+                renderObject(object2, scene, camera, geometry, material, group);
               }
             }
           }
-          function renderObject(object, scene, camera, geometry, material, group) {
-            if (_nodesHandler !== null && material.isNodeMaterial) _nodesHandler.setObject(object, material);
-            object.onBeforeRender(_this, scene, camera, geometry, material, group);
-            object.modelViewMatrix.multiplyMatrices(camera.matrixWorldInverse, object.matrixWorld);
-            object.normalMatrix.getNormalMatrix(object.modelViewMatrix);
-            material.onBeforeRender(_this, scene, camera, geometry, object, group);
+          function renderObject(object2, scene, camera, geometry, material, group) {
+            if (_nodesHandler !== null && material.isNodeMaterial) _nodesHandler.setObject(object2, material);
+            object2.onBeforeRender(_this, scene, camera, geometry, material, group);
+            object2.modelViewMatrix.multiplyMatrices(camera.matrixWorldInverse, object2.matrixWorld);
+            object2.normalMatrix.getNormalMatrix(object2.modelViewMatrix);
+            material.onBeforeRender(_this, scene, camera, geometry, object2, group);
             if (material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false) {
               material.side = BackSide;
               material.needsUpdate = true;
-              _this.renderBufferDirect(camera, scene, geometry, material, object, group);
+              _this.renderBufferDirect(camera, scene, geometry, material, object2, group);
               material.side = FrontSide;
               material.needsUpdate = true;
-              _this.renderBufferDirect(camera, scene, geometry, material, object, group);
+              _this.renderBufferDirect(camera, scene, geometry, material, object2, group);
               material.side = DoubleSide;
             } else {
-              _this.renderBufferDirect(camera, scene, geometry, material, object, group);
+              _this.renderBufferDirect(camera, scene, geometry, material, object2, group);
             }
-            object.onAfterRender(_this, scene, camera, geometry, material, group);
+            object2.onAfterRender(_this, scene, camera, geometry, material, group);
           }
-          function getProgram(material, scene, object) {
+          function getProgram(material, scene, object2) {
             if (scene.isScene !== true) scene = _emptyScene;
             const materialProperties = properties.get(material);
             const lights = currentRenderState.state.lights;
             const shadowsArray = currentRenderState.state.shadowsArray;
             const lightsStateVersion = lights.state.version;
-            const parameters2 = programCache.getParameters(material, lights.state, shadowsArray, scene, object, currentRenderState.state.lightProbeGridArray);
+            const parameters2 = programCache.getParameters(material, lights.state, shadowsArray, scene, object2, currentRenderState.state.lightProbeGridArray);
             const programCacheKey = programCache.getProgramCacheKey(parameters2);
             let programs = materialProperties.programs;
             materialProperties.environment = material.isMeshStandardMaterial || material.isMeshLambertMaterial || material.isMeshPhongMaterial ? scene.environment : null;
@@ -32299,7 +32299,7 @@ void main() {
             } else {
               parameters2.uniforms = programCache.getUniforms(material);
               if (_nodesHandler !== null && material.isNodeMaterial) {
-                _nodesHandler.build(material, object, parameters2);
+                _nodesHandler.build(material, object2, parameters2);
               }
               material.onBeforeCompile(parameters2, _this);
               program = programCache.acquireProgram(parameters2, programCacheKey);
@@ -32366,19 +32366,19 @@ void main() {
             materialProperties.vertexTangents = parameters2.vertexTangents;
             materialProperties.toneMapping = parameters2.toneMapping;
           }
-          function findLightProbeGrid(volumes, object) {
+          function findLightProbeGrid(volumes, object2) {
             if (volumes.length === 0) return null;
             if (volumes.length === 1) {
               return volumes[0].texture !== null ? volumes[0] : null;
             }
-            objectPosition.setFromMatrixPosition(object.matrixWorld);
+            objectPosition.setFromMatrixPosition(object2.matrixWorld);
             for (let i4 = 0, l4 = volumes.length; i4 < l4; i4++) {
               const v5 = volumes[i4];
               if (v5.texture !== null && v5.boundingBox.containsPoint(objectPosition)) return v5;
             }
             return null;
           }
-          function setProgram(camera, scene, geometry, material, object) {
+          function setProgram(camera, scene, geometry, material, object2) {
             if (scene.isScene !== true) scene = _emptyScene;
             textures.resetTextureUnits();
             const fog = scene.fog;
@@ -32413,29 +32413,29 @@ void main() {
                 needsProgramChange = true;
               } else if (materialProperties.outputColorSpace !== colorSpace) {
                 needsProgramChange = true;
-              } else if (object.isBatchedMesh && materialProperties.batching === false) {
+              } else if (object2.isBatchedMesh && materialProperties.batching === false) {
                 needsProgramChange = true;
-              } else if (!object.isBatchedMesh && materialProperties.batching === true) {
+              } else if (!object2.isBatchedMesh && materialProperties.batching === true) {
                 needsProgramChange = true;
-              } else if (object.isBatchedMesh && materialProperties.batchingColor === true && object._colorsTexture === null) {
+              } else if (object2.isBatchedMesh && materialProperties.batchingColor === true && object2._colorsTexture === null) {
                 needsProgramChange = true;
-              } else if (object.isBatchedMesh && materialProperties.batchingColor === false && object._colorsTexture !== null) {
+              } else if (object2.isBatchedMesh && materialProperties.batchingColor === false && object2._colorsTexture !== null) {
                 needsProgramChange = true;
-              } else if (object.isInstancedMesh && materialProperties.instancing === false) {
+              } else if (object2.isInstancedMesh && materialProperties.instancing === false) {
                 needsProgramChange = true;
-              } else if (!object.isInstancedMesh && materialProperties.instancing === true) {
+              } else if (!object2.isInstancedMesh && materialProperties.instancing === true) {
                 needsProgramChange = true;
-              } else if (object.isSkinnedMesh && materialProperties.skinning === false) {
+              } else if (object2.isSkinnedMesh && materialProperties.skinning === false) {
                 needsProgramChange = true;
-              } else if (!object.isSkinnedMesh && materialProperties.skinning === true) {
+              } else if (!object2.isSkinnedMesh && materialProperties.skinning === true) {
                 needsProgramChange = true;
-              } else if (object.isInstancedMesh && materialProperties.instancingColor === true && object.instanceColor === null) {
+              } else if (object2.isInstancedMesh && materialProperties.instancingColor === true && object2.instanceColor === null) {
                 needsProgramChange = true;
-              } else if (object.isInstancedMesh && materialProperties.instancingColor === false && object.instanceColor !== null) {
+              } else if (object2.isInstancedMesh && materialProperties.instancingColor === false && object2.instanceColor !== null) {
                 needsProgramChange = true;
-              } else if (object.isInstancedMesh && materialProperties.instancingMorph === true && object.morphTexture === null) {
+              } else if (object2.isInstancedMesh && materialProperties.instancingMorph === true && object2.morphTexture === null) {
                 needsProgramChange = true;
-              } else if (object.isInstancedMesh && materialProperties.instancingMorph === false && object.morphTexture !== null) {
+              } else if (object2.isInstancedMesh && materialProperties.instancingMorph === false && object2.morphTexture !== null) {
                 needsProgramChange = true;
               } else if (materialProperties.envMap !== envMap) {
                 needsProgramChange = true;
@@ -32466,7 +32466,7 @@ void main() {
             }
             let program = materialProperties.currentProgram;
             if (needsProgramChange === true) {
-              program = getProgram(material, scene, object);
+              program = getProgram(material, scene, object2);
               if (_nodesHandler && material.isNodeMaterial) {
                 _nodesHandler.onUpdateProgram(material, program, materialProperties);
               }
@@ -32485,7 +32485,7 @@ void main() {
               refreshMaterial = true;
             }
             if (materialProperties.needsLights) {
-              const objectVolume = findLightProbeGrid(currentRenderState.state.lightProbeGridArray, object);
+              const objectVolume = findLightProbeGrid(currentRenderState.state.lightProbeGridArray, object2);
               if (materialProperties.lightProbeGrid !== objectVolume) {
                 materialProperties.lightProbeGrid = objectVolume;
                 refreshMaterial = true;
@@ -32533,32 +32533,32 @@ void main() {
                 p_uniforms.setValue(_gl, "pointShadowMap", lights.state.pointShadowMap, textures);
               }
             }
-            if (object.isSkinnedMesh) {
-              p_uniforms.setOptional(_gl, object, "bindMatrix");
-              p_uniforms.setOptional(_gl, object, "bindMatrixInverse");
-              const skeleton = object.skeleton;
+            if (object2.isSkinnedMesh) {
+              p_uniforms.setOptional(_gl, object2, "bindMatrix");
+              p_uniforms.setOptional(_gl, object2, "bindMatrixInverse");
+              const skeleton = object2.skeleton;
               if (skeleton) {
                 if (skeleton.boneTexture === null) skeleton.computeBoneTexture();
                 p_uniforms.setValue(_gl, "boneTexture", skeleton.boneTexture, textures);
               }
             }
-            if (object.isBatchedMesh) {
-              p_uniforms.setOptional(_gl, object, "batchingTexture");
-              p_uniforms.setValue(_gl, "batchingTexture", object._matricesTexture, textures);
-              p_uniforms.setOptional(_gl, object, "batchingIdTexture");
-              p_uniforms.setValue(_gl, "batchingIdTexture", object._indirectTexture, textures);
-              p_uniforms.setOptional(_gl, object, "batchingColorTexture");
-              if (object._colorsTexture !== null) {
-                p_uniforms.setValue(_gl, "batchingColorTexture", object._colorsTexture, textures);
+            if (object2.isBatchedMesh) {
+              p_uniforms.setOptional(_gl, object2, "batchingTexture");
+              p_uniforms.setValue(_gl, "batchingTexture", object2._matricesTexture, textures);
+              p_uniforms.setOptional(_gl, object2, "batchingIdTexture");
+              p_uniforms.setValue(_gl, "batchingIdTexture", object2._indirectTexture, textures);
+              p_uniforms.setOptional(_gl, object2, "batchingColorTexture");
+              if (object2._colorsTexture !== null) {
+                p_uniforms.setValue(_gl, "batchingColorTexture", object2._colorsTexture, textures);
               }
             }
             const morphAttributes = geometry.morphAttributes;
             if (morphAttributes.position !== void 0 || morphAttributes.normal !== void 0 || morphAttributes.color !== void 0) {
-              morphtargets.update(object, geometry, program);
+              morphtargets.update(object2, geometry, program);
             }
-            if (refreshMaterial || materialProperties.receiveShadow !== object.receiveShadow) {
-              materialProperties.receiveShadow = object.receiveShadow;
-              p_uniforms.setValue(_gl, "receiveShadow", object.receiveShadow);
+            if (refreshMaterial || materialProperties.receiveShadow !== object2.receiveShadow) {
+              materialProperties.receiveShadow = object2.receiveShadow;
+              p_uniforms.setValue(_gl, "receiveShadow", object2.receiveShadow);
             }
             if ((material.isMeshStandardMaterial || material.isMeshLambertMaterial || material.isMeshPhongMaterial) && material.envMap === null && scene.environment !== null) {
               m_uniforms.envMapIntensity.value = scene.environmentIntensity;
@@ -32589,11 +32589,11 @@ void main() {
               material.uniformsNeedUpdate = false;
             }
             if (material.isSpriteMaterial) {
-              p_uniforms.setValue(_gl, "center", object.center);
+              p_uniforms.setValue(_gl, "center", object2.center);
             }
-            p_uniforms.setValue(_gl, "modelViewMatrix", object.modelViewMatrix);
-            p_uniforms.setValue(_gl, "normalMatrix", object.normalMatrix);
-            p_uniforms.setValue(_gl, "modelMatrix", object.matrixWorld);
+            p_uniforms.setValue(_gl, "modelViewMatrix", object2.modelViewMatrix);
+            p_uniforms.setValue(_gl, "normalMatrix", object2.normalMatrix);
+            p_uniforms.setValue(_gl, "modelMatrix", object2.matrixWorld);
             if (material.uniformsGroups !== void 0) {
               const groups = material.uniformsGroups;
               for (let i4 = 0, l4 = groups.length; i4 < l4; i4++) {
@@ -36694,9 +36694,9 @@ void main() {
              *
              *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
              */
-            _parse: function(ciphertext, format2) {
+            _parse: function(ciphertext, format3) {
               if (typeof ciphertext == "string") {
-                return format2.parse(ciphertext, this);
+                return format3.parse(ciphertext, this);
               } else {
                 return ciphertext;
               }
@@ -42301,7 +42301,7 @@ void main() {
         static createTexture() {
           return new Texture();
         }
-        static loadInBackground(src, format2 = RGBAFormat, rotation = 0) {
+        static loadInBackground(src, format3 = RGBAFormat, rotation = 0) {
           const texture = this.createTexture();
           texture.colorSpace = SRGBColorSpace;
           const image = ImageLoader2.loadElement(src, () => {
@@ -42311,11 +42311,11 @@ void main() {
             console.warn("Failed to load texture", src, error2);
           });
           texture.image = image;
-          texture.format = format2;
+          texture.format = format3;
           texture.rotation = rotation;
           return Textures.initTextureProps(texture);
         }
-        static load(src, format2 = RGBAFormat, rotation = 0) {
+        static load(src, format3 = RGBAFormat, rotation = 0) {
           const texture = new Texture();
           texture.colorSpace = SRGBColorSpace;
           ImageLoader2.getData(src).then((image) => {
@@ -42325,7 +42325,7 @@ void main() {
             this.failedTextures.add(texture);
             console.warn("Failed to load texture", src, error2);
           });
-          texture.format = format2;
+          texture.format = format3;
           texture.rotation = rotation;
           return Textures.initTextureProps(texture);
         }
@@ -42539,7 +42539,7 @@ void main() {
           };
           return material;
         }
-        static createShadedCanvasMaterial(canvas, transparent = false, shade = false) {
+        static createShadedCanvasMaterial(canvas, transparent = false, shade = false, boundUvs = false) {
           const vertShader = `
             uniform bool SHADE;
             
@@ -42549,6 +42549,10 @@ void main() {
             #else
             varying vec2 vUv;
             #endif
+            #ifdef BOUND_UVS
+            attribute vec4 uvBounds;
+            flat out vec4 vUvBounds;
+            #endif
             varying vec3 vTint;
             varying float light;
             varying float lift;
@@ -42584,13 +42588,17 @@ void main() {
                 }
                 
                 vUv = uv;
+                #ifdef BOUND_UVS
+                vUvBounds = uvBounds;
+                #endif
                 vTint = color;
                
+                vec4 mvPosition = vec4(position, 1.0);
                 #ifdef USE_INSTANCING
-                    gl_Position = projectionMatrix * viewMatrix * modelMatrix * instanceMatrix * vec4(position, 1.0);
-                #else
-                    gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+                    mvPosition = instanceMatrix * mvPosition;
                 #endif
+                mvPosition = modelViewMatrix * mvPosition;
+                gl_Position = projectionMatrix * mvPosition;
                 
             }
         `;
@@ -42610,13 +42618,22 @@ void main() {
             #else
             varying vec2 vUv;
             #endif
+            #ifdef BOUND_UVS
+            flat in vec4 vUvBounds;
+            #endif
             varying vec3 vTint;
             varying float light;
             varying float lift;
 
             void main(void)
             {
-                vec4 color = texture2D(map, vUv);
+                #ifdef BOUND_UVS
+                // Keep edge samples inside their texture even without centroid interpolation.
+                vec2 mapUv = clamp(vUv, vUvBounds.xy, vUvBounds.zw);
+                #else
+                vec2 mapUv = vUv;
+                #endif
+                vec4 color = texture2D(map, mapUv);
                 color.rgb *= vTint;
                 
                 if (color.a < 0.01) discard;
@@ -42637,7 +42654,8 @@ void main() {
             }
         `;
           try {
-            return new ShaderMaterial({
+            const material = new ShaderMaterial({
+              defines: boundUvs ? { BOUND_UVS: true } : {},
               uniforms: {
                 SHADE: { value: true },
                 BRIGHTNESS: { value: 1 },
@@ -42655,6 +42673,8 @@ void main() {
               side: transparent ? DoubleSide : FrontSide,
               alphaTest: 0.5
             });
+            Object.assign(material.defaultAttributeValues, { uvBounds: [0, 0, 1, 1] });
+            return material;
           } catch (e6) {
             console.warn(e6);
           }
@@ -43294,6 +43314,10 @@ void main() {
       AssetSource = class {
         constructor() {
         }
+        /** Whether this source prevents lower-priority sources from supplying the key. Its own assets remain available. */
+        blocks(key) {
+          return false;
+        }
         /**
          * Identifies this source's content across sessions for persistent caching. Sources that
          * cannot tell whether their content changed (an unnamed archive, for example) return
@@ -45328,7 +45352,7 @@ void main() {
     Buffer2.isBuffer = function isBuffer2(b4) {
       return b4 != null && b4._isBuffer === true && b4 !== Buffer2.prototype;
     };
-    Buffer2.compare = function compare(a4, b4) {
+    Buffer2.compare = function compare2(a4, b4) {
       if (isInstance(a4, Uint8Array)) a4 = Buffer2.from(a4, a4.offset, a4.byteLength);
       if (isInstance(b4, Uint8Array)) b4 = Buffer2.from(b4, b4.offset, b4.byteLength);
       if (!Buffer2.isBuffer(a4) || !Buffer2.isBuffer(b4)) {
@@ -45550,7 +45574,7 @@ void main() {
     if (customInspectSymbol) {
       Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
     }
-    Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+    Buffer2.prototype.compare = function compare2(target, start, end, thisStart, thisEnd) {
       if (isInstance(target, Uint8Array)) {
         target = Buffer2.from(target, target.offset, target.byteLength);
       }
@@ -46691,12 +46715,12 @@ void main() {
   function dew$d() {
     if (_dewExec$d) return exports$d;
     _dewExec$d = true;
-    function ownKeys(object, enumerableOnly) {
-      var keys = Object.keys(object);
+    function ownKeys(object2, enumerableOnly) {
+      var keys = Object.keys(object2);
       if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
+        var symbols = Object.getOwnPropertySymbols(object2);
         if (enumerableOnly) symbols = symbols.filter(function(sym) {
-          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+          return Object.getOwnPropertyDescriptor(object2, sym).enumerable;
         });
         keys.push.apply(keys, symbols);
       }
@@ -47262,15 +47286,15 @@ void main() {
     if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
       realHasInstance = Function.prototype[Symbol.hasInstance];
       Object.defineProperty(Writable, Symbol.hasInstance, {
-        value: function value(object) {
-          if (realHasInstance.call(this, object)) return true;
+        value: function value(object2) {
+          if (realHasInstance.call(this, object2)) return true;
           if (this !== Writable) return false;
-          return object && object._writableState instanceof WritableState;
+          return object2 && object2._writableState instanceof WritableState;
         }
       });
     } else {
-      realHasInstance = function realHasInstance2(object) {
-        return object instanceof this;
+      realHasInstance = function realHasInstance2(object2) {
+        return object2 instanceof this;
       };
     }
     function Writable(options) {
@@ -55765,8 +55789,8 @@ void main() {
         return false;
       }
       function baseProperty(key) {
-        return function(object) {
-          return object == null ? void 0 : object[key];
+        return function(object2) {
+          return object2 == null ? void 0 : object2[key];
         };
       }
       function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
@@ -55787,8 +55811,8 @@ void main() {
           return func(value);
         };
       }
-      function getValue(object, key) {
-        return object == null ? void 0 : object[key];
+      function getValue(object2, key) {
+        return object2 == null ? void 0 : object2[key];
       }
       function isHostObject(value) {
         var result = false;
@@ -56036,22 +56060,22 @@ void main() {
       }
       var baseEach = createBaseEach(baseForOwn);
       var baseFor = createBaseFor();
-      function baseForOwn(object, iteratee) {
-        return object && baseFor(object, iteratee, keys);
+      function baseForOwn(object2, iteratee) {
+        return object2 && baseFor(object2, iteratee, keys);
       }
-      function baseGet(object, path) {
-        path = isKey(path, object) ? [path] : castPath(path);
+      function baseGet(object2, path) {
+        path = isKey(path, object2) ? [path] : castPath(path);
         var index = 0, length = path.length;
-        while (object != null && index < length) {
-          object = object[toKey(path[index++])];
+        while (object2 != null && index < length) {
+          object2 = object2[toKey(path[index++])];
         }
-        return index && index == length ? object : void 0;
+        return index && index == length ? object2 : void 0;
       }
       function baseGetTag(value) {
         return objectToString.call(value);
       }
-      function baseHasIn(object, key) {
-        return object != null && key in Object(object);
+      function baseHasIn(object2, key) {
+        return object2 != null && key in Object(object2);
       }
       function baseIsEqual(value, other, customizer, bitmask, stack) {
         if (value === other) {
@@ -56062,25 +56086,25 @@ void main() {
         }
         return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack);
       }
-      function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
-        var objIsArr = isArray2(object), othIsArr = isArray2(other), objTag = arrayTag, othTag = arrayTag;
+      function baseIsEqualDeep(object2, other, equalFunc, customizer, bitmask, stack) {
+        var objIsArr = isArray2(object2), othIsArr = isArray2(other), objTag = arrayTag, othTag = arrayTag;
         if (!objIsArr) {
-          objTag = getTag(object);
+          objTag = getTag(object2);
           objTag = objTag == argsTag ? objectTag : objTag;
         }
         if (!othIsArr) {
           othTag = getTag(other);
           othTag = othTag == argsTag ? objectTag : othTag;
         }
-        var objIsObj = objTag == objectTag && !isHostObject(object), othIsObj = othTag == objectTag && !isHostObject(other), isSameTag = objTag == othTag;
+        var objIsObj = objTag == objectTag && !isHostObject(object2), othIsObj = othTag == objectTag && !isHostObject(other), isSameTag = objTag == othTag;
         if (isSameTag && !objIsObj) {
           stack || (stack = new Stack());
-          return objIsArr || isTypedArray2(object) ? equalArrays(object, other, equalFunc, customizer, bitmask, stack) : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
+          return objIsArr || isTypedArray2(object2) ? equalArrays(object2, other, equalFunc, customizer, bitmask, stack) : equalByTag(object2, other, objTag, equalFunc, customizer, bitmask, stack);
         }
         if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
-          var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+          var objIsWrapped = objIsObj && hasOwnProperty.call(object2, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
           if (objIsWrapped || othIsWrapped) {
-            var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+            var objUnwrapped = objIsWrapped ? object2.value() : object2, othUnwrapped = othIsWrapped ? other.value() : other;
             stack || (stack = new Stack());
             return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);
           }
@@ -56089,31 +56113,31 @@ void main() {
           return false;
         }
         stack || (stack = new Stack());
-        return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
+        return equalObjects(object2, other, equalFunc, customizer, bitmask, stack);
       }
-      function baseIsMatch(object, source, matchData, customizer) {
+      function baseIsMatch(object2, source, matchData, customizer) {
         var index = matchData.length, length = index, noCustomizer = !customizer;
-        if (object == null) {
+        if (object2 == null) {
           return !length;
         }
-        object = Object(object);
+        object2 = Object(object2);
         while (index--) {
           var data = matchData[index];
-          if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+          if (noCustomizer && data[2] ? data[1] !== object2[data[0]] : !(data[0] in object2)) {
             return false;
           }
         }
         while (++index < length) {
           data = matchData[index];
-          var key = data[0], objValue = object[key], srcValue = data[1];
+          var key = data[0], objValue = object2[key], srcValue = data[1];
           if (noCustomizer && data[2]) {
-            if (objValue === void 0 && !(key in object)) {
+            if (objValue === void 0 && !(key in object2)) {
               return false;
             }
           } else {
             var stack = new Stack();
             if (customizer) {
-              var result = customizer(objValue, srcValue, key, object, source, stack);
+              var result = customizer(objValue, srcValue, key, object2, source, stack);
             }
             if (!(result === void 0 ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack) : result)) {
               return false;
@@ -56126,8 +56150,8 @@ void main() {
         if (!isObject2(value) || isMasked(value)) {
           return false;
         }
-        var pattern = isFunction2(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
-        return pattern.test(toSource(value));
+        var pattern2 = isFunction2(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
+        return pattern2.test(toSource(value));
       }
       function baseIsTypedArray(value) {
         return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
@@ -56144,13 +56168,13 @@ void main() {
         }
         return property(value);
       }
-      function baseKeys(object) {
-        if (!isPrototype(object)) {
-          return nativeKeys(object);
+      function baseKeys(object2) {
+        if (!isPrototype(object2)) {
+          return nativeKeys(object2);
         }
         var result = [];
-        for (var key in Object(object)) {
-          if (hasOwnProperty.call(object, key) && key != "constructor") {
+        for (var key in Object(object2)) {
+          if (hasOwnProperty.call(object2, key) && key != "constructor") {
             result.push(key);
           }
         }
@@ -56161,22 +56185,22 @@ void main() {
         if (matchData.length == 1 && matchData[0][2]) {
           return matchesStrictComparable(matchData[0][0], matchData[0][1]);
         }
-        return function(object) {
-          return object === source || baseIsMatch(object, source, matchData);
+        return function(object2) {
+          return object2 === source || baseIsMatch(object2, source, matchData);
         };
       }
       function baseMatchesProperty(path, srcValue) {
         if (isKey(path) && isStrictComparable(srcValue)) {
           return matchesStrictComparable(toKey(path), srcValue);
         }
-        return function(object) {
-          var objValue = get(object, path);
-          return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, void 0, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
+        return function(object2) {
+          var objValue = get(object2, path);
+          return objValue === void 0 && objValue === srcValue ? hasIn(object2, path) : baseIsEqual(srcValue, objValue, void 0, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
         };
       }
       function basePropertyDeep(path) {
-        return function(object) {
-          return baseGet(object, path);
+        return function(object2) {
+          return baseGet(object2, path);
         };
       }
       function baseToString(value) {
@@ -56210,15 +56234,15 @@ void main() {
         };
       }
       function createBaseFor(fromRight) {
-        return function(object, iteratee, keysFunc) {
-          var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+        return function(object2, iteratee, keysFunc) {
+          var index = -1, iterable = Object(object2), props = keysFunc(object2), length = props.length;
           while (length--) {
             var key = props[fromRight ? length : ++index];
             if (iteratee(iterable[key], key, iterable) === false) {
               break;
             }
           }
-          return object;
+          return object2;
         };
       }
       function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
@@ -56263,54 +56287,54 @@ void main() {
         stack["delete"](other);
         return result;
       }
-      function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
+      function equalByTag(object2, other, tag, equalFunc, customizer, bitmask, stack) {
         switch (tag) {
           case dataViewTag:
-            if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+            if (object2.byteLength != other.byteLength || object2.byteOffset != other.byteOffset) {
               return false;
             }
-            object = object.buffer;
+            object2 = object2.buffer;
             other = other.buffer;
           case arrayBufferTag:
-            if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
+            if (object2.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object2), new Uint8Array2(other))) {
               return false;
             }
             return true;
           case boolTag:
           case dateTag:
           case numberTag:
-            return eq(+object, +other);
+            return eq(+object2, +other);
           case errorTag:
-            return object.name == other.name && object.message == other.message;
+            return object2.name == other.name && object2.message == other.message;
           case regexpTag:
           case stringTag:
-            return object == other + "";
+            return object2 == other + "";
           case mapTag:
             var convert = mapToArray;
           case setTag:
             var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
             convert || (convert = setToArray);
-            if (object.size != other.size && !isPartial) {
+            if (object2.size != other.size && !isPartial) {
               return false;
             }
-            var stacked = stack.get(object);
+            var stacked = stack.get(object2);
             if (stacked) {
               return stacked == other;
             }
             bitmask |= UNORDERED_COMPARE_FLAG;
-            stack.set(object, other);
-            var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
-            stack["delete"](object);
+            stack.set(object2, other);
+            var result = equalArrays(convert(object2), convert(other), equalFunc, customizer, bitmask, stack);
+            stack["delete"](object2);
             return result;
           case symbolTag:
             if (symbolValueOf) {
-              return symbolValueOf.call(object) == symbolValueOf.call(other);
+              return symbolValueOf.call(object2) == symbolValueOf.call(other);
             }
         }
         return false;
       }
-      function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
-        var isPartial = bitmask & PARTIAL_COMPARE_FLAG, objProps = keys(object), objLength = objProps.length, othProps = keys(other), othLength = othProps.length;
+      function equalObjects(object2, other, equalFunc, customizer, bitmask, stack) {
+        var isPartial = bitmask & PARTIAL_COMPARE_FLAG, objProps = keys(object2), objLength = objProps.length, othProps = keys(other), othLength = othProps.length;
         if (objLength != othLength && !isPartial) {
           return false;
         }
@@ -56321,19 +56345,19 @@ void main() {
             return false;
           }
         }
-        var stacked = stack.get(object);
+        var stacked = stack.get(object2);
         if (stacked && stack.get(other)) {
           return stacked == other;
         }
         var result = true;
-        stack.set(object, other);
-        stack.set(other, object);
+        stack.set(object2, other);
+        stack.set(other, object2);
         var skipCtor = isPartial;
         while (++index < objLength) {
           key = objProps[index];
-          var objValue = object[key], othValue = other[key];
+          var objValue = object2[key], othValue = other[key];
           if (customizer) {
-            var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+            var compared = isPartial ? customizer(othValue, objValue, key, other, object2, stack) : customizer(objValue, othValue, key, object2, other, stack);
           }
           if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack) : compared)) {
             result = false;
@@ -56342,12 +56366,12 @@ void main() {
           skipCtor || (skipCtor = key == "constructor");
         }
         if (result && !skipCtor) {
-          var objCtor = object.constructor, othCtor = other.constructor;
-          if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+          var objCtor = object2.constructor, othCtor = other.constructor;
+          if (objCtor != othCtor && ("constructor" in object2 && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
             result = false;
           }
         }
-        stack["delete"](object);
+        stack["delete"](object2);
         stack["delete"](other);
         return result;
       }
@@ -56355,16 +56379,16 @@ void main() {
         var data = map.__data__;
         return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
       }
-      function getMatchData(object) {
-        var result = keys(object), length = result.length;
+      function getMatchData(object2) {
+        var result = keys(object2), length = result.length;
         while (length--) {
-          var key = result[length], value = object[key];
+          var key = result[length], value = object2[key];
           result[length] = [key, value, isStrictComparable(value)];
         }
         return result;
       }
-      function getNative(object, key) {
-        var value = getValue(object, key);
+      function getNative(object2, key) {
+        var value = getValue(object2, key);
         return baseIsNative(value) ? value : void 0;
       }
       var getTag = baseGetTag;
@@ -56388,27 +56412,27 @@ void main() {
           return result;
         };
       }
-      function hasPath(object, path, hasFunc) {
-        path = isKey(path, object) ? [path] : castPath(path);
+      function hasPath(object2, path, hasFunc) {
+        path = isKey(path, object2) ? [path] : castPath(path);
         var result, index = -1, length = path.length;
         while (++index < length) {
           var key = toKey(path[index]);
-          if (!(result = object != null && hasFunc(object, key))) {
+          if (!(result = object2 != null && hasFunc(object2, key))) {
             break;
           }
-          object = object[key];
+          object2 = object2[key];
         }
         if (result) {
           return result;
         }
-        var length = object ? object.length : 0;
-        return !!length && isLength(length) && isIndex(key, length) && (isArray2(object) || isArguments(object));
+        var length = object2 ? object2.length : 0;
+        return !!length && isLength(length) && isIndex(key, length) && (isArray2(object2) || isArguments(object2));
       }
       function isIndex(value, length) {
         length = length == null ? MAX_SAFE_INTEGER : length;
         return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
       }
-      function isKey(value, object) {
+      function isKey(value, object2) {
         if (isArray2(value)) {
           return false;
         }
@@ -56416,7 +56440,7 @@ void main() {
         if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol2(value)) {
           return true;
         }
-        return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+        return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object2 != null && value in Object(object2);
       }
       function isKeyable(value) {
         var type = typeof value;
@@ -56433,11 +56457,11 @@ void main() {
         return value === value && !isObject2(value);
       }
       function matchesStrictComparable(key, srcValue) {
-        return function(object) {
-          if (object == null) {
+        return function(object2) {
+          if (object2 == null) {
             return false;
           }
-          return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+          return object2[key] === srcValue && (srcValue !== void 0 || key in Object(object2));
         };
       }
       var stringToPath = memoize(function(string) {
@@ -56526,15 +56550,15 @@ void main() {
       function toString(value) {
         return value == null ? "" : baseToString(value);
       }
-      function get(object, path, defaultValue) {
-        var result = object == null ? void 0 : baseGet(object, path);
+      function get(object2, path, defaultValue) {
+        var result = object2 == null ? void 0 : baseGet(object2, path);
         return result === void 0 ? defaultValue : result;
       }
-      function hasIn(object, path) {
-        return object != null && hasPath(object, path, baseHasIn);
+      function hasIn(object2, path) {
+        return object2 != null && hasPath(object2, path, baseHasIn);
       }
-      function keys(object) {
-        return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+      function keys(object2) {
+        return isArrayLike(object2) ? arrayLikeKeys(object2) : baseKeys(object2);
       }
       function identity(value) {
         return value;
@@ -62833,9 +62857,9 @@ void main() {
         }
         return text.slice(0, -separator.length);
       }
-      function addFormat(name2, format2) {
-        if (typeof format2 == "string") format2 = new RegExp(format2);
-        this._formats[name2] = format2;
+      function addFormat(name2, format3) {
+        if (typeof format3 == "string") format3 = new RegExp(format3);
+        this._formats[name2] = format3;
         return this;
       }
       function addDefaultMetaSchema(self2) {
@@ -62858,8 +62882,8 @@ void main() {
       }
       function addInitialFormats(self2) {
         for (var name2 in self2._opts.formats) {
-          var format2 = self2._opts.formats[name2];
-          self2.addFormat(name2, format2);
+          var format3 = self2._opts.formats[name2];
+          self2.addFormat(name2, format3);
         }
       }
       function addInitialKeywords(self2) {
@@ -63926,13 +63950,13 @@ void main() {
         }
       }
     };
-    var forEachObject = function forEachObject2(object, iterator, receiver) {
-      for (var k4 in object) {
-        if (hasOwnProperty.call(object, k4)) {
+    var forEachObject = function forEachObject2(object2, iterator, receiver) {
+      for (var k4 in object2) {
+        if (hasOwnProperty.call(object2, k4)) {
           if (receiver == null) {
-            iterator(object[k4], k4, object);
+            iterator(object2[k4], k4, object2);
           } else {
-            iterator.call(receiver, object[k4], k4, object);
+            iterator.call(receiver, object2[k4], k4, object2);
           }
         }
       }
@@ -65785,36 +65809,36 @@ void main() {
           return false;
         }
       };
-      keysShim = function keys(object) {
-        var isObject2 = object !== null && typeof object === "object";
-        var isFunction2 = toStr.call(object) === "[object Function]";
-        var isArguments = isArgs(object);
-        var isString2 = isObject2 && toStr.call(object) === "[object String]";
+      keysShim = function keys(object2) {
+        var isObject2 = object2 !== null && typeof object2 === "object";
+        var isFunction2 = toStr.call(object2) === "[object Function]";
+        var isArguments = isArgs(object2);
+        var isString2 = isObject2 && toStr.call(object2) === "[object String]";
         var theKeys = [];
         if (!isObject2 && !isFunction2 && !isArguments) {
           throw new TypeError("Object.keys called on a non-object");
         }
         var skipProto = hasProtoEnumBug && isFunction2;
-        if (isString2 && object.length > 0 && !has.call(object, 0)) {
-          for (var i4 = 0; i4 < object.length; ++i4) {
+        if (isString2 && object2.length > 0 && !has.call(object2, 0)) {
+          for (var i4 = 0; i4 < object2.length; ++i4) {
             theKeys.push(String(i4));
           }
         }
-        if (isArguments && object.length > 0) {
-          for (var j4 = 0; j4 < object.length; ++j4) {
+        if (isArguments && object2.length > 0) {
+          for (var j4 = 0; j4 < object2.length; ++j4) {
             theKeys.push(String(j4));
           }
         } else {
-          for (var name2 in object) {
-            if (!(skipProto && name2 === "prototype") && has.call(object, name2)) {
+          for (var name2 in object2) {
+            if (!(skipProto && name2 === "prototype") && has.call(object2, name2)) {
               theKeys.push(String(name2));
             }
           }
         }
         if (hasDontEnumBug) {
-          var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+          var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object2);
           for (var k4 = 0; k4 < dontEnums.length; ++k4) {
-            if (!(skipConstructor && dontEnums[k4] === "constructor") && has.call(object, dontEnums[k4])) {
+            if (!(skipConstructor && dontEnums[k4] === "constructor") && has.call(object2, dontEnums[k4])) {
               theKeys.push(dontEnums[k4]);
             }
           }
@@ -65842,11 +65866,11 @@ void main() {
           return args && args.length === arguments.length;
         }(1, 2);
         if (!keysWorksWithArguments) {
-          Object.keys = function keys(object) {
-            if (isArgs(object)) {
-              return originalKeys(slice.call(object));
+          Object.keys = function keys(object2) {
+            if (isArgs(object2)) {
+              return originalKeys(slice.call(object2));
             }
-            return originalKeys(object);
+            return originalKeys(object2);
           };
         }
       } else {
@@ -65990,10 +66014,10 @@ void main() {
       return typeof fn === "function" && toStr.call(fn) === "[object Function]";
     };
     var supportsDescriptors = dew$33()();
-    var defineProperty = function(object, name2, value, predicate) {
-      if (name2 in object) {
+    var defineProperty = function(object2, name2, value, predicate) {
+      if (name2 in object2) {
         if (predicate === true) {
-          if (object[name2] === value) {
+          if (object2[name2] === value) {
             return;
           }
         } else if (!isFunction2(predicate) || !predicate()) {
@@ -66001,19 +66025,19 @@ void main() {
         }
       }
       if (supportsDescriptors) {
-        defineDataProperty(object, name2, value, true);
+        defineDataProperty(object2, name2, value, true);
       } else {
-        defineDataProperty(object, name2, value);
+        defineDataProperty(object2, name2, value);
       }
     };
-    var defineProperties = function(object, map) {
+    var defineProperties = function(object2, map) {
       var predicates = arguments.length > 2 ? arguments[2] : {};
       var props = keys(map);
       if (hasSymbols) {
         props = concat2.call(props, Object.getOwnPropertySymbols(map));
       }
       for (var i4 = 0; i4 < props.length; i4 += 1) {
-        defineProperty(object, props[i4], map[props[i4]], predicates[props[i4]]);
+        defineProperty(object2, props[i4], map[props[i4]], predicates[props[i4]]);
       }
     };
     defineProperties.supportsDescriptors = !!supportsDescriptors;
@@ -66200,7 +66224,7 @@ void main() {
     function getOwnNonIndexProperties(value) {
       return Object.keys(value).filter(isNonIndex).concat(objectGetOwnPropertySymbols(value).filter(Object.prototype.propertyIsEnumerable.bind(value)));
     }
-    function compare(a4, b4) {
+    function compare2(a4, b4) {
       if (a4 === b4) {
         return 0;
       }
@@ -66245,10 +66269,10 @@ void main() {
       if (a4.byteLength !== b4.byteLength) {
         return false;
       }
-      return compare(new Uint8Array(a4.buffer, a4.byteOffset, a4.byteLength), new Uint8Array(b4.buffer, b4.byteOffset, b4.byteLength)) === 0;
+      return compare2(new Uint8Array(a4.buffer, a4.byteOffset, a4.byteLength), new Uint8Array(b4.buffer, b4.byteOffset, b4.byteLength)) === 0;
     }
     function areEqualArrayBuffers(buf1, buf2) {
-      return buf1.byteLength === buf2.byteLength && compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0;
+      return buf1.byteLength === buf2.byteLength && compare2(new Uint8Array(buf1), new Uint8Array(buf2)) === 0;
     }
     function isEqualBoxedPrimitive(val1, val2) {
       if (isNumberObject(val1)) {
@@ -69360,8 +69384,8 @@ void main() {
       init_buffer2();
       init_process2();
       module2.exports = {
-        format(format2, ...args) {
-          return format2.replace(/%([sdifj])/g, function(...[_unused, type]) {
+        format(format3, ...args) {
+          return format3.replace(/%([sdifj])/g, function(...[_unused, type]) {
             const replacement = args.shift();
             if (type === "f") {
               return replacement.toFixed(6);
@@ -69413,7 +69437,7 @@ void main() {
       init_dirname();
       init_buffer2();
       init_process2();
-      var { format: format2, inspect: inspect2 } = require_inspect();
+      var { format: format3, inspect: inspect2 } = require_inspect();
       var { AggregateError: CustomAggregateError } = require_primordials();
       var AggregateError2 = globalThis.AggregateError || CustomAggregateError;
       var kIsNodeError = Symbol("kIsNodeError");
@@ -69463,7 +69487,7 @@ void main() {
         if (args.length === 0) {
           return msg;
         }
-        return format2(msg, ...args);
+        return format3(msg, ...args);
       }
       function E4(code2, message, Base) {
         if (!Base) {
@@ -69752,7 +69776,7 @@ void main() {
       init_buffer2();
       init_process2();
       var bufferModule = (init_buffer(), __toCommonJS(buffer_exports));
-      var { format: format2, inspect: inspect2 } = require_inspect();
+      var { format: format3, inspect: inspect2 } = require_inspect();
       var {
         codes: { ERR_INVALID_ARG_TYPE }
       } = require_errors();
@@ -69817,7 +69841,7 @@ void main() {
           return function() {
           };
         },
-        format: format2,
+        format: format3,
         inspect: inspect2,
         types: {
           isAsyncFunction(fn) {
@@ -72877,10 +72901,10 @@ void main() {
       }
       ObjectDefineProperty(Writable, SymbolHasInstance, {
         __proto__: null,
-        value: function(object) {
-          if (FunctionPrototypeSymbolHasInstance(this, object)) return true;
+        value: function(object2) {
+          if (FunctionPrototypeSymbolHasInstance(this, object2)) return true;
           if (this !== Writable) return false;
-          return object && object._writableState instanceof WritableState;
+          return object2 && object2._writableState instanceof WritableState;
         }
       });
       Writable.prototype.pipe = function() {
@@ -75328,13 +75352,13 @@ void main() {
       module2.exports = {
         Read: {
           switch: ["parametrizable", (compiler, struct) => {
-            let compare = struct.compareTo ? struct.compareTo : struct.compareToValue;
+            let compare2 = struct.compareTo ? struct.compareTo : struct.compareToValue;
             const args = [];
-            if (compare.startsWith("$")) args.push(compare);
+            if (compare2.startsWith("$")) args.push(compare2);
             else if (struct.compareTo) {
-              compare = compiler.getField(compare, true);
+              compare2 = compiler.getField(compare2, true);
             }
-            let code2 = `switch (${compare}) {
+            let code2 = `switch (${compare2}) {
 `;
             for (const key in struct.fields) {
               let val = key;
@@ -75358,13 +75382,13 @@ void main() {
         },
         Write: {
           switch: ["parametrizable", (compiler, struct) => {
-            let compare = struct.compareTo ? struct.compareTo : struct.compareToValue;
+            let compare2 = struct.compareTo ? struct.compareTo : struct.compareToValue;
             const args = [];
-            if (compare.startsWith("$")) args.push(compare);
+            if (compare2.startsWith("$")) args.push(compare2);
             else if (struct.compareTo) {
-              compare = compiler.getField(compare, true);
+              compare2 = compiler.getField(compare2, true);
             }
-            let code2 = `switch (${compare}) {
+            let code2 = `switch (${compare2}) {
 `;
             for (const key in struct.fields) {
               let val = key;
@@ -75389,13 +75413,13 @@ void main() {
         },
         SizeOf: {
           switch: ["parametrizable", (compiler, struct) => {
-            let compare = struct.compareTo ? struct.compareTo : struct.compareToValue;
+            let compare2 = struct.compareTo ? struct.compareTo : struct.compareToValue;
             const args = [];
-            if (compare.startsWith("$")) args.push(compare);
+            if (compare2.startsWith("$")) args.push(compare2);
             else if (struct.compareTo) {
-              compare = compiler.getField(compare, true);
+              compare2 = compiler.getField(compare2, true);
             }
-            let code2 = `switch (${compare}) {
+            let code2 = `switch (${compare2}) {
 `;
             for (const key in struct.fields) {
               let val = key;
@@ -76950,18 +76974,18 @@ return ${compiler2.callType("value", tagType)}
         parsed.type = type;
         return parsed;
       }
-      async function parse(data, format2, callback) {
+      async function parse(data, format3, callback) {
         let fmt = null;
-        if (typeof format2 === "function") {
-          callback = format2;
-        } else if (format2 === true || format2 === "little") {
+        if (typeof format3 === "function") {
+          callback = format3;
+        } else if (format3 === true || format3 === "little") {
           fmt = "little";
-        } else if (format2 === "big") {
+        } else if (format3 === "big") {
           fmt = "big";
-        } else if (format2 === "littleVarint") {
+        } else if (format3 === "littleVarint") {
           fmt = "littleVarint";
-        } else if (format2) {
-          throw new Error("Unrecognized format: " + format2);
+        } else if (format3) {
+          throw new Error("Unrecognized format: " + format3);
         }
         data.startOffset = data.startOffset || 0;
         if (!fmt && !data.startOffset) {
@@ -77137,10 +77161,10 @@ return ${compiler2.callType("value", tagType)}
       init_process2();
       init_buffer();
       NBTHelper = class {
-        static async fromBuffer(data, format2) {
+        static async fromBuffer(data, format3) {
           const buffer2 = Buffer.from(data instanceof Uint8Array ? data : new Uint8Array(data));
           const prismarineNbt = await Promise.resolve().then(() => __toESM(require_nbt2()));
-          const { parsed, type, metadata } = await prismarineNbt.parse(buffer2, format2);
+          const { parsed, type, metadata } = await prismarineNbt.parse(buffer2, format3);
           return Object.assign(parsed, {
             format: type,
             metadata,
@@ -84995,10 +85019,10 @@ return ${compiler2.callType("value", tagType)}
     });
     return passwordVerification;
   }
-  async function importKey(format2, password, algorithm, extractable, keyUsages) {
+  async function importKey(format3, password, algorithm, extractable, keyUsages) {
     if (IMPORT_KEY_SUPPORTED) {
       try {
-        return await subtle.importKey(format2, password, algorithm, extractable, keyUsages);
+        return await subtle.importKey(format3, password, algorithm, extractable, keyUsages);
       } catch (_4) {
         IMPORT_KEY_SUPPORTED = false;
         return misc.importKey(password);
@@ -87004,6 +87028,168 @@ return ${compiler2.callType("value", tagType)}
     }
   });
 
+  // src/assets/source/archive/PackMetadata.ts
+  function object(value, field) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error(`Invalid ${field}: expected an object`);
+    }
+    return value;
+  }
+  function integer(value, field) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+      throw new Error(`Invalid ${field}: expected a nonnegative integer`);
+    }
+    return value;
+  }
+  function format2(value, field, upper = false) {
+    const parts = Array.isArray(value) ? value : [value];
+    if (parts.length < 1 || parts.length > 2) {
+      throw new Error(`Invalid ${field}: expected a major version or [major, minor]`);
+    }
+    return [integer(parts[0], field), parts.length === 2 ? integer(parts[1], field) : upper ? Infinity : 0];
+  }
+  function compare(a4, b4) {
+    return a4[0] === b4[0] ? a4[1] - b4[1] : a4[0] - b4[0];
+  }
+  function overlay(value, field) {
+    const entry = object(value, field);
+    const directory = entry.directory;
+    if (typeof directory !== "string" || !directory || /[^-_a-zA-Z0-9.]/.test(directory) || directory === "." || directory === "..") {
+      throw new Error(`Invalid ${field}.directory: expected a directory name without path separators`);
+    }
+    let min, max2;
+    if ("min_format" in entry || "max_format" in entry) {
+      min = format2(entry.min_format, `${field}.min_format`);
+      max2 = format2(entry.max_format, `${field}.max_format`, true);
+    } else {
+      const range = entry.formats;
+      let lower, upper;
+      if (typeof range === "number") {
+        lower = upper = range;
+      } else if (Array.isArray(range)) {
+        if (range.length !== 2) throw new Error(`Invalid ${field}.formats: expected [min, max]`);
+        [lower, upper] = range;
+      } else {
+        const bounds = object(range, `${field}.formats`);
+        lower = bounds.min_inclusive;
+        upper = bounds.max_inclusive;
+      }
+      min = [integer(lower, `${field}.formats.min_inclusive`), 0];
+      max2 = [integer(upper, `${field}.formats.max_inclusive`), Infinity];
+    }
+    if (compare(min, max2) > 0) throw new Error(`Invalid ${field}: minimum format exceeds maximum format`);
+    return { directory, min, max: max2 };
+  }
+  function pattern(value, field) {
+    if (value === void 0) return void 0;
+    if (typeof value !== "string") throw new Error(`Invalid ${field}: expected a regular expression string`);
+    try {
+      return new RegExp(value);
+    } catch (cause) {
+      throw new Error(`Invalid ${field}: ${String(cause)}`);
+    }
+  }
+  var PackMetadata;
+  var init_PackMetadata = __esm({
+    "src/assets/source/archive/PackMetadata.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      PackMetadata = class _PackMetadata {
+        constructor(overlays, filters) {
+          this.overlays = overlays;
+          this.filters = filters;
+          this.hasOverlays = overlays.length > 0;
+        }
+        static parse(value) {
+          const metadata = object(value, "pack.mcmeta");
+          let overlays = [];
+          if ("overlays" in metadata) {
+            const entries = object(metadata.overlays, "overlays").entries;
+            if (!Array.isArray(entries)) throw new Error("Invalid overlays.entries: expected an array");
+            overlays = entries.map((entry, index) => overlay(entry, `overlays.entries[${index}]`));
+          }
+          let filters = [];
+          if ("filter" in metadata) {
+            const entries = object(metadata.filter, "filter").block;
+            if (!Array.isArray(entries)) throw new Error("Invalid filter.block: expected an array");
+            filters = entries.map((value2, index) => {
+              const field = `filter.block[${index}]`;
+              const entry = object(value2, field);
+              return { namespace: pattern(entry.namespace, `${field}.namespace`), path: pattern(entry.path, `${field}.path`) };
+            });
+          }
+          return new _PackMetadata(overlays, filters);
+        }
+        /** Returns applicable directories in lookup order, with the last declared overlay first. */
+        overlayDirectories(target) {
+          const selected = format2(target, "target format");
+          return this.overlays.filter((entry) => compare(selected, entry.min) >= 0 && compare(selected, entry.max) <= 0).map((entry) => entry.directory).reverse();
+        }
+        blocks(namespace, path) {
+          return this.filters.some((entry) => entry.namespace?.test(namespace) ?? true) && this.filters.some((entry) => entry.path?.test(path) ?? true);
+        }
+      };
+    }
+  });
+
+  // src/assets/source/archive/PackFormats.ts
+  var PackFormats;
+  var init_PackFormats = __esm({
+    "src/assets/source/archive/PackFormats.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_Requests();
+      PackFormats = class {
+        /** Resolves pack formats from Mojang's client metadata hosted on assets.mcasset.cloud. */
+        static async get(version2, type) {
+          let pending = this.versions.get(version2);
+          if (!pending || pending.expires <= Date.now()) {
+            pending = {
+              formats: this.load(version2),
+              expires: ["latest", "release", "snapshot"].includes(version2) ? Date.now() + 3e5 : Infinity
+            };
+            this.versions.set(version2, pending);
+          }
+          try {
+            return (await pending.formats)[type];
+          } catch (cause) {
+            if (this.versions.get(version2) === pending) this.versions.delete(version2);
+            const option = type === "assets" ? "resourcePackFormat" : "dataPackFormat";
+            const reason = cause instanceof Error ? cause.message : String(cause);
+            throw new Error(`Could not resolve the pack format for Minecraft ${version2}. Set ArchiveAssetSource ${option} explicitly. ${reason}`);
+          }
+        }
+        static async load(version2) {
+          const response = await Requests.genericRequest({
+            url: `https://assets.mcasset.cloud/${encodeURIComponent(version2)}/game-version.json`,
+            responseType: "json"
+          });
+          const data = response.data;
+          if (!data || typeof data !== "object" || Array.isArray(data)) {
+            throw new Error("Expected version metadata to be an object");
+          }
+          const packs = data.pack_version;
+          if (typeof packs !== "number" && (!packs || typeof packs !== "object" || Array.isArray(packs))) {
+            throw new Error("Expected pack_version to be a number or an object");
+          }
+          const format3 = (type) => {
+            const modern = typeof packs === "object" && ["resource_major", "resource_minor", "data_major", "data_minor"].some((key) => key in packs);
+            const major = typeof packs === "number" ? packs : packs[modern ? `${type}_major` : type];
+            const minor = modern ? packs[`${type}_minor`] : 0;
+            if (typeof major !== "number" || !Number.isSafeInteger(major) || major < 0 || typeof minor !== "number" || !Number.isSafeInteger(minor) || minor < 0) {
+              throw new Error(`Invalid ${type} pack format in version metadata`);
+            }
+            return Object.freeze([major, minor]);
+          };
+          return { assets: format3("resource"), data: format3("data") };
+        }
+      };
+      PackFormats.versions = /* @__PURE__ */ new Map();
+    }
+  });
+
   // src/assets/source/archive/ArchiveAssetSource.ts
   var ArchiveAssetSource;
   var init_ArchiveAssetSource = __esm({
@@ -87015,35 +87201,77 @@ return ${compiler2.callType("value", tagType)}
       init_request();
       init_HostedAssetSource();
       init_BrowserArchiveProxy();
+      init_AssetLoader();
+      init_PackMetadata();
+      init_PackFormats();
       ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
-        constructor(archiveProxy) {
+        constructor(archiveProxy, options = {}) {
           super();
-          console.log(archiveProxy);
           this._archiveProxy = archiveProxy;
+          const copyFormat = (format3) => typeof format3 === "object" ? [format3[0], format3[1]] : format3;
+          this.options = {
+            resourcePackFormat: copyFormat(options.resourcePackFormat),
+            dataPackFormat: copyFormat(options.dataPackFormat)
+          };
         }
-        static blob(blob) {
-          return new _ArchiveAssetSource(new BrowserArchiveProxy(blob));
+        static blob(blob, options) {
+          return new _ArchiveAssetSource(new BrowserArchiveProxy(blob), options);
         }
         get cacheId() {
           const id = this._archiveProxy.id;
-          return id === void 0 ? void 0 : `archive:${id}`;
+          const formats = [this.options.resourcePackFormat ?? AssetLoader.version, this.options.dataPackFormat ?? AssetLoader.version];
+          return id === void 0 ? void 0 : `archive-metadata:1:${id}:${JSON.stringify(formats)}`;
         }
         async getEntries() {
-          return this._archiveProxy.getEntries();
+          return this.entries ?? (this.entries = this._archiveProxy.getEntries().catch((error2) => {
+            this.entries = void 0;
+            throw error2;
+          }));
         }
         async getEntry(path) {
           const entries = await this.getEntries();
           return entries.find((e6) => e6.filename === path);
         }
+        async getMetadata(key) {
+          try {
+            return await (this.metadata ?? (this.metadata = this.getEntry("pack.mcmeta").then(async (entry) => PackMetadata.parse(entry ? JSON.parse(await (await entry.getData()).text()) : {})).catch((error2) => {
+              this.metadata = void 0;
+              throw error2;
+            })));
+          } catch (cause) {
+            throw new AssetLoadError(this, key, "pack.mcmeta", cause);
+          }
+        }
+        async blocks(key) {
+          if (key.rootType !== "assets" && key.rootType !== "data") return false;
+          const metadata = await this.getMetadata(key);
+          const path = `${key.assetType !== void 0 ? key.assetType + "/" : ""}${key.getFullPath()}${key.extension}`;
+          return metadata.blocks(key.namespace, path);
+        }
         async get(key, parser) {
           const responseParser = HostedAssetSource.PARSER_MAP.get(parser);
           return this.load(key, responseParser);
         }
         async load(key, parser) {
           const path = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
+          const version2 = AssetLoader.version;
+          let selectedPath = path;
           let url;
           try {
-            const entry = await this.getEntry(path);
+            let directories = [];
+            if (key.rootType === "assets" || key.rootType === "data") {
+              const metadata = await this.getMetadata(key);
+              if (metadata.hasOverlays) {
+                const format3 = (key.rootType === "assets" ? this.options.resourcePackFormat : this.options.dataPackFormat) ?? await PackFormats.get(version2, key.rootType);
+                directories = metadata.overlayDirectories(format3);
+              }
+            }
+            let entry;
+            for (const directory of [...directories, ""]) {
+              selectedPath = directory ? `${directory}/${path}` : path;
+              entry = await this.getEntry(selectedPath);
+              if (entry) break;
+            }
             if (!entry) {
               return void 0;
             }
@@ -87056,7 +87284,8 @@ return ${compiler2.callType("value", tagType)}
             }
             return await parser.parse(response);
           } catch (cause) {
-            throw new AssetLoadError(this, key, path, cause);
+            if (cause instanceof AssetLoadError) throw cause;
+            throw new AssetLoadError(this, key, selectedPath, cause);
           } finally {
             if (url !== void 0) {
               URL.revokeObjectURL(url);
@@ -87098,6 +87327,8 @@ return ${compiler2.callType("value", tagType)}
       init_ArchiveEntry();
       init_ArchiveProxy();
       init_BrowserArchiveProxy();
+      init_PackFormats();
+      init_PackMetadata();
     }
   });
 
@@ -87186,13 +87417,14 @@ ${key}` : key;
           return void 0;
         }
         static async getAll(key, parser) {
-          let promises = [];
-          for (const source of this._SOURCES) {
-            promises.push(source.source.get(key, parser));
+          const sources = [...this._SOURCES];
+          const results = [];
+          for (const { source } of sources) {
+            const asset = await source.get(key, parser);
+            if (asset != void 0) results.push(asset);
+            if (await source.blocks(key)) break;
           }
-          return Promise.all(promises).then((results) => {
-            return results.filter((r5) => r5 != void 0);
-          });
+          return results;
         }
         /** Returns the first defined result in source-priority order, without merging assets. */
         static async get(key, parser) {
@@ -87213,13 +87445,17 @@ ${key}` : key;
         /** Tries each path within a source before considering lower-priority sources. */
         static async getFirst(keys, parser) {
           const sources = [...this._SOURCES];
+          let remaining = [...keys];
           for (const source of sources) {
-            for (const key of keys) {
+            for (const key of remaining) {
               const result = await source.source.get(key, parser);
               if (result !== void 0) {
                 return { key, asset: result };
               }
             }
+            const blocked = await Promise.all(remaining.map((key) => source.source.blocks(key)));
+            remaining = remaining.filter((_4, index) => !blocked[index]);
+            if (!remaining.length) break;
           }
           return void 0;
         }
@@ -87688,6 +87924,37 @@ ${key}` : key;
         static facesToUv(faces, originalTextureSize, actualTextureSize) {
           return new Float32BufferAttribute(this.facesToUvArray(faces, originalTextureSize, actualTextureSize), 2);
         }
+        /** Bounds texture sampling to texel centres without changing cropped face UVs. */
+        static setAtlasUvBounds(geometry, faces, atlas) {
+          const uv = geometry.getAttribute("uv");
+          const bounds = new Float32Array(uv.count * 4);
+          for (const [faceIndex, faceName] of CUBE_FACES.entries()) {
+            const texture = faces[faceName]?.texture?.substring(1);
+            const position = texture && atlas.positions[texture];
+            const size = texture && atlas.sizes[texture];
+            let minU = Infinity, minV = Infinity, maxU = -Infinity, maxV = -Infinity;
+            if (position && size) {
+              minU = position[0] / atlas.image.width;
+              maxU = (position[0] + size[0]) / atlas.image.width;
+              minV = 1 - (position[1] + size[1]) / atlas.image.height;
+              maxV = 1 - position[1] / atlas.image.height;
+            } else {
+              for (let corner = 0; corner < 4; corner++) {
+                const index = faceIndex * 4 + corner;
+                minU = Math.min(minU, uv.getX(index));
+                minV = Math.min(minV, uv.getY(index));
+                maxU = Math.max(maxU, uv.getX(index));
+                maxV = Math.max(maxV, uv.getY(index));
+              }
+            }
+            const insetU = Math.min(0.5 / atlas.image.width, (maxU - minU) / 2);
+            const insetV = Math.min(0.5 / atlas.image.height, (maxV - minV) / 2);
+            for (let corner = 0; corner < 4; corner++) {
+              bounds.set([minU + insetU, minV + insetV, maxU - insetU, maxV - insetV], (faceIndex * 4 + corner) * 4);
+            }
+          }
+          geometry.setAttribute("uvBounds", new Float32BufferAttribute(bounds, 4));
+        }
         static lockUvs(geometry, faces, atlas, rotation) {
           const uv = geometry.getAttribute("uv");
           for (let faceIndex = 0; faceIndex < CUBE_FACES.length; faceIndex++) {
@@ -88359,27 +88626,27 @@ ${key}` : key;
           for (const layer of layers) {
             const objects = [];
             if (poses) {
-              layer.traverse((object) => {
-                if (poses.has(object)) objects.push(object);
+              layer.traverse((object2) => {
+                if (poses.has(object2)) objects.push(object2);
               });
             } else {
               for (const bone of Object.keys(animation.bones)) {
-                const object = layer.getObjectByName(`group:${bone}`);
-                if (object) objects.push(object);
+                const object2 = layer.getObjectByName(`group:${bone}`);
+                if (object2) objects.push(object2);
               }
             }
-            for (const object of objects) {
-              const bone = object.name.slice("group:".length);
-              const pose = poses?.get(object);
+            for (const object2 of objects) {
+              const bone = object2.name.slice("group:".length);
+              const pose = poses?.get(object2);
               this.parts.push({
                 bone,
-                object,
-                position: object.position.clone(),
-                rotation: object.rotation.clone(),
-                scale: object.scale.clone(),
-                basePosition: pose ? new Vector3(...pose.offset) : object.position.clone(),
-                baseRotation: pose ? new Euler(...pose.rotation, "ZYX") : object.rotation.clone(),
-                baseScale: pose ? new Vector3(...pose.scale ?? [1, 1, 1]) : object.scale.clone()
+                object: object2,
+                position: object2.position.clone(),
+                rotation: object2.rotation.clone(),
+                scale: object2.scale.clone(),
+                basePosition: pose ? new Vector3(...pose.offset) : object2.position.clone(),
+                baseRotation: pose ? new Euler(...pose.rotation, "ZYX") : object2.rotation.clone(),
+                baseScale: pose ? new Vector3(...pose.scale ?? [1, 1, 1]) : object2.scale.clone()
               });
             }
           }
@@ -88904,15 +89171,15 @@ ${key}` : key;
           }
         }
         //</editor-fold>
-        toggleObjectVisibility(object, visible) {
-          if (object) {
+        toggleObjectVisibility(object2, visible) {
+          if (object2) {
             if (typeof visible !== "undefined") {
-              object.visible = visible;
+              object2.visible = visible;
             } else {
-              object.visible = !object.visible;
+              object2.visible = !object2.visible;
             }
             this.notifyDirty();
-            return object.visible;
+            return object2.visible;
           }
           this.notifyDirty();
           return false;
@@ -89210,8 +89477,8 @@ ${key}` : key;
                 this.scrollMaterials.push({ material: mat, offset: mat.map.offset, speed: scroll });
               }
             }
-            this.getLayerGroup(name2)?.traverse((object) => {
-              if (isMesh(object)) object.material = mat;
+            this.getLayerGroup(name2)?.traverse((object2) => {
+              if (isMesh(object2)) object2.material = mat;
             });
           }));
           if (!this.children.length) {
@@ -89541,8 +89808,8 @@ ${key}` : key;
       return geometry;
     }
   }
-  function computeMorphedAttributes(object) {
-    if (object.geometry.isBufferGeometry !== true) {
+  function computeMorphedAttributes(object2) {
+    if (object2.geometry.isBufferGeometry !== true) {
       console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
       return null;
     }
@@ -89555,11 +89822,11 @@ ${key}` : key;
     const _morphA2 = new Vector3();
     const _morphB = new Vector3();
     const _morphC = new Vector3();
-    function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a5, b5, c5, modifiedAttributeArray) {
+    function _calculateMorphedAttributeData(object3, material2, attribute, morphAttribute, morphTargetsRelative2, a5, b5, c5, modifiedAttributeArray) {
       _vA2.fromBufferAttribute(attribute, a5);
       _vB2.fromBufferAttribute(attribute, b5);
       _vC2.fromBufferAttribute(attribute, c5);
-      const morphInfluences = object2.morphTargetInfluences;
+      const morphInfluences = object3.morphTargetInfluences;
       if (material2.morphTargets && morphAttribute && morphInfluences) {
         _morphA2.set(0, 0, 0);
         _morphB.set(0, 0, 0);
@@ -89585,10 +89852,10 @@ ${key}` : key;
         _vB2.add(_morphB);
         _vC2.add(_morphC);
       }
-      if (object2.isSkinnedMesh) {
-        object2.boneTransform(a5, _vA2);
-        object2.boneTransform(b5, _vB2);
-        object2.boneTransform(c5, _vC2);
+      if (object3.isSkinnedMesh) {
+        object3.boneTransform(a5, _vA2);
+        object3.boneTransform(b5, _vB2);
+        object3.boneTransform(c5, _vC2);
       }
       modifiedAttributeArray[a5 * 3 + 0] = _vA2.x;
       modifiedAttributeArray[a5 * 3 + 1] = _vA2.y;
@@ -89600,8 +89867,8 @@ ${key}` : key;
       modifiedAttributeArray[c5 * 3 + 1] = _vC2.y;
       modifiedAttributeArray[c5 * 3 + 2] = _vC2.z;
     }
-    const geometry = object.geometry;
-    const material = object.material;
+    const geometry = object2.geometry;
+    const material = object2.material;
     let a4, b4, c4;
     const index = geometry.index;
     const positionAttribute = geometry.attributes.position;
@@ -89628,7 +89895,7 @@ ${key}` : key;
             b4 = index.getX(j4 + 1);
             c4 = index.getX(j4 + 2);
             _calculateMorphedAttributeData(
-              object,
+              object2,
               groupMaterial,
               positionAttribute,
               morphPosition,
@@ -89639,7 +89906,7 @@ ${key}` : key;
               modifiedPosition
             );
             _calculateMorphedAttributeData(
-              object,
+              object2,
               groupMaterial,
               normalAttribute,
               morphNormal,
@@ -89659,7 +89926,7 @@ ${key}` : key;
           b4 = index.getX(i4 + 1);
           c4 = index.getX(i4 + 2);
           _calculateMorphedAttributeData(
-            object,
+            object2,
             material,
             positionAttribute,
             morphPosition,
@@ -89670,7 +89937,7 @@ ${key}` : key;
             modifiedPosition
           );
           _calculateMorphedAttributeData(
-            object,
+            object2,
             material,
             normalAttribute,
             morphNormal,
@@ -89694,7 +89961,7 @@ ${key}` : key;
             b4 = j4 + 1;
             c4 = j4 + 2;
             _calculateMorphedAttributeData(
-              object,
+              object2,
               groupMaterial,
               positionAttribute,
               morphPosition,
@@ -89705,7 +89972,7 @@ ${key}` : key;
               modifiedPosition
             );
             _calculateMorphedAttributeData(
-              object,
+              object2,
               groupMaterial,
               normalAttribute,
               morphNormal,
@@ -89725,7 +89992,7 @@ ${key}` : key;
           b4 = i4 + 1;
           c4 = i4 + 2;
           _calculateMorphedAttributeData(
-            object,
+            object2,
             material,
             positionAttribute,
             morphPosition,
@@ -89736,7 +90003,7 @@ ${key}` : key;
             modifiedPosition
           );
           _calculateMorphedAttributeData(
-            object,
+            object2,
             material,
             normalAttribute,
             morphNormal,
@@ -90067,13 +90334,13 @@ ${shader.fragmentShader}`.replace(
             transform.multiply(new Matrix4().makeTranslation(-8, -8, -8));
             try {
               for (const part of parts) {
-                const object = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe });
-                object.matrix.copy(transform).multiply(part.transform);
-                object.matrixWorldNeedsUpdate = true;
-                object.matrixAutoUpdate = false;
-                this.add(object);
-                await object.init();
-                object.iterateAllMeshes((mesh) => {
+                const object2 = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe });
+                object2.matrix.copy(transform).multiply(part.transform);
+                object2.matrixWorldNeedsUpdate = true;
+                object2.matrixAutoUpdate = false;
+                this.add(object2);
+                await object2.init();
+                object2.iterateAllMeshes((mesh) => {
                   const source = mesh.material;
                   let material = this.specialMaterials.get(source);
                   if (!material) {
@@ -90084,7 +90351,7 @@ ${shader.fragmentShader}`.replace(
                   mesh.material = material;
                 });
                 for (const [name2, rotation] of Object.entries(part.rotations)) {
-                  object.getGroupByName(name2)?.rotation.set(...rotation, "ZYX");
+                  object2.getGroupByName(name2)?.rotation.set(...rotation, "ZYX");
                 }
               }
             } catch (error2) {
@@ -90129,6 +90396,7 @@ ${shader.fragmentShader}`.replace(
                 if (this.options.uvLockRotation) {
                   UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler(...this.options.uvLockRotation));
                 }
+                UVMapper.setAtlasUvBounds(elGeo, el.faces, this.atlas);
                 if (this.options.tints) {
                   const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
                   for (const [faceIndex, faceName] of CUBE_FACES.entries()) {
@@ -90194,7 +90462,7 @@ ${shader.fragmentShader}`.replace(
         }
         applyTextures() {
           if (this.atlas) {
-            const mat = Materials.createShadedCanvasMaterial(this.atlas.image.canvas, this.atlas.hasTransparency, false);
+            const mat = Materials.createShadedCanvasMaterial(this.atlas.image.canvas, this.atlas.hasTransparency, false, true);
             this.atlasMaterial = mat;
             this.atlasTexture = mat.uniforms?.map?.value ?? mat.map;
             this.iterateAllMeshes((mesh) => {
@@ -93379,6 +93647,8 @@ ${shader.fragmentShader}`.replace(
     Models: () => Models,
     NBTHelper: () => NBTHelper,
     OrbitControls: () => OrbitControls,
+    PackFormats: () => PackFormats,
+    PackMetadata: () => PackMetadata,
     PersistentCache: () => PersistentCache,
     Renderer: () => Renderer,
     RequestError: () => RequestError,
@@ -94027,7 +94297,7 @@ ${shader.fragmentShader}`.replace(
      * @param {Object3D} object - The 3D object to export.
      * @return {string} The exported OBJ.
      */
-    parse(object) {
+    parse(object2) {
       let output = "";
       let indexVertex = 0;
       let indexVertexUvs = 0;
@@ -94146,7 +94416,7 @@ ${shader.fragmentShader}`.replace(
         }
         indexVertex += nbVertex;
       }
-      object.traverse(function(child) {
+      object2.traverse(function(child) {
         if (child.isMesh === true) {
           parseMesh(child);
         }
@@ -94177,9 +94447,9 @@ ${shader.fragmentShader}`.replace(
      * @param {PLYExporter~Options} options - The export options.
      * @return {?(string|ArrayBuffer)} The exported PLY.
      */
-    parse(object, onDone, options = {}) {
+    parse(object2, onDone, options = {}) {
       function traverseMeshes(cb) {
-        object.traverse(function(child) {
+        object2.traverse(function(child) {
           if (child.isMesh === true || child.isPoints) {
             const mesh = child;
             const geometry = mesh.geometry;
@@ -94212,7 +94482,7 @@ ${shader.fragmentShader}`.replace(
       for (const name2 of customAttributeNames) customTypes[name2] = "float";
       let vertexCount = 0;
       let faceCount = 0;
-      object.traverse(function(child) {
+      object2.traverse(function(child) {
         if (child.isMesh === true) {
           const mesh = child;
           const geometry = mesh.geometry;
@@ -95003,12 +95273,12 @@ property list uchar int vertex_index
      * @param {THREE.Object3D|THREE.Material|THREE.BufferGeometry|THREE.AnimationClip} object
      * @param {Object} objectDef
      */
-    serializeUserData(object, objectDef) {
-      if (Object.keys(object.userData).length === 0) return;
+    serializeUserData(object2, objectDef) {
+      if (Object.keys(object2.userData).length === 0) return;
       const options = this.options;
       const extensionsUsed = this.extensionsUsed;
       try {
-        const json = JSON.parse(JSON.stringify(object.userData));
+        const json = JSON.parse(JSON.stringify(object2.userData));
         if (options.includeCustomExtensions && json.gltfExtensions) {
           if (objectDef.extensions === void 0) objectDef.extensions = {};
           for (const extensionName in json.gltfExtensions) {
@@ -95019,7 +95289,7 @@ property list uchar int vertex_index
         }
         if (Object.keys(json).length > 0) objectDef.extras = json;
       } catch (error2) {
-        console.warn("THREE.GLTFExporter: userData of '" + object.name + "' won't be serialized because of JSON.stringify error - " + error2.message);
+        console.warn("THREE.GLTFExporter: userData of '" + object2.name + "' won't be serialized because of JSON.stringify error - " + error2.message);
       }
     }
     /**
@@ -95392,7 +95662,7 @@ property list uchar int vertex_index
      * @param {string} mimeType export format
      * @return {number}     Index of the processed texture in the "images" array
      */
-    processImage(image, format2, flipY, mimeType = "image/png") {
+    processImage(image, format3, flipY, mimeType = "image/png") {
       if (image !== null) {
         const writer = this;
         const cache = writer.cache;
@@ -95416,8 +95686,8 @@ property list uchar int vertex_index
           ctx2.scale(1, -1);
         }
         if (image.data !== void 0) {
-          if (format2 !== RGBAFormat) {
-            console.error("GLTFExporter: Only RGBAFormat is supported.", format2);
+          if (format3 !== RGBAFormat) {
+            console.error("GLTFExporter: Only RGBAFormat is supported.", format3);
           }
           if (image.width > options.maxTextureSize || image.height > options.maxTextureSize) {
             console.warn("GLTFExporter: Image size is bigger than maxTextureSize", image);
@@ -95945,13 +96215,13 @@ property list uchar int vertex_index
      * @param {THREE.Object3D} object
      * @return {?number}
      */
-    processSkin(object) {
+    processSkin(object2) {
       const json = this.json;
       const nodeMap = this.nodeMap;
-      const node = json.nodes[nodeMap.get(object)];
-      const skeleton = object.skeleton;
+      const node = json.nodes[nodeMap.get(object2)];
+      const skeleton = object2.skeleton;
       if (skeleton === void 0) return null;
-      const rootJoint = object.skeleton.bones[0];
+      const rootJoint = object2.skeleton.bones[0];
       if (rootJoint === void 0) return null;
       const joints = [];
       const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
@@ -95959,7 +96229,7 @@ property list uchar int vertex_index
       for (let i4 = 0; i4 < skeleton.bones.length; ++i4) {
         joints.push(nodeMap.get(skeleton.bones[i4]));
         temporaryBoneInverse.copy(skeleton.boneInverses[i4]);
-        temporaryBoneInverse.multiply(object.bindMatrix).toArray(inverseBindMatrices, i4 * 16);
+        temporaryBoneInverse.multiply(object2.bindMatrix).toArray(inverseBindMatrices, i4 * 16);
       }
       if (json.skins === void 0) json.skins = [];
       json.skins.push({
@@ -95975,19 +96245,19 @@ property list uchar int vertex_index
      * @param {THREE.Object3D} object Object3D to processNodeAsync
      * @return {Promise<number>} Index of the node in the nodes list
      */
-    async processNodeAsync(object) {
+    async processNodeAsync(object2) {
       const json = this.json;
       const options = this.options;
       const nodeMap = this.nodeMap;
       if (!json.nodes) json.nodes = [];
-      if (object.pivot !== null) {
-        return await this._processNodeWithPivotAsync(object);
+      if (object2.pivot !== null) {
+        return await this._processNodeWithPivotAsync(object2);
       }
       const nodeDef = {};
       if (options.trs) {
-        const rotation = object.quaternion.toArray();
-        const position = object.position.toArray();
-        const scale = object.scale.toArray();
+        const rotation = object2.quaternion.toArray();
+        const position = object2.position.toArray();
+        const scale = object2.scale.toArray();
         if (!equalArray(rotation, [0, 0, 0, 1])) {
           nodeDef.rotation = rotation;
         }
@@ -95998,28 +96268,28 @@ property list uchar int vertex_index
           nodeDef.scale = scale;
         }
       } else {
-        if (object.matrixAutoUpdate) {
-          object.updateMatrix();
+        if (object2.matrixAutoUpdate) {
+          object2.updateMatrix();
         }
-        if (isIdentityMatrix(object.matrix) === false) {
-          nodeDef.matrix = object.matrix.elements;
+        if (isIdentityMatrix(object2.matrix) === false) {
+          nodeDef.matrix = object2.matrix.elements;
         }
       }
-      if (object.name !== "") nodeDef.name = String(object.name);
-      this.serializeUserData(object, nodeDef);
-      if (object.isMesh || object.isLine || object.isPoints) {
-        const meshIndex = await this.processMeshAsync(object);
+      if (object2.name !== "") nodeDef.name = String(object2.name);
+      this.serializeUserData(object2, nodeDef);
+      if (object2.isMesh || object2.isLine || object2.isPoints) {
+        const meshIndex = await this.processMeshAsync(object2);
         if (meshIndex !== null) nodeDef.mesh = meshIndex;
-      } else if (object.isCamera) {
-        nodeDef.camera = this.processCamera(object);
+      } else if (object2.isCamera) {
+        nodeDef.camera = this.processCamera(object2);
       }
-      if (object.isSkinnedMesh) this.skins.push(object);
+      if (object2.isSkinnedMesh) this.skins.push(object2);
       const nodeIndex = json.nodes.push(nodeDef) - 1;
-      nodeMap.set(object, nodeIndex);
-      if (object.children.length > 0) {
+      nodeMap.set(object2, nodeIndex);
+      if (object2.children.length > 0) {
         const children = [];
-        for (let i4 = 0, l4 = object.children.length; i4 < l4; i4++) {
-          const child = object.children[i4];
+        for (let i4 = 0, l4 = object2.children.length; i4 < l4; i4++) {
+          const child = object2.children[i4];
           if (child.visible || options.onlyVisible === false) {
             const childNodeIndex = await this.processNodeAsync(child);
             if (childNodeIndex !== null) children.push(childNodeIndex);
@@ -96028,7 +96298,7 @@ property list uchar int vertex_index
         if (children.length > 0) nodeDef.children = children;
       }
       await this._invokeAllAsync(function(ext) {
-        ext.writeNode && ext.writeNode(object, nodeDef);
+        ext.writeNode && ext.writeNode(object2, nodeDef);
       });
       return nodeIndex;
     }
@@ -96037,19 +96307,19 @@ property list uchar int vertex_index
      * @param {THREE.Object3D} object Object3D with pivot
      * @return {Promise<number>} Index of the container node
      */
-    async _processNodeWithPivotAsync(object) {
+    async _processNodeWithPivotAsync(object2) {
       const json = this.json;
       const options = this.options;
       const nodeMap = this.nodeMap;
-      const pivot = object.pivot;
+      const pivot = object2.pivot;
       const containerDef = {};
-      const rotation = object.quaternion.toArray();
+      const rotation = object2.quaternion.toArray();
       const position = [
-        object.position.x + pivot.x,
-        object.position.y + pivot.y,
-        object.position.z + pivot.z
+        object2.position.x + pivot.x,
+        object2.position.y + pivot.y,
+        object2.position.z + pivot.z
       ];
-      const scale = object.scale.toArray();
+      const scale = object2.scale.toArray();
       if (!equalArray(rotation, [0, 0, 0, 1])) {
         containerDef.rotation = rotation;
       }
@@ -96060,28 +96330,28 @@ property list uchar int vertex_index
         containerDef.scale = scale;
       }
       containerDef.extras = { pivot: pivot.toArray() };
-      if (object.name !== "") containerDef.name = String(object.name);
-      this.serializeUserData(object, containerDef);
+      if (object2.name !== "") containerDef.name = String(object2.name);
+      this.serializeUserData(object2, containerDef);
       const containerIndex = json.nodes.push(containerDef) - 1;
-      nodeMap.set(object, containerIndex);
+      nodeMap.set(object2, containerIndex);
       const childDef = {};
       const childPosition = [-pivot.x, -pivot.y, -pivot.z];
       if (!equalArray(childPosition, [0, 0, 0])) {
         childDef.translation = childPosition;
       }
-      if (object.isMesh || object.isLine || object.isPoints) {
-        const meshIndex = await this.processMeshAsync(object);
+      if (object2.isMesh || object2.isLine || object2.isPoints) {
+        const meshIndex = await this.processMeshAsync(object2);
         if (meshIndex !== null) childDef.mesh = meshIndex;
-      } else if (object.isCamera) {
-        childDef.camera = this.processCamera(object);
+      } else if (object2.isCamera) {
+        childDef.camera = this.processCamera(object2);
       }
-      if (object.isSkinnedMesh) this.skins.push(object);
+      if (object2.isSkinnedMesh) this.skins.push(object2);
       const childIndex = json.nodes.push(childDef) - 1;
       const containerChildren = [childIndex];
-      if (object.children.length > 0) {
+      if (object2.children.length > 0) {
         const grandchildren = [];
-        for (let i4 = 0, l4 = object.children.length; i4 < l4; i4++) {
-          const child = object.children[i4];
+        for (let i4 = 0, l4 = object2.children.length; i4 < l4; i4++) {
+          const child = object2.children[i4];
           if (child.visible || options.onlyVisible === false) {
             const childNodeIndex = await this.processNodeAsync(child);
             if (childNodeIndex !== null) grandchildren.push(childNodeIndex);
@@ -96091,7 +96361,7 @@ property list uchar int vertex_index
       }
       containerDef.children = containerChildren;
       await this._invokeAllAsync(function(ext) {
-        ext.writeNode && ext.writeNode(object, containerDef);
+        ext.writeNode && ext.writeNode(object2, containerDef);
       });
       return containerIndex;
     }
@@ -96534,10 +96804,10 @@ property list uchar int vertex_index
       this.writer = writer;
       this.name = "EXT_mesh_gpu_instancing";
     }
-    writeNode(object, nodeDef) {
-      if (!object.isInstancedMesh) return;
+    writeNode(object2, nodeDef) {
+      if (!object2.isInstancedMesh) return;
       const writer = this.writer;
-      const mesh = object;
+      const mesh = object2;
       const translationAttr = new Float32Array(mesh.count * 3);
       const rotationAttr = new Float32Array(mesh.count * 4);
       const scaleAttr = new Float32Array(mesh.count * 3);
@@ -96727,8 +96997,8 @@ property list uchar int vertex_index
       }
     }
   };
-  function localMatrix(object) {
-    return object.matrixAutoUpdate ? new Matrix4().compose(object.position, object.quaternion, object.scale) : object.matrix.clone();
+  function localMatrix(object2) {
+    return object2.matrixAutoUpdate ? new Matrix4().compose(object2.position, object2.quaternion, object2.scale) : object2.matrix.clone();
   }
   function createSnapshot(root, gltf, bakeColors = false) {
     const scene = new Scene();
@@ -96832,10 +97102,10 @@ property list uchar int vertex_index
         scene.add(copy);
       }
     };
-    const visit = (object, parentWorld) => {
-      if (!object.visible) return;
-      const world = parentWorld.clone().multiply(localMatrix(object));
-      const mesh = object;
+    const visit = (object2, parentWorld) => {
+      if (!object2.visible) return;
+      const world = parentWorld.clone().multiply(localMatrix(object2));
+      const mesh = object2;
       if (mesh.isMesh) {
         const instanced = mesh;
         if (instanced.isInstancedMesh) {
@@ -96849,7 +97119,7 @@ property list uchar int vertex_index
           addMesh(mesh, world);
         }
       }
-      for (const child of object.children) visit(child, world);
+      for (const child of object2.children) visit(child, world);
     };
     try {
       const ancestors = [];
@@ -97092,11 +97362,11 @@ property list uchar int vertex_index
       switch (recipe.type) {
         case "minecraft:crafting_shaped":
         case "crafting_shaped": {
-          const pattern = recipe.pattern;
-          if (!pattern.length || pattern.length > 3 || !pattern[0].length || pattern[0].length > 3 || pattern.some((row) => row.length !== pattern[0].length)) {
+          const pattern2 = recipe.pattern;
+          if (!pattern2.length || pattern2.length > 3 || !pattern2[0].length || pattern2[0].length > 3 || pattern2.some((row) => row.length !== pattern2[0].length)) {
             throw new Error("Crafting patterns must be rectangular, with 1\u20133 rows and columns");
           }
-          const cells = pattern.flatMap((row, y5) => row.split("").map((symbol, x4) => ({ symbol, x: x4, y: y5 }))).filter((cell) => cell.symbol !== " ");
+          const cells = pattern2.flatMap((row, y5) => row.split("").map((symbol, x4) => ({ symbol, x: x4, y: y5 }))).filter((cell) => cell.symbol !== " ");
           if (!cells.length) throw new Error("Crafting patterns must contain an ingredient");
           const minX = Math.min(...cells.map((cell) => cell.x)), maxX = Math.max(...cells.map((cell) => cell.x));
           const minY = Math.min(...cells.map((cell) => cell.y)), maxY = Math.max(...cells.map((cell) => cell.y));
@@ -97532,29 +97802,29 @@ property list uchar int vertex_index
       this.objectControlsContainer.innerHTML = "";
       this.addControls(targetObject, targetIntersection, instance);
     }
-    addControls(object, intersection, instance) {
+    addControls(object2, intersection, instance) {
       const container = document.createElement("div");
       container.append(this.separator("Select Parent/Child"));
-      if (object.parent) {
-        container.append(this.buttonControl("Select Parent " + object.parent.constructor.name + " " + object.parent.name, "P", () => {
-          this.selectObject(object.parent, intersection, instance);
+      if (object2.parent) {
+        container.append(this.buttonControl("Select Parent " + object2.parent.constructor.name + " " + object2.parent.name, "P", () => {
+          this.selectObject(object2.parent, intersection, instance);
         }));
       }
-      if (object.children.length > 0) {
+      if (object2.children.length > 0) {
         let i4 = 1;
-        for (let child of object.children) {
+        for (let child of object2.children) {
           container.append(this.buttonControl("Select Child " + child.constructor.name + " " + child.name, "C" + i4++, () => {
             this.selectObject(child, intersection, instance);
           }));
         }
       }
       container.append(this.separator());
-      const selectedInstance = instance && (object === instance.instanceable || object === intersection?.object) ? instance : void 0;
+      const selectedInstance = instance && (object2 === instance.instanceable || object2 === intersection?.object) ? instance : void 0;
       if (!selectedInstance) {
-        container.append(this.toggleControl("Visibility", "V", object.visible, (v5) => object.visible = v5));
+        container.append(this.toggleControl("Visibility", "V", object2.visible, (v5) => object2.visible = v5));
       }
       container.append(this.separator("Mesh"));
-      this.addObjectControls(object, intersection, container, selectedInstance);
+      this.addObjectControls(object2, intersection, container, selectedInstance);
       container.append(this.separator());
       this.objectControlsContainer.append(container);
     }
@@ -98185,8 +98455,8 @@ property list uchar int vertex_index
         return false;
       }
       return this._models.some((model) => {
-        const object = isInstanceReference(model) ? model.instanceable : model;
-        return object.isOpaqueFullCube && this.getModelCullMask(model, 63) === 63;
+        const object2 = isInstanceReference(model) ? model.instanceable : model;
+        return object2.isOpaqueFullCube && this.getModelCullMask(model, 63) === 63;
       });
     }
     getModelMatrix(model) {
@@ -98195,8 +98465,8 @@ property list uchar int vertex_index
       return model.matrix.clone();
     }
     getModelCullMask(model, worldMask) {
-      const object = isInstanceReference(model) ? model.instanceable : model;
-      if (object.options.displayPosition) return 0;
+      const object2 = isInstanceReference(model) ? model.instanceable : model;
+      if (object2.options.displayPosition) return 0;
       const position = new Vector3();
       const rotation = new Quaternion();
       const scale = new Vector3();
@@ -98213,14 +98483,14 @@ property list uchar int vertex_index
             replacements.push(model);
             continue;
           }
-          const object = isInstanceReference(model) ? model.instanceable : model;
+          const object2 = isInstanceReference(model) ? model.instanceable : model;
           const cullMask = this.getModelCullMask(model, worldMask);
-          if (cullMask === (object.options.cullMask ?? 0)) {
+          if (cullMask === (object2.options.cullMask ?? 0)) {
             replacements.push(model);
             continue;
           }
           const matrix = this.getModelMatrix(model);
-          const replacement = await this.scene.addModel(object.originalModel, { ...object.options, cullMask });
+          const replacement = await this.scene.addModel(object2.originalModel, { ...object2.options, cullMask });
           replacements.push(replacement);
           if (isInstanceReference(replacement)) {
             replacement.setMatrix(matrix);
@@ -98228,8 +98498,8 @@ property list uchar int vertex_index
             replacement.matrix.copy(matrix);
             replacement.matrixWorldNeedsUpdate = true;
             matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
-            replacement.matrixAutoUpdate = object.matrixAutoUpdate;
-            replacement.visible = object.visible;
+            replacement.matrixAutoUpdate = object2.matrixAutoUpdate;
+            replacement.visible = object2.visible;
           }
         }
       } catch (error2) {
@@ -100167,9 +100437,9 @@ property list uchar int vertex_index
      * Parses a legacy schematic using custom mappings before the bundled defaults.
      * Keys are `id:metadata`; values are block states such as `minecraft:oak_log[axis=x]`.
      */
-    static async parse(nbt, customMappings = {}) {
+    static async parse(nbt, customMappings = {}, options = {}) {
       const tags = nbt.value;
-      if (tags.Materials?.type !== "string" || tags.Materials.value !== "Alpha") {
+      if (!options.lenient && (tags.Materials?.type !== "string" || tags.Materials.value !== "Alpha")) {
         throw new MineRenderError("Schematic Materials must be Alpha");
       }
       const size = ["Width", "Height", "Length"].map((name2) => {
@@ -100210,8 +100480,16 @@ property list uchar int vertex_index
         const id = high << 8 | ids.value[index] & 255;
         const metadata = data.value[index] & 255;
         const key = `${id}:${metadata}`;
-        const mapped = customMappings[key] ?? mapping[key];
-        if (!mapped) throw new MineRenderError(`Unsupported legacy block ${id}:${metadata} at schematic index ${index}`);
+        let mapped = customMappings[key] ?? mapping[key];
+        if (!mapped && options.lenient) {
+          mapped = customMappings[`${id}:0`] ?? mapping[`${id}:0`];
+        }
+        if (!mapped) {
+          if (options.lenient) {
+            continue;
+          }
+          throw new MineRenderError(`Unsupported legacy block ${id}:${metadata} at schematic index ${index}`);
+        }
         const [type, state] = mapped.split("[");
         if (type === "minecraft:air") continue;
         const properties = {};
@@ -101404,53 +101682,53 @@ property list uchar int vertex_index
       this.options = (0, import_ts_deepmerge8.default)({}, _MineRenderScene.DEFAULT_OPTIONS, options ?? {});
     }
     add(...objects) {
-      for (const object of objects) {
+      for (const object2 of objects) {
         this.dirty = true;
         try {
-          super.add(object);
+          super.add(object2);
         } finally {
-          if (object?.isObject3D && object !== this) {
-            this.updateObjectRegistration(object, object.parent === this);
+          if (object2?.isObject3D && object2 !== this) {
+            this.updateObjectRegistration(object2, object2.parent === this);
           }
         }
       }
       return this;
     }
     remove(...objects) {
-      for (const object of objects) {
-        if (!this.children.includes(object)) continue;
+      for (const object2 of objects) {
+        if (!this.children.includes(object2)) continue;
         this.dirty = true;
-        this.updateObjectRegistration(object, false);
+        this.updateObjectRegistration(object2, false);
         try {
-          super.remove(object);
+          super.remove(object2);
         } finally {
-          this.updateObjectRegistration(object, object.parent === this);
+          this.updateObjectRegistration(object2, object2.parent === this);
         }
       }
       return this;
     }
-    updateObjectRegistration(object, attached) {
-      if (this.observedObjects.has(object) === attached) return;
-      const observable = object;
+    updateObjectRegistration(object2, attached) {
+      if (this.observedObjects.has(object2) === attached) return;
+      const observable = object2;
       if (attached) {
-        this.observedObjects.add(object);
+        this.observedObjects.add(object2);
         observable.addEventListener("change", this.onObjectChange);
       } else {
-        this.observedObjects.delete(object);
+        this.observedObjects.delete(object2);
         observable.removeEventListener("change", this.onObjectChange);
       }
       const change = attached ? 1 : -1;
       this.stats.objectCount += change;
-      if (isSceneObject(object)) {
+      if (isSceneObject(object2)) {
         this.stats.sceneObjectCount += change;
       }
     }
-    async initAndAdd(...object) {
+    async initAndAdd(...object2) {
       this.dirty = true;
-      for (let obj of object) {
+      for (let obj of object2) {
         await obj.init();
       }
-      return this.add(...object);
+      return this.add(...object2);
     }
     async addSceneObject(asset, objectSupplier, _options, parent = this) {
       this.dirty = true;
@@ -103516,11 +103794,11 @@ gl_FragDepth=readDepth(vUv);
   var _startEvent = { type: "start" };
   var _endEvent = { type: "end" };
   var OrbitControls = class extends EventDispatcher {
-    constructor(object, domElement) {
+    constructor(object2, 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.object = object2;
       this.domElement = domElement;
       this.domElement.style.touchAction = "none";
       this.enabled = true;
@@ -103577,7 +103855,7 @@ gl_FragDepth=readDepth(vUv);
       };
       this.update = function() {
         const offset = new Vector3();
-        const quat = new Quaternion().setFromUnitVectors(object.up, new Vector3(0, 1, 0));
+        const quat = new Quaternion().setFromUnitVectors(object2.up, new Vector3(0, 1, 0));
         const quatInverse = quat.clone().invert();
         const lastPosition = new Vector3();
         const lastQuaternion = new Quaternion();
@@ -104142,8 +104420,8 @@ gl_FragDepth=readDepth(vUv);
     }
   };
   var MapControls = class extends OrbitControls {
-    constructor(object, domElement) {
-      super(object, domElement);
+    constructor(object2, domElement) {
+      super(object2, domElement);
       this.screenSpacePanning = false;
       this.mouseButtons.LEFT = MOUSE.PAN;
       this.mouseButtons.RIGHT = MOUSE.ROTATE;
@@ -105119,16 +105397,16 @@ gl_FragDepth=readDepth(vUv);
         if (!models) this.models.set(model, models = /* @__PURE__ */ new Map());
         const key = JSON.stringify([rotation.x, rotation.y, rotation.z, variant.uvlock, tints]);
         const template = await cached(models, key, async () => {
-          const object = new SectionModel(model, {
+          const object2 = new SectionModel(model, {
             instanceMeshes: false,
             mergeMeshes: false,
             tints,
             uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0
           });
-          await object.init();
-          const geometry = object.children[0].geometry;
+          await object2.init();
+          const geometry = object2.children[0].geometry;
           geometry.applyMatrix4(new Matrix4().makeRotationFromEuler(rotation));
-          object.clear();
+          object2.clear();
           const cullFaces = CUBE_FACES.map((face) => {
             const local = CUBE_FACES.findIndex((name2) => name2 === atlas.model.elements[0].faces[face]?.cullface);
             if (local < 0) return 0;
@@ -105316,10 +105594,10 @@ gl_FragDepth=readDepth(vUv);
                 await block.object.updateFluid((x4, y5, z4) => {
                   const neighbor = pos.clone().add(new Vector3(x4, y5, z4));
                   const section = this.getChunkAt(neighbor);
-                  const object = section?.isBlockVisibleAt(neighbor) ? section.getBlockAt(neighbor)?.object : void 0;
+                  const object2 = section?.isBlockVisibleAt(neighbor) ? section.getBlockAt(neighbor)?.object : void 0;
                   return {
-                    fluid: object?.fluidKind,
-                    level: object?.fluidLevel,
+                    fluid: object2?.fluidKind,
+                    level: object2?.fluidLevel,
                     solid: section?.isOccludingAt(neighbor) ?? false
                   };
                 });
@@ -105442,14 +105720,17 @@ gl_FragDepth=readDepth(vUv);
         for (const { atlas, x: x4, y: y5 } of page.placements) {
           context.drawImage(atlas.image.canvas, x4, y5);
         }
-        const positions = [], normals = [], uvs = [], colors = [], indices = [];
+        const positions = [], normals = [], uvs = [], uvBounds = [], colors = [], indices = [];
         for (const { index, template, cullMask } of page.entries) {
           const position = template.geometry.getAttribute("position");
           const normal = template.geometry.getAttribute("normal");
           const uv = template.geometry.getAttribute("uv");
+          const bounds = template.geometry.getAttribute("uvBounds");
           const color2 = template.geometry.getAttribute("color");
           const sourceIndices = template.geometry.getIndex();
           const placement = locations.get(template.atlas).placement;
+          const mapU = (u4) => (placement.x + u4 * template.atlas.image.width) / page.width;
+          const mapV = (v5) => 1 - (placement.y + (1 - v5) * template.atlas.image.height) / page.height;
           const offsetX = index % 16 * 16;
           const offsetY = Math.floor(index / 256) * 16;
           const offsetZ = Math.floor(index / 16) % 16 * 16;
@@ -105460,9 +105741,12 @@ gl_FragDepth=readDepth(vUv);
               const vertex2 = face * 4 + corner;
               positions.push(position.getX(vertex2) + offsetX, position.getY(vertex2) + offsetY, position.getZ(vertex2) + offsetZ);
               normals.push(normal.getX(vertex2), normal.getY(vertex2), normal.getZ(vertex2));
-              uvs.push(
-                (placement.x + uv.getX(vertex2) * template.atlas.image.width) / page.width,
-                1 - (placement.y + (1 - uv.getY(vertex2)) * template.atlas.image.height) / page.height
+              uvs.push(mapU(uv.getX(vertex2)), mapV(uv.getY(vertex2)));
+              uvBounds.push(
+                mapU(bounds?.getX(vertex2) ?? 0),
+                mapV(bounds?.getY(vertex2) ?? 0),
+                mapU(bounds?.getZ(vertex2) ?? 1),
+                mapV(bounds?.getW(vertex2) ?? 1)
               );
               colors.push(color2?.getX(vertex2) ?? 1, color2?.getY(vertex2) ?? 1, color2?.getZ(vertex2) ?? 1);
             }
@@ -105473,11 +105757,12 @@ gl_FragDepth=readDepth(vUv);
         geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
         geometry.setAttribute("normal", new Float32BufferAttribute(normals, 3));
         geometry.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
+        geometry.setAttribute("uvBounds", new Float32BufferAttribute(uvBounds, 4));
         geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
         geometry.setIndex(indices);
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
-        const material = Materials.createShadedCanvasMaterial(canvas, false);
+        const material = Materials.createShadedCanvasMaterial(canvas, false, false, true);
         material.vertexColors = true;
         const texture = material.uniforms?.map?.value ?? material.map;
         const mesh = new Mesh(geometry, material);
@@ -105551,7 +105836,7 @@ gl_FragDepth=readDepth(vUv);
       this.renderedBlocks.get(index)?.object?.removeFromScene();
       if (this.sectionBlocks.delete(index)) this.meshDirty = true;
       this.renderedBlocks.delete(index);
-      let object;
+      let object2;
       try {
         if (!readBlock) return void 0;
         const stored = readBlock();
@@ -105566,22 +105851,22 @@ gl_FragDepth=readDepth(vUv);
           this.sectionBlocks.set(index, { index, template, cullMask: 0 });
           this.meshDirty = true;
         } else {
-          object = await this.scene.addBlock(blockState, {
+          object2 = await this.scene.addBlock(blockState, {
             mergeMeshes: true,
             instanceMeshes: true,
             maxInstanceCount: 2e3,
             initialState: stored.properties
           });
-          object.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
+          object2.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
         }
         const info = { get block() {
           return readBlock();
-        }, object };
+        }, object: object2 };
         this.renderedBlocks.set(index, info);
         return info;
       } catch (error2) {
         this.data.set(index, void 0);
-        object?.removeFromScene();
+        object2?.removeFromScene();
         throw error2;
       } finally {
         await onBlocksChanged?.([worldPos]);