@needle-tools/gltf-progressive 3.1.0 → 3.1.1-next.1039397

package/gltf-progressive.js

@@ -1,108 +1,98 @@
-var Ye = Object.defineProperty;
-var He = (o, t, e) => t in o ? Ye(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
-var u = (o, t, e) => (He(o, typeof t != "symbol" ? t + "" : t, e), e), Be = (o, t, e) => {
-  if (!t.has(o))
-    throw TypeError("Cannot " + e);
-};
-var y = (o, t, e) => (Be(o, t, "read from private field"), e ? e.call(o) : t.get(o)), H = (o, t, e) => {
-  if (t.has(o))
-    throw TypeError("Cannot add the same private member more than once");
-  t instanceof WeakSet ? t.add(o) : t.set(o, e);
-}, q = (o, t, e, s) => (Be(o, t, "write to private field"), s ? s.call(o, e) : t.set(o, e), e);
-import { BufferGeometry as xe, Mesh as se, Texture as oe, TextureLoader as Qe, Matrix4 as Ge, Clock as je, MeshStandardMaterial as Je, Sphere as Ze, Box3 as Ee, Vector3 as W } from "three";
-import { GLTFLoader as Ce } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { MeshoptDecoder as et } from "three/examples/jsm/libs/meshopt_decoder.module.js";
-import { DRACOLoader as tt } from "three/examples/jsm/loaders/DRACOLoader.js";
-import { KTX2Loader as st } from "three/examples/jsm/loaders/KTX2Loader.js";
-const rt = "";
-globalThis.GLTF_PROGRESSIVE_VERSION = rt;
+import { BufferGeometry as Q, 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 Ue, BufferAttribute as We, TextureLoader as ze, Matrix4 as Le, Clock as Ee, MeshStandardMaterial as Ne } 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 { DRACOLoader as Ve } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { KTX2Loader as Xe } from "three/examples/jsm/loaders/KTX2Loader.js";
+const Ke = "";
+globalThis.GLTF_PROGRESSIVE_VERSION = Ke;
 console.debug("[gltf-progressive] version -");
-let V = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", re = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
-const it = V, nt = re, Re = new URL(V + "draco_decoder.js");
-Re.searchParams.append("range", "true");
-fetch(Re, {
+let k = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", V = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
+const je = k, Ye = V, Oe = new URL(k + "draco_decoder.js");
+Oe.searchParams.append("range", "true");
+fetch(Oe, {
   method: "GET",
   headers: {
     Range: "bytes=0-1"
   }
-}).catch((o) => {
-  console.debug(`Failed to fetch remote Draco decoder from ${V} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), V === it && ot("./include/draco/"), re === nt && at("./include/ktx2/");
+}).catch((i) => {
+  console.debug(`Failed to fetch remote Draco decoder from ${k} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), k === je && Qe("./include/draco/"), V === Ye && Je("./include/ktx2/");
 }).finally(() => {
-  Fe();
+  Pe();
+});
+const He = () => ({
+  dracoDecoderPath: k,
+  ktx2TranscoderPath: V
 });
-function ot(o) {
-  V = o, I && I[Pe] != V ? (console.debug("Updating Draco decoder path to " + o), I[Pe] = V, I.setDecoderPath(V), I.preload()) : console.debug("Setting Draco decoder path to " + o);
+function Qe(i) {
+  k = i, T && T[ge] != k ? (console.debug("Updating Draco decoder path to " + i), T[ge] = k, T.setDecoderPath(k), T.preload()) : console.debug("Setting Draco decoder path to " + i);
 }
-function at(o) {
-  re = o, U && U.transcoderPath != re ? (console.debug("Updating KTX2 transcoder path to " + o), U.setTranscoderPath(re), U.init()) : console.debug("Setting KTX2 transcoder path to " + o);
+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);
 }
-const Pe = Symbol("dracoDecoderPath");
-let I, Le, U;
-function Fe() {
-  I || (I = new tt(), I[Pe] = V, I.setDecoderPath(V), I.setDecoderConfig({ type: "js" }), I.preload()), U || (U = new st(), U.setTranscoderPath(re), U.init()), Le || (Le = et);
+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 Ue(o) {
-  return Fe(), o ? U.detectSupport(o) : o !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: I, ktx2Loader: U, meshoptDecoder: Le };
+function Se(i) {
+  i.dracoLoader || i.setDRACOLoader(T), i.ktx2Loader || i.setKTX2Loader(R), i.meshoptDecoder || i.setMeshoptDecoder(ne);
 }
-function Ne(o) {
-  o.dracoLoader || o.setDRACOLoader(I), o.ktx2Loader || o.setKTX2Loader(U), o.meshoptDecoder || o.setMeshoptDecoder(Le);
+const ge = Symbol("dracoDecoderPath");
+let T, ne, R;
+function Pe() {
+  T || (T = new Ve(), T[ge] = k, T.setDecoderPath(k), T.setDecoderConfig({ type: "js" }), T.preload()), R || (R = new Xe(), R.setTranscoderPath(V), R.init()), ne || (ne = qe);
 }
-const Te = /* @__PURE__ */ new WeakMap();
-function ze(o, t) {
-  let e = Te.get(o);
-  e ? e = Object.assign(e, t) : e = t, Te.set(o, e);
+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);
 }
-const De = Ce.prototype.load;
-function lt(...o) {
-  const t = Te.get(this);
-  let e = o[0];
+const Ze = ye.prototype.load;
+function et(...i) {
+  const t = pe.get(this);
+  let e = i[0];
   const s = new URL(e, window.location.href);
   if (s.hostname.endsWith("needle.tools")) {
-    const r = (t == null ? void 0 : t.progressive) !== void 0 ? t.progressive : !0, i = t != null && t.usecase ? t.usecase : "default";
-    r ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${i}` : this.requestHeader.Accept = `*/*;usecase=${i}`, e = s.toString();
+    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();
   }
-  return o[0] = e, De == null ? void 0 : De.call(this, ...o);
+  return i[0] = e, Ze?.call(this, ...i);
 }
-Ce.prototype.load = lt;
-de("debugprogressive");
-function de(o) {
-  if (typeof window > "u")
-    return !1;
-  const e = new URL(window.location.href).searchParams.get(o);
+ye.prototype.load = et;
+X("debugprogressive");
+function X(i) {
+  if (typeof window > "u") return !1;
+  const e = new URL(window.location.href).searchParams.get(i);
   return e == null || e === "0" || e === "false" ? !1 : e === "" ? !0 : e;
 }
-function ut(o, t) {
-  if (t === void 0 || t.startsWith("./") || t.startsWith("http") || o === void 0)
+function tt(i, t) {
+  if (t === void 0 || t.startsWith("./") || t.startsWith("http") || i === void 0)
     return t;
-  const e = o.lastIndexOf("/");
+  const e = i.lastIndexOf("/");
   if (e >= 0) {
-    const s = o.substring(0, e + 1);
-    for (; s.endsWith("/") && t.startsWith("/"); )
-      t = t.substring(1);
+    const s = i.substring(0, e + 1);
+    for (; s.endsWith("/") && t.startsWith("/"); ) t = t.substring(1);
     return s + t;
   }
   return t;
 }
-let ae;
-function dt() {
-  return ae !== void 0 || (ae = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), de("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", ae)), ae;
+let j;
+function Ae() {
+  return j !== void 0 || (j = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), X("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", j)), j;
 }
-function ct() {
-  if (typeof window > "u")
-    return !1;
-  const o = new URL(window.location.href), t = o.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(o.hostname);
-  return o.hostname === "127.0.0.1" || t;
+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;
 }
-class ft {
+class st {
   constructor(t = 100, e = {}) {
-    u(this, "_running", /* @__PURE__ */ new Map());
-    u(this, "_queue", []);
-    u(this, "debug", !1);
-    u(this, "tick", () => {
-      this.internalUpdate(), setTimeout(this.tick, 10);
-    });
     this.maxConcurrent = t, this.debug = e.debug ?? !1, window.requestAnimationFrame(this.tick);
   }
+  _running = /* @__PURE__ */ new Map();
+  _queue = [];
+  debug = !1;
+  tick = () => {
+    this.internalUpdate(), setTimeout(this.tick, 10);
+  };
   /**
    * Request a slot for a promise with a specific key. This function returns a promise with a `use` method that can be called to add the promise to the queue.
    */
@@ -113,8 +103,8 @@ class ft {
   }
   add(t, e) {
     this._running.has(t) || (this._running.set(t, e), e.finally(() => {
-      this._running.delete(t), this.debug && console.debug(`[PromiseQueue]: Promise for key ${t} finished, running: ${this._running.size}, waiting: ${this._queue.length}`);
-    }), this.debug && console.debug(`[PromiseQueue]: Adding promise for key ${t}, running: ${this._running.size}, waiting: ${this._queue.length}`));
+      this._running.delete(t), this.debug && console.debug(`[PromiseQueue]: Promise finished now running: ${this._running.size}, waiting: ${this._queue.length}. (finished ${t})`);
+    }), this.debug && console.debug(`[PromiseQueue]: Added new promise, now running: ${this._running.size}, waiting: ${this._queue.length}. (added ${t})`));
   }
   internalUpdate() {
     const t = this.maxConcurrent - this._running.size;
@@ -127,123 +117,258 @@ class ft {
     }
   }
 }
-const ht = typeof window > "u" && typeof document > "u", Ae = Symbol("needle:raycast-mesh");
-function ce(o) {
-  return (o == null ? void 0 : o[Ae]) instanceof xe ? o[Ae] : null;
+const rt = typeof window > "u" && typeof document > "u", me = Symbol("needle:raycast-mesh");
+function J(i) {
+  return i?.[me] instanceof Q ? i[me] : null;
 }
-function gt(o, t) {
-  if ((o.type === "Mesh" || o.type === "SkinnedMesh") && !ce(o)) {
-    const s = mt(t);
-    s.userData = { isRaycastMesh: !0 }, o[Ae] = s;
+function nt(i, t) {
+  if ((i.type === "Mesh" || i.type === "SkinnedMesh") && !J(i)) {
+    const s = it(t);
+    s.userData = { isRaycastMesh: !0 }, i[me] = s;
   }
 }
-function pt(o = !0) {
-  if (o) {
-    if (le)
-      return;
-    const t = le = se.prototype.raycast;
-    se.prototype.raycast = function(e, s) {
-      const n = this, r = ce(n);
-      let i;
-      r && n.isMesh && (i = n.geometry, n.geometry = r), t.call(this, e, s), i && (n.geometry = i);
+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 = J(n);
+      let o;
+      r && n.isMesh && (o = n.geometry, n.geometry = r), t.call(this, e, s), o && (n.geometry = o);
     };
   } else {
-    if (!le)
-      return;
-    se.prototype.raycast = le, le = null;
+    if (!Y) return;
+    q.prototype.raycast = Y, Y = null;
   }
 }
-let le = null;
-function mt(o) {
-  const t = new xe();
-  for (const e in o.attributes)
-    t.setAttribute(e, o.getAttribute(e));
-  return t.setIndex(o.getIndex()), t;
+let Y = null;
+function it(i) {
+  const t = new Q();
+  for (const e in i.attributes)
+    t.setAttribute(e, i.getAttribute(e));
+  return t.setIndex(i.getIndex()), t;
 }
-const j = new Array(), x = de("debugprogressive");
-let me, te = -1;
-if (x) {
-  let o = function() {
-    te += 1, te >= t && (te = -1), console.log(`Toggle LOD level [${te}]`);
+const W = new Array(), g = X("debugprogressive");
+let re, N = -1;
+if (g) {
+  let i = function() {
+    N += 1, N >= t && (N = -1), console.log(`Toggle LOD level [${N}]`);
   }, t = 6;
   window.addEventListener("keyup", (e) => {
-    e.key === "p" && o(), e.key === "w" && (me = !me, console.log(`Toggle wireframe [${me}]`));
+    e.key === "p" && i(), e.key === "w" && (re = !re, console.log(`Toggle wireframe [${re}]`));
     const s = parseInt(e.key);
-    !isNaN(s) && s >= 0 && (te = s, console.log(`Set LOD level to [${te}]`));
+    !isNaN(s) && s >= 0 && (N = s, console.log(`Set LOD level to [${N}]`));
   });
 }
-function qe(o) {
-  if (x)
-    if (Array.isArray(o))
-      for (const t of o)
-        qe(t);
-    else
-      o && "wireframe" in o && (o.wireframe = me === !0);
+function Ie(i) {
+  if (g)
+    if (Array.isArray(i))
+      for (const t of i)
+        Ie(t);
+    else i && "wireframe" in i && (i.wireframe = re === !0);
+}
+const H = new Array();
+let at = 0;
+const lt = Ae() ? 2 : 10;
+function ut(i) {
+  if (H.length < lt) {
+    const s = H.length;
+    g && console.warn(`[Worker] Creating new worker #${s}`);
+    const n = we.createWorker(i || {});
+    return H.push(n), n;
+  }
+  const t = at++ % H.length;
+  return H[t];
 }
-const X = "NEEDLE_progressive", Oe = Symbol("needle-progressive-texture"), D = class {
+class we {
   constructor(t, e) {
-    u(this, "parser");
-    u(this, "url");
-    u(this, "_isLoadingMesh");
-    u(this, "loadMesh", (t) => {
-      var s, n;
-      if (this._isLoadingMesh)
-        return null;
-      const e = (n = (s = this.parser.json.meshes[t]) == null ? void 0 : s.extensions) == null ? void 0 : n[X];
-      return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((r) => {
-        var i;
-        return this._isLoadingMesh = !1, r && D.registerMesh(this.url, e.guid, r, (i = e.lods) == null ? void 0 : i.length, 0, e), r;
-      })) : null;
+    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) {
+        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);
+            }
+      }
+    }, t.onerror = (s) => {
+      console.error("[Worker] Error in gltf-progressive worker:", s);
+    }, t.postMessage({
+      type: "init"
+    });
+  }
+  static async createWorker(t) {
+    const e = new Worker(new URL(
+      /* @vite-ignore */
+      "/assets/loader.worker-8olmVOL4.js",
+      import.meta.url
+    ), {
+      type: "module"
     });
-    x && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
+    return new we(e, t);
   }
+  _running = [];
+  _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;
+    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",
+      url: t,
+      dracoDecoderPath: s.dracoDecoderPath,
+      ktx2TranscoderPath: s.ktx2TranscoderPath,
+      ktx2LoaderConfig: l
+    };
+    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
+      });
+    });
+  }
+  _debug = !1;
+}
+function dt(i) {
+  for (const t of i.geometries) {
+    const e = t.geometry, s = new Q();
+    if (s.name = e.name || "", e.index) {
+      const n = e.index;
+      s.setIndex(ae(n));
+    }
+    for (const n in e.attributes) {
+      const r = e.attributes[n], o = ae(r);
+      s.setAttribute(n, o);
+    }
+    if (e.morphAttributes)
+      for (const n in e.morphAttributes) {
+        const o = e.morphAttributes[n].map((l) => ae(l));
+        s.morphAttributes[n] = o;
+      }
+    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new he(), s.boundingBox.min = new A(
+      e.boundingBox?.min.x,
+      e.boundingBox?.min.y,
+      e.boundingBox?.min.z
+    ), s.boundingBox.max = new A(
+      e.boundingBox?.max.x,
+      e.boundingBox?.max.y,
+      e.boundingBox?.max.z
+    ), s.boundingSphere = new De(
+      new A(
+        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);
+    e.userData && (s.userData = e.userData), t.geometry = s;
+  }
+  for (const t of i.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,
+        o,
+        e.format,
+        e.type,
+        e.mapping,
+        e.wrapS,
+        e.wrapT,
+        e.magFilter,
+        e.minFilter,
+        e.anisotropy,
+        e.colorSpace
+      );
+    } else
+      s = new E(
+        e.image,
+        e.mapping,
+        e.wrapS,
+        e.wrapT,
+        e.magFilter,
+        e.minFilter,
+        e.format,
+        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 Ge(...e.matrix.elements);
+    if (!s) {
+      console.error("[Worker] Failed to create new texture from received data. Texture is not a CompressedTexture or Texture.");
+      continue;
+    }
+    t.texture = s;
+  }
+  return i;
+}
+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 Ue(n, i.itemSize, s.byteOffset, i.normalized), t.offset = i.offset;
+  } else "isBufferAttribute" in i && i.isBufferAttribute && (t = new We(i.array, i.itemSize, i.normalized), t.usage = i.usage, t.gpuType = i.gpuType, t.updateRanges = i.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 {
   /** The name of the extension */
   get name() {
-    return X;
+    return F;
   }
   static getMeshLODExtension(t) {
     const e = this.getAssignedLODInformation(t);
-    return e != null && e.key ? this.lodInfos.get(e.key) : null;
+    return e?.key ? this.lodInfos.get(e.key) : null;
   }
   static getPrimitiveIndex(t) {
-    var s;
-    const e = (s = this.getAssignedLODInformation(t)) == null ? void 0 : s.index;
+    const e = this.getAssignedLODInformation(t)?.index;
     return e ?? -1;
   }
   static getMaterialMinMaxLODsCount(t, e) {
     const s = this, n = "LODS:minmax", r = t[n];
-    if (r != null)
-      return r;
+    if (r != null) return r;
     if (e || (e = {
       min_count: 1 / 0,
       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[n] = e, e;
     }
-    if (x === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
-      const a = t;
-      for (const l of Object.keys(a.uniforms)) {
-        const c = a.uniforms[l].value;
-        (c == null ? void 0 : c.isTexture) === !0 && i(c, 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);
       }
     } else if (t.isMaterial)
-      for (const a of Object.keys(t)) {
-        const l = t[a];
-        (l == null ? void 0 : l.isTexture) === !0 && i(l, e);
+      for (const l of Object.keys(t)) {
+        const a = t[l];
+        a?.isTexture === !0 && o(a, e);
       }
+    else
+      g && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
     return t[n] = e, e;
-    function i(a, l) {
-      const c = s.getAssignedLODInformation(a);
-      if (c) {
-        const d = s.lodInfos.get(c.key);
-        if (d && d.lods) {
-          l.min_count = Math.min(l.min_count, d.lods.length), l.max_count = Math.max(l.max_count, d.lods.length);
-          for (let p = 0; p < d.lods.length; p++) {
-            const f = d.lods[p];
-            f.width && (l.lods[p] = l.lods[p] || { min_height: 1 / 0, max_height: 0 }, l.lods[p].min_height = Math.min(l.lods[p].min_height, f.height), l.lods[p].max_height = Math.max(l.lods[p].max_height, f.height));
+    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));
           }
         }
       }
@@ -255,30 +380,27 @@ const X = "NEEDLE_progressive", Oe = Symbol("needle-progressive-texture"), D = c
    * @returns true if the LOD level is available (or if any LOD level is available if level is undefined)
    */
   static hasLODLevelAvailable(t, e) {
-    var r;
     if (Array.isArray(t)) {
-      for (const i of t)
-        if (this.hasLODLevelAvailable(i, e))
-          return !0;
+      for (const r of t)
+        if (this.hasLODLevelAvailable(r, e)) return !0;
       return !1;
     }
     if (t.isMaterial === !0) {
-      for (const i of Object.keys(t)) {
-        const a = t[i];
-        if (a && a.isTexture && this.hasLODLevelAvailable(a, e))
+      for (const r of Object.keys(t)) {
+        const o = t[r];
+        if (o && o.isTexture && this.hasLODLevelAvailable(o, e))
           return !0;
       }
       return !1;
     } else if (t.isGroup === !0) {
-      for (const i of t.children)
-        if (i.isMesh === !0 && this.hasLODLevelAvailable(i, e))
+      for (const r of t.children)
+        if (r.isMesh === !0 && this.hasLODLevelAvailable(r, e))
           return !0;
     }
     let s, n;
-    if (t.isMesh ? s = t.geometry : (t.isBufferGeometry || t.isTexture) && (s = t), s && (r = s == null ? void 0 : s.userData) != null && r.LODS) {
-      const i = s.userData.LODS;
-      if (n = this.lodInfos.get(i.key), e === void 0)
-        return n != null;
+    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;
     }
@@ -299,42 +421,38 @@ const X = "NEEDLE_progressive", Oe = Symbol("needle-progressive-texture"), D = c
    * ```
    */
   static assignMeshLOD(t, e) {
-    var s;
-    if (!t)
-      return Promise.resolve(null);
-    if (t instanceof se || t.isMesh === !0) {
-      const n = t.geometry, r = this.getAssignedLODInformation(n);
-      if (!r)
+    if (!t) return Promise.resolve(null);
+    if (t instanceof q || t.isMesh === !0) {
+      const s = t.geometry, n = this.getAssignedLODInformation(s);
+      if (!n)
         return Promise.resolve(null);
-      for (const i of j)
-        (s = i.onBeforeGetLODMesh) == null || s.call(i, t, e);
-      return t["LOD:requested level"] = e, D.getOrLoadLOD(n, e).then((i) => {
-        if (Array.isArray(i)) {
-          const a = r.index || 0;
-          i = i[a];
+      for (const r of W)
+        r.onBeforeGetLODMesh?.(t, e);
+      return t["LOD:requested level"] = e, y.getOrLoadLOD(s, e).then((r) => {
+        if (Array.isArray(r)) {
+          const o = n.index || 0;
+          r = r[o];
         }
-        return t["LOD:requested level"] === e && (delete t["LOD:requested level"], i && n != i && ((i == null ? void 0 : i.isBufferGeometry) ? t.geometry = i : x && console.error("Invalid LOD geometry", i))), i;
-      }).catch((i) => (console.error("Error loading mesh LOD", t, i), null));
-    } else
-      x && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
+        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));
+    } 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) {
-    if (!t)
-      return Promise.resolve(null);
+    if (!t) return Promise.resolve(null);
     if (t.isMesh === !0) {
       const s = t;
       if (Array.isArray(s.material)) {
         const n = new Array();
         for (const r of s.material) {
-          const i = this.assignTextureLOD(r, e);
-          n.push(i);
+          const o = this.assignTextureLOD(r, e);
+          n.push(o);
         }
         return Promise.all(n).then((r) => {
-          const i = new Array();
-          for (const a of r)
-            Array.isArray(a) && i.push(...a);
-          return i;
+          const o = new Array();
+          for (const l of r)
+            Array.isArray(l) && o.push(...l);
+          return o;
         });
       } else
         return this.assignTextureLOD(s.material, e);
@@ -342,290 +460,319 @@ const X = "NEEDLE_progressive", Oe = Symbol("needle-progressive-texture"), D = c
     if (t.isMaterial === !0) {
       const s = t, n = [], r = new Array();
       if (s.uniforms && (s.isRawShaderMaterial || s.isShaderMaterial === !0)) {
-        const i = s;
-        for (const a of Object.keys(i.uniforms)) {
-          const l = i.uniforms[a].value;
-          if ((l == null ? void 0 : l.isTexture) === !0) {
-            const c = this.assignTextureLODForSlot(l, e, s, a).then((d) => (d && i.uniforms[a].value != d && (i.uniforms[a].value = d, i.uniformsNeedUpdate = !0), d));
-            n.push(c), r.push(a);
+        const o = s;
+        for (const l of Object.keys(o.uniforms)) {
+          const a = o.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);
           }
         }
       } else
-        for (const i of Object.keys(s)) {
-          const a = s[i];
-          if ((a == null ? void 0 : a.isTexture) === !0) {
-            const l = this.assignTextureLODForSlot(a, e, s, i);
-            n.push(l), r.push(i);
+        for (const o of Object.keys(s)) {
+          const l = s[o];
+          if (l?.isTexture === !0) {
+            const a = this.assignTextureLODForSlot(l, e, s, o);
+            n.push(a), r.push(o);
           }
         }
-      return Promise.all(n).then((i) => {
-        const a = new Array();
-        for (let l = 0; l < i.length; l++) {
-          const c = i[l], d = r[l];
-          c && c.isTexture === !0 ? a.push({ material: s, slot: d, texture: c, level: e }) : a.push({ material: s, slot: d, texture: null, level: e });
+      return Promise.all(n).then((o) => {
+        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 });
         }
-        return a;
+        return l;
       });
     }
-    if (t instanceof oe || t.isTexture === !0) {
+    if (t instanceof E || t.isTexture === !0) {
       const s = t;
       return this.assignTextureLODForSlot(s, e, null, null);
     }
     return Promise.resolve(null);
   }
   static assignTextureLODForSlot(t, e, s, n) {
-    return (t == null ? void 0 : t.isTexture) !== !0 ? Promise.resolve(null) : n === "glyphMap" ? Promise.resolve(t) : D.getOrLoadLOD(t, e).then((r) => {
+    return t?.isTexture !== !0 ? Promise.resolve(null) : n === "glyphMap" ? Promise.resolve(t) : y.getOrLoadLOD(t, e).then((r) => {
       if (Array.isArray(r))
-        return null;
-      if ((r == null ? void 0 : r.isTexture) === !0) {
+        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 i = s[n];
-          if (i && !x) {
-            const a = this.getAssignedLODInformation(i);
-            if (a && (a == null ? void 0 : a.level) < e)
-              return x === "verbose" && console.warn("Assigned texture level is already higher: ", a.level, e, s, i, r), null;
+          const o = s[n];
+          if (o && !g) {
+            const l = this.getAssignedLODInformation(o);
+            if (l && l?.level < e)
+              return g === "verbose" && console.warn("Assigned texture level is already higher: ", l.level, e, s, o, 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;
         }
         return r;
-      } else
-        x == "verbose" && console.warn("No LOD found for", t, e);
+      } else g == "verbose" && console.warn("No LOD found for", t, e);
       return null;
     }).catch((r) => (console.error("Error loading LOD", t, r), null));
   }
+  parser;
+  url;
+  constructor(t, 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?.[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;
+  };
+  // private _isLoadingTexture;
+  // loadTexture = (textureIndex: number) => {
+  //     if (this._isLoadingTexture) return null;
+  //     const ext = this.parser.json.textures[textureIndex]?.extensions?.[EXTENSION_NAME] as NEEDLE_ext_progressive_texture;
+  //     if (!ext) return null;
+  //     this._isLoadingTexture = true;
+  //     return this.parser.getDependency("texture", textureIndex).then(tex => {
+  //         this._isLoadingTexture = false;
+  //         if (tex) {
+  //             NEEDLE_progressive.registerTexture(this.url, tex as Texture, ext.lods?.length, textureIndex, ext);
+  //         }
+  //         return tex;
+  //     });
+  // }
   afterRoot(t) {
-    var e, s;
-    return x && console.log("AFTER", this.url, t), (e = this.parser.json.textures) == null || e.forEach((n, r) => {
-      var i;
-      if (n != null && n.extensions) {
-        const a = n == null ? void 0 : n.extensions[X];
-        if (a) {
-          if (!a.lods) {
-            x && console.warn("Texture has no LODs", a);
+    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);
             return;
           }
-          let l = !1;
-          for (const c of this.parser.associations.keys())
-            if (c.isTexture === !0) {
-              const d = this.parser.associations.get(c);
-              (d == null ? void 0 : d.textures) === r && (l = !0, D.registerTexture(this.url, c, (i = a.lods) == null ? void 0 : i.length, r, a));
-            }
-          l || this.parser.getDependency("texture", r).then((c) => {
-            var d;
-            c && D.registerTexture(this.url, c, (d = a.lods) == null ? void 0 : d.length, r, a);
+          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);
           });
         }
       }
-    }), (s = this.parser.json.meshes) == null || s.forEach((n, r) => {
-      if (n != null && n.extensions) {
-        const i = n == null ? void 0 : n.extensions[X];
-        if (i && i.lods) {
-          for (const a of this.parser.associations.keys())
-            if (a.isMesh) {
-              const l = this.parser.associations.get(a);
-              (l == null ? void 0 : l.meshes) === r && D.registerMesh(this.url, i.guid, a, i.lods.length, l.primitives, i);
+    }), this.parser.json.meshes?.forEach((e, s) => {
+      if (e?.extensions) {
+        const n = e?.extensions[F];
+        if (n && n.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);
             }
         }
       }
     }), null;
   }
+  /**
+   * Register a texture with LOD information
+   */
+  static registerTexture = (t, e, s, n, 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(`> 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);
+    }
+    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);
+  };
+  /**
+   * Register a mesh with LOD information
+   */
+  static registerMesh = (t, e, s, n, r, o) => {
+    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 && !J(s) && nt(s, l);
+    for (const u of W)
+      u.onRegisteredNewMesh?.(s, o);
+  };
+  /** A map of key = asset uuid and value = LOD information */
+  static lodInfos = /* @__PURE__ */ new Map();
+  /** cache of already loaded mesh lods */
+  static previouslyLoaded = /* @__PURE__ */ new Map();
+  /** this contains the geometry/textures that were originally loaded */
+  static lowresCache = /* @__PURE__ */ new Map();
+  static workers = [];
+  static _workersIndex = 0;
   static async getOrLoadLOD(t, e) {
-    var a, l, c, d;
-    const s = x == "verbose", n = t.userData.LODS;
+    const s = g == "verbose", n = this.getAssignedLODInformation(t);
     if (!n)
-      return null;
-    const r = n == null ? void 0 : n.key;
-    let i;
+      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;
     if (t.isTexture === !0) {
-      const p = t;
-      p.source && p.source[Oe] && (i = p.source[Oe]);
+      const a = t;
+      a.source && a.source[le] && (o = a.source[le]);
     }
-    if (i || (i = D.lodInfos.get(r)), i) {
+    if (o || (o = y.lodInfos.get(r)), o) {
       if (e > 0) {
-        let w = !1;
-        const M = Array.isArray(i.lods);
-        if (M && e >= i.lods.length ? w = !0 : M || (w = !0), w)
+        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);
       }
-      const p = Array.isArray(i.lods) ? (a = i.lods[e]) == null ? void 0 : a.path : i.lods;
-      if (!p)
-        return x && !i["missing:uri"] && (i["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, i)), null;
-      const f = ut(n.url, p);
-      if (f.endsWith(".glb") || f.endsWith(".gltf")) {
-        if (!i.guid)
-          return console.warn("missing pointer for glb/gltf texture", i), null;
-        const w = f + "_" + i.guid, M = this.previouslyLoaded.get(w);
-        if (M !== void 0) {
-          s && console.log(`LOD ${e} was already loading/loaded: ${w}`);
-          let h = await M.catch((C) => (console.error(`Error loading LOD ${e} from ${f}
-`, C), null)), L = !1;
-          if (h == null || (h instanceof oe && t instanceof oe ? (l = h.image) != null && l.data || (c = h.source) != null && c.data ? h = this.copySettings(t, h) : (L = !0, this.previouslyLoaded.delete(w)) : h instanceof xe && t instanceof xe && ((d = h.attributes.position) != null && d.array || (L = !0, this.previouslyLoaded.delete(w)))), !L)
-            return h;
+      const a = Array.isArray(o.lods) ? o.lods[e]?.path : o.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 Q && t instanceof Q && (d.attributes.position?.array || (x = !0, this.previouslyLoaded.delete(c)))), !x)
+            return d;
         }
-        const A = await this.queue.slot(f);
-        if (!A.use)
-          return x && console.log(`LOD ${e} was aborted: ${f}`), null;
-        const b = i, R = new Promise(async (h, L) => {
-          const C = new Ce();
-          Ne(C), x && (await new Promise((v) => setTimeout(v, 1e3)), s && console.warn("Start loading (delayed) " + f, b.guid));
-          let N = f;
-          if (b && Array.isArray(b.lods)) {
-            const v = b.lods[e];
-            v.hash && (N += "?v=" + v.hash);
+        if (!p.use)
+          return g && console.log(`LOD ${e} was aborted: ${u}`), null;
+        const v = o, I = new Promise(async (d, x) => {
+          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);
+              }
+            if (m.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);
+              }
+              return d(f);
+            }
+            return d(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 S = await C.loadAsync(N).catch((v) => (console.error(`Error loading LOD ${e} from ${f}
-`, v), h(null)));
-          if (!S)
-            return h(null);
-          const ee = S.parser;
-          s && console.log("Loading finished " + f, b.guid);
-          let B = 0;
-          if (S.parser.json.textures) {
-            let v = !1;
-            for (const m of S.parser.json.textures) {
-              if (m != null && m.extensions) {
-                const g = m == null ? void 0 : m.extensions[X];
-                if (g != null && g.guid && g.guid === b.guid) {
-                  v = !0;
+          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;
                   break;
                 }
               }
-              B++;
+              S++;
             }
-            if (v) {
-              let m = await ee.getDependency("texture", B);
-              return m && D.assignLODInformation(n.url, m, r, e, void 0), s && console.log('change "' + t.name + '" → "' + m.name + '"', f, B, m, w), t instanceof oe && (m = this.copySettings(t, m)), m && (m.guid = b.guid), h(m);
-            } else
-              x && console.warn("Could not find texture with guid", b.guid, S.parser.json);
+            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 (B = 0, S.parser.json.meshes) {
-            let v = !1;
-            for (const m of S.parser.json.meshes) {
-              if (m != null && m.extensions) {
-                const g = m == null ? void 0 : m.extensions[X];
-                if (g != null && g.guid && g.guid === b.guid) {
-                  v = !0;
+          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;
                   break;
                 }
               }
-              B++;
+              S++;
             }
-            if (v) {
-              const m = await ee.getDependency("mesh", B);
-              if (s && console.log(`Loaded Mesh "${m.name}"`, f, B, m, w), m.isMesh === !0) {
-                const g = m.geometry;
-                return D.assignLODInformation(n.url, g, r, e, 0), h(g);
+            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);
               } else {
-                const g = new Array();
-                for (let _ = 0; _ < m.children.length; _++) {
-                  const G = m.children[_];
-                  if (G.isMesh === !0) {
-                    const E = G.geometry;
-                    D.assignLODInformation(n.url, E, r, e, _), g.push(E);
+                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);
                   }
                 }
-                return h(g);
+                return d(f);
               }
-            } else
-              x && console.warn("Could not find mesh with guid", b.guid, S.parser.json);
+            } else g && console.warn("Could not find mesh with guid", v.guid, b.parser.json);
           }
-          return h(null);
+          return d(null);
         });
-        return this.previouslyLoaded.set(w, R), A.use(R), await R;
-      } else if (t instanceof oe) {
-        s && console.log("Load texture from uri: " + f);
-        const M = await new Qe().loadAsync(f);
-        return M ? (M.guid = i.guid, M.flipY = !1, M.needsUpdate = !0, M.colorSpace = t.colorSpace, s && console.log(i, M)) : x && console.warn("failed loading", f), M;
+        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;
       }
     } else
-      x && console.warn(`Can not load LOD ${e}: no LOD info found for "${r}" ${t.name}`, t.type);
+      g && console.warn(`Can not load LOD ${e}: no LOD info found for "${r}" ${t.name}`, t.type);
     return null;
   }
+  static maxConcurrent = 50;
+  static queue = new st(y.maxConcurrent, { debug: g != !1 });
   static assignLODInformation(t, e, s, n, r) {
-    if (!e)
-      return;
+    if (!e) return;
     e.userData || (e.userData = {});
-    const i = new yt(t, s, n, r);
-    e.userData.LODS = i;
+    const o = new ht(t, s, n, r);
+    e.userData.LODS = o, "source" in e && typeof e.source == "object" && (e.source.LODS = o);
   }
   static getAssignedLODInformation(t) {
-    var e;
-    return ((e = t == null ? void 0 : t.userData) == null ? void 0 : e.LODS) || null;
+    return t ? t.userData?.LODS ? t.userData.LODS : "source" in t && t.source?.LODS ? t.source.LODS : null : null;
   }
   // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
   static copySettings(t, e) {
-    return e ? (x && console.warn(`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;
   }
-};
-let P = D;
-/**
- * Register a texture with LOD information
- */
-u(P, "registerTexture", (t, e, s, n, r) => {
-  if (x && console.log("> Progressive: register texture", n, e.name, e.uuid, e, r), !e) {
-    x && console.error("gltf-progressive: Register texture without texture");
-    return;
-  }
-  e.source && (e.source[Oe] = r);
-  const i = r.guid;
-  D.assignLODInformation(t, e, i, s, n), D.lodInfos.set(i, r), D.lowresCache.set(i, e);
-}), /**
- * Register a mesh with LOD information
- */
-u(P, "registerMesh", (t, e, s, n, r, i) => {
-  var c;
-  const a = s.geometry;
-  if (!a) {
-    x && console.warn("gltf-progressive: Register mesh without geometry");
-    return;
-  }
-  a.userData || (a.userData = {}), x && console.log("> Progressive: register mesh " + s.name, { index: r, uuid: s.uuid }, i, s), D.assignLODInformation(t, a, e, n, r), D.lodInfos.set(e, i);
-  let l = D.lowresCache.get(e);
-  l ? l.push(s.geometry) : l = [s.geometry], D.lowresCache.set(e, l), n > 0 && !ce(s) && gt(s, a);
-  for (const d of j)
-    (c = d.onRegisteredNewMesh) == null || c.call(d, s, i);
-}), /** A map of key = asset uuid and value = LOD information */
-u(P, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
-u(P, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
-u(P, "lowresCache", /* @__PURE__ */ new Map()), u(P, "queue", new ft(100, { debug: x != !1 }));
-class yt {
+}
+class ht {
+  url;
+  /** the key to lookup the LOD information */
+  key;
+  level;
+  /** For multi objects (e.g. a group of meshes) this is the index of the object */
+  index;
   constructor(t, e, s, n) {
-    u(this, "url");
-    /** the key to lookup the LOD information */
-    u(this, "key");
-    u(this, "level");
-    /** For multi objects (e.g. a group of meshes) this is the index of the object */
-    u(this, "index");
     this.url = t, this.key = e, this.level = s, n != null && (this.index = n);
   }
 }
-class ye {
-  constructor(t, e) {
-    u(this, "frame_start");
-    u(this, "frame_capture_end");
-    u(this, "ready");
-    u(this, "_resolve");
-    u(this, "_signal");
-    u(this, "_resolved", !1);
-    u(this, "_addedCount", 0);
-    u(this, "_resolvedCount", 0);
-    /** These promises are currently being awaited */
-    u(this, "_awaiting", []);
-    u(this, "_maxPromisesPerObject", 1);
-    u(this, "_currentFrame", 0);
-    u(this, "_seen", /* @__PURE__ */ new WeakMap());
-    var r;
-    const n = Math.max(e.frames ?? 2, 2);
-    this.frame_start = t, this.frame_capture_end = t + n, this.ready = new Promise((i) => {
-      this._resolve = i;
-    }), this.ready.finally(() => {
-      this._resolved = !0, this._awaiting.length = 0;
-    }), this._signal = e.signal, (r = this._signal) == null || r.addEventListener("abort", () => {
-      this.resolveNow();
-    }), this._maxPromisesPerObject = Math.max(1, e.maxPromisesPerObject ?? 1);
-  }
+class ue {
+  static addPromise = (t, e, s, n) => {
+    n.forEach((r) => {
+      r.add(t, e, s);
+    });
+  };
+  frame_start;
+  frame_capture_end;
+  ready;
+  _resolve;
+  _signal;
   /**
    * The number of promises that have been added to this group so far.
    */
@@ -638,13 +785,30 @@ class ye {
   get currentlyAwaiting() {
     return this._awaiting.length;
   }
+  _resolved = !1;
+  _addedCount = 0;
+  _resolvedCount = 0;
+  /** These promises are currently being awaited */
+  _awaiting = [];
+  _maxPromisesPerObject = 1;
+  constructor(t, e) {
+    const n = Math.max(e.frames ?? 2, 2);
+    this.frame_start = t, this.frame_capture_end = t + n, this.ready = new Promise((r) => {
+      this._resolve = r;
+    }), this.ready.finally(() => {
+      this._resolved = !0, this._awaiting.length = 0;
+    }), this._signal = e.signal, this._signal?.addEventListener("abort", () => {
+      this.resolveNow();
+    }), this._maxPromisesPerObject = Math.max(1, e.maxPromisesPerObject ?? 1);
+  }
+  _currentFrame = 0;
   update(t) {
-    var e;
-    this._currentFrame = t, ((e = this._signal) != null && e.aborted || this._currentFrame > this.frame_capture_end && this._awaiting.length === 0) && this.resolveNow();
+    this._currentFrame = t, (this._signal?.aborted || this._currentFrame > this.frame_capture_end && this._awaiting.length === 0) && this.resolveNow();
   }
+  _seen = /* @__PURE__ */ new WeakMap();
   add(t, e, s) {
     if (this._resolved) {
-      x && 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._currentFrame > this.frame_capture_end)) {
@@ -652,7 +816,7 @@ class ye {
         if (this._seen.has(e)) {
           let n = this._seen.get(e);
           if (n >= this._maxPromisesPerObject) {
-            x && 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, n + 1);
@@ -664,85 +828,33 @@ class ye {
     }
   }
   resolveNow() {
-    var t, e;
-    this._resolved || (e = this._resolve) == null || e.call(this, {
+    this._resolved || this._resolve?.({
       awaited_count: this._addedCount,
       resolved_count: this._resolvedCount,
-      cancelled: ((t = this._signal) == null ? void 0 : t.aborted) ?? !1
+      cancelled: this._signal?.aborted ?? !1
     });
   }
 }
-u(ye, "addPromise", (t, e, s, n) => {
-  n.forEach((r) => {
-    r.add(t, e, s);
-  });
-});
-const F = de("debugprogressive"), xt = de("noprogressive"), be = Symbol("Needle:LODSManager"), Se = Symbol("Needle:LODState"), Q = Symbol("Needle:CurrentLOD"), $ = { mesh_lod: -1, texture_lod: -1 };
-var k, K, _e, J, ie, we, Y;
-const O = class {
-  // readonly plugins: NEEDLE_progressive_plugin[] = [];
-  constructor(t, e) {
-    u(this, "renderer");
-    u(this, "context");
-    u(this, "projectionScreenMatrix", new Ge());
-    /**
-     * The target triangle density is the desired max amount of triangles on screen when the mesh is filling the screen.  
-     * @default 200_000
-     */
-    u(this, "targetTriangleDensity", 2e5);
-    /**
-     * The interval in frames to automatically update the bounds of skinned meshes.   
-     * Set to 0 or a negative value to disable automatic bounds updates. 
-     * @default 30
-     */
-    u(this, "skinnedMeshAutoUpdateBoundsInterval", 30);
-    /**
-     * The update interval in frames. If set to 0, the LODs will be updated every frame. If set to 2, the LODs will be updated every second frame, etc.
-     * @default "auto"
-     */
-    u(this, "updateInterval", "auto");
-    H(this, k, 1);
-    /**
-     * If set to true, the LODsManager will not update the LODs.
-     * @default false
-     */
-    u(this, "pause", !1);
-    /**
-     * When set to true the LODsManager will not update the LODs. This can be used to manually update the LODs using the `update` method.  
-     * Otherwise the LODs will be updated automatically when the renderer renders the scene.
-     * @default false
-     */
-    u(this, "manual", !1);
-    u(this, "_newPromiseGroups", []);
-    u(this, "_promiseGroupIds", 0);
-    u(this, "_lodchangedlisteners", []);
-    H(this, K, void 0);
-    H(this, _e, new je());
-    H(this, J, 0);
-    H(this, ie, 0);
-    H(this, we, 0);
-    H(this, Y, 0);
-    u(this, "_fpsBuffer", [60, 60, 60, 60, 60]);
-    // private testIfLODLevelsAreAvailable() {
-    u(this, "_sphere", new Ze());
-    u(this, "_tempBox", new Ee());
-    u(this, "_tempBox2", new Ee());
-    u(this, "tempMatrix", new Ge());
-    u(this, "_tempWorldPosition", new W());
-    u(this, "_tempBoxSize", new W());
-    u(this, "_tempBox2Size", new W());
-    this.renderer = t, this.context = { ...e };
-  }
+const C = X("debugprogressive"), gt = X("noprogressive"), de = Symbol("Needle:LODSManager"), ce = Symbol("Needle:LODState"), U = Symbol("Needle:CurrentLOD"), P = { mesh_lod: -1, texture_lod: -1 };
+class L {
+  /** 
+   * 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;
+  /**
+   * Force override the LOD level for all objects in the scene
+   */
+  static overrideGlobalLodLevel;
   /** @internal */
   static getObjectLODState(t) {
-    return t[Se];
+    return t[ce];
   }
   static addPlugin(t) {
-    j.push(t);
+    W.push(t);
   }
   static removePlugin(t) {
-    const e = j.indexOf(t);
-    e >= 0 && j.splice(e, 1);
+    const e = W.indexOf(t);
+    e >= 0 && W.splice(e, 1);
   }
   /**
    * Gets the LODsManager for the given renderer. If the LODsManager does not exist yet, it will be created.  
@@ -750,38 +862,72 @@ const O = class {
    * @returns The LODsManager instance.
    */
   static get(t, e) {
-    if (t[be])
-      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[be];
-    const s = new O(t, {
+    if (t[de])
+      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[de];
+    const s = new L(t, {
       engine: "unknown",
       ...e
     });
-    return t[be] = s, s;
+    return t[de] = s, s;
   }
+  renderer;
+  context;
+  projectionScreenMatrix = new Le();
   /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
   get plugins() {
-    return j;
+    return W;
   }
+  /**
+   * The target triangle density is the desired max amount of triangles on screen when the mesh is filling the screen.  
+   * @default 200_000
+   */
+  targetTriangleDensity = 2e5;
+  /**
+   * The interval in frames to automatically update the bounds of skinned meshes.   
+   * Set to 0 or a negative value to disable automatic bounds updates. 
+   * @default 30
+   */
+  skinnedMeshAutoUpdateBoundsInterval = 30;
+  /**
+   * The update interval in frames. If set to 0, the LODs will be updated every frame. If set to 2, the LODs will be updated every second frame, etc.
+   * @default "auto"
+   */
+  updateInterval = "auto";
+  #e = 1;
+  /**
+   * If set to true, the LODsManager will not update the LODs.
+   * @default false
+   */
+  pause = !1;
+  /**
+   * When set to true the LODsManager will not update the LODs. This can be used to manually update the LODs using the `update` method.  
+   * Otherwise the LODs will be updated automatically when the renderer renders the scene.
+   * @default false
+   */
+  manual = !1;
+  _newPromiseGroups = [];
+  _promiseGroupIds = 0;
   /**
    * Call to await LODs loading during the next render cycle.
    */
   awaitLoading(t) {
-    const e = this._promiseGroupIds++, s = new ye(y(this, J), { ...t });
+    const e = this._promiseGroupIds++, s = new ue(this.#r, { ...t });
     this._newPromiseGroups.push(s);
     const n = performance.now();
     return s.ready.finally(() => {
       const r = this._newPromiseGroups.indexOf(s);
-      r >= 0 && (this._newPromiseGroups.splice(r, 1), ct() && performance.measure("LODsManager:awaitLoading", {
+      r >= 0 && (this._newPromiseGroups.splice(r, 1), _e() && performance.measure("LODsManager:awaitLoading", {
         start: n,
-        detail: { id: e, name: t == null ? void 0 : t.name, awaited: s.awaitedCount, resolved: s.resolvedCount }
+        detail: { id: e, name: t?.name, awaited: s.awaitedCount, resolved: s.resolvedCount }
       }));
     }), s.ready;
   }
   _postprocessPromiseGroups() {
     if (this._newPromiseGroups.length !== 0)
       for (let t = this._newPromiseGroups.length - 1; t >= 0; t--)
-        this._newPromiseGroups[t].update(y(this, J));
+        this._newPromiseGroups[t].update(this.#r);
   }
+  _lodchangedlisteners = [];
   addEventListener(t, e) {
     t === "changed" && this._lodchangedlisteners.push(e);
   }
@@ -791,40 +937,49 @@ const O = class {
       s >= 0 && this._lodchangedlisteners.splice(s, 1);
     }
   }
+  // readonly plugins: NEEDLE_progressive_plugin[] = [];
+  constructor(t, e) {
+    this.renderer = t, this.context = { ...e };
+  }
+  #t;
+  #o = new Ee();
+  #r = 0;
+  #n = 0;
+  #i = 0;
+  #s = 0;
+  _fpsBuffer = [60, 60, 60, 60, 60];
   /**
    * Enable the LODsManager. This will replace the render method of the renderer with a method that updates the LODs.
    */
   enable() {
-    if (y(this, K))
-      return;
+    if (this.#t) return;
     console.debug("[gltf-progressive] Enabling LODsManager for renderer");
     let t = 0;
-    q(this, K, this.renderer.render);
+    this.#t = this.renderer.render;
     const e = this;
-    Ue(this.renderer), this.renderer.render = function(s, n) {
+    xe(this.renderer), this.renderer.render = function(s, n) {
       const r = e.renderer.getRenderTarget();
-      (r == null || "isXRRenderTarget" in r && r.isXRRenderTarget) && (t = 0, q(e, J, y(e, J) + 1), q(e, ie, y(e, _e).getDelta()), q(e, we, y(e, we) + y(e, ie)), e._fpsBuffer.shift(), e._fpsBuffer.push(1 / y(e, ie)), q(e, Y, e._fpsBuffer.reduce((a, l) => a + l) / e._fpsBuffer.length), F && y(e, J) % 200 === 0 && console.log("FPS", Math.round(y(e, Y)), "Interval:", y(e, k)));
-      const i = t++;
-      y(e, K).call(this, s, n), e.onAfterRender(s, n, i);
+      (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, C && 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);
     };
   }
   disable() {
-    y(this, K) && (console.debug("[gltf-progressive] Disabling LODsManager for renderer"), this.renderer.render = y(this, K), q(this, K, void 0));
+    this.#t && (console.debug("[gltf-progressive] Disabling LODsManager for renderer"), this.renderer.render = this.#t, this.#t = void 0);
   }
   update(t, e) {
     this.internalUpdate(t, e);
   }
   onAfterRender(t, e, s) {
-    if (this.pause)
-      return;
+    if (this.pause) return;
     const r = this.renderer.renderLists.get(t, 0).opaque;
-    let i = !0;
+    let o = !0;
     if (r.length === 1) {
-      const a = r[0].material;
-      (a.name === "EffectMaterial" || a.name === "CopyShader") && (i = !1);
+      const l = r[0].material;
+      (l.name === "EffectMaterial" || l.name === "CopyShader") && (o = !1);
     }
-    if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (i = !1), i) {
-      if (xt || (this.updateInterval === "auto" ? y(this, Y) < 40 && y(this, k) < 10 ? (q(this, k, y(this, k) + 1), F && console.warn("↓ Reducing LOD updates", y(this, k), y(this, Y).toFixed(0))) : y(this, Y) >= 60 && y(this, k) > 1 && (q(this, k, y(this, k) - 1), F && console.warn("↑ Increasing LOD updates", y(this, k), y(this, Y).toFixed(0))) : q(this, k, this.updateInterval), y(this, k) > 0 && y(this, J) % y(this, k) != 0))
+    if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (o = !1), o) {
+      if (gt || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, C && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, C && 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();
     }
@@ -833,16 +988,15 @@ const O = class {
    * Update LODs in a scene
    */
   internalUpdate(t, e) {
-    var l, c;
     const s = this.renderer.renderLists.get(t, 0), n = s.opaque;
     this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse);
     const r = this.targetTriangleDensity;
-    for (const d of n) {
-      if (d.material && (((l = d.geometry) == null ? void 0 : l.type) === "BoxGeometry" || ((c = d.geometry) == null ? void 0 : c.type) === "BufferGeometry") && (d.material.name === "SphericalGaussianBlur" || d.material.name == "BackgroundCubeMaterial" || d.material.name === "CubemapFromEquirect" || d.material.name === "EquirectangularToCubeUV")) {
-        F && (d.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (d.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", d, d.material.name, d.material.type)));
+    for (const a of n) {
+      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")) {
+        C && (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 (d.material.type) {
+      switch (a.material.type) {
         case "LineBasicMaterial":
         case "LineDashedMaterial":
         case "PointsMaterial":
@@ -851,62 +1005,58 @@ const O = class {
         case "MeshDepthMaterial":
           continue;
       }
-      if (F === "color" && d.material && !d.object.progressive_debug_color) {
-        d.object.progressive_debug_color = !0;
-        const f = Math.random() * 16777215, w = new Je({ color: f });
-        d.object.material = w;
+      if (C === "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 p = d.object;
-      (p instanceof se || p.isMesh) && this.updateLODs(t, e, p, r);
+      const u = a.object;
+      (u instanceof q || u.isMesh) && this.updateLODs(t, e, u, r);
     }
-    const i = s.transparent;
-    for (const d of i) {
-      const p = d.object;
-      (p instanceof se || p.isMesh) && this.updateLODs(t, e, p, 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 a = s.transmissive;
-    for (const d of a) {
-      const p = d.object;
-      (p instanceof se || p.isMesh) && this.updateLODs(t, e, p, 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);
     }
   }
   /** Update the LOD levels for the renderer. */
   updateLODs(t, e, s, n) {
-    var a, l;
     s.userData || (s.userData = {});
-    let r = s[Se];
-    if (r || (r = new Lt(), s[Se] = r), r.frames++ < 2)
+    let r = s[ce];
+    if (r || (r = new pt(), s[ce] = r), r.frames++ < 2)
       return;
-    for (const c of j)
-      (a = c.onBeforeUpdateLOD) == null || a.call(c, this.renderer, t, e, s);
-    const i = O.overrideGlobalLodLevel !== void 0 ? O.overrideGlobalLodLevel : te;
-    i >= 0 ? ($.mesh_lod = i, $.texture_lod = i) : (this.calculateLodLevel(e, s, r, n, $), $.mesh_lod = Math.round($.mesh_lod), $.texture_lod = Math.round($.texture_lod)), $.mesh_lod >= 0 && this.loadProgressiveMeshes(s, $.mesh_lod), s.material && $.texture_lod >= 0 && this.loadProgressiveTextures(s.material, $.texture_lod), x && s.material && !s.isGizmo && qe(s.material);
-    for (const c of j)
-      (l = c.onAfterUpdatedLOD) == null || l.call(c, this.renderer, t, e, s, $);
-    r.lastLodLevel_Mesh = $.mesh_lod, r.lastLodLevel_Texture = $.texture_lod;
+    for (const l of W)
+      l.onBeforeUpdateLOD?.(this.renderer, t, e, s);
+    const o = L.overrideGlobalLodLevel !== void 0 ? L.overrideGlobalLodLevel : 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 W)
+      l.onAfterUpdatedLOD?.(this.renderer, t, e, s, P);
+    r.lastLodLevel_Mesh = P.mesh_lod, r.lastLodLevel_Texture = P.texture_lod;
   }
   /** Load progressive textures for the given material
    * @param material the material to load the textures for
    * @param level the LOD level to load. Level 0 is the best quality, higher levels are lower quality
    * @returns Promise with true if the LOD was loaded, false if not
    */
-  loadProgressiveTextures(t, e) {
-    if (!t)
-      return;
+  loadProgressiveTextures(t, e, s) {
+    if (!t) return;
     if (Array.isArray(t)) {
       for (const r of t)
         this.loadProgressiveTextures(r, e);
       return;
     }
-    let s = !1;
-    (t[Q] === void 0 || e < t[Q]) && (s = !0);
-    const n = t["DEBUG:LOD"];
-    if (n != null && (s = t[Q] != n, e = n), s) {
-      t[Q] = e;
-      const r = P.assignTextureLOD(t, e).then((i) => {
-        this._lodchangedlisteners.forEach((a) => a({ type: "texture", level: e, object: t }));
+    let n = !1;
+    if ((t[U] === void 0 || e < t[U]) && (n = !0), s !== void 0 && s >= 0 && (n = t[U] != s, e = s), n) {
+      t[U] = e;
+      const r = y.assignTextureLOD(t, e).then((o) => {
+        this._lodchangedlisteners.forEach((l) => l({ type: "texture", level: e, object: t }));
       });
-      ye.addPromise("texture", t, r, this._newPromiseGroups);
+      ue.addPromise("texture", t, r, this._newPromiseGroups);
     }
   }
   /** Load progressive meshes for the given mesh
@@ -916,23 +1066,37 @@ const O = class {
    * @returns Promise with true if the LOD was loaded, false if not
    */
   loadProgressiveMeshes(t, e) {
-    if (!t)
-      return Promise.resolve(null);
-    let s = t[Q] !== e;
+    if (!t) return Promise.resolve(null);
+    let s = t[U] !== e;
     const n = t["DEBUG:LOD"];
-    if (n != null && (s = t[Q] != n, e = n), s) {
-      t[Q] = e;
-      const r = t.geometry, i = P.assignMeshLOD(t, e).then((a) => (a && t[Q] == e && r != t.geometry && this._lodchangedlisteners.forEach((l) => l({ type: "mesh", level: e, object: t })), a));
-      return ye.addPromise("mesh", t, i, this._newPromiseGroups), i;
+    if (n != null && (s = t[U] != n, e = n), s) {
+      t[U] = e;
+      const r = t.geometry, o = y.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 ue.addPromise("mesh", t, o, this._newPromiseGroups), o;
     }
     return Promise.resolve(null);
   }
+  // private testIfLODLevelsAreAvailable() {
+  _sphere = new De();
+  _tempBox = new he();
+  _tempBox2 = new he();
+  tempMatrix = new Le();
+  _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();
   static isInside(t, e) {
-    const s = t.min, n = t.max, r = (s.x + n.x) * 0.5, i = (s.y + n.y) * 0.5;
-    return this._tempPtInside.set(r, i, s.z).applyMatrix4(e).z < 0;
+    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;
   }
+  static skinnedMeshBoundsFrameOffsetCounter = 0;
+  static $skinnedMeshBoundsOffset = Symbol("gltf-progressive-skinnedMeshBoundsOffset");
+  // #region calculateLodLevel
   calculateLodLevel(t, e, s, n, r) {
-    var b, R, Z;
     if (!e) {
       r.mesh_lod = -1, r.texture_lod = -1;
       return;
@@ -941,105 +1105,105 @@ const O = class {
       r.mesh_lod = -1, r.texture_lod = -1;
       return;
     }
-    let a = 10 + 1, l = !1;
-    if (F && e["DEBUG:LOD"] != null)
+    let l = 10 + 1, a = !1;
+    if (C && e["DEBUG:LOD"] != null)
       return e["DEBUG:LOD"];
-    const c = (b = P.getMeshLODExtension(e.geometry)) == null ? void 0 : b.lods, d = P.getPrimitiveIndex(e.geometry), p = c && c.length > 0, f = P.getMaterialMinMaxLODsCount(e.material), w = (f == null ? void 0 : f.min_count) != 1 / 0 && f.min_count > 0 && f.max_count > 0;
-    if (!p && !w) {
+    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) {
       r.mesh_lod = 0, r.texture_lod = 0;
       return;
     }
-    p || (l = !0, a = 0);
-    const M = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let A = e.geometry.boundingBox;
+    p || (a = !0, l = 0);
+    const I = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let G = e.geometry.boundingBox;
     if (e.type === "SkinnedMesh") {
-      const h = e;
-      if (!h.boundingBox)
-        h.computeBoundingBox();
+      const d = e;
+      if (!d.boundingBox)
+        d.computeBoundingBox();
       else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
-        if (!h[O.$skinnedMeshBoundsOffset]) {
-          const C = O.skinnedMeshBoundsFrameOffsetCounter++;
-          h[O.$skinnedMeshBoundsOffset] = C;
+        if (!d[L.$skinnedMeshBoundsOffset]) {
+          const O = L.skinnedMeshBoundsFrameOffsetCounter++;
+          d[L.$skinnedMeshBoundsOffset] = O;
         }
-        const L = h[O.$skinnedMeshBoundsOffset];
-        if ((s.frames + L) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
-          const C = ce(h), N = h.geometry;
-          C && (h.geometry = C), h.computeBoundingBox(), h.geometry = N;
+        const x = d[L.$skinnedMeshBoundsOffset];
+        if ((s.frames + x) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
+          const O = J(d), B = d.geometry;
+          O && (d.geometry = O), d.computeBoundingBox(), d.geometry = B;
         }
       }
-      A = h.boundingBox;
+      G = d.boundingBox;
     }
-    if (A) {
-      const h = t;
+    if (G) {
+      const d = 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 g = t.getWorldPosition(this._tempWorldPosition);
-        if (this._sphere.containsPoint(g)) {
+        const f = t.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(f)) {
           r.mesh_lod = 0, r.texture_lod = 0;
           return;
         }
       }
-      if (this._tempBox.copy(A), this._tempBox.applyMatrix4(e.matrixWorld), h.isPerspectiveCamera && O.isInside(this._tempBox, this.projectionScreenMatrix)) {
+      if (this._tempBox.copy(G), this._tempBox.applyMatrix4(e.matrixWorld), d.isPerspectiveCamera && L.isInside(this._tempBox, this.projectionScreenMatrix)) {
         r.mesh_lod = 0, r.texture_lod = 0;
         return;
       }
-      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && h.isPerspectiveCamera && h.fov > 70) {
-        const g = this._tempBox.min, _ = this._tempBox.max;
-        let G = g.x, E = g.y, z = _.x, ne = _.y;
-        const fe = 2, ve = 1.5, he = (g.x + _.x) * 0.5, ge = (g.y + _.y) * 0.5;
-        G = (G - he) * fe + he, E = (E - ge) * fe + ge, z = (z - he) * fe + he, ne = (ne - ge) * fe + ge;
-        const Xe = G < 0 && z > 0 ? 0 : Math.min(Math.abs(g.x), Math.abs(_.x)), Ke = E < 0 && ne > 0 ? 0 : Math.min(Math.abs(g.y), Math.abs(_.y)), Me = Math.max(Xe, Ke);
-        s.lastCentrality = (ve - Me) * (ve - Me) * (ve - Me);
+      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, K = h.y;
+        const Z = 2, oe = 1.5, ee = (f.x + h.x) * 0.5, te = (f.y + h.y) * 0.5;
+        M = (M - ee) * Z + ee, D = (D - te) * Z + te, $ = ($ - ee) * Z + ee, K = (K - te) * Z + te;
+        const Re = M < 0 && $ > 0 ? 0 : Math.min(Math.abs(f.x), Math.abs(h.x)), Be = D < 0 && K > 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);
       } else
         s.lastCentrality = 1;
-      const L = this._tempBox.getSize(this._tempBoxSize);
-      L.multiplyScalar(0.5), screen.availHeight > 0 && M > 0 && L.multiplyScalar(M / screen.availHeight), t.isPerspectiveCamera ? L.x *= t.aspect : t.isOrthographicCamera;
-      const C = t.matrixWorldInverse, N = this._tempBox2;
-      N.copy(A), N.applyMatrix4(e.matrixWorld), N.applyMatrix4(C);
-      const S = N.getSize(this._tempBox2Size), ee = Math.max(S.x, S.y);
-      if (Math.max(L.x, L.y) != 0 && ee != 0 && (L.z = S.z / Math.max(S.x, S.y) * Math.max(L.x, L.y)), s.lastScreenCoverage = Math.max(L.x, L.y, L.z), s.lastScreenspaceVolume.copy(L), s.lastScreenCoverage *= s.lastCentrality, F && O.debugDrawLine) {
-        const g = this.tempMatrix.copy(this.projectionScreenMatrix);
-        g.invert();
-        const _ = O.corner0, G = O.corner1, E = O.corner2, z = O.corner3;
-        _.copy(this._tempBox.min), G.copy(this._tempBox.max), G.x = _.x, E.copy(this._tempBox.max), E.y = _.y, z.copy(this._tempBox.max);
-        const ne = (_.z + z.z) * 0.5;
-        _.z = G.z = E.z = z.z = ne, _.applyMatrix4(g), G.applyMatrix4(g), E.applyMatrix4(g), z.applyMatrix4(g), O.debugDrawLine(_, G, 255), O.debugDrawLine(_, E, 255), O.debugDrawLine(G, z, 255), O.debugDrawLine(E, z, 255);
+      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, C && L.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 K = (h.z + $.z) * 0.5;
+        h.z = M.z = D.z = $.z = K, 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);
       }
-      let v = 999;
-      if (c && s.lastScreenCoverage > 0)
-        for (let g = 0; g < c.length; g++) {
-          const _ = c[g];
-          if ((((R = _.densities) == null ? void 0 : R[d]) || _.density || 1e-5) / s.lastScreenCoverage < n) {
-            v = g;
+      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 && _e() && !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;
             break;
           }
         }
-      v < a && (a = v, l = !0);
+      w < l && (l = w, a = !0);
     }
-    if (l ? r.mesh_lod = a : r.mesh_lod = s.lastLodLevel_Mesh, F && r.mesh_lod != s.lastLodLevel_Mesh) {
-      const L = c == null ? void 0 : c[r.mesh_lod];
-      L && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${r.mesh_lod} (${L.density.toFixed(0)}) - ${e.name}`);
+    if (a ? r.mesh_lod = l : r.mesh_lod = s.lastLodLevel_Mesh, C && r.mesh_lod != s.lastLodLevel_Mesh) {
+      const x = u?.[r.mesh_lod];
+      x && console.debug(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${r.mesh_lod} (density: ${x.densities?.[c].toFixed(0)}) | ${e.name}`);
     }
-    if (w) {
-      const h = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
+    if (v) {
+      const d = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
       if (s.lastLodLevel_Texture < 0) {
-        if (r.texture_lod = f.max_count - 1, F) {
-          const L = f.lods[f.max_count - 1];
-          F && console.log(`First Texture LOD ${r.texture_lod} (${L.max_height}px) - ${e.name}`);
+        if (r.texture_lod = _.max_count - 1, C) {
+          const x = _.lods[_.max_count - 1];
+          C && console.log(`First Texture LOD ${r.texture_lod} (${x.max_height}px) - ${e.name}`);
         }
       } else {
-        const L = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
-        let C = s.lastScreenCoverage * 4;
-        ((Z = this.context) == null ? void 0 : Z.engine) === "model-viewer" && (C *= 1.5);
-        const S = M / window.devicePixelRatio * C;
-        let ee = !1;
-        for (let B = f.lods.length - 1; B >= 0; B--) {
-          const v = f.lods[B];
-          if (!(h && v.max_height >= 2048) && !(dt() && v.max_height > 4096) && (v.max_height > S || !ee && B === 0)) {
-            if (ee = !0, r.texture_lod = B, r.texture_lod < s.lastLodLevel_Texture) {
-              const m = v.max_height;
-              F && console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${r.texture_lod} = ${m}px 
-Screensize: ${S.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${L.toFixed(1)} 
+        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, C && 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)} 
 ${e.name}`);
             }
             break;
@@ -1049,85 +1213,73 @@ ${e.name}`);
     } else
       r.texture_lod = 0;
   }
-};
-let T = O;
-k = new WeakMap(), K = new WeakMap(), _e = new WeakMap(), J = new WeakMap(), ie = new WeakMap(), we = new WeakMap(), Y = new WeakMap(), /** 
- * 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.
- */
-u(T, "debugDrawLine"), /**
- * Force override the LOD level for all objects in the scene
- */
-u(T, "overrideGlobalLodLevel"), u(T, "corner0", new W()), u(T, "corner1", new W()), u(T, "corner2", new W()), u(T, "corner3", new W()), u(T, "_tempPtInside", new W()), u(T, "skinnedMeshBoundsFrameOffsetCounter", 0), u(T, "$skinnedMeshBoundsOffset", Symbol("gltf-progressive-skinnedMeshBoundsOffset"));
-class Lt {
-  constructor() {
-    u(this, "frames", 0);
-    u(this, "lastLodLevel_Mesh", -1);
-    u(this, "lastLodLevel_Texture", -1);
-    u(this, "lastScreenCoverage", 0);
-    u(this, "lastScreenspaceVolume", new W());
-    u(this, "lastCentrality", 0);
-  }
 }
-const $e = Symbol("NEEDLE_mesh_lod"), pe = Symbol("NEEDLE_texture_lod");
-let ue = null;
-function Ve() {
-  const o = _t();
-  o && (o.mapURLs(function(t) {
-    return ke(), t;
-  }), ke(), ue == null || ue.disconnect(), ue = new MutationObserver((t) => {
+class pt {
+  frames = 0;
+  lastLodLevel_Mesh = -1;
+  lastLodLevel_Texture = -1;
+  lastScreenCoverage = 0;
+  lastScreenspaceVolume = new A();
+  lastCentrality = 0;
+}
+const ve = Symbol("NEEDLE_mesh_lod"), se = Symbol("NEEDLE_texture_lod");
+let fe = null;
+function Ce() {
+  const i = mt();
+  i && (i.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" && We(s);
+        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && ke(s);
       });
     });
-  }), ue.observe(document, { childList: !0, subtree: !0 }));
+  }), fe.observe(document, { childList: !0, subtree: !0 }));
 }
-function _t() {
-  if (typeof customElements > "u")
-    return null;
-  const o = customElements.get("model-viewer");
-  return o || (customElements.whenDefined("model-viewer").then(() => {
-    console.debug("[gltf-progressive] model-viewer defined"), Ve();
+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"), Ce();
   }), null);
 }
-function ke() {
-  if (typeof document > "u")
-    return;
+function be() {
+  if (typeof document > "u") return;
   document.querySelectorAll("model-viewer").forEach((t) => {
-    We(t);
+    ke(t);
   });
 }
-const Ie = /* @__PURE__ */ new WeakSet();
-let wt = 0;
-function We(o) {
-  if (!o || Ie.has(o))
+const Me = /* @__PURE__ */ new WeakSet();
+let yt = 0;
+function ke(i) {
+  if (!i || Me.has(i))
     return null;
-  Ie.add(o), console.debug("[gltf-progressive] found new model-viewer..." + ++wt + `
-`, o.getAttribute("src"));
+  Me.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++yt + `
+`, i.getAttribute("src"));
   let t = null, e = null, s = null;
-  for (let n = o; n != null; n = Object.getPrototypeOf(n)) {
-    const r = Object.getOwnPropertySymbols(n), i = r.find((c) => c.toString() == "Symbol(renderer)"), a = r.find((c) => c.toString() == "Symbol(scene)"), l = r.find((c) => c.toString() == "Symbol(needsRender)");
-    !t && i != null && (t = o[i].threeRenderer), !e && a != null && (e = o[a]), !s && l != null && (s = o[l]);
+  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]);
   }
   if (t && e) {
     let n = function() {
       if (s) {
-        let i = 0, a = setInterval(() => {
-          if (i++ > 5) {
-            clearInterval(a);
+        let o = 0, l = setInterval(() => {
+          if (o++ > 5) {
+            clearInterval(l);
             return;
           }
-          s == null || s.call(o);
+          s?.call(i);
         }, 300);
       }
     };
     console.debug("[gltf-progressive] setup model-viewer");
-    const r = T.get(t, { engine: "model-viewer" });
-    return T.addPlugin(new vt()), r.enable(), r.addEventListener("changed", () => {
-      s == null || s.call(o);
-    }), o.addEventListener("model-visibility", (i) => {
-      i.detail.visible && (s == null || s.call(o));
-    }), o.addEventListener("load", () => {
+    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();
     }), () => {
       r.disable();
@@ -1135,10 +1287,8 @@ function We(o) {
   }
   return null;
 }
-class vt {
-  constructor() {
-    u(this, "_didWarnAboutMissingUrl", !1);
-  }
+class xt {
+  _didWarnAboutMissingUrl = !1;
   onBeforeUpdateLOD(t, e, s, n) {
     this.tryParseMeshLOD(e, n), this.tryParseTextureLOD(e, n);
   }
@@ -1155,96 +1305,87 @@ class vt {
     return t.element;
   }
   tryParseTextureLOD(t, e) {
-    if (e[pe] == !0)
-      return;
-    e[pe] = !0;
+    if (e[se] == !0) return;
+    e[se] = !0;
     const s = this.tryGetCurrentGLTF(t), n = this.tryGetCurrentModelViewer(t), r = this.getUrl(n);
     if (r && s && e.material) {
-      let i = function(l) {
-        var d, p, f;
-        if (l[pe] == !0)
-          return;
-        l[pe] = !0, l.userData && (l.userData.LOD = -1);
-        const c = Object.keys(l);
-        for (let w = 0; w < c.length; w++) {
-          const M = c[w], A = l[M];
-          if ((A == null ? void 0 : A.isTexture) === !0) {
-            const b = (p = (d = A.userData) == null ? void 0 : d.associations) == null ? void 0 : p.textures;
-            if (b == null)
-              continue;
-            const R = s.parser.json.textures[b];
-            if (!R) {
-              console.warn("Texture data not found for texture index " + b);
+      let o = function(a) {
+        if (a[se] == !0) return;
+        a[se] = !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];
+            if (!I) {
+              console.warn("Texture data not found for texture index " + v);
               continue;
             }
-            if ((f = R == null ? void 0 : R.extensions) != null && f[X]) {
-              const Z = R.extensions[X];
-              Z && r && P.registerTexture(r, A, Z.lods.length, b, Z);
+            if (I?.extensions?.[F]) {
+              const G = I.extensions[F];
+              G && r && y.registerTexture(r, _, G.lods.length, v, G);
             }
           }
         }
       };
-      const a = e.material;
-      if (Array.isArray(a))
-        for (const l of a)
-          i(l);
-      else
-        i(a);
+      const l = e.material;
+      if (Array.isArray(l)) for (const a of l) o(a);
+      else o(l);
     }
   }
   tryParseMeshLOD(t, e) {
-    var i, a;
-    if (e[$e] == !0)
-      return;
-    e[$e] = !0;
+    if (e[ve] == !0) return;
+    e[ve] = !0;
     const s = this.tryGetCurrentModelViewer(t), n = this.getUrl(s);
     if (!n)
       return;
-    const r = (a = (i = e.userData) == null ? void 0 : i.gltfExtensions) == null ? void 0 : a[X];
+    const r = e.userData?.gltfExtensions?.[F];
     if (r && n) {
-      const l = e.uuid;
-      P.registerMesh(n, l, e, 0, r.lods.length, r);
+      const o = e.uuid;
+      y.registerMesh(n, o, e, 0, r.lods.length, r);
     }
   }
 }
-function Mt(o, t, e, s) {
-  Ue(t), Ne(e), ze(e, {
+function wt(i, t, e, s) {
+  xe(t), Se(e), Te(e, {
     progressive: !0,
-    ...s == null ? void 0 : s.hints
-  }), e.register((r) => new P(r, o));
-  const n = T.get(t);
-  return (s == null ? void 0 : s.enableLODsManager) !== !1 && n.enable(), n;
+    ...s?.hints
+  }), e.register((r) => new y(r, i));
+  const n = L.get(t);
+  return s?.enableLODsManager !== !1 && n.enable(), n;
 }
-Ve();
-if (!ht) {
-  const o = {
+Ce();
+if (!rt) {
+  const i = {
     gltfProgressive: {
-      useNeedleProgressive: Mt,
-      LODsManager: T,
-      configureLoader: ze,
-      getRaycastMesh: ce,
-      useRaycastMeshes: pt
+      useNeedleProgressive: wt,
+      LODsManager: L,
+      configureLoader: Te,
+      getRaycastMesh: J,
+      useRaycastMeshes: ot
     }
   };
   if (!globalThis.Needle)
-    globalThis.Needle = o;
+    globalThis.Needle = i;
   else
-    for (const t in o)
-      globalThis.Needle[t] = o[t];
+    for (const t in i)
+      globalThis.Needle[t] = i[t];
 }
 export {
-  X as EXTENSION_NAME,
-  T as LODsManager,
-  P as NEEDLE_progressive,
-  rt as VERSION,
-  Ne as addDracoAndKTX2Loaders,
-  ze as configureLoader,
-  Ue as createLoaders,
-  ce as getRaycastMesh,
-  Ve as patchModelViewer,
-  gt as registerRaycastMesh,
-  ot as setDracoDecoderLocation,
-  at as setKTX2TranscoderLocation,
-  Mt as useNeedleProgressive,
-  pt as useRaycastMeshes
+  F as EXTENSION_NAME,
+  L as LODsManager,
+  y as NEEDLE_progressive,
+  Ke as VERSION,
+  Se as addDracoAndKTX2Loaders,
+  Te as configureLoader,
+  xe as createLoaders,
+  J as getRaycastMesh,
+  Ce as patchModelViewer,
+  nt as registerRaycastMesh,
+  Qe as setDracoDecoderLocation,
+  Je as setKTX2TranscoderLocation,
+  wt as useNeedleProgressive,
+  ot as useRaycastMeshes
 };