npm - @needle-tools/gltf-progressive - Versions diffs - 3.6.0 → 3.6.2 - Mend

@needle-tools/gltf-progressive 3.6.0 → 3.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/gltf-progressive.js CHANGED Viewed

@@ -1,64 +1,70 @@
-import * as Xe from "three";
-import { RedFormat as je, RedIntegerFormat as Ke, RGFormat as Ye, RGIntegerFormat as He, RGBFormat as Qe, RGBAFormat as Je, RGBAIntegerFormat as Ze, BufferGeometry as j, Mesh as K, Box3 as ue, Vector3 as k, Sphere as Ae, CompressedTexture as et, Texture as q, Matrix3 as tt, InterleavedBuffer as st, InterleavedBufferAttribute as rt, BufferAttribute as nt, TextureLoader as it, Color as Ie, Matrix4 as $e } from "three";
-import { GLTFLoader as De } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { MeshoptDecoder as ot } from "three/examples/jsm/libs/meshopt_decoder.module.js";
-import { DRACOLoader as at } from "three/examples/jsm/loaders/DRACOLoader.js";
-import { KTX2Loader as lt } from "three/examples/jsm/loaders/KTX2Loader.js";
-const ut = "";
-globalThis.GLTF_PROGRESSIVE_VERSION = ut;
+import * as je from "three";
+import { RedFormat as Ke, RedIntegerFormat as Ye, RGFormat as He, RGIntegerFormat as Qe, RGBFormat as Je, RGBAFormat as Ze, RGBAIntegerFormat as et, BufferGeometry as Y, Mesh as H, Box3 as ce, Vector3 as A, Sphere as Ge, CompressedTexture as tt, Texture as W, Matrix3 as st, InterleavedBuffer as rt, InterleavedBufferAttribute as nt, BufferAttribute as it, TextureLoader as ot, Color as Be, Matrix4 as qe } from "three";
+import { GLTFLoader as Me } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { MeshoptDecoder as at } from "three/examples/jsm/libs/meshopt_decoder.module.js";
+import { DRACOLoader as lt } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { KTX2Loader as ut } from "three/examples/jsm/loaders/KTX2Loader.js";
+const ct = "";
+globalThis.GLTF_PROGRESSIVE_VERSION = ct;
 console.debug("[gltf-progressive] version -");
