opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/loaders/EXRLoader.js

@@ -0,0 +1,1834 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../libs/fflate.module.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../libs/fflate.module.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.fflateModule);
+    global.EXRLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, fflate) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.EXRLoader = void 0;
+  fflate = _interopRequireWildcard(fflate);
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  /**
+   * OpenEXR loader currently supports uncompressed, ZIP(S), RLE, PIZ and DWA/B compression.
+   * Supports reading as UnsignedByte, HalfFloat and Float type data texture.
+   *
+   * Referred to the original Industrial Light & Magic OpenEXR implementation and the TinyEXR / Syoyo Fujita
+   * implementation, so I have preserved their copyright notices.
+   */
+  // /*
+  // Copyright (c) 2014 - 2017, Syoyo Fujita
+  // All rights reserved.
+  // Redistribution and use in source and binary forms, with or without
+  // modification, are permitted provided that the following conditions are met:
+  //     * Redistributions of source code must retain the above copyright
+  //       notice, this list of conditions and the following disclaimer.
+  //     * Redistributions in binary form must reproduce the above copyright
+  //       notice, this list of conditions and the following disclaimer in the
+  //       documentation and/or other materials provided with the distribution.
+  //     * Neither the name of the Syoyo Fujita nor the
+  //       names of its contributors may be used to endorse or promote products
+  //       derived from this software without specific prior written permission.
+  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+  // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  // DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  // */
+  // // TinyEXR contains some OpenEXR code, which is licensed under ------------
+  // ///////////////////////////////////////////////////////////////////////////
+  // //
+  // // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+  // // Digital Ltd. LLC
+  // //
+  // // All rights reserved.
+  // //
+  // // Redistribution and use in source and binary forms, with or without
+  // // modification, are permitted provided that the following conditions are
+  // // met:
+  // // *       Redistributions of source code must retain the above copyright
+  // // notice, this list of conditions and the following disclaimer.
+  // // *       Redistributions in binary form must reproduce the above
+  // // copyright notice, this list of conditions and the following disclaimer
+  // // in the documentation and/or other materials provided with the
+  // // distribution.
+  // // *       Neither the name of Industrial Light & Magic nor the names of
+  // // its contributors may be used to endorse or promote products derived
+  // // from this software without specific prior written permission.
+  // //
+  // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  // // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  // // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+  // // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+  // // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+  // // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+  // // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+  // // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+  // // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  // // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  // // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  // //
+  // ///////////////////////////////////////////////////////////////////////////
+  // // End of OpenEXR license -------------------------------------------------
+  var EXRLoader = /*#__PURE__*/function (_DataTextureLoader) {
+    _inherits(EXRLoader, _DataTextureLoader);
+
+    var _super = _createSuper(EXRLoader);
+
+    function EXRLoader(manager) {
+      var _this;
+
+      _classCallCheck(this, EXRLoader);
+
+      _this = _super.call(this, manager);
+      _this.type = _three.HalfFloatType;
+      return _this;
+    }
+
+    _createClass(EXRLoader, [{
+      key: "parse",
+      value: function parse(buffer) {
+        var USHORT_RANGE = 1 << 16;
+        var BITMAP_SIZE = USHORT_RANGE >> 3;
+        var HUF_ENCBITS = 16; // literal (value) bit length
+
+        var HUF_DECBITS = 14; // decoding bit size (>= 8)
+
+        var HUF_ENCSIZE = (1 << HUF_ENCBITS) + 1; // encoding table size
+
+        var HUF_DECSIZE = 1 << HUF_DECBITS; // decoding table size
+
+        var HUF_DECMASK = HUF_DECSIZE - 1;
+        var NBITS = 16;
+        var A_OFFSET = 1 << NBITS - 1;
+        var MOD_MASK = (1 << NBITS) - 1;
+        var SHORT_ZEROCODE_RUN = 59;
+        var LONG_ZEROCODE_RUN = 63;
+        var SHORTEST_LONG_RUN = 2 + LONG_ZEROCODE_RUN - SHORT_ZEROCODE_RUN;
+        var ULONG_SIZE = 8;
+        var FLOAT32_SIZE = 4;
+        var INT32_SIZE = 4;
+        var INT16_SIZE = 2;
+        var INT8_SIZE = 1;
+        var STATIC_HUFFMAN = 0;
+        var DEFLATE = 1;
+        var UNKNOWN = 0;
+        var LOSSY_DCT = 1;
+        var RLE = 2;
+        var logBase = Math.pow(2.7182818, 2.2);
+        var tmpDataView = new DataView(new ArrayBuffer(8));
+
+        function frexp(value) {
+          if (value === 0) return [value, 0];
+          tmpDataView.setFloat64(0, value);
+          var bits = tmpDataView.getUint32(0) >>> 20 & 0x7FF;
+
+          if (bits === 0) {
+            // denormal
+            tmpDataView.setFloat64(0, value * Math.pow(2, 64)); // exp + 64
+
+            bits = (tmpDataView.getUint32(0) >>> 20 & 0x7FF) - 64;
+          }
+
+          var exponent = bits - 1022;
+          var mantissa = ldexp(value, -exponent);
+          return [mantissa, exponent];
+        }
+
+        function ldexp(mantissa, exponent) {
+          var steps = Math.min(3, Math.ceil(Math.abs(exponent) / 1023));
+          var result = mantissa;
+
+          for (var i = 0; i < steps; i++) {
+            result *= Math.pow(2, Math.floor((exponent + i) / steps));
+          }
+
+          return result;
+        }
+
+        function reverseLutFromBitmap(bitmap, lut) {
+          var k = 0;
+
+          for (var i = 0; i < USHORT_RANGE; ++i) {
+            if (i == 0 || bitmap[i >> 3] & 1 << (i & 7)) {
+              lut[k++] = i;
+            }
+          }
+
+          var n = k - 1;
+
+          while (k < USHORT_RANGE) {
+            lut[k++] = 0;
+          }
+
+          return n;
+        }
+
+        function hufClearDecTable(hdec) {
+          for (var i = 0; i < HUF_DECSIZE; i++) {
+            hdec[i] = {};
+            hdec[i].len = 0;
+            hdec[i].lit = 0;
+            hdec[i].p = null;
+          }
+        }
+
+        var getBitsReturn = {
+          l: 0,
+          c: 0,
+          lc: 0
+        };
+
+        function getBits(nBits, c, lc, uInt8Array, inOffset) {
+          while (lc < nBits) {
+            c = c << 8 | parseUint8Array(uInt8Array, inOffset);
+            lc += 8;
+          }
+
+          lc -= nBits;
+          getBitsReturn.l = c >> lc & (1 << nBits) - 1;
+          getBitsReturn.c = c;
+          getBitsReturn.lc = lc;
+        }
+
+        var hufTableBuffer = new Array(59);
+
+        function hufCanonicalCodeTable(hcode) {
+          for (var i = 0; i <= 58; ++i) {
+            hufTableBuffer[i] = 0;
+          }
+
+          for (var i = 0; i < HUF_ENCSIZE; ++i) {
+            hufTableBuffer[hcode[i]] += 1;
+          }
+
+          var c = 0;
+
+          for (var i = 58; i > 0; --i) {
+            var nc = c + hufTableBuffer[i] >> 1;
+            hufTableBuffer[i] = c;
+            c = nc;
+          }
+
+          for (var i = 0; i < HUF_ENCSIZE; ++i) {
+            var l = hcode[i];
+            if (l > 0) hcode[i] = l | hufTableBuffer[l]++ << 6;
+          }
+        }
+
+        function hufUnpackEncTable(uInt8Array, inDataView, inOffset, ni, im, iM, hcode) {
+          var p = inOffset;
+          var c = 0;
+          var lc = 0;
+
+          for (; im <= iM; im++) {
+            if (p.value - inOffset.value > ni) return false;
+            getBits(6, c, lc, uInt8Array, p);
+            var l = getBitsReturn.l;
+            c = getBitsReturn.c;
+            lc = getBitsReturn.lc;
+            hcode[im] = l;
+
+            if (l == LONG_ZEROCODE_RUN) {
+              if (p.value - inOffset.value > ni) {
+                throw 'Something wrong with hufUnpackEncTable';
+              }
+
+              getBits(8, c, lc, uInt8Array, p);
+              var zerun = getBitsReturn.l + SHORTEST_LONG_RUN;
+              c = getBitsReturn.c;
+              lc = getBitsReturn.lc;
+
+              if (im + zerun > iM + 1) {
+                throw 'Something wrong with hufUnpackEncTable';
+              }
+
+              while (zerun--) {
+                hcode[im++] = 0;
+              }
+
+              im--;
+            } else if (l >= SHORT_ZEROCODE_RUN) {
+              var zerun = l - SHORT_ZEROCODE_RUN + 2;
+
+              if (im + zerun > iM + 1) {
+                throw 'Something wrong with hufUnpackEncTable';
+              }
+
+              while (zerun--) {
+                hcode[im++] = 0;
+              }
+
+              im--;
+            }
+          }
+
+          hufCanonicalCodeTable(hcode);
+        }
+
+        function hufLength(code) {
+          return code & 63;
+        }
+
+        function hufCode(code) {
+          return code >> 6;
+        }
+
+        function hufBuildDecTable(hcode, im, iM, hdecod) {
+          for (; im <= iM; im++) {
+            var c = hufCode(hcode[im]);
+            var l = hufLength(hcode[im]);
+
+            if (c >> l) {
+              throw 'Invalid table entry';
+            }
+
+            if (l > HUF_DECBITS) {
+              var pl = hdecod[c >> l - HUF_DECBITS];
+
+              if (pl.len) {
+                throw 'Invalid table entry';
+              }
+
+              pl.lit++;
+
+              if (pl.p) {
+                var p = pl.p;
+                pl.p = new Array(pl.lit);
+
+                for (var i = 0; i < pl.lit - 1; ++i) {
+                  pl.p[i] = p[i];
+                }
+              } else {
+                pl.p = new Array(1);
+              }
+
+              pl.p[pl.lit - 1] = im;
+            } else if (l) {
+              var plOffset = 0;
+
+              for (var i = 1 << HUF_DECBITS - l; i > 0; i--) {
+                var pl = hdecod[(c << HUF_DECBITS - l) + plOffset];
+
+                if (pl.len || pl.p) {
+                  throw 'Invalid table entry';
+                }
+
+                pl.len = l;
+                pl.lit = im;
+                plOffset++;
+              }
+            }
+          }
+
+          return true;
+        }
+
+        var getCharReturn = {
+          c: 0,
+          lc: 0
+        };
+
+        function getChar(c, lc, uInt8Array, inOffset) {
+          c = c << 8 | parseUint8Array(uInt8Array, inOffset);
+          lc += 8;
+          getCharReturn.c = c;
+          getCharReturn.lc = lc;
+        }
+
+        var getCodeReturn = {
+          c: 0,
+          lc: 0
+        };
+
+        function getCode(po, rlc, c, lc, uInt8Array, inDataView, inOffset, outBuffer, outBufferOffset, outBufferEndOffset) {
+          if (po == rlc) {
+            if (lc < 8) {
+              getChar(c, lc, uInt8Array, inOffset);
+              c = getCharReturn.c;
+              lc = getCharReturn.lc;
+            }
+
+            lc -= 8;
+            var cs = c >> lc;
+            var cs = new Uint8Array([cs])[0];
+
+            if (outBufferOffset.value + cs > outBufferEndOffset) {
+              return false;
+            }
+
+            var s = outBuffer[outBufferOffset.value - 1];
+
+            while (cs-- > 0) {
+              outBuffer[outBufferOffset.value++] = s;
+            }
+          } else if (outBufferOffset.value < outBufferEndOffset) {
+            outBuffer[outBufferOffset.value++] = po;
+          } else {
+            return false;
+          }
+
+          getCodeReturn.c = c;
+          getCodeReturn.lc = lc;
+        }
+
+        function UInt16(value) {
+          return value & 0xFFFF;
+        }
+
+        function Int16(value) {
+          var ref = UInt16(value);
+          return ref > 0x7FFF ? ref - 0x10000 : ref;
+        }
+
+        var wdec14Return = {
+          a: 0,
+          b: 0
+        };
+
+        function wdec14(l, h) {
+          var ls = Int16(l);
+          var hs = Int16(h);
+          var hi = hs;
+          var ai = ls + (hi & 1) + (hi >> 1);
+          var as = ai;
+          var bs = ai - hi;
+          wdec14Return.a = as;
+          wdec14Return.b = bs;
+        }
+
+        function wdec16(l, h) {
+          var m = UInt16(l);
+          var d = UInt16(h);
+          var bb = m - (d >> 1) & MOD_MASK;
+          var aa = d + bb - A_OFFSET & MOD_MASK;
+          wdec14Return.a = aa;
+          wdec14Return.b = bb;
+        }
+
+        function wav2Decode(buffer, j, nx, ox, ny, oy, mx) {
+          var w14 = mx < 1 << 14;
+          var n = nx > ny ? ny : nx;
+          var p = 1;
+          var p2;
+
+          while (p <= n) {
+            p <<= 1;
+          }
+
+          p >>= 1;
+          p2 = p;
+          p >>= 1;
+
+          while (p >= 1) {
+            var py = 0;
+            var ey = py + oy * (ny - p2);
+            var oy1 = oy * p;
+            var oy2 = oy * p2;
+            var ox1 = ox * p;
+            var ox2 = ox * p2;
+            var i00, i01, i10, i11;
+
+            for (; py <= ey; py += oy2) {
+              var px = py;
+              var ex = py + ox * (nx - p2);
+
+              for (; px <= ex; px += ox2) {
+                var p01 = px + ox1;
+                var p10 = px + oy1;
+                var p11 = p10 + ox1;
+
+                if (w14) {
+                  wdec14(buffer[px + j], buffer[p10 + j]);
+                  i00 = wdec14Return.a;
+                  i10 = wdec14Return.b;
+                  wdec14(buffer[p01 + j], buffer[p11 + j]);
+                  i01 = wdec14Return.a;
+                  i11 = wdec14Return.b;
+                  wdec14(i00, i01);
+                  buffer[px + j] = wdec14Return.a;
+                  buffer[p01 + j] = wdec14Return.b;
+                  wdec14(i10, i11);
+                  buffer[p10 + j] = wdec14Return.a;
+                  buffer[p11 + j] = wdec14Return.b;
+                } else {
+                  wdec16(buffer[px + j], buffer[p10 + j]);
+                  i00 = wdec14Return.a;
+                  i10 = wdec14Return.b;
+                  wdec16(buffer[p01 + j], buffer[p11 + j]);
+                  i01 = wdec14Return.a;
+                  i11 = wdec14Return.b;
+                  wdec16(i00, i01);
+                  buffer[px + j] = wdec14Return.a;
+                  buffer[p01 + j] = wdec14Return.b;
+                  wdec16(i10, i11);
+                  buffer[p10 + j] = wdec14Return.a;
+                  buffer[p11 + j] = wdec14Return.b;
+                }
+              }
+
+              if (nx & p) {
+                var p10 = px + oy1;
+                if (w14) wdec14(buffer[px + j], buffer[p10 + j]);else wdec16(buffer[px + j], buffer[p10 + j]);
+                i00 = wdec14Return.a;
+                buffer[p10 + j] = wdec14Return.b;
+                buffer[px + j] = i00;
+              }
+            }
+
+            if (ny & p) {
+              var px = py;
+              var ex = py + ox * (nx - p2);
+
+              for (; px <= ex; px += ox2) {
+                var p01 = px + ox1;
+                if (w14) wdec14(buffer[px + j], buffer[p01 + j]);else wdec16(buffer[px + j], buffer[p01 + j]);
+                i00 = wdec14Return.a;
+                buffer[p01 + j] = wdec14Return.b;
+                buffer[px + j] = i00;
+              }
+            }
+
+            p2 = p;
+            p >>= 1;
+          }
+
+          return py;
+        }
+
+        function hufDecode(encodingTable, decodingTable, uInt8Array, inDataView, inOffset, ni, rlc, no, outBuffer, outOffset) {
+          var c = 0;
+          var lc = 0;
+          var outBufferEndOffset = no;
+          var inOffsetEnd = Math.trunc(inOffset.value + (ni + 7) / 8);
+
+          while (inOffset.value < inOffsetEnd) {
+            getChar(c, lc, uInt8Array, inOffset);
+            c = getCharReturn.c;
+            lc = getCharReturn.lc;
+
+            while (lc >= HUF_DECBITS) {
+              var index = c >> lc - HUF_DECBITS & HUF_DECMASK;
+              var pl = decodingTable[index];
+
+              if (pl.len) {
+                lc -= pl.len;
+                getCode(pl.lit, rlc, c, lc, uInt8Array, inDataView, inOffset, outBuffer, outOffset, outBufferEndOffset);
+                c = getCodeReturn.c;
+                lc = getCodeReturn.lc;
+              } else {
+                if (!pl.p) {
+                  throw 'hufDecode issues';
+                }
+
+                var j;
+
+                for (j = 0; j < pl.lit; j++) {
+                  var l = hufLength(encodingTable[pl.p[j]]);
+
+                  while (lc < l && inOffset.value < inOffsetEnd) {
+                    getChar(c, lc, uInt8Array, inOffset);
+                    c = getCharReturn.c;
+                    lc = getCharReturn.lc;
+                  }
+
+                  if (lc >= l) {
+                    if (hufCode(encodingTable[pl.p[j]]) == (c >> lc - l & (1 << l) - 1)) {
+                      lc -= l;
+                      getCode(pl.p[j], rlc, c, lc, uInt8Array, inDataView, inOffset, outBuffer, outOffset, outBufferEndOffset);
+                      c = getCodeReturn.c;
+                      lc = getCodeReturn.lc;
+                      break;
+                    }
+                  }
+                }
+
+                if (j == pl.lit) {
+                  throw 'hufDecode issues';
+                }
+              }
+            }
+          }
+
+          var i = 8 - ni & 7;
+          c >>= i;
+          lc -= i;
+
+          while (lc > 0) {
+            var pl = decodingTable[c << HUF_DECBITS - lc & HUF_DECMASK];
+
+            if (pl.len) {
+              lc -= pl.len;
+              getCode(pl.lit, rlc, c, lc, uInt8Array, inDataView, inOffset, outBuffer, outOffset, outBufferEndOffset);
+              c = getCodeReturn.c;
+              lc = getCodeReturn.lc;
+            } else {
+              throw 'hufDecode issues';
+            }
+          }
+
+          return true;
+        }
+
+        function hufUncompress(uInt8Array, inDataView, inOffset, nCompressed, outBuffer, nRaw) {
+          var outOffset = {
+            value: 0
+          };
+          var initialInOffset = inOffset.value;
+          var im = parseUint32(inDataView, inOffset);
+          var iM = parseUint32(inDataView, inOffset);
+          inOffset.value += 4;
+          var nBits = parseUint32(inDataView, inOffset);
+          inOffset.value += 4;
+
+          if (im < 0 || im >= HUF_ENCSIZE || iM < 0 || iM >= HUF_ENCSIZE) {
+            throw 'Something wrong with HUF_ENCSIZE';
+          }
+
+          var freq = new Array(HUF_ENCSIZE);
+          var hdec = new Array(HUF_DECSIZE);
+          hufClearDecTable(hdec);
+          var ni = nCompressed - (inOffset.value - initialInOffset);
+          hufUnpackEncTable(uInt8Array, inDataView, inOffset, ni, im, iM, freq);
+
+          if (nBits > 8 * (nCompressed - (inOffset.value - initialInOffset))) {
+            throw 'Something wrong with hufUncompress';
+          }
+
+          hufBuildDecTable(freq, im, iM, hdec);
+          hufDecode(freq, hdec, uInt8Array, inDataView, inOffset, nBits, iM, nRaw, outBuffer, outOffset);
+        }
+
+        function applyLut(lut, data, nData) {
+          for (var i = 0; i < nData; ++i) {
+            data[i] = lut[data[i]];
+          }
+        }
+
+        function predictor(source) {
+          for (var t = 1; t < source.length; t++) {
+            var d = source[t - 1] + source[t] - 128;
+            source[t] = d;
+          }
+        }
+
+        function interleaveScalar(source, out) {
+          var t1 = 0;
+          var t2 = Math.floor((source.length + 1) / 2);
+          var s = 0;
+          var stop = source.length - 1;
+
+          while (true) {
+            if (s > stop) break;
+            out[s++] = source[t1++];
+            if (s > stop) break;
+            out[s++] = source[t2++];
+          }
+        }
+
+        function decodeRunLength(source) {
+          var size = source.byteLength;
+          var out = new Array();
+          var p = 0;
+          var reader = new DataView(source);
+
+          while (size > 0) {
+            var l = reader.getInt8(p++);
+
+            if (l < 0) {
+              var count = -l;
+              size -= count + 1;
+
+              for (var i = 0; i < count; i++) {
+                out.push(reader.getUint8(p++));
+              }
+            } else {
+              var count = l;
+              size -= 2;
+              var value = reader.getUint8(p++);
+
+              for (var i = 0; i < count + 1; i++) {
+                out.push(value);
+              }
+            }
+          }
+
+          return out;
+        }
+
+        function lossyDctDecode(cscSet, rowPtrs, channelData, acBuffer, dcBuffer, outBuffer) {
+          var dataView = new DataView(outBuffer.buffer);
+          var width = channelData[cscSet.idx[0]].width;
+          var height = channelData[cscSet.idx[0]].height;
+          var numComp = 3;
+          var numFullBlocksX = Math.floor(width / 8.0);
+          var numBlocksX = Math.ceil(width / 8.0);
+          var numBlocksY = Math.ceil(height / 8.0);
+          var leftoverX = width - (numBlocksX - 1) * 8;
+          var leftoverY = height - (numBlocksY - 1) * 8;
+          var currAcComp = {
+            value: 0
+          };
+          var currDcComp = new Array(numComp);
+          var dctData = new Array(numComp);
+          var halfZigBlock = new Array(numComp);
+          var rowBlock = new Array(numComp);
+          var rowOffsets = new Array(numComp);
+
+          for (var _comp = 0; _comp < numComp; ++_comp) {
+            rowOffsets[_comp] = rowPtrs[cscSet.idx[_comp]];
+            currDcComp[_comp] = _comp < 1 ? 0 : currDcComp[_comp - 1] + numBlocksX * numBlocksY;
+            dctData[_comp] = new Float32Array(64);
+            halfZigBlock[_comp] = new Uint16Array(64);
+            rowBlock[_comp] = new Uint16Array(numBlocksX * 64);
+          }
+
+          for (var blocky = 0; blocky < numBlocksY; ++blocky) {
+            var maxY = 8;
+            if (blocky == numBlocksY - 1) maxY = leftoverY;
+            var maxX = 8;
+
+            for (var blockx = 0; blockx < numBlocksX; ++blockx) {
+              if (blockx == numBlocksX - 1) maxX = leftoverX;
+
+              for (var _comp2 = 0; _comp2 < numComp; ++_comp2) {
+                halfZigBlock[_comp2].fill(0); // set block DC component
+
+
+                halfZigBlock[_comp2][0] = dcBuffer[currDcComp[_comp2]++]; // set block AC components
+
+                unRleAC(currAcComp, acBuffer, halfZigBlock[_comp2]); // UnZigZag block to float
+
+                unZigZag(halfZigBlock[_comp2], dctData[_comp2]); // decode float dct
+
+                dctInverse(dctData[_comp2]);
+              }
+
+              if (numComp == 3) {
+                csc709Inverse(dctData);
+              }
+
+              for (var _comp3 = 0; _comp3 < numComp; ++_comp3) {
+                convertToHalf(dctData[_comp3], rowBlock[_comp3], blockx * 64);
+              }
+            } // blockx
+
+
+            var _offset = 0;
+
+            for (var _comp4 = 0; _comp4 < numComp; ++_comp4) {
+              var _type = channelData[cscSet.idx[_comp4]].type;
+
+              for (var _y = 8 * blocky; _y < 8 * blocky + maxY; ++_y) {
+                _offset = rowOffsets[_comp4][_y];
+
+                for (var _blockx = 0; _blockx < numFullBlocksX; ++_blockx) {
+                  var src = _blockx * 64 + (_y & 0x7) * 8;
+                  dataView.setUint16(_offset + 0 * INT16_SIZE * _type, rowBlock[_comp4][src + 0], true);
+                  dataView.setUint16(_offset + 1 * INT16_SIZE * _type, rowBlock[_comp4][src + 1], true);
+                  dataView.setUint16(_offset + 2 * INT16_SIZE * _type, rowBlock[_comp4][src + 2], true);
+                  dataView.setUint16(_offset + 3 * INT16_SIZE * _type, rowBlock[_comp4][src + 3], true);
+                  dataView.setUint16(_offset + 4 * INT16_SIZE * _type, rowBlock[_comp4][src + 4], true);
+                  dataView.setUint16(_offset + 5 * INT16_SIZE * _type, rowBlock[_comp4][src + 5], true);
+                  dataView.setUint16(_offset + 6 * INT16_SIZE * _type, rowBlock[_comp4][src + 6], true);
+                  dataView.setUint16(_offset + 7 * INT16_SIZE * _type, rowBlock[_comp4][src + 7], true);
+                  _offset += 8 * INT16_SIZE * _type;
+                }
+              } // handle partial X blocks
+
+
+              if (numFullBlocksX != numBlocksX) {
+                for (var _y2 = 8 * blocky; _y2 < 8 * blocky + maxY; ++_y2) {
+                  var _offset2 = rowOffsets[_comp4][_y2] + 8 * numFullBlocksX * INT16_SIZE * _type;
+
+                  var _src = numFullBlocksX * 64 + (_y2 & 0x7) * 8;
+
+                  for (var _x = 0; _x < maxX; ++_x) {
+                    dataView.setUint16(_offset2 + _x * INT16_SIZE * _type, rowBlock[_comp4][_src + _x], true);
+                  }
+                }
+              }
+            } // comp
+
+          } // blocky
+
+
+          var halfRow = new Uint16Array(width);
+          var dataView = new DataView(outBuffer.buffer); // convert channels back to float, if needed
+
+          for (var comp = 0; comp < numComp; ++comp) {
+            channelData[cscSet.idx[comp]].decoded = true;
+            var type = channelData[cscSet.idx[comp]].type;
+            if (channelData[comp].type != 2) continue;
+
+            for (var y = 0; y < height; ++y) {
+              var _offset3 = rowOffsets[comp][y];
+
+              for (var x = 0; x < width; ++x) {
+                halfRow[x] = dataView.getUint16(_offset3 + x * INT16_SIZE * type, true);
+              }
+
+              for (var x = 0; x < width; ++x) {
+                dataView.setFloat32(_offset3 + x * INT16_SIZE * type, decodeFloat16(halfRow[x]), true);
+              }
+            }
+          }
+        }
+
+        function unRleAC(currAcComp, acBuffer, halfZigBlock) {
+          var acValue;
+          var dctComp = 1;
+
+          while (dctComp < 64) {
+            acValue = acBuffer[currAcComp.value];
+
+            if (acValue == 0xff00) {
+              dctComp = 64;
+            } else if (acValue >> 8 == 0xff) {
+              dctComp += acValue & 0xff;
+            } else {
+              halfZigBlock[dctComp] = acValue;
+              dctComp++;
+            }
+
+            currAcComp.value++;
+          }
+        }
+
+        function unZigZag(src, dst) {
+          dst[0] = decodeFloat16(src[0]);
+          dst[1] = decodeFloat16(src[1]);
+          dst[2] = decodeFloat16(src[5]);
+          dst[3] = decodeFloat16(src[6]);
+          dst[4] = decodeFloat16(src[14]);
+          dst[5] = decodeFloat16(src[15]);
+          dst[6] = decodeFloat16(src[27]);
+          dst[7] = decodeFloat16(src[28]);
+          dst[8] = decodeFloat16(src[2]);
+          dst[9] = decodeFloat16(src[4]);
+          dst[10] = decodeFloat16(src[7]);
+          dst[11] = decodeFloat16(src[13]);
+          dst[12] = decodeFloat16(src[16]);
+          dst[13] = decodeFloat16(src[26]);
+          dst[14] = decodeFloat16(src[29]);
+          dst[15] = decodeFloat16(src[42]);
+          dst[16] = decodeFloat16(src[3]);
+          dst[17] = decodeFloat16(src[8]);
+          dst[18] = decodeFloat16(src[12]);
+          dst[19] = decodeFloat16(src[17]);
+          dst[20] = decodeFloat16(src[25]);
+          dst[21] = decodeFloat16(src[30]);
+          dst[22] = decodeFloat16(src[41]);
+          dst[23] = decodeFloat16(src[43]);
+          dst[24] = decodeFloat16(src[9]);
+          dst[25] = decodeFloat16(src[11]);
+          dst[26] = decodeFloat16(src[18]);
+          dst[27] = decodeFloat16(src[24]);
+          dst[28] = decodeFloat16(src[31]);
+          dst[29] = decodeFloat16(src[40]);
+          dst[30] = decodeFloat16(src[44]);
+          dst[31] = decodeFloat16(src[53]);
+          dst[32] = decodeFloat16(src[10]);
+          dst[33] = decodeFloat16(src[19]);
+          dst[34] = decodeFloat16(src[23]);
+          dst[35] = decodeFloat16(src[32]);
+          dst[36] = decodeFloat16(src[39]);
+          dst[37] = decodeFloat16(src[45]);
+          dst[38] = decodeFloat16(src[52]);
+          dst[39] = decodeFloat16(src[54]);
+          dst[40] = decodeFloat16(src[20]);
+          dst[41] = decodeFloat16(src[22]);
+          dst[42] = decodeFloat16(src[33]);
+          dst[43] = decodeFloat16(src[38]);
+          dst[44] = decodeFloat16(src[46]);
+          dst[45] = decodeFloat16(src[51]);
+          dst[46] = decodeFloat16(src[55]);
+          dst[47] = decodeFloat16(src[60]);
+          dst[48] = decodeFloat16(src[21]);
+          dst[49] = decodeFloat16(src[34]);
+          dst[50] = decodeFloat16(src[37]);
+          dst[51] = decodeFloat16(src[47]);
+          dst[52] = decodeFloat16(src[50]);
+          dst[53] = decodeFloat16(src[56]);
+          dst[54] = decodeFloat16(src[59]);
+          dst[55] = decodeFloat16(src[61]);
+          dst[56] = decodeFloat16(src[35]);
+          dst[57] = decodeFloat16(src[36]);
+          dst[58] = decodeFloat16(src[48]);
+          dst[59] = decodeFloat16(src[49]);
+          dst[60] = decodeFloat16(src[57]);
+          dst[61] = decodeFloat16(src[58]);
+          dst[62] = decodeFloat16(src[62]);
+          dst[63] = decodeFloat16(src[63]);
+        }
+
+        function dctInverse(data) {
+          var a = 0.5 * Math.cos(3.14159 / 4.0);
+          var b = 0.5 * Math.cos(3.14159 / 16.0);
+          var c = 0.5 * Math.cos(3.14159 / 8.0);
+          var d = 0.5 * Math.cos(3.0 * 3.14159 / 16.0);
+          var e = 0.5 * Math.cos(5.0 * 3.14159 / 16.0);
+          var f = 0.5 * Math.cos(3.0 * 3.14159 / 8.0);
+          var g = 0.5 * Math.cos(7.0 * 3.14159 / 16.0);
+          var alpha = new Array(4);
+          var beta = new Array(4);
+          var theta = new Array(4);
+          var gamma = new Array(4);
+
+          for (var row = 0; row < 8; ++row) {
+            var rowPtr = row * 8;
+            alpha[0] = c * data[rowPtr + 2];
+            alpha[1] = f * data[rowPtr + 2];
+            alpha[2] = c * data[rowPtr + 6];
+            alpha[3] = f * data[rowPtr + 6];
+            beta[0] = b * data[rowPtr + 1] + d * data[rowPtr + 3] + e * data[rowPtr + 5] + g * data[rowPtr + 7];
+            beta[1] = d * data[rowPtr + 1] - g * data[rowPtr + 3] - b * data[rowPtr + 5] - e * data[rowPtr + 7];
+            beta[2] = e * data[rowPtr + 1] - b * data[rowPtr + 3] + g * data[rowPtr + 5] + d * data[rowPtr + 7];
+            beta[3] = g * data[rowPtr + 1] - e * data[rowPtr + 3] + d * data[rowPtr + 5] - b * data[rowPtr + 7];
+            theta[0] = a * (data[rowPtr + 0] + data[rowPtr + 4]);
+            theta[3] = a * (data[rowPtr + 0] - data[rowPtr + 4]);
+            theta[1] = alpha[0] + alpha[3];
+            theta[2] = alpha[1] - alpha[2];
+            gamma[0] = theta[0] + theta[1];
+            gamma[1] = theta[3] + theta[2];
+            gamma[2] = theta[3] - theta[2];
+            gamma[3] = theta[0] - theta[1];
+            data[rowPtr + 0] = gamma[0] + beta[0];
+            data[rowPtr + 1] = gamma[1] + beta[1];
+            data[rowPtr + 2] = gamma[2] + beta[2];
+            data[rowPtr + 3] = gamma[3] + beta[3];
+            data[rowPtr + 4] = gamma[3] - beta[3];
+            data[rowPtr + 5] = gamma[2] - beta[2];
+            data[rowPtr + 6] = gamma[1] - beta[1];
+            data[rowPtr + 7] = gamma[0] - beta[0];
+          }
+
+          for (var column = 0; column < 8; ++column) {
+            alpha[0] = c * data[16 + column];
+            alpha[1] = f * data[16 + column];
+            alpha[2] = c * data[48 + column];
+            alpha[3] = f * data[48 + column];
+            beta[0] = b * data[8 + column] + d * data[24 + column] + e * data[40 + column] + g * data[56 + column];
+            beta[1] = d * data[8 + column] - g * data[24 + column] - b * data[40 + column] - e * data[56 + column];
+            beta[2] = e * data[8 + column] - b * data[24 + column] + g * data[40 + column] + d * data[56 + column];
+            beta[3] = g * data[8 + column] - e * data[24 + column] + d * data[40 + column] - b * data[56 + column];
+            theta[0] = a * (data[column] + data[32 + column]);
+            theta[3] = a * (data[column] - data[32 + column]);
+            theta[1] = alpha[0] + alpha[3];
+            theta[2] = alpha[1] - alpha[2];
+            gamma[0] = theta[0] + theta[1];
+            gamma[1] = theta[3] + theta[2];
+            gamma[2] = theta[3] - theta[2];
+            gamma[3] = theta[0] - theta[1];
+            data[0 + column] = gamma[0] + beta[0];
+            data[8 + column] = gamma[1] + beta[1];
+            data[16 + column] = gamma[2] + beta[2];
+            data[24 + column] = gamma[3] + beta[3];
+            data[32 + column] = gamma[3] - beta[3];
+            data[40 + column] = gamma[2] - beta[2];
+            data[48 + column] = gamma[1] - beta[1];
+            data[56 + column] = gamma[0] - beta[0];
+          }
+        }
+
+        function csc709Inverse(data) {
+          for (var i = 0; i < 64; ++i) {
+            var y = data[0][i];
+            var cb = data[1][i];
+            var cr = data[2][i];
+            data[0][i] = y + 1.5747 * cr;
+            data[1][i] = y - 0.1873 * cb - 0.4682 * cr;
+            data[2][i] = y + 1.8556 * cb;
+          }
+        }
+
+        function convertToHalf(src, dst, idx) {
+          for (var i = 0; i < 64; ++i) {
+            dst[idx + i] = _three.DataUtils.toHalfFloat(toLinear(src[i]));
+          }
+        }
+
+        function toLinear(float) {
+          if (float <= 1) {
+            return Math.sign(float) * Math.pow(Math.abs(float), 2.2);
+          } else {
+            return Math.sign(float) * Math.pow(logBase, Math.abs(float) - 1.0);
+          }
+        }
+
+        function uncompressRAW(info) {
+          return new DataView(info.array.buffer, info.offset.value, info.size);
+        }
+
+        function uncompressRLE(info) {
+          var compressed = info.viewer.buffer.slice(info.offset.value, info.offset.value + info.size);
+          var rawBuffer = new Uint8Array(decodeRunLength(compressed));
+          var tmpBuffer = new Uint8Array(rawBuffer.length);
+          predictor(rawBuffer); // revert predictor
+
+          interleaveScalar(rawBuffer, tmpBuffer); // interleave pixels
+
+          return new DataView(tmpBuffer.buffer);
+        }
+
+        function uncompressZIP(info) {
+          var compressed = info.array.slice(info.offset.value, info.offset.value + info.size);
+
+          if (typeof fflate === 'undefined') {
+            console.error('THREE.EXRLoader: External library fflate.min.js required.');
+          }
+
+          var rawBuffer = fflate.unzlibSync(compressed); // eslint-disable-line no-undef
+
+          var tmpBuffer = new Uint8Array(rawBuffer.length);
+          predictor(rawBuffer); // revert predictor
+
+          interleaveScalar(rawBuffer, tmpBuffer); // interleave pixels
+
+          return new DataView(tmpBuffer.buffer);
+        }
+
+        function uncompressPIZ(info) {
+          var inDataView = info.viewer;
+          var inOffset = {
+            value: info.offset.value
+          };
+          var tmpBufSize = info.width * scanlineBlockSize * (EXRHeader.channels.length * info.type);
+          var outBuffer = new Uint16Array(tmpBufSize);
+          var bitmap = new Uint8Array(BITMAP_SIZE); // Setup channel info
+
+          var outBufferEnd = 0;
+          var pizChannelData = new Array(info.channels);
+
+          for (var i = 0; i < info.channels; i++) {
+            pizChannelData[i] = {};
+            pizChannelData[i]['start'] = outBufferEnd;
+            pizChannelData[i]['end'] = pizChannelData[i]['start'];
+            pizChannelData[i]['nx'] = info.width;
+            pizChannelData[i]['ny'] = info.lines;
+            pizChannelData[i]['size'] = info.type;
+            outBufferEnd += pizChannelData[i].nx * pizChannelData[i].ny * pizChannelData[i].size;
+          } // Read range compression data
+
+
+          var minNonZero = parseUint16(inDataView, inOffset);
+          var maxNonZero = parseUint16(inDataView, inOffset);
+
+          if (maxNonZero >= BITMAP_SIZE) {
+            throw 'Something is wrong with PIZ_COMPRESSION BITMAP_SIZE';
+          }
+
+          if (minNonZero <= maxNonZero) {
+            for (var i = 0; i < maxNonZero - minNonZero + 1; i++) {
+              bitmap[i + minNonZero] = parseUint8(inDataView, inOffset);
+            }
+          } // Reverse LUT
+
+
+          var lut = new Uint16Array(USHORT_RANGE);
+          var maxValue = reverseLutFromBitmap(bitmap, lut);
+          var length = parseUint32(inDataView, inOffset); // Huffman decoding
+
+          hufUncompress(info.array, inDataView, inOffset, length, outBuffer, outBufferEnd); // Wavelet decoding
+
+          for (var i = 0; i < info.channels; ++i) {
+            var cd = pizChannelData[i];
+
+            for (var j = 0; j < pizChannelData[i].size; ++j) {
+              wav2Decode(outBuffer, cd.start + j, cd.nx, cd.size, cd.ny, cd.nx * cd.size, maxValue);
+            }
+          } // Expand the pixel data to their original range
+
+
+          applyLut(lut, outBuffer, outBufferEnd); // Rearrange the pixel data into the format expected by the caller.
+
+          var tmpOffset = 0;
+          var tmpBuffer = new Uint8Array(outBuffer.buffer.byteLength);
+
+          for (var y = 0; y < info.lines; y++) {
+            for (var c = 0; c < info.channels; c++) {
+              var cd = pizChannelData[c];
+              var n = cd.nx * cd.size;
+              var cp = new Uint8Array(outBuffer.buffer, cd.end * INT16_SIZE, n * INT16_SIZE);
+              tmpBuffer.set(cp, tmpOffset);
+              tmpOffset += n * INT16_SIZE;
+              cd.end += n;
+            }
+          }
+
+          return new DataView(tmpBuffer.buffer);
+        }
+
+        function uncompressPXR(info) {
+          var compressed = info.array.slice(info.offset.value, info.offset.value + info.size);
+
+          if (typeof fflate === 'undefined') {
+            console.error('THREE.EXRLoader: External library fflate.min.js required.');
+          }
+
+          var rawBuffer = fflate.unzlibSync(compressed); // eslint-disable-line no-undef
+
+          var sz = info.lines * info.channels * info.width;
+          var tmpBuffer = info.type == 1 ? new Uint16Array(sz) : new Uint32Array(sz);
+          var tmpBufferEnd = 0;
+          var writePtr = 0;
+          var ptr = new Array(4);
+
+          for (var y = 0; y < info.lines; y++) {
+            for (var c = 0; c < info.channels; c++) {
+              var pixel = 0;
+
+              switch (info.type) {
+                case 1:
+                  ptr[0] = tmpBufferEnd;
+                  ptr[1] = ptr[0] + info.width;
+                  tmpBufferEnd = ptr[1] + info.width;
+
+                  for (var j = 0; j < info.width; ++j) {
+                    var diff = rawBuffer[ptr[0]++] << 8 | rawBuffer[ptr[1]++];
+                    pixel += diff;
+                    tmpBuffer[writePtr] = pixel;
+                    writePtr++;
+                  }
+
+                  break;
+
+                case 2:
+                  ptr[0] = tmpBufferEnd;
+                  ptr[1] = ptr[0] + info.width;
+                  ptr[2] = ptr[1] + info.width;
+                  tmpBufferEnd = ptr[2] + info.width;
+
+                  for (var _j = 0; _j < info.width; ++_j) {
+                    var _diff = rawBuffer[ptr[0]++] << 24 | rawBuffer[ptr[1]++] << 16 | rawBuffer[ptr[2]++] << 8;
+
+                    pixel += _diff;
+                    tmpBuffer[writePtr] = pixel;
+                    writePtr++;
+                  }
+
+                  break;
+              }
+            }
+          }
+
+          return new DataView(tmpBuffer.buffer);
+        }
+
+        function uncompressDWA(info) {
+          var inDataView = info.viewer;
+          var inOffset = {
+            value: info.offset.value
+          };
+          var outBuffer = new Uint8Array(info.width * info.lines * (EXRHeader.channels.length * info.type * INT16_SIZE)); // Read compression header information
+
+          var dwaHeader = {
+            version: parseInt64(inDataView, inOffset),
+            unknownUncompressedSize: parseInt64(inDataView, inOffset),
+            unknownCompressedSize: parseInt64(inDataView, inOffset),
+            acCompressedSize: parseInt64(inDataView, inOffset),
+            dcCompressedSize: parseInt64(inDataView, inOffset),
+            rleCompressedSize: parseInt64(inDataView, inOffset),
+            rleUncompressedSize: parseInt64(inDataView, inOffset),
+            rleRawSize: parseInt64(inDataView, inOffset),
+            totalAcUncompressedCount: parseInt64(inDataView, inOffset),
+            totalDcUncompressedCount: parseInt64(inDataView, inOffset),
+            acCompression: parseInt64(inDataView, inOffset)
+          };
+          if (dwaHeader.version < 2) throw 'EXRLoader.parse: ' + EXRHeader.compression + ' version ' + dwaHeader.version + ' is unsupported'; // Read channel ruleset information
+
+          var channelRules = new Array();
+          var ruleSize = parseUint16(inDataView, inOffset) - INT16_SIZE;
+
+          while (ruleSize > 0) {
+            var name = parseNullTerminatedString(inDataView.buffer, inOffset);
+            var value = parseUint8(inDataView, inOffset);
+            var compression = value >> 2 & 3;
+            var csc = (value >> 4) - 1;
+            var index = new Int8Array([csc])[0];
+            var type = parseUint8(inDataView, inOffset);
+            channelRules.push({
+              name: name,
+              index: index,
+              type: type,
+              compression: compression
+            });
+            ruleSize -= name.length + 3;
+          } // Classify channels
+
+
+          var channels = EXRHeader.channels;
+          var channelData = new Array(info.channels);
+
+          for (var i = 0; i < info.channels; ++i) {
+            var cd = channelData[i] = {};
+            var channel = channels[i];
+            cd.name = channel.name;
+            cd.compression = UNKNOWN;
+            cd.decoded = false;
+            cd.type = channel.pixelType;
+            cd.pLinear = channel.pLinear;
+            cd.width = info.width;
+            cd.height = info.lines;
+          }
+
+          var cscSet = {
+            idx: new Array(3)
+          };
+
+          for (var offset = 0; offset < info.channels; ++offset) {
+            var cd = channelData[offset];
+
+            for (var i = 0; i < channelRules.length; ++i) {
+              var rule = channelRules[i];
+
+              if (cd.name == rule.name) {
+                cd.compression = rule.compression;
+
+                if (rule.index >= 0) {
+                  cscSet.idx[rule.index] = offset;
+                }
+
+                cd.offset = offset;
+              }
+            }
+          } // Read DCT - AC component data
+
+
+          if (dwaHeader.acCompressedSize > 0) {
+            switch (dwaHeader.acCompression) {
+              case STATIC_HUFFMAN:
+                var acBuffer = new Uint16Array(dwaHeader.totalAcUncompressedCount);
+                hufUncompress(info.array, inDataView, inOffset, dwaHeader.acCompressedSize, acBuffer, dwaHeader.totalAcUncompressedCount);
+                break;
+
+              case DEFLATE:
+                var compressed = info.array.slice(inOffset.value, inOffset.value + dwaHeader.totalAcUncompressedCount);
+                var data = fflate.unzlibSync(compressed); // eslint-disable-line no-undef
+
+                var acBuffer = new Uint16Array(data.buffer);
+                inOffset.value += dwaHeader.totalAcUncompressedCount;
+                break;
+            }
+          } // Read DCT - DC component data
+
+
+          if (dwaHeader.dcCompressedSize > 0) {
+            var zlibInfo = {
+              array: info.array,
+              offset: inOffset,
+              size: dwaHeader.dcCompressedSize
+            };
+            var dcBuffer = new Uint16Array(uncompressZIP(zlibInfo).buffer);
+            inOffset.value += dwaHeader.dcCompressedSize;
+          } // Read RLE compressed data
+
+
+          if (dwaHeader.rleRawSize > 0) {
+            var compressed = info.array.slice(inOffset.value, inOffset.value + dwaHeader.rleCompressedSize);
+            var data = fflate.unzlibSync(compressed); // eslint-disable-line no-undef
+
+            var rleBuffer = decodeRunLength(data.buffer);
+            inOffset.value += dwaHeader.rleCompressedSize;
+          } // Prepare outbuffer data offset
+
+
+          var outBufferEnd = 0;
+          var rowOffsets = new Array(channelData.length);
+
+          for (var i = 0; i < rowOffsets.length; ++i) {
+            rowOffsets[i] = new Array();
+          }
+
+          for (var y = 0; y < info.lines; ++y) {
+            for (var chan = 0; chan < channelData.length; ++chan) {
+              rowOffsets[chan].push(outBufferEnd);
+              outBufferEnd += channelData[chan].width * info.type * INT16_SIZE;
+            }
+          } // Lossy DCT decode RGB channels
+
+
+          lossyDctDecode(cscSet, rowOffsets, channelData, acBuffer, dcBuffer, outBuffer); // Decode other channels
+
+          for (var i = 0; i < channelData.length; ++i) {
+            var cd = channelData[i];
+            if (cd.decoded) continue;
+
+            switch (cd.compression) {
+              case RLE:
+                var row = 0;
+                var rleOffset = 0;
+
+                for (var y = 0; y < info.lines; ++y) {
+                  var rowOffsetBytes = rowOffsets[i][row];
+
+                  for (var x = 0; x < cd.width; ++x) {
+                    for (var byte = 0; byte < INT16_SIZE * cd.type; ++byte) {
+                      outBuffer[rowOffsetBytes++] = rleBuffer[rleOffset + byte * cd.width * cd.height];
+                    }
+
+                    rleOffset++;
+                  }
+
+                  row++;
+                }
+
+                break;
+
+              case LOSSY_DCT: // skip
+
+              default:
+                throw 'EXRLoader.parse: unsupported channel compression';
+            }
+          }
+
+          return new DataView(outBuffer.buffer);
+        }
+
+        function parseNullTerminatedString(buffer, offset) {
+          var uintBuffer = new Uint8Array(buffer);
+          var endOffset = 0;
+
+          while (uintBuffer[offset.value + endOffset] != 0) {
+            endOffset += 1;
+          }
+
+          var stringValue = new TextDecoder().decode(uintBuffer.slice(offset.value, offset.value + endOffset));
+          offset.value = offset.value + endOffset + 1;
+          return stringValue;
+        }
+
+        function parseFixedLengthString(buffer, offset, size) {
+          var stringValue = new TextDecoder().decode(new Uint8Array(buffer).slice(offset.value, offset.value + size));
+          offset.value = offset.value + size;
+          return stringValue;
+        }
+
+        function parseUlong(dataView, offset) {
+          var uLong = dataView.getUint32(0, true);
+          offset.value = offset.value + ULONG_SIZE;
+          return uLong;
+        }
+
+        function parseRational(dataView, offset) {
+          var x = parseInt32(dataView, offset);
+          var y = parseUint32(dataView, offset);
+          return [x, y];
+        }
+
+        function parseTimecode(dataView, offset) {
+          var x = parseUint32(dataView, offset);
+          var y = parseUint32(dataView, offset);
+          return [x, y];
+        }
+
+        function parseInt32(dataView, offset) {
+          var Int32 = dataView.getInt32(offset.value, true);
+          offset.value = offset.value + INT32_SIZE;
+          return Int32;
+        }
+
+        function parseUint32(dataView, offset) {
+          var Uint32 = dataView.getUint32(offset.value, true);
+          offset.value = offset.value + INT32_SIZE;
+          return Uint32;
+        }
+
+        function parseUint8Array(uInt8Array, offset) {
+          var Uint8 = uInt8Array[offset.value];
+          offset.value = offset.value + INT8_SIZE;
+          return Uint8;
+        }
+
+        function parseUint8(dataView, offset) {
+          var Uint8 = dataView.getUint8(offset.value);
+          offset.value = offset.value + INT8_SIZE;
+          return Uint8;
+        }
+
+        function parseInt64(dataView, offset) {
+          var int = Number(dataView.getBigInt64(offset.value, true));
+          offset.value += ULONG_SIZE;
+          return int;
+        }
+
+        function parseFloat32(dataView, offset) {
+          var float = dataView.getFloat32(offset.value, true);
+          offset.value += FLOAT32_SIZE;
+          return float;
+        }
+
+        function decodeFloat32(dataView, offset) {
+          return _three.DataUtils.toHalfFloat(parseFloat32(dataView, offset));
+        } // https://stackoverflow.com/questions/5678432/decompressing-half-precision-floats-in-javascript
+
+
+        function decodeFloat16(binary) {
+          var exponent = (binary & 0x7C00) >> 10,
+              fraction = binary & 0x03FF;
+          return (binary >> 15 ? -1 : 1) * (exponent ? exponent === 0x1F ? fraction ? NaN : Infinity : Math.pow(2, exponent - 15) * (1 + fraction / 0x400) : 6.103515625e-5 * (fraction / 0x400));
+        }
+
+        function parseUint16(dataView, offset) {
+          var Uint16 = dataView.getUint16(offset.value, true);
+          offset.value += INT16_SIZE;
+          return Uint16;
+        }
+
+        function parseFloat16(buffer, offset) {
+          return decodeFloat16(parseUint16(buffer, offset));
+        }
+
+        function parseChlist(dataView, buffer, offset, size) {
+          var startOffset = offset.value;
+          var channels = [];
+
+          while (offset.value < startOffset + size - 1) {
+            var name = parseNullTerminatedString(buffer, offset);
+            var pixelType = parseInt32(dataView, offset);
+            var pLinear = parseUint8(dataView, offset);
+            offset.value += 3; // reserved, three chars
+
+            var xSampling = parseInt32(dataView, offset);
+            var ySampling = parseInt32(dataView, offset);
+            channels.push({
+              name: name,
+              pixelType: pixelType,
+              pLinear: pLinear,
+              xSampling: xSampling,
+              ySampling: ySampling
+            });
+          }
+
+          offset.value += 1;
+          return channels;
+        }
+
+        function parseChromaticities(dataView, offset) {
+          var redX = parseFloat32(dataView, offset);
+          var redY = parseFloat32(dataView, offset);
+          var greenX = parseFloat32(dataView, offset);
+          var greenY = parseFloat32(dataView, offset);
+          var blueX = parseFloat32(dataView, offset);
+          var blueY = parseFloat32(dataView, offset);
+          var whiteX = parseFloat32(dataView, offset);
+          var whiteY = parseFloat32(dataView, offset);
+          return {
+            redX: redX,
+            redY: redY,
+            greenX: greenX,
+            greenY: greenY,
+            blueX: blueX,
+            blueY: blueY,
+            whiteX: whiteX,
+            whiteY: whiteY
+          };
+        }
+
+        function parseCompression(dataView, offset) {
+          var compressionCodes = ['NO_COMPRESSION', 'RLE_COMPRESSION', 'ZIPS_COMPRESSION', 'ZIP_COMPRESSION', 'PIZ_COMPRESSION', 'PXR24_COMPRESSION', 'B44_COMPRESSION', 'B44A_COMPRESSION', 'DWAA_COMPRESSION', 'DWAB_COMPRESSION'];
+          var compression = parseUint8(dataView, offset);
+          return compressionCodes[compression];
+        }
+
+        function parseBox2i(dataView, offset) {
+          var xMin = parseUint32(dataView, offset);
+          var yMin = parseUint32(dataView, offset);
+          var xMax = parseUint32(dataView, offset);
+          var yMax = parseUint32(dataView, offset);
+          return {
+            xMin: xMin,
+            yMin: yMin,
+            xMax: xMax,
+            yMax: yMax
+          };
+        }
+
+        function parseLineOrder(dataView, offset) {
+          var lineOrders = ['INCREASING_Y'];
+          var lineOrder = parseUint8(dataView, offset);
+          return lineOrders[lineOrder];
+        }
+
+        function parseV2f(dataView, offset) {
+          var x = parseFloat32(dataView, offset);
+          var y = parseFloat32(dataView, offset);
+          return [x, y];
+        }
+
+        function parseV3f(dataView, offset) {
+          var x = parseFloat32(dataView, offset);
+          var y = parseFloat32(dataView, offset);
+          var z = parseFloat32(dataView, offset);
+          return [x, y, z];
+        }
+
+        function parseValue(dataView, buffer, offset, type, size) {
+          if (type === 'string' || type === 'stringvector' || type === 'iccProfile') {
+            return parseFixedLengthString(buffer, offset, size);
+          } else if (type === 'chlist') {
+            return parseChlist(dataView, buffer, offset, size);
+          } else if (type === 'chromaticities') {
+            return parseChromaticities(dataView, offset);
+          } else if (type === 'compression') {
+            return parseCompression(dataView, offset);
+          } else if (type === 'box2i') {
+            return parseBox2i(dataView, offset);
+          } else if (type === 'lineOrder') {
+            return parseLineOrder(dataView, offset);
+          } else if (type === 'float') {
+            return parseFloat32(dataView, offset);
+          } else if (type === 'v2f') {
+            return parseV2f(dataView, offset);
+          } else if (type === 'v3f') {
+            return parseV3f(dataView, offset);
+          } else if (type === 'int') {
+            return parseInt32(dataView, offset);
+          } else if (type === 'rational') {
+            return parseRational(dataView, offset);
+          } else if (type === 'timecode') {
+            return parseTimecode(dataView, offset);
+          } else if (type === 'preview') {
+            offset.value += size;
+            return 'skipped';
+          } else {
+            offset.value += size;
+            return undefined;
+          }
+        }
+
+        var bufferDataView = new DataView(buffer);
+        var uInt8Array = new Uint8Array(buffer);
+        var EXRHeader = {};
+        bufferDataView.getUint32(0, true); // magic
+
+        bufferDataView.getUint8(4, true); // versionByteZero
+
+        bufferDataView.getUint8(5, true); // fullMask
+        // start of header
+
+        var offset = {
+          value: 8
+        }; // start at 8, after magic stuff
+
+        var keepReading = true;
+
+        while (keepReading) {
+          var attributeName = parseNullTerminatedString(buffer, offset);
+
+          if (attributeName == 0) {
+            keepReading = false;
+          } else {
+            var attributeType = parseNullTerminatedString(buffer, offset);
+            var attributeSize = parseUint32(bufferDataView, offset);
+            var attributeValue = parseValue(bufferDataView, buffer, offset, attributeType, attributeSize);
+
+            if (attributeValue === undefined) {
+              console.warn("EXRLoader.parse: skipped unknown header attribute type '".concat(attributeType, "'."));
+            } else {
+              EXRHeader[attributeName] = attributeValue;
+            }
+          }
+        } // offsets
+
+
+        var dataWindowHeight = EXRHeader.dataWindow.yMax + 1;
+        var uncompress;
+        var scanlineBlockSize;
+
+        switch (EXRHeader.compression) {
+          case 'NO_COMPRESSION':
+            scanlineBlockSize = 1;
+            uncompress = uncompressRAW;
+            break;
+
+          case 'RLE_COMPRESSION':
+            scanlineBlockSize = 1;
+            uncompress = uncompressRLE;
+            break;
+
+          case 'ZIPS_COMPRESSION':
+            scanlineBlockSize = 1;
+            uncompress = uncompressZIP;
+            break;
+
+          case 'ZIP_COMPRESSION':
+            scanlineBlockSize = 16;
+            uncompress = uncompressZIP;
+            break;
+
+          case 'PIZ_COMPRESSION':
+            scanlineBlockSize = 32;
+            uncompress = uncompressPIZ;
+            break;
+
+          case 'PXR24_COMPRESSION':
+            scanlineBlockSize = 16;
+            uncompress = uncompressPXR;
+            break;
+
+          case 'DWAA_COMPRESSION':
+            scanlineBlockSize = 32;
+            uncompress = uncompressDWA;
+            break;
+
+          case 'DWAB_COMPRESSION':
+            scanlineBlockSize = 256;
+            uncompress = uncompressDWA;
+            break;
+
+          default:
+            throw 'EXRLoader.parse: ' + EXRHeader.compression + ' is unsupported';
+        }
+
+        var size_t;
+        var getValue; // mixed pixelType not supported
+
+        var pixelType = EXRHeader.channels[0].pixelType;
+
+        if (pixelType === 1) {
+          // half
+          switch (this.type) {
+            case _three.UnsignedByteType:
+            case _three.FloatType:
+              getValue = parseFloat16;
+              size_t = INT16_SIZE;
+              break;
+
+            case _three.HalfFloatType:
+              getValue = parseUint16;
+              size_t = INT16_SIZE;
+              break;
+          }
+        } else if (pixelType === 2) {
+          // float
+          switch (this.type) {
+            case _three.UnsignedByteType:
+            case _three.FloatType:
+              getValue = parseFloat32;
+              size_t = FLOAT32_SIZE;
+              break;
+
+            case _three.HalfFloatType:
+              getValue = decodeFloat32;
+              size_t = FLOAT32_SIZE;
+          }
+        } else {
+          throw 'EXRLoader.parse: unsupported pixelType ' + pixelType + ' for ' + EXRHeader.compression + '.';
+        }
+
+        var numBlocks = dataWindowHeight / scanlineBlockSize;
+
+        for (var i = 0; i < numBlocks; i++) {
+          parseUlong(bufferDataView, offset); // scanlineOffset
+        } // we should be passed the scanline offset table, start reading pixel data
+
+
+        var width = EXRHeader.dataWindow.xMax - EXRHeader.dataWindow.xMin + 1;
+        var height = EXRHeader.dataWindow.yMax - EXRHeader.dataWindow.yMin + 1; // Firefox only supports RGBA (half) float textures
+        // var numChannels = EXRHeader.channels.length;
+
+        var numChannels = 4;
+        var size = width * height * numChannels; // Fill initially with 1s for the alpha value if the texture is not RGBA, RGB values will be overwritten
+
+        switch (this.type) {
+          case _three.UnsignedByteType:
+          case _three.FloatType:
+            var byteArray = new Float32Array(size);
+
+            if (EXRHeader.channels.length < numChannels) {
+              byteArray.fill(1, 0, size);
+            }
+
+            break;
+
+          case _three.HalfFloatType:
+            var byteArray = new Uint16Array(size);
+
+            if (EXRHeader.channels.length < numChannels) {
+              byteArray.fill(0x3C00, 0, size); // Uint16Array holds half float data, 0x3C00 is 1
+            }
+
+            break;
+
+          default:
+            console.error('THREE.EXRLoader: unsupported type: ', this.type);
+            break;
+        }
+
+        var channelOffsets = {
+          R: 0,
+          G: 1,
+          B: 2,
+          A: 3
+        };
+        var compressionInfo = {
+          size: 0,
+          width: width,
+          lines: scanlineBlockSize,
+          offset: offset,
+          array: uInt8Array,
+          viewer: bufferDataView,
+          type: pixelType,
+          channels: EXRHeader.channels.length
+        };
+        var line;
+        var size;
+        var viewer;
+        var tmpOffset = {
+          value: 0
+        };
+
+        for (var scanlineBlockIdx = 0; scanlineBlockIdx < height / scanlineBlockSize; scanlineBlockIdx++) {
+          line = parseUint32(bufferDataView, offset); // line_no
+
+          size = parseUint32(bufferDataView, offset); // data_len
+
+          compressionInfo.lines = line + scanlineBlockSize > height ? height - line : scanlineBlockSize;
+          compressionInfo.offset = offset;
+          compressionInfo.size = size;
+          viewer = uncompress(compressionInfo);
+          offset.value += size;
+
+          for (var line_y = 0; line_y < scanlineBlockSize; line_y++) {
+            var true_y = line_y + scanlineBlockIdx * scanlineBlockSize;
+            if (true_y >= height) break;
+
+            for (var channelID = 0; channelID < EXRHeader.channels.length; channelID++) {
+              var cOff = channelOffsets[EXRHeader.channels[channelID].name];
+
+              for (var x = 0; x < width; x++) {
+                var idx = line_y * (EXRHeader.channels.length * width) + channelID * width + x;
+                tmpOffset.value = idx * size_t;
+                var val = getValue(viewer, tmpOffset);
+                byteArray[(height - 1 - true_y) * (width * numChannels) + x * numChannels + cOff] = val;
+              }
+            }
+          }
+        }
+
+        if (this.type === _three.UnsignedByteType) {
+          var v, _i;
+
+          var _size = byteArray.length;
+          var RGBEArray = new Uint8Array(_size);
+
+          for (var h = 0; h < height; ++h) {
+            for (var w = 0; w < width; ++w) {
+              _i = h * width * 4 + w * 4;
+              var red = byteArray[_i];
+              var green = byteArray[_i + 1];
+              var blue = byteArray[_i + 2];
+              v = red > green ? red : green;
+              v = blue > v ? blue : v;
+
+              if (v < 1e-32) {
+                RGBEArray[_i] = RGBEArray[_i + 1] = RGBEArray[_i + 2] = RGBEArray[_i + 3] = 0;
+              } else {
+                var res = frexp(v);
+                v = res[0] * 256 / v;
+                RGBEArray[_i] = red * v;
+                RGBEArray[_i + 1] = green * v;
+                RGBEArray[_i + 2] = blue * v;
+                RGBEArray[_i + 3] = res[1] + 128;
+              }
+            }
+          }
+
+          byteArray = RGBEArray;
+        }
+
+        var format = this.type === _three.UnsignedByteType ? _three.RGBEFormat : numChannels === 4 ? _three.RGBAFormat : _three.RGBFormat;
+        return {
+          header: EXRHeader,
+          width: width,
+          height: height,
+          data: byteArray,
+          format: format,
+          type: this.type
+        };
+      }
+    }, {
+      key: "setDataType",
+      value: function setDataType(value) {
+        this.type = value;
+        return this;
+      }
+    }, {
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        function onLoadCallback(texture, texData) {
+          switch (texture.type) {
+            case _three.UnsignedByteType:
+              texture.encoding = _three.RGBEEncoding;
+              texture.minFilter = _three.NearestFilter;
+              texture.magFilter = _three.NearestFilter;
+              texture.generateMipmaps = false;
+              texture.flipY = false;
+              break;
+
+            case _three.FloatType:
+            case _three.HalfFloatType:
+              texture.encoding = _three.LinearEncoding;
+              texture.minFilter = _three.LinearFilter;
+              texture.magFilter = _three.LinearFilter;
+              texture.generateMipmaps = false;
+              texture.flipY = false;
+              break;
+          }
+
+          if (onLoad) onLoad(texture, texData);
+        }
+
+        return _get(_getPrototypeOf(EXRLoader.prototype), "load", this).call(this, url, onLoadCallback, onProgress, onError);
+      }
+    }]);
+
+    return EXRLoader;
+  }(_three.DataTextureLoader);
+
+  _exports.EXRLoader = EXRLoader;
+});