@aether-stack-dev/client-sdk 1.2.5 → 1.3.0

package/dist/react.esm.js

@@ -3,8 +3,17 @@ import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
 import { EventEmitter } from 'eventemitter3';
 import { jsxs, jsx } from 'react/jsx-runtime';
 import * as THREE from 'three';
+import { DataTextureLoader, HalfFloatType, RGBAFormat, RGFormat, LinearSRGBColorSpace, RedFormat, FloatType, LinearFilter, DataUtils } from 'three';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
 import { VRMLoaderPlugin, VRMHumanBoneName } from '@pixiv/three-vrm';
+import { VRMAnimationLoaderPlugin, createVRMAnimationClip } from '@pixiv/three-vrm-animation';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
+import { UnrealBloomPass } from 'three/examples/jsm/postprocessing/UnrealBloomPass.js';
+import { SSAOPass } from 'three/examples/jsm/postprocessing/SSAOPass.js';
+import { BokehPass } from 'three/examples/jsm/postprocessing/BokehPass.js';
+import { OutputPass } from 'three/examples/jsm/postprocessing/OutputPass.js';
+import { RGBELoader } from 'three/examples/jsm/loaders/RGBELoader.js';
 
 const ARKIT_BLENDSHAPES = [
     'jawOpen', 'jawForward', 'jawLeft', 'jawRight',
@@ -28,8 +37,18 @@ const CRITICAL_BLENDSHAPES = [
     'jawOpen', 'eyeBlinkLeft', 'eyeBlinkRight',
 ];
 const DEFAULT_BLENDSHAPE_MAP = Object.fromEntries(ARKIT_BLENDSHAPES.map(name => [name, name]));
-({
-    ...DEFAULT_BLENDSHAPE_MAP});
+const VROID_BLENDSHAPE_MAP = {
+    ...DEFAULT_BLENDSHAPE_MAP,
+    jawOpen: 'Fcl_MTH_A',
+    mouthFunnel: 'Fcl_MTH_U',
+    mouthSmileLeft: 'Fcl_MTH_Fun',
+    mouthSmileRight: 'Fcl_MTH_Fun',
+    eyeBlinkLeft: 'Fcl_EYE_Close_L',
+    eyeBlinkRight: 'Fcl_EYE_Close_R',
+    browDownLeft: 'Fcl_BRW_Angry_L',
+    browDownRight: 'Fcl_BRW_Angry_R',
+    browInnerUp: 'Fcl_BRW_Surprised',
+};
 
 const IDX_JAW_OPEN = ARKIT_BLENDSHAPES.indexOf('jawOpen');
 const IDX_MOUTH_FUNNEL = ARKIT_BLENDSHAPES.indexOf('mouthFunnel');
@@ -797,7 +816,6 @@ function useAStackCSR(options) {
     };
 }
 
