@needle-tools/gltf-progressive 1.2.2-alpha.3 → 1.2.3-alpha

package/gltf-progressive.js

@@ -1,176 +1,184 @@
-var Se = Object.defineProperty;
-var be = (l, e, t) => e in l ? Se(l, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : l[e] = t;
-var f = (l, e, t) => (be(l, typeof e != "symbol" ? e + "" : e, t), t);
-import { BufferGeometry as se, Mesh as W, Material as Te, Texture as q, TextureLoader as Ae, Matrix4 as ye, Frustum as Pe, Sphere as Ce, Box3 as me, Vector3 as G } from "three";
-import { GLTFLoader as Ee } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { MeshoptDecoder as Be } from "three/examples/jsm/libs/meshopt_decoder.module.js";
-import { DRACOLoader as ke } from "three/examples/jsm/loaders/DRACOLoader.js";
-import { KTX2Loader as Re } from "three/examples/jsm/loaders/KTX2Loader.js";
-const De = "";
-globalThis.GLTF_PROGRESSIVE_VERSION = De;
-console.debug(`[gltf-progressive] version ${De}`);
-let ie = "https://www.gstatic.com/draco/versioned/decoders/1.4.1/", ge = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
-fetch(ie + "draco_decoder.js", { method: "head" }).catch((l) => {
-  ie = "./include/draco/", ge = "./include/ktx2/";
+var ze = Object.defineProperty;
+var Ve = (a, t, e) => t in a ? ze(a, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[t] = e;
+var d = (a, t, e) => (Ve(a, typeof t != "symbol" ? t + "" : t, e), e), Se = (a, t, e) => {
+  if (!t.has(a))
+    throw TypeError("Cannot " + e);
+};
+var m = (a, t, e) => (Se(a, t, "read from private field"), e ? e.call(a) : t.get(a)), q = (a, t, e) => {
+  if (t.has(a))
+    throw TypeError("Cannot add the same private member more than once");
+  t instanceof WeakSet ? t.add(a) : t.set(a, e);
+}, $ = (a, t, e, r) => (Se(a, t, "write to private field"), r ? r.call(a, e) : t.set(a, e), e);
+import { BufferGeometry as de, Mesh as J, Material as Ne, Texture as ee, TextureLoader as Ue, Matrix4 as be, Frustum as We, Clock as Ke, MeshStandardMaterial as qe, Sphere as Xe, Box3 as Te, Vector3 as V } from "three";
+import { GLTFLoader as Ye } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { MeshoptDecoder as He } from "three/examples/jsm/libs/meshopt_decoder.module.js";
+import { DRACOLoader as Je } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { KTX2Loader as Qe } from "three/examples/jsm/loaders/KTX2Loader.js";
+const Be = "";
+globalThis.GLTF_PROGRESSIVE_VERSION = Be;
+console.debug(`[gltf-progressive] version ${Be}`);
+let he = "https://www.gstatic.com/draco/versioned/decoders/1.4.1/", _e = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
+fetch(he + "draco_decoder.js", { method: "head" }).catch((a) => {
+  he = "./include/draco/", _e = "./include/ktx2/";
 });
-function Ze(l) {
-  ie = l;
+function gt(a) {
+  he = a;
 }
-function je(l) {
-  ge = l;
+function pt(a) {
+  _e = a;
 }
-let H, fe, J;
-function we(l) {
-  H || (H = new ke(), H.setDecoderPath(ie), H.setDecoderConfig({ type: "js" })), J || (J = new Re(), J.setTranscoderPath(ge)), fe || (fe = Be), l ? J.detectSupport(l) : console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures will probably fail");
+let ie, De, oe;
+function ke(a) {
+  ie || (ie = new Je(), ie.setDecoderPath(he), ie.setDecoderConfig({ type: "js" })), oe || (oe = new Qe(), oe.setTranscoderPath(_e)), De || (De = He), a ? oe.detectSupport(a) : console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures will probably fail");
 }
-function _e(l) {
-  l.dracoLoader || l.setDRACOLoader(H), l.ktx2Loader || l.setKTX2Loader(J), l.meshoptDecoder || l.setMeshoptDecoder(fe);
+function Ie(a) {
+  a.dracoLoader || a.setDRACOLoader(ie), a.ktx2Loader || a.setKTX2Loader(oe), a.meshoptDecoder || a.setMeshoptDecoder(De);
 }
-Z("debugprogressive");
-function Z(l) {
-  const t = new URL(window.location.href).searchParams.get(l);
-  return t == null || t === "0" || t === "false" ? !1 : t === "" ? !0 : t;
+ae("debugprogressive");
+function ae(a) {
+  const e = new URL(window.location.href).searchParams.get(a);
+  return e == null || e === "0" || e === "false" ? !1 : e === "" ? !0 : e;
 }
-function Ie(l, e) {
-  if (e === void 0 || e.startsWith("./") || e.startsWith("http") || l === void 0)
-    return e;
-  const t = l.lastIndexOf("/");
-  if (t >= 0) {
-    const r = l.substring(0, t + 1);
-    for (; r.endsWith("/") && e.startsWith("/"); )
-      e = e.substring(1);
-    return r + e;
-  }
-  return e;
+function Ze(a, t) {
+  if (t === void 0 || t.startsWith("./") || t.startsWith("http") || a === void 0)
+    return t;
+  const e = a.lastIndexOf("/");
+  if (e >= 0) {
+    const r = a.substring(0, e + 1);
+    for (; r.endsWith("/") && t.startsWith("/"); )
+      t = t.substring(1);
+    return r + t;
+  }
+  return t;
 }
-let X;
-function Ge() {
-  return X !== void 0 || (X = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), Z("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", X)), X;
+let te;
+function je() {
+  return te !== void 0 || (te = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), ae("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", te)), te;
 }
-const de = Symbol("needle:raycast-mesh");
-function pe(l) {
-  return (l == null ? void 0 : l[de]) instanceof se ? l[de] : null;
+const we = Symbol("needle:raycast-mesh");
+function Oe(a) {
+  return (a == null ? void 0 : a[we]) instanceof de ? a[we] : null;
 }
-function Fe(l, e) {
-  if ((l.type === "Mesh" || l.type === "SkinnedMesh") && !pe(l)) {
-    const r = $e(e);
-    r.userData = { isRaycastMesh: !0 }, l[de] = r;
+function et(a, t) {
+  if ((a.type === "Mesh" || a.type === "SkinnedMesh") && !Oe(a)) {
+    const r = tt(t);
+    r.userData = { isRaycastMesh: !0 }, a[we] = r;
   }
 }
-function et(l = !0) {
-  if (l) {
-    if (Y)
+function yt(a = !0) {
+  if (a) {
+    if (re)
       return;
-    const e = Y = W.prototype.raycast;
-    W.prototype.raycast = function(t, r) {
-      const i = this, n = pe(i);
+    const t = re = J.prototype.raycast;
+    J.prototype.raycast = function(e, r) {
+      const o = this, i = Oe(o);
       let s;
-      n && i.isMesh && (s = i.geometry, i.geometry = n), e.call(this, t, r), s && (i.geometry = s);
+      i && o.isMesh && (s = o.geometry, o.geometry = i), t.call(this, e, r), s && (o.geometry = s);
     };
   } else {
-    if (!Y)
+    if (!re)
       return;
-    W.prototype.raycast = Y, Y = null;
+    J.prototype.raycast = re, re = null;
   }
 }
-let Y = null;
-function $e(l) {
-  const e = new se();
-  for (const t in l.attributes)
-    e.setAttribute(t, l.getAttribute(t));
-  return e.setIndex(l.getIndex()), e;
+let re = null;
+function tt(a) {
+  const t = new de();
+  for (const e in a.attributes)
+    t.setAttribute(e, a.getAttribute(e));
+  return t.setIndex(a.getIndex()), t;
 }
-const z = new Array(), F = "NEEDLE_progressive", m = Z("debugprogressive"), ae = Symbol("needle-progressive-texture"), Q = /* @__PURE__ */ new Map(), he = /* @__PURE__ */ new Set();
-if (m) {
-  let l = function() {
-    e += 1, console.log("Toggle LOD level", e, Q), Q.forEach((i, n) => {
-      for (const s of i.keys) {
-        const o = n[s];
-        if (o != null) {
-          if (o.isBufferGeometry === !0) {
-            const a = O.getMeshLODInformation(o), d = a ? Math.min(e, a.lods.length) : 0;
-            n["DEBUG:LOD"] = e, O.assignMeshLOD(n, d), a && (t = Math.max(t, a.lods.length - 1));
-          } else if (n.isMaterial === !0) {
-            n["DEBUG:LOD"] = e, O.assignTextureLOD(n, e);
+const X = new Array(), N = "NEEDLE_progressive", L = ae("debugprogressive"), xe = Symbol("needle-progressive-texture"), ne = /* @__PURE__ */ new Map(), ve = /* @__PURE__ */ new Set();
+if (L) {
+  let a = function() {
+    t += 1, console.log("Toggle LOD level", t, ne), ne.forEach((o, i) => {
+      for (const s of o.keys) {
+        const n = i[s];
+        if (n != null) {
+          if (n.isBufferGeometry === !0) {
+            const l = S.getMeshLODInformation(n), u = l ? Math.min(t, l.lods.length) : 0;
+            i["DEBUG:LOD"] = t, S.assignMeshLOD(i, u), l && (e = Math.max(e, l.lods.length - 1));
+          } else if (i.isMaterial === !0) {
+            i["DEBUG:LOD"] = t, S.assignTextureLOD(i, t);
             break;
           }
         }
       }
-    }), e >= t && (e = -1);
-  }, e = -1, t = 2, r = !1;
-  window.addEventListener("keyup", (i) => {
-    i.key === "p" && l(), i.key === "w" && (r = !r, he && he.forEach((n) => {
-      n.name != "BackgroundCubeMaterial" && n.glyphMap == null && "wireframe" in n && (n.wireframe = r);
+    }), t >= e && (t = -1);
+  }, t = -1, e = 2, r = !1;
+  window.addEventListener("keyup", (o) => {
+    o.key === "p" && a(), o.key === "w" && (r = !r, ve && ve.forEach((i) => {
+      i.name != "BackgroundCubeMaterial" && i.glyphMap == null && "wireframe" in i && (i.wireframe = r);
     }));
   });
 }
-function xe(l, e, t) {
-  var i;
-  if (!m)
+function Ae(a, t, e) {
+  var o;
+  if (!L)
     return;
-  Q.has(l) || Q.set(l, { keys: [], sourceId: t });
-  const r = Q.get(l);
-  ((i = r == null ? void 0 : r.keys) == null ? void 0 : i.includes(e)) == !1 && r.keys.push(e);
+  ne.has(a) || ne.set(a, { keys: [], sourceId: e });
+  const r = ne.get(a);
+  ((o = r == null ? void 0 : r.keys) == null ? void 0 : o.includes(t)) == !1 && r.keys.push(t);
 }
-const v = class {
-  constructor(e, t) {
-    f(this, "parser");
-    f(this, "url");
-    f(this, "_isLoadingMesh");
-    f(this, "loadMesh", (e) => {
-      var r, i;
+const O = class {
+  constructor(t, e) {
+    d(this, "parser");
+    d(this, "url");
+    d(this, "_isLoadingMesh");
+    d(this, "loadMesh", (t) => {
+      var r, o;
       if (this._isLoadingMesh)
         return null;
-      const t = (i = (r = this.parser.json.meshes[e]) == null ? void 0 : r.extensions) == null ? void 0 : i[F];
-      return t ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", e).then((n) => {
+      const e = (o = (r = this.parser.json.meshes[t]) == null ? void 0 : r.extensions) == null ? void 0 : o[N];
+      return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((i) => {
         var s;
-        return this._isLoadingMesh = !1, n && v.registerMesh(this.url, t.guid, n, (s = t.lods) == null ? void 0 : s.length, void 0, t), n;
+        return this._isLoadingMesh = !1, i && O.registerMesh(this.url, e.guid, i, (s = e.lods) == null ? void 0 : s.length, void 0, e), i;
       })) : null;
     });
-    m && console.log("Progressive extension registered for", t), this.parser = e, this.url = t;
+    L && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
   }
   /** The name of the extension */
   get name() {
-    return F;
+    return N;
   }
-  static getMeshLODInformation(e) {
-    const t = this.getAssignedLODInformation(e);
-    return t != null && t.key ? this.lodInfos.get(t.key) : null;
+  static getMeshLODInformation(t) {
+    const e = this.getAssignedLODInformation(t);
+    return e != null && e.key ? this.lodInfos.get(e.key) : null;
   }
-  static getMaterialMinMaxLODsCount(e, t) {
-    const r = this, i = "LODS:minmax", n = e[i];
-    if (n != null)
-      return n;
-    if (t || (t = {
+  static getMaterialMinMaxLODsCount(t, e) {
+    const r = this, o = "LODS:minmax", i = t[o];
+    if (i != null)
+      return i;
+    if (e || (e = {
       min_count: 1 / 0,
       max_count: 0,
       lods: []
-    }), Array.isArray(e)) {
-      for (const o of e)
-        this.getMaterialMinMaxLODsCount(o, t);
-      return e[i] = t, t;
+    }), Array.isArray(t)) {
+      for (const n of t)
+        this.getMaterialMinMaxLODsCount(n, e);
+      return t[o] = e, e;
     }
-    if (m === "verbose" && console.log("getMaterialMinMaxLODsCount", e), e.type === "ShaderMaterial" || e.type === "RawShaderMaterial") {
-      const o = e;
-      for (const a of Object.keys(o.uniforms)) {
-        const d = o.uniforms[a].value;
-        (d == null ? void 0 : d.isTexture) === !0 && s(d, t);
+    if (L === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
+      const n = t;
+      for (const l of Object.keys(n.uniforms)) {
+        const u = n.uniforms[l].value;
+        (u == null ? void 0 : u.isTexture) === !0 && s(u, e);
       }
-    } else if (e.isMaterial)
-      for (const o of Object.keys(e)) {
-        const a = e[o];
-        (a == null ? void 0 : a.isTexture) === !0 && s(a, t);
+    } else if (t.isMaterial)
+      for (const n of Object.keys(t)) {
+        const l = t[n];
+        (l == null ? void 0 : l.isTexture) === !0 && s(l, e);
       }
-    return e[i] = t, t;
-    function s(o, a) {
-      const d = r.getAssignedLODInformation(o);
-      if (d) {
-        const c = r.lodInfos.get(d.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 x = 0; x < c.lods.length; x++) {
-            const u = c.lods[x];
-            u.width && (a.lods[x] = a.lods[x] || { min_height: 1 / 0, max_height: 0 }, a.lods[x].min_height = Math.min(a.lods[x].min_height, u.height), a.lods[x].max_height = Math.max(a.lods[x].max_height, u.height));
+    return t[o] = e, e;
+    function s(n, l) {
+      const u = r.getAssignedLODInformation(n);
+      if (u) {
+        const f = r.lodInfos.get(u.key);
+        if (f && f.lods) {
+          l.min_count = Math.min(l.min_count, f.lods.length), l.max_count = Math.max(l.max_count, f.lods.length);
+          for (let M = 0; M < f.lods.length; M++) {
+            const c = f.lods[M];
+            c.width && (l.lods[M] = l.lods[M] || { min_height: 1 / 0, max_height: 0 }, l.lods[M].min_height = Math.min(l.lods[M].min_height, c.height), l.lods[M].max_height = Math.max(l.lods[M].max_height, c.height));
           }
         }
       }
@@ -181,33 +189,33 @@ const v = class {
    * @param level the level of detail to check for (0 is the highest resolution). If undefined, the function checks if any LOD level is available
    * @returns true if the LOD level is available (or if any LOD level is available if level is undefined)
    */
-  static hasLODLevelAvailable(e, t) {
-    var n;
-    if (Array.isArray(e)) {
-      for (const s of e)
-        if (this.hasLODLevelAvailable(s, t))
+  static hasLODLevelAvailable(t, e) {
+    var i;
+    if (Array.isArray(t)) {
+      for (const s of t)
+        if (this.hasLODLevelAvailable(s, e))
           return !0;
       return !1;
     }
-    if (e.isMaterial === !0) {
-      for (const s of Object.keys(e)) {
-        const o = e[s];
-        if (o && o.isTexture && this.hasLODLevelAvailable(o, t))
+    if (t.isMaterial === !0) {
+      for (const s of Object.keys(t)) {
+        const n = t[s];
+        if (n && n.isTexture && this.hasLODLevelAvailable(n, e))
           return !0;
       }
       return !1;
-    } else if (e.isGroup === !0) {
-      for (const s of e.children)
-        if (s.isMesh === !0 && this.hasLODLevelAvailable(s, t))
+    } else if (t.isGroup === !0) {
+      for (const s of t.children)
+        if (s.isMesh === !0 && this.hasLODLevelAvailable(s, e))
           return !0;
     }
-    let r, i;
-    if (e.isMesh ? r = e.geometry : (e.isBufferGeometry || e.isTexture) && (r = e), r && (n = r == null ? void 0 : r.userData) != null && n.LODS) {
+    let r, o;
+    if (t.isMesh ? r = t.geometry : (t.isBufferGeometry || t.isTexture) && (r = t), r && (i = r == null ? void 0 : r.userData) != null && i.LODS) {
       const s = r.userData.LODS;
-      if (i = this.lodInfos.get(s.key), t === void 0)
-        return i != null;
-      if (i)
-        return Array.isArray(i.lods) ? t < i.lods.length : t === 0;
+      if (o = this.lodInfos.get(s.key), e === void 0)
+        return o != null;
+      if (o)
+        return Array.isArray(o.lods) ? e < o.lods.length : e === 0;
     }
     return !1;
   }
@@ -225,28 +233,28 @@ const v = class {
    * });
    * ```
    */
-  static assignMeshLOD(e, t) {
+  static assignMeshLOD(t, e) {
     var r;
-    if (!e)
+    if (!t)
       return Promise.resolve(null);
-    if (e instanceof W || e.isMesh === !0) {
-      const i = e.geometry, n = this.getAssignedLODInformation(i);
-      if (!n)
+    if (t instanceof J || t.isMesh === !0) {
+      const o = t.geometry, i = this.getAssignedLODInformation(o);
+      if (!i)
         return Promise.resolve(null);
-      for (const s of z)
-        (r = s.onBeforeGetLODMesh) == null || r.call(s, e, t);
-      return e["LOD:requested level"] = t, v.getOrLoadLOD(i, t).then((s) => {
-        if (e["LOD:requested level"] === t) {
-          if (delete e["LOD:requested level"], Array.isArray(s)) {
-            const o = n.index || 0;
-            s = s[o];
+      for (const s of X)
+        (r = s.onBeforeGetLODMesh) == null || r.call(s, t, e);
+      return t["LOD:requested level"] = e, O.getOrLoadLOD(o, e).then((s) => {
+        if (t["LOD:requested level"] === e) {
+          if (delete t["LOD:requested level"], Array.isArray(s)) {
+            const n = i.index || 0;
+            s = s[n];
           }
-          s && i != s && ((s == null ? void 0 : s.isBufferGeometry) ? (e.geometry = s, m && xe(e, "geometry", n.url)) : m && console.error("Invalid LOD geometry", s));
+          s && o != s && ((s == null ? void 0 : s.isBufferGeometry) ? (t.geometry = s, L && Ae(t, "geometry", i.url)) : L && console.error("Invalid LOD geometry", s));
         }
         return s;
-      }).catch((s) => (console.error("Error loading mesh LOD", e, s), null));
+      }).catch((s) => (console.error("Error loading mesh LOD", t, s), null));
     } else
-      m && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", e);
+      L && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
     return Promise.resolve(null);
   }
   /** Load a different resolution of a texture (if available)  
@@ -256,381 +264,389 @@ const v = class {
    * @param level the level of detail to load (0 is the highest resolution) - currently only 0 is supported
    * @returns a promise that resolves to the material or texture with the requested LOD level
    */
-  static assignTextureLOD(e, t = 0) {
-    if (!e)
+  static assignTextureLOD(t, e = 0) {
+    if (!t)
       return Promise.resolve(null);
-    if (e instanceof Te || e.isMaterial === !0) {
-      const r = e, i = [], n = new Array();
-      if (m && he.add(r), r.uniforms && r.isRawShaderMaterial || r.isShaderMaterial === !0) {
+    if (t instanceof Ne || t.isMaterial === !0) {
+      const r = t, o = [], i = new Array();
+      if (L && ve.add(r), r.uniforms && r.isRawShaderMaterial || r.isShaderMaterial === !0) {
         const s = r;
-        for (const o of Object.keys(s.uniforms)) {
-          const a = s.uniforms[o].value;
-          if ((a == null ? void 0 : a.isTexture) === !0) {
-            const d = this.assignTextureLODForSlot(a, t, r, o);
-            i.push(d), n.push(o);
+        for (const n of Object.keys(s.uniforms)) {
+          const l = s.uniforms[n].value;
+          if ((l == null ? void 0 : l.isTexture) === !0) {
+            const u = this.assignTextureLODForSlot(l, e, r, n);
+            o.push(u), i.push(n);
           }
         }
       } else
         for (const s of Object.keys(r)) {
-          const o = r[s];
-          if ((o == null ? void 0 : o.isTexture) === !0) {
-            const a = this.assignTextureLODForSlot(o, t, r, s);
-            i.push(a), n.push(s);
+          const n = r[s];
+          if ((n == null ? void 0 : n.isTexture) === !0) {
+            const l = this.assignTextureLODForSlot(n, e, r, s);
+            o.push(l), i.push(s);
           }
         }
-      return Promise.all(i).then((s) => {
-        const o = new Array();
-        for (let a = 0; a < s.length; a++) {
-          const d = s[a], c = n[a];
-          d && d.isTexture === !0 ? o.push({ material: r, slot: c, texture: d, level: t }) : o.push({ material: r, slot: c, texture: null, level: t });
+      return Promise.all(o).then((s) => {
+        const n = new Array();
+        for (let l = 0; l < s.length; l++) {
+          const u = s[l], f = i[l];
+          u && u.isTexture === !0 ? n.push({ material: r, slot: f, texture: u, level: e }) : n.push({ material: r, slot: f, texture: null, level: e });
         }
-        return o;
+        return n;
       });
     }
-    if (e instanceof q || e.isTexture === !0) {
-      const r = e;
-      return this.assignTextureLODForSlot(r, t, null, null);
+    if (t instanceof ee || t.isTexture === !0) {
+      const r = t;
+      return this.assignTextureLODForSlot(r, e, null, null);
     }
     return Promise.resolve(null);
   }
-  static assignTextureLODForSlot(e, t, r, i) {
-    return (e == null ? void 0 : e.isTexture) !== !0 ? Promise.resolve(null) : i === "glyphMap" ? Promise.resolve(e) : v.getOrLoadLOD(e, t).then((n) => {
-      if (Array.isArray(n))
+  static assignTextureLODForSlot(t, e, r, o) {
+    return (t == null ? void 0 : t.isTexture) !== !0 ? Promise.resolve(null) : o === "glyphMap" ? Promise.resolve(t) : O.getOrLoadLOD(t, e).then((i) => {
+      if (Array.isArray(i))
         return null;
-      if ((n == null ? void 0 : n.isTexture) === !0) {
-        if (n != e) {
-          if (r && i) {
-            const s = r[i];
+      if ((i == null ? void 0 : i.isTexture) === !0) {
+        if (i != t) {
+          if (r && o) {
+            const s = r[o];
             if (s) {
-              const o = this.getAssignedLODInformation(s);
-              if (o && (o == null ? void 0 : o.level) < t)
-                return m === "verbose" && console.warn("Assigned texture level is already higher: ", o.level, t, r, s, n), null;
+              const n = this.getAssignedLODInformation(s);
+              if (n && (n == null ? void 0 : n.level) < e)
+                return L === "verbose" && console.warn("Assigned texture level is already higher: ", n.level, e, r, s, i), null;
             }
-            r[i] = n;
+            r[o] = i;
           }
-          if (m && i && r) {
-            const s = this.getAssignedLODInformation(e);
-            s && xe(r, i, s.url);
+          if (L && o && r) {
+            const s = this.getAssignedLODInformation(t);
+            s && Ae(r, o, s.url);
           }
         }
-        return n;
+        return i;
       } else
-        m == "verbose" && console.warn("No LOD found for", e, t);
+        L == "verbose" && console.warn("No LOD found for", t, e);
       return null;
-    }).catch((n) => (console.error("Error loading LOD", e, n), null));
+    }).catch((i) => (console.error("Error loading LOD", t, i), null));
   }
-  afterRoot(e) {
-    var t, r;
-    return m && console.log("AFTER", this.url, e), (t = this.parser.json.textures) == null || t.forEach((i, n) => {
+  afterRoot(t) {
+    var e, r;
+    return L && console.log("AFTER", this.url, t), (e = this.parser.json.textures) == null || e.forEach((o, i) => {
       var s;
-      if (i != null && i.extensions) {
-        const o = i == null ? void 0 : i.extensions[F];
-        if (o) {
-          if (!o.lods) {
-            m && console.warn("Texture has no LODs", o);
+      if (o != null && o.extensions) {
+        const n = o == null ? void 0 : o.extensions[N];
+        if (n) {
+          if (!n.lods) {
+            L && console.warn("Texture has no LODs", n);
             return;
           }
-          let a = !1;
-          for (const d of this.parser.associations.keys())
-            d.isTexture === !0 && this.parser.associations.get(d).textures === n && (a = !0, v.registerTexture(this.url, d, (s = o.lods) == null ? void 0 : s.length, n, o));
-          a || this.parser.getDependency("texture", n).then((d) => {
-            var c;
-            d && v.registerTexture(this.url, d, (c = o.lods) == null ? void 0 : c.length, n, o);
+          let l = !1;
+          for (const u of this.parser.associations.keys())
+            u.isTexture === !0 && this.parser.associations.get(u).textures === i && (l = !0, O.registerTexture(this.url, u, (s = n.lods) == null ? void 0 : s.length, i, n));
+          l || this.parser.getDependency("texture", i).then((u) => {
+            var f;
+            u && O.registerTexture(this.url, u, (f = n.lods) == null ? void 0 : f.length, i, n);
           });
         }
       }
-    }), (r = this.parser.json.meshes) == null || r.forEach((i, n) => {
-      if (i != null && i.extensions) {
-        const s = i == null ? void 0 : i.extensions[F];
+    }), (r = this.parser.json.meshes) == null || r.forEach((o, i) => {
+      if (o != null && o.extensions) {
+        const s = o == null ? void 0 : o.extensions[N];
         if (s && s.lods) {
-          for (const o of this.parser.associations.keys())
-            if (o.isMesh) {
-              const a = this.parser.associations.get(o);
-              a.meshes === n && v.registerMesh(this.url, s.guid, o, s.lods.length, a.primitives, s);
+          for (const n of this.parser.associations.keys())
+            if (n.isMesh) {
+              const l = this.parser.associations.get(n);
+              l.meshes === i && O.registerMesh(this.url, s.guid, n, s.lods.length, l.primitives, s);
             }
         }
       }
     }), null;
   }
-  static async getOrLoadLOD(e, t) {
-    var o, a, d, c;
-    const r = m == "verbose", i = e.userData.LODS;
-    if (!i)
+  static async getOrLoadLOD(t, e) {
+    var n, l, u, f;
+    const r = L == "verbose", o = t.userData.LODS;
+    if (!o)
       return null;
-    const n = i == null ? void 0 : i.key;
+    const i = o == null ? void 0 : o.key;
     let s;
-    if (e.isTexture === !0) {
-      const x = e;
-      x.source && x.source[ae] && (s = x.source[ae]);
+    if (t.isTexture === !0) {
+      const M = t;
+      M.source && M.source[xe] && (s = M.source[xe]);
     }
-    if (s || (s = v.lodInfos.get(n)), s) {
-      if (t > 0) {
+    if (s || (s = O.lodInfos.get(i)), s) {
+      if (e > 0) {
         let y = !1;
-        const w = Array.isArray(s.lods);
-        if (w && t >= s.lods.length ? y = !0 : w || (y = !0), y)
-          return this.lowresCache.get(n);
+        const v = Array.isArray(s.lods);
+        if (v && e >= s.lods.length ? y = !0 : v || (y = !0), y)
+          return this.lowresCache.get(i);
       }
-      const x = Array.isArray(s.lods) ? (o = s.lods[t]) == null ? void 0 : o.path : s.lods;
-      if (!x)
-        return m && !s["missing:uri"] && (s["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + t, s)), null;
-      const u = Ie(i.url, x);
-      if (u.endsWith(".glb") || u.endsWith(".gltf")) {
+      const M = Array.isArray(s.lods) ? (n = s.lods[e]) == null ? void 0 : n.path : s.lods;
+      if (!M)
+        return L && !s["missing:uri"] && (s["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, s)), null;
+      const c = Ze(o.url, M);
+      if (c.endsWith(".glb") || c.endsWith(".gltf")) {
         if (!s.guid)
           return console.warn("missing pointer for glb/gltf texture", s), null;
-        const y = u + "_" + s.guid, w = this.previouslyLoaded.get(y);
-        if (w !== void 0) {
-          r && console.log(`LOD ${t} was already loading/loaded: ${y}`);
-          let p = await w.catch((U) => (console.error(`Error loading LOD ${t} from ${u}
-`, U), null)), M = !1;
-          if (p == null || (p instanceof q && e instanceof q ? (a = p.image) != null && a.data || (d = p.source) != null && d.data ? p = this.copySettings(e, p) : (M = !0, this.previouslyLoaded.delete(y)) : p instanceof se && e instanceof se && ((c = p.attributes.position) != null && c.array || (M = !0, this.previouslyLoaded.delete(y)))), !M)
+        const y = c + "_" + s.guid, v = this.previouslyLoaded.get(y);
+        if (v !== void 0) {
+          r && console.log(`LOD ${e} was already loading/loaded: ${y}`);
+          let p = await v.catch((Y) => (console.error(`Error loading LOD ${e} from ${c}
+`, Y), null)), D = !1;
+          if (p == null || (p instanceof ee && t instanceof ee ? (l = p.image) != null && l.data || (u = p.source) != null && u.data ? p = this.copySettings(t, p) : (D = !0, this.previouslyLoaded.delete(y)) : p instanceof de && t instanceof de && ((f = p.attributes.position) != null && f.array || (D = !0, this.previouslyLoaded.delete(y)))), !D)
             return p;
         }
-        const L = s, B = new Promise(async (p, M) => {
-          const U = new Ee();
-          _e(U), m && (await new Promise((S) => setTimeout(S, 1e3)), r && console.warn("Start loading (delayed) " + u, L.guid));
-          let k = u;
-          if (L && Array.isArray(L.lods)) {
-            const S = L.lods[t];
-            S.hash && (k += "?v=" + S.hash);
+        const x = s, R = new Promise(async (p, D) => {
+          const Y = new Ye();
+          Ie(Y), L && (await new Promise((b) => setTimeout(b, 1e3)), r && console.warn("Start loading (delayed) " + c, x.guid));
+          let G = c;
+          if (x && Array.isArray(x.lods)) {
+            const b = x.lods[e];
+            b.hash && (G += "?v=" + b.hash);
           }
-          const _ = await U.loadAsync(k).catch((S) => (console.error(`Error loading LOD ${t} from ${u}
-`, S), null));
+          const _ = await Y.loadAsync(G).catch((b) => (console.error(`Error loading LOD ${e} from ${c}
+`, b), null));
           if (!_)
             return null;
-          const $ = _.parser;
-          r && console.log("Loading finished " + u, L.guid);
-          let R = 0;
+          const K = _.parser;
+          r && console.log("Loading finished " + c, x.guid);
+          let F = 0;
           if (_.parser.json.textures) {
-            let S = !1;
+            let b = !1;
             for (const g of _.parser.json.textures) {
               if (g != null && g.extensions) {
-                const h = g == null ? void 0 : g.extensions[F];
-                if (h != null && h.guid && h.guid === L.guid) {
-                  S = !0;
+                const h = g == null ? void 0 : g.extensions[N];
+                if (h != null && h.guid && h.guid === x.guid) {
+                  b = !0;
                   break;
                 }
               }
-              R++;
+              F++;
             }
-            if (S) {
-              let g = await $.getDependency("texture", R);
-              return g && v.assignLODInformation(i.url, g, n, t, void 0, void 0), r && console.log('change "' + e.name + '" → "' + g.name + '"', u, R, g, y), e instanceof q && (g = this.copySettings(e, g)), g && (g.guid = L.guid), p(g);
+            if (b) {
+              let g = await K.getDependency("texture", F);
+              return g && O.assignLODInformation(o.url, g, i, e, void 0, void 0), r && console.log('change "' + t.name + '" → "' + g.name + '"', c, F, g, y), t instanceof ee && (g = this.copySettings(t, g)), g && (g.guid = x.guid), p(g);
             } else
-              m && console.warn("Could not find texture with guid", L.guid, _.parser.json);
+              L && console.warn("Could not find texture with guid", x.guid, _.parser.json);
           }
-          if (R = 0, _.parser.json.meshes) {
-            let S = !1;
+          if (F = 0, _.parser.json.meshes) {
+            let b = !1;
             for (const g of _.parser.json.meshes) {
               if (g != null && g.extensions) {
-                const h = g == null ? void 0 : g.extensions[F];
-                if (h != null && h.guid && h.guid === L.guid) {
-                  S = !0;
+                const h = g == null ? void 0 : g.extensions[N];
+                if (h != null && h.guid && h.guid === x.guid) {
+                  b = !0;
                   break;
                 }
               }
-              R++;
+              F++;
             }
-            if (S) {
-              const g = await $.getDependency("mesh", R), h = L;
-              if (r && console.log(`Loaded Mesh "${g.name}"`, u, R, g, y), g.isMesh === !0) {
-                const D = g.geometry;
-                return v.assignLODInformation(i.url, D, n, t, void 0, h.density), p(D);
+            if (b) {
+              const g = await K.getDependency("mesh", F), h = x;
+              if (r && console.log(`Loaded Mesh "${g.name}"`, c, F, g, y), g.isMesh === !0) {
+                const w = g.geometry;
+                return O.assignLODInformation(o.url, w, i, e, void 0, h.density), p(w);
               } else {
-                const D = new Array();
-                for (let b = 0; b < g.children.length; b++) {
-                  const T = g.children[b];
-                  if (T.isMesh === !0) {
-                    const A = T.geometry;
-                    v.assignLODInformation(i.url, A, n, t, b, h.density), D.push(A);
+                const w = new Array();
+                for (let T = 0; T < g.children.length; T++) {
+                  const A = g.children[T];
+                  if (A.isMesh === !0) {
+                    const P = A.geometry;
+                    O.assignLODInformation(o.url, P, i, e, T, h.density), w.push(P);
                   }
                 }
-                return p(D);
+                return p(w);
               }
             } else
-              m && console.warn("Could not find mesh with guid", L.guid, _.parser.json);
+              L && console.warn("Could not find mesh with guid", x.guid, _.parser.json);
           }
           return p(null);
         });
-        return this.previouslyLoaded.set(y, B), await B;
-      } else if (e instanceof q) {
-        r && console.log("Load texture from uri: " + u);
-        const w = await new Ae().loadAsync(u);
-        return w ? (w.guid = s.guid, w.flipY = !1, w.needsUpdate = !0, w.colorSpace = e.colorSpace, r && console.log(s, w)) : m && console.warn("failed loading", u), w;
+        return this.previouslyLoaded.set(y, R), await R;
+      } else if (t instanceof ee) {
+        r && console.log("Load texture from uri: " + c);
+        const v = await new Ue().loadAsync(c);
+        return v ? (v.guid = s.guid, v.flipY = !1, v.needsUpdate = !0, v.colorSpace = t.colorSpace, r && console.log(s, v)) : L && console.warn("failed loading", c), v;
       }
     } else
-      m && console.warn(`Can not load LOD ${t}: no LOD info found for "${n}" ${e.name}`, e.type);
+      L && console.warn(`Can not load LOD ${e}: no LOD info found for "${i}" ${t.name}`, t.type);
     return null;
   }
-  static assignLODInformation(e, t, r, i, n, s) {
-    if (!t)
+  static assignLODInformation(t, e, r, o, i, s) {
+    if (!e)
       return;
-    t.userData || (t.userData = {});
-    const o = new ze(e, r, i, n, s);
-    t.userData.LODS = o;
+    e.userData || (e.userData = {});
+    const n = new rt(t, r, o, i, s);
+    e.userData.LODS = n;
   }
-  static getAssignedLODInformation(e) {
-    var t;
-    return ((t = e == null ? void 0 : e.userData) == null ? void 0 : t.LODS) || null;
+  static getAssignedLODInformation(t) {
+    var e;
+    return ((e = t == null ? void 0 : t.userData) == null ? void 0 : e.LODS) || null;
   }
   // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
-  static copySettings(e, t) {
-    return t = t.clone(), m && console.warn(`Copying texture settings
-`, e.uuid, `
-`, t.uuid), t.offset = e.offset, t.repeat = e.repeat, t.colorSpace = e.colorSpace, t.magFilter = e.magFilter, t.minFilter = e.minFilter, t.wrapS = e.wrapS, t.wrapT = e.wrapT, t.flipY = e.flipY, t.anisotropy = e.anisotropy, t.mipmaps || (t.generateMipmaps = e.generateMipmaps), t;
+  static copySettings(t, e) {
+    return e = e.clone(), L && console.warn(`Copying texture settings
+`, t.uuid, `
+`, e.uuid), 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;
   }
 };
-let O = v;
+let S = O;
 /**
  * Register a texture with LOD information
  */
-f(O, "registerTexture", (e, t, r, i, n) => {
-  if (m && console.log("> Progressive: register texture", i, t.name, t.uuid, t, n), !t) {
-    m && console.error("gltf-progressive: Register texture without texture");
+d(S, "registerTexture", (t, e, r, o, i) => {
+  if (L && console.log("> Progressive: register texture", o, e.name, e.uuid, e, i), !e) {
+    L && console.error("gltf-progressive: Register texture without texture");
     return;
   }
-  t.source && (t.source[ae] = n);
-  const s = n.guid;
-  v.assignLODInformation(e, t, s, r, i, void 0), v.lodInfos.set(s, n), v.lowresCache.set(s, t);
+  e.source && (e.source[xe] = i);
+  const s = i.guid;
+  O.assignLODInformation(t, e, s, r, o, void 0), O.lodInfos.set(s, i), O.lowresCache.set(s, e);
 }), /**
  * Register a mesh with LOD information
  */
-f(O, "registerMesh", (e, t, r, i, n, s) => {
-  var d;
-  m && console.log("> Progressive: register mesh", n, r.name, s, r.uuid, r);
-  const o = r.geometry;
-  if (!o) {
-    m && console.warn("gltf-progressive: Register mesh without geometry");
+d(S, "registerMesh", (t, e, r, o, i, s) => {
+  var u;
+  L && console.log("> Progressive: register mesh", i, r.name, s, r.uuid, r);
+  const n = r.geometry;
+  if (!n) {
+    L && console.warn("gltf-progressive: Register mesh without geometry");
     return;
   }
-  o.userData || (o.userData = {}), v.assignLODInformation(e, o, t, i, n, s.density), v.lodInfos.set(t, s);
-  let a = v.lowresCache.get(t);
-  a ? a.push(r.geometry) : a = [r.geometry], v.lowresCache.set(t, a), i > 0 && !pe(r) && Fe(r, o);
-  for (const c of z)
-    (d = c.onRegisteredNewMesh) == null || d.call(c, r, s);
+  n.userData || (n.userData = {}), O.assignLODInformation(t, n, e, o, i, s.density), O.lodInfos.set(e, s);
+  let l = O.lowresCache.get(e);
+  l ? l.push(r.geometry) : l = [r.geometry], O.lowresCache.set(e, l), o > 0 && !Oe(r) && et(r, n);
+  for (const f of X)
+    (u = f.onRegisteredNewMesh) == null || u.call(f, r, s);
 }), /** A map of key = asset uuid and value = LOD information */
-f(O, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
-f(O, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
-f(O, "lowresCache", /* @__PURE__ */ new Map());
-class ze {
-  constructor(e, t, r, i, n) {
-    f(this, "url");
+d(S, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
+d(S, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
+d(S, "lowresCache", /* @__PURE__ */ new Map());
+class rt {
+  constructor(t, e, r, o, i) {
+    d(this, "url");
     /** the key to lookup the LOD information */
-    f(this, "key");
-    f(this, "level");
+    d(this, "key");
+    d(this, "level");
     /** For multi objects (e.g. a group of meshes) this is the index of the object */
-    f(this, "index");
+    d(this, "index");
     /** the mesh density */
-    f(this, "density");
-    this.url = e, this.key = t, this.level = r, i != null && (this.index = i), n != null && (this.density = n);
+    d(this, "density");
+    this.url = t, this.key = e, this.level = r, o != null && (this.index = o), i != null && (this.density = i);
   }
 }
-const N = Z("debugprogressive"), Ue = Z("noprogressive"), le = Symbol("Needle:LODSManager"), ce = Symbol("Needle:LODState"), V = Symbol("Needle:CurrentLOD"), C = { mesh_lod: -1, texture_lod: -1 }, P = class {
+const B = ae("debugprogressive"), st = ae("noprogressive"), Le = Symbol("Needle:LODSManager"), Me = Symbol("Needle:LODState"), H = Symbol("Needle:CurrentLOD"), k = { mesh_lod: -1, texture_lod: -1 };
+var C, U, ge, Q, Z, pe, W;
+const E = class {
   // readonly plugins: NEEDLE_progressive_plugin[] = [];
-  constructor(e, t) {
-    f(this, "context");
-    f(this, "renderer");
-    f(this, "projectionScreenMatrix", new ye());
-    f(this, "cameraFrustrum", new Pe());
+  constructor(t, e) {
+    d(this, "context");
+    d(this, "renderer");
+    d(this, "projectionScreenMatrix", new be());
+    d(this, "cameraFrustrum", new We());
     /**
      * The target triangle density is the desired max amount of triangles on screen when the mesh is filling the screen.  
      * @default 200_000
      */
-    f(this, "targetTriangleDensity", 2e5);
+    d(this, "targetTriangleDensity", 2e5);
     /**
-     * The update interval in frames. If set to 0, the LODs will be updated every frame. If set to 1, the LODs will be updated every second frame, etc.
+     * 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.
      */
-    f(this, "updateInterval", 0);
+    d(this, "updateInterval", "auto");
+    q(this, C, 1);
     /**
      * If set to true, the LODsManager will not update the LODs.
      */
-    f(this, "pause", !1);
-    f(this, "_lodchangedlisteners", []);
-    f(this, "_frame", 0);
-    f(this, "_originalRender");
+    d(this, "pause", !1);
+    d(this, "_lodchangedlisteners", []);
+    q(this, U, void 0);
+    q(this, ge, new Ke());
+    q(this, Q, 0);
+    q(this, Z, 0);
+    q(this, pe, 0);
+    q(this, W, 0);
+    d(this, "_fpsBuffer", [60, 60, 60, 60, 60]);
     // private testIfLODLevelsAreAvailable() {
-    f(this, "_sphere", new Ce());
-    f(this, "_tempBox", new me());
-    f(this, "_tempBox2", new me());
-    f(this, "tempMatrix", new ye());
-    f(this, "_tempWorldPosition", new G());
-    f(this, "_tempBoxSize", new G());
-    f(this, "_tempBox2Size", new G());
-    this.renderer = e, this.context = { ...t };
+    d(this, "_sphere", new Xe());
+    d(this, "_tempBox", new Te());
+    d(this, "_tempBox2", new Te());
+    d(this, "tempMatrix", new be());
+    d(this, "_tempWorldPosition", new V());
+    d(this, "_tempBoxSize", new V());
+    d(this, "_tempBox2Size", new V());
+    this.renderer = t, this.context = { ...e };
   }
   /** @internal */
-  static getObjectLODState(e) {
-    return e[ce];
+  static getObjectLODState(t) {
+    return t[Me];
   }
-  static addPlugin(e) {
-    z.push(e);
+  static addPlugin(t) {
+    X.push(t);
   }
-  static removePlugin(e) {
-    const t = z.indexOf(e);
-    t >= 0 && z.splice(t, 1);
+  static removePlugin(t) {
+    const e = X.indexOf(t);
+    e >= 0 && X.splice(e, 1);
   }
   /**
    * Gets the LODsManager for the given renderer. If the LODsManager does not exist yet, it will be created.  
    * @param renderer The renderer to get the LODsManager for.
    * @returns The LODsManager instance.
    */
-  static get(e, t) {
-    if (e[le])
-      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), e[le];
-    const r = new P(e, {
+  static get(t, e) {
+    if (t[Le])
+      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[Le];
+    const r = new E(t, {
       engine: "unknown",
-      ...t
+      ...e
     });
-    return e[le] = r, r;
+    return t[Le] = r, r;
   }
   /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
   get plugins() {
-    return z;
+    return X;
   }
-  addEventListener(e, t) {
-    e === "changed" && this._lodchangedlisteners.push(t);
+  addEventListener(t, e) {
+    t === "changed" && this._lodchangedlisteners.push(e);
   }
   /**
    * Enable the LODsManager. This will replace the render method of the renderer with a method that updates the LODs.
    */
   enable() {
-    if (this._originalRender)
+    if (m(this, U))
       return;
     console.debug("[gltf-progressive] Enabling LODsManager for renderer");
-    let e = 0;
-    this._originalRender = this.renderer.render;
-    const t = this;
-    we(this.renderer), this.renderer.render = function(r, i) {
-      t.renderer.getRenderTarget() == null && (e = 0, t._frame += 1);
-      const s = t._frame, o = e++;
-      t.onBeforeRender(r, i, o, s), t._originalRender.call(this, r, i), t.onAfterRender(r, i, o, s);
+    let t = 0;
+    $(this, U, this.renderer.render);
+    const e = this;
+    ke(this.renderer), this.renderer.render = function(r, o) {
+      e.renderer.getRenderTarget() == null && (t = 0, $(e, Q, m(e, Q) + 1), $(e, Z, m(e, ge).getDelta()), $(e, pe, m(e, pe) + m(e, Z)), e._fpsBuffer.shift(), e._fpsBuffer.push(1 / m(e, Z)), $(e, W, e._fpsBuffer.reduce((l, u) => l + u) / e._fpsBuffer.length), B && m(e, Q) % 30 === 0 && console.log("FPS", Math.round(m(e, W)), "Interval:", m(e, C)));
+      const s = m(e, Q), n = t++;
+      e.onBeforeRender(r, o, n, s), m(e, U).call(this, r, o), e.onAfterRender(r, o, n, s);
     };
   }
   disable() {
-    this._originalRender && (this.renderer.render = this._originalRender, this._originalRender = void 0);
+    m(this, U) && (this.renderer.render = m(this, U), $(this, U, void 0));
   }
-  onBeforeRender(e, t, r, i) {
+  onBeforeRender(t, e, r, o) {
   }
-  onAfterRender(e, t, r, i) {
-    var a, d;
+  onAfterRender(t, e, r, o) {
+    var l, u;
     if (this.pause)
       return;
-    const n = this.renderer.renderLists.get(e, 0), s = n.opaque;
-    let o = !0;
+    const i = this.renderer.renderLists.get(t, 0), s = i.opaque;
+    let n = !0;
     if (s.length === 1) {
-      const c = s[0].material;
-      (c.name === "EffectMaterial" || c.name === "CopyShader") && (o = !1);
+      const f = s[0].material;
+      (f.name === "EffectMaterial" || f.name === "CopyShader") && (n = !1);
     }
-    if ((t.parent && t.parent.type === "CubeCamera" || r >= 1 && t.type === "OrthographicCamera") && (o = !1), o) {
-      if (Ue || this.updateInterval > 0 && i % this.updateInterval != 0)
+    if ((e.parent && e.parent.type === "CubeCamera" || r >= 1 && e.type === "OrthographicCamera") && (n = !1), n) {
+      if (st || (this.updateInterval === "auto" ? m(this, W) < 40 && m(this, C) < 10 ? ($(this, C, m(this, C) + 1), B && console.warn("↓ Reducing LOD updates", m(this, C), m(this, W).toFixed(0))) : m(this, W) >= 80 && m(this, C) > 1 && ($(this, C, m(this, C) - 1), B && console.warn("↑ Increasing LOD updates", m(this, C), m(this, W).toFixed(0))) : $(this, C, this.updateInterval), m(this, C) > 0 && o % m(this, C) != 0))
         return;
-      this.projectionScreenMatrix.multiplyMatrices(t.projectionMatrix, t.matrixWorldInverse), this.cameraFrustrum.setFromProjectionMatrix(this.projectionScreenMatrix, this.renderer.coordinateSystem);
-      const c = this.targetTriangleDensity;
-      for (const u of s) {
-        if (u.material && (((a = u.geometry) == null ? void 0 : a.type) === "BoxGeometry" || ((d = u.geometry) == null ? void 0 : d.type) === "BufferGeometry") && (u.material.name === "SphericalGaussianBlur" || u.material.name == "BackgroundCubeMaterial" || u.material.name === "CubemapFromEquirect" || u.material.name === "EquirectangularToCubeUV")) {
-          N && (u.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (u.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", u, u.material.name, u.material.type)));
+      this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse), this.cameraFrustrum.setFromProjectionMatrix(this.projectionScreenMatrix, this.renderer.coordinateSystem);
+      const f = this.targetTriangleDensity;
+      for (const c of s) {
+        if (c.material && (((l = c.geometry) == null ? void 0 : l.type) === "BoxGeometry" || ((u = c.geometry) == null ? void 0 : u.type) === "BufferGeometry") && (c.material.name === "SphericalGaussianBlur" || c.material.name == "BackgroundCubeMaterial" || c.material.name === "CubemapFromEquirect" || c.material.name === "EquirectangularToCubeUV")) {
+          B && (c.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (c.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", c, c.material.name, c.material.type)));
           continue;
         }
-        switch (u.material.type) {
+        switch (c.material.type) {
           case "LineBasicMaterial":
           case "LineDashedMaterial":
           case "PointsMaterial":
@@ -639,51 +655,56 @@ const N = Z("debugprogressive"), Ue = Z("noprogressive"), le = Symbol("Needle:LO
           case "MeshDepthMaterial":
             continue;
         }
-        const y = u.object;
-        (y instanceof W || y.isMesh) && this.updateLODs(e, t, y, c, i);
+        if (B === "color" && c.material && !c.object.progressive_debug_color) {
+          c.object.progressive_debug_color = !0;
+          const v = Math.random() * 16777215, x = new qe({ color: v });
+          c.object.material = x;
+        }
+        const y = c.object;
+        (y instanceof J || y.isMesh) && this.updateLODs(t, e, y, f, o);
       }
-      const x = n.transparent;
-      for (const u of x) {
-        const y = u.object;
-        (y instanceof W || y.isMesh) && this.updateLODs(e, t, y, c, i);
+      const M = i.transparent;
+      for (const c of M) {
+        const y = c.object;
+        (y instanceof J || y.isMesh) && this.updateLODs(t, e, y, f, o);
       }
     }
   }
   /** Update the LOD levels for the renderer. */
-  updateLODs(e, t, r, i, n) {
-    var a, d;
+  updateLODs(t, e, r, o, i) {
+    var l, u;
     r.userData || (r.userData = {});
-    let s = r[ce];
-    if (s || (s = new Ne(), r[ce] = s), s.frames++ < 2)
+    let s = r[Me];
+    if (s || (s = new it(), r[Me] = s), s.frames++ < 2)
       return;
-    for (const c of z)
-      (a = c.onBeforeUpdateLOD) == null || a.call(c, this.renderer, e, t, r);
-    this.calculateLodLevel(t, r, s, i, C), C.mesh_lod = Math.round(C.mesh_lod), C.texture_lod = Math.round(C.texture_lod), C.mesh_lod >= 0 && this.loadProgressiveMeshes(r, C.mesh_lod);
-    let o = C.texture_lod;
-    if (r.material && o >= 0) {
-      const c = r["DEBUG:LOD"];
-      c != null && (o = c), this.loadProgressiveTextures(r.material, o);
+    for (const f of X)
+      (l = f.onBeforeUpdateLOD) == null || l.call(f, this.renderer, t, e, r);
+    this.calculateLodLevel(e, r, s, o, k), k.mesh_lod = Math.round(k.mesh_lod), k.texture_lod = Math.round(k.texture_lod), k.mesh_lod >= 0 && this.loadProgressiveMeshes(r, k.mesh_lod);
+    let n = k.texture_lod;
+    if (r.material && n >= 0) {
+      const f = r["DEBUG:LOD"];
+      f != null && (n = f), this.loadProgressiveTextures(r.material, n);
     }
-    for (const c of z)
-      (d = c.onAfterUpdatedLOD) == null || d.call(c, this.renderer, e, t, r, C);
-    s.lastLodLevel_Mesh = C.mesh_lod, s.lastLodLevel_Texture = C.texture_lod;
+    for (const f of X)
+      (u = f.onAfterUpdatedLOD) == null || u.call(f, this.renderer, t, e, r, k);
+    s.lastLodLevel_Mesh = k.mesh_lod, s.lastLodLevel_Texture = k.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(e, t) {
-    if (!e)
+  loadProgressiveTextures(t, e) {
+    if (!t)
       return;
-    if (Array.isArray(e)) {
-      for (const i of e)
-        this.loadProgressiveTextures(i, t);
+    if (Array.isArray(t)) {
+      for (const o of t)
+        this.loadProgressiveTextures(o, e);
       return;
     }
     let r = !1;
-    (e[V] === void 0 || t < e[V]) && (r = !0), r && (e[V] = t, O.assignTextureLOD(e, t).then((i) => {
-      this._lodchangedlisteners.forEach((n) => n({ type: "texture", level: t, object: e }));
+    (t[H] === void 0 || e < t[H]) && (r = !0), r && (t[H] = e, S.assignTextureLOD(t, e).then((o) => {
+      this._lodchangedlisteners.forEach((i) => i({ type: "texture", level: e, object: t }));
     }));
   }
   /** Load progressive meshes for the given mesh
@@ -692,275 +713,293 @@ const N = Z("debugprogressive"), Ue = Z("noprogressive"), le = Symbol("Needle:LO
    * @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
    */
-  loadProgressiveMeshes(e, t) {
-    if (!e)
+  loadProgressiveMeshes(t, e) {
+    if (!t)
       return Promise.resolve(null);
-    if (e[V] !== t) {
-      e[V] = t;
-      const r = e.geometry;
-      return O.assignMeshLOD(e, t).then((i) => (i && e[V] == t && r != e.geometry && this._lodchangedlisteners.forEach((n) => n({ type: "mesh", level: t, object: e })), i));
+    if (t[H] !== e) {
+      t[H] = e;
+      const r = t.geometry;
+      return S.assignMeshLOD(t, e).then((o) => (o && t[H] == e && r != t.geometry && this._lodchangedlisteners.forEach((i) => i({ type: "mesh", level: e, object: t })), o));
     }
     return Promise.resolve(null);
   }
-  static isInside(e, t) {
-    const r = e.min, i = e.max, n = (r.x + i.x) * 0.5, s = (r.y + i.y) * 0.5;
-    return this._tempPtInside.set(n, s, r.z).applyMatrix4(t).z < 0;
+  static isInside(t, e) {
+    const r = t.min, o = t.max, i = (r.x + o.x) * 0.5, s = (r.y + o.y) * 0.5;
+    return this._tempPtInside.set(i, s, r.z).applyMatrix4(e).z < 0;
   }
-  calculateLodLevel(e, t, r, i, n) {
-    var B, I;
-    if (!t) {
-      n.mesh_lod = -1, n.texture_lod = -1;
-      return;
-    }
+  calculateLodLevel(t, e, r, o, i) {
+    var R, z;
     if (!e) {
-      n.mesh_lod = -1, n.texture_lod = -1;
+      i.mesh_lod = -1, i.texture_lod = -1;
       return;
     }
-    let o = 10 + 1, a = !1;
-    if (N && t["DEBUG:LOD"] != null)
-      return t["DEBUG:LOD"];
-    const d = O.getMeshLODInformation(t.geometry), c = d == null ? void 0 : d.lods, x = c && c.length > 0, u = O.getMaterialMinMaxLODsCount(t.material), y = (u == null ? void 0 : u.min_count) != 1 / 0 && u.min_count > 0 && u.max_count > 0;
-    if (!x && !y) {
-      n.mesh_lod = 0, n.texture_lod = 0;
+    if (!t) {
+      i.mesh_lod = -1, i.texture_lod = -1;
       return;
     }
-    if (x || (a = !0, o = 0), !((B = this.cameraFrustrum) != null && B.intersectsObject(t))) {
-      n.mesh_lod = 99, n.texture_lod = 99;
+    let n = 10 + 1, l = !1;
+    if (B && e["DEBUG:LOD"] != null)
+      return e["DEBUG:LOD"];
+    const u = S.getMeshLODInformation(e.geometry), f = u == null ? void 0 : u.lods, M = f && f.length > 0, c = S.getMaterialMinMaxLODsCount(e.material), y = (c == null ? void 0 : c.min_count) != 1 / 0 && c.min_count > 0 && c.max_count > 0;
+    if (!M && !y) {
+      i.mesh_lod = 0, i.texture_lod = 0;
       return;
     }
-    const w = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let L = t.geometry.boundingBox;
-    if (t.type === "SkinnedMesh") {
-      const p = t;
-      p.boundingBox || p.computeBoundingBox(), L = p.boundingBox;
+    if (M || (l = !0, n = 0), !((R = this.cameraFrustrum) != null && R.intersectsObject(e))) {
+      i.mesh_lod = 99, i.texture_lod = 99;
+      return;
     }
-    if (L && e.isPerspectiveCamera) {
+    const v = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let x = e.geometry.boundingBox;
+    if (e.type === "SkinnedMesh") {
       const p = e;
-      if (t.geometry.attributes.color && t.geometry.attributes.color.count < 100 && t.geometry.boundingSphere) {
-        this._sphere.copy(t.geometry.boundingSphere), this._sphere.applyMatrix4(t.matrixWorld);
-        const h = e.getWorldPosition(this._tempWorldPosition);
+      p.boundingBox || p.computeBoundingBox(), x = p.boundingBox;
+    }
+    if (x && t.isPerspectiveCamera) {
+      const p = 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 h = t.getWorldPosition(this._tempWorldPosition);
         if (this._sphere.containsPoint(h)) {
-          n.mesh_lod = 0, n.texture_lod = 0;
+          i.mesh_lod = 0, i.texture_lod = 0;
           return;
         }
       }
-      if (this._tempBox.copy(L), this._tempBox.applyMatrix4(t.matrixWorld), P.isInside(this._tempBox, this.projectionScreenMatrix)) {
-        n.mesh_lod = 0, n.texture_lod = 0;
+      if (this._tempBox.copy(x), this._tempBox.applyMatrix4(e.matrixWorld), E.isInside(this._tempBox, this.projectionScreenMatrix)) {
+        i.mesh_lod = 0, i.texture_lod = 0;
         return;
       }
       if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && p.fov > 70) {
-        const h = this._tempBox.min, D = this._tempBox.max;
-        let b = h.x, T = h.y, A = D.x, K = D.y;
-        const j = 2, ne = 1.5, ee = (h.x + D.x) * 0.5, te = (h.y + D.y) * 0.5;
-        b = (b - ee) * j + ee, T = (T - te) * j + te, A = (A - ee) * j + ee, K = (K - te) * j + te;
-        const ve = b < 0 && A > 0 ? 0 : Math.min(Math.abs(h.x), Math.abs(D.x)), Oe = T < 0 && K > 0 ? 0 : Math.min(Math.abs(h.y), Math.abs(D.y)), oe = Math.max(ve, Oe);
-        r.lastCentrality = (ne - oe) * (ne - oe) * (ne - oe);
+        const h = this._tempBox.min, w = this._tempBox.max;
+        let T = h.x, A = h.y, P = w.x, j = w.y;
+        const le = 2, ye = 1.5, ce = (h.x + w.x) * 0.5, ue = (h.y + w.y) * 0.5;
+        T = (T - ce) * le + ce, A = (A - ue) * le + ue, P = (P - ce) * le + ce, j = (j - ue) * le + ue;
+        const Fe = T < 0 && P > 0 ? 0 : Math.min(Math.abs(h.x), Math.abs(w.x)), $e = A < 0 && j > 0 ? 0 : Math.min(Math.abs(h.y), Math.abs(w.y)), me = Math.max(Fe, $e);
+        r.lastCentrality = (ye - me) * (ye - me) * (ye - me);
       } else
         r.lastCentrality = 1;
-      const M = this._tempBox.getSize(this._tempBoxSize);
-      M.multiplyScalar(0.5), screen.availHeight > 0 && w > 0 && M.multiplyScalar(w / screen.availHeight), M.x *= p.aspect;
-      const U = e.matrixWorldInverse, k = this._tempBox2;
-      k.copy(L), k.applyMatrix4(t.matrixWorld), k.applyMatrix4(U);
-      const _ = k.getSize(this._tempBox2Size), $ = Math.max(_.x, _.y);
-      if (Math.max(M.x, M.y) != 0 && $ != 0 && (M.z = _.z / Math.max(_.x, _.y) * Math.max(M.x, M.y)), r.lastScreenCoverage = Math.max(M.x, M.y, M.z), r.lastScreenspaceVolume.copy(M), r.lastScreenCoverage *= r.lastCentrality, N && P.debugDrawLine) {
+      const D = this._tempBox.getSize(this._tempBoxSize);
+      D.multiplyScalar(0.5), screen.availHeight > 0 && v > 0 && D.multiplyScalar(v / screen.availHeight), D.x *= p.aspect;
+      const Y = t.matrixWorldInverse, G = this._tempBox2;
+      G.copy(x), G.applyMatrix4(e.matrixWorld), G.applyMatrix4(Y);
+      const _ = G.getSize(this._tempBox2Size), K = Math.max(_.x, _.y);
+      if (Math.max(D.x, D.y) != 0 && K != 0 && (D.z = _.z / Math.max(_.x, _.y) * Math.max(D.x, D.y)), r.lastScreenCoverage = Math.max(D.x, D.y, D.z), r.lastScreenspaceVolume.copy(D), r.lastScreenCoverage *= r.lastCentrality, B && E.debugDrawLine) {
         const h = this.tempMatrix.copy(this.projectionScreenMatrix);
         h.invert();
-        const D = P.corner0, b = P.corner1, T = P.corner2, A = P.corner3;
-        D.copy(this._tempBox.min), b.copy(this._tempBox.max), b.x = D.x, T.copy(this._tempBox.max), T.y = D.y, A.copy(this._tempBox.max);
-        const K = (D.z + A.z) * 0.5;
-        D.z = b.z = T.z = A.z = K, D.applyMatrix4(h), b.applyMatrix4(h), T.applyMatrix4(h), A.applyMatrix4(h), P.debugDrawLine(D, b, 255), P.debugDrawLine(D, T, 255), P.debugDrawLine(b, A, 255), P.debugDrawLine(T, A, 255);
+        const w = E.corner0, T = E.corner1, A = E.corner2, P = E.corner3;
+        w.copy(this._tempBox.min), T.copy(this._tempBox.max), T.x = w.x, A.copy(this._tempBox.max), A.y = w.y, P.copy(this._tempBox.max);
+        const j = (w.z + P.z) * 0.5;
+        w.z = T.z = A.z = P.z = j, w.applyMatrix4(h), T.applyMatrix4(h), A.applyMatrix4(h), P.applyMatrix4(h), E.debugDrawLine(w, T, 255), E.debugDrawLine(w, A, 255), E.debugDrawLine(T, P, 255), E.debugDrawLine(A, P, 255);
       }
-      let S = 999;
-      if (c && r.lastScreenCoverage > 0) {
-        for (let h = 0; h < c.length; h++)
-          if (c[h].density / r.lastScreenCoverage < i) {
-            S = h;
+      let b = 999;
+      if (f && r.lastScreenCoverage > 0) {
+        for (let h = 0; h < f.length; h++)
+          if (f[h].density / r.lastScreenCoverage < o) {
+            b = h;
             break;
           }
       }
-      S < o && (o = S, a = !0);
+      b < n && (n = b, l = !0);
     }
-    if (a ? n.mesh_lod = o : n.mesh_lod = r.lastLodLevel_Mesh, N && n.mesh_lod != r.lastLodLevel_Mesh) {
-      const M = c == null ? void 0 : c[n.mesh_lod];
-      M && console.log(`Mesh LOD changed: ${r.lastLodLevel_Mesh} → ${n.mesh_lod} (${M.density.toFixed(0)}) - ${t.name}`);
+    if (l ? i.mesh_lod = n : i.mesh_lod = r.lastLodLevel_Mesh, B && i.mesh_lod != r.lastLodLevel_Mesh) {
+      const D = f == null ? void 0 : f[i.mesh_lod];
+      D && console.log(`Mesh LOD changed: ${r.lastLodLevel_Mesh} → ${i.mesh_lod} (${D.density.toFixed(0)}) - ${e.name}`);
     }
     if (y)
       if (r.lastLodLevel_Texture < 0) {
-        if (n.texture_lod = u.max_count - 1, N) {
-          const p = u.lods[u.max_count - 1];
-          N && console.log(`First Texture LOD ${n.texture_lod} (${p.max_height}px) - ${t.name}`);
+        if (i.texture_lod = c.max_count - 1, B) {
+          const p = c.lods[c.max_count - 1];
+          B && console.log(`First Texture LOD ${i.texture_lod} (${p.max_height}px) - ${e.name}`);
         }
       } else {
         const p = r.lastScreenspaceVolume.x + r.lastScreenspaceVolume.y + r.lastScreenspaceVolume.z;
-        let M = r.lastScreenCoverage * 2;
-        ((I = this.context) == null ? void 0 : I.engine) === "model-viewer" && (M *= 2);
-        const k = w / window.devicePixelRatio * M;
-        for (let _ = u.lods.length - 1; _ >= 0; _--) {
-          let $ = u.lods[_];
-          if (!(Ge() && $.max_height > 4096) && $.max_height > k) {
-            if (n.texture_lod = _, n.texture_lod < r.lastLodLevel_Texture) {
-              const R = $.max_height;
-              N && console.log(`Texture LOD changed: ${r.lastLodLevel_Texture} → ${n.texture_lod} = ${R}px 
-Screensize: ${k.toFixed(0)}px, Coverage: ${(100 * r.lastScreenCoverage).toFixed(2)}%, Volume ${p.toFixed(1)} 
-${t.name}`);
+        let D = r.lastScreenCoverage * 2;
+        ((z = this.context) == null ? void 0 : z.engine) === "model-viewer" && (D *= 2);
+        const G = v / window.devicePixelRatio * D;
+        for (let _ = c.lods.length - 1; _ >= 0; _--) {
+          let K = c.lods[_];
+          if (!(je() && K.max_height > 4096) && K.max_height > G) {
+            if (i.texture_lod = _, i.texture_lod < r.lastLodLevel_Texture) {
+              const F = K.max_height;
+              B && console.log(`Texture LOD changed: ${r.lastLodLevel_Texture} → ${i.texture_lod} = ${F}px 
+Screensize: ${G.toFixed(0)}px, Coverage: ${(100 * r.lastScreenCoverage).toFixed(2)}%, Volume ${p.toFixed(1)} 
+${e.name}`);
             }
             break;
           }
         }
       }
     else
-      n.texture_lod = 0;
+      i.texture_lod = 0;
   }
 };
-let E = P;
-/** 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.
+let I = E;
+C = new WeakMap(), U = new WeakMap(), ge = new WeakMap(), Q = new WeakMap(), Z = new WeakMap(), pe = new WeakMap(), W = 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.
  */
-f(E, "debugDrawLine"), f(E, "corner0", new G()), f(E, "corner1", new G()), f(E, "corner2", new G()), f(E, "corner3", new G()), f(E, "_tempPtInside", new G());
-class Ne {
+d(I, "debugDrawLine"), d(I, "corner0", new V()), d(I, "corner1", new V()), d(I, "corner2", new V()), d(I, "corner3", new V()), d(I, "_tempPtInside", new V());
+class it {
   constructor() {
-    f(this, "frames", 0);
-    f(this, "lastLodLevel_Mesh", -1);
-    f(this, "lastLodLevel_Texture", -1);
-    f(this, "lastScreenCoverage", 0);
-    f(this, "lastScreenspaceVolume", new G());
-    f(this, "lastCentrality", 0);
+    d(this, "frames", 0);
+    d(this, "lastLodLevel_Mesh", -1);
+    d(this, "lastLodLevel_Texture", -1);
+    d(this, "lastScreenCoverage", 0);
+    d(this, "lastScreenspaceVolume", new V());
+    d(this, "lastCentrality", 0);
   }
 }
-const Le = Symbol("NEEDLE_mesh_lod"), re = Symbol("NEEDLE_texture_lod");
-function Ve() {
-  document.removeEventListener("DOMContentLoaded", ue), document.addEventListener("DOMContentLoaded", ue), ue();
+const Pe = Symbol("NEEDLE_mesh_lod"), fe = Symbol("NEEDLE_texture_lod");
+let se = null;
+function Re() {
+  const a = ot();
+  a && (a.mapURLs(function(t) {
+    return Ee(), t;
+  }), Ee(), se == null || se.disconnect(), se = new MutationObserver((t) => {
+    t.forEach((e) => {
+      e.addedNodes.forEach((r) => {
+        r instanceof HTMLElement && r.tagName.toLowerCase() === "model-viewer" && Ge(r);
+      });
+    });
+  }), se.observe(document, { childList: !0, subtree: !0 }));
+}
+function ot() {
+  const a = customElements.get("model-viewer");
+  return a || (customElements.whenDefined("model-viewer").then(() => {
+    console.debug("[gltf-progressive] model-viewer defined"), Re();
+  }), null);
 }
-function ue() {
-  document.querySelectorAll("model-viewer").forEach((e, t) => {
-    We(e, t);
+function Ee() {
+  document.querySelectorAll("model-viewer").forEach((t) => {
+    Ge(t);
   });
 }
-const Me = /* @__PURE__ */ new WeakSet();
-function We(l, e) {
-  if (!l || Me.has(l))
+const Ce = /* @__PURE__ */ new WeakSet();
+let nt = 0;
+function Ge(a) {
+  if (!a || Ce.has(a))
     return null;
-  Me.add(l), console.debug("[gltf-progressive] found model-viewer..." + e);
-  let t = null, r = null, i = null;
-  for (let n = l; n != null; n = Object.getPrototypeOf(n)) {
-    const s = Object.getOwnPropertySymbols(n), o = s.find((c) => c.toString() == "Symbol(renderer)"), a = s.find((c) => c.toString() == "Symbol(scene)"), d = s.find((c) => c.toString() == "Symbol(needsRender)");
-    !t && o != null && (t = l[o].threeRenderer), !r && a != null && (r = l[a]), !i && d != null && (i = l[d]);
-  }
-  if (t && r) {
-    let n = function() {
-      if (i) {
-        let o = 0, a = setInterval(() => {
-          if (o++ > 5) {
-            clearInterval(a);
+  Ce.add(a), console.debug("[gltf-progressive] found new model-viewer..." + ++nt + `
+`, a.getAttribute("src"));
+  let t = null, e = null, r = null;
+  for (let o = a; o != null; o = Object.getPrototypeOf(o)) {
+    const i = Object.getOwnPropertySymbols(o), s = i.find((u) => u.toString() == "Symbol(renderer)"), n = i.find((u) => u.toString() == "Symbol(scene)"), l = i.find((u) => u.toString() == "Symbol(needsRender)");
+    !t && s != null && (t = a[s].threeRenderer), !e && n != null && (e = a[n]), !r && l != null && (r = a[l]);
+  }
+  if (t && e) {
+    let o = function() {
+      if (r) {
+        let s = 0, n = setInterval(() => {
+          if (s++ > 5) {
+            clearInterval(n);
             return;
           }
-          i == null || i.call(l);
+          r == null || r.call(a);
         }, 300);
       }
     };
     console.debug("[gltf-progressive] setup model-viewer");
-    const s = E.get(t, { engine: "model-viewer" });
-    return E.addPlugin(new Ke()), s.enable(), s.addEventListener("changed", () => {
-      i == null || i.call(l);
-    }), l.addEventListener("model-visibility", (o) => {
-      o.detail.visible && (i == null || i.call(l));
-    }), l.addEventListener("load", () => {
-      n();
+    const i = I.get(t, { engine: "model-viewer" });
+    return I.addPlugin(new at()), i.enable(), i.addEventListener("changed", () => {
+      r == null || r.call(a);
+    }), a.addEventListener("model-visibility", (s) => {
+      s.detail.visible && (r == null || r.call(a));
+    }), a.addEventListener("load", () => {
+      o();
     }), () => {
-      s.disable();
+      i.disable();
     };
   }
   return null;
 }
-class Ke {
+class at {
   constructor() {
-    f(this, "_didWarnAboutMissingUrl", !1);
+    d(this, "_didWarnAboutMissingUrl", !1);
   }
-  onBeforeUpdateLOD(e, t, r, i) {
-    this.tryParseMeshLOD(t, i), this.tryParseTextureLOD(t, i);
+  onBeforeUpdateLOD(t, e, r, o) {
+    this.tryParseMeshLOD(e, o), this.tryParseTextureLOD(e, o);
   }
-  getUrl(e) {
-    if (!e)
+  getUrl(t) {
+    if (!t)
       return null;
-    let t = e.getAttribute("src");
-    return t || (t = e.src), t || (this._didWarnAboutMissingUrl || console.warn("No url found in modelviewer", e), this._didWarnAboutMissingUrl = !0), t;
+    let e = t.getAttribute("src");
+    return e || (e = t.src), e || (this._didWarnAboutMissingUrl || console.warn("No url found in modelviewer", t), this._didWarnAboutMissingUrl = !0), e;
   }
-  tryGetCurrentGLTF(e) {
-    return e._currentGLTF;
+  tryGetCurrentGLTF(t) {
+    return t._currentGLTF;
   }
-  tryGetCurrentModelViewer(e) {
-    return e.element;
+  tryGetCurrentModelViewer(t) {
+    return t.element;
   }
-  tryParseTextureLOD(e, t) {
-    if (t[re] == !0)
+  tryParseTextureLOD(t, e) {
+    if (e[fe] == !0)
       return;
-    t[re] = !0;
-    const r = this.tryGetCurrentGLTF(e), i = this.tryGetCurrentModelViewer(e), n = this.getUrl(i);
-    if (n && r && t.material) {
-      let s = function(a) {
-        var c, x, u;
-        if (a[re] == !0)
+    e[fe] = !0;
+    const r = this.tryGetCurrentGLTF(t), o = this.tryGetCurrentModelViewer(t), i = this.getUrl(o);
+    if (i && r && e.material) {
+      let s = function(l) {
+        var f, M, c;
+        if (l[fe] == !0)
           return;
-        a[re] = !0, a.userData && (a.userData.LOD = -1);
-        const d = Object.keys(a);
-        for (let y = 0; y < d.length; y++) {
-          const w = d[y], L = a[w];
-          if ((L == null ? void 0 : L.isTexture) === !0) {
-            const B = (x = (c = L.userData) == null ? void 0 : c.associations) == null ? void 0 : x.textures;
-            if (B == null)
+        l[fe] = !0, l.userData && (l.userData.LOD = -1);
+        const u = Object.keys(l);
+        for (let y = 0; y < u.length; y++) {
+          const v = u[y], x = l[v];
+          if ((x == null ? void 0 : x.isTexture) === !0) {
+            const R = (M = (f = x.userData) == null ? void 0 : f.associations) == null ? void 0 : M.textures;
+            if (R == null)
               continue;
-            const I = r.parser.json.textures[B];
-            if (!I) {
-              console.warn("Texture data not found for texture index " + B);
+            const z = r.parser.json.textures[R];
+            if (!z) {
+              console.warn("Texture data not found for texture index " + R);
               continue;
             }
-            if ((u = I == null ? void 0 : I.extensions) != null && u[F]) {
-              const p = I.extensions[F];
-              p && n && O.registerTexture(n, L, p.lods.length, B, p);
+            if ((c = z == null ? void 0 : z.extensions) != null && c[N]) {
+              const p = z.extensions[N];
+              p && i && S.registerTexture(i, x, p.lods.length, R, p);
             }
           }
         }
       };
-      const o = t.material;
-      if (Array.isArray(o))
-        for (const a of o)
-          s(a);
+      const n = e.material;
+      if (Array.isArray(n))
+        for (const l of n)
+          s(l);
       else
-        s(o);
+        s(n);
     }
   }
-  tryParseMeshLOD(e, t) {
-    var s, o;
-    if (t[Le] == !0)
+  tryParseMeshLOD(t, e) {
+    var s, n;
+    if (e[Pe] == !0)
       return;
-    t[Le] = !0;
-    const r = this.tryGetCurrentModelViewer(e), i = this.getUrl(r);
-    if (!i)
+    e[Pe] = !0;
+    const r = this.tryGetCurrentModelViewer(t), o = this.getUrl(r);
+    if (!o)
       return;
-    const n = (o = (s = t.userData) == null ? void 0 : s.gltfExtensions) == null ? void 0 : o[F];
-    if (n && i) {
-      const a = t.uuid;
-      O.registerMesh(i, a, t, 0, n.lods.length, n);
+    const i = (n = (s = e.userData) == null ? void 0 : s.gltfExtensions) == null ? void 0 : n[N];
+    if (i && o) {
+      const l = e.uuid;
+      S.registerMesh(o, l, e, 0, i.lods.length, i);
     }
   }
 }
-Ve();
-function tt(l, e, t, r) {
-  we(e), _e(t), t.register((n) => new O(n, l));
-  const i = E.get(e);
-  return (r == null ? void 0 : r.enableLODsManager) !== !1 && i.enable(), i;
+function mt(a, t, e, r) {
+  ke(t), Ie(e), e.register((i) => new S(i, a));
+  const o = I.get(t);
+  return (r == null ? void 0 : r.enableLODsManager) !== !1 && o.enable(), o;
 }
+Re();
 export {
-  F as EXTENSION_NAME,
-  E as LODsManager,
-  O as NEEDLE_progressive,
-  De as VERSION,
-  _e as addDracoAndKTX2Loaders,
-  we as createLoaders,
-  pe as getRaycastMesh,
-  Ve as patchModelViewer,
-  Ze as setDracoDecoderLocation,
-  je as setKTX2TranscoderLocation,
-  Fe as setRaycastMesh,
-  tt as useNeedleProgressive,
-  et as useRaycastMeshes
+  N as EXTENSION_NAME,
+  I as LODsManager,
+  S as NEEDLE_progressive,
+  Be as VERSION,
+  Ie as addDracoAndKTX2Loaders,
+  ke as createLoaders,
+  Oe as getRaycastMesh,
+  Re as patchModelViewer,
+  gt as setDracoDecoderLocation,
+  pt as setKTX2TranscoderLocation,
+  et as setRaycastMesh,
+  mt as useNeedleProgressive,
+  yt as useRaycastMeshes
 };