@iwsdk/core 0.2.1 → 0.3.0

package/dist/node_modules/.pnpm/super-three@0.177.0/node_modules/super-three/examples/jsm/loaders/EXRLoader.js

@@ -1,2587 +0,0 @@
-import { DataTextureLoader, HalfFloatType, FloatType, RGBAFormat, LinearSRGBColorSpace, RedFormat, NoColorSpace, LinearFilter, DataUtils } from 'three';
-import { unzlibSync } from '../libs/fflate.module.js';
-
-// 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;
-
-	}
-
-	/**
-	 * 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 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;
-
-				}
-
-			}
-
-			// Lossy DCT decode RGB channels
-			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: // skip
-
-					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 ) {
-
-			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: {},
-				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;
-
-			if ( channels.R && channels.G && channels.B ) {
-
-				fillAlpha = ! channels.A;
-				EXRDecoder.outputChannels = 4;
-				EXRDecoder.decodeChannels = { R: 0, G: 1, B: 2, A: 3 };
-
-			} else if ( channels.Y ) {
-
-				EXRDecoder.outputChannels = 1;
-				EXRDecoder.decodeChannels = { Y: 0 };
-
-			} else {
-
-				throw new Error( 'EXRLoader.parse: file contains unsupported data channels.' );
-
-			}
-
-			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 ( EXRDecoder.outputChannels == 4 ) {
-
-				EXRDecoder.format = RGBAFormat;
-				EXRDecoder.colorSpace = LinearSRGBColorSpace;
-
-			} else {
-
-				EXRDecoder.format = RedFormat;
-				EXRDecoder.colorSpace = NoColorSpace;
-
-			}
-
-			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 );
-
-		// parse input data
-		EXRDecoder.decode();
-
-		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 {RGBMLoader} A reference to this loader.
-	 */
-	setDataType( value ) {
-
-		this.type = 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 );
-
-	}
-
-}
-
-export { EXRLoader };
-//# sourceMappingURL=EXRLoader.js.map