minerender 2.1.0-alpha.132 → 2.1.0-alpha.133

package/dist/bundle.js

@@ -35632,6 +35632,7 @@ void main() {
             this.entityAnimationCache,
             this.blockEntityIndexCache,
             this.fontCache,
+            this.unihexCache,
             this.bannerPatternCache,
             this.mineRenderDataCache,
             this.usernameUuidCache,
@@ -35685,6 +35686,7 @@ void main() {
       _Caching.entityTextureCache = _Caching.createAssetCache();
       _Caching.entityAnimationCache = _Caching.createAssetCache();
       _Caching.blockEntityIndexCache = _Caching.createAssetCache();
+      _Caching.unihexCache = _Caching.createAssetCache();
       _Caching.fontCache = _Caching.createAssetCache();
       _Caching.bannerPatternCache = _Caching.createAssetCache();
       _Caching.mineRenderDataCache = _Caching.createAssetCache();
@@ -37098,6 +37100,7 @@ void main() {
         AssetParser2["IMAGE"] = "image";
         AssetParser2["LIST"] = "list";
         AssetParser2["JSON"] = "json";
+        AssetParser2["BINARY"] = "binary";
         return AssetParser2;
       })(AssetParser || {});
     }
@@ -73063,7 +73066,7 @@ return ${compiler2.callType("value", tagType)}
   });
 
   // src/assets/source/HostedAssetSource.ts