-let $ = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", Y = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
-const ct = $, ft = Y, Be = new URL($ + "draco_decoder.js");
-Be.searchParams.append("range", "true");
-fetch(Be, {
+let q = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", Q = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
+const ft = q, dt = Q, We = new URL(q + "draco_decoder.js");
+We.searchParams.append("range", "true");
+fetch(We, {
   method: "GET",
   headers: {
     Range: "bytes=0-1"
   }
 }).catch((i) => {
-  console.debug(`Failed to fetch remote Draco decoder from ${$} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), $ === ct && ht("./include/draco/"), Y === ft && gt("./include/ktx2/");
+  console.debug(`Failed to fetch remote Draco decoder from ${q} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), q === ft && gt("./include/draco/"), Q === dt && pt("./include/ktx2/");
 }).finally(() => {
-  qe();
+  be && Te();
 });
-const dt = () => ({
-  dracoDecoderPath: $,
-  ktx2TranscoderPath: Y
+const ht = () => ({
+  dracoDecoderPath: q,
+  ktx2TranscoderPath: Q
 });
-function ht(i) {
-  $ = i, C && C[ye] != $ ? (console.debug("Updating Draco decoder path to " + i), C[ye] = $, C.setDecoderPath($), C.preload()) : console.debug("Setting Draco decoder path to " + i);
-}
 function gt(i) {
-  Y = i, B && B.transcoderPath != Y ? (console.debug("Updating KTX2 transcoder path to " + i), B.setTranscoderPath(Y), B.init()) : console.debug("Setting KTX2 transcoder path to " + i);
+  q = i, C && C[xe] != q ? (console.debug("Updating Draco decoder path to " + i), C[xe] = q, C.setDecoderPath(q), C.preload()) : console.debug("Setting Draco decoder path to " + i);
+}
+function pt(i) {
+  Q = i, B && B.transcoderPath != Q ? (console.debug("Updating KTX2 transcoder path to " + i), B.setTranscoderPath(Q), B.init()) : console.debug("Setting KTX2 transcoder path to " + i);
 }
 function _e(i) {
-  return qe(), i ? B.detectSupport(i) : i !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: C, ktx2Loader: B, meshoptDecoder: le };
+  be = !0;
+  const t = Te();
+  return i ? t.ktx2Loader.detectSupport(i) : i !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), t;
+}
+function es() {
+  be = !1, C?.dispose(), B?.dispose(), C = void 0, B = void 0;
 }
-function Ge(i) {
-  i.dracoLoader || i.setDRACOLoader(C), i.ktx2Loader || i.setKTX2Loader(B), i.meshoptDecoder || i.setMeshoptDecoder(le);
+function Fe(i) {
+  const { dracoLoader: t, ktx2Loader: e, meshoptDecoder: s } = Te();
+  i.dracoLoader || i.setDRACOLoader(t), i.ktx2Loader || i.setKTX2Loader(e), i.meshoptDecoder || i.setMeshoptDecoder(s);
 }
-const ye = /* @__PURE__ */ Symbol("dracoDecoderPath");
-let C, le, B;
-function qe() {
-  C || (C = new at(), C[ye] = $, C.setDecoderPath($), C.setDecoderConfig({ type: "js" }), C.preload()), B || (B = new lt(), B.setTranscoderPath(Y), B.init()), le || (le = ot);
+const xe = /* @__PURE__ */ Symbol("dracoDecoderPath");
+let be = !0, C, fe, B;
+function Te() {
+  return C || (C = new lt(), C[xe] = q, C.setDecoderPath(q), C.setDecoderConfig({ type: "js" }), C.preload()), B || (B = new ut(), B.setTranscoderPath(Q), B.init()), fe || (fe = at), { dracoLoader: C, ktx2Loader: B, meshoptDecoder: fe };
 }
-const xe = /* @__PURE__ */ new WeakMap();
-function We(i, t) {
-  let e = xe.get(i);
-  e ? e = Object.assign(e, t) : e = t, xe.set(i, e);
+const Le = /* @__PURE__ */ new WeakMap();
+function Ue(i, t) {
+  let e = Le.get(i);
+  e ? e = Object.assign(e, t) : e = t, Le.set(i, e);
 }
-const pt = De.prototype.load;
-function mt(...i) {
-  const t = xe.get(this);
+const mt = Me.prototype.load;
+function yt(...i) {
+  const t = Le.get(this);
   let e = i[0];
-  const s = yt(e);
+  const s = xt(e);
   if (s?.hostname.endsWith("needle.tools")) {
     const n = t?.progressive !== void 0 ? t.progressive : !0, o = t?.usecase ? t.usecase : "default";
     n ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${o}` : this.requestHeader.Accept = `*/*;usecase=${o}`, e = s.toString();
   }
-  return i[0] = e, pt?.call(this, ...i);
+  return i[0] = e, mt?.call(this, ...i);
 }
-De.prototype.load = mt;
-function yt(i) {
+Me.prototype.load = yt;
+function xt(i) {
   try {
     if (i instanceof URL)
       return i;
@@ -68,32 +74,32 @@ function yt(i) {
     return null;
   }
 }
-function Te(i) {
+function Re(i) {
   return i != null && i.data != null;
 }
-function Le(i) {
+function we(i) {
   const t = i.source?.data;
   return t != null && typeof t == "object" ? t : null;
 }
-function xt(i) {
+function Lt(i) {
   const t = i.image;
   return t != null && typeof t == "object" ? t : null;
 }
-function we(i) {
-  const t = xt(i), e = Le(i);
+function ve(i) {
+  const t = Lt(i), e = we(i);
   return {
     width: t?.width || e?.width || 0,
     height: t?.height || e?.height || 0
   };
 }
-V("debugprogressive");
-function V(i) {
+X("debugprogressive");
+function X(i) {
   const t = globalThis.location?.href;
   if (!t) return !1;
   const s = new URL(t).searchParams.get(i);
   return s == null || s === "0" || s === "false" ? !1 : s === "" ? !0 : s;
 }
-function Lt(i, t) {
+function wt(i, t) {
   if (t === void 0 || i === void 0 || t.startsWith("./") || t.startsWith("http") || t.startsWith("data:") || t.startsWith("blob:"))
     return t;
   const e = i.lastIndexOf("/");
@@ -104,19 +110,19 @@ function Lt(i, t) {
   }
   return t;
 }
-function Me() {
-  if (Z !== void 0) return Z;
+function Oe() {
+  if (se !== void 0) return se;
   const i = globalThis.navigator?.userAgent || "";
-  return Z = /iPhone|iPad|iPod|Android|IEMobile/i.test(i), V("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", Z), Z;
+  return se = /iPhone|iPad|iPod|Android|IEMobile/i.test(i), X("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", se), se;
 }
-let Z;
-function Fe() {
+let se;
+function ze() {
   const i = globalThis.location?.href;
   if (!i) return !1;
   const t = new URL(i), e = t.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(t.hostname);
   return t.hostname === "127.0.0.1" || e;
 }
-class wt {
+class vt {
   constructor(t, e = {}) {
     this.maxConcurrent = t, this.debug = e.debug ?? !1, typeof globalThis.requestAnimationFrame == "function" ? globalThis.requestAnimationFrame(this.tick) : setTimeout(this.tick, 0);
   }
@@ -150,83 +156,83 @@ class wt {
     }
   }
 }
-function vt(i) {
-  const t = i.image, e = t?.width ?? 0, s = t?.height ?? 0, r = t?.depth ?? 1, n = Math.floor(Math.log2(Math.max(e, s, r))) + 1, o = Dt(i);
+function Dt(i) {
+  const t = i.image, e = t?.width ?? 0, s = t?.height ?? 0, r = t?.depth ?? 1, n = Math.floor(Math.log2(Math.max(e, s, r))) + 1, o = Mt(i);
   return e * s * r * o * (1 - Math.pow(0.25, n)) / (1 - 0.25);
 }
-function Dt(i) {
+function Mt(i) {
   let t = 4;
   const e = i.format;
-  e === je || e === Ke ? t = 1 : e === Ye || e === He ? t = 2 : e === Qe || e === 1029 ? t = 3 : (e === Je || e === Ze) && (t = 4);
+  e === Ke || e === Ye ? t = 1 : e === He || e === Qe ? t = 2 : e === Je || e === 1029 ? t = 3 : (e === Ze || e === et) && (t = 4);
   let s = 1;
   const r = i.type;
   return r === 1009 || r === 1010 ? s = 1 : r === 1011 || r === 1012 ? s = 2 : r === 1013 || r === 1014 || r === 1015 ? s = 4 : r === 1016 && (s = 2), t * s;
 }
-const _t = typeof window > "u" && typeof document > "u", ve = /* @__PURE__ */ Symbol("needle:raycast-mesh");
-function ne(i) {
-  return i?.[ve] instanceof j ? i[ve] : null;
+const _t = typeof window > "u" && typeof document > "u", De = /* @__PURE__ */ Symbol("needle:raycast-mesh");
+function ae(i) {
+  return i?.[De] instanceof Y ? i[De] : null;
 }
-function Mt(i, t) {
-  if ((i.type === "Mesh" || i.type === "SkinnedMesh") && !ne(i)) {
-    const s = Tt(t);
-    s.userData = { isRaycastMesh: !0 }, i[ve] = s;
+function bt(i, t) {
+  if ((i.type === "Mesh" || i.type === "SkinnedMesh") && !ae(i)) {
+    const s = Ot(t);
+    s.userData = { isRaycastMesh: !0 }, i[De] = s;
   }
 }
-function bt(i = !0) {
+function Tt(i = !0) {
   if (i) {
-    if (ee) return;
-    const t = ee = K.prototype.raycast;
-    K.prototype.raycast = function(e, s) {
-      const r = this, n = ne(r);
+    if (re) return;
+    const t = re = H.prototype.raycast;
+    H.prototype.raycast = function(e, s) {
+      const r = this, n = ae(r);
       let o;
       n && r.isMesh && (o = r.geometry, r.geometry = n), t.call(this, e, s), o && (r.geometry = o);
     };
   } else {
-    if (!ee) return;
-    K.prototype.raycast = ee, ee = null;
+    if (!re) return;
+    H.prototype.raycast = re, re = null;
   }
 }
-let ee = null;
-function Tt(i) {
-  const t = new j();
+let re = null;
+function Ot(i) {
+  const t = new Y();
   for (const e in i.attributes)
     t.setAttribute(e, i.getAttribute(e));
   return t.setIndex(i.getIndex()), t;
 }
-const F = new Array(), h = V("debugprogressive");
-let re, X = -1;
-if (h && typeof window < "u") {
+const U = new Array(), g = X("debugprogressive");
+let oe, K = -1;
+if (g && typeof window < "u") {
   let i = function() {
-    X += 1, X >= t && (X = -1), console.log(`Toggle LOD level [${X}]`);
+    K += 1, K >= t && (K = -1), console.log(`Toggle LOD level [${K}]`);
   };
   const t = 6;
   window.addEventListener("keyup", (e) => {
-    e.key === "p" && i(), e.key === "w" && (re = !re, console.log(`Toggle wireframe [${re}]`));
+    e.key === "p" && i(), e.key === "w" && (oe = !oe, console.log(`Toggle wireframe [${oe}]`));
     const s = parseInt(e.key);
-    !isNaN(s) && s >= 0 && (X = s, console.log(`Set LOD level to [${X}]`));
+    !isNaN(s) && s >= 0 && (K = s, console.log(`Set LOD level to [${K}]`));
   });
 }
-function Ue(i) {
-  if (h && re !== void 0)
+function Ee(i) {
+  if (g && oe !== void 0)
     if (Array.isArray(i))
       for (const t of i)
-        Ue(t);
-    else i && "wireframe" in i && (i.wireframe = re === !0);
+        Ee(t);
+    else i && "wireframe" in i && (i.wireframe = oe === !0);
 }
-const te = new Array();
-let Ot = 0;
-const St = Me() ? 2 : 10;
-function Rt(i) {
-  if (te.length < St) {
-    const s = te.length;
-    h && console.warn(`[Worker] Creating new worker #${s}`);
-    const r = be.createWorker(i || {});
-    return te.push(r), r;
-  }
-  const t = Ot++ % te.length;
-  return te[t];
+const ne = new Array();
+let St = 0;
+const Rt = Oe() ? 2 : 10;
+function Ct(i) {
+  if (ne.length < Rt) {
+    const s = ne.length;
+    g && console.warn(`[Worker] Creating new worker #${s}`);
+    const r = Se.createWorker(i || {});
+    return ne.push(r), r;
+  }
+  const t = St++ % ne.length;
+  return ne[t];
 }
-class be {
+class Se {
   constructor(t, e) {
     this.worker = t, this._debug = e.debug ?? !1, t.onmessage = (s) => {
       const r = s.data;
@@ -234,7 +240,7 @@ class be {
         case "loaded-gltf":
           for (const n of this._running)
             if (n.url === r.result.url) {
-              Ct(r.result), n.resolve(r.result);
+              Pt(r.result), n.resolve(r.result);
               const o = n.url;
               o.startsWith("blob:") && URL.revokeObjectURL(o);
             }
@@ -253,18 +259,18 @@ class be {
     ), {
       type: "module"
     });
-    return new be(e, t);
+    return new Se(e, t);
   }
   _running = [];
   _webglRenderer = null;
   async load(t, e) {
-    const s = dt();
+    const s = ht();
     let r = e?.renderer;
     r || (this._webglRenderer ??= (async () => {
       const { WebGLRenderer: u } = await import("three");
       return new u();
     })(), r = await this._webglRenderer);
-    const a = _e(r).ktx2Loader.workerConfig;
+    const l = _e(r).ktx2Loader.workerConfig;
     if (t instanceof URL)
       t = t.toString();
     else if (t.startsWith("file:"))
@@ -273,14 +279,14 @@ class be {
       const u = globalThis.location?.href;
       u && (t = new URL(t, u).toString());
     }
-    const l = {
+    const a = {
       type: "load",
       url: t,
       dracoDecoderPath: s.dracoDecoderPath,
       ktx2TranscoderPath: s.ktx2TranscoderPath,
-      ktx2LoaderConfig: a
+      ktx2LoaderConfig: l
     };
-    return this._debug && console.debug("[Worker] Sending load request", l), this.worker.postMessage(l), new Promise((u) => {
+    return this._debug && console.debug("[Worker] Sending load request", a), this.worker.postMessage(a), new Promise((u) => {
       this._running.push({
         url: t.toString(),
         resolve: u
@@ -289,32 +295,32 @@ class be {
   }
   _debug = !1;
 }
-function Ct(i) {
+function Pt(i) {
   for (const t of i.geometries) {
-    const e = t.geometry, s = new j();
+    const e = t.geometry, s = new Y();
     if (s.name = e.name || "", e.index) {
       const r = e.index;
-      s.setIndex(fe(r));
+      s.setIndex(de(r));
     }
     for (const r in e.attributes) {
-      const n = e.attributes[r], o = fe(n);
+      const n = e.attributes[r], o = de(n);
       s.setAttribute(r, o);
     }
     if (e.morphAttributes)
       for (const r in e.morphAttributes) {
-        const o = e.morphAttributes[r].map((a) => fe(a));
+        const o = e.morphAttributes[r].map((l) => de(l));
         s.morphAttributes[r] = o;
       }
-    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new ue(), s.boundingBox.min = new k(
+    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new ce(), s.boundingBox.min = new A(
       e.boundingBox?.min.x,
       e.boundingBox?.min.y,
       e.boundingBox?.min.z
-    ), s.boundingBox.max = new k(
+    ), s.boundingBox.max = new A(
       e.boundingBox?.max.x,
       e.boundingBox?.max.y,
       e.boundingBox?.max.z
-    ), s.boundingSphere = new Ae(
-      new k(
+    ), s.boundingSphere = new Ge(
+      new A(
         e.boundingSphere?.center.x,
         e.boundingSphere?.center.y,
         e.boundingSphere?.center.z
@@ -329,8 +335,8 @@ function Ct(i) {
     const e = t.texture;
     let s = null;
     if (e.isCompressedTexture) {
-      const r = e.mipmaps, { width: n, height: o } = we(e);
-      s = new et(
+      const r = e.mipmaps, { width: n, height: o } = ve(e);
+      s = new tt(
         r,
         n,
         o,
@@ -345,7 +351,7 @@ function Ct(i) {
         e.colorSpace
       );
     } else
-      s = new q(
+      s = new W(
         e.image,
         e.mapping,
         e.wrapS,
@@ -356,7 +362,7 @@ function Ct(i) {
         e.type,
         e.anisotropy,
         e.colorSpace
-      ), s.mipmaps = e.mipmaps, s.channel = e.channel, s.source.data = e.source.data, s.flipY = e.flipY, s.premultiplyAlpha = e.premultiplyAlpha, s.unpackAlignment = e.unpackAlignment, s.matrix = new tt(...e.matrix.elements);
+      ), s.mipmaps = e.mipmaps, s.channel = e.channel, s.source.data = e.source.data, s.flipY = e.flipY, s.premultiplyAlpha = e.premultiplyAlpha, s.unpackAlignment = e.unpackAlignment, s.matrix = new st(...e.matrix.elements);
     if (!s) {
       console.error("[Worker] Failed to create new texture from received data. Texture is not a CompressedTexture or Texture.");
       continue;
@@ -365,21 +371,21 @@ function Ct(i) {
   }
   return i;
 }
-function fe(i) {
+function de(i) {
   let t = i;
   if ("isInterleavedBufferAttribute" in i && i.isInterleavedBufferAttribute) {
-    const e = i.data, s = e.array, r = new st(s, e.stride);
-    t = new rt(r, i.itemSize, s.byteOffset, i.normalized), t.offset = i.offset;
-  } else "isBufferAttribute" in i && i.isBufferAttribute && (t = new nt(i.array, i.itemSize, i.normalized), t.usage = i.usage, t.gpuType = i.gpuType, t.updateRanges = i.updateRanges);
+    const e = i.data, s = e.array, r = new rt(s, e.stride);
+    t = new nt(r, i.itemSize, s.byteOffset, i.normalized), t.offset = i.offset;
+  } else "isBufferAttribute" in i && i.isBufferAttribute && (t = new it(i.array, i.itemSize, i.normalized), t.usage = i.usage, t.gpuType = i.gpuType, t.updateRanges = i.updateRanges);
   return t;
 }
-const Pt = V("gltf-progressive-worker");
-V("gltf-progressive-reduce-mipmaps");
-const se = V("gltf-progressive-gc"), de = /* @__PURE__ */ Symbol("needle-progressive-texture"), U = "NEEDLE_progressive";
-class g {
+const kt = X("gltf-progressive-worker");
+X("gltf-progressive-reduce-mipmaps");
+const ie = X("gltf-progressive-gc"), he = /* @__PURE__ */ Symbol("needle-progressive-texture"), z = "NEEDLE_progressive";
+class p {
   /** The name of the extension */
   get name() {
-    return U;
+    return z;
   }
   // #region PUBLIC API
   /**
@@ -421,33 +427,33 @@ class g {
       max_count: 0,
       lods: []
     }), Array.isArray(t)) {
-      for (const a of t)
-        this.getMaterialMinMaxLODsCount(a, e);
+      for (const l of t)
+        this.getMaterialMinMaxLODsCount(l, e);
       return t[r] = e, e;
     }
-    if (h === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
-      const a = t;
-      for (const l of Object.keys(a.uniforms)) {
-        const u = a.uniforms[l].value;
+    if (g === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
+      const l = t;
+      for (const a of Object.keys(l.uniforms)) {
+        const u = l.uniforms[a].value;
         u?.isTexture === !0 && o(u, e);
       }
     } else if (t.isMaterial)
-      for (const a of Object.keys(t)) {
-        const l = t[a];
-        l?.isTexture === !0 && o(l, e);
+      for (const l of Object.keys(t)) {
+        const a = t[l];
+        a?.isTexture === !0 && o(a, e);
       }
     else
-      h && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
+      g && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
     return t[r] = e, e;
-    function o(a, l) {
-      const u = s.getAssignedLODInformation(a);
+    function o(l, a) {
+      const u = s.getAssignedLODInformation(l);
       if (u) {
-        const f = s.lodInfos.get(u.key);
-        if (f && f.lods) {
-          l.min_count = Math.min(l.min_count, f.lods.length), l.max_count = Math.max(l.max_count, f.lods.length);
-          for (let c = 0; c < f.lods.length; c++) {
-            const d = f.lods[c];
-            d.width && (l.lods[c] = l.lods[c] || { min_height: 1 / 0, max_height: 0 }, l.lods[c].min_height = Math.min(l.lods[c].min_height, d.height), l.lods[c].max_height = Math.max(l.lods[c].max_height, d.height));
+        const d = s.lodInfos.get(u.key);
+        if (d && d.lods) {
+          a.min_count = Math.min(a.min_count, d.lods.length), a.max_count = Math.max(a.max_count, d.lods.length);
+          for (let c = 0; c < d.lods.length; c++) {
+            const f = d.lods[c];
+            f.width && (a.lods[c] = a.lods[c] || { min_height: 1 / 0, max_height: 0 }, a.lods[c].min_height = Math.min(a.lods[c].min_height, f.height), a.lods[c].max_height = Math.max(a.lods[c].max_height, f.height));
           }
         }
       }
@@ -501,25 +507,25 @@ class g {
    */
   static assignMeshLOD(t, e, s) {
     if (!t) return Promise.resolve(null);
-    if (t instanceof K || t.isMesh === !0) {
+    if (t instanceof H || t.isMesh === !0) {
       const r = t.geometry, n = this.getAssignedLODInformation(r);
       if (!n)
         return Promise.resolve(null);
-      for (const a of F)
-        a.onBeforeGetLODMesh?.(t, e);
+      for (const l of U)
+        l.onBeforeGetLODMesh?.(t, e);
       t["LOD:requested level"] = e;
       const o = () => t["LOD:requested level"] === e || this.shouldApplyStaleMeshLOD(t, e);
-      return g.getOrLoadLOD(r, e, {
+      return p.getOrLoadLOD(r, e, {
         isCurrent: o
-      }).then((a) => {
-        if (Array.isArray(a)) {
+      }).then((l) => {
+        if (Array.isArray(l)) {
           const u = n.index || 0;
-          a = a[u];
+          l = l[u];
         }
-        const l = t["LOD:requested level"] === e;
-        return (l || this.shouldApplyStaleMeshLOD(t, e)) && (l && delete t["LOD:requested level"], a && r != a && (a?.isBufferGeometry ? typeof s?.apply == "function" ? s.apply(a, e, t) : s?.apply !== !1 && (t.geometry = a) : h && console.error("Invalid LOD geometry", a))), a;
-      }).catch((a) => (console.error("Error loading mesh LOD", t, a), null));
-    } else h && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
+        const a = t["LOD:requested level"] === e;
+        return (a || this.shouldApplyStaleMeshLOD(t, e)) && (a && delete t["LOD:requested level"], l && r != l && (l?.isBufferGeometry ? typeof s?.apply == "function" ? s.apply(l, e, t) : s?.apply !== !1 && (t.geometry = l) : g && console.error("Invalid LOD geometry", l))), l;
+      }).catch((l) => (console.error("Error loading mesh LOD", t, l), null));
+    } else g && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
     return Promise.resolve(null);
   }
   static assignTextureLOD(t, e = 0, s) {
@@ -529,48 +535,48 @@ class g {
       const n = t;
       if (Array.isArray(n.material)) {
         const o = new Array();
-        for (const a of n.material) {
-          const l = this.assignTextureLOD(a, e, s);
-          o.push(l);
+        for (const l of n.material) {
+          const a = this.assignTextureLOD(l, e, s);
+          o.push(a);
         }
-        return Promise.all(o).then((a) => {
-          const l = new Array();
-          for (const u of a)
-            Array.isArray(u) && l.push(...u);
-          return l;
+        return Promise.all(o).then((l) => {
+          const a = new Array();
+          for (const u of l)
+            Array.isArray(u) && a.push(...u);
+          return a;
         });
       } else
         return this.assignTextureLOD(n.material, e, s);
     }
     if (t.isMaterial === !0) {
-      const n = t, o = [], a = new Array();
+      const n = t, o = [], l = new Array();
       if (this.trackCurrentMaterialTextureSlots(n), n.uniforms && (n.isRawShaderMaterial || n.isShaderMaterial === !0)) {
-        const l = n;
-        for (const u of Object.keys(l.uniforms)) {
-          const f = l.uniforms[u].value;
-          if (f?.isTexture === !0) {
-            const c = this.assignTextureLODForSlot(f, e, n, u, r).then((d) => (d && l.uniforms[u].value != d && (l.uniforms[u].value = d, l.uniformsNeedUpdate = !0), d));
-            o.push(c), a.push(u);
+        const a = n;
+        for (const u of Object.keys(a.uniforms)) {
+          const d = a.uniforms[u].value;
+          if (d?.isTexture === !0) {
+            const c = this.assignTextureLODForSlot(d, e, n, u, r).then((f) => (f && a.uniforms[u].value != f && (a.uniforms[u].value = f, a.uniformsNeedUpdate = !0), f));
+            o.push(c), l.push(u);
           }
         }
       } else
-        for (const l of Object.keys(n)) {
-          const u = n[l];
+        for (const a of Object.keys(n)) {
+          const u = n[a];
           if (u?.isTexture === !0) {
-            const f = this.assignTextureLODForSlot(u, e, n, l, r);
-            o.push(f), a.push(l);
+            const d = this.assignTextureLODForSlot(u, e, n, a, r);
+            o.push(d), l.push(a);
           }
         }
-      return Promise.all(o).then((l) => {
+      return Promise.all(o).then((a) => {
         const u = new Array();
-        for (let f = 0; f < l.length; f++) {
-          const c = l[f], d = a[f];
-          c && c.isTexture === !0 ? u.push({ material: n, slot: d, texture: c, level: e }) : u.push({ material: n, slot: d, texture: null, level: e });
+        for (let d = 0; d < a.length; d++) {
+          const c = a[d], f = l[d];
+          c && c.isTexture === !0 ? u.push({ material: n, slot: f, texture: c, level: e }) : u.push({ material: n, slot: f, texture: null, level: e });
         }
         return u;
       });
     }
-    if (t instanceof q || t.isTexture === !0) {
+    if (t instanceof W || t.isTexture === !0) {
       const n = t;
       return this.assignTextureLODForSlot(n, e, null, null, r);
     }
@@ -581,10 +587,10 @@ class g {
    * @default 50 on desktop, 20 on mobile devices
    */
   static set maxConcurrentLoadingTasks(t) {
-    g.queue.maxConcurrent = t;
+    p.queue.maxConcurrent = t;
   }
   static get maxConcurrentLoadingTasks() {
-    return g.queue.maxConcurrent;
+    return p.queue.maxConcurrent;
   }
   // #region INTERNAL
   static assignTextureLODForSlot(t, e, s, r, n) {
@@ -600,27 +606,27 @@ class g {
       if (c && c.level === e && c.force === n)
         return c.promise;
     }
-    const a = s && r ? this.nextTextureSlotRequestId(s, r, e, n) : 0, l = () => !s || !r || this.getLatestTextureSlotRequest(s, r)?.id === a, u = () => l() || this.shouldApplyStaleTextureSlotLOD(s, r, e, n), f = g.getOrLoadLOD(t, e, {
+    const l = s && r ? this.nextTextureSlotRequestId(s, r, e, n) : 0, a = () => !s || !r || this.getLatestTextureSlotRequest(s, r)?.id === l, u = () => a() || this.shouldApplyStaleTextureSlotLOD(s, r, e, n), d = p.getOrLoadLOD(t, e, {
       isCurrent: u
     }).then((c) => {
-      if (!l() && !this.shouldApplyStaleTextureSlotLOD(s, r, e, n)) return null;
+      if (!a() && !this.shouldApplyStaleTextureSlotLOD(s, r, e, n)) return null;
       if (Array.isArray(c))
         return console.warn("Progressive: Got an array of textures for a texture slot, this should not happen..."), null;
       if (c?.isTexture === !0) {
         if (c != t && s && r) {
-          const d = this.getMaterialTextureSlot(s, r) ?? t;
-          if (d && !n) {
-            const p = this.getAssignedLODInformation(d);
-            if (p && p?.level < e)
-              return h === "verbose" && console.warn("Assigned texture level is already higher: ", p.level, e, s, d, c), null;
+          const f = this.getMaterialTextureSlot(s, r) ?? t;
+          if (f && !n) {
+            const h = this.getAssignedLODInformation(f);
+            if (h && h?.level < e)
+              return g === "verbose" && console.warn("Assigned texture level is already higher: ", h.level, e, s, f, c), null;
           }
           this.assignTrackedTextureSlot(s, r, c);
         }
         return c;
-      } else h == "verbose" && console.warn("No LOD found for", t, e);
+      } else g == "verbose" && console.warn("No LOD found for", t, e);
       return null;
     }).catch((c) => (console.error("Error loading LOD", t, c), null));
-    return s && r && this.setPendingTextureSlotRequest(s, r, e, n, a, f), f;
+    return s && r && this.setPendingTextureSlotRequest(s, r, e, n, l, d), d;
   }
   // Track material slots, not just texture objects. A shared fallback texture can be
   // referenced by many slots and should only be disposed after every slot moved away.
@@ -656,8 +662,8 @@ class g {
   }
   static shouldApplyStaleTextureSlotLOD(t, e, s, r) {
     if (!t || !e) return !1;
-    const n = this.getLatestTextureSlotRequest(t, e), o = this.getMaterialTextureSlot(t, e), a = this.getAssignedLODInformation(o)?.level ?? 1 / 0;
-    return s >= a ? !1 : r ? n ? s >= n.level : !1 : !0;
+    const n = this.getLatestTextureSlotRequest(t, e), o = this.getMaterialTextureSlot(t, e), l = this.getAssignedLODInformation(o)?.level ?? 1 / 0;
+    return s >= l ? !1 : r ? n ? s >= n.level : !1 : !0;
   }
   static shouldApplyStaleMeshLOD(t, e) {
     const s = t["LOD:requested level"];
@@ -666,11 +672,11 @@ class g {
     return e < r && e >= s;
   }
   static setPendingTextureSlotRequest(t, e, s, r, n, o) {
-    let a = this.pendingTextureSlotRequests.get(t);
-    a || (a = /* @__PURE__ */ new Map(), this.pendingTextureSlotRequests.set(t, a));
-    const l = { level: s, force: r, id: n, promise: o };
-    a.set(e, l), o.finally(() => {
-      a.get(e)?.id === n && a.delete(e);
+    let l = this.pendingTextureSlotRequests.get(t);
+    l || (l = /* @__PURE__ */ new Map(), this.pendingTextureSlotRequests.set(t, l));
+    const a = { level: s, force: r, id: n, promise: o };
+    l.set(e, a), o.finally(() => {
+      l.get(e)?.id === n && l.delete(e);
     });
   }
   static getMaterialTextureSlot(t, e) {
@@ -703,7 +709,7 @@ class g {
   }
   static releaseTrackedTextureSlot(t, e, s) {
     const r = this.trackedTextureSlots.get(t);
-    if (r?.get(e) === s && r.delete(e), this.untrackTextureUsage(s) && (h || se)) {
+    if (r?.get(e) === s && r.delete(e), this.untrackTextureUsage(s) && (g || ie)) {
       const o = this.getAssignedLODInformation(s);
       console.log(`[gltf-progressive] Disposed old texture LOD ${o?.level ?? "?"} for ${t.name || t.type}.${e}`, s.uuid);
     }
@@ -712,13 +718,13 @@ class g {
   url;
   constructor(t) {
     const e = t.options.path;
-    h && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
+    g && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
   }
   _isLoadingMesh;
   loadMesh = (t) => {
     if (this._isLoadingMesh) return null;
-    const e = this.parser.json.meshes[t]?.extensions?.[U];
-    return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((s) => (this._isLoadingMesh = !1, s && g.registerMesh(this.url, e.guid, s, e.lods?.length, 0, e), s))) : null;
+    const e = this.parser.json.meshes[t]?.extensions?.[z];
+    return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((s) => (this._isLoadingMesh = !1, s && p.registerMesh(this.url, e.guid, s, e.lods?.length, 0, e), s))) : null;
   };
   // private _isLoadingTexture;
   // loadTexture = (textureIndex: number) => {
@@ -735,30 +741,30 @@ class g {
   //     });
   // }
   afterRoot(t) {
-    return h && console.log("AFTER", this.url, t), this.parser.json.textures?.forEach((e, s) => {
+    return g && console.log("AFTER", this.url, t), this.parser.json.textures?.forEach((e, s) => {
       if (e?.extensions) {
-        const r = e?.extensions[U];
+        const r = e?.extensions[z];
         if (r) {
           if (!r.lods) {
-            h && console.warn("Texture has no LODs", r);
+            g && console.warn("Texture has no LODs", r);
             return;
           }
           let n = !1;
           for (const o of this.parser.associations.keys())
-            o.isTexture === !0 && this.parser.associations.get(o)?.textures === s && (n = !0, g.registerTexture(this.url, o, r.lods?.length, s, r));
+            o.isTexture === !0 && this.parser.associations.get(o)?.textures === s && (n = !0, p.registerTexture(this.url, o, r.lods?.length, s, r));
           n || this.parser.getDependency("texture", s).then((o) => {
-            o && g.registerTexture(this.url, o, r.lods?.length, s, r);
+            o && p.registerTexture(this.url, o, r.lods?.length, s, r);
           });
         }
       }
     }), this.parser.json.meshes?.forEach((e, s) => {
       if (e?.extensions) {
-        const r = e?.extensions[U];
+        const r = e?.extensions[z];
         if (r && r.lods) {
           for (const n of this.parser.associations.keys())
             if (n.isMesh) {
               const o = this.parser.associations.get(n);
-              o?.meshes === s && g.registerMesh(this.url, r.guid, n, r.lods.length, o.primitives, r);
+              o?.meshes === s && p.registerMesh(this.url, r.guid, n, r.lods.length, o.primitives, r);
             }
         }
       }
@@ -777,16 +783,16 @@ class g {
    */
   static registerTexture = (t, e, s, r, n) => {
     if (!e) {
-      h && console.error("!! gltf-progressive: Called register texture without texture");
+      g && console.error("!! gltf-progressive: Called register texture without texture");
       return;
     }
-    if (h) {
-      const { width: a, height: l } = we(e);
-      console.log(`> gltf-progressive: register texture[${r}] "${e.name || e.uuid}", Current: ${a}x${l}, Max: ${n.lods[0]?.width}x${n.lods[0]?.height}, uuid: ${e.uuid}`, n, e);
+    if (g) {
+      const { width: l, height: a } = ve(e);
+      console.log(`> gltf-progressive: register texture[${r}] "${e.name || e.uuid}", Current: ${l}x${a}, Max: ${n.lods[0]?.width}x${n.lods[0]?.height}, uuid: ${e.uuid}`, n, e);
     }
-    e.source && (e.source[de] = n);
+    e.source && (e.source[he] = n);
     const o = n.guid;
-    g.assignLODInformation(t, e, o, s, r), g.lodInfos.set(o, n), g.lowresCache.set(o, new WeakRef(e));
+    p.assignLODInformation(t, e, o, s, r), p.lodInfos.set(o, n), p.lowresCache.set(o, new WeakRef(e));
   };
   /**
    * Register a mesh with progressive LOD information. This associates the mesh geometry with its LOD extension data
@@ -802,16 +808,16 @@ class g {
    * @param ext - The parsed progressive mesh extension data containing all available LOD levels with vertex/index counts and densities.
    */
   static registerMesh = (t, e, s, r, n, o) => {
-    const a = s.geometry;
-    if (!a) {
-      h && console.warn("gltf-progressive: Register mesh without geometry");
+    const l = s.geometry;
+    if (!l) {
+      g && console.warn("gltf-progressive: Register mesh without geometry");
       return;
     }
-    a.userData || (a.userData = {}), h && console.log("> Progressive: register mesh " + s.name, { index: n, uuid: s.uuid }, o, s), g.assignLODInformation(t, a, e, r, n), g.lodInfos.set(e, o);
-    let u = g.lowresCache.get(e)?.deref();
-    u ? u.push(s.geometry) : u = [s.geometry], g.lowresCache.set(e, new WeakRef(u)), r > 0 && !ne(s) && Mt(s, a);
-    for (const f of F)
-      f.onRegisteredNewMesh?.(s, o);
+    l.userData || (l.userData = {}), g && console.log("> Progressive: register mesh " + s.name, { index: n, uuid: s.uuid }, o, s), p.assignLODInformation(t, l, e, r, n), p.lodInfos.set(e, o);
+    let u = p.lowresCache.get(e)?.deref();
+    u ? u.push(s.geometry) : u = [s.geometry], p.lowresCache.set(e, new WeakRef(u)), r > 0 && !ae(s) && bt(s, l);
+    for (const d of U)
+      d.onRegisteredNewMesh?.(s, o);
   };
   /**
    * Dispose cached resources to free memory.
@@ -838,7 +844,7 @@ class g {
       for (const [s, r] of this.cache)
         s.includes(t) && (this._disposeCacheEntry(r), this.cache.delete(s));
     } else {
-      this.lodInfos.clear();
+      this.cacheGeneration++, this.lodInfos.clear();
       for (const [, e] of this.lowresCache) {
         const s = e.deref();
         if (s) {
@@ -861,7 +867,7 @@ class g {
       const e = t.deref();
       e && (e.isTexture && this.textureRefCounts.delete(e.uuid), e.dispose());
     } else
-      t.then((e) => {
+      this.disposedRequests.add(t), t.then((e) => {
         if (e)
           if (Array.isArray(e))
             for (const s of e) s.dispose();
@@ -884,16 +890,16 @@ class g {
    * The held value is the cache key string used in `previouslyLoaded`.
    */
   static _resourceRegistry = new FinalizationRegistry((t) => {
-    const e = g.cache.get(t);
-    (h || se) && console.debug(`[gltf-progressive] Memory: Resource GC'd
-${t}`), e instanceof WeakRef && (e.deref() || (g.cache.delete(t), (h || se) && console.log("[gltf-progressive] ↪ Cache entry deleted (GC)")));
+    const e = p.cache.get(t);
+    (g || ie) && console.debug(`[gltf-progressive] Memory: Resource GC'd
+${t}`), e instanceof WeakRef && (e.deref() || (p.cache.delete(t), (g || ie) && console.log("[gltf-progressive] ↪ Cache entry deleted (GC)")));
   });
   /**
    * Track texture usage by incrementing reference count
    */
   static trackTextureUsage(t) {
     const e = t.uuid, s = this.textureRefCounts.get(e) || 0;
-    this.textureRefCounts.set(e, s + 1), h === "verbose" && console.log(`[gltf-progressive] Track texture ${e}, refCount: ${s} → ${s + 1}`);
+    this.textureRefCounts.set(e, s + 1), g === "verbose" && console.log(`[gltf-progressive] Track texture ${e}, refCount: ${s} → ${s + 1}`);
   }
   /**
    * Untrack texture usage by decrementing reference count.
@@ -903,155 +909,166 @@ ${t}`), e instanceof WeakRef && (e.deref() || (g.cache.delete(t), (h || se) && c
   static untrackTextureUsage(t) {
     const e = t.uuid, s = this.textureRefCounts.get(e);
     if (!s)
-      return (h === "verbose" || se) && n("[gltf-progressive] Memory: Untrack untracked texture (dispose immediately)", 0), t.dispose(), !0;
+      return (g === "verbose" || ie) && n("[gltf-progressive] Memory: Untrack untracked texture (dispose immediately)", 0), t.dispose(), !0;
     const r = s - 1;
     if (r <= 0)
-      return this.textureRefCounts.delete(e), (h || se) && n("[gltf-progressive] Memory: Dispose texture", r), t.dispose(), !0;
-    return this.textureRefCounts.set(e, r), h === "verbose" && n("[gltf-progressive] Memory: Untrack texture", r), !1;
-    function n(o, a) {
-      let { width: l, height: u } = we(t);
-      const f = l && u ? `${l}x${u}` : "N/A";
+      return this.textureRefCounts.delete(e), (g || ie) && n("[gltf-progressive] Memory: Dispose texture", r), t.dispose(), !0;
+    return this.textureRefCounts.set(e, r), g === "verbose" && n("[gltf-progressive] Memory: Untrack texture", r), !1;
+    function n(o, l) {
+      let { width: a, height: u } = ve(t);
+      const d = a && u ? `${a}x${u}` : "N/A";
       let c = "N/A";
-      l && u && (c = `~${(vt(t) / (1024 * 1024)).toFixed(2)} MB`), console.log(`${o} — ${t.name} ${f} (${c}), refCount: ${s} → ${a}
+      a && u && (c = `~${(Dt(t) / (1024 * 1024)).toFixed(2)} MB`), console.log(`${o} — ${t.name} ${d} (${c}), refCount: ${s} → ${l}
 ${e}`);
     }
   }
   static workers = [];
+  static cacheGeneration = 0;
+  static disposedRequests = /* @__PURE__ */ new WeakSet();
   static _workersIndex = 0;
   static async getOrLoadLOD(t, e, s) {
-    const r = h == "verbose", n = this.getAssignedLODInformation(t);
-    if (!n)
-      return h && console.warn(`[gltf-progressive] No LOD information found: ${t.name}, uuid: ${t.uuid}, type: ${t.type}`, t), null;
-    const o = n?.key;
+    const r = this.cacheGeneration, n = g == "verbose", o = this.getAssignedLODInformation(t);
+    if (!o)
+      return g && console.warn(`[gltf-progressive] No LOD information found: ${t.name}, uuid: ${t.uuid}, type: ${t.type}`, t), null;
+    const l = o?.key;
     let a;
     if (t.isTexture === !0) {
-      const u = t;
-      u.source && u.source[de] && (a = u.source[de]);
+      const d = t;
+      d.source && d.source[he] && (a = d.source[he]);
     }
-    if (a || (a = g.lodInfos.get(o)), !a)
-      h && console.warn(`Can not load LOD ${e}: no LOD info found for "${o}" ${t.name}`, t.type, g.lodInfos);
+    if (a || (a = p.lodInfos.get(l)), !a)
+      g && console.warn(`Can not load LOD ${e}: no LOD info found for "${l}" ${t.name}`, t.type, p.lodInfos);
     else {
       if (e > 0) {
-        let c = !1;
-        const d = Array.isArray(a.lods);
-        if (d && e >= a.lods.length ? c = !0 : d || (c = !0), c) {
-          const p = this.lowresCache.get(o);
-          if (p) {
-            const b = p.deref();
-            if (b) return b;
-            this.lowresCache.delete(o), h && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${o}`);
+        let f = !1;
+        const h = Array.isArray(a.lods);
+        if (h && e >= a.lods.length ? f = !0 : h || (f = !0), f) {
+          const D = this.lowresCache.get(l);
+          if (D) {
+            const L = D.deref();
+            if (L) return L;
+            this.lowresCache.delete(l), g && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${l}`);
           }
           return null;
         }
       }
-      const u = Array.isArray(a.lods) ? a.lods[e]?.path : a.lods;
-      if (!u)
-        return h && !a["missing:uri"] && (a["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, a)), null;
-      const f = Lt(n.url, u);
-      if (f.endsWith(".glb") || f.endsWith(".gltf")) {
+      const d = Array.isArray(a.lods) ? a.lods[e]?.path : a.lods;
+      if (!d)
+        return g && !a["missing:uri"] && (a["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, a)), null;
+      const c = wt(o.url, d);
+      if (c.endsWith(".glb") || c.endsWith(".gltf")) {
         if (!a.guid)
           return console.warn("missing pointer for glb/gltf texture", a), null;
-        const c = f + "_" + a.guid, d = await this.tryResolveLODCacheEntry(this.cache.get(c), c, f, t, e, r);
-        if (d.found) return d.value;
+        const f = c + "_" + a.guid, h = await this.tryResolveLODCacheEntry(this.cache.get(f), f, c, t, e, n);
+        if (r !== this.cacheGeneration) return null;
+        if (h.found) return h.value;
         if (s?.isCurrent?.() === !1)
-          return r && console.log(`Skipping stale LOD ${e} request before queue: ${f}`), null;
-        const p = await this.queue.slot(f);
+          return n && console.log(`Skipping stale LOD ${e} request before queue: ${c}`), null;
+        const D = await this.queue.slot(c);
+        if (r !== this.cacheGeneration) return null;
         if (s?.isCurrent?.() === !1)
-          return r && console.log(`Skipping stale LOD ${e} request after queue: ${f}`), null;
-        const b = await this.tryResolveLODCacheEntry(this.cache.get(c), c, f, t, e, r);
-        if (b.found) return b.value;
-        if (!p.use)
-          return h && console.log(`LOD ${e} was aborted: ${f}`), null;
-        const y = a, x = new Promise(async (L, z) => {
-          if (Pt) {
-            const m = await (await Rt({})).load(f);
+          return n && console.log(`Skipping stale LOD ${e} request after queue: ${c}`), null;
+        const L = await this.tryResolveLODCacheEntry(this.cache.get(f), f, c, t, e, n);
+        if (r !== this.cacheGeneration) return null;
+        if (L.found) return L.value;
+        const x = this.cache.get(f);
+        if (x !== void 0) {
+          const y = await this.tryResolveLODCacheEntry(x, f, c, t, e, n);
+          if (r !== this.cacheGeneration) return null;
+          if (y.found) return y.value;
+        }
+        if (!D.use)
+          return g && console.log(`LOD ${e} was aborted: ${c}`), null;
+        const w = a, M = new Promise(async (y, O) => {
+          if (kt) {
+            const m = await (await Ct({})).load(c);
             if (m.textures.length > 0)
-              for (const D of m.textures) {
-                let M = D.texture;
-                return g.assignLODInformation(n.url, M, o, e, void 0), t instanceof q && (M = this.copySettings(t, M)), M && (M.guid = y.guid), L(M);
+              for (const v of m.textures) {
+                let S = v.texture;
+                return p.assignLODInformation(o.url, S, l, e, void 0), t instanceof W && (S = this.copySettings(t, S)), S && (S.guid = w.guid), y(S);
               }
             if (m.geometries.length > 0) {
-              const D = new Array();
-              for (const M of m.geometries) {
-                const G = M.geometry;
-                g.assignLODInformation(n.url, G, o, e, M.primitiveIndex), D.push(G);
+              const v = new Array();
+              for (const S of m.geometries) {
+                const j = S.geometry;
+                p.assignLODInformation(o.url, j, l, e, S.primitiveIndex), v.push(j);
               }
-              return L(D);
+              return y(v);
             }
-            return L(null);
+            return y(null);
           }
-          const v = new De();
-          Ge(v), h && (await new Promise((_) => setTimeout(_, 1e3)), r && console.warn("Start loading (delayed) " + f, y.guid));
-          let T = f;
-          if (y && Array.isArray(y.lods)) {
-            const _ = y.lods[e];
-            _.hash && (T += "?v=" + _.hash);
+          const I = new Me();
+          Fe(I), g && (await new Promise((b) => setTimeout(b, 1e3)), n && console.warn("Start loading (delayed) " + c, w.guid));
+          let P = c;
+          if (w && Array.isArray(w.lods)) {
+            const b = w.lods[e];
+            b.hash && (P += "?v=" + b.hash);
           }
-          const O = await v.loadAsync(T).catch((_) => (console.error(`Error loading LOD ${e} from ${f}
-`, _), L(null)));
-          if (!O)
-            return L(null);
-          const P = O.parser;
-          r && console.log("Loading finished " + f, y.guid);
-          let S = 0;
-          if (O.parser.json.textures) {
-            let _ = !1;
-            for (const m of O.parser.json.textures) {
+          const _ = await I.loadAsync(P).catch((b) => (console.error(`Error loading LOD ${e} from ${c}
+`, b), y(null)));
+          if (!_)
+            return y(null);
+          const E = _.parser;
+          n && console.log("Loading finished " + c, w.guid);
+          let k = 0;
+          if (_.parser.json.textures) {
+            let b = !1;
+            for (const m of _.parser.json.textures) {
               if (m?.extensions) {
-                const D = m?.extensions[U];
-                if (D?.guid && D.guid === y.guid) {
-                  _ = !0;
+                const v = m?.extensions[z];
+                if (v?.guid && v.guid === w.guid) {
+                  b = !0;
                   break;
                 }
               }
-              S++;
+              k++;
             }
-            if (_) {
-              let m = await P.getDependency("texture", S);
-              return m && g.assignLODInformation(n.url, m, o, e, void 0), r && console.log('change "' + t.name + '" → "' + m.name + '"', f, S, m, c), t instanceof q && (m = this.copySettings(t, m)), m && (m.guid = y.guid), L(m);
-            } else h && console.warn("Could not find texture with guid", y.guid, O.parser.json);
+            if (b) {
+              let m = await E.getDependency("texture", k);
+              return m && p.assignLODInformation(o.url, m, l, e, void 0), n && console.log('change "' + t.name + '" → "' + m.name + '"', c, k, m, f), t instanceof W && (m = this.copySettings(t, m)), m && (m.guid = w.guid), y(m);
+            } else g && console.warn("Could not find texture with guid", w.guid, _.parser.json);
           }
-          if (S = 0, O.parser.json.meshes) {
-            let _ = !1;
-            for (const m of O.parser.json.meshes) {
+          if (k = 0, _.parser.json.meshes) {
+            let b = !1;
+            for (const m of _.parser.json.meshes) {
               if (m?.extensions) {
-                const D = m?.extensions[U];
-                if (D?.guid && D.guid === y.guid) {
-                  _ = !0;
+                const v = m?.extensions[z];
+                if (v?.guid && v.guid === w.guid) {
+                  b = !0;
                   break;
                 }
               }
-              S++;
+              k++;
             }
-            if (_) {
-              const m = await P.getDependency("mesh", S);
-              if (r && console.log(`Loaded Mesh "${m.name}"`, f, S, m, c), m.isMesh === !0) {
-                const D = m.geometry;
-                return g.assignLODInformation(n.url, D, o, e, 0), L(D);
+            if (b) {
+              const m = await E.getDependency("mesh", k);
+              if (n && console.log(`Loaded Mesh "${m.name}"`, c, k, m, f), m.isMesh === !0) {
+                const v = m.geometry;
+                return p.assignLODInformation(o.url, v, l, e, 0), y(v);
               } else {
-                const D = new Array();
-                for (let M = 0; M < m.children.length; M++) {
-                  const G = m.children[M];
-                  if (G.isMesh === !0) {
-                    const ie = G.geometry;
-                    g.assignLODInformation(n.url, ie, o, e, M), D.push(ie);
+                const v = new Array();
+                for (let S = 0; S < m.children.length; S++) {
+                  const j = m.children[S];
+                  if (j.isMesh === !0) {
+                    const J = j.geometry;
+                    p.assignLODInformation(o.url, J, l, e, S), v.push(J);
                   }
                 }
-                return L(D);
+                return y(v);
               }
-            } else h && console.warn("Could not find mesh with guid", y.guid, O.parser.json);
+            } else g && console.warn("Could not find mesh with guid", w.guid, _.parser.json);
           }
-          return L(null);
+          return y(null);
         });
-        this.cache.set(c, x), p.use(x);
-        const w = await x;
-        return w != null ? w instanceof q ? (this.cache.set(c, new WeakRef(w)), g._resourceRegistry.register(w, c)) : Array.isArray(w) ? this.cache.set(c, Promise.resolve(w)) : this.cache.set(c, Promise.resolve(w)) : this.cache.set(c, Promise.resolve(null)), w;
-      } else if (t instanceof q) {
+        this.cache.set(f, M), D.use(M);
+        const T = await M;
+        return r !== this.cacheGeneration || this.cache.get(f) !== M ? null : (T != null ? T instanceof W ? (this.cache.set(f, new WeakRef(T)), p._resourceRegistry.register(T, f)) : Array.isArray(T) ? this.cache.set(f, Promise.resolve(T)) : this.cache.set(f, Promise.resolve(T)) : this.cache.set(f, Promise.resolve(null)), T);
+      } else if (t instanceof W) {
         if (s?.isCurrent?.() === !1)
-          return r && console.log(`Skipping stale texture LOD ${e} request: ${f}`), null;
-        r && console.log("Load texture from uri: " + f);
-        const d = await new it().loadAsync(f);
-        return s?.isCurrent?.() === !1 ? (d?.dispose(), null) : (d ? (d.guid = a.guid, d.flipY = !1, d.needsUpdate = !0, d.colorSpace = t.colorSpace, r && console.log(a, d)) : h && console.warn("failed loading", f), d);
+          return n && console.log(`Skipping stale texture LOD ${e} request: ${c}`), null;
+        n && console.log("Load texture from uri: " + c);
+        const h = await new ot().loadAsync(c);
+        return r !== this.cacheGeneration || s?.isCurrent?.() === !1 ? (h?.dispose(), null) : (h ? (h.guid = a.guid, h.flipY = !1, h.needsUpdate = !0, h.colorSpace = t.colorSpace, n && console.log(a, h)) : g && console.warn("failed loading", c), h);
       }
     }
     return null;
@@ -1062,24 +1079,26 @@ ${e}`);
     if (o && console.log(`LOD ${n} was already loading/loaded: ${e}`), t instanceof WeakRef) {
       const u = t.deref();
       if (u) {
-        let f = u, c = !1;
-        if (f instanceof q && r instanceof q ? Te(f.image) || Le(f) ? f = this.copySettings(r, f) : c = !0 : f instanceof j && r instanceof j && (f.attributes.position?.array || (c = !0)), !c)
-          return { found: !0, value: f };
+        let d = u, c = !1;
+        if (d instanceof W && r instanceof W ? Re(d.image) || we(d) ? d = this.copySettings(r, d) : c = !0 : d instanceof Y && r instanceof Y && (d.attributes.position?.array || (c = !0)), !c)
+          return { found: !0, value: d };
       }
-      return this.cache.delete(e), h && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${e}`), { found: !1 };
+      return this.cache.delete(e), g && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${e}`), { found: !1 };
     }
-    let a = await t.catch((u) => (console.error(`Error loading LOD ${n} from ${s}
-`, u), null)), l = !1;
-    return a == null || (a instanceof q && r instanceof q ? Te(a.image) || Le(a) ? a = this.copySettings(r, a) : (l = !0, this.cache.delete(e)) : a instanceof j && r instanceof j && (a.attributes.position?.array || (l = !0, this.cache.delete(e)))), l ? { found: !1 } : { found: !0, value: a };
+    let l = await t.catch((u) => (console.error(`Error loading LOD ${n} from ${s}
+`, u), null));
+    if (this.disposedRequests.has(t)) return { found: !0, value: null };
+    let a = !1;
+    return l == null || (l instanceof W && r instanceof W ? Re(l.image) || we(l) ? l = this.copySettings(r, l) : (a = !0, this.cache.delete(e)) : l instanceof Y && r instanceof Y && (l.attributes.position?.array || (a = !0, this.cache.delete(e)))), a ? { found: !1 } : { found: !0, value: l };
   }
   static _queue;
   static get queue() {
-    return this._queue ??= new wt(Me() ? 20 : 50, { debug: h != !1 });
+    return this._queue ??= new vt(Oe() ? 20 : 50, { debug: g != !1 });
   }
   static assignLODInformation(t, e, s, r, n) {
     if (!e) return;
     e.userData || (e.userData = {});
-    const o = new kt(t, s, r, n);
+    const o = new At(t, s, r, n);
     e.userData.LODS = o, "source" in e && typeof e.source == "object" && (e.source.LODS = o);
   }
   static getAssignedLODInformation(t) {
@@ -1087,12 +1106,12 @@ ${e}`);
   }
   // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
   static copySettings(t, e) {
-    return e ? (h === "verbose" && console.debug(`Copy texture settings
+    return e ? (g === "verbose" && console.debug(`Copy texture settings
 `, t.uuid, `
 `, e.uuid), e = e.clone(), e.offset = t.offset, e.repeat = t.repeat, e.colorSpace = t.colorSpace, e.magFilter = t.magFilter, e.minFilter = t.minFilter, e.wrapS = t.wrapS, e.wrapT = t.wrapT, e.flipY = t.flipY, e.anisotropy = t.anisotropy, e.mipmaps || (e.generateMipmaps = t.generateMipmaps), e) : t;
   }
 }
-class kt {
+class At {
   url;
   /** the key to lookup the LOD information */
   key;
@@ -1103,7 +1122,7 @@ class kt {
     this.url = t, this.key = e, this.level = s, r != null && (this.index = r);
   }
 }
-class oe {
+class le {
   static addPromise = (t, e, s, r) => {
     r.forEach((n) => {
       n.add(t, e, s);
@@ -1152,7 +1171,7 @@ class oe {
   _seen = /* @__PURE__ */ new WeakMap();
   add(t, e, s) {
     if (this._resolved) {
-      h && console.warn("PromiseGroup: Trying to add a promise to a resolved group, ignoring.");
+      g && console.warn("PromiseGroup: Trying to add a promise to a resolved group, ignoring.");
       return;
     }
     if (!(this._frame_start !== void 0 && this._currentFrame > this._frame_start + this._frames_to_capture)) {
@@ -1160,7 +1179,7 @@ class oe {
         if (this._seen.has(e)) {
           const r = this._seen.get(e);
           if (r >= this._maxPromisesPerObject) {
-            h && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
+            g && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
             return;
           }
           this._seen.set(e, r + 1);
@@ -1179,7 +1198,7 @@ class oe {
     });
   }
 }
-const A = V("debugprogressive"), At = A === "colors", It = V("noprogressive"), he = /* @__PURE__ */ Symbol("Needle:LODSManager"), ge = /* @__PURE__ */ Symbol("Needle:LODState"), E = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), Oe = Xe, R = { mesh_lod: -1, texture_lod: -1 }, $t = new Ie(), Se = [
+const $ = X("debugprogressive"), It = $ === "colors", $t = X("noprogressive"), ge = /* @__PURE__ */ Symbol("Needle:LODSManager"), pe = /* @__PURE__ */ Symbol("Needle:LODState"), N = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), Ce = je, R = { mesh_lod: -1, texture_lod: -1 }, Gt = new Be(), Pe = [
   3526751,
   11065402,
   15978811,
@@ -1214,15 +1233,15 @@ const A = V("debugprogressive"), At = A === "colors", It = V("noprogressive"), h
   5592405
 ];
 function Bt() {
-  const i = Oe.Timer || Oe.Clock;
+  const i = Ce.Timer || Ce.Clock;
   return new i();
 }
-const pe = new ue(), N = new ue(), Re = new ue(), Gt = new k(), qt = new k(), Wt = new $e(), W = new k(), H = new k(), Q = new k(), J = new k();
-function Ft(i, t) {
+const me = new ce(), V = new ce(), ke = new ce(), qt = new A(), Wt = new A(), Ft = new qe(), F = new A(), Z = new A(), ee = new A(), te = new A();
+function Ut(i, t) {
   const e = i.min, s = i.max, r = (e.x + s.x) * 0.5, n = (e.y + s.y) * 0.5;
-  return W.set(r, n, e.z).applyMatrix4(t).z < 0;
+  return F.set(r, n, e.z).applyMatrix4(t).z < 0;
 }
-function Ut(i) {
+function zt(i) {
   const {
     geometry: t,
     matrixWorld: e,
@@ -1230,71 +1249,71 @@ function Ut(i) {
     projectionScreenMatrix: r,
     desiredDensity: n,
     canvasHeight: o = 0,
-    currentLevel: a = -1,
-    xrEnabled: l = !1,
+    currentLevel: l = -1,
+    xrEnabled: a = !1,
     debugDrawLine: u,
-    warnMissingPrimitiveDensities: f = !1
-  } = i, c = g.getMeshLODExtension(t)?.lods, d = g.getPrimitiveIndex(t), p = i.target ?? {
-    level: a,
-    primitiveIndex: d,
+    warnMissingPrimitiveDensities: d = !1
+  } = i, c = p.getMeshLODExtension(t)?.lods, f = p.getPrimitiveIndex(t), h = i.target ?? {
+    level: l,
+    primitiveIndex: f,
     screenCoverage: 0,
-    screenspaceVolume: new k(),
+    screenspaceVolume: new A(),
     centrality: 1
   };
-  p.level = a, p.primitiveIndex = d, p.screenCoverage = 0, p.screenspaceVolume.set(0, 0, 0), p.centrality = 1;
-  let b = i.boundingBox ?? t.boundingBox;
-  if (b || (t.computeBoundingBox(), b = t.boundingBox), !b) return p;
-  if (pe.copy(b).applyMatrix4(e), s.isPerspectiveCamera && Ft(pe, r))
-    return p.level = 0, p.screenCoverage = 1 / 0, p.screenspaceVolume.set(1 / 0, 1 / 0, 1 / 0), p;
-  if (N.copy(pe).applyMatrix4(r), l && s.isPerspectiveCamera && s.fov > 70) {
-    const v = N.min, T = N.max;
-    let O = v.x, P = v.y, S = T.x, _ = T.y;
-    const m = 2, D = 1.5, M = (v.x + T.x) * 0.5, G = (v.y + T.y) * 0.5;
-    O = (O - M) * m + M, P = (P - G) * m + G, S = (S - M) * m + M, _ = (_ - G) * m + G;
-    const ie = O < 0 && S > 0 ? 0 : Math.min(Math.abs(v.x), Math.abs(T.x)), Ve = P < 0 && _ > 0 ? 0 : Math.min(Math.abs(v.y), Math.abs(T.y)), ce = Math.max(ie, Ve);
-    p.centrality = (D - ce) * (D - ce) * (D - ce);
-  }
-  const y = N.getSize(Gt);
-  y.multiplyScalar(0.5), globalThis.screen?.availHeight > 0 && o > 0 && y.multiplyScalar(o / globalThis.screen.availHeight), s.isPerspectiveCamera && (y.x *= s.aspect), Re.copy(b).applyMatrix4(e).applyMatrix4(s.matrixWorldInverse);
-  const x = Re.getSize(qt), w = Math.max(y.x, y.y), L = Math.max(x.x, x.y);
-  w !== 0 && L !== 0 && (y.z = x.z / L * w);
-  const z = Math.max(y.x, y.y, y.z) * p.centrality;
-  if (p.screenCoverage = z, p.screenspaceVolume.copy(y), z <= 0) return p;
+  h.level = l, h.primitiveIndex = f, h.screenCoverage = 0, h.screenspaceVolume.set(0, 0, 0), h.centrality = 1;
+  let D = i.boundingBox ?? t.boundingBox;
+  if (D || (t.computeBoundingBox(), D = t.boundingBox), !D) return h;
+  if (me.copy(D).applyMatrix4(e), s.isPerspectiveCamera && Ut(me, r))
+    return h.level = 0, h.screenCoverage = 1 / 0, h.screenspaceVolume.set(1 / 0, 1 / 0, 1 / 0), h;
+  if (V.copy(me).applyMatrix4(r), a && s.isPerspectiveCamera && s.fov > 70) {
+    const y = V.min, O = V.max;
+    let I = y.x, P = y.y, _ = O.x, E = O.y;
+    const k = 2, b = 1.5, m = (y.x + O.x) * 0.5, v = (y.y + O.y) * 0.5;
+    I = (I - m) * k + m, P = (P - v) * k + v, _ = (_ - m) * k + m, E = (E - v) * k + v;
+    const S = I < 0 && _ > 0 ? 0 : Math.min(Math.abs(y.x), Math.abs(O.x)), j = P < 0 && E > 0 ? 0 : Math.min(Math.abs(y.y), Math.abs(O.y)), J = Math.max(S, j);
+    h.centrality = (b - J) * (b - J) * (b - J);
+  }
+  const L = V.getSize(qt);
+  L.multiplyScalar(0.5), globalThis.screen?.availHeight > 0 && o > 0 && L.multiplyScalar(o / globalThis.screen.availHeight), s.isPerspectiveCamera && (L.x *= s.aspect), ke.copy(D).applyMatrix4(e).applyMatrix4(s.matrixWorldInverse);
+  const x = ke.getSize(Wt), w = Math.max(L.x, L.y), M = Math.max(x.x, x.y);
+  w !== 0 && M !== 0 && (L.z = x.z / M * w);
+  const T = Math.max(L.x, L.y, L.z) * h.centrality;
+  if (h.screenCoverage = T, h.screenspaceVolume.copy(L), T <= 0) return h;
   if (u) {
-    const v = Wt.copy(r);
-    v.invert(), W.copy(N.min), H.copy(N.max), H.x = W.x, Q.copy(N.max), Q.y = W.y, J.copy(N.max);
-    const T = (W.z + J.z) * 0.5;
-    W.z = H.z = Q.z = J.z = T, W.applyMatrix4(v), H.applyMatrix4(v), Q.applyMatrix4(v), J.applyMatrix4(v), u(W, H, 255), u(W, Q, 255), u(H, J, 255), u(Q, J, 255);
+    const y = Ft.copy(r);
+    y.invert(), F.copy(V.min), Z.copy(V.max), Z.x = F.x, ee.copy(V.max), ee.y = F.y, te.copy(V.max);
+    const O = (F.z + te.z) * 0.5;
+    F.z = Z.z = ee.z = te.z = O, F.applyMatrix4(y), Z.applyMatrix4(y), ee.applyMatrix4(y), te.applyMatrix4(y), u(F, Z, 255), u(F, ee, 255), u(Z, te, 255), u(ee, te, 255);
   }
   if (c?.length)
-    for (let v = 0; v < c.length; v++) {
-      const T = c[v], O = T.densities?.[d] || T.density || 1e-5;
-      if (d > 0 && f && Fe() && !T.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] && (globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] = !0, console.warn("[Needle Progressive] Detected usage of mesh without primitive densities. This might cause incorrect LOD level selection: Consider re-optimizing your model by updating your Needle Integration, Needle glTF Pipeline or running optimization again on Needle Cloud.")), O / z < n) {
-        p.level = v;
+    for (let y = 0; y < c.length; y++) {
+      const O = c[y], I = O.densities?.[f] || O.density || 1e-5;
+      if (f > 0 && d && ze() && !O.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] && (globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] = !0, console.warn("[Needle Progressive] Detected usage of mesh without primitive densities. This might cause incorrect LOD level selection: Consider re-optimizing your model by updating your Needle Integration, Needle glTF Pipeline or running optimization again on Needle Cloud.")), I / T < n) {
+        h.level = y;
         break;
       }
     }
-  return p;
+  return h;
 }
-class I {
+class G {
   /**
    * Assign a function to draw debug lines for the LODs. This function will be called with the start and end position of the line and the color of the line when the `debugprogressive` query parameter is set.
    */
   static debugDrawLine;
   /** @internal */
   static getObjectLODState(t) {
-    return t[ge];
+    return t[pe];
   }
   static addPlugin(t) {
-    F.push(t);
+    U.push(t);
   }
   static removePlugin(t) {
-    const e = F.indexOf(t);
-    e >= 0 && F.splice(e, 1);
+    const e = U.indexOf(t);
+    e >= 0 && U.splice(e, 1);
   }
   /** Read-only snapshot of the currently registered plugins, for inspection. Use {@link addPlugin} / {@link removePlugin} to modify the registry. */
   static getPlugins() {
-    return F;
+    return U;
   }
   /**
    * Gets the LODsManager for the given renderer. If the LODsManager does not exist yet, it will be created.
@@ -1302,20 +1321,20 @@ class I {
    * @returns The LODsManager instance.
    */
   static get(t, e) {
-    if (t[he])
-      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[he];
-    const s = new I(t, {
+    if (t[ge])
+      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[ge];
+    const s = new G(t, {
       engine: "unknown",
       ...e
     });
-    return t[he] = s, s;
+    return t[ge] = s, s;
   }
   renderer;
   context;
-  projectionScreenMatrix = new $e();
+  projectionScreenMatrix = new qe();
   /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
   get plugins() {
-    return F;
+    return U;
   }
   /**
    * Force override the LOD level for all objects (meshes + textures) rendered in the scene
@@ -1380,12 +1399,12 @@ class I {
    * ```
    */
   awaitLoading(t) {
-    const e = this._promiseGroupIds++, s = new oe(this.#r, { ...t });
+    const e = this._promiseGroupIds++, s = new le(this.#r, { ...t });
     this._newPromiseGroups.push(s);
     const r = performance.now();
     return s.ready.finally(() => {
       const n = this._newPromiseGroups.indexOf(s);
-      n >= 0 && (this._newPromiseGroups.splice(n, 1), Fe() && performance.measure("LODsManager:awaitLoading", {
+      n >= 0 && (this._newPromiseGroups.splice(n, 1), ze() && performance.measure("LODsManager:awaitLoading", {
         start: r,
         detail: { id: e, name: t?.name, awaited: s.awaitedCount, resolved: s.resolvedCount }
       }));
@@ -1393,7 +1412,7 @@ class I {
   }
   /** Track LOD work started outside this manager so {@link awaitLoading} waits for it too. */
   trackLoadingPromise(t, e, s) {
-    return oe.addPromise(t, e, s, this._newPromiseGroups), s;
+    return le.addPromise(t, e, s, this._newPromiseGroups), s;
   }
   _postprocessPromiseGroups() {
     if (this._newPromiseGroups.length !== 0)
@@ -1458,7 +1477,7 @@ class I {
     const e = this;
     _e(this.renderer), this.renderer.render = function(s, r) {
       const n = e.renderer.getRenderTarget();
-      (n == null || "isXRRenderTarget" in n && n.isXRRenderTarget) && (t = 0, e.#r += 1, e.#i.update?.(), e.#n = Math.max(e.#i.getDelta(), 1 / 1e3), e.#o += e.#n, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#n), e.#s = e._fpsBuffer.reduce((a, l) => a + l) / e._fpsBuffer.length, A && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
+      (n == null || "isXRRenderTarget" in n && n.isXRRenderTarget) && (t = 0, e.#r += 1, e.#i.update?.(), e.#n = Math.max(e.#i.getDelta(), 1 / 1e3), e.#o += e.#n, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#n), e.#s = e._fpsBuffer.reduce((l, a) => l + a) / e._fpsBuffer.length, $ && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
       const o = t++;
       e.#t.call(this, s, r), e.onAfterRender(s, r, o);
     };
@@ -1491,11 +1510,11 @@ class I {
     const n = r.opaque;
     let o = !0;
     if (n.length === 1) {
-      const a = n[0].material;
-      (a.name === "EffectMaterial" || a.name === "CopyShader") && (o = !1);
+      const l = n[0].material;
+      (l.name === "EffectMaterial" || l.name === "CopyShader") && (o = !1);
     }
     if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (o = !1), o) {
-      if (It || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, A && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, A && console.warn("↑ Increasing LOD updates", this.#e, this.#s.toFixed(0))) : this.#e = this.updateInterval, this.#e > 0 && this.#r % this.#e != 0))
+      if ($t || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, $ && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, $ && console.warn("↑ Increasing LOD updates", this.#e, this.#s.toFixed(0))) : this.#e = this.updateInterval, this.#e > 0 && this.#r % this.#e != 0))
         return;
       this.internalUpdate(t, e), this._postprocessPromiseGroups();
     }
@@ -1509,12 +1528,12 @@ class I {
     const r = s.opaque;
     this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse);
     const n = this.targetTriangleDensity;
-    for (const l of r) {
-      if (l.material && (l.geometry?.type === "BoxGeometry" || l.geometry?.type === "BufferGeometry") && (l.material.name === "SphericalGaussianBlur" || l.material.name == "BackgroundCubeMaterial" || l.material.name === "CubemapFromEquirect" || l.material.name === "EquirectangularToCubeUV")) {
-        A && (l.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (l.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", l, l.material.name, l.material.type)));
+    for (const a of r) {
+      if (a.material && (a.geometry?.type === "BoxGeometry" || a.geometry?.type === "BufferGeometry") && (a.material.name === "SphericalGaussianBlur" || a.material.name == "BackgroundCubeMaterial" || a.material.name === "CubemapFromEquirect" || a.material.name === "EquirectangularToCubeUV")) {
+        $ && (a.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (a.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", a, a.material.name, a.material.type)));
         continue;
       }
-      switch (l.material.type) {
+      switch (a.material.type) {
         case "LineBasicMaterial":
         case "LineDashedMaterial":
         case "PointsMaterial":
@@ -1523,18 +1542,18 @@ class I {
         case "MeshDepthMaterial":
           continue;
       }
-      const u = l.object;
-      (u instanceof K || u.isMesh) && this.updateLODs(t, e, u, n);
+      const u = a.object;
+      (u instanceof H || u.isMesh) && this.updateLODs(t, e, u, n);
     }
     const o = s.transparent;
-    for (const l of o) {
-      const u = l.object;
-      (u instanceof K || u.isMesh) && this.updateLODs(t, e, u, n);
+    for (const a of o) {
+      const u = a.object;
+      (u instanceof H || u.isMesh) && this.updateLODs(t, e, u, n);
     }
-    const a = s.transmissive;
-    for (const l of a) {
-      const u = l.object;
-      (u instanceof K || u.isMesh) && this.updateLODs(t, e, u, n);
+    const l = s.transmissive;
+    for (const a of l) {
+      const u = a.object;
+      (u instanceof H || u.isMesh) && this.updateLODs(t, e, u, n);
     }
   }
   getRenderList(t, e, s) {
@@ -1559,15 +1578,15 @@ class I {
   /** Update the LOD levels for the renderer. */
   updateLODs(t, e, s, r) {
     s.userData || (s.userData = {});
-    let n = s[ge];
-    if (n || (n = new zt(), s[ge] = n), n.frames++ < 2)
+    let n = s[pe];
+    if (n || (n = new Et(), s[pe] = n), n.frames++ < 2)
       return;
-    for (const a of F)
-      a.onBeforeUpdateLOD?.(this.renderer, t, e, s);
-    const o = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : X;
-    o >= 0 ? (R.mesh_lod = o, R.texture_lod = o) : (this.calculateLodLevel(e, s, n, r, R), R.mesh_lod = Math.round(R.mesh_lod), R.texture_lod = Math.round(R.texture_lod)), R.mesh_lod >= 0 && this.loadProgressiveMeshes(s, R.mesh_lod), s.material && R.texture_lod >= 0 && this.loadProgressiveTextures(s.material, R.texture_lod, o), h && s.material && !s.isGizmo && Ue(s.material), At && s.material && !s.isGizmo && !s.isBatchedMesh && ze(s.material, R.mesh_lod);
-    for (const a of F)
-      a.onAfterUpdatedLOD?.(this.renderer, t, e, s, R);
+    for (const l of U)
+      l.onBeforeUpdateLOD?.(this.renderer, t, e, s);
+    const o = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : K;
+    o >= 0 ? (R.mesh_lod = o, R.texture_lod = o) : (this.calculateLodLevel(e, s, n, r, R), R.mesh_lod = Math.round(R.mesh_lod), R.texture_lod = Math.round(R.texture_lod)), R.mesh_lod >= 0 && this.loadProgressiveMeshes(s, R.mesh_lod), s.material && R.texture_lod >= 0 && this.loadProgressiveTextures(s.material, R.texture_lod, o), g && s.material && !s.isGizmo && Ee(s.material), It && s.material && !s.isGizmo && !s.isBatchedMesh && Ne(s.material, R.mesh_lod);
+    for (const l of U)
+      l.onAfterUpdatedLOD?.(this.renderer, t, e, s, R);
     n.lastLodLevel_Mesh = R.mesh_lod, n.lastLodLevel_Texture = R.texture_lod;
   }
   /** Load progressive textures for the given material
@@ -1583,14 +1602,14 @@ class I {
       return;
     }
     let r = !1;
-    (t[E] === void 0 || e < t[E]) && (r = !0);
+    (t[N] === void 0 || e < t[N]) && (r = !0);
     const n = s !== void 0 && s >= 0;
-    if (n && (r = t[E] != s, e = s), r) {
-      t[E] = e;
-      const o = n ? { force: !0 } : void 0, a = g.assignTextureLOD(t, e, o).then((l) => {
+    if (n && (r = t[N] != s, e = s), r) {
+      t[N] = e;
+      const o = n ? { force: !0 } : void 0, l = p.assignTextureLOD(t, e, o).then((a) => {
         this._lodchangedlisteners.forEach((u) => u({ type: "texture", level: e, object: t }));
       });
-      oe.addPromise("texture", t, a, this._newPromiseGroups);
+      le.addPromise("texture", t, l, this._newPromiseGroups);
     }
   }
   /** Load progressive meshes for the given mesh
@@ -1601,18 +1620,18 @@ class I {
    */
   loadProgressiveMeshes(t, e) {
     if (!t) return Promise.resolve(null);
-    let s = t[E] !== e;
+    let s = t[N] !== e;
     const r = t["DEBUG:LOD"];
-    if (r != null && (s = t[E] != r, e = r), s) {
-      t[E] = e;
-      const n = t.geometry, o = g.assignMeshLOD(t, e).then((a) => (a && t[E] == e && n != t.geometry && this._lodchangedlisteners.forEach((l) => l({ type: "mesh", level: e, object: t })), a));
-      return oe.addPromise("mesh", t, o, this._newPromiseGroups), o;
+    if (r != null && (s = t[N] != r, e = r), s) {
+      t[N] = e;
+      const n = t.geometry, o = p.assignMeshLOD(t, e).then((l) => (l && t[N] == e && n != t.geometry && this._lodchangedlisteners.forEach((a) => a({ type: "mesh", level: e, object: t })), l));
+      return le.addPromise("mesh", t, o, this._newPromiseGroups), o;
     }
     return Promise.resolve(null);
   }
   // private testIfLODLevelsAreAvailable() {
-  _sphere = new Ae();
-  _tempWorldPosition = new k();
+  _sphere = new Ge();
+  _tempWorldPosition = new A();
   static skinnedMeshBoundsFrameOffsetCounter = 0;
   static $skinnedMeshBoundsOffset = /* @__PURE__ */ Symbol("gltf-progressive-skinnedMeshBoundsOffset");
   // #region calculateLodLevel
@@ -1625,86 +1644,86 @@ class I {
       n.mesh_lod = -1, n.texture_lod = -1;
       return;
     }
-    let a = 10 + 1, l = !1;
-    if (A && e["DEBUG:LOD"] != null)
+    let l = 10 + 1, a = !1;
+    if ($ && e["DEBUG:LOD"] != null)
       return e["DEBUG:LOD"];
-    const u = g.getMeshLODExtension(e.geometry)?.lods, f = g.getPrimitiveIndex(e.geometry), c = u && u.length > 0, d = g.getMaterialMinMaxLODsCount(e.material), p = d.min_count !== 1 / 0 && d.min_count >= 0 && d.max_count >= 0;
-    if (!c && !p) {
+    const u = p.getMeshLODExtension(e.geometry)?.lods, d = p.getPrimitiveIndex(e.geometry), c = u && u.length > 0, f = p.getMaterialMinMaxLODsCount(e.material), h = f.min_count !== 1 / 0 && f.min_count >= 0 && f.max_count >= 0;
+    if (!c && !h) {
       n.mesh_lod = 0, n.texture_lod = 0;
       return;
     }
-    c || (l = !0, a = 0);
-    const b = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let y = e.geometry.boundingBox;
+    c || (a = !0, l = 0);
+    const D = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let L = e.geometry.boundingBox;
     if (e.type === "SkinnedMesh") {
       const x = e;
       if (!x.boundingBox)
         x.computeBoundingBox();
       else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
-        if (!x[I.$skinnedMeshBoundsOffset]) {
-          const L = I.skinnedMeshBoundsFrameOffsetCounter++;
-          x[I.$skinnedMeshBoundsOffset] = L;
+        if (!x[G.$skinnedMeshBoundsOffset]) {
+          const M = G.skinnedMeshBoundsFrameOffsetCounter++;
+          x[G.$skinnedMeshBoundsOffset] = M;
         }
-        const w = x[I.$skinnedMeshBoundsOffset];
+        const w = x[G.$skinnedMeshBoundsOffset];
         if ((s.frames + w) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
-          const L = ne(x), z = x.geometry;
-          L && (x.geometry = L), x.computeBoundingBox(), x.geometry = z;
+          const M = ae(x), T = x.geometry;
+          M && (x.geometry = M), x.computeBoundingBox(), x.geometry = T;
         }
       }
-      y = x.boundingBox;
+      L = x.boundingBox;
     }
-    if (y) {
+    if (L) {
       if (e.geometry.attributes.color && e.geometry.attributes.color.count < 100 && e.geometry.boundingSphere) {
         this._sphere.copy(e.geometry.boundingSphere), this._sphere.applyMatrix4(e.matrixWorld);
-        const L = t.getWorldPosition(this._tempWorldPosition);
-        if (this._sphere.containsPoint(L)) {
+        const M = t.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(M)) {
           n.mesh_lod = 0, n.texture_lod = 0;
           return;
         }
       }
-      const x = Ut({
+      const x = zt({
         geometry: e.geometry,
         matrixWorld: e.matrixWorld,
         camera: t,
         projectionScreenMatrix: this.projectionScreenMatrix,
         desiredDensity: r,
-        canvasHeight: b,
+        canvasHeight: D,
         currentLevel: s.lastLodLevel_Mesh,
-        boundingBox: y,
+        boundingBox: L,
         xrEnabled: this.renderer.xr.enabled,
-        debugDrawLine: A ? I.debugDrawLine : void 0,
+        debugDrawLine: $ ? G.debugDrawLine : void 0,
         warnMissingPrimitiveDensities: !0
       });
       if (s.lastCentrality = x.centrality, s.lastScreenCoverage = x.screenCoverage, s.lastScreenspaceVolume.copy(x.screenspaceVolume), x.screenCoverage === 1 / 0) {
         n.mesh_lod = 0, n.texture_lod = 0;
         return;
       }
-      x.level >= 0 && x.level < a && (a = x.level, l = !0);
+      x.level >= 0 && x.level < l && (l = x.level, a = !0);
     }
-    if (l ? n.mesh_lod = a : n.mesh_lod = s.lastLodLevel_Mesh, A && n.mesh_lod != s.lastLodLevel_Mesh) {
+    if (a ? n.mesh_lod = l : n.mesh_lod = s.lastLodLevel_Mesh, $ && n.mesh_lod != s.lastLodLevel_Mesh) {
       const w = u?.[n.mesh_lod];
-      w && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${n.mesh_lod} (density: ${w.densities?.[f].toFixed(0)}) | ${e.name}`);
+      w && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${n.mesh_lod} (density: ${w.densities?.[d].toFixed(0)}) | ${e.name}`);
     }
-    if (p) {
+    if (h) {
       const x = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
       if (s.lastLodLevel_Texture < 0) {
-        if (n.texture_lod = d.max_count - 1, A) {
-          const w = d.lods[d.max_count - 1];
-          A && console.log(`First Texture LOD ${n.texture_lod} (${w.max_height}px) - ${e.name}`);
+        if (n.texture_lod = f.max_count - 1, $) {
+          const w = f.lods[f.max_count - 1];
+          $ && console.log(`First Texture LOD ${n.texture_lod} (${w.max_height}px) - ${e.name}`);
         }
       } else {
         const w = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
-        let L = s.lastScreenCoverage * 4;
-        this.context?.engine === "model-viewer" && (L *= 1.5);
-        const z = this.renderer.getPixelRatio?.() || globalThis.devicePixelRatio || 1, T = b / z * L;
-        let O = !1;
-        for (let P = d.lods.length - 1; P >= 0; P--) {
-          const S = d.lods[P];
-          if (!(x && S.max_height >= 2048) && !(Me() && S.max_height > 4096) && (S.max_height > T || !O && P === 0)) {
-            if (O = !0, n.texture_lod = P, A && n.texture_lod < s.lastLodLevel_Texture) {
-              const _ = S.max_height;
-              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${n.texture_lod} = ${_}px
-Screensize: ${T.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${w.toFixed(1)}
+        let M = s.lastScreenCoverage * 4;
+        this.context?.engine === "model-viewer" && (M *= 1.5);
+        const T = this.renderer.getPixelRatio?.() || globalThis.devicePixelRatio || 1, O = D / T * M;
+        let I = !1;
+        for (let P = f.lods.length - 1; P >= 0; P--) {
+          const _ = f.lods[P];
+          if (!(x && _.max_height >= 2048) && !(Oe() && _.max_height > 4096) && (_.max_height > O || !I && P === 0)) {
+            if (I = !0, n.texture_lod = P, $ && n.texture_lod < s.lastLodLevel_Texture) {
+              const E = _.max_height;
+              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${n.texture_lod} = ${E}px
+Screensize: ${O.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${w.toFixed(1)}
 ${e.name}`);
             }
             break;
@@ -1715,74 +1734,74 @@ ${e.name}`);
       n.texture_lod = 0;
   }
 }
-class zt {
+class Et {
   frames = 0;
   lastLodLevel_Mesh = -1;
   lastLodLevel_Texture = -1;
   lastScreenCoverage = 0;
-  lastScreenspaceVolume = new k();
+  lastScreenspaceVolume = new A();
   lastCentrality = 0;
 }
-function ze(i, t) {
+function Ne(i, t) {
   if (!(t < 0)) {
     if (Array.isArray(i)) {
       for (const e of i)
-        ze(e, t);
+        Ne(e, t);
       return;
     }
-    "color" in i && i.color instanceof Ie && (i.color.copy(Et(t, $t)), i.needsUpdate = !0);
+    "color" in i && i.color instanceof Be && (i.color.copy(Nt(t, Gt)), i.needsUpdate = !0);
   }
 }
-function Et(i, t) {
-  const e = Math.max(0, Math.min(Se.length - 1, Math.floor(i)));
-  return t.setHex(Se[e]);
+function Nt(i, t) {
+  const e = Math.max(0, Math.min(Pe.length - 1, Math.floor(i)));
+  return t.setHex(Pe[e]);
 }
-const Ce = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), ae = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
-let me = null;
-function Ee() {
-  const i = Nt();
+const Ae = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), ue = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
+let ye = null;
+function Ve() {
+  const i = Vt();
   i && (i.mapURLs(function(t) {
-    return Pe(), t;
-  }), Pe(), me?.disconnect(), me = new MutationObserver((t) => {
+    return Ie(), t;
+  }), Ie(), ye?.disconnect(), ye = new MutationObserver((t) => {
     t.forEach((e) => {
       e.addedNodes.forEach((s) => {
-        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Ne(s);
+        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Xe(s);
       });
     });
-  }), me.observe(document, { childList: !0, subtree: !0 }));
+  }), ye.observe(document, { childList: !0, subtree: !0 }));
 }
-function Nt() {
+function Vt() {
   if (typeof customElements > "u") return null;
   const i = customElements.get("model-viewer");
   return i || (customElements.whenDefined("model-viewer").then(() => {
-    console.debug("[gltf-progressive] model-viewer defined"), Ee();
+    console.debug("[gltf-progressive] model-viewer defined"), Ve();
   }), null);
 }
-function Pe() {
+function Ie() {
   if (typeof document > "u") return;
   document.querySelectorAll("model-viewer").forEach((t) => {
-    Ne(t);
+    Xe(t);
   });
 }
-const ke = /* @__PURE__ */ new WeakSet();
-let Vt = 0;
-function Ne(i) {
-  if (!i || ke.has(i))
+const $e = /* @__PURE__ */ new WeakSet();
+let Xt = 0;
+function Xe(i) {
+  if (!i || $e.has(i))
     return null;
-  ke.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++Vt + `
+  $e.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++Xt + `
 `, i.getAttribute("src"));
   let t = null, e = null, s = null;
   for (let r = i; r != null; r = Object.getPrototypeOf(r)) {
-    const n = Object.getOwnPropertySymbols(r), o = n.find((u) => u.toString() == "Symbol(renderer)"), a = n.find((u) => u.toString() == "Symbol(scene)"), l = n.find((u) => u.toString() == "Symbol(needsRender)");
-    !t && o != null && (t = i[o].threeRenderer), !e && a != null && (e = i[a]), !s && l != null && (s = i[l]);
+    const n = Object.getOwnPropertySymbols(r), o = n.find((u) => u.toString() == "Symbol(renderer)"), l = n.find((u) => u.toString() == "Symbol(scene)"), a = n.find((u) => u.toString() == "Symbol(needsRender)");
+    !t && o != null && (t = i[o].threeRenderer), !e && l != null && (e = i[l]), !s && a != null && (s = i[a]);
   }
   if (t && e) {
     let r = function() {
       if (s) {
         let o = 0;
-        const a = setInterval(() => {
+        const l = setInterval(() => {
           if (o++ > 5) {
-            clearInterval(a);
+            clearInterval(l);
             return;
           }
           s?.call(i);
@@ -1790,8 +1809,8 @@ function Ne(i) {
       }
     };
     console.debug("[gltf-progressive] setup model-viewer");
-    const n = I.get(t, { engine: "model-viewer" });
-    return I.addPlugin(new Xt()), n.enable(), n.addEventListener("changed", () => {
+    const n = G.get(t, { engine: "model-viewer" });
+    return G.addPlugin(new jt()), n.enable(), n.addEventListener("changed", () => {
       s?.call(i);
     }), i.addEventListener("model-visibility", (o) => {
       o.detail.visible && s?.call(i);
@@ -1803,7 +1822,7 @@ function Ne(i) {
   }
   return null;
 }
-class Xt {
+class jt {
   _didWarnAboutMissingUrl = !1;
   onBeforeUpdateLOD(t, e, s, r) {
     this.tryParseMeshLOD(e, r), this.tryParseTextureLOD(e, r);
@@ -1821,50 +1840,50 @@ class Xt {
     return t.element;
   }
   tryParseTextureLOD(t, e) {
-    if (e[ae] == !0) return;
-    e[ae] = !0;
+    if (e[ue] == !0) return;
+    e[ue] = !0;
     const s = this.tryGetCurrentGLTF(t), r = this.tryGetCurrentModelViewer(t), n = this.getUrl(r);
     if (n && s && e.material) {
-      let o = function(l) {
-        if (l[ae] == !0) return;
-        l[ae] = !0, l.userData && (l.userData.LOD = -1);
-        const u = Object.keys(l);
-        for (let f = 0; f < u.length; f++) {
-          const c = u[f], d = l[c];
-          if (d?.isTexture === !0) {
-            const p = d.userData?.associations?.textures;
-            if (p == null) continue;
-            const b = s.parser.json.textures[p];
-            if (!b) {
-              console.warn("Texture data not found for texture index " + p);
+      let o = function(a) {
+        if (a[ue] == !0) return;
+        a[ue] = !0, a.userData && (a.userData.LOD = -1);
+        const u = Object.keys(a);
+        for (let d = 0; d < u.length; d++) {
+          const c = u[d], f = a[c];
+          if (f?.isTexture === !0) {
+            const h = f.userData?.associations?.textures;
+            if (h == null) continue;
+            const D = s.parser.json.textures[h];
+            if (!D) {
+              console.warn("Texture data not found for texture index " + h);
               continue;
             }
-            if (b?.extensions?.[U]) {
-              const y = b.extensions[U];
-              y && n && g.registerTexture(n, d, y.lods.length, p, y);
+            if (D?.extensions?.[z]) {
+              const L = D.extensions[z];
+              L && n && p.registerTexture(n, f, L.lods.length, h, L);
             }
           }
         }
       };
-      const a = e.material;
-      if (Array.isArray(a)) for (const l of a) o(l);
-      else o(a);
+      const l = e.material;
+      if (Array.isArray(l)) for (const a of l) o(a);
+      else o(l);
     }
   }
   tryParseMeshLOD(t, e) {
-    if (e[Ce] == !0) return;
-    e[Ce] = !0;
+    if (e[Ae] == !0) return;
+    e[Ae] = !0;
     const s = this.tryGetCurrentModelViewer(t), r = this.getUrl(s);
     if (!r)
       return;
-    const n = e.userData?.gltfExtensions?.[U];
+    const n = e.userData?.gltfExtensions?.[z];
     if (n && r) {
       const o = e.uuid;
-      g.registerMesh(r, o, e, 0, n.lods.length, n);
+      p.registerMesh(r, o, e, 0, n.lods.length, n);
     }
   }
 }
-function jt(...i) {
+function Kt(...i) {
   let t, e, s, r;
   switch (i.length) {
     case 2:
@@ -1879,22 +1898,22 @@ function jt(...i) {
     default:
       throw new Error("Invalid arguments");
   }
-  _e(e), Ge(s), We(s, {
+  _e(e), Fe(s), Ue(s, {
     progressive: !0,
     ...r?.hints
-  }), s.register((o) => new g(o));
-  const n = I.get(e);
+  }), s.register((o) => new p(o));
+  const n = G.get(e);
   return r?.enableLODsManager !== !1 && n.enable(), n;
 }
-Ee();
+Ve();
 if (!_t) {
   const i = {
     gltfProgressive: {
-      useNeedleProgressive: jt,
-      LODsManager: I,
-      configureLoader: We,
-      getRaycastMesh: ne,
-      useRaycastMeshes: bt
+      useNeedleProgressive: Kt,
+      LODsManager: G,
+      configureLoader: Ue,
+      getRaycastMesh: ae,
+      useRaycastMeshes: Tt
     }
   };
   if (!globalThis.Needle)
@@ -1904,21 +1923,22 @@ if (!_t) {
       globalThis.Needle[t] = i[t];
 }
 export {
-  U as EXTENSION_NAME,
-  I as LODsManager,
-  g as NEEDLE_progressive,
-  ut as VERSION,
-  Ge as addDracoAndKTX2Loaders,
-  Ut as calculateMeshLODLevel,
-  We as configureLoader,
+  z as EXTENSION_NAME,
+  G as LODsManager,
+  p as NEEDLE_progressive,
+  ct as VERSION,
+  Fe as addDracoAndKTX2Loaders,
+  zt as calculateMeshLODLevel,
+  Ue as configureLoader,
   _e as createLoaders,
-  Et as getLODColor,
-  ne as getRaycastMesh,
-  Se as lodDebugColors,
-  Ee as patchModelViewer,
-  Mt as registerRaycastMesh,
-  ht as setDracoDecoderLocation,
-  gt as setKTX2TranscoderLocation,
-  jt as useNeedleProgressive,
-  bt as useRaycastMeshes
+  es as disposeLoaders,
+  Nt as getLODColor,
+  ae as getRaycastMesh,
+  Pe as lodDebugColors,
+  Ve as patchModelViewer,
+  bt as registerRaycastMesh,
+  gt as setDracoDecoderLocation,
+  pt as setKTX2TranscoderLocation,
+  Kt as useNeedleProgressive,
+  Tt as useRaycastMeshes
 };