super-three 0.136.0 → 0.141.0

package/examples/js/loaders/EXRLoader.js

@@ -109,9 +109,9 @@
 
 			function reverseLutFromBitmap( bitmap, lut ) {
 
-				var k = 0;
+				let k = 0;
 
-				for ( var i = 0; i < USHORT_RANGE; ++ i ) {
+				for ( let i = 0; i < USHORT_RANGE; ++ i ) {
 
 					if ( i == 0 || bitmap[ i >> 3 ] & 1 << ( i & 7 ) ) {
 
@@ -121,7 +121,7 @@
 
 				}
 
-				var n = k - 1;
+				const n = k - 1;
 
 				while ( k < USHORT_RANGE ) lut[ k ++ ] = 0;
 
@@ -131,7 +131,7 @@
 
 			function hufClearDecTable( hdec ) {
 
-				for ( var i = 0; i < HUF_DECSIZE; i ++ ) {
+				for ( let i = 0; i < HUF_DECSIZE; i ++ ) {
 
 					hdec[ i ] = {};
 					hdec[ i ].len = 0;
@@ -168,40 +168,40 @@
 
 			function hufCanonicalCodeTable( hcode ) {
 
-				for ( var i = 0; i <= 58; ++ i ) hufTableBuffer[ i ] = 0;
+				for ( let i = 0; i <= 58; ++ i ) hufTableBuffer[ i ] = 0;
 
-				for ( var i = 0; i < HUF_ENCSIZE; ++ i ) hufTableBuffer[ hcode[ i ] ] += 1;
+				for ( let i = 0; i < HUF_ENCSIZE; ++ i ) hufTableBuffer[ hcode[ i ] ] += 1;
 
-				var c = 0;
+				let c = 0;
 
-				for ( var i = 58; i > 0; -- i ) {
+				for ( let i = 58; i > 0; -- i ) {
 
-					var nc = c + hufTableBuffer[ i ] >> 1;
+					const nc = c + hufTableBuffer[ i ] >> 1;
 					hufTableBuffer[ i ] = c;
 					c = nc;
 
 				}
 
-				for ( var i = 0; i < HUF_ENCSIZE; ++ i ) {
+				for ( let i = 0; i < HUF_ENCSIZE; ++ i ) {
 
-					var l = hcode[ i ];
+					const l = hcode[ i ];
 					if ( l > 0 ) hcode[ i ] = l | hufTableBuffer[ l ] ++ << 6;
 
 				}
 
 			}
 
-			function hufUnpackEncTable( uInt8Array, inDataView, inOffset, ni, im, iM, hcode ) {
+			function hufUnpackEncTable( uInt8Array, inOffset, ni, im, iM, hcode ) {
 
-				var p = inOffset;
-				var c = 0;
-				var lc = 0;
+				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 );
-					var l = getBitsReturn.l;
+					const l = getBitsReturn.l;
 					c = getBitsReturn.c;
 					lc = getBitsReturn.lc;
 					hcode[ im ] = l;
@@ -210,18 +210,18 @@
 
 						if ( p.value - inOffset.value > ni ) {
 
-							throw 'Something wrong with hufUnpackEncTable';
+							throw new Error( 'Something wrong with hufUnpackEncTable' );
 
 						}
 
 						getBits( 8, c, lc, uInt8Array, p );
-						var zerun = getBitsReturn.l + SHORTEST_LONG_RUN;
+						let zerun = getBitsReturn.l + SHORTEST_LONG_RUN;
 						c = getBitsReturn.c;
 						lc = getBitsReturn.lc;
 
 						if ( im + zerun > iM + 1 ) {
 
-							throw 'Something wrong with hufUnpackEncTable';
+							throw new Error( 'Something wrong with hufUnpackEncTable' );
 
 						}
 
@@ -231,11 +231,11 @@
 
 					} else if ( l >= SHORT_ZEROCODE_RUN ) {
 
-						var zerun = l - SHORT_ZEROCODE_RUN + 2;
+						let zerun = l - SHORT_ZEROCODE_RUN + 2;
 
 						if ( im + zerun > iM + 1 ) {
 
-							throw 'Something wrong with hufUnpackEncTable';
+							throw new Error( 'Something wrong with hufUnpackEncTable' );
 
 						}
 
@@ -267,22 +267,22 @@
 
 				for ( ; im <= iM; im ++ ) {
 
-					var c = hufCode( hcode[ im ] );
-					var l = hufLength( hcode[ im ] );
+					const c = hufCode( hcode[ im ] );
+					const l = hufLength( hcode[ im ] );
 
 					if ( c >> l ) {
 
-						throw 'Invalid table entry';
+						throw new Error( 'Invalid table entry' );
 
 					}
 
 					if ( l > HUF_DECBITS ) {
 
-						var pl = hdecod[ c >> l - HUF_DECBITS ];
+						const pl = hdecod[ c >> l - HUF_DECBITS ];
 
 						if ( pl.len ) {
 
-							throw 'Invalid table entry';
+							throw new Error( 'Invalid table entry' );
 
 						}
 
@@ -290,10 +290,10 @@
 
 						if ( pl.p ) {
 
-							var p = pl.p;
+							const p = pl.p;
 							pl.p = new Array( pl.lit );
 
-							for ( var i = 0; i < pl.lit - 1; ++ i ) {
+							for ( let i = 0; i < pl.lit - 1; ++ i ) {
 
 								pl.p[ i ] = p[ i ];
 
@@ -309,15 +309,15 @@
 
 					} else if ( l ) {
 
-						var plOffset = 0;
+						let plOffset = 0;
 
-						for ( var i = 1 << HUF_DECBITS - l; i > 0; i -- ) {
+						for ( let i = 1 << HUF_DECBITS - l; i > 0; i -- ) {
 
-							var pl = hdecod[ ( c << HUF_DECBITS - l ) + plOffset ];
+							const pl = hdecod[ ( c << HUF_DECBITS - l ) + plOffset ];
 
 							if ( pl.len || pl.p ) {
 
-								throw 'Invalid table entry';
+								throw new Error( 'Invalid table entry' );
 
 							}
 
@@ -354,7 +354,7 @@
 				lc: 0
 			};
 
-			function getCode( po, rlc, c, lc, uInt8Array, inDataView, inOffset, outBuffer, outBufferOffset, outBufferEndOffset ) {
+			function getCode( po, rlc, c, lc, uInt8Array, inOffset, outBuffer, outBufferOffset, outBufferEndOffset ) {
 
 				if ( po == rlc ) {
 
@@ -367,8 +367,8 @@
 					}
 
 					lc -= 8;
-					var cs = c >> lc;
-					var cs = new Uint8Array( [ cs ] )[ 0 ];
+					let cs = c >> lc;
+					cs = new Uint8Array( [ cs ] )[ 0 ];
 
 					if ( outBufferOffset.value + cs > outBufferEndOffset ) {
 
@@ -376,7 +376,7 @@
 
 					}
 
-					var s = outBuffer[ outBufferOffset.value - 1 ];
+					const s = outBuffer[ outBufferOffset.value - 1 ];
 
 					while ( cs -- > 0 ) {
 
@@ -407,7 +407,7 @@
 
 			function Int16( value ) {
 
-				var ref = UInt16( value );
+				const ref = UInt16( value );
 				return ref > 0x7FFF ? ref - 0x10000 : ref;
 
 			}
@@ -419,12 +419,12 @@
 
 			function wdec14( l, h ) {
 
-				var ls = Int16( l );
-				var hs = Int16( h );
-				var hi = hs;
-				var ai = ls + ( hi & 1 ) + ( hi >> 1 );
-				var as = ai;
-				var bs = ai - hi;
+				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;
 
@@ -432,10 +432,10 @@
 
 			function wdec16( l, h ) {
 
-				var m = UInt16( l );
-				var d = UInt16( h );
-				var bb = m - ( d >> 1 ) & MOD_MASK;
-				var aa = d + bb - A_OFFSET & MOD_MASK;
+				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;
 
@@ -443,10 +443,11 @@
 
 			function wav2Decode( buffer, j, nx, ox, ny, oy, mx ) {
 
-				var w14 = mx < 1 << 14;
-				var n = nx > ny ? ny : nx;
-				var p = 1;
-				var p2;
+				const w14 = mx < 1 << 14;
+				const n = nx > ny ? ny : nx;
+				let p = 1;
+				let p2;
+				let py;
 
 				while ( p <= n ) p <<= 1;
 
@@ -456,24 +457,24 @@
 
 				while ( p >= 1 ) {
 
-					var py = 0;
-					var ey = py + oy * ( ny - p2 );
-					var oy1 = oy * p;
-					var oy2 = oy * p2;
-					var ox1 = ox * p;
-					var ox2 = ox * p2;
-					var i00, i01, i10, i11;
+					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 ) {
 
-						var px = py;
-						var ex = py + ox * ( nx - p2 );
+						let px = py;
+						const ex = py + ox * ( nx - p2 );
 
 						for ( ; px <= ex; px += ox2 ) {
 
-							var p01 = px + ox1;
-							var p10 = px + oy1;
-							var p11 = p10 + ox1;
+							const p01 = px + ox1;
+							const p10 = px + oy1;
+							const p11 = p10 + ox1;
 
 							if ( w14 ) {
 
@@ -511,7 +512,7 @@
 
 						if ( nx & p ) {
 
-							var p10 = px + oy1;
+							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;
@@ -523,12 +524,12 @@
 
 					if ( ny & p ) {
 
-						var px = py;
-						var ex = py + ox * ( nx - p2 );
+						let px = py;
+						const ex = py + ox * ( nx - p2 );
 
 						for ( ; px <= ex; px += ox2 ) {
 
-							var p01 = px + ox1;
+							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;
@@ -547,12 +548,12 @@
 
 			}
 
-			function hufDecode( encodingTable, decodingTable, uInt8Array, inDataView, inOffset, ni, rlc, no, outBuffer, outOffset ) {
+			function hufDecode( encodingTable, decodingTable, uInt8Array, inOffset, ni, rlc, no, outBuffer, outOffset ) {
 
-				var c = 0;
-				var lc = 0;
-				var outBufferEndOffset = no;
-				var inOffsetEnd = Math.trunc( inOffset.value + ( ni + 7 ) / 8 );
+				let c = 0;
+				let lc = 0;
+				const outBufferEndOffset = no;
+				const inOffsetEnd = Math.trunc( inOffset.value + ( ni + 7 ) / 8 );
 
 				while ( inOffset.value < inOffsetEnd ) {
 
@@ -562,13 +563,13 @@
 
 					while ( lc >= HUF_DECBITS ) {
 
-						var index = c >> lc - HUF_DECBITS & HUF_DECMASK;
-						var pl = decodingTable[ index ];
+						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, inDataView, inOffset, outBuffer, outOffset, outBufferEndOffset );
+							getCode( pl.lit, rlc, c, lc, uInt8Array, inOffset, outBuffer, outOffset, outBufferEndOffset );
 							c = getCodeReturn.c;
 							lc = getCodeReturn.lc;
 
@@ -576,15 +577,15 @@
 
 							if ( ! pl.p ) {
 
-								throw 'hufDecode issues';
+								throw new Error( 'hufDecode issues' );
 
 							}
 
-							var j;
+							let j;
 
 							for ( j = 0; j < pl.lit; j ++ ) {
 
-								var l = hufLength( encodingTable[ pl.p[ j ] ] );
+								const l = hufLength( encodingTable[ pl.p[ j ] ] );
 
 								while ( lc < l && inOffset.value < inOffsetEnd ) {
 
@@ -599,7 +600,7 @@
 									if ( hufCode( encodingTable[ pl.p[ j ] ] ) == ( c >> lc - l & ( 1 << l ) - 1 ) ) {
 
 										lc -= l;
-										getCode( pl.p[ j ], rlc, c, lc, uInt8Array, inDataView, inOffset, outBuffer, outOffset, outBufferEndOffset );
+										getCode( pl.p[ j ], rlc, c, lc, uInt8Array, inOffset, outBuffer, outOffset, outBufferEndOffset );
 										c = getCodeReturn.c;
 										lc = getCodeReturn.lc;
 										break;
@@ -612,7 +613,7 @@
 
 							if ( j == pl.lit ) {
 
-								throw 'hufDecode issues';
+								throw new Error( 'hufDecode issues' );
 
 							}
 
@@ -622,24 +623,24 @@
 
 				}
 
-				var i = 8 - ni & 7;
+				const i = 8 - ni & 7;
 				c >>= i;
 				lc -= i;
 
 				while ( lc > 0 ) {
 
-					var pl = decodingTable[ c << HUF_DECBITS - lc & HUF_DECMASK ];
+					const pl = decodingTable[ c << HUF_DECBITS - lc & HUF_DECMASK ];
 
 					if ( pl.len ) {
 
 						lc -= pl.len;
-						getCode( pl.lit, rlc, c, lc, uInt8Array, inDataView, inOffset, outBuffer, outOffset, outBufferEndOffset );
+						getCode( pl.lit, rlc, c, lc, uInt8Array, inOffset, outBuffer, outOffset, outBufferEndOffset );
 						c = getCodeReturn.c;
 						lc = getCodeReturn.lc;
 
 					} else {
 
-						throw 'hufDecode issues';
+						throw new Error( 'hufDecode issues' );
 
 					}
 
@@ -651,42 +652,42 @@
 
 			function hufUncompress( uInt8Array, inDataView, inOffset, nCompressed, outBuffer, nRaw ) {
 
-				var outOffset = {
+				const outOffset = {
 					value: 0
 				};
-				var initialInOffset = inOffset.value;
-				var im = parseUint32( inDataView, inOffset );
-				var iM = parseUint32( inDataView, inOffset );
+				const initialInOffset = inOffset.value;
+				const im = parseUint32( inDataView, inOffset );
+				const iM = parseUint32( inDataView, inOffset );
 				inOffset.value += 4;
-				var nBits = parseUint32( inDataView, inOffset );
+				const nBits = parseUint32( inDataView, inOffset );
 				inOffset.value += 4;
 
 				if ( im < 0 || im >= HUF_ENCSIZE || iM < 0 || iM >= HUF_ENCSIZE ) {
 
-					throw 'Something wrong with HUF_ENCSIZE';
+					throw new Error( 'Something wrong with HUF_ENCSIZE' );
 
 				}
 
-				var freq = new Array( HUF_ENCSIZE );
-				var hdec = new Array( HUF_DECSIZE );
+				const freq = new Array( HUF_ENCSIZE );
+				const hdec = new Array( HUF_DECSIZE );
 				hufClearDecTable( hdec );
-				var ni = nCompressed - ( inOffset.value - initialInOffset );
-				hufUnpackEncTable( uInt8Array, inDataView, inOffset, ni, im, iM, freq );
+				const ni = nCompressed - ( inOffset.value - initialInOffset );
+				hufUnpackEncTable( uInt8Array, inOffset, ni, im, iM, freq );
 
 				if ( nBits > 8 * ( nCompressed - ( inOffset.value - initialInOffset ) ) ) {
 
-					throw 'Something wrong with hufUncompress';
+					throw new Error( 'Something wrong with hufUncompress' );
 
 				}
 
 				hufBuildDecTable( freq, im, iM, hdec );
-				hufDecode( freq, hdec, uInt8Array, inDataView, inOffset, nBits, iM, nRaw, outBuffer, outOffset );
+				hufDecode( freq, hdec, uInt8Array, inOffset, nBits, iM, nRaw, outBuffer, outOffset );
 
 			}
 
 			function applyLut( lut, data, nData ) {
 
-				for ( var i = 0; i < nData; ++ i ) {
+				for ( let i = 0; i < nData; ++ i ) {
 
 					data[ i ] = lut[ data[ i ] ];
 
@@ -696,9 +697,9 @@
 
 			function predictor( source ) {
 
-				for ( var t = 1; t < source.length; t ++ ) {
+				for ( let t = 1; t < source.length; t ++ ) {
 
-					var d = source[ t - 1 ] + source[ t ] - 128;
+					const d = source[ t - 1 ] + source[ t ] - 128;
 					source[ t ] = d;
 
 				}
@@ -707,10 +708,10 @@
 
 			function interleaveScalar( source, out ) {
 
-				var t1 = 0;
-				var t2 = Math.floor( ( source.length + 1 ) / 2 );
-				var s = 0;
-				var stop = source.length - 1;
+				let t1 = 0;
+				let t2 = Math.floor( ( source.length + 1 ) / 2 );
+				let s = 0;
+				const stop = source.length - 1;
 
 				while ( true ) {
 
@@ -725,21 +726,21 @@
 
 			function decodeRunLength( source ) {
 
-				var size = source.byteLength;
-				var out = new Array();
-				var p = 0;
-				var reader = new DataView( source );
+				let size = source.byteLength;
+				const out = new Array();
+				let p = 0;
+				const reader = new DataView( source );
 
 				while ( size > 0 ) {
 
-					var l = reader.getInt8( p ++ );
+					const l = reader.getInt8( p ++ );
 
 					if ( l < 0 ) {
 
-						var count = - l;
+						const count = - l;
 						size -= count + 1;
 
-						for ( var i = 0; i < count; i ++ ) {
+						for ( let i = 0; i < count; i ++ ) {
 
 							out.push( reader.getUint8( p ++ ) );
 
@@ -747,11 +748,11 @@
 
 					} else {
 
-						var count = l;
+						const count = l;
 						size -= 2;
-						var value = reader.getUint8( p ++ );
+						const value = reader.getUint8( p ++ );
 
-						for ( var i = 0; i < count + 1; i ++ ) {
+						for ( let i = 0; i < count + 1; i ++ ) {
 
 							out.push( value );
 
@@ -767,23 +768,23 @@
 
 			function lossyDctDecode( cscSet, rowPtrs, channelData, acBuffer, dcBuffer, outBuffer ) {
 
-				var dataView = new DataView( outBuffer.buffer );
-				var width = channelData[ cscSet.idx[ 0 ] ].width;
-				var height = channelData[ cscSet.idx[ 0 ] ].height;
-				var numComp = 3;
-				var numFullBlocksX = Math.floor( width / 8.0 );
-				var numBlocksX = Math.ceil( width / 8.0 );
-				var numBlocksY = Math.ceil( height / 8.0 );
-				var leftoverX = width - ( numBlocksX - 1 ) * 8;
-				var leftoverY = height - ( numBlocksY - 1 ) * 8;
-				var currAcComp = {
+				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
 				};
-				var currDcComp = new Array( numComp );
-				var dctData = new Array( numComp );
-				var halfZigBlock = new Array( numComp );
-				var rowBlock = new Array( numComp );
-				var rowOffsets = new Array( numComp );
+				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 ) {
 
@@ -797,9 +798,9 @@
 
 				for ( let blocky = 0; blocky < numBlocksY; ++ blocky ) {
 
-					var maxY = 8;
+					let maxY = 8;
 					if ( blocky == numBlocksY - 1 ) maxY = leftoverY;
-					var maxX = 8;
+					let maxX = 8;
 
 					for ( let blockx = 0; blockx < numBlocksX; ++ blockx ) {
 
@@ -884,26 +885,26 @@
 				} // blocky
 
 
-				var halfRow = new Uint16Array( width );
-				var dataView = new DataView( outBuffer.buffer ); // convert channels back to float, if needed
+				const halfRow = new Uint16Array( width );
+				dataView = new DataView( outBuffer.buffer ); // convert channels back to float, if needed
 
-				for ( var comp = 0; comp < numComp; ++ comp ) {
+				for ( let comp = 0; comp < numComp; ++ comp ) {
 
 					channelData[ cscSet.idx[ comp ] ].decoded = true;
-					var type = channelData[ cscSet.idx[ comp ] ].type;
+					const type = channelData[ cscSet.idx[ comp ] ].type;
 					if ( channelData[ comp ].type != 2 ) continue;
 
-					for ( var y = 0; y < height; ++ y ) {
+					for ( let y = 0; y < height; ++ y ) {
 
 						const offset = rowOffsets[ comp ][ y ];
 
-						for ( var x = 0; x < width; ++ x ) {
+						for ( let x = 0; x < width; ++ x ) {
 
 							halfRow[ x ] = dataView.getUint16( offset + x * INT16_SIZE * type, true );
 
 						}
 
-						for ( var x = 0; x < width; ++ x ) {
+						for ( let x = 0; x < width; ++ x ) {
 
 							dataView.setFloat32( offset + x * INT16_SIZE * type, decodeFloat16( halfRow[ x ] ), true );
 
@@ -917,8 +918,8 @@
 
 			function unRleAC( currAcComp, acBuffer, halfZigBlock ) {
 
-				var acValue;
-				var dctComp = 1;
+				let acValue;
+				let dctComp = 1;
 
 				while ( dctComp < 64 ) {
 
@@ -1023,14 +1024,14 @@
 				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 );
-				var alpha = new Array( 4 );
-				var beta = new Array( 4 );
-				var theta = new Array( 4 );
-				var gamma = new Array( 4 );
+				const alpha = new Array( 4 );
+				const beta = new Array( 4 );
+				const theta = new Array( 4 );
+				const gamma = new Array( 4 );
 
-				for ( var row = 0; row < 8; ++ row ) {
+				for ( let row = 0; row < 8; ++ row ) {
 
-					var rowPtr = row * 8;
+					const rowPtr = row * 8;
 					alpha[ 0 ] = c * data[ rowPtr + 2 ];
 					alpha[ 1 ] = f * data[ rowPtr + 2 ];
 					alpha[ 2 ] = c * data[ rowPtr + 6 ];
@@ -1058,7 +1059,7 @@
 
 				}
 
-				for ( var column = 0; column < 8; ++ column ) {
+				for ( let column = 0; column < 8; ++ column ) {
 
 					alpha[ 0 ] = c * data[ 16 + column ];
 					alpha[ 1 ] = f * data[ 16 + column ];
@@ -1091,11 +1092,11 @@
 
 			function csc709Inverse( data ) {
 
-				for ( var i = 0; i < 64; ++ i ) {
+				for ( let i = 0; i < 64; ++ i ) {
 
-					var y = data[ 0 ][ i ];
-					var cb = data[ 1 ][ i ];
-					var cr = data[ 2 ][ 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;
@@ -1106,7 +1107,7 @@
 
 			function convertToHalf( src, dst, idx ) {
 
-				for ( var i = 0; i < 64; ++ i ) {
+				for ( let i = 0; i < 64; ++ i ) {
 
 					dst[ idx + i ] = THREE.DataUtils.toHalfFloat( toLinear( src[ i ] ) );
 
@@ -1136,9 +1137,9 @@
 
 			function uncompressRLE( info ) {
 
-				var compressed = info.viewer.buffer.slice( info.offset.value, info.offset.value + info.size );
-				var rawBuffer = new Uint8Array( decodeRunLength( compressed ) );
-				var tmpBuffer = new Uint8Array( rawBuffer.length );
+				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
@@ -1149,7 +1150,7 @@
 
 			function uncompressZIP( info ) {
 
-				var compressed = info.array.slice( info.offset.value, info.offset.value + info.size );
+				const compressed = info.array.slice( info.offset.value, info.offset.value + info.size );
 
 				if ( typeof fflate === 'undefined' ) {
 
@@ -1157,9 +1158,9 @@
 
 				}
 
-				var rawBuffer = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
+				const rawBuffer = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
 
-				var tmpBuffer = new Uint8Array( rawBuffer.length );
+				const tmpBuffer = new Uint8Array( rawBuffer.length );
 				predictor( rawBuffer ); // revert predictor
 
 				interleaveScalar( rawBuffer, tmpBuffer ); // interleave pixels
@@ -1170,17 +1171,17 @@
 
 			function uncompressPIZ( info ) {
 
-				var inDataView = info.viewer;
-				var inOffset = {
+				const inDataView = info.viewer;
+				const inOffset = {
 					value: info.offset.value
 				};
-				var outBuffer = new Uint16Array( info.width * info.scanlineBlockSize * ( info.channels * info.type ) );
-				var bitmap = new Uint8Array( BITMAP_SIZE ); // Setup channel info
+				const outBuffer = new Uint16Array( info.width * info.scanlineBlockSize * ( info.channels * info.type ) );
+				const bitmap = new Uint8Array( BITMAP_SIZE ); // Setup channel info
 
-				var outBufferEnd = 0;
-				var pizChannelData = new Array( info.channels );
+				let outBufferEnd = 0;
+				const pizChannelData = new Array( info.channels );
 
-				for ( var i = 0; i < info.channels; i ++ ) {
+				for ( let i = 0; i < info.channels; i ++ ) {
 
 					pizChannelData[ i ] = {};
 					pizChannelData[ i ][ 'start' ] = outBufferEnd;
@@ -1193,18 +1194,18 @@
 				} // Read range compression data
 
 
-				var minNonZero = parseUint16( inDataView, inOffset );
-				var maxNonZero = parseUint16( inDataView, inOffset );
+				const minNonZero = parseUint16( inDataView, inOffset );
+				const maxNonZero = parseUint16( inDataView, inOffset );
 
 				if ( maxNonZero >= BITMAP_SIZE ) {
 
-					throw 'Something is wrong with PIZ_COMPRESSION BITMAP_SIZE';
+					throw new Error( 'Something is wrong with PIZ_COMPRESSION BITMAP_SIZE' );
 
 				}
 
 				if ( minNonZero <= maxNonZero ) {
 
-					for ( var i = 0; i < maxNonZero - minNonZero + 1; i ++ ) {
+					for ( let i = 0; i < maxNonZero - minNonZero + 1; i ++ ) {
 
 						bitmap[ i + minNonZero ] = parseUint8( inDataView, inOffset );
 
@@ -1213,17 +1214,17 @@
 				} // Reverse LUT
 
 
-				var lut = new Uint16Array( USHORT_RANGE );
-				var maxValue = reverseLutFromBitmap( bitmap, lut );
-				var length = parseUint32( inDataView, inOffset ); // Huffman decoding
+				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 ( var i = 0; i < info.channels; ++ i ) {
+				for ( let i = 0; i < info.channels; ++ i ) {
 
-					var cd = pizChannelData[ i ];
+					const cd = pizChannelData[ i ];
 
-					for ( var j = 0; j < pizChannelData[ i ].size; ++ j ) {
+					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 );
 
@@ -1234,16 +1235,16 @@
 
 				applyLut( lut, outBuffer, outBufferEnd ); // Rearrange the pixel data into the format expected by the caller.
 
-				var tmpOffset = 0;
-				var tmpBuffer = new Uint8Array( outBuffer.buffer.byteLength );
+				let tmpOffset = 0;
+				const tmpBuffer = new Uint8Array( outBuffer.buffer.byteLength );
 
-				for ( var y = 0; y < info.lines; y ++ ) {
+				for ( let y = 0; y < info.lines; y ++ ) {
 
-					for ( var c = 0; c < info.channels; c ++ ) {
+					for ( let c = 0; c < info.channels; c ++ ) {
 
-						var cd = pizChannelData[ c ];
-						var n = cd.nx * cd.size;
-						var cp = new Uint8Array( outBuffer.buffer, cd.end * INT16_SIZE, n * INT16_SIZE );
+						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;
@@ -1258,7 +1259,7 @@
 
 			function uncompressPXR( info ) {
 
-				var compressed = info.array.slice( info.offset.value, info.offset.value + info.size );
+				const compressed = info.array.slice( info.offset.value, info.offset.value + info.size );
 
 				if ( typeof fflate === 'undefined' ) {
 
@@ -1266,7 +1267,7 @@
 
 				}
 
-				var rawBuffer = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
+				const rawBuffer = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
 
 				const sz = info.lines * info.channels * info.width;
 				const tmpBuffer = info.type == 1 ? new Uint16Array( sz ) : new Uint32Array( sz );
@@ -1327,13 +1328,13 @@
 
 			function uncompressDWA( info ) {
 
-				var inDataView = info.viewer;
-				var inOffset = {
+				const inDataView = info.viewer;
+				const inOffset = {
 					value: info.offset.value
 				};
-				var outBuffer = new Uint8Array( info.width * info.lines * ( info.channels * info.type * INT16_SIZE ) ); // Read compression header information
+				const outBuffer = new Uint8Array( info.width * info.lines * ( info.channels * info.type * INT16_SIZE ) ); // Read compression header information
 
-				var dwaHeader = {
+				const dwaHeader = {
 					version: parseInt64( inDataView, inOffset ),
 					unknownUncompressedSize: parseInt64( inDataView, inOffset ),
 					unknownCompressedSize: parseInt64( inDataView, inOffset ),
@@ -1346,19 +1347,19 @@
 					totalDcUncompressedCount: parseInt64( inDataView, inOffset ),
 					acCompression: parseInt64( inDataView, inOffset )
 				};
-				if ( dwaHeader.version < 2 ) throw 'EXRLoader.parse: ' + EXRHeader.compression + ' version ' + dwaHeader.version + ' is unsupported'; // Read channel ruleset information
+				if ( dwaHeader.version < 2 ) throw new Error( 'EXRLoader.parse: ' + EXRHeader.compression + ' version ' + dwaHeader.version + ' is unsupported' ); // Read channel ruleset information
 
-				var channelRules = new Array();
-				var ruleSize = parseUint16( inDataView, inOffset ) - INT16_SIZE;
+				const channelRules = new Array();
+				let ruleSize = parseUint16( inDataView, inOffset ) - INT16_SIZE;
 
 				while ( ruleSize > 0 ) {
 
-					var name = parseNullTerminatedString( inDataView.buffer, inOffset );
-					var value = parseUint8( inDataView, inOffset );
-					var compression = value >> 2 & 3;
-					var csc = ( value >> 4 ) - 1;
-					var index = new Int8Array( [ csc ] )[ 0 ];
-					var type = parseUint8( inDataView, inOffset );
+					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,
@@ -1370,13 +1371,13 @@
 				} // Classify channels
 
 
-				var channels = EXRHeader.channels;
-				var channelData = new Array( info.channels );
+				const channels = EXRHeader.channels;
+				const channelData = new Array( info.channels );
 
-				for ( var i = 0; i < info.channels; ++ i ) {
+				for ( let i = 0; i < info.channels; ++ i ) {
 
-					var cd = channelData[ i ] = {};
-					var channel = channels[ i ];
+					const cd = channelData[ i ] = {};
+					const channel = channels[ i ];
 					cd.name = channel.name;
 					cd.compression = UNKNOWN;
 					cd.decoded = false;
@@ -1387,17 +1388,17 @@
 
 				}
 
-				var cscSet = {
+				const cscSet = {
 					idx: new Array( 3 )
 				};
 
-				for ( var offset = 0; offset < info.channels; ++ offset ) {
+				for ( let offset = 0; offset < info.channels; ++ offset ) {
 
-					var cd = channelData[ offset ];
+					const cd = channelData[ offset ];
 
-					for ( var i = 0; i < channelRules.length; ++ i ) {
+					for ( let i = 0; i < channelRules.length; ++ i ) {
 
-						var rule = channelRules[ i ];
+						const rule = channelRules[ i ];
 
 						if ( cd.name == rule.name ) {
 
@@ -1415,23 +1416,24 @@
 
 					}
 
-				} // Read DCT - AC component data
+				}
 
+				let acBuffer, dcBuffer, rleBuffer; // Read DCT - AC component data
 
 				if ( dwaHeader.acCompressedSize > 0 ) {
 
 					switch ( dwaHeader.acCompression ) {
 
 						case STATIC_HUFFMAN:
-							var acBuffer = new Uint16Array( dwaHeader.totalAcUncompressedCount );
+							acBuffer = new Uint16Array( dwaHeader.totalAcUncompressedCount );
 							hufUncompress( info.array, inDataView, inOffset, dwaHeader.acCompressedSize, acBuffer, dwaHeader.totalAcUncompressedCount );
 							break;
 
 						case DEFLATE:
-							var compressed = info.array.slice( inOffset.value, inOffset.value + dwaHeader.totalAcUncompressedCount );
-							var data = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
+							const compressed = info.array.slice( inOffset.value, inOffset.value + dwaHeader.totalAcUncompressedCount );
+							const data = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
 
-							var acBuffer = new Uint16Array( data.buffer );
+							acBuffer = new Uint16Array( data.buffer );
 							inOffset.value += dwaHeader.totalAcUncompressedCount;
 							break;
 
@@ -1442,12 +1444,12 @@
 
 				if ( dwaHeader.dcCompressedSize > 0 ) {
 
-					var zlibInfo = {
+					const zlibInfo = {
 						array: info.array,
 						offset: inOffset,
 						size: dwaHeader.dcCompressedSize
 					};
-					var dcBuffer = new Uint16Array( uncompressZIP( zlibInfo ).buffer );
+					dcBuffer = new Uint16Array( uncompressZIP( zlibInfo ).buffer );
 					inOffset.value += dwaHeader.dcCompressedSize;
 
 				} // Read RLE compressed data
@@ -1455,27 +1457,27 @@
 
 				if ( dwaHeader.rleRawSize > 0 ) {
 
-					var compressed = info.array.slice( inOffset.value, inOffset.value + dwaHeader.rleCompressedSize );
-					var data = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
+					const compressed = info.array.slice( inOffset.value, inOffset.value + dwaHeader.rleCompressedSize );
+					const data = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
 
-					var rleBuffer = decodeRunLength( data.buffer );
+					rleBuffer = decodeRunLength( data.buffer );
 					inOffset.value += dwaHeader.rleCompressedSize;
 
 				} // Prepare outbuffer data offset
 
 
-				var outBufferEnd = 0;
-				var rowOffsets = new Array( channelData.length );
+				let outBufferEnd = 0;
+				const rowOffsets = new Array( channelData.length );
 
-				for ( var i = 0; i < rowOffsets.length; ++ i ) {
+				for ( let i = 0; i < rowOffsets.length; ++ i ) {
 
 					rowOffsets[ i ] = new Array();
 
 				}
 
-				for ( var y = 0; y < info.lines; ++ y ) {
+				for ( let y = 0; y < info.lines; ++ y ) {
 
-					for ( var chan = 0; chan < channelData.length; ++ chan ) {
+					for ( let chan = 0; chan < channelData.length; ++ chan ) {
 
 						rowOffsets[ chan ].push( outBufferEnd );
 						outBufferEnd += channelData[ chan ].width * info.type * INT16_SIZE;
@@ -1487,24 +1489,24 @@
 
 				lossyDctDecode( cscSet, rowOffsets, channelData, acBuffer, dcBuffer, outBuffer ); // Decode other channels
 
-				for ( var i = 0; i < channelData.length; ++ i ) {
+				for ( let i = 0; i < channelData.length; ++ i ) {
 
-					var cd = channelData[ i ];
+					const cd = channelData[ i ];
 					if ( cd.decoded ) continue;
 
 					switch ( cd.compression ) {
 
 						case RLE:
-							var row = 0;
-							var rleOffset = 0;
+							let row = 0;
+							let rleOffset = 0;
 
-							for ( var y = 0; y < info.lines; ++ y ) {
+							for ( let y = 0; y < info.lines; ++ y ) {
 
-								var rowOffsetBytes = rowOffsets[ i ][ row ];
+								let rowOffsetBytes = rowOffsets[ i ][ row ];
 
-								for ( var x = 0; x < cd.width; ++ x ) {
+								for ( let x = 0; x < cd.width; ++ x ) {
 
-									for ( var byte = 0; byte < INT16_SIZE * cd.type; ++ byte ) {
+									for ( let byte = 0; byte < INT16_SIZE * cd.type; ++ byte ) {
 
 										outBuffer[ rowOffsetBytes ++ ] = rleBuffer[ rleOffset + byte * cd.width * cd.height ];
 
@@ -1523,7 +1525,7 @@
 						case LOSSY_DCT: // skip
 
 						default:
-							throw 'EXRLoader.parse: unsupported channel compression';
+							throw new Error( 'EXRLoader.parse: unsupported channel compression' );
 
 					}
 
@@ -1535,8 +1537,8 @@
 
 			function parseNullTerminatedString( buffer, offset ) {
 
-				var uintBuffer = new Uint8Array( buffer );
-				var endOffset = 0;
+				const uintBuffer = new Uint8Array( buffer );
+				let endOffset = 0;
 
 				while ( uintBuffer[ offset.value + endOffset ] != 0 ) {
 
@@ -1544,7 +1546,7 @@
 
 				}
 
-				var stringValue = new TextDecoder().decode( uintBuffer.slice( offset.value, offset.value + endOffset ) );
+				const stringValue = new TextDecoder().decode( uintBuffer.slice( offset.value, offset.value + endOffset ) );
 				offset.value = offset.value + endOffset + 1;
 				return stringValue;
 
@@ -1552,7 +1554,7 @@
 
 			function parseFixedLengthString( buffer, offset, size ) {
 
-				var stringValue = new TextDecoder().decode( new Uint8Array( buffer ).slice( offset.value, offset.value + size ) );
+				const stringValue = new TextDecoder().decode( new Uint8Array( buffer ).slice( offset.value, offset.value + size ) );
 				offset.value = offset.value + size;
 				return stringValue;
 
@@ -1560,23 +1562,23 @@
 
 			function parseRational( dataView, offset ) {
 
-				var x = parseInt32( dataView, offset );
-				var y = parseUint32( dataView, offset );
+				const x = parseInt32( dataView, offset );
+				const y = parseUint32( dataView, offset );
 				return [ x, y ];
 
 			}
 
 			function parseTimecode( dataView, offset ) {
 
-				var x = parseUint32( dataView, offset );
-				var y = parseUint32( dataView, offset );
+				const x = parseUint32( dataView, offset );
+				const y = parseUint32( dataView, offset );
 				return [ x, y ];
 
 			}
 
 			function parseInt32( dataView, offset ) {
 
-				var Int32 = dataView.getInt32( offset.value, true );
+				const Int32 = dataView.getInt32( offset.value, true );
 				offset.value = offset.value + INT32_SIZE;
 				return Int32;
 
@@ -1584,7 +1586,7 @@
 
 			function parseUint32( dataView, offset ) {
 
-				var Uint32 = dataView.getUint32( offset.value, true );
+				const Uint32 = dataView.getUint32( offset.value, true );
 				offset.value = offset.value + INT32_SIZE;
 				return Uint32;
 
@@ -1592,7 +1594,7 @@
 
 			function parseUint8Array( uInt8Array, offset ) {
 
-				var Uint8 = uInt8Array[ offset.value ];
+				const Uint8 = uInt8Array[ offset.value ];
 				offset.value = offset.value + INT8_SIZE;
 				return Uint8;
 
@@ -1600,23 +1602,34 @@
 
 			function parseUint8( dataView, offset ) {
 
-				var Uint8 = dataView.getUint8( offset.value );
+				const Uint8 = dataView.getUint8( offset.value );
 				offset.value = offset.value + INT8_SIZE;
 				return Uint8;
 
 			}
 
-			function parseInt64( dataView, offset ) {
+			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 );
+
+				}
 
-				var int = Number( dataView.getBigInt64( offset.value, true ) );
 				offset.value += ULONG_SIZE;
 				return int;
 
-			}
+			};
 
 			function parseFloat32( dataView, offset ) {
 
-				var float = dataView.getFloat32( offset.value, true );
+				const float = dataView.getFloat32( offset.value, true );
 				offset.value += FLOAT32_SIZE;
 				return float;
 
@@ -1631,7 +1644,7 @@
 
 			function decodeFloat16( binary ) {
 
-				var exponent = ( binary & 0x7C00 ) >> 10,
+				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 ) );
 
@@ -1639,7 +1652,7 @@
 
 			function parseUint16( dataView, offset ) {
 
-				var Uint16 = dataView.getUint16( offset.value, true );
+				const Uint16 = dataView.getUint16( offset.value, true );
 				offset.value += INT16_SIZE;
 				return Uint16;
 
@@ -1653,18 +1666,18 @@
 
 			function parseChlist( dataView, buffer, offset, size ) {
 
-				var startOffset = offset.value;
-				var channels = [];
+				const startOffset = offset.value;
+				const channels = [];
 
 				while ( offset.value < startOffset + size - 1 ) {
 
-					var name = parseNullTerminatedString( buffer, offset );
-					var pixelType = parseInt32( dataView, offset );
-					var pLinear = parseUint8( dataView, offset );
+					const name = parseNullTerminatedString( buffer, offset );
+					const pixelType = parseInt32( dataView, offset );
+					const pLinear = parseUint8( dataView, offset );
 					offset.value += 3; // reserved, three chars
 
-					var xSampling = parseInt32( dataView, offset );
-					var ySampling = parseInt32( dataView, offset );
+					const xSampling = parseInt32( dataView, offset );
+					const ySampling = parseInt32( dataView, offset );
 					channels.push( {
 						name: name,
 						pixelType: pixelType,
@@ -1682,14 +1695,14 @@
 
 			function parseChromaticities( dataView, offset ) {
 
-				var redX = parseFloat32( dataView, offset );
-				var redY = parseFloat32( dataView, offset );
-				var greenX = parseFloat32( dataView, offset );
-				var greenY = parseFloat32( dataView, offset );
-				var blueX = parseFloat32( dataView, offset );
-				var blueY = parseFloat32( dataView, offset );
-				var whiteX = parseFloat32( dataView, offset );
-				var whiteY = parseFloat32( dataView, offset );
+				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,
@@ -1705,18 +1718,18 @@
 
 			function parseCompression( dataView, offset ) {
 
-				var compressionCodes = [ 'NO_COMPRESSION', 'RLE_COMPRESSION', 'ZIPS_COMPRESSION', 'ZIP_COMPRESSION', 'PIZ_COMPRESSION', 'PXR24_COMPRESSION', 'B44_COMPRESSION', 'B44A_COMPRESSION', 'DWAA_COMPRESSION', 'DWAB_COMPRESSION' ];
-				var compression = parseUint8( dataView, offset );
+				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 ) {
 
-				var xMin = parseUint32( dataView, offset );
-				var yMin = parseUint32( dataView, offset );
-				var xMax = parseUint32( dataView, offset );
-				var yMax = parseUint32( dataView, offset );
+				const xMin = parseUint32( dataView, offset );
+				const yMin = parseUint32( dataView, offset );
+				const xMax = parseUint32( dataView, offset );
+				const yMax = parseUint32( dataView, offset );
 				return {
 					xMin: xMin,
 					yMin: yMin,
@@ -1728,25 +1741,25 @@
 
 			function parseLineOrder( dataView, offset ) {
 
-				var lineOrders = [ 'INCREASING_Y' ];
-				var lineOrder = parseUint8( dataView, offset );
+				const lineOrders = [ 'INCREASING_Y' ];
+				const lineOrder = parseUint8( dataView, offset );
 				return lineOrders[ lineOrder ];
 
 			}
 
 			function parseV2f( dataView, offset ) {
 
-				var x = parseFloat32( dataView, offset );
-				var y = parseFloat32( dataView, offset );
+				const x = parseFloat32( dataView, offset );
+				const y = parseFloat32( dataView, offset );
 				return [ x, y ];
 
 			}
 
 			function parseV3f( dataView, offset ) {
 
-				var x = parseFloat32( dataView, offset );
-				var y = parseFloat32( dataView, offset );
-				var z = parseFloat32( dataView, offset );
+				const x = parseFloat32( dataView, offset );
+				const y = parseFloat32( dataView, offset );
+				const z = parseFloat32( dataView, offset );
 				return [ x, y, z ];
 
 			}
@@ -1818,25 +1831,31 @@
 			function parseHeader( dataView, buffer, offset ) {
 
 				const EXRHeader = {};
-				if ( dataView.getUint32( 0, true ) != 20000630 ) // magic
-					throw 'THREE.EXRLoader: provided file doesn\'t appear to be in OpenEXR format.';
-				EXRHeader.version = dataView.getUint8( 4, true );
-				const spec = dataView.getUint8( 5, true ); // fullMask
+
+				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 & 1 ),
-					longName: !! ( spec & 2 ),
-					deepFormat: !! ( spec & 4 ),
-					multiPart: !! ( spec & 8 )
+					singleTile: !! ( spec & 2 ),
+					longName: !! ( spec & 4 ),
+					deepFormat: !! ( spec & 8 ),
+					multiPart: !! ( spec & 16 )
 				}; // start of header
 
 				offset.value = 8; // start at 8 - after pre-amble
 
-				var keepReading = true;
+				let keepReading = true;
 
 				while ( keepReading ) {
 
-					var attributeName = parseNullTerminatedString( buffer, offset );
+					const attributeName = parseNullTerminatedString( buffer, offset );
 
 					if ( attributeName == 0 ) {
 
@@ -1844,9 +1863,9 @@
 
 					} else {
 
-						var attributeType = parseNullTerminatedString( buffer, offset );
-						var attributeSize = parseUint32( dataView, offset );
-						var attributeValue = parseValue( dataView, buffer, offset, attributeType, attributeSize );
+						const attributeType = parseNullTerminatedString( buffer, offset );
+						const attributeSize = parseUint32( dataView, offset );
+						const attributeValue = parseValue( dataView, buffer, offset, attributeType, attributeSize );
 
 						if ( attributeValue === undefined ) {
 
@@ -1862,10 +1881,11 @@
 
 				}
 
-				if ( spec != 0 ) {
+				if ( ( spec & ~ 0x04 ) != 0 ) {
 
+					// unsupported tiled, deep-image, multi-part
 					console.error( 'EXRHeader:', EXRHeader );
-					throw 'THREE.EXRLoader: provided file is currently unsupported.';
+					throw new Error( 'THREE.EXRLoader: provided file is currently unsupported.' );
 
 				}
 
@@ -1936,7 +1956,7 @@
 						break;
 
 					default:
-						throw 'EXRLoader.parse: ' + EXRHeader.compression + ' is unsupported';
+						throw new Error( 'EXRLoader.parse: ' + EXRHeader.compression + ' is unsupported' );
 
 				}
 
@@ -1977,13 +1997,13 @@
 
 				} else {
 
-					throw 'EXRLoader.parse: unsupported pixelType ' + EXRDecoder.type + ' for ' + EXRHeader.compression + '.';
+					throw new Error( 'EXRLoader.parse: unsupported pixelType ' + EXRDecoder.type + ' for ' + EXRHeader.compression + '.' );
 
 				}
 
 				EXRDecoder.blockCount = ( EXRHeader.dataWindow.yMax + 1 ) / EXRDecoder.scanlineBlockSize;
 
-				for ( var i = 0; i < EXRDecoder.blockCount; i ++ ) parseInt64( dataView, offset ); // scanlineOffset
+				for ( let i = 0; i < EXRDecoder.blockCount; i ++ ) parseInt64( dataView, offset ); // scanlineOffset
 				// we should be passed the scanline offset table, ready to start reading pixel data.
 				// RGB images will be converted to RGBA format, preventing software emulation in select devices.