-  var p7, DEFAULT_OPTIONS2, _HostedAssetSource, HostedAssetSource;
+  var BINARY_TIMEOUT, p7, DEFAULT_OPTIONS2, _HostedAssetSource, HostedAssetSource;
   var init_HostedAssetSource = __esm({
     "src/assets/source/HostedAssetSource.ts"() {
       init_dirname();
@@ -73079,6 +73082,7 @@ return ${compiler2.callType("value", tagType)}
       init_AssetLoader();
       init_parser();
       init_merge();
+      BINARY_TIMEOUT = 6e4;
       p7 = prefix("HostedAssetSource");
       DEFAULT_OPTIONS2 = {
         retryDefaults: true
@@ -73219,6 +73223,15 @@ return ${compiler2.callType("value", tagType)}
           return response.data;
         }
       };
+      _HostedAssetSource.BINARY = {
+        config(request) {
+          request.timeout = BINARY_TIMEOUT;
+          request.responseType = "arraybuffer";
+        },
+        parse(response) {
+          return { data: new Uint8Array(response.data) };
+        }
+      };
       _HostedAssetSource.PARSER_MAP = /* @__PURE__ */ new Map([
         ["model" /* MODEL */, _HostedAssetSource.MODEL],
         ["blockstate" /* BLOCKSTATE */, _HostedAssetSource.BLOCKSTATE],
@@ -73226,7 +73239,8 @@ return ${compiler2.callType("value", tagType)}
         ["nbt" /* NBT */, _HostedAssetSource.NBT],
         ["image" /* IMAGE */, _HostedAssetSource.IMAGE],
         ["list" /* LIST */, _HostedAssetSource.LIST],
-        ["json" /* JSON */, _HostedAssetSource.JSON]
+        ["json" /* JSON */, _HostedAssetSource.JSON],
+        ["binary" /* BINARY */, _HostedAssetSource.BINARY]
       ]);
       HostedAssetSource = _HostedAssetSource;
     }
@@ -81841,7 +81855,7 @@ return ${compiler2.callType("value", tagType)}
   function readUint8Array(reader, offset, size, diskNumber) {
     return reader.readUint8Array(offset, size, diskNumber);
   }
-  var ERR_ITERATOR_COMPLETED_TOO_SOON, HTTP_HEADER_CONTENT_TYPE, DEFAULT_CHUNK_SIZE, PROPERTY_NAME_WRITABLE, Stream, Reader, BlobReader, BlobWriter, SplitDataReader, SplitDataWriter;
+  var ERR_ITERATOR_COMPLETED_TOO_SOON, HTTP_HEADER_CONTENT_TYPE, DEFAULT_CHUNK_SIZE, PROPERTY_NAME_WRITABLE, Stream, Reader, BlobReader, BlobWriter, TextWriter, Uint8ArrayReader, SplitDataReader, SplitDataWriter;
   var init_io = __esm({
     "../../node_modules/@zip.js/zip.js/lib/core/io.js"() {
       init_dirname();
@@ -81924,6 +81938,46 @@ return ${compiler2.callType("value", tagType)}
           return this.blob;
         }
       };
+      TextWriter = class extends BlobWriter {
+        constructor(encoding) {
+          super(encoding);
+          Object.assign(this, {
+            encoding,
+            utf8: !encoding || encoding.toLowerCase() == "utf-8"
+          });
+        }
+        async getData() {
+          const {
+            encoding,
+            utf8
+          } = this;
+          const blob = await super.getData();
+          if (blob.text && utf8) {
+            return blob.text();
+          } else {
+            const reader = new FileReader();
+            return new Promise((resolve, reject) => {
+              Object.assign(reader, {
+                onload: ({ target }) => resolve(target.result),
+                onerror: () => reject(reader.error)
+              });
+              reader.readAsText(blob, encoding);
+            });
+          }
+        }
+      };
+      Uint8ArrayReader = class extends Reader {
+        constructor(array) {
+          super();
+          Object.assign(this, {
+            array,
+            size: array.length
+          });
+        }
+        readUint8Array(index, length) {
+          return this.array.slice(index, index + length);
+        }
+      };
       SplitDataReader = class extends Reader {
         constructor(readers) {
           super();
@@ -84682,6 +84736,181 @@ ${key}` : key;
     }
   });
 
+  // src/assets/_fonts/Unihex.ts
+  var Unihex_exports = {};
+  __export(Unihex_exports, {
+    loadUnihex: () => loadUnihex
+  });
+  function readHex(text2, filename, glyphs) {
+    const lines = text2.split("\n");
+    if (lines[lines.length - 1] === "") lines.pop();
+    lines.forEach((line, index) => {
+      const match = /^([0-9A-F]{4,6}):([0-9A-F]+)$/.exec(line);
+      if (!match || ![32, 64, 96, 128].includes(match[2].length)) {
+        throw new Error(`Invalid Unihex record in ${filename} at line ${index + 1}`);
+      }
+      const codepoint = parseInt(match[1], 16);
+      if (codepoint > 1114111) throw new Error(`Invalid Unihex codepoint in ${filename} at line ${index + 1}`);
+      const bitWidth = match[2].length / 4;
+      const rowLength = bitWidth / 4;
+      const rows = new Uint32Array(GLYPH_HEIGHT);
+      let mask = 0;
+      for (let y5 = 0; y5 < GLYPH_HEIGHT; y5++) {
+        rows[y5] = parseInt(match[2].slice(y5 * rowLength, (y5 + 1) * rowLength), 16);
+        mask |= rows[y5];
+      }
+      let left = 0, right = bitWidth;
+      if (mask) {
+        while (!(mask >>> bitWidth - left - 1 & 1)) left++;
+        right = bitWidth - 1;
+        while (!(mask >>> bitWidth - right - 1 & 1)) right--;
+      }
+      glyphs.set(codepoint, { rows, bitWidth, left, right });
+    });
+  }
+  async function parseUnihex(key) {
+    try {
+      const asset2 = await AssetLoader.get(key, "binary" /* BINARY */);
+      if (!asset2) throw new Error(`Could not load Unihex archive ${key.toNamespacedString()}`);
+      const records = /* @__PURE__ */ new Map();
+      const reader = new ZipReader(new Uint8ArrayReader(asset2.data), { useWebWorkers: false, useCompressionStream: false });
+      try {
+        for (const entry of await reader.getEntries()) {
+          if (!entry.directory && entry.filename.endsWith(".hex")) {
+            readHex(await entry.getData(new TextWriter(), { checkSignature: true }), entry.filename, records);
+          }
+        }
+      } finally {
+        await reader.close();
+      }
+      const indices = new Int32Array(1114112).fill(-1);
+      const rows = new Uint32Array(records.size * GLYPH_HEIGHT), metrics = new Uint8Array(records.size * 3);
+      let index = 0;
+      for (const [codepoint, record] of records) {
+        indices[codepoint] = index;
+        rows.set(record.rows, index * GLYPH_HEIGHT);
+        metrics.set([record.bitWidth, record.left, record.right], index * 3);
+        index++;
+      }
+      return { indices, rows, metrics };
+    } catch (error2) {
+      console.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error2);
+      return void 0;
+    }
+  }
+  async function loadUnihex(provider, fontKey, characters) {
+    const origin = new AssetKey(DEFAULT_NAMESPACE, "", void 0, void 0, "assets", "", fontKey.root);
+    const key = AssetKey.parse("font", provider.hex_file, origin);
+    key.assetType = void 0;
+    const glyphs = /* @__PURE__ */ new Map();
+    let overrides;
+    try {
+      overrides = (provider.size_overrides ?? []).map((override) => {
+        const from = override.from.codePointAt(0), to = override.to.codePointAt(0);
+        if ([...override.from].length !== 1 || [...override.to].length !== 1 || from >= to || !Number.isInteger(override.left) || !Number.isInteger(override.right) || override.right < override.left) {
+          throw new Error(`Invalid Unihex size override in font ${fontKey.toNamespacedString()}`);
+        }
+        return { ...override, from, to };
+      });
+    } catch (error2) {
+      console.warn(`Could not load Unihex file ${key.toNamespacedString()}`, error2);
+      return glyphs;
+    }
+    const file = await Caching.unihexCache.get(key.serialize(), () => parseUnihex(key));
+    if (!file) return glyphs;
+    let atlas = atlases.get(provider);
+    if (!atlas) {
+      atlas = new UnihexAtlas();
+      atlases.set(provider, atlas);
+    }
+    for (const character of characters) {
+      const codepoint = character.codePointAt(0), index = file.indices[codepoint];
+      if (index < 0) continue;
+      const record = {
+        rows: file.rows.subarray(index * GLYPH_HEIGHT, (index + 1) * GLYPH_HEIGHT),
+        bitWidth: file.metrics[index * 3],
+        left: file.metrics[index * 3 + 1],
+        right: file.metrics[index * 3 + 2]
+      };
+      const override = overrides.find((range) => codepoint >= range.from && codepoint <= range.to);
+      if (override) {
+        record.left = override.left;
+        record.right = override.right;
+      }
+      const width = record.right - record.left + 1;
+      let rendered;
+      const render = () => rendered ?? (rendered = atlas.draw(record));
+      glyphs.set(character, {
+        get image() {
+          return render().image;
+        },
+        get x() {
+          return render().x;
+        },
+        get y() {
+          return render().y;
+        },
+        width,
+        height: GLYPH_HEIGHT,
+        scale: 0.5,
+        ascent: 7,
+        advance: Math.floor(width / 2) + 1,
+        boldOffset: 0.5,
+        shadowOffset: 0.5
+      });
+    }
+    return glyphs;
+  }
+  var ATLAS_SIZE, GLYPH_HEIGHT, UnihexAtlas, atlases;
+  var init_Unihex = __esm({
+    "src/assets/_fonts/Unihex.ts"() {
+      init_dirname();
+      init_buffer2();
+      init_process2();
+      init_zip();
+      init_AssetKey();
+      init_AssetLoader();
+      init_Assets();
+      init_Caching();
+      init_AssetParsers();
+      init_CanvasCompat();
+      ATLAS_SIZE = 512;
+      GLYPH_HEIGHT = 16;
+      UnihexAtlas = class {
+        constructor() {
+          this.x = 0;
+          this.y = 0;
+        }
+        draw(glyph) {
+          const width = glyph.right - glyph.left + 1;
+          if (this.image && this.x + width > this.image.width) {
+            this.x = 0;
+            this.y += GLYPH_HEIGHT;
+          }
+          if (!this.image || this.y + GLYPH_HEIGHT > this.image.height || width > this.image.width) {
+            this.image = createCanvas(Math.max(ATLAS_SIZE, width), ATLAS_SIZE);
+            this.x = 0;
+            this.y = 0;
+          }
+          const context = this.image.getContext("2d");
+          const pixels = context.createImageData(width, GLYPH_HEIGHT);
+          for (let y5 = 0; y5 < GLYPH_HEIGHT; y5++) {
+            for (let x4 = 0; x4 < width; x4++) {
+              const column = glyph.left + x4;
+              if (column < 0 || column >= glyph.bitWidth || !(glyph.rows[y5] >>> glyph.bitWidth - column - 1 & 1)) continue;
+              pixels.data.fill(255, (y5 * width + x4) * 4, (y5 * width + x4 + 1) * 4);
+            }
+          }
+          const result = { image: this.image, x: this.x, y: this.y };
+          context.putImageData(pixels, this.x, this.y);
+          this.x += width;
+          return result;
+        }
+      };
+      atlases = /* @__PURE__ */ new WeakMap();
+    }
+  });
+
   // src/assets/Fonts.ts
   var Fonts;
   var init_Fonts = __esm({
@@ -84695,7 +84924,7 @@ ${key}` : key;
       init_ModelTextures();
       init_Caching();
       Fonts = class {
-        /** Combines font definitions in source-priority order. Unsupported Unihex and TrueType providers are skipped. */
+        /** Combines font definitions in source-priority order. TrueType providers are skipped. */
         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, []));
@@ -84711,6 +84940,7 @@ ${key}` : key;
           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();
+          const providers = [];
           for (const asset2 of stack) {
             for (const provider of asset2.providers) {
               if (provider.filter?.uniform || provider.filter?.jp) continue;
@@ -84729,17 +84959,43 @@ ${key}` : key;
                   break;
                 case "reference":
                 case "minecraft:reference":
-                  provided = (await this.load(this.relatedKey("font", provider.id, key), [...parents, serialized])).glyphs;
+                  const reference = await this.load(this.relatedKey("font", provider.id, key), [...parents, serialized]);
+                  if (reference.resolve) {
+                    providers.push(async (characters) => {
+                      await reference.resolve(characters);
+                      return reference.glyphs;
+                    });
+                    continue;
+                  }
+                  provided = reference.glyphs;
                   break;
+                case "unihex":
+                case "minecraft:unihex":
+                  providers.push(async (characters) => (await Promise.resolve().then(() => (init_Unihex(), Unihex_exports))).loadUnihex(provider, key, characters));
+                  continue;
                 default:
                   continue;
               }
-              for (const [character, glyph] of provided) {
+              if (providers.every((provider2) => provider2 instanceof Map)) for (const [character, glyph] of provided) {
                 if (character !== "\0" && !glyphs.has(character)) glyphs.set(character, glyph);
               }
+              providers.push(provided);
             }
           }
-          return { glyphs };
+          return { glyphs, resolve: providers.every((provider) => provider instanceof Map) ? void 0 : async (characters) => {
+            const remaining = new Set([...characters].filter((character) => character !== "\0" && character !== "\n" && character !== "\r" && !glyphs.has(character)));
+            for (const provider of providers) {
+              if (!remaining.size) break;
+              const provided = provider instanceof Map ? provider : await provider([...remaining].join(""));
+              for (const character of remaining) {
+                const glyph = provided.get(character);
+                if (glyph) {
+                  glyphs.set(character, glyph);
+                  remaining.delete(character);
+                }
+              }
+            }
+          } };
         }
         static async bitmap(provider, fontKey) {
           const rows = provider.chars.map((row) => [...row]);
@@ -87964,6 +88220,7 @@ ${key}` : key;
     }
     const font = await Fonts.get(options.font);
     const runs = typeof text2 === "string" ? [{ text: text2 }] : text2;
+    await font.resolve?.(runs.map((run) => run.text).join(""));
     const glyphs = [], lineWidths = [];
     let line = [], width = 0;
     let trailingNewline = false;
@@ -87990,7 +88247,7 @@ ${key}` : key;
           continue;
         }
         const glyph = font.glyphs.get(character);
