@ridp/threejs 1.3.2 → 1.4.0

package/dist/ImageLoader-DXx88iwh.js

@@ -0,0 +1,1444 @@
+import { t as pn } from "./PredictiveLoader--_3bEnce.js";
+import { DataTextureLoader as fn, HalfFloatType as Ue, FloatType as Be, RGBAFormat as jn, LinearSRGBColorSpace as tn, RedFormat as et, NoColorSpace as nt, LinearFilter as qe, DataUtils as Fe, 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, De = Uint16Array, rt = Int32Array, wn = 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
+]), En = 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]), mn = function(h, u) {
+  for (var w = new De(31), _ = 0; _ < 31; ++_)
+    w[_] = u += 1 << h[_ - 1];
+  for (var I = new rt(w[30]), _ = 1; _ < 30; ++_)
+    for (var W = w[_]; W < w[_ + 1]; ++W)
+      I[W] = W - w[_] << 5 | _;
+  return { b: w, r: I };
+}, gn = mn(wn, 2), vn = gn.b, lt = gn.r;
+vn[28] = 258, lt[258] = 28;
+var it = mn(En, 0), ct = it.b, rn = new De(32768);
+for (var H = 0; H < 32768; ++H) {
+  var de = (H & 43690) >> 1 | (H & 21845) << 1;
+  de = (de & 52428) >> 2 | (de & 13107) << 2, de = (de & 61680) >> 4 | (de & 3855) << 4, rn[H] = ((de & 65280) >> 8 | (de & 255) << 8) >> 1;
+}
+var ze = function(h, u, w) {
+  for (var _ = h.length, I = 0, W = new De(u); I < _; ++I)
+    h[I] && ++W[h[I] - 1];
+  var d = new De(u);
+  for (I = 1; I < u; ++I)
+    d[I] = d[I - 1] + W[I - 1] << 1;
+  var V;
+  if (w) {
+    V = new De(1 << u);
+    var _e = 15 - u;
+    for (I = 0; I < _; ++I)
+      if (h[I])
+        for (var Te = I << 4 | h[I], ce = u - h[I], R = d[h[I] - 1]++ << ce, B = R | (1 << ce) - 1; R <= B; ++R)
+          V[rn[R] >> _e] = Te;
+  } else
+    for (V = new De(_), I = 0; I < _; ++I)
+      h[I] && (V[I] = rn[d[h[I] - 1]++] >> 15 - h[I]);
+  return V;
+}, Ge = new ie(288);
+for (var H = 0; H < 144; ++H)
+  Ge[H] = 8;
+for (var H = 144; H < 256; ++H)
+  Ge[H] = 9;
+for (var H = 256; H < 280; ++H)
+  Ge[H] = 7;
+for (var H = 280; H < 288; ++H)
+  Ge[H] = 8;
+var Sn = new ie(32);
+for (var H = 0; H < 32; ++H)
+  Sn[H] = 5;
+var st = /* @__PURE__ */ ze(Ge, 9, 1), at = /* @__PURE__ */ ze(Sn, 5, 1), je = function(h) {
+  for (var u = h[0], w = 1; w < h.length; ++w)
+    h[w] > u && (u = h[w]);
+  return u;
+}, ae = function(h, u, w) {
+  var _ = u / 8 | 0;
+  return (h[_] | h[_ + 1] << 8) >> (u & 7) & w;
+}, en = function(h, u) {
+  var w = u / 8 | 0;
+  return (h[w] | h[w + 1] << 8 | h[w + 2] << 16) >> (u & 7);
+}, ut = function(h) {
+  return (h + 7) / 8 | 0;
+}, ht = function(h, u, w) {
+  return (w == null || w > h.length) && (w = h.length), new ie(h.subarray(u, w));
+}, 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(h, u, w) {
+  var _ = new Error(u || pt[h]);
+  if (_.code = h, Error.captureStackTrace && Error.captureStackTrace(_, ue), !w)
+    throw _;
+  return _;
+}, ft = function(h, u, w, _) {
+  var I = h.length, W = 0;
+  if (!I || u.f && !u.l)
+    return w || new ie(0);
+  var d = !w, V = d || u.i != 2, _e = u.i;
+  d && (w = new ie(I * 3));
+  var Te = function(Le) {
+    var We = w.length;
+    if (Le > We) {
+      var Pe = new ie(Math.max(We * 2, Le));
+      Pe.set(w), w = Pe;
+    }
+  }, ce = u.f || 0, R = u.p || 0, B = u.b || 0, he = u.l, Ne = u.d, ye = u.m, se = u.n, pe = I * 8;
+  do {
+    if (!he) {
+      ce = ae(h, R, 1);
+      var Me = ae(h, R + 1, 3);
+      if (R += 3, Me)
+        if (Me == 1)
+          he = st, Ne = at, ye = 9, se = 5;
+        else if (Me == 2) {
+          var Ce = ae(h, R, 31) + 257, fe = ae(h, R + 10, 15) + 4, C = Ce + ae(h, R + 5, 31) + 1;
+          R += 14;
+          for (var T = new ie(C), x = new ie(19), U = 0; U < fe; ++U)
+            x[ot[U]] = ae(h, R + U * 3, 7);
+          R += fe * 3;
+          for (var O = je(x), P = (1 << O) - 1, A = ze(x, O, 1), U = 0; U < C; ) {
+            var z = A[ae(h, R, P)];
+            R += z & 15;
+            var j = z >> 4;
+            if (j < 16)
+              T[U++] = j;
+            else {
+              var N = 0, ee = 0;
+              for (j == 16 ? (ee = 3 + ae(h, R, 3), R += 2, N = T[U - 1]) : j == 17 ? (ee = 3 + ae(h, R, 7), R += 3) : j == 18 && (ee = 11 + ae(h, R, 127), R += 7); ee--; )
+                T[U++] = N;
+            }
+          }
+          var be = T.subarray(0, Ce), J = T.subarray(Ce);
+          ye = je(be), se = je(J), he = ze(be, ye, 1), Ne = ze(J, se, 1);
+        } else
+          ue(1);
+      else {
+        var j = ut(R) + 4, me = h[j - 4] | h[j - 3] << 8, Ie = j + me;
+        if (Ie > I) {
+          _e && ue(0);
+          break;
+        }
+        V && Te(B + me), w.set(h.subarray(j, Ie), B), u.b = B += me, u.p = R = Ie * 8, u.f = ce;
+        continue;
+      }
+      if (R > pe) {
+        _e && ue(0);
+        break;
+      }
+    }
+    V && Te(B + 131072);
+    for (var X = (1 << ye) - 1, Oe = (1 << se) - 1, Y = R; ; Y = R) {
+      var N = he[en(h, R) & X], K = N >> 4;
+      if (R += N & 15, R > pe) {
+        _e && ue(0);
+        break;
+      }
+      if (N || ue(2), K < 256)
+        w[B++] = K;
+      else if (K == 256) {
+        Y = R, he = null;
+        break;
+      } else {
+        var ge = K - 254;
+        if (K > 264) {
+          var U = K - 257, Re = wn[U];
+          ge = ae(h, R, (1 << Re) - 1) + vn[U], R += Re;
+        }
+        var F = Ne[en(h, R) & Oe], we = F >> 4;
+        F || ue(3), R += F & 15;
+        var J = ct[we];
+        if (we > 3) {
+          var Re = En[we];
+          J += en(h, R) & (1 << Re) - 1, R += Re;
+        }
+        if (R > pe) {
+          _e && ue(0);
+          break;
+        }
+        V && Te(B + 131072);
+        var ve = B + ge;
+        if (B < J) {
+          var Ye = W - J, Ve = Math.min(J, ve);
+          for (Ye + B < 0 && ue(3); B < Ve; ++B)
+            w[B] = _[Ye + B];
+        }
+        for (; B < ve; ++B)
+          w[B] = w[B - J];
+      }
+    }
+    u.l = he, u.p = Y, u.b = B, u.f = ce, he && (ce = 1, u.m = ye, u.d = Ne, u.n = se);
+  } while (!ce);
+  return B != w.length && d ? ht(w, 0, B) : w.subarray(0, B);
+}, wt = /* @__PURE__ */ new ie(0), Et = function(h, u) {
+  return ((h[0] & 15) != 8 || h[0] >> 4 > 7 || (h[0] << 8 | h[1]) % 31) && ue(6, "invalid zlib data"), (h[1] >> 5 & 1) == 1 && ue(6, "invalid zlib data: " + (h[1] & 32 ? "need" : "unexpected") + " dictionary"), (h[1] >> 3 & 4) + 2;
+};
+function $e(h, u) {
+  return ft(h.subarray(Et(h), -4), { i: 2 }, u, u);
+}
+var mt = typeof TextDecoder < "u" && /* @__PURE__ */ new TextDecoder(), gt = 0;
+try {
+  mt.decode(wt, { stream: !0 }), gt = 1;
+} catch {
+}
+class vt extends fn {
+  /**
+   * Constructs a new EXR loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(u) {
+    super(u), this.type = Ue;
+  }
+  /**
+   * Parses the given EXR texture data.
+   *
+   * @param {ArrayBuffer} buffer - The raw texture data.
+   * @return {DataTextureLoader~TexData} An object representing the parsed texture data.
+   */
+  parse(u) {
+    const T = 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 U(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 P(e, n, t, r, l) {
+      for (; t < e; )
+        n = n << 8 | sn(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 z(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 s = n;
+      let p = 0, a = 0;
+      for (; r <= l; r++) {
+        if (s.value - n.value > t) return !1;
+        P(6, p, a, e, s);
+        const c = O.l;
+        if (p = O.c, a = O.lc, o[r] = c, c == 63) {
+          if (s.value - n.value > t)
+            throw new Error("Something wrong with hufUnpackEncTable");
+          P(8, p, a, e, s);
+          let i = O.l + 6;
+          if (p = O.c, a = O.lc, r + i > l + 1)
+            throw new Error("Something wrong with hufUnpackEncTable");
+          for (; i--; ) o[r++] = 0;
+          r--;
+        } else if (c >= 59) {
+          let i = c - 59 + 2;
+          if (r + i > l + 1)
+            throw new Error("Something wrong with hufUnpackEncTable");
+          for (; i--; ) o[r++] = 0;
+          r--;
+        }
+      }
+      z(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 s = r[l >> o - 14];
+          if (s.len)
+            throw new Error("Invalid table entry");
+          if (s.lit++, s.p) {
+            const p = s.p;
+            s.p = new Array(s.lit);
+            for (let a = 0; a < s.lit - 1; ++a)
+              s.p[a] = p[a];
+          } else
+            s.p = new Array(1);
+          s.p[s.lit - 1] = n;
+        } else if (o) {
+          let s = 0;
+          for (let p = 1 << 14 - o; p > 0; p--) {
+            const a = r[(l << 14 - o) + s];
+            if (a.len || a.p)
+              throw new Error("Invalid table entry");
+            a.len = o, a.lit = n, s++;
+          }
+        }
+      }
+      return !0;
+    }
+    const X = { c: 0, lc: 0 };
+    function Oe(e, n, t, r) {
+      e = e << 8 | sn(t, r), n += 8, X.c = e, X.lc = n;
+    }
+    const Y = { c: 0, lc: 0 };
+    function K(e, n, t, r, l, o, s, p, a) {
+      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], p.value + c > a)
+          return !1;
+        const i = s[p.value - 1];
+        for (; c-- > 0; )
+          s[p.value++] = i;
+      } else if (p.value < a)
+        s[p.value++] = e;
+      else
+        return !1;
+      Y.c = t, Y.lc = r;
+    }
+    function ge(e) {
+      return e & 65535;
+    }
+    function Re(e) {
+      const n = ge(e);
+      return n > 32767 ? n - 65536 : n;
+    }
+    const F = { a: 0, b: 0 };
+    function we(e, n) {
+      const t = Re(e), l = Re(n), o = t + (l & 1) + (l >> 1), s = o, p = o - l;
+      F.a = s, F.b = p;
+    }
+    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, s) {
+      const p = s < 16384, a = t > l ? l : t;
+      let c = 1, i, f;
+      for (; c <= a; ) c <<= 1;
+      for (c >>= 1, i = c, c >>= 1; c >= 1; ) {
+        f = 0;
+        const v = f + o * (l - i), E = o * c, y = o * i, m = r * c, S = r * i;
+        let b, D, G, te;
+        for (; f <= v; f += y) {
+          let Z = f;
+          const M = f + r * (t - i);
+          for (; Z <= M; Z += S) {
+            const $ = Z + m, le = Z + E, q = le + m;
+            p ? (we(e[Z + n], e[le + n]), b = F.a, G = F.b, we(e[$ + n], e[q + n]), D = F.a, te = F.b, we(b, D), e[Z + n] = F.a, e[$ + n] = F.b, we(G, te), e[le + n] = F.a, e[q + n] = F.b) : (ve(e[Z + n], e[le + n]), b = F.a, G = F.b, ve(e[$ + n], e[q + n]), D = F.a, te = F.b, ve(b, D), e[Z + n] = F.a, e[$ + n] = F.b, ve(G, te), e[le + n] = F.a, e[q + n] = F.b);
+          }
+          if (t & c) {
+            const $ = Z + E;
+            p ? we(e[Z + n], e[$ + n]) : ve(e[Z + n], e[$ + n]), b = F.a, e[$ + n] = F.b, e[Z + n] = b;
+          }
+        }
+        if (l & c) {
+          let Z = f;
+          const M = f + r * (t - i);
+          for (; Z <= M; Z += S) {
+            const $ = Z + m;
+            p ? we(e[Z + n], e[$ + n]) : ve(e[Z + n], e[$ + n]), b = F.a, e[$ + n] = F.b, e[Z + n] = b;
+          }
+        }
+        i = c, c >>= 1;
+      }
+      return f;
+    }
+    function Ve(e, n, t, r, l, o, s, p, a) {
+      let c = 0, i = 0;
+      const f = s, v = Math.trunc(r.value + (l + 7) / 8);
+      for (; r.value < v; )
+        for (Oe(c, i, t, r), c = X.c, i = X.lc; i >= 14; ) {
+          const y = c >> i - 14 & 16383, m = n[y];
+          if (m.len)
+            i -= m.len, K(m.lit, o, c, i, t, r, p, a, f), c = Y.c, i = Y.lc;
+          else {
+            if (!m.p)
+              throw new Error("hufDecode issues");
+            let S;
+            for (S = 0; S < m.lit; S++) {
+              const b = ee(e[m.p[S]]);
+              for (; i < b && r.value < v; )
+                Oe(c, i, t, r), c = X.c, i = X.lc;
+              if (i >= b && be(e[m.p[S]]) == (c >> i - b & (1 << b) - 1)) {
+                i -= b, K(m.p[S], o, c, i, t, r, p, a, f), c = Y.c, i = Y.lc;
+                break;
+              }
+            }
+            if (S == m.lit)
+              throw new Error("hufDecode issues");
+          }
+        }
+      const E = 8 - l & 7;
+      for (c >>= E, i -= E; i > 0; ) {
+        const y = n[c << 14 - i & 16383];
+        if (y.len)
+          i -= y.len, K(y.lit, o, c, i, t, r, p, a, f), c = Y.c, i = Y.lc;
+        else
+          throw new Error("hufDecode issues");
+      }
+      return !0;
+    }
+    function Le(e, n, t, r, l, o) {
+      const s = { value: 0 }, p = t.value, a = oe(n, t), c = oe(n, t);
+      t.value += 4;
+      const i = oe(n, t);
+      if (t.value += 4, a < 0 || a >= 65537 || c < 0 || c >= 65537)
+        throw new Error("Something wrong with HUF_ENCSIZE");
+      const f = new Array(65537), v = new Array(16384);
+      U(v);
+      const E = r - (t.value - p);
+      if (N(e, t, E, a, c, f), i > 8 * (r - (t.value - p)))
+        throw new Error("Something wrong with hufUncompress");
+      J(f, a, c, v), Ve(f, v, e, t, i, c, o, l, s);
+    }
+    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 s = -o;
+          n -= s + 1;
+          for (let p = 0; p < s; p++)
+            t.push(l.getUint8(r++));
+        } else {
+          const s = o;
+          n -= 2;
+          const p = l.getUint8(r++);
+          for (let a = 0; a < s + 1; a++)
+            t.push(p);
+        }
+      }
+      return t;
+    }
+    function yn(e, n, t, r, l, o) {
+      let s = new DataView(o.buffer);
+      const p = t[e.idx[0]].width, a = t[e.idx[0]].height, c = 3, i = Math.floor(p / 8), f = Math.ceil(p / 8), v = Math.ceil(a / 8), E = p - (f - 1) * 8, y = a - (v - 1) * 8, m = { value: 0 }, S = new Array(c), b = new Array(c), D = new Array(c), G = new Array(c), te = new Array(c);
+      for (let M = 0; M < c; ++M)
+        te[M] = n[e.idx[M]], S[M] = M < 1 ? 0 : S[M - 1] + f * v, b[M] = new Float32Array(64), D[M] = new Uint16Array(64), G[M] = new Uint16Array(f * 64);
+      for (let M = 0; M < v; ++M) {
+        let $ = 8;
+        M == v - 1 && ($ = y);
+        let le = 8;
+        for (let k = 0; k < f; ++k) {
+          k == f - 1 && (le = E);
+          for (let L = 0; L < c; ++L)
+            D[L].fill(0), D[L][0] = l[S[L]++], In(m, r, D[L]), Cn(D[L], b[L]), bn(b[L]);
+          Rn(b);
+          for (let L = 0; L < c; ++L)
+            An(b[L], G[L], k * 64);
+        }
+        let q = 0;
+        for (let k = 0; k < c; ++k) {
+          const L = t[e.idx[k]].type;
+          for (let Se = 8 * M; Se < 8 * M + $; ++Se) {
+            q = te[k][Se];
+            for (let He = 0; He < i; ++He) {
+              const Ee = He * 64 + (Se & 7) * 8;
+              s.setUint16(q + 0 * 2 * L, G[k][Ee + 0], !0), s.setUint16(q + 1 * 2 * L, G[k][Ee + 1], !0), s.setUint16(q + 2 * 2 * L, G[k][Ee + 2], !0), s.setUint16(q + 3 * 2 * L, G[k][Ee + 3], !0), s.setUint16(q + 4 * 2 * L, G[k][Ee + 4], !0), s.setUint16(q + 5 * 2 * L, G[k][Ee + 5], !0), s.setUint16(q + 6 * 2 * L, G[k][Ee + 6], !0), s.setUint16(q + 7 * 2 * L, G[k][Ee + 7], !0), q += 8 * 2 * L;
+            }
+          }
+          if (i != f)
+            for (let Se = 8 * M; Se < 8 * M + $; ++Se) {
+              const He = te[k][Se] + 8 * i * 2 * L, Ee = i * 64 + (Se & 7) * 8;
+              for (let Ke = 0; Ke < le; ++Ke)
+                s.setUint16(He + Ke * 2 * L, G[k][Ee + Ke], !0);
+            }
+        }
+      }
+      const Z = new Uint16Array(p);
+      s = new DataView(o.buffer);
+      for (let M = 0; M < c; ++M) {
+        t[e.idx[M]].decoded = !0;
+        const $ = t[e.idx[M]].type;
+        if (t[M].type == 2)
+          for (let le = 0; le < a; ++le) {
+            const q = te[M][le];
+            for (let k = 0; k < p; ++k)
+              Z[k] = s.getUint16(q + k * 2 * $, !0);
+            for (let k = 0; k < p; ++k)
+              s.setFloat32(q + k * 2 * $, g(Z[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), s = 0.5 * Math.cos(3 * 3.14159 / 8), p = 0.5 * Math.cos(7 * 3.14159 / 16), a = new Array(4), c = new Array(4), i = new Array(4), f = new Array(4);
+      for (let v = 0; v < 8; ++v) {
+        const E = v * 8;
+        a[0] = r * e[E + 2], a[1] = s * e[E + 2], a[2] = r * e[E + 6], a[3] = s * e[E + 6], c[0] = t * e[E + 1] + l * e[E + 3] + o * e[E + 5] + p * e[E + 7], c[1] = l * e[E + 1] - p * e[E + 3] - t * e[E + 5] - o * e[E + 7], c[2] = o * e[E + 1] - t * e[E + 3] + p * e[E + 5] + l * e[E + 7], c[3] = p * e[E + 1] - o * e[E + 3] + l * e[E + 5] - t * e[E + 7], i[0] = n * (e[E + 0] + e[E + 4]), i[3] = n * (e[E + 0] - e[E + 4]), i[1] = a[0] + a[3], i[2] = a[1] - a[2], f[0] = i[0] + i[1], f[1] = i[3] + i[2], f[2] = i[3] - i[2], f[3] = i[0] - i[1], e[E + 0] = f[0] + c[0], e[E + 1] = f[1] + c[1], e[E + 2] = f[2] + c[2], e[E + 3] = f[3] + c[3], e[E + 4] = f[3] - c[3], e[E + 5] = f[2] - c[2], e[E + 6] = f[1] - c[1], e[E + 7] = f[0] - c[0];
+      }
+      for (let v = 0; v < 8; ++v)
+        a[0] = r * e[16 + v], a[1] = s * e[16 + v], a[2] = r * e[48 + v], a[3] = s * e[48 + v], c[0] = t * e[8 + v] + l * e[24 + v] + o * e[40 + v] + p * e[56 + v], c[1] = l * e[8 + v] - p * e[24 + v] - t * e[40 + v] - o * e[56 + v], c[2] = o * e[8 + v] - t * e[24 + v] + p * e[40 + v] + l * e[56 + v], c[3] = p * e[8 + v] - o * e[24 + v] + l * e[40 + v] - t * e[56 + v], i[0] = n * (e[v] + e[32 + v]), i[3] = n * (e[v] - e[32 + v]), i[1] = a[0] + a[3], i[2] = a[1] - a[2], f[0] = i[0] + i[1], f[1] = i[3] + i[2], f[2] = i[3] - i[2], f[3] = i[0] - i[1], e[0 + v] = f[0] + c[0], e[8 + v] = f[1] + c[1], e[16 + v] = f[2] + c[2], e[24 + v] = f[3] + c[3], e[32 + v] = f[3] - c[3], e[40 + v] = f[2] - c[2], e[48 + v] = f[1] - c[1], e[56 + v] = f[0] - c[0];
+    }
+    function Rn(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 An(e, n, t) {
+      for (let r = 0; r < 64; ++r)
+        n[t + r] = Fe.toHalfFloat(dn(e[r]));
+    }
+    function dn(e) {
+      return e <= 1 ? Math.sign(e) * Math.pow(Math.abs(e), 2.2) : Math.sign(e) * Math.pow(T, Math.abs(e) - 1);
+    }
+    function Je(e) {
+      return new DataView(e.array.buffer, e.offset.value, e.size);
+    }
+    function Un(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 = $e(n), r = new Uint8Array(t.length);
+      return Pe(t), on(t, r), new DataView(r.buffer);
+    }
+    function Tn(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 s = new Array(e.inputChannels.length);
+      for (let y = 0, m = e.inputChannels.length; y < m; y++)
+        s[y] = {}, s[y].start = o, s[y].end = s[y].start, s[y].nx = e.columns, s[y].ny = e.lines, s[y].size = e.type, o += s[y].nx * s[y].ny * s[y].size;
+      const p = Ze(n, t), a = Ze(n, t);
+      if (a >= 8192)
+        throw new Error("Something is wrong with PIZ_COMPRESSION BITMAP_SIZE");
+      if (p <= a)
+        for (let y = 0; y < a - p + 1; y++)
+          l[y + p] = Ae(n, t);
+      const c = new Uint16Array(65536), i = x(l, c), f = oe(n, t);
+      Le(e.array, n, t, f, r, o);
+      for (let y = 0; y < e.inputChannels.length; ++y) {
+        const m = s[y];
+        for (let S = 0; S < s[y].size; ++S)
+          Ye(
+            r,
+            m.start + S,
+            m.nx,
+            m.size,
+            m.ny,
+            m.nx * m.size,
+            i
+          );
+      }
+      We(c, r, o);
+      let v = 0;
+      const E = new Uint8Array(r.buffer.byteLength);
+      for (let y = 0; y < e.lines; y++)
+        for (let m = 0; m < e.inputChannels.length; m++) {
+          const S = s[m], b = S.nx * S.size, D = new Uint8Array(r.buffer, S.end * 2, b * 2);
+          E.set(D, v), v += b * 2, S.end += b;
+        }
+      return new DataView(E.buffer);
+    }
+    function Nn(e) {
+      const n = e.array.slice(e.offset.value, e.offset.value + e.size), t = $e(n), r = e.inputChannels.length * e.lines * e.columns * e.totalBytes, l = new ArrayBuffer(r), o = new DataView(l);
+      let s = 0, p = 0;
+      const a = new Array(4);
+      for (let c = 0; c < e.lines; c++)
+        for (let i = 0; i < e.inputChannels.length; i++) {
+          let f = 0;
+          switch (e.inputChannels[i].pixelType) {
+            case 1:
+              a[0] = s, a[1] = a[0] + e.columns, s = a[1] + e.columns;
+              for (let E = 0; E < e.columns; ++E) {
+                const y = t[a[0]++] << 8 | t[a[1]++];
+                f += y, o.setUint16(p, f, !0), p += 2;
+              }
+              break;
+            case 2:
+              a[0] = s, a[1] = a[0] + e.columns, a[2] = a[1] + e.columns, s = a[2] + e.columns;
+              for (let E = 0; E < e.columns; ++E) {
+                const y = t[a[0]++] << 24 | t[a[1]++] << 16 | t[a[2]++] << 8;
+                f += y, o.setUint32(p, f, !0), p += 4;
+              }
+              break;
+          }
+        }
+      return o;
+    }
+    function cn(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 s = Ze(n, t) - 2;
+      for (; s > 0; ) {
+        const m = Xe(n.buffer, t), S = Ae(n, t), b = S >> 2 & 3, D = (S >> 4) - 1, G = new Int8Array([D])[0], te = Ae(n, t);
+        o.push({
+          name: m,
+          index: G,
+          type: te,
+          compression: b
+        }), s -= m.length + 3;
+      }
+      const p = xe.channels, a = new Array(e.inputChannels.length);
+      for (let m = 0; m < e.inputChannels.length; ++m) {
+        const S = a[m] = {}, b = p[m];
+        S.name = b.name, S.compression = 0, S.decoded = !1, S.type = b.pixelType, S.pLinear = b.pLinear, S.width = e.columns, S.height = e.lines;
+      }
+      const c = {
+        idx: new Array(3)
+      };
+      for (let m = 0; m < e.inputChannels.length; ++m) {
+        const S = a[m];
+        for (let b = 0; b < o.length; ++b) {
+          const D = o[b];
+          S.name == D.name && (S.compression = D.compression, D.index >= 0 && (c.idx[D.index] = m), S.offset = m);
+        }
+      }
+      let i, f, v;
+      if (l.acCompressedSize > 0)
+        switch (l.acCompression) {
+          case 0:
+            i = new Uint16Array(l.totalAcUncompressedCount), Le(e.array, n, t, l.acCompressedSize, i, l.totalAcUncompressedCount);
+            break;
+          case 1:
+            const m = e.array.slice(t.value, t.value + l.totalAcUncompressedCount), S = $e(m);
+            i = new Uint16Array(S.buffer), t.value += l.totalAcUncompressedCount;
+            break;
+        }
+      if (l.dcCompressedSize > 0) {
+        const m = {
+          array: e.array,
+          offset: t,
+          size: l.dcCompressedSize
+        };
+        f = new Uint16Array(Qe(m).buffer), t.value += l.dcCompressedSize;
+      }
+      if (l.rleRawSize > 0) {
+        const m = e.array.slice(t.value, t.value + l.rleCompressedSize), S = $e(m);
+        v = ln(S.buffer), t.value += l.rleCompressedSize;
+      }
+      let E = 0;
+      const y = new Array(a.length);
+      for (let m = 0; m < y.length; ++m)
+        y[m] = new Array();
+      for (let m = 0; m < e.lines; ++m)
+        for (let S = 0; S < a.length; ++S)
+          y[S].push(E), E += a[S].width * e.type * 2;
+      yn(c, y, a, i, f, r);
+      for (let m = 0; m < a.length; ++m) {
+        const S = a[m];
+        if (!S.decoded)
+          switch (S.compression) {
+            case 2:
+              let b = 0, D = 0;
+              for (let G = 0; G < e.lines; ++G) {
+                let te = y[m][b];
+                for (let Z = 0; Z < S.width; ++Z) {
+                  for (let M = 0; M < 2 * S.type; ++M)
+                    r[te++] = v[D + M * S.width * S.height];
+                  D++;
+                }
+                b++;
+              }
+              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 sn(e, n) {
+      const t = e[n.value];
+      return n.value = n.value + 1, t;
+    }
+    function Ae(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 Fe.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 Fn(e, n) {
+      return g(Ze(e, n));
+    }
+    function Dn(e, n, t, r) {
+      const l = t.value, o = [];
+      for (; t.value < l + r - 1; ) {
+        const s = Xe(n, t), p = re(e, t), a = Ae(e, t);
+        t.value += 3;
+        const c = re(e, t), i = re(e, t);
+        o.push({
+          name: s,
+          pixelType: p,
+          pLinear: a,
+          xSampling: c,
+          ySampling: i
+        });
+      }
+      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), s = Q(e, n), p = Q(e, n), a = Q(e, n), c = Q(e, n);
+      return { redX: t, redY: r, greenX: l, greenY: o, blueX: s, blueY: p, whiteX: a, 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 = Ae(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 = Ae(e, n);
+      return t[r];
+    }
+    function Hn(e, n) {
+      const t = [
+        "ENVMAP_LATLONG",
+        "ENVMAP_CUBE"
+      ], r = Ae(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), s = Ae(e, n);
+      return {
+        xSize: l,
+        ySize: o,
+        levelMode: t[s & 15],
+        roundingMode: r[s >> 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 Dn(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 s = 1 << o;
+        let p = n / s | 0;
+        r == "ROUND_UP" && p * s < n && (p += 1);
+        const a = Math.max(p, 1);
+        l[o] = (a + t - 1) / t | 0;
+      }
+      return l;
+    }
+    function $n() {
+      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 s = l * e.blockWidth, p = o * e.blockHeight;
+        e.columns = s + e.blockWidth > e.width ? e.width - s : e.blockWidth, e.lines = p + e.blockHeight > e.height ? e.height - p : e.blockHeight;
+        const a = e.columns * e.totalBytes, i = e.size < e.lines * a ? e.uncompress(e) : Je(e);
+        n.value += e.size;
+        for (let f = 0; f < e.lines; f++) {
+          const v = f * e.columns * e.totalBytes;
+          for (let E = 0; E < e.inputChannels.length; E++) {
+            const y = xe.channels[E].name, m = e.channelByteOffsets[y] * e.columns, S = e.decodeChannels[y];
+            if (S === void 0) continue;
+            t.value = v + m;
+            const b = (e.height - (1 + p + f)) * e.outLineWidth;
+            for (let D = 0; D < e.columns; D++) {
+              const G = b + (D + s) * e.outputChannels + S;
+              e.byteArray[G] = e.getter(i, t);
+            }
+          }
+        }
+      }
+    }
+    function qn() {
+      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, p = e.size < e.lines * o ? e.uncompress(e) : Je(e);
+        n.value += e.size;
+        for (let a = 0; a < e.blockHeight; a++) {
+          const c = r * e.blockHeight, i = a + e.scanOrder(c);
+          if (i >= e.height) continue;
+          const f = a * o, v = (e.height - 1 - i) * e.outLineWidth;
+          for (let E = 0; E < e.inputChannels.length; E++) {
+            const y = xe.channels[E].name, m = e.channelByteOffsets[y] * e.columns, S = e.decodeChannels[y];
+            if (S !== void 0) {
+              t.value = f + m;
+              for (let b = 0; b < e.columns; b++) {
+                const D = v + b * e.outputChannels + S;
+                e.byteArray[D] = e.getter(p, 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 s = Xe(n, t);
+        if (s === "")
+          o = !1;
+        else {
+          const p = Xe(n, t), a = oe(e, t), c = Wn(e, n, t, p, a);
+          c === void 0 ? console.warn(`THREE.EXRLoader: Skipped unknown header attribute type '${p}'.`) : r[s] = 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 = Un;
+          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 = Tn;
+          break;
+        case "PXR24_COMPRESSION":
+          o.blockHeight = 16, o.uncompress = Nn;
+          break;
+        case "DWAA_COMPRESSION":
+          o.blockHeight = 32, o.uncompress = cn;
+          break;
+        case "DWAB_COMPRESSION":
+          o.blockHeight = 256, o.uncompress = cn;
+          break;
+        default:
+          throw new Error("EXRLoader.parse: " + e.compression + " is unsupported");
+      }
+      const s = {};
+      for (const i of e.channels)
+        switch (i.name) {
+          case "Y":
+          case "R":
+          case "G":
+          case "B":
+          case "A":
+            s[i.name] = !0, o.type = i.pixelType;
+        }
+      let p = !1;
+      if (s.R && s.G && s.B)
+        p = !s.A, o.outputChannels = 4, o.decodeChannels = { R: 0, G: 1, B: 2, A: 3 };
+      else if (s.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 = Fn;
+            break;
+          case Ue:
+            o.getter = Ze;
+            break;
+        }
+      else if (o.type == 2)
+        switch (l) {
+          case Be:
+            o.getter = Q;
+            break;
+          case Ue:
+            o.getter = kn;
+        }
+      else
+        throw new Error("EXRLoader.parse: unsupported pixelType " + o.type + " for " + e.compression + ".");
+      o.columns = o.width;
+      const a = o.width * o.height * o.outputChannels;
+      switch (l) {
+        case Be:
+          o.byteArray = new Float32Array(a), p && o.byteArray.fill(1, 0, a);
+          break;
+        case Ue:
+          o.byteArray = new Uint16Array(a), p && o.byteArray.fill(15360, 0, a);
+          break;
+        default:
+          console.error("THREE.EXRLoader: unsupported type: ", l);
+          break;
+      }
+      let c = 0;
+      for (const i of e.channels)
+        o.decodeChannels[i.name] !== void 0 && (o.channelByteOffsets[i.name] = c), c += i.pixelType * 2;
+      if (o.totalBytes = c, o.outLineWidth = o.width * o.outputChannels, e.lineOrder === "INCREASING_Y" ? o.scanOrder = (i) => i : o.scanOrder = (i) => o.height - 1 - i, 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 i = Kn(e.tiles, o.width, o.height), f = an(i, o.width, e.tiles.xSize, e.tiles.roundingMode), v = an(i, o.height, e.tiles.ySize, e.tiles.roundingMode);
+        o.tileCount = f[0] * v[0];
+        for (let E = 0; E < i; E++)
+          for (let y = 0; y < v[E]; y++)
+            for (let m = 0; m < f[E]; m++)
+              ne(n, r);
+        o.decode = $n.bind(o);
+      } else {
+        o.blockWidth = o.width;
+        const i = Math.ceil(o.height / o.blockHeight);
+        for (let f = 0; f < i; f++)
+          ne(n, r);
+        o.decode = qn.bind(o);
+      }
+      return o;
+    }
+    const un = { value: 0 }, hn = new DataView(u), Qn = new Uint8Array(u), xe = Vn(hn, u, 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(u) {
+    return this.type = u, this;
+  }
+  load(u, w, _, I) {
+    function W(d, V) {
+      d.colorSpace = V.colorSpace, d.minFilter = qe, d.magFilter = qe, d.generateMipmaps = !1, d.flipY = !1, w && w(d, V);
+    }
+    return super.load(u, W, _, I);
+  }
+}
+class St extends fn {
+  /**
+   * Constructs a new RGBE loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(u) {
+    super(u), this.type = Ue;
+  }
+  /**
+   * Parses the given RGBE texture data.
+   *
+   * @param {ArrayBuffer} buffer - The raw texture data.
+   * @return {DataTextureLoader~TexData} An object representing the parsed texture data.
+   */
+  parse(u) {
+    const d = function(C, T) {
+      switch (C) {
+        case 1:
+          throw new Error("THREE.RGBELoader: Read Error: " + (T || ""));
+        case 2:
+          throw new Error("THREE.RGBELoader: Write Error: " + (T || ""));
+        case 3:
+          throw new Error("THREE.RGBELoader: Bad File Format: " + (T || ""));
+        default:
+        case 4:
+          throw new Error("THREE.RGBELoader: Memory Error: " + (T || ""));
+      }
+    }, ce = `
+`, R = function(C, T, x) {
+      T = T || 1024;
+      let O = C.pos, P = -1, A = 0, z = "", N = String.fromCharCode.apply(null, new Uint16Array(C.subarray(O, O + 128)));
+      for (; 0 > (P = N.indexOf(ce)) && A < T && O < C.byteLength; )
+        z += N, A += N.length, O += 128, N += String.fromCharCode.apply(null, new Uint16Array(C.subarray(O, O + 128)));
+      return -1 < P ? (C.pos += A + P + 1, z + N.slice(0, P)) : !1;
+    }, B = function(C) {
+      const T = /^#\?(\S+)/, x = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/, U = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/, O = /^\s*FORMAT=(\S+)\s*$/, P = /^\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 z, N;
+      for ((C.pos >= C.byteLength || !(z = R(C))) && d(1, "no header found"), (N = z.match(T)) || d(3, "bad initial token"), A.valid |= 1, A.programtype = N[1], A.string += z + `
+`; z = R(C), z !== !1; ) {
+        if (A.string += z + `
+`, z.charAt(0) === "#") {
+          A.comments += z + `
+`;
+          continue;
+        }
+        if ((N = z.match(x)) && (A.gamma = parseFloat(N[1])), (N = z.match(U)) && (A.exposure = parseFloat(N[1])), (N = z.match(O)) && (A.valid |= 2, A.format = N[1]), (N = z.match(P)) && (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 || d(3, "missing format specifier"), A.valid & 4 || d(3, "missing image size specifier"), A;
+    }, he = function(C, T, x) {
+      const U = T;
+      if (
+        // run length encoding is not allowed so read flat
+        U < 8 || U > 32767 || // this file is not run length encoded
+        C[0] !== 2 || C[1] !== 2 || C[2] & 128
+      )
+        return new Uint8Array(C);
+      U !== (C[2] << 8 | C[3]) && d(3, "wrong scanline width");
+      const O = new Uint8Array(4 * T * x);
+      O.length || d(4, "unable to allocate buffer space");
+      let P = 0, A = 0;
+      const z = 4 * U, N = new Uint8Array(4), ee = new Uint8Array(z);
+      let be = x;
+      for (; be > 0 && A < C.byteLength; ) {
+        A + 4 > C.byteLength && d(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]) != U) && d(3, "bad rgbe scanline format");
+        let J = 0, X;
+        for (; J < z && A < C.byteLength; ) {
+          X = C[A++];
+          const Y = X > 128;
+          if (Y && (X -= 128), (X === 0 || J + X > z) && d(3, "bad scanline data"), Y) {
+            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 = U;
+        for (let Y = 0; Y < Oe; Y++) {
+          let K = 0;
+          O[P] = ee[Y + K], K += U, O[P + 1] = ee[Y + K], K += U, O[P + 2] = ee[Y + K], K += U, O[P + 3] = ee[Y + K], P += 4;
+        }
+        be--;
+      }
+      return O;
+    }, Ne = function(C, T, x, U) {
+      const O = C[T + 3], P = Math.pow(2, O - 128) / 255;
+      x[U + 0] = C[T + 0] * P, x[U + 1] = C[T + 1] * P, x[U + 2] = C[T + 2] * P, x[U + 3] = 1;
+    }, ye = function(C, T, x, U) {
+      const O = C[T + 3], P = Math.pow(2, O - 128) / 255;
+      x[U + 0] = Fe.toHalfFloat(Math.min(C[T + 0] * P, 65504)), x[U + 1] = Fe.toHalfFloat(Math.min(C[T + 1] * P, 65504)), x[U + 2] = Fe.toHalfFloat(Math.min(C[T + 2] * P, 65504)), x[U + 3] = Fe.toHalfFloat(1);
+    }, se = new Uint8Array(u);
+    se.pos = 0;
+    const pe = B(se), Me = pe.width, j = pe.height, me = he(se.subarray(se.pos), Me, j);
+    let Ie, Ce, fe;
+    switch (this.type) {
+      case Be:
+        fe = me.length / 4;
+        const C = new Float32Array(fe * 4);
+        for (let x = 0; x < fe; x++)
+          Ne(me, x * 4, C, x * 4);
+        Ie = C, Ce = Be;
+        break;
+      case Ue:
+        fe = me.length / 4;
+        const T = new Uint16Array(fe * 4);
+        for (let x = 0; x < fe; x++)
+          ye(me, x * 4, T, x * 4);
+        Ie = T, Ce = Ue;
+        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(u) {
+    return this.type = u, this;
+  }
+  load(u, w, _, I) {
+    function W(d, V) {
+      switch (d.type) {
+        case Be:
+        case Ue:
+          d.colorSpace = tn, d.minFilter = qe, d.magFilter = qe, d.generateMipmaps = !1, d.flipY = !0;
+          break;
+      }
+      w && w(d, V);
+    }
+    return super.load(u, W, _, I);
+  }
+}
+function Ct(h, u = [0.3, 0.3, 0.3]) {
+  const w = document.querySelector(`#${h}`);
+  if (!w) {
+    console.log(" 获取 infoPlane 元素失败 (id) =====> :", h);
+    return;
+  }
+  const _ = w.cloneNode(!0);
+  _.style.display = "block";
+  const I = new pn(_);
+  return I.visible = !1, I.scale.set(...u), I;
+}
+function bt(h, u) {
+  const w = _t(h);
+  w.style.display = "block";
+  const _ = new pn(w);
+  return _.visible = !1, _.scale.set(u, u, u), _;
+}
+const _t = (h) => {
+  const u = document.createElement("div");
+  u.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 w = document.createElement("span");
+  return w.style.cssText = `
+      font-size: 40px;
+      line-height: 1;
+      white-space: nowrap;
+      color: #fff;
+      font-weight: 700;
+    `, w.innerText = h, u.appendChild(w), u;
+}, Rt = (h, u) => {
+  const w = {};
+  h.forEach((W) => {
+    let d = W.parent;
+    for (; d; )
+      w[d.uuid] ? w[d.uuid]++ : w[d.uuid] = 1, d = d.parent;
+  });
+  let _ = null, I = 0;
+  for (const W in w)
+    w[W] > I && (I = w[W], _ = u.getObjectByProperty("uuid", W));
+  return _;
+}, nn = {};
+async function At(h, u) {
+  if (!u) return;
+  if (nn[u]) {
+    const _ = nn[u];
+    h.environment = _;
+    return;
+  }
+  let w = _n(u);
+  return new Promise((_, I) => {
+    w.load(u, _, void 0, I);
+  }).then((_) => {
+    _.mapping = tt, h.environment = _, nn[u] = _;
+  }).catch((_) => {
+    console.log("  =====> e:", _);
+  });
+}
+async function dt(h) {
+  let u = _n(h);
+  return new Promise((w, _) => {
+    u.load(h, w, void 0, _);
+  });
+}
+function _n(h) {
+  return h.split(".").pop() === "exr" ? new vt() : new St();
+}
+export {
+  dt as I,
+  bt as a,
+  Ct as c,
+  Rt as g,
+  At as i
+};