minerender 2.1.0-alpha.67 → 2.1.0-alpha.69

package/dist/node/index.js

@@ -297,6 +297,9 @@ var init_Caching = __esm({
       static {
         this.blockEntityIndexCache = _Caching.createAssetCache();
       }
+      static {
+        this.fontCache = _Caching.createAssetCache();
+      }
       static createAssetCache() {
         return import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
       }
@@ -323,7 +326,8 @@ var init_Caching = __esm({
           this.entityModelCache,
           this.entityTextureCache,
           this.entityAnimationCache,
-          this.blockEntityIndexCache
+          this.blockEntityIndexCache,
+          this.fontCache
         ];
       }
       static clear() {
@@ -4346,7 +4350,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three20.BufferGeometry();
+  const mergedGeometry = new import_three22.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -4470,7 +4474,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three20.BufferAttribute(array, itemSize, normalized);
+  return new import_three22.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -4486,7 +4490,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three20.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three22.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -4495,7 +4499,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three20.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three22.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -4579,13 +4583,13 @@ function mergeVertices(geometry, tolerance = 1e-4) {
     const name = attributeNames[i];
     const oldAttribute = geometry.getAttribute(name);
     const buffer = new oldAttribute.array.constructor(attrArrays[name]);
-    const attribute = new import_three20.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three22.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
     result.setAttribute(name, attribute);
     if (name in morphAttrsArrays) {
       for (let j = 0; j < morphAttrsArrays[name].length; j++) {
         const oldMorphAttribute = geometry.morphAttributes[name][j];
         const buffer2 = new oldMorphAttribute.array.constructor(morphAttrsArrays[name][j]);
-        const morphAttribute = new import_three20.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three22.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -4594,11 +4598,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three20.TrianglesDrawMode) {
+  if (drawMode === import_three22.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three20.TriangleFanDrawMode || drawMode === import_three20.TriangleStripDrawMode) {
+  if (drawMode === import_three22.TriangleFanDrawMode || drawMode === import_three22.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -4616,7 +4620,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three20.TriangleFanDrawMode) {
+    if (drawMode === import_three22.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -4652,15 +4656,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three20.Vector3();
-  const _vB = new import_three20.Vector3();
-  const _vC = new import_three20.Vector3();
-  const _tempA = new import_three20.Vector3();
-  const _tempB = new import_three20.Vector3();
-  const _tempC = new import_three20.Vector3();
-  const _morphA = new import_three20.Vector3();
-  const _morphB = new import_three20.Vector3();
-  const _morphC = new import_three20.Vector3();
+  const _vA = new import_three22.Vector3();
+  const _vB = new import_three22.Vector3();
+  const _vC = new import_three22.Vector3();
+  const _tempA = new import_three22.Vector3();
+  const _tempB = new import_three22.Vector3();
+  const _tempC = new import_three22.Vector3();
+  const _morphA = new import_three22.Vector3();
+  const _morphB = new import_three22.Vector3();
+  const _morphC = new import_three22.Vector3();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4855,8 +4859,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three20.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three20.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three22.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three22.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4864,24 +4868,24 @@ function computeMorphedAttributes(object) {
     morphedNormalAttribute
   };
 }
-var import_three20;
+var import_three22;
 var init_BufferGeometryUtils = __esm({
   "src/three/BufferGeometryUtils.js"() {
-    import_three20 = require("three");
+    import_three22 = require("three");
   }
 });
 
 // src/model/ModelCulling.ts
-var import_three21, ModelCulling;
+var import_three23, ModelCulling;
 var init_ModelCulling = __esm({
   "src/model/ModelCulling.ts"() {
-    import_three21 = require("three");
+    import_three23 = require("three");
     init_CubeFace();
     ModelCulling = class {
       static toLocalMask(worldMask, rotation) {
         let localMask = 0;
         for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
-          const normal = new import_three21.Vector3(...offset).applyEuler(rotation);
+          const normal = new import_three23.Vector3(...offset).applyEuler(rotation);
           const worldFace = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           if (worldFace < 0) return 0;
           if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
@@ -4914,10 +4918,10 @@ var init_ModelCulling = __esm({
 });
 
 // src/model/SpecialItems.ts
-var import_three22, SpecialItems;
+var import_three24, SpecialItems;
 var init_SpecialItems = __esm({
   "src/model/SpecialItems.ts"() {
-    import_three22 = require("three");
+    import_three24 = require("three");
     init_AssetKey();
     init_Entities();
     SpecialItems = class {
@@ -4945,7 +4949,7 @@ var init_SpecialItems = __esm({
           case "minecraft:chest":
           case "chest": {
             const angle = -(special.openness ?? 0) * Math.PI / 2;
-            const chest = await load("chest", texture(special.texture, "chest"), new import_three22.Matrix4(), {
+            const chest = await load("chest", texture(special.texture, "chest"), new import_three24.Matrix4(), {
               lid: [angle, 0, 0],
               lock: [angle, 0, 0]
             });
@@ -4954,11 +4958,11 @@ var init_SpecialItems = __esm({
           }
           case "minecraft:bed":
           case "bed": {
-            const transform = new import_three22.Matrix4().makeTranslation(0, 9, 0).multiply(new import_three22.Matrix4().makeRotationX(Math.PI / 2)).multiply(new import_three22.Matrix4().makeTranslation(8, 8, 8)).multiply(new import_three22.Matrix4().makeRotationZ(Math.PI)).multiply(new import_three22.Matrix4().makeTranslation(-8, -8, -8));
+            const transform = new import_three24.Matrix4().makeTranslation(0, 9, 0).multiply(new import_three24.Matrix4().makeRotationX(Math.PI / 2)).multiply(new import_three24.Matrix4().makeTranslation(8, 8, 8)).multiply(new import_three24.Matrix4().makeRotationZ(Math.PI)).multiply(new import_three24.Matrix4().makeTranslation(-8, -8, -8));
             const key = texture(special.texture, "bed");
             return Promise.all([
               load("bed_head", key, transform),
-              load("bed_foot", key, new import_three22.Matrix4().makeTranslation(0, 0, -16).multiply(transform))
+              load("bed_foot", key, new import_three24.Matrix4().makeTranslation(0, 0, -16).multiply(transform))
             ]);
           }
           case "minecraft:head":
@@ -4983,7 +4987,7 @@ var init_SpecialItems = __esm({
             return [await load(
               id,
               special.texture ? texture(special.texture, "") : void 0,
-              new import_three22.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three22.Matrix4().makeScale(-1, -1, 1)),
+              new import_three24.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three24.Matrix4().makeScale(-1, -1, 1)),
               rotations
             )];
           }
@@ -5111,13 +5115,13 @@ var init_ItemTints = __esm({
 function isModelObject(obj) {
   return obj.isModelObject;
 }
-var import_three23, import_ts_deepmerge5, p7, ModelObject;
+var import_three25, import_ts_deepmerge5, p7, ModelObject;
 var init_ModelObject = __esm({
   "src/model/scene/ModelObject.ts"() {
     init_SceneObject();
     init_Materials();
     init_UVMapper();
-    import_three23 = require("three");
+    import_three25 = require("three");
     init_BufferGeometryUtils();
     init_model();
     import_ts_deepmerge5 = __toESM(require_dist());
@@ -5152,8 +5156,8 @@ var init_ModelObject = __esm({
         const special = this.originalModel.special;
         if (special) {
           const parts = await SpecialItems.getParts(special, this.originalModel.key?.root);
-          const transform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : new import_three23.Matrix4();
-          transform.multiply(new import_three23.Matrix4().makeTranslation(-8, -8, -8));
+          const transform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : new import_three25.Matrix4();
+          transform.multiply(new import_three25.Matrix4().makeTranslation(-8, -8, -8));
           try {
             for (const part of parts) {
               const object = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe });
@@ -5216,7 +5220,7 @@ var init_ModelObject = __esm({
                 elGeo.clearGroups();
               }
               if (this.options.uvLockRotation) {
-                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three23.Euler(...this.options.uvLockRotation));
+                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three25.Euler(...this.options.uvLockRotation));
               }
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -5225,19 +5229,19 @@ var init_ModelObject = __esm({
                   if (tintIndex === void 0 || tintIndex < 0) continue;
                   const tint = this.options.tints[tintIndex];
                   if (tint === void 0) continue;
-                  const color = new import_three23.Color(tint);
+                  const color = new import_three25.Color(tint);
                   for (let vertex = 0; vertex < 4; vertex++) {
                     color.toArray(colors, (faceIndex * 4 + vertex) * 3);
                   }
                 }
-                elGeo.setAttribute("color", new import_three23.BufferAttribute(colors, 3));
+                elGeo.setAttribute("color", new import_three25.BufferAttribute(colors, 3));
               }
-              elGeo.applyMatrix4(new import_three23.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
-              elGeo.applyMatrix4(new import_three23.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
+              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
               if (el.rotation) {
                 applyElementRotation(el.rotation, elGeo);
               }
-              elGeo.applyMatrix4(new import_three23.Matrix4().makeTranslation(-8, -8, -8));
+              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation(-8, -8, -8));
               if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
               if (this.options.mergeMeshes) {
                 allGeos.push(elGeo);
@@ -5259,7 +5263,7 @@ var init_ModelObject = __esm({
           if (allGeos.length > 0) {
             combinedGeo = mergeBufferGeometries(allGeos);
           } else {
-            combinedGeo = new import_three23.BoxGeometry(16, 16, 16);
+            combinedGeo = new import_three25.BoxGeometry(16, 16, 16);
             if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
           }
           combinedGeo.computeBoundingBox();
@@ -5369,7 +5373,7 @@ function ownHeight(sample) {
   return (level === 0 || level >= 8 ? 8 : 8 - level) / 9;
 }
 function createFluidGeometry(kind, sample) {
-  const geometry = new import_three28.BufferGeometry();
+  const geometry = new import_three30.BufferGeometry();
   const positions = [], normals = [], uvs = [], indices = [];
   const self = sample(0, 0, 0);
   const height = (x, z) => {
@@ -5468,16 +5472,16 @@ function createFluidGeometry(kind, sample) {
       1
     );
   }
-  geometry.setAttribute("position", new import_three28.Float32BufferAttribute(positions, 3));
-  geometry.setAttribute("normal", new import_three28.Float32BufferAttribute(normals, 3));
-  geometry.setAttribute("uv", new import_three28.Float32BufferAttribute(uvs, 2));
+  geometry.setAttribute("position", new import_three30.Float32BufferAttribute(positions, 3));
+  geometry.setAttribute("normal", new import_three30.Float32BufferAttribute(normals, 3));
+  geometry.setAttribute("uv", new import_three30.Float32BufferAttribute(uvs, 2));
   geometry.setIndex(indices);
   return geometry;
 }
-var import_three28, fluidRules, HORIZONTAL, EPSILON;
+var import_three30, fluidRules, HORIZONTAL, EPSILON;
 var init_FluidGeometry = __esm({
   "src/model/fluid/FluidGeometry.ts"() {
-    import_three28 = require("three");
+    import_three30 = require("three");
     init_fluidBlocks();
     fluidRules = fluidBlocks_default;
     HORIZONTAL = [[0, -1], [0, 1], [-1, 0], [1, 0]];
@@ -5506,10 +5510,10 @@ function sampleFluid(kind, sample) {
   }
   return { key: key.join(""), sample: (x, y, z) => cells[(y + 1) * 9 + (z + 1) * 3 + x + 1] };
 }
-var import_three29, FluidModelObject;
+var import_three31, FluidModelObject;
 var init_FluidModelObject = __esm({
   "src/model/fluid/FluidModelObject.ts"() {
-    import_three29 = require("three");
+    import_three31 = require("three");
     init_AssetKey();
     init_Materials();
     init_ModelObject();
@@ -5542,10 +5546,10 @@ var init_FluidModelObject = __esm({
           }
         }
         geometry.clearGroups();
-        const color = new import_three29.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
+        const color = new import_three31.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
         const colors = new Float32Array(geometry.getAttribute("position").count * 3);
         for (let i = 0; i < colors.length; i += 3) color.toArray(colors, i);
-        geometry.setAttribute("color", new import_three29.BufferAttribute(colors, 3));
+        geometry.setAttribute("color", new import_three31.BufferAttribute(colors, 3));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
         if (this.options.instanceMeshes) {
@@ -5559,7 +5563,7 @@ var init_FluidModelObject = __esm({
         super.applyTextures();
         this.iterateAllMeshes((mesh) => {
           const material = mesh.material;
-          material.side = import_three29.DoubleSide;
+          material.side = import_three31.DoubleSide;
           material.forceSinglePass = true;
           material.depthWrite = !material.transparent;
         });
@@ -5619,6 +5623,7 @@ __export(index_node_exports, {
   EntityObject: () => EntityObject,
   Env: () => Env,
   FluidModelObject: () => FluidModelObject,
+  Fonts: () => Fonts,
   Geometries: () => Geometries,
   GuiHelper: () => GuiHelper,
   GuiLight: () => GuiLight,
@@ -5692,6 +5697,8 @@ __export(index_node_exports, {
   computeTangents: () => computeTangents,
   createCanvas: () => createCanvas2,
   createFluidGeometry: () => createFluidGeometry,
+  createGuiTextGeometry: () => createGuiTextGeometry,
+  createGuiTextureGeometry: () => createGuiTextureGeometry,
   createImage: () => createImage,
   entityAnimationTime: () => entityAnimationTime,
   estimateBytesUsed: () => estimateBytesUsed,
@@ -5720,6 +5727,7 @@ __export(index_node_exports, {
   isTransformable: () => isTransformable,
   isTripleArray: () => isTripleArray,
   isVector3: () => isVector3,
+  layoutGuiText: () => layoutGuiText,
   md5: () => md5,
   mergeBufferAttributes: () => mergeBufferAttributes,
   mergeBufferGeometries: () => mergeBufferGeometries,
@@ -5952,6 +5960,101 @@ var BlockEntities = class {
 // src/assets/index.ts
 init_BlockStates();
 init_Entities();
+
+// src/assets/Fonts.ts
+init_AssetKey();
+init_AssetLoader();
+init_AssetParsers();
+init_ModelTextures();
+init_Caching();
+var Fonts = class {
+  static async get(key = "minecraft:default") {
+    const fontKey = typeof key === "string" ? AssetKey.parse("font", key) : key;
+    return await Caching.fontCache.get(fontKey.serialize(), () => this.load(fontKey, []));
+  }
+  static relatedKey(assetType, id, origin) {
+    const key = AssetKey.parse(assetType, id);
+    key.root = origin.root;
+    return key;
+  }
+  static async load(key, parents) {
+    const serialized = key.serialize();
+    if (parents.includes(serialized)) throw new Error(`Cyclic font reference: ${key.toNamespacedString()}`);
+    const stack = await AssetLoader.getAll(key, "json" /* JSON */);
+    if (stack.length === 0) throw new Error(`Could not load font ${key.toNamespacedString()}`);
+    const glyphs = /* @__PURE__ */ new Map();
+    for (const asset of stack) {
+      for (const provider of asset.providers) {
+        if (provider.filter?.uniform || provider.filter?.jp) continue;
+        let provided;
+        switch (provider.type) {
+          case "bitmap":
+          case "minecraft:bitmap":
+            provided = await this.bitmap(provider, key);
+            break;
+          case "space":
+          case "minecraft:space":
+            provided = new Map(Object.entries(provider.advances).map(([character, advance]) => [
+              character,
+              { x: 0, y: 0, width: 0, height: 0, scale: 1, ascent: 0, advance }
+            ]));
+            break;
+          case "reference":
+          case "minecraft:reference":
+            provided = (await this.load(this.relatedKey("font", provider.id, key), [...parents, serialized])).glyphs;
+            break;
+          default:
+            continue;
+        }
+        for (const [character, glyph] of provided) {
+          if (character !== "\0" && !glyphs.has(character)) glyphs.set(character, glyph);
+        }
+      }
+    }
+    return { glyphs };
+  }
+  static async bitmap(provider, fontKey) {
+    const rows = provider.chars.map((row) => [...row]);
+    const columns = rows[0]?.length;
+    if (!columns || rows.some((row) => row.length !== columns)) {
+      throw new Error(`Invalid character grid in font ${fontKey.toNamespacedString()}`);
+    }
+    const key = this.relatedKey("textures", provider.file, fontKey);
+    const image = await ModelTextures.get(key);
+    if (!image) throw new Error(`Could not load font texture ${key.toNamespacedString()}`);
+    const width = Math.floor(image.width / columns), height = Math.floor(image.height / rows.length);
+    if (!width || !height) throw new Error(`Font texture ${key.toNamespacedString()} is smaller than its character grid`);
+    const scale = (provider.height ?? 8) / height;
+    const pixels = image.data.getImageData(0, 0, image.width, image.height).data;
+    const glyphs = /* @__PURE__ */ new Map();
+    rows.forEach((row, rowIndex) => row.forEach((character, columnIndex) => {
+      if (character === "\0") return;
+      const x = columnIndex * width, y = rowIndex * height;
+      let occupiedWidth = 0;
+      for (let column = width - 1; column >= 0 && !occupiedWidth; column--) {
+        for (let row2 = 0; row2 < height; row2++) {
+          if (pixels[((y + row2) * image.width + x + column) * 4 + 3] !== 0) {
+            occupiedWidth = column + 1;
+            break;
+          }
+        }
+      }
+      glyphs.set(character, {
+        image: image.data.canvas,
+        x,
+        y,
+        width,
+        height,
+        scale,
+        ascent: provider.ascent,
+        advance: Math.floor(occupiedWidth * scale + 0.5) + 1
+      });
+    }));
+    return glyphs;
+  }
+};
+
+// src/assets/index.ts
 init_ModelTextures();
 init_Models();
 init_source();
@@ -8909,7 +9012,137 @@ function copyDataTexture(source) {
 
 // src/gui/GuiHelper.ts
 init_AssetKey();
+
+// src/gui/GuiText.ts
+var import_three20 = require("three");
+async function layoutGuiText(text, options = {}) {
+  const maxWidth = options.maxWidth ?? Infinity, lineHeight = options.lineHeight ?? 9;
+  if (!(maxWidth > 0) || !Number.isFinite(lineHeight) || lineHeight <= 0) {
+    throw new Error("Text wrap width and line height must be positive");
+  }
+  const font = await Fonts.get(options.font);
+  const runs = typeof text === "string" ? [{ text }] : text;
+  const glyphs = [], lineWidths = [];
+  let line = [], width = 0;
+  let trailingNewline = false;
+  const finishLine = (entries) => {
+    let x = 0;
+    for (const entry of entries) {
+      glyphs.push({ ...entry, x, y: lineWidths.length * lineHeight });
+      x += entry.advance;
+    }
+    lineWidths.push(x);
+  };
+  for (const run of runs) {
+    const style = {
+      color: run.color ?? options.color ?? 16777215,
+      bold: run.bold ?? options.bold ?? false,
+      italic: run.italic ?? options.italic ?? false
+    };
+    for (const character of run.text.replace(/\r\n?/g, "\n")) {
+      trailingNewline = character === "\n";
+      if (character === "\n") {
+        finishLine(line);
+        line = [];
+        width = 0;
+        continue;
+      }
+      const glyph = font.glyphs.get(character);
+      const advance = (glyph?.advance ?? 6) + (style.bold ? 1 : 0);
+      line.push({ character, glyph, advance, style, x: 0, y: 0 });
+      width += advance;
+      while (width > maxWidth && line.length > 1) {
+        let space = -1;
+        for (let i = 0; i < line.length; i++) if (line[i].character === " ") space = i;
+        const split = space >= 0 ? space : line.length - 1;
+        if (split > 0) finishLine(line.slice(0, split));
+        line = line.slice(split + (space >= 0 ? 1 : 0));
+        width = line.reduce((sum, entry) => sum + entry.advance, 0);
+      }
+    }
+  }
+  if (line.length || !lineWidths.length || trailingNewline) finishLine(line);
+  return { glyphs, lineWidths, width: Math.max(0, ...lineWidths), height: lineWidths.length * lineHeight };
+}
+function createGuiTextGeometry(layout, shadow = true) {
+  const batches = [];
+  for (const isShadow of shadow ? [true, false] : [false]) {
+    let batch;
+    for (const entry of layout.glyphs) {
+      const { glyph, style } = entry;
+      if (glyph && !glyph.image) continue;
+      if (!batch || batch.image !== glyph?.image) {
+        batch = { image: glyph?.image, positions: [], uvs: [], colors: [], indices: [] };
+        batches.push(batch);
+      }
+      const color = new import_three20.Color(isShadow ? (style.color & 16579836) >> 2 : style.color);
+      const offset = isShadow ? 1 : 0;
+      const top = glyph ? 7 - glyph.ascent : 0;
+      const height = glyph ? glyph.height * glyph.scale : 8;
+      const width = glyph ? glyph.width * glyph.scale : 5;
+      const shear = (y) => style.italic ? 1 - 0.25 * y : 0;
+      const quad = (left, upper, right, lower, boldOffset) => {
+        const base = batch.positions.length / 3;
+        const x = entry.x + offset + boldOffset, y = entry.y + offset;
+        batch.positions.push(
+          x + left + shear(upper),
+          -y - upper,
+          0,
+          x + right + shear(upper),
+          -y - upper,
+          0,
+          x + left + shear(lower),
+          -y - lower,
+          0,
+          x + right + shear(lower),
+          -y - lower,
+          0
+        );
+        const u0 = glyph ? glyph.x / glyph.image.width : 0;
+        const u1 = glyph ? (glyph.x + glyph.width) / glyph.image.width : 1;
+        const v0 = glyph ? 1 - glyph.y / glyph.image.height : 1;
+        const v1 = glyph ? 1 - (glyph.y + glyph.height) / glyph.image.height : 0;
+        batch.uvs.push(u0, v0, u1, v0, u0, v1, u1, v1);
+        for (let i = 0; i < 4; i++) batch.colors.push(color.r, color.g, color.b);
+        batch.indices.push(base, base + 2, base + 1, base + 2, base + 3, base + 1);
+      };
+      for (const boldOffset of style.bold ? [0, 1] : [0]) {
+        if (glyph) quad(0, top, width, top + height, boldOffset);
+        else {
+          quad(0, 0, 5, 1, boldOffset);
+          quad(0, 7, 5, 8, boldOffset);
+          quad(0, 1, 1, 7, boldOffset);
+          quad(4, 1, 5, 7, boldOffset);
+        }
+      }
+    }
+  }
+  return batches.map(({ image, positions, uvs, colors, indices }) => ({ image, geometry: new import_three20.BufferGeometry().setAttribute("position", new import_three20.Float32BufferAttribute(positions, 3)).setAttribute("uv", new import_three20.Float32BufferAttribute(uvs, 2)).setAttribute("color", new import_three20.Float32BufferAttribute(colors, 3)).setIndex(indices) }));
+}
+
+// src/gui/GuiHelper.ts
 var GuiHelper = class {
+  /** Sizes a tooltip around supplied text; the first entry is its title. */
+  static async tooltip(lines, options = {}) {
+    if (!lines.length) return [];
+    const { position = [0, 0], titleGap = 2, lineHeight = 10, shadow = true, ...style } = options;
+    const textOptions = { ...style, lineHeight, shadow };
+    const layouts = await Promise.all(lines.map((line) => layoutGuiText(line, textOptions)));
+    const width = Math.max(...layouts.map((layout) => layout.width));
+    const height = layouts.reduce((sum, layout) => sum + layout.height, 0) - 2 + (lines.length > 1 ? titleGap : 0);
+    const layers = ["background", "frame"].map((part) => ({
+      name: `tooltip-${part}`,
+      texture: `minecraft:gui/sprites/tooltip/${part}`,
+      position: [position[0] - 12, position[1] - 12],
+      size: [width + 24, height + 24]
+    }));
+    let y = position[1];
+    lines.forEach((text, index) => {
+      layers.push({ ...textOptions, name: `tooltip-line-${index}`, text, position: [position[0], y] });
+      y += layouts[index].height + (index === 0 ? titleGap : 0);
+    });
+    return layers;
+  }
   static inventorySlot(slot, origin = [0, 0], offset = [18, 18], rowSize = 9) {
     const [column, row] = typeof slot === "number" ? [slot % rowSize, Math.floor(slot / rowSize)] : slot;
     return [origin[0] + column * offset[0], origin[1] + row * offset[1]];
@@ -8973,8 +9206,87 @@ var GuiHelper = class {
   }
 };
 
+// src/gui/GuiTextureGeometry.ts
+var import_three21 = require("three");
+function createGuiTextureGeometry(width, height, imageWidth, imageHeight, crop, scaling) {
+  if (crop || !scaling || scaling.type === "stretch") {
+    const [x, y, w, h] = crop ?? [0, 0, imageWidth, imageHeight];
+    const geometry = new import_three21.PlaneGeometry(width, height);
+    const uv = geometry.getAttribute("uv");
+    for (let i = 0; i < uv.count; i++) {
+      uv.setXY(
+        i,
+        (x + uv.getX(i) * w) / imageWidth,
+        1 - (y + (1 - uv.getY(i)) * h) / imageHeight
+      );
+    }
+    return geometry;
+  }
+  const sw = scaling.width, sh = scaling.height;
+  if (![sw, sh].every((value) => Number.isInteger(value) && value > 0)) {
+    throw new Error("GUI sprite dimensions must be positive integers");
+  }
+  if (![width, height].every((value) => Number.isFinite(value) && value >= 0)) {
+    throw new Error("GUI output dimensions must be finite and nonnegative");
+  }
+  const positions = [], uvs = [], normals = [], indices = [];
+  function quad(x, y, w, h, u, v, uw, vh) {
+    if (w <= 0 || h <= 0) return;
+    const index = positions.length / 3;
+    const left = x - width / 2, top = height / 2 - y;
+    positions.push(left, top, 0, left + w, top, 0, left, top - h, 0, left + w, top - h, 0);
+    uvs.push(
+      u / sw,
+      1 - v / sh,
+      (u + uw) / sw,
+      1 - v / sh,
+      u / sw,
+      1 - (v + vh) / sh,
+      (u + uw) / sw,
+      1 - (v + vh) / sh
+    );
+    normals.push(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1);
+    indices.push(index, index + 2, index + 1, index + 2, index + 3, index + 1);
+  }
+  function tile(x, y, w, h, u, v, tw, th) {
+    for (let dy = 0; dy < h; dy += th) {
+      for (let dx = 0; dx < w; dx += tw) {
+        const cw = Math.min(tw, w - dx), ch = Math.min(th, h - dy);
+        quad(x + dx, y + dy, cw, ch, u, v, cw, ch);
+      }
+    }
+  }
+  if (scaling.type === "tile") {
+    tile(0, 0, width, height, 0, 0, sw, sh);
+  } else {
+    let segments = function(size, sourceSize, start, end) {
+      if (size === sourceSize) return [[0, size, 0, sourceSize]];
+      start = Math.min(start, Math.floor(size / 2));
+      end = Math.min(end, Math.floor(size / 2));
+      return [
+        [0, start, 0, start],
+        [start, size - start - end, start, sourceSize - start - end],
+        [size - end, end, sourceSize - end, end]
+      ];
+    };
+    const border = typeof scaling.border === "number" ? { left: scaling.border, top: scaling.border, right: scaling.border, bottom: scaling.border } : scaling.border;
+    if (!border || typeof scaling.border === "number" && scaling.border <= 0 || ![border.left, border.top, border.right, border.bottom].every((value) => Number.isInteger(value) && value >= 0) || border.left + border.right >= sw || border.top + border.bottom >= sh) {
+      throw new Error("GUI nine-slice borders must be nonnegative integers with a nonempty center");
+    }
+    const columns = segments(width, sw, border.left, border.right);
+    const rows = segments(height, sh, border.top, border.bottom);
+    for (const [y, h, v, vh] of rows) {
+      for (const [x, w, u, uw] of columns) {
+        if (w <= 0 || h <= 0) continue;
+        (scaling.stretch_inner ? quad : tile)(x, y, w, h, u, v, uw, vh);
+      }
+    }
+  }
+  return new import_three21.BufferGeometry().setAttribute("position", new import_three21.Float32BufferAttribute(positions, 3)).setAttribute("normal", new import_three21.Float32BufferAttribute(normals, 3)).setAttribute("uv", new import_three21.Float32BufferAttribute(uvs, 2)).setIndex(indices);
+}
+
 // src/gui/scene/GuiObject.ts
-var import_three24 = require("three");
+var import_three26 = require("three");
 init_AssetKey();
 init_ModelTextures();
 init_Models();
@@ -8990,9 +9302,10 @@ var GuiObject = class extends SceneObject {
     this.textureLayers = textureLayers;
     this.isGuiObject = true;
     /** Local bounds in GUI pixels, with y growing down from the origin. */
-    this.bounds = new import_three24.Box2();
+    this.bounds = new import_three26.Box2();
     this.geometries = /* @__PURE__ */ new Set();
     this.ownedMaterials = /* @__PURE__ */ new Set();
+    this.textMaterials = /* @__PURE__ */ new Map();
     this.initialized = false;
   }
   async init() {
@@ -9001,6 +9314,43 @@ var GuiObject = class extends SceneObject {
       let depth = 0;
       for (const [index, layer] of this.textureLayers.entries()) {
         const [x, y] = layer.position ?? [0, 0];
+        if ("text" in layer) {
+          const layout = await layoutGuiText(layer.text, layer);
+          const group = new import_three26.Group();
+          group.name = `group:${layer.name ?? index}`;
+          group.position.set(x, -y, depth);
+          const [width2, height2] = layer.size ?? [layout.width, layout.height];
+          group.scale.set(layout.width ? width2 / layout.width : 1, height2 / layout.height, 1);
+          this.add(group);
+          const parts = createGuiTextGeometry(layout, layer.shadow);
+          const bounds = new import_three26.Box3();
+          for (const [partIndex, { image: image2, geometry: geometry2 }] of parts.entries()) {
+            this.geometries.add(geometry2);
+            geometry2.computeBoundingBox();
+            bounds.union(geometry2.boundingBox);
+            let material2 = this.textMaterials.get(image2);
+            if (!material2) {
+              material2 = image2 ? Materials.createGuiCanvasMaterial(image2) : new import_three26.MeshBasicMaterial({ transparent: true, depthWrite: false, side: import_three26.DoubleSide, toneMapped: false });
+              material2.vertexColors = true;
+              this.textMaterials.set(image2, material2);
+              this.ownedMaterials.add(material2);
+            }
+            const mesh2 = new import_three26.Mesh(geometry2, material2);
+            mesh2.name = `mesh:${layer.name ?? index}:${partIndex}`;
+            mesh2.renderOrder = index + partIndex / (parts.length + 1) * 0.5;
+            group.add(mesh2);
+          }
+          group.updateMatrix();
+          bounds.applyMatrix4(group.matrix);
+          this.bounds.expandByPoint(new import_three26.Vector2(x, y));
+          this.bounds.expandByPoint(new import_three26.Vector2(x + width2, y + height2));
+          if (!bounds.isEmpty()) {
+            this.bounds.expandByPoint(new import_three26.Vector2(bounds.min.x, -bounds.max.y));
+            this.bounds.expandByPoint(new import_three26.Vector2(bounds.max.x, -bounds.min.y));
+          }
+          depth += 0.01;
+          continue;
+        }
         if ("item" in layer) {
           const [width2, height2] = layer.size ?? [16, 16];
           const item = await this.createItem(layer, index);
@@ -9008,41 +9358,33 @@ var GuiObject = class extends SceneObject {
           item.scale.set(width2 / 16, height2 / 16, width2 / 16);
           item.updateWorldMatrix(true, true);
           const inverse = this.matrixWorld.clone().invert();
-          const bounds = new import_three24.Box3();
+          const bounds = new import_three26.Box3();
           item.iterateAllMeshes((mesh2) => {
             mesh2.geometry.computeBoundingBox();
-            bounds.union(mesh2.geometry.boundingBox.clone().applyMatrix4(new import_three24.Matrix4().multiplyMatrices(inverse, mesh2.matrixWorld)));
+            bounds.union(mesh2.geometry.boundingBox.clone().applyMatrix4(new import_three26.Matrix4().multiplyMatrices(inverse, mesh2.matrixWorld)));
           });
           item.position.z = depth - bounds.min.z;
           depth += bounds.max.z - bounds.min.z + 0.01;
-          this.bounds.expandByPoint(new import_three24.Vector2(x, y));
-          this.bounds.expandByPoint(new import_three24.Vector2(x + width2, y + height2));
-          this.bounds.expandByPoint(new import_three24.Vector2(bounds.min.x, -bounds.max.y));
-          this.bounds.expandByPoint(new import_three24.Vector2(bounds.max.x, -bounds.min.y));
+          this.bounds.expandByPoint(new import_three26.Vector2(x, y));
+          this.bounds.expandByPoint(new import_three26.Vector2(x + width2, y + height2));
+          this.bounds.expandByPoint(new import_three26.Vector2(bounds.min.x, -bounds.max.y));
+          this.bounds.expandByPoint(new import_three26.Vector2(bounds.max.x, -bounds.min.y));
           continue;
         }
         const key = typeof layer.texture === "string" ? AssetKey.parse("textures", layer.texture) : layer.texture;
         const material = await this.loadMaterial(key);
         const image = material.map.image;
-        const [cropX, cropY, cropWidth, cropHeight] = layer.crop ?? [0, 0, image.width, image.height];
-        const [width, height] = layer.size ?? [cropWidth, cropHeight];
-        const geometry = new import_three24.PlaneGeometry(width, height);
+        const scaling = layer.crop ? void 0 : (await ModelTextures.getMeta(key))?.gui?.scaling;
+        const [width, height] = layer.size ?? (layer.crop ? layer.crop.slice(2) : scaling && scaling.type !== "stretch" ? [scaling.width, scaling.height] : [image.width, image.height]);
+        const geometry = createGuiTextureGeometry(width, height, image.width, image.height, layer.crop, scaling);
         this.geometries.add(geometry);
-        const uv = geometry.getAttribute("uv");
-        for (let i = 0; i < uv.count; i++) {
-          uv.setXY(
-            i,
-            (cropX + uv.getX(i) * cropWidth) / image.width,
-            1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
-          );
-        }
-        const mesh = new import_three24.Mesh(geometry, material);
+        const mesh = new import_three26.Mesh(geometry, material);
         mesh.name = `mesh:${layer.name ?? index}`;
         mesh.position.set(x + width / 2, -y - height / 2, depth);
         mesh.renderOrder = index;
         this.add(mesh);
-        this.bounds.expandByPoint(new import_three24.Vector2(x, y));
-        this.bounds.expandByPoint(new import_three24.Vector2(x + width, y + height));
+        this.bounds.expandByPoint(new import_three26.Vector2(x, y));
+        this.bounds.expandByPoint(new import_three26.Vector2(x + width, y + height));
         depth += 0.01;
       }
       for (const child of this.children) child.position.z -= depth - 0.01;
@@ -9100,10 +9442,11 @@ var GuiObject = class extends SceneObject {
     for (const geometry of this.geometries) geometry.dispose();
     this.geometries.clear();
     for (const material of this.ownedMaterials) {
-      material.map.dispose();
+      material.map?.dispose();
       material.dispose();
     }
     this.ownedMaterials.clear();
+    this.textMaterials.clear();
     this.bounds.makeEmpty();
     this.initialized = false;
     super.disposeAndRemoveAllChildren();
@@ -9117,7 +9460,7 @@ function isGuiObject(obj) {
 init_image();
 
 // src/inspector/SceneInspector.ts
-var import_three25 = require("three");
+var import_three27 = require("three");
 init_SceneObject();
 init_util();
 init_log();
@@ -9127,11 +9470,11 @@ var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new import_three25.Vector2();
+    this.mouse = new import_three27.Vector2();
     this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three25.Raycaster();
+    this.raycaster = new import_three27.Raycaster();
     this.init();
   }
   init() {
@@ -9534,7 +9877,7 @@ init_ModelMerger();
 init_SpecialItems();
 
 // src/model/block/BlockStateResolver.ts
-var import_three27 = require("three");
+var import_three29 = require("three");
 init_BlockStates();
 init_MineRenderError();
 init_util();
@@ -9612,7 +9955,7 @@ var BlockStateResolver = class {
     return variants[variants.length - 1];
   }
   static rotation(variant) {
-    const rotation = new import_three27.Euler();
+    const rotation = new import_three29.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -9704,7 +10047,7 @@ init_SceneObject();
 init_ModelObject();
 init_Models();
 var import_ts_deepmerge6 = __toESM(require_dist());
-var import_three30 = require("three");
+var import_three32 = require("three");
 init_MineRenderError();
 init_InstanceReference();
 init_AssetKey();
@@ -9726,7 +10069,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     this._models = [];
     this._cullMask = 0;
     this._entities = [];
-    this._entityPlacement = new import_three30.Matrix4();
+    this._entityPlacement = new import_three32.Matrix4();
     this._entityGeneration = 0;
     this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
   }
@@ -9827,7 +10170,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     return true;
   }
   placeEntities() {
-    const matrix = new import_three30.Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
+    const matrix = new import_three32.Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
     for (const entity of this._entities) {
       matrix.decompose(entity.position, entity.quaternion, entity.scale);
     }
@@ -9849,12 +10192,12 @@ var BlockObject = class _BlockObject extends SceneObject {
   getModelCullMask(model, worldMask) {
     const object = isInstanceReference(model) ? model.instanceable : model;
     if (object.options.displayPosition) return 0;
-    const position = new import_three30.Vector3();
-    const rotation = new import_three30.Quaternion();
-    const scale = new import_three30.Vector3();
+    const position = new import_three32.Vector3();
+    const rotation = new import_three32.Quaternion();
+    const scale = new import_three32.Vector3();
     this.getModelMatrix(model).decompose(position, rotation, scale);
-    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three30.Vector3(1, 1, 1)) > 1e-10) return 0;
-    return ModelCulling.toLocalMask(worldMask, new import_three30.Euler().setFromQuaternion(rotation));
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three32.Vector3(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new import_three32.Euler().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
     worldMask &= 63;
@@ -9920,7 +10263,7 @@ var BlockObject = class _BlockObject extends SceneObject {
       () => new FluidModelObject2(kind, surface.sample, this.blockState.key, this.options)
     );
     const previous = this._fluidModel;
-    const matrix = previous ? this.getModelMatrix(previous) : new import_three30.Matrix4().makeTranslation(...this.position.toArray());
+    const matrix = previous ? this.getModelMatrix(previous) : new import_three32.Matrix4().makeTranslation(...this.position.toArray());
     if (isInstanceReference(replacement)) replacement.setMatrix(matrix);
     else matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
     this._models = this._models.filter((model) => model !== previous);
@@ -10062,7 +10405,7 @@ var BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three30.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three32.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -11934,7 +12277,7 @@ init_ModelObject();
 init_nbt();
 
 // src/renderer/MineRenderScene.ts
-var import_three32 = require("three");
+var import_three34 = require("three");
 init_SceneObject();
 var import_ts_deepmerge8 = __toESM(require_dist());
 init_ModelObject();
@@ -12667,7 +13010,7 @@ var import_ts_deepmerge7 = __toESM(require_dist());
 init_util();
 
 // src/skin/SkinTextures.ts
-var import_three31 = require("three");
+var import_three33 = require("three");
 init_Caching();
 init_CacheKey();
 init_MineRenderError();
@@ -12751,11 +13094,11 @@ var SkinTextures = class {
     });
   }
   static createMaterial(pixels, width, height, transparent = true) {
-    const texture = Textures.initTextureProps(new import_three31.DataTexture(pixels, width, height));
-    texture.colorSpace = import_three31.SRGBColorSpace;
+    const texture = Textures.initTextureProps(new import_three33.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three33.SRGBColorSpace;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new import_three31.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three31.DoubleSide : import_three31.FrontSide, alphaTest: transparent ? 0.1 : 0 });
+    return new import_three33.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three33.DoubleSide : import_three33.FrontSide, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -12985,7 +13328,7 @@ var SkinObject = class extends SceneObject {
 // src/renderer/MineRenderScene.ts
 init_EntityObject();
 init_ItemTints();
-var MineRenderScene = class _MineRenderScene extends import_three32.Scene {
+var MineRenderScene = class _MineRenderScene extends import_three34.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -13115,7 +13458,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three34 = require("three");
+var import_three36 = require("three");
 var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
@@ -13124,11 +13467,11 @@ init_Model();
 init_three();
 
 // src/three/OrbitControls.js
-var import_three33 = require("three");
+var import_three35 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three33.EventDispatcher {
+var OrbitControls = class extends import_three35.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -13137,7 +13480,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three33.Vector3();
+    this.target = new import_three35.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -13159,8 +13502,8 @@ var OrbitControls = class extends import_three33.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three33.MOUSE.ROTATE, MIDDLE: import_three33.MOUSE.DOLLY, RIGHT: import_three33.MOUSE.PAN };
-    this.touches = { ONE: import_three33.TOUCH.ROTATE, TWO: import_three33.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three35.MOUSE.ROTATE, MIDDLE: import_three35.MOUSE.DOLLY, RIGHT: import_three35.MOUSE.PAN };
+    this.touches = { ONE: import_three35.TOUCH.ROTATE, TWO: import_three35.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -13189,11 +13532,11 @@ var OrbitControls = class extends import_three33.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three33.Vector3();
-      const quat = new import_three33.Quaternion().setFromUnitVectors(object.up, new import_three33.Vector3(0, 1, 0));
+      const offset = new import_three35.Vector3();
+      const quat = new import_three35.Quaternion().setFromUnitVectors(object.up, new import_three35.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three33.Vector3();
-      const lastQuaternion = new import_three33.Quaternion();
+      const lastPosition = new import_three35.Vector3();
+      const lastQuaternion = new import_three35.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -13279,20 +13622,20 @@ var OrbitControls = class extends import_three33.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three33.Spherical();
-    const sphericalDelta = new import_three33.Spherical();
+    const spherical = new import_three35.Spherical();
+    const sphericalDelta = new import_three35.Spherical();
     let scale = 1;
-    const panOffset = new import_three33.Vector3();
+    const panOffset = new import_three35.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three33.Vector2();
-    const rotateEnd = new import_three33.Vector2();
-    const rotateDelta = new import_three33.Vector2();
-    const panStart = new import_three33.Vector2();
-    const panEnd = new import_three33.Vector2();
-    const panDelta = new import_three33.Vector2();
-    const dollyStart = new import_three33.Vector2();
-    const dollyEnd = new import_three33.Vector2();
-    const dollyDelta = new import_three33.Vector2();
+    const rotateStart = new import_three35.Vector2();
+    const rotateEnd = new import_three35.Vector2();
+    const rotateDelta = new import_three35.Vector2();
+    const panStart = new import_three35.Vector2();
+    const panEnd = new import_three35.Vector2();
+    const panDelta = new import_three35.Vector2();
+    const dollyStart = new import_three35.Vector2();
+    const dollyEnd = new import_three35.Vector2();
+    const dollyDelta = new import_three35.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -13308,7 +13651,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three33.Vector3();
+      const v = new import_three35.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -13316,7 +13659,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three33.Vector3();
+      const v = new import_three35.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -13329,7 +13672,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three33.Vector3();
+      const offset = new import_three35.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -13578,12 +13921,12 @@ var OrbitControls = class extends import_three33.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three33.MOUSE.DOLLY:
+        case import_three35.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three33.MOUSE.ROTATE:
+        case import_three35.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -13594,7 +13937,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three33.MOUSE.PAN:
+        case import_three35.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -13650,12 +13993,12 @@ var OrbitControls = class extends import_three33.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three33.TOUCH.ROTATE:
+            case import_three35.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three33.TOUCH.PAN:
+            case import_three35.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -13666,12 +14009,12 @@ var OrbitControls = class extends import_three33.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three33.TOUCH.DOLLY_PAN:
+            case import_three35.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three33.TOUCH.DOLLY_ROTATE:
+            case import_three35.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -13738,7 +14081,7 @@ var OrbitControls = class extends import_three33.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three33.Vector2();
+        position = new import_three35.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -13758,10 +14101,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three33.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three33.MOUSE.ROTATE;
-    this.touches.ONE = import_three33.TOUCH.PAN;
-    this.touches.TWO = import_three33.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three35.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three35.MOUSE.ROTATE;
+    this.touches.ONE = import_three35.TOUCH.PAN;
+    this.touches.TWO = import_three35.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -13820,8 +14163,8 @@ var Renderer = class _Renderer {
           top: void 0,
           bottom: void 0
         },
-        position: new import_three34.Vector3(50, 50, 50),
-        lookingAt: new import_three34.Vector3(0, 0, 0)
+        position: new import_three36.Vector3(50, 50, 50),
+        lookingAt: new import_three36.Vector3(0, 0, 0)
       },
       render: {
         fpsLimit: 60,
@@ -13852,14 +14195,14 @@ var Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three34.PerspectiveCamera(
+        return new import_three36.PerspectiveCamera(
           this.options.camera.perspective.fov,
           this.options.camera.perspective.aspect ?? this.viewWidth / this.viewHeight,
           this.options.camera.near,
           this.options.camera.far
         );
       case "orthographic":
-        return new import_three34.OrthographicCamera(
+        return new import_three36.OrthographicCamera(
           this.options.camera.orthographic.left ?? this.viewWidth / -2,
           this.options.camera.orthographic.right ?? this.viewWidth / 2,
           this.options.camera.orthographic.top ?? this.viewHeight / 2,
@@ -13870,7 +14213,7 @@ var Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three34.WebGLRenderer({
+    const renderer = new import_three36.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -13878,8 +14221,8 @@ var Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three34.PCFShadowMap;
-    renderer.outputColorSpace = import_three34.SRGBColorSpace;
+    renderer.shadowMap.type = import_three36.PCFShadowMap;
+    renderer.outputColorSpace = import_three36.SRGBColorSpace;
     renderer.setPixelRatio(this.options.render.pixelRatio ?? 1);
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
@@ -13914,20 +14257,20 @@ var Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three34.GridHelper(128, 16);
+      const gridHelper = new import_three36.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three34.GridHelper(128, 16);
+      const gridHelper2 = new import_three36.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three34.GridHelper(128, 16);
+      const gridHelper3 = new import_three36.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper3);
       gridHelper3.rotation.z = 90 * (Math.PI / 180);
       this.scene.add(gridHelper3);
     }
     if (this.options.debug.axes) {
-      const axesHelper = new import_three34.AxesHelper(64);
+      const axesHelper = new import_three36.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -14613,12 +14956,12 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
-var import_three39 = require("three");
+var import_three41 = require("three");
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
-var import_three37 = require("three");
+var import_three39 = require("three");
 init_Model();
 init_BatchedExecutor();
 init_AssetKey();
@@ -14626,7 +14969,7 @@ init_BlockStates();
 init_CubeFace();
 
 // src/world/SectionModels.ts
-var import_three36 = require("three");
+var import_three38 = require("three");
 init_AssetKey();
 init_Models();
 init_CubeFace();
@@ -14692,12 +15035,12 @@ var SectionModels = class {
         });
         await object.init();
         const geometry = object.children[0].geometry;
-        geometry.applyMatrix4(new import_three36.Matrix4().makeRotationFromEuler(rotation));
+        geometry.applyMatrix4(new import_three38.Matrix4().makeRotationFromEuler(rotation));
         object.clear();
         const cullFaces = CUBE_FACES.map((face) => {
           const local = CUBE_FACES.findIndex((name) => name === atlas.model.elements[0].faces[face]?.cullface);
           if (local < 0) return 0;
-          const normal = new import_three36.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const normal = new import_three38.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
           const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           return 1 << world;
         });
@@ -14727,20 +15070,20 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three37.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three39.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three37.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three39.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three37.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three39.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three37.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three39.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -14751,10 +15094,10 @@ var MineRenderWorld = class {
   }
   async setBlockVisibleAt(posOrX, yOrVisible, z, visible) {
     if (typeof posOrX === "number") {
-      return this.setBlockVisibleAt(new import_three37.Vector3(posOrX, yOrVisible, z), visible);
+      return this.setBlockVisibleAt(new import_three39.Vector3(posOrX, yOrVisible, z), visible);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockVisibleAt(new import_three37.Vector3(...posOrX), yOrVisible);
+      return this.setBlockVisibleAt(new import_three39.Vector3(...posOrX), yOrVisible);
     }
     this.validatePosBounds(posOrX);
     await this.getChunkAt(posOrX)?.setBlockVisibleAt(posOrX, yOrVisible);
@@ -14771,7 +15114,7 @@ var MineRenderWorld = class {
     const collect = async (positions2) => {
       for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
     };
-    const place = (block) => this.placeBlock(new import_three37.Vector3(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new import_three39.Vector3(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -14849,13 +15192,13 @@ var MineRenderWorld = class {
     for (const pos of positions) {
       this.pendingCulling.set(pos.toArray().join(","), pos.clone());
       for (const offset of CUBE_FACE_OFFSETS) {
-        const neighbor = pos.clone().add(new import_three37.Vector3(...offset));
+        const neighbor = pos.clone().add(new import_three39.Vector3(...offset));
         this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
       }
       for (let y = -1; y <= 1; y++) {
         for (let z = -1; z <= 1; z++) {
           for (let x = -1; x <= 1; x++) {
-            const neighbor = pos.clone().add(new import_three37.Vector3(x, y, z));
+            const neighbor = pos.clone().add(new import_three39.Vector3(x, y, z));
             if (this.getBlockAt(neighbor)?.object?.fluidKind) {
               this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
             }
@@ -14879,7 +15222,7 @@ var MineRenderWorld = class {
             }
             if (block.object?.fluidKind) {
               await block.object.updateFluid((x, y, z) => {
-                const neighbor = pos.clone().add(new import_three37.Vector3(x, y, z));
+                const neighbor = pos.clone().add(new import_three39.Vector3(x, y, z));
                 const section = this.getChunkAt(neighbor);
                 const object = section?.isBlockVisibleAt(neighbor) ? section.getBlockAt(neighbor)?.object : void 0;
                 return {
@@ -14891,7 +15234,7 @@ var MineRenderWorld = class {
             }
             let mask = 0;
             for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-              const neighbor = pos.clone().add(new import_three37.Vector3(...offset));
+              const neighbor = pos.clone().add(new import_three39.Vector3(...offset));
               if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
                 mask |= 1 << face;
               }
@@ -14925,14 +15268,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new import_three37.Vector3(
+    return new import_three39.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three37.Vector3(
+    return new import_three39.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -14955,10 +15298,10 @@ var MineRenderWorld = class {
 init_Model();
 
 // src/world/SectionMesh.ts
-var import_three38 = require("three");
+var import_three40 = require("three");
 init_CanvasCompat();
 init_Materials();
-var SectionMesh = class _SectionMesh extends import_three38.Group {
+var SectionMesh = class _SectionMesh extends import_three40.Group {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
@@ -15031,18 +15374,18 @@ var SectionMesh = class _SectionMesh extends import_three38.Group {
           for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
         }
       }
-      const geometry = new import_three38.BufferGeometry();
-      geometry.setAttribute("position", new import_three38.Float32BufferAttribute(positions, 3));
-      geometry.setAttribute("normal", new import_three38.Float32BufferAttribute(normals, 3));
-      geometry.setAttribute("uv", new import_three38.Float32BufferAttribute(uvs, 2));
-      geometry.setAttribute("color", new import_three38.Float32BufferAttribute(colors, 3));
+      const geometry = new import_three40.BufferGeometry();
+      geometry.setAttribute("position", new import_three40.Float32BufferAttribute(positions, 3));
+      geometry.setAttribute("normal", new import_three40.Float32BufferAttribute(normals, 3));
+      geometry.setAttribute("uv", new import_three40.Float32BufferAttribute(uvs, 2));
+      geometry.setAttribute("color", new import_three40.Float32BufferAttribute(colors, 3));
       geometry.setIndex(indices);
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
       const material = Materials.createShadedCanvasMaterial(canvas, false);
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
-      const mesh = new import_three38.Mesh(geometry, material);
+      const mesh = new import_three40.Mesh(geometry, material);
       section.add(mesh);
       section.ownedMeshes.push({ mesh, texture });
     }
@@ -15078,10 +15421,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three39.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three41.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three39.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three41.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -15089,10 +15432,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three39.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three41.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three39.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three41.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -15204,7 +15547,7 @@ var Chunk = class _Chunk {
   }
   async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new import_three39.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new import_three41.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     ));
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -15229,14 +15572,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three39.Vector3(
+    return new import_three41.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three39.Vector3(
+    return new import_three41.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -15288,6 +15631,7 @@ var Chunk = class _Chunk {
   EntityObject,
   Env,
   FluidModelObject,
+  Fonts,
   Geometries,
   GuiHelper,
   GuiLight,
@@ -15361,6 +15705,8 @@ var Chunk = class _Chunk {
   computeTangents,
   createCanvas,
   createFluidGeometry,
+  createGuiTextGeometry,
+  createGuiTextureGeometry,
   createImage,
   entityAnimationTime,
   estimateBytesUsed,
@@ -15389,6 +15735,7 @@ var Chunk = class _Chunk {
   isTransformable,
   isTripleArray,
   isVector3,
+  layoutGuiText,
   md5,
   mergeBufferAttributes,
   mergeBufferGeometries,