@needle-tools/gltf-progressive 3.3.5 → 3.4.0-next.a9f46ea

package/gltf-progressive.js

@@ -1,87 +1,87 @@
-import { BufferGeometry as J, Mesh as q, Box3 as he, Vector3 as A, Sphere as De, CompressedTexture as $e, Texture as E, Matrix3 as Ge, InterleavedBuffer as Fe, InterleavedBufferAttribute as We, BufferAttribute as Ue, TextureLoader as ze, Matrix4 as _e, Clock as Ee, MeshStandardMaterial as Ne } from "three";
+import { BufferGeometry as E, Mesh as V, Box3 as he, Vector3 as C, Sphere as De, CompressedTexture as Be, Texture as F, Matrix3 as Ge, InterleavedBuffer as Fe, InterleavedBufferAttribute as We, BufferAttribute as Ue, TextureLoader as ze, Matrix4 as Le, Clock as Ne, MeshStandardMaterial as qe } from "three";
 import { GLTFLoader as ye } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { MeshoptDecoder as qe } from "three/examples/jsm/libs/meshopt_decoder.module.js";
+import { MeshoptDecoder as Ee } from "three/examples/jsm/libs/meshopt_decoder.module.js";
 import { DRACOLoader as Ve } from "three/examples/jsm/loaders/DRACOLoader.js";
 import { KTX2Loader as Xe } from "three/examples/jsm/loaders/KTX2Loader.js";
 const je = "";
 globalThis.GLTF_PROGRESSIVE_VERSION = je;
 console.debug("[gltf-progressive] version -");
-let C = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", V = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
-const Ke = C, Ye = V, Oe = new URL(C + "draco_decoder.js");
+let R = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", X = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
+const Ye = R, Ke = X, Oe = new URL(R + "draco_decoder.js");
 Oe.searchParams.append("range", "true");
 fetch(Oe, {
   method: "GET",
   headers: {
     Range: "bytes=0-1"
   }
-}).catch((i) => {
-  console.debug(`Failed to fetch remote Draco decoder from ${C} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), C === Ke && Qe("./include/draco/"), V === Ye && Je("./include/ktx2/");
+}).catch((n) => {
+  console.debug(`Failed to fetch remote Draco decoder from ${R} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), R === Ye && Qe("./include/draco/"), X === Ke && Je("./include/ktx2/");
 }).finally(() => {
   Pe();
 });
 const He = () => ({
-  dracoDecoderPath: C,
-  ktx2TranscoderPath: V
+  dracoDecoderPath: R,
+  ktx2TranscoderPath: X
 });