-        const advance = (glyph?.advance ?? 6) + (style.bold ? 1 : 0);
+        const advance = (glyph?.advance ?? 6) + (style.bold ? glyph?.boldOffset ?? 1 : 0);
         line.push({ character, glyph, advance, style, x: 0, y: 0 });
         width += advance;
         while (width > maxWidth && line.length > 1) {
@@ -88018,7 +88275,7 @@ ${key}` : key;
           batches.push(batch);
         }
         const color3 = new Color(isShadow ? (style.color & 16579836) >> 2 : style.color);
-        const offset = isShadow ? 1 : 0;
+        const offset = isShadow ? glyph?.shadowOffset ?? 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;
@@ -88048,7 +88305,7 @@ ${key}` : key;
           for (let i4 = 0; i4 < 4; i4++) batch.colors.push(color3.r, color3.g, color3.b);
           batch.indices.push(base, base + 2, base + 1, base + 2, base + 3, base + 1);
         };
-        for (const boldOffset of style.bold ? [0, 1] : [0]) {
+        for (const boldOffset of style.bold ? [0, glyph?.boldOffset ?? 1] : [0]) {
           if (glyph) quad(0, top, width, top + height, boldOffset);
           else {
             quad(0, 0, 5, 1, boldOffset);
@@ -104158,7 +104415,7 @@ gl_FragDepth=readDepth(vUv);
 
   // src/world/SectionGeometry.ts
   function buildSectionGeometry(input) {
-    const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids, light, ambientLight, ambientOcclusion, biomeTints } = input;
+    const { count, indices, templates, cullMasks, templateData, atlases: atlases2, maxAtlasSize, fluids, light, ambientLight, ambientOcclusion, biomeTints } = input;
     if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
     if (count > indices.length || count > templates.length || count > cullMasks.length) throw new RangeError("Section entry count exceeds its arrays");
     if (biomeTints && biomeTints.length !== count * 3) throw new RangeError("Section biome tints must contain RGB for each placement");
@@ -104193,8 +104450,8 @@ gl_FragDepth=readDepth(vUv);
     const locations = /* @__PURE__ */ new Map();
     for (const [layer, layerAtlases] of [...visibleAtlases].sort(([a4], [b4]) => a4 - b4)) {
       const firstPage = pages.length;
-      for (const atlas of [...layerAtlases].sort((a4, b4) => Number(atlases[a4].animated) - Number(atlases[b4].animated) || (atlases[a4].animated ? a4 - b4 : atlases[b4].height - atlases[a4].height))) {
-        const { width, height, animated } = atlases[atlas];
+      for (const atlas of [...layerAtlases].sort((a4, b4) => Number(atlases2[a4].animated) - Number(atlases2[b4].animated) || (atlases2[a4].animated ? a4 - b4 : atlases2[b4].height - atlases2[a4].height))) {
+        const { width, height, animated } = atlases2[atlas];
         if (width > maxAtlasSize || height > maxAtlasSize) throw new RangeError("Model atlas exceeds the section atlas size limit");
         let selected = -1;
         for (let i4 = firstPage; !animated && i4 < pages.length; i4++) {
@@ -104237,7 +104494,7 @@ gl_FragDepth=readDepth(vUv);
         });
         if (!quads.sprites.length) continue;
         if (!fluidPages.has(fluid)) {
-          const { width, height } = atlases[data.atlas];
+          const { width, height } = atlases2[data.atlas];
           if (width > maxAtlasSize || height > maxAtlasSize) throw new RangeError("Model atlas exceeds the section atlas size limit");
           fluidPages.set(fluid, {
             layer: 2,
@@ -104255,7 +104512,7 @@ gl_FragDepth=readDepth(vUv);
         const tint = fluid === "water" && fluids.waterTints ? fluids.waterTints.subarray(tintIndex, tintIndex + 3) : data.tint;
         fluidPages.get(fluid).fluids.push({ quads, x: x4, y: y5, z: z4, data, tint });
       }
-      pages.push(...[...fluidPages.values()].sort((a4, b4) => Number(atlases[a4.placements[0].atlas].animated) - Number(atlases[b4.placements[0].atlas].animated) || a4.placements[0].atlas - b4.placements[0].atlas));
+      pages.push(...[...fluidPages.values()].sort((a4, b4) => Number(atlases2[a4.placements[0].atlas].animated) - Number(atlases2[b4.placements[0].atlas].animated) || a4.placements[0].atlas - b4.placements[0].atlas));
     }
     return pages.map((page) => {
       let faces = page.fluids.reduce((sum, fluid) => sum + fluid.quads.sprites.length, 0);
@@ -104272,7 +104529,7 @@ gl_FragDepth=readDepth(vUv);
       let vertex2 = 0, indexOffset = 0;
       for (const entry of page.entries) {
         const template = templateData[templates[entry]];
-        const atlas = atlases[template.atlas];
+        const atlas = atlases2[template.atlas];
         const placement = locations.get(template.atlas);
         const mapU = (u4) => (placement.x + u4 * atlas.width) / page.width;
         const mapV = (v5) => 1 - (placement.y + (1 - v5) * atlas.height) / page.height;
@@ -104311,7 +104568,7 @@ gl_FragDepth=readDepth(vUv);
         }
       }
       for (const { quads, x: x4, y: y5, z: z4, data, tint } of page.fluids) {
-        const atlas = atlases[data.atlas];
+        const atlas = atlases2[data.atlas];
         const placement = page.placements[0];
         const mapU = (u4) => (placement.x + u4 * atlas.width) / page.width;
         const mapV = (v5) => 1 - (placement.y + (1 - v5) * atlas.height) / page.height;
@@ -104415,7 +104672,7 @@ gl_FragDepth=readDepth(vUv);
   var WATER_TINT = new Color(4159204).toArray();
   function toInput(entries, maxAtlasSize, fluids, lighting) {
     if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
-    const atlases = [];
+    const atlases2 = [];
     const atlasIds = /* @__PURE__ */ new Map();
     const templateIds = /* @__PURE__ */ new Map();
     const input = {
@@ -104438,9 +104695,9 @@ gl_FragDepth=readDepth(vUv);
       if (id === void 0) {
         let atlas = atlasIds.get(template.atlas);
         if (atlas === void 0) {
-          atlas = atlases.length;
+          atlas = atlases2.length;
           atlasIds.set(template.atlas, atlas);
-          atlases.push(template.atlas);
+          atlases2.push(template.atlas);
           input.atlases.push({ width: template.atlas.image.width, height: template.atlas.image.height, animated: template.atlas.hasAnimation });
         }
         let data = templateCache.get(template);
@@ -104499,9 +104756,9 @@ gl_FragDepth=readDepth(vUv);
         if (!atlas) continue;
         let id = atlasIds.get(atlas);
         if (id === void 0) {
-          id = atlases.length;
+          id = atlases2.length;
           atlasIds.set(atlas, id);
-          atlases.push(atlas);
+          atlases2.push(atlas);
           input.atlases.push({ width: atlas.image.width, height: atlas.image.height, animated: atlas.hasAnimation });
         }
         input.fluids[kind] = {
@@ -104512,7 +104769,7 @@ gl_FragDepth=readDepth(vUv);
         };
       }
     }
-    return { input, atlases };
+    return { input, atlases: atlases2 };
   }
   var SectionMesh = class _SectionMesh extends Group {
     constructor() {
@@ -104527,23 +104784,23 @@ gl_FragDepth=readDepth(vUv);
     }
     /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
     static build(entries, maxAtlasSize = 2048, fluids, lighting) {
-      const { input, atlases } = toInput(entries, maxAtlasSize, fluids, lighting);
-      return this.fromPages(buildSectionGeometry(input), atlases);
+      const { input, atlases: atlases2 } = toInput(entries, maxAtlasSize, fluids, lighting);
+      return this.fromPages(buildSectionGeometry(input), atlases2);
     }
     /** Builds section-local meshes in a browser worker when available, with synchronous fallback. */
     static async buildAsync(entries, maxAtlasSize = 2048, fluids, lighting) {
-      const { input, atlases } = toInput(entries, maxAtlasSize, fluids, lighting);
+      const { input, atlases: atlases2 } = toInput(entries, maxAtlasSize, fluids, lighting);
       const worker = SectionWorker.shared();
       const pages = worker ? await worker.build(input).catch(() => buildSectionGeometry(input)) : buildSectionGeometry(input);
-      return this.fromPages(pages, atlases);
+      return this.fromPages(pages, atlases2);
     }
-    static fromPages(pages, atlases) {
+    static fromPages(pages, atlases2) {
       const section = new _SectionMesh();
       for (const page of pages) {
         const canvas = createCanvas(page.width, page.height);
         const context = canvas.getContext("2d");
         for (const { atlas, x: x4, y: y5 } of page.placements) {
-          context.drawImage(atlases[atlas].image.canvas, x4, y5);
+          context.drawImage(atlases2[atlas].image.canvas, x4, y5);
         }
         const geometry = new BufferGeometry();
         geometry.setAttribute("position", new Float32BufferAttribute(page.positions.buffer, 3));
@@ -104554,7 +104811,7 @@ gl_FragDepth=readDepth(vUv);
         geometry.setIndex(new Uint32BufferAttribute(page.indices.buffer, 1));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
-        const transparent = page.layer === 2 ? atlases[page.placements[0].atlas].hasTranslucency : page.layer === 1;
+        const transparent = page.layer === 2 ? atlases2[page.placements[0].atlas].hasTranslucency : page.layer === 1;
         const material = Materials.createShadedCanvasMaterial(canvas, transparent, false, true);
         material.side = FrontSide;
         if (page.layer === 2) {
@@ -104569,7 +104826,7 @@ gl_FragDepth=readDepth(vUv);
         section.blockIndices.set(mesh, page.blockIndices);
         const unsubscribe = [];
         for (const { atlas: id, x: x4, y: y5 } of page.placements) {
-          const atlas = atlases[id];
+          const atlas = atlases2[id];
           if (!atlas.hasAnimation) continue;
           unsubscribe.push(atlas.subscribe(() => {
             context.clearRect(x4, y5, atlas.image.width, atlas.image.height);