-const DEFAULT_MAX_MODEL_SIZE = 30 * 1024 * 1024; // 30MB
 const HIGH_VERTEX_THRESHOLD = 100000;
 function buildCompatibilityReport(vrm) {
     const foundNames = new Set();
@@ -834,67 +852,3328 @@ function buildCompatibilityReport(vrm) {
     const supported = [];
     const missing = [];
     for (const name of ARKIT_BLENDSHAPES) {
-        if (foundNames.has(name) || foundNames.has(name.toLowerCase())) {
+        const vroidMapped = VROID_BLENDSHAPE_MAP[name];
+        if (foundNames.has(name) || foundNames.has(name.toLowerCase())
+            || (vroidMapped && (foundNames.has(vroidMapped) || foundNames.has(vroidMapped.toLowerCase())))) {
             supported.push(name);
         }
         else {
-            missing.push(name);
-        }
-    }
-    const warnings = [];
-    for (const name of CRITICAL_BLENDSHAPES) {
-        if (missing.includes(name)) {
-            warnings.push(`Missing critical blendshape: ${name}`);
+            missing.push(name);
+        }
+    }
+    const warnings = [];
+    for (const name of CRITICAL_BLENDSHAPES) {
+        if (missing.includes(name)) {
+            warnings.push(`Missing critical blendshape: ${name}`);
+        }
+    }
+    if (vertexCount > HIGH_VERTEX_THRESHOLD) {
+        warnings.push(`High vertex count (${vertexCount.toLocaleString()}) may impact performance`);
+    }
+    return {
+        supported: supported.length,
+        missing,
+        warnings,
+        modelStats: { vertexCount, textureCount, morphTargetCount },
+    };
+}
+
+function createPostProcessing(renderer, scene, camera, config, width, height) {
+    const composer = new EffectComposer(renderer);
+    composer.addPass(new RenderPass(scene, camera));
+    if (config.bloom !== undefined && config.bloom > 0) {
+        composer.addPass(new UnrealBloomPass(new THREE.Vector2(width, height), config.bloom * 0.8, 0.4, 0.85));
+    }
+    if (config.ao !== undefined && config.ao > 0) {
+        const ssao = new SSAOPass(scene, camera, width, height);
+        ssao.kernelRadius = 8 * config.ao;
+        ssao.minDistance = 0.005;
+        ssao.maxDistance = 0.1;
+        composer.addPass(ssao);
+    }
+    if (config.dof) {
+        composer.addPass(new BokehPass(scene, camera, { focus: 1.4, aperture: 0.002, maxblur: 0.005 }));
+    }
+    composer.addPass(new OutputPass());
+    return {
+        composer,
+        dispose: () => { composer.renderTarget1.dispose(); composer.renderTarget2.dispose(); },
+        setSize: (w, h) => composer.setSize(w, h),
+    };
+}
+const FPS_SAMPLE_SIZE = 60;
+const FPS_THRESHOLD = 30;
+class FpsMonitor {
+    constructor() {
+        this.samples = [];
+        this.lastTime = 0;
+        this.disabled = false;
+    }
+    tick(time) {
+        if (this.lastTime > 0) {
+            const delta = time - this.lastTime;
+            if (delta > 0)
+                this.samples.push(1000 / delta);
+            if (this.samples.length > FPS_SAMPLE_SIZE)
+                this.samples.shift();
+        }
+        this.lastTime = time;
+        if (this.samples.length >= FPS_SAMPLE_SIZE) {
+            const avg = this.samples.reduce((a, b) => a + b, 0) / this.samples.length;
+            if (avg < FPS_THRESHOLD) {
+                this.disabled = true;
+                console.warn(`[VRM] Post-processing auto-disabled (avg FPS: ${avg.toFixed(0)})`);
+            }
+        }
+    }
+    reset() {
+        this.samples = [];
+        this.lastTime = 0;
+        this.disabled = false;
+    }
+}
+
+/*!
+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
+*/
+
+
+// aliases for shorter compressed code (most minifers don't do this)
+var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
+// fixed length extra bits
+var fleb = new u8([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]);
+// fixed distance extra bits
+var fdeb = new u8([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]);
+// code length index map
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+// get base, reverse index map from extra bits
+var freb = function (eb, start) {
+    var b = new u16(31);
+    for (var i = 0; i < 31; ++i) {
+        b[i] = start += 1 << eb[i - 1];
+    }
+    // numbers here are at max 18 bits
+    var r = new i32(b[30]);
+    for (var i = 1; i < 30; ++i) {
+        for (var j = b[i]; j < b[i + 1]; ++j) {
+            r[j] = ((j - b[i]) << 5) | i;
+        }
+    }
+    return { b: b, r: r };
+};
+var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
+// we can ignore the fact that the other numbers are wrong; they never happen anyway
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0), fd = _b.b;
+// map of value to reverse (assuming 16 bits)
+var rev = new u16(32768);
+for (var i = 0; i < 32768; ++i) {
+    // reverse table algorithm from SO
+    var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);
+    x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);
+    x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);
+    rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;
+}
+// create huffman tree from u8 "map": index -> code length for code index
+// mb (max bits) must be at most 15
+// TODO: optimize/split up?
+var hMap = (function (cd, mb, r) {
+    var s = cd.length;
+    // index
+    var i = 0;
+    // u16 "map": index -> # of codes with bit length = index
+    var l = new u16(mb);
+    // length of cd must be 288 (total # of codes)
+    for (; i < s; ++i) {
+        if (cd[i])
+            ++l[cd[i] - 1];
+    }
+    // u16 "map": index -> minimum code for bit length = index
+    var le = new u16(mb);
+    for (i = 1; i < mb; ++i) {
+        le[i] = (le[i - 1] + l[i - 1]) << 1;
+    }
+    var co;
+    if (r) {
+        // u16 "map": index -> number of actual bits, symbol for code
+        co = new u16(1 << mb);
+        // bits to remove for reverser
+        var rvb = 15 - mb;
+        for (i = 0; i < s; ++i) {
+            // ignore 0 lengths
+            if (cd[i]) {
+                // num encoding both symbol and bits read
+                var sv = (i << 4) | cd[i];
+                // free bits
+                var r_1 = mb - cd[i];
+                // start value
+                var v = le[cd[i] - 1]++ << r_1;
+                // m is end value
+                for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
+                    // every 16 bit value starting with the code yields the same result
+                    co[rev[v] >> rvb] = sv;
+                }
+            }
+        }
+    }
+    else {
+        co = new u16(s);
+        for (i = 0; i < s; ++i) {
+            if (cd[i]) {
+                co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);
+            }
+        }
+    }
+    return co;
+});
+// fixed length tree
+var flt = new u8(288);
+for (var i = 0; i < 144; ++i)
+    flt[i] = 8;
+for (var i = 144; i < 256; ++i)
+    flt[i] = 9;
+for (var i = 256; i < 280; ++i)
+    flt[i] = 7;
+for (var i = 280; i < 288; ++i)
+    flt[i] = 8;
+// fixed distance tree
+var fdt = new u8(32);
+for (var i = 0; i < 32; ++i)
+    fdt[i] = 5;
+// fixed length map
+var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
+// fixed distance map
+var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
+// find max of array
+var max = function (a) {
+    var m = a[0];
+    for (var i = 1; i < a.length; ++i) {
+        if (a[i] > m)
+            m = a[i];
+    }
+    return m;
+};
+// read d, starting at bit p and mask with m
+var bits = function (d, p, m) {
+    var o = (p / 8) | 0;
+    return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;
+};
+// read d, starting at bit p continuing for at least 16 bits
+var bits16 = function (d, p) {
+    var o = (p / 8) | 0;
+    return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));
+};
+// get end of byte
+var shft = function (p) { return ((p + 7) / 8) | 0; };
+// typed array slice - allows garbage collector to free original reference,
+// while being more compatible than .slice
+var slc = function (v, s, e) {
+    if (e == null || e > v.length)
+        e = v.length;
+    // can't use .constructor in case user-supplied
+    return new u8(v.subarray(s, e));
+};
+// error codes
+var ec = [
+    '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
+];
+var err = function (ind, msg, nt) {
+    var e = new Error(msg || ec[ind]);
+    e.code = ind;
+    if (Error.captureStackTrace)
+        Error.captureStackTrace(e, err);
+    if (!nt)
+        throw e;
+    return e;
+};
+// expands raw DEFLATE data
+var inflt = function (dat, st, buf, dict) {
+    // source length       dict length
+    var sl = dat.length, dl = 0;
+    if (!sl || st.f && !st.l)
+        return buf || new u8(0);
+    var noBuf = !buf;
+    // have to estimate size
+    var resize = noBuf || st.i != 2;
+    // no state
+    var noSt = st.i;
+    // Assumes roughly 33% compression ratio average
+    if (noBuf)
+        buf = new u8(sl * 3);
+    // ensure buffer can fit at least l elements
+    var cbuf = function (l) {
+        var bl = buf.length;
+        // need to increase size to fit
+        if (l > bl) {
+            // Double or set to necessary, whichever is greater
+            var nbuf = new u8(Math.max(bl * 2, l));
+            nbuf.set(buf);
+            buf = nbuf;
+        }
+    };
+    //  last chunk         bitpos           bytes
+    var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+    // total bits
+    var tbts = sl * 8;
+    do {
+        if (!lm) {
+            // BFINAL - this is only 1 when last chunk is next
+            final = bits(dat, pos, 1);
+            // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman
+            var type = bits(dat, pos + 1, 3);
+            pos += 3;
+            if (!type) {
+                // go to end of byte boundary
+                var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
+                if (t > sl) {
+                    if (noSt)
+                        err(0);
+                    break;
+                }
+                // ensure size
+                if (resize)
+                    cbuf(bt + l);
+                // Copy over uncompressed data
+                buf.set(dat.subarray(s, t), bt);
+                // Get new bitpos, update byte count
+                st.b = bt += l, st.p = pos = t * 8, st.f = final;
+                continue;
+            }
+            else if (type == 1)
+                lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+            else if (type == 2) {
+                //  literal                            lengths
+                var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+                var tl = hLit + bits(dat, pos + 5, 31) + 1;
+                pos += 14;
+                // length+distance tree
+                var ldt = new u8(tl);
+                // code length tree
+                var clt = new u8(19);
+                for (var i = 0; i < hcLen; ++i) {
+                    // use index map to get real code
+                    clt[clim[i]] = bits(dat, pos + i * 3, 7);
+                }
+                pos += hcLen * 3;
+                // code lengths bits
+                var clb = max(clt), clbmsk = (1 << clb) - 1;
+                // code lengths map
+                var clm = hMap(clt, clb, 1);
+                for (var i = 0; i < tl;) {
+                    var r = clm[bits(dat, pos, clbmsk)];
+                    // bits read
+                    pos += r & 15;
+                    // symbol
+                    var s = r >> 4;
+                    // code length to copy
+                    if (s < 16) {
+                        ldt[i++] = s;
+                    }
+                    else {
+                        //  copy   count
+                        var c = 0, n = 0;
+                        if (s == 16)
+                            n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                        else if (s == 17)
+                            n = 3 + bits(dat, pos, 7), pos += 3;
+                        else if (s == 18)
+                            n = 11 + bits(dat, pos, 127), pos += 7;
+                        while (n--)
+                            ldt[i++] = c;
+                    }
+                }
+                //    length tree                 distance tree
+                var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+                // max length bits
+                lbt = max(lt);
+                // max dist bits
+                dbt = max(dt);
+                lm = hMap(lt, lbt, 1);
+                dm = hMap(dt, dbt, 1);
+            }
+            else
+                err(1);
+            if (pos > tbts) {
+                if (noSt)
+                    err(0);
+                break;
+            }
+        }
+        // Make sure the buffer can hold this + the largest possible addition
+        // Maximum chunk size (practically, theoretically infinite) is 2^17
+        if (resize)
+            cbuf(bt + 131072);
+        var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+        var lpos = pos;
+        for (;; lpos = pos) {
+            // bits read, code
+            var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+            pos += c & 15;
+            if (pos > tbts) {
+                if (noSt)
+                    err(0);
+                break;
+            }
+            if (!c)
+                err(2);
+            if (sym < 256)
+                buf[bt++] = sym;
+            else if (sym == 256) {
+                lpos = pos, lm = null;
+                break;
+            }
+            else {
+                var add = sym - 254;
+                // no extra bits needed if less
+                if (sym > 264) {
+                    // index
+                    var i = sym - 257, b = fleb[i];
+                    add = bits(dat, pos, (1 << b) - 1) + fl[i];
+                    pos += b;
+                }
+                // dist
+                var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+                if (!d)
+                    err(3);
+                pos += d & 15;
+                var dt = fd[dsym];
+                if (dsym > 3) {
+                    var b = fdeb[dsym];
+                    dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+                }
+                if (pos > tbts) {
+                    if (noSt)
+                        err(0);
+                    break;
+                }
+                if (resize)
+                    cbuf(bt + 131072);
+                var end = bt + add;
+                if (bt < dt) {
+                    var shift = dl - dt, dend = Math.min(dt, end);
+                    if (shift + bt < 0)
+                        err(3);
+                    for (; bt < dend; ++bt)
+                        buf[bt] = dict[shift + bt];
+                }
+                for (; bt < end; ++bt)
+                    buf[bt] = buf[bt - dt];
+            }
+        }
+        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+        if (lm)
+            final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+    } while (!final);
+    // don't reallocate for streams or user buffers
+    return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+// empty
+var et = /*#__PURE__*/ new u8(0);
+// zlib start
+var zls = function (d, dict) {
+    if ((d[0] & 15) != 8 || (d[0] >> 4) > 7 || ((d[0] << 8 | d[1]) % 31))
+        err(6, 'invalid zlib data');
+    if ((d[1] >> 5 & 1) == 1)
+        err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary');
+    return (d[1] >> 3 & 4) + 2;
+};
+/**
+ * Expands Zlib data
+ * @param data The data to decompress
+ * @param opts The decompression options
+ * @returns The decompressed version of the data
+ */
+function unzlibSync(data, opts) {
+    return inflt(data.subarray(zls(data), -4), { i: 2 }, opts, opts);
+}
+// text decoder
+var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();
+// text decoder stream
+var tds = 0;
+try {
+    td.decode(et, { stream: true });
+    tds = 1;
+}
+catch (e) { }
+
+// 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 -------------------------------------------------
+
+
+/**
+ * A loader for the OpenEXR texture format.
+ *
+ * `EXRLoader` currently supports uncompressed, ZIP(S), RLE, PIZ and DWA/B compression.
+ * Supports reading as UnsignedByte, HalfFloat and Float type data texture.
+ *
+ * ```js
+ * const loader = new EXRLoader();
+ * const texture = await loader.loadAsync( 'textures/memorial.exr' );
+ * ```
+ *
+ * @augments DataTextureLoader
+ * @three_import import { EXRLoader } from 'three/addons/loaders/EXRLoader.js';
+ */
+class EXRLoader extends DataTextureLoader {
+
+	/**
+	 * Constructs a new EXR loader.
+	 *
+	 * @param {LoadingManager} [manager] - The loading manager.
+	 */
+	constructor( manager ) {
+
+		super( manager );
+
+		/**
+		 * The texture type.
+		 *
+		 * @type {(HalfFloatType|FloatType)}
+		 * @default HalfFloatType
+		 */
+		this.type = HalfFloatType;
+
+		/**
+		 * Texture output format.
+		 *
+		 * @type {(RGBAFormat|RGFormat|RedFormat)}
+		 * @default RGBAFormat
+		 */
+		this.outputFormat = RGBAFormat;
+
+	}
+
+	/**
+	 * Parses the given EXR texture data.
+	 *
+	 * @param {ArrayBuffer} buffer - The raw texture data.
+	 * @return {DataTextureLoader~TexData} An object representing the parsed texture data.
+	 */
+	parse( buffer ) {
+
+		const USHORT_RANGE = ( 1 << 16 );
+		const BITMAP_SIZE = ( USHORT_RANGE >> 3 );
+
+		const HUF_ENCBITS = 16; // literal (value) bit length
+		const HUF_DECBITS = 14; // decoding bit size (>= 8)
+
+		const HUF_ENCSIZE = ( 1 << HUF_ENCBITS ) + 1; // encoding table size
+		const HUF_DECSIZE = 1 << HUF_DECBITS; // decoding table size
+		const HUF_DECMASK = HUF_DECSIZE - 1;
+
+		const NBITS = 16;
+		const A_OFFSET = 1 << ( NBITS - 1 );
+		const MOD_MASK = ( 1 << NBITS ) - 1;
+
+		const SHORT_ZEROCODE_RUN = 59;
+		const LONG_ZEROCODE_RUN = 63;
+		const SHORTEST_LONG_RUN = 2 + LONG_ZEROCODE_RUN - SHORT_ZEROCODE_RUN;
+
+		const ULONG_SIZE = 8;
+		const FLOAT32_SIZE = 4;
+		const INT32_SIZE = 4;
+		const INT16_SIZE = 2;
+		const INT8_SIZE = 1;
+
+		const STATIC_HUFFMAN = 0;
+		const DEFLATE = 1;
+
+		const UNKNOWN = 0;
+		const LOSSY_DCT = 1;
+		const RLE = 2;
+
+		const logBase = Math.pow( 2.7182818, 2.2 );
+
+		function reverseLutFromBitmap( bitmap, lut ) {
+
+			let k = 0;
+
+			for ( let i = 0; i < USHORT_RANGE; ++ i ) {
+
+				if ( ( i == 0 ) || ( bitmap[ i >> 3 ] & ( 1 << ( i & 7 ) ) ) ) {
+
+					lut[ k ++ ] = i;
+
+				}
+
+			}
+
+			const n = k - 1;
+
+			while ( k < USHORT_RANGE ) lut[ k ++ ] = 0;
+
+			return n;
+
+		}
+
+		function hufClearDecTable( hdec ) {
+
+			for ( let i = 0; i < HUF_DECSIZE; i ++ ) {
+
+				hdec[ i ] = {};
+				hdec[ i ].len = 0;
+				hdec[ i ].lit = 0;
+				hdec[ i ].p = null;
+
+			}
+
+		}
+
+		const 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;
+
+		}
+
+		const hufTableBuffer = new Array( 59 );
+
+		function hufCanonicalCodeTable( hcode ) {
+
+			for ( let i = 0; i <= 58; ++ i ) hufTableBuffer[ i ] = 0;
+			for ( let i = 0; i < HUF_ENCSIZE; ++ i ) hufTableBuffer[ hcode[ i ] ] += 1;
+
+			let c = 0;
+
+			for ( let i = 58; i > 0; -- i ) {
+
+				const nc = ( ( c + hufTableBuffer[ i ] ) >> 1 );
+				hufTableBuffer[ i ] = c;
+				c = nc;
+
+			}
+
+			for ( let i = 0; i < HUF_ENCSIZE; ++ i ) {
+
+				const l = hcode[ i ];
+				if ( l > 0 ) hcode[ i ] = l | ( hufTableBuffer[ l ] ++ << 6 );
+
+			}
+
+		}
+
+		function hufUnpackEncTable( uInt8Array, inOffset, ni, im, iM, hcode ) {
+
+			const p = inOffset;
+			let c = 0;
+			let lc = 0;
+
+			for ( ; im <= iM; im ++ ) {
+
+				if ( p.value - inOffset.value > ni ) return false;
+
+				getBits( 6, c, lc, uInt8Array, p );
+
+				const l = getBitsReturn.l;
+				c = getBitsReturn.c;
+				lc = getBitsReturn.lc;
+
+				hcode[ im ] = l;
+
+				if ( l == LONG_ZEROCODE_RUN ) {
+
+					if ( p.value - inOffset.value > ni ) {
+
+						throw new Error( 'Something wrong with hufUnpackEncTable' );
+
+					}
+
+					getBits( 8, c, lc, uInt8Array, p );
+
+					let zerun = getBitsReturn.l + SHORTEST_LONG_RUN;
+					c = getBitsReturn.c;
+					lc = getBitsReturn.lc;
+
+					if ( im + zerun > iM + 1 ) {
+
+						throw new Error( 'Something wrong with hufUnpackEncTable' );
+
+					}
+
+					while ( zerun -- ) hcode[ im ++ ] = 0;
+
+					im --;
+
+				} else if ( l >= SHORT_ZEROCODE_RUN ) {
+
+					let zerun = l - SHORT_ZEROCODE_RUN + 2;
+
+					if ( im + zerun > iM + 1 ) {
+
+						throw new Error( '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 ++ ) {
+
+				const c = hufCode( hcode[ im ] );
+				const l = hufLength( hcode[ im ] );
+
+				if ( c >> l ) {
+
+					throw new Error( 'Invalid table entry' );
+
+				}
+
+				if ( l > HUF_DECBITS ) {
+
+					const pl = hdecod[ ( c >> ( l - HUF_DECBITS ) ) ];
+
+					if ( pl.len ) {
+
+						throw new Error( 'Invalid table entry' );
+
+					}
+
+					pl.lit ++;
+
+					if ( pl.p ) {
+
+						const p = pl.p;
+						pl.p = new Array( pl.lit );
+
+						for ( let 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 ) {
+
+					let plOffset = 0;
+
+					for ( let i = 1 << ( HUF_DECBITS - l ); i > 0; i -- ) {
+
+						const pl = hdecod[ ( c << ( HUF_DECBITS - l ) ) + plOffset ];
+
+						if ( pl.len || pl.p ) {
+
+							throw new Error( 'Invalid table entry' );
+
+						}
+
+						pl.len = l;
+						pl.lit = im;
+
+						plOffset ++;
+
+					}
+
+				}
+
+			}
+
+			return true;
+
+		}
+
+		const 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;
+
+		}
+
+		const getCodeReturn = { c: 0, lc: 0 };
+
+		function getCode( po, rlc, c, lc, uInt8Array, inOffset, outBuffer, outBufferOffset, outBufferEndOffset ) {
+
+			if ( po == rlc ) {
+
+				if ( lc < 8 ) {
+
+					getChar( c, lc, uInt8Array, inOffset );
+					c = getCharReturn.c;
+					lc = getCharReturn.lc;
+
+				}
+
+				lc -= 8;
+
+				let cs = ( c >> lc );
+				cs = new Uint8Array( [ cs ] )[ 0 ];
+
+				if ( outBufferOffset.value + cs > outBufferEndOffset ) {
+
+					return false;
+
+				}
+
+				const 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 ) {
+
+			const ref = UInt16( value );
+			return ( ref > 0x7FFF ) ? ref - 0x10000 : ref;
+
+		}
+
+		const wdec14Return = { a: 0, b: 0 };
+
+		function wdec14( l, h ) {
+
+			const ls = Int16( l );
+			const hs = Int16( h );
+
+			const hi = hs;
+			const ai = ls + ( hi & 1 ) + ( hi >> 1 );
+
+			const as = ai;
+			const bs = ai - hi;
+
+			wdec14Return.a = as;
+			wdec14Return.b = bs;
+
+		}
+
+		function wdec16( l, h ) {
+
+			const m = UInt16( l );
+			const d = UInt16( h );
+
+			const bb = ( m - ( d >> 1 ) ) & MOD_MASK;
+			const aa = ( d + bb - A_OFFSET ) & MOD_MASK;
+
+			wdec14Return.a = aa;
+			wdec14Return.b = bb;
+
+		}
+
+		function wav2Decode( buffer, j, nx, ox, ny, oy, mx ) {
+
+			const w14 = mx < ( 1 << 14 );
+			const n = ( nx > ny ) ? ny : nx;
+			let p = 1;
+			let p2;
+			let py;
+
+			while ( p <= n ) p <<= 1;
+
+			p >>= 1;
+			p2 = p;
+			p >>= 1;
+
+			while ( p >= 1 ) {
+
+				py = 0;
+				const ey = py + oy * ( ny - p2 );
+				const oy1 = oy * p;
+				const oy2 = oy * p2;
+				const ox1 = ox * p;
+				const ox2 = ox * p2;
+				let i00, i01, i10, i11;
+
+				for ( ; py <= ey; py += oy2 ) {
+
+					let px = py;
+					const ex = py + ox * ( nx - p2 );
+
+					for ( ; px <= ex; px += ox2 ) {
+
+						const p01 = px + ox1;
+						const p10 = px + oy1;
+						const 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 ) {
+
+						const 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 ) {
+
+					let px = py;
+					const ex = py + ox * ( nx - p2 );
+
+					for ( ; px <= ex; px += ox2 ) {
+
+						const 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, inOffset, ni, rlc, no, outBuffer, outOffset ) {
+
+			let c = 0;
+			let lc = 0;
+			const outBufferEndOffset = no;
+			const 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 ) {
+
+					const index = ( c >> ( lc - HUF_DECBITS ) ) & HUF_DECMASK;
+					const pl = decodingTable[ index ];
+
+					if ( pl.len ) {
+
+						lc -= pl.len;
+
+						getCode( pl.lit, rlc, c, lc, uInt8Array, inOffset, outBuffer, outOffset, outBufferEndOffset );
+
+						c = getCodeReturn.c;
+						lc = getCodeReturn.lc;
+
+					} else {
+
+						if ( ! pl.p ) {
+
+							throw new Error( 'hufDecode issues' );
+
+						}
+
+						let j;
+
+						for ( j = 0; j < pl.lit; j ++ ) {
+
+							const 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, inOffset, outBuffer, outOffset, outBufferEndOffset );
+
+									c = getCodeReturn.c;
+									lc = getCodeReturn.lc;
+
+									break;
+
+								}
+
+							}
+
+						}
+
+						if ( j == pl.lit ) {
+
+							throw new Error( 'hufDecode issues' );
+
+						}
+
+					}
+
+				}
+
+			}
+
+			const i = ( 8 - ni ) & 7;
+
+			c >>= i;
+			lc -= i;
+
+			while ( lc > 0 ) {
+
+				const pl = decodingTable[ ( c << ( HUF_DECBITS - lc ) ) & HUF_DECMASK ];
+
+				if ( pl.len ) {
+
+					lc -= pl.len;
+
+					getCode( pl.lit, rlc, c, lc, uInt8Array, inOffset, outBuffer, outOffset, outBufferEndOffset );
+
+					c = getCodeReturn.c;
+					lc = getCodeReturn.lc;
+
+				} else {
+
+					throw new Error( 'hufDecode issues' );
+
+				}
+
+			}
+
+			return true;
+
+		}
+
+		function hufUncompress( uInt8Array, inDataView, inOffset, nCompressed, outBuffer, nRaw ) {
+
+			const outOffset = { value: 0 };
+			const initialInOffset = inOffset.value;
+
+			const im = parseUint32( inDataView, inOffset );
+			const iM = parseUint32( inDataView, inOffset );
+
+			inOffset.value += 4;
+
+			const nBits = parseUint32( inDataView, inOffset );
+
+			inOffset.value += 4;
+
+			if ( im < 0 || im >= HUF_ENCSIZE || iM < 0 || iM >= HUF_ENCSIZE ) {
+
+				throw new Error( 'Something wrong with HUF_ENCSIZE' );
+
+			}
+
+			const freq = new Array( HUF_ENCSIZE );
+			const hdec = new Array( HUF_DECSIZE );
+
+			hufClearDecTable( hdec );
+
+			const ni = nCompressed - ( inOffset.value - initialInOffset );
+
+			hufUnpackEncTable( uInt8Array, inOffset, ni, im, iM, freq );
+
+			if ( nBits > 8 * ( nCompressed - ( inOffset.value - initialInOffset ) ) ) {
+
+				throw new Error( 'Something wrong with hufUncompress' );
+
+			}
+
+			hufBuildDecTable( freq, im, iM, hdec );
+
+			hufDecode( freq, hdec, uInt8Array, inOffset, nBits, iM, nRaw, outBuffer, outOffset );
+
+		}
+
+		function applyLut( lut, data, nData ) {
+
+			for ( let i = 0; i < nData; ++ i ) {
+
+				data[ i ] = lut[ data[ i ] ];
+
+			}
+
+		}
+
+		function predictor( source ) {
+
+			for ( let t = 1; t < source.length; t ++ ) {
+
+				const d = source[ t - 1 ] + source[ t ] - 128;
+				source[ t ] = d;
+
+			}
+
+		}
+
+		function interleaveScalar( source, out ) {
+
+			let t1 = 0;
+			let t2 = Math.floor( ( source.length + 1 ) / 2 );
+			let s = 0;
+			const 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 ) {
+
+			let size = source.byteLength;
+			const out = new Array();
+			let p = 0;
+
+			const reader = new DataView( source );
+
+			while ( size > 0 ) {
+
+				const l = reader.getInt8( p ++ );
+
+				if ( l < 0 ) {
+
+					const count = - l;
+					size -= count + 1;
+
+					for ( let i = 0; i < count; i ++ ) {
+
+						out.push( reader.getUint8( p ++ ) );
+
+					}
+
+
+				} else {
+
+					const count = l;
+					size -= 2;
+
+					const value = reader.getUint8( p ++ );
+
+					for ( let i = 0; i < count + 1; i ++ ) {
+
+						out.push( value );
+
+					}
+
+				}
+
+			}
+
+			return out;
+
+		}
+
+		function lossyDctDecode( cscSet, rowPtrs, channelData, acBuffer, dcBuffer, outBuffer ) {
+
+			let dataView = new DataView( outBuffer.buffer );
+
+			const width = channelData[ cscSet.idx[ 0 ] ].width;
+			const height = channelData[ cscSet.idx[ 0 ] ].height;
+
+			const numComp = 3;
+
+			const numFullBlocksX = Math.floor( width / 8.0 );
+			const numBlocksX = Math.ceil( width / 8.0 );
+			const numBlocksY = Math.ceil( height / 8.0 );
+			const leftoverX = width - ( numBlocksX - 1 ) * 8;
+			const leftoverY = height - ( numBlocksY - 1 ) * 8;
+
+			const currAcComp = { value: 0 };
+			const currDcComp = new Array( numComp );
+			const dctData = new Array( numComp );
+			const halfZigBlock = new Array( numComp );
+			const rowBlock = new Array( numComp );
+			const rowOffsets = new Array( numComp );
+
+			for ( let 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 ( let blocky = 0; blocky < numBlocksY; ++ blocky ) {
+
+				let maxY = 8;
+
+				if ( blocky == numBlocksY - 1 )
+					maxY = leftoverY;
+
+				let maxX = 8;
+
+				for ( let blockx = 0; blockx < numBlocksX; ++ blockx ) {
+
+					if ( blockx == numBlocksX - 1 )
+						maxX = leftoverX;
+
+					for ( let comp = 0; comp < numComp; ++ comp ) {
+
+						halfZigBlock[ comp ].fill( 0 );
+
+						// set block DC component
+						halfZigBlock[ comp ][ 0 ] = dcBuffer[ currDcComp[ comp ] ++ ];
+						// set block AC components
+						unRleAC( currAcComp, acBuffer, halfZigBlock[ comp ] );
+
+						// UnZigZag block to float
+						unZigZag( halfZigBlock[ comp ], dctData[ comp ] );
+						// decode float dct
+						dctInverse( dctData[ comp ] );
+
+					}
+
+					{
+
+						csc709Inverse( dctData );
+
+					}
+
+					for ( let comp = 0; comp < numComp; ++ comp ) {
+
+						convertToHalf( dctData[ comp ], rowBlock[ comp ], blockx * 64 );
+
+					}
+
+				} // blockx
+
+				let offset = 0;
+
+				for ( let comp = 0; comp < numComp; ++ comp ) {
+
+					const type = channelData[ cscSet.idx[ comp ] ].type;
+
+					for ( let y = 8 * blocky; y < 8 * blocky + maxY; ++ y ) {
+
+						offset = rowOffsets[ comp ][ y ];
+
+						for ( let blockx = 0; blockx < numFullBlocksX; ++ blockx ) {
+
+							const src = blockx * 64 + ( ( y & 0x7 ) * 8 );
+
+							dataView.setUint16( offset + 0 * INT16_SIZE * type, rowBlock[ comp ][ src + 0 ], true );
+							dataView.setUint16( offset + 1 * INT16_SIZE * type, rowBlock[ comp ][ src + 1 ], true );
+							dataView.setUint16( offset + 2 * INT16_SIZE * type, rowBlock[ comp ][ src + 2 ], true );
+							dataView.setUint16( offset + 3 * INT16_SIZE * type, rowBlock[ comp ][ src + 3 ], true );
+
+							dataView.setUint16( offset + 4 * INT16_SIZE * type, rowBlock[ comp ][ src + 4 ], true );
+							dataView.setUint16( offset + 5 * INT16_SIZE * type, rowBlock[ comp ][ src + 5 ], true );
+							dataView.setUint16( offset + 6 * INT16_SIZE * type, rowBlock[ comp ][ src + 6 ], true );
+							dataView.setUint16( offset + 7 * INT16_SIZE * type, rowBlock[ comp ][ src + 7 ], true );
+
+							offset += 8 * INT16_SIZE * type;
+
+						}
+
+					}
+
+					// handle partial X blocks
+					if ( numFullBlocksX != numBlocksX ) {
+
+						for ( let y = 8 * blocky; y < 8 * blocky + maxY; ++ y ) {
+
+							const offset = rowOffsets[ comp ][ y ] + 8 * numFullBlocksX * INT16_SIZE * type;
+							const src = numFullBlocksX * 64 + ( ( y & 0x7 ) * 8 );
+
+							for ( let x = 0; x < maxX; ++ x ) {
+
+								dataView.setUint16( offset + x * INT16_SIZE * type, rowBlock[ comp ][ src + x ], true );
+
+							}
+
+						}
+
+					}
+
+				} // comp
+
+			} // blocky
+
+			const halfRow = new Uint16Array( width );
+			dataView = new DataView( outBuffer.buffer );
+
+			// convert channels back to float, if needed
+			for ( let comp = 0; comp < numComp; ++ comp ) {
+
+				channelData[ cscSet.idx[ comp ] ].decoded = true;
+				const type = channelData[ cscSet.idx[ comp ] ].type;
+
+				if ( channelData[ comp ].type != 2 ) continue;
+
+				for ( let y = 0; y < height; ++ y ) {
+
+					const offset = rowOffsets[ comp ][ y ];
+
+					for ( let x = 0; x < width; ++ x ) {
+
+						halfRow[ x ] = dataView.getUint16( offset + x * INT16_SIZE * type, true );
+
+					}
+
+					for ( let x = 0; x < width; ++ x ) {
+
+						dataView.setFloat32( offset + x * INT16_SIZE * type, decodeFloat16( halfRow[ x ] ), true );
+
+					}
+
+				}
+
+			}
+
+		}
+
+		function lossyDctChannelDecode( channelIndex, rowPtrs, channelData, acBuffer, dcBuffer, outBuffer ) {
+
+			const dataView = new DataView( outBuffer.buffer );
+			const cd = channelData[ channelIndex ];
+			const width = cd.width;
+			const height = cd.height;
+
+			const numBlocksX = Math.ceil( width / 8.0 );
+			const numBlocksY = Math.ceil( height / 8.0 );
+			const numFullBlocksX = Math.floor( width / 8.0 );
+			const leftoverX = width - ( numBlocksX - 1 ) * 8;
+			const leftoverY = height - ( numBlocksY - 1 ) * 8;
+
+			const currAcComp = { value: 0 };
+			let currDcComp = 0;
+			const dctData = new Float32Array( 64 );
+			const halfZigBlock = new Uint16Array( 64 );
+			const rowBlock = new Uint16Array( numBlocksX * 64 );
+
+			for ( let blocky = 0; blocky < numBlocksY; ++ blocky ) {
+
+				let maxY = 8;
+
+				if ( blocky == numBlocksY - 1 ) maxY = leftoverY;
+
+				for ( let blockx = 0; blockx < numBlocksX; ++ blockx ) {
+
+					halfZigBlock.fill( 0 );
+					halfZigBlock[ 0 ] = dcBuffer[ currDcComp ++ ];
+					unRleAC( currAcComp, acBuffer, halfZigBlock );
+					unZigZag( halfZigBlock, dctData );
+					dctInverse( dctData );
+					convertToHalf( dctData, rowBlock, blockx * 64 );
+
+				}
+
+				// Write decoded data to output buffer
+				for ( let y = 8 * blocky; y < 8 * blocky + maxY; ++ y ) {
+
+					let offset = rowPtrs[ channelIndex ][ y ];
+
+					for ( let blockx = 0; blockx < numFullBlocksX; ++ blockx ) {
+
+						const src = blockx * 64 + ( ( y & 0x7 ) * 8 );
+
+						for ( let x = 0; x < 8; ++ x ) {
+
+							dataView.setUint16( offset + x * INT16_SIZE * cd.type, rowBlock[ src + x ], true );
+
+						}
+
+						offset += 8 * INT16_SIZE * cd.type;
+
+					}
+
+					if ( numBlocksX != numFullBlocksX ) {
+
+						const src = numFullBlocksX * 64 + ( ( y & 0x7 ) * 8 );
+
+						for ( let x = 0; x < leftoverX; ++ x ) {
+
+							dataView.setUint16( offset + x * INT16_SIZE * cd.type, rowBlock[ src + x ], true );
+
+						}
+
+					}
+
+				}
+
+			}
+
+			cd.decoded = true;
+
+		}
+
+		function unRleAC( currAcComp, acBuffer, halfZigBlock ) {
+
+			let acValue;
+			let 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 ) {
+
+			const a = 0.5 * Math.cos( 3.14159 / 4.0 );
+			const b = 0.5 * Math.cos( 3.14159 / 16.0 );
+			const c = 0.5 * Math.cos( 3.14159 / 8.0 );
+			const d = 0.5 * Math.cos( 3.0 * 3.14159 / 16.0 );
+			const e = 0.5 * Math.cos( 5.0 * 3.14159 / 16.0 );
+			const f = 0.5 * Math.cos( 3.0 * 3.14159 / 8.0 );
+			const g = 0.5 * Math.cos( 7.0 * 3.14159 / 16.0 );
+
+			const alpha = new Array( 4 );
+			const beta = new Array( 4 );
+			const theta = new Array( 4 );
+			const gamma = new Array( 4 );
+
+			for ( let row = 0; row < 8; ++ row ) {
+
+				const 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 ( let 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 ( let i = 0; i < 64; ++ i ) {
+
+				const y = data[ 0 ][ i ];
+				const cb = data[ 1 ][ i ];
+				const 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 ( let i = 0; i < 64; ++ i ) {
+
+				dst[ idx + i ] = 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 ) {
+
+			const compressed = info.viewer.buffer.slice( info.offset.value, info.offset.value + info.size );
+
+			const rawBuffer = new Uint8Array( decodeRunLength( compressed ) );
+			const tmpBuffer = new Uint8Array( rawBuffer.length );
+
+			predictor( rawBuffer ); // revert predictor
+
+			interleaveScalar( rawBuffer, tmpBuffer ); // interleave pixels
+
+			return new DataView( tmpBuffer.buffer );
+
+		}
+
+		function uncompressZIP( info ) {
+
+			const compressed = info.array.slice( info.offset.value, info.offset.value + info.size );
+
+			const rawBuffer = unzlibSync( compressed );
+			const tmpBuffer = new Uint8Array( rawBuffer.length );
+
+			predictor( rawBuffer ); // revert predictor
+
+			interleaveScalar( rawBuffer, tmpBuffer ); // interleave pixels
+
+			return new DataView( tmpBuffer.buffer );
+
+		}
+
+		function uncompressPIZ( info ) {
+
+			const inDataView = info.viewer;
+			const inOffset = { value: info.offset.value };
+
+			const outBuffer = new Uint16Array( info.columns * info.lines * ( info.inputChannels.length * info.type ) );
+			const bitmap = new Uint8Array( BITMAP_SIZE );
+
+			// Setup channel info
+			let outBufferEnd = 0;
+			const pizChannelData = new Array( info.inputChannels.length );
+			for ( let i = 0, il = info.inputChannels.length; i < il; i ++ ) {
+
+				pizChannelData[ i ] = {};
+				pizChannelData[ i ][ 'start' ] = outBufferEnd;
+				pizChannelData[ i ][ 'end' ] = pizChannelData[ i ][ 'start' ];
+				pizChannelData[ i ][ 'nx' ] = info.columns;
+				pizChannelData[ i ][ 'ny' ] = info.lines;
+				pizChannelData[ i ][ 'size' ] = info.type;
+
+				outBufferEnd += pizChannelData[ i ].nx * pizChannelData[ i ].ny * pizChannelData[ i ].size;
+
+			}
+
+			// Read range compression data
+
+			const minNonZero = parseUint16( inDataView, inOffset );
+			const maxNonZero = parseUint16( inDataView, inOffset );
+
+			if ( maxNonZero >= BITMAP_SIZE ) {
+
+				throw new Error( 'Something is wrong with PIZ_COMPRESSION BITMAP_SIZE' );
+
+			}
+
+			if ( minNonZero <= maxNonZero ) {
+
+				for ( let i = 0; i < maxNonZero - minNonZero + 1; i ++ ) {
+
+					bitmap[ i + minNonZero ] = parseUint8( inDataView, inOffset );
+
+				}
+
+			}
+
+			// Reverse LUT
+			const lut = new Uint16Array( USHORT_RANGE );
+			const maxValue = reverseLutFromBitmap( bitmap, lut );
+
+			const length = parseUint32( inDataView, inOffset );
+
+			// Huffman decoding
+			hufUncompress( info.array, inDataView, inOffset, length, outBuffer, outBufferEnd );
+
+			// Wavelet decoding
+			for ( let i = 0; i < info.inputChannels.length; ++ i ) {
+
+				const cd = pizChannelData[ i ];
+
+				for ( let 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.
+			let tmpOffset = 0;
+			const tmpBuffer = new Uint8Array( outBuffer.buffer.byteLength );
+			for ( let y = 0; y < info.lines; y ++ ) {
+
+				for ( let c = 0; c < info.inputChannels.length; c ++ ) {
+
+					const cd = pizChannelData[ c ];
+
+					const n = cd.nx * cd.size;
+					const 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 ) {
+
+			const compressed = info.array.slice( info.offset.value, info.offset.value + info.size );
+
+			const rawBuffer = unzlibSync( compressed );
+
+			const byteSize = info.inputChannels.length * info.lines * info.columns * info.totalBytes;
+			const tmpBuffer = new ArrayBuffer( byteSize );
+			const viewer = new DataView( tmpBuffer );
+
+			let tmpBufferEnd = 0;
+			let writePtr = 0;
+			const ptr = new Array( 4 );
+
+			for ( let y = 0; y < info.lines; y ++ ) {
+
+				for ( let c = 0; c < info.inputChannels.length; c ++ ) {
+
+					let pixel = 0;
+
+					const type = info.inputChannels[ c ].pixelType;
+					switch ( type ) {
+
+						case 1:
+
+							ptr[ 0 ] = tmpBufferEnd;
+							ptr[ 1 ] = ptr[ 0 ] + info.columns;
+							tmpBufferEnd = ptr[ 1 ] + info.columns;
+
+							for ( let j = 0; j < info.columns; ++ j ) {
+
+								const diff = ( rawBuffer[ ptr[ 0 ] ++ ] << 8 ) | rawBuffer[ ptr[ 1 ] ++ ];
+
+								pixel += diff;
+
+								viewer.setUint16( writePtr, pixel, true );
+								writePtr += 2;
+
+							}
+
+							break;
+
+						case 2:
+
+							ptr[ 0 ] = tmpBufferEnd;
+							ptr[ 1 ] = ptr[ 0 ] + info.columns;
+							ptr[ 2 ] = ptr[ 1 ] + info.columns;
+							tmpBufferEnd = ptr[ 2 ] + info.columns;
+
+							for ( let j = 0; j < info.columns; ++ j ) {
+
+								const diff = ( rawBuffer[ ptr[ 0 ] ++ ] << 24 ) | ( rawBuffer[ ptr[ 1 ] ++ ] << 16 ) | ( rawBuffer[ ptr[ 2 ] ++ ] << 8 );
+
+								pixel += diff;
+
+								viewer.setUint32( writePtr, pixel, true );
+								writePtr += 4;
+
+							}
+
+							break;
+
+					}
+
+				}
+
+			}
+
+			return viewer;
+
+		}
+
+		function uncompressDWA( info ) {
+
+			const inDataView = info.viewer;
+			const inOffset = { value: info.offset.value };
+			const outBuffer = new Uint8Array( info.columns * info.lines * ( info.inputChannels.length * info.type * INT16_SIZE ) );
+
+			// Read compression header information
+			const 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 new Error( 'EXRLoader.parse: ' + EXRHeader.compression + ' version ' + dwaHeader.version + ' is unsupported' );
+
+			// Read channel ruleset information
+			const channelRules = new Array();
+			let ruleSize = parseUint16( inDataView, inOffset ) - INT16_SIZE;
+
+			while ( ruleSize > 0 ) {
+
+				const name = parseNullTerminatedString( inDataView.buffer, inOffset );
+				const value = parseUint8( inDataView, inOffset );
+				const compression = ( value >> 2 ) & 3;
+				const csc = ( value >> 4 ) - 1;
+				const index = new Int8Array( [ csc ] )[ 0 ];
+				const type = parseUint8( inDataView, inOffset );
+
+				channelRules.push( {
+					name: name,
+					index: index,
+					type: type,
+					compression: compression,
+				} );
+
+				ruleSize -= name.length + 3;
+
+			}
+
+			// Classify channels
+			const channels = EXRHeader.channels;
+			const channelData = new Array( info.inputChannels.length );
+
+			for ( let i = 0; i < info.inputChannels.length; ++ i ) {
+
+				const cd = channelData[ i ] = {};
+				const channel = channels[ i ];
+
+				cd.name = channel.name;
+				cd.compression = UNKNOWN;
+				cd.decoded = false;
+				cd.type = channel.pixelType;
+				cd.pLinear = channel.pLinear;
+				cd.width = info.columns;
+				cd.height = info.lines;
+
+			}
+
+			const cscSet = {
+				idx: new Array( 3 )
+			};
+
+			for ( let offset = 0; offset < info.inputChannels.length; ++ offset ) {
+
+				const cd = channelData[ offset ];
+
+				for ( let i = 0; i < channelRules.length; ++ i ) {
+
+					const rule = channelRules[ i ];
+
+					if ( cd.name == rule.name ) {
+
+						cd.compression = rule.compression;
+
+						if ( rule.index >= 0 ) {
+
+							cscSet.idx[ rule.index ] = offset;
+
+						}
+
+						cd.offset = offset;
+
+					}
+
+				}
+
+			}
+
+			let acBuffer, dcBuffer, rleBuffer;
+
+			// Read DCT - AC component data
+			if ( dwaHeader.acCompressedSize > 0 ) {
+
+				switch ( dwaHeader.acCompression ) {
+
+					case STATIC_HUFFMAN:
+
+						acBuffer = new Uint16Array( dwaHeader.totalAcUncompressedCount );
+						hufUncompress( info.array, inDataView, inOffset, dwaHeader.acCompressedSize, acBuffer, dwaHeader.totalAcUncompressedCount );
+						break;
+
+					case DEFLATE:
+
+						const compressed = info.array.slice( inOffset.value, inOffset.value + dwaHeader.totalAcUncompressedCount );
+						const data = unzlibSync( compressed );
+						acBuffer = new Uint16Array( data.buffer );
+						inOffset.value += dwaHeader.totalAcUncompressedCount;
+						break;
+
+				}
+
+
+			}
+
+			// Read DCT - DC component data
+			if ( dwaHeader.dcCompressedSize > 0 ) {
+
+				const zlibInfo = {
+					array: info.array,
+					offset: inOffset,
+					size: dwaHeader.dcCompressedSize
+				};
+				dcBuffer = new Uint16Array( uncompressZIP( zlibInfo ).buffer );
+				inOffset.value += dwaHeader.dcCompressedSize;
+
+			}
+
+			// Read RLE compressed data
+			if ( dwaHeader.rleRawSize > 0 ) {
+
+				const compressed = info.array.slice( inOffset.value, inOffset.value + dwaHeader.rleCompressedSize );
+				const data = unzlibSync( compressed );
+				rleBuffer = decodeRunLength( data.buffer );
+
+				inOffset.value += dwaHeader.rleCompressedSize;
+
+			}
+
+			// Prepare outbuffer data offset
+			let outBufferEnd = 0;
+			const rowOffsets = new Array( channelData.length );
+			for ( let i = 0; i < rowOffsets.length; ++ i ) {
+
+				rowOffsets[ i ] = new Array();
+
+			}
+
+			for ( let y = 0; y < info.lines; ++ y ) {
+
+				for ( let chan = 0; chan < channelData.length; ++ chan ) {
+
+					rowOffsets[ chan ].push( outBufferEnd );
+					outBufferEnd += channelData[ chan ].width * info.type * INT16_SIZE;
+
+				}
+
+			}
+
+			// Decode lossy DCT data if we have a valid color space conversion set with the first RGB channel present
+			if ( cscSet.idx[ 0 ] !== undefined && channelData[ cscSet.idx[ 0 ] ] ) {
+
+				lossyDctDecode( cscSet, rowOffsets, channelData, acBuffer, dcBuffer, outBuffer );
+
+			}
+
+			// Decode other channels
+			for ( let i = 0; i < channelData.length; ++ i ) {
+
+				const cd = channelData[ i ];
+
+				if ( cd.decoded ) continue;
+
+				switch ( cd.compression ) {
+
+					case RLE:
+
+						let row = 0;
+						let rleOffset = 0;
+
+						for ( let y = 0; y < info.lines; ++ y ) {
+
+							let rowOffsetBytes = rowOffsets[ i ][ row ];
+
+							for ( let x = 0; x < cd.width; ++ x ) {
+
+								for ( let byte = 0; byte < INT16_SIZE * cd.type; ++ byte ) {
+
+									outBuffer[ rowOffsetBytes ++ ] = rleBuffer[ rleOffset + byte * cd.width * cd.height ];
+
+								}
+
+								rleOffset ++;
+
+							}
+
+							row ++;
+
+						}
+
+						break;
+
+					case LOSSY_DCT:
+
+						lossyDctChannelDecode( i, rowOffsets, channelData, acBuffer, dcBuffer, outBuffer );
+
+						break;
+
+					default:
+						throw new Error( 'EXRLoader.parse: unsupported channel compression' );
+
+				}
+
+			}
+
+			return new DataView( outBuffer.buffer );
+
+		}
+
+		function parseNullTerminatedString( buffer, offset ) {
+
+			const uintBuffer = new Uint8Array( buffer );
+			let endOffset = 0;
+
+			while ( uintBuffer[ offset.value + endOffset ] != 0 ) {
+
+				endOffset += 1;
+
+			}
+
+			const stringValue = new TextDecoder().decode(
+				uintBuffer.slice( offset.value, offset.value + endOffset )
+			);
+
+			offset.value = offset.value + endOffset + 1;
+
+			return stringValue;
+
+		}
+
+		function parseFixedLengthString( buffer, offset, size ) {
+
+			const stringValue = new TextDecoder().decode(
+				new Uint8Array( buffer ).slice( offset.value, offset.value + size )
+			);
+
+			offset.value = offset.value + size;
+
+			return stringValue;
+
+		}
+
+		function parseRational( dataView, offset ) {
+
+			const x = parseInt32( dataView, offset );
+			const y = parseUint32( dataView, offset );
+
+			return [ x, y ];
+
+		}
+
+		function parseTimecode( dataView, offset ) {
+
+			const x = parseUint32( dataView, offset );
+			const y = parseUint32( dataView, offset );
+
+			return [ x, y ];
+
+		}
+
+		function parseInt32( dataView, offset ) {
+
+			const Int32 = dataView.getInt32( offset.value, true );
+
+			offset.value = offset.value + INT32_SIZE;
+
+			return Int32;
+
+		}
+
+		function parseUint32( dataView, offset ) {
+
+			const Uint32 = dataView.getUint32( offset.value, true );
+
+			offset.value = offset.value + INT32_SIZE;
+
+			return Uint32;
+
+		}
+
+		function parseUint8Array( uInt8Array, offset ) {
+
+			const Uint8 = uInt8Array[ offset.value ];
+
+			offset.value = offset.value + INT8_SIZE;
+
+			return Uint8;
+
+		}
+
+		function parseUint8( dataView, offset ) {
+
+			const Uint8 = dataView.getUint8( offset.value );
+
+			offset.value = offset.value + INT8_SIZE;
+
+			return Uint8;
+
+		}
+
+		const parseInt64 = function ( dataView, offset ) {
+
+			let int;
+
+			if ( 'getBigInt64' in DataView.prototype ) {
+
+				int = Number( dataView.getBigInt64( offset.value, true ) );
+
+			} else {
+
+				int = dataView.getUint32( offset.value + 4, true ) + Number( dataView.getUint32( offset.value, true ) << 32 );
+
+			}
+
+			offset.value += ULONG_SIZE;
+
+			return int;
+
+		};
+
+		function parseFloat32( dataView, offset ) {
+
+			const float = dataView.getFloat32( offset.value, true );
+
+			offset.value += FLOAT32_SIZE;
+
+			return float;
+
+		}
+
+		function decodeFloat32( dataView, offset ) {
+
+			return DataUtils.toHalfFloat( parseFloat32( dataView, offset ) );
+
+		}
+
+		// https://stackoverflow.com/questions/5678432/decompressing-half-precision-floats-in-javascript
+		function decodeFloat16( binary ) {
+
+			const 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 ) {
+
+			const 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 ) {
+
+			const startOffset = offset.value;
+			const channels = [];
+
+			while ( offset.value < ( startOffset + size - 1 ) ) {
+
+				const name = parseNullTerminatedString( buffer, offset );
+				const pixelType = parseInt32( dataView, offset );
+				const pLinear = parseUint8( dataView, offset );
+				offset.value += 3; // reserved, three chars
+				const xSampling = parseInt32( dataView, offset );
+				const 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 ) {
+
+			const redX = parseFloat32( dataView, offset );
+			const redY = parseFloat32( dataView, offset );
+			const greenX = parseFloat32( dataView, offset );
+			const greenY = parseFloat32( dataView, offset );
+			const blueX = parseFloat32( dataView, offset );
+			const blueY = parseFloat32( dataView, offset );
+			const whiteX = parseFloat32( dataView, offset );
+			const 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 ) {
+
+			const compressionCodes = [
+				'NO_COMPRESSION',
+				'RLE_COMPRESSION',
+				'ZIPS_COMPRESSION',
+				'ZIP_COMPRESSION',
+				'PIZ_COMPRESSION',
+				'PXR24_COMPRESSION',
+				'B44_COMPRESSION',
+				'B44A_COMPRESSION',
+				'DWAA_COMPRESSION',
+				'DWAB_COMPRESSION'
+			];
+
+			const compression = parseUint8( dataView, offset );
+
+			return compressionCodes[ compression ];
+
+		}
+
+		function parseBox2i( dataView, offset ) {
+
+			const xMin = parseInt32( dataView, offset );
+			const yMin = parseInt32( dataView, offset );
+			const xMax = parseInt32( dataView, offset );
+			const yMax = parseInt32( dataView, offset );
+
+			return { xMin: xMin, yMin: yMin, xMax: xMax, yMax: yMax };
+
+		}
+
+		function parseLineOrder( dataView, offset ) {
+
+			const lineOrders = [
+				'INCREASING_Y',
+				'DECREASING_Y',
+				'RANDOM_Y',
+			];
+
+			const lineOrder = parseUint8( dataView, offset );
+
+			return lineOrders[ lineOrder ];
+
+		}
+
+		function parseEnvmap( dataView, offset ) {
+
+			const envmaps = [
+				'ENVMAP_LATLONG',
+				'ENVMAP_CUBE'
+			];
+
+			const envmap = parseUint8( dataView, offset );
+
+			return envmaps[ envmap ];
+
+		}
+
+		function parseTiledesc( dataView, offset ) {
+
+			const levelModes = [
+				'ONE_LEVEL',
+				'MIPMAP_LEVELS',
+				'RIPMAP_LEVELS',
+			];
+
+			const roundingModes = [
+				'ROUND_DOWN',
+				'ROUND_UP',
+			];
+
+			const xSize = parseUint32( dataView, offset );
+			const ySize = parseUint32( dataView, offset );
+			const modes = parseUint8( dataView, offset );
+
+			return {
+				xSize: xSize,
+				ySize: ySize,
+				levelMode: levelModes[ modes & 0xf ],
+				roundingMode: roundingModes[ modes >> 4 ]
+			};
+
+		}
+
+		function parseV2f( dataView, offset ) {
+
+			const x = parseFloat32( dataView, offset );
+			const y = parseFloat32( dataView, offset );
+
+			return [ x, y ];
+
+		}
+
+		function parseV3f( dataView, offset ) {
+
+			const x = parseFloat32( dataView, offset );
+			const y = parseFloat32( dataView, offset );
+			const 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 === 'envmap' ) {
+
+				return parseEnvmap( dataView, offset );
+
+			} else if ( type === 'tiledesc' ) {
+
+				return parseTiledesc( 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;
+
+			}
+
+		}
+
+		function roundLog2( x, mode ) {
+
+			const log2 = Math.log2( x );
+			return mode == 'ROUND_DOWN' ? Math.floor( log2 ) : Math.ceil( log2 );
+
+		}
+
+		function calculateTileLevels( tiledesc, w, h ) {
+
+			let num = 0;
+
+			switch ( tiledesc.levelMode ) {
+
+				case 'ONE_LEVEL':
+					num = 1;
+					break;
+
+				case 'MIPMAP_LEVELS':
+					num = roundLog2( Math.max( w, h ), tiledesc.roundingMode ) + 1;
+					break;
+
+				case 'RIPMAP_LEVELS':
+					throw new Error( 'THREE.EXRLoader: RIPMAP_LEVELS tiles currently unsupported.' );
+
+			}
+
+			return num;
+
+		}
+
+		function calculateTiles( count, dataSize, size, roundingMode ) {
+
+			const tiles = new Array( count );
+
+			for ( let i = 0; i < count; i ++ ) {
+
+				const b = ( 1 << i );
+				let s = ( dataSize / b ) | 0;
+
+				if ( roundingMode == 'ROUND_UP' && s * b < dataSize ) s += 1;
+
+				const l = Math.max( s, 1 );
+
+				tiles[ i ] = ( ( l + size - 1 ) / size ) | 0;
+
+			}
+
+			return tiles;
+
+		}
+
+		function parseTiles() {
+
+			const EXRDecoder = this;
+			const offset = EXRDecoder.offset;
+			const tmpOffset = { value: 0 };
+
+			for ( let tile = 0; tile < EXRDecoder.tileCount; tile ++ ) {
+
+				const tileX = parseInt32( EXRDecoder.viewer, offset );
+				const tileY = parseInt32( EXRDecoder.viewer, offset );
+				offset.value += 8; // skip levels - only parsing top-level
+				EXRDecoder.size = parseUint32( EXRDecoder.viewer, offset );
+
+				const startX = tileX * EXRDecoder.blockWidth;
+				const startY = tileY * EXRDecoder.blockHeight;
+				EXRDecoder.columns = ( startX + EXRDecoder.blockWidth > EXRDecoder.width ) ? EXRDecoder.width - startX : EXRDecoder.blockWidth;
+				EXRDecoder.lines = ( startY + EXRDecoder.blockHeight > EXRDecoder.height ) ? EXRDecoder.height - startY : EXRDecoder.blockHeight;
+
+				const bytesBlockLine = EXRDecoder.columns * EXRDecoder.totalBytes;
+				const isCompressed = EXRDecoder.size < EXRDecoder.lines * bytesBlockLine;
+				const viewer = isCompressed ? EXRDecoder.uncompress( EXRDecoder ) : uncompressRAW( EXRDecoder );
+
+				offset.value += EXRDecoder.size;
+
+				for ( let line = 0; line < EXRDecoder.lines; line ++ ) {
+
+					const lineOffset = line * EXRDecoder.columns * EXRDecoder.totalBytes;
+
+					for ( let channelID = 0; channelID < EXRDecoder.inputChannels.length; channelID ++ ) {
+
+						const name = EXRHeader.channels[ channelID ].name;
+						const lOff = EXRDecoder.channelByteOffsets[ name ] * EXRDecoder.columns;
+						const cOff = EXRDecoder.decodeChannels[ name ];
+
+						if ( cOff === undefined ) continue;
+
+						tmpOffset.value = lineOffset + lOff;
+						const outLineOffset = ( EXRDecoder.height - ( 1 + startY + line ) ) * EXRDecoder.outLineWidth;
+
+						for ( let x = 0; x < EXRDecoder.columns; x ++ ) {
+
+							const outIndex = outLineOffset + ( x + startX ) * EXRDecoder.outputChannels + cOff;
+							EXRDecoder.byteArray[ outIndex ] = EXRDecoder.getter( viewer, tmpOffset );
+
+						}
+
+					}
+
+				}
+
+			}
+
+		}
+
+		function parseScanline() {
+
+			const EXRDecoder = this;
+			const offset = EXRDecoder.offset;
+			const tmpOffset = { value: 0 };
+
+			for ( let scanlineBlockIdx = 0; scanlineBlockIdx < EXRDecoder.height / EXRDecoder.blockHeight; scanlineBlockIdx ++ ) {
+
+				const line = parseInt32( EXRDecoder.viewer, offset ) - EXRHeader.dataWindow.yMin; // line_no
+				EXRDecoder.size = parseUint32( EXRDecoder.viewer, offset ); // data_len
+				EXRDecoder.lines = ( ( line + EXRDecoder.blockHeight > EXRDecoder.height ) ? ( EXRDecoder.height - line ) : EXRDecoder.blockHeight );
+
+				const bytesPerLine = EXRDecoder.columns * EXRDecoder.totalBytes;
+				const isCompressed = EXRDecoder.size < EXRDecoder.lines * bytesPerLine;
+				const viewer = isCompressed ? EXRDecoder.uncompress( EXRDecoder ) : uncompressRAW( EXRDecoder );
+
+				offset.value += EXRDecoder.size;
+
+				for ( let line_y = 0; line_y < EXRDecoder.blockHeight; line_y ++ ) {
+
+					const scan_y = scanlineBlockIdx * EXRDecoder.blockHeight;
+					const true_y = line_y + EXRDecoder.scanOrder( scan_y );
+					if ( true_y >= EXRDecoder.height ) continue;
+
+					const lineOffset = line_y * bytesPerLine;
+					const outLineOffset = ( EXRDecoder.height - 1 - true_y ) * EXRDecoder.outLineWidth;
+
+					for ( let channelID = 0; channelID < EXRDecoder.inputChannels.length; channelID ++ ) {
+
+						const name = EXRHeader.channels[ channelID ].name;
+						const lOff = EXRDecoder.channelByteOffsets[ name ] * EXRDecoder.columns;
+						const cOff = EXRDecoder.decodeChannels[ name ];
+
+						if ( cOff === undefined ) continue;
+
+						tmpOffset.value = lineOffset + lOff;
+
+						for ( let x = 0; x < EXRDecoder.columns; x ++ ) {
+
+							const outIndex = outLineOffset + x * EXRDecoder.outputChannels + cOff;
+							EXRDecoder.byteArray[ outIndex ] = EXRDecoder.getter( viewer, tmpOffset );
+
+						}
+
+					}
+
+				}
+
+			}
+
+		}
+
+		function parseHeader( dataView, buffer, offset ) {
+
+			const EXRHeader = {};
+
+			if ( dataView.getUint32( 0, true ) != 20000630 ) { // magic
+
+				throw new Error( 'THREE.EXRLoader: Provided file doesn\'t appear to be in OpenEXR format.' );
+
+			}
+
+			EXRHeader.version = dataView.getUint8( 4 );
+
+			const spec = dataView.getUint8( 5 ); // fullMask
+
+			EXRHeader.spec = {
+				singleTile: !! ( spec & 2 ),
+				longName: !! ( spec & 4 ),
+				deepFormat: !! ( spec & 8 ),
+				multiPart: !! ( spec & 16 ),
+			};
+
+			// start of header
+
+			offset.value = 8; // start at 8 - after pre-amble
+
+			let keepReading = true;
+
+			while ( keepReading ) {
+
+				const attributeName = parseNullTerminatedString( buffer, offset );
+
+				if ( attributeName === '' ) {
+
+					keepReading = false;
+
+				} else {
+
+					const attributeType = parseNullTerminatedString( buffer, offset );
+					const attributeSize = parseUint32( dataView, offset );
+					const attributeValue = parseValue( dataView, buffer, offset, attributeType, attributeSize );
+
+					if ( attributeValue === undefined ) {
+
+						console.warn( `THREE.EXRLoader: Skipped unknown header attribute type \'${attributeType}\'.` );
+
+					} else {
+
+						EXRHeader[ attributeName ] = attributeValue;
+
+					}
+
+				}
+
+			}
+
+			if ( ( spec & -7 ) != 0 ) { // unsupported deep-image, multi-part
+
+				console.error( 'THREE.EXRHeader:', EXRHeader );
+				throw new Error( 'THREE.EXRLoader: Provided file is currently unsupported.' );
+
+			}
+
+			return EXRHeader;
+
+		}
+
+		function setupDecoder( EXRHeader, dataView, uInt8Array, offset, outputType, outputFormat ) {
+
+			const EXRDecoder = {
+				size: 0,
+				viewer: dataView,
+				array: uInt8Array,
+				offset: offset,
+				width: EXRHeader.dataWindow.xMax - EXRHeader.dataWindow.xMin + 1,
+				height: EXRHeader.dataWindow.yMax - EXRHeader.dataWindow.yMin + 1,
+				inputChannels: EXRHeader.channels,
+				channelByteOffsets: {},
+				shouldExpand: false,
+				scanOrder: null,
+				totalBytes: null,
+				columns: null,
+				lines: null,
+				type: null,
+				uncompress: null,
+				getter: null,
+				format: null,
+				colorSpace: LinearSRGBColorSpace,
+			};
+
+			switch ( EXRHeader.compression ) {
+
+				case 'NO_COMPRESSION':
+					EXRDecoder.blockHeight = 1;
+					EXRDecoder.uncompress = uncompressRAW;
+					break;
+
+				case 'RLE_COMPRESSION':
+					EXRDecoder.blockHeight = 1;
+					EXRDecoder.uncompress = uncompressRLE;
+					break;
+
+				case 'ZIPS_COMPRESSION':
+					EXRDecoder.blockHeight = 1;
+					EXRDecoder.uncompress = uncompressZIP;
+					break;
+
+				case 'ZIP_COMPRESSION':
+					EXRDecoder.blockHeight = 16;
+					EXRDecoder.uncompress = uncompressZIP;
+					break;
+
+				case 'PIZ_COMPRESSION':
+					EXRDecoder.blockHeight = 32;
+					EXRDecoder.uncompress = uncompressPIZ;
+					break;
+
+				case 'PXR24_COMPRESSION':
+					EXRDecoder.blockHeight = 16;
+					EXRDecoder.uncompress = uncompressPXR;
+					break;
+
+				case 'DWAA_COMPRESSION':
+					EXRDecoder.blockHeight = 32;
+					EXRDecoder.uncompress = uncompressDWA;
+					break;
+
+				case 'DWAB_COMPRESSION':
+					EXRDecoder.blockHeight = 256;
+					EXRDecoder.uncompress = uncompressDWA;
+					break;
+
+				default:
+					throw new Error( 'EXRLoader.parse: ' + EXRHeader.compression + ' is unsupported' );
+
+			}
+
+			const channels = {};
+			for ( const channel of EXRHeader.channels ) {
+
+				switch ( channel.name ) {
+
+					case 'Y':
+					case 'R':
+					case 'G':
+					case 'B':
+					case 'A':
+						channels[ channel.name ] = true;
+						EXRDecoder.type = channel.pixelType;
+
+				}
+
+			}
+
+			// RGB images will be converted to RGBA format, preventing software emulation in select devices.
+			let fillAlpha = false;
+			let invalidOutput = false;
+
+			// Validate if input texture contain supported channels
+			if ( channels.R && channels.G && channels.B ) {
+
+				EXRDecoder.outputChannels = 4;
+
+			} else if ( channels.Y ) {
+
+				EXRDecoder.outputChannels = 1;
+
+			} else {
+
+				throw new Error( 'EXRLoader.parse: file contains unsupported data channels.' );
+
+			}
+
+			// Setup output texture configuration
+			switch ( EXRDecoder.outputChannels ) {
+
+				case 4:
+
+					if ( outputFormat == RGBAFormat ) {
+
+						fillAlpha = ! channels.A;
+						EXRDecoder.format = RGBAFormat;
+						EXRDecoder.colorSpace = LinearSRGBColorSpace;
+						EXRDecoder.outputChannels = 4;
+						EXRDecoder.decodeChannels = { R: 0, G: 1, B: 2, A: 3 };
+
+					} else if ( outputFormat == RGFormat ) {
+
+						EXRDecoder.format = RGFormat;
+						EXRDecoder.colorSpace = LinearSRGBColorSpace;
+						EXRDecoder.outputChannels = 2;
+						EXRDecoder.decodeChannels = { R: 0, G: 1 };
+
+					} else if ( outputFormat == RedFormat ) {
+
+						EXRDecoder.format = RedFormat;
+						EXRDecoder.colorSpace = LinearSRGBColorSpace;
+						EXRDecoder.outputChannels = 1;
+						EXRDecoder.decodeChannels = { R: 0 };
+
+					} else {
+
+						invalidOutput = true;
+
+					}
+
+					break;
+
+				case 1:
+
+					if ( outputFormat == RGBAFormat ) {
+
+						fillAlpha = true;
+						EXRDecoder.format = RGBAFormat;
+						EXRDecoder.colorSpace = LinearSRGBColorSpace;
+						EXRDecoder.outputChannels = 4;
+						EXRDecoder.shouldExpand = true;
+						EXRDecoder.decodeChannels = { Y: 0 };
+
+					} else if ( outputFormat == RGFormat ) {
+
+						EXRDecoder.format = RGFormat;
+						EXRDecoder.colorSpace = LinearSRGBColorSpace;
+						EXRDecoder.outputChannels = 2;
+						EXRDecoder.shouldExpand = true;
+						EXRDecoder.decodeChannels = { Y: 0 };
+
+					} else if ( outputFormat == RedFormat ) {
+
+						EXRDecoder.format = RedFormat;
+						EXRDecoder.colorSpace = LinearSRGBColorSpace;
+						EXRDecoder.outputChannels = 1;
+						EXRDecoder.decodeChannels = { Y: 0 };
+
+					} else {
+
+						invalidOutput = true;
+
+					}
+
+					break;
+
+				default:
+
+					invalidOutput = true;
+
+			}
+
+			if ( invalidOutput ) throw new Error( 'EXRLoader.parse: invalid output format for specified file.' );
+
+			if ( EXRDecoder.type == 1 ) {
+
+				// half
+				switch ( outputType ) {
+
+					case FloatType:
+						EXRDecoder.getter = parseFloat16;
+						break;
+
+					case HalfFloatType:
+						EXRDecoder.getter = parseUint16;
+						break;
+
+				}
+
+			} else if ( EXRDecoder.type == 2 ) {
+
+				// float
+				switch ( outputType ) {
+
+					case FloatType:
+						EXRDecoder.getter = parseFloat32;
+						break;
+
+					case HalfFloatType:
+						EXRDecoder.getter = decodeFloat32;
+
+				}
+
+			} else {
+
+				throw new Error( 'EXRLoader.parse: unsupported pixelType ' + EXRDecoder.type + ' for ' + EXRHeader.compression + '.' );
+
+			}
+
+			EXRDecoder.columns = EXRDecoder.width;
+			const size = EXRDecoder.width * EXRDecoder.height * EXRDecoder.outputChannels;
+
+			switch ( outputType ) {
+
+				case FloatType:
+					EXRDecoder.byteArray = new Float32Array( size );
+
+					// Fill initially with 1s for the alpha value if the texture is not RGBA, RGB values will be overwritten
+					if ( fillAlpha )
+						EXRDecoder.byteArray.fill( 1, 0, size );
+
+					break;
+
+				case HalfFloatType:
+					EXRDecoder.byteArray = new Uint16Array( size );
+
+					if ( fillAlpha )
+						EXRDecoder.byteArray.fill( 0x3C00, 0, size ); // Uint16Array holds half float data, 0x3C00 is 1
+
+					break;
+
+				default:
+					console.error( 'THREE.EXRLoader: unsupported type: ', outputType );
+					break;
+
+			}
+
+			let byteOffset = 0;
+			for ( const channel of EXRHeader.channels ) {
+
+				if ( EXRDecoder.decodeChannels[ channel.name ] !== undefined ) {
+
+					EXRDecoder.channelByteOffsets[ channel.name ] = byteOffset;
+
+				}
+
+				byteOffset += channel.pixelType * 2;
+
+			}
+
+			EXRDecoder.totalBytes = byteOffset;
+			EXRDecoder.outLineWidth = EXRDecoder.width * EXRDecoder.outputChannels;
+
+			if ( EXRHeader.lineOrder === 'INCREASING_Y' ) {
+
+				EXRDecoder.scanOrder = ( y ) => y;
+
+			} else {
+
+				EXRDecoder.scanOrder = ( y ) => EXRDecoder.height - 1 - y;
+
+			}
+
+			if ( EXRHeader.spec.singleTile ) {
+
+				EXRDecoder.blockHeight = EXRHeader.tiles.ySize;
+				EXRDecoder.blockWidth = EXRHeader.tiles.xSize;
+
+				const numXLevels = calculateTileLevels( EXRHeader.tiles, EXRDecoder.width, EXRDecoder.height );
+				// const numYLevels = calculateTileLevels( EXRHeader.tiles, EXRDecoder.width, EXRDecoder.height );
+
+				const numXTiles = calculateTiles( numXLevels, EXRDecoder.width, EXRHeader.tiles.xSize, EXRHeader.tiles.roundingMode );
+				const numYTiles = calculateTiles( numXLevels, EXRDecoder.height, EXRHeader.tiles.ySize, EXRHeader.tiles.roundingMode );
+
+				EXRDecoder.tileCount = numXTiles[ 0 ] * numYTiles[ 0 ];
+
+				for ( let l = 0; l < numXLevels; l ++ )
+					for ( let y = 0; y < numYTiles[ l ]; y ++ )
+						for ( let x = 0; x < numXTiles[ l ]; x ++ )
+							parseInt64( dataView, offset ); // tileOffset
+
+				EXRDecoder.decode = parseTiles.bind( EXRDecoder );
+
+			} else {
+
+				EXRDecoder.blockWidth = EXRDecoder.width;
+				const blockCount = Math.ceil( EXRDecoder.height / EXRDecoder.blockHeight );
+
+				for ( let i = 0; i < blockCount; i ++ )
+					parseInt64( dataView, offset ); // scanlineOffset
+
+				EXRDecoder.decode = parseScanline.bind( EXRDecoder );
+
+			}
+
+			return EXRDecoder;
+
+		}
+
+		// start parsing file [START]
+		const offset = { value: 0 };
+		const bufferDataView = new DataView( buffer );
+		const uInt8Array = new Uint8Array( buffer );
+
+		// get header information and validate format.
+		const EXRHeader = parseHeader( bufferDataView, buffer, offset );
+
+		// get input compression information and prepare decoding.
+		const EXRDecoder = setupDecoder( EXRHeader, bufferDataView, uInt8Array, offset, this.type, this.outputFormat );
+
+		// parse input data
+		EXRDecoder.decode();
+
+		// output texture post-processing
+		if ( EXRDecoder.shouldExpand ) {
+
+			const byteArray = EXRDecoder.byteArray;
+
+			if ( this.outputFormat == RGBAFormat ) {
+
+				for ( let i = 0; i < byteArray.length; i += 4 )
+					byteArray[ i + 2 ] = ( byteArray[ i + 1 ] = byteArray[ i ] );
+
+			} else if ( this.outputFormat == RGFormat ) {
+
+				for ( let i = 0; i < byteArray.length; i += 2 )
+					byteArray[ i + 1 ] = byteArray[ i ];
+
+			}
+
+		}
+
+		return {
+			header: EXRHeader,
+			width: EXRDecoder.width,
+			height: EXRDecoder.height,
+			data: EXRDecoder.byteArray,
+			format: EXRDecoder.format,
+			colorSpace: EXRDecoder.colorSpace,
+			type: this.type,
+		};
+
+	}
+
+	/**
+	 * Sets the texture type.
+	 *
+	 * @param {(HalfFloatType|FloatType)} value - The texture type to set.
+	 * @return {EXRLoader} A reference to this loader.
+	 */
+	setDataType( value ) {
+
+		this.type = value;
+		return this;
+
+	}
+
+	/**
+	 * Sets texture output format. Defaults to `RGBAFormat`.
+	 *
+	 * @param {(RGBAFormat|RGFormat|RedFormat)} value - Texture output format.
+	 * @return {EXRLoader} A reference to this loader.
+	 */
+	setOutputFormat( value ) {
+
+		this.outputFormat = value;
+		return this;
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		function onLoadCallback( texture, texData ) {
+
+			texture.colorSpace = texData.colorSpace;
+			texture.minFilter = LinearFilter;
+			texture.magFilter = LinearFilter;
+			texture.generateMipmaps = false;
+			texture.flipY = false;
+
+			if ( onLoad ) onLoad( texture, texData );
+
+		}
+
+		return super.load( url, onLoadCallback, onProgress, onError );
+
+	}
+
+}
+
+function loadEnvironment(renderer, url) {
+    return new Promise((resolve, reject) => {
+        const pmrem = new THREE.PMREMGenerator(renderer);
+        pmrem.compileEquirectangularShader();
+        const onLoad = (texture) => {
+            const envMap = pmrem.fromEquirectangular(texture).texture;
+            texture.dispose();
+            pmrem.dispose();
+            resolve({ envMap, dispose: () => envMap.dispose() });
+        };
+        const cleanUrl = url.split('?')[0].split('#')[0].toLowerCase();
+        if (cleanUrl.endsWith('.exr')) {
+            new EXRLoader().load(url, onLoad, undefined, reject);
+        }
+        else {
+            new RGBELoader().load(url, onLoad, undefined, reject);
         }
-    }
-    if (vertexCount > HIGH_VERTEX_THRESHOLD) {
-        warnings.push(`High vertex count (${vertexCount.toLocaleString()}) may impact performance`);
-    }
-    return {
-        supported: supported.length,
-        missing,
-        warnings,
-        modelStats: { vertexCount, textureCount, morphTargetCount },
-    };
+    });
 }
-function VRMAvatar({ blendshapes, width = 400, height = 400, modelUrl = '/models/avatar.vrm', backgroundColor = 0x1a1a2e, blendshapeMap, onModelLoad, maxModelSize = DEFAULT_MAX_MODEL_SIZE, }) {
+
+const DEFAULT_MAX_MODEL_SIZE = 30 * 1024 * 1024; // 30MB
+function VRMAvatar({ blendshapes, width = 400, height = 400, modelUrl = 'https://xwqtyabmavpacejuypyp.supabase.co/storage/v1/object/public/vrm-templates/5705015963733407866.vrm', backgroundColor = 0xffffff, blendshapeMap, expressionOverrides, onModelLoad, maxModelSize = DEFAULT_MAX_MODEL_SIZE, cameraPosition, cameraTarget, cameraFov, lightIntensity, idleAnimationUrl, animationSpeed = 1, animationWeight = 1, animationCrossfade = 0.5, postProcessing, environmentUrl, environmentIntensity, environmentBlur, environmentZoom, onEnvironmentLoad, features, orbitAngle, orbitElevation, avatarRotation, onOrbitChange, }) {
     const containerRef = useRef(null);
     const rendererRef = useRef(null);
     const sceneRef = useRef(null);
     const cameraRef = useRef(null);
     const vrmRef = useRef(null);
+    const lightsRef = useRef(null);
+    const onModelLoadRef = useRef(onModelLoad);
+    onModelLoadRef.current = onModelLoad;
+    const animSpeedRef = useRef(animationSpeed);
+    animSpeedRef.current = animationSpeed;
+    const animWeightRef = useRef(animationWeight);
+    animWeightRef.current = animationWeight;
+    const animCrossfadeRef = useRef(animationCrossfade);
+    animCrossfadeRef.current = animationCrossfade;
+    const exprOverridesRef = useRef(expressionOverrides);
+    exprOverridesRef.current = expressionOverrides;
+    const featuresRef = useRef(features);
+    featuresRef.current = features;
+    const envZoomRef = useRef(environmentZoom);
+    envZoomRef.current = environmentZoom;
+    const onEnvLoadRef = useRef(onEnvironmentLoad);
+    onEnvLoadRef.current = onEnvironmentLoad;
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(null);
     const animationFrameRef = useRef(0);
     const animationTimeRef = useRef(0);
+    const mixerRef = useRef(null);
+    const clipActionRef = useRef(null);
+    const composerRef = useRef(null);
+    const envMapRef = useRef(null);
+    const bgSceneRef = useRef(new THREE.Scene());
+    useRef(null);
+    const fpsMonitorRef = useRef(new FpsMonitor());
+    const orbitRef = useRef({ angle: 0, targetAngle: 0, elevation: 0, targetElevation: 0, zoomOffset: 0, dragging: false, lastX: 0, lastY: 0 });
+    const orbitAnglePropRef = useRef(orbitAngle);
+    orbitAnglePropRef.current = orbitAngle;
+    const onOrbitChangeRef = useRef(onOrbitChange);
+    onOrbitChangeRef.current = onOrbitChange;
+    const baseCamRef = useRef({ distance: 1.2, height: 1.4, targetY: 1.3 });
+    const idleRef = useRef({ blinkNext: 2 + Math.random() * 4, blinkPhase: 0, blinkStart: 0,
+        happy: 0, happyTarget: 0, browInner: 0, browTarget: 0, cheek: 0, cheekTarget: 0, microNext: 3,
+        eyeX: 0, eyeY: 0, eyeTargetX: 0, eyeTargetY: 0, eyeNext: 1 });
+    const isA2FActiveRef = useRef(false);
+    const idleMorphsRef = useRef([]);
+    const springSettleFramesRef = useRef(0);
     const applyBlendshapes = useCallback((vrm, shapes) => {
         const arkitMap = {};
         ARKIT_BLENDSHAPES.forEach((name, i) => {
             arkitMap[name] = shapes[i] || 0;
         });
-        const mouthOpen = arkitMap.jawOpen || 0;
+        const mouthOpen = arkitMap.jawOpen || 0, funnel = arkitMap.mouthFunnel || 0;
         const smile = ((arkitMap.mouthSmileLeft || 0) + (arkitMap.mouthSmileRight || 0)) / 2;
-        const funnel = arkitMap.mouthFunnel || 0;
-        const blinkLeft = arkitMap.eyeBlinkLeft || 0;
-        const blinkRight = arkitMap.eyeBlinkRight || 0;
+        const blinkLeft = arkitMap.eyeBlinkLeft || 0, blinkRight = arkitMap.eyeBlinkRight || 0;
         if (vrm.expressionManager) {
             vrm.expressionManager.expressions.forEach(exp => {
                 vrm.expressionManager?.setValue(exp.expressionName, 0);
             });
-            const trySetExpression = (name, value) => {
+            const trySet = (name, value) => {
                 try {
                     vrm.expressionManager?.setValue(name, Math.min(Math.max(value, 0), 1));
                 }
-                catch {
-                    // Expression doesn't exist
-                }
+                catch { }
             };
-            trySetExpression('aa', mouthOpen * 1.5);
-            trySetExpression('happy', smile * 2);
-            trySetExpression('blink', (blinkLeft + blinkRight) / 2);
-            trySetExpression('blinkLeft', blinkLeft);
-            trySetExpression('blinkRight', blinkRight);
-            trySetExpression('ou', funnel);
+            trySet('aa', mouthOpen * 1.5);
+            trySet('happy', smile * 2);
+            trySet('blink', (blinkLeft + blinkRight) / 2);
+            trySet('blinkLeft', blinkLeft);
+            trySet('blinkRight', blinkRight);
+            trySet('ou', funnel);
             vrm.expressionManager.update();
         }
         vrm.scene.traverse((obj) => {
@@ -937,20 +4216,21 @@ function VRMAvatar({ blendshapes, width = 400, height = 400, modelUrl = '/models
         container.appendChild(renderer.domElement);
         rendererRef.current = renderer;
         const scene = new THREE.Scene();
-        scene.background = new THREE.Color(backgroundColor);
+        scene.background = backgroundColor === null ? null : new THREE.Color(backgroundColor ?? 0xffffff);
         sceneRef.current = scene;
         const camera = new THREE.PerspectiveCamera(30, width / height, 0.1, 20);
         camera.position.set(0, 1.4, 1.2);
         camera.lookAt(0, 1.3, 0);
         cameraRef.current = camera;
-        const ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
+        const ambientLight = new THREE.AmbientLight(0xffffff, 1.0);
         scene.add(ambientLight);
-        const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
+        const directionalLight = new THREE.DirectionalLight(0xffffff, 1.2);
         directionalLight.position.set(1, 1, 1);
         scene.add(directionalLight);
-        const backLight = new THREE.DirectionalLight(0x4a9eff, 0.3);
+        const backLight = new THREE.DirectionalLight(0x4a9eff, 0.4);
         backLight.position.set(-1, 1, -1);
         scene.add(backLight);
+        lightsRef.current = { ambient: ambientLight, directional: directionalLight, back: backLight };
         let cancelled = false;
         // Size guard: fire HEAD check in parallel — if model is too large, cancel before render
         if (maxModelSize > 0) {
@@ -965,7 +4245,7 @@ function VRMAvatar({ blendshapes, width = 400, height = 400, modelUrl = '/models
                     const errMsg = `Model too large (${sizeMB}MB, limit ${limitMB}MB)`;
                     setError(errMsg);
                     setLoading(false);
-                    onModelLoad?.({
+                    onModelLoadRef.current?.({
                         supported: 0, missing: [...ARKIT_BLENDSHAPES], warnings: [errMsg],
                         modelStats: { vertexCount: 0, textureCount: 0, morphTargetCount: 0 },
                     });
@@ -981,12 +4261,44 @@ function VRMAvatar({ blendshapes, width = 400, height = 400, modelUrl = '/models
             if (vrm) {
                 scene.add(vrm.scene);
                 vrmRef.current = vrm;
+                const mc = [];
+                vrm.scene.traverse((o) => {
+                    const mesh = o;
+                    if (!mesh.isMesh)
+                        return;
+                    const d = mesh.morphTargetDictionary, inf = mesh.morphTargetInfluences;
+                    if (!d || !inf)
+                        return;
+                    const e = { inf };
+                    if (d['browInnerUp'] !== undefined)
+                        e.brow = d['browInnerUp'];
+                    if (d['cheekSquintLeft'] !== undefined)
+                        e.cheekL = d['cheekSquintLeft'];
+                    if (d['cheekSquintRight'] !== undefined)
+                        e.cheekR = d['cheekSquintRight'];
+                    if (e.brow !== undefined || e.cheekL !== undefined)
+                        mc.push(e);
+                });
+                idleMorphsRef.current = mc;
+                // Apply idle pose immediately so the model never renders in T-pose
+                const humanoid = vrm.humanoid;
+                if (humanoid) {
+                    const b = (n) => humanoid.getNormalizedBoneNode(n);
+                    const lArm = b(VRMHumanBoneName.LeftUpperArm), rArm = b(VRMHumanBoneName.RightUpperArm);
+                    if (lArm)
+                        lArm.rotation.z = -1;
+                    if (rArm)
+                        rArm.rotation.z = 1.0;
+                }
+                vrm.update(0);
+                vrm.springBoneManager?.reset();
+                springSettleFramesRef.current = 30;
                 setLoading(false);
                 const report = buildCompatibilityReport(vrm);
                 if (report.warnings.length > 0) {
                     console.warn('[VRM] Compatibility warnings:', report.warnings);
                 }
-                onModelLoad?.(report);
+                onModelLoadRef.current?.(report);
             }
         }, () => { }, (err) => {
             if (cancelled)
@@ -1007,71 +4319,458 @@ function VRMAvatar({ blendshapes, width = 400, height = 400, modelUrl = '/models
             animationTimeRef.current += delta;
             if (vrmRef.current) {
                 vrmRef.current.update(delta);
+                if (featuresRef.current?.springBones === false || springSettleFramesRef.current > 0) {
+                    vrmRef.current.springBoneManager?.reset();
+                    if (springSettleFramesRef.current > 0)
+                        springSettleFramesRef.current--;
+                }
+                if (mixerRef.current)
+                    mixerRef.current.update(delta);
                 const humanoid = vrmRef.current.humanoid;
-                if (humanoid) {
-                    const time = animationTimeRef.current;
-                    const breathCycle = time * 1.2;
-                    const breathIntensity = 0.03;
-                    const idleSway = time * 0.5;
-                    const swayIntensity = 0.02;
-                    const headBob = time * 0.7;
-                    const headBobIntensity = 0.015;
-                    const spineBone = humanoid.getNormalizedBoneNode(VRMHumanBoneName.Spine);
-                    if (spineBone) {
-                        spineBone.rotation.x = Math.sin(breathCycle) * breathIntensity;
-                        spineBone.rotation.z = Math.sin(idleSway) * swayIntensity * 0.3;
+                if (featuresRef.current?.idleAnimation !== false && humanoid && !clipActionRef.current) {
+                    const t = animationTimeRef.current, br = t * 1.2, sw = t * 0.5, hb = t * 0.7;
+                    const b = (n) => humanoid.getNormalizedBoneNode(n);
+                    const spine = b(VRMHumanBoneName.Spine);
+                    if (spine) {
+                        spine.rotation.x = Math.sin(br) * 0.03;
+                        spine.rotation.z = Math.sin(sw) * 0.006;
+                    }
+                    const chest = b(VRMHumanBoneName.Chest);
+                    if (chest) {
+                        chest.rotation.x = Math.sin(br + 0.3) * 0.015;
+                        chest.rotation.z = Math.sin(sw + 0.5) * 0.004;
                     }
-                    const chestBone = humanoid.getNormalizedBoneNode(VRMHumanBoneName.Chest);
-                    if (chestBone) {
-                        chestBone.rotation.x = Math.sin(breathCycle + 0.3) * breathIntensity * 0.5;
-                        chestBone.rotation.z = Math.sin(idleSway + 0.5) * swayIntensity * 0.2;
+                    const neck = b(VRMHumanBoneName.Neck);
+                    if (neck) {
+                        neck.rotation.x = Math.sin(hb) * 0.015;
+                        neck.rotation.y = Math.sin(sw * 0.7) * 0.01;
                     }
-                    const neckBone = humanoid.getNormalizedBoneNode(VRMHumanBoneName.Neck);
-                    if (neckBone) {
-                        neckBone.rotation.x = Math.sin(headBob) * headBobIntensity;
-                        neckBone.rotation.y = Math.sin(idleSway * 0.7) * swayIntensity * 0.5;
+                    const head = b(VRMHumanBoneName.Head);
+                    if (head) {
+                        head.rotation.x = Math.sin(hb + 0.5) * 0.006;
+                        head.rotation.y = Math.sin(sw * 0.6 + 0.8) * 0.006;
                     }
-                    const headBone = humanoid.getNormalizedBoneNode(VRMHumanBoneName.Head);
-                    if (headBone) {
-                        headBone.rotation.x = Math.sin(headBob + 0.5) * headBobIntensity * 0.4;
-                        headBone.rotation.y = Math.sin(idleSway * 0.6 + 0.8) * swayIntensity * 0.3;
+                    const lSh = b(VRMHumanBoneName.LeftShoulder), rSh = b(VRMHumanBoneName.RightShoulder);
+                    if (lSh)
+                        lSh.rotation.z = Math.sin(br) * 0.006;
+                    if (rSh)
+                        rSh.rotation.z = -Math.sin(br) * 0.006;
+                    const lArm = b(VRMHumanBoneName.LeftUpperArm), rArm = b(VRMHumanBoneName.RightUpperArm);
+                    if (lArm)
+                        lArm.rotation.z = -1 + Math.sin(sw * 0.4) * 0.02;
+                    if (rArm)
+                        rArm.rotation.z = 1.0 + Math.sin(sw * 0.4 + 0.5) * 0.02;
+                }
+                if (featuresRef.current?.microExpressions !== false && vrmRef.current.expressionManager && !isA2FActiveRef.current &&
+                    !Object.keys(exprOverridesRef.current ?? {}).length) {
+                    const idle = idleRef.current, t = animationTimeRef.current;
+                    let bv = 0;
+                    if (idle.blinkPhase === 0 && t >= idle.blinkNext) {
+                        idle.blinkPhase = 1;
+                        idle.blinkStart = t;
+                    }
+                    if (idle.blinkPhase === 1) {
+                        bv = Math.min((t - idle.blinkStart) / 0.15, 1);
+                        if (bv >= 1) {
+                            idle.blinkPhase = 2;
+                            idle.blinkStart = t;
+                        }
+                    }
+                    else if (idle.blinkPhase === 2) {
+                        bv = 1 - Math.min((t - idle.blinkStart) / 0.15, 1);
+                        if (bv <= 0) {
+                            idle.blinkPhase = 0;
+                            idle.blinkNext = t + 2 + Math.random() * 4;
+                        }
+                    }
+                    if (t >= idle.microNext) {
+                        idle.happyTarget = Math.random() * 0.1;
+                        idle.browTarget = Math.random() * 0.08;
+                        idle.cheekTarget = Math.random() * 0.05;
+                        idle.microNext = t + 3 + Math.random() * 5;
                     }
-                    const leftShoulder = humanoid.getNormalizedBoneNode(VRMHumanBoneName.LeftShoulder);
-                    const rightShoulder = humanoid.getNormalizedBoneNode(VRMHumanBoneName.RightShoulder);
-                    if (leftShoulder) {
-                        leftShoulder.rotation.z = Math.sin(breathCycle) * breathIntensity * 0.2;
+                    idle.happy += (idle.happyTarget - idle.happy) * 0.02;
+                    idle.browInner += (idle.browTarget - idle.browInner) * 0.02;
+                    idle.cheek += (idle.cheekTarget - idle.cheek) * 0.02;
+                    if (t >= idle.eyeNext) {
+                        idle.eyeTargetX = (Math.random() - 0.5) * 0.06;
+                        idle.eyeTargetY = (Math.random() - 0.5) * 0.04;
+                        idle.eyeNext = t + 1.5 + Math.random() * 3;
+                    }
+                    idle.eyeX += (idle.eyeTargetX - idle.eyeX) * 0.03;
+                    idle.eyeY += (idle.eyeTargetY - idle.eyeY) * 0.03;
+                    const em = vrmRef.current.expressionManager;
+                    try {
+                        em.setValue('blink', Math.max(bv, 0));
                     }
-                    if (rightShoulder) {
-                        rightShoulder.rotation.z = -Math.sin(breathCycle) * breathIntensity * 0.2;
+                    catch { }
+                    try {
+                        em.setValue('happy', Math.max(idle.happy, 0));
                     }
-                    const leftUpperArm = humanoid.getNormalizedBoneNode(VRMHumanBoneName.LeftUpperArm);
-                    const rightUpperArm = humanoid.getNormalizedBoneNode(VRMHumanBoneName.RightUpperArm);
-                    if (leftUpperArm) {
-                        leftUpperArm.rotation.z = -1 + Math.sin(idleSway * 0.4) * 0.02;
+                    catch { }
+                    em.update();
+                    for (const m of idleMorphsRef.current) {
+                        if (m.brow !== undefined)
+                            m.inf[m.brow] = idle.browInner;
+                        if (m.cheekL !== undefined)
+                            m.inf[m.cheekL] = idle.cheek;
+                        if (m.cheekR !== undefined)
+                            m.inf[m.cheekR] = idle.cheek;
                     }
-                    if (rightUpperArm) {
-                        rightUpperArm.rotation.z = 1.0 + Math.sin(idleSway * 0.4 + 0.5) * 0.02;
+                    if (humanoid) {
+                        for (const bn of [VRMHumanBoneName.LeftEye, VRMHumanBoneName.RightEye]) {
+                            const eye = humanoid.getNormalizedBoneNode(bn);
+                            if (eye) {
+                                eye.rotation.x = idle.eyeY;
+                                eye.rotation.y = idle.eyeX;
+                            }
+                        }
                     }
                 }
             }
-            renderer.render(scene, camera);
+            // Smooth lerp for spherical orbit (azimuth + elevation)
+            const orbit = orbitRef.current;
+            const elevDiff = orbit.targetElevation - orbit.elevation;
+            const angleDiff = orbit.targetAngle - orbit.angle;
+            if (Math.abs(elevDiff) > 0.0005 || Math.abs(angleDiff) > 0.0005) {
+                orbit.elevation += elevDiff * 0.1;
+                orbit.angle += angleDiff * 0.1;
+                const base = baseCamRef.current;
+                const d = Math.max(0.3, base.distance + orbit.zoomOffset);
+                const cosEl = Math.cos(orbit.elevation);
+                const sinEl = Math.sin(orbit.elevation);
+                camera.position.set(Math.sin(orbit.angle) * cosEl * d, base.height + sinEl * d, Math.cos(orbit.angle) * cosEl * d);
+                camera.lookAt(0, base.targetY, 0);
+            }
+            const pipeline = composerRef.current;
+            const ez = envZoomRef.current;
+            const hasBgZoom = ez && ez !== 1 && scene.background && envMapRef.current;
+            if (hasBgZoom && !pipeline) {
+                const baseFov = camera.fov;
+                const bgScene = bgSceneRef.current;
+                bgScene.backgroundBlurriness = scene.backgroundBlurriness;
+                bgScene.backgroundIntensity = scene.backgroundIntensity ?? 1;
+                camera.fov = baseFov / ez;
+                camera.updateProjectionMatrix();
+                renderer.render(bgScene, camera);
+                camera.fov = baseFov;
+                camera.updateProjectionMatrix();
+                const savedBg = scene.background;
+                scene.background = null;
+                renderer.autoClear = false;
+                renderer.clearDepth();
+                renderer.render(scene, camera);
+                renderer.autoClear = true;
+                scene.background = savedBg;
+            }
+            else if (pipeline && !fpsMonitorRef.current.disabled) {
+                pipeline.composer.render();
+                fpsMonitorRef.current.tick(performance.now());
+            }
+            else {
+                renderer.render(scene, camera);
+            }
         };
         animate();
         return () => {
             cancelled = true;
             cancelAnimationFrame(animationFrameRef.current);
+            clipActionRef.current = null;
+            mixerRef.current = null;
+            composerRef.current?.dispose();
+            composerRef.current = null;
+            envMapRef.current?.dispose();
+            envMapRef.current = null;
             renderer.dispose();
             if (container && renderer.domElement) {
                 container.removeChild(renderer.domElement);
             }
         };
-    }, [width, height, modelUrl, backgroundColor, maxModelSize, onModelLoad]);
+    }, [width, height, modelUrl, maxModelSize]);
+    useEffect(() => {
+        composerRef.current?.dispose();
+        composerRef.current = null;
+        fpsMonitorRef.current.reset();
+        const renderer = rendererRef.current, scene = sceneRef.current, camera = cameraRef.current;
+        const pp = features?.postProcessing ?? postProcessing;
+        if (!renderer || !scene || !camera || !pp)
+            return;
+        const hasAnyEffect = (pp.bloom && pp.bloom > 0) || (pp.ao && pp.ao > 0) || pp.dof;
+        if (!hasAnyEffect)
+            return;
+        composerRef.current = createPostProcessing(renderer, scene, camera, pp, width, height);
+        return () => { composerRef.current?.dispose(); composerRef.current = null; };
+    }, [postProcessing, features, width, height]);
+    // Load/unload .vrma animation clip — crossfade between clips
+    useEffect(() => {
+        const vrm = vrmRef.current;
+        const fade = animCrossfadeRef.current;
+        if (!idleAnimationUrl) {
+            const old = clipActionRef.current;
+            if (old) {
+                old.fadeOut(fade);
+                setTimeout(() => {
+                    old.stop();
+                    if (clipActionRef.current === old)
+                        clipActionRef.current = null;
+                    if (mixerRef.current && !clipActionRef.current) {
+                        mixerRef.current.stopAllAction();
+                        mixerRef.current = null;
+                    }
+                }, fade * 1000);
+            }
+            return;
+        }
+        if (!vrm)
+            return;
+        let cancelled = false;
+        const loader = new GLTFLoader();
+        loader.register((parser) => new VRMAnimationLoaderPlugin(parser));
+        loader.load(idleAnimationUrl, (gltf) => {
+            if (cancelled || !vrmRef.current)
+                return;
+            const animations = gltf.userData.vrmAnimations;
+            if (!animations || animations.length === 0)
+                return;
+            const mixer = mixerRef.current ?? new THREE.AnimationMixer(vrmRef.current.scene);
+            mixerRef.current = mixer;
+            const clip = createVRMAnimationClip(animations[0], vrmRef.current);
+            const newAction = mixer.clipAction(clip);
+            newAction.setLoop(THREE.LoopPingPong, Infinity);
+            newAction.timeScale = animSpeedRef.current;
+            newAction.setEffectiveWeight(animWeightRef.current);
+            const oldAction = clipActionRef.current;
+            const cf = animCrossfadeRef.current;
+            if (oldAction) {
+                newAction.reset().play();
+                oldAction.crossFadeTo(newAction, cf, true);
+                setTimeout(() => { oldAction.stop(); mixer.uncacheAction(oldAction.getClip()); }, cf * 1000);
+            }
+            else {
+                newAction.reset().fadeIn(cf).play();
+            }
+            clipActionRef.current = newAction;
+        }, () => { }, (err) => {
+            if (cancelled)
+                return;
+            console.warn('[VRM] Failed to load animation clip:', err);
+        });
+        return () => { cancelled = true; };
+    }, [idleAnimationUrl, loading]);
+    // Update animation speed/weight in real time
+    useEffect(() => {
+        if (clipActionRef.current)
+            clipActionRef.current.timeScale = animationSpeed;
+    }, [animationSpeed]);
+    useEffect(() => {
+        if (clipActionRef.current)
+            clipActionRef.current.setEffectiveWeight(animationWeight);
+    }, [animationWeight]);
+    // Update background in-place (skip when HDRI active)
+    useEffect(() => {
+        if (sceneRef.current && !environmentUrl) {
+            sceneRef.current.background = backgroundColor === null ? null : new THREE.Color(backgroundColor ?? 0xffffff);
+        }
+    }, [backgroundColor, environmentUrl]);
+    // HDRI environment map loading — keep old envMap visible until new one is ready
+    useEffect(() => {
+        const scene = sceneRef.current, renderer = rendererRef.current;
+        if (!scene || !renderer || !environmentUrl) {
+            envMapRef.current?.dispose();
+            envMapRef.current = null;
+            if (scene) {
+                scene.environment = null;
+                scene.background = null;
+                scene.backgroundBlurriness = 0;
+                scene.environmentIntensity = 1;
+            }
+            return;
+        }
+        let cancelled = false;
+        const prev = envMapRef.current;
+        loadEnvironment(renderer, environmentUrl).then(r => {
+            if (cancelled) {
+                r.dispose();
+                return;
+            }
+            prev?.dispose();
+            scene.environment = r.envMap;
+            scene.background = r.envMap;
+            scene.backgroundBlurriness = environmentBlur ?? 0;
+            scene.environmentIntensity = environmentIntensity ?? 1;
+            scene.backgroundIntensity = environmentIntensity ?? 1;
+            bgSceneRef.current.background = r.envMap;
+            envMapRef.current = { dispose: r.dispose, envMap: r.envMap };
+            onEnvLoadRef.current?.();
+        }).catch(e => console.warn('[VRM] HDRI load failed:', e));
+        return () => { cancelled = true; };
+    }, [environmentUrl]);
+    // Update HDRI intensity/blur without reloading
+    useEffect(() => {
+        if (!sceneRef.current || !envMapRef.current)
+            return;
+        sceneRef.current.backgroundBlurriness = environmentBlur ?? 0;
+        sceneRef.current.environmentIntensity = environmentIntensity ?? 1;
+        sceneRef.current.backgroundIntensity = environmentIntensity ?? 1;
+    }, [environmentIntensity, environmentBlur]);
+    // Update camera base values and apply orbit
+    useEffect(() => {
+        const pos = cameraPosition ?? [0, 1.4, 1.2];
+        const target = cameraTarget ?? [0, 1.3, 0];
+        baseCamRef.current = { distance: pos[2], height: pos[1], targetY: target[1] };
+        if (orbitAnglePropRef.current === undefined) {
+            orbitRef.current.angle = 0;
+            orbitRef.current.targetAngle = 0;
+        }
+        orbitRef.current.zoomOffset = 0;
+        if (orbitElevation === undefined) {
+            orbitRef.current.elevation = 0;
+            orbitRef.current.targetElevation = 0;
+        }
+        const camera = cameraRef.current;
+        if (!camera)
+            return;
+        const d = baseCamRef.current.distance;
+        camera.position.set(0, baseCamRef.current.height, d);
+        camera.lookAt(0, baseCamRef.current.targetY, 0);
+        if (cameraFov !== undefined && camera.fov !== cameraFov) {
+            camera.fov = cameraFov;
+            camera.updateProjectionMatrix();
+        }
+    }, [cameraPosition, cameraTarget, cameraFov]);
+    // Prop-driven orbit angle
+    useEffect(() => {
+        if (orbitAngle !== undefined) {
+            orbitRef.current.targetAngle = orbitAngle;
+        }
+    }, [orbitAngle]);
+    // Prop-driven orbit elevation
+    useEffect(() => {
+        if (orbitElevation !== undefined) {
+            orbitRef.current.targetElevation = orbitElevation;
+        }
+    }, [orbitElevation]);
+    // Prop-driven avatar rotation
+    useEffect(() => {
+        if (avatarRotation !== undefined && vrmRef.current) {
+            vrmRef.current.scene.rotation.y = avatarRotation;
+        }
+    }, [avatarRotation, loading]);
+    // Mouse orbit (horizontal only) + scroll zoom
+    useEffect(() => {
+        const container = containerRef.current;
+        if (!container)
+            return;
+        const applyCameraOrbit = () => {
+            const camera = cameraRef.current;
+            if (!camera)
+                return;
+            const base = baseCamRef.current;
+            const orbit = orbitRef.current;
+            const d = Math.max(0.3, base.distance + orbit.zoomOffset);
+            const cosEl = Math.cos(orbit.elevation);
+            const sinEl = Math.sin(orbit.elevation);
+            camera.position.set(Math.sin(orbit.angle) * cosEl * d, base.height + sinEl * d, Math.cos(orbit.angle) * cosEl * d);
+            camera.lookAt(0, base.targetY, 0);
+        };
+        const onWheel = (e) => {
+            e.preventDefault();
+            orbitRef.current.zoomOffset += e.deltaY * 0.002;
+            applyCameraOrbit();
+        };
+        const onMouseDown = (e) => {
+            orbitRef.current.dragging = true;
+            orbitRef.current.lastX = e.clientX;
+            orbitRef.current.lastY = e.clientY;
+        };
+        const onMouseMove = (e) => {
+            if (!orbitRef.current.dragging)
+                return;
+            const dx = e.clientX - orbitRef.current.lastX;
+            const dy = e.clientY - orbitRef.current.lastY;
+            orbitRef.current.lastX = e.clientX;
+            orbitRef.current.lastY = e.clientY;
+            orbitRef.current.angle -= dx * 0.005;
+            orbitRef.current.targetAngle = orbitRef.current.angle;
+            orbitRef.current.elevation = Math.max(-Math.PI / 3, Math.min(Math.PI / 3, orbitRef.current.elevation + dy * 0.005));
+            orbitRef.current.targetElevation = orbitRef.current.elevation;
+            applyCameraOrbit();
+            onOrbitChangeRef.current?.(orbitRef.current.angle, orbitRef.current.elevation);
+        };
+        const onMouseUp = () => {
+            orbitRef.current.dragging = false;
+        };
+        const onKeyDown = (e) => {
+            const o = orbitRef.current;
+            if (e.key === 'ArrowUp') {
+                e.preventDefault();
+                o.targetElevation = Math.min(o.targetElevation + 0.1, Math.PI / 3);
+            }
+            else if (e.key === 'ArrowDown') {
+                e.preventDefault();
+                o.targetElevation = Math.max(o.targetElevation - 0.1, -Math.PI / 3);
+            }
+            else if (e.key === 'ArrowLeft') {
+                e.preventDefault();
+                o.targetAngle += 0.15;
+            }
+            else if (e.key === 'ArrowRight') {
+                e.preventDefault();
+                o.targetAngle -= 0.15;
+            }
+            onOrbitChangeRef.current?.(o.targetAngle, o.targetElevation);
+        };
+        container.addEventListener('wheel', onWheel, { passive: false });
+        container.addEventListener('mousedown', onMouseDown);
+        window.addEventListener('mousemove', onMouseMove);
+        window.addEventListener('mouseup', onMouseUp);
+        window.addEventListener('keydown', onKeyDown);
+        return () => {
+            container.removeEventListener('wheel', onWheel);
+            container.removeEventListener('mousedown', onMouseDown);
+            window.removeEventListener('mousemove', onMouseMove);
+            window.removeEventListener('mouseup', onMouseUp);
+            window.removeEventListener('keydown', onKeyDown);
+        };
+    }, []);
+    // Update lighting in-place
+    useEffect(() => {
+        if (!lightsRef.current)
+            return;
+        const intensity = lightIntensity ?? 1;
+        lightsRef.current.ambient.intensity = 1.0 * intensity;
+        lightsRef.current.directional.intensity = 1.2 * intensity;
+        lightsRef.current.back.intensity = 0.4 * intensity;
+    }, [lightIntensity]);
     useEffect(() => {
+        isA2FActiveRef.current = blendshapes.some(v => v !== 0);
         if (vrmRef.current && blendshapes.length > 0) {
             applyBlendshapes(vrmRef.current, blendshapes);
         }
     }, [blendshapes, applyBlendshapes]);
+    useEffect(() => {
+        const vrm = vrmRef.current;
+        if (!vrm?.expressionManager)
+            return;
+        const hasLiveData = blendshapes.some(v => v !== 0);
+        if (hasLiveData)
+            return;
+        if (features?.expressionPresets === false)
+            return;
+        vrm.expressionManager.expressions.forEach(exp => {
+            vrm.expressionManager.setValue(exp.expressionName, 0);
+        });
+        if (expressionOverrides) {
+            for (const [name, value] of Object.entries(expressionOverrides)) {
+                try {
+                    vrm.expressionManager.setValue(name, Math.min(Math.max(value, 0), 1));
+                }
+                catch { /* expression doesn't exist on this model */ }
+            }
+        }
+        vrm.expressionManager.update();
+    }, [expressionOverrides, blendshapes]);
     return (jsxs("div", { className: "relative", style: { width, height }, children: [jsx("div", { ref: containerRef, className: "rounded-lg overflow-hidden" }), loading && (jsx("div", { className: "absolute inset-0 flex items-center justify-center bg-gray-800 rounded-lg", children: jsx("div", { className: "text-white text-sm", children: "Loading VRM avatar..." }) })), error && (jsx("div", { className: "absolute inset-0 flex items-center justify-center bg-red-900/50 rounded-lg", children: jsx("div", { className: "text-white text-sm", children: error }) }))] }));
 }
 
-export { VRMAvatar, useAStackCSR };
+export { VRMAvatar, VROID_BLENDSHAPE_MAP, useAStackCSR };