-function Qe(i) {
-  C = i, T && T[ge] != C ? (console.debug("Updating Draco decoder path to " + i), T[ge] = C, T.setDecoderPath(C), T.preload()) : console.debug("Setting Draco decoder path to " + i);
+function Qe(n) {
+  R = n, A && A[ge] != R ? (console.debug("Updating Draco decoder path to " + n), A[ge] = R, A.setDecoderPath(R), A.preload()) : console.debug("Setting Draco decoder path to " + n);
 }
-function Je(i) {
-  V = i, R && R.transcoderPath != V ? (console.debug("Updating KTX2 transcoder path to " + i), R.setTranscoderPath(V), R.init()) : console.debug("Setting KTX2 transcoder path to " + i);
+function Je(n) {
+  X = n, $ && $.transcoderPath != X ? (console.debug("Updating KTX2 transcoder path to " + n), $.setTranscoderPath(X), $.init()) : console.debug("Setting KTX2 transcoder path to " + n);
 }
-function xe(i) {
-  return Pe(), i ? R.detectSupport(i) : i !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: T, ktx2Loader: R, meshoptDecoder: ne };
+function xe(n) {
+  return Pe(), n ? $.detectSupport(n) : n !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: A, ktx2Loader: $, meshoptDecoder: oe };
 }
-function Se(i) {
-  i.dracoLoader || i.setDRACOLoader(T), i.ktx2Loader || i.setKTX2Loader(R), i.meshoptDecoder || i.setMeshoptDecoder(ne);
+function Se(n) {
+  n.dracoLoader || n.setDRACOLoader(A), n.ktx2Loader || n.setKTX2Loader($), n.meshoptDecoder || n.setMeshoptDecoder(oe);
 }
-const ge = Symbol("dracoDecoderPath");
-let T, ne, R;
+const ge = /* @__PURE__ */ Symbol("dracoDecoderPath");
+let A, oe, $;
 function Pe() {
-  T || (T = new Ve(), T[ge] = C, T.setDecoderPath(C), T.setDecoderConfig({ type: "js" }), T.preload()), R || (R = new Xe(), R.setTranscoderPath(V), R.init()), ne || (ne = qe);
+  A || (A = new Ve(), A[ge] = R, A.setDecoderPath(R), A.setDecoderConfig({ type: "js" }), A.preload()), $ || ($ = new Xe(), $.setTranscoderPath(X), $.init()), oe || (oe = Ee);
 }
 const pe = /* @__PURE__ */ new WeakMap();
-function Te(i, t) {
-  let e = pe.get(i);
-  e ? e = Object.assign(e, t) : e = t, pe.set(i, e);
+function Te(n, t) {
+  let e = pe.get(n);
+  e ? e = Object.assign(e, t) : e = t, pe.set(n, e);
 }
 const Ze = ye.prototype.load;
-function et(...i) {
+function et(...n) {
   const t = pe.get(this);
-  let e = i[0];
+  let e = n[0];
   const s = new URL(e, window.location.href);
   if (s.hostname.endsWith("needle.tools")) {
-    const r = t?.progressive !== void 0 ? t.progressive : !0, o = t?.usecase ? t.usecase : "default";
-    r ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${o}` : this.requestHeader.Accept = `*/*;usecase=${o}`, e = s.toString();
+    const r = t?.progressive !== void 0 ? t.progressive : !0, i = t?.usecase ? t.usecase : "default";
+    r ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${i}` : this.requestHeader.Accept = `*/*;usecase=${i}`, e = s.toString();
   }
-  return i[0] = e, Ze?.call(this, ...i);
+  return n[0] = e, Ze?.call(this, ...n);
 }
 ye.prototype.load = et;
-X("debugprogressive");
-function X(i) {
+j("debugprogressive");
+function j(n) {
   if (typeof window > "u") return !1;
-  const e = new URL(window.location.href).searchParams.get(i);
+  const e = new URL(window.location.href).searchParams.get(n);
   return e == null || e === "0" || e === "false" ? !1 : e === "" ? !0 : e;
 }
-function tt(i, t) {
-  if (t === void 0 || i === void 0 || t.startsWith("./") || t.startsWith("http") || t.startsWith("data:") || t.startsWith("blob:"))
+function tt(n, t) {
+  if (t === void 0 || n === void 0 || t.startsWith("./") || t.startsWith("http") || t.startsWith("data:") || t.startsWith("blob:"))
     return t;
-  const e = i.lastIndexOf("/");
+  const e = n.lastIndexOf("/");
   if (e >= 0) {
-    const s = i.substring(0, e + 1);
+    const s = n.substring(0, e + 1);
     for (; s.endsWith("/") && t.startsWith("/"); ) t = t.substring(1);
     return s + t;
   }
   return t;
 }
 function Ae() {
-  return K !== void 0 || (K = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), X("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", K)), K;
+  return K !== void 0 || (K = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), j("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", K)), K;
 }
 let K;
-function Le() {
+function _e() {
   if (typeof window > "u") return !1;
-  const i = new URL(window.location.href), t = i.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(i.hostname);
-  return i.hostname === "127.0.0.1" || t;
+  const n = new URL(window.location.href), t = n.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(n.hostname);
+  return n.hostname === "127.0.0.1" || t;
 }
 class st {
   constructor(t = 100, e = {}) {
@@ -110,87 +110,87 @@ class st {
     const t = this.maxConcurrent - this._running.size;
     for (let e = 0; e < t && this._queue.length > 0; e++) {
       this.debug && console.debug(`[PromiseQueue]: Running ${this._running.size} promises, waiting for ${this._queue.length} more.`);
-      const { key: s, resolve: n } = this._queue.shift();
-      n({
+      const { key: s, resolve: o } = this._queue.shift();
+      o({
         use: (r) => this.add(s, r)
       });
     }
   }
 }
-const rt = typeof window > "u" && typeof document > "u", me = Symbol("needle:raycast-mesh");
-function Z(i) {
-  return i?.[me] instanceof J ? i[me] : null;
+const rt = typeof window > "u" && typeof document > "u", me = /* @__PURE__ */ Symbol("needle:raycast-mesh");
+function Z(n) {
+  return n?.[me] instanceof E ? n[me] : null;
 }
-function nt(i, t) {
-  if ((i.type === "Mesh" || i.type === "SkinnedMesh") && !Z(i)) {
-    const s = it(t);
-    s.userData = { isRaycastMesh: !0 }, i[me] = s;
+function ot(n, t) {
+  if ((n.type === "Mesh" || n.type === "SkinnedMesh") && !Z(n)) {
+    const s = nt(t);
+    s.userData = { isRaycastMesh: !0 }, n[me] = s;
   }
 }
-function ot(i = !0) {
-  if (i) {
-    if (Y) return;
-    const t = Y = q.prototype.raycast;
-    q.prototype.raycast = function(e, s) {
-      const n = this, r = Z(n);
-      let o;
-      r && n.isMesh && (o = n.geometry, n.geometry = r), t.call(this, e, s), o && (n.geometry = o);
+function it(n = !0) {
+  if (n) {
+    if (H) return;
+    const t = H = V.prototype.raycast;
+    V.prototype.raycast = function(e, s) {
+      const o = this, r = Z(o);
+      let i;
+      r && o.isMesh && (i = o.geometry, o.geometry = r), t.call(this, e, s), i && (o.geometry = i);
     };
   } else {
-    if (!Y) return;
-    q.prototype.raycast = Y, Y = null;
+    if (!H) return;
+    V.prototype.raycast = H, H = null;
   }
 }
-let Y = null;
-function it(i) {
-  const t = new J();
-  for (const e in i.attributes)
-    t.setAttribute(e, i.getAttribute(e));
-  return t.setIndex(i.getIndex()), t;
+let H = null;
+function nt(n) {
+  const t = new E();
+  for (const e in n.attributes)
+    t.setAttribute(e, n.getAttribute(e));
+  return t.setIndex(n.getIndex()), t;
 }
-const U = new Array(), g = X("debugprogressive");
-let Q, N = -1;
+const z = new Array(), g = j("debugprogressive");
+let J, q = -1;
 if (g) {
-  let i = function() {
-    N += 1, N >= t && (N = -1), console.log(`Toggle LOD level [${N}]`);
+  let n = function() {
+    q += 1, q >= t && (q = -1), console.log(`Toggle LOD level [${q}]`);
   }, t = 6;
   window.addEventListener("keyup", (e) => {
-    e.key === "p" && i(), e.key === "w" && (Q = !Q, console.log(`Toggle wireframe [${Q}]`));
+    e.key === "p" && n(), e.key === "w" && (J = !J, console.log(`Toggle wireframe [${J}]`));
     const s = parseInt(e.key);
-    !isNaN(s) && s >= 0 && (N = s, console.log(`Set LOD level to [${N}]`));
+    !isNaN(s) && s >= 0 && (q = s, console.log(`Set LOD level to [${q}]`));
   });
 }
-function Ie(i) {
-  if (g && Q !== void 0)
-    if (Array.isArray(i))
-      for (const t of i)
-        Ie(t);
-    else i && "wireframe" in i && (i.wireframe = Q === !0);
+function Ce(n) {
+  if (g && J !== void 0)
+    if (Array.isArray(n))
+      for (const t of n)
+        Ce(t);
+    else n && "wireframe" in n && (n.wireframe = J === !0);
 }
-const H = new Array();
+const Q = new Array();
 let at = 0;
 const lt = Ae() ? 2 : 10;
-function ut(i) {
-  if (H.length < lt) {
-    const s = H.length;
+function dt(n) {
+  if (Q.length < lt) {
+    const s = Q.length;
     g && console.warn(`[Worker] Creating new worker #${s}`);
-    const n = we.createWorker(i || {});
-    return H.push(n), n;
+    const o = we.createWorker(n || {});
+    return Q.push(o), o;
   }
-  const t = at++ % H.length;
-  return H[t];
+  const t = at++ % Q.length;
+  return Q[t];
 }
 class we {
   constructor(t, e) {
     this.worker = t, this._debug = e.debug ?? !1, t.onmessage = (s) => {
-      const n = s.data;
-      switch (this._debug && console.log("[Worker] EVENT", n), n.type) {
+      const o = s.data;
+      switch (this._debug && console.log("[Worker] EVENT", o), o.type) {
         case "loaded-gltf":
           for (const r of this._running)
-            if (r.url === n.result.url) {
-              dt(n.result), r.resolve(n.result);
-              const o = r.url;
-              o.startsWith("blob:") && URL.revokeObjectURL(o);
+            if (r.url === o.result.url) {
+              ut(o.result), r.resolve(o.result);
+              const i = r.url;
+              i.startsWith("blob:") && URL.revokeObjectURL(i);
             }
       }
     }, t.onerror = (s) => {
@@ -202,7 +202,7 @@ class we {
   static async createWorker(t) {
     const e = new Worker(new URL(
       /* @vite-ignore */
-      "/assets/loader.worker-CwaLRBn2.js",
+      "/assets/loader.worker-CCrD-Ycm.js",
       import.meta.url
     ), {
       type: "module"
@@ -213,12 +213,12 @@ class we {
   _webglRenderer = null;
   async load(t, e) {
     const s = He();
-    let n = e?.renderer;
-    n || (this._webglRenderer ??= (async () => {
-      const { WebGLRenderer: u } = await import("three");
-      return new u();
-    })(), n = await this._webglRenderer);
-    const l = xe(n).ktx2Loader.workerConfig;
+    let o = e?.renderer;
+    o || (this._webglRenderer ??= (async () => {
+      const { WebGLRenderer: d } = await import("three");
+      return new d();
+    })(), o = await this._webglRenderer);
+    const l = xe(o).ktx2Loader.workerConfig;
     t instanceof URL ? t = t.toString() : t.startsWith("file:") ? t = URL.createObjectURL(new Blob([t])) : !t.startsWith("blob:") && !t.startsWith("http:") && !t.startsWith("https:") && (t = new URL(t, window.location.href).toString());
     const a = {
       type: "load",
@@ -227,60 +227,60 @@ class we {
       ktx2TranscoderPath: s.ktx2TranscoderPath,
       ktx2LoaderConfig: l
     };
-    return this._debug && console.debug("[Worker] Sending load request", a), this.worker.postMessage(a), new Promise((u) => {
+    return this._debug && console.debug("[Worker] Sending load request", a), this.worker.postMessage(a), new Promise((d) => {
       this._running.push({
         url: t.toString(),
-        resolve: u
+        resolve: d
       });
     });
   }
   _debug = !1;
 }
-function dt(i) {
-  for (const t of i.geometries) {
-    const e = t.geometry, s = new J();
+function ut(n) {
+  for (const t of n.geometries) {
+    const e = t.geometry, s = new E();
     if (s.name = e.name || "", e.index) {
-      const n = e.index;
-      s.setIndex(ae(n));
+      const o = e.index;
+      s.setIndex(ae(o));
     }
-    for (const n in e.attributes) {
-      const r = e.attributes[n], o = ae(r);
-      s.setAttribute(n, o);
+    for (const o in e.attributes) {
+      const r = e.attributes[o], i = ae(r);
+      s.setAttribute(o, i);
     }
     if (e.morphAttributes)
-      for (const n in e.morphAttributes) {
-        const o = e.morphAttributes[n].map((l) => ae(l));
-        s.morphAttributes[n] = o;
+      for (const o in e.morphAttributes) {
+        const i = e.morphAttributes[o].map((l) => ae(l));
+        s.morphAttributes[o] = i;
       }
-    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new he(), s.boundingBox.min = new A(
+    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new he(), s.boundingBox.min = new C(
       e.boundingBox?.min.x,
       e.boundingBox?.min.y,
       e.boundingBox?.min.z
-    ), s.boundingBox.max = new A(
+    ), s.boundingBox.max = new C(
       e.boundingBox?.max.x,
       e.boundingBox?.max.y,
       e.boundingBox?.max.z
     ), s.boundingSphere = new De(
-      new A(
+      new C(
         e.boundingSphere?.center.x,
         e.boundingSphere?.center.y,
         e.boundingSphere?.center.z
       ),
       e.boundingSphere?.radius
     ), e.groups)
-      for (const n of e.groups)
-        s.addGroup(n.start, n.count, n.materialIndex);
+      for (const o of e.groups)
+        s.addGroup(o.start, o.count, o.materialIndex);
     e.userData && (s.userData = e.userData), t.geometry = s;
   }
-  for (const t of i.textures) {
+  for (const t of n.textures) {
     const e = t.texture;
     let s = null;
     if (e.isCompressedTexture) {
-      const n = e.mipmaps, r = e.image?.width || e.source?.data?.width || -1, o = e.image?.height || e.source?.data?.height || -1;
-      s = new $e(
-        n,
-        r,
+      const o = e.mipmaps, r = e.image?.width || e.source?.data?.width || -1, i = e.image?.height || e.source?.data?.height || -1;
+      s = new Be(
         o,
+        r,
+        i,
         e.format,
         e.type,
         e.mapping,
@@ -292,7 +292,7 @@ function dt(i) {
         e.colorSpace
       );
     } else
-      s = new E(
+      s = new F(
         e.image,
         e.mapping,
         e.wrapS,
@@ -310,21 +310,21 @@ function dt(i) {
     }
     t.texture = s;
   }
-  return i;
+  return n;
 }
-function ae(i) {
-  let t = i;
-  if ("isInterleavedBufferAttribute" in i && i.isInterleavedBufferAttribute) {
-    const e = i.data, s = e.array, n = new Fe(s, e.stride);
-    t = new We(n, i.itemSize, s.byteOffset, i.normalized), t.offset = i.offset;
-  } else "isBufferAttribute" in i && i.isBufferAttribute && (t = new Ue(i.array, i.itemSize, i.normalized), t.usage = i.usage, t.gpuType = i.gpuType, t.updateRanges = i.updateRanges);
+function ae(n) {
+  let t = n;
+  if ("isInterleavedBufferAttribute" in n && n.isInterleavedBufferAttribute) {
+    const e = n.data, s = e.array, o = new Fe(s, e.stride);
+    t = new We(o, n.itemSize, s.byteOffset, n.normalized), t.offset = n.offset;
+  } else "isBufferAttribute" in n && n.isBufferAttribute && (t = new Ue(n.array, n.itemSize, n.normalized), t.usage = n.usage, t.gpuType = n.gpuType, t.updateRanges = n.updateRanges);
   return t;
 }
-const ct = X("gltf-progressive-worker"), ft = X("gltf-progressive-reduce-mipmaps"), le = Symbol("needle-progressive-texture"), F = "NEEDLE_progressive";
-class y {
+const ct = j("gltf-progressive-worker"), ft = j("gltf-progressive-reduce-mipmaps"), le = /* @__PURE__ */ Symbol("needle-progressive-texture"), W = "NEEDLE_progressive";
+class m {
   /** The name of the extension */
   get name() {
-    return F;
+    return W;
   }
   // #region PUBLIC API
   static getMeshLODExtension(t) {
@@ -336,7 +336,7 @@ class y {
     return e ?? -1;
   }
   static getMaterialMinMaxLODsCount(t, e) {
-    const s = this, n = "LODS:minmax", r = t[n];
+    const s = this, o = "LODS:minmax", r = t[o];
     if (r != null) return r;
     if (e || (e = {
       min_count: 1 / 0,
@@ -345,31 +345,31 @@ class y {
     }), Array.isArray(t)) {
       for (const l of t)
         this.getMaterialMinMaxLODsCount(l, e);
-      return t[n] = e, e;
+      return t[o] = e, e;
     }
     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);
+        const d = l.uniforms[a].value;
+        d?.isTexture === !0 && i(d, e);
       }
     } else if (t.isMaterial)
       for (const l of Object.keys(t)) {
         const a = t[l];
-        a?.isTexture === !0 && o(a, e);
+        a?.isTexture === !0 && i(a, e);
       }
     else
       g && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
-    return t[n] = e, e;
-    function o(l, a) {
-      const u = s.getAssignedLODInformation(l);
-      if (u) {
-        const c = s.lodInfos.get(u.key);
-        if (c && c.lods) {
-          a.min_count = Math.min(a.min_count, c.lods.length), a.max_count = Math.max(a.max_count, c.lods.length);
-          for (let p = 0; p < c.lods.length; p++) {
-            const _ = c.lods[p];
-            _.width && (a.lods[p] = a.lods[p] || { min_height: 1 / 0, max_height: 0 }, a.lods[p].min_height = Math.min(a.lods[p].min_height, _.height), a.lods[p].max_height = Math.max(a.lods[p].max_height, _.height));
+    return t[o] = e, e;
+    function i(l, a) {
+      const d = s.getAssignedLODInformation(l);
+      if (d) {
+        const u = s.lodInfos.get(d.key);
+        if (u && u.lods) {
+          a.min_count = Math.min(a.min_count, u.lods.length), a.max_count = Math.max(a.max_count, u.lods.length);
+          for (let y = 0; y < u.lods.length; y++) {
+            const w = u.lods[y];
+            w.width && (a.lods[y] = a.lods[y] || { min_height: 1 / 0, max_height: 0 }, a.lods[y].min_height = Math.min(a.lods[y].min_height, w.height), a.lods[y].max_height = Math.max(a.lods[y].max_height, w.height));
           }
         }
       }
@@ -388,8 +388,8 @@ class y {
     }
     if (t.isMaterial === !0) {
       for (const r of Object.keys(t)) {
-        const o = t[r];
-        if (o && o.isTexture && this.hasLODLevelAvailable(o, e))
+        const i = t[r];
+        if (i && i.isTexture && this.hasLODLevelAvailable(i, e))
           return !0;
       }
       return !1;
@@ -398,12 +398,12 @@ class y {
         if (r.isMesh === !0 && this.hasLODLevelAvailable(r, e))
           return !0;
     }
-    let s, n;
+    let s, o;
     if (t.isMesh ? s = t.geometry : (t.isBufferGeometry || t.isTexture) && (s = t), s && s?.userData?.LODS) {
       const r = s.userData.LODS;
-      if (n = this.lodInfos.get(r.key), e === void 0) return n != null;
-      if (n)
-        return Array.isArray(n.lods) ? e < n.lods.length : e === 0;
+      if (o = this.lodInfos.get(r.key), e === void 0) return o != null;
+      if (o)
+        return Array.isArray(o.lods) ? e < o.lods.length : e === 0;
     }
     return !1;
   }
@@ -423,16 +423,16 @@ class y {
    */
   static assignMeshLOD(t, e) {
     if (!t) return Promise.resolve(null);
-    if (t instanceof q || t.isMesh === !0) {
-      const s = t.geometry, n = this.getAssignedLODInformation(s);
-      if (!n)
+    if (t instanceof V || t.isMesh === !0) {
+      const s = t.geometry, o = this.getAssignedLODInformation(s);
+      if (!o)
         return Promise.resolve(null);
-      for (const r of U)
+      for (const r of z)
         r.onBeforeGetLODMesh?.(t, e);
-      return t["LOD:requested level"] = e, y.getOrLoadLOD(s, e).then((r) => {
+      return t["LOD:requested level"] = e, m.getOrLoadLOD(s, e).then((r) => {
         if (Array.isArray(r)) {
-          const o = n.index || 0;
-          r = r[o];
+          const i = o.index || 0;
+          r = r[i];
         }
         return t["LOD:requested level"] === e && (delete t["LOD:requested level"], r && s != r && (r?.isBufferGeometry ? t.geometry = r : g && console.error("Invalid LOD geometry", r))), r;
       }).catch((r) => (console.error("Error loading mesh LOD", t, r), null));
@@ -444,72 +444,72 @@ class y {
     if (t.isMesh === !0) {
       const s = t;
       if (Array.isArray(s.material)) {
-        const n = new Array();
+        const o = new Array();
         for (const r of s.material) {
-          const o = this.assignTextureLOD(r, e);
-          n.push(o);
+          const i = this.assignTextureLOD(r, e);
+          o.push(i);
         }
-        return Promise.all(n).then((r) => {
-          const o = new Array();
+        return Promise.all(o).then((r) => {
+          const i = new Array();
           for (const l of r)
-            Array.isArray(l) && o.push(...l);
-          return o;
+            Array.isArray(l) && i.push(...l);
+          return i;
         });
       } else
         return this.assignTextureLOD(s.material, e);
     }
     if (t.isMaterial === !0) {
-      const s = t, n = [], r = new Array();
+      const s = t, o = [], r = new Array();
       if (s.uniforms && (s.isRawShaderMaterial || s.isShaderMaterial === !0)) {
-        const o = s;
-        for (const l of Object.keys(o.uniforms)) {
-          const a = o.uniforms[l].value;
+        const i = s;
+        for (const l of Object.keys(i.uniforms)) {
+          const a = i.uniforms[l].value;
           if (a?.isTexture === !0) {
-            const u = this.assignTextureLODForSlot(a, e, s, l).then((c) => (c && o.uniforms[l].value != c && (o.uniforms[l].value = c, o.uniformsNeedUpdate = !0), c));
-            n.push(u), r.push(l);
+            const d = this.assignTextureLODForSlot(a, e, s, l).then((u) => (u && i.uniforms[l].value != u && (i.uniforms[l].value = u, i.uniformsNeedUpdate = !0), u));
+            o.push(d), r.push(l);
           }
         }
       } else
-        for (const o of Object.keys(s)) {
-          const l = s[o];
+        for (const i of Object.keys(s)) {
+          const l = s[i];
           if (l?.isTexture === !0) {
-            const a = this.assignTextureLODForSlot(l, e, s, o);
-            n.push(a), r.push(o);
+            const a = this.assignTextureLODForSlot(l, e, s, i);
+            o.push(a), r.push(i);
           }
         }
-      return Promise.all(n).then((o) => {
+      return Promise.all(o).then((i) => {
         const l = new Array();
-        for (let a = 0; a < o.length; a++) {
-          const u = o[a], c = r[a];
-          u && u.isTexture === !0 ? l.push({ material: s, slot: c, texture: u, level: e }) : l.push({ material: s, slot: c, texture: null, level: e });
+        for (let a = 0; a < i.length; a++) {
+          const d = i[a], u = r[a];
+          d && d.isTexture === !0 ? l.push({ material: s, slot: u, texture: d, level: e }) : l.push({ material: s, slot: u, texture: null, level: e });
         }
         return l;
       });
     }
-    if (t instanceof E || t.isTexture === !0) {
+    if (t instanceof F || t.isTexture === !0) {
       const s = t;
       return this.assignTextureLODForSlot(s, e, null, null);
     }
     return Promise.resolve(null);
   }
   // #region INTERNAL
-  static assignTextureLODForSlot(t, e, s, n) {
-    return t?.isTexture !== !0 ? Promise.resolve(null) : n === "glyphMap" ? Promise.resolve(t) : y.getOrLoadLOD(t, e).then((r) => {
+  static assignTextureLODForSlot(t, e, s, o) {
+    return t?.isTexture !== !0 ? Promise.resolve(null) : o === "glyphMap" ? Promise.resolve(t) : m.getOrLoadLOD(t, e).then((r) => {
       if (Array.isArray(r))
         return console.warn("Progressive: Got an array of textures for a texture slot, this should not happen..."), null;
       if (r?.isTexture === !0) {
-        if (r != t && s && n) {
-          const o = s[n];
-          if (o && !g) {
-            const l = this.getAssignedLODInformation(o);
+        if (r != t && s && o) {
+          const i = s[o];
+          if (i && !g) {
+            const l = this.getAssignedLODInformation(i);
             if (l && l?.level < e)
-              return g === "verbose" && console.warn("Assigned texture level is already higher: ", l.level, e, s, o, r), null;
+              return g === "verbose" && console.warn("Assigned texture level is already higher: ", l.level, e, s, i, r), null;
           }
           if (ft && r.mipmaps) {
             const l = r.mipmaps.length;
             r.mipmaps.length = Math.min(r.mipmaps.length, 3), l !== r.mipmaps.length && g && console.debug(`Reduced mipmap count from ${l} to ${r.mipmaps.length} for ${r.uuid}: ${r.image?.width}x${r.image?.height}.`);
           }
-          s[n] = r;
+          s[o] = r;
         }
         return r;
       } else g == "verbose" && console.warn("No LOD found for", t, e);
@@ -525,8 +525,8 @@ class y {
   _isLoadingMesh;
   loadMesh = (t) => {
     if (this._isLoadingMesh) return null;
-    const e = this.parser.json.meshes[t]?.extensions?.[F];
-    return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((s) => (this._isLoadingMesh = !1, s && y.registerMesh(this.url, e.guid, s, e.lods?.length, 0, e), s))) : null;
+    const e = this.parser.json.meshes[t]?.extensions?.[W];
+    return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((s) => (this._isLoadingMesh = !1, s && m.registerMesh(this.url, e.guid, s, e.lods?.length, 0, e), s))) : null;
   };
   // private _isLoadingTexture;
   // loadTexture = (textureIndex: number) => {
@@ -545,28 +545,28 @@ class y {
   afterRoot(t) {
     return g && console.log("AFTER", this.url, t), this.parser.json.textures?.forEach((e, s) => {
       if (e?.extensions) {
-        const n = e?.extensions[F];
-        if (n) {
-          if (!n.lods) {
-            g && console.warn("Texture has no LODs", n);
+        const o = e?.extensions[W];
+        if (o) {
+          if (!o.lods) {
+            g && console.warn("Texture has no LODs", o);
             return;
           }
           let r = !1;
-          for (const o of this.parser.associations.keys())
-            o.isTexture === !0 && this.parser.associations.get(o)?.textures === s && (r = !0, y.registerTexture(this.url, o, n.lods?.length, s, n));
-          r || this.parser.getDependency("texture", s).then((o) => {
-            o && y.registerTexture(this.url, o, n.lods?.length, s, n);
+          for (const i of this.parser.associations.keys())
+            i.isTexture === !0 && this.parser.associations.get(i)?.textures === s && (r = !0, m.registerTexture(this.url, i, o.lods?.length, s, o));
+          r || this.parser.getDependency("texture", s).then((i) => {
+            i && m.registerTexture(this.url, i, o.lods?.length, s, o);
           });
         }
       }
     }), this.parser.json.meshes?.forEach((e, s) => {
       if (e?.extensions) {
-        const n = e?.extensions[F];
-        if (n && n.lods) {
+        const o = e?.extensions[W];
+        if (o && o.lods) {
           for (const r of this.parser.associations.keys())
             if (r.isMesh) {
-              const o = this.parser.associations.get(r);
-              o?.meshes === s && y.registerMesh(this.url, n.guid, r, n.lods.length, o.primitives, n);
+              const i = this.parser.associations.get(r);
+              i?.meshes === s && m.registerMesh(this.url, o.guid, r, o.lods.length, i.primitives, o);
             }
         }
       }
@@ -575,175 +575,251 @@ class y {
   /**
    * Register a texture with LOD information
    */
-  static registerTexture = (t, e, s, n, r) => {
+  static registerTexture = (t, e, s, o, r) => {
     if (!e) {
       g && console.error("!! gltf-progressive: Called register texture without texture");
       return;
     }
     if (g) {
       const l = e.image?.width || e.source?.data?.width || 0, a = e.image?.height || e.source?.data?.height || 0;
-      console.log(`> gltf-progressive: register texture[${n}] "${e.name || e.uuid}", Current: ${l}x${a}, Max: ${r.lods[0]?.width}x${r.lods[0]?.height}, uuid: ${e.uuid}`, r, e);
+      console.log(`> gltf-progressive: register texture[${o}] "${e.name || e.uuid}", Current: ${l}x${a}, Max: ${r.lods[0]?.width}x${r.lods[0]?.height}, uuid: ${e.uuid}`, r, e);
     }
     e.source && (e.source[le] = r);
-    const o = r.guid;
-    y.assignLODInformation(t, e, o, s, n), y.lodInfos.set(o, r), y.lowresCache.set(o, e);
+    const i = r.guid;
+    m.assignLODInformation(t, e, i, s, o), m.lodInfos.set(i, r), m.lowresCache.set(i, new WeakRef(e));
   };
   /**
    * Register a mesh with LOD information
    */
-  static registerMesh = (t, e, s, n, r, o) => {
+  static registerMesh = (t, e, s, o, r, i) => {
     const l = s.geometry;
     if (!l) {
       g && console.warn("gltf-progressive: Register mesh without geometry");
       return;
     }
-    l.userData || (l.userData = {}), g && console.log("> Progressive: register mesh " + s.name, { index: r, uuid: s.uuid }, o, s), y.assignLODInformation(t, l, e, n, r), y.lodInfos.set(e, o);
-    let a = y.lowresCache.get(e);
-    a ? a.push(s.geometry) : a = [s.geometry], y.lowresCache.set(e, a), n > 0 && !Z(s) && nt(s, l);
-    for (const u of U)
-      u.onRegisteredNewMesh?.(s, o);
+    l.userData || (l.userData = {}), g && console.log("> Progressive: register mesh " + s.name, { index: r, uuid: s.uuid }, i, s), m.assignLODInformation(t, l, e, o, r), m.lodInfos.set(e, i);
+    let d = m.lowresCache.get(e)?.deref();
+    d ? d.push(s.geometry) : d = [s.geometry], m.lowresCache.set(e, new WeakRef(d)), o > 0 && !Z(s) && ot(s, l);
+    for (const u of z)
+      u.onRegisteredNewMesh?.(s, i);
   };
+  /**
+   * Dispose cached resources to free memory.
+   * Call this when a model is removed from the scene to allow garbage collection of its LOD resources.
+   * Calls three.js `.dispose()` on cached Textures and BufferGeometries to free GPU memory.
+   * @param guid Optional GUID to dispose resources for a specific model. If omitted, all cached resources are cleared.
+   */
+  static dispose(t) {
+    if (t) {
+      this.lodInfos.delete(t);
+      const e = this.lowresCache.get(t);
+      if (e) {
+        const s = e.deref();
+        if (s) {
+          if (s.isTexture)
+            s.dispose();
+          else if (Array.isArray(s))
+            for (const o of s) o.dispose();
+        }
+        this.lowresCache.delete(t);
+      }
+      for (const [s, o] of this.previouslyLoaded)
+        s.includes(t) && (this._disposeCacheEntry(o), this.previouslyLoaded.delete(s));
+    } else {
+      this.lodInfos.clear();
+      for (const [, e] of this.lowresCache) {
+        const s = e.deref();
+        if (s) {
+          if (s.isTexture)
+            s.dispose();
+          else if (Array.isArray(s))
+            for (const o of s) o.dispose();
+        }
+      }
+      this.lowresCache.clear();
+      for (const [, e] of this.previouslyLoaded)
+        this._disposeCacheEntry(e);
+      this.previouslyLoaded.clear();
+    }
+  }
+  /** Dispose a single cache entry's three.js resource(s) to free GPU memory. */
+  static _disposeCacheEntry(t) {
+    t instanceof WeakRef ? t.deref()?.dispose() : t.then((e) => {
+      if (e)
+        if (Array.isArray(e))
+          for (const s of e) s.dispose();
+        else
+          e.dispose();
+    }).catch(() => {
+    });
+  }
   /** A map of key = asset uuid and value = LOD information */
   static lodInfos = /* @__PURE__ */ new Map();
-  /** cache of already loaded mesh lods */
+  /** cache of already loaded mesh lods. Uses WeakRef for single resources to allow garbage collection when unused. */
   static previouslyLoaded = /* @__PURE__ */ new Map();
-  /** this contains the geometry/textures that were originally loaded */
+  /** this contains the geometry/textures that were originally loaded. Uses WeakRef to allow garbage collection when unused. */
   static lowresCache = /* @__PURE__ */ new Map();
+  /**
+   * FinalizationRegistry to automatically clean up `previouslyLoaded` cache entries
+   * when their associated three.js resources are garbage collected by the browser.
+   * The held value is the cache key string used in `previouslyLoaded`.
+   */
+  static _resourceRegistry = new FinalizationRegistry((t) => {
+    const e = m.previouslyLoaded.get(t);
+    console.debug(`[gltf-progressive] FinalizationRegistry cleanup: Resource GC'd for ${t}.`), e instanceof WeakRef && (e.deref() || (m.previouslyLoaded.delete(t), g && console.log(`[gltf-progressive] Cache entry auto-cleaned (GC'd): ${t}`)));
+  });
   static workers = [];
   static _workersIndex = 0;
   static async getOrLoadLOD(t, e) {
-    const s = g == "verbose", n = this.getAssignedLODInformation(t);
-    if (!n)
+    const s = 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 r = n?.key;
-    let o;
+    const r = o?.key;
+    let i;
     if (t.isTexture === !0) {
       const a = t;
-      a.source && a.source[le] && (o = a.source[le]);
+      a.source && a.source[le] && (i = a.source[le]);
     }
-    if (o || (o = y.lodInfos.get(r)), !o)
-      g && console.warn(`Can not load LOD ${e}: no LOD info found for "${r}" ${t.name}`, t.type, y.lodInfos);
+    if (i || (i = m.lodInfos.get(r)), !i)
+      g && console.warn(`Can not load LOD ${e}: no LOD info found for "${r}" ${t.name}`, t.type, m.lodInfos);
     else {
       if (e > 0) {
-        let c = !1;
-        const p = Array.isArray(o.lods);
-        if (p && e >= o.lods.length ? c = !0 : p || (c = !0), c)
-          return this.lowresCache.get(r);
+        let u = !1;
+        const y = Array.isArray(i.lods);
+        if (y && e >= i.lods.length ? u = !0 : y || (u = !0), u) {
+          const w = this.lowresCache.get(r);
+          if (w) {
+            const L = w.deref();
+            if (L) return L;
+            this.lowresCache.delete(r), g && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${r}`);
+          }
+          return null;
+        }
       }
-      const a = Array.isArray(o.lods) ? o.lods[e]?.path : o.lods;
+      const a = Array.isArray(i.lods) ? i.lods[e]?.path : i.lods;
       if (!a)
-        return g && !o["missing:uri"] && (o["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, o)), null;
-      const u = tt(n.url, a);
-      if (u.endsWith(".glb") || u.endsWith(".gltf")) {
-        if (!o.guid)
-          return console.warn("missing pointer for glb/gltf texture", o), null;
-        const c = u + "_" + o.guid, p = await this.queue.slot(u), _ = this.previouslyLoaded.get(c);
-        if (_ !== void 0) {
-          s && console.log(`LOD ${e} was already loading/loaded: ${c}`);
-          let d = await _.catch((O) => (console.error(`Error loading LOD ${e} from ${u}
-`, O), null)), x = !1;
-          if (d == null || (d instanceof E && t instanceof E ? d.image?.data || d.source?.data ? d = this.copySettings(t, d) : (x = !0, this.previouslyLoaded.delete(c)) : d instanceof J && t instanceof J && (d.attributes.position?.array || (x = !0, this.previouslyLoaded.delete(c)))), !x)
-            return d;
-        }
-        if (!p.use)
-          return g && console.log(`LOD ${e} was aborted: ${u}`), null;
-        const v = o, I = new Promise(async (d, x) => {
+        return g && !i["missing:uri"] && (i["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, i)), null;
+      const d = tt(o.url, a);
+      if (d.endsWith(".glb") || d.endsWith(".gltf")) {
+        if (!i.guid)
+          return console.warn("missing pointer for glb/gltf texture", i), null;
+        const u = d + "_" + i.guid, y = await this.queue.slot(d), w = this.previouslyLoaded.get(u);
+        if (w !== void 0)
+          if (s && console.log(`LOD ${e} was already loading/loaded: ${u}`), w instanceof WeakRef) {
+            const c = w.deref();
+            if (c) {
+              let h = c, b = !1;
+              if (h instanceof F && t instanceof F ? h.image?.data || h.source?.data ? h = this.copySettings(t, h) : b = !0 : h instanceof E && t instanceof E && (h.attributes.position?.array || (b = !0)), !b)
+                return h;
+            }
+            this.previouslyLoaded.delete(u), g && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${u}`);
+          } else {
+            let c = await w.catch((b) => (console.error(`Error loading LOD ${e} from ${d}
+`, b), null)), h = !1;
+            if (c == null || (c instanceof F && t instanceof F ? c.image?.data || c.source?.data ? c = this.copySettings(t, c) : (h = !0, this.previouslyLoaded.delete(u)) : c instanceof E && t instanceof E && (c.attributes.position?.array || (h = !0, this.previouslyLoaded.delete(u)))), !h)
+              return c;
+          }
+        if (!y.use)
+          return g && console.log(`LOD ${e} was aborted: ${d}`), null;
+        const L = i, I = new Promise(async (c, h) => {
           if (ct) {
-            const m = await (await ut({})).load(u);
-            if (m.textures.length > 0)
-              for (const f of m.textures) {
-                let h = f.texture;
-                return y.assignLODInformation(n.url, h, r, e, void 0), t instanceof E && (h = this.copySettings(t, h)), h && (h.guid = v.guid), d(h);
+            const x = await (await dt({})).load(d);
+            if (x.textures.length > 0)
+              for (const f of x.textures) {
+                let p = f.texture;
+                return m.assignLODInformation(o.url, p, r, e, void 0), t instanceof F && (p = this.copySettings(t, p)), p && (p.guid = L.guid), c(p);
               }
-            if (m.geometries.length > 0) {
+            if (x.geometries.length > 0) {
               const f = new Array();
-              for (const h of m.geometries) {
-                const M = h.geometry;
-                y.assignLODInformation(n.url, M, r, e, h.primitiveIndex), f.push(M);
+              for (const p of x.geometries) {
+                const D = p.geometry;
+                m.assignLODInformation(o.url, D, r, e, p.primitiveIndex), f.push(D);
               }
-              return d(f);
+              return c(f);
             }
-            return d(null);
+            return c(null);
           }
-          const O = new ye();
-          Se(O), g && (await new Promise((w) => setTimeout(w, 1e3)), s && console.warn("Start loading (delayed) " + u, v.guid));
-          let B = u;
-          if (v && Array.isArray(v.lods)) {
-            const w = v.lods[e];
-            w.hash && (B += "?v=" + w.hash);
+          const b = new ye();
+          Se(b), g && (await new Promise((_) => setTimeout(_, 1e3)), s && console.warn("Start loading (delayed) " + d, L.guid));
+          let B = d;
+          if (L && Array.isArray(L.lods)) {
+            const _ = L.lods[e];
+            _.hash && (B += "?v=" + _.hash);
           }
-          const b = await O.loadAsync(B).catch((w) => (console.error(`Error loading LOD ${e} from ${u}
-`, w), d(null)));
-          if (!b)
-            return d(null);
-          const z = b.parser;
-          s && console.log("Loading finished " + u, v.guid);
-          let S = 0;
-          if (b.parser.json.textures) {
-            let w = !1;
-            for (const m of b.parser.json.textures) {
-              if (m?.extensions) {
-                const f = m?.extensions[F];
-                if (f?.guid && f.guid === v.guid) {
-                  w = !0;
+          const M = await b.loadAsync(B).catch((_) => (console.error(`Error loading LOD ${e} from ${d}
+`, _), c(null)));
+          if (!M)
+            return c(null);
+          const N = M.parser;
+          s && console.log("Loading finished " + d, L.guid);
+          let P = 0;
+          if (M.parser.json.textures) {
+            let _ = !1;
+            for (const x of M.parser.json.textures) {
+              if (x?.extensions) {
+                const f = x?.extensions[W];
+                if (f?.guid && f.guid === L.guid) {
+                  _ = !0;
                   break;
                 }
               }
-              S++;
+              P++;
             }
-            if (w) {
-              let m = await z.getDependency("texture", S);
-              return m && y.assignLODInformation(n.url, m, r, e, void 0), s && console.log('change "' + t.name + '" → "' + m.name + '"', u, S, m, c), t instanceof E && (m = this.copySettings(t, m)), m && (m.guid = v.guid), d(m);
-            } else g && console.warn("Could not find texture with guid", v.guid, b.parser.json);
+            if (_) {
+              let x = await N.getDependency("texture", P);
+              return x && m.assignLODInformation(o.url, x, r, e, void 0), s && console.log('change "' + t.name + '" → "' + x.name + '"', d, P, x, u), t instanceof F && (x = this.copySettings(t, x)), x && (x.guid = L.guid), c(x);
+            } else g && console.warn("Could not find texture with guid", L.guid, M.parser.json);
           }
-          if (S = 0, b.parser.json.meshes) {
-            let w = !1;
-            for (const m of b.parser.json.meshes) {
-              if (m?.extensions) {
-                const f = m?.extensions[F];
-                if (f?.guid && f.guid === v.guid) {
-                  w = !0;
+          if (P = 0, M.parser.json.meshes) {
+            let _ = !1;
+            for (const x of M.parser.json.meshes) {
+              if (x?.extensions) {
+                const f = x?.extensions[W];
+                if (f?.guid && f.guid === L.guid) {
+                  _ = !0;
                   break;
                 }
               }
-              S++;
+              P++;
             }
-            if (w) {
-              const m = await z.getDependency("mesh", S);
-              if (s && console.log(`Loaded Mesh "${m.name}"`, u, S, m, c), m.isMesh === !0) {
-                const f = m.geometry;
-                return y.assignLODInformation(n.url, f, r, e, 0), d(f);
+            if (_) {
+              const x = await N.getDependency("mesh", P);
+              if (s && console.log(`Loaded Mesh "${x.name}"`, d, P, x, u), x.isMesh === !0) {
+                const f = x.geometry;
+                return m.assignLODInformation(o.url, f, r, e, 0), c(f);
               } else {
                 const f = new Array();
-                for (let h = 0; h < m.children.length; h++) {
-                  const M = m.children[h];
-                  if (M.isMesh === !0) {
-                    const D = M.geometry;
-                    y.assignLODInformation(n.url, D, r, e, h), f.push(D);
+                for (let p = 0; p < x.children.length; p++) {
+                  const D = x.children[p];
+                  if (D.isMesh === !0) {
+                    const S = D.geometry;
+                    m.assignLODInformation(o.url, S, r, e, p), f.push(S);
                   }
                 }
-                return d(f);
+                return c(f);
               }
-            } else g && console.warn("Could not find mesh with guid", v.guid, b.parser.json);
+            } else g && console.warn("Could not find mesh with guid", L.guid, M.parser.json);
           }
-          return d(null);
+          return c(null);
         });
-        return this.previouslyLoaded.set(c, I), p.use(I), await I;
-      } else if (t instanceof E) {
-        s && console.log("Load texture from uri: " + u);
-        const p = await new ze().loadAsync(u);
-        return p ? (p.guid = o.guid, p.flipY = !1, p.needsUpdate = !0, p.colorSpace = t.colorSpace, s && console.log(o, p)) : g && console.warn("failed loading", u), p;
+        this.previouslyLoaded.set(u, I), y.use(I);
+        const O = await I;
+        return O != null ? Array.isArray(O) ? this.previouslyLoaded.set(u, Promise.resolve(O)) : (this.previouslyLoaded.set(u, new WeakRef(O)), m._resourceRegistry.register(O, u)) : this.previouslyLoaded.set(u, Promise.resolve(null)), O;
+      } else if (t instanceof F) {
+        s && console.log("Load texture from uri: " + d);
+        const y = await new ze().loadAsync(d);
+        return y ? (y.guid = i.guid, y.flipY = !1, y.needsUpdate = !0, y.colorSpace = t.colorSpace, s && console.log(i, y)) : g && console.warn("failed loading", d), y;
       }
     }
     return null;
   }
   static maxConcurrent = 50;
-  static queue = new st(y.maxConcurrent, { debug: g != !1 });
-  static assignLODInformation(t, e, s, n, r) {
+  static queue = new st(m.maxConcurrent, { debug: g != !1 });
+  static assignLODInformation(t, e, s, o, r) {
     if (!e) return;
     e.userData || (e.userData = {});
-    const o = new ht(t, s, n, r);
-    e.userData.LODS = o, "source" in e && typeof e.source == "object" && (e.source.LODS = o);
+    const i = new ht(t, s, o, r);
+    e.userData.LODS = i, "source" in e && typeof e.source == "object" && (e.source.LODS = i);
   }
   static getAssignedLODInformation(t) {
     return t ? t.userData?.LODS ? t.userData.LODS : "source" in t && t.source?.LODS ? t.source.LODS : null : null;
@@ -762,13 +838,13 @@ class ht {
   level;
   /** For multi objects (e.g. a group of meshes) this is the index of the object */
   index;
-  constructor(t, e, s, n) {
-    this.url = t, this.key = e, this.level = s, n != null && (this.index = n);
+  constructor(t, e, s, o) {
+    this.url = t, this.key = e, this.level = s, o != null && (this.index = o);
   }
 }
-class ue {
-  static addPromise = (t, e, s, n) => {
-    n.forEach((r) => {
+class de {
+  static addPromise = (t, e, s, o) => {
+    o.forEach((r) => {
       r.add(t, e, s);
     });
   };
@@ -799,8 +875,8 @@ class ue {
   _awaiting = [];
   _maxPromisesPerObject = 1;
   constructor(t, e) {
-    const n = Math.max(e.frames ?? 2, 2);
-    this._frame_start = e.waitForFirstCapture ? void 0 : t, this._frames_to_capture = n, this.ready = new Promise((r) => {
+    const o = Math.max(e.frames ?? 2, 2);
+    this._frame_start = e.waitForFirstCapture ? void 0 : t, this._frames_to_capture = o, this.ready = new Promise((r) => {
       this._resolve = r;
     }), this.ready.finally(() => {
       this._resolved = !0, this._awaiting.length = 0;
@@ -821,12 +897,12 @@ class ue {
     if (!(this._frame_start !== void 0 && this._currentFrame > this._frame_start + this._frames_to_capture)) {
       if (this._maxPromisesPerObject >= 1)
         if (this._seen.has(e)) {
-          let n = this._seen.get(e);
-          if (n >= this._maxPromisesPerObject) {
+          let o = this._seen.get(e);
+          if (o >= this._maxPromisesPerObject) {
             g && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
             return;
           }
-          this._seen.set(e, n + 1);
+          this._seen.set(e, o + 1);
         } else
           this._seen.set(e, 1);
       this._awaiting.push(s), this._addedCount++, s.finally(() => {
@@ -842,8 +918,8 @@ class ue {
     });
   }
 }
-const k = X("debugprogressive"), gt = X("noprogressive"), de = Symbol("Needle:LODSManager"), ce = Symbol("Needle:LODState"), W = Symbol("Needle:CurrentLOD"), P = { mesh_lod: -1, texture_lod: -1 };
-class L {
+const k = j("debugprogressive"), gt = j("noprogressive"), ue = /* @__PURE__ */ Symbol("Needle:LODSManager"), ce = /* @__PURE__ */ Symbol("Needle:LODState"), U = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), T = { mesh_lod: -1, texture_lod: -1 };
+class v {
   /** 
    * 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.
    */
@@ -853,11 +929,11 @@ class L {
     return t[ce];
   }
   static addPlugin(t) {
-    U.push(t);
+    z.push(t);
   }
   static removePlugin(t) {
-    const e = U.indexOf(t);
-    e >= 0 && U.splice(e, 1);
+    const e = z.indexOf(t);
+    e >= 0 && z.splice(e, 1);
   }
   /**
    * Gets the LODsManager for the given renderer. If the LODsManager does not exist yet, it will be created.  
@@ -865,20 +941,20 @@ class L {
    * @returns The LODsManager instance.
    */
   static get(t, e) {
-    if (t[de])
-      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[de];
-    const s = new L(t, {
+    if (t[ue])
+      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[ue];
+    const s = new v(t, {
       engine: "unknown",
       ...e
     });
-    return t[de] = s, s;
+    return t[ue] = s, s;
   }
   renderer;
   context;
-  projectionScreenMatrix = new _e();
+  projectionScreenMatrix = new Le();
   /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
   get plugins() {
-    return U;
+    return z;
   }
   /**
    * Force override the LOD level for all objects (meshes + textures) rendered in the scene
@@ -919,13 +995,13 @@ class L {
    * Call to await LODs loading during the next render cycle.
    */
   awaitLoading(t) {
-    const e = this._promiseGroupIds++, s = new ue(this.#r, { ...t });
+    const e = this._promiseGroupIds++, s = new de(this.#r, { ...t });
     this._newPromiseGroups.push(s);
-    const n = performance.now();
+    const o = performance.now();
     return s.ready.finally(() => {
       const r = this._newPromiseGroups.indexOf(s);
-      r >= 0 && (this._newPromiseGroups.splice(r, 1), Le() && performance.measure("LODsManager:awaitLoading", {
-        start: n,
+      r >= 0 && (this._newPromiseGroups.splice(r, 1), _e() && performance.measure("LODsManager:awaitLoading", {
+        start: o,
         detail: { id: e, name: t?.name, awaited: s.awaitedCount, resolved: s.resolvedCount }
       }));
     }), s.ready;
@@ -950,10 +1026,10 @@ class L {
     this.renderer = t, this.context = { ...e };
   }
   #t;
-  #o = new Ee();
+  #i = new Ne();
   #r = 0;
+  #o = 0;
   #n = 0;
-  #i = 0;
   #s = 0;
   _fpsBuffer = [60, 60, 60, 60, 60];
   /**
@@ -965,11 +1041,11 @@ class L {
     let t = 0;
     this.#t = this.renderer.render;
     const e = this;
-    xe(this.renderer), this.renderer.render = function(s, n) {
+    xe(this.renderer), this.renderer.render = function(s, o) {
       const r = e.renderer.getRenderTarget();
-      (r == null || "isXRRenderTarget" in r && r.isXRRenderTarget) && (t = 0, e.#r += 1, e.#n = e.#o.getDelta(), e.#i += e.#n, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#n), e.#s = e._fpsBuffer.reduce((l, a) => l + a) / e._fpsBuffer.length, k && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
-      const o = t++;
-      e.#t.call(this, s, n), e.onAfterRender(s, n, o);
+      (r == null || "isXRRenderTarget" in r && r.isXRRenderTarget) && (t = 0, e.#r += 1, e.#o = e.#i.getDelta(), e.#n += e.#o, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#o), e.#s = e._fpsBuffer.reduce((l, a) => l + a) / e._fpsBuffer.length, k && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
+      const i = t++;
+      e.#t.call(this, s, o), e.onAfterRender(s, o, i);
     };
   }
   disable() {
@@ -981,12 +1057,12 @@ class L {
   onAfterRender(t, e, s) {
     if (this.pause) return;
     const r = this.renderer.renderLists.get(t, 0).opaque;
-    let o = !0;
+    let i = !0;
     if (r.length === 1) {
       const l = r[0].material;
-      (l.name === "EffectMaterial" || l.name === "CopyShader") && (o = !1);
+      (l.name === "EffectMaterial" || l.name === "CopyShader") && (i = !1);
     }
-    if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (o = !1), o) {
+    if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (i = !1), i) {
       if (gt || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, k && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, k && 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();
@@ -996,10 +1072,10 @@ class L {
    * Update LODs in a scene
    */
   internalUpdate(t, e) {
-    const s = this.renderer.renderLists.get(t, 0), n = s.opaque;
+    const s = this.renderer.renderLists.get(t, 0), o = s.opaque;
     this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse);
     const r = this.targetTriangleDensity;
-    for (const a of n) {
+    for (const a of o) {
       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")) {
         k && (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;
@@ -1015,36 +1091,36 @@ class L {
       }
       if (k === "color" && a.material && !a.object.progressive_debug_color) {
         a.object.progressive_debug_color = !0;
-        const c = Math.random() * 16777215, p = new Ne({ color: c });
-        a.object.material = p;
+        const u = Math.random() * 16777215, y = new qe({ color: u });
+        a.object.material = y;
       }
-      const u = a.object;
-      (u instanceof q || u.isMesh) && this.updateLODs(t, e, u, r);
+      const d = a.object;
+      (d instanceof V || d.isMesh) && this.updateLODs(t, e, d, r);
     }
-    const o = s.transparent;
-    for (const a of o) {
-      const u = a.object;
-      (u instanceof q || u.isMesh) && this.updateLODs(t, e, u, r);
+    const i = s.transparent;
+    for (const a of i) {
+      const d = a.object;
+      (d instanceof V || d.isMesh) && this.updateLODs(t, e, d, r);
     }
     const l = s.transmissive;
     for (const a of l) {
-      const u = a.object;
-      (u instanceof q || u.isMesh) && this.updateLODs(t, e, u, r);
+      const d = a.object;
+      (d instanceof V || d.isMesh) && this.updateLODs(t, e, d, r);
     }
   }
   /** Update the LOD levels for the renderer. */
-  updateLODs(t, e, s, n) {
+  updateLODs(t, e, s, o) {
     s.userData || (s.userData = {});
     let r = s[ce];
     if (r || (r = new pt(), s[ce] = r), r.frames++ < 2)
       return;
-    for (const l of U)
+    for (const l of z)
       l.onBeforeUpdateLOD?.(this.renderer, t, e, s);
-    const o = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : N;
-    o >= 0 ? (P.mesh_lod = o, P.texture_lod = o) : (this.calculateLodLevel(e, s, r, n, P), P.mesh_lod = Math.round(P.mesh_lod), P.texture_lod = Math.round(P.texture_lod)), P.mesh_lod >= 0 && this.loadProgressiveMeshes(s, P.mesh_lod), s.material && P.texture_lod >= 0 && this.loadProgressiveTextures(s.material, P.texture_lod, o), g && s.material && !s.isGizmo && Ie(s.material);
-    for (const l of U)
-      l.onAfterUpdatedLOD?.(this.renderer, t, e, s, P);
-    r.lastLodLevel_Mesh = P.mesh_lod, r.lastLodLevel_Texture = P.texture_lod;
+    const i = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : q;
+    i >= 0 ? (T.mesh_lod = i, T.texture_lod = i) : (this.calculateLodLevel(e, s, r, o, T), T.mesh_lod = Math.round(T.mesh_lod), T.texture_lod = Math.round(T.texture_lod)), T.mesh_lod >= 0 && this.loadProgressiveMeshes(s, T.mesh_lod), s.material && T.texture_lod >= 0 && this.loadProgressiveTextures(s.material, T.texture_lod, i), g && s.material && !s.isGizmo && Ce(s.material);
+    for (const l of z)
+      l.onAfterUpdatedLOD?.(this.renderer, t, e, s, T);
+    r.lastLodLevel_Mesh = T.mesh_lod, r.lastLodLevel_Texture = T.texture_lod;
   }
   /** Load progressive textures for the given material
    * @param material the material to load the textures for
@@ -1058,13 +1134,13 @@ class L {
         this.loadProgressiveTextures(r, e);
       return;
     }
-    let n = !1;
-    if ((t[W] === void 0 || e < t[W]) && (n = !0), s !== void 0 && s >= 0 && (n = t[W] != s, e = s), n) {
-      t[W] = e;
-      const r = y.assignTextureLOD(t, e).then((o) => {
+    let o = !1;
+    if ((t[U] === void 0 || e < t[U]) && (o = !0), s !== void 0 && s >= 0 && (o = t[U] != s, e = s), o) {
+      t[U] = e;
+      const r = m.assignTextureLOD(t, e).then((i) => {
         this._lodchangedlisteners.forEach((l) => l({ type: "texture", level: e, object: t }));
       });
-      ue.addPromise("texture", t, r, this._newPromiseGroups);
+      de.addPromise("texture", t, r, this._newPromiseGroups);
     }
   }
   /** Load progressive meshes for the given mesh
@@ -1075,12 +1151,12 @@ class L {
    */
   loadProgressiveMeshes(t, e) {
     if (!t) return Promise.resolve(null);
-    let s = t[W] !== e;
-    const n = t["DEBUG:LOD"];
-    if (n != null && (s = t[W] != n, e = n), s) {
-      t[W] = e;
-      const r = t.geometry, o = y.assignMeshLOD(t, e).then((l) => (l && t[W] == e && r != t.geometry && this._lodchangedlisteners.forEach((a) => a({ type: "mesh", level: e, object: t })), l));
-      return ue.addPromise("mesh", t, o, this._newPromiseGroups), o;
+    let s = t[U] !== e;
+    const o = t["DEBUG:LOD"];
+    if (o != null && (s = t[U] != o, e = o), s) {
+      t[U] = e;
+      const r = t.geometry, i = m.assignMeshLOD(t, e).then((l) => (l && t[U] == e && r != t.geometry && this._lodchangedlisteners.forEach((a) => a({ type: "mesh", level: e, object: t })), l));
+      return de.addPromise("mesh", t, i, this._newPromiseGroups), i;
     }
     return Promise.resolve(null);
   }
@@ -1088,23 +1164,23 @@ class L {
   _sphere = new De();
   _tempBox = new he();
   _tempBox2 = new he();
-  tempMatrix = new _e();
-  _tempWorldPosition = new A();
-  _tempBoxSize = new A();
-  _tempBox2Size = new A();
-  static corner0 = new A();
-  static corner1 = new A();
-  static corner2 = new A();
-  static corner3 = new A();
-  static _tempPtInside = new A();
+  tempMatrix = new Le();
+  _tempWorldPosition = new C();
+  _tempBoxSize = new C();
+  _tempBox2Size = new C();
+  static corner0 = new C();
+  static corner1 = new C();
+  static corner2 = new C();
+  static corner3 = new C();
+  static _tempPtInside = new C();
   static isInside(t, e) {
-    const s = t.min, n = t.max, r = (s.x + n.x) * 0.5, o = (s.y + n.y) * 0.5;
-    return this._tempPtInside.set(r, o, s.z).applyMatrix4(e).z < 0;
+    const s = t.min, o = t.max, r = (s.x + o.x) * 0.5, i = (s.y + o.y) * 0.5;
+    return this._tempPtInside.set(r, i, s.z).applyMatrix4(e).z < 0;
   }
   static skinnedMeshBoundsFrameOffsetCounter = 0;
-  static $skinnedMeshBoundsOffset = Symbol("gltf-progressive-skinnedMeshBoundsOffset");
+  static $skinnedMeshBoundsOffset = /* @__PURE__ */ Symbol("gltf-progressive-skinnedMeshBoundsOffset");
   // #region calculateLodLevel
-  calculateLodLevel(t, e, s, n, r) {
+  calculateLodLevel(t, e, s, o, r) {
     if (!e) {
       r.mesh_lod = -1, r.texture_lod = -1;
       return;
@@ -1116,33 +1192,33 @@ class L {
     let l = 10 + 1, a = !1;
     if (k && e["DEBUG:LOD"] != null)
       return e["DEBUG:LOD"];
-    const u = y.getMeshLODExtension(e.geometry)?.lods, c = y.getPrimitiveIndex(e.geometry), p = u && u.length > 0, _ = y.getMaterialMinMaxLODsCount(e.material), v = _.min_count !== 1 / 0 && _.min_count >= 0 && _.max_count >= 0;
-    if (!p && !v) {
+    const d = m.getMeshLODExtension(e.geometry)?.lods, u = m.getPrimitiveIndex(e.geometry), y = d && d.length > 0, w = m.getMaterialMinMaxLODsCount(e.material), L = w.min_count !== 1 / 0 && w.min_count >= 0 && w.max_count >= 0;
+    if (!y && !L) {
       r.mesh_lod = 0, r.texture_lod = 0;
       return;
     }
-    p || (a = !0, l = 0);
+    y || (a = !0, l = 0);
     const I = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let G = e.geometry.boundingBox;
+    let O = e.geometry.boundingBox;
     if (e.type === "SkinnedMesh") {
-      const d = e;
-      if (!d.boundingBox)
-        d.computeBoundingBox();
+      const c = e;
+      if (!c.boundingBox)
+        c.computeBoundingBox();
       else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
-        if (!d[L.$skinnedMeshBoundsOffset]) {
-          const O = L.skinnedMeshBoundsFrameOffsetCounter++;
-          d[L.$skinnedMeshBoundsOffset] = O;
+        if (!c[v.$skinnedMeshBoundsOffset]) {
+          const b = v.skinnedMeshBoundsFrameOffsetCounter++;
+          c[v.$skinnedMeshBoundsOffset] = b;
         }
-        const x = d[L.$skinnedMeshBoundsOffset];
-        if ((s.frames + x) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
-          const O = Z(d), B = d.geometry;
-          O && (d.geometry = O), d.computeBoundingBox(), d.geometry = B;
+        const h = c[v.$skinnedMeshBoundsOffset];
+        if ((s.frames + h) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
+          const b = Z(c), B = c.geometry;
+          b && (c.geometry = b), c.computeBoundingBox(), c.geometry = B;
         }
       }
-      G = d.boundingBox;
+      O = c.boundingBox;
     }
-    if (G) {
-      const d = t;
+    if (O) {
+      const c = t;
       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 f = t.getWorldPosition(this._tempWorldPosition);
@@ -1151,67 +1227,67 @@ class L {
           return;
         }
       }
-      if (this._tempBox.copy(G), this._tempBox.applyMatrix4(e.matrixWorld), d.isPerspectiveCamera && L.isInside(this._tempBox, this.projectionScreenMatrix)) {
+      if (this._tempBox.copy(O), this._tempBox.applyMatrix4(e.matrixWorld), c.isPerspectiveCamera && v.isInside(this._tempBox, this.projectionScreenMatrix)) {
         r.mesh_lod = 0, r.texture_lod = 0;
         return;
       }
-      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && d.isPerspectiveCamera && d.fov > 70) {
-        const f = this._tempBox.min, h = this._tempBox.max;
-        let M = f.x, D = f.y, $ = h.x, j = h.y;
-        const ee = 2, oe = 1.5, te = (f.x + h.x) * 0.5, se = (f.y + h.y) * 0.5;
-        M = (M - te) * ee + te, D = (D - se) * ee + se, $ = ($ - te) * ee + te, j = (j - se) * ee + se;
-        const Re = M < 0 && $ > 0 ? 0 : Math.min(Math.abs(f.x), Math.abs(h.x)), Be = D < 0 && j > 0 ? 0 : Math.min(Math.abs(f.y), Math.abs(h.y)), ie = Math.max(Re, Be);
-        s.lastCentrality = (oe - ie) * (oe - ie) * (oe - ie);
+      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && c.isPerspectiveCamera && c.fov > 70) {
+        const f = this._tempBox.min, p = this._tempBox.max;
+        let D = f.x, S = f.y, G = p.x, Y = p.y;
+        const ee = 2, ie = 1.5, te = (f.x + p.x) * 0.5, se = (f.y + p.y) * 0.5;
+        D = (D - te) * ee + te, S = (S - se) * ee + se, G = (G - te) * ee + te, Y = (Y - se) * ee + se;
+        const Re = D < 0 && G > 0 ? 0 : Math.min(Math.abs(f.x), Math.abs(p.x)), $e = S < 0 && Y > 0 ? 0 : Math.min(Math.abs(f.y), Math.abs(p.y)), ne = Math.max(Re, $e);
+        s.lastCentrality = (ie - ne) * (ie - ne) * (ie - ne);
       } else
         s.lastCentrality = 1;
-      const x = this._tempBox.getSize(this._tempBoxSize);
-      x.multiplyScalar(0.5), screen.availHeight > 0 && I > 0 && x.multiplyScalar(I / screen.availHeight), t.isPerspectiveCamera ? x.x *= t.aspect : t.isOrthographicCamera;
-      const O = t.matrixWorldInverse, B = this._tempBox2;
-      B.copy(G), B.applyMatrix4(e.matrixWorld), B.applyMatrix4(O);
-      const b = B.getSize(this._tempBox2Size), z = Math.max(b.x, b.y);
-      if (Math.max(x.x, x.y) != 0 && z != 0 && (x.z = b.z / Math.max(b.x, b.y) * Math.max(x.x, x.y)), s.lastScreenCoverage = Math.max(x.x, x.y, x.z), s.lastScreenspaceVolume.copy(x), s.lastScreenCoverage *= s.lastCentrality, k && L.debugDrawLine) {
+      const h = this._tempBox.getSize(this._tempBoxSize);
+      h.multiplyScalar(0.5), screen.availHeight > 0 && I > 0 && h.multiplyScalar(I / screen.availHeight), t.isPerspectiveCamera ? h.x *= t.aspect : t.isOrthographicCamera;
+      const b = t.matrixWorldInverse, B = this._tempBox2;
+      B.copy(O), B.applyMatrix4(e.matrixWorld), B.applyMatrix4(b);
+      const M = B.getSize(this._tempBox2Size), N = Math.max(M.x, M.y);
+      if (Math.max(h.x, h.y) != 0 && N != 0 && (h.z = M.z / Math.max(M.x, M.y) * Math.max(h.x, h.y)), s.lastScreenCoverage = Math.max(h.x, h.y, h.z), s.lastScreenspaceVolume.copy(h), s.lastScreenCoverage *= s.lastCentrality, k && v.debugDrawLine) {
         const f = this.tempMatrix.copy(this.projectionScreenMatrix);
         f.invert();
-        const h = L.corner0, M = L.corner1, D = L.corner2, $ = L.corner3;
-        h.copy(this._tempBox.min), M.copy(this._tempBox.max), M.x = h.x, D.copy(this._tempBox.max), D.y = h.y, $.copy(this._tempBox.max);
-        const j = (h.z + $.z) * 0.5;
-        h.z = M.z = D.z = $.z = j, h.applyMatrix4(f), M.applyMatrix4(f), D.applyMatrix4(f), $.applyMatrix4(f), L.debugDrawLine(h, M, 255), L.debugDrawLine(h, D, 255), L.debugDrawLine(M, $, 255), L.debugDrawLine(D, $, 255);
+        const p = v.corner0, D = v.corner1, S = v.corner2, G = v.corner3;
+        p.copy(this._tempBox.min), D.copy(this._tempBox.max), D.x = p.x, S.copy(this._tempBox.max), S.y = p.y, G.copy(this._tempBox.max);
+        const Y = (p.z + G.z) * 0.5;
+        p.z = D.z = S.z = G.z = Y, p.applyMatrix4(f), D.applyMatrix4(f), S.applyMatrix4(f), G.applyMatrix4(f), v.debugDrawLine(p, D, 255), v.debugDrawLine(p, S, 255), v.debugDrawLine(D, G, 255), v.debugDrawLine(S, G, 255);
       }
-      let w = 999;
-      if (u && s.lastScreenCoverage > 0)
-        for (let f = 0; f < u.length; f++) {
-          const h = u[f], D = (h.densities?.[c] || h.density || 1e-5) / s.lastScreenCoverage;
-          if (c > 0 && Le() && !h.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] && (window["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.")), D < n) {
-            w = f;
+      let _ = 999;
+      if (d && s.lastScreenCoverage > 0)
+        for (let f = 0; f < d.length; f++) {
+          const p = d[f], S = (p.densities?.[u] || p.density || 1e-5) / s.lastScreenCoverage;
+          if (u > 0 && _e() && !p.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] && (window["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.")), S < o) {
+            _ = f;
             break;
           }
         }
-      w < l && (l = w, a = !0);
+      _ < l && (l = _, a = !0);
     }
     if (a ? r.mesh_lod = l : r.mesh_lod = s.lastLodLevel_Mesh, k && r.mesh_lod != s.lastLodLevel_Mesh) {
-      const x = u?.[r.mesh_lod];
-      x && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${r.mesh_lod} (density: ${x.densities?.[c].toFixed(0)}) | ${e.name}`);
+      const h = d?.[r.mesh_lod];
+      h && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${r.mesh_lod} (density: ${h.densities?.[u].toFixed(0)}) | ${e.name}`);
     }
-    if (v) {
-      const d = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
+    if (L) {
+      const c = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
       if (s.lastLodLevel_Texture < 0) {
-        if (r.texture_lod = _.max_count - 1, k) {
-          const x = _.lods[_.max_count - 1];
-          k && console.log(`First Texture LOD ${r.texture_lod} (${x.max_height}px) - ${e.name}`);
+        if (r.texture_lod = w.max_count - 1, k) {
+          const h = w.lods[w.max_count - 1];
+          k && console.log(`First Texture LOD ${r.texture_lod} (${h.max_height}px) - ${e.name}`);
         }
       } else {
-        const x = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
-        let O = s.lastScreenCoverage * 4;
-        this.context?.engine === "model-viewer" && (O *= 1.5);
-        const b = I / window.devicePixelRatio * O;
-        let z = !1;
-        for (let S = _.lods.length - 1; S >= 0; S--) {
-          const w = _.lods[S];
-          if (!(d && w.max_height >= 2048) && !(Ae() && w.max_height > 4096) && (w.max_height > b || !z && S === 0)) {
-            if (z = !0, r.texture_lod = S, k && r.texture_lod < s.lastLodLevel_Texture) {
-              const m = w.max_height;
-              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${r.texture_lod} = ${m}px 
-Screensize: ${b.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${x.toFixed(1)} 
+        const h = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
+        let b = s.lastScreenCoverage * 4;
+        this.context?.engine === "model-viewer" && (b *= 1.5);
+        const M = I / window.devicePixelRatio * b;
+        let N = !1;
+        for (let P = w.lods.length - 1; P >= 0; P--) {
+          const _ = w.lods[P];
+          if (!(c && _.max_height >= 2048) && !(Ae() && _.max_height > 4096) && (_.max_height > M || !N && P === 0)) {
+            if (N = !0, r.texture_lod = P, k && r.texture_lod < s.lastLodLevel_Texture) {
+              const x = _.max_height;
+              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${r.texture_lod} = ${x}px 
+Screensize: ${M.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${h.toFixed(1)} 
 ${e.name}`);
             }
             break;
@@ -1227,68 +1303,68 @@ class pt {
   lastLodLevel_Mesh = -1;
   lastLodLevel_Texture = -1;
   lastScreenCoverage = 0;
-  lastScreenspaceVolume = new A();
+  lastScreenspaceVolume = new C();
   lastCentrality = 0;
 }
-const ve = Symbol("NEEDLE_mesh_lod"), re = Symbol("NEEDLE_texture_lod");
+const ve = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), re = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
 let fe = null;
-function ke() {
-  const i = mt();
-  i && (i.mapURLs(function(t) {
+function Ie() {
+  const n = mt();
+  n && (n.mapURLs(function(t) {
     return be(), t;
   }), be(), fe?.disconnect(), fe = new MutationObserver((t) => {
     t.forEach((e) => {
       e.addedNodes.forEach((s) => {
-        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Ce(s);
+        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && ke(s);
       });
     });
   }), fe.observe(document, { childList: !0, subtree: !0 }));
 }
 function mt() {
   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"), ke();
+  const n = customElements.get("model-viewer");
+  return n || (customElements.whenDefined("model-viewer").then(() => {
+    console.debug("[gltf-progressive] model-viewer defined"), Ie();
   }), null);
 }
 function be() {
   if (typeof document > "u") return;
   document.querySelectorAll("model-viewer").forEach((t) => {
-    Ce(t);
+    ke(t);
   });
 }
 const Me = /* @__PURE__ */ new WeakSet();
 let yt = 0;
-function Ce(i) {
-  if (!i || Me.has(i))
+function ke(n) {
+  if (!n || Me.has(n))
     return null;
-  Me.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++yt + `
-`, i.getAttribute("src"));
+  Me.add(n), console.debug("[gltf-progressive] found new model-viewer..." + ++yt + `
+`, n.getAttribute("src"));
   let t = null, e = null, s = null;
-  for (let n = i; n != null; n = Object.getPrototypeOf(n)) {
-    const r = Object.getOwnPropertySymbols(n), o = r.find((u) => u.toString() == "Symbol(renderer)"), l = r.find((u) => u.toString() == "Symbol(scene)"), a = r.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]);
+  for (let o = n; o != null; o = Object.getPrototypeOf(o)) {
+    const r = Object.getOwnPropertySymbols(o), i = r.find((d) => d.toString() == "Symbol(renderer)"), l = r.find((d) => d.toString() == "Symbol(scene)"), a = r.find((d) => d.toString() == "Symbol(needsRender)");
+    !t && i != null && (t = n[i].threeRenderer), !e && l != null && (e = n[l]), !s && a != null && (s = n[a]);
   }
   if (t && e) {
-    let n = function() {
+    let o = function() {
       if (s) {
-        let o = 0, l = setInterval(() => {
-          if (o++ > 5) {
+        let i = 0, l = setInterval(() => {
+          if (i++ > 5) {
             clearInterval(l);
             return;
           }
-          s?.call(i);
+          s?.call(n);
         }, 300);
       }
     };
     console.debug("[gltf-progressive] setup model-viewer");
-    const r = L.get(t, { engine: "model-viewer" });
-    return L.addPlugin(new xt()), r.enable(), r.addEventListener("changed", () => {
-      s?.call(i);
-    }), i.addEventListener("model-visibility", (o) => {
-      o.detail.visible && s?.call(i);
-    }), i.addEventListener("load", () => {
-      n();
+    const r = v.get(t, { engine: "model-viewer" });
+    return v.addPlugin(new xt()), r.enable(), r.addEventListener("changed", () => {
+      s?.call(n);
+    }), n.addEventListener("model-visibility", (i) => {
+      i.detail.visible && s?.call(n);
+    }), n.addEventListener("load", () => {
+      o();
     }), () => {
       r.disable();
     };
@@ -1297,8 +1373,8 @@ function Ce(i) {
 }
 class xt {
   _didWarnAboutMissingUrl = !1;
-  onBeforeUpdateLOD(t, e, s, n) {
-    this.tryParseMeshLOD(e, n), this.tryParseTextureLOD(e, n);
+  onBeforeUpdateLOD(t, e, s, o) {
+    this.tryParseMeshLOD(e, o), this.tryParseTextureLOD(e, o);
   }
   getUrl(t) {
     if (!t)
@@ -1315,99 +1391,99 @@ class xt {
   tryParseTextureLOD(t, e) {
     if (e[re] == !0) return;
     e[re] = !0;
-    const s = this.tryGetCurrentGLTF(t), n = this.tryGetCurrentModelViewer(t), r = this.getUrl(n);
+    const s = this.tryGetCurrentGLTF(t), o = this.tryGetCurrentModelViewer(t), r = this.getUrl(o);
     if (r && s && e.material) {
-      let o = function(a) {
+      let i = function(a) {
         if (a[re] == !0) return;
         a[re] = !0, a.userData && (a.userData.LOD = -1);
-        const u = Object.keys(a);
-        for (let c = 0; c < u.length; c++) {
-          const p = u[c], _ = a[p];
-          if (_?.isTexture === !0) {
-            const v = _.userData?.associations?.textures;
-            if (v == null) continue;
-            const I = s.parser.json.textures[v];
+        const d = Object.keys(a);
+        for (let u = 0; u < d.length; u++) {
+          const y = d[u], w = a[y];
+          if (w?.isTexture === !0) {
+            const L = w.userData?.associations?.textures;
+            if (L == null) continue;
+            const I = s.parser.json.textures[L];
             if (!I) {
-              console.warn("Texture data not found for texture index " + v);
+              console.warn("Texture data not found for texture index " + L);
               continue;
             }
-            if (I?.extensions?.[F]) {
-              const G = I.extensions[F];
-              G && r && y.registerTexture(r, _, G.lods.length, v, G);
+            if (I?.extensions?.[W]) {
+              const O = I.extensions[W];
+              O && r && m.registerTexture(r, w, O.lods.length, L, O);
             }
           }
         }
       };
       const l = e.material;
-      if (Array.isArray(l)) for (const a of l) o(a);
-      else o(l);
+      if (Array.isArray(l)) for (const a of l) i(a);
+      else i(l);
     }
   }
   tryParseMeshLOD(t, e) {
     if (e[ve] == !0) return;
     e[ve] = !0;
-    const s = this.tryGetCurrentModelViewer(t), n = this.getUrl(s);
-    if (!n)
+    const s = this.tryGetCurrentModelViewer(t), o = this.getUrl(s);
+    if (!o)
       return;
-    const r = e.userData?.gltfExtensions?.[F];
-    if (r && n) {
-      const o = e.uuid;
-      y.registerMesh(n, o, e, 0, r.lods.length, r);
+    const r = e.userData?.gltfExtensions?.[W];
+    if (r && o) {
+      const i = e.uuid;
+      m.registerMesh(o, i, e, 0, r.lods.length, r);
     }
   }
 }
-function wt(...i) {
-  let t, e, s, n;
-  switch (i.length) {
+function wt(...n) {
+  let t, e, s, o;
+  switch (n.length) {
     case 2:
-      [s, e] = i, n = {};
+      [s, e] = n, o = {};
       break;
     case 3:
-      [s, e, n] = i;
+      [s, e, o] = n;
       break;
     case 4:
-      [t, e, s, n] = i;
+      [t, e, s, o] = n;
       break;
     default:
       throw new Error("Invalid arguments");
   }
   xe(e), Se(s), Te(s, {
     progressive: !0,
-    ...n?.hints
-  }), s.register((o) => new y(o));
-  const r = L.get(e);
-  return n?.enableLODsManager !== !1 && r.enable(), r;
+    ...o?.hints
+  }), s.register((i) => new m(i));
+  const r = v.get(e);
+  return o?.enableLODsManager !== !1 && r.enable(), r;
 }
-ke();
+Ie();
 if (!rt) {
-  const i = {
+  const n = {
     gltfProgressive: {
       useNeedleProgressive: wt,
-      LODsManager: L,
+      LODsManager: v,
       configureLoader: Te,
       getRaycastMesh: Z,
-      useRaycastMeshes: ot
+      useRaycastMeshes: it
     }
   };
   if (!globalThis.Needle)
-    globalThis.Needle = i;
+    globalThis.Needle = n;
   else
-    for (const t in i)
-      globalThis.Needle[t] = i[t];
+    for (const t in n)
+      globalThis.Needle[t] = n[t];
 }
 export {
-  F as EXTENSION_NAME,
-  L as LODsManager,
-  y as NEEDLE_progressive,
+  W as EXTENSION_NAME,
+  v as LODsManager,
+  m as NEEDLE_progressive,
   je as VERSION,
   Se as addDracoAndKTX2Loaders,
   Te as configureLoader,
   xe as createLoaders,
   Z as getRaycastMesh,
-  ke as patchModelViewer,
-  nt as registerRaycastMesh,
+  Ie as patchModelViewer,
+  ot as registerRaycastMesh,
   Qe as setDracoDecoderLocation,
   Je as setKTX2TranscoderLocation,
   wt as useNeedleProgressive,
-  ot as useRaycastMeshes
+  it as useRaycastMeshes
 };