pdfjs-dist 2.0.943 → 2.4.456

package/lib/core/jpx.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,103 +19,124 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.JpxImage = undefined;
+exports.JpxImage = void 0;
 
-var _util = require('../shared/util');
+var _util = require("../shared/util.js");
 
-var _arithmetic_decoder = require('./arithmetic_decoder');
+var _core_utils = require("./core_utils.js");
 
-var JpxError = function JpxErrorClosure() {
-  function JpxError(msg) {
-    this.message = 'JPX error: ' + msg;
+var _arithmetic_decoder = require("./arithmetic_decoder.js");
+
+class JpxError extends _util.BaseException {
+  constructor(msg) {
+    super(`JPX error: ${msg}`);
   }
-  JpxError.prototype = new Error();
-  JpxError.prototype.name = 'JpxError';
-  JpxError.constructor = JpxError;
-  return JpxError;
-}();
+
+}
+
 var JpxImage = function JpxImageClosure() {
   var SubbandsGainLog2 = {
-    'LL': 0,
-    'LH': 1,
-    'HL': 1,
-    'HH': 2
+    LL: 0,
+    LH: 1,
+    HL: 1,
+    HH: 2
   };
+
   function JpxImage() {
     this.failOnCorruptedImage = false;
   }
+
   JpxImage.prototype = {
     parse: function JpxImage_parse(data) {
-      var head = (0, _util.readUint16)(data, 0);
-      if (head === 0xFF4F) {
+      var head = (0, _core_utils.readUint16)(data, 0);
+
+      if (head === 0xff4f) {
         this.parseCodestream(data, 0, data.length);
         return;
       }
+
       var position = 0,
           length = data.length;
+
       while (position < length) {
         var headerSize = 8;
-        var lbox = (0, _util.readUint32)(data, position);
-        var tbox = (0, _util.readUint32)(data, position + 4);
+        var lbox = (0, _core_utils.readUint32)(data, position);
+        var tbox = (0, _core_utils.readUint32)(data, position + 4);
         position += headerSize;
+
         if (lbox === 1) {
-          lbox = (0, _util.readUint32)(data, position) * 4294967296 + (0, _util.readUint32)(data, position + 4);
+          lbox = (0, _core_utils.readUint32)(data, position) * 4294967296 + (0, _core_utils.readUint32)(data, position + 4);
           position += 8;
           headerSize += 8;
         }
+
         if (lbox === 0) {
           lbox = length - position + headerSize;
         }
+
         if (lbox < headerSize) {
-          throw new JpxError('Invalid box field size');
+          throw new JpxError("Invalid box field size");
         }
+
         var dataLength = lbox - headerSize;
         var jumpDataLength = true;
+
         switch (tbox) {
-          case 0x6A703268:
+          case 0x6a703268:
             jumpDataLength = false;
             break;
-          case 0x636F6C72:
+
+          case 0x636f6c72:
             var method = data[position];
+
             if (method === 1) {
-              var colorspace = (0, _util.readUint32)(data, position + 3);
+              var colorspace = (0, _core_utils.readUint32)(data, position + 3);
+
               switch (colorspace) {
                 case 16:
                 case 17:
                 case 18:
                   break;
+
                 default:
-                  (0, _util.warn)('Unknown colorspace ' + colorspace);
+                  (0, _util.warn)("Unknown colorspace " + colorspace);
                   break;
               }
             } else if (method === 2) {
-              (0, _util.info)('ICC profile not supported');
+              (0, _util.info)("ICC profile not supported");
             }
+
             break;
-          case 0x6A703263:
+
+          case 0x6a703263:
             this.parseCodestream(data, position, position + dataLength);
             break;
-          case 0x6A502020:
-            if ((0, _util.readUint32)(data, position) !== 0x0d0a870a) {
-              (0, _util.warn)('Invalid JP2 signature');
+
+          case 0x6a502020:
+            if ((0, _core_utils.readUint32)(data, position) !== 0x0d0a870a) {
+              (0, _util.warn)("Invalid JP2 signature");
             }
+
             break;
-          case 0x6A501A1A:
+
+          case 0x6a501a1a:
           case 0x66747970:
           case 0x72726571:
           case 0x72657320:
           case 0x69686472:
             break;
+
           default:
-            var headerType = String.fromCharCode(tbox >> 24 & 0xFF, tbox >> 16 & 0xFF, tbox >> 8 & 0xFF, tbox & 0xFF);
-            (0, _util.warn)('Unsupported header type ' + tbox + ' (' + headerType + ')');
+            var headerType = String.fromCharCode(tbox >> 24 & 0xff, tbox >> 16 & 0xff, tbox >> 8 & 0xff, tbox & 0xff);
+            (0, _util.warn)("Unsupported header type " + tbox + " (" + headerType + ")");
             break;
         }
+
         if (jumpDataLength) {
           position += dataLength;
         }
@@ -123,11 +144,13 @@ var JpxImage = function JpxImageClosure() {
     },
     parseImageProperties: function JpxImage_parseImageProperties(stream) {
       var newByte = stream.getByte();
+
       while (newByte >= 0) {
         var oldByte = newByte;
         newByte = stream.getByte();
         var code = oldByte << 8 | newByte;
-        if (code === 0xFF51) {
+
+        if (code === 0xff51) {
           stream.skip(4);
           var Xsiz = stream.getInt32() >>> 0;
           var Ysiz = stream.getInt32() >>> 0;
@@ -142,15 +165,18 @@ var JpxImage = function JpxImageClosure() {
           return;
         }
       }
-      throw new JpxError('No size marker found in JPX stream');
+
+      throw new JpxError("No size marker found in JPX stream");
     },
     parseCodestream: function JpxImage_parseCodestream(data, start, end) {
       var context = {};
       var doNotRecover = false;
+
       try {
         var position = start;
+
         while (position + 1 < end) {
-          var code = (0, _util.readUint16)(data, position);
+          var code = (0, _core_utils.readUint16)(data, position);
           position += 2;
           var length = 0,
               j,
@@ -159,30 +185,34 @@ var JpxImage = function JpxImageClosure() {
               spqcdSize,
               scalarExpounded,
               tile;
+
           switch (code) {
-            case 0xFF4F:
+            case 0xff4f:
               context.mainHeader = true;
               break;
-            case 0xFFD9:
+
+            case 0xffd9:
               break;
-            case 0xFF51:
-              length = (0, _util.readUint16)(data, position);
+
+            case 0xff51:
+              length = (0, _core_utils.readUint16)(data, position);
               var siz = {};
-              siz.Xsiz = (0, _util.readUint32)(data, position + 4);
-              siz.Ysiz = (0, _util.readUint32)(data, position + 8);
-              siz.XOsiz = (0, _util.readUint32)(data, position + 12);
-              siz.YOsiz = (0, _util.readUint32)(data, position + 16);
-              siz.XTsiz = (0, _util.readUint32)(data, position + 20);
-              siz.YTsiz = (0, _util.readUint32)(data, position + 24);
-              siz.XTOsiz = (0, _util.readUint32)(data, position + 28);
-              siz.YTOsiz = (0, _util.readUint32)(data, position + 32);
-              var componentsCount = (0, _util.readUint16)(data, position + 36);
+              siz.Xsiz = (0, _core_utils.readUint32)(data, position + 4);
+              siz.Ysiz = (0, _core_utils.readUint32)(data, position + 8);
+              siz.XOsiz = (0, _core_utils.readUint32)(data, position + 12);
+              siz.YOsiz = (0, _core_utils.readUint32)(data, position + 16);
+              siz.XTsiz = (0, _core_utils.readUint32)(data, position + 20);
+              siz.YTsiz = (0, _core_utils.readUint32)(data, position + 24);
+              siz.XTOsiz = (0, _core_utils.readUint32)(data, position + 28);
+              siz.YTOsiz = (0, _core_utils.readUint32)(data, position + 32);
+              var componentsCount = (0, _core_utils.readUint16)(data, position + 36);
               siz.Csiz = componentsCount;
               var components = [];
               j = position + 38;
+
               for (var i = 0; i < componentsCount; i++) {
                 var component = {
-                  precision: (data[j] & 0x7F) + 1,
+                  precision: (data[j] & 0x7f) + 1,
                   isSigned: !!(data[j] & 0x80),
                   XRsiz: data[j + 1],
                   YRsiz: data[j + 2]
@@ -191,39 +221,48 @@ var JpxImage = function JpxImageClosure() {
                 calculateComponentDimensions(component, siz);
                 components.push(component);
               }
+
               context.SIZ = siz;
               context.components = components;
               calculateTileGrids(context, components);
               context.QCC = [];
               context.COC = [];
               break;
-            case 0xFF5C:
-              length = (0, _util.readUint16)(data, position);
+
+            case 0xff5c:
+              length = (0, _core_utils.readUint16)(data, position);
               var qcd = {};
               j = position + 2;
               sqcd = data[j++];
-              switch (sqcd & 0x1F) {
+
+              switch (sqcd & 0x1f) {
                 case 0:
                   spqcdSize = 8;
                   scalarExpounded = true;
                   break;
+
                 case 1:
                   spqcdSize = 16;
                   scalarExpounded = false;
                   break;
+
                 case 2:
                   spqcdSize = 16;
                   scalarExpounded = true;
                   break;
+
                 default:
-                  throw new Error('Invalid SQcd value ' + sqcd);
+                  throw new Error("Invalid SQcd value " + sqcd);
               }
+
               qcd.noQuantization = spqcdSize === 8;
               qcd.scalarExpounded = scalarExpounded;
               qcd.guardBits = sqcd >> 5;
               spqcds = [];
+
               while (j < length + position) {
                 var spqcd = {};
+
                 if (spqcdSize === 8) {
                   spqcd.epsilon = data[j++] >> 3;
                   spqcd.mu = 0;
@@ -232,50 +271,64 @@ var JpxImage = function JpxImageClosure() {
                   spqcd.mu = (data[j] & 0x7) << 8 | data[j + 1];
                   j += 2;
                 }
+
                 spqcds.push(spqcd);
               }
+
               qcd.SPqcds = spqcds;
+
               if (context.mainHeader) {
                 context.QCD = qcd;
               } else {
                 context.currentTile.QCD = qcd;
                 context.currentTile.QCC = [];
               }
+
               break;
-            case 0xFF5D:
-              length = (0, _util.readUint16)(data, position);
+
+            case 0xff5d:
+              length = (0, _core_utils.readUint16)(data, position);
               var qcc = {};
               j = position + 2;
               var cqcc;
+
               if (context.SIZ.Csiz < 257) {
                 cqcc = data[j++];
               } else {
-                cqcc = (0, _util.readUint16)(data, j);
+                cqcc = (0, _core_utils.readUint16)(data, j);
                 j += 2;
               }
+
               sqcd = data[j++];
-              switch (sqcd & 0x1F) {
+
+              switch (sqcd & 0x1f) {
                 case 0:
                   spqcdSize = 8;
                   scalarExpounded = true;
                   break;
+
                 case 1:
                   spqcdSize = 16;
                   scalarExpounded = false;
                   break;
+
                 case 2:
                   spqcdSize = 16;
                   scalarExpounded = true;
                   break;
+
                 default:
-                  throw new Error('Invalid SQcd value ' + sqcd);
+                  throw new Error("Invalid SQcd value " + sqcd);
               }
+
               qcc.noQuantization = spqcdSize === 8;
               qcc.scalarExpounded = scalarExpounded;
               qcc.guardBits = sqcd >> 5;
               spqcds = [];
+
               while (j < length + position) {
                 spqcd = {};
+
                 if (spqcdSize === 8) {
                   spqcd.epsilon = data[j++] >> 3;
                   spqcd.mu = 0;
@@ -284,17 +337,22 @@ var JpxImage = function JpxImageClosure() {
                   spqcd.mu = (data[j] & 0x7) << 8 | data[j + 1];
                   j += 2;
                 }
+
                 spqcds.push(spqcd);
               }
+
               qcc.SPqcds = spqcds;
+
               if (context.mainHeader) {
                 context.QCC[cqcc] = qcc;
               } else {
                 context.currentTile.QCC[cqcc] = qcc;
               }
+
               break;
-            case 0xFF52:
-              length = (0, _util.readUint16)(data, position);
+
+            case 0xff52:
+              length = (0, _core_utils.readUint16)(data, position);
               var cod = {};
               j = position + 2;
               var scod = data[j++];
@@ -302,12 +360,12 @@ var JpxImage = function JpxImageClosure() {
               cod.sopMarkerUsed = !!(scod & 2);
               cod.ephMarkerUsed = !!(scod & 4);
               cod.progressionOrder = data[j++];
-              cod.layersCount = (0, _util.readUint16)(data, j);
+              cod.layersCount = (0, _core_utils.readUint16)(data, j);
               j += 2;
               cod.multipleComponentTransform = data[j++];
               cod.decompositionLevelsCount = data[j++];
-              cod.xcb = (data[j++] & 0xF) + 2;
-              cod.ycb = (data[j++] & 0xF) + 2;
+              cod.xcb = (data[j++] & 0xf) + 2;
+              cod.ycb = (data[j++] & 0xf) + 2;
               var blockStyle = data[j++];
               cod.selectiveArithmeticCodingBypass = !!(blockStyle & 1);
               cod.resetContextProbabilities = !!(blockStyle & 2);
@@ -316,96 +374,120 @@ var JpxImage = function JpxImageClosure() {
               cod.predictableTermination = !!(blockStyle & 16);
               cod.segmentationSymbolUsed = !!(blockStyle & 32);
               cod.reversibleTransformation = data[j++];
+
               if (cod.entropyCoderWithCustomPrecincts) {
                 var precinctsSizes = [];
+
                 while (j < length + position) {
                   var precinctsSize = data[j++];
                   precinctsSizes.push({
-                    PPx: precinctsSize & 0xF,
+                    PPx: precinctsSize & 0xf,
                     PPy: precinctsSize >> 4
                   });
                 }
+
                 cod.precinctsSizes = precinctsSizes;
               }
+
               var unsupported = [];
+
               if (cod.selectiveArithmeticCodingBypass) {
-                unsupported.push('selectiveArithmeticCodingBypass');
+                unsupported.push("selectiveArithmeticCodingBypass");
               }
+
               if (cod.resetContextProbabilities) {
-                unsupported.push('resetContextProbabilities');
+                unsupported.push("resetContextProbabilities");
               }
+
               if (cod.terminationOnEachCodingPass) {
-                unsupported.push('terminationOnEachCodingPass');
+                unsupported.push("terminationOnEachCodingPass");
               }
+
               if (cod.verticallyStripe) {
-                unsupported.push('verticallyStripe');
+                unsupported.push("verticallyStripe");
               }
+
               if (cod.predictableTermination) {
-                unsupported.push('predictableTermination');
+                unsupported.push("predictableTermination");
               }
+
               if (unsupported.length > 0) {
                 doNotRecover = true;
-                throw new Error('Unsupported COD options (' + unsupported.join(', ') + ')');
+                throw new Error("Unsupported COD options (" + unsupported.join(", ") + ")");
               }
+
               if (context.mainHeader) {
                 context.COD = cod;
               } else {
                 context.currentTile.COD = cod;
                 context.currentTile.COC = [];
               }
+
               break;
-            case 0xFF90:
-              length = (0, _util.readUint16)(data, position);
+
+            case 0xff90:
+              length = (0, _core_utils.readUint16)(data, position);
               tile = {};
-              tile.index = (0, _util.readUint16)(data, position + 2);
-              tile.length = (0, _util.readUint32)(data, position + 4);
+              tile.index = (0, _core_utils.readUint16)(data, position + 2);
+              tile.length = (0, _core_utils.readUint32)(data, position + 4);
               tile.dataEnd = tile.length + position - 2;
               tile.partIndex = data[position + 8];
               tile.partsCount = data[position + 9];
               context.mainHeader = false;
+
               if (tile.partIndex === 0) {
                 tile.COD = context.COD;
                 tile.COC = context.COC.slice(0);
                 tile.QCD = context.QCD;
                 tile.QCC = context.QCC.slice(0);
               }
+
               context.currentTile = tile;
               break;
-            case 0xFF93:
+
+            case 0xff93:
               tile = context.currentTile;
+
               if (tile.partIndex === 0) {
                 initializeTile(context, tile.index);
                 buildPackets(context);
               }
+
               length = tile.dataEnd - position;
               parseTilePackets(context, data, position, length);
               break;
-            case 0xFF55:
-            case 0xFF57:
-            case 0xFF58:
-            case 0xFF64:
-              length = (0, _util.readUint16)(data, position);
+
+            case 0xff55:
+            case 0xff57:
+            case 0xff58:
+            case 0xff64:
+              length = (0, _core_utils.readUint16)(data, position);
               break;
-            case 0xFF53:
-              throw new Error('Codestream code 0xFF53 (COC) is ' + 'not implemented');
+
+            case 0xff53:
+              throw new Error("Codestream code 0xFF53 (COC) is not implemented");
+
             default:
-              throw new Error('Unknown codestream code: ' + code.toString(16));
+              throw new Error("Unknown codestream code: " + code.toString(16));
           }
+
           position += length;
         }
       } catch (e) {
         if (doNotRecover || this.failOnCorruptedImage) {
           throw new JpxError(e.message);
         } else {
-          (0, _util.warn)('JPX: Trying to recover from: ' + e.message);
+          (0, _util.warn)("JPX: Trying to recover from: " + e.message);
         }
       }
+
       this.tiles = transformComponents(context);
       this.width = context.SIZ.Xsiz - context.SIZ.XOsiz;
       this.height = context.SIZ.Ysiz - context.SIZ.YOsiz;
       this.componentsCount = context.SIZ.Csiz;
     }
   };
+
   function calculateComponentDimensions(component, siz) {
     component.x0 = Math.ceil(siz.XOsiz / component.XRsiz);
     component.x1 = Math.ceil(siz.Xsiz / component.XRsiz);
@@ -414,12 +496,14 @@ var JpxImage = function JpxImageClosure() {
     component.width = component.x1 - component.x0;
     component.height = component.y1 - component.y0;
   }
+
   function calculateTileGrids(context, components) {
     var siz = context.SIZ;
     var tile,
         tiles = [];
     var numXtiles = Math.ceil((siz.Xsiz - siz.XTOsiz) / siz.XTsiz);
     var numYtiles = Math.ceil((siz.Ysiz - siz.YTOsiz) / siz.YTsiz);
+
     for (var q = 0; q < numYtiles; q++) {
       for (var p = 0; p < numXtiles; p++) {
         tile = {};
@@ -433,10 +517,13 @@ var JpxImage = function JpxImageClosure() {
         tiles.push(tile);
       }
     }
+
     context.tiles = tiles;
     var componentsCount = siz.Csiz;
+
     for (var i = 0, ii = componentsCount; i < ii; i++) {
       var component = components[i];
+
       for (var j = 0, jj = tiles.length; j < jj; j++) {
         var tileComponent = {};
         tile = tiles[j];
@@ -450,9 +537,11 @@ var JpxImage = function JpxImageClosure() {
       }
     }
   }
+
   function getBlocksDimensions(context, component, r) {
     var codOrCoc = component.codingStyleParameters;
     var result = {};
+
     if (!codOrCoc.entropyCoderWithCustomPrecincts) {
       result.PPx = 15;
       result.PPy = 15;
@@ -460,10 +549,12 @@ var JpxImage = function JpxImageClosure() {
       result.PPx = codOrCoc.precinctsSizes[r].PPx;
       result.PPy = codOrCoc.precinctsSizes[r].PPy;
     }
+
     result.xcb_ = r > 0 ? Math.min(codOrCoc.xcb, result.PPx - 1) : Math.min(codOrCoc.xcb, result.PPx);
     result.ycb_ = r > 0 ? Math.min(codOrCoc.ycb, result.PPy - 1) : Math.min(codOrCoc.ycb, result.PPy);
     return result;
   }
+
   function buildPrecincts(context, resolution, dimensions) {
     var precinctWidth = 1 << dimensions.PPx;
     var precinctHeight = 1 << dimensions.PPy;
@@ -474,15 +565,16 @@ var JpxImage = function JpxImageClosure() {
     var numprecinctshigh = resolution.try1 > resolution.try0 ? Math.ceil(resolution.try1 / precinctHeight) - Math.floor(resolution.try0 / precinctHeight) : 0;
     var numprecincts = numprecinctswide * numprecinctshigh;
     resolution.precinctParameters = {
-      precinctWidth: precinctWidth,
-      precinctHeight: precinctHeight,
-      numprecinctswide: numprecinctswide,
-      numprecinctshigh: numprecinctshigh,
-      numprecincts: numprecincts,
-      precinctWidthInSubband: precinctWidthInSubband,
-      precinctHeightInSubband: precinctHeightInSubband
+      precinctWidth,
+      precinctHeight,
+      numprecinctswide,
+      numprecinctshigh,
+      numprecincts,
+      precinctWidthInSubband,
+      precinctHeightInSubband
     };
   }
+
   function buildCodeblocks(context, subband, dimensions) {
     var xcb_ = dimensions.xcb_;
     var ycb_ = dimensions.ycb_;
@@ -496,6 +588,7 @@ var JpxImage = function JpxImageClosure() {
     var codeblocks = [];
     var precincts = [];
     var i, j, codeblock, precinctNumber;
+
     for (j = cby0; j < cby1; j++) {
       for (i = cbx0; i < cbx1; i++) {
         codeblock = {
@@ -516,17 +609,21 @@ var JpxImage = function JpxImageClosure() {
         codeblock.precinctNumber = precinctNumber;
         codeblock.subbandType = subband.type;
         codeblock.Lblock = 3;
+
         if (codeblock.tbx1_ <= codeblock.tbx0_ || codeblock.tby1_ <= codeblock.tby0_) {
           continue;
         }
+
         codeblocks.push(codeblock);
         var precinct = precincts[precinctNumber];
+
         if (precinct !== undefined) {
           if (i < precinct.cbxMin) {
             precinct.cbxMin = i;
           } else if (i > precinct.cbxMax) {
             precinct.cbxMax = i;
           }
+
           if (j < precinct.cbyMin) {
             precinct.cbxMin = j;
           } else if (j > precinct.cbyMax) {
@@ -540,9 +637,11 @@ var JpxImage = function JpxImageClosure() {
             cbyMax: j
           };
         }
+
         codeblock.precinct = precinct;
       }
     }
+
     subband.codeblockParameters = {
       codeblockWidth: xcb_,
       codeblockHeight: ycb_,
@@ -552,25 +651,32 @@ var JpxImage = function JpxImageClosure() {
     subband.codeblocks = codeblocks;
     subband.precincts = precincts;
   }
+
   function createPacket(resolution, precinctNumber, layerNumber) {
     var precinctCodeblocks = [];
     var subbands = resolution.subbands;
+
     for (var i = 0, ii = subbands.length; i < ii; i++) {
       var subband = subbands[i];
       var codeblocks = subband.codeblocks;
+
       for (var j = 0, jj = codeblocks.length; j < jj; j++) {
         var codeblock = codeblocks[j];
+
         if (codeblock.precinctNumber !== precinctNumber) {
           continue;
         }
+
         precinctCodeblocks.push(codeblock);
       }
     }
+
     return {
-      layerNumber: layerNumber,
+      layerNumber,
       codeblocks: precinctCodeblocks
     };
   }
+
   function LayerResolutionComponentPositionIterator(context) {
     var siz = context.SIZ;
     var tileIndex = context.currentTile.index;
@@ -578,37 +684,48 @@ var JpxImage = function JpxImageClosure() {
     var layersCount = tile.codingStyleDefaultParameters.layersCount;
     var componentsCount = siz.Csiz;
     var maxDecompositionLevelsCount = 0;
+
     for (var q = 0; q < componentsCount; q++) {
       maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, tile.components[q].codingStyleParameters.decompositionLevelsCount);
     }
+
     var l = 0,
         r = 0,
         i = 0,
         k = 0;
+
     this.nextPacket = function JpxImage_nextPacket() {
       for (; l < layersCount; l++) {
         for (; r <= maxDecompositionLevelsCount; r++) {
           for (; i < componentsCount; i++) {
             var component = tile.components[i];
+
             if (r > component.codingStyleParameters.decompositionLevelsCount) {
               continue;
             }
+
             var resolution = component.resolutions[r];
             var numprecincts = resolution.precinctParameters.numprecincts;
+
             for (; k < numprecincts;) {
               var packet = createPacket(resolution, k, l);
               k++;
               return packet;
             }
+
             k = 0;
           }
+
           i = 0;
         }
+
         r = 0;
       }
-      throw new JpxError('Out of packets');
+
+      throw new JpxError("Out of packets");
     };
   }
+
   function ResolutionLayerComponentPositionIterator(context) {
     var siz = context.SIZ;
     var tileIndex = context.currentTile.index;
@@ -616,37 +733,48 @@ var JpxImage = function JpxImageClosure() {
     var layersCount = tile.codingStyleDefaultParameters.layersCount;
     var componentsCount = siz.Csiz;
     var maxDecompositionLevelsCount = 0;
+
     for (var q = 0; q < componentsCount; q++) {
       maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, tile.components[q].codingStyleParameters.decompositionLevelsCount);
     }
+
     var r = 0,
         l = 0,
         i = 0,
         k = 0;
+
     this.nextPacket = function JpxImage_nextPacket() {
       for (; r <= maxDecompositionLevelsCount; r++) {
         for (; l < layersCount; l++) {
           for (; i < componentsCount; i++) {
             var component = tile.components[i];
+
             if (r > component.codingStyleParameters.decompositionLevelsCount) {
               continue;
             }
+
             var resolution = component.resolutions[r];
             var numprecincts = resolution.precinctParameters.numprecincts;
+
             for (; k < numprecincts;) {
               var packet = createPacket(resolution, k, l);
               k++;
               return packet;
             }
+
             k = 0;
           }
+
           i = 0;
         }
+
         l = 0;
       }
-      throw new JpxError('Out of packets');
+
+      throw new JpxError("Out of packets");
     };
   }
+
   function ResolutionPositionComponentLayerIterator(context) {
     var siz = context.SIZ;
     var tileIndex = context.currentTile.index;
@@ -655,52 +783,69 @@ var JpxImage = function JpxImageClosure() {
     var componentsCount = siz.Csiz;
     var l, r, c, p;
     var maxDecompositionLevelsCount = 0;
+
     for (c = 0; c < componentsCount; c++) {
       var component = tile.components[c];
       maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, component.codingStyleParameters.decompositionLevelsCount);
     }
+
     var maxNumPrecinctsInLevel = new Int32Array(maxDecompositionLevelsCount + 1);
+
     for (r = 0; r <= maxDecompositionLevelsCount; ++r) {
       var maxNumPrecincts = 0;
+
       for (c = 0; c < componentsCount; ++c) {
         var resolutions = tile.components[c].resolutions;
+
         if (r < resolutions.length) {
           maxNumPrecincts = Math.max(maxNumPrecincts, resolutions[r].precinctParameters.numprecincts);
         }
       }
+
       maxNumPrecinctsInLevel[r] = maxNumPrecincts;
     }
+
     l = 0;
     r = 0;
     c = 0;
     p = 0;
+
     this.nextPacket = function JpxImage_nextPacket() {
       for (; r <= maxDecompositionLevelsCount; r++) {
         for (; p < maxNumPrecinctsInLevel[r]; p++) {
           for (; c < componentsCount; c++) {
             var component = tile.components[c];
+
             if (r > component.codingStyleParameters.decompositionLevelsCount) {
               continue;
             }
+
             var resolution = component.resolutions[r];
             var numprecincts = resolution.precinctParameters.numprecincts;
+
             if (p >= numprecincts) {
               continue;
             }
+
             for (; l < layersCount;) {
               var packet = createPacket(resolution, p, l);
               l++;
               return packet;
             }
+
             l = 0;
           }
+
           c = 0;
         }
+
         p = 0;
       }
-      throw new JpxError('Out of packets');
+
+      throw new JpxError("Out of packets");
     };
   }
+
   function PositionComponentResolutionLayerIterator(context) {
     var siz = context.SIZ;
     var tileIndex = context.currentTile.index;
@@ -714,35 +859,45 @@ var JpxImage = function JpxImageClosure() {
         c = 0,
         px = 0,
         py = 0;
+
     this.nextPacket = function JpxImage_nextPacket() {
       for (; py < precinctsIterationSizes.maxNumHigh; py++) {
         for (; px < precinctsIterationSizes.maxNumWide; px++) {
           for (; c < componentsCount; c++) {
             var component = tile.components[c];
             var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
+
             for (; r <= decompositionLevelsCount; r++) {
               var resolution = component.resolutions[r];
               var sizeInImageScale = precinctsSizes.components[c].resolutions[r];
               var k = getPrecinctIndexIfExist(px, py, sizeInImageScale, precinctsIterationSizes, resolution);
+
               if (k === null) {
                 continue;
               }
+
               for (; l < layersCount;) {
                 var packet = createPacket(resolution, k, l);
                 l++;
                 return packet;
               }
+
               l = 0;
             }
+
             r = 0;
           }
+
           c = 0;
         }
+
         px = 0;
       }
-      throw new JpxError('Out of packets');
+
+      throw new JpxError("Out of packets");
     };
   }
+
   function ComponentPositionResolutionLayerIterator(context) {
     var siz = context.SIZ;
     var tileIndex = context.currentTile.index;
@@ -755,45 +910,58 @@ var JpxImage = function JpxImageClosure() {
         c = 0,
         px = 0,
         py = 0;
+
     this.nextPacket = function JpxImage_nextPacket() {
       for (; c < componentsCount; ++c) {
         var component = tile.components[c];
         var precinctsIterationSizes = precinctsSizes.components[c];
         var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
+
         for (; py < precinctsIterationSizes.maxNumHigh; py++) {
           for (; px < precinctsIterationSizes.maxNumWide; px++) {
             for (; r <= decompositionLevelsCount; r++) {
               var resolution = component.resolutions[r];
               var sizeInImageScale = precinctsIterationSizes.resolutions[r];
               var k = getPrecinctIndexIfExist(px, py, sizeInImageScale, precinctsIterationSizes, resolution);
+
               if (k === null) {
                 continue;
               }
+
               for (; l < layersCount;) {
                 var packet = createPacket(resolution, k, l);
                 l++;
                 return packet;
               }
+
               l = 0;
             }
+
             r = 0;
           }
+
           px = 0;
         }
+
         py = 0;
       }
-      throw new JpxError('Out of packets');
+
+      throw new JpxError("Out of packets");
     };
   }
+
   function getPrecinctIndexIfExist(pxIndex, pyIndex, sizeInImageScale, precinctIterationSizes, resolution) {
     var posX = pxIndex * precinctIterationSizes.minWidth;
     var posY = pyIndex * precinctIterationSizes.minHeight;
+
     if (posX % sizeInImageScale.width !== 0 || posY % sizeInImageScale.height !== 0) {
       return null;
     }
+
     var startPrecinctRowIndex = posY / sizeInImageScale.width * resolution.precinctParameters.numprecinctswide;
     return posX / sizeInImageScale.height + startPrecinctRowIndex;
   }
+
   function getPrecinctSizesInImageScale(tile) {
     var componentsCount = tile.components.length;
     var minWidth = Number.MAX_VALUE;
@@ -801,6 +969,7 @@ var JpxImage = function JpxImageClosure() {
     var maxNumWide = 0;
     var maxNumHigh = 0;
     var sizePerComponent = new Array(componentsCount);
+
     for (var c = 0; c < componentsCount; c++) {
       var component = tile.components[c];
       var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
@@ -810,6 +979,7 @@ var JpxImage = function JpxImageClosure() {
       var maxNumWideCurrentComponent = 0;
       var maxNumHighCurrentComponent = 0;
       var scale = 1;
+
       for (var r = decompositionLevelsCount; r >= 0; --r) {
         var resolution = component.resolutions[r];
         var widthCurrentResolution = scale * resolution.precinctParameters.precinctWidth;
@@ -824,6 +994,7 @@ var JpxImage = function JpxImageClosure() {
         };
         scale <<= 1;
       }
+
       minWidth = Math.min(minWidth, minWidthCurrentComponent);
       minHeight = Math.min(minHeight, minHeightCurrentComponent);
       maxNumWide = Math.max(maxNumWide, maxNumWideCurrentComponent);
@@ -836,24 +1007,28 @@ var JpxImage = function JpxImageClosure() {
         maxNumHigh: maxNumHighCurrentComponent
       };
     }
+
     return {
       components: sizePerComponent,
-      minWidth: minWidth,
-      minHeight: minHeight,
-      maxNumWide: maxNumWide,
-      maxNumHigh: maxNumHigh
+      minWidth,
+      minHeight,
+      maxNumWide,
+      maxNumHigh
     };
   }
+
   function buildPackets(context) {
     var siz = context.SIZ;
     var tileIndex = context.currentTile.index;
     var tile = context.tiles[tileIndex];
     var componentsCount = siz.Csiz;
+
     for (var c = 0; c < componentsCount; c++) {
       var component = tile.components[c];
       var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
       var resolutions = [];
       var subbands = [];
+
       for (var r = 0; r <= decompositionLevelsCount; r++) {
         var blocksDimensions = getBlocksDimensions(context, component, r);
         var resolution = {};
@@ -866,9 +1041,10 @@ var JpxImage = function JpxImageClosure() {
         buildPrecincts(context, resolution, blocksDimensions);
         resolutions.push(resolution);
         var subband;
+
         if (r === 0) {
           subband = {};
-          subband.type = 'LL';
+          subband.type = "LL";
           subband.tbx0 = Math.ceil(component.tcx0 / scale);
           subband.tby0 = Math.ceil(component.tcy0 / scale);
           subband.tbx1 = Math.ceil(component.tcx1 / scale);
@@ -881,7 +1057,7 @@ var JpxImage = function JpxImageClosure() {
           var bscale = 1 << decompositionLevelsCount - r + 1;
           var resolutionSubbands = [];
           subband = {};
-          subband.type = 'HL';
+          subband.type = "HL";
           subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);
           subband.tby0 = Math.ceil(component.tcy0 / bscale);
           subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);
@@ -891,7 +1067,7 @@ var JpxImage = function JpxImageClosure() {
           subbands.push(subband);
           resolutionSubbands.push(subband);
           subband = {};
-          subband.type = 'LH';
+          subband.type = "LH";
           subband.tbx0 = Math.ceil(component.tcx0 / bscale);
           subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);
           subband.tbx1 = Math.ceil(component.tcx1 / bscale);
@@ -901,7 +1077,7 @@ var JpxImage = function JpxImageClosure() {
           subbands.push(subband);
           resolutionSubbands.push(subband);
           subband = {};
-          subband.type = 'HH';
+          subband.type = "HH";
           subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);
           subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);
           subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);
@@ -913,39 +1089,50 @@ var JpxImage = function JpxImageClosure() {
           resolution.subbands = resolutionSubbands;
         }
       }
+
       component.resolutions = resolutions;
       component.subbands = subbands;
     }
+
     var progressionOrder = tile.codingStyleDefaultParameters.progressionOrder;
+
     switch (progressionOrder) {
       case 0:
         tile.packetsIterator = new LayerResolutionComponentPositionIterator(context);
         break;
+
       case 1:
         tile.packetsIterator = new ResolutionLayerComponentPositionIterator(context);
         break;
+
       case 2:
         tile.packetsIterator = new ResolutionPositionComponentLayerIterator(context);
         break;
+
       case 3:
         tile.packetsIterator = new PositionComponentResolutionLayerIterator(context);
         break;
+
       case 4:
         tile.packetsIterator = new ComponentPositionResolutionLayerIterator(context);
         break;
+
       default:
-        throw new JpxError('Unsupported progression order ' + progressionOrder);
+        throw new JpxError(`Unsupported progression order ${progressionOrder}`);
     }
   }
+
   function parseTilePackets(context, data, offset, dataLength) {
     var position = 0;
     var buffer,
         bufferSize = 0,
         skipNextBit = false;
+
     function readBits(count) {
       while (bufferSize < count) {
         var b = data[offset + position];
         position++;
+
         if (skipNextBit) {
           buffer = buffer << 7 | b;
           bufferSize += 7;
@@ -954,68 +1141,89 @@ var JpxImage = function JpxImageClosure() {
           buffer = buffer << 8 | b;
           bufferSize += 8;
         }
-        if (b === 0xFF) {
+
+        if (b === 0xff) {
           skipNextBit = true;
         }
       }
+
       bufferSize -= count;
       return buffer >>> bufferSize & (1 << count) - 1;
     }
+
     function skipMarkerIfEqual(value) {
-      if (data[offset + position - 1] === 0xFF && data[offset + position] === value) {
+      if (data[offset + position - 1] === 0xff && data[offset + position] === value) {
         skipBytes(1);
         return true;
-      } else if (data[offset + position] === 0xFF && data[offset + position + 1] === value) {
+      } else if (data[offset + position] === 0xff && data[offset + position + 1] === value) {
         skipBytes(2);
         return true;
       }
+
       return false;
     }
+
     function skipBytes(count) {
       position += count;
     }
+
     function alignToByte() {
       bufferSize = 0;
+
       if (skipNextBit) {
         position++;
         skipNextBit = false;
       }
     }
+
     function readCodingpasses() {
       if (readBits(1) === 0) {
         return 1;
       }
+
       if (readBits(1) === 0) {
         return 2;
       }
+
       var value = readBits(2);
+
       if (value < 3) {
         return value + 3;
       }
+
       value = readBits(5);
+
       if (value < 31) {
         return value + 6;
       }
+
       value = readBits(7);
       return value + 37;
     }
+
     var tileIndex = context.currentTile.index;
     var tile = context.tiles[tileIndex];
     var sopMarkerUsed = context.COD.sopMarkerUsed;
     var ephMarkerUsed = context.COD.ephMarkerUsed;
     var packetsIterator = tile.packetsIterator;
+
     while (position < dataLength) {
       alignToByte();
+
       if (sopMarkerUsed && skipMarkerIfEqual(0x91)) {
         skipBytes(4);
       }
+
       var packet = packetsIterator.nextPacket();
+
       if (!readBits(1)) {
         continue;
       }
+
       var layerNumber = packet.layerNumber;
       var queue = [],
           codeblock;
+
       for (var i = 0, ii = packet.codeblocks.length; i < ii; i++) {
         codeblock = packet.codeblocks[i];
         var precinct = codeblock.precinct;
@@ -1024,12 +1232,14 @@ var JpxImage = function JpxImageClosure() {
         var codeblockIncluded = false;
         var firstTimeInclusion = false;
         var valueReady;
-        if (codeblock['included'] !== undefined) {
+
+        if (codeblock["included"] !== undefined) {
           codeblockIncluded = !!readBits(1);
         } else {
           precinct = codeblock.precinct;
           var inclusionTree, zeroBitPlanesTree;
-          if (precinct['inclusionTree'] !== undefined) {
+
+          if (precinct["inclusionTree"] !== undefined) {
             inclusionTree = precinct.inclusionTree;
           } else {
             var width = precinct.cbxMax - precinct.cbxMin + 1;
@@ -1039,10 +1249,12 @@ var JpxImage = function JpxImageClosure() {
             precinct.inclusionTree = inclusionTree;
             precinct.zeroBitPlanesTree = zeroBitPlanesTree;
           }
+
           if (inclusionTree.reset(codeblockColumn, codeblockRow, layerNumber)) {
             while (true) {
               if (readBits(1)) {
                 valueReady = !inclusionTree.nextLevel();
+
                 if (valueReady) {
                   codeblock.included = true;
                   codeblockIncluded = firstTimeInclusion = true;
@@ -1055,15 +1267,19 @@ var JpxImage = function JpxImageClosure() {
             }
           }
         }
+
         if (!codeblockIncluded) {
           continue;
         }
+
         if (firstTimeInclusion) {
           zeroBitPlanesTree = precinct.zeroBitPlanesTree;
           zeroBitPlanesTree.reset(codeblockColumn, codeblockRow);
+
           while (true) {
             if (readBits(1)) {
               valueReady = !zeroBitPlanesTree.nextLevel();
+
               if (valueReady) {
                 break;
               }
@@ -1071,33 +1287,42 @@ var JpxImage = function JpxImageClosure() {
               zeroBitPlanesTree.incrementValue();
             }
           }
+
           codeblock.zeroBitPlanes = zeroBitPlanesTree.value;
         }
+
         var codingpasses = readCodingpasses();
+
         while (readBits(1)) {
           codeblock.Lblock++;
         }
-        var codingpassesLog2 = (0, _util.log2)(codingpasses);
+
+        var codingpassesLog2 = (0, _core_utils.log2)(codingpasses);
         var bits = (codingpasses < 1 << codingpassesLog2 ? codingpassesLog2 - 1 : codingpassesLog2) + codeblock.Lblock;
         var codedDataLength = readBits(bits);
         queue.push({
-          codeblock: codeblock,
-          codingpasses: codingpasses,
+          codeblock,
+          codingpasses,
           dataLength: codedDataLength
         });
       }
+
       alignToByte();
+
       if (ephMarkerUsed) {
         skipMarkerIfEqual(0x92);
       }
+
       while (queue.length > 0) {
         var packetItem = queue.shift();
         codeblock = packetItem.codeblock;
-        if (codeblock['data'] === undefined) {
+
+        if (codeblock["data"] === undefined) {
           codeblock.data = [];
         }
+
         codeblock.data.push({
-          data: data,
+          data,
           start: offset + position,
           end: offset + position + packetItem.dataLength,
           codingpasses: packetItem.codingpasses
@@ -1105,25 +1330,31 @@ var JpxImage = function JpxImageClosure() {
         position += packetItem.dataLength;
       }
     }
+
     return position;
   }
+
   function copyCoefficients(coefficients, levelWidth, levelHeight, subband, delta, mb, reversible, segmentationSymbolUsed) {
     var x0 = subband.tbx0;
     var y0 = subband.tby0;
     var width = subband.tbx1 - subband.tbx0;
     var codeblocks = subband.codeblocks;
-    var right = subband.type.charAt(0) === 'H' ? 1 : 0;
-    var bottom = subband.type.charAt(1) === 'H' ? levelWidth : 0;
+    var right = subband.type.charAt(0) === "H" ? 1 : 0;
+    var bottom = subband.type.charAt(1) === "H" ? levelWidth : 0;
+
     for (var i = 0, ii = codeblocks.length; i < ii; ++i) {
       var codeblock = codeblocks[i];
       var blockWidth = codeblock.tbx1_ - codeblock.tbx0_;
       var blockHeight = codeblock.tby1_ - codeblock.tby0_;
+
       if (blockWidth === 0 || blockHeight === 0) {
         continue;
       }
-      if (codeblock['data'] === undefined) {
+
+      if (codeblock["data"] === undefined) {
         continue;
       }
+
       var bitModel, currentCodingpassType;
       bitModel = new BitModel(blockWidth, blockHeight, codeblock.subbandType, codeblock.zeroBitPlanes, mb);
       currentCodingpassType = 2;
@@ -1131,38 +1362,49 @@ var JpxImage = function JpxImageClosure() {
           totalLength = 0,
           codingpasses = 0;
       var j, jj, dataItem;
+
       for (j = 0, jj = data.length; j < jj; j++) {
         dataItem = data[j];
         totalLength += dataItem.end - dataItem.start;
         codingpasses += dataItem.codingpasses;
       }
+
       var encodedData = new Uint8Array(totalLength);
       var position = 0;
+
       for (j = 0, jj = data.length; j < jj; j++) {
         dataItem = data[j];
         var chunk = dataItem.data.subarray(dataItem.start, dataItem.end);
         encodedData.set(chunk, position);
         position += chunk.length;
       }
+
       var decoder = new _arithmetic_decoder.ArithmeticDecoder(encodedData, 0, totalLength);
       bitModel.setDecoder(decoder);
+
       for (j = 0; j < codingpasses; j++) {
         switch (currentCodingpassType) {
           case 0:
             bitModel.runSignificancePropagationPass();
             break;
+
           case 1:
             bitModel.runMagnitudeRefinementPass();
             break;
+
           case 2:
             bitModel.runCleanupPass();
+
             if (segmentationSymbolUsed) {
               bitModel.checkSegmentationSymbol();
             }
+
             break;
         }
+
         currentCodingpassType = (currentCodingpassType + 1) % 3;
       }
+
       var offset = codeblock.tbx0_ - x0 + (codeblock.tby0_ - y0) * width;
       var sign = bitModel.coefficentsSign;
       var magnitude = bitModel.coefficentsMagnitude;
@@ -1170,32 +1412,41 @@ var JpxImage = function JpxImageClosure() {
       var magnitudeCorrection = reversible ? 0 : 0.5;
       var k, n, nb;
       position = 0;
-      var interleave = subband.type !== 'LL';
+      var interleave = subband.type !== "LL";
+
       for (j = 0; j < blockHeight; j++) {
         var row = offset / width | 0;
         var levelOffset = 2 * row * (levelWidth - width) + right + bottom;
+
         for (k = 0; k < blockWidth; k++) {
           n = magnitude[position];
+
           if (n !== 0) {
             n = (n + magnitudeCorrection) * delta;
+
             if (sign[position] !== 0) {
               n = -n;
             }
+
             nb = bitsDecoded[position];
             var pos = interleave ? levelOffset + (offset << 1) : offset;
+
             if (reversible && nb >= mb) {
               coefficients[pos] = n;
             } else {
               coefficients[pos] = n * (1 << mb - nb);
             }
           }
+
           offset++;
           position++;
         }
+
         offset += width - blockWidth;
       }
     }
   }
+
   function transformTile(context, tile, c) {
     var component = tile.components[c];
     var codingStyleParameters = component.codingStyleParameters;
@@ -1210,13 +1461,16 @@ var JpxImage = function JpxImageClosure() {
     var transform = reversible ? new ReversibleTransform() : new IrreversibleTransform();
     var subbandCoefficients = [];
     var b = 0;
+
     for (var i = 0; i <= decompositionLevelsCount; i++) {
       var resolution = component.resolutions[i];
       var width = resolution.trx1 - resolution.trx0;
       var height = resolution.try1 - resolution.try0;
       var coefficients = new Float32Array(width * height);
+
       for (var j = 0, jj = resolution.subbands.length; j < jj; j++) {
         var mu, epsilon;
+
         if (!scalarExpounded) {
           mu = spqcds[0].mu;
           epsilon = spqcds[0].epsilon + (i > 0 ? 1 - i : 0);
@@ -1225,18 +1479,21 @@ var JpxImage = function JpxImageClosure() {
           epsilon = spqcds[b].epsilon;
           b++;
         }
+
         var subband = resolution.subbands[j];
         var gainLog2 = SubbandsGainLog2[subband.type];
-        var delta = reversible ? 1 : Math.pow(2, precision + gainLog2 - epsilon) * (1 + mu / 2048);
+        var delta = reversible ? 1 : 2 ** (precision + gainLog2 - epsilon) * (1 + mu / 2048);
         var mb = guardBits + epsilon - 1;
         copyCoefficients(coefficients, width, height, subband, delta, mb, reversible, segmentationSymbolUsed);
       }
+
       subbandCoefficients.push({
-        width: width,
-        height: height,
+        width,
+        height,
         items: coefficients
       });
     }
+
     var result = transform.calculate(subbandCoefficients, component.tcx0, component.tcy0);
     return {
       left: component.tcx0,
@@ -1246,18 +1503,22 @@ var JpxImage = function JpxImageClosure() {
       items: result.items
     };
   }
+
   function transformComponents(context) {
     var siz = context.SIZ;
     var components = context.components;
     var componentsCount = siz.Csiz;
     var resultImages = [];
+
     for (var i = 0, ii = context.tiles.length; i < ii; i++) {
       var tile = context.tiles[i];
       var transformedTiles = [];
       var c;
+
       for (c = 0; c < componentsCount; c++) {
         transformedTiles[c] = transformTile(context, tile, c);
       }
+
       var tile0 = transformedTiles[0];
       var out = new Uint8ClampedArray(tile0.items.length * componentsCount);
       var result = {
@@ -1274,6 +1535,7 @@ var JpxImage = function JpxImageClosure() {
           y0,
           y1,
           y2;
+
       if (tile.codingStyleDefaultParameters.multipleComponentTransform) {
         var fourComponents = componentsCount === 4;
         var y0items = transformedTiles[0].items;
@@ -1285,6 +1547,7 @@ var JpxImage = function JpxImageClosure() {
         var component0 = tile.components[0];
         var alpha01 = componentsCount - 3;
         jj = y0items.length;
+
         if (!component0.codingStyleParameters.reversibleTransformation) {
           for (j = 0; j < jj; j++, pos += alpha01) {
             y0 = y0items[j] + offset;
@@ -1299,12 +1562,13 @@ var JpxImage = function JpxImageClosure() {
             y0 = y0items[j] + offset;
             y1 = y1items[j];
             y2 = y2items[j];
-            var g = y0 - (y2 + y1 >> 2);
+            const g = y0 - (y2 + y1 >> 2);
             out[pos++] = g + y2 >> shift;
             out[pos++] = g >> shift;
             out[pos++] = g + y1 >> shift;
           }
         }
+
         if (fourComponents) {
           for (j = 0, pos = 3; j < jj; j++, pos += 4) {
             out[pos] = y3items[j] + offset >> shift;
@@ -1315,20 +1579,25 @@ var JpxImage = function JpxImageClosure() {
           var items = transformedTiles[c].items;
           shift = components[c].precision - 8;
           offset = (128 << shift) + 0.5;
+
           for (pos = c, j = 0, jj = items.length; j < jj; j++) {
             out[pos] = items[j] + offset >> shift;
             pos += componentsCount;
           }
         }
       }
+
       resultImages.push(result);
     }
+
     return resultImages;
   }
+
   function initializeTile(context, tileIndex) {
     var siz = context.SIZ;
     var componentsCount = siz.Csiz;
     var tile = context.tiles[tileIndex];
+
     for (var c = 0; c < componentsCount; c++) {
       var component = tile.components[c];
       var qcdOrQcc = context.currentTile.QCC[c] !== undefined ? context.currentTile.QCC[c] : context.currentTile.QCD;
@@ -1336,16 +1605,19 @@ var JpxImage = function JpxImageClosure() {
       var codOrCoc = context.currentTile.COC[c] !== undefined ? context.currentTile.COC[c] : context.currentTile.COD;
       component.codingStyleParameters = codOrCoc;
     }
+
     tile.codingStyleDefaultParameters = context.currentTile.COD;
   }
+
   var TagTree = function TagTreeClosure() {
     function TagTree(width, height) {
-      var levelsLength = (0, _util.log2)(Math.max(width, height)) + 1;
+      var levelsLength = (0, _core_utils.log2)(Math.max(width, height)) + 1;
       this.levels = [];
+
       for (var i = 0; i < levelsLength; i++) {
         var level = {
-          width: width,
-          height: height,
+          width,
+          height,
           items: []
         };
         this.levels.push(level);
@@ -1353,23 +1625,28 @@ var JpxImage = function JpxImageClosure() {
         height = Math.ceil(height / 2);
       }
     }
+
     TagTree.prototype = {
       reset: function TagTree_reset(i, j) {
         var currentLevel = 0,
             value = 0,
             level;
+
         while (currentLevel < this.levels.length) {
           level = this.levels[currentLevel];
           var index = i + j * level.width;
+
           if (level.items[index] !== undefined) {
             value = level.items[index];
             break;
           }
+
           level.index = index;
           i >>= 1;
           j >>= 1;
           currentLevel++;
         }
+
         currentLevel--;
         level = this.levels[currentLevel];
         level.items[level.index] = value;
@@ -1385,10 +1662,12 @@ var JpxImage = function JpxImageClosure() {
         var level = this.levels[currentLevel];
         var value = level.items[level.index];
         currentLevel--;
+
         if (currentLevel < 0) {
           this.value = value;
           return false;
         }
+
         this.currentLevel = currentLevel;
         level = this.levels[currentLevel];
         level.items[level.index] = value;
@@ -1397,45 +1676,55 @@ var JpxImage = function JpxImageClosure() {
     };
     return TagTree;
   }();
+
   var InclusionTree = function InclusionTreeClosure() {
     function InclusionTree(width, height, defaultValue) {
-      var levelsLength = (0, _util.log2)(Math.max(width, height)) + 1;
+      var levelsLength = (0, _core_utils.log2)(Math.max(width, height)) + 1;
       this.levels = [];
+
       for (var i = 0; i < levelsLength; i++) {
         var items = new Uint8Array(width * height);
+
         for (var j = 0, jj = items.length; j < jj; j++) {
           items[j] = defaultValue;
         }
+
         var level = {
-          width: width,
-          height: height,
-          items: items
+          width,
+          height,
+          items
         };
         this.levels.push(level);
         width = Math.ceil(width / 2);
         height = Math.ceil(height / 2);
       }
     }
+
     InclusionTree.prototype = {
       reset: function InclusionTree_reset(i, j, stopValue) {
         var currentLevel = 0;
+
         while (currentLevel < this.levels.length) {
           var level = this.levels[currentLevel];
           var index = i + j * level.width;
           level.index = index;
           var value = level.items[index];
-          if (value === 0xFF) {
+
+          if (value === 0xff) {
             break;
           }
+
           if (value > stopValue) {
             this.currentLevel = currentLevel;
             this.propagateValues();
             return false;
           }
+
           i >>= 1;
           j >>= 1;
           currentLevel++;
         }
+
         this.currentLevel = currentLevel - 1;
         return true;
       },
@@ -1448,6 +1737,7 @@ var JpxImage = function JpxImageClosure() {
         var levelIndex = this.currentLevel;
         var level = this.levels[levelIndex];
         var currentValue = level.items[level.index];
+
         while (--levelIndex >= 0) {
           level = this.levels[levelIndex];
           level.items[level.index] = currentValue;
@@ -1457,11 +1747,13 @@ var JpxImage = function JpxImageClosure() {
         var currentLevel = this.currentLevel;
         var level = this.levels[currentLevel];
         var value = level.items[level.index];
-        level.items[level.index] = 0xFF;
+        level.items[level.index] = 0xff;
         currentLevel--;
+
         if (currentLevel < 0) {
           return false;
         }
+
         this.currentLevel = currentLevel;
         level = this.levels[currentLevel];
         level.items[level.index] = value;
@@ -1470,30 +1762,55 @@ var JpxImage = function JpxImageClosure() {
     };
     return InclusionTree;
   }();
+
   var BitModel = function BitModelClosure() {
     var UNIFORM_CONTEXT = 17;
     var RUNLENGTH_CONTEXT = 18;
     var LLAndLHContextsLabel = new Uint8Array([0, 5, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 1, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8]);
     var HLContextLabel = new Uint8Array([0, 3, 4, 0, 5, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 1, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8]);
     var HHContextLabel = new Uint8Array([0, 1, 2, 0, 1, 2, 2, 0, 2, 2, 2, 0, 0, 0, 0, 0, 3, 4, 5, 0, 4, 5, 5, 0, 5, 5, 5, 0, 0, 0, 0, 0, 6, 7, 7, 0, 7, 7, 7, 0, 7, 7, 7, 0, 0, 0, 0, 0, 8, 8, 8, 0, 8, 8, 8, 0, 8, 8, 8, 0, 0, 0, 0, 0, 8, 8, 8, 0, 8, 8, 8, 0, 8, 8, 8]);
+
     function BitModel(width, height, subband, zeroBitPlanes, mb) {
       this.width = width;
       this.height = height;
-      this.contextLabelTable = subband === 'HH' ? HHContextLabel : subband === 'HL' ? HLContextLabel : LLAndLHContextsLabel;
+      let contextLabelTable;
+
+      if (subband === "HH") {
+        contextLabelTable = HHContextLabel;
+      } else if (subband === "HL") {
+        contextLabelTable = HLContextLabel;
+      } else {
+        contextLabelTable = LLAndLHContextsLabel;
+      }
+
+      this.contextLabelTable = contextLabelTable;
       var coefficientCount = width * height;
       this.neighborsSignificance = new Uint8Array(coefficientCount);
       this.coefficentsSign = new Uint8Array(coefficientCount);
-      this.coefficentsMagnitude = mb > 14 ? new Uint32Array(coefficientCount) : mb > 6 ? new Uint16Array(coefficientCount) : new Uint8Array(coefficientCount);
+      let coefficentsMagnitude;
+
+      if (mb > 14) {
+        coefficentsMagnitude = new Uint32Array(coefficientCount);
+      } else if (mb > 6) {
+        coefficentsMagnitude = new Uint16Array(coefficientCount);
+      } else {
+        coefficentsMagnitude = new Uint8Array(coefficientCount);
+      }
+
+      this.coefficentsMagnitude = coefficentsMagnitude;
       this.processingFlags = new Uint8Array(coefficientCount);
       var bitsDecoded = new Uint8Array(coefficientCount);
+
       if (zeroBitPlanes !== 0) {
         for (var i = 0; i < coefficientCount; i++) {
           bitsDecoded[i] = zeroBitPlanes;
         }
       }
+
       this.bitsDecoded = bitsDecoded;
       this.reset();
     }
+
     BitModel.prototype = {
       setDecoder: function BitModel_setDecoder(decoder) {
         this.decoder = decoder;
@@ -1511,32 +1828,43 @@ var JpxImage = function JpxImageClosure() {
         var left = column > 0;
         var right = column + 1 < width;
         var i;
+
         if (row > 0) {
           i = index - width;
+
           if (left) {
             neighborsSignificance[i - 1] += 0x10;
           }
+
           if (right) {
             neighborsSignificance[i + 1] += 0x10;
           }
+
           neighborsSignificance[i] += 0x04;
         }
+
         if (row + 1 < height) {
           i = index + width;
+
           if (left) {
             neighborsSignificance[i - 1] += 0x10;
           }
+
           if (right) {
             neighborsSignificance[i + 1] += 0x10;
           }
+
           neighborsSignificance[i] += 0x04;
         }
+
         if (left) {
           neighborsSignificance[index - 1] += 0x01;
         }
+
         if (right) {
           neighborsSignificance[index + 1] += 0x01;
         }
+
         neighborsSignificance[index] |= 0x80;
       },
       runSignificancePropagationPass: function BitModel_runSignificancePropagationPass() {
@@ -1553,20 +1881,27 @@ var JpxImage = function JpxImageClosure() {
         var processedInverseMask = ~1;
         var processedMask = 1;
         var firstMagnitudeBitMask = 2;
+
         for (var i0 = 0; i0 < height; i0 += 4) {
           for (var j = 0; j < width; j++) {
             var index = i0 * width + j;
+
             for (var i1 = 0; i1 < 4; i1++, index += width) {
               var i = i0 + i1;
+
               if (i >= height) {
                 break;
               }
+
               processingFlags[index] &= processedInverseMask;
+
               if (coefficentsMagnitude[index] || !neighborsSignificance[index]) {
                 continue;
               }
+
               var contextLabel = labels[neighborsSignificance[index]];
               var decision = decoder.readBit(contexts, contextLabel);
+
               if (decision) {
                 var sign = this.decodeSignBit(i, j, index);
                 coefficentsSign[index] = sign;
@@ -1574,6 +1909,7 @@ var JpxImage = function JpxImageClosure() {
                 this.setNeighborsSignificance(i, j, index);
                 processingFlags[index] |= firstMagnitudeBitMask;
               }
+
               bitsDecoded[index]++;
               processingFlags[index] |= processedMask;
             }
@@ -1588,8 +1924,10 @@ var JpxImage = function JpxImageClosure() {
         var contribution, sign0, sign1, significance1;
         var contextLabel, decoded;
         significance1 = column > 0 && coefficentsMagnitude[index - 1] !== 0;
+
         if (column + 1 < width && coefficentsMagnitude[index + 1] !== 0) {
           sign1 = coefficentsSign[index + 1];
+
           if (significance1) {
             sign0 = coefficentsSign[index - 1];
             contribution = 1 - sign1 - sign0;
@@ -1602,10 +1940,13 @@ var JpxImage = function JpxImageClosure() {
         } else {
           contribution = 0;
         }
+
         var horizontalContribution = 3 * contribution;
         significance1 = row > 0 && coefficentsMagnitude[index - width] !== 0;
+
         if (row + 1 < height && coefficentsMagnitude[index + width] !== 0) {
           sign1 = coefficentsSign[index + width];
+
           if (significance1) {
             sign0 = coefficentsSign[index - width];
             contribution = 1 - sign1 - sign0 + horizontalContribution;
@@ -1618,6 +1959,7 @@ var JpxImage = function JpxImageClosure() {
         } else {
           contribution = horizontalContribution;
         }
+
         if (contribution >= 0) {
           contextLabel = 9 + contribution;
           decoded = this.decoder.readBit(this.contexts, contextLabel);
@@ -1625,6 +1967,7 @@ var JpxImage = function JpxImageClosure() {
           contextLabel = 9 - contribution;
           decoded = this.decoder.readBit(this.contexts, contextLabel) ^ 1;
         }
+
         return decoded;
       },
       runMagnitudeRefinementPass: function BitModel_runMagnitudeRefinementPass() {
@@ -1640,19 +1983,24 @@ var JpxImage = function JpxImageClosure() {
         var firstMagnitudeBitMask = 2;
         var length = width * height;
         var width4 = width * 4;
+
         for (var index0 = 0, indexNext; index0 < length; index0 = indexNext) {
           indexNext = Math.min(length, index0 + width4);
+
           for (var j = 0; j < width; j++) {
             for (var index = index0 + j; index < indexNext; index += width) {
               if (!coefficentsMagnitude[index] || (processingFlags[index] & processedMask) !== 0) {
                 continue;
               }
+
               var contextLabel = 16;
+
               if ((processingFlags[index] & firstMagnitudeBitMask) !== 0) {
                 processingFlags[index] ^= firstMagnitudeBitMask;
                 var significance = neighborsSignificance[index] & 127;
                 contextLabel = significance === 0 ? 15 : 14;
               }
+
               var bit = decoder.readBit(contexts, contextLabel);
               coefficentsMagnitude[index] = coefficentsMagnitude[index] << 1 | bit;
               bitsDecoded[index]++;
@@ -1678,10 +2026,12 @@ var JpxImage = function JpxImageClosure() {
         var twoRowsDown = width * 2;
         var threeRowsDown = width * 3;
         var iNext;
+
         for (var i0 = 0; i0 < height; i0 = iNext) {
           iNext = Math.min(i0 + 4, height);
           var indexBase = i0 * width;
           var checkAllEmpty = i0 + 3 < height;
+
           for (var j = 0; j < width; j++) {
             var index0 = indexBase + j;
             var allEmpty = checkAllEmpty && processingFlags[index0] === 0 && processingFlags[index0 + oneRowDown] === 0 && processingFlags[index0 + twoRowsDown] === 0 && processingFlags[index0 + threeRowsDown] === 0 && neighborsSignificance[index0] === 0 && neighborsSignificance[index0 + oneRowDown] === 0 && neighborsSignificance[index0 + twoRowsDown] === 0 && neighborsSignificance[index0 + threeRowsDown] === 0;
@@ -1689,8 +2039,10 @@ var JpxImage = function JpxImageClosure() {
                 index = index0;
             var i = i0,
                 sign;
+
             if (allEmpty) {
               var hasSignificantCoefficent = decoder.readBit(contexts, RUNLENGTH_CONTEXT);
+
               if (!hasSignificantCoefficent) {
                 bitsDecoded[index0]++;
                 bitsDecoded[index0 + oneRowDown]++;
@@ -1698,28 +2050,36 @@ var JpxImage = function JpxImageClosure() {
                 bitsDecoded[index0 + threeRowsDown]++;
                 continue;
               }
+
               i1 = decoder.readBit(contexts, UNIFORM_CONTEXT) << 1 | decoder.readBit(contexts, UNIFORM_CONTEXT);
+
               if (i1 !== 0) {
                 i = i0 + i1;
                 index += i1 * width;
               }
+
               sign = this.decodeSignBit(i, j, index);
               coefficentsSign[index] = sign;
               coefficentsMagnitude[index] = 1;
               this.setNeighborsSignificance(i, j, index);
               processingFlags[index] |= firstMagnitudeBitMask;
               index = index0;
+
               for (var i2 = i0; i2 <= i; i2++, index += width) {
                 bitsDecoded[index]++;
               }
+
               i1++;
             }
+
             for (i = i0 + i1; i < iNext; i++, index += width) {
               if (coefficentsMagnitude[index] || (processingFlags[index] & processedMask) !== 0) {
                 continue;
               }
+
               var contextLabel = labels[neighborsSignificance[index]];
               var decision = decoder.readBit(contexts, contextLabel);
+
               if (decision === 1) {
                 sign = this.decodeSignBit(i, j, index);
                 coefficentsSign[index] = sign;
@@ -1727,6 +2087,7 @@ var JpxImage = function JpxImageClosure() {
                 this.setNeighborsSignificance(i, j, index);
                 processingFlags[index] |= firstMagnitudeBitMask;
               }
+
               bitsDecoded[index]++;
             }
           }
@@ -1736,22 +2097,28 @@ var JpxImage = function JpxImageClosure() {
         var decoder = this.decoder;
         var contexts = this.contexts;
         var symbol = decoder.readBit(contexts, UNIFORM_CONTEXT) << 3 | decoder.readBit(contexts, UNIFORM_CONTEXT) << 2 | decoder.readBit(contexts, UNIFORM_CONTEXT) << 1 | decoder.readBit(contexts, UNIFORM_CONTEXT);
-        if (symbol !== 0xA) {
-          throw new JpxError('Invalid segmentation symbol');
+
+        if (symbol !== 0xa) {
+          throw new JpxError("Invalid segmentation symbol");
         }
       }
     };
     return BitModel;
   }();
+
   var Transform = function TransformClosure() {
     function Transform() {}
+
     Transform.prototype.calculate = function transformCalculate(subbands, u0, v0) {
       var ll = subbands[0];
+
       for (var i = 1, ii = subbands.length; i < ii; i++) {
         ll = this.iterate(ll, subbands[i], u0, v0);
       }
+
       return ll;
     };
+
     Transform.prototype.extend = function extend(buffer, offset, size) {
       var i1 = offset - 1,
           j1 = offset + 1;
@@ -1766,6 +2133,7 @@ var JpxImage = function JpxImageClosure() {
       buffer[i1] = buffer[j1];
       buffer[j2] = buffer[i2];
     };
+
     Transform.prototype.iterate = function Transform_iterate(ll, hl_lh_hh, u0, v0) {
       var llWidth = ll.width,
           llHeight = ll.height,
@@ -1774,15 +2142,19 @@ var JpxImage = function JpxImageClosure() {
       var height = hl_lh_hh.height;
       var items = hl_lh_hh.items;
       var i, j, k, l, u, v;
+
       for (k = 0, i = 0; i < llHeight; i++) {
         l = i * 2 * width;
+
         for (j = 0; j < llWidth; j++, k++, l += 2) {
           items[l] = llItems[k];
         }
       }
+
       llItems = ll.items = null;
       var bufferPadding = 4;
       var rowBuffer = new Float32Array(width + 2 * bufferPadding);
+
       if (width === 1) {
         if ((u0 & 1) !== 0) {
           for (v = 0, k = 0; v < height; v++, k += width) {
@@ -1797,14 +2169,18 @@ var JpxImage = function JpxImageClosure() {
           items.set(rowBuffer.subarray(bufferPadding, bufferPadding + width), k);
         }
       }
+
       var numBuffers = 16;
       var colBuffers = [];
+
       for (i = 0; i < numBuffers; i++) {
         colBuffers.push(new Float32Array(height + 2 * bufferPadding));
       }
+
       var b,
           currentBuffer = 0;
       ll = bufferPadding + height;
+
       if (height === 1) {
         if ((v0 & 1) !== 0) {
           for (u = 0; u < width; u++) {
@@ -1815,19 +2191,24 @@ var JpxImage = function JpxImageClosure() {
         for (u = 0; u < width; u++) {
           if (currentBuffer === 0) {
             numBuffers = Math.min(width - u, numBuffers);
+
             for (k = u, l = bufferPadding; l < ll; k += width, l++) {
               for (b = 0; b < numBuffers; b++) {
                 colBuffers[b][l] = items[k + b];
               }
             }
+
             currentBuffer = numBuffers;
           }
+
           currentBuffer--;
           var buffer = colBuffers[currentBuffer];
           this.extend(buffer, bufferPadding, height);
           this.filter(buffer, bufferPadding, height);
+
           if (currentBuffer === 0) {
             k = u - numBuffers + 1;
+
             for (l = bufferPadding; l < ll; k += width, l++) {
               for (b = 0; b < numBuffers; b++) {
                 items[k + b] = colBuffers[b][l];
@@ -1836,19 +2217,24 @@ var JpxImage = function JpxImageClosure() {
           }
         }
       }
+
       return {
-        width: width,
-        height: height,
-        items: items
+        width,
+        height,
+        items
       };
     };
+
     return Transform;
   }();
+
   var IrreversibleTransform = function IrreversibleTransformClosure() {
     function IrreversibleTransform() {
       Transform.call(this);
     }
+
     IrreversibleTransform.prototype = Object.create(Transform.prototype);
+
     IrreversibleTransform.prototype.filter = function irreversibleTransformFilter(x, offset, length) {
       var len = length >> 1;
       offset = offset | 0;
@@ -1860,14 +2246,18 @@ var JpxImage = function JpxImageClosure() {
       var K = 1.230174104914001;
       var K_ = 1 / K;
       j = offset - 3;
+
       for (n = len + 4; n--; j += 2) {
         x[j] *= K_;
       }
+
       j = offset - 2;
       current = delta * x[j - 1];
+
       for (n = len + 3; n--; j += 2) {
         next = delta * x[j + 1];
         x[j] = K * x[j] - current - next;
+
         if (n--) {
           j += 2;
           current = delta * x[j + 1];
@@ -1876,11 +2266,14 @@ var JpxImage = function JpxImageClosure() {
           break;
         }
       }
+
       j = offset - 1;
       current = gamma * x[j - 1];
+
       for (n = len + 2; n--; j += 2) {
         next = gamma * x[j + 1];
         x[j] -= current + next;
+
         if (n--) {
           j += 2;
           current = gamma * x[j + 1];
@@ -1889,11 +2282,14 @@ var JpxImage = function JpxImageClosure() {
           break;
         }
       }
+
       j = offset;
       current = beta * x[j - 1];
+
       for (n = len + 1; n--; j += 2) {
         next = beta * x[j + 1];
         x[j] -= current + next;
+
         if (n--) {
           j += 2;
           current = beta * x[j + 1];
@@ -1902,12 +2298,15 @@ var JpxImage = function JpxImageClosure() {
           break;
         }
       }
+
       if (len !== 0) {
         j = offset + 1;
         current = alpha * x[j - 1];
+
         for (n = len; n--; j += 2) {
           next = alpha * x[j + 1];
           x[j] -= current + next;
+
           if (n--) {
             j += 2;
             current = alpha * x[j + 1];
@@ -1918,26 +2317,35 @@ var JpxImage = function JpxImageClosure() {
         }
       }
     };
+
     return IrreversibleTransform;
   }();
+
   var ReversibleTransform = function ReversibleTransformClosure() {
     function ReversibleTransform() {
       Transform.call(this);
     }
+
     ReversibleTransform.prototype = Object.create(Transform.prototype);
+
     ReversibleTransform.prototype.filter = function reversibleTransformFilter(x, offset, length) {
       var len = length >> 1;
       offset = offset | 0;
       var j, n;
+
       for (j = offset, n = len + 1; n--; j += 2) {
         x[j] -= x[j - 1] + x[j + 1] + 2 >> 2;
       }
+
       for (j = offset + 1, n = len; n--; j += 2) {
         x[j] += x[j - 1] + x[j + 1] >> 1;
       }
     };
+
     return ReversibleTransform;
   }();
+
   return JpxImage;
 }();
+
 exports.JpxImage = JpxImage;