@ridp/threejs 1.5.1 → 1.5.2

package/dist/objectQuery-BcL0iGx1.js

@@ -0,0 +1,1473 @@
+import { z as pn } from "./PredictiveLoader-Ce8DXwbW.js";
+import { DataTextureLoader as fn, HalfFloatType as Te, FloatType as Be, RGBAFormat as jn, LinearSRGBColorSpace as tn, RedFormat as et, NoColorSpace as nt, LinearFilter as $e, DataUtils as De, EquirectangularReflectionMapping as tt } from "three";
+/*!
+fflate - fast JavaScript compression/decompression
+<https://101arrowz.github.io/fflate>
+Licensed under MIT. https://github.com/101arrowz/fflate/blob/master/LICENSE
+version 0.8.2
+*/
+var ie = Uint8Array, Fe = Uint16Array, rt = Int32Array, mn = new ie([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]), wn = new ie([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]), ot = new ie([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]), En = function(i, h) {
+  for (var p = new Fe(31), S = 0; S < 31; ++S)
+    p[S] = h += 1 << i[S - 1];
+  for (var y = new rt(p[30]), S = 1; S < 30; ++S)
+    for (var D = p[S]; D < p[S + 1]; ++D)
+      y[D] = D - p[S] << 5 | S;
+  return { b: p, r: y };
+}, gn = En(mn, 2), vn = gn.b, lt = gn.r;
+vn[28] = 258, lt[258] = 28;
+var it = En(wn, 0), st = it.b, rn = new Fe(32768);
+for (var z = 0; z < 32768; ++z) {
+  var Ae = (z & 43690) >> 1 | (z & 21845) << 1;
+  Ae = (Ae & 52428) >> 2 | (Ae & 13107) << 2, Ae = (Ae & 61680) >> 4 | (Ae & 3855) << 4, rn[z] = ((Ae & 65280) >> 8 | (Ae & 255) << 8) >> 1;
+}
+var ze = function(i, h, p) {
+  for (var S = i.length, y = 0, D = new Fe(h); y < S; ++y)
+    i[y] && ++D[i[y] - 1];
+  var b = new Fe(h);
+  for (y = 1; y < h; ++y)
+    b[y] = b[y - 1] + D[y - 1] << 1;
+  var V;
+  if (p) {
+    V = new Fe(1 << h);
+    var _e = 15 - h;
+    for (y = 0; y < S; ++y)
+      if (i[y])
+        for (var Ue = y << 4 | i[y], se = h - i[y], R = b[i[y] - 1]++ << se, L = R | (1 << se) - 1; R <= L; ++R)
+          V[rn[R] >> _e] = Ue;
+  } else
+    for (V = new Fe(S), y = 0; y < S; ++y)
+      i[y] && (V[y] = rn[b[i[y] - 1]++] >> 15 - i[y]);
+  return V;
+}, Ge = new ie(288);
+for (var z = 0; z < 144; ++z)
+  Ge[z] = 8;
+for (var z = 144; z < 256; ++z)
+  Ge[z] = 9;
+for (var z = 256; z < 280; ++z)
+  Ge[z] = 7;
+for (var z = 280; z < 288; ++z)
+  Ge[z] = 8;
+var Sn = new ie(32);
+for (var z = 0; z < 32; ++z)
+  Sn[z] = 5;
+var ct = /* @__PURE__ */ ze(Ge, 9, 1), at = /* @__PURE__ */ ze(Sn, 5, 1), je = function(i) {
+  for (var h = i[0], p = 1; p < i.length; ++p)
+    i[p] > h && (h = i[p]);
+  return h;
+}, ae = function(i, h, p) {
+  var S = h / 8 | 0;
+  return (i[S] | i[S + 1] << 8) >> (h & 7) & p;
+}, en = function(i, h) {
+  var p = h / 8 | 0;
+  return (i[p] | i[p + 1] << 8 | i[p + 2] << 16) >> (h & 7);
+}, ut = function(i) {
+  return (i + 7) / 8 | 0;
+}, ht = function(i, h, p) {
+  return (p == null || p > i.length) && (p = i.length), new ie(i.subarray(h, p));
+}, pt = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+], ue = function(i, h, p) {
+  var S = new Error(h || pt[i]);
+  if (S.code = i, Error.captureStackTrace && Error.captureStackTrace(S, ue), !p)
+    throw S;
+  return S;
+}, ft = function(i, h, p, S) {
+  var y = i.length, D = 0;
+  if (!y || h.f && !h.l)
+    return p || new ie(0);
+  var b = !p, V = b || h.i != 2, _e = h.i;
+  b && (p = new ie(y * 3));
+  var Ue = function(Le) {
+    var We = p.length;
+    if (Le > We) {
+      var Pe = new ie(Math.max(We * 2, Le));
+      Pe.set(p), p = Pe;
+    }
+  }, se = h.f || 0, R = h.p || 0, L = h.b || 0, he = h.l, Ne = h.d, ye = h.m, ce = h.n, pe = y * 8;
+  do {
+    if (!he) {
+      se = ae(i, R, 1);
+      var Me = ae(i, R + 1, 3);
+      if (R += 3, Me)
+        if (Me == 1)
+          he = ct, Ne = at, ye = 9, ce = 5;
+        else if (Me == 2) {
+          var Ce = ae(i, R, 31) + 257, fe = ae(i, R + 10, 15) + 4, C = Ce + ae(i, R + 5, 31) + 1;
+          R += 14;
+          for (var U = new ie(C), x = new ie(19), T = 0; T < fe; ++T)
+            x[ot[T]] = ae(i, R + T * 3, 7);
+          R += fe * 3;
+          for (var O = je(x), Z = (1 << O) - 1, A = ze(x, O, 1), T = 0; T < C; ) {
+            var G = A[ae(i, R, Z)];
+            R += G & 15;
+            var j = G >> 4;
+            if (j < 16)
+              U[T++] = j;
+            else {
+              var N = 0, ee = 0;
+              for (j == 16 ? (ee = 3 + ae(i, R, 3), R += 2, N = U[T - 1]) : j == 17 ? (ee = 3 + ae(i, R, 7), R += 3) : j == 18 && (ee = 11 + ae(i, R, 127), R += 7); ee--; )
+                U[T++] = N;
+            }
+          }
+          var be = U.subarray(0, Ce), J = U.subarray(Ce);
+          ye = je(be), ce = je(J), he = ze(be, ye, 1), Ne = ze(J, ce, 1);
+        } else
+          ue(1);
+      else {
+        var j = ut(R) + 4, Ee = i[j - 4] | i[j - 3] << 8, Ie = j + Ee;
+        if (Ie > y) {
+          _e && ue(0);
+          break;
+        }
+        V && Ue(L + Ee), p.set(i.subarray(j, Ie), L), h.b = L += Ee, h.p = R = Ie * 8, h.f = se;
+        continue;
+      }
+      if (R > pe) {
+        _e && ue(0);
+        break;
+      }
+    }
+    V && Ue(L + 131072);
+    for (var X = (1 << ye) - 1, Oe = (1 << ce) - 1, W = R; ; W = R) {
+      var N = he[en(i, R) & X], K = N >> 4;
+      if (R += N & 15, R > pe) {
+        _e && ue(0);
+        break;
+      }
+      if (N || ue(2), K < 256)
+        p[L++] = K;
+      else if (K == 256) {
+        W = R, he = null;
+        break;
+      } else {
+        var ge = K - 254;
+        if (K > 264) {
+          var T = K - 257, de = mn[T];
+          ge = ae(i, R, (1 << de) - 1) + vn[T], R += de;
+        }
+        var F = Ne[en(i, R) & Oe], me = F >> 4;
+        F || ue(3), R += F & 15;
+        var J = st[me];
+        if (me > 3) {
+          var de = wn[me];
+          J += en(i, R) & (1 << de) - 1, R += de;
+        }
+        if (R > pe) {
+          _e && ue(0);
+          break;
+        }
+        V && Ue(L + 131072);
+        var ve = L + ge;
+        if (L < J) {
+          var Ye = D - J, Ve = Math.min(J, ve);
+          for (Ye + L < 0 && ue(3); L < Ve; ++L)
+            p[L] = S[Ye + L];
+        }
+        for (; L < ve; ++L)
+          p[L] = p[L - J];
+      }
+    }
+    h.l = he, h.p = W, h.b = L, h.f = se, he && (se = 1, h.m = ye, h.d = Ne, h.n = ce);
+  } while (!se);
+  return L != p.length && b ? ht(p, 0, L) : p.subarray(0, L);
+}, mt = /* @__PURE__ */ new ie(0), wt = function(i, h) {
+  return ((i[0] & 15) != 8 || i[0] >> 4 > 7 || (i[0] << 8 | i[1]) % 31) && ue(6, "invalid zlib data"), (i[1] >> 5 & 1) == 1 && ue(6, "invalid zlib data: " + (i[1] & 32 ? "need" : "unexpected") + " dictionary"), (i[1] >> 3 & 4) + 2;
+};
+function qe(i, h) {
+  return ft(i.subarray(wt(i), -4), { i: 2 }, h, h);
+}
+var Et = typeof TextDecoder < "u" && /* @__PURE__ */ new TextDecoder(), gt = 0;
+try {
+  Et.decode(mt, { stream: !0 }), gt = 1;
+} catch {
+}
+class vt extends fn {
+  /**
+   * Constructs a new EXR loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(h) {
+    super(h), this.type = Te;
+  }
+  /**
+   * Parses the given EXR texture data.
+   *
+   * @param {ArrayBuffer} buffer - The raw texture data.
+   * @return {DataTextureLoader~TexData} An object representing the parsed texture data.
+   */
+  parse(h) {
+    const U = Math.pow(2.7182818, 2.2);
+    function x(e, n) {
+      let t = 0;
+      for (let l = 0; l < 65536; ++l)
+        (l == 0 || e[l >> 3] & 1 << (l & 7)) && (n[t++] = l);
+      const r = t - 1;
+      for (; t < 65536; ) n[t++] = 0;
+      return r;
+    }
+    function T(e) {
+      for (let n = 0; n < 16384; n++)
+        e[n] = {}, e[n].len = 0, e[n].lit = 0, e[n].p = null;
+    }
+    const O = { l: 0, c: 0, lc: 0 };
+    function Z(e, n, t, r, l) {
+      for (; t < e; )
+        n = n << 8 | cn(r, l), t += 8;
+      t -= e, O.l = n >> t & (1 << e) - 1, O.c = n, O.lc = t;
+    }
+    const A = new Array(59);
+    function G(e) {
+      for (let t = 0; t <= 58; ++t) A[t] = 0;
+      for (let t = 0; t < 65537; ++t) A[e[t]] += 1;
+      let n = 0;
+      for (let t = 58; t > 0; --t) {
+        const r = n + A[t] >> 1;
+        A[t] = n, n = r;
+      }
+      for (let t = 0; t < 65537; ++t) {
+        const r = e[t];
+        r > 0 && (e[t] = r | A[r]++ << 6);
+      }
+    }
+    function N(e, n, t, r, l, o) {
+      const a = n;
+      let f = 0, u = 0;
+      for (; r <= l; r++) {
+        if (a.value - n.value > t) return !1;
+        Z(6, f, u, e, a);
+        const c = O.l;
+        if (f = O.c, u = O.lc, o[r] = c, c == 63) {
+          if (a.value - n.value > t)
+            throw new Error("Something wrong with hufUnpackEncTable");
+          Z(8, f, u, e, a);
+          let s = O.l + 6;
+          if (f = O.c, u = O.lc, r + s > l + 1)
+            throw new Error("Something wrong with hufUnpackEncTable");
+          for (; s--; ) o[r++] = 0;
+          r--;
+        } else if (c >= 59) {
+          let s = c - 59 + 2;
+          if (r + s > l + 1)
+            throw new Error("Something wrong with hufUnpackEncTable");
+          for (; s--; ) o[r++] = 0;
+          r--;
+        }
+      }
+      G(o);
+    }
+    function ee(e) {
+      return e & 63;
+    }
+    function be(e) {
+      return e >> 6;
+    }
+    function J(e, n, t, r) {
+      for (; n <= t; n++) {
+        const l = be(e[n]), o = ee(e[n]);
+        if (l >> o)
+          throw new Error("Invalid table entry");
+        if (o > 14) {
+          const a = r[l >> o - 14];
+          if (a.len)
+            throw new Error("Invalid table entry");
+          if (a.lit++, a.p) {
+            const f = a.p;
+            a.p = new Array(a.lit);
+            for (let u = 0; u < a.lit - 1; ++u)
+              a.p[u] = f[u];
+          } else
+            a.p = new Array(1);
+          a.p[a.lit - 1] = n;
+        } else if (o) {
+          let a = 0;
+          for (let f = 1 << 14 - o; f > 0; f--) {
+            const u = r[(l << 14 - o) + a];
+            if (u.len || u.p)
+              throw new Error("Invalid table entry");
+            u.len = o, u.lit = n, a++;
+          }
+        }
+      }
+      return !0;
+    }
+    const X = { c: 0, lc: 0 };
+    function Oe(e, n, t, r) {
+      e = e << 8 | cn(t, r), n += 8, X.c = e, X.lc = n;
+    }
+    const W = { c: 0, lc: 0 };
+    function K(e, n, t, r, l, o, a, f, u) {
+      if (e == n) {
+        r < 8 && (Oe(t, r, l, o), t = X.c, r = X.lc), r -= 8;
+        let c = t >> r;
+        if (c = new Uint8Array([c])[0], f.value + c > u)
+          return !1;
+        const s = a[f.value - 1];
+        for (; c-- > 0; )
+          a[f.value++] = s;
+      } else if (f.value < u)
+        a[f.value++] = e;
+      else
+        return !1;
+      W.c = t, W.lc = r;
+    }
+    function ge(e) {
+      return e & 65535;
+    }
+    function de(e) {
+      const n = ge(e);
+      return n > 32767 ? n - 65536 : n;
+    }
+    const F = { a: 0, b: 0 };
+    function me(e, n) {
+      const t = de(e), l = de(n), o = t + (l & 1) + (l >> 1), a = o, f = o - l;
+      F.a = a, F.b = f;
+    }
+    function ve(e, n) {
+      const t = ge(e), r = ge(n), l = t - (r >> 1) & 65535, o = r + l - 32768 & 65535;
+      F.a = o, F.b = l;
+    }
+    function Ye(e, n, t, r, l, o, a) {
+      const f = a < 16384, u = t > l ? l : t;
+      let c = 1, s, m;
+      for (; c <= u; ) c <<= 1;
+      for (c >>= 1, s = c, c >>= 1; c >= 1; ) {
+        m = 0;
+        const v = m + o * (l - s), w = o * c, I = o * s, E = r * c, _ = r * s;
+        let d, B, Y, te;
+        for (; m <= v; m += I) {
+          let H = m;
+          const M = m + r * (t - s);
+          for (; H <= M; H += _) {
+            const q = H + E, le = H + w, $ = le + E;
+            f ? (me(e[H + n], e[le + n]), d = F.a, Y = F.b, me(e[q + n], e[$ + n]), B = F.a, te = F.b, me(d, B), e[H + n] = F.a, e[q + n] = F.b, me(Y, te), e[le + n] = F.a, e[$ + n] = F.b) : (ve(e[H + n], e[le + n]), d = F.a, Y = F.b, ve(e[q + n], e[$ + n]), B = F.a, te = F.b, ve(d, B), e[H + n] = F.a, e[q + n] = F.b, ve(Y, te), e[le + n] = F.a, e[$ + n] = F.b);
+          }
+          if (t & c) {
+            const q = H + w;
+            f ? me(e[H + n], e[q + n]) : ve(e[H + n], e[q + n]), d = F.a, e[q + n] = F.b, e[H + n] = d;
+          }
+        }
+        if (l & c) {
+          let H = m;
+          const M = m + r * (t - s);
+          for (; H <= M; H += _) {
+            const q = H + E;
+            f ? me(e[H + n], e[q + n]) : ve(e[H + n], e[q + n]), d = F.a, e[q + n] = F.b, e[H + n] = d;
+          }
+        }
+        s = c, c >>= 1;
+      }
+      return m;
+    }
+    function Ve(e, n, t, r, l, o, a, f, u) {
+      let c = 0, s = 0;
+      const m = a, v = Math.trunc(r.value + (l + 7) / 8);
+      for (; r.value < v; )
+        for (Oe(c, s, t, r), c = X.c, s = X.lc; s >= 14; ) {
+          const I = c >> s - 14 & 16383, E = n[I];
+          if (E.len)
+            s -= E.len, K(E.lit, o, c, s, t, r, f, u, m), c = W.c, s = W.lc;
+          else {
+            if (!E.p)
+              throw new Error("hufDecode issues");
+            let _;
+            for (_ = 0; _ < E.lit; _++) {
+              const d = ee(e[E.p[_]]);
+              for (; s < d && r.value < v; )
+                Oe(c, s, t, r), c = X.c, s = X.lc;
+              if (s >= d && be(e[E.p[_]]) == (c >> s - d & (1 << d) - 1)) {
+                s -= d, K(E.p[_], o, c, s, t, r, f, u, m), c = W.c, s = W.lc;
+                break;
+              }
+            }
+            if (_ == E.lit)
+              throw new Error("hufDecode issues");
+          }
+        }
+      const w = 8 - l & 7;
+      for (c >>= w, s -= w; s > 0; ) {
+        const I = n[c << 14 - s & 16383];
+        if (I.len)
+          s -= I.len, K(I.lit, o, c, s, t, r, f, u, m), c = W.c, s = W.lc;
+        else
+          throw new Error("hufDecode issues");
+      }
+      return !0;
+    }
+    function Le(e, n, t, r, l, o) {
+      const a = { value: 0 }, f = t.value, u = oe(n, t), c = oe(n, t);
+      t.value += 4;
+      const s = oe(n, t);
+      if (t.value += 4, u < 0 || u >= 65537 || c < 0 || c >= 65537)
+        throw new Error("Something wrong with HUF_ENCSIZE");
+      const m = new Array(65537), v = new Array(16384);
+      T(v);
+      const w = r - (t.value - f);
+      if (N(e, t, w, u, c, m), s > 8 * (r - (t.value - f)))
+        throw new Error("Something wrong with hufUncompress");
+      J(m, u, c, v), Ve(m, v, e, t, s, c, o, l, a);
+    }
+    function We(e, n, t) {
+      for (let r = 0; r < t; ++r)
+        n[r] = e[n[r]];
+    }
+    function Pe(e) {
+      for (let n = 1; n < e.length; n++) {
+        const t = e[n - 1] + e[n] - 128;
+        e[n] = t;
+      }
+    }
+    function on(e, n) {
+      let t = 0, r = Math.floor((e.length + 1) / 2), l = 0;
+      const o = e.length - 1;
+      for (; !(l > o || (n[l++] = e[t++], l > o)); )
+        n[l++] = e[r++];
+    }
+    function ln(e) {
+      let n = e.byteLength;
+      const t = new Array();
+      let r = 0;
+      const l = new DataView(e);
+      for (; n > 0; ) {
+        const o = l.getInt8(r++);
+        if (o < 0) {
+          const a = -o;
+          n -= a + 1;
+          for (let f = 0; f < a; f++)
+            t.push(l.getUint8(r++));
+        } else {
+          const a = o;
+          n -= 2;
+          const f = l.getUint8(r++);
+          for (let u = 0; u < a + 1; u++)
+            t.push(f);
+        }
+      }
+      return t;
+    }
+    function yn(e, n, t, r, l, o) {
+      let a = new DataView(o.buffer);
+      const f = t[e.idx[0]].width, u = t[e.idx[0]].height, c = 3, s = Math.floor(f / 8), m = Math.ceil(f / 8), v = Math.ceil(u / 8), w = f - (m - 1) * 8, I = u - (v - 1) * 8, E = { value: 0 }, _ = new Array(c), d = new Array(c), B = new Array(c), Y = new Array(c), te = new Array(c);
+      for (let M = 0; M < c; ++M)
+        te[M] = n[e.idx[M]], _[M] = M < 1 ? 0 : _[M - 1] + m * v, d[M] = new Float32Array(64), B[M] = new Uint16Array(64), Y[M] = new Uint16Array(m * 64);
+      for (let M = 0; M < v; ++M) {
+        let q = 8;
+        M == v - 1 && (q = I);
+        let le = 8;
+        for (let k = 0; k < m; ++k) {
+          k == m - 1 && (le = w);
+          for (let P = 0; P < c; ++P)
+            B[P].fill(0), B[P][0] = l[_[P]++], In(E, r, B[P]), Cn(B[P], d[P]), bn(d[P]);
+          dn(d);
+          for (let P = 0; P < c; ++P)
+            Rn(d[P], Y[P], k * 64);
+        }
+        let $ = 0;
+        for (let k = 0; k < c; ++k) {
+          const P = t[e.idx[k]].type;
+          for (let Se = 8 * M; Se < 8 * M + q; ++Se) {
+            $ = te[k][Se];
+            for (let He = 0; He < s; ++He) {
+              const we = He * 64 + (Se & 7) * 8;
+              a.setUint16($ + 0 * 2 * P, Y[k][we + 0], !0), a.setUint16($ + 1 * 2 * P, Y[k][we + 1], !0), a.setUint16($ + 2 * 2 * P, Y[k][we + 2], !0), a.setUint16($ + 3 * 2 * P, Y[k][we + 3], !0), a.setUint16($ + 4 * 2 * P, Y[k][we + 4], !0), a.setUint16($ + 5 * 2 * P, Y[k][we + 5], !0), a.setUint16($ + 6 * 2 * P, Y[k][we + 6], !0), a.setUint16($ + 7 * 2 * P, Y[k][we + 7], !0), $ += 8 * 2 * P;
+            }
+          }
+          if (s != m)
+            for (let Se = 8 * M; Se < 8 * M + q; ++Se) {
+              const He = te[k][Se] + 8 * s * 2 * P, we = s * 64 + (Se & 7) * 8;
+              for (let Ke = 0; Ke < le; ++Ke)
+                a.setUint16(He + Ke * 2 * P, Y[k][we + Ke], !0);
+            }
+        }
+      }
+      const H = new Uint16Array(f);
+      a = new DataView(o.buffer);
+      for (let M = 0; M < c; ++M) {
+        t[e.idx[M]].decoded = !0;
+        const q = t[e.idx[M]].type;
+        if (t[M].type == 2)
+          for (let le = 0; le < u; ++le) {
+            const $ = te[M][le];
+            for (let k = 0; k < f; ++k)
+              H[k] = a.getUint16($ + k * 2 * q, !0);
+            for (let k = 0; k < f; ++k)
+              a.setFloat32($ + k * 2 * q, g(H[k]), !0);
+          }
+      }
+    }
+    function In(e, n, t) {
+      let r, l = 1;
+      for (; l < 64; )
+        r = n[e.value], r == 65280 ? l = 64 : r >> 8 == 255 ? l += r & 255 : (t[l] = r, l++), e.value++;
+    }
+    function Cn(e, n) {
+      n[0] = g(e[0]), n[1] = g(e[1]), n[2] = g(e[5]), n[3] = g(e[6]), n[4] = g(e[14]), n[5] = g(e[15]), n[6] = g(e[27]), n[7] = g(e[28]), n[8] = g(e[2]), n[9] = g(e[4]), n[10] = g(e[7]), n[11] = g(e[13]), n[12] = g(e[16]), n[13] = g(e[26]), n[14] = g(e[29]), n[15] = g(e[42]), n[16] = g(e[3]), n[17] = g(e[8]), n[18] = g(e[12]), n[19] = g(e[17]), n[20] = g(e[25]), n[21] = g(e[30]), n[22] = g(e[41]), n[23] = g(e[43]), n[24] = g(e[9]), n[25] = g(e[11]), n[26] = g(e[18]), n[27] = g(e[24]), n[28] = g(e[31]), n[29] = g(e[40]), n[30] = g(e[44]), n[31] = g(e[53]), n[32] = g(e[10]), n[33] = g(e[19]), n[34] = g(e[23]), n[35] = g(e[32]), n[36] = g(e[39]), n[37] = g(e[45]), n[38] = g(e[52]), n[39] = g(e[54]), n[40] = g(e[20]), n[41] = g(e[22]), n[42] = g(e[33]), n[43] = g(e[38]), n[44] = g(e[46]), n[45] = g(e[51]), n[46] = g(e[55]), n[47] = g(e[60]), n[48] = g(e[21]), n[49] = g(e[34]), n[50] = g(e[37]), n[51] = g(e[47]), n[52] = g(e[50]), n[53] = g(e[56]), n[54] = g(e[59]), n[55] = g(e[61]), n[56] = g(e[35]), n[57] = g(e[36]), n[58] = g(e[48]), n[59] = g(e[49]), n[60] = g(e[57]), n[61] = g(e[58]), n[62] = g(e[62]), n[63] = g(e[63]);
+    }
+    function bn(e) {
+      const n = 0.5 * Math.cos(0.7853975), t = 0.5 * Math.cos(3.14159 / 16), r = 0.5 * Math.cos(3.14159 / 8), l = 0.5 * Math.cos(3 * 3.14159 / 16), o = 0.5 * Math.cos(5 * 3.14159 / 16), a = 0.5 * Math.cos(3 * 3.14159 / 8), f = 0.5 * Math.cos(7 * 3.14159 / 16), u = new Array(4), c = new Array(4), s = new Array(4), m = new Array(4);
+      for (let v = 0; v < 8; ++v) {
+        const w = v * 8;
+        u[0] = r * e[w + 2], u[1] = a * e[w + 2], u[2] = r * e[w + 6], u[3] = a * e[w + 6], c[0] = t * e[w + 1] + l * e[w + 3] + o * e[w + 5] + f * e[w + 7], c[1] = l * e[w + 1] - f * e[w + 3] - t * e[w + 5] - o * e[w + 7], c[2] = o * e[w + 1] - t * e[w + 3] + f * e[w + 5] + l * e[w + 7], c[3] = f * e[w + 1] - o * e[w + 3] + l * e[w + 5] - t * e[w + 7], s[0] = n * (e[w + 0] + e[w + 4]), s[3] = n * (e[w + 0] - e[w + 4]), s[1] = u[0] + u[3], s[2] = u[1] - u[2], m[0] = s[0] + s[1], m[1] = s[3] + s[2], m[2] = s[3] - s[2], m[3] = s[0] - s[1], e[w + 0] = m[0] + c[0], e[w + 1] = m[1] + c[1], e[w + 2] = m[2] + c[2], e[w + 3] = m[3] + c[3], e[w + 4] = m[3] - c[3], e[w + 5] = m[2] - c[2], e[w + 6] = m[1] - c[1], e[w + 7] = m[0] - c[0];
+      }
+      for (let v = 0; v < 8; ++v)
+        u[0] = r * e[16 + v], u[1] = a * e[16 + v], u[2] = r * e[48 + v], u[3] = a * e[48 + v], c[0] = t * e[8 + v] + l * e[24 + v] + o * e[40 + v] + f * e[56 + v], c[1] = l * e[8 + v] - f * e[24 + v] - t * e[40 + v] - o * e[56 + v], c[2] = o * e[8 + v] - t * e[24 + v] + f * e[40 + v] + l * e[56 + v], c[3] = f * e[8 + v] - o * e[24 + v] + l * e[40 + v] - t * e[56 + v], s[0] = n * (e[v] + e[32 + v]), s[3] = n * (e[v] - e[32 + v]), s[1] = u[0] + u[3], s[2] = u[1] - u[2], m[0] = s[0] + s[1], m[1] = s[3] + s[2], m[2] = s[3] - s[2], m[3] = s[0] - s[1], e[0 + v] = m[0] + c[0], e[8 + v] = m[1] + c[1], e[16 + v] = m[2] + c[2], e[24 + v] = m[3] + c[3], e[32 + v] = m[3] - c[3], e[40 + v] = m[2] - c[2], e[48 + v] = m[1] - c[1], e[56 + v] = m[0] - c[0];
+    }
+    function dn(e) {
+      for (let n = 0; n < 64; ++n) {
+        const t = e[0][n], r = e[1][n], l = e[2][n];
+        e[0][n] = t + 1.5747 * l, e[1][n] = t - 0.1873 * r - 0.4682 * l, e[2][n] = t + 1.8556 * r;
+      }
+    }
+    function Rn(e, n, t) {
+      for (let r = 0; r < 64; ++r)
+        n[t + r] = De.toHalfFloat(An(e[r]));
+    }
+    function An(e) {
+      return e <= 1 ? Math.sign(e) * Math.pow(Math.abs(e), 2.2) : Math.sign(e) * Math.pow(U, Math.abs(e) - 1);
+    }
+    function Je(e) {
+      return new DataView(e.array.buffer, e.offset.value, e.size);
+    }
+    function Tn(e) {
+      const n = e.viewer.buffer.slice(e.offset.value, e.offset.value + e.size), t = new Uint8Array(ln(n)), r = new Uint8Array(t.length);
+      return Pe(t), on(t, r), new DataView(r.buffer);
+    }
+    function Qe(e) {
+      const n = e.array.slice(e.offset.value, e.offset.value + e.size), t = qe(n), r = new Uint8Array(t.length);
+      return Pe(t), on(t, r), new DataView(r.buffer);
+    }
+    function Un(e) {
+      const n = e.viewer, t = { value: e.offset.value }, r = new Uint16Array(e.columns * e.lines * (e.inputChannels.length * e.type)), l = new Uint8Array(8192);
+      let o = 0;
+      const a = new Array(e.inputChannels.length);
+      for (let I = 0, E = e.inputChannels.length; I < E; I++)
+        a[I] = {}, a[I].start = o, a[I].end = a[I].start, a[I].nx = e.columns, a[I].ny = e.lines, a[I].size = e.type, o += a[I].nx * a[I].ny * a[I].size;
+      const f = Ze(n, t), u = Ze(n, t);
+      if (u >= 8192)
+        throw new Error("Something is wrong with PIZ_COMPRESSION BITMAP_SIZE");
+      if (f <= u)
+        for (let I = 0; I < u - f + 1; I++)
+          l[I + f] = Re(n, t);
+      const c = new Uint16Array(65536), s = x(l, c), m = oe(n, t);
+      Le(e.array, n, t, m, r, o);
+      for (let I = 0; I < e.inputChannels.length; ++I) {
+        const E = a[I];
+        for (let _ = 0; _ < a[I].size; ++_)
+          Ye(
+            r,
+            E.start + _,
+            E.nx,
+            E.size,
+            E.ny,
+            E.nx * E.size,
+            s
+          );
+      }
+      We(c, r, o);
+      let v = 0;
+      const w = new Uint8Array(r.buffer.byteLength);
+      for (let I = 0; I < e.lines; I++)
+        for (let E = 0; E < e.inputChannels.length; E++) {
+          const _ = a[E], d = _.nx * _.size, B = new Uint8Array(r.buffer, _.end * 2, d * 2);
+          w.set(B, v), v += d * 2, _.end += d;
+        }
+      return new DataView(w.buffer);
+    }
+    function Nn(e) {
+      const n = e.array.slice(e.offset.value, e.offset.value + e.size), t = qe(n), r = e.inputChannels.length * e.lines * e.columns * e.totalBytes, l = new ArrayBuffer(r), o = new DataView(l);
+      let a = 0, f = 0;
+      const u = new Array(4);
+      for (let c = 0; c < e.lines; c++)
+        for (let s = 0; s < e.inputChannels.length; s++) {
+          let m = 0;
+          switch (e.inputChannels[s].pixelType) {
+            case 1:
+              u[0] = a, u[1] = u[0] + e.columns, a = u[1] + e.columns;
+              for (let w = 0; w < e.columns; ++w) {
+                const I = t[u[0]++] << 8 | t[u[1]++];
+                m += I, o.setUint16(f, m, !0), f += 2;
+              }
+              break;
+            case 2:
+              u[0] = a, u[1] = u[0] + e.columns, u[2] = u[1] + e.columns, a = u[2] + e.columns;
+              for (let w = 0; w < e.columns; ++w) {
+                const I = t[u[0]++] << 24 | t[u[1]++] << 16 | t[u[2]++] << 8;
+                m += I, o.setUint32(f, m, !0), f += 4;
+              }
+              break;
+          }
+        }
+      return o;
+    }
+    function sn(e) {
+      const n = e.viewer, t = { value: e.offset.value }, r = new Uint8Array(e.columns * e.lines * (e.inputChannels.length * e.type * 2)), l = {
+        version: ne(n, t),
+        unknownUncompressedSize: ne(n, t),
+        unknownCompressedSize: ne(n, t),
+        acCompressedSize: ne(n, t),
+        dcCompressedSize: ne(n, t),
+        rleCompressedSize: ne(n, t),
+        rleUncompressedSize: ne(n, t),
+        rleRawSize: ne(n, t),
+        totalAcUncompressedCount: ne(n, t),
+        totalDcUncompressedCount: ne(n, t),
+        acCompression: ne(n, t)
+      };
+      if (l.version < 2)
+        throw new Error("EXRLoader.parse: " + xe.compression + " version " + l.version + " is unsupported");
+      const o = new Array();
+      let a = Ze(n, t) - 2;
+      for (; a > 0; ) {
+        const E = Xe(n.buffer, t), _ = Re(n, t), d = _ >> 2 & 3, B = (_ >> 4) - 1, Y = new Int8Array([B])[0], te = Re(n, t);
+        o.push({
+          name: E,
+          index: Y,
+          type: te,
+          compression: d
+        }), a -= E.length + 3;
+      }
+      const f = xe.channels, u = new Array(e.inputChannels.length);
+      for (let E = 0; E < e.inputChannels.length; ++E) {
+        const _ = u[E] = {}, d = f[E];
+        _.name = d.name, _.compression = 0, _.decoded = !1, _.type = d.pixelType, _.pLinear = d.pLinear, _.width = e.columns, _.height = e.lines;
+      }
+      const c = {
+        idx: new Array(3)
+      };
+      for (let E = 0; E < e.inputChannels.length; ++E) {
+        const _ = u[E];
+        for (let d = 0; d < o.length; ++d) {
+          const B = o[d];
+          _.name == B.name && (_.compression = B.compression, B.index >= 0 && (c.idx[B.index] = E), _.offset = E);
+        }
+      }
+      let s, m, v;
+      if (l.acCompressedSize > 0)
+        switch (l.acCompression) {
+          case 0:
+            s = new Uint16Array(l.totalAcUncompressedCount), Le(e.array, n, t, l.acCompressedSize, s, l.totalAcUncompressedCount);
+            break;
+          case 1:
+            const E = e.array.slice(t.value, t.value + l.totalAcUncompressedCount), _ = qe(E);
+            s = new Uint16Array(_.buffer), t.value += l.totalAcUncompressedCount;
+            break;
+        }
+      if (l.dcCompressedSize > 0) {
+        const E = {
+          array: e.array,
+          offset: t,
+          size: l.dcCompressedSize
+        };
+        m = new Uint16Array(Qe(E).buffer), t.value += l.dcCompressedSize;
+      }
+      if (l.rleRawSize > 0) {
+        const E = e.array.slice(t.value, t.value + l.rleCompressedSize), _ = qe(E);
+        v = ln(_.buffer), t.value += l.rleCompressedSize;
+      }
+      let w = 0;
+      const I = new Array(u.length);
+      for (let E = 0; E < I.length; ++E)
+        I[E] = new Array();
+      for (let E = 0; E < e.lines; ++E)
+        for (let _ = 0; _ < u.length; ++_)
+          I[_].push(w), w += u[_].width * e.type * 2;
+      yn(c, I, u, s, m, r);
+      for (let E = 0; E < u.length; ++E) {
+        const _ = u[E];
+        if (!_.decoded)
+          switch (_.compression) {
+            case 2:
+              let d = 0, B = 0;
+              for (let Y = 0; Y < e.lines; ++Y) {
+                let te = I[E][d];
+                for (let H = 0; H < _.width; ++H) {
+                  for (let M = 0; M < 2 * _.type; ++M)
+                    r[te++] = v[B + M * _.width * _.height];
+                  B++;
+                }
+                d++;
+              }
+              break;
+            case 1:
+            // skip
+            default:
+              throw new Error("EXRLoader.parse: unsupported channel compression");
+          }
+      }
+      return new DataView(r.buffer);
+    }
+    function Xe(e, n) {
+      const t = new Uint8Array(e);
+      let r = 0;
+      for (; t[n.value + r] != 0; )
+        r += 1;
+      const l = new TextDecoder().decode(
+        t.slice(n.value, n.value + r)
+      );
+      return n.value = n.value + r + 1, l;
+    }
+    function Mn(e, n, t) {
+      const r = new TextDecoder().decode(
+        new Uint8Array(e).slice(n.value, n.value + t)
+      );
+      return n.value = n.value + t, r;
+    }
+    function On(e, n) {
+      const t = re(e, n), r = oe(e, n);
+      return [t, r];
+    }
+    function xn(e, n) {
+      const t = oe(e, n), r = oe(e, n);
+      return [t, r];
+    }
+    function re(e, n) {
+      const t = e.getInt32(n.value, !0);
+      return n.value = n.value + 4, t;
+    }
+    function oe(e, n) {
+      const t = e.getUint32(n.value, !0);
+      return n.value = n.value + 4, t;
+    }
+    function cn(e, n) {
+      const t = e[n.value];
+      return n.value = n.value + 1, t;
+    }
+    function Re(e, n) {
+      const t = e.getUint8(n.value);
+      return n.value = n.value + 1, t;
+    }
+    const ne = function(e, n) {
+      let t;
+      return "getBigInt64" in DataView.prototype ? t = Number(e.getBigInt64(n.value, !0)) : t = e.getUint32(n.value + 4, !0) + Number(e.getUint32(n.value, !0) << 32), n.value += 8, t;
+    };
+    function Q(e, n) {
+      const t = e.getFloat32(n.value, !0);
+      return n.value += 4, t;
+    }
+    function kn(e, n) {
+      return De.toHalfFloat(Q(e, n));
+    }
+    function g(e) {
+      const n = (e & 31744) >> 10, t = e & 1023;
+      return (e >> 15 ? -1 : 1) * (n ? n === 31 ? t ? NaN : 1 / 0 : Math.pow(2, n - 15) * (1 + t / 1024) : 6103515625e-14 * (t / 1024));
+    }
+    function Ze(e, n) {
+      const t = e.getUint16(n.value, !0);
+      return n.value += 2, t;
+    }
+    function Dn(e, n) {
+      return g(Ze(e, n));
+    }
+    function Fn(e, n, t, r) {
+      const l = t.value, o = [];
+      for (; t.value < l + r - 1; ) {
+        const a = Xe(n, t), f = re(e, t), u = Re(e, t);
+        t.value += 3;
+        const c = re(e, t), s = re(e, t);
+        o.push({
+          name: a,
+          pixelType: f,
+          pLinear: u,
+          xSampling: c,
+          ySampling: s
+        });
+      }
+      return t.value += 1, o;
+    }
+    function Bn(e, n) {
+      const t = Q(e, n), r = Q(e, n), l = Q(e, n), o = Q(e, n), a = Q(e, n), f = Q(e, n), u = Q(e, n), c = Q(e, n);
+      return { redX: t, redY: r, greenX: l, greenY: o, blueX: a, blueY: f, whiteX: u, whiteY: c };
+    }
+    function Ln(e, n) {
+      const t = [
+        "NO_COMPRESSION",
+        "RLE_COMPRESSION",
+        "ZIPS_COMPRESSION",
+        "ZIP_COMPRESSION",
+        "PIZ_COMPRESSION",
+        "PXR24_COMPRESSION",
+        "B44_COMPRESSION",
+        "B44A_COMPRESSION",
+        "DWAA_COMPRESSION",
+        "DWAB_COMPRESSION"
+      ], r = Re(e, n);
+      return t[r];
+    }
+    function Pn(e, n) {
+      const t = re(e, n), r = re(e, n), l = re(e, n), o = re(e, n);
+      return { xMin: t, yMin: r, xMax: l, yMax: o };
+    }
+    function Zn(e, n) {
+      const t = [
+        "INCREASING_Y",
+        "DECREASING_Y",
+        "RANDOM_Y"
+      ], r = Re(e, n);
+      return t[r];
+    }
+    function Hn(e, n) {
+      const t = [
+        "ENVMAP_LATLONG",
+        "ENVMAP_CUBE"
+      ], r = Re(e, n);
+      return t[r];
+    }
+    function zn(e, n) {
+      const t = [
+        "ONE_LEVEL",
+        "MIPMAP_LEVELS",
+        "RIPMAP_LEVELS"
+      ], r = [
+        "ROUND_DOWN",
+        "ROUND_UP"
+      ], l = oe(e, n), o = oe(e, n), a = Re(e, n);
+      return {
+        xSize: l,
+        ySize: o,
+        levelMode: t[a & 15],
+        roundingMode: r[a >> 4]
+      };
+    }
+    function Gn(e, n) {
+      const t = Q(e, n), r = Q(e, n);
+      return [t, r];
+    }
+    function Yn(e, n) {
+      const t = Q(e, n), r = Q(e, n), l = Q(e, n);
+      return [t, r, l];
+    }
+    function Wn(e, n, t, r, l) {
+      if (r === "string" || r === "stringvector" || r === "iccProfile")
+        return Mn(n, t, l);
+      if (r === "chlist")
+        return Fn(e, n, t, l);
+      if (r === "chromaticities")
+        return Bn(e, t);
+      if (r === "compression")
+        return Ln(e, t);
+      if (r === "box2i")
+        return Pn(e, t);
+      if (r === "envmap")
+        return Hn(e, t);
+      if (r === "tiledesc")
+        return zn(e, t);
+      if (r === "lineOrder")
+        return Zn(e, t);
+      if (r === "float")
+        return Q(e, t);
+      if (r === "v2f")
+        return Gn(e, t);
+      if (r === "v3f")
+        return Yn(e, t);
+      if (r === "int")
+        return re(e, t);
+      if (r === "rational")
+        return On(e, t);
+      if (r === "timecode")
+        return xn(e, t);
+      if (r === "preview")
+        return t.value += l, "skipped";
+      t.value += l;
+    }
+    function Xn(e, n) {
+      const t = Math.log2(e);
+      return n == "ROUND_DOWN" ? Math.floor(t) : Math.ceil(t);
+    }
+    function Kn(e, n, t) {
+      let r = 0;
+      switch (e.levelMode) {
+        case "ONE_LEVEL":
+          r = 1;
+          break;
+        case "MIPMAP_LEVELS":
+          r = Xn(Math.max(n, t), e.roundingMode) + 1;
+          break;
+        case "RIPMAP_LEVELS":
+          throw new Error("THREE.EXRLoader: RIPMAP_LEVELS tiles currently unsupported.");
+      }
+      return r;
+    }
+    function an(e, n, t, r) {
+      const l = new Array(e);
+      for (let o = 0; o < e; o++) {
+        const a = 1 << o;
+        let f = n / a | 0;
+        r == "ROUND_UP" && f * a < n && (f += 1);
+        const u = Math.max(f, 1);
+        l[o] = (u + t - 1) / t | 0;
+      }
+      return l;
+    }
+    function qn() {
+      const e = this, n = e.offset, t = { value: 0 };
+      for (let r = 0; r < e.tileCount; r++) {
+        const l = re(e.viewer, n), o = re(e.viewer, n);
+        n.value += 8, e.size = oe(e.viewer, n);
+        const a = l * e.blockWidth, f = o * e.blockHeight;
+        e.columns = a + e.blockWidth > e.width ? e.width - a : e.blockWidth, e.lines = f + e.blockHeight > e.height ? e.height - f : e.blockHeight;
+        const u = e.columns * e.totalBytes, s = e.size < e.lines * u ? e.uncompress(e) : Je(e);
+        n.value += e.size;
+        for (let m = 0; m < e.lines; m++) {
+          const v = m * e.columns * e.totalBytes;
+          for (let w = 0; w < e.inputChannels.length; w++) {
+            const I = xe.channels[w].name, E = e.channelByteOffsets[I] * e.columns, _ = e.decodeChannels[I];
+            if (_ === void 0) continue;
+            t.value = v + E;
+            const d = (e.height - (1 + f + m)) * e.outLineWidth;
+            for (let B = 0; B < e.columns; B++) {
+              const Y = d + (B + a) * e.outputChannels + _;
+              e.byteArray[Y] = e.getter(s, t);
+            }
+          }
+        }
+      }
+    }
+    function $n() {
+      const e = this, n = e.offset, t = { value: 0 };
+      for (let r = 0; r < e.height / e.blockHeight; r++) {
+        const l = re(e.viewer, n) - xe.dataWindow.yMin;
+        e.size = oe(e.viewer, n), e.lines = l + e.blockHeight > e.height ? e.height - l : e.blockHeight;
+        const o = e.columns * e.totalBytes, f = e.size < e.lines * o ? e.uncompress(e) : Je(e);
+        n.value += e.size;
+        for (let u = 0; u < e.blockHeight; u++) {
+          const c = r * e.blockHeight, s = u + e.scanOrder(c);
+          if (s >= e.height) continue;
+          const m = u * o, v = (e.height - 1 - s) * e.outLineWidth;
+          for (let w = 0; w < e.inputChannels.length; w++) {
+            const I = xe.channels[w].name, E = e.channelByteOffsets[I] * e.columns, _ = e.decodeChannels[I];
+            if (_ !== void 0) {
+              t.value = m + E;
+              for (let d = 0; d < e.columns; d++) {
+                const B = v + d * e.outputChannels + _;
+                e.byteArray[B] = e.getter(f, t);
+              }
+            }
+          }
+        }
+      }
+    }
+    function Vn(e, n, t) {
+      const r = {};
+      if (e.getUint32(0, !0) != 20000630)
+        throw new Error("THREE.EXRLoader: Provided file doesn't appear to be in OpenEXR format.");
+      r.version = e.getUint8(4);
+      const l = e.getUint8(5);
+      r.spec = {
+        singleTile: !!(l & 2),
+        longName: !!(l & 4),
+        deepFormat: !!(l & 8),
+        multiPart: !!(l & 16)
+      }, t.value = 8;
+      let o = !0;
+      for (; o; ) {
+        const a = Xe(n, t);
+        if (a === "")
+          o = !1;
+        else {
+          const f = Xe(n, t), u = oe(e, t), c = Wn(e, n, t, f, u);
+          c === void 0 ? console.warn(`THREE.EXRLoader: Skipped unknown header attribute type '${f}'.`) : r[a] = c;
+        }
+      }
+      if ((l & -7) != 0)
+        throw console.error("THREE.EXRHeader:", r), new Error("THREE.EXRLoader: Provided file is currently unsupported.");
+      return r;
+    }
+    function Jn(e, n, t, r, l) {
+      const o = {
+        size: 0,
+        viewer: n,
+        array: t,
+        offset: r,
+        width: e.dataWindow.xMax - e.dataWindow.xMin + 1,
+        height: e.dataWindow.yMax - e.dataWindow.yMin + 1,
+        inputChannels: e.channels,
+        channelByteOffsets: {},
+        scanOrder: null,
+        totalBytes: null,
+        columns: null,
+        lines: null,
+        type: null,
+        uncompress: null,
+        getter: null,
+        format: null,
+        colorSpace: tn
+      };
+      switch (e.compression) {
+        case "NO_COMPRESSION":
+          o.blockHeight = 1, o.uncompress = Je;
+          break;
+        case "RLE_COMPRESSION":
+          o.blockHeight = 1, o.uncompress = Tn;
+          break;
+        case "ZIPS_COMPRESSION":
+          o.blockHeight = 1, o.uncompress = Qe;
+          break;
+        case "ZIP_COMPRESSION":
+          o.blockHeight = 16, o.uncompress = Qe;
+          break;
+        case "PIZ_COMPRESSION":
+          o.blockHeight = 32, o.uncompress = Un;
+          break;
+        case "PXR24_COMPRESSION":
+          o.blockHeight = 16, o.uncompress = Nn;
+          break;
+        case "DWAA_COMPRESSION":
+          o.blockHeight = 32, o.uncompress = sn;
+          break;
+        case "DWAB_COMPRESSION":
+          o.blockHeight = 256, o.uncompress = sn;
+          break;
+        default:
+          throw new Error("EXRLoader.parse: " + e.compression + " is unsupported");
+      }
+      const a = {};
+      for (const s of e.channels)
+        switch (s.name) {
+          case "Y":
+          case "R":
+          case "G":
+          case "B":
+          case "A":
+            a[s.name] = !0, o.type = s.pixelType;
+        }
+      let f = !1;
+      if (a.R && a.G && a.B)
+        f = !a.A, o.outputChannels = 4, o.decodeChannels = { R: 0, G: 1, B: 2, A: 3 };
+      else if (a.Y)
+        o.outputChannels = 1, o.decodeChannels = { Y: 0 };
+      else
+        throw new Error("EXRLoader.parse: file contains unsupported data channels.");
+      if (o.type == 1)
+        switch (l) {
+          case Be:
+            o.getter = Dn;
+            break;
+          case Te:
+            o.getter = Ze;
+            break;
+        }
+      else if (o.type == 2)
+        switch (l) {
+          case Be:
+            o.getter = Q;
+            break;
+          case Te:
+            o.getter = kn;
+        }
+      else
+        throw new Error("EXRLoader.parse: unsupported pixelType " + o.type + " for " + e.compression + ".");
+      o.columns = o.width;
+      const u = o.width * o.height * o.outputChannels;
+      switch (l) {
+        case Be:
+          o.byteArray = new Float32Array(u), f && o.byteArray.fill(1, 0, u);
+          break;
+        case Te:
+          o.byteArray = new Uint16Array(u), f && o.byteArray.fill(15360, 0, u);
+          break;
+        default:
+          console.error("THREE.EXRLoader: unsupported type: ", l);
+          break;
+      }
+      let c = 0;
+      for (const s of e.channels)
+        o.decodeChannels[s.name] !== void 0 && (o.channelByteOffsets[s.name] = c), c += s.pixelType * 2;
+      if (o.totalBytes = c, o.outLineWidth = o.width * o.outputChannels, e.lineOrder === "INCREASING_Y" ? o.scanOrder = (s) => s : o.scanOrder = (s) => o.height - 1 - s, o.outputChannels == 4 ? (o.format = jn, o.colorSpace = tn) : (o.format = et, o.colorSpace = nt), e.spec.singleTile) {
+        o.blockHeight = e.tiles.ySize, o.blockWidth = e.tiles.xSize;
+        const s = Kn(e.tiles, o.width, o.height), m = an(s, o.width, e.tiles.xSize, e.tiles.roundingMode), v = an(s, o.height, e.tiles.ySize, e.tiles.roundingMode);
+        o.tileCount = m[0] * v[0];
+        for (let w = 0; w < s; w++)
+          for (let I = 0; I < v[w]; I++)
+            for (let E = 0; E < m[w]; E++)
+              ne(n, r);
+        o.decode = qn.bind(o);
+      } else {
+        o.blockWidth = o.width;
+        const s = Math.ceil(o.height / o.blockHeight);
+        for (let m = 0; m < s; m++)
+          ne(n, r);
+        o.decode = $n.bind(o);
+      }
+      return o;
+    }
+    const un = { value: 0 }, hn = new DataView(h), Qn = new Uint8Array(h), xe = Vn(hn, h, un), ke = Jn(xe, hn, Qn, un, this.type);
+    return ke.decode(), {
+      header: xe,
+      width: ke.width,
+      height: ke.height,
+      data: ke.byteArray,
+      format: ke.format,
+      colorSpace: ke.colorSpace,
+      type: this.type
+    };
+  }
+  /**
+   * Sets the texture type.
+   *
+   * @param {(HalfFloatType|FloatType)} value - The texture type to set.
+   * @return {RGBMLoader} A reference to this loader.
+   */
+  setDataType(h) {
+    return this.type = h, this;
+  }
+  load(h, p, S, y) {
+    function D(b, V) {
+      b.colorSpace = V.colorSpace, b.minFilter = $e, b.magFilter = $e, b.generateMipmaps = !1, b.flipY = !1, p && p(b, V);
+    }
+    return super.load(h, D, S, y);
+  }
+}
+class St extends fn {
+  /**
+   * Constructs a new RGBE loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(h) {
+    super(h), this.type = Te;
+  }
+  /**
+   * Parses the given RGBE texture data.
+   *
+   * @param {ArrayBuffer} buffer - The raw texture data.
+   * @return {DataTextureLoader~TexData} An object representing the parsed texture data.
+   */
+  parse(h) {
+    const b = function(C, U) {
+      switch (C) {
+        case 1:
+          throw new Error("THREE.RGBELoader: Read Error: " + (U || ""));
+        case 2:
+          throw new Error("THREE.RGBELoader: Write Error: " + (U || ""));
+        case 3:
+          throw new Error("THREE.RGBELoader: Bad File Format: " + (U || ""));
+        default:
+        case 4:
+          throw new Error("THREE.RGBELoader: Memory Error: " + (U || ""));
+      }
+    }, se = `
+`, R = function(C, U, x) {
+      U = U || 1024;
+      let O = C.pos, Z = -1, A = 0, G = "", N = String.fromCharCode.apply(null, new Uint16Array(C.subarray(O, O + 128)));
+      for (; 0 > (Z = N.indexOf(se)) && A < U && O < C.byteLength; )
+        G += N, A += N.length, O += 128, N += String.fromCharCode.apply(null, new Uint16Array(C.subarray(O, O + 128)));
+      return -1 < Z ? (C.pos += A + Z + 1, G + N.slice(0, Z)) : !1;
+    }, L = function(C) {
+      const U = /^#\?(\S+)/, x = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/, T = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/, O = /^\s*FORMAT=(\S+)\s*$/, Z = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/, A = {
+        valid: 0,
+        /* indicate which fields are valid */
+        string: "",
+        /* the actual header string */
+        comments: "",
+        /* comments found in header */
+        programtype: "RGBE",
+        /* listed at beginning of file to identify it after "#?". defaults to "RGBE" */
+        format: "",
+        /* RGBE format, default 32-bit_rle_rgbe */
+        gamma: 1,
+        /* image has already been gamma corrected with given gamma. defaults to 1.0 (no correction) */
+        exposure: 1,
+        /* a value of 1.0 in an image corresponds to <exposure> watts/steradian/m^2. defaults to 1.0 */
+        width: 0,
+        height: 0
+        /* image dimensions, width/height */
+      };
+      let G, N;
+      for ((C.pos >= C.byteLength || !(G = R(C))) && b(1, "no header found"), (N = G.match(U)) || b(3, "bad initial token"), A.valid |= 1, A.programtype = N[1], A.string += G + `
+`; G = R(C), G !== !1; ) {
+        if (A.string += G + `
+`, G.charAt(0) === "#") {
+          A.comments += G + `
+`;
+          continue;
+        }
+        if ((N = G.match(x)) && (A.gamma = parseFloat(N[1])), (N = G.match(T)) && (A.exposure = parseFloat(N[1])), (N = G.match(O)) && (A.valid |= 2, A.format = N[1]), (N = G.match(Z)) && (A.valid |= 4, A.height = parseInt(N[1], 10), A.width = parseInt(N[2], 10)), A.valid & 2 && A.valid & 4) break;
+      }
+      return A.valid & 2 || b(3, "missing format specifier"), A.valid & 4 || b(3, "missing image size specifier"), A;
+    }, he = function(C, U, x) {
+      const T = U;
+      if (
+        // run length encoding is not allowed so read flat
+        T < 8 || T > 32767 || // this file is not run length encoded
+        C[0] !== 2 || C[1] !== 2 || C[2] & 128
+      )
+        return new Uint8Array(C);
+      T !== (C[2] << 8 | C[3]) && b(3, "wrong scanline width");
+      const O = new Uint8Array(4 * U * x);
+      O.length || b(4, "unable to allocate buffer space");
+      let Z = 0, A = 0;
+      const G = 4 * T, N = new Uint8Array(4), ee = new Uint8Array(G);
+      let be = x;
+      for (; be > 0 && A < C.byteLength; ) {
+        A + 4 > C.byteLength && b(1), N[0] = C[A++], N[1] = C[A++], N[2] = C[A++], N[3] = C[A++], (N[0] != 2 || N[1] != 2 || (N[2] << 8 | N[3]) != T) && b(3, "bad rgbe scanline format");
+        let J = 0, X;
+        for (; J < G && A < C.byteLength; ) {
+          X = C[A++];
+          const W = X > 128;
+          if (W && (X -= 128), (X === 0 || J + X > G) && b(3, "bad scanline data"), W) {
+            const K = C[A++];
+            for (let ge = 0; ge < X; ge++)
+              ee[J++] = K;
+          } else
+            ee.set(C.subarray(A, A + X), J), J += X, A += X;
+        }
+        const Oe = T;
+        for (let W = 0; W < Oe; W++) {
+          let K = 0;
+          O[Z] = ee[W + K], K += T, O[Z + 1] = ee[W + K], K += T, O[Z + 2] = ee[W + K], K += T, O[Z + 3] = ee[W + K], Z += 4;
+        }
+        be--;
+      }
+      return O;
+    }, Ne = function(C, U, x, T) {
+      const O = C[U + 3], Z = Math.pow(2, O - 128) / 255;
+      x[T + 0] = C[U + 0] * Z, x[T + 1] = C[U + 1] * Z, x[T + 2] = C[U + 2] * Z, x[T + 3] = 1;
+    }, ye = function(C, U, x, T) {
+      const O = C[U + 3], Z = Math.pow(2, O - 128) / 255;
+      x[T + 0] = De.toHalfFloat(Math.min(C[U + 0] * Z, 65504)), x[T + 1] = De.toHalfFloat(Math.min(C[U + 1] * Z, 65504)), x[T + 2] = De.toHalfFloat(Math.min(C[U + 2] * Z, 65504)), x[T + 3] = De.toHalfFloat(1);
+    }, ce = new Uint8Array(h);
+    ce.pos = 0;
+    const pe = L(ce), Me = pe.width, j = pe.height, Ee = he(ce.subarray(ce.pos), Me, j);
+    let Ie, Ce, fe;
+    switch (this.type) {
+      case Be:
+        fe = Ee.length / 4;
+        const C = new Float32Array(fe * 4);
+        for (let x = 0; x < fe; x++)
+          Ne(Ee, x * 4, C, x * 4);
+        Ie = C, Ce = Be;
+        break;
+      case Te:
+        fe = Ee.length / 4;
+        const U = new Uint16Array(fe * 4);
+        for (let x = 0; x < fe; x++)
+          ye(Ee, x * 4, U, x * 4);
+        Ie = U, Ce = Te;
+        break;
+      default:
+        throw new Error("THREE.RGBELoader: Unsupported type: " + this.type);
+    }
+    return {
+      width: Me,
+      height: j,
+      data: Ie,
+      header: pe.string,
+      gamma: pe.gamma,
+      exposure: pe.exposure,
+      type: Ce
+    };
+  }
+  /**
+   * Sets the texture type.
+   *
+   * @param {(HalfFloatType|FloatType)} value - The texture type to set.
+   * @return {RGBELoader} A reference to this loader.
+   */
+  setDataType(h) {
+    return this.type = h, this;
+  }
+  load(h, p, S, y) {
+    function D(b, V) {
+      switch (b.type) {
+        case Be:
+        case Te:
+          b.colorSpace = tn, b.minFilter = $e, b.magFilter = $e, b.generateMipmaps = !1, b.flipY = !0;
+          break;
+      }
+      p && p(b, V);
+    }
+    return super.load(h, D, S, y);
+  }
+}
+function bt(i, h = [0.3, 0.3, 0.3]) {
+  const p = document.querySelector(`#${i}`);
+  if (!p) {
+    console.log(" 获取 infoPlane 元素失败 (id) =====> :", i);
+    return;
+  }
+  const S = p.cloneNode(!0);
+  S.style.display = "block";
+  const y = new pn(S);
+  return y.visible = !1, y.scale.set(...h), y;
+}
+function dt(i, h) {
+  const p = _t(i);
+  p.style.display = "block";
+  const S = new pn(p);
+  return S.visible = !1, S.scale.set(h, h, h), S;
+}
+const _t = (i) => {
+  const h = document.createElement("div");
+  h.style.cssText = `
+    border-radius: 50px;
+    border: 2px solid rgba(255, 255, 255, 0.5);
+    background-color: rgba(15, 20, 22, 0.562);
+    justify-content: flex-start;
+    align-items: center;
+    padding: 20px 30px;
+    display: flex;
+    transform-origin: center 0;`;
+  const p = document.createElement("span");
+  return p.style.cssText = `
+      font-size: 40px;
+      line-height: 1;
+      white-space: nowrap;
+      color: #fff;
+      font-weight: 700;
+    `, p.innerText = i, h.appendChild(p), h;
+}, Rt = (i, h) => {
+  const p = {};
+  i.forEach((D) => {
+    let b = D.parent;
+    for (; b; )
+      p[b.uuid] ? p[b.uuid]++ : p[b.uuid] = 1, b = b.parent;
+  });
+  let S = null, y = 0;
+  for (const D in p)
+    p[D] > y && (y = p[D], S = h.getObjectByProperty("uuid", D));
+  return S;
+}, At = (i, h = { timeout: 2e3 }) => typeof requestIdleCallback < "u" ? requestIdleCallback(i, h) : setTimeout(i, 1), Tt = (i) => {
+  typeof cancelIdleCallback < "u" ? cancelIdleCallback(i) : clearTimeout(i);
+}, Ut = (i, h = 16) => {
+  let p = !1;
+  return function(...S) {
+    p || (i.apply(this, S), p = !0, setTimeout(() => p = !1, h));
+  };
+}, Nt = (i, h, p = 10) => new Promise((S) => {
+  let y = 0;
+  const D = () => {
+    const b = Math.min(y + p, i.length);
+    for (; y < b; y++)
+      h(i[y], y);
+    y < i.length ? requestAnimationFrame(D) : S();
+  };
+  D();
+}), nn = {};
+async function Mt(i, h) {
+  if (!h) return;
+  if (nn[h]) {
+    const S = nn[h];
+    i.environment = S;
+    return;
+  }
+  let p = _n(h);
+  return new Promise((S, y) => {
+    p.load(h, S, void 0, y);
+  }).then((S) => {
+    S.mapping = tt, i.environment = S, nn[h] = S;
+  }).catch((S) => {
+    console.log("  =====> e:", S);
+  });
+}
+async function Ot(i) {
+  let h = _n(i);
+  return new Promise((p, S) => {
+    h.load(i, p, void 0, S);
+  });
+}
+function _n(i) {
+  return i.split(".").pop() === "exr" ? new vt() : new St();
+}
+const xt = (i, h, p) => {
+  if (i.userData && i.userData[h] === p) return i;
+  let S = !1, y = null;
+  return i.traverse((D) => {
+    S || D.userData && D.userData[h] === p && (y = D, S = !0);
+  }), y;
+}, yt = (i, h, p) => i ? i.userData && i.userData[h] === p ? i : yt(i.parent, h, p) : null;
+export {
+  Ot as I,
+  dt as a,
+  Tt as b,
+  bt as c,
+  xt as d,
+  yt as e,
+  Rt as g,
+  Mt as i,
+  Nt as p,
+  At as r,
+  Ut as t
+};