minerender 2.1.0-alpha.18 → 2.1.0-alpha.2

package/dist/node/index.js

@@ -28,6 +28,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
 
 // ../../node_modules/ts-deepmerge/dist/index.js
 var require_dist = __commonJS({
@@ -37,8 +45,8 @@ var require_dist = __commonJS({
       __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
           s = arguments[i];
-          for (var p12 in s) if (Object.prototype.hasOwnProperty.call(s, p12))
-            t[p12] = s[p12];
+          for (var p13 in s) if (Object.prototype.hasOwnProperty.call(s, p13))
+            t[p13] = s[p13];
         }
         return t;
       };
@@ -82,7 +90,7 @@ var require_dist = __commonJS({
       return false;
     };
     var PROTECTED_KEYS = ["__proto__"];
-    var merge10 = function() {
+    var merge11 = function() {
       var objects = [];
       for (var _i = 0; _i < arguments.length; _i++) {
         objects[_i] = arguments[_i];
@@ -93,9 +101,9 @@ var require_dist = __commonJS({
             return;
           }
           if (Array.isArray(result[key]) && Array.isArray(current[key])) {
-            result[key] = merge10.options.mergeArrays ? Array.from(new Set(result[key].concat(current[key]))) : current[key];
+            result[key] = merge11.options.mergeArrays ? Array.from(new Set(result[key].concat(current[key]))) : current[key];
           } else if (isObject(result[key]) && isObject(current[key])) {
-            result[key] = merge10(result[key], current[key]);
+            result[key] = merge11(result[key], current[key]);
           } else {
             result[key] = current[key];
           }
@@ -106,18 +114,18 @@ var require_dist = __commonJS({
     var defaultOptions = {
       mergeArrays: true
     };
-    merge10.options = defaultOptions;
-    merge10.withOptions = function(options) {
+    merge11.options = defaultOptions;
+    merge11.withOptions = function(options) {
       var objects = [];
       for (var _i = 1; _i < arguments.length; _i++) {
         objects[_i - 1] = arguments[_i];
       }
-      merge10.options = __assign({ mergeArrays: true }, options);
-      var result = merge10.apply(void 0, __spreadArray([], __read(objects), false));
-      merge10.options = defaultOptions;
+      merge11.options = __assign({ mergeArrays: true }, options);
+      var result = merge11.apply(void 0, __spreadArray([], __read(objects), false));
+      merge11.options = defaultOptions;
       return result;
     };
-    exports2.default = merge10;
+    exports2.default = merge11;
   }
 });
 
@@ -127,7 +135,6 @@ __export(index_node_exports, {
   AXES: () => AXES,
   ArchiveAssetSource: () => ArchiveAssetSource,
   AssetKey: () => AssetKey,
-  AssetLoadError: () => AssetLoadError,
   AssetLoader: () => AssetLoader,
   AssetParser: () => AssetParser,
   AssetSource: () => AssetSource,
@@ -185,7 +192,6 @@ __export(index_node_exports, {
   OrbitControls: () => OrbitControls,
   PersistentCache: () => PersistentCache,
   Renderer: () => Renderer,
-  RequestError: () => RequestError,
   Requests: () => Requests,
   SKIN_PARTS: () => SKIN_PARTS,
   SceneInspector: () => SceneInspector,
@@ -296,29 +302,25 @@ var Env = class {
 };
 
 // src/cache/PersistentCache.ts
-var PersistentCache = class _PersistentCache {
+var _PersistentCache = class _PersistentCache {
   constructor(backing) {
     this.backing = backing;
   }
-  static {
-    /** Bump to invalidate every persisted entry. */
-    this.VERSION = 2;
-  }
   static open(name) {
     return Env.provider.openCache(name, _PersistentCache.VERSION);
   }
-  /** Loads a missing entry and stores only non-nullish results. */
   async getOrLoad(key, loader) {
     let v = await this.get(key);
     if (typeof v === "undefined" || v === null) {
       v = await loader(key);
-      if (typeof v !== "undefined" && v !== null) {
-        await this.put(key, v);
-      }
+      await this.put(key, v);
     }
     return v;
   }
 };
+/** Bump to invalidate every persisted entry. */
+_PersistentCache.VERSION = 1;
+var PersistentCache = _PersistentCache;
 
 // src/env/node/NodeCache.ts
 var NodeCache = class extends PersistentCache {
@@ -396,7 +398,7 @@ registerNodeEnv();
 // src/Axis.ts
 var import_three = require("three");
 var Axis = /* @__PURE__ */ ((Axis3) => {
-  Axis3["X"] = "x";
+  Axis3["X"] = "X";
   Axis3["Y"] = "y";
   Axis3["Z"] = "z";
   return Axis3;
@@ -404,7 +406,7 @@ var Axis = /* @__PURE__ */ ((Axis3) => {
 var AXES = Object.values(Axis);
 function axisToVec3(axis) {
   switch (axis) {
-    case "x" /* X */:
+    case "X" /* X */:
       return new import_three.Vector3(1, 0, 0);
     case "y" /* Y */:
       return new import_three.Vector3(0, 1, 0);
@@ -492,7 +494,8 @@ function serializeImageKey(key) {
   return md5(key.src);
 }
 function serializeBoxGeometryKey(key) {
-  return md5([key.width, key.height, key.depth, key.uv?.join(":")].join("_"));
+  var _a;
+  return md5([key.width, key.height, key.depth, (_a = key.uv) == null ? void 0 : _a.join(":")].join("_"));
 }
 function serializeTextureKey(key) {
   return md5([key.src, key.format, key.rotation].join("$"));
@@ -507,61 +510,7 @@ function serializeMeshKey(key) {
 // src/cache/Caching.ts
 var import_loading_cache = require("@inventivetalent/loading-cache");
 var import_time = require("@inventivetalent/time");
-var Caching = class _Caching {
-  static {
-    this.rawImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(5)).buildAsync();
-  }
-  static {
-    this.imageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-  }
-  static {
-    this.canvasImageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-  }
-  static {
-    this.wrappedImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-  }
-  static {
-    this.boxGeometryCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(20)).build();
-  }
-  static {
-    this.textureCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-  }
-  static {
-    this.materialCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-  }
-  static {
-    this.boxMeshCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-  }
-  static {
-    this.textureAssetCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-  }
-  static {
-    this.textureMetaCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-  }
-  static {
-    this.rawModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-  }
-  static {
-    this.mergedModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-  }
-  static {
-    this.modelTextureAtlasCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-  }
-  static {
-    this.blockStateCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-  }
-  static {
-    this.listAssetCache = _Caching.createAssetCache();
-  }
-  static {
-    this.defaultBlockStatesCache = _Caching.createAssetCache();
-  }
-  static {
-    this.entityModelsCache = _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();
-  }
+var Caching = class {
   /** Every cache above, so clear()/end() can never fall out of sync with the field list again. */
   static get all() {
     return [
@@ -578,10 +527,7 @@ var Caching = class _Caching {
       this.rawModelCache,
       this.mergedModelCache,
       this.modelTextureAtlasCache,
-      this.blockStateCache,
-      this.listAssetCache,
-      this.defaultBlockStatesCache,
-      this.entityModelsCache
+      this.blockStateCache
     ];
   }
   static clear() {
@@ -592,8 +538,8 @@ var Caching = class _Caching {
   /**
    * Clears every cache and stops its expiry timer.
    *
-   * Expiry timers are unref'd in Node, so idle processes can exit without this cleanup.
-   * Use {@link shutdown} to also stop requests and the shared Ticker.
+   * loading-cache reschedules that timer indefinitely, so a Node process will not exit until
+   * this is called - see {@link shutdown}.
    */
   static end() {
     for (const cache of this.all) {
@@ -607,6 +553,20 @@ var Caching = class _Caching {
     };
   }
 };
+Caching.rawImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(5)).buildAsync();
+Caching.imageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+Caching.canvasImageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+Caching.wrappedImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+Caching.boxGeometryCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(20)).build();
+Caching.textureCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+Caching.materialCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+Caching.boxMeshCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+Caching.textureAssetCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+Caching.textureMetaCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+Caching.rawModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+Caching.mergedModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+Caching.modelTextureAtlasCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+Caching.blockStateCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
 
 // src/Geometries.ts
 var Geometries = class _Geometries {
@@ -627,14 +587,13 @@ var Geometries = class _Geometries {
 };
 
 // src/Materials.ts
-var import_three5 = require("three");
+var import_three6 = require("three");
 
 // src/texture/Textures.ts
-var import_three4 = require("three");
+var import_three5 = require("three");
 
 // src/texture/TextureLoader.ts
-var import_three3 = require("three");
-var THREE = __toESM(require("three"));
+var import_three4 = require("three");
 
 // src/canvas/CanvasCompat.ts
 function createImage(width, height) {
@@ -645,7 +604,9 @@ function createCanvas2(width, height) {
 }
 
 // src/request/Requests.ts
+var import_axios = __toESM(require("axios"));
 var import_jobqu = require("jobqu");
+var import_time2 = require("@inventivetalent/time");
 
 // src/util/log.ts
 var Reset = "\x1B[0m";
@@ -655,174 +616,198 @@ function prefix(prefix2) {
   return `${FgGreen}MR${BgBlack}${prefix2 ?? ""}${Reset}`;
 }
 
-// src/request/Requests.ts
-var p = prefix("Requests");
-var RequestError = class extends Error {
-  constructor(message, response, cause) {
-    super(message);
-    this.response = response;
-    this.cause = cause;
-    this.name = "RequestError";
+// src/util/BatchedExecutor.ts
+var BatchedExecutor = class {
+  constructor(interval = 1, batch = 30) {
+    this.interval = interval;
+    this.batch = batch;
+    this.queue = [];
+    this.task = setInterval(() => this.run());
   }
-};
-async function fetchRequest(config, defaultBaseURL) {
-  const { url, baseURL = defaultBaseURL, timeout = 5e3, responseType = "json", signal, ...options } = config;
-  const target = baseURL && !/^([a-z][a-z\d+.-]*:|\/\/)/i.test(url) ? `${baseURL.replace(/\/+$/, "")}/${url.replace(/^\/+/, "")}` : url;
-  const headers = new Headers(options.headers);
-  if (typeof window === "undefined" && !headers.has("User-Agent")) {
-    headers.set("User-Agent", "MineRender");
-  }
-  const attemptSignal = AbortSignal.any([
-    ...signal ? [signal] : [],
-    ...timeout === 0 ? [] : [AbortSignal.timeout(timeout)]
-  ]);
-  const request = new Request(target, { ...options, headers, signal: attemptSignal });
-  attemptSignal.throwIfAborted();
-  try {
-    const response = await fetch(request);
-    const result = {
-      data: void 0,
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers,
-      url: response.url
-    };
-    if (!response.ok) {
-      await response.body?.cancel().catch(() => {
-      });
-      throw new RequestError(`Request failed with status ${response.status}`, result);
+  submit(task) {
+    this.queue.push(task);
+  }
+  run() {
+    for (let i = 0; i < this.batch; i++) {
+      this.runNext();
     }
-    const emptyBody = request.method === "HEAD" || response.status === 204 || response.status === 205;
-    const data = responseType === "arraybuffer" ? await response.arrayBuffer() : emptyBody || response.body === null ? void 0 : await response.json();
-    return { ...result, data };
-  } catch (error) {
-    attemptSignal.throwIfAborted();
-    if (/^https?:/.test(request.url) && request.redirect !== "error" && error instanceof TypeError) {
-      throw new RequestError("Network request failed", void 0, error);
+  }
+  runNext() {
+    let next = this.queue.shift();
+    if (next) next();
+  }
+};
+
+// src/util/model.ts
+var import_three3 = require("three");
+function applyElementRotation(rotation, geometry) {
+  const origin = new import_three3.Vector3(rotation.origin[0], rotation.origin[1], rotation.origin[2]);
+  geometry.translate(-origin.x, -origin.y, -origin.z);
+  switch (rotation.axis) {
+    case "X" /* X */:
+      geometry.rotateX(toRadians(rotation.angle));
+      break;
+    case "y" /* Y */:
+      geometry.rotateY(toRadians(rotation.angle));
+      break;
+    case "z" /* Z */:
+      geometry.rotateZ(toRadians(rotation.angle));
+      break;
+  }
+  if (rotation.rescale) {
+    if (Math.abs(rotation.angle) === 22.5) {
+      const s = 1 / Math.cos(0.39269909262657166);
+      geometry.scale(s, 1, s);
+    } else {
+      const s = 1 / Math.cos(0.7853981852531433);
+      geometry.scale(s, 1, s);
     }
-    throw error;
   }
+  geometry.translate(origin.x, origin.y, origin.z);
 }
-async function abortable(promise, signal) {
-  if (!signal) return promise;
-  let abort;
-  const cancelled = new Promise((_, reject) => {
-    abort = () => reject(signal.reason);
-    signal.addEventListener("abort", abort, { once: true });
-    if (signal.aborted) abort();
-  });
-  try {
-    return await Promise.race([promise, cancelled]);
-  } finally {
-    signal.removeEventListener("abort", abort);
+function applyModelPartRotation(modelPart, geometry) {
+  const origin = new import_three3.Vector3(modelPart.pivotX, modelPart.pivotY, modelPart.pivotZ);
+  geometry.translate(-origin.x, -origin.y, -origin.z);
+  geometry.rotateX(toRadians(modelPart.pitch));
+  geometry.rotateY(toRadians(modelPart.yaw));
+  geometry.rotateZ(toRadians(modelPart.roll));
+  geometry.translate(origin.x, origin.y, origin.z);
+}
+function applyGenericRotation(axis, rotation, obj) {
+  switch (axis) {
+    case "X" /* X */:
+      obj.rotateOnAxis(new import_three3.Vector3(1, 0, 0), toRadians(rotation));
+      break;
+    case "y" /* Y */:
+      obj.rotateOnAxis(new import_three3.Vector3(0, 1, 0), toRadians(rotation));
+      break;
+    case "z" /* Z */:
+      obj.rotateOnAxis(new import_three3.Vector3(0, 0, 1), toRadians(rotation));
+      break;
   }
 }
-var RequestQueue = class {
-  constructor() {
-    this.pendingRequests = 0;
-    this.stopped = new AbortController();
-    this.queue = new import_jobqu.JobQueue(
-      (request) => fetchRequest(request, this.baseURL),
-      { interval: 10, maxPerRun: 1, maxActive: 8 }
-    );
+function addBox3WireframeToObject(box, obj, color = 16777215, w = 2) {
+  let size = new import_three3.Vector3();
+  box.getSize(size);
+  let boxGeo = new import_three3.BoxGeometry(size.x, size.y, size.z, 1, 1, 1);
+  let wireGeo = new import_three3.EdgesGeometry(boxGeo);
+  let wireMat = new import_three3.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three3.LineSegments(wireGeo, wireMat);
+  obj.add(wireframe);
+  let axes = new import_three3.AxesHelper(1);
+  obj.add(axes);
+}
+function addWireframeToObject(obj, color = 16777215, w = 2) {
+  let boxGeo = new import_three3.BoxGeometry(16, 16, 16, 1, 1, 1);
+  let wireGeo = new import_three3.EdgesGeometry(boxGeo);
+  let wireMat = new import_three3.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three3.LineSegments(wireGeo, wireMat);
+  obj.add(wireframe);
+  let axes = new import_three3.AxesHelper(1);
+  obj.add(axes);
+}
+function addWireframeToMesh(geo, mesh, color = 16777215, w = 2) {
+  let wireGeo = new import_three3.EdgesGeometry(geo);
+  let wireMat = new import_three3.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three3.LineSegments(wireGeo, wireMat);
+  mesh.add(wireframe);
+  let axes = new import_three3.AxesHelper(1);
+  mesh.add(axes);
+}
+
+// src/util/performance.ts
+function captureException(e, ...extra) {
+  console.error(e, extra);
+}
+function timingStart(marker) {
+  console.time(marker);
+}
+function timingEnd(marker) {
+  console.timeEnd(marker);
+}
+
+// src/util/three.ts
+function isObject3D(obj) {
+  return obj.isObject3D;
+}
+function isMesh(obj) {
+  return obj.isMesh;
+}
+function isInstancedMesh(obj) {
+  return obj.isInstancedMesh;
+}
+function isPerspectiveCamera(obj) {
+  return obj.isPerspectiveCamera;
+}
+function isOrthographicCamera(obj) {
+  return obj.isOrthographicCamera;
+}
+
+// src/request/Requests.ts
+var p = prefix("Requests");
+if (typeof window === "undefined") {
+  import_axios.default.defaults.headers["User-Agent"] = "MineRender";
+}
+var _Requests = class _Requests {
+  static genericRequest(request) {
+    return this.genericQueue.add(request).catch(async (e) => {
+      console.debug(p, "generic catch", e.code, e);
+      if (this.shouldRetry(e, request)) {
+        await sleep(100);
+        return this.genericRequest(request);
+      }
+      throw e;
+    });
   }
-  async request(request) {
-    this.pendingRequests++;
-    const signal = request.signal;
-    try {
-      for (let retries = 0; ; retries++) {
-        signal?.throwIfAborted();
-        try {
-          return await abortable(this.queue.add(request), signal);
-        } catch (error) {
-          console.debug(p, "Request failed", error);
-          const delay = this.retryDelay(error, request, retries);
-          if (delay === void 0) {
-            throw error;
+  static mcAssetRequest(request) {
+    return this.mcAssetRequestQueue.add(request).catch((e) => {
+      console.debug(p, "mcAssetRequest catch", e.code, e);
+      throw e;
+    });
+  }
+  static shouldRetry(e, request) {
+    if ("code" in e) {
+      if ("ECONNABORTED" === e.code) {
+        if ("minerenderRetry" in request) {
+          if (request["minerenderRetry"] > 0) {
+            request["minerenderRetry"]--;
+            return true;
           }
-          await this.waitForRetry(delay, signal);
+        } else {
+          request["minerenderRetry"] = 3;
+          return true;
         }
       }
-    } finally {
-      if (signal?.aborted) {
-        this.queue.remove(request);
-      }
-      this.pendingRequests--;
-    }
-  }
-  retryDelay(error, request, retries) {
-    if (this.stopped.signal.aborted || retries >= 3 || (request.method ?? "get").toLowerCase() !== "get" || request.signal?.aborted) {
-      return void 0;
-    }
-    if (error instanceof RequestError) {
-      const status = error.response?.status;
-      if (status !== void 0 && status !== 408 && status !== 429 && !(status >= 500 && status < 600)) return void 0;
-    } else if (!(error instanceof DOMException && error.name === "TimeoutError")) {
-      return void 0;
-    }
-    let delay = 100 * 2 ** retries;
-    const retryAfter = error instanceof RequestError ? error.response?.headers.get("Retry-After") : void 0;
-    if (retryAfter !== void 0 && retryAfter !== null) {
-      const seconds = Number(retryAfter);
-      if (!retryAfter.trim() || !Number.isFinite(seconds) || seconds < 0) {
-        return void 0;
-      }
-      delay = Math.max(delay, seconds * 1e3);
-    }
-    return delay;
-  }
-  async waitForRetry(delay, signal) {
-    let timer;
-    const waiting = new Promise((resolve) => {
-      timer = setTimeout(resolve, delay);
-    });
-    try {
-      await abortable(waiting, AbortSignal.any([this.stopped.signal, ...signal ? [signal] : []]));
-    } finally {
-      clearTimeout(timer);
     }
-  }
-  get pendingSize() {
-    return this.pendingRequests;
-  }
-  end() {
-    this.queue.end();
-    this.stopped.abort(new import_jobqu.JobCancelledError("ended"));
-  }
-};
-var Requests = class {
-  static {
-    this.genericQueue = new RequestQueue();
-  }
-  static {
-    this.mcAssetRequestQueue = new RequestQueue();
-  }
-  static genericRequest(request) {
-    return this.genericQueue.request(request);
-  }
-  static mcAssetRequest(request) {
-    return this.mcAssetRequestQueue.request(request);
+    return false;
   }
   static setMcAssetRoot(root) {
-    this.mcAssetRequestQueue.baseURL = root;
+    this.mcAssetInstance.defaults.baseURL = root;
   }
-  /** Counts unsettled calls, including retry delays and requests still running after shutdown. */
   static get queueSizes() {
     return {
-      generic: this.genericQueue.pendingSize,
-      mcAsset: this.mcAssetRequestQueue.pendingSize
+      generic: this.genericQueue.size,
+      mcAsset: this.mcAssetRequestQueue.size
     };
   }
   /**
-   * Permanently stops both queues and rejects waiting, retrying, and future requests.
-   * Requests already running can finish. Idle queues hold no timer, so Node can exit without
-   * this cleanup. See {@link shutdown}.
+   * Stops both queue timers. jobqu reschedules itself indefinitely, so a Node process will not
+   * exit until this is called - see {@link shutdown}.
    */
   static end() {
     this.genericQueue.end();
     this.mcAssetRequestQueue.end();
   }
 };
+_Requests.axiosInstance = import_axios.default.create({
+  timeout: 5e3
+});
+_Requests.mcAssetInstance = import_axios.default.create({
+  timeout: 5e3
+});
+_Requests.genericQueue = new import_jobqu.JobQueue((request) => _Requests.axiosInstance.request(request), import_time2.Time.millis(10), 1);
+_Requests.mcAssetRequestQueue = new import_jobqu.JobQueue((request) => _Requests.mcAssetInstance.request(request), import_time2.Time.millis(10), 1);
+var Requests = _Requests;
 
 // src/WrappedImage.ts
 var WrappedImage = class {
@@ -860,10 +845,10 @@ var WrappedImage = class {
     return this.animated ? this.width : this.height;
   }
   get frameCount() {
-    return this.height / this.frameHeight;
+    return this.height / this.width;
   }
   getFrameY(frame) {
-    return this.frameHeight * Math.max(0, Math.min(this.frameCount - 1, frame));
+    return this.height / this.frameCount * Math.max(0, Math.min(this.frameCount, frame));
   }
   getSectionData(sx, sy, sw, sh) {
     return this.dta.data.getImageData(sx, sy, sw, sh);
@@ -873,7 +858,7 @@ var WrappedImage = class {
   }
   getFrameSectionData(frame) {
     const y = this.getFrameY(frame);
-    return this.getSectionData(0, y, this.frameWidth, this.frameHeight);
+    return this.getSectionData(0, y, this.width, this.width + y);
   }
 };
 
@@ -887,41 +872,29 @@ var ImageLoader = class _ImageLoader {
   static async loadAsync(src) {
     return new Promise((resolve, reject) => {
       const image = this._createImage();
-      image.onload = () => resolve(image);
-      image.onerror = (err) => reject(err instanceof Error ? err : new Error("Failed to decode image"));
       image.src = src;
+      image.onload = () => resolve(image);
+      image.onerror = (err) => reject(err);
     });
   }
   static loadElement(src, onload, onerr) {
     const image = this._createImage();
+    image.src = src;
     if (onload)
       image.onload = onload;
     if (onerr)
       image.onerror = onerr;
-    image.src = src;
     return image;
   }
   static async loadData(src) {
     console.debug(p2, "loadData", src);
-    const image = await this.loadCanvasData(src);
-    return image.data.getImageData(0, 0, image.width, image.height);
+    return await this.infoToData(await this.getInfo(src));
   }
   static async loadCanvasData(src) {
-    const keyStr = serializeImageKey({ src });
-    const info = this.getInfo(src);
-    const cached = Caching.rawImageCache.getIfPresent(keyStr);
-    try {
-      return await this.infoToCanvasData(await info);
-    } catch (err) {
-      if (cached && Caching.rawImageCache.getIfPresent(keyStr) === cached) {
-        Caching.rawImageCache.invalidate(keyStr);
-      }
-      throw err;
-    }
+    return await this.infoToCanvasData(await this.getInfo(src));
   }
   static async infoToCanvasData(info) {
-    const type = info.type === "jpg" ? "jpeg" : info.type ?? "png";
-    const image = await _ImageLoader.loadAsync(`data:image/${type};base64,${info.data.toString("base64")}`);
+    const image = await _ImageLoader.loadAsync(info.src);
     const canvas = createCanvas2(info.width, info.height);
     const context = canvas.getContext("2d");
     context.drawImage(image, 0, 0);
@@ -932,8 +905,11 @@ var ImageLoader = class _ImageLoader {
     };
   }
   static async infoToData(info) {
-    const image = await this.infoToCanvasData(info);
-    return image.data.getImageData(0, 0, image.width, image.height);
+    const image = await _ImageLoader.loadAsync(info.src);
+    const canvas = createCanvas2(info.width, info.height);
+    const context = canvas.getContext("2d");
+    context.drawImage(image, 0, 0);
+    return context.getImageData(0, 0, canvas.width, canvas.height);
   }
   static async getData(src) {
     const keyStr = serializeImageKey({ src });
@@ -948,25 +924,38 @@ var ImageLoader = class _ImageLoader {
     });
   }
   static async processResponse(response) {
-    const src = response.url;
+    const src = response.config.url;
     const data = import_buffer.Buffer.from(response.data);
     const { width, height, type } = Env.provider.imageSize(data);
-    if (!width || !height) {
-      throw new Error("Invalid or unsupported image dimensions");
-    }
     return {
       src,
-      width,
-      height,
+      width: width || 0,
+      height: height || 0,
       type,
       data
     };
   }
   static async loadInfo(src) {
+    if (src.startsWith("data:image/png;base64")) {
+      return this.processResponse({
+        config: {
+          url: src
+        },
+        data: import_buffer.Buffer.from(src.substr("data:image/png;base64,".length), "base64")
+      });
+    }
     return Requests.genericRequest({
       url: src,
       responseType: "arraybuffer"
-    }).then(this.processResponse);
+    }).then(this.processResponse).catch((err) => {
+      return {
+        src,
+        width: 0,
+        height: 0,
+        type: void 0,
+        data: import_buffer.Buffer.from([0])
+      };
+    });
   }
   static async getInfo(src) {
     const keyStr = serializeImageKey({ src });
@@ -988,39 +977,25 @@ var ImageLoader = class _ImageLoader {
 
 // src/texture/TextureLoader.ts
 var TextureLoader = class {
-  static {
-    this.failedTextures = /* @__PURE__ */ new WeakSet();
-  }
-  /** Reports whether image loading failed, so cached textures can be retried. */
-  static hasFailed(texture) {
-    return this.failedTextures.has(texture);
-  }
   static createTexture() {
-    return new import_three3.Texture();
+    return new import_three4.Texture();
   }
-  static loadInBackground(src, format = import_three3.RGBAFormat, rotation = 0) {
+  static loadInBackground(src, format = import_three4.RGBAFormat, rotation = 0) {
     const texture = this.createTexture();
-    texture.colorSpace = THREE.SRGBColorSpace;
-    const image = ImageLoader.loadElement(src, () => {
+    const image = ImageLoader.loadElement(src);
+    image.onload = function() {
       texture.needsUpdate = true;
-    }, (error) => {
-      this.failedTextures.add(texture);
-      console.warn("Failed to load texture", src, error);
-    });
+    };
     texture.image = image;
     texture.format = format;
     texture.rotation = rotation;
     return Textures.initTextureProps(texture);
   }
-  static load(src, format = import_three3.RGBAFormat, rotation = 0) {
-    const texture = new import_three3.Texture();
-    texture.colorSpace = THREE.SRGBColorSpace;
+  static load(src, format = import_three4.RGBAFormat, rotation = 0) {
+    const texture = new import_three4.Texture();
     ImageLoader.getData(src).then((image) => {
-      texture.image = image;
       texture.needsUpdate = true;
-    }).catch((error) => {
-      this.failedTextures.add(texture);
-      console.warn("Failed to load texture", src, error);
+      texture.image = image;
     });
     texture.format = format;
     texture.rotation = rotation;
@@ -1029,11 +1004,11 @@ var TextureLoader = class {
 };
 
 // src/texture/Textures.ts
-var THREE2 = __toESM(require("three"));
+var THREE = __toESM(require("three"));
 var Textures = class _Textures {
   static initTextureProps(texture) {
-    texture.magFilter = THREE2.NearestFilter;
-    texture.minFilter = THREE2.NearestFilter;
+    texture.magFilter = THREE.NearestFilter;
+    texture.minFilter = THREE.NearestFilter;
     texture.anisotropy = 0;
     return texture;
   }
@@ -1041,19 +1016,13 @@ var Textures = class _Textures {
     return TextureLoader.load(key.src, key.format, key.rotation);
   }
   static createAsset(key) {
-    return new import_three4.Texture();
+    return new import_three5.Texture();
   }
   static createCanvasTexture(canvas) {
-    const texture = new import_three4.CanvasTexture(canvas);
-    texture.colorSpace = THREE2.SRGBColorSpace;
-    return this.initTextureProps(texture);
+    return this.initTextureProps(new import_three5.CanvasTexture(canvas));
   }
   static getImage(key) {
     const keyStr = serializeTextureKey(key);
-    const cached = Caching.textureCache.peek(keyStr);
-    if (cached && TextureLoader.hasFailed(cached)) {
-      Caching.textureCache.invalidate(keyStr);
-    }
     return Caching.textureCache.get(keyStr, (k) => {
       return _Textures.createImage(key);
     });
@@ -1061,10 +1030,7 @@ var Textures = class _Textures {
 };
 
 // src/Materials.ts
-var Materials = class _Materials {
-  static {
-    this.MISSING_TEXTURE_SRC = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABAAQMAAACQp+OdAAAABlBMVEX/AP8AAACfphTyAAAAFUlEQVQoz2MIhQKGVVAwKjIqQrwIAHRz/wFI17TEAAAAAElFTkSuQmCC";
-  }
+var _Materials = class _Materials {
   // resolved lazily: as a static field this decoded an image the moment the library was
   // imported, which needs both a DOM and an EnvProvider to already be in place
   static get MISSING_TEXTURE() {
@@ -1072,26 +1038,26 @@ var Materials = class _Materials {
   }
   static createImage(key) {
     const transparent = key.transparent || false;
-    return new import_three5.MeshBasicMaterial({
+    return new import_three6.MeshBasicMaterial({
       map: Textures.getImage(key.texture),
       transparent,
-      side: transparent ? import_three5.DoubleSide : import_three5.FrontSide,
+      side: transparent ? import_three6.DoubleSide : import_three6.FrontSide,
       alphaTest: 0.5
     });
   }
   static createBasicCanvasMaterial(canvas, transparent = false, shade = false) {
     if (shade) {
-      return new import_three5.MeshStandardMaterial({
+      return new import_three6.MeshStandardMaterial({
         map: Textures.createCanvasTexture(canvas),
         transparent,
-        side: transparent ? import_three5.DoubleSide : import_three5.FrontSide,
+        side: transparent ? import_three6.DoubleSide : import_three6.FrontSide,
         alphaTest: 0.5
       });
     }
-    return new import_three5.MeshBasicMaterial({
+    return new import_three6.MeshBasicMaterial({
       map: Textures.createCanvasTexture(canvas),
       transparent,
-      side: transparent ? import_three5.DoubleSide : import_three5.FrontSide,
+      side: transparent ? import_three6.DoubleSide : import_three6.FrontSide,
       alphaTest: 0.5
     });
   }
@@ -1112,11 +1078,7 @@ var Materials = class _Materials {
 
                 if (SHADE) {
 
-                    #ifdef USE_INSTANCING
-                        vec3 N = vec3( modelMatrix * instanceMatrix * vec4(normal, 0.0) );
-                    #else
-                        vec3 N = vec3( modelMatrix * vec4(normal, 0.0) );
-                    #endif
+                    vec3 N = vec3( modelMatrix * instanceMatrix * vec4(normal, 0.0) );
 
                     float yLight = (1.0+N.y) * 0.5;
                     light = yLight * (1.0-AMBIENT) + N.x*N.x * XFAC + N.z*N.z * ZFAC + AMBIENT;
@@ -1174,19 +1136,16 @@ var Materials = class _Materials {
                     gl_FragColor = vec4(lift + color.rgb * light2, 1.0);
 
                 }
-
-                #include <tonemapping_fragment>
-                #include <colorspace_fragment>
             }
         `;
     try {
-      return new import_three5.ShaderMaterial({
+      return new import_three6.ShaderMaterial({
         uniforms: {
           SHADE: { value: true },
           BRIGHTNESS: { value: 1 },
           EMISSIVE: { value: false },
           base: {
-            value: new import_three5.Color(12698049)
+            value: new import_three6.Color(12698049)
             /*TODO*/
           },
           map: { value: Textures.createCanvasTexture(canvas) }
@@ -1195,7 +1154,7 @@ var Materials = class _Materials {
         fragmentShader: fragShader,
         vertexColors: true,
         transparent,
-        side: transparent ? import_three5.DoubleSide : import_three5.FrontSide,
+        side: transparent ? import_three6.DoubleSide : import_three6.FrontSide,
         alphaTest: 0.5
       });
     } catch (e) {
@@ -1205,10 +1164,6 @@ var Materials = class _Materials {
   }
   static getImage(key) {
     const keyStr = serializeMaterialKey(key);
-    const map = Caching.materialCache.peek(keyStr)?.map;
-    if (map && TextureLoader.hasFailed(map)) {
-      Caching.materialCache.invalidate(keyStr);
-    }
     return Caching.materialCache.get(keyStr, (k) => {
       return _Materials.createImage(key);
     });
@@ -1229,12 +1184,14 @@ var Materials = class _Materials {
     }
   }
 };
+_Materials.MISSING_TEXTURE_SRC = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABAAQMAAACQp+OdAAAABlBMVEX/AP8AAACfphTyAAAAFUlEQVQoz2MIhQKGVVAwKjIqQrwIAHRz/wFI17TEAAAAAElFTkSuQmCC";
+var Materials = _Materials;
 
 // src/Meshes.ts
-var import_three6 = require("three");
+var import_three7 = require("three");
 var Meshes = class _Meshes {
   static createBox(key) {
-    return new import_three6.Mesh(Geometries.getBox(key.geometry), Materials.getImage(key.material));
+    return new import_three7.Mesh(Geometries.getBox(key.geometry), Materials.getImage(key.material));
   }
   static getBox(key) {
     const keyStr = serializeMeshKey(key);
@@ -1281,10 +1238,9 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
     this.rootType = rootType;
     this.extension = extension;
     this.root = root;
-    this.isAssetKey = true;
   }
   static parse(assetType, str, origin) {
-    let namespace = origin?.namespace || DEFAULT_NAMESPACE;
+    let namespace = (origin == null ? void 0 : origin.namespace) || DEFAULT_NAMESPACE;
     if (str.includes(":")) {
       let split2 = str.split(":");
       namespace = split2[0];
@@ -1297,15 +1253,12 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
       split.shift();
     }
     let path = split.join("/");
-    const extension = assetType === "textures" ? ".png" : origin?.extension ?? ".json";
-    if (extension && path.endsWith(extension)) {
-      path = path.slice(0, -extension.length);
-    }
-    return new _AssetKey(namespace, path, assetType, type, "assets", extension, origin?.root);
+    let extension = assetType === "textures" ? ".png" : (origin == null ? void 0 : origin.assetType) || ".json";
+    return new _AssetKey(namespace, path, assetType, type, "assets", extension, origin == null ? void 0 : origin.root);
   }
   toString() {
     let a = [
-      this.root ?? AssetLoader.ROOT,
+      typeof this.root !== "undefined" || AssetLoader.ROOT !== DEFAULT_ROOT ? this.root ?? AssetLoader.ROOT : "__root__",
       this.rootType ?? "__rootType__",
       this.assetType ?? "__assetType__",
       this.type ?? "__type__",
@@ -1315,12 +1268,12 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
     return a.join("/");
   }
   getFullPath() {
-    let p12 = [];
+    let p13 = [];
     if (this.type) {
-      p12.push(this.type);
+      p13.push(this.type);
     }
-    p12.push(this.path);
-    return p12.join("/");
+    p13.push(this.path);
+    return p13.join("/");
   }
   toNamespacedString() {
     return this.namespace + ":" + this.getFullPath();
@@ -1330,10 +1283,10 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
   }
 };
 function isBasicAssetKey(obj) {
-  return obj !== null && typeof obj === "object" && typeof obj.namespace === "string" && typeof obj.path === "string";
+  return "namespace" in obj && "path" in obj;
 }
 function isAssetKey(obj) {
-  return isBasicAssetKey(obj) && obj.isAssetKey === true;
+  return isBasicAssetKey(obj) && "parse" in obj;
 }
 
 // src/model/ModelMerger.ts
@@ -1342,10 +1295,10 @@ var ModelMerger = class {
     const models = await this.collectAllParents(model);
     let merged = {};
     for (let parentModel of models) {
-      merged = import_ts_deepmerge.default.withOptions({ mergeArrays: false }, merged, parentModel);
+      merged = (0, import_ts_deepmerge.default)(merged, parentModel);
     }
-    merged = import_ts_deepmerge.default.withOptions({ mergeArrays: false }, merged, model);
-    merged.hierarchy = models.map((m) => m.parent).filter((p12) => `${p12}`);
+    merged = (0, import_ts_deepmerge.default)(merged, model);
+    merged.hierarchy = models.map((m) => m.parent).filter((p13) => `${p13}`);
     merged.hierarchy.push(`${merged.parent}`);
     return merged;
   }
@@ -1355,7 +1308,6 @@ var ModelMerger = class {
     }
     const models = [];
     const parentKey = AssetKey.parse("models", model.parent);
-    parentKey.root = model.key?.root;
     const parentModel = await Models.getRaw(parentKey);
     if (parentModel) {
       models.unshift(parentModel);
@@ -1365,6 +1317,9 @@ var ModelMerger = class {
   }
 };
 
+// src/assets/Models.ts
+var import_typescript_memoize = require("typescript-memoize");
+
 // src/assets/source/parser/AssetParsers.ts
 var AssetParser = /* @__PURE__ */ ((AssetParser2) => {
   AssetParser2["MODEL"] = "model";
@@ -1378,65 +1333,30 @@ var AssetParser = /* @__PURE__ */ ((AssetParser2) => {
 })(AssetParser || {});
 
 // src/assets/Models.ts
-var Models = class _Models {
+var _Models = class _Models {
   // opened lazily: touching the store at import time would hit IndexedDB/disk just for loading
   // the library, and would require an EnvProvider before any entry has had a chance to register
   static get PERSISTENT_CACHE() {
     return this._persistentCache ??= PersistentCache.open("minerender-models");
   }
   static async getItemList() {
-    const key = new AssetKey(DEFAULT_NAMESPACE, "_list", "items");
-    const legacyKey = new AssetKey(DEFAULT_NAMESPACE, "_list", "models", "item");
-    return Caching.listAssetCache.get(key.serialize(), async () => {
-      return (await AssetLoader.getFirst([key, legacyKey], "list" /* LIST */))?.asset;
-    }).then((r) => r?.files ?? []);
+    return AssetLoader.get(new AssetKey(
+      DEFAULT_NAMESPACE,
+      "_list",
+      "models",
+      "item",
+      "assets",
+      ".json",
+      DEFAULT_ROOT
+    ), "list" /* LIST */).then((r) => (r == null ? void 0 : r.files) ?? []);
   }
   static async loadAndMerge(key) {
-    const model = key.type === "item" ? await this.getItemModel(key) : await this.getRaw(key);
+    const model = await this.getRaw(key);
     if (!model) {
       return void 0;
     }
     return ModelMerger.mergeWithParents(model);
   }
-  static async getItemModel(key) {
-    const itemKey = new AssetKey(key.namespace, key.path, "items", void 0, key.rootType, ".json", key.root);
-    const model = await this.PERSISTENT_CACHE.getOrLoad(itemKey.serialize(), async () => {
-      const result = await AssetLoader.getFirst([itemKey, key], "json" /* JSON */);
-      if (!result) return void 0;
-      if (result.key.assetType !== "items") return { ...result.asset, key };
-      const reference = this.defaultItemModel(result.asset.model, key);
-      const modelKey = AssetKey.parse("models", reference);
-      modelKey.root = key.root;
-      const model2 = await this.getRaw(modelKey);
-      if (!model2) throw new Error(`Item ${key.toNamespacedString()} references missing model ${reference}`);
-      return model2;
-    });
-    return model ? { ...model, key: Object.assign(new AssetKey("", ""), model.key) } : void 0;
-  }
-  // Item previews use the GUI context, false conditions, and zero numeric properties.
-  static defaultItemModel(node, key) {
-    if (!node || typeof node.type !== "string") {
-      throw new Error(`Unsupported item model definition for ${key.toNamespacedString()}`);
-    }
-    switch (node.type.replace(/^minecraft:/, "")) {
-      case "model":
-        if (typeof node.model === "string" && node.model) return node.model;
-        break;
-      case "condition":
-        return this.defaultItemModel(node.on_false, key);
-      case "select": {
-        const selected = node.property?.replace(/^minecraft:/, "") === "display_context" ? node.cases?.find((entry) => Array.isArray(entry.when) ? entry.when.includes("gui") : entry.when === "gui")?.model : void 0;
-        return this.defaultItemModel(selected ?? node.fallback, key);
-      }
-      case "range_dispatch": {
-        const selected = node.entries?.reduce((match, entry) => {
-          return entry.threshold <= 0 && (!match || entry.threshold >= match.threshold) ? entry : match;
-        }, void 0);
-        return this.defaultItemModel(selected?.model ?? node.fallback, key);
-      }
-    }
-    throw new Error(`Unsupported item model ${node?.type ?? "definition"} for ${key.toNamespacedString()}`);
-  }
   static async getRaw(key) {
     if (!key.assetType) {
       key.assetType = "models";
@@ -1475,15 +1395,19 @@ var Models = class _Models {
     return this.PERSISTENT_CACHE.clear();
   }
 };
+__decorateClass([
+  (0, import_typescript_memoize.Memoize)()
+], _Models, "getItemList", 1);
+var Models = _Models;
 
 // src/assets/BlockStates.ts
+var import_typescript_memoize2 = require("typescript-memoize");
 var BlockStates = class {
   static get PERSISTENT_CACHE() {
     return this._persistentCache ??= PersistentCache.open("minerender-blockstates");
   }
-  // BlockState names are hardcoded
   static async getList() {
-    const key = new AssetKey(
+    return AssetLoader.get(new AssetKey(
       DEFAULT_NAMESPACE,
       "_list",
       "blockstates",
@@ -1491,16 +1415,11 @@ var BlockStates = class {
       "assets",
       ".json",
       DEFAULT_ROOT
-    );
-    return Caching.listAssetCache.get(key.serialize(), () => {
-      return AssetLoader.get(key, "list" /* LIST */);
-    }).then((r) => r?.files ?? []);
+    ), "list" /* LIST */).then((r) => (r == null ? void 0 : r.files) ?? []);
   }
   static async getDefaultStates() {
     const key = AssetKey.parse("blockstates", "minerender:defaultBlockStates");
-    return Caching.defaultBlockStatesCache.get(key.serialize(), () => {
-      return AssetLoader.get(key, "json" /* JSON */);
-    });
+    return AssetLoader.get(key, "json" /* JSON */);
   }
   static async getDefaultState(key) {
     const defaultStates = await this.getDefaultStates();
@@ -1539,11 +1458,17 @@ var BlockStates = class {
     await this.PERSISTENT_CACHE.clear();
   }
 };
+__decorateClass([
+  (0, import_typescript_memoize2.Memoize)()
+], BlockStates, "getList", 1);
+__decorateClass([
+  (0, import_typescript_memoize2.Memoize)()
+], BlockStates, "getDefaultStates", 1);
 var DefaultBlockStates = class {
 };
 
 // src/assets/Assets.ts
-var DEFAULT_ROOT = "https://assets.mcasset.cloud/1.21.11";
+var DEFAULT_ROOT = "https://assets.mcasset.cloud/1.17.1";
 var DEFAULT_NAMESPACE = "minecraft";
 var Assets = class {
   /**
@@ -1565,150 +1490,13 @@ var AssetSource = class {
   constructor() {
   }
 };
-var AssetLoadError = class extends Error {
-  constructor(source, key, path, cause) {
-    super(`Failed to load ${key.toNamespacedString()} from ${path}${cause instanceof Error ? `: ${cause.message}` : ""}`);
-    this.source = source;
-    this.key = key;
-    this.path = path;
-    this.cause = cause;
-    this.name = "AssetLoadError";
-  }
-};
 
-// src/util/BatchedExecutor.ts
-var BatchedExecutor = class {
-  constructor(interval = 1, batch = 30) {
-    this.interval = interval;
-    this.batch = batch;
-    this.queue = [];
-    this.task = setInterval(() => this.run());
-  }
-  submit(task) {
-    this.queue.push(task);
-  }
-  run() {
-    for (let i = 0; i < this.batch; i++) {
-      this.runNext();
-    }
-  }
-  runNext() {
-    let next = this.queue.shift();
-    if (next) next();
-  }
-};
-
-// src/util/model.ts
-var import_three7 = require("three");
-function applyElementRotation(rotation, geometry) {
-  const origin = new import_three7.Vector3(rotation.origin[0], rotation.origin[1], rotation.origin[2]);
-  geometry.translate(-origin.x, -origin.y, -origin.z);
-  switch (rotation.axis) {
-    case "x" /* X */:
-      geometry.rotateX(toRadians(rotation.angle));
-      break;
-    case "y" /* Y */:
-      geometry.rotateY(toRadians(rotation.angle));
-      break;
-    case "z" /* Z */:
-      geometry.rotateZ(toRadians(rotation.angle));
-      break;
-  }
-  if (rotation.rescale) {
-    if (Math.abs(rotation.angle) === 22.5) {
-      const s = 1 / Math.cos(0.39269909262657166);
-      geometry.scale(s, 1, s);
-    } else {
-      const s = 1 / Math.cos(0.7853981852531433);
-      geometry.scale(s, 1, s);
-    }
-  }
-  geometry.translate(origin.x, origin.y, origin.z);
-}
-function applyModelPartRotation(modelPart, geometry) {
-  const origin = new import_three7.Vector3(modelPart.pivotX, modelPart.pivotY, modelPart.pivotZ);
-  geometry.translate(-origin.x, -origin.y, -origin.z);
-  geometry.rotateX(toRadians(modelPart.pitch));
-  geometry.rotateY(toRadians(modelPart.yaw));
-  geometry.rotateZ(toRadians(modelPart.roll));
-  geometry.translate(origin.x, origin.y, origin.z);
-}
-function applyGenericRotation(axis, rotation, obj) {
-  switch (axis) {
-    case "x" /* X */:
-      obj.rotateOnAxis(new import_three7.Vector3(1, 0, 0), toRadians(rotation));
-      break;
-    case "y" /* Y */:
-      obj.rotateOnAxis(new import_three7.Vector3(0, 1, 0), toRadians(rotation));
-      break;
-    case "z" /* Z */:
-      obj.rotateOnAxis(new import_three7.Vector3(0, 0, 1), toRadians(rotation));
-      break;
-  }
-}
-function addBox3WireframeToObject(box, obj, color = 16777215, w = 2) {
-  let size = new import_three7.Vector3();
-  box.getSize(size);
-  let boxGeo = new import_three7.BoxGeometry(size.x, size.y, size.z, 1, 1, 1);
-  let wireGeo = new import_three7.EdgesGeometry(boxGeo);
-  let wireMat = new import_three7.LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new import_three7.LineSegments(wireGeo, wireMat);
-  obj.add(wireframe);
-  let axes = new import_three7.AxesHelper(1);
-  obj.add(axes);
-}
-function addWireframeToObject(obj, color = 16777215, w = 2) {
-  let boxGeo = new import_three7.BoxGeometry(16, 16, 16, 1, 1, 1);
-  let wireGeo = new import_three7.EdgesGeometry(boxGeo);
-  let wireMat = new import_three7.LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new import_three7.LineSegments(wireGeo, wireMat);
-  obj.add(wireframe);
-  let axes = new import_three7.AxesHelper(1);
-  obj.add(axes);
-}
-function addWireframeToMesh(geo, mesh, color = 16777215, w = 2) {
-  let wireGeo = new import_three7.EdgesGeometry(geo);
-  let wireMat = new import_three7.LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new import_three7.LineSegments(wireGeo, wireMat);
-  mesh.add(wireframe);
-  let axes = new import_three7.AxesHelper(1);
-  mesh.add(axes);
-}
-
-// src/util/performance.ts
-function captureException(e, ...extra) {
-  console.error(e, extra);
-}
-function timingStart(marker) {
-  console.time(marker);
-}
-function timingEnd(marker) {
-  console.timeEnd(marker);
-}
-
-// src/util/three.ts
-function isObject3D(obj) {
-  return obj.isObject3D;
-}
-function isMesh(obj) {
-  return obj.isMesh;
-}
-function isInstancedMesh(obj) {
-  return obj.isInstancedMesh;
-}
-function isPerspectiveCamera(obj) {
-  return obj.isPerspectiveCamera;
-}
-function isOrthographicCamera(obj) {
-  return obj.isOrthographicCamera;
-}
-
-// src/nbt/NBTHelper.ts
-var NBTHelper = class {
-  static async fromBuffer(buffer) {
-    const prismarineNbt = await import("prismarine-nbt");
-    const { parsed, type, metadata } = await prismarineNbt.parse(buffer);
-    return parsed;
+// src/nbt/NBTHelper.ts
+var NBTHelper = class {
+  static async fromBuffer(buffer) {
+    const prismarineNbt = await import("prismarine-nbt");
+    const { parsed, type, metadata } = await prismarineNbt.parse(buffer);
+    return parsed;
   }
 };
 
@@ -1718,83 +1506,7 @@ var p3 = prefix("HostedAssetSource");
 var DEFAULT_OPTIONS = {
   retryDefaults: true
 };
-var HostedAssetSource = class _HostedAssetSource extends AssetSource {
-  static {
-    this.MODEL = {
-      config(request) {
-      },
-      parse(response) {
-        return response.data;
-      }
-    };
-  }
-  static {
-    this.BLOCKSTATE = {
-      config(request) {
-      },
-      parse(response) {
-        return response.data;
-      }
-    };
-  }
-  static {
-    this.META = {
-      config(request) {
-      },
-      parse(response) {
-        return response.data;
-      }
-    };
-  }
-  static {
-    this.NBT = {
-      config(request) {
-        request.responseType = "arraybuffer";
-      },
-      parse(response) {
-        return NBTHelper.fromBuffer(Buffer.from(response.data));
-      }
-    };
-  }
-  static {
-    this.IMAGE = {
-      config(request) {
-        request.responseType = "arraybuffer";
-      },
-      async parse(response) {
-        return await ImageLoader.processResponse(response);
-      }
-    };
-  }
-  static {
-    this.LIST = {
-      config(request) {
-      },
-      parse(response) {
-        return response.data;
-      }
-    };
-  }
-  static {
-    this.JSON = {
-      config(request) {
-      },
-      parse(response) {
-        return response.data;
-      }
-    };
-  }
-  static {
-    this.PARSER_MAP = /* @__PURE__ */ new Map([
-      ["model" /* MODEL */, _HostedAssetSource.MODEL],
-      ["blockstate" /* BLOCKSTATE */, _HostedAssetSource.BLOCKSTATE],
-      ["meta" /* META */, _HostedAssetSource.META],
-      ["nbt" /* NBT */, _HostedAssetSource.NBT],
-      ["image" /* IMAGE */, _HostedAssetSource.IMAGE],
-      ["list" /* LIST */, _HostedAssetSource.LIST],
-      ["json" /* JSON */, _HostedAssetSource.JSON]
-    ]);
-  }
+var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
   async loadOrRetryWithDefaults(key, parser) {
     const direct = await this.load(key, parser);
     if (typeof direct !== "undefined") {
@@ -1829,25 +1541,31 @@ var HostedAssetSource = class _HostedAssetSource extends AssetSource {
     console.info(p3, "Loading", key);
     const url = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
     console.debug(p3, url);
-    const request = { url };
-    try {
-      parser.config(request);
-      let response;
-      try {
-        response = await Requests.mcAssetRequest(request);
-      } catch (cause) {
-        if (cause instanceof RequestError && cause.response?.status === 404) {
-          return void 0;
+    let req = {
+      url
+    };
+    parser.config(req);
+    return await Requests.mcAssetRequest(req).then((response) => {
+      if (response && response.data) {
+        try {
+          return parser.parse(response);
+        } catch (e) {
+          console.warn("Parser failed to process response", response, e);
+          throw e;
         }
-        throw cause;
       }
-      if (response.data === void 0) {
-        throw new Error("Asset response has no data");
+      return void 0;
+    }).catch((err) => {
+      if (err.response) {
+        let response = err.response;
+        if (response.status === 404) {
+          console.debug(p3, key, "not found");
+          return void 0;
+        }
       }
-      return await parser.parse(response);
-    } catch (cause) {
-      throw new AssetLoadError(this, key, request.url, cause);
-    }
+      console.debug(p3, "Failed to load", key, err == null ? void 0 : err.message);
+      return void 0;
+    });
   }
   assetBasePath(key) {
     return `${key.root ?? this.root ?? AssetLoader.ROOT}/${key.rootType !== void 0 ? key.rootType + "/" : ""}${key.namespace !== void 0 ? key.namespace + "/" : ""}${key.assetType !== void 0 ? key.assetType + "/" : ""}`;
@@ -1871,6 +1589,67 @@ var HostedAssetSource = class _HostedAssetSource extends AssetSource {
     return this.load(key, responseParser);
   }
 };
+_HostedAssetSource.MODEL = {
+  config(request) {
+  },
+  parse(response) {
+    return response.data;
+  }
+};
+_HostedAssetSource.BLOCKSTATE = {
+  config(request) {
+  },
+  parse(response) {
+    return response.data;
+  }
+};
+_HostedAssetSource.META = {
+  config(request) {
+  },
+  parse(response) {
+    return response.data;
+  }
+};
+_HostedAssetSource.NBT = {
+  config(request) {
+    request.responseType = "arraybuffer";
+  },
+  parse(response) {
+    return NBTHelper.fromBuffer(Buffer.from(response.data));
+  }
+};
+_HostedAssetSource.IMAGE = {
+  config(request) {
+    request.responseType = "arraybuffer";
+  },
+  async parse(response) {
+    return await ImageLoader.processResponse(response);
+  }
+};
+_HostedAssetSource.LIST = {
+  config(request) {
+  },
+  parse(response) {
+    return response.data;
+  }
+};
+_HostedAssetSource.JSON = {
+  config(request) {
+  },
+  parse(response) {
+    return response.data;
+  }
+};
+_HostedAssetSource.PARSER_MAP = /* @__PURE__ */ new Map([
+  ["model" /* MODEL */, _HostedAssetSource.MODEL],
+  ["blockstate" /* BLOCKSTATE */, _HostedAssetSource.BLOCKSTATE],
+  ["meta" /* META */, _HostedAssetSource.META],
+  ["nbt" /* NBT */, _HostedAssetSource.NBT],
+  ["image" /* IMAGE */, _HostedAssetSource.IMAGE],
+  ["list" /* LIST */, _HostedAssetSource.LIST],
+  ["json" /* JSON */, _HostedAssetSource.JSON]
+]);
+var HostedAssetSource = _HostedAssetSource;
 
 // src/assets/source/archive/BrowserArchiveProxy.ts
 var import_zip = require("@zip.js/zip.js");
@@ -1893,6 +1672,7 @@ var BrowserArchiveProxy = class {
 };
 
 // src/assets/source/archive/ArchiveAssetSource.ts
+var p4 = prefix("ArchiveAssetSource");
 var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
   constructor(archiveProxy) {
     super();
@@ -1911,31 +1691,74 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
   }
   async get(key, parser) {
     const responseParser = HostedAssetSource.PARSER_MAP.get(parser);
-    return this.load(key, responseParser);
-  }
-  async load(key, parser) {
+    console.log("ArchiveAssetSource.get", key, parser);
+    let entries = await this.getEntries();
     const path = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
-    let url;
-    try {
-      const entry = await this.getEntry(path);
-      if (!entry) {
-        return void 0;
+    console.log(path);
+    const entry = await this.getEntry(path);
+    console.log(entry);
+    if (!entry) {
+      return void 0;
+    }
+    let blob = await entry.getData();
+    const url = URL.createObjectURL(blob);
+    console.log(url);
+    let req = {
+      url
+    };
+    responseParser.config(req);
+    return Requests.genericRequest(req).then((response) => {
+      if (response && response.data) {
+        try {
+          return responseParser.parse(response);
+        } catch (e) {
+          console.warn("Parser failed to process response", response, e);
+          throw e;
+        }
+      }
+      return void 0;
+    }).catch((err) => {
+      if (err.response) {
+        let response = err.response;
+        if (response.status === 404) {
+          console.debug(p4, key, "not found");
+          return void 0;
+        }
       }
-      url = URL.createObjectURL(await entry.getData());
-      const request = { url };
-      parser.config(request);
-      const response = await Requests.genericRequest(request);
-      if (response.data === void 0) {
-        throw new Error("Asset response has no data");
+      console.debug(p4, "Failed to load", key, err == null ? void 0 : err.message);
+      return void 0;
+    });
+  }
+  //TODO: abstract this
+  async load(key, parser) {
+    console.info(p4, "Loading", key);
+    const url = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
+    console.debug(p4, url);
+    let req = {
+      url
+    };
+    parser.config(req);
+    return await Requests.genericRequest(req).then((response) => {
+      if (response && response.data) {
+        try {
+          return parser.parse(response);
+        } catch (e) {
+          console.warn("Parser failed to process response", response, e);
+          throw e;
+        }
       }
-      return await parser.parse(response);
-    } catch (cause) {
-      throw new AssetLoadError(this, key, path, cause);
-    } finally {
-      if (url !== void 0) {
-        URL.revokeObjectURL(url);
+      return void 0;
+    }).catch((err) => {
+      if (err.response) {
+        let response = err.response;
+        if (response.status === 404) {
+          console.debug(p4, key, "not found");
+          return void 0;
+        }
       }
-    }
+      console.debug(p4, "Failed to load", key, err == null ? void 0 : err.message);
+      return void 0;
+    });
   }
   assetBasePath(key) {
     return `${key.rootType !== void 0 ? key.rootType + "/" : ""}${key.namespace !== void 0 ? key.namespace + "/" : ""}${key.assetType !== void 0 ? key.assetType + "/" : ""}`;
@@ -1943,23 +1766,18 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
 };
 
 // src/assets/AssetLoader.ts
-var p4 = prefix("AssetLoader");
-var AssetLoader = class {
-  static {
-    this.ROOT = DEFAULT_ROOT;
-  }
-  static {
-    this._SOURCES = [];
-  }
+var import_ts_deepmerge3 = __toESM(require_dist());
+var p5 = prefix("AssetLoader");
+var _AssetLoader = class _AssetLoader {
   static addSource(key, source, override = true) {
     if (override) {
       const existing = this.removeSource(key);
       if (existing) {
-        console.log(p4, "Removed existing AssetSource", key);
+        console.log(p5, "Removed existing AssetSource", key);
       }
     }
     this._SOURCES.unshift({ key, source });
-    console.log(p4, "Added AssetSource", key);
+    console.log(p5, "Added AssetSource", key);
   }
   static removeSource(key) {
     const index = this._SOURCES.findIndex((s) => s.key === key);
@@ -1971,11 +1789,8 @@ var AssetLoader = class {
     }
     return void 0;
   }
-  static {
-    this.addSource("mcassets-fallback", new HostedAssetSource("https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master", { retryDefaults: false }));
-    this.addSource("mcassets", new HostedAssetSource(DEFAULT_ROOT, { retryDefaults: false }));
-  }
   static async getAll(key, parser) {
+    console.log(this._SOURCES);
     let promises = [];
     for (const source of this._SOURCES) {
       promises.push(source.source.get(key, parser));
@@ -1984,36 +1799,31 @@ var AssetLoader = class {
       return results.filter((r) => r != void 0);
     });
   }
-  /** Returns the first defined result in source-priority order, without merging assets. */
   static async get(key, parser) {
-    const keys = [key];
-    if (key.rootType === "data" && (key.assetType === "structure" || key.assetType === "structures")) {
-      keys.push(new AssetKey(
-        key.namespace,
-        key.path,
-        key.assetType === "structure" ? "structures" : "structure",
-        key.type,
-        key.rootType,
-        key.extension,
-        key.root
-      ));
-    }
-    return (await this.getFirst(keys, parser))?.asset;
-  }
-  /** Tries each path within a source before considering lower-priority sources. */
-  static async getFirst(keys, parser) {
-    const sources = [...this._SOURCES];
-    for (const source of sources) {
-      for (const key of keys) {
-        const result = await source.source.get(key, parser);
-        if (result !== void 0) {
-          return { key, asset: result };
+    console.log(this._SOURCES);
+    let promises = [];
+    for (const source of this._SOURCES) {
+      promises.push(source.source.get(key, parser));
+    }
+    return Promise.all(promises).then((results) => {
+      const fallback = results[results.length - 1];
+      for (const result of results) {
+        if (result) {
+          if (fallback) {
+            return (0, import_ts_deepmerge3.default)({}, fallback, result);
+          }
+          return result;
         }
       }
-    }
-    return void 0;
+      return void 0;
+    });
   }
 };
+_AssetLoader.ROOT = DEFAULT_ROOT;
+_AssetLoader._SOURCES = [];
+_AssetLoader.addSource("mcassets-fallback", new HostedAssetSource("https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master", { retryDefaults: false }));
+_AssetLoader.addSource("mcassets", new HostedAssetSource(DEFAULT_ROOT, { retryDefaults: false }));
+var AssetLoader = _AssetLoader;
 
 // src/assets/ModelTextures.ts
 var ModelTextures = class {
@@ -2021,21 +1831,11 @@ var ModelTextures = class {
     return this._persistentMetaCache ??= PersistentCache.open("minerender-texturemeta");
   }
   static async get(key) {
-    const keyStr = key.serialize();
-    const pending = this.preload(key);
-    const cached = Caching.textureAssetCache.getIfPresent(keyStr);
-    try {
-      const asset = await pending;
-      if (asset) {
-        return await ImageLoader.infoToCanvasData(asset);
-      }
-      return void 0;
-    } catch (err) {
-      if (cached && Caching.textureAssetCache.getIfPresent(keyStr) === cached) {
-        Caching.textureAssetCache.invalidate(keyStr);
-      }
-      throw err;
+    const asset = await this.preload(key);
+    if (asset) {
+      return ImageLoader.infoToCanvasData(asset);
     }
+    return void 0;
   }
   static async preload(key) {
     const keyStr = key.serialize();
@@ -2109,28 +1909,7 @@ var CanvasImage = class {
 };
 
 // src/Ticker.ts
-var Ticker = class _Ticker {
-  static {
-    this.TPS = 20;
-  }
-  static {
-    this.counter = 0;
-  }
-  static {
-    this._tickers = /* @__PURE__ */ new Map();
-  }
-  static {
-    this.oneSecondTps = 0;
-  }
-  static {
-    this.oneSecondTicks = 0;
-  }
-  static {
-    this.fiveSecondTps = 0;
-  }
-  static {
-    this.fiveSecondTicks = 0;
-  }
+var _Ticker = class _Ticker {
   static schedule(fn, ms) {
     const handle = setInterval(fn, ms);
     const unref = handle.unref;
@@ -2192,6 +1971,14 @@ var Ticker = class _Ticker {
     this._tickers.clear();
   }
 };
+_Ticker.TPS = 20;
+_Ticker.counter = 0;
+_Ticker._tickers = /* @__PURE__ */ new Map();
+_Ticker.oneSecondTps = 0;
+_Ticker.oneSecondTicks = 0;
+_Ticker.fiveSecondTps = 0;
+_Ticker.fiveSecondTicks = 0;
+var Ticker = _Ticker;
 
 // src/texture/TextureAtlas.ts
 var TextureAtlas = class {
@@ -2217,9 +2004,6 @@ var TextureAtlas = class {
 
 // src/model/ModelGenerator.ts
 var ModelGenerator = class {
-  static {
-    this.ITEM_LAYERS = ["layer0", "layer1", "layer2", "layer3", "layer4"];
-  }
   static generateItemModel(imageData, layer) {
     const mainElement = {
       from: [0, 0, 7.5],
@@ -2239,9 +2023,10 @@ var ModelGenerator = class {
     return [mainElement];
   }
 };
+ModelGenerator.ITEM_LAYERS = ["layer0", "layer1", "layer2", "layer3", "layer4"];
 
 // src/UVMapper.ts
-var p5 = prefix("UVMapper");
+var p6 = prefix("UVMapper");
 var DEFAULT_UV = [0, 0, 16, 16];
 var X = 0;
 var Y = 1;
@@ -2414,11 +2199,12 @@ var UVMapper = class {
     return [tl, tr, bl, br];
   }
   static async createAtlas(originalModel) {
+    var _a;
     const textureMap = {};
     const metaMap = {};
     const model = { ...originalModel };
     const isItemModel = !("elements" in model);
-    console.debug(p5, "Creating Atlas for", model.key);
+    console.debug(p6, "Creating Atlas for", model.key);
     if (model.textures) {
       const promises = [];
       const uniqueTextureNames = [];
@@ -2432,7 +2218,7 @@ var UVMapper = class {
           const assetKey = AssetKey.parse("textures", textureValue, model.key);
           promises.push(ModelTextures.get(assetKey).then((asset) => {
             if (!asset) {
-              console.warn(p5, "Missing texture", assetKey);
+              console.warn(p6, "Missing texture", assetKey);
               return;
             }
             textureMap[textureKey] = new WrappedImage(asset);
@@ -2444,7 +2230,7 @@ var UVMapper = class {
       }
       await Promise.all(promises);
       const textureCount = uniqueTextureNames.length;
-      console.debug(p5, "Creating Atlas for", textureCount, "textures");
+      console.debug(p6, "Creating Atlas for", textureCount, "textures");
       this.fillMissingTextureKeys(model.textures, textureMap);
       this.fillMissingTextureKeys(model.textures, metaMap);
       const sizes = {};
@@ -2464,7 +2250,7 @@ var UVMapper = class {
       this.fillMissingTextureKeys(model.textures, sizes);
       const s = Math.ceil(Math.sqrt(textureCount + 1));
       const size = Math.ceil(s * maxWidth);
-      console.debug(p5, "Atlas size:", size);
+      console.debug(p6, "Atlas size:", size);
       const squaredSize = size * size;
       const missing = await ImageLoader.getData("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABAAQMAAACQp+OdAAAABlBMVEX/AP8AAACfphTyAAAAFUlEQVQoz2MIhQKGVVAwKjIqQrwIAHRz/wFI17TEAAAAAElFTkSuQmCC");
       const empty = await ImageLoader.getData("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABAAQMAAACQp+OdAAAAA1BMVEUAAACnej3aAAAAAXRSTlMAQObYZgAAAA5JREFUKM9jGAWjgAIAAAJAAAFSSwuTAAAAAElFTkSuQmCC");
@@ -2493,15 +2279,16 @@ var UVMapper = class {
           if (texture.animated) {
             hasAnimation = true;
             const meta = metaMap[textureKey];
-            const frameTime = meta?.animation?.frametime ?? 1;
+            const frameTime = ((_a = meta == null ? void 0 : meta.animation) == null ? void 0 : _a.frametime) ?? 1;
             console.log(meta);
             console.log(frameTime);
             let t = 0;
             let f = 0;
             animatorFunctions[textureKey] = () => {
+              var _a2;
               if (t++ >= frameTime) {
                 t = 0;
-                const frames = meta?.animation?.frames;
+                const frames = (_a2 = meta == null ? void 0 : meta.animation) == null ? void 0 : _a2.frames;
                 const frame = frames ? frames[f] : f;
                 image.putData(texture.getFrameSectionData(frame), x, y, 0, 0, maxWidth, maxWidth);
                 f++;
@@ -2519,10 +2306,10 @@ var UVMapper = class {
         }
       }
       const atlasImageData = image.toDataURL();
-      console.log(p5, "Atlas Image for", model.key, atlasImageData);
+      console.log(p6, "Atlas Image for", model.key, atlasImageData);
       this.fillMissingTextureKeys(model.textures, positions);
       if (isItemModel) {
-        console.debug(p5, "Generating item model for", model);
+        console.debug(p6, "Generating item model for", model);
         model.elements = [];
         for (let layerName of ModelGenerator.ITEM_LAYERS) {
           const textureImage = textureMap[layerName];
@@ -2530,7 +2317,7 @@ var UVMapper = class {
             model.elements.push(...ModelGenerator.generateItemModel(textureImage.data, layerName));
           }
         }
-        console.debug(p5, "Item model elements", model.elements);
+        console.debug(p6, "Item model elements", model.elements);
       }
       if (!model.elements) {
       }
@@ -2548,13 +2335,17 @@ var UVMapper = class {
               this.setCubeFaceUvInArray(uv, faceIndex * 4, [0, 1, 8 / size, (size - 8) / size]);
               continue;
             }
-            if (!face.texture) continue;
             if (!face.uv) {
               face.uv = this.getFallbackUv(element, faceName);
             }
-            const faceTexture = face.texture.substr(1);
-            const texPosition = positions[faceTexture] || [0, 0];
-            const texSize = sizes[faceTexture] || [16, 16];
+            let faceTexture = face.texture;
+            let texPosition;
+            let texSize;
+            if (faceTexture) {
+              faceTexture = faceTexture.substr(1);
+              texPosition = positions[faceTexture] || [0, 0];
+              texSize = sizes[faceTexture] || [16, 16];
+            }
             let texPosV = new import_three8.Vector2(texPosition[0], texPosition[1]);
             const [tl, tr, bl, br] = this.expandAndRotateMcUvs(face.uv, face.rotation, texSize[0], texSize[1]);
             tl.add(texPosV);
@@ -2586,7 +2377,7 @@ var UVMapper = class {
         hasTransparency
       );
     } else {
-      console.warn(p5, "Model does not have any textures", model);
+      console.warn(p6, "Model does not have any textures", model);
     }
     return void 0;
   }
@@ -2724,20 +2515,17 @@ function shutdown() {
 }
 
 // src/assets/Entities.ts
+var import_typescript_memoize3 = require("typescript-memoize");
 var Entities = class {
   static async getBlockEntityModels() {
     const key = AssetKey.parse("models", "minerender:blockEntityModels");
     console.log(key);
-    return Caching.entityModelsCache.get(key.serialize(), () => {
-      return AssetLoader.get(key, "json" /* JSON */);
-    });
+    return AssetLoader.get(key, "json" /* JSON */);
   }
   static async getEntityModels() {
     const key = AssetKey.parse("models", "minerender:entityModels");
     console.log(key);
-    return Caching.entityModelsCache.get(key.serialize(), () => {
-      return AssetLoader.get(key, "json" /* JSON */);
-    });
+    return AssetLoader.get(key, "json" /* JSON */);
   }
   // BlockEntity names are hardcoded
   static async getBlockList() {
@@ -2783,6 +2571,12 @@ var Entities = class {
     };
   }
 };
+__decorateClass([
+  (0, import_typescript_memoize3.Memoize)()
+], Entities, "getBlockEntityModels", 1);
+__decorateClass([
+  (0, import_typescript_memoize3.Memoize)()
+], Entities, "getEntityModels", 1);
 var EntityModels = class {
 };
 var BlockEntityModels = class {
@@ -2846,26 +2640,18 @@ var MineRenderError = class _MineRenderError extends Error {
 };
 
 // src/renderer/SceneObject.ts
-var import_ts_deepmerge3 = __toESM(require_dist());
-var p6 = prefix("SceneObject");
-var SceneObject = class _SceneObject extends import_three9.Object3D {
+var import_ts_deepmerge4 = __toESM(require_dist());
+var p7 = prefix("SceneObject");
+var _SceneObject = class _SceneObject extends import_three9.Object3D {
   constructor(options) {
     super();
     this.isSceneObject = true;
     this.materialCallbacks = {};
     this._isInstanced = false;
     this._instanceCounter = 0;
-    this.options = (0, import_ts_deepmerge3.default)({}, _SceneObject.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge4.default)({}, _SceneObject.DEFAULT_OPTIONS, options ?? {});
     console.log("SceneObject options", this.options);
   }
-  static {
-    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge3.default)({}, {
-      instanceMeshes: true,
-      maxInstanceCount: 50,
-      mergeMeshes: true,
-      wireframe: false
-    });
-  }
   set scene(scene) {
     if (!!this._scene) throw new MineRenderError("Scene already set");
     this._scene = scene;
@@ -3034,9 +2820,9 @@ var SceneObject = class _SceneObject extends import_three9.Object3D {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const i = this._instanceCounter++;
     this.setMatrixAt(i, new import_three9.Matrix4());
-    console.debug(p6, "nextInstance " + i);
+    console.debug(p7, "nextInstance " + i);
     if (i === this.options.maxInstanceCount) {
-      console.warn(p6, "Max instance count reached for " + this);
+      console.warn(p7, "Max instance count reached for " + this);
     }
     if (this.scene) {
       this.scene.stats.instanceCount++;
@@ -3207,29 +2993,34 @@ var SceneObject = class _SceneObject extends import_three9.Object3D {
     this.notifyDirty();
   }
   removeFromScene() {
-    this._scene?.remove(this);
+    var _a;
+    (_a = this._scene) == null ? void 0 : _a.remove(this);
     this.notifyDirty();
   }
   //</editor-fold>
 };
+_SceneObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, {
+  instanceMeshes: true,
+  maxInstanceCount: 50,
+  mergeMeshes: true,
+  wireframe: false
+});
+var SceneObject = _SceneObject;
 function isSceneObject(obj) {
   return obj.isSceneObject;
 }
 
 // src/entity/scene/EntityObject.ts
-var import_ts_deepmerge4 = __toESM(require_dist());
+var import_ts_deepmerge5 = __toESM(require_dist());
 var import_three11 = require("three");
-var THREE3 = __toESM(require("three"));
+var THREE2 = __toESM(require("three"));
 var EntityObject = class extends SceneObject {
   constructor(entity, options) {
     super();
     this.entity = entity;
     this.isEntityObject = true;
     this.meshesCreated = false;
-    this.options = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
-  }
-  static {
-    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS, {});
+    this.options = (0, import_ts_deepmerge5.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
   }
   async init() {
     this.createMeshes();
@@ -3238,19 +3029,17 @@ var EntityObject = class extends SceneObject {
   dispose() {
     super.dispose();
   }
-  get textureKey() {
-    return new AssetKey(
-      this.entity.key?.namespace ?? DEFAULT_NAMESPACE,
+  async loadTextures() {
+    var _a;
+    this.imageData = await ModelTextures.get(new AssetKey(
+      ((_a = this.entity.key) == null ? void 0 : _a.namespace) ?? DEFAULT_NAMESPACE,
       this.entity.key.path,
       //TODO: texture may differ from entity name; most of them are in subdirectories for multiple variants etc.
       "textures",
       "entity",
       "assets",
       ".png"
-    );
-  }
-  async loadTextures() {
-    this.imageData = await ModelTextures.get(this.textureKey);
+    ));
   }
   //TODO: abstract this, since extracted model data can be used for entities, blocks, players
   createMeshes(force = false) {
@@ -3269,8 +3058,8 @@ var EntityObject = class extends SceneObject {
         const l = cube.maxZ - cube.minZ;
         const uv = texture.toUvArray(w, h, l);
         const cubeGeo = this._getBoxGeometryForDimensionsAndUv(w, h, l, uv).clone();
-        cubeGeo.applyMatrix4(new THREE3.Matrix4().makeTranslation(w / 2, h / 2, l / 2));
-        cubeGeo.applyMatrix4(new THREE3.Matrix4().makeTranslation(cube.minX, cube.minY, cube.minZ));
+        cubeGeo.applyMatrix4(new THREE2.Matrix4().makeTranslation(w / 2, h / 2, l / 2));
+        cubeGeo.applyMatrix4(new THREE2.Matrix4().makeTranslation(cube.minX, cube.minY, cube.minZ));
         applyModelPartRotation(part, cubeGeo);
         const mesh = this.createMesh(partName, cubeGeo, mat);
         partAnchor.add(mesh);
@@ -3283,25 +3072,24 @@ var EntityObject = class extends SceneObject {
     this.meshesCreated = true;
   }
   async applyTextures() {
-    const assetKeyStr = this.textureKey.serialize();
-    const keyStr = `entity:${assetKeyStr}`;
-    let mat = Caching.materialCache.getIfPresent(keyStr);
-    if (!mat) {
-      const pending = this.loadTextures();
-      const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
-      await pending;
-      if (!this.imageData) return;
-      const canvas = this.imageData.data.canvas;
-      const createMaterial = () => Materials.createBasicCanvasMaterial(canvas);
-      mat = cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
-      this.imageData = void 0;
-    }
-    this.iterateAllMeshes((mesh) => {
-      mesh.material = mat;
-    });
-    this.notifyDirty();
+    var _a;
+    const textureAsset = await ModelTextures.preload(new AssetKey(
+      ((_a = this.entity.key) == null ? void 0 : _a.namespace) ?? DEFAULT_NAMESPACE,
+      this.entity.key.path,
+      "textures",
+      "entity",
+      "assets",
+      ".png"
+    ));
+    if (textureAsset) {
+      let mat = Materials.getImage({ texture: { src: textureAsset.src } });
+      this.iterateAllMeshes((mesh) => {
+        mesh.material = mat;
+      });
+    }
   }
 };
+EntityObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge5.default)({}, SceneObject.DEFAULT_OPTIONS, {});
 function isEntityObject(obj) {
   return obj.isEntityObject;
 }
@@ -3313,7 +3101,7 @@ var GuiObject = class extends SceneObject {
 
 // src/inspector/SceneInspector.ts
 var import_three12 = require("three");
-var p7 = prefix("SceneInspector");
+var p8 = prefix("SceneInspector");
 var help = "<span>Ctrl+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
@@ -3342,7 +3130,8 @@ var SceneInspector = class {
     return out;
   }
   onClick(event) {
-    if (event.target?.nodeName !== "CANVAS") return;
+    var _a;
+    if (((_a = event.target) == null ? void 0 : _a.nodeName) !== "CANVAS") return;
     if (!event.ctrlKey) return;
     setTimeout(() => {
       this.mouse.x = event.clientX / window.innerWidth * 2 - 1;
@@ -3382,7 +3171,7 @@ var SceneInspector = class {
   }
   selectObject(targetObject, targetIntersection) {
     this.selectedObject = targetObject;
-    console.log(p7, "selected", targetObject);
+    console.log(p8, "selected", targetObject);
     this.redraw(targetObject, targetIntersection);
   }
   redraw(targetObject, targetIntersection) {
@@ -3680,7 +3469,7 @@ var SceneStatsDisplay = class {
 };
 
 // src/instance/InstanceManager.ts
-var p8 = prefix("InstanceManager");
+var p9 = prefix("InstanceManager");
 var InstanceManager = class {
   constructor() {
     this.isInstanceManager = true;
@@ -3688,7 +3477,7 @@ var InstanceManager = class {
   }
   async get(key) {
     if (key in this.instanceCache) {
-      console.debug(p8, "key in cache", key);
+      console.debug(p9, "key in cache", key);
       return (await this.instanceCache[key]).nextInstance();
     }
     return void 0;
@@ -3697,17 +3486,13 @@ var InstanceManager = class {
     if (key in this.instanceCache) {
       return await this.get(key);
     }
-    console.debug(p8, "key not in cache", key);
-    const pending = Promise.resolve().then(supplier).then((obj) => obj.nextInstance());
-    this.instanceCache[key] = pending;
-    try {
-      return await pending;
-    } catch (error) {
-      if (this.instanceCache[key] === pending) {
-        delete this.instanceCache[key];
-      }
-      throw error;
-    }
+    console.debug(p9, "key not in cache", key);
+    this.instanceCache[key] = new Promise(async (resolve) => {
+      const obj = await supplier();
+      const instance = obj.nextInstance();
+      resolve(instance);
+    });
+    return await this.instanceCache[key];
   }
   reset() {
     for (let instanceCacheKey in this.instanceCache) {
@@ -4296,28 +4081,26 @@ function computeMorphedAttributes(object) {
 }
 
 // src/model/scene/ModelObject.ts
-var import_ts_deepmerge5 = __toESM(require_dist());
-var p9 = prefix("ModelObject");
-var ModelObject = class _ModelObject extends SceneObject {
+var import_ts_deepmerge6 = __toESM(require_dist());
+var p10 = prefix("ModelObject");
+var _ModelObject = class _ModelObject extends SceneObject {
   constructor(originalModel, options) {
     super(options);
     this.originalModel = originalModel;
     this.isModelObject = true;
     this.meshesCreated = false;
-    this.options = (0, import_ts_deepmerge5.default)({}, _ModelObject.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge6.default)({}, _ModelObject.DEFAULT_OPTIONS, options ?? {});
     console.log("ModelObject options", this.options);
   }
-  static {
-    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge5.default)({}, SceneObject.DEFAULT_OPTIONS, {});
-  }
   async init() {
     await this.loadTextures();
     this.createMeshes();
     this.applyTextures();
   }
   dispose() {
+    var _a;
     super.dispose();
-    this.atlas?.dispose();
+    (_a = this.atlas) == null ? void 0 : _a.dispose();
   }
   get textureAtlas() {
     return this.atlas;
@@ -4327,12 +4110,13 @@ var ModelObject = class _ModelObject extends SceneObject {
     this.atlas = await UVMapper.getAtlas(this.originalModel);
   }
   createMeshes(force = false) {
+    var _a;
     if (this.meshesCreated && !force) return;
     const mat = Materials.MISSING_TEXTURE;
     let allGeos = [];
     if (this.atlas) {
       if (this.atlas.model.elements) {
-        this.atlas.model.elements?.forEach((el) => {
+        (_a = this.atlas.model.elements) == null ? void 0 : _a.forEach((el) => {
           const elGeo = this._getBoxGeometryFromElement(el).clone();
           elGeo.applyMatrix4(new import_three15.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_three15.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
@@ -4350,10 +4134,10 @@ var ModelObject = class _ModelObject extends SceneObject {
           }
         });
       } else {
-        console.debug(p9, this.atlas.model, "has no elements");
+        console.debug(p10, this.atlas.model, "has no elements");
       }
     } else {
-      console.debug(p9, "Missing atlas for", this);
+      console.debug(p10, "Missing atlas for", this);
     }
     if (this.options.mergeMeshes) {
       let combinedGeo;
@@ -4405,25 +4189,17 @@ var ModelObject = class _ModelObject extends SceneObject {
     }
   }
 };
+_ModelObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge6.default)({}, SceneObject.DEFAULT_OPTIONS, {});
+var ModelObject = _ModelObject;
 function isModelObject(obj) {
   return obj.isModelObject;
 }
 
 // src/model/block/scene/BlockObject.ts
-var import_ts_deepmerge6 = __toESM(require_dist());
+var import_ts_deepmerge7 = __toESM(require_dist());
 var import_three16 = require("three");
-var p10 = prefix("BlockObject");
-function matchesCondition(condition, state) {
-  return Object.entries(condition).every(([key, value]) => {
-    if (Array.isArray(value)) {
-      if (key === "OR") return value.some((child) => matchesCondition(child, state));
-      if (key === "AND") return value.every((child) => matchesCondition(child, state));
-      return false;
-    }
-    return typeof value === "string" && state[key] !== void 0 && value.split("|").includes(`${state[key]}`);
-  });
-}
-var BlockObject = class _BlockObject extends SceneObject {
+var p11 = prefix("BlockObject");
+var _BlockObject = class _BlockObject extends SceneObject {
   constructor(blockState, options) {
     super(options);
     this.blockState = blockState;
@@ -4436,16 +4212,11 @@ var BlockObject = class _BlockObject extends SceneObject {
     this._instanceModel = [];
     this._variants = [];
     this._models = [];
-    this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
-  }
-  static {
-    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge6.default)({}, ModelObject.DEFAULT_OPTIONS, {
-      applyDefaultState: true
-    });
+    this.options = (0, import_ts_deepmerge7.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
   }
   async init() {
     if (this.options.applyDefaultState) {
-      const defaultState = this.blockState.key ? await BlockStates.getDefaultState(this.blockState.key) : void 0;
+      const defaultState = this.blockState.key ? BlockStates.getDefaultState(this.blockState.key) : void 0;
       if (defaultState && Object.keys(defaultState).length > 0) {
         const state = {};
         for (let k in defaultState) {
@@ -4456,10 +4227,16 @@ var BlockObject = class _BlockObject extends SceneObject {
         if (this.blockState.variants) {
           await this.setState(Object.keys(this.blockState.variants)[0]);
         } else if (this.blockState.multipart) {
-          const condition = this.blockState.multipart.map((part) => part.when).find((when) => when !== void 0 && Object.values(when).every((value) => typeof value === "string"));
-          const state = Object.fromEntries(Object.entries(condition ?? {}).map(([key, value]) => [key, value.split("|")[0]]));
-          await this.setState(state);
-        }
+          for (let part of this.blockState.multipart) {
+            if (part.when && !("OR" in part.when)) {
+              const k = Object.keys(part.when)[0];
+              if (k) {
+                await this.setState(k, part.when[k].split("|")[0]);
+                break;
+              }
+            }
+          }
+        }
       }
     } else {
       await this.recreateModels();
@@ -4515,11 +4292,55 @@ var BlockObject = class _BlockObject extends SceneObject {
     } else if (this.blockState.multipart) {
       for (let part of this.blockState.multipart) {
         if (!part.apply) {
-          console.debug(p10, "Missing apply for blockState part", part);
+          console.debug(p11, "Missing apply for blockState part", part);
           continue;
         }
-        if (!part.when || matchesCondition(part.when, state)) {
+        if (!part.when) {
           out.push(this.getSingleVariant(part.apply));
+        } else {
+          let matches = true;
+          if ("OR" in part.when) {
+            const or = part.when.OR;
+            let anyMatch = false;
+            for (let o of or) {
+              for (let k in o) {
+                const split = o[k].split("|");
+                let m = false;
+                for (let s of split) {
+                  if (`${state[k]}` === `${s}`) {
+                    m = true;
+                    break;
+                  }
+                }
+                if (m) {
+                  anyMatch = true;
+                  break;
+                }
+              }
+            }
+            if (!anyMatch) {
+              matches = false;
+            }
+          } else {
+            for (let k in part.when) {
+              const split = part.when[k].split("|");
+              let m = false;
+              for (let s of split) {
+                if (`${state[k]}` === `${s}`) {
+                  m = true;
+                  break;
+                }
+              }
+              if (!m) {
+                matches = false;
+                break;
+              }
+            }
+          }
+          if (matches) {
+            const variants = part.apply;
+            out.push(this.getSingleVariant(variants));
+          }
         }
       }
     }
@@ -4549,21 +4370,11 @@ var BlockObject = class _BlockObject extends SceneObject {
     }
   }
   getSingleVariant(variants) {
-    if (!Array.isArray(variants)) return variants;
-    if (!variants.length) throw new MineRenderError("Blockstate variant arrays must not be empty");
-    const total = variants.reduce((sum, variant) => {
-      const weight = variant.weight ?? 1;
-      if (!Number.isInteger(weight) || weight < 1) {
-        throw new MineRenderError(`Invalid blockstate variant weight: ${weight}`);
-      }
-      return sum + weight;
-    }, 0);
-    let choice = Math.random() * total;
-    for (const variant of variants) {
-      choice -= variant.weight ?? 1;
-      if (choice < 0) return variant;
-    }
-    return variants[variants.length - 1];
+    if (Array.isArray(variants)) {
+      return variants[0];
+    } else {
+      return variants;
+    }
   }
   // @deprecated
   async createAVariant(variants, instanceInfo) {
@@ -4589,6 +4400,9 @@ var BlockObject = class _BlockObject extends SceneObject {
       }
     }
     obj.setRotation(rotation);
+    setTimeout(() => {
+      obj.setRotation(rotation);
+    }, 150);
     console.log(obj);
     return obj;
   }
@@ -4679,15 +4493,18 @@ var BlockObject = class _BlockObject extends SceneObject {
     }
   }
   setPosition(position) {
-    this.position.copy(position);
+    super.setPosition(position);
     for (let model of this._models) {
       model.setPosition(position);
     }
-    this.notifyDirty();
   }
   //TODO: should override rotation + scale methods
   //TODO
 };
+_BlockObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge7.default)({}, ModelObject.DEFAULT_OPTIONS, {
+  applyDefaultState: true
+});
+var BlockObject = _BlockObject;
 function isBlockObject(obj) {
   return obj.isBlockObject;
 }
@@ -4712,10 +4529,11 @@ var StructureParser = class {
       throw new MineRenderError("Structure does not have palette(s)");
     }
     const blocks = nbt.blocks.value.value.map((block) => {
+      var _a;
       const state = palette.value.value[block.state.value];
       if (state.Name.value === "minecraft:air") return void 0;
       const props = {};
-      for (let k in state.Properties?.value) {
+      for (let k in (_a = state.Properties) == null ? void 0 : _a.value) {
         props[k] = state.Properties.value[k].value;
       }
       return {
@@ -4734,7 +4552,7 @@ var StructureParser = class {
 
 // src/renderer/MineRenderScene.ts
 var import_three17 = require("three");
-var import_ts_deepmerge8 = __toESM(require_dist());
+var import_ts_deepmerge9 = __toESM(require_dist());
 
 // src/skin/SkinPart.ts
 var SkinPart = /* @__PURE__ */ ((SkinPart2) => {
@@ -5465,7 +5283,7 @@ var slimSkinGeometries = {
 };
 
 // src/skin/scene/SkinObject.ts
-var import_ts_deepmerge7 = __toESM(require_dist());
+var import_ts_deepmerge8 = __toESM(require_dist());
 var SkinObject = class extends SceneObject {
   constructor(options) {
     super();
@@ -5473,7 +5291,7 @@ var SkinObject = class extends SceneObject {
     this.legacy = false;
     this.skinTextureWidth = 64;
     this.skinTextureHeight = 64;
-    this.options = (0, import_ts_deepmerge7.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge8.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
   }
   async init() {
     this.createMeshes();
@@ -5577,7 +5395,7 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
-var MineRenderScene = class _MineRenderScene extends import_three17.Scene {
+var _MineRenderScene = class _MineRenderScene extends import_three17.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -5586,14 +5404,12 @@ var MineRenderScene = class _MineRenderScene extends import_three17.Scene {
     this.dirty = true;
     this.observedObjects = /* @__PURE__ */ new Set();
     this.onObjectChange = (event) => {
-      if (event.target?.parent === this) {
+      var _a;
+      if (((_a = event.target) == null ? void 0 : _a.parent) === this) {
         this.dirty = true;
       }
     };
-    this.options = (0, import_ts_deepmerge8.default)({}, _MineRenderScene.DEFAULT_OPTIONS, options ?? {});
-  }
-  static {
-    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge8.default)({}, {});
+    this.options = (0, import_ts_deepmerge9.default)({}, _MineRenderScene.DEFAULT_OPTIONS, options ?? {});
   }
   add(...objects) {
     for (const object of objects) {
@@ -5601,7 +5417,7 @@ var MineRenderScene = class _MineRenderScene extends import_three17.Scene {
       try {
         super.add(object);
       } finally {
-        if (object?.isObject3D && object !== this) {
+        if ((object == null ? void 0 : object.isObject3D) && object !== this) {
           this.updateObjectRegistration(object, object.parent === this);
         }
       }
@@ -5644,12 +5460,13 @@ var MineRenderScene = class _MineRenderScene extends import_three17.Scene {
     return this.add(...object);
   }
   async addSceneObject(asset, objectSupplier, _options, parent = this) {
+    var _a, _b;
     console.log("addSceneObject", asset);
     console.log("parent", parent);
     console.log(_options);
     this.dirty = true;
     const obj = await objectSupplier();
-    if (obj?.options?.instanceMeshes && asset.key && asset.key?.assetType === "models") {
+    if (((_a = obj == null ? void 0 : obj.options) == null ? void 0 : _a.instanceMeshes) && asset.key && ((_b = asset.key) == null ? void 0 : _b.assetType) === "models") {
       console.log("instanceMeshes + key");
       const key = asset.key.serialize();
       return this.instanceManager.getOrCreate(key, async () => {
@@ -5689,1139 +5506,1109 @@ var MineRenderScene = class _MineRenderScene extends import_three17.Scene {
     return this.addSceneObject(entity, () => new EntityObject(entity, options), options, parent);
   }
 };
+_MineRenderScene.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {});
+var MineRenderScene = _MineRenderScene;
 function isMineRenderScene(obj) {
   return obj.isMineRenderScene;
 }
 
 // src/renderer/Renderer.ts
-var import_three19 = require("three");
-var import_ts_deepmerge9 = __toESM(require_dist());
+var import_three18 = require("three");
+var import_ts_deepmerge10 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
-
-// src/three/OrbitControls.js
-var import_three18 = require("three");
-var _changeEvent = { type: "change" };
-var _startEvent = { type: "start" };
-var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three18.EventDispatcher {
-  constructor(object, domElement) {
-    super();
-    if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
-    if (domElement === document) console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.');
-    this.object = object;
-    this.domElement = domElement;
-    this.domElement.style.touchAction = "none";
-    this.enabled = true;
-    this.target = new import_three18.Vector3();
-    this.minDistance = 0;
-    this.maxDistance = Infinity;
-    this.minZoom = 0;
-    this.maxZoom = Infinity;
-    this.minPolarAngle = 0;
-    this.maxPolarAngle = Math.PI;
-    this.minAzimuthAngle = -Infinity;
-    this.maxAzimuthAngle = Infinity;
-    this.enableDamping = false;
-    this.dampingFactor = 0.05;
-    this.enableZoom = true;
-    this.zoomSpeed = 1;
-    this.enableRotate = true;
-    this.rotateSpeed = 1;
-    this.enablePan = true;
-    this.panSpeed = 1;
-    this.screenSpacePanning = true;
-    this.keyPanSpeed = 7;
-    this.autoRotate = false;
-    this.autoRotateSpeed = 2;
-    this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three18.MOUSE.ROTATE, MIDDLE: import_three18.MOUSE.DOLLY, RIGHT: import_three18.MOUSE.PAN };
-    this.touches = { ONE: import_three18.TOUCH.ROTATE, TWO: import_three18.TOUCH.DOLLY_PAN };
-    this.target0 = this.target.clone();
-    this.position0 = this.object.position.clone();
-    this.zoom0 = this.object.zoom;
-    this._domElementKeyEvents = null;
-    this.getPolarAngle = function() {
-      return spherical.phi;
-    };
-    this.getAzimuthalAngle = function() {
-      return spherical.theta;
-    };
-    this.getDistance = function() {
-      return this.object.position.distanceTo(this.target);
-    };
-    this.saveState = function() {
-      scope.target0.copy(scope.target);
-      scope.position0.copy(scope.object.position);
-      scope.zoom0 = scope.object.zoom;
-    };
-    this.reset = function() {
-      scope.target.copy(scope.target0);
-      scope.object.position.copy(scope.position0);
-      scope.object.zoom = scope.zoom0;
-      scope.object.updateProjectionMatrix();
-      scope.dispatchEvent(_changeEvent);
-      scope.update();
-      state = STATE.NONE;
-    };
-    this.update = function() {
-      const offset = new import_three18.Vector3();
-      const quat = new import_three18.Quaternion().setFromUnitVectors(object.up, new import_three18.Vector3(0, 1, 0));
-      const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three18.Vector3();
-      const lastQuaternion = new import_three18.Quaternion();
-      const twoPI = 2 * Math.PI;
-      return function update() {
-        const position = scope.object.position;
-        offset.copy(position).sub(scope.target);
-        offset.applyQuaternion(quat);
-        spherical.setFromVector3(offset);
-        if (scope.autoRotate && state === STATE.NONE) {
-          rotateLeft(getAutoRotationAngle());
-        }
-        if (scope.enableDamping) {
-          spherical.theta += sphericalDelta.theta * scope.dampingFactor;
-          spherical.phi += sphericalDelta.phi * scope.dampingFactor;
-        } else {
-          spherical.theta += sphericalDelta.theta;
-          spherical.phi += sphericalDelta.phi;
-        }
-        let min = scope.minAzimuthAngle;
-        let max = scope.maxAzimuthAngle;
-        if (isFinite(min) && isFinite(max)) {
-          if (min < -Math.PI) min += twoPI;
-          else if (min > Math.PI) min -= twoPI;
-          if (max < -Math.PI) max += twoPI;
-          else if (max > Math.PI) max -= twoPI;
-          if (min <= max) {
-            spherical.theta = Math.max(min, Math.min(max, spherical.theta));
-          } else {
-            spherical.theta = spherical.theta > (min + max) / 2 ? Math.max(min, spherical.theta) : Math.min(max, spherical.theta);
-          }
-        }
-        spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi));
-        spherical.makeSafe();
-        spherical.radius *= scale;
-        spherical.radius = Math.max(scope.minDistance, Math.min(scope.maxDistance, spherical.radius));
-        if (scope.enableDamping === true) {
-          scope.target.addScaledVector(panOffset, scope.dampingFactor);
-        } else {
-          scope.target.add(panOffset);
-        }
-        offset.setFromSpherical(spherical);
-        offset.applyQuaternion(quatInverse);
-        position.copy(scope.target).add(offset);
-        scope.object.lookAt(scope.target);
-        if (scope.enableDamping === true) {
-          sphericalDelta.theta *= 1 - scope.dampingFactor;
-          sphericalDelta.phi *= 1 - scope.dampingFactor;
-          panOffset.multiplyScalar(1 - scope.dampingFactor);
-        } else {
-          sphericalDelta.set(0, 0, 0);
-          panOffset.set(0, 0, 0);
-        }
-        scale = 1;
-        if (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) {
-          scope.dispatchEvent(_changeEvent);
-          lastPosition.copy(scope.object.position);
-          lastQuaternion.copy(scope.object.quaternion);
-          zoomChanged = false;
-          return true;
-        }
-        return false;
-      };
-    }();
-    this.dispose = function() {
-      scope.domElement.removeEventListener("contextmenu", onContextMenu);
-      scope.domElement.removeEventListener("pointerdown", onPointerDown);
-      scope.domElement.removeEventListener("pointercancel", onPointerCancel);
-      scope.domElement.removeEventListener("wheel", onMouseWheel);
-      scope.domElement.removeEventListener("pointermove", onPointerMove);
-      scope.domElement.removeEventListener("pointerup", onPointerUp);
-      if (scope._domElementKeyEvents !== null) {
-        scope._domElementKeyEvents.removeEventListener("keydown", onKeyDown);
-      }
-    };
-    const scope = this;
-    const STATE = {
-      NONE: -1,
-      ROTATE: 0,
-      DOLLY: 1,
-      PAN: 2,
-      TOUCH_ROTATE: 3,
-      TOUCH_PAN: 4,
-      TOUCH_DOLLY_PAN: 5,
-      TOUCH_DOLLY_ROTATE: 6
+var _Renderer = class _Renderer {
+  constructor(options) {
+    this._dirty = true;
+    this._animationTimer = void 0;
+    this._animationFrame = void 0;
+    this._resizeListener = void 0;
+    this._disposed = false;
+    this._debugHelpers = [];
+    this._eventDispatchers = /* @__PURE__ */ new Map();
+    this._changeListener = () => {
+      this._dirty = true;
     };
-    let state = STATE.NONE;
-    const EPS = 1e-6;
-    const spherical = new import_three18.Spherical();
-    const sphericalDelta = new import_three18.Spherical();
-    let scale = 1;
-    const panOffset = new import_three18.Vector3();
-    let zoomChanged = false;
-    const rotateStart = new import_three18.Vector2();
-    const rotateEnd = new import_three18.Vector2();
-    const rotateDelta = new import_three18.Vector2();
-    const panStart = new import_three18.Vector2();
-    const panEnd = new import_three18.Vector2();
-    const panDelta = new import_three18.Vector2();
-    const dollyStart = new import_three18.Vector2();
-    const dollyEnd = new import_three18.Vector2();
-    const dollyDelta = new import_three18.Vector2();
-    const pointers = [];
-    const pointerPositions = {};
-    function getAutoRotationAngle() {
-      return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
+    this.options = (0, import_ts_deepmerge10.default)({}, _Renderer.DEFAULT_OPTIONS, options ?? {});
+    this._animationLoop = this.animate.bind(this);
+    this._fpsTimer = this.options.render.fpsLimit > 0 ? 1e3 / this.options.render.fpsLimit : void 0;
+    this._scene = this.createScene();
+    this._camera = this.createCamera();
+    this._renderer = this.createRenderer();
+    this._composer = this.createComposer();
+    if (this.options.render.stats) {
+      this._stats = new import_stats.default();
+      document.body.appendChild(this._stats.dom);
     }
-    function getZoomScale() {
-      return Math.pow(0.95, scope.zoomSpeed);
+    this.init();
+  }
+  //<editor-fold desc="INIT">
+  createScene() {
+    return new MineRenderScene();
+  }
+  createCamera() {
+    switch (this.options.camera.type) {
+      case "perspective":
+      default:
+        return new import_three18.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_three18.OrthographicCamera(
+          this.options.camera.orthographic.left ?? this.viewWidth / -2,
+          this.options.camera.orthographic.right ?? this.viewWidth / 2,
+          this.options.camera.orthographic.top ?? this.viewHeight / 2,
+          this.options.camera.orthographic.bottom ?? this.viewHeight / -2,
+          this.options.camera.near,
+          this.options.camera.far
+        );
     }
-    function rotateLeft(angle) {
-      sphericalDelta.theta -= angle;
+  }
+  createRenderer() {
+    const renderer = new import_three18.WebGLRenderer({
+      antialias: this.options.render.antialias,
+      alpha: true,
+      powerPreference: "high-performance",
+      depth: true
+    });
+    renderer.setClearColor(0, 0);
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = import_three18.PCFSoftShadowMap;
+    renderer.outputEncoding = import_three18.LinearEncoding;
+    renderer.setSize(this.viewWidth, this.viewHeight);
+    return renderer;
+  }
+  createComposer() {
+    const composer = new import_postprocessing.EffectComposer(this.renderer);
+    if (!this.options.composer.enabled) return composer;
+    composer.setSize(this.viewWidth, this.viewHeight);
+    composer.addPass(new import_postprocessing.RenderPass(this.scene, this.camera));
+    return composer;
+  }
+  //</editor-fold>
+  init() {
+    if (this._disposed) return;
+    if (typeof window["__THREE_DEVTOOLS__"] !== "undefined") {
+      window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
-    function rotateUp(angle) {
-      sphericalDelta.phi -= angle;
+    if (this.options.debug.grid) {
+      const gridHelper = new import_three18.GridHelper(128, 16);
+      this._debugHelpers.push(gridHelper);
+      this.scene.add(gridHelper);
+      const gridHelper2 = new import_three18.GridHelper(128, 16);
+      this._debugHelpers.push(gridHelper2);
+      gridHelper2.rotation.x = 90 * (Math.PI / 180);
+      this.scene.add(gridHelper2);
+      const gridHelper3 = new import_three18.GridHelper(128, 16);
+      this._debugHelpers.push(gridHelper3);
+      gridHelper3.rotation.z = 90 * (Math.PI / 180);
+      this.scene.add(gridHelper3);
     }
-    const panLeft = function() {
-      const v = new import_three18.Vector3();
-      return function panLeft2(distance, objectMatrix) {
-        v.setFromMatrixColumn(objectMatrix, 0);
-        v.multiplyScalar(-distance);
-        panOffset.add(v);
-      };
-    }();
-    const panUp = function() {
-      const v = new import_three18.Vector3();
-      return function panUp2(distance, objectMatrix) {
-        if (scope.screenSpacePanning === true) {
-          v.setFromMatrixColumn(objectMatrix, 1);
-        } else {
-          v.setFromMatrixColumn(objectMatrix, 0);
-          v.crossVectors(scope.object.up, v);
-        }
-        v.multiplyScalar(distance);
-        panOffset.add(v);
-      };
-    }();
-    const pan = function() {
-      const offset = new import_three18.Vector3();
-      return function pan2(deltaX, deltaY) {
-        const element = scope.domElement;
-        if (scope.object.isPerspectiveCamera) {
-          const position = scope.object.position;
-          offset.copy(position).sub(scope.target);
-          let targetDistance = offset.length();
-          targetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180);
-          panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);
-          panUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix);
-        } else if (scope.object.isOrthographicCamera) {
-          panLeft(deltaX * (scope.object.right - scope.object.left) / scope.object.zoom / element.clientWidth, scope.object.matrix);
-          panUp(deltaY * (scope.object.top - scope.object.bottom) / scope.object.zoom / element.clientHeight, scope.object.matrix);
-        } else {
-          console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.");
-          scope.enablePan = false;
-        }
-      };
-    }();
-    function dollyOut(dollyScale) {
-      if (scope.object.isPerspectiveCamera) {
-        scale /= dollyScale;
-      } else if (scope.object.isOrthographicCamera) {
-        scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom * dollyScale));
-        scope.object.updateProjectionMatrix();
-        zoomChanged = true;
-      } else {
-        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
-        scope.enableZoom = false;
-      }
+    if (this.options.debug.axes) {
+      const axesHelper = new import_three18.AxesHelper(64);
+      this._debugHelpers.push(axesHelper);
+      this.scene.add(axesHelper);
     }
-    function dollyIn(dollyScale) {
-      if (scope.object.isPerspectiveCamera) {
-        scale *= dollyScale;
-      } else if (scope.object.isOrthographicCamera) {
-        scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / dollyScale));
-        scope.object.updateProjectionMatrix();
-        zoomChanged = true;
-      } else {
-        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
-        scope.enableZoom = false;
+    if (this.options.camera.position) {
+      if (isVector3(this.options.camera.position)) {
+        this.camera.position.set(this.options.camera.position.x, this.options.camera.position.y, this.options.camera.position.z);
+      } else if (isTripleArray(this.options.camera.position)) {
+        this.camera.position.set(this.options.camera.position[0], this.options.camera.position[1], this.options.camera.position[2]);
       }
     }
-    function handleMouseDownRotate(event) {
-      rotateStart.set(event.clientX, event.clientY);
+    if (this.options.camera.lookingAt) {
+      if (isVector3(this.options.camera.lookingAt)) {
+        this.camera.lookAt(this.options.camera.lookingAt);
+      } else if (isTripleArray(this.options.camera.lookingAt)) {
+        this.camera.lookAt(this.options.camera.lookingAt[0], this.options.camera.lookingAt[1], this.options.camera.lookingAt[2]);
+      }
     }
-    function handleMouseDownDolly(event) {
-      dollyStart.set(event.clientX, event.clientY);
+    if (this.options.render.autoResize && !this._resizeListener) {
+      this._resizeListener = () => {
+        this.resize(this.viewWidth, this.viewHeight);
+      };
+      window.addEventListener("resize", this._resizeListener);
     }
-    function handleMouseDownPan(event) {
-      panStart.set(event.clientX, event.clientY);
+  }
+  get element() {
+    return this._element;
+  }
+  appendTo(element) {
+    if (this._disposed) return;
+    this._element = element;
+    this._element.appendChild(this.renderer.domElement);
+    if (this.viewWidth == 0) {
+      console.warn("0 element width");
     }
-    function handleMouseMoveRotate(event) {
-      rotateEnd.set(event.clientX, event.clientY);
-      rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
-      const element = scope.domElement;
-      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
-      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
-      rotateStart.copy(rotateEnd);
-      scope.update();
+    if (this.viewHeight == 0) {
+      console.warn("0 element height");
     }
-    function handleMouseMoveDolly(event) {
-      dollyEnd.set(event.clientX, event.clientY);
-      dollyDelta.subVectors(dollyEnd, dollyStart);
-      if (dollyDelta.y > 0) {
-        dollyOut(getZoomScale());
-      } else if (dollyDelta.y < 0) {
-        dollyIn(getZoomScale());
-      }
-      dollyStart.copy(dollyEnd);
-      scope.update();
+    this.resize(this.viewWidth, this.viewHeight);
+  }
+  /**
+   * Redraws when the dispatcher emits the selected event. Registering the same pair twice has no effect.
+   * The renderer removes its listener on disposal; the caller retains ownership of the dispatcher.
+   */
+  registerEventDispatcher(dispatcher, changeEvent2 = "change") {
+    if (this._disposed) return;
+    let events = this._eventDispatchers.get(dispatcher);
+    if (!events) {
+      events = /* @__PURE__ */ new Set();
+      this._eventDispatchers.set(dispatcher, events);
     }
-    function handleMouseMovePan(event) {
-      panEnd.set(event.clientX, event.clientY);
-      panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
-      pan(panDelta.x, panDelta.y);
-      panStart.copy(panEnd);
-      scope.update();
+    if (events.has(changeEvent2)) return;
+    events.add(changeEvent2);
+    dispatcher.addEventListener(changeEvent2, this._changeListener);
+  }
+  resize(width, height) {
+    if (this._disposed) return;
+    if (isPerspectiveCamera(this.camera)) {
+      this.camera.aspect = width / height;
+      this.camera.updateProjectionMatrix();
+    } else if (isOrthographicCamera(this.camera)) {
+      this.camera.left = width / -2;
+      this.camera.right = width / 2;
+      this.camera.top = height / 2;
+      this.camera.bottom = height / -2;
+      this.camera.updateProjectionMatrix();
     }
-    function handleMouseUp() {
+    this.renderer.setSize(width, height);
+    this.composer.setSize(width, height);
+    this._dirty = true;
+  }
+  //<editor-fold desc="RENDER">
+  get dirty() {
+    return this._dirty || this.scene.dirty;
+  }
+  set dirty(dirty) {
+    this._dirty = dirty;
+    this.scene.dirty = dirty;
+  }
+  start() {
+    if (this._disposed) return;
+    this.stop();
+    this.renderer.setAnimationLoop(this._animationLoop);
+  }
+  stop() {
+    if (this._disposed) return;
+    this.renderer.setAnimationLoop(null);
+    if (this._animationTimer)
+      clearTimeout(this._animationTimer);
+    this._animationTimer = void 0;
+    if (this._animationFrame)
+      cancelAnimationFrame(this._animationFrame);
+    this._animationFrame = void 0;
+  }
+  /**
+   * Stops rendering and releases owned resources. Repeated calls have no effect, and a disposed
+   * renderer cannot be restarted. Scene objects are detached; shared assets and caller-owned
+   * controls must be managed by their owners.
+   */
+  dispose() {
+    var _a;
+    if (this._disposed) return;
+    this.stop();
+    this._disposed = true;
+    if (this._resizeListener) {
+      window.removeEventListener("resize", this._resizeListener);
+      this._resizeListener = void 0;
     }
-    function handleMouseWheel(event) {
-      if (event.deltaY < 0) {
-        dollyIn(getZoomScale());
-      } else if (event.deltaY > 0) {
-        dollyOut(getZoomScale());
+    for (const [dispatcher, events] of this._eventDispatchers) {
+      for (const event of events) {
+        dispatcher.removeEventListener(event, this._changeListener);
       }
-      scope.update();
     }
-    function handleKeyDown(event) {
-      let needsUpdate = false;
-      switch (event.code) {
-        case scope.keys.UP:
-          pan(0, scope.keyPanSpeed);
-          needsUpdate = true;
-          break;
-        case scope.keys.BOTTOM:
-          pan(0, -scope.keyPanSpeed);
-          needsUpdate = true;
-          break;
-        case scope.keys.LEFT:
-          pan(scope.keyPanSpeed, 0);
-          needsUpdate = true;
-          break;
-        case scope.keys.RIGHT:
-          pan(-scope.keyPanSpeed, 0);
-          needsUpdate = true;
-          break;
-      }
-      if (needsUpdate) {
-        event.preventDefault();
-        scope.update();
+    this._eventDispatchers.clear();
+    (_a = this._stats) == null ? void 0 : _a.dom.remove();
+    this._stats = void 0;
+    this.renderer.domElement.remove();
+    this._element = void 0;
+    this.scene.clear();
+    for (const helper of this._debugHelpers) {
+      helper.geometry.dispose();
+      const materials = Array.isArray(helper.material) ? helper.material : [helper.material];
+      for (const material of materials) {
+        material.dispose();
       }
     }
-    function handleTouchStartRotate() {
-      if (pointers.length === 1) {
-        rotateStart.set(pointers[0].pageX, pointers[0].pageY);
-      } else {
-        const x = 0.5 * (pointers[0].pageX + pointers[1].pageX);
-        const y = 0.5 * (pointers[0].pageY + pointers[1].pageY);
-        rotateStart.set(x, y);
-      }
+    this._debugHelpers.length = 0;
+    this.composer.dispose();
+    this.renderer.dispose();
+    this.renderer.forceContextLoss();
+  }
+  animate(t) {
+    if (this._disposed) return;
+    if (this._stats) {
+      this._stats.begin();
     }
-    function handleTouchStartPan() {
-      if (pointers.length === 1) {
-        panStart.set(pointers[0].pageX, pointers[0].pageY);
+    if (this.dirty || this.options.render.renderAlways) {
+      if (this.options.composer.enabled) {
+        this.composer.render();
       } else {
-        const x = 0.5 * (pointers[0].pageX + pointers[1].pageX);
-        const y = 0.5 * (pointers[0].pageY + pointers[1].pageY);
-        panStart.set(x, y);
+        this.renderer.render(this.scene, this.camera);
       }
     }
-    function handleTouchStartDolly() {
-      const dx = pointers[0].pageX - pointers[1].pageX;
-      const dy = pointers[0].pageY - pointers[1].pageY;
-      const distance = Math.sqrt(dx * dx + dy * dy);
-      dollyStart.set(0, distance);
-    }
-    function handleTouchStartDollyPan() {
-      if (scope.enableZoom) handleTouchStartDolly();
-      if (scope.enablePan) handleTouchStartPan();
+    this.dirty = false;
+    if (this._stats) {
+      this._stats.end();
     }
-    function handleTouchStartDollyRotate() {
-      if (scope.enableZoom) handleTouchStartDolly();
-      if (scope.enableRotate) handleTouchStartRotate();
+  }
+  //</editor-fold>
+  toImage() {
+    return this.renderer.domElement.toDataURL();
+  }
+  ///
+  get attachedToBody() {
+    return this.element === document.body;
+  }
+  get viewWidth() {
+    var _a;
+    return this.attachedToBody ? window.innerWidth : ((_a = this.element) == null ? void 0 : _a.offsetWidth) || 0;
+  }
+  get viewHeight() {
+    var _a;
+    return this.attachedToBody ? window.innerHeight : ((_a = this.element) == null ? void 0 : _a.offsetHeight) || 0;
+  }
+  get scene() {
+    return this._scene;
+  }
+  get camera() {
+    return this._camera;
+  }
+  get renderer() {
+    return this._renderer;
+  }
+  get composer() {
+    return this._composer;
+  }
+  ///
+};
+_Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge10.default)({}, {
+  camera: {
+    type: "perspective",
+    near: 1,
+    far: 5e3,
+    perspective: {
+      aspect: void 0,
+      fov: 50
+    },
+    orthographic: {
+      left: void 0,
+      right: void 0,
+      top: void 0,
+      bottom: void 0
+    },
+    position: new import_three18.Vector3(50, 50, 50),
+    lookingAt: new import_three18.Vector3(0, 0, 0)
+  },
+  render: {
+    fpsLimit: 60,
+    stats: false,
+    antialias: true,
+    shade: true,
+    autoResize: true,
+    renderAlways: false
+  },
+  composer: {
+    enabled: true
+  },
+  debug: {
+    grid: false,
+    axes: false
+  }
+});
+var Renderer = _Renderer;
+
+// src/skin/Skins.ts
+var Skins = class {
+  //<editor-fold desc="Skins">
+  static async fromUuidOrUsername(uuidOrUsername) {
+    if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
+      return this.fromUuid(uuidOrUsername);
     }
-    function handleTouchMoveRotate(event) {
-      if (pointers.length == 1) {
-        rotateEnd.set(event.pageX, event.pageY);
-      } else {
-        const position = getSecondPointerPosition(event);
-        const x = 0.5 * (event.pageX + position.x);
-        const y = 0.5 * (event.pageY + position.y);
-        rotateEnd.set(x, y);
+    return this.fromUsername(uuidOrUsername);
+  }
+  static async fromUuid(uuid) {
+    return this.getSkinProxySkinUrl(uuid);
+  }
+  static async fromUsername(username) {
+    return this.usernameToUuid(username).then((uuid) => {
+      if (uuid) {
+        return this.fromUuid(uuid);
       }
-      rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
-      const element = scope.domElement;
-      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
-      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
-      rotateStart.copy(rotateEnd);
+      return void 0;
+    });
+  }
+  static async fromMineSkin(mineskinId) {
+    return this.getMineSkin(mineskinId).then((mineskin) => {
+      if (mineskin) {
+        return mineskin["data"]["texture"]["value"]["urls"]["skins"];
+      }
+      return void 0;
+    });
+  }
+  //</editor-fold>
+  //<editor-fold desc="Capes">
+  static async capeFromUuidOrUsername(uuidOrUsername) {
+    if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
+      return this.capeFromUuid(uuidOrUsername);
     }
-    function handleTouchMovePan(event) {
-      if (pointers.length === 1) {
-        panEnd.set(event.pageX, event.pageY);
-      } else {
-        const position = getSecondPointerPosition(event);
-        const x = 0.5 * (event.pageX + position.x);
-        const y = 0.5 * (event.pageY + position.y);
-        panEnd.set(x, y);
+    return this.capeFromUsername(uuidOrUsername);
+  }
+  static async capeFromUuid(uuid) {
+    return this.getSkinProxyCapeUrl(uuid);
+  }
+  static async capeFromUsername(username) {
+    return this.usernameToUuid(username).then((uuid) => {
+      if (uuid) {
+        return this.capeFromUuid(uuid);
+      }
+      return void 0;
+    });
+  }
+  static async capeFromCapesDev(uuid, capeType = "minecraft") {
+    return this.getCapesDev(uuid, capeType).then((cape) => {
+      if (cape) {
+        return cape == null ? void 0 : cape.stillImageUrl;
+      }
+      return void 0;
+    });
+  }
+  //</editor-fold>
+  //<editor-fold desc="Helpers">
+  static async usernameToUuid(username) {
+    return this.usernameToUuidSkinProxy(username);
+  }
+  static async usernameToUuidSkinProxy(username) {
+    return Requests.genericRequest({
+      baseURL: "https://minecraft-skin-proxy.inventive.workers.dev",
+      url: "/uuid/" + username
+    }).then((res) => {
+      if (res.status === 200) {
+        return res.data["id"];
+      }
+      return void 0;
+    }).catch((err) => {
+      console.warn(err);
+      return void 0;
+    });
+  }
+  static async usernameToUuidMineTools(username) {
+    return Requests.genericRequest({
+      baseURL: "https://api.minetools.eu",
+      url: "/uuid/" + username
+    }).then((res) => {
+      if (res.status === 200) {
+        return res.data["id"];
+      }
+      return void 0;
+    }).catch((err) => {
+      console.warn(err);
+      return void 0;
+    });
+  }
+  static async getProfileFromMinetools(uuid) {
+    return Requests.genericRequest({
+      baseURL: "https://api.minetools.eu",
+      url: "/profile/" + uuid
+    }).then((res) => {
+      if (res.status === 200) {
+        return res.data;
+      }
+    });
+  }
+  static async getMineSkin(mineskinId) {
+    return Requests.genericRequest({
+      baseURL: "https://api.mineskin.org",
+      url: "/get/uuid/" + mineskinId
+    }).then((res) => {
+      if (res.status === 200) {
+        return res.data;
+      }
+      return void 0;
+    }).catch((err) => {
+      console.warn(err);
+      return void 0;
+    });
+  }
+  static async getCapesDev(uuid, type = "all") {
+    return Requests.genericRequest({
+      baseURL: "https://api.capes.dev",
+      url: "/load/" + uuid + "/" + type
+    }).then((res) => {
+      if (res.status === 200) {
+        return res.data;
+      }
+      return void 0;
+    }).catch((err) => {
+      console.warn(err);
+      return void 0;
+    });
+  }
+  static getCrafatarSkinUrl(uuid) {
+    return "https://crafatar.com/skins/" + uuid;
+  }
+  static getCrafatarCapeUrl(uuid) {
+    return "https://crafatar.com/capes/" + uuid;
+  }
+  static getMcHeadsSkinUrl(uuid) {
+    return "https://mc-heads.net/skin/" + uuid;
+  }
+  static getMineSkinPlayerSkinUrl(uuid) {
+    return "https://mineskin.org/skin/player/" + uuid;
+  }
+  static getSkinProxySkinUrl(uuid) {
+    return "https://minecraft-skin-proxy.inventive.workers.dev/skin/" + uuid;
+  }
+  static getSkinProxyCapeUrl(uuid) {
+    return "https://minecraft-skin-proxy.inventive.workers.dev/cape/" + uuid;
+  }
+  //</editor-fold>
+};
+
+// src/three/OrbitControls.js
+var import_three20 = require("three");
+var _changeEvent = { type: "change" };
+var _startEvent = { type: "start" };
+var _endEvent = { type: "end" };
+var OrbitControls = class extends import_three20.EventDispatcher {
+  constructor(object, domElement) {
+    super();
+    if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
+    if (domElement === document) console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.');
+    this.object = object;
+    this.domElement = domElement;
+    this.domElement.style.touchAction = "none";
+    this.enabled = true;
+    this.target = new import_three20.Vector3();
+    this.minDistance = 0;
+    this.maxDistance = Infinity;
+    this.minZoom = 0;
+    this.maxZoom = Infinity;
+    this.minPolarAngle = 0;
+    this.maxPolarAngle = Math.PI;
+    this.minAzimuthAngle = -Infinity;
+    this.maxAzimuthAngle = Infinity;
+    this.enableDamping = false;
+    this.dampingFactor = 0.05;
+    this.enableZoom = true;
+    this.zoomSpeed = 1;
+    this.enableRotate = true;
+    this.rotateSpeed = 1;
+    this.enablePan = true;
+    this.panSpeed = 1;
+    this.screenSpacePanning = true;
+    this.keyPanSpeed = 7;
+    this.autoRotate = false;
+    this.autoRotateSpeed = 2;
+    this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
+    this.mouseButtons = { LEFT: import_three20.MOUSE.ROTATE, MIDDLE: import_three20.MOUSE.DOLLY, RIGHT: import_three20.MOUSE.PAN };
+    this.touches = { ONE: import_three20.TOUCH.ROTATE, TWO: import_three20.TOUCH.DOLLY_PAN };
+    this.target0 = this.target.clone();
+    this.position0 = this.object.position.clone();
+    this.zoom0 = this.object.zoom;
+    this._domElementKeyEvents = null;
+    this.getPolarAngle = function() {
+      return spherical.phi;
+    };
+    this.getAzimuthalAngle = function() {
+      return spherical.theta;
+    };
+    this.getDistance = function() {
+      return this.object.position.distanceTo(this.target);
+    };
+    this.saveState = function() {
+      scope.target0.copy(scope.target);
+      scope.position0.copy(scope.object.position);
+      scope.zoom0 = scope.object.zoom;
+    };
+    this.reset = function() {
+      scope.target.copy(scope.target0);
+      scope.object.position.copy(scope.position0);
+      scope.object.zoom = scope.zoom0;
+      scope.object.updateProjectionMatrix();
+      scope.dispatchEvent(_changeEvent);
+      scope.update();
+      state = STATE.NONE;
+    };
+    this.update = function() {
+      const offset = new import_three20.Vector3();
+      const quat = new import_three20.Quaternion().setFromUnitVectors(object.up, new import_three20.Vector3(0, 1, 0));
+      const quatInverse = quat.clone().invert();
+      const lastPosition = new import_three20.Vector3();
+      const lastQuaternion = new import_three20.Quaternion();
+      const twoPI = 2 * Math.PI;
+      return function update() {
+        const position = scope.object.position;
+        offset.copy(position).sub(scope.target);
+        offset.applyQuaternion(quat);
+        spherical.setFromVector3(offset);
+        if (scope.autoRotate && state === STATE.NONE) {
+          rotateLeft(getAutoRotationAngle());
+        }
+        if (scope.enableDamping) {
+          spherical.theta += sphericalDelta.theta * scope.dampingFactor;
+          spherical.phi += sphericalDelta.phi * scope.dampingFactor;
+        } else {
+          spherical.theta += sphericalDelta.theta;
+          spherical.phi += sphericalDelta.phi;
+        }
+        let min = scope.minAzimuthAngle;
+        let max = scope.maxAzimuthAngle;
+        if (isFinite(min) && isFinite(max)) {
+          if (min < -Math.PI) min += twoPI;
+          else if (min > Math.PI) min -= twoPI;
+          if (max < -Math.PI) max += twoPI;
+          else if (max > Math.PI) max -= twoPI;
+          if (min <= max) {
+            spherical.theta = Math.max(min, Math.min(max, spherical.theta));
+          } else {
+            spherical.theta = spherical.theta > (min + max) / 2 ? Math.max(min, spherical.theta) : Math.min(max, spherical.theta);
+          }
+        }
+        spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi));
+        spherical.makeSafe();
+        spherical.radius *= scale;
+        spherical.radius = Math.max(scope.minDistance, Math.min(scope.maxDistance, spherical.radius));
+        if (scope.enableDamping === true) {
+          scope.target.addScaledVector(panOffset, scope.dampingFactor);
+        } else {
+          scope.target.add(panOffset);
+        }
+        offset.setFromSpherical(spherical);
+        offset.applyQuaternion(quatInverse);
+        position.copy(scope.target).add(offset);
+        scope.object.lookAt(scope.target);
+        if (scope.enableDamping === true) {
+          sphericalDelta.theta *= 1 - scope.dampingFactor;
+          sphericalDelta.phi *= 1 - scope.dampingFactor;
+          panOffset.multiplyScalar(1 - scope.dampingFactor);
+        } else {
+          sphericalDelta.set(0, 0, 0);
+          panOffset.set(0, 0, 0);
+        }
+        scale = 1;
+        if (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) {
+          scope.dispatchEvent(_changeEvent);
+          lastPosition.copy(scope.object.position);
+          lastQuaternion.copy(scope.object.quaternion);
+          zoomChanged = false;
+          return true;
+        }
+        return false;
+      };
+    }();
+    this.dispose = function() {
+      scope.domElement.removeEventListener("contextmenu", onContextMenu);
+      scope.domElement.removeEventListener("pointerdown", onPointerDown);
+      scope.domElement.removeEventListener("pointercancel", onPointerCancel);
+      scope.domElement.removeEventListener("wheel", onMouseWheel);
+      scope.domElement.removeEventListener("pointermove", onPointerMove);
+      scope.domElement.removeEventListener("pointerup", onPointerUp);
+      if (scope._domElementKeyEvents !== null) {
+        scope._domElementKeyEvents.removeEventListener("keydown", onKeyDown);
       }
-      panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
-      pan(panDelta.x, panDelta.y);
-      panStart.copy(panEnd);
-    }
-    function handleTouchMoveDolly(event) {
-      const position = getSecondPointerPosition(event);
-      const dx = event.pageX - position.x;
-      const dy = event.pageY - position.y;
-      const distance = Math.sqrt(dx * dx + dy * dy);
-      dollyEnd.set(0, distance);
-      dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed));
-      dollyOut(dollyDelta.y);
-      dollyStart.copy(dollyEnd);
+    };
+    const scope = this;
+    const STATE = {
+      NONE: -1,
+      ROTATE: 0,
+      DOLLY: 1,
+      PAN: 2,
+      TOUCH_ROTATE: 3,
+      TOUCH_PAN: 4,
+      TOUCH_DOLLY_PAN: 5,
+      TOUCH_DOLLY_ROTATE: 6
+    };
+    let state = STATE.NONE;
+    const EPS = 1e-6;
+    const spherical = new import_three20.Spherical();
+    const sphericalDelta = new import_three20.Spherical();
+    let scale = 1;
+    const panOffset = new import_three20.Vector3();
+    let zoomChanged = false;
+    const rotateStart = new import_three20.Vector2();
+    const rotateEnd = new import_three20.Vector2();
+    const rotateDelta = new import_three20.Vector2();
+    const panStart = new import_three20.Vector2();
+    const panEnd = new import_three20.Vector2();
+    const panDelta = new import_three20.Vector2();
+    const dollyStart = new import_three20.Vector2();
+    const dollyEnd = new import_three20.Vector2();
+    const dollyDelta = new import_three20.Vector2();
+    const pointers = [];
+    const pointerPositions = {};
+    function getAutoRotationAngle() {
+      return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
     }
-    function handleTouchMoveDollyPan(event) {
-      if (scope.enableZoom) handleTouchMoveDolly(event);
-      if (scope.enablePan) handleTouchMovePan(event);
+    function getZoomScale() {
+      return Math.pow(0.95, scope.zoomSpeed);
     }
-    function handleTouchMoveDollyRotate(event) {
-      if (scope.enableZoom) handleTouchMoveDolly(event);
-      if (scope.enableRotate) handleTouchMoveRotate(event);
+    function rotateLeft(angle) {
+      sphericalDelta.theta -= angle;
     }
-    function handleTouchEnd() {
+    function rotateUp(angle) {
+      sphericalDelta.phi -= angle;
     }
-    function onPointerDown(event) {
-      if (scope.enabled === false) return;
-      if (pointers.length === 0) {
-        scope.domElement.setPointerCapture(event.pointerId);
-        scope.domElement.addEventListener("pointermove", onPointerMove);
-        scope.domElement.addEventListener("pointerup", onPointerUp);
-      }
-      addPointer(event);
-      if (event.pointerType === "touch") {
-        onTouchStart(event);
+    const panLeft = function() {
+      const v = new import_three20.Vector3();
+      return function panLeft2(distance, objectMatrix) {
+        v.setFromMatrixColumn(objectMatrix, 0);
+        v.multiplyScalar(-distance);
+        panOffset.add(v);
+      };
+    }();
+    const panUp = function() {
+      const v = new import_three20.Vector3();
+      return function panUp2(distance, objectMatrix) {
+        if (scope.screenSpacePanning === true) {
+          v.setFromMatrixColumn(objectMatrix, 1);
+        } else {
+          v.setFromMatrixColumn(objectMatrix, 0);
+          v.crossVectors(scope.object.up, v);
+        }
+        v.multiplyScalar(distance);
+        panOffset.add(v);
+      };
+    }();
+    const pan = function() {
+      const offset = new import_three20.Vector3();
+      return function pan2(deltaX, deltaY) {
+        const element = scope.domElement;
+        if (scope.object.isPerspectiveCamera) {
+          const position = scope.object.position;
+          offset.copy(position).sub(scope.target);
+          let targetDistance = offset.length();
+          targetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180);
+          panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);
+          panUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix);
+        } else if (scope.object.isOrthographicCamera) {
+          panLeft(deltaX * (scope.object.right - scope.object.left) / scope.object.zoom / element.clientWidth, scope.object.matrix);
+          panUp(deltaY * (scope.object.top - scope.object.bottom) / scope.object.zoom / element.clientHeight, scope.object.matrix);
+        } else {
+          console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.");
+          scope.enablePan = false;
+        }
+      };
+    }();
+    function dollyOut(dollyScale) {
+      if (scope.object.isPerspectiveCamera) {
+        scale /= dollyScale;
+      } else if (scope.object.isOrthographicCamera) {
+        scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom * dollyScale));
+        scope.object.updateProjectionMatrix();
+        zoomChanged = true;
       } else {
-        onMouseDown(event);
+        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
+        scope.enableZoom = false;
       }
     }
-    function onPointerMove(event) {
-      if (scope.enabled === false) return;
-      if (event.pointerType === "touch") {
-        onTouchMove(event);
+    function dollyIn(dollyScale) {
+      if (scope.object.isPerspectiveCamera) {
+        scale *= dollyScale;
+      } else if (scope.object.isOrthographicCamera) {
+        scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / dollyScale));
+        scope.object.updateProjectionMatrix();
+        zoomChanged = true;
       } else {
-        onMouseMove(event);
+        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
+        scope.enableZoom = false;
       }
     }
-    function onPointerUp(event) {
-      if (scope.enabled === false) return;
-      if (event.pointerType === "touch") {
-        onTouchEnd();
-      } else {
-        onMouseUp(event);
-      }
-      removePointer(event);
-      if (pointers.length === 0) {
-        scope.domElement.releasePointerCapture(event.pointerId);
-        scope.domElement.removeEventListener("pointermove", onPointerMove);
-        scope.domElement.removeEventListener("pointerup", onPointerUp);
-      }
+    function handleMouseDownRotate(event) {
+      rotateStart.set(event.clientX, event.clientY);
     }
-    function onPointerCancel(event) {
-      removePointer(event);
+    function handleMouseDownDolly(event) {
+      dollyStart.set(event.clientX, event.clientY);
     }
-    function onMouseDown(event) {
-      let mouseAction;
-      switch (event.button) {
-        case 0:
-          mouseAction = scope.mouseButtons.LEFT;
-          break;
-        case 1:
-          mouseAction = scope.mouseButtons.MIDDLE;
-          break;
-        case 2:
-          mouseAction = scope.mouseButtons.RIGHT;
-          break;
-        default:
-          mouseAction = -1;
-      }
-      switch (mouseAction) {
-        case import_three18.MOUSE.DOLLY:
-          if (scope.enableZoom === false) return;
-          handleMouseDownDolly(event);
-          state = STATE.DOLLY;
-          break;
-        case import_three18.MOUSE.ROTATE:
-          if (event.ctrlKey || event.metaKey || event.shiftKey) {
-            if (scope.enablePan === false) return;
-            handleMouseDownPan(event);
-            state = STATE.PAN;
-          } else {
-            if (scope.enableRotate === false) return;
-            handleMouseDownRotate(event);
-            state = STATE.ROTATE;
-          }
-          break;
-        case import_three18.MOUSE.PAN:
-          if (event.ctrlKey || event.metaKey || event.shiftKey) {
-            if (scope.enableRotate === false) return;
-            handleMouseDownRotate(event);
-            state = STATE.ROTATE;
-          } else {
-            if (scope.enablePan === false) return;
-            handleMouseDownPan(event);
-            state = STATE.PAN;
-          }
-          break;
-        default:
-          state = STATE.NONE;
-      }
-      if (state !== STATE.NONE) {
-        scope.dispatchEvent(_startEvent);
-      }
+    function handleMouseDownPan(event) {
+      panStart.set(event.clientX, event.clientY);
     }
-    function onMouseMove(event) {
-      if (scope.enabled === false) return;
-      switch (state) {
-        case STATE.ROTATE:
-          if (scope.enableRotate === false) return;
-          handleMouseMoveRotate(event);
-          break;
-        case STATE.DOLLY:
-          if (scope.enableZoom === false) return;
-          handleMouseMoveDolly(event);
-          break;
-        case STATE.PAN:
-          if (scope.enablePan === false) return;
-          handleMouseMovePan(event);
-          break;
-      }
+    function handleMouseMoveRotate(event) {
+      rotateEnd.set(event.clientX, event.clientY);
+      rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
+      const element = scope.domElement;
+      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
+      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
+      rotateStart.copy(rotateEnd);
+      scope.update();
     }
-    function onMouseUp(event) {
-      handleMouseUp(event);
-      scope.dispatchEvent(_endEvent);
-      state = STATE.NONE;
+    function handleMouseMoveDolly(event) {
+      dollyEnd.set(event.clientX, event.clientY);
+      dollyDelta.subVectors(dollyEnd, dollyStart);
+      if (dollyDelta.y > 0) {
+        dollyOut(getZoomScale());
+      } else if (dollyDelta.y < 0) {
+        dollyIn(getZoomScale());
+      }
+      dollyStart.copy(dollyEnd);
+      scope.update();
     }
-    function onMouseWheel(event) {
-      if (scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE) return;
-      event.preventDefault();
-      scope.dispatchEvent(_startEvent);
-      handleMouseWheel(event);
-      scope.dispatchEvent(_endEvent);
+    function handleMouseMovePan(event) {
+      panEnd.set(event.clientX, event.clientY);
+      panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
+      pan(panDelta.x, panDelta.y);
+      panStart.copy(panEnd);
+      scope.update();
     }
-    function onKeyDown(event) {
-      if (scope.enabled === false || scope.enablePan === false) return;
-      handleKeyDown(event);
+    function handleMouseUp() {
     }
-    function onTouchStart(event) {
-      trackPointer(event);
-      switch (pointers.length) {
-        case 1:
-          switch (scope.touches.ONE) {
-            case import_three18.TOUCH.ROTATE:
-              if (scope.enableRotate === false) return;
-              handleTouchStartRotate();
-              state = STATE.TOUCH_ROTATE;
-              break;
-            case import_three18.TOUCH.PAN:
-              if (scope.enablePan === false) return;
-              handleTouchStartPan();
-              state = STATE.TOUCH_PAN;
-              break;
-            default:
-              state = STATE.NONE;
-          }
-          break;
-        case 2:
-          switch (scope.touches.TWO) {
-            case import_three18.TOUCH.DOLLY_PAN:
-              if (scope.enableZoom === false && scope.enablePan === false) return;
-              handleTouchStartDollyPan();
-              state = STATE.TOUCH_DOLLY_PAN;
-              break;
-            case import_three18.TOUCH.DOLLY_ROTATE:
-              if (scope.enableZoom === false && scope.enableRotate === false) return;
-              handleTouchStartDollyRotate();
-              state = STATE.TOUCH_DOLLY_ROTATE;
-              break;
-            default:
-              state = STATE.NONE;
-          }
-          break;
-        default:
-          state = STATE.NONE;
-      }
-      if (state !== STATE.NONE) {
-        scope.dispatchEvent(_startEvent);
+    function handleMouseWheel(event) {
+      if (event.deltaY < 0) {
+        dollyIn(getZoomScale());
+      } else if (event.deltaY > 0) {
+        dollyOut(getZoomScale());
       }
+      scope.update();
     }
-    function onTouchMove(event) {
-      trackPointer(event);
-      switch (state) {
-        case STATE.TOUCH_ROTATE:
-          if (scope.enableRotate === false) return;
-          handleTouchMoveRotate(event);
-          scope.update();
+    function handleKeyDown(event) {
+      let needsUpdate = false;
+      switch (event.code) {
+        case scope.keys.UP:
+          pan(0, scope.keyPanSpeed);
+          needsUpdate = true;
           break;
-        case STATE.TOUCH_PAN:
-          if (scope.enablePan === false) return;
-          handleTouchMovePan(event);
-          scope.update();
+        case scope.keys.BOTTOM:
+          pan(0, -scope.keyPanSpeed);
+          needsUpdate = true;
           break;
-        case STATE.TOUCH_DOLLY_PAN:
-          if (scope.enableZoom === false && scope.enablePan === false) return;
-          handleTouchMoveDollyPan(event);
-          scope.update();
+        case scope.keys.LEFT:
+          pan(scope.keyPanSpeed, 0);
+          needsUpdate = true;
           break;
-        case STATE.TOUCH_DOLLY_ROTATE:
-          if (scope.enableZoom === false && scope.enableRotate === false) return;
-          handleTouchMoveDollyRotate(event);
-          scope.update();
+        case scope.keys.RIGHT:
+          pan(-scope.keyPanSpeed, 0);
+          needsUpdate = true;
           break;
-        default:
-          state = STATE.NONE;
+      }
+      if (needsUpdate) {
+        event.preventDefault();
+        scope.update();
       }
     }
-    function onTouchEnd(event) {
-      handleTouchEnd(event);
-      scope.dispatchEvent(_endEvent);
-      state = STATE.NONE;
-    }
-    function onContextMenu(event) {
-      if (scope.enabled === false) return;
-      event.preventDefault();
-    }
-    function addPointer(event) {
-      pointers.push(event);
-    }
-    function removePointer(event) {
-      delete pointerPositions[event.pointerId];
-      for (let i = 0; i < pointers.length; i++) {
-        if (pointers[i].pointerId == event.pointerId) {
-          pointers.splice(i, 1);
-          return;
-        }
+    function handleTouchStartRotate() {
+      if (pointers.length === 1) {
+        rotateStart.set(pointers[0].pageX, pointers[0].pageY);
+      } else {
+        const x = 0.5 * (pointers[0].pageX + pointers[1].pageX);
+        const y = 0.5 * (pointers[0].pageY + pointers[1].pageY);
+        rotateStart.set(x, y);
       }
     }
-    function trackPointer(event) {
-      let position = pointerPositions[event.pointerId];
-      if (position === void 0) {
-        position = new import_three18.Vector2();
-        pointerPositions[event.pointerId] = position;
+    function handleTouchStartPan() {
+      if (pointers.length === 1) {
+        panStart.set(pointers[0].pageX, pointers[0].pageY);
+      } else {
+        const x = 0.5 * (pointers[0].pageX + pointers[1].pageX);
+        const y = 0.5 * (pointers[0].pageY + pointers[1].pageY);
+        panStart.set(x, y);
       }
-      position.set(event.pageX, event.pageY);
     }
-    function getSecondPointerPosition(event) {
-      const pointer = event.pointerId === pointers[0].pointerId ? pointers[1] : pointers[0];
-      return pointerPositions[pointer.pointerId];
+    function handleTouchStartDolly() {
+      const dx = pointers[0].pageX - pointers[1].pageX;
+      const dy = pointers[0].pageY - pointers[1].pageY;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      dollyStart.set(0, distance);
     }
-    scope.domElement.addEventListener("contextmenu", onContextMenu);
-    scope.domElement.addEventListener("pointerdown", onPointerDown);
-    scope.domElement.addEventListener("pointercancel", onPointerCancel);
-    scope.domElement.addEventListener("wheel", onMouseWheel, { passive: false });
-    this.update();
-  }
-};
-var MapControls = class extends OrbitControls {
-  constructor(object, domElement) {
-    super(object, domElement);
-    this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three18.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three18.MOUSE.ROTATE;
-    this.touches.ONE = import_three18.TOUCH.PAN;
-    this.touches.TWO = import_three18.TOUCH.DOLLY_ROTATE;
-  }
-};
-
-// src/renderer/Renderer.ts
-var Renderer = class _Renderer {
-  constructor(options) {
-    this._dirty = true;
-    this._resizeListener = void 0;
-    this._disposed = false;
-    this._debugHelpers = [];
-    this._eventDispatchers = /* @__PURE__ */ new Map();
-    this._changeListener = () => {
-      this._dirty = true;
-    };
-    this.options = (0, import_ts_deepmerge9.default)({}, _Renderer.DEFAULT_OPTIONS, options ?? {});
-    this._animationLoop = this.animate.bind(this);
-    this._frameInterval = this.options.render.fpsLimit > 0 ? 1e3 / this.options.render.fpsLimit : void 0;
-    this._scene = this.createScene();
-    this._camera = this.createCamera();
-    this._renderer = this.createRenderer();
-    this._composer = this.createComposer();
-    if (this.options.render.stats) {
-      this._stats = new import_stats.default();
-      document.body.appendChild(this._stats.dom);
+    function handleTouchStartDollyPan() {
+      if (scope.enableZoom) handleTouchStartDolly();
+      if (scope.enablePan) handleTouchStartPan();
     }
-    this.init();
-    this._controls = this.createControls();
-  }
-  static {
-    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
-      camera: {
-        type: "perspective",
-        near: 1,
-        far: 5e3,
-        perspective: {
-          aspect: void 0,
-          fov: 50
-        },
-        orthographic: {
-          left: void 0,
-          right: void 0,
-          top: void 0,
-          bottom: void 0
-        },
-        position: new import_three19.Vector3(50, 50, 50),
-        lookingAt: new import_three19.Vector3(0, 0, 0)
-      },
-      render: {
-        fpsLimit: 60,
-        stats: false,
-        antialias: true,
-        shade: true,
-        autoResize: true,
-        renderAlways: false
-      },
-      composer: {
-        enabled: true
-      },
-      controls: {
-        enabled: false
-      },
-      debug: {
-        grid: false,
-        axes: false
+    function handleTouchStartDollyRotate() {
+      if (scope.enableZoom) handleTouchStartDolly();
+      if (scope.enableRotate) handleTouchStartRotate();
+    }
+    function handleTouchMoveRotate(event) {
+      if (pointers.length == 1) {
+        rotateEnd.set(event.pageX, event.pageY);
+      } else {
+        const position = getSecondPointerPosition(event);
+        const x = 0.5 * (event.pageX + position.x);
+        const y = 0.5 * (event.pageY + position.y);
+        rotateEnd.set(x, y);
       }
-    });
-  }
-  //<editor-fold desc="INIT">
-  createScene() {
-    return new MineRenderScene();
-  }
-  createCamera() {
-    switch (this.options.camera.type) {
-      case "perspective":
-      default:
-        return new import_three19.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_three19.OrthographicCamera(
-          this.options.camera.orthographic.left ?? this.viewWidth / -2,
-          this.options.camera.orthographic.right ?? this.viewWidth / 2,
-          this.options.camera.orthographic.top ?? this.viewHeight / 2,
-          this.options.camera.orthographic.bottom ?? this.viewHeight / -2,
-          this.options.camera.near,
-          this.options.camera.far
-        );
+      rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
+      const element = scope.domElement;
+      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
+      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
+      rotateStart.copy(rotateEnd);
     }
-  }
-  createRenderer() {
-    const renderer = new import_three19.WebGLRenderer({
-      antialias: this.options.render.antialias,
-      alpha: true,
-      powerPreference: "high-performance",
-      depth: true
-    });
-    renderer.setClearColor(0, 0);
-    renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three19.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three19.SRGBColorSpace;
-    renderer.setSize(this.viewWidth, this.viewHeight);
-    return renderer;
-  }
-  createComposer() {
-    if (!this.options.composer.enabled) return void 0;
-    const composer = new import_postprocessing.EffectComposer(this.renderer);
-    composer.setSize(this.viewWidth, this.viewHeight);
-    composer.addPass(new import_postprocessing.RenderPass(this.scene, this.camera));
-    return composer;
-  }
-  createControls() {
-    if (!this.options.controls?.enabled) return void 0;
-    const position = this.camera.position.clone();
-    const controls = new OrbitControls(this.camera, this.renderer.domElement);
-    this.camera.position.copy(position);
-    const target = this.options.camera.lookingAt;
-    if (isVector3(target)) {
-      controls.target.copy(target);
-    } else if (isTripleArray(target)) {
-      controls.target.set(target[0], target[1], target[2]);
-    }
-    controls.update();
-    controls.saveState();
-    this.registerEventDispatcher(controls);
-    return controls;
-  }
-  //</editor-fold>
-  init() {
-    if (this._disposed) return;
-    if (typeof window["__THREE_DEVTOOLS__"] !== "undefined") {
-      window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
+    function handleTouchMovePan(event) {
+      if (pointers.length === 1) {
+        panEnd.set(event.pageX, event.pageY);
+      } else {
+        const position = getSecondPointerPosition(event);
+        const x = 0.5 * (event.pageX + position.x);
+        const y = 0.5 * (event.pageY + position.y);
+        panEnd.set(x, y);
+      }
+      panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
+      pan(panDelta.x, panDelta.y);
+      panStart.copy(panEnd);
+    }
+    function handleTouchMoveDolly(event) {
+      const position = getSecondPointerPosition(event);
+      const dx = event.pageX - position.x;
+      const dy = event.pageY - position.y;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      dollyEnd.set(0, distance);
+      dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed));
+      dollyOut(dollyDelta.y);
+      dollyStart.copy(dollyEnd);
     }
-    if (this.options.debug.grid) {
-      const gridHelper = new import_three19.GridHelper(128, 16);
-      this._debugHelpers.push(gridHelper);
-      this.scene.add(gridHelper);
-      const gridHelper2 = new import_three19.GridHelper(128, 16);
-      this._debugHelpers.push(gridHelper2);
-      gridHelper2.rotation.x = 90 * (Math.PI / 180);
-      this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three19.GridHelper(128, 16);
-      this._debugHelpers.push(gridHelper3);
-      gridHelper3.rotation.z = 90 * (Math.PI / 180);
-      this.scene.add(gridHelper3);
+    function handleTouchMoveDollyPan(event) {
+      if (scope.enableZoom) handleTouchMoveDolly(event);
+      if (scope.enablePan) handleTouchMovePan(event);
     }
-    if (this.options.debug.axes) {
-      const axesHelper = new import_three19.AxesHelper(64);
-      this._debugHelpers.push(axesHelper);
-      this.scene.add(axesHelper);
+    function handleTouchMoveDollyRotate(event) {
+      if (scope.enableZoom) handleTouchMoveDolly(event);
+      if (scope.enableRotate) handleTouchMoveRotate(event);
     }
-    if (this.options.camera.position) {
-      if (isVector3(this.options.camera.position)) {
-        this.camera.position.set(this.options.camera.position.x, this.options.camera.position.y, this.options.camera.position.z);
-      } else if (isTripleArray(this.options.camera.position)) {
-        this.camera.position.set(this.options.camera.position[0], this.options.camera.position[1], this.options.camera.position[2]);
+    function handleTouchEnd() {
+    }
+    function onPointerDown(event) {
+      if (scope.enabled === false) return;
+      if (pointers.length === 0) {
+        scope.domElement.setPointerCapture(event.pointerId);
+        scope.domElement.addEventListener("pointermove", onPointerMove);
+        scope.domElement.addEventListener("pointerup", onPointerUp);
+      }
+      addPointer(event);
+      if (event.pointerType === "touch") {
+        onTouchStart(event);
+      } else {
+        onMouseDown(event);
       }
     }
-    if (this.options.camera.lookingAt) {
-      if (isVector3(this.options.camera.lookingAt)) {
-        this.camera.lookAt(this.options.camera.lookingAt);
-      } else if (isTripleArray(this.options.camera.lookingAt)) {
-        this.camera.lookAt(this.options.camera.lookingAt[0], this.options.camera.lookingAt[1], this.options.camera.lookingAt[2]);
+    function onPointerMove(event) {
+      if (scope.enabled === false) return;
+      if (event.pointerType === "touch") {
+        onTouchMove(event);
+      } else {
+        onMouseMove(event);
       }
     }
-    if (this.options.render.autoResize && !this._resizeListener) {
-      this._resizeListener = () => {
-        this.resize(this.viewWidth, this.viewHeight);
-      };
-      window.addEventListener("resize", this._resizeListener);
+    function onPointerUp(event) {
+      if (scope.enabled === false) return;
+      if (event.pointerType === "touch") {
+        onTouchEnd();
+      } else {
+        onMouseUp(event);
+      }
+      removePointer(event);
+      if (pointers.length === 0) {
+        scope.domElement.releasePointerCapture(event.pointerId);
+        scope.domElement.removeEventListener("pointermove", onPointerMove);
+        scope.domElement.removeEventListener("pointerup", onPointerUp);
+      }
     }
-  }
-  get element() {
-    return this._element;
-  }
-  appendTo(element) {
-    if (this._disposed) return;
-    this._element = element;
-    this._element.appendChild(this.renderer.domElement);
-    if (this.viewWidth == 0) {
-      console.warn("0 element width");
+    function onPointerCancel(event) {
+      removePointer(event);
     }
-    if (this.viewHeight == 0) {
-      console.warn("0 element height");
+    function onMouseDown(event) {
+      let mouseAction;
+      switch (event.button) {
+        case 0:
+          mouseAction = scope.mouseButtons.LEFT;
+          break;
+        case 1:
+          mouseAction = scope.mouseButtons.MIDDLE;
+          break;
+        case 2:
+          mouseAction = scope.mouseButtons.RIGHT;
+          break;
+        default:
+          mouseAction = -1;
+      }
+      switch (mouseAction) {
+        case import_three20.MOUSE.DOLLY:
+          if (scope.enableZoom === false) return;
+          handleMouseDownDolly(event);
+          state = STATE.DOLLY;
+          break;
+        case import_three20.MOUSE.ROTATE:
+          if (event.ctrlKey || event.metaKey || event.shiftKey) {
+            if (scope.enablePan === false) return;
+            handleMouseDownPan(event);
+            state = STATE.PAN;
+          } else {
+            if (scope.enableRotate === false) return;
+            handleMouseDownRotate(event);
+            state = STATE.ROTATE;
+          }
+          break;
+        case import_three20.MOUSE.PAN:
+          if (event.ctrlKey || event.metaKey || event.shiftKey) {
+            if (scope.enableRotate === false) return;
+            handleMouseDownRotate(event);
+            state = STATE.ROTATE;
+          } else {
+            if (scope.enablePan === false) return;
+            handleMouseDownPan(event);
+            state = STATE.PAN;
+          }
+          break;
+        default:
+          state = STATE.NONE;
+      }
+      if (state !== STATE.NONE) {
+        scope.dispatchEvent(_startEvent);
+      }
     }
-    this.resize(this.viewWidth, this.viewHeight);
-  }
-  /**
-   * Redraws when the dispatcher emits the selected event. Registering the same pair twice has no effect.
-   * The renderer removes its listener on disposal; the caller retains ownership of the dispatcher.
-   */
-  registerEventDispatcher(dispatcher, changeEvent2 = "change") {
-    if (this._disposed) return;
-    let events = this._eventDispatchers.get(dispatcher);
-    if (!events) {
-      events = /* @__PURE__ */ new Set();
-      this._eventDispatchers.set(dispatcher, events);
+    function onMouseMove(event) {
+      if (scope.enabled === false) return;
+      switch (state) {
+        case STATE.ROTATE:
+          if (scope.enableRotate === false) return;
+          handleMouseMoveRotate(event);
+          break;
+        case STATE.DOLLY:
+          if (scope.enableZoom === false) return;
+          handleMouseMoveDolly(event);
+          break;
+        case STATE.PAN:
+          if (scope.enablePan === false) return;
+          handleMouseMovePan(event);
+          break;
+      }
     }
-    if (events.has(changeEvent2)) return;
-    events.add(changeEvent2);
-    dispatcher.addEventListener(changeEvent2, this._changeListener);
-  }
-  resize(width, height) {
-    if (this._disposed) return;
-    if (isPerspectiveCamera(this.camera)) {
-      this.camera.aspect = width / height;
-      this.camera.updateProjectionMatrix();
-    } else if (isOrthographicCamera(this.camera)) {
-      this.camera.left = width / -2;
-      this.camera.right = width / 2;
-      this.camera.top = height / 2;
-      this.camera.bottom = height / -2;
-      this.camera.updateProjectionMatrix();
+    function onMouseUp(event) {
+      handleMouseUp(event);
+      scope.dispatchEvent(_endEvent);
+      state = STATE.NONE;
     }
-    this.renderer.setSize(width, height);
-    this.composer?.setSize(width, height);
-    this._dirty = true;
-  }
-  //<editor-fold desc="RENDER">
-  get dirty() {
-    return this._dirty || this.scene.dirty;
-  }
-  set dirty(dirty) {
-    this._dirty = dirty;
-    this.scene.dirty = dirty;
-  }
-  start() {
-    if (this._disposed) return;
-    this.stop();
-    this.renderer.setAnimationLoop(this._animationLoop);
-  }
-  stop() {
-    if (this._disposed) return;
-    this.renderer.setAnimationLoop(null);
-    this._nextFrameTime = void 0;
-  }
-  /**
-   * Stops rendering and releases owned resources. Repeated calls have no effect, and a disposed
-   * renderer cannot be restarted. Scene objects are detached; shared assets and caller-owned
-   * controls must be managed by their owners.
-   */
-  dispose() {
-    if (this._disposed) return;
-    this.stop();
-    this._disposed = true;
-    if (this._resizeListener) {
-      window.removeEventListener("resize", this._resizeListener);
-      this._resizeListener = void 0;
+    function onMouseWheel(event) {
+      if (scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE) return;
+      event.preventDefault();
+      scope.dispatchEvent(_startEvent);
+      handleMouseWheel(event);
+      scope.dispatchEvent(_endEvent);
     }
-    for (const [dispatcher, events] of this._eventDispatchers) {
-      for (const event of events) {
-        dispatcher.removeEventListener(event, this._changeListener);
+    function onKeyDown(event) {
+      if (scope.enabled === false || scope.enablePan === false) return;
+      handleKeyDown(event);
+    }
+    function onTouchStart(event) {
+      trackPointer(event);
+      switch (pointers.length) {
+        case 1:
+          switch (scope.touches.ONE) {
+            case import_three20.TOUCH.ROTATE:
+              if (scope.enableRotate === false) return;
+              handleTouchStartRotate();
+              state = STATE.TOUCH_ROTATE;
+              break;
+            case import_three20.TOUCH.PAN:
+              if (scope.enablePan === false) return;
+              handleTouchStartPan();
+              state = STATE.TOUCH_PAN;
+              break;
+            default:
+              state = STATE.NONE;
+          }
+          break;
+        case 2:
+          switch (scope.touches.TWO) {
+            case import_three20.TOUCH.DOLLY_PAN:
+              if (scope.enableZoom === false && scope.enablePan === false) return;
+              handleTouchStartDollyPan();
+              state = STATE.TOUCH_DOLLY_PAN;
+              break;
+            case import_three20.TOUCH.DOLLY_ROTATE:
+              if (scope.enableZoom === false && scope.enableRotate === false) return;
+              handleTouchStartDollyRotate();
+              state = STATE.TOUCH_DOLLY_ROTATE;
+              break;
+            default:
+              state = STATE.NONE;
+          }
+          break;
+        default:
+          state = STATE.NONE;
+      }
+      if (state !== STATE.NONE) {
+        scope.dispatchEvent(_startEvent);
       }
     }
-    this._eventDispatchers.clear();
-    this._stats?.dom.remove();
-    this._stats = void 0;
-    this.renderer.domElement.remove();
-    this._element = void 0;
-    if (this._controls) {
-      const controls = this._controls;
-      this._controls = void 0;
-      controls.enabled = false;
-      controls.dispose();
-    }
-    this.scene.clear();
-    for (const helper of this._debugHelpers) {
-      helper.geometry.dispose();
-      const materials = Array.isArray(helper.material) ? helper.material : [helper.material];
-      for (const material of materials) {
-        material.dispose();
+    function onTouchMove(event) {
+      trackPointer(event);
+      switch (state) {
+        case STATE.TOUCH_ROTATE:
+          if (scope.enableRotate === false) return;
+          handleTouchMoveRotate(event);
+          scope.update();
+          break;
+        case STATE.TOUCH_PAN:
+          if (scope.enablePan === false) return;
+          handleTouchMovePan(event);
+          scope.update();
+          break;
+        case STATE.TOUCH_DOLLY_PAN:
+          if (scope.enableZoom === false && scope.enablePan === false) return;
+          handleTouchMoveDollyPan(event);
+          scope.update();
+          break;
+        case STATE.TOUCH_DOLLY_ROTATE:
+          if (scope.enableZoom === false && scope.enableRotate === false) return;
+          handleTouchMoveDollyRotate(event);
+          scope.update();
+          break;
+        default:
+          state = STATE.NONE;
       }
     }
-    this._debugHelpers.length = 0;
-    this.composer?.dispose();
-    this.renderer.dispose();
-    this.renderer.forceContextLoss();
-  }
-  animate(t = performance.now()) {
-    if (this._disposed) return;
-    if (this._controls?.enabled) {
-      this._controls.update();
-    }
-    if (this._disposed) return;
-    if (!this.dirty && !this.options.render.renderAlways) return;
-    const interval = this._frameInterval;
-    if (interval) {
-      const next = this._nextFrameTime;
-      if (next !== void 0 && t + 0.1 < next) return;
-      this._nextFrameTime = next !== void 0 && t - next < interval ? next + interval : t + interval;
-    }
-    if (this._stats) {
-      this._stats.begin();
-    }
-    if (this.options.composer.enabled && this.composer) {
-      this.composer.render();
-    } else {
-      this.renderer.render(this.scene, this.camera);
+    function onTouchEnd(event) {
+      handleTouchEnd(event);
+      scope.dispatchEvent(_endEvent);
+      state = STATE.NONE;
     }
-    this.dirty = false;
-    if (this._stats) {
-      this._stats.end();
+    function onContextMenu(event) {
+      if (scope.enabled === false) return;
+      event.preventDefault();
     }
-  }
-  //</editor-fold>
-  toImage() {
-    return this.renderer.domElement.toDataURL();
-  }
-  ///
-  get attachedToBody() {
-    return this.element === document.body;
-  }
-  get viewWidth() {
-    return this.attachedToBody ? window.innerWidth : this.element?.offsetWidth || 0;
-  }
-  get viewHeight() {
-    return this.attachedToBody ? window.innerHeight : this.element?.offsetHeight || 0;
-  }
-  get scene() {
-    return this._scene;
-  }
-  get camera() {
-    return this._camera;
-  }
-  get renderer() {
-    return this._renderer;
-  }
-  get composer() {
-    return this._composer;
-  }
-  /** Renderer-owned controls, or undefined when disabled at construction or after disposal. */
-  get controls() {
-    return this._controls;
-  }
-  ///
-};
-
-// src/skin/Skins.ts
-var Skins = class {
-  //<editor-fold desc="Skins">
-  static async fromUuidOrUsername(uuidOrUsername) {
-    if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
-      return this.fromUuid(uuidOrUsername);
+    function addPointer(event) {
+      pointers.push(event);
     }
-    return this.fromUsername(uuidOrUsername);
-  }
-  static async fromUuid(uuid) {
-    return this.getSkinProxySkinUrl(uuid);
-  }
-  static async fromUsername(username) {
-    return this.usernameToUuid(username).then((uuid) => {
-      if (uuid) {
-        return this.fromUuid(uuid);
-      }
-      return void 0;
-    });
-  }
-  static async fromMineSkin(mineskinId) {
-    return this.getMineSkin(mineskinId).then((mineskin) => {
-      if (mineskin) {
-        return mineskin["data"]["texture"]["value"]["urls"]["skins"];
+    function removePointer(event) {
+      delete pointerPositions[event.pointerId];
+      for (let i = 0; i < pointers.length; i++) {
+        if (pointers[i].pointerId == event.pointerId) {
+          pointers.splice(i, 1);
+          return;
+        }
       }
-      return void 0;
-    });
-  }
-  //</editor-fold>
-  //<editor-fold desc="Capes">
-  static async capeFromUuidOrUsername(uuidOrUsername) {
-    if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
-      return this.capeFromUuid(uuidOrUsername);
     }
-    return this.capeFromUsername(uuidOrUsername);
-  }
-  static async capeFromUuid(uuid) {
-    return this.getSkinProxyCapeUrl(uuid);
-  }
-  static async capeFromUsername(username) {
-    return this.usernameToUuid(username).then((uuid) => {
-      if (uuid) {
-        return this.capeFromUuid(uuid);
-      }
-      return void 0;
-    });
-  }
-  static async capeFromCapesDev(uuid, capeType = "minecraft") {
-    return this.getCapesDev(uuid, capeType).then((cape) => {
-      if (cape) {
-        return cape?.stillImageUrl;
-      }
-      return void 0;
-    });
-  }
-  //</editor-fold>
-  //<editor-fold desc="Helpers">
-  static async usernameToUuid(username) {
-    return this.usernameToUuidSkinProxy(username);
-  }
-  static async usernameToUuidSkinProxy(username) {
-    return Requests.genericRequest({
-      baseURL: "https://minecraft-skin-proxy.inventive.workers.dev",
-      url: "/uuid/" + username
-    }).then((res) => {
-      if (res.status === 200) {
-        return res.data["id"];
-      }
-      return void 0;
-    }).catch((err) => {
-      console.warn(err);
-      return void 0;
-    });
-  }
-  static async usernameToUuidMineTools(username) {
-    return Requests.genericRequest({
-      baseURL: "https://api.minetools.eu",
-      url: "/uuid/" + username
-    }).then((res) => {
-      if (res.status === 200) {
-        return res.data["id"];
-      }
-      return void 0;
-    }).catch((err) => {
-      console.warn(err);
-      return void 0;
-    });
-  }
-  static async getProfileFromMinetools(uuid) {
-    return Requests.genericRequest({
-      baseURL: "https://api.minetools.eu",
-      url: "/profile/" + uuid
-    }).then((res) => {
-      if (res.status === 200) {
-        return res.data;
-      }
-    });
-  }
-  static async getMineSkin(mineskinId) {
-    return Requests.genericRequest({
-      baseURL: "https://api.mineskin.org",
-      url: "/get/uuid/" + mineskinId
-    }).then((res) => {
-      if (res.status === 200) {
-        return res.data;
-      }
-      return void 0;
-    }).catch((err) => {
-      console.warn(err);
-      return void 0;
-    });
-  }
-  static async getCapesDev(uuid, type = "all") {
-    return Requests.genericRequest({
-      baseURL: "https://api.capes.dev",
-      url: "/load/" + uuid + "/" + type
-    }).then((res) => {
-      if (res.status === 200) {
-        return res.data;
+    function trackPointer(event) {
+      let position = pointerPositions[event.pointerId];
+      if (position === void 0) {
+        position = new import_three20.Vector2();
+        pointerPositions[event.pointerId] = position;
       }
-      return void 0;
-    }).catch((err) => {
-      console.warn(err);
-      return void 0;
-    });
-  }
-  static getCrafatarSkinUrl(uuid) {
-    return "https://crafatar.com/skins/" + uuid;
-  }
-  static getCrafatarCapeUrl(uuid) {
-    return "https://crafatar.com/capes/" + uuid;
-  }
-  static getMcHeadsSkinUrl(uuid) {
-    return "https://mc-heads.net/skin/" + uuid;
-  }
-  static getMineSkinPlayerSkinUrl(uuid) {
-    return "https://mineskin.org/skin/player/" + uuid;
-  }
-  static getSkinProxySkinUrl(uuid) {
-    return "https://minecraft-skin-proxy.inventive.workers.dev/skin/" + uuid;
+      position.set(event.pageX, event.pageY);
+    }
+    function getSecondPointerPosition(event) {
+      const pointer = event.pointerId === pointers[0].pointerId ? pointers[1] : pointers[0];
+      return pointerPositions[pointer.pointerId];
+    }
+    scope.domElement.addEventListener("contextmenu", onContextMenu);
+    scope.domElement.addEventListener("pointerdown", onPointerDown);
+    scope.domElement.addEventListener("pointercancel", onPointerCancel);
+    scope.domElement.addEventListener("wheel", onMouseWheel, { passive: false });
+    this.update();
   }
-  static getSkinProxyCapeUrl(uuid) {
-    return "https://minecraft-skin-proxy.inventive.workers.dev/cape/" + uuid;
+};
+var MapControls = class extends OrbitControls {
+  constructor(object, domElement) {
+    super(object, domElement);
+    this.screenSpacePanning = false;
+    this.mouseButtons.LEFT = import_three20.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three20.MOUSE.ROTATE;
+    this.touches.ONE = import_three20.TOUCH.PAN;
+    this.touches.TWO = import_three20.TOUCH.DOLLY_ROTATE;
   }
-  //</editor-fold>
 };
 
 // src/world/Chunk.ts
@@ -6884,7 +6671,7 @@ var MineRenderWorld = class {
     console.log("CHUNKS", this._chunks);
     for (let chunk of this._chunks.values()) {
       console.log("dispose chunk", chunk);
-      await chunk?.dispose();
+      await (chunk == null ? void 0 : chunk.dispose());
     }
     this._chunks.clear();
   }
@@ -6938,7 +6725,7 @@ var MineRenderWorld = class {
 };
 
 // src/world/Chunk.ts
-var p11 = prefix("Chunk");
+var p12 = prefix("Chunk");
 var Chunk = class _Chunk {
   constructor(scene, x, y, z) {
     this._blocks = [];
@@ -6990,7 +6777,7 @@ var Chunk = class _Chunk {
     const index = _Chunk.chunkPosToBlockIndex(pos);
     const current = this._blocks[index];
     if (typeof current !== "undefined") {
-      console.debug(p11, "deleting existing block at", pos, worldPos, index);
+      console.debug(p12, "deleting existing block at", pos, worldPos, index);
       current.object.removeFromScene();
       delete this._blocks[index];
     }
@@ -7057,7 +6844,6 @@ var Chunk = class _Chunk {
   AXES,
   ArchiveAssetSource,
   AssetKey,
-  AssetLoadError,
   AssetLoader,
   AssetParser,
   AssetSource,
@@ -7115,7 +6901,6 @@ var Chunk = class _Chunk {
   OrbitControls,
   PersistentCache,
   Renderer,
-  RequestError,
   Requests,
   SKIN_PARTS,
   SceneInspector,