ag-psd 30.1.1 → 30.2.0

package/dist/jpeg.js

@@ -17,7 +17,7 @@
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeJpeg = void 0;
-var dctZigZag = new Int32Array([
+const dctZigZag = new Int32Array([
     0,
     1, 8,
     16, 9, 2,
@@ -34,34 +34,34 @@ var dctZigZag = new Int32Array([
     55, 62,
     63
 ]);
-var dctCos1 = 4017; // cos(pi/16)
-var dctSin1 = 799; // sin(pi/16)
-var dctCos3 = 3406; // cos(3*pi/16)
-var dctSin3 = 2276; // sin(3*pi/16)
-var dctCos6 = 1567; // cos(6*pi/16)
-var dctSin6 = 3784; // sin(6*pi/16)
-var dctSqrt2 = 5793; // sqrt(2)
-var dctSqrt1d2 = 2896; // sqrt(2) / 2
-var maxResolutionInMP = 100; // Don't decode more than 100 megapixels
-var maxMemoryUsageBytes = 64 * 1024 * 1024; // Don't decode if memory footprint is more than 64MB
-var totalBytesAllocated = 0; // avoid unexpected OOMs from untrusted content.
+const dctCos1 = 4017; // cos(pi/16)
+const dctSin1 = 799; // sin(pi/16)
+const dctCos3 = 3406; // cos(3*pi/16)
+const dctSin3 = 2276; // sin(3*pi/16)
+const dctCos6 = 1567; // cos(6*pi/16)
+const dctSin6 = 3784; // sin(6*pi/16)
+const dctSqrt2 = 5793; // sqrt(2)
+const dctSqrt1d2 = 2896; // sqrt(2) / 2
+const maxResolutionInMP = 100; // Don't decode more than 100 megapixels
+const maxMemoryUsageBytes = 64 * 1024 * 1024; // Don't decode if memory footprint is more than 64MB
+let totalBytesAllocated = 0; // avoid unexpected OOMs from untrusted content.
 function requestMemoryAllocation(increaseAmount) {
-    var totalMemoryImpactBytes = totalBytesAllocated + increaseAmount;
+    const totalMemoryImpactBytes = totalBytesAllocated + increaseAmount;
     if (totalMemoryImpactBytes > maxMemoryUsageBytes) {
-        var exceededAmount = Math.ceil((totalMemoryImpactBytes - maxMemoryUsageBytes) / 1024 / 1024);
-        throw new Error("Max memory limit exceeded by at least ".concat(exceededAmount, "MB"));
+        const exceededAmount = Math.ceil((totalMemoryImpactBytes - maxMemoryUsageBytes) / 1024 / 1024);
+        throw new Error(`Max memory limit exceeded by at least ${exceededAmount}MB`);
     }
     totalBytesAllocated = totalMemoryImpactBytes;
 }
 function buildHuffmanTable(codeLengths, values) {
-    var length = 16;
+    let length = 16;
     while (length > 0 && !codeLengths[length - 1])
         length--;
-    var code = [{ children: [], index: 0 }];
-    var k = 0;
-    var p = code[0];
-    for (var i = 0; i < length; i++) {
-        for (var j = 0; j < codeLengths[i]; j++) {
+    const code = [{ children: [], index: 0 }];
+    let k = 0;
+    let p = code[0];
+    for (let i = 0; i < length; i++) {
+        for (let j = 0; j < codeLengths[i]; j++) {
             p = code.pop();
             p.children[p.index] = values[k];
             while (p.index > 0) {
@@ -72,7 +72,7 @@ function buildHuffmanTable(codeLengths, values) {
             p.index++;
             code.push(p);
             while (code.length <= i) {
-                var q = { children: [], index: 0 };
+                const q = { children: [], index: 0 };
                 code.push(q);
                 p.children[p.index] = q.children;
                 p = q;
@@ -81,7 +81,7 @@ function buildHuffmanTable(codeLengths, values) {
         }
         if (i + 1 < length) {
             // p here points to last code
-            var q = { children: [], index: 0 };
+            const q = { children: [], index: 0 };
             code.push(q);
             p.children[p.index] = q.children;
             p = q;
@@ -90,11 +90,11 @@ function buildHuffmanTable(codeLengths, values) {
     return code[0].children;
 }
 function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive) {
-    var mcusPerLine = frame.mcusPerLine;
-    var progressive = frame.progressive;
-    var startOffset = offset;
-    var bitsData = 0;
-    var bitsCount = 0;
+    const mcusPerLine = frame.mcusPerLine;
+    const progressive = frame.progressive;
+    const startOffset = offset;
+    let bitsData = 0;
+    let bitsCount = 0;
     function readBit() {
         if (bitsCount > 0) {
             bitsCount--;
@@ -102,16 +102,16 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
         }
         bitsData = data[offset++];
         if (bitsData == 0xFF) {
-            var nextByte = data[offset++];
+            const nextByte = data[offset++];
             if (nextByte)
-                throw new Error("unexpected marker: ".concat(((bitsData << 8) | nextByte).toString(16)));
+                throw new Error(`unexpected marker: ${((bitsData << 8) | nextByte).toString(16)}`);
             // unstuff 0
         }
         bitsCount = 7;
         return bitsData >>> 7;
     }
     function decodeHuffman(tree) {
-        var node = tree;
+        let node = tree;
         while (true) {
             node = node[readBit()];
             if (typeof node === 'number')
@@ -121,7 +121,7 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
         }
     }
     function receive(length) {
-        var n = 0;
+        let n = 0;
         while (length > 0) {
             n = (n << 1) | readBit();
             length--;
@@ -129,20 +129,20 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
         return n;
     }
     function receiveAndExtend(length) {
-        var n = receive(length);
+        let n = receive(length);
         if (n >= 1 << (length - 1))
             return n;
         return n + (-1 << length) + 1;
     }
     function decodeBaseline(component, zz) {
-        var t = decodeHuffman(component.huffmanTableDC);
-        var diff = t === 0 ? 0 : receiveAndExtend(t);
+        const t = decodeHuffman(component.huffmanTableDC);
+        const diff = t === 0 ? 0 : receiveAndExtend(t);
         zz[0] = (component.pred += diff);
-        var k = 1;
+        let k = 1;
         while (k < 64) {
-            var rs = decodeHuffman(component.huffmanTableAC);
-            var s = rs & 15;
-            var r = rs >> 4;
+            const rs = decodeHuffman(component.huffmanTableAC);
+            const s = rs & 15;
+            const r = rs >> 4;
             if (s === 0) {
                 if (r < 15)
                     break;
@@ -150,30 +150,30 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
                 continue;
             }
             k += r;
-            var z = dctZigZag[k];
+            const z = dctZigZag[k];
             zz[z] = receiveAndExtend(s);
             k++;
         }
     }
     function decodeDCFirst(component, zz) {
-        var t = decodeHuffman(component.huffmanTableDC);
-        var diff = t === 0 ? 0 : (receiveAndExtend(t) << successive);
+        const t = decodeHuffman(component.huffmanTableDC);
+        const diff = t === 0 ? 0 : (receiveAndExtend(t) << successive);
         zz[0] = (component.pred += diff);
     }
     function decodeDCSuccessive(_component, zz) {
         zz[0] |= readBit() << successive;
     }
-    var eobrun = 0;
+    let eobrun = 0;
     function decodeACFirst(component, zz) {
         if (eobrun > 0) {
             eobrun--;
             return;
         }
-        var k = spectralStart, e = spectralEnd;
+        let k = spectralStart, e = spectralEnd;
         while (k <= e) {
-            var rs = decodeHuffman(component.huffmanTableAC);
-            var s = rs & 15;
-            var r = rs >> 4;
+            const rs = decodeHuffman(component.huffmanTableAC);
+            const s = rs & 15;
+            const r = rs >> 4;
             if (s === 0) {
                 if (r < 15) {
                     eobrun = receive(r) + (1 << r) - 1;
@@ -183,24 +183,24 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
                 continue;
             }
             k += r;
-            var z = dctZigZag[k];
+            const z = dctZigZag[k];
             zz[z] = receiveAndExtend(s) * (1 << successive);
             k++;
         }
     }
-    var successiveACState = 0;
-    var successiveACNextValue = 0;
+    let successiveACState = 0;
+    let successiveACNextValue = 0;
     function decodeACSuccessive(component, zz) {
-        var k = spectralStart;
-        var e = spectralEnd;
-        var r = 0;
+        let k = spectralStart;
+        let e = spectralEnd;
+        let r = 0;
         while (k <= e) {
-            var z = dctZigZag[k];
-            var direction = zz[z] < 0 ? -1 : 1;
+            const z = dctZigZag[k];
+            const direction = zz[z] < 0 ? -1 : 1;
             switch (successiveACState) {
                 case 0: // initial state
-                    var rs = decodeHuffman(component.huffmanTableAC);
-                    var s = rs & 15;
+                    const rs = decodeHuffman(component.huffmanTableAC);
+                    const s = rs & 15;
                     r = rs >> 4; // this was new variable in old code
                     if (s === 0) {
                         if (r < 15) {
@@ -254,26 +254,26 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
         }
     }
     function decodeMcu(component, decode, mcu, row, col) {
-        var mcuRow = (mcu / mcusPerLine) | 0;
-        var mcuCol = mcu % mcusPerLine;
-        var blockRow = mcuRow * component.v + row;
-        var blockCol = mcuCol * component.h + col;
+        const mcuRow = (mcu / mcusPerLine) | 0;
+        const mcuCol = mcu % mcusPerLine;
+        const blockRow = mcuRow * component.v + row;
+        const blockCol = mcuCol * component.h + col;
         // If the block is missing, just skip it.
         if (component.blocks[blockRow] === undefined)
             return;
         decode(component, component.blocks[blockRow][blockCol]);
     }
     function decodeBlock(component, decode, mcu) {
-        var blockRow = (mcu / component.blocksPerLine) | 0;
-        var blockCol = mcu % component.blocksPerLine;
+        const blockRow = (mcu / component.blocksPerLine) | 0;
+        const blockCol = mcu % component.blocksPerLine;
         // If the block is missing, just skip it.
         if (component.blocks[blockRow] === undefined)
             return;
         decode(component, component.blocks[blockRow][blockCol]);
     }
-    var componentsLength = components.length;
-    var component;
-    var decodeFn;
+    const componentsLength = components.length;
+    let component;
+    let decodeFn;
     if (progressive) {
         if (spectralStart === 0) {
             decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
@@ -285,8 +285,8 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
     else {
         decodeFn = decodeBaseline;
     }
-    var mcu = 0;
-    var mcuExpected;
+    let mcu = 0;
+    let mcuExpected;
     if (componentsLength == 1) {
         mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
     }
@@ -295,29 +295,29 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
     }
     if (!resetInterval)
         resetInterval = mcuExpected;
-    var h;
-    var v;
-    var marker;
+    let h;
+    let v;
+    let marker;
     while (mcu < mcuExpected) {
         // reset interval stuff
-        for (var i = 0; i < componentsLength; i++)
+        for (let i = 0; i < componentsLength; i++)
             components[i].pred = 0;
         eobrun = 0;
         if (componentsLength == 1) {
             component = components[0];
-            for (var n = 0; n < resetInterval; n++) {
+            for (let n = 0; n < resetInterval; n++) {
                 decodeBlock(component, decodeFn, mcu);
                 mcu++;
             }
         }
         else {
-            for (var n = 0; n < resetInterval; n++) {
-                for (var i = 0; i < componentsLength; i++) {
+            for (let n = 0; n < resetInterval; n++) {
+                for (let i = 0; i < componentsLength; i++) {
                     component = components[i];
                     h = component.h;
                     v = component.v;
-                    for (var j = 0; j < v; j++) {
-                        for (var k = 0; k < h; k++) {
+                    for (let j = 0; j < v; j++) {
+                        for (let k = 0; k < h; k++) {
                             decodeMcu(component, decodeFn, mcu, j, k);
                         }
                     }
@@ -354,54 +354,54 @@ function decodeScan(data, offset, frame, components, resetInterval, spectralStar
     return offset - startOffset;
 }
 function buildComponentData(component) {
-    var lines = [];
-    var blocksPerLine = component.blocksPerLine;
-    var blocksPerColumn = component.blocksPerColumn;
-    var samplesPerLine = blocksPerLine << 3;
+    const lines = [];
+    const blocksPerLine = component.blocksPerLine;
+    const blocksPerColumn = component.blocksPerColumn;
+    const samplesPerLine = blocksPerLine << 3;
     // Only 1 used per invocation of this function and garbage collected after invocation, so no need to account for its memory footprint.
-    var R = new Int32Array(64);
-    var r = new Uint8Array(64);
+    const R = new Int32Array(64);
+    const r = new Uint8Array(64);
     // A port of poppler's IDCT method which in turn is taken from:
     //   Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz,
     //   "Practical Fast 1-D DCT Algorithms with 11 Multiplications",
     //   IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,
     //   988-991.
     function quantizeAndInverse(zz, dataOut, dataIn) {
-        var qt = component.quantizationTable;
-        var p = dataIn;
+        const qt = component.quantizationTable;
+        const p = dataIn;
         // dequant
-        for (var i = 0; i < 64; i++) {
+        for (let i = 0; i < 64; i++) {
             p[i] = zz[i] * qt[i];
         }
         // inverse DCT on rows
-        for (var i = 0; i < 8; ++i) {
-            var row = 8 * i;
+        for (let i = 0; i < 8; ++i) {
+            const row = 8 * i;
             // check for all-zero AC coefficients
             if (p[1 + row] == 0 && p[2 + row] == 0 && p[3 + row] == 0 &&
                 p[4 + row] == 0 && p[5 + row] == 0 && p[6 + row] == 0 &&
                 p[7 + row] == 0) {
-                var t_1 = (dctSqrt2 * p[0 + row] + 512) >> 10;
-                p[0 + row] = t_1;
-                p[1 + row] = t_1;
-                p[2 + row] = t_1;
-                p[3 + row] = t_1;
-                p[4 + row] = t_1;
-                p[5 + row] = t_1;
-                p[6 + row] = t_1;
-                p[7 + row] = t_1;
+                const t = (dctSqrt2 * p[0 + row] + 512) >> 10;
+                p[0 + row] = t;
+                p[1 + row] = t;
+                p[2 + row] = t;
+                p[3 + row] = t;
+                p[4 + row] = t;
+                p[5 + row] = t;
+                p[6 + row] = t;
+                p[7 + row] = t;
                 continue;
             }
             // stage 4
-            var v0 = (dctSqrt2 * p[0 + row] + 128) >> 8;
-            var v1 = (dctSqrt2 * p[4 + row] + 128) >> 8;
-            var v2 = p[2 + row];
-            var v3 = p[6 + row];
-            var v4 = (dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128) >> 8;
-            var v7 = (dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128) >> 8;
-            var v5 = p[3 + row] << 4;
-            var v6 = p[5 + row] << 4;
+            let v0 = (dctSqrt2 * p[0 + row] + 128) >> 8;
+            let v1 = (dctSqrt2 * p[4 + row] + 128) >> 8;
+            let v2 = p[2 + row];
+            let v3 = p[6 + row];
+            let v4 = (dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128) >> 8;
+            let v7 = (dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128) >> 8;
+            let v5 = p[3 + row] << 4;
+            let v6 = p[5 + row] << 4;
             // stage 3
-            var t = (v0 - v1 + 1) >> 1;
+            let t = (v0 - v1 + 1) >> 1;
             v0 = (v0 + v1 + 1) >> 1;
             v1 = t;
             t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8;
@@ -437,34 +437,34 @@ function buildComponentData(component) {
             p[4 + row] = v3 - v4;
         }
         // inverse DCT on columns
-        for (var i = 0; i < 8; ++i) {
-            var col = i;
+        for (let i = 0; i < 8; ++i) {
+            const col = i;
             // check for all-zero AC coefficients
             if (p[1 * 8 + col] == 0 && p[2 * 8 + col] == 0 && p[3 * 8 + col] == 0 &&
                 p[4 * 8 + col] == 0 && p[5 * 8 + col] == 0 && p[6 * 8 + col] == 0 &&
                 p[7 * 8 + col] == 0) {
-                var t_2 = (dctSqrt2 * dataIn[i + 0] + 8192) >> 14;
-                p[0 * 8 + col] = t_2;
-                p[1 * 8 + col] = t_2;
-                p[2 * 8 + col] = t_2;
-                p[3 * 8 + col] = t_2;
-                p[4 * 8 + col] = t_2;
-                p[5 * 8 + col] = t_2;
-                p[6 * 8 + col] = t_2;
-                p[7 * 8 + col] = t_2;
+                const t = (dctSqrt2 * dataIn[i + 0] + 8192) >> 14;
+                p[0 * 8 + col] = t;
+                p[1 * 8 + col] = t;
+                p[2 * 8 + col] = t;
+                p[3 * 8 + col] = t;
+                p[4 * 8 + col] = t;
+                p[5 * 8 + col] = t;
+                p[6 * 8 + col] = t;
+                p[7 * 8 + col] = t;
                 continue;
             }
             // stage 4
-            var v0 = (dctSqrt2 * p[0 * 8 + col] + 2048) >> 12;
-            var v1 = (dctSqrt2 * p[4 * 8 + col] + 2048) >> 12;
-            var v2 = p[2 * 8 + col];
-            var v3 = p[6 * 8 + col];
-            var v4 = (dctSqrt1d2 * (p[1 * 8 + col] - p[7 * 8 + col]) + 2048) >> 12;
-            var v7 = (dctSqrt1d2 * (p[1 * 8 + col] + p[7 * 8 + col]) + 2048) >> 12;
-            var v5 = p[3 * 8 + col];
-            var v6 = p[5 * 8 + col];
+            let v0 = (dctSqrt2 * p[0 * 8 + col] + 2048) >> 12;
+            let v1 = (dctSqrt2 * p[4 * 8 + col] + 2048) >> 12;
+            let v2 = p[2 * 8 + col];
+            let v3 = p[6 * 8 + col];
+            let v4 = (dctSqrt1d2 * (p[1 * 8 + col] - p[7 * 8 + col]) + 2048) >> 12;
+            let v7 = (dctSqrt1d2 * (p[1 * 8 + col] + p[7 * 8 + col]) + 2048) >> 12;
+            let v5 = p[3 * 8 + col];
+            let v6 = p[5 * 8 + col];
             // stage 3
-            var t = (v0 - v1 + 1) >> 1;
+            let t = (v0 - v1 + 1) >> 1;
             v0 = (v0 + v1 + 1) >> 1;
             v1 = t;
             t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12;
@@ -500,23 +500,23 @@ function buildComponentData(component) {
             p[4 * 8 + col] = v3 - v4;
         }
         // convert to 8-bit integers
-        for (var i = 0; i < 64; ++i) {
-            var sample = 128 + ((p[i] + 8) >> 4);
+        for (let i = 0; i < 64; ++i) {
+            const sample = 128 + ((p[i] + 8) >> 4);
             dataOut[i] = sample < 0 ? 0 : sample > 0xFF ? 0xFF : sample;
         }
     }
     requestMemoryAllocation(samplesPerLine * blocksPerColumn * 8);
-    for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
-        var scanLine = blockRow << 3;
-        for (var i = 0; i < 8; i++)
+    for (let blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
+        const scanLine = blockRow << 3;
+        for (let i = 0; i < 8; i++)
             lines.push(new Uint8Array(samplesPerLine));
-        for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
+        for (let blockCol = 0; blockCol < blocksPerLine; blockCol++) {
             quantizeAndInverse(component.blocks[blockRow][blockCol], r, R);
-            var offset = 0;
-            var sample = blockCol << 3;
-            for (var j = 0; j < 8; j++) {
-                var line = lines[scanLine + j];
-                for (var i = 0; i < 8; i++)
+            let offset = 0;
+            const sample = blockCol << 3;
+            for (let j = 0; j < 8; j++) {
+                const line = lines[scanLine + j];
+                for (let i = 0; i < 8; i++)
                     line[sample + i] = r[offset++];
             }
         }
@@ -527,7 +527,7 @@ function clampTo8bit(a) {
     return a < 0 ? 0 : a > 255 ? 255 : a;
 }
 function parse(data) {
-    var self = {
+    const self = {
         width: 0,
         height: 0,
         comments: [],
@@ -536,46 +536,46 @@ function parse(data) {
         exifBuffer: undefined,
         jfif: undefined,
     };
-    var maxResolutionInPixels = maxResolutionInMP * 1000 * 1000;
-    var offset = 0;
+    const maxResolutionInPixels = maxResolutionInMP * 1000 * 1000;
+    let offset = 0;
     function readUint16() {
-        var value = (data[offset] << 8) | data[offset + 1];
+        const value = (data[offset] << 8) | data[offset + 1];
         offset += 2;
         return value;
     }
     function readDataBlock() {
-        var length = readUint16();
-        var array = data.subarray(offset, offset + length - 2);
+        const length = readUint16();
+        const array = data.subarray(offset, offset + length - 2);
         offset += array.length;
         return array;
     }
     function prepareComponents(frame) {
-        var maxH = 0, maxV = 0;
-        for (var componentId in frame.components) {
+        let maxH = 0, maxV = 0;
+        for (let componentId in frame.components) {
             if (frame.components.hasOwnProperty(componentId)) {
-                var component = frame.components[componentId];
+                const component = frame.components[componentId];
                 if (maxH < component.h)
                     maxH = component.h;
                 if (maxV < component.v)
                     maxV = component.v;
             }
         }
-        var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH);
-        var mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV);
-        for (var componentId in frame.components) {
+        const mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH);
+        const mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV);
+        for (let componentId in frame.components) {
             if (frame.components.hasOwnProperty(componentId)) {
-                var component = frame.components[componentId];
-                var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH);
-                var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV);
-                var blocksPerLineForMcu = mcusPerLine * component.h;
-                var blocksPerColumnForMcu = mcusPerColumn * component.v;
-                var blocksToAllocate = blocksPerColumnForMcu * blocksPerLineForMcu;
-                var blocks = [];
+                const component = frame.components[componentId];
+                const blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH);
+                const blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV);
+                const blocksPerLineForMcu = mcusPerLine * component.h;
+                const blocksPerColumnForMcu = mcusPerColumn * component.v;
+                const blocksToAllocate = blocksPerColumnForMcu * blocksPerLineForMcu;
+                const blocks = [];
                 // Each block is a Int32Array of length 64 (4 x 64 = 256 bytes)
                 requestMemoryAllocation(blocksToAllocate * 256);
-                for (var i = 0; i < blocksPerColumnForMcu; i++) {
-                    var row = [];
-                    for (var j = 0; j < blocksPerLineForMcu; j++) {
+                for (let i = 0; i < blocksPerColumnForMcu; i++) {
+                    const row = [];
+                    for (let j = 0; j < blocksPerLineForMcu; j++) {
                         row.push(new Int32Array(64));
                     }
                     blocks.push(row);
@@ -590,16 +590,16 @@ function parse(data) {
         frame.mcusPerLine = mcusPerLine;
         frame.mcusPerColumn = mcusPerColumn;
     }
-    var jfif = null;
-    var adobe = null;
-    var frame = undefined;
-    var resetInterval = 0;
-    var quantizationTables = [];
-    var frames = [];
-    var huffmanTablesAC = [];
-    var huffmanTablesDC = [];
-    var fileMarker = readUint16();
-    var malformedDataOffset = -1;
+    let jfif = null;
+    let adobe = null;
+    let frame = undefined;
+    let resetInterval = 0;
+    let quantizationTables = [];
+    let frames = [];
+    let huffmanTablesAC = [];
+    let huffmanTablesDC = [];
+    let fileMarker = readUint16();
+    let malformedDataOffset = -1;
     if (fileMarker != 0xFFD8) { // SOI (Start of Image)
         throw new Error('SOI not found');
     }
@@ -624,10 +624,10 @@ function parse(data) {
             case 0xFFEE: // APP14
             case 0xFFEF: // APP15
             case 0xFFFE: { // COM (Comment)
-                var appData = readDataBlock();
+                const appData = readDataBlock();
                 if (fileMarker === 0xFFFE) {
-                    var comment = '';
-                    for (var ii = 0; ii < appData.byteLength; ii++) {
+                    let comment = '';
+                    for (let ii = 0; ii < appData.byteLength; ii++) {
                         comment += String.fromCharCode(appData[ii]);
                     }
                     self.comments.push(comment);
@@ -670,21 +670,21 @@ function parse(data) {
                 break;
             }
             case 0xFFDB: { // DQT (Define Quantization Tables)
-                var quantizationTablesLength = readUint16();
-                var quantizationTablesEnd = quantizationTablesLength + offset - 2;
+                const quantizationTablesLength = readUint16();
+                const quantizationTablesEnd = quantizationTablesLength + offset - 2;
                 while (offset < quantizationTablesEnd) {
-                    var quantizationTableSpec = data[offset++];
+                    const quantizationTableSpec = data[offset++];
                     requestMemoryAllocation(64 * 4);
-                    var tableData = new Int32Array(64);
+                    const tableData = new Int32Array(64);
                     if ((quantizationTableSpec >> 4) === 0) { // 8 bit values
-                        for (var j = 0; j < 64; j++) {
-                            var z = dctZigZag[j];
+                        for (let j = 0; j < 64; j++) {
+                            const z = dctZigZag[j];
                             tableData[z] = data[offset++];
                         }
                     }
                     else if ((quantizationTableSpec >> 4) === 1) { //16 bit
-                        for (var j = 0; j < 64; j++) {
-                            var z = dctZigZag[j];
+                        for (let j = 0; j < 64; j++) {
+                            const z = dctZigZag[j];
                             tableData[z] = readUint16();
                         }
                     }
@@ -711,17 +711,17 @@ function parse(data) {
                     mcusPerLine: 0,
                     mcusPerColumn: 0,
                 };
-                var pixelsInFrame = frame.scanLines * frame.samplesPerLine;
+                const pixelsInFrame = frame.scanLines * frame.samplesPerLine;
                 if (pixelsInFrame > maxResolutionInPixels) {
-                    var exceededAmount = Math.ceil((pixelsInFrame - maxResolutionInPixels) / 1e6);
-                    throw new Error("maxResolutionInMP limit exceeded by ".concat(exceededAmount, "MP"));
+                    const exceededAmount = Math.ceil((pixelsInFrame - maxResolutionInPixels) / 1e6);
+                    throw new Error(`maxResolutionInMP limit exceeded by ${exceededAmount}MP`);
                 }
-                var componentsCount = data[offset++];
-                for (var i = 0; i < componentsCount; i++) {
-                    var componentId = data[offset];
-                    var h = data[offset + 1] >> 4;
-                    var v = data[offset + 1] & 15;
-                    var qId = data[offset + 2];
+                const componentsCount = data[offset++];
+                for (let i = 0; i < componentsCount; i++) {
+                    const componentId = data[offset];
+                    const h = data[offset + 1] >> 4;
+                    const v = data[offset + 1] & 15;
+                    const qId = data[offset + 2];
                     frame.componentsOrder.push(componentId);
                     frame.components[componentId] = {
                         h: h,
@@ -739,22 +739,22 @@ function parse(data) {
                 break;
             }
             case 0xFFC4: { // DHT (Define Huffman Tables)
-                var huffmanLength = readUint16();
-                for (var i = 2; i < huffmanLength;) {
-                    var huffmanTableSpec = data[offset++];
-                    var codeLengths = new Uint8Array(16);
-                    var codeLengthSum = 0;
-                    for (var j = 0; j < 16; j++, offset++) {
+                const huffmanLength = readUint16();
+                for (let i = 2; i < huffmanLength;) {
+                    const huffmanTableSpec = data[offset++];
+                    const codeLengths = new Uint8Array(16);
+                    let codeLengthSum = 0;
+                    for (let j = 0; j < 16; j++, offset++) {
                         codeLengthSum += (codeLengths[j] = data[offset]);
                     }
                     requestMemoryAllocation(16 + codeLengthSum);
-                    var huffmanValues = new Uint8Array(codeLengthSum);
-                    for (var j = 0; j < codeLengthSum; j++, offset++) {
+                    const huffmanValues = new Uint8Array(codeLengthSum);
+                    for (let j = 0; j < codeLengthSum; j++, offset++) {
                         huffmanValues[j] = data[offset];
                     }
                     i += 17 + codeLengthSum;
-                    var index = huffmanTableSpec & 15;
-                    var table = (huffmanTableSpec >> 4) === 0 ? huffmanTablesDC : huffmanTablesAC;
+                    const index = huffmanTableSpec & 15;
+                    const table = (huffmanTableSpec >> 4) === 0 ? huffmanTablesDC : huffmanTablesAC;
                     table[index] = buildHuffmanTable(codeLengths, huffmanValues);
                 }
                 break;
@@ -769,19 +769,19 @@ function parse(data) {
                 break;
             case 0xFFDA: { // SOS (Start of Scan)
                 readUint16(); // skip data length
-                var selectorsCount = data[offset++];
-                var components = [];
-                for (var i = 0; i < selectorsCount; i++) {
-                    var component = frame.components[data[offset++]];
-                    var tableSpec = data[offset++];
+                const selectorsCount = data[offset++];
+                const components = [];
+                for (let i = 0; i < selectorsCount; i++) {
+                    const component = frame.components[data[offset++]];
+                    const tableSpec = data[offset++];
                     component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
                     component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
                     components.push(component);
                 }
-                var spectralStart = data[offset++];
-                var spectralEnd = data[offset++];
-                var successiveApproximation = data[offset++];
-                var processed = decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successiveApproximation >> 4, successiveApproximation & 15);
+                const spectralStart = data[offset++];
+                const spectralEnd = data[offset++];
+                const successiveApproximation = data[offset++];
+                const processed = decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successiveApproximation >> 4, successiveApproximation & 15);
                 offset += processed;
                 break;
             }
@@ -801,10 +801,10 @@ function parse(data) {
                     // Recover from malformed APP1 markers popular in some phone models.
                     // See https://github.com/eugeneware/jpeg-js/issues/82
                     if (malformedDataOffset !== -1) {
-                        throw new Error("first unknown JPEG marker at offset ".concat(malformedDataOffset.toString(16), ", second unknown JPEG marker ").concat(fileMarker.toString(16), " at offset ").concat((offset - 1).toString(16)));
+                        throw new Error(`first unknown JPEG marker at offset ${malformedDataOffset.toString(16)}, second unknown JPEG marker ${fileMarker.toString(16)} at offset ${(offset - 1).toString(16)}`);
                     }
                     malformedDataOffset = offset - 1;
-                    var nextOffset = readUint16();
+                    const nextOffset = readUint16();
                     if (data[offset + nextOffset - 2] === 0xFF) {
                         offset += nextOffset - 2;
                         break;
@@ -818,9 +818,9 @@ function parse(data) {
     if (frames.length != 1)
         throw new Error('only single frame JPEGs supported');
     // set each frame's components quantization table
-    for (var i = 0; i < frames.length; i++) {
-        var cp = frames[i].components;
-        for (var j in cp) { // TODO: don't use `in`
+    for (let i = 0; i < frames.length; i++) {
+        const cp = frames[i].components;
+        for (let j in cp) { // TODO: don't use `in`
             cp[j].quantizationTable = quantizationTables[cp[j].quantizationIdx];
             delete cp[j].quantizationIdx; // TODO: why ???
         }
@@ -830,8 +830,8 @@ function parse(data) {
     self.jfif = jfif;
     self.adobe = adobe;
     self.components = [];
-    for (var i = 0; i < frame.componentsOrder.length; i++) {
-        var component = frame.components[frame.componentsOrder[i]];
+    for (let i = 0; i < frame.componentsOrder.length; i++) {
+        const component = frame.components[frame.componentsOrder[i]];
         self.components.push({
             lines: buildComponentData(component),
             scaleX: component.h / frame.maxH,
@@ -841,20 +841,20 @@ function parse(data) {
     return self;
 }
 function getData(decoded) {
-    var offset = 0;
-    var colorTransform = false;
-    var width = decoded.width;
-    var height = decoded.height;
-    var dataLength = width * height * decoded.components.length;
+    let offset = 0;
+    let colorTransform = false;
+    const width = decoded.width;
+    const height = decoded.height;
+    const dataLength = width * height * decoded.components.length;
     requestMemoryAllocation(dataLength);
-    var data = new Uint8Array(dataLength);
+    const data = new Uint8Array(dataLength);
     switch (decoded.components.length) {
         case 1: {
-            var component1 = decoded.components[0];
-            for (var y = 0; y < height; y++) {
-                var component1Line = component1.lines[0 | (y * component1.scaleY)];
-                for (var x = 0; x < width; x++) {
-                    var Y = component1Line[0 | (x * component1.scaleX)];
+            const component1 = decoded.components[0];
+            for (let y = 0; y < height; y++) {
+                const component1Line = component1.lines[0 | (y * component1.scaleY)];
+                for (let x = 0; x < width; x++) {
+                    const Y = component1Line[0 | (x * component1.scaleX)];
                     data[offset++] = Y;
                 }
             }
@@ -862,15 +862,15 @@ function getData(decoded) {
         }
         case 2: {
             // PDF might compress two component data in custom colorspace
-            var component1 = decoded.components[0];
-            var component2 = decoded.components[1];
-            for (var y = 0; y < height; y++) {
-                var component1Line = component1.lines[0 | (y * component1.scaleY)];
-                var component2Line = component2.lines[0 | (y * component2.scaleY)];
-                for (var x = 0; x < width; x++) {
-                    var Y1 = component1Line[0 | (x * component1.scaleX)];
+            const component1 = decoded.components[0];
+            const component2 = decoded.components[1];
+            for (let y = 0; y < height; y++) {
+                const component1Line = component1.lines[0 | (y * component1.scaleY)];
+                const component2Line = component2.lines[0 | (y * component2.scaleY)];
+                for (let x = 0; x < width; x++) {
+                    const Y1 = component1Line[0 | (x * component1.scaleX)];
                     data[offset++] = Y1;
-                    var Y2 = component2Line[0 | (x * component2.scaleX)];
+                    const Y2 = component2Line[0 | (x * component2.scaleX)];
                     data[offset++] = Y2;
                 }
             }
@@ -882,15 +882,15 @@ function getData(decoded) {
             // The adobe transform marker overrides any previous setting
             if (decoded.adobe && decoded.adobe.transformCode)
                 colorTransform = true;
-            var component1 = decoded.components[0];
-            var component2 = decoded.components[1];
-            var component3 = decoded.components[2];
-            for (var y = 0; y < height; y++) {
-                var component1Line = component1.lines[0 | (y * component1.scaleY)];
-                var component2Line = component2.lines[0 | (y * component2.scaleY)];
-                var component3Line = component3.lines[0 | (y * component3.scaleY)];
-                for (var x = 0; x < width; x++) {
-                    var Y = void 0, Cb = void 0, Cr = void 0, R = void 0, G = void 0, B = void 0;
+            const component1 = decoded.components[0];
+            const component2 = decoded.components[1];
+            const component3 = decoded.components[2];
+            for (let y = 0; y < height; y++) {
+                const component1Line = component1.lines[0 | (y * component1.scaleY)];
+                const component2Line = component2.lines[0 | (y * component2.scaleY)];
+                const component3Line = component3.lines[0 | (y * component3.scaleY)];
+                for (let x = 0; x < width; x++) {
+                    let Y, Cb, Cr, R, G, B;
                     if (!colorTransform) {
                         R = component1Line[0 | (x * component1.scaleX)];
                         G = component2Line[0 | (x * component2.scaleX)];
@@ -919,17 +919,17 @@ function getData(decoded) {
             // The adobe transform marker overrides any previous setting
             if (decoded.adobe && decoded.adobe.transformCode)
                 colorTransform = true;
-            var component1 = decoded.components[0];
-            var component2 = decoded.components[1];
-            var component3 = decoded.components[2];
-            var component4 = decoded.components[3];
-            for (var y = 0; y < height; y++) {
-                var component1Line = component1.lines[0 | (y * component1.scaleY)];
-                var component2Line = component2.lines[0 | (y * component2.scaleY)];
-                var component3Line = component3.lines[0 | (y * component3.scaleY)];
-                var component4Line = component4.lines[0 | (y * component4.scaleY)];
-                for (var x = 0; x < width; x++) {
-                    var Y = void 0, Cb = void 0, Cr = void 0, K = void 0, C = void 0, M = void 0, Ye = void 0;
+            const component1 = decoded.components[0];
+            const component2 = decoded.components[1];
+            const component3 = decoded.components[2];
+            const component4 = decoded.components[3];
+            for (let y = 0; y < height; y++) {
+                const component1Line = component1.lines[0 | (y * component1.scaleY)];
+                const component2Line = component2.lines[0 | (y * component2.scaleY)];
+                const component3Line = component3.lines[0 | (y * component3.scaleY)];
+                const component4Line = component4.lines[0 | (y * component4.scaleY)];
+                for (let x = 0; x < width; x++) {
+                    let Y, Cb, Cr, K, C, M, Ye;
                     if (!colorTransform) {
                         C = component1Line[0 | (x * component1.scaleX)];
                         M = component2Line[0 | (x * component2.scaleX)];
@@ -962,20 +962,20 @@ function decodeJpeg(encoded, createImageData) {
     totalBytesAllocated = 0;
     if (encoded.length === 0)
         throw new Error('Empty jpeg buffer');
-    var decoded = parse(encoded);
+    const decoded = parse(encoded);
     requestMemoryAllocation(decoded.width * decoded.height * 4);
-    var data = getData(decoded);
-    var imageData = createImageData(decoded.width, decoded.height);
-    var width = imageData.width;
-    var height = imageData.height;
-    var imageDataArray = imageData.data;
-    var i = 0;
-    var j = 0;
+    const data = getData(decoded);
+    const imageData = createImageData(decoded.width, decoded.height);
+    const width = imageData.width;
+    const height = imageData.height;
+    const imageDataArray = imageData.data;
+    let i = 0;
+    let j = 0;
     switch (decoded.components.length) {
         case 1:
-            for (var y = 0; y < height; y++) {
-                for (var x = 0; x < width; x++) {
-                    var Y = data[i++];
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const Y = data[i++];
                     imageDataArray[j++] = Y;
                     imageDataArray[j++] = Y;
                     imageDataArray[j++] = Y;
@@ -984,11 +984,11 @@ function decodeJpeg(encoded, createImageData) {
             }
             break;
         case 3:
-            for (var y = 0; y < height; y++) {
-                for (var x = 0; x < width; x++) {
-                    var R = data[i++];
-                    var G = data[i++];
-                    var B = data[i++];
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const R = data[i++];
+                    const G = data[i++];
+                    const B = data[i++];
                     imageDataArray[j++] = R;
                     imageDataArray[j++] = G;
                     imageDataArray[j++] = B;
@@ -997,15 +997,15 @@ function decodeJpeg(encoded, createImageData) {
             }
             break;
         case 4:
-            for (var y = 0; y < height; y++) {
-                for (var x = 0; x < width; x++) {
-                    var C = data[i++];
-                    var M = data[i++];
-                    var Y = data[i++];
-                    var K = data[i++];
-                    var R = 255 - clampTo8bit(C * (1 - K / 255) + K);
-                    var G = 255 - clampTo8bit(M * (1 - K / 255) + K);
-                    var B = 255 - clampTo8bit(Y * (1 - K / 255) + K);
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const C = data[i++];
+                    const M = data[i++];
+                    const Y = data[i++];
+                    const K = data[i++];
+                    const R = 255 - clampTo8bit(C * (1 - K / 255) + K);
+                    const G = 255 - clampTo8bit(M * (1 - K / 255) + K);
+                    const B = 255 - clampTo8bit(Y * (1 - K / 255) + K);
                     imageDataArray[j++] = R;
                     imageDataArray[j++] = G;
                     imageDataArray[j++] = B;