@needle-tools/engine 4.7.2-alpha → 4.7.2-next.0e4e068

package/dist/gltf-progressive-CNdBjvz6.js

@@ -0,0 +1,1145 @@
+var He = Object.defineProperty;
+var Ee = (n) => {
+  throw TypeError(n);
+};
+var je = (n, t, e) => t in n ? He(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var d = (n, t, e) => je(n, typeof t != "symbol" ? t + "" : t, e), Ge = (n, t, e) => t.has(n) || Ee("Cannot " + e);
+var p = (n, t, e) => (Ge(n, t, "read from private field"), e ? e.call(n) : t.get(n)), j = (n, t, e) => t.has(n) ? Ee("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(n) : t.set(n, e), N = (n, t, e, s) => (Ge(n, t, "write to private field"), s ? s.call(n, e) : t.set(n, e), e);
+import { BufferGeometry as me, Mesh as te, Texture as oe, TextureLoader as Je, Matrix4 as Be, Clock as Qe, MeshStandardMaterial as Ze, Sphere as et, Box3 as Ie, Vector3 as q } from "./three-DrqIzZTH.js";
+import { DRACOLoader as tt, KTX2Loader as st, MeshoptDecoder as rt, GLTFLoader as Ce } from "./three-examples-B50TT3Iu.js";
+const it = "";
+globalThis.GLTF_PROGRESSIVE_VERSION = it;
+console.debug("[gltf-progressive] version -");
+let V = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", se = "https://www.gstatic.com/basis-universal/versioned/2021-04-15-ba1c3e4/";
+const ot = V, nt = se, Fe = new URL(V + "draco_decoder.js");
+Fe.searchParams.append("range", "true");
+fetch(Fe, {
+  method: "GET",
+  headers: {
+    Range: "bytes=0-1"
+  }
+}).catch((n) => {
+  console.debug(`Failed to fetch remote Draco decoder from ${V} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), V === ot && at("./include/draco/"), se === nt && lt("./include/ktx2/");
+}).finally(() => {
+  Ue();
+});
+function at(n) {
+  V = n, G && G[Te] != V ? (console.debug("Updating Draco decoder path to " + n), G[Te] = V, G.setDecoderPath(V), G.preload()) : console.debug("Setting Draco decoder path to " + n);
+}
+function lt(n) {
+  se = n, $ && $.transcoderPath != se ? (console.debug("Updating KTX2 transcoder path to " + n), $.setTranscoderPath(se), $.init()) : console.debug("Setting KTX2 transcoder path to " + n);
+}
+const Te = Symbol("dracoDecoderPath");
+let G, Le, $;
+function Ue() {
+  G || (G = new tt(), G[Te] = V, G.setDecoderPath(V), G.setDecoderConfig({ type: "js" }), G.preload()), $ || ($ = new st(), $.setTranscoderPath(se), $.init()), Le || (Le = rt);
+}
+function Ne(n) {
+  return Ue(), n ? $.detectSupport(n) : n !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: G, ktx2Loader: $, meshoptDecoder: Le };
+}
+function ze(n) {
+  n.dracoLoader || n.setDRACOLoader(G), n.ktx2Loader || n.setKTX2Loader($), n.meshoptDecoder || n.setMeshoptDecoder(Le);
+}
+const Pe = /* @__PURE__ */ new WeakMap();
+function Ve(n, t) {
+  let e = Pe.get(n);
+  e ? e = Object.assign(e, t) : e = t, Pe.set(n, e);
+}
+const Me = Ce.prototype.load;
+function dt(...n) {
+  const t = Pe.get(this);
+  let e = n[0];
+  const s = new URL(e, window.location.href);
+  if (s.hostname.endsWith("needle.tools")) {
+    const i = (t == null ? void 0 : t.progressive) !== void 0 ? t.progressive : !0, r = t != null && t.usecase ? t.usecase : "default";
+    i ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${r}` : this.requestHeader.Accept = `*/*;usecase=${r}`, e = s.toString();
+  }
+  return n[0] = e, Me == null ? void 0 : Me.call(this, ...n);
+}
+Ce.prototype.load = dt;
+de("debugprogressive");
+function de(n) {
+  if (typeof window > "u") return !1;
+  const e = new URL(window.location.href).searchParams.get(n);
+  return e == null || e === "0" || e === "false" ? !1 : e === "" ? !0 : e;
+}
+function ut(n, t) {
+  if (t === void 0 || t.startsWith("./") || t.startsWith("http") || n === void 0)
+    return t;
+  const e = n.lastIndexOf("/");
+  if (e >= 0) {
+    const s = n.substring(0, e + 1);
+    for (; s.endsWith("/") && t.startsWith("/"); ) t = t.substring(1);
+    return s + t;
+  }
+  return t;
+}
+let ne;
+function ct() {
+  return ne !== void 0 || (ne = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), de("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", ne)), ne;
+}
+function ft() {
+  if (typeof window > "u") return !1;
+  const n = new URL(window.location.href), t = n.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(n.hostname);
+  return n.hostname === "127.0.0.1" || t;
+}
+const ht = typeof window > "u" && typeof document > "u", Ae = Symbol("needle:raycast-mesh");
+function ue(n) {
+  return (n == null ? void 0 : n[Ae]) instanceof me ? n[Ae] : null;
+}
+function gt(n, t) {
+  if ((n.type === "Mesh" || n.type === "SkinnedMesh") && !ue(n)) {
+    const s = yt(t);
+    s.userData = { isRaycastMesh: !0 }, n[Ae] = s;
+  }
+}
+function pt(n = !0) {
+  if (n) {
+    if (ae) return;
+    const t = ae = te.prototype.raycast;
+    te.prototype.raycast = function(e, s) {
+      const o = this, i = ue(o);
+      let r;
+      i && o.isMesh && (r = o.geometry, o.geometry = i), t.call(this, e, s), r && (o.geometry = r);
+    };
+  } else {
+    if (!ae) return;
+    te.prototype.raycast = ae, ae = null;
+  }
+}
+let ae = null;
+function yt(n) {
+  const t = new me();
+  for (const e in n.attributes)
+    t.setAttribute(e, n.getAttribute(e));
+  return t.setIndex(n.getIndex()), t;
+}
+const Q = new Array(), w = de("debugprogressive");
+let pe, ee = -1;
+if (w) {
+  let n = function() {
+    ee += 1, ee >= t && (ee = -1), console.log(`Toggle LOD level [${ee}]`);
+  }, t = 6;
+  window.addEventListener("keyup", (e) => {
+    e.key === "p" && n(), e.key === "w" && (pe = !pe, console.log(`Toggle wireframe [${pe}]`));
+    const s = parseInt(e.key);
+    !isNaN(s) && s >= 0 && (ee = s, console.log(`Set LOD level to [${ee}]`));
+  });
+}
+function We(n) {
+  if (w)
+    if (Array.isArray(n))
+      for (const t of n)
+        We(t);
+    else n && "wireframe" in n && (n.wireframe = pe === !0);
+}
+const K = "NEEDLE_progressive", Oe = Symbol("needle-progressive-texture"), x = class x {
+  constructor(t, e) {
+    d(this, "parser");
+    d(this, "url");
+    d(this, "_isLoadingMesh");
+    d(this, "loadMesh", (t) => {
+      var s, o;
+      if (this._isLoadingMesh) return null;
+      const e = (o = (s = this.parser.json.meshes[t]) == null ? void 0 : s.extensions) == null ? void 0 : o[K];
+      return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((i) => {
+        var r;
+        return this._isLoadingMesh = !1, i && x.registerMesh(this.url, e.guid, i, (r = e.lods) == null ? void 0 : r.length, 0, e), i;
+      })) : null;
+    });
+    w && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
+  }
+  /** The name of the extension */
+  get name() {
+    return K;
+  }
+  static getMeshLODExtension(t) {
+    const e = this.getAssignedLODInformation(t);
+    return e != null && e.key ? this.lodInfos.get(e.key) : null;
+  }
+  static getPrimitiveIndex(t) {
+    var s;
+    const e = (s = this.getAssignedLODInformation(t)) == null ? void 0 : s.index;
+    return e ?? -1;
+  }
+  static getMaterialMinMaxLODsCount(t, e) {
+    const s = 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(t)) {
+      for (const a of t)
+        this.getMaterialMinMaxLODsCount(a, e);
+      return t[o] = e, e;
+    }
+    if (w === "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 && r(c, e);
+      }
+    } else if (t.isMaterial)
+      for (const a of Object.keys(t)) {
+        const l = t[a];
+        (l == null ? void 0 : l.isTexture) === !0 && r(l, e);
+      }
+    return t[o] = e, e;
+    function r(a, l) {
+      const c = s.getAssignedLODInformation(a);
+      if (c) {
+        const u = s.lodInfos.get(c.key);
+        if (u && u.lods) {
+          l.min_count = Math.min(l.min_count, u.lods.length), l.max_count = Math.max(l.max_count, u.lods.length);
+          for (let h = 0; h < u.lods.length; h++) {
+            const g = u.lods[h];
+            g.width && (l.lods[h] = l.lods[h] || { min_height: 1 / 0, max_height: 0 }, l.lods[h].min_height = Math.min(l.lods[h].min_height, g.height), l.lods[h].max_height = Math.max(l.lods[h].max_height, g.height));
+          }
+        }
+      }
+    }
+  }
+  /** Check if a LOD level is available for a mesh or a texture
+   * @param obj the mesh or texture to check
+   * @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(t, e) {
+    var i;
+    if (Array.isArray(t)) {
+      for (const r of t)
+        if (this.hasLODLevelAvailable(r, e)) return !0;
+      return !1;
+    }
+    if (t.isMaterial === !0) {
+      for (const r of Object.keys(t)) {
+        const a = t[r];
+        if (a && a.isTexture && this.hasLODLevelAvailable(a, e))
+          return !0;
+      }
+      return !1;
+    } else if (t.isGroup === !0) {
+      for (const r of t.children)
+        if (r.isMesh === !0 && this.hasLODLevelAvailable(r, e))
+          return !0;
+    }
+    let s, o;
+    if (t.isMesh ? s = t.geometry : (t.isBufferGeometry || t.isTexture) && (s = t), s && (i = s == null ? void 0 : s.userData) != null && i.LODS) {
+      const r = s.userData.LODS;
+      if (o = this.lodInfos.get(r.key), e === void 0) return o != null;
+      if (o)
+        return Array.isArray(o.lods) ? e < o.lods.length : e === 0;
+    }
+    return !1;
+  }
+  /** Load a different resolution of a mesh (if available)
+   * @param context the context
+   * @param source the sourceid of the file from which the mesh is loaded (this is usually the component's sourceId)
+   * @param mesh the mesh to load the LOD for
+   * @param level the level of detail to load (0 is the highest resolution)
+   * @returns a promise that resolves to the mesh with the requested LOD level
+   * @example
+   * ```javascript
+   * const mesh = this.gameObject as Mesh;
+   * NEEDLE_progressive.assignMeshLOD(context, sourceId, mesh, 1).then(mesh => {
+   *    console.log("Mesh with LOD level 1 loaded", mesh);
+   * });
+   * ```
+   */
+  static assignMeshLOD(t, e) {
+    var s;
+    if (!t) return Promise.resolve(null);
+    if (t instanceof te || t.isMesh === !0) {
+      const o = t.geometry, i = this.getAssignedLODInformation(o);
+      if (!i)
+        return Promise.resolve(null);
+      for (const r of Q)
+        (s = r.onBeforeGetLODMesh) == null || s.call(r, t, e);
+      return t["LOD:requested level"] = e, x.getOrLoadLOD(o, e).then((r) => {
+        if (Array.isArray(r)) {
+          const a = i.index || 0;
+          r = r[a];
+        }
+        return t["LOD:requested level"] === e && (delete t["LOD:requested level"], r && o != r && ((r == null ? void 0 : r.isBufferGeometry) ? t.geometry = r : w && console.error("Invalid LOD geometry", r))), r;
+      }).catch((r) => (console.error("Error loading mesh LOD", t, r), null));
+    } else w && 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.isMesh === !0) {
+      const s = t;
+      if (Array.isArray(s.material)) {
+        const o = new Array();
+        for (const i of s.material) {
+          const r = this.assignTextureLOD(i, e);
+          o.push(r);
+        }
+        return Promise.all(o).then((i) => {
+          const r = new Array();
+          for (const a of i)
+            Array.isArray(a) && r.push(...a);
+          return r;
+        });
+      } else
+        return this.assignTextureLOD(s.material, e);
+    }
+    if (t.isMaterial === !0) {
+      const s = t, o = [], i = new Array();
+      if (s.uniforms && (s.isRawShaderMaterial || s.isShaderMaterial === !0)) {
+        const r = s;
+        for (const a of Object.keys(r.uniforms)) {
+          const l = r.uniforms[a].value;
+          if ((l == null ? void 0 : l.isTexture) === !0) {
+            const c = this.assignTextureLODForSlot(l, e, s, a).then((u) => (u && r.uniforms[a].value != u && (r.uniforms[a].value = u, r.uniformsNeedUpdate = !0), u));
+            o.push(c), i.push(a);
+          }
+        }
+      } else
+        for (const r of Object.keys(s)) {
+          const a = s[r];
+          if ((a == null ? void 0 : a.isTexture) === !0) {
+            const l = this.assignTextureLODForSlot(a, e, s, r);
+            o.push(l), i.push(r);
+          }
+        }
+      return Promise.all(o).then((r) => {
+        const a = new Array();
+        for (let l = 0; l < r.length; l++) {
+          const c = r[l], u = i[l];
+          c && c.isTexture === !0 ? a.push({ material: s, slot: u, texture: c, level: e }) : a.push({ material: s, slot: u, texture: null, level: e });
+        }
+        return a;
+      });
+    }
+    if (t instanceof oe || t.isTexture === !0) {
+      const s = t;
+      return this.assignTextureLODForSlot(s, e, null, null);
+    }
+    return Promise.resolve(null);
+  }
+  static assignTextureLODForSlot(t, e, s, o) {
+    return (t == null ? void 0 : t.isTexture) !== !0 ? Promise.resolve(null) : o === "glyphMap" ? Promise.resolve(t) : x.getOrLoadLOD(t, e).then((i) => {
+      if (Array.isArray(i)) return null;
+      if ((i == null ? void 0 : i.isTexture) === !0) {
+        if (i != t && s && o) {
+          const r = s[o];
+          if (r && !w) {
+            const a = this.getAssignedLODInformation(r);
+            if (a && (a == null ? void 0 : a.level) < e)
+              return w === "verbose" && console.warn("Assigned texture level is already higher: ", a.level, e, s, r, i), null;
+          }
+          s[o] = i;
+        }
+        return i;
+      } else w == "verbose" && console.warn("No LOD found for", t, e);
+      return null;
+    }).catch((i) => (console.error("Error loading LOD", t, i), null));
+  }
+  afterRoot(t) {
+    var e, s;
+    return w && console.log("AFTER", this.url, t), (e = this.parser.json.textures) == null || e.forEach((o, i) => {
+      var r;
+      if (o != null && o.extensions) {
+        const a = o == null ? void 0 : o.extensions[K];
+        if (a) {
+          if (!a.lods) {
+            w && console.warn("Texture has no LODs", a);
+            return;
+          }
+          let l = !1;
+          for (const c of this.parser.associations.keys())
+            if (c.isTexture === !0) {
+              const u = this.parser.associations.get(c);
+              (u == null ? void 0 : u.textures) === i && (l = !0, x.registerTexture(this.url, c, (r = a.lods) == null ? void 0 : r.length, i, a));
+            }
+          l || this.parser.getDependency("texture", i).then((c) => {
+            var u;
+            c && x.registerTexture(this.url, c, (u = a.lods) == null ? void 0 : u.length, i, a);
+          });
+        }
+      }
+    }), (s = this.parser.json.meshes) == null || s.forEach((o, i) => {
+      if (o != null && o.extensions) {
+        const r = o == null ? void 0 : o.extensions[K];
+        if (r && r.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) === i && x.registerMesh(this.url, r.guid, a, r.lods.length, l.primitives, r);
+            }
+        }
+      }
+    }), null;
+  }
+  static async getOrLoadLOD(t, e) {
+    var a, l, c, u;
+    const s = w == "verbose", o = t.userData.LODS;
+    if (!o)
+      return null;
+    const i = o == null ? void 0 : o.key;
+    let r;
+    if (t.isTexture === !0) {
+      const h = t;
+      h.source && h.source[Oe] && (r = h.source[Oe]);
+    }
+    if (r || (r = x.lodInfos.get(i)), r) {
+      if (e > 0) {
+        let D = !1;
+        const b = Array.isArray(r.lods);
+        if (b && e >= r.lods.length ? D = !0 : b || (D = !0), D)
+          return this.lowresCache.get(i);
+      }
+      const h = Array.isArray(r.lods) ? (a = r.lods[e]) == null ? void 0 : a.path : r.lods;
+      if (!h)
+        return w && !r["missing:uri"] && (r["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, r)), null;
+      const g = ut(o.url, h);
+      if (g.endsWith(".glb") || g.endsWith(".gltf")) {
+        if (!r.guid)
+          return console.warn("missing pointer for glb/gltf texture", r), null;
+        const D = g + "_" + r.guid, b = this.previouslyLoaded.get(D);
+        if (b !== void 0) {
+          s && console.log(`LOD ${e} was already loading/loaded: ${D}`);
+          let _ = await b.catch((y) => (console.error(`Error loading LOD ${e} from ${g}
+`, y), null)), O = !1;
+          if (_ == null || (_ instanceof oe && t instanceof oe ? (l = _.image) != null && l.data || (c = _.source) != null && c.data ? _ = this.copySettings(t, _) : (O = !0, this.previouslyLoaded.delete(D)) : _ instanceof me && t instanceof me && ((u = _.attributes.position) != null && u.array || (O = !0, this.previouslyLoaded.delete(D)))), !O)
+            return _;
+        }
+        const v = r, F = new Promise(async (_, O) => {
+          const y = new Ce();
+          ze(y), w && (await new Promise((S) => setTimeout(S, 1e3)), s && console.warn("Start loading (delayed) " + g, v.guid));
+          let X = g;
+          if (v && Array.isArray(v.lods)) {
+            const S = v.lods[e];
+            S.hash && (X += "?v=" + S.hash);
+          }
+          const P = await y.loadAsync(X).catch((S) => (console.error(`Error loading LOD ${e} from ${g}
+`, S), null));
+          if (!P) return null;
+          const I = P.parser;
+          s && console.log("Loading finished " + g, v.guid);
+          let B = 0;
+          if (P.parser.json.textures) {
+            let S = !1;
+            for (const f of P.parser.json.textures) {
+              if (f != null && f.extensions) {
+                const T = f == null ? void 0 : f.extensions[K];
+                if (T != null && T.guid && T.guid === v.guid) {
+                  S = !0;
+                  break;
+                }
+              }
+              B++;
+            }
+            if (S) {
+              let f = await I.getDependency("texture", B);
+              return f && x.assignLODInformation(o.url, f, i, e, void 0), s && console.log('change "' + t.name + '" → "' + f.name + '"', g, B, f, D), t instanceof oe && (f = this.copySettings(t, f)), f && (f.guid = v.guid), _(f);
+            } else w && console.warn("Could not find texture with guid", v.guid, P.parser.json);
+          }
+          if (B = 0, P.parser.json.meshes) {
+            let S = !1;
+            for (const f of P.parser.json.meshes) {
+              if (f != null && f.extensions) {
+                const T = f == null ? void 0 : f.extensions[K];
+                if (T != null && T.guid && T.guid === v.guid) {
+                  S = !0;
+                  break;
+                }
+              }
+              B++;
+            }
+            if (S) {
+              const f = await I.getDependency("mesh", B);
+              if (s && console.log(`Loaded Mesh "${f.name}"`, g, B, f, D), f.isMesh === !0) {
+                const T = f.geometry;
+                return x.assignLODInformation(o.url, T, i, e, 0), _(T);
+              } else {
+                const T = new Array();
+                for (let L = 0; L < f.children.length; L++) {
+                  const M = f.children[L];
+                  if (M.isMesh === !0) {
+                    const A = M.geometry;
+                    x.assignLODInformation(o.url, A, i, e, L), T.push(A);
+                  }
+                }
+                return _(T);
+              }
+            } else w && console.warn("Could not find mesh with guid", v.guid, P.parser.json);
+          }
+          return _(null);
+        });
+        return this.previouslyLoaded.set(D, F), await F;
+      } else if (t instanceof oe) {
+        s && console.log("Load texture from uri: " + g);
+        const b = await new Je().loadAsync(g);
+        return b ? (b.guid = r.guid, b.flipY = !1, b.needsUpdate = !0, b.colorSpace = t.colorSpace, s && console.log(r, b)) : w && console.warn("failed loading", g), b;
+      }
+    } else
+      w && console.warn(`Can not load LOD ${e}: no LOD info found for "${i}" ${t.name}`, t.type);
+    return null;
+  }
+  static assignLODInformation(t, e, s, o, i) {
+    if (!e) return;
+    e.userData || (e.userData = {});
+    const r = new mt(t, s, o, i);
+    e.userData.LODS = r;
+  }
+  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(t, e) {
+    return e ? (w && console.warn(`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;
+  }
+};
+/**
+ * Register a texture with LOD information
+ */
+d(x, "registerTexture", (t, e, s, o, i) => {
+  if (w && console.log("> Progressive: register texture", o, e.name, e.uuid, e, i), !e) {
+    w && console.error("gltf-progressive: Register texture without texture");
+    return;
+  }
+  e.source && (e.source[Oe] = i);
+  const r = i.guid;
+  x.assignLODInformation(t, e, r, s, o), x.lodInfos.set(r, i), x.lowresCache.set(r, e);
+}), /**
+ * Register a mesh with LOD information
+ */
+d(x, "registerMesh", (t, e, s, o, i, r) => {
+  var c;
+  const a = s.geometry;
+  if (!a) {
+    w && console.warn("gltf-progressive: Register mesh without geometry");
+    return;
+  }
+  a.userData || (a.userData = {}), w && console.log("> Progressive: register mesh " + s.name, { index: i, uuid: s.uuid }, r, s), x.assignLODInformation(t, a, e, o, i), x.lodInfos.set(e, r);
+  let l = x.lowresCache.get(e);
+  l ? l.push(s.geometry) : l = [s.geometry], x.lowresCache.set(e, l), o > 0 && !ue(s) && gt(s, a);
+  for (const u of Q)
+    (c = u.onRegisteredNewMesh) == null || c.call(u, s, r);
+}), /** A map of key = asset uuid and value = LOD information */
+d(x, "lodInfos", /* @__PURE__ */ new Map()), /** cache of already loaded mesh lods */
+d(x, "previouslyLoaded", /* @__PURE__ */ new Map()), /** this contains the geometry/textures that were originally loaded */
+d(x, "lowresCache", /* @__PURE__ */ new Map());
+let z = x;
+class mt {
+  constructor(t, e, s, o) {
+    d(this, "url");
+    /** the key to lookup the LOD information */
+    d(this, "key");
+    d(this, "level");
+    /** For multi objects (e.g. a group of meshes) this is the index of the object */
+    d(this, "index");
+    this.url = t, this.key = e, this.level = s, o != null && (this.index = o);
+  }
+}
+class ye {
+  constructor(t, e) {
+    d(this, "frame_start");
+    d(this, "frame_capture_end");
+    d(this, "ready");
+    d(this, "_resolve");
+    d(this, "_signal");
+    d(this, "_resolved", !1);
+    d(this, "_addedCount", 0);
+    d(this, "_resolvedCount", 0);
+    /** These promises are currently being awaited */
+    d(this, "_awaiting", []);
+    d(this, "_currentFrame", 0);
+    var i;
+    const s = t === 0 ? 2 : 1, o = Math.max(e.frames ?? s, s);
+    this.frame_start = t, this.frame_capture_end = t + o, this.ready = new Promise((r) => {
+      this._resolve = r;
+    }), this.ready.finally(() => {
+      this._resolved = !0, this._awaiting.length = 0;
+    }), this._signal = e.signal, (i = this._signal) == null || i.addEventListener("abort", () => {
+      this.resolveNow();
+    });
+  }
+  /**
+   * The number of promises that have been added to this group so far.
+   */
+  get awaitedCount() {
+    return this._addedCount;
+  }
+  get resolvedCount() {
+    return this._resolvedCount;
+  }
+  get currentlyAwaiting() {
+    return this._awaiting.length;
+  }
+  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();
+  }
+  add(t, e) {
+    if (this._resolved) {
+      console.warn("PromiseGroup: Trying to add a promise to a resolved group, ignoring.");
+      return;
+    }
+    this._currentFrame > this.frame_capture_end || (this._awaiting.push(e), this._addedCount++, e.finally(() => {
+      this._resolvedCount++, this._awaiting.splice(this._awaiting.indexOf(e), 1);
+    }));
+  }
+  resolveNow() {
+    var t, e;
+    this._resolved || (e = this._resolve) == null || e.call(this, {
+      awaited_count: this._addedCount,
+      resolved_count: this._resolvedCount,
+      cancelled: ((t = this._signal) == null ? void 0 : t.aborted) ?? !1
+    });
+  }
+}
+d(ye, "addPromise", (t, e, s) => {
+  s.forEach((o) => {
+    o.add(t, e);
+  });
+});
+const k = de("debugprogressive"), Lt = de("noprogressive"), be = Symbol("Needle:LODSManager"), Se = Symbol("Needle:LODState"), J = Symbol("Needle:CurrentLOD"), C = { mesh_lod: -1, texture_lod: -1 };
+var m, E, Y, we, Z, re, ve, H;
+let xe = (m = class {
+  // readonly plugins: NEEDLE_progressive_plugin[] = [];
+  constructor(t, e) {
+    d(this, "renderer");
+    d(this, "context");
+    d(this, "projectionScreenMatrix", new Be());
+    /**
+     * The target triangle density is the desired max amount of triangles on screen when the mesh is filling the screen.  
+     * @default 200_000
+     */
+    d(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
+     */
+    d(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"
+     */
+    d(this, "updateInterval", "auto");
+    j(this, E, 1);
+    /**
+     * If set to true, the LODsManager will not update the LODs.
+     * @default false
+     */
+    d(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
+     */
+    d(this, "manual", !1);
+    d(this, "_newPromiseGroups", []);
+    d(this, "_promiseGroupIds", 0);
+    d(this, "_lodchangedlisteners", []);
+    j(this, Y);
+    j(this, we, new Qe());
+    j(this, Z, 0);
+    j(this, re, 0);
+    j(this, ve, 0);
+    j(this, H, 0);
+    d(this, "_fpsBuffer", [60, 60, 60, 60, 60]);
+    // private testIfLODLevelsAreAvailable() {
+    d(this, "_sphere", new et());
+    d(this, "_tempBox", new Ie());
+    d(this, "_tempBox2", new Ie());
+    d(this, "tempMatrix", new Be());
+    d(this, "_tempWorldPosition", new q());
+    d(this, "_tempBoxSize", new q());
+    d(this, "_tempBox2Size", new q());
+    this.renderer = t, this.context = { ...e };
+  }
+  /** @internal */
+  static getObjectLODState(t) {
+    return t[Se];
+  }
+  static addPlugin(t) {
+    Q.push(t);
+  }
+  static removePlugin(t) {
+    const e = Q.indexOf(t);
+    e >= 0 && Q.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(t, e) {
+    if (t[be])
+      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[be];
+    const s = new m(t, {
+      engine: "unknown",
+      ...e
+    });
+    return t[be] = s, s;
+  }
+  /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
+  get plugins() {
+    return Q;
+  }
+  /**
+   * Call to await LODs loading during the next render cycle.
+   */
+  awaitLoading(t) {
+    const e = this._promiseGroupIds++, s = new ye(p(this, Z), { ...t });
+    this._newPromiseGroups.push(s);
+    const o = performance.now();
+    return s.ready.finally(() => {
+      const i = this._newPromiseGroups.indexOf(s);
+      i >= 0 && (this._newPromiseGroups.splice(i, 1), ft() && performance.measure("LODsManager:awaitLoading", {
+        start: o,
+        detail: { id: e, name: t == null ? void 0 : 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(p(this, Z));
+  }
+  addEventListener(t, e) {
+    t === "changed" && this._lodchangedlisteners.push(e);
+  }
+  removeEventListener(t, e) {
+    if (t === "changed") {
+      const s = this._lodchangedlisteners.indexOf(e);
+      s >= 0 && this._lodchangedlisteners.splice(s, 1);
+    }
+  }
+  /**
+   * Enable the LODsManager. This will replace the render method of the renderer with a method that updates the LODs.
+   */
+  enable() {
+    if (p(this, Y)) return;
+    console.debug("[gltf-progressive] Enabling LODsManager for renderer");
+    let t = 0;
+    N(this, Y, this.renderer.render);
+    const e = this;
+    Ne(this.renderer), this.renderer.render = function(s, o) {
+      const i = e.renderer.getRenderTarget();
+      (i == null || "isXRRenderTarget" in i && i.isXRRenderTarget) && (t = 0, N(e, Z, p(e, Z) + 1), N(e, re, p(e, we).getDelta()), N(e, ve, p(e, ve) + p(e, re)), e._fpsBuffer.shift(), e._fpsBuffer.push(1 / p(e, re)), N(e, H, e._fpsBuffer.reduce((a, l) => a + l) / e._fpsBuffer.length), k && p(e, Z) % 200 === 0 && console.log("FPS", Math.round(p(e, H)), "Interval:", p(e, E)));
+      const r = t++;
+      p(e, Y).call(this, s, o), e.onAfterRender(s, o, r);
+    };
+  }
+  disable() {
+    p(this, Y) && (console.debug("[gltf-progressive] Disabling LODsManager for renderer"), this.renderer.render = p(this, Y), N(this, Y, void 0));
+  }
+  update(t, e) {
+    this.internalUpdate(t, e);
+  }
+  onAfterRender(t, e, s) {
+    if (this.pause) return;
+    const i = this.renderer.renderLists.get(t, 0).opaque;
+    let r = !0;
+    if (i.length === 1) {
+      const a = i[0].material;
+      (a.name === "EffectMaterial" || a.name === "CopyShader") && (r = !1);
+    }
+    if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (r = !1), r) {
+      if (Lt || (this.updateInterval === "auto" ? p(this, H) < 40 && p(this, E) < 10 ? (N(this, E, p(this, E) + 1), k && console.warn("↓ Reducing LOD updates", p(this, E), p(this, H).toFixed(0))) : p(this, H) >= 60 && p(this, E) > 1 && (N(this, E, p(this, E) - 1), k && console.warn("↑ Increasing LOD updates", p(this, E), p(this, H).toFixed(0))) : N(this, E, this.updateInterval), p(this, E) > 0 && p(this, Z) % p(this, E) != 0))
+        return;
+      this.internalUpdate(t, e), this._postprocessPromiseGroups();
+    }
+  }
+  /**
+   * Update LODs in a scene
+   */
+  internalUpdate(t, e) {
+    var l, c;
+    const s = this.renderer.renderLists.get(t, 0), o = s.opaque;
+    this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse);
+    const i = this.targetTriangleDensity;
+    for (const u of o) {
+      if (u.material && (((l = u.geometry) == null ? void 0 : l.type) === "BoxGeometry" || ((c = u.geometry) == null ? void 0 : c.type) === "BufferGeometry") && (u.material.name === "SphericalGaussianBlur" || u.material.name == "BackgroundCubeMaterial" || u.material.name === "CubemapFromEquirect" || u.material.name === "EquirectangularToCubeUV")) {
+        k && (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)));
+        continue;
+      }
+      switch (u.material.type) {
+        case "LineBasicMaterial":
+        case "LineDashedMaterial":
+        case "PointsMaterial":
+        case "ShadowMaterial":
+        case "MeshDistanceMaterial":
+        case "MeshDepthMaterial":
+          continue;
+      }
+      if (k === "color" && u.material && !u.object.progressive_debug_color) {
+        u.object.progressive_debug_color = !0;
+        const g = Math.random() * 16777215, D = new Ze({ color: g });
+        u.object.material = D;
+      }
+      const h = u.object;
+      (h instanceof te || h.isMesh) && this.updateLODs(t, e, h, i);
+    }
+    const r = s.transparent;
+    for (const u of r) {
+      const h = u.object;
+      (h instanceof te || h.isMesh) && this.updateLODs(t, e, h, i);
+    }
+    const a = s.transmissive;
+    for (const u of a) {
+      const h = u.object;
+      (h instanceof te || h.isMesh) && this.updateLODs(t, e, h, i);
+    }
+  }
+  /** Update the LOD levels for the renderer. */
+  updateLODs(t, e, s, o) {
+    var a, l;
+    s.userData || (s.userData = {});
+    let i = s[Se];
+    if (i || (i = new xt(), s[Se] = i), i.frames++ < 2)
+      return;
+    for (const c of Q)
+      (a = c.onBeforeUpdateLOD) == null || a.call(c, this.renderer, t, e, s);
+    const r = m.overrideGlobalLodLevel !== void 0 ? m.overrideGlobalLodLevel : ee;
+    r >= 0 ? (C.mesh_lod = r, C.texture_lod = r) : (this.calculateLodLevel(e, s, i, o, C), C.mesh_lod = Math.round(C.mesh_lod), C.texture_lod = Math.round(C.texture_lod)), C.mesh_lod >= 0 && this.loadProgressiveMeshes(s, C.mesh_lod), s.material && C.texture_lod >= 0 && this.loadProgressiveTextures(s.material, C.texture_lod), w && s.material && !s.isGizmo && We(s.material);
+    for (const c of Q)
+      (l = c.onAfterUpdatedLOD) == null || l.call(c, this.renderer, t, e, s, C);
+    i.lastLodLevel_Mesh = C.mesh_lod, i.lastLodLevel_Texture = C.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;
+    if (Array.isArray(t)) {
+      for (const i of t)
+        this.loadProgressiveTextures(i, e);
+      return;
+    }
+    let s = !1;
+    (t[J] === void 0 || e < t[J]) && (s = !0);
+    const o = t["DEBUG:LOD"];
+    if (o != null && (s = t[J] != o, e = o), s) {
+      t[J] = e;
+      const i = z.assignTextureLOD(t, e).then((r) => {
+        this._lodchangedlisteners.forEach((a) => a({ type: "texture", level: e, object: t }));
+      });
+      ye.addPromise("texture", i, this._newPromiseGroups);
+    }
+  }
+  /** Load progressive meshes for the given mesh
+   * @param mesh the mesh to load the LOD for
+   * @param index the index of the mesh if it's part of a group
+   * @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(t, e) {
+    if (!t) return Promise.resolve(null);
+    let s = t[J] !== e;
+    const o = t["DEBUG:LOD"];
+    if (o != null && (s = t[J] != o, e = o), s) {
+      t[J] = e;
+      const i = t.geometry, r = z.assignMeshLOD(t, e).then((a) => (a && t[J] == e && i != t.geometry && this._lodchangedlisteners.forEach((l) => l({ type: "mesh", level: e, object: t })), a));
+      return ye.addPromise("mesh", r, this._newPromiseGroups), r;
+    }
+    return Promise.resolve(null);
+  }
+  static isInside(t, e) {
+    const s = t.min, o = t.max, i = (s.x + o.x) * 0.5, r = (s.y + o.y) * 0.5;
+    return this._tempPtInside.set(i, r, s.z).applyMatrix4(e).z < 0;
+  }
+  calculateLodLevel(t, e, s, o, i) {
+    var F, W, _;
+    if (!e) {
+      i.mesh_lod = -1, i.texture_lod = -1;
+      return;
+    }
+    if (!t) {
+      i.mesh_lod = -1, i.texture_lod = -1;
+      return;
+    }
+    let a = 10 + 1, l = !1;
+    if (k && e["DEBUG:LOD"] != null)
+      return e["DEBUG:LOD"];
+    const c = (F = z.getMeshLODExtension(e.geometry)) == null ? void 0 : F.lods, u = z.getPrimitiveIndex(e.geometry), h = c && c.length > 0, g = z.getMaterialMinMaxLODsCount(e.material), D = (g == null ? void 0 : g.min_count) != 1 / 0 && g.min_count > 0 && g.max_count > 0;
+    if (!h && !D) {
+      i.mesh_lod = 0, i.texture_lod = 0;
+      return;
+    }
+    h || (l = !0, a = 0);
+    const b = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let v = e.geometry.boundingBox;
+    if (e.type === "SkinnedMesh") {
+      const O = e;
+      if (!O.boundingBox)
+        O.computeBoundingBox();
+      else if (this.skinnedMeshAutoUpdateBoundsInterval > 0 && s.frames % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
+        const y = ue(O), X = O.geometry;
+        y && (O.geometry = y), O.computeBoundingBox(), O.geometry = X;
+      }
+      v = O.boundingBox;
+    }
+    if (v) {
+      const O = 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 L = t.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(L)) {
+          i.mesh_lod = 0, i.texture_lod = 0;
+          return;
+        }
+      }
+      if (this._tempBox.copy(v), this._tempBox.applyMatrix4(e.matrixWorld), O.isPerspectiveCamera && m.isInside(this._tempBox, this.projectionScreenMatrix)) {
+        i.mesh_lod = 0, i.texture_lod = 0;
+        return;
+      }
+      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && O.isPerspectiveCamera && O.fov > 70) {
+        const L = this._tempBox.min, M = this._tempBox.max;
+        let A = L.x, R = L.y, U = M.x, ie = M.y;
+        const ce = 2, De = 1.5, fe = (L.x + M.x) * 0.5, he = (L.y + M.y) * 0.5;
+        A = (A - fe) * ce + fe, R = (R - he) * ce + he, U = (U - fe) * ce + fe, ie = (ie - he) * ce + he;
+        const Ke = A < 0 && U > 0 ? 0 : Math.min(Math.abs(L.x), Math.abs(M.x)), Ye = R < 0 && ie > 0 ? 0 : Math.min(Math.abs(L.y), Math.abs(M.y)), _e = Math.max(Ke, Ye);
+        s.lastCentrality = (De - _e) * (De - _e) * (De - _e);
+      } else
+        s.lastCentrality = 1;
+      const y = this._tempBox.getSize(this._tempBoxSize);
+      y.multiplyScalar(0.5), screen.availHeight > 0 && b > 0 && y.multiplyScalar(b / screen.availHeight), t.isPerspectiveCamera ? y.x *= t.aspect : t.isOrthographicCamera;
+      const X = t.matrixWorldInverse, P = this._tempBox2;
+      P.copy(v), P.applyMatrix4(e.matrixWorld), P.applyMatrix4(X);
+      const I = P.getSize(this._tempBox2Size), B = Math.max(I.x, I.y);
+      if (Math.max(y.x, y.y) != 0 && B != 0 && (y.z = I.z / Math.max(I.x, I.y) * Math.max(y.x, y.y)), s.lastScreenCoverage = Math.max(y.x, y.y, y.z), s.lastScreenspaceVolume.copy(y), s.lastScreenCoverage *= s.lastCentrality, k && m.debugDrawLine) {
+        const L = this.tempMatrix.copy(this.projectionScreenMatrix);
+        L.invert();
+        const M = m.corner0, A = m.corner1, R = m.corner2, U = m.corner3;
+        M.copy(this._tempBox.min), A.copy(this._tempBox.max), A.x = M.x, R.copy(this._tempBox.max), R.y = M.y, U.copy(this._tempBox.max);
+        const ie = (M.z + U.z) * 0.5;
+        M.z = A.z = R.z = U.z = ie, M.applyMatrix4(L), A.applyMatrix4(L), R.applyMatrix4(L), U.applyMatrix4(L), m.debugDrawLine(M, A, 255), m.debugDrawLine(M, R, 255), m.debugDrawLine(A, U, 255), m.debugDrawLine(R, U, 255);
+      }
+      let f = 999;
+      if (c && s.lastScreenCoverage > 0)
+        for (let L = 0; L < c.length; L++) {
+          const M = c[L];
+          if ((((W = M.densities) == null ? void 0 : W[u]) || M.density || 1e-5) / s.lastScreenCoverage < o) {
+            f = L;
+            break;
+          }
+        }
+      f < a && (a = f, l = !0);
+    }
+    if (l ? i.mesh_lod = a : i.mesh_lod = s.lastLodLevel_Mesh, k && i.mesh_lod != s.lastLodLevel_Mesh) {
+      const y = c == null ? void 0 : c[i.mesh_lod];
+      y && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${i.mesh_lod} (${y.density.toFixed(0)}) - ${e.name}`);
+    }
+    if (D) {
+      const O = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
+      if (s.lastLodLevel_Texture < 0) {
+        if (i.texture_lod = g.max_count - 1, k) {
+          const y = g.lods[g.max_count - 1];
+          k && console.log(`First Texture LOD ${i.texture_lod} (${y.max_height}px) - ${e.name}`);
+        }
+      } else {
+        const y = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
+        let X = s.lastScreenCoverage * 4;
+        ((_ = this.context) == null ? void 0 : _.engine) === "model-viewer" && (X *= 1.5);
+        const I = b / window.devicePixelRatio * X;
+        let B = !1;
+        for (let S = g.lods.length - 1; S >= 0; S--) {
+          const f = g.lods[S];
+          if (!(O && f.max_height >= 2048) && !(ct() && f.max_height > 4096) && (f.max_height > I || !B && S === 0)) {
+            if (B = !0, i.texture_lod = S, i.texture_lod < s.lastLodLevel_Texture) {
+              const T = f.max_height;
+              k && console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${i.texture_lod} = ${T}px 
+Screensize: ${I.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${y.toFixed(1)} 
+${e.name}`);
+            }
+            break;
+          }
+        }
+      }
+    } else
+      i.texture_lod = 0;
+  }
+}, E = new WeakMap(), Y = new WeakMap(), we = new WeakMap(), Z = new WeakMap(), re = new WeakMap(), ve = new WeakMap(), H = 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.
+ */
+d(m, "debugDrawLine"), /**
+ * Force override the LOD level for all objects in the scene
+ */
+d(m, "overrideGlobalLodLevel"), d(m, "corner0", new q()), d(m, "corner1", new q()), d(m, "corner2", new q()), d(m, "corner3", new q()), d(m, "_tempPtInside", new q()), m);
+class xt {
+  constructor() {
+    d(this, "frames", 0);
+    d(this, "lastLodLevel_Mesh", -1);
+    d(this, "lastLodLevel_Texture", -1);
+    d(this, "lastScreenCoverage", 0);
+    d(this, "lastScreenspaceVolume", new q());
+    d(this, "lastCentrality", 0);
+  }
+}
+const Re = Symbol("NEEDLE_mesh_lod"), ge = Symbol("NEEDLE_texture_lod");
+let le = null;
+function Xe() {
+  const n = wt();
+  n && (n.mapURLs(function(t) {
+    return ke(), t;
+  }), ke(), le == null || le.disconnect(), le = new MutationObserver((t) => {
+    t.forEach((e) => {
+      e.addedNodes.forEach((s) => {
+        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && qe(s);
+      });
+    });
+  }), le.observe(document, { childList: !0, subtree: !0 }));
+}
+function wt() {
+  if (typeof customElements > "u") return null;
+  const n = customElements.get("model-viewer");
+  return n || (customElements.whenDefined("model-viewer").then(() => {
+    console.debug("[gltf-progressive] model-viewer defined"), Xe();
+  }), null);
+}
+function ke() {
+  if (typeof document > "u") return;
+  document.querySelectorAll("model-viewer").forEach((t) => {
+    qe(t);
+  });
+}
+const $e = /* @__PURE__ */ new WeakSet();
+let vt = 0;
+function qe(n) {
+  if (!n || $e.has(n))
+    return null;
+  $e.add(n), console.debug("[gltf-progressive] found new model-viewer..." + ++vt + `
+`, n.getAttribute("src"));
+  let t = null, e = null, s = null;
+  for (let o = n; o != null; o = Object.getPrototypeOf(o)) {
+    const i = Object.getOwnPropertySymbols(o), r = i.find((c) => c.toString() == "Symbol(renderer)"), a = i.find((c) => c.toString() == "Symbol(scene)"), l = i.find((c) => c.toString() == "Symbol(needsRender)");
+    !t && r != null && (t = n[r].threeRenderer), !e && a != null && (e = n[a]), !s && l != null && (s = n[l]);
+  }
+  if (t && e) {
+    let o = function() {
+      if (s) {
+        let r = 0, a = setInterval(() => {
+          if (r++ > 5) {
+            clearInterval(a);
+            return;
+          }
+          s == null || s.call(n);
+        }, 300);
+      }
+    };
+    console.debug("[gltf-progressive] setup model-viewer");
+    const i = xe.get(t, { engine: "model-viewer" });
+    return xe.addPlugin(new Dt()), i.enable(), i.addEventListener("changed", () => {
+      s == null || s.call(n);
+    }), n.addEventListener("model-visibility", (r) => {
+      r.detail.visible && (s == null || s.call(n));
+    }), n.addEventListener("load", () => {
+      o();
+    }), () => {
+      i.disable();
+    };
+  }
+  return null;
+}
+class Dt {
+  constructor() {
+    d(this, "_didWarnAboutMissingUrl", !1);
+  }
+  onBeforeUpdateLOD(t, e, s, o) {
+    this.tryParseMeshLOD(e, o), this.tryParseTextureLOD(e, o);
+  }
+  getUrl(t) {
+    if (!t)
+      return null;
+    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(t) {
+    return t._currentGLTF;
+  }
+  tryGetCurrentModelViewer(t) {
+    return t.element;
+  }
+  tryParseTextureLOD(t, e) {
+    if (e[ge] == !0) return;
+    e[ge] = !0;
+    const s = this.tryGetCurrentGLTF(t), o = this.tryGetCurrentModelViewer(t), i = this.getUrl(o);
+    if (i && s && e.material) {
+      let r = function(l) {
+        var u, h, g;
+        if (l[ge] == !0) return;
+        l[ge] = !0, l.userData && (l.userData.LOD = -1);
+        const c = Object.keys(l);
+        for (let D = 0; D < c.length; D++) {
+          const b = c[D], v = l[b];
+          if ((v == null ? void 0 : v.isTexture) === !0) {
+            const F = (h = (u = v.userData) == null ? void 0 : u.associations) == null ? void 0 : h.textures;
+            if (F == null) continue;
+            const W = s.parser.json.textures[F];
+            if (!W) {
+              console.warn("Texture data not found for texture index " + F);
+              continue;
+            }
+            if ((g = W == null ? void 0 : W.extensions) != null && g[K]) {
+              const _ = W.extensions[K];
+              _ && i && z.registerTexture(i, v, _.lods.length, F, _);
+            }
+          }
+        }
+      };
+      const a = e.material;
+      if (Array.isArray(a)) for (const l of a) r(l);
+      else r(a);
+    }
+  }
+  tryParseMeshLOD(t, e) {
+    var r, a;
+    if (e[Re] == !0) return;
+    e[Re] = !0;
+    const s = this.tryGetCurrentModelViewer(t), o = this.getUrl(s);
+    if (!o)
+      return;
+    const i = (a = (r = e.userData) == null ? void 0 : r.gltfExtensions) == null ? void 0 : a[K];
+    if (i && o) {
+      const l = e.uuid;
+      z.registerMesh(o, l, e, 0, i.lods.length, i);
+    }
+  }
+}
+function _t(n, t, e, s) {
+  Ne(t), ze(e), Ve(e, {
+    progressive: !0,
+    ...s == null ? void 0 : s.hints
+  }), e.register((i) => new z(i, n));
+  const o = xe.get(t);
+  return (s == null ? void 0 : s.enableLODsManager) !== !1 && o.enable(), o;
+}
+Xe();
+if (!ht) {
+  const n = {
+    gltfProgressive: {
+      useNeedleProgressive: _t,
+      LODsManager: xe,
+      configureLoader: Ve,
+      getRaycastMesh: ue,
+      useRaycastMeshes: pt
+    }
+  };
+  if (!globalThis.Needle)
+    globalThis.Needle = n;
+  else
+    for (const t in n)
+      globalThis.Needle[t] = n[t];
+}
+export {
+  xe as LODsManager,
+  z as NEEDLE_progressive,
+  ze as addDracoAndKTX2Loaders,
+  Ve as configureLoader,
+  Ne as createLoaders,
+  ue as getRaycastMesh,
+  at as setDracoDecoderLocation,
+  lt as setKTX2TranscoderLocation
+};