@stencil/core 2.17.4 → 2.18.1

package/screenshot/pixel-match.js

@@ -18,44 +18,78 @@ var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
 
 var pixelmatch_1 = pixelmatch;
 
+const defaultOptions = {
+    threshold: 0.1,         // matching threshold (0 to 1); smaller is more sensitive
+    includeAA: false,       // whether to skip anti-aliasing detection
+    alpha: 0.1,             // opacity of original image in diff output
+    aaColor: [255, 255, 0], // color of anti-aliased pixels in diff output
+    diffColor: [255, 0, 0], // color of different pixels in diff output
+    diffColorAlt: null,     // whether to detect dark on light differences between img1 and img2 and set an alternative color to differentiate between the two
+    diffMask: false         // draw the diff over a transparent background (a mask)
+};
+
 function pixelmatch(img1, img2, output, width, height, options) {
 
-    if (!options) options = {};
+    if (!isPixelData(img1) || !isPixelData(img2) || (output && !isPixelData(output)))
+        throw new Error('Image data: Uint8Array, Uint8ClampedArray or Buffer expected.');
+
+    if (img1.length !== img2.length || (output && output.length !== img1.length))
+        throw new Error('Image sizes do not match.');
+
+    if (img1.length !== width * height * 4) throw new Error('Image data size does not match width/height.');
 
-    var threshold = options.threshold === undefined ? 0.1 : options.threshold;
+    options = Object.assign({}, defaultOptions, options);
+
+    // check if images are identical
+    const len = width * height;
+    const a32 = new Uint32Array(img1.buffer, img1.byteOffset, len);
+    const b32 = new Uint32Array(img2.buffer, img2.byteOffset, len);
+    let identical = true;
+
+    for (let i = 0; i < len; i++) {
+        if (a32[i] !== b32[i]) { identical = false; break; }
+    }
+    if (identical) { // fast path if identical
+        if (output && !options.diffMask) {
+            for (let i = 0; i < len; i++) drawGrayPixel(img1, 4 * i, options.alpha, output);
+        }
+        return 0;
+    }
 
     // maximum acceptable square distance between two colors;
     // 35215 is the maximum possible value for the YIQ difference metric
-    var maxDelta = 35215 * threshold * threshold,
-        diff = 0;
+    const maxDelta = 35215 * options.threshold * options.threshold;
+    let diff = 0;
 
     // compare each pixel of one image against the other one
-    for (var y = 0; y < height; y++) {
-        for (var x = 0; x < width; x++) {
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
 
-            var pos = (y * width + x) * 4;
+            const pos = (y * width + x) * 4;
 
-            // squared YUV distance between colors at this pixel position
-            var delta = colorDelta(img1, img2, pos, pos);
+            // squared YUV distance between colors at this pixel position, negative if the img2 pixel is darker
+            const delta = colorDelta(img1, img2, pos, pos);
 
             // the color difference is above the threshold
-            if (delta > maxDelta) {
+            if (Math.abs(delta) > maxDelta) {
                 // check it's a real rendering difference or just anti-aliasing
                 if (!options.includeAA && (antialiased(img1, x, y, width, height, img2) ||
-                                   antialiased(img2, x, y, width, height, img1))) {
+                                           antialiased(img2, x, y, width, height, img1))) {
                     // one of the pixels is anti-aliasing; draw as yellow and do not count as difference
-                    if (output) drawPixel(output, pos, 255, 255, 0);
+                    // note that we do not include such pixels in a mask
+                    if (output && !options.diffMask) drawPixel(output, pos, ...options.aaColor);
 
                 } else {
-                    // found substantial difference not caused by anti-aliasing; draw it as red
-                    if (output) drawPixel(output, pos, 255, 0, 0);
+                    // found substantial difference not caused by anti-aliasing; draw it as such
+                    if (output) {
+                        drawPixel(output, pos, ...(delta < 0 && options.diffColorAlt || options.diffColor));
+                    }
                     diff++;
                 }
 
             } else if (output) {
                 // pixels are similar; draw background as grayscale image blended with white
-                var val = blend(grayPixel(img1, pos), 0.1);
-                drawPixel(output, pos, val, val, val);
+                if (!options.diffMask) drawGrayPixel(img1, pos, options.alpha, output);
             }
         }
     }
@@ -64,48 +98,47 @@ function pixelmatch(img1, img2, output, width, height, options) {
     return diff;
 }
 
+function isPixelData(arr) {
+    // work around instanceof Uint8Array not working properly in some Jest environments
+    return ArrayBuffer.isView(arr) && arr.constructor.BYTES_PER_ELEMENT === 1;
+}
+
 // check if a pixel is likely a part of anti-aliasing;
 // based on "Anti-aliased Pixel and Intensity Slope Detector" paper by V. Vysniauskas, 2009
 
 function antialiased(img, x1, y1, width, height, img2) {
-    var x0 = Math.max(x1 - 1, 0),
-        y0 = Math.max(y1 - 1, 0),
-        x2 = Math.min(x1 + 1, width - 1),
-        y2 = Math.min(y1 + 1, height - 1),
-        pos = (y1 * width + x1) * 4,
-        zeroes = 0,
-        positives = 0,
-        negatives = 0,
-        min = 0,
-        max = 0,
-        minX, minY, maxX, maxY;
+    const x0 = Math.max(x1 - 1, 0);
+    const y0 = Math.max(y1 - 1, 0);
+    const x2 = Math.min(x1 + 1, width - 1);
+    const y2 = Math.min(y1 + 1, height - 1);
+    const pos = (y1 * width + x1) * 4;
+    let zeroes = x1 === x0 || x1 === x2 || y1 === y0 || y1 === y2 ? 1 : 0;
+    let min = 0;
+    let max = 0;
+    let minX, minY, maxX, maxY;
 
     // go through 8 adjacent pixels
-    for (var x = x0; x <= x2; x++) {
-        for (var y = y0; y <= y2; y++) {
+    for (let x = x0; x <= x2; x++) {
+        for (let y = y0; y <= y2; y++) {
             if (x === x1 && y === y1) continue;
 
             // brightness delta between the center pixel and adjacent one
-            var delta = colorDelta(img, img, pos, (y * width + x) * 4, true);
+            const delta = colorDelta(img, img, pos, (y * width + x) * 4, true);
 
             // count the number of equal, darker and brighter adjacent pixels
-            if (delta === 0) zeroes++;
-            else if (delta < 0) negatives++;
-            else if (delta > 0) positives++;
-
-            // if found more than 2 equal siblings, it's definitely not anti-aliasing
-            if (zeroes > 2) return false;
-
-            if (!img2) continue;
+            if (delta === 0) {
+                zeroes++;
+                // if found more than 2 equal siblings, it's definitely not anti-aliasing
+                if (zeroes > 2) return false;
 
             // remember the darkest pixel
-            if (delta < min) {
+            } else if (delta < min) {
                 min = delta;
                 minX = x;
                 minY = y;
-            }
+
             // remember the brightest pixel
-            if (delta > max) {
+            } else if (delta > max) {
                 max = delta;
                 maxX = x;
                 maxY = y;
@@ -113,40 +146,85 @@ function antialiased(img, x1, y1, width, height, img2) {
         }
     }
 
-    if (!img2) return true;
-
     // if there are no both darker and brighter pixels among siblings, it's not anti-aliasing
-    if (negatives === 0 || positives === 0) return false;
+    if (min === 0 || max === 0) return false;
 
-    // if either the darkest or the brightest pixel has more than 2 equal siblings in both images
+    // if either the darkest or the brightest pixel has 3+ equal siblings in both images
     // (definitely not anti-aliased), this pixel is anti-aliased
-    return (!antialiased(img, minX, minY, width, height) && !antialiased(img2, minX, minY, width, height)) ||
-           (!antialiased(img, maxX, maxY, width, height) && !antialiased(img2, maxX, maxY, width, height));
+    return (hasManySiblings(img, minX, minY, width, height) && hasManySiblings(img2, minX, minY, width, height)) ||
+           (hasManySiblings(img, maxX, maxY, width, height) && hasManySiblings(img2, maxX, maxY, width, height));
+}
+
+// check if a pixel has 3+ adjacent pixels of the same color.
+function hasManySiblings(img, x1, y1, width, height) {
+    const x0 = Math.max(x1 - 1, 0);
+    const y0 = Math.max(y1 - 1, 0);
+    const x2 = Math.min(x1 + 1, width - 1);
+    const y2 = Math.min(y1 + 1, height - 1);
+    const pos = (y1 * width + x1) * 4;
+    let zeroes = x1 === x0 || x1 === x2 || y1 === y0 || y1 === y2 ? 1 : 0;
+
+    // go through 8 adjacent pixels
+    for (let x = x0; x <= x2; x++) {
+        for (let y = y0; y <= y2; y++) {
+            if (x === x1 && y === y1) continue;
+
+            const pos2 = (y * width + x) * 4;
+            if (img[pos] === img[pos2] &&
+                img[pos + 1] === img[pos2 + 1] &&
+                img[pos + 2] === img[pos2 + 2] &&
+                img[pos + 3] === img[pos2 + 3]) zeroes++;
+
+            if (zeroes > 2) return true;
+        }
+    }
+
+    return false;
 }
 
 // calculate color difference according to the paper "Measuring perceived color difference
 // using YIQ NTSC transmission color space in mobile applications" by Y. Kotsarenko and F. Ramos
 
 function colorDelta(img1, img2, k, m, yOnly) {
-    var a1 = img1[k + 3] / 255,
-        a2 = img2[m + 3] / 255,
-
-        r1 = blend(img1[k + 0], a1),
-        g1 = blend(img1[k + 1], a1),
-        b1 = blend(img1[k + 2], a1),
+    let r1 = img1[k + 0];
+    let g1 = img1[k + 1];
+    let b1 = img1[k + 2];
+    let a1 = img1[k + 3];
+
+    let r2 = img2[m + 0];
+    let g2 = img2[m + 1];
+    let b2 = img2[m + 2];
+    let a2 = img2[m + 3];
+
+    if (a1 === a2 && r1 === r2 && g1 === g2 && b1 === b2) return 0;
+
+    if (a1 < 255) {
+        a1 /= 255;
+        r1 = blend(r1, a1);
+        g1 = blend(g1, a1);
+        b1 = blend(b1, a1);
+    }
 
-        r2 = blend(img2[m + 0], a2),
-        g2 = blend(img2[m + 1], a2),
-        b2 = blend(img2[m + 2], a2),
+    if (a2 < 255) {
+        a2 /= 255;
+        r2 = blend(r2, a2);
+        g2 = blend(g2, a2);
+        b2 = blend(b2, a2);
+    }
 
-        y = rgb2y(r1, g1, b1) - rgb2y(r2, g2, b2);
+    const y1 = rgb2y(r1, g1, b1);
+    const y2 = rgb2y(r2, g2, b2);
+    const y = y1 - y2;
 
     if (yOnly) return y; // brightness difference only
 
-    var i = rgb2i(r1, g1, b1) - rgb2i(r2, g2, b2),
-        q = rgb2q(r1, g1, b1) - rgb2q(r2, g2, b2);
+    const i = rgb2i(r1, g1, b1) - rgb2i(r2, g2, b2);
+    const q = rgb2q(r1, g1, b1) - rgb2q(r2, g2, b2);
+
+    const delta = 0.5053 * y * y + 0.299 * i * i + 0.1957 * q * q;
 
-    return 0.5053 * y * y + 0.299 * i * i + 0.1957 * q * q;
+    // encode whether the pixel lightens or darkens in the sign
+    return y1 > y2 ? -delta : delta;
 }
 
 function rgb2y(r, g, b) { return r * 0.29889531 + g * 0.58662247 + b * 0.11448223; }
@@ -165,12 +243,12 @@ function drawPixel(output, pos, r, g, b) {
     output[pos + 3] = 255;
 }
 
-function grayPixel(img, i) {
-    var a = img[i + 3] / 255,
-        r = blend(img[i + 0], a),
-        g = blend(img[i + 1], a),
-        b = blend(img[i + 2], a);
-    return rgb2y(r, g, b);
+function drawGrayPixel(img, i, alpha, output) {
+    const r = img[i + 0];
+    const g = img[i + 1];
+    const b = img[i + 2];
+    const val = blend(rgb2y(r, g, b), alpha * img[i + 3] / 255);
+    drawPixel(output, i, val, val, val);
 }
 
 function createCommonjsModule(fn, basedir, module) {
@@ -192,9 +270,7 @@ var chunkstream = createCommonjsModule(function (module) {
 
 
 
-
-
-var ChunkStream = module.exports = function() {
+let ChunkStream = (module.exports = function () {
   Stream__default['default'].call(this);
 
   this._buffers = [];
@@ -203,45 +279,43 @@ var ChunkStream = module.exports = function() {
   this._reads = [];
   this._paused = false;
 
-  this._encoding = 'utf8';
+  this._encoding = "utf8";
   this.writable = true;
-};
+});
 util__default['default'].inherits(ChunkStream, Stream__default['default']);
 
-
-ChunkStream.prototype.read = function(length, callback) {
-
+ChunkStream.prototype.read = function (length, callback) {
   this._reads.push({
     length: Math.abs(length), // if length < 0 then at most this length
     allowLess: length < 0,
-    func: callback
+    func: callback,
   });
 
-  process.nextTick(function() {
-    this._process();
+  process.nextTick(
+    function () {
+      this._process();
 
-    // its paused and there is not enought data then ask for more
-    if (this._paused && this._reads.length > 0) {
-      this._paused = false;
+      // its paused and there is not enought data then ask for more
+      if (this._paused && this._reads && this._reads.length > 0) {
+        this._paused = false;
 
-      this.emit('drain');
-    }
-  }.bind(this));
+        this.emit("drain");
+      }
+    }.bind(this)
+  );
 };
 
-ChunkStream.prototype.write = function(data, encoding) {
-
+ChunkStream.prototype.write = function (data, encoding) {
   if (!this.writable) {
-    this.emit('error', new Error('Stream not writable'));
+    this.emit("error", new Error("Stream not writable"));
     return false;
   }
 
-  var dataBuffer;
+  let dataBuffer;
   if (Buffer.isBuffer(data)) {
     dataBuffer = data;
-  }
-  else {
-    dataBuffer = new Buffer(data, encoding || this._encoding);
+  } else {
+    dataBuffer = Buffer.from(data, encoding || this._encoding);
   }
 
   this._buffers.push(dataBuffer);
@@ -257,8 +331,7 @@ ChunkStream.prototype.write = function(data, encoding) {
   return this.writable && !this._paused;
 };
 
-ChunkStream.prototype.end = function(data, encoding) {
-
+ChunkStream.prototype.end = function (data, encoding) {
   if (data) {
     this.write(data, encoding);
   }
@@ -273,8 +346,7 @@ ChunkStream.prototype.end = function(data, encoding) {
   // enqueue or handle end
   if (this._buffers.length === 0) {
     this._end();
-  }
-  else {
+  } else {
     this._buffers.push(null);
     this._process();
   }
@@ -282,19 +354,15 @@ ChunkStream.prototype.end = function(data, encoding) {
 
 ChunkStream.prototype.destroySoon = ChunkStream.prototype.end;
 
-ChunkStream.prototype._end = function() {
-
+ChunkStream.prototype._end = function () {
   if (this._reads.length > 0) {
-    this.emit('error',
-      new Error('Unexpected end of input')
-    );
+    this.emit("error", new Error("Unexpected end of input"));
   }
 
   this.destroy();
 };
 
-ChunkStream.prototype.destroy = function() {
-
+ChunkStream.prototype.destroy = function () {
   if (!this._buffers) {
     return;
   }
@@ -303,26 +371,23 @@ ChunkStream.prototype.destroy = function() {
   this._reads = null;
   this._buffers = null;
 
-  this.emit('close');
+  this.emit("close");
 };
 
-ChunkStream.prototype._processReadAllowingLess = function(read) {
+ChunkStream.prototype._processReadAllowingLess = function (read) {
   // ok there is any data so that we can satisfy this request
   this._reads.shift(); // == read
 
   // first we need to peek into first buffer
-  var smallerBuf = this._buffers[0];
+  let smallerBuf = this._buffers[0];
 
   // ok there is more data than we need
   if (smallerBuf.length > read.length) {
-
     this._buffered -= read.length;
     this._buffers[0] = smallerBuf.slice(read.length);
 
     read.func.call(this, smallerBuf.slice(0, read.length));
-
-  }
-  else {
+  } else {
     // ok this is less than maximum length so use it all
     this._buffered -= smallerBuf.length;
     this._buffers.shift(); // == smallerBuf
@@ -331,18 +396,17 @@ ChunkStream.prototype._processReadAllowingLess = function(read) {
   }
 };
 
-ChunkStream.prototype._processRead = function(read) {
+ChunkStream.prototype._processRead = function (read) {
   this._reads.shift(); // == read
 
-  var pos = 0;
-  var count = 0;
-  var data = new Buffer(read.length);
+  let pos = 0;
+  let count = 0;
+  let data = Buffer.alloc(read.length);
 
   // create buffer for all data
   while (pos < read.length) {
-
-    var buf = this._buffers[count++];
-    var len = Math.min(buf.length, read.length - pos);
+    let buf = this._buffers[count++];
+    let len = Math.min(buf.length, read.length - pos);
 
     buf.copy(data, pos, 0, len);
     pos += len;
@@ -363,25 +427,20 @@ ChunkStream.prototype._processRead = function(read) {
   read.func.call(this, data);
 };
 
-ChunkStream.prototype._process = function() {
-
+ChunkStream.prototype._process = function () {
   try {
     // as long as there is any data and read requests
     while (this._buffered > 0 && this._reads && this._reads.length > 0) {
-
-      var read = this._reads[0];
+      let read = this._reads[0];
 
       // read any data (but no more than length)
       if (read.allowLess) {
         this._processReadAllowingLess(read);
-
-      }
-      else if (this._buffered >= read.length) {
+      } else if (this._buffered >= read.length) {
         // ok we can meet some expectations
 
         this._processRead(read);
-      }
-      else {
+      } else {
         // not enought data to satisfy first request in queue
         // so we need to wait for more
         break;
@@ -391,9 +450,8 @@ ChunkStream.prototype._process = function() {
     if (this._buffers && !this.writable) {
       this._end();
     }
-  }
-  catch (ex) {
-    this.emit('error', ex);
+  } catch (ex) {
+    this.emit("error", ex);
   }
 };
 });
@@ -409,61 +467,65 @@ ChunkStream.prototype._process = function() {
 // 6 5 6 5 6 5 6 5 6
 // 7 7 7 7 7 7 7 7 7
 
-
-var imagePasses = [
-  { // pass 1 - 1px
+let imagePasses = [
+  {
+    // pass 1 - 1px
     x: [0],
-    y: [0]
+    y: [0],
   },
-  { // pass 2 - 1px
+  {
+    // pass 2 - 1px
     x: [4],
-    y: [0]
+    y: [0],
   },
-  { // pass 3 - 2px
+  {
+    // pass 3 - 2px
     x: [0, 4],
-    y: [4]
+    y: [4],
   },
-  { // pass 4 - 4px
+  {
+    // pass 4 - 4px
     x: [2, 6],
-    y: [0, 4]
+    y: [0, 4],
   },
-  { // pass 5 - 8px
+  {
+    // pass 5 - 8px
     x: [0, 2, 4, 6],
-    y: [2, 6]
+    y: [2, 6],
   },
-  { // pass 6 - 16px
+  {
+    // pass 6 - 16px
     x: [1, 3, 5, 7],
-    y: [0, 2, 4, 6]
+    y: [0, 2, 4, 6],
   },
-  { // pass 7 - 32px
+  {
+    // pass 7 - 32px
     x: [0, 1, 2, 3, 4, 5, 6, 7],
-    y: [1, 3, 5, 7]
-  }
+    y: [1, 3, 5, 7],
+  },
 ];
 
-var getImagePasses = function(width, height) {
-  var images = [];
-  var xLeftOver = width % 8;
-  var yLeftOver = height % 8;
-  var xRepeats = (width - xLeftOver) / 8;
-  var yRepeats = (height - yLeftOver) / 8;
-  for (var i = 0; i < imagePasses.length; i++) {
-    var pass = imagePasses[i];
-    var passWidth = xRepeats * pass.x.length;
-    var passHeight = yRepeats * pass.y.length;
-    for (var j = 0; j < pass.x.length; j++) {
+var getImagePasses = function (width, height) {
+  let images = [];
+  let xLeftOver = width % 8;
+  let yLeftOver = height % 8;
+  let xRepeats = (width - xLeftOver) / 8;
+  let yRepeats = (height - yLeftOver) / 8;
+  for (let i = 0; i < imagePasses.length; i++) {
+    let pass = imagePasses[i];
+    let passWidth = xRepeats * pass.x.length;
+    let passHeight = yRepeats * pass.y.length;
+    for (let j = 0; j < pass.x.length; j++) {
       if (pass.x[j] < xLeftOver) {
         passWidth++;
-      }
-      else {
+      } else {
         break;
       }
     }
-    for (j = 0; j < pass.y.length; j++) {
+    for (let j = 0; j < pass.y.length; j++) {
       if (pass.y[j] < yLeftOver) {
         passHeight++;
-      }
-      else {
+      } else {
         break;
       }
     }
@@ -474,13 +536,17 @@ var getImagePasses = function(width, height) {
   return images;
 };
 
-var getInterlaceIterator = function(width) {
-  return function(x, y, pass) {
-    var outerXLeftOver = x % imagePasses[pass].x.length;
-    var outerX = (((x - outerXLeftOver) / imagePasses[pass].x.length) * 8) + imagePasses[pass].x[outerXLeftOver];
-    var outerYLeftOver = y % imagePasses[pass].y.length;
-    var outerY = (((y - outerYLeftOver) / imagePasses[pass].y.length) * 8) + imagePasses[pass].y[outerYLeftOver];
-    return (outerX * 4) + (outerY * width * 4);
+var getInterlaceIterator = function (width) {
+  return function (x, y, pass) {
+    let outerXLeftOver = x % imagePasses[pass].x.length;
+    let outerX =
+      ((x - outerXLeftOver) / imagePasses[pass].x.length) * 8 +
+      imagePasses[pass].x[outerXLeftOver];
+    let outerYLeftOver = y % imagePasses[pass].y.length;
+    let outerY =
+      ((y - outerYLeftOver) / imagePasses[pass].y.length) * 8 +
+      imagePasses[pass].y[outerYLeftOver];
+    return outerX * 4 + outerY * width * 4;
   };
 };
 
@@ -489,20 +555,19 @@ var interlace = {
 	getInterlaceIterator: getInterlaceIterator
 };
 
-var paethPredictor = function paethPredictor(left, above, upLeft) {
-
-  var paeth = left + above - upLeft;
-  var pLeft = Math.abs(paeth - left);
-  var pAbove = Math.abs(paeth - above);
-  var pUpLeft = Math.abs(paeth - upLeft);
-
-  if (pLeft <= pAbove && pLeft <= pUpLeft) {
-    return left;
-  }
-  if (pAbove <= pUpLeft) {
-    return above;
-  }
-  return upLeft;
+var paethPredictor = function paethPredictor(left, above, upLeft) {
+  let paeth = left + above - upLeft;
+  let pLeft = Math.abs(paeth - left);
+  let pAbove = Math.abs(paeth - above);
+  let pUpLeft = Math.abs(paeth - upLeft);
+
+  if (pLeft <= pAbove && pLeft <= pUpLeft) {
+    return left;
+  }
+  if (pAbove <= pUpLeft) {
+    return above;
+  }
+  return upLeft;
 };
 
 var filterParse = createCommonjsModule(function (module) {
@@ -511,20 +576,19 @@ var filterParse = createCommonjsModule(function (module) {
 
 
 function getByteWidth(width, bpp, depth) {
-  var byteWidth = width * bpp;
+  let byteWidth = width * bpp;
   if (depth !== 8) {
     byteWidth = Math.ceil(byteWidth / (8 / depth));
   }
   return byteWidth;
 }
 
-var Filter = module.exports = function(bitmapInfo, dependencies) {
-
-  var width = bitmapInfo.width;
-  var height = bitmapInfo.height;
-  var interlace$1 = bitmapInfo.interlace;
-  var bpp = bitmapInfo.bpp;
-  var depth = bitmapInfo.depth;
+let Filter = (module.exports = function (bitmapInfo, dependencies) {
+  let width = bitmapInfo.width;
+  let height = bitmapInfo.height;
+  let interlace$1 = bitmapInfo.interlace;
+  let bpp = bitmapInfo.bpp;
+  let depth = bitmapInfo.depth;
 
   this.read = dependencies.read;
   this.write = dependencies.write;
@@ -533,20 +597,19 @@ var Filter = module.exports = function(bitmapInfo, dependencies) {
   this._imageIndex = 0;
   this._images = [];
   if (interlace$1) {
-    var passes = interlace.getImagePasses(width, height);
-    for (var i = 0; i < passes.length; i++) {
+    let passes = interlace.getImagePasses(width, height);
+    for (let i = 0; i < passes.length; i++) {
       this._images.push({
         byteWidth: getByteWidth(passes[i].width, bpp, depth),
         height: passes[i].height,
-        lineIndex: 0
+        lineIndex: 0,
       });
     }
-  }
-  else {
+  } else {
     this._images.push({
       byteWidth: getByteWidth(width, bpp, depth),
       height: height,
-      lineIndex: 0
+      lineIndex: 0,
     });
   }
 
@@ -556,86 +619,96 @@ var Filter = module.exports = function(bitmapInfo, dependencies) {
   // a pixel rather than just a different byte part. However if we are sub byte, we ignore.
   if (depth === 8) {
     this._xComparison = bpp;
-  }
-  else if (depth === 16) {
+  } else if (depth === 16) {
     this._xComparison = bpp * 2;
-  }
-  else {
+  } else {
     this._xComparison = 1;
   }
-};
+});
 
-Filter.prototype.start = function() {
-  this.read(this._images[this._imageIndex].byteWidth + 1, this._reverseFilterLine.bind(this));
+Filter.prototype.start = function () {
+  this.read(
+    this._images[this._imageIndex].byteWidth + 1,
+    this._reverseFilterLine.bind(this)
+  );
 };
 
-Filter.prototype._unFilterType1 = function(rawData, unfilteredLine, byteWidth) {
-
-  var xComparison = this._xComparison;
-  var xBiggerThan = xComparison - 1;
+Filter.prototype._unFilterType1 = function (
+  rawData,
+  unfilteredLine,
+  byteWidth
+) {
+  let xComparison = this._xComparison;
+  let xBiggerThan = xComparison - 1;
 
-  for (var x = 0; x < byteWidth; x++) {
-    var rawByte = rawData[1 + x];
-    var f1Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
+  for (let x = 0; x < byteWidth; x++) {
+    let rawByte = rawData[1 + x];
+    let f1Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
     unfilteredLine[x] = rawByte + f1Left;
   }
 };
 
-Filter.prototype._unFilterType2 = function(rawData, unfilteredLine, byteWidth) {
+Filter.prototype._unFilterType2 = function (
+  rawData,
+  unfilteredLine,
+  byteWidth
+) {
+  let lastLine = this._lastLine;
 
-  var lastLine = this._lastLine;
-
-  for (var x = 0; x < byteWidth; x++) {
-    var rawByte = rawData[1 + x];
-    var f2Up = lastLine ? lastLine[x] : 0;
+  for (let x = 0; x < byteWidth; x++) {
+    let rawByte = rawData[1 + x];
+    let f2Up = lastLine ? lastLine[x] : 0;
     unfilteredLine[x] = rawByte + f2Up;
   }
 };
 
-Filter.prototype._unFilterType3 = function(rawData, unfilteredLine, byteWidth) {
-
-  var xComparison = this._xComparison;
-  var xBiggerThan = xComparison - 1;
-  var lastLine = this._lastLine;
+Filter.prototype._unFilterType3 = function (
+  rawData,
+  unfilteredLine,
+  byteWidth
+) {
+  let xComparison = this._xComparison;
+  let xBiggerThan = xComparison - 1;
+  let lastLine = this._lastLine;
 
-  for (var x = 0; x < byteWidth; x++) {
-    var rawByte = rawData[1 + x];
-    var f3Up = lastLine ? lastLine[x] : 0;
-    var f3Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
-    var f3Add = Math.floor((f3Left + f3Up) / 2);
+  for (let x = 0; x < byteWidth; x++) {
+    let rawByte = rawData[1 + x];
+    let f3Up = lastLine ? lastLine[x] : 0;
+    let f3Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
+    let f3Add = Math.floor((f3Left + f3Up) / 2);
     unfilteredLine[x] = rawByte + f3Add;
   }
 };
 
-Filter.prototype._unFilterType4 = function(rawData, unfilteredLine, byteWidth) {
-
-  var xComparison = this._xComparison;
-  var xBiggerThan = xComparison - 1;
-  var lastLine = this._lastLine;
+Filter.prototype._unFilterType4 = function (
+  rawData,
+  unfilteredLine,
+  byteWidth
+) {
+  let xComparison = this._xComparison;
+  let xBiggerThan = xComparison - 1;
+  let lastLine = this._lastLine;
 
-  for (var x = 0; x < byteWidth; x++) {
-    var rawByte = rawData[1 + x];
-    var f4Up = lastLine ? lastLine[x] : 0;
-    var f4Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
-    var f4UpLeft = x > xBiggerThan && lastLine ? lastLine[x - xComparison] : 0;
-    var f4Add = paethPredictor(f4Left, f4Up, f4UpLeft);
+  for (let x = 0; x < byteWidth; x++) {
+    let rawByte = rawData[1 + x];
+    let f4Up = lastLine ? lastLine[x] : 0;
+    let f4Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
+    let f4UpLeft = x > xBiggerThan && lastLine ? lastLine[x - xComparison] : 0;
+    let f4Add = paethPredictor(f4Left, f4Up, f4UpLeft);
     unfilteredLine[x] = rawByte + f4Add;
   }
 };
 
-Filter.prototype._reverseFilterLine = function(rawData) {
-
-  var filter = rawData[0];
-  var unfilteredLine;
-  var currentImage = this._images[this._imageIndex];
-  var byteWidth = currentImage.byteWidth;
+Filter.prototype._reverseFilterLine = function (rawData) {
+  let filter = rawData[0];
+  let unfilteredLine;
+  let currentImage = this._images[this._imageIndex];
+  let byteWidth = currentImage.byteWidth;
 
   if (filter === 0) {
     unfilteredLine = rawData.slice(1, byteWidth + 1);
-  }
-  else {
-
-    unfilteredLine = new Buffer(byteWidth);
+  } else {
+    unfilteredLine = Buffer.alloc(byteWidth);
 
     switch (filter) {
       case 1:
@@ -651,7 +724,7 @@ Filter.prototype._reverseFilterLine = function(rawData) {
         this._unFilterType4(rawData, unfilteredLine, byteWidth);
         break;
       default:
-        throw new Error('Unrecognised filter type - ' + filter);
+        throw new Error("Unrecognised filter type - " + filter);
     }
   }
 
@@ -662,16 +735,14 @@ Filter.prototype._reverseFilterLine = function(rawData) {
     this._lastLine = null;
     this._imageIndex++;
     currentImage = this._images[this._imageIndex];
-  }
-  else {
+  } else {
     this._lastLine = unfilteredLine;
   }
 
   if (currentImage) {
     // read, using the byte width that may be from the new current image
     this.read(currentImage.byteWidth + 1, this._reverseFilterLine.bind(this));
-  }
-  else {
+  } else {
     this._lastLine = null;
     this.complete();
   }
@@ -684,29 +755,27 @@ var filterParseAsync = createCommonjsModule(function (module) {
 
 
 
-
-var FilterAsync = module.exports = function(bitmapInfo) {
+let FilterAsync = (module.exports = function (bitmapInfo) {
   chunkstream.call(this);
 
-  var buffers = [];
-  var that = this;
+  let buffers = [];
+  let that = this;
   this._filter = new filterParse(bitmapInfo, {
     read: this.read.bind(this),
-    write: function(buffer) {
+    write: function (buffer) {
       buffers.push(buffer);
     },
-    complete: function() {
-      that.emit('complete', Buffer.concat(buffers));
-    }
+    complete: function () {
+      that.emit("complete", Buffer.concat(buffers));
+    },
   });
 
   this._filter.start();
-};
+});
 util__default['default'].inherits(FilterAsync, chunkstream);
 });
 
 var constants = {
-
   PNG_SIGNATURE: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a],
 
   TYPE_IHDR: 0x49484452,
@@ -731,52 +800,48 @@ var constants = {
     2: 3,
     3: 1,
     4: 2,
-    6: 4
+    6: 4,
   },
 
-  GAMMA_DIVISION: 100000
+  GAMMA_DIVISION: 100000,
 };
 
 var crc = createCommonjsModule(function (module) {
 
-var crcTable = [];
+let crcTable = [];
 
-(function() {
-  for (var i = 0; i < 256; i++) {
-    var currentCrc = i;
-    for (var j = 0; j < 8; j++) {
+(function () {
+  for (let i = 0; i < 256; i++) {
+    let currentCrc = i;
+    for (let j = 0; j < 8; j++) {
       if (currentCrc & 1) {
         currentCrc = 0xedb88320 ^ (currentCrc >>> 1);
-      }
-      else {
+      } else {
         currentCrc = currentCrc >>> 1;
       }
     }
     crcTable[i] = currentCrc;
   }
-}());
+})();
 
-var CrcCalculator = module.exports = function() {
+let CrcCalculator = (module.exports = function () {
   this._crc = -1;
-};
-
-CrcCalculator.prototype.write = function(data) {
+});
 
-  for (var i = 0; i < data.length; i++) {
+CrcCalculator.prototype.write = function (data) {
+  for (let i = 0; i < data.length; i++) {
     this._crc = crcTable[(this._crc ^ data[i]) & 0xff] ^ (this._crc >>> 8);
   }
   return true;
 };
 
-CrcCalculator.prototype.crc32 = function() {
+CrcCalculator.prototype.crc32 = function () {
   return this._crc ^ -1;
 };
 
-
-CrcCalculator.crc32 = function(buf) {
-
-  var crc = -1;
-  for (var i = 0; i < buf.length; i++) {
+CrcCalculator.crc32 = function (buf) {
+  let crc = -1;
+  for (let i = 0; i < buf.length; i++) {
     crc = crcTable[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
   }
   return crc ^ -1;
@@ -788,9 +853,7 @@ var parser = createCommonjsModule(function (module) {
 
 
 
-
-var Parser = module.exports = function(options, dependencies) {
-
+let Parser = (module.exports = function (options, dependencies) {
   this._options = options;
   options.checkCRC = options.checkCRC !== false;
 
@@ -820,83 +883,78 @@ var Parser = module.exports = function(options, dependencies) {
   this.inflateData = dependencies.inflateData;
   this.finished = dependencies.finished;
   this.simpleTransparency = dependencies.simpleTransparency;
-  this.headersFinished = dependencies.headersFinished || function() {};
-};
+  this.headersFinished = dependencies.headersFinished || function () {};
+});
 
-Parser.prototype.start = function() {
-  this.read(constants.PNG_SIGNATURE.length,
-    this._parseSignature.bind(this)
-  );
+Parser.prototype.start = function () {
+  this.read(constants.PNG_SIGNATURE.length, this._parseSignature.bind(this));
 };
 
-Parser.prototype._parseSignature = function(data) {
-
-  var signature = constants.PNG_SIGNATURE;
+Parser.prototype._parseSignature = function (data) {
+  let signature = constants.PNG_SIGNATURE;
 
-  for (var i = 0; i < signature.length; i++) {
+  for (let i = 0; i < signature.length; i++) {
     if (data[i] !== signature[i]) {
-      this.error(new Error('Invalid file signature'));
+      this.error(new Error("Invalid file signature"));
       return;
     }
   }
   this.read(8, this._parseChunkBegin.bind(this));
 };
 
-Parser.prototype._parseChunkBegin = function(data) {
-
+Parser.prototype._parseChunkBegin = function (data) {
   // chunk content length
-  var length = data.readUInt32BE(0);
+  let length = data.readUInt32BE(0);
 
   // chunk type
-  var type = data.readUInt32BE(4);
-  var name = '';
-  for (var i = 4; i < 8; i++) {
+  let type = data.readUInt32BE(4);
+  let name = "";
+  for (let i = 4; i < 8; i++) {
     name += String.fromCharCode(data[i]);
   }
 
   //console.log('chunk ', name, length);
 
   // chunk flags
-  var ancillary = Boolean(data[4] & 0x20); // or critical
+  let ancillary = Boolean(data[4] & 0x20); // or critical
   //    priv = Boolean(data[5] & 0x20), // or public
   //    safeToCopy = Boolean(data[7] & 0x20); // or unsafe
 
   if (!this._hasIHDR && type !== constants.TYPE_IHDR) {
-    this.error(new Error('Expected IHDR on beggining'));
+    this.error(new Error("Expected IHDR on beggining"));
     return;
   }
 
   this._crc = new crc();
-  this._crc.write(new Buffer(name));
+  this._crc.write(Buffer.from(name));
 
   if (this._chunks[type]) {
     return this._chunks[type](length);
   }
 
   if (!ancillary) {
-    this.error(new Error('Unsupported critical chunk type ' + name));
+    this.error(new Error("Unsupported critical chunk type " + name));
     return;
   }
 
   this.read(length + 4, this._skipChunk.bind(this));
 };
 
-Parser.prototype._skipChunk = function(/*data*/) {
+Parser.prototype._skipChunk = function (/*data*/) {
   this.read(8, this._parseChunkBegin.bind(this));
 };
 
-Parser.prototype._handleChunkEnd = function() {
+Parser.prototype._handleChunkEnd = function () {
   this.read(4, this._parseChunkEnd.bind(this));
 };
 
-Parser.prototype._parseChunkEnd = function(data) {
-
-  var fileCrc = data.readInt32BE(0);
-  var calcCrc = this._crc.crc32();
+Parser.prototype._parseChunkEnd = function (data) {
+  let fileCrc = data.readInt32BE(0);
+  let calcCrc = this._crc.crc32();
 
   // check CRC
   if (this._options.checkCRC && calcCrc !== fileCrc) {
-    this.error(new Error('Crc error - ' + fileCrc + ' - ' + calcCrc));
+    this.error(new Error("Crc error - " + fileCrc + " - " + calcCrc));
     return;
   }
 
@@ -905,50 +963,55 @@ Parser.prototype._parseChunkEnd = function(data) {
   }
 };
 
-Parser.prototype._handleIHDR = function(length) {
+Parser.prototype._handleIHDR = function (length) {
   this.read(length, this._parseIHDR.bind(this));
 };
-Parser.prototype._parseIHDR = function(data) {
-
+Parser.prototype._parseIHDR = function (data) {
   this._crc.write(data);
 
-  var width = data.readUInt32BE(0);
-  var height = data.readUInt32BE(4);
-  var depth = data[8];
-  var colorType = data[9]; // bits: 1 palette, 2 color, 4 alpha
-  var compr = data[10];
-  var filter = data[11];
-  var interlace = data[12];
+  let width = data.readUInt32BE(0);
+  let height = data.readUInt32BE(4);
+  let depth = data[8];
+  let colorType = data[9]; // bits: 1 palette, 2 color, 4 alpha
+  let compr = data[10];
+  let filter = data[11];
+  let interlace = data[12];
 
   // console.log('    width', width, 'height', height,
   //     'depth', depth, 'colorType', colorType,
   //     'compr', compr, 'filter', filter, 'interlace', interlace
   // );
 
-  if (depth !== 8 && depth !== 4 && depth !== 2 && depth !== 1 && depth !== 16) {
-    this.error(new Error('Unsupported bit depth ' + depth));
+  if (
+    depth !== 8 &&
+    depth !== 4 &&
+    depth !== 2 &&
+    depth !== 1 &&
+    depth !== 16
+  ) {
+    this.error(new Error("Unsupported bit depth " + depth));
     return;
   }
   if (!(colorType in constants.COLORTYPE_TO_BPP_MAP)) {
-    this.error(new Error('Unsupported color type'));
+    this.error(new Error("Unsupported color type"));
     return;
   }
   if (compr !== 0) {
-    this.error(new Error('Unsupported compression method'));
+    this.error(new Error("Unsupported compression method"));
     return;
   }
   if (filter !== 0) {
-    this.error(new Error('Unsupported filter method'));
+    this.error(new Error("Unsupported filter method"));
     return;
   }
   if (interlace !== 0 && interlace !== 1) {
-    this.error(new Error('Unsupported interlace method'));
+    this.error(new Error("Unsupported interlace method"));
     return;
   }
 
   this._colorType = colorType;
 
-  var bpp = constants.COLORTYPE_TO_BPP_MAP[this._colorType];
+  let bpp = constants.COLORTYPE_TO_BPP_MAP[this._colorType];
 
   this._hasIHDR = true;
 
@@ -961,30 +1024,23 @@ Parser.prototype._parseIHDR = function(data) {
     color: Boolean(colorType & constants.COLORTYPE_COLOR),
     alpha: Boolean(colorType & constants.COLORTYPE_ALPHA),
     bpp: bpp,
-    colorType: colorType
+    colorType: colorType,
   });
 
   this._handleChunkEnd();
 };
 
-
-Parser.prototype._handlePLTE = function(length) {
+Parser.prototype._handlePLTE = function (length) {
   this.read(length, this._parsePLTE.bind(this));
 };
-Parser.prototype._parsePLTE = function(data) {
-
+Parser.prototype._parsePLTE = function (data) {
   this._crc.write(data);
 
-  var entries = Math.floor(data.length / 3);
+  let entries = Math.floor(data.length / 3);
   // console.log('Palette:', entries);
 
-  for (var i = 0; i < entries; i++) {
-    this._palette.push([
-      data[i * 3],
-      data[i * 3 + 1],
-      data[i * 3 + 2],
-      0xff
-    ]);
+  for (let i = 0; i < entries; i++) {
+    this._palette.push([data[i * 3], data[i * 3 + 1], data[i * 3 + 2], 0xff]);
   }
 
   this.palette(this._palette);
@@ -992,25 +1048,24 @@ Parser.prototype._parsePLTE = function(data) {
   this._handleChunkEnd();
 };
 
-Parser.prototype._handleTRNS = function(length) {
+Parser.prototype._handleTRNS = function (length) {
   this.simpleTransparency();
   this.read(length, this._parseTRNS.bind(this));
 };
-Parser.prototype._parseTRNS = function(data) {
-
+Parser.prototype._parseTRNS = function (data) {
   this._crc.write(data);
 
   // palette
   if (this._colorType === constants.COLORTYPE_PALETTE_COLOR) {
     if (this._palette.length === 0) {
-      this.error(new Error('Transparency chunk must be after palette'));
+      this.error(new Error("Transparency chunk must be after palette"));
       return;
     }
     if (data.length > this._palette.length) {
-      this.error(new Error('More transparent colors than palette size'));
+      this.error(new Error("More transparent colors than palette size"));
       return;
     }
-    for (var i = 0; i < data.length; i++) {
+    for (let i = 0; i < data.length; i++) {
       this._palette[i][3] = data[i];
     }
     this.palette(this._palette);
@@ -1023,54 +1078,57 @@ Parser.prototype._parseTRNS = function(data) {
     this.transColor([data.readUInt16BE(0)]);
   }
   if (this._colorType === constants.COLORTYPE_COLOR) {
-    this.transColor([data.readUInt16BE(0), data.readUInt16BE(2), data.readUInt16BE(4)]);
+    this.transColor([
+      data.readUInt16BE(0),
+      data.readUInt16BE(2),
+      data.readUInt16BE(4),
+    ]);
   }
 
   this._handleChunkEnd();
 };
 
-Parser.prototype._handleGAMA = function(length) {
+Parser.prototype._handleGAMA = function (length) {
   this.read(length, this._parseGAMA.bind(this));
 };
-Parser.prototype._parseGAMA = function(data) {
-
+Parser.prototype._parseGAMA = function (data) {
   this._crc.write(data);
   this.gamma(data.readUInt32BE(0) / constants.GAMMA_DIVISION);
 
   this._handleChunkEnd();
 };
 
-Parser.prototype._handleIDAT = function(length) {
+Parser.prototype._handleIDAT = function (length) {
   if (!this._emittedHeadersFinished) {
     this._emittedHeadersFinished = true;
     this.headersFinished();
   }
   this.read(-length, this._parseIDAT.bind(this, length));
 };
-Parser.prototype._parseIDAT = function(length, data) {
-
+Parser.prototype._parseIDAT = function (length, data) {
   this._crc.write(data);
 
-  if (this._colorType === constants.COLORTYPE_PALETTE_COLOR && this._palette.length === 0) {
-    throw new Error('Expected palette not found');
+  if (
+    this._colorType === constants.COLORTYPE_PALETTE_COLOR &&
+    this._palette.length === 0
+  ) {
+    throw new Error("Expected palette not found");
   }
 
   this.inflateData(data);
-  var leftOverLength = length - data.length;
+  let leftOverLength = length - data.length;
 
   if (leftOverLength > 0) {
     this._handleIDAT(leftOverLength);
-  }
-  else {
+  } else {
     this._handleChunkEnd();
   }
 };
 
-Parser.prototype._handleIEND = function(length) {
+Parser.prototype._handleIEND = function (length) {
   this.read(length, this._parseIEND.bind(this));
 };
-Parser.prototype._parseIEND = function(data) {
-
+Parser.prototype._parseIEND = function (data) {
   this._crc.write(data);
 
   this._hasIEND = true;
@@ -1082,18 +1140,18 @@ Parser.prototype._parseIEND = function(data) {
 };
 });
 
-var pixelBppMapper = [
+let pixelBppMapper = [
   // 0 - dummy entry
-  function() {},
+  function () {},
 
   // 1 - L
   // 0: 0, 1: 0, 2: 0, 3: 0xff
-  function(pxData, data, pxPos, rawPos) {
+  function (pxData, data, pxPos, rawPos) {
     if (rawPos === data.length) {
-      throw new Error('Ran out of data');
+      throw new Error("Ran out of data");
     }
 
-    var pixel = data[rawPos];
+    let pixel = data[rawPos];
     pxData[pxPos] = pixel;
     pxData[pxPos + 1] = pixel;
     pxData[pxPos + 2] = pixel;
@@ -1102,12 +1160,12 @@ var pixelBppMapper = [
 
   // 2 - LA
   // 0: 0, 1: 0, 2: 0, 3: 1
-  function(pxData, data, pxPos, rawPos) {
+  function (pxData, data, pxPos, rawPos) {
     if (rawPos + 1 >= data.length) {
-      throw new Error('Ran out of data');
+      throw new Error("Ran out of data");
     }
 
-    var pixel = data[rawPos];
+    let pixel = data[rawPos];
     pxData[pxPos] = pixel;
     pxData[pxPos + 1] = pixel;
     pxData[pxPos + 2] = pixel;
@@ -1116,9 +1174,9 @@ var pixelBppMapper = [
 
   // 3 - RGB
   // 0: 0, 1: 1, 2: 2, 3: 0xff
-  function(pxData, data, pxPos, rawPos) {
+  function (pxData, data, pxPos, rawPos) {
     if (rawPos + 2 >= data.length) {
-      throw new Error('Ran out of data');
+      throw new Error("Ran out of data");
     }
 
     pxData[pxPos] = data[rawPos];
@@ -1129,26 +1187,26 @@ var pixelBppMapper = [
 
   // 4 - RGBA
   // 0: 0, 1: 1, 2: 2, 3: 3
-  function(pxData, data, pxPos, rawPos) {
+  function (pxData, data, pxPos, rawPos) {
     if (rawPos + 3 >= data.length) {
-      throw new Error('Ran out of data');
+      throw new Error("Ran out of data");
     }
 
     pxData[pxPos] = data[rawPos];
     pxData[pxPos + 1] = data[rawPos + 1];
     pxData[pxPos + 2] = data[rawPos + 2];
     pxData[pxPos + 3] = data[rawPos + 3];
-  }
+  },
 ];
 
-var pixelBppCustomMapper = [
+let pixelBppCustomMapper = [
   // 0 - dummy entry
-  function() {},
+  function () {},
 
   // 1 - L
   // 0: 0, 1: 0, 2: 0, 3: 0xff
-  function(pxData, pixelData, pxPos, maxBit) {
-    var pixel = pixelData[0];
+  function (pxData, pixelData, pxPos, maxBit) {
+    let pixel = pixelData[0];
     pxData[pxPos] = pixel;
     pxData[pxPos + 1] = pixel;
     pxData[pxPos + 2] = pixel;
@@ -1157,8 +1215,8 @@ var pixelBppCustomMapper = [
 
   // 2 - LA
   // 0: 0, 1: 0, 2: 0, 3: 1
-  function(pxData, pixelData, pxPos) {
-    var pixel = pixelData[0];
+  function (pxData, pixelData, pxPos) {
+    let pixel = pixelData[0];
     pxData[pxPos] = pixel;
     pxData[pxPos + 1] = pixel;
     pxData[pxPos + 2] = pixel;
@@ -1167,7 +1225,7 @@ var pixelBppCustomMapper = [
 
   // 3 - RGB
   // 0: 0, 1: 1, 2: 2, 3: 0xff
-  function(pxData, pixelData, pxPos, maxBit) {
+  function (pxData, pixelData, pxPos, maxBit) {
     pxData[pxPos] = pixelData[0];
     pxData[pxPos + 1] = pixelData[1];
     pxData[pxPos + 2] = pixelData[2];
@@ -1176,33 +1234,32 @@ var pixelBppCustomMapper = [
 
   // 4 - RGBA
   // 0: 0, 1: 1, 2: 2, 3: 3
-  function(pxData, pixelData, pxPos) {
+  function (pxData, pixelData, pxPos) {
     pxData[pxPos] = pixelData[0];
     pxData[pxPos + 1] = pixelData[1];
     pxData[pxPos + 2] = pixelData[2];
     pxData[pxPos + 3] = pixelData[3];
-  }
+  },
 ];
 
 function bitRetriever(data, depth) {
-
-  var leftOver = [];
-  var i = 0;
+  let leftOver = [];
+  let i = 0;
 
   function split() {
     if (i === data.length) {
-      throw new Error('Ran out of data');
+      throw new Error("Ran out of data");
     }
-    var byte = data[i];
+    let byte = data[i];
     i++;
-    var byte8, byte7, byte6, byte5, byte4, byte3, byte2, byte1;
+    let byte8, byte7, byte6, byte5, byte4, byte3, byte2, byte1;
     switch (depth) {
       default:
-        throw new Error('unrecognised depth');
+        throw new Error("unrecognised depth");
       case 16:
         byte2 = data[i];
         i++;
-        leftOver.push(((byte << 8) + byte2));
+        leftOver.push((byte << 8) + byte2);
         break;
       case 4:
         byte2 = byte & 0x0f;
@@ -1211,52 +1268,53 @@ function bitRetriever(data, depth) {
         break;
       case 2:
         byte4 = byte & 3;
-        byte3 = byte >> 2 & 3;
-        byte2 = byte >> 4 & 3;
-        byte1 = byte >> 6 & 3;
+        byte3 = (byte >> 2) & 3;
+        byte2 = (byte >> 4) & 3;
+        byte1 = (byte >> 6) & 3;
         leftOver.push(byte1, byte2, byte3, byte4);
         break;
       case 1:
         byte8 = byte & 1;
-        byte7 = byte >> 1 & 1;
-        byte6 = byte >> 2 & 1;
-        byte5 = byte >> 3 & 1;
-        byte4 = byte >> 4 & 1;
-        byte3 = byte >> 5 & 1;
-        byte2 = byte >> 6 & 1;
-        byte1 = byte >> 7 & 1;
+        byte7 = (byte >> 1) & 1;
+        byte6 = (byte >> 2) & 1;
+        byte5 = (byte >> 3) & 1;
+        byte4 = (byte >> 4) & 1;
+        byte3 = (byte >> 5) & 1;
+        byte2 = (byte >> 6) & 1;
+        byte1 = (byte >> 7) & 1;
         leftOver.push(byte1, byte2, byte3, byte4, byte5, byte6, byte7, byte8);
         break;
     }
   }
 
   return {
-    get: function(count) {
+    get: function (count) {
       while (leftOver.length < count) {
         split();
       }
-      var returner = leftOver.slice(0, count);
+      let returner = leftOver.slice(0, count);
       leftOver = leftOver.slice(count);
       return returner;
     },
-    resetAfterLine: function() {
+    resetAfterLine: function () {
       leftOver.length = 0;
     },
-    end: function() {
+    end: function () {
       if (i !== data.length) {
-        throw new Error('extra data found');
+        throw new Error("extra data found");
       }
-    }
+    },
   };
 }
 
-function mapImage8Bit(image, pxData, getPxPos, bpp, data, rawPos) { // eslint-disable-line max-params
-  var imageWidth = image.width;
-  var imageHeight = image.height;
-  var imagePass = image.index;
-  for (var y = 0; y < imageHeight; y++) {
-    for (var x = 0; x < imageWidth; x++) {
-      var pxPos = getPxPos(x, y, imagePass);
+function mapImage8Bit(image, pxData, getPxPos, bpp, data, rawPos) {
+  // eslint-disable-line max-params
+  let imageWidth = image.width;
+  let imageHeight = image.height;
+  let imagePass = image.index;
+  for (let y = 0; y < imageHeight; y++) {
+    for (let x = 0; x < imageWidth; x++) {
+      let pxPos = getPxPos(x, y, imagePass);
       pixelBppMapper[bpp](pxData, data, pxPos, rawPos);
       rawPos += bpp; //eslint-disable-line no-param-reassign
     }
@@ -1264,71 +1322,82 @@ function mapImage8Bit(image, pxData, getPxPos, bpp, data, rawPos) { // eslint-di
   return rawPos;
 }
 
-function mapImageCustomBit(image, pxData, getPxPos, bpp, bits, maxBit) { // eslint-disable-line max-params
-  var imageWidth = image.width;
-  var imageHeight = image.height;
-  var imagePass = image.index;
-  for (var y = 0; y < imageHeight; y++) {
-    for (var x = 0; x < imageWidth; x++) {
-      var pixelData = bits.get(bpp);
-      var pxPos = getPxPos(x, y, imagePass);
+function mapImageCustomBit(image, pxData, getPxPos, bpp, bits, maxBit) {
+  // eslint-disable-line max-params
+  let imageWidth = image.width;
+  let imageHeight = image.height;
+  let imagePass = image.index;
+  for (let y = 0; y < imageHeight; y++) {
+    for (let x = 0; x < imageWidth; x++) {
+      let pixelData = bits.get(bpp);
+      let pxPos = getPxPos(x, y, imagePass);
       pixelBppCustomMapper[bpp](pxData, pixelData, pxPos, maxBit);
     }
     bits.resetAfterLine();
   }
 }
 
-var dataToBitMap = function(data, bitmapInfo) {
-
-  var width = bitmapInfo.width;
-  var height = bitmapInfo.height;
-  var depth = bitmapInfo.depth;
-  var bpp = bitmapInfo.bpp;
-  var interlace$1 = bitmapInfo.interlace;
+var dataToBitMap = function (data, bitmapInfo) {
+  let width = bitmapInfo.width;
+  let height = bitmapInfo.height;
+  let depth = bitmapInfo.depth;
+  let bpp = bitmapInfo.bpp;
+  let interlace$1 = bitmapInfo.interlace;
+  let bits;
 
   if (depth !== 8) {
-    var bits = bitRetriever(data, depth);
+    bits = bitRetriever(data, depth);
   }
-  var pxData;
+  let pxData;
   if (depth <= 8) {
-    pxData = new Buffer(width * height * 4);
-  }
-  else {
+    pxData = Buffer.alloc(width * height * 4);
+  } else {
     pxData = new Uint16Array(width * height * 4);
   }
-  var maxBit = Math.pow(2, depth) - 1;
-  var rawPos = 0;
-  var images;
-  var getPxPos;
+  let maxBit = Math.pow(2, depth) - 1;
+  let rawPos = 0;
+  let images;
+  let getPxPos;
 
   if (interlace$1) {
     images = interlace.getImagePasses(width, height);
     getPxPos = interlace.getInterlaceIterator(width, height);
-  }
-  else {
-    var nonInterlacedPxPos = 0;
-    getPxPos = function() {
-      var returner = nonInterlacedPxPos;
+  } else {
+    let nonInterlacedPxPos = 0;
+    getPxPos = function () {
+      let returner = nonInterlacedPxPos;
       nonInterlacedPxPos += 4;
       return returner;
     };
     images = [{ width: width, height: height }];
   }
 
-  for (var imageIndex = 0; imageIndex < images.length; imageIndex++) {
+  for (let imageIndex = 0; imageIndex < images.length; imageIndex++) {
     if (depth === 8) {
-      rawPos = mapImage8Bit(images[imageIndex], pxData, getPxPos, bpp, data, rawPos);
-    }
-    else {
-      mapImageCustomBit(images[imageIndex], pxData, getPxPos, bpp, bits, maxBit);
+      rawPos = mapImage8Bit(
+        images[imageIndex],
+        pxData,
+        getPxPos,
+        bpp,
+        data,
+        rawPos
+      );
+    } else {
+      mapImageCustomBit(
+        images[imageIndex],
+        pxData,
+        getPxPos,
+        bpp,
+        bits,
+        maxBit
+      );
     }
   }
   if (depth === 8) {
     if (rawPos !== data.length) {
-      throw new Error('extra data found');
+      throw new Error("extra data found");
     }
-  }
-  else {
+  } else {
     bits.end();
   }
 
@@ -1340,17 +1409,17 @@ var bitmapper = {
 };
 
 function dePalette(indata, outdata, width, height, palette) {
-  var pxPos = 0;
+  let pxPos = 0;
   // use values from palette
-  for (var y = 0; y < height; y++) {
-    for (var x = 0; x < width; x++) {
-      var color = palette[indata[pxPos]];
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      let color = palette[indata[pxPos]];
 
       if (!color) {
-        throw new Error('index ' + indata[pxPos] + ' not in palette');
+        throw new Error("index " + indata[pxPos] + " not in palette");
       }
 
-      for (var i = 0; i < 4; i++) {
+      for (let i = 0; i < 4; i++) {
         outdata[pxPos + i] = color[i];
       }
       pxPos += 4;
@@ -1359,21 +1428,24 @@ function dePalette(indata, outdata, width, height, palette) {
 }
 
 function replaceTransparentColor(indata, outdata, width, height, transColor) {
-  var pxPos = 0;
-  for (var y = 0; y < height; y++) {
-    for (var x = 0; x < width; x++) {
-      var makeTrans = false;
+  let pxPos = 0;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      let makeTrans = false;
 
       if (transColor.length === 1) {
         if (transColor[0] === indata[pxPos]) {
           makeTrans = true;
         }
-      }
-      else if (transColor[0] === indata[pxPos] && transColor[1] === indata[pxPos + 1] && transColor[2] === indata[pxPos + 2]) {
+      } else if (
+        transColor[0] === indata[pxPos] &&
+        transColor[1] === indata[pxPos + 1] &&
+        transColor[2] === indata[pxPos + 2]
+      ) {
         makeTrans = true;
       }
       if (makeTrans) {
-        for (var i = 0; i < 4; i++) {
+        for (let i = 0; i < 4; i++) {
           outdata[pxPos + i] = 0;
         }
       }
@@ -1383,43 +1455,44 @@ function replaceTransparentColor(indata, outdata, width, height, transColor) {
 }
 
 function scaleDepth(indata, outdata, width, height, depth) {
-  var maxOutSample = 255;
-  var maxInSample = Math.pow(2, depth) - 1;
-  var pxPos = 0;
-
-  for (var y = 0; y < height; y++) {
-    for (var x = 0; x < width; x++) {
-      for (var i = 0; i < 4; i++) {
-        outdata[pxPos + i] = Math.floor((indata[pxPos + i] * maxOutSample) / maxInSample + 0.5);
+  let maxOutSample = 255;
+  let maxInSample = Math.pow(2, depth) - 1;
+  let pxPos = 0;
+
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      for (let i = 0; i < 4; i++) {
+        outdata[pxPos + i] = Math.floor(
+          (indata[pxPos + i] * maxOutSample) / maxInSample + 0.5
+        );
       }
       pxPos += 4;
     }
   }
 }
 
-var formatNormaliser = function(indata, imageData) {
-
-  var depth = imageData.depth;
-  var width = imageData.width;
-  var height = imageData.height;
-  var colorType = imageData.colorType;
-  var transColor = imageData.transColor;
-  var palette = imageData.palette;
+var formatNormaliser = function (indata, imageData, skipRescale = false) {
+  let depth = imageData.depth;
+  let width = imageData.width;
+  let height = imageData.height;
+  let colorType = imageData.colorType;
+  let transColor = imageData.transColor;
+  let palette = imageData.palette;
 
-  var outdata = indata; // only different for 16 bits
+  let outdata = indata; // only different for 16 bits
 
-  if (colorType === 3) { // paletted
+  if (colorType === 3) {
+    // paletted
     dePalette(indata, outdata, width, height, palette);
-  }
-  else {
+  } else {
     if (transColor) {
       replaceTransparentColor(indata, outdata, width, height, transColor);
     }
     // if it needs scaling
-    if (depth !== 8) {
+    if (depth !== 8 && !skipRescale) {
       // if we need to change the buffer size
       if (depth === 16) {
-        outdata = new Buffer(width * height * 4);
+        outdata = Buffer.alloc(width * height * 4);
       }
       scaleDepth(indata, outdata, width, height, depth);
     }
@@ -1437,32 +1510,30 @@ var parserAsync = createCommonjsModule(function (module) {
 
 
 
-var ParserAsync = module.exports = function(options) {
+let ParserAsync = (module.exports = function (options) {
   chunkstream.call(this);
 
   this._parser = new parser(options, {
     read: this.read.bind(this),
     error: this._handleError.bind(this),
     metadata: this._handleMetaData.bind(this),
-    gamma: this.emit.bind(this, 'gamma'),
+    gamma: this.emit.bind(this, "gamma"),
     palette: this._handlePalette.bind(this),
     transColor: this._handleTransColor.bind(this),
     finished: this._finished.bind(this),
     inflateData: this._inflateData.bind(this),
     simpleTransparency: this._simpleTransparency.bind(this),
-    headersFinished: this._headersFinished.bind(this)
+    headersFinished: this._headersFinished.bind(this),
   });
   this._options = options;
   this.writable = true;
 
   this._parser.start();
-};
+});
 util__default['default'].inherits(ParserAsync, chunkstream);
 
-
-ParserAsync.prototype._handleError = function(err) {
-
-  this.emit('error', err);
+ParserAsync.prototype._handleError = function (err) {
+  this.emit("error", err);
 
   this.writable = false;
 
@@ -1477,42 +1548,47 @@ ParserAsync.prototype._handleError = function(err) {
     // For backward compatibility with Node 7 and below.
     // Suppress errors due to _inflate calling write() even after
     // it's destroy()'ed.
-    this._filter.on('error', function() {});
+    this._filter.on("error", function () {});
   }
 
   this.errord = true;
 };
 
-ParserAsync.prototype._inflateData = function(data) {
+ParserAsync.prototype._inflateData = function (data) {
   if (!this._inflate) {
     if (this._bitmapInfo.interlace) {
       this._inflate = zlib__default['default'].createInflate();
 
-      this._inflate.on('error', this.emit.bind(this, 'error'));
-      this._filter.on('complete', this._complete.bind(this));
+      this._inflate.on("error", this.emit.bind(this, "error"));
+      this._filter.on("complete", this._complete.bind(this));
 
       this._inflate.pipe(this._filter);
-    }
-    else {
-      var rowSize = ((this._bitmapInfo.width * this._bitmapInfo.bpp * this._bitmapInfo.depth + 7) >> 3) + 1;
-      var imageSize = rowSize * this._bitmapInfo.height;
-      var chunkSize = Math.max(imageSize, zlib__default['default'].Z_MIN_CHUNK);
+    } else {
+      let rowSize =
+        ((this._bitmapInfo.width *
+          this._bitmapInfo.bpp *
+          this._bitmapInfo.depth +
+          7) >>
+          3) +
+        1;
+      let imageSize = rowSize * this._bitmapInfo.height;
+      let chunkSize = Math.max(imageSize, zlib__default['default'].Z_MIN_CHUNK);
 
       this._inflate = zlib__default['default'].createInflate({ chunkSize: chunkSize });
-      var leftToInflate = imageSize;
+      let leftToInflate = imageSize;
 
-      var emitError = this.emit.bind(this, 'error');
-      this._inflate.on('error', function(err) {
+      let emitError = this.emit.bind(this, "error");
+      this._inflate.on("error", function (err) {
         if (!leftToInflate) {
           return;
         }
 
         emitError(err);
       });
-      this._filter.on('complete', this._complete.bind(this));
+      this._filter.on("complete", this._complete.bind(this));
 
-      var filterWrite = this._filter.write.bind(this._filter);
-      this._inflate.on('data', function(chunk) {
+      let filterWrite = this._filter.write.bind(this._filter);
+      this._inflate.on("data", function (chunk) {
         if (!leftToInflate) {
           return;
         }
@@ -1526,78 +1602,83 @@ ParserAsync.prototype._inflateData = function(data) {
         filterWrite(chunk);
       });
 
-      this._inflate.on('end', this._filter.end.bind(this._filter));
+      this._inflate.on("end", this._filter.end.bind(this._filter));
     }
   }
   this._inflate.write(data);
 };
 
-ParserAsync.prototype._handleMetaData = function(metaData) {
+ParserAsync.prototype._handleMetaData = function (metaData) {
   this._metaData = metaData;
   this._bitmapInfo = Object.create(metaData);
 
   this._filter = new filterParseAsync(this._bitmapInfo);
 };
 
-ParserAsync.prototype._handleTransColor = function(transColor) {
+ParserAsync.prototype._handleTransColor = function (transColor) {
   this._bitmapInfo.transColor = transColor;
 };
 
-ParserAsync.prototype._handlePalette = function(palette) {
+ParserAsync.prototype._handlePalette = function (palette) {
   this._bitmapInfo.palette = palette;
 };
 
-ParserAsync.prototype._simpleTransparency = function() {
+ParserAsync.prototype._simpleTransparency = function () {
   this._metaData.alpha = true;
 };
 
-ParserAsync.prototype._headersFinished = function() {
+ParserAsync.prototype._headersFinished = function () {
   // Up until this point, we don't know if we have a tRNS chunk (alpha)
   // so we can't emit metadata any earlier
-  this.emit('metadata', this._metaData);
+  this.emit("metadata", this._metaData);
 };
 
-ParserAsync.prototype._finished = function() {
+ParserAsync.prototype._finished = function () {
   if (this.errord) {
     return;
   }
 
   if (!this._inflate) {
-    this.emit('error', 'No Inflate block');
-  }
-  else {
+    this.emit("error", "No Inflate block");
+  } else {
     // no more data to inflate
     this._inflate.end();
   }
-  this.destroySoon();
 };
 
-ParserAsync.prototype._complete = function(filteredData) {
-
+ParserAsync.prototype._complete = function (filteredData) {
   if (this.errord) {
     return;
   }
 
+  let normalisedBitmapData;
+
   try {
-    var bitmapData = bitmapper.dataToBitMap(filteredData, this._bitmapInfo);
+    let bitmapData = bitmapper.dataToBitMap(filteredData, this._bitmapInfo);
 
-    var normalisedBitmapData = formatNormaliser(bitmapData, this._bitmapInfo);
+    normalisedBitmapData = formatNormaliser(
+      bitmapData,
+      this._bitmapInfo,
+      this._options.skipRescale
+    );
     bitmapData = null;
-  }
-  catch (ex) {
+  } catch (ex) {
     this._handleError(ex);
     return;
   }
 
-  this.emit('parsed', normalisedBitmapData);
+  this.emit("parsed", normalisedBitmapData);
 };
 });
 
-var bitpacker = function(dataIn, width, height, options) {
-  var outHasAlpha = [constants.COLORTYPE_COLOR_ALPHA, constants.COLORTYPE_ALPHA].indexOf(options.colorType) !== -1;
+var bitpacker = function (dataIn, width, height, options) {
+  let outHasAlpha =
+    [constants.COLORTYPE_COLOR_ALPHA, constants.COLORTYPE_ALPHA].indexOf(
+      options.colorType
+    ) !== -1;
   if (options.colorType === options.inputColorType) {
-    var bigEndian = (function() {
-      var buffer = new ArrayBuffer(2);
+    let bigEndian = (function () {
+      let buffer = new ArrayBuffer(2);
       new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
       // Int16Array uses the platform's endianness.
       return new Int16Array(buffer)[0] !== 256;
@@ -1609,24 +1690,24 @@ var bitpacker = function(dataIn, width, height, options) {
   }
 
   // map to a UInt16 array if data is 16bit, fix endianness below
-  var data = options.bitDepth !== 16 ? dataIn : new Uint16Array(dataIn.buffer);
+  let data = options.bitDepth !== 16 ? dataIn : new Uint16Array(dataIn.buffer);
 
-  var maxValue = 255;
-  var inBpp = constants.COLORTYPE_TO_BPP_MAP[options.inputColorType];
+  let maxValue = 255;
+  let inBpp = constants.COLORTYPE_TO_BPP_MAP[options.inputColorType];
   if (inBpp === 4 && !options.inputHasAlpha) {
     inBpp = 3;
   }
-  var outBpp = constants.COLORTYPE_TO_BPP_MAP[options.colorType];
+  let outBpp = constants.COLORTYPE_TO_BPP_MAP[options.colorType];
   if (options.bitDepth === 16) {
     maxValue = 65535;
     outBpp *= 2;
   }
-  var outData = new Buffer(width * height * outBpp);
+  let outData = Buffer.alloc(width * height * outBpp);
 
-  var inIndex = 0;
-  var outIndex = 0;
+  let inIndex = 0;
+  let outIndex = 0;
 
-  var bgColor = options.bgColor || {};
+  let bgColor = options.bgColor || {};
   if (bgColor.red === undefined) {
     bgColor.red = maxValue;
   }
@@ -1638,10 +1719,10 @@ var bitpacker = function(dataIn, width, height, options) {
   }
 
   function getRGBA() {
-    var red;
-    var green;
-    var blue;
-    var alpha = maxValue;
+    let red;
+    let green;
+    let blue;
+    let alpha = maxValue;
     switch (options.inputColorType) {
       case constants.COLORTYPE_COLOR_ALPHA:
         alpha = data[inIndex + 3];
@@ -1666,23 +1747,36 @@ var bitpacker = function(dataIn, width, height, options) {
         blue = red;
         break;
       default:
-        throw new Error('input color type:' + options.inputColorType + ' is not supported at present');
+        throw new Error(
+          "input color type:" +
+            options.inputColorType +
+            " is not supported at present"
+        );
     }
 
     if (options.inputHasAlpha) {
       if (!outHasAlpha) {
         alpha /= maxValue;
-        red = Math.min(Math.max(Math.round((1 - alpha) * bgColor.red + alpha * red), 0), maxValue);
-        green = Math.min(Math.max(Math.round((1 - alpha) * bgColor.green + alpha * green), 0), maxValue);
-        blue = Math.min(Math.max(Math.round((1 - alpha) * bgColor.blue + alpha * blue), 0), maxValue);
+        red = Math.min(
+          Math.max(Math.round((1 - alpha) * bgColor.red + alpha * red), 0),
+          maxValue
+        );
+        green = Math.min(
+          Math.max(Math.round((1 - alpha) * bgColor.green + alpha * green), 0),
+          maxValue
+        );
+        blue = Math.min(
+          Math.max(Math.round((1 - alpha) * bgColor.blue + alpha * blue), 0),
+          maxValue
+        );
       }
     }
     return { red: red, green: green, blue: blue, alpha: alpha };
   }
 
-  for (var y = 0; y < height; y++) {
-    for (var x = 0; x < width; x++) {
-      var rgba = getRGBA();
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      let rgba = getRGBA();
 
       switch (options.colorType) {
         case constants.COLORTYPE_COLOR_ALPHA:
@@ -1694,8 +1788,7 @@ var bitpacker = function(dataIn, width, height, options) {
             if (outHasAlpha) {
               outData[outIndex + 3] = rgba.alpha;
             }
-          }
-          else {
+          } else {
             outData.writeUInt16BE(rgba.red, outIndex);
             outData.writeUInt16BE(rgba.green, outIndex + 2);
             outData.writeUInt16BE(rgba.blue, outIndex + 4);
@@ -1705,24 +1798,24 @@ var bitpacker = function(dataIn, width, height, options) {
           }
           break;
         case constants.COLORTYPE_ALPHA:
-        case constants.COLORTYPE_GRAYSCALE:
+        case constants.COLORTYPE_GRAYSCALE: {
           // Convert to grayscale and alpha
-          var grayscale = (rgba.red + rgba.green + rgba.blue) / 3;
+          let grayscale = (rgba.red + rgba.green + rgba.blue) / 3;
           if (options.bitDepth === 8) {
             outData[outIndex] = grayscale;
             if (outHasAlpha) {
               outData[outIndex + 1] = rgba.alpha;
             }
-          }
-          else {
+          } else {
             outData.writeUInt16BE(grayscale, outIndex);
             if (outHasAlpha) {
               outData.writeUInt16BE(rgba.alpha, outIndex + 2);
             }
           }
           break;
+        }
         default:
-          throw new Error('unrecognised color Type ' + options.colorType);
+          throw new Error("unrecognised color Type " + options.colorType);
       }
 
       inIndex += inBpp;
@@ -1734,41 +1827,35 @@ var bitpacker = function(dataIn, width, height, options) {
 };
 
 function filterNone(pxData, pxPos, byteWidth, rawData, rawPos) {
-
-  for (var x = 0; x < byteWidth; x++) {
+  for (let x = 0; x < byteWidth; x++) {
     rawData[rawPos + x] = pxData[pxPos + x];
   }
 }
 
 function filterSumNone(pxData, pxPos, byteWidth) {
+  let sum = 0;
+  let length = pxPos + byteWidth;
 
-  var sum = 0;
-  var length = pxPos + byteWidth;
-
-  for (var i = pxPos; i < length; i++) {
+  for (let i = pxPos; i < length; i++) {
     sum += Math.abs(pxData[i]);
   }
   return sum;
 }
 
 function filterSub(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
-
-  for (var x = 0; x < byteWidth; x++) {
-
-    var left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    var val = pxData[pxPos + x] - left;
+  for (let x = 0; x < byteWidth; x++) {
+    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+    let val = pxData[pxPos + x] - left;
 
     rawData[rawPos + x] = val;
   }
 }
 
 function filterSumSub(pxData, pxPos, byteWidth, bpp) {
-
-  var sum = 0;
-  for (var x = 0; x < byteWidth; x++) {
-
-    var left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    var val = pxData[pxPos + x] - left;
+  let sum = 0;
+  for (let x = 0; x < byteWidth; x++) {
+    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+    let val = pxData[pxPos + x] - left;
 
     sum += Math.abs(val);
   }
@@ -1777,24 +1864,20 @@ function filterSumSub(pxData, pxPos, byteWidth, bpp) {
 }
 
 function filterUp(pxData, pxPos, byteWidth, rawData, rawPos) {
-
-  for (var x = 0; x < byteWidth; x++) {
-
-    var up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
-    var val = pxData[pxPos + x] - up;
+  for (let x = 0; x < byteWidth; x++) {
+    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+    let val = pxData[pxPos + x] - up;
 
     rawData[rawPos + x] = val;
   }
 }
 
 function filterSumUp(pxData, pxPos, byteWidth) {
-
-  var sum = 0;
-  var length = pxPos + byteWidth;
-  for (var x = pxPos; x < length; x++) {
-
-    var up = pxPos > 0 ? pxData[x - byteWidth] : 0;
-    var val = pxData[x] - up;
+  let sum = 0;
+  let length = pxPos + byteWidth;
+  for (let x = pxPos; x < length; x++) {
+    let up = pxPos > 0 ? pxData[x - byteWidth] : 0;
+    let val = pxData[x] - up;
 
     sum += Math.abs(val);
   }
@@ -1803,25 +1886,21 @@ function filterSumUp(pxData, pxPos, byteWidth) {
 }
 
 function filterAvg(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
-
-  for (var x = 0; x < byteWidth; x++) {
-
-    var left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    var up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
-    var val = pxData[pxPos + x] - ((left + up) >> 1);
+  for (let x = 0; x < byteWidth; x++) {
+    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+    let val = pxData[pxPos + x] - ((left + up) >> 1);
 
     rawData[rawPos + x] = val;
   }
 }
 
 function filterSumAvg(pxData, pxPos, byteWidth, bpp) {
-
-  var sum = 0;
-  for (var x = 0; x < byteWidth; x++) {
-
-    var left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    var up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
-    var val = pxData[pxPos + x] - ((left + up) >> 1);
+  let sum = 0;
+  for (let x = 0; x < byteWidth; x++) {
+    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+    let val = pxData[pxPos + x] - ((left + up) >> 1);
 
     sum += Math.abs(val);
   }
@@ -1830,26 +1909,25 @@ function filterSumAvg(pxData, pxPos, byteWidth, bpp) {
 }
 
 function filterPaeth(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
-
-  for (var x = 0; x < byteWidth; x++) {
-
-    var left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    var up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
-    var upleft = pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
-    var val = pxData[pxPos + x] - paethPredictor(left, up, upleft);
+  for (let x = 0; x < byteWidth; x++) {
+    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+    let upleft =
+      pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
+    let val = pxData[pxPos + x] - paethPredictor(left, up, upleft);
 
     rawData[rawPos + x] = val;
   }
 }
 
 function filterSumPaeth(pxData, pxPos, byteWidth, bpp) {
-  var sum = 0;
-  for (var x = 0; x < byteWidth; x++) {
-
-    var left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    var up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
-    var upleft = pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
-    var val = pxData[pxPos + x] - paethPredictor(left, up, upleft);
+  let sum = 0;
+  for (let x = 0; x < byteWidth; x++) {
+    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
+    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
+    let upleft =
+      pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
+    let val = pxData[pxPos + x] - paethPredictor(left, up, upleft);
 
     sum += Math.abs(val);
   }
@@ -1857,53 +1935,49 @@ function filterSumPaeth(pxData, pxPos, byteWidth, bpp) {
   return sum;
 }
 
-var filters = {
+let filters = {
   0: filterNone,
   1: filterSub,
   2: filterUp,
   3: filterAvg,
-  4: filterPaeth
+  4: filterPaeth,
 };
 
-var filterSums = {
+let filterSums = {
   0: filterSumNone,
   1: filterSumSub,
   2: filterSumUp,
   3: filterSumAvg,
-  4: filterSumPaeth
+  4: filterSumPaeth,
 };
 
-var filterPack = function(pxData, width, height, options, bpp) {
-
-  var filterTypes;
-  if (!('filterType' in options) || options.filterType === -1) {
+var filterPack = function (pxData, width, height, options, bpp) {
+  let filterTypes;
+  if (!("filterType" in options) || options.filterType === -1) {
     filterTypes = [0, 1, 2, 3, 4];
-  }
-  else if (typeof options.filterType === 'number') {
+  } else if (typeof options.filterType === "number") {
     filterTypes = [options.filterType];
-  }
-  else {
-    throw new Error('unrecognised filter types');
+  } else {
+    throw new Error("unrecognised filter types");
   }
 
   if (options.bitDepth === 16) {
     bpp *= 2;
   }
-  var byteWidth = width * bpp;
-  var rawPos = 0;
-  var pxPos = 0;
-  var rawData = new Buffer((byteWidth + 1) * height);
-
-  var sel = filterTypes[0];
+  let byteWidth = width * bpp;
+  let rawPos = 0;
+  let pxPos = 0;
+  let rawData = Buffer.alloc((byteWidth + 1) * height);
 
-  for (var y = 0; y < height; y++) {
+  let sel = filterTypes[0];
 
+  for (let y = 0; y < height; y++) {
     if (filterTypes.length > 1) {
       // find best filter for this line (with lowest sum of values)
-      var min = Infinity;
+      let min = Infinity;
 
-      for (var i = 0; i < filterTypes.length; i++) {
-        var sum = filterSums[filterTypes[i]](pxData, pxPos, byteWidth, bpp);
+      for (let i = 0; i < filterTypes.length; i++) {
+        let sum = filterSums[filterTypes[i]](pxData, pxPos, byteWidth, bpp);
         if (sum < min) {
           sel = filterTypes[i];
           min = sum;
@@ -1928,66 +2002,86 @@ var packer = createCommonjsModule(function (module) {
 
 
 
-var Packer = module.exports = function(options) {
+let Packer = (module.exports = function (options) {
   this._options = options;
 
   options.deflateChunkSize = options.deflateChunkSize || 32 * 1024;
-  options.deflateLevel = options.deflateLevel != null ? options.deflateLevel : 9;
-  options.deflateStrategy = options.deflateStrategy != null ? options.deflateStrategy : 3;
-  options.inputHasAlpha = options.inputHasAlpha != null ? options.inputHasAlpha : true;
+  options.deflateLevel =
+    options.deflateLevel != null ? options.deflateLevel : 9;
+  options.deflateStrategy =
+    options.deflateStrategy != null ? options.deflateStrategy : 3;
+  options.inputHasAlpha =
+    options.inputHasAlpha != null ? options.inputHasAlpha : true;
   options.deflateFactory = options.deflateFactory || zlib__default['default'].createDeflate;
   options.bitDepth = options.bitDepth || 8;
   // This is outputColorType
-  options.colorType = (typeof options.colorType === 'number') ? options.colorType : constants.COLORTYPE_COLOR_ALPHA;
-  options.inputColorType = (typeof options.inputColorType === 'number') ? options.inputColorType : constants.COLORTYPE_COLOR_ALPHA;
-
-  if ([
-    constants.COLORTYPE_GRAYSCALE,
-    constants.COLORTYPE_COLOR,
-    constants.COLORTYPE_COLOR_ALPHA,
-    constants.COLORTYPE_ALPHA
-  ].indexOf(options.colorType) === -1) {
-    throw new Error('option color type:' + options.colorType + ' is not supported at present');
-  }
-  if ([
-    constants.COLORTYPE_GRAYSCALE,
-    constants.COLORTYPE_COLOR,
-    constants.COLORTYPE_COLOR_ALPHA,
-    constants.COLORTYPE_ALPHA
-  ].indexOf(options.inputColorType) === -1) {
-    throw new Error('option input color type:' + options.inputColorType + ' is not supported at present');
+  options.colorType =
+    typeof options.colorType === "number"
+      ? options.colorType
+      : constants.COLORTYPE_COLOR_ALPHA;
+  options.inputColorType =
+    typeof options.inputColorType === "number"
+      ? options.inputColorType
+      : constants.COLORTYPE_COLOR_ALPHA;
+
+  if (
+    [
+      constants.COLORTYPE_GRAYSCALE,
+      constants.COLORTYPE_COLOR,
+      constants.COLORTYPE_COLOR_ALPHA,
+      constants.COLORTYPE_ALPHA,
+    ].indexOf(options.colorType) === -1
+  ) {
+    throw new Error(
+      "option color type:" + options.colorType + " is not supported at present"
+    );
+  }
+  if (
+    [
+      constants.COLORTYPE_GRAYSCALE,
+      constants.COLORTYPE_COLOR,
+      constants.COLORTYPE_COLOR_ALPHA,
+      constants.COLORTYPE_ALPHA,
+    ].indexOf(options.inputColorType) === -1
+  ) {
+    throw new Error(
+      "option input color type:" +
+        options.inputColorType +
+        " is not supported at present"
+    );
   }
   if (options.bitDepth !== 8 && options.bitDepth !== 16) {
-    throw new Error('option bit depth:' + options.bitDepth + ' is not supported at present');
+    throw new Error(
+      "option bit depth:" + options.bitDepth + " is not supported at present"
+    );
   }
-};
+});
 
-Packer.prototype.getDeflateOptions = function() {
+Packer.prototype.getDeflateOptions = function () {
   return {
     chunkSize: this._options.deflateChunkSize,
     level: this._options.deflateLevel,
-    strategy: this._options.deflateStrategy
+    strategy: this._options.deflateStrategy,
   };
 };
 
-Packer.prototype.createDeflate = function() {
+Packer.prototype.createDeflate = function () {
   return this._options.deflateFactory(this.getDeflateOptions());
 };
 
-Packer.prototype.filterData = function(data, width, height) {
+Packer.prototype.filterData = function (data, width, height) {
   // convert to correct format for filtering (e.g. right bpp and bit depth)
-  var packedData = bitpacker(data, width, height, this._options);
+  let packedData = bitpacker(data, width, height, this._options);
 
   // filter pixel data
-  var bpp = constants.COLORTYPE_TO_BPP_MAP[this._options.colorType];
-  var filteredData = filterPack(packedData, width, height, this._options, bpp);
+  let bpp = constants.COLORTYPE_TO_BPP_MAP[this._options.colorType];
+  let filteredData = filterPack(packedData, width, height, this._options, bpp);
   return filteredData;
 };
 
-Packer.prototype._packChunk = function(type, data) {
-
-  var len = (data ? data.length : 0);
-  var buf = new Buffer(len + 12);
+Packer.prototype._packChunk = function (type, data) {
+  let len = data ? data.length : 0;
+  let buf = Buffer.alloc(len + 12);
 
   buf.writeUInt32BE(len, 0);
   buf.writeUInt32BE(type, 4);
@@ -1996,19 +2090,21 @@ Packer.prototype._packChunk = function(type, data) {
     data.copy(buf, 8);
   }
 
-  buf.writeInt32BE(crc.crc32(buf.slice(4, buf.length - 4)), buf.length - 4);
+  buf.writeInt32BE(
+    crc.crc32(buf.slice(4, buf.length - 4)),
+    buf.length - 4
+  );
   return buf;
 };
 
-Packer.prototype.packGAMA = function(gamma) {
-  var buf = new Buffer(4);
+Packer.prototype.packGAMA = function (gamma) {
+  let buf = Buffer.alloc(4);
   buf.writeUInt32BE(Math.floor(gamma * constants.GAMMA_DIVISION), 0);
   return this._packChunk(constants.TYPE_gAMA, buf);
 };
 
-Packer.prototype.packIHDR = function(width, height) {
-
-  var buf = new Buffer(13);
+Packer.prototype.packIHDR = function (width, height) {
+  let buf = Buffer.alloc(13);
   buf.writeUInt32BE(width, 0);
   buf.writeUInt32BE(height, 4);
   buf[8] = this._options.bitDepth; // Bit depth
@@ -2020,11 +2116,11 @@ Packer.prototype.packIHDR = function(width, height) {
   return this._packChunk(constants.TYPE_IHDR, buf);
 };
 
-Packer.prototype.packIDAT = function(data) {
+Packer.prototype.packIDAT = function (data) {
   return this._packChunk(constants.TYPE_IDAT, data);
 };
 
-Packer.prototype.packIEND = function() {
+Packer.prototype.packIEND = function () {
   return this._packChunk(constants.TYPE_IEND, null);
 };
 });
@@ -2036,41 +2132,46 @@ var packerAsync = createCommonjsModule(function (module) {
 
 
 
-var PackerAsync = module.exports = function(opt) {
+let PackerAsync = (module.exports = function (opt) {
   Stream__default['default'].call(this);
 
-  var options = opt || {};
+  let options = opt || {};
 
   this._packer = new packer(options);
   this._deflate = this._packer.createDeflate();
 
   this.readable = true;
-};
+});
 util__default['default'].inherits(PackerAsync, Stream__default['default']);
 
-
-PackerAsync.prototype.pack = function(data, width, height, gamma) {
+PackerAsync.prototype.pack = function (data, width, height, gamma) {
   // Signature
-  this.emit('data', new Buffer(constants.PNG_SIGNATURE));
-  this.emit('data', this._packer.packIHDR(width, height));
+  this.emit("data", Buffer.from(constants.PNG_SIGNATURE));
+  this.emit("data", this._packer.packIHDR(width, height));
 
   if (gamma) {
-    this.emit('data', this._packer.packGAMA(gamma));
+    this.emit("data", this._packer.packGAMA(gamma));
   }
 
-  var filteredData = this._packer.filterData(data, width, height);
+  let filteredData = this._packer.filterData(data, width, height);
 
   // compress it
-  this._deflate.on('error', this.emit.bind(this, 'error'));
+  this._deflate.on("error", this.emit.bind(this, "error"));
 
-  this._deflate.on('data', function(compressedData) {
-    this.emit('data', this._packer.packIDAT(compressedData));
-  }.bind(this));
+  this._deflate.on(
+    "data",
+    function (compressedData) {
+      this.emit("data", this._packer.packIDAT(compressedData));
+    }.bind(this)
+  );
 
-  this._deflate.on('end', function() {
-    this.emit('data', this._packer.packIEND());
-    this.emit('end');
-  }.bind(this));
+  this._deflate.on(
+    "end",
+    function () {
+      this.emit("data", this._packer.packIEND());
+      this.emit("end");
+    }.bind(this)
+  );
 
   this._deflate.end(filteredData);
 };
@@ -2078,11 +2179,11 @@ PackerAsync.prototype.pack = function(data, width, height, gamma) {
 
 var syncInflate = createCommonjsModule(function (module, exports) {
 
-var assert = require$$0__default['default'].ok;
+let assert = require$$0__default['default'].ok;
 
 
 
-var kMaxLength = require$$1__default['default'].kMaxLength;
+let kMaxLength = require$$1__default['default'].kMaxLength;
 
 function Inflate(opts) {
   if (!(this instanceof Inflate)) {
@@ -2122,23 +2223,23 @@ function _close(engine, callback) {
   engine._handle = null;
 }
 
-Inflate.prototype._processChunk = function(chunk, flushFlag, asyncCb) {
-  if (typeof asyncCb === 'function') {
+Inflate.prototype._processChunk = function (chunk, flushFlag, asyncCb) {
+  if (typeof asyncCb === "function") {
     return zlib__default['default'].Inflate._processChunk.call(this, chunk, flushFlag, asyncCb);
   }
 
-  var self = this;
+  let self = this;
 
-  var availInBefore = chunk && chunk.length;
-  var availOutBefore = this._chunkSize - this._offset;
-  var leftToInflate = this._maxLength;
-  var inOff = 0;
+  let availInBefore = chunk && chunk.length;
+  let availOutBefore = this._chunkSize - this._offset;
+  let leftToInflate = this._maxLength;
+  let inOff = 0;
 
-  var buffers = [];
-  var nread = 0;
+  let buffers = [];
+  let nread = 0;
 
-  var error;
-  this.on('error', function(err) {
+  let error;
+  this.on("error", function (err) {
     error = err;
   });
 
@@ -2147,11 +2248,11 @@ Inflate.prototype._processChunk = function(chunk, flushFlag, asyncCb) {
       return;
     }
 
-    var have = availOutBefore - availOutAfter;
-    assert(have >= 0, 'have should not go down');
+    let have = availOutBefore - availOutAfter;
+    assert(have >= 0, "have should not go down");
 
     if (have > 0) {
-      var out = self._buffer.slice(self._offset, self._offset + have);
+      let out = self._buffer.slice(self._offset, self._offset + have);
       self._offset += have;
 
       if (out.length > leftToInflate) {
@@ -2174,7 +2275,7 @@ Inflate.prototype._processChunk = function(chunk, flushFlag, asyncCb) {
     }
 
     if (availOutAfter === 0) {
-      inOff += (availInBefore - availInAfter);
+      inOff += availInBefore - availInAfter;
       availInBefore = availInAfter;
 
       return true;
@@ -2183,15 +2284,18 @@ Inflate.prototype._processChunk = function(chunk, flushFlag, asyncCb) {
     return false;
   }
 
-  assert(this._handle, 'zlib binding closed');
+  assert(this._handle, "zlib binding closed");
+  let res;
   do {
-    var res = this._handle.writeSync(flushFlag,
+    res = this._handle.writeSync(
+      flushFlag,
       chunk, // in
       inOff, // in_off
       availInBefore, // in_len
       this._buffer, // out
       this._offset, //out_off
-      availOutBefore); // out_len
+      availOutBefore
+    ); // out_len
     // Node 8 --> 9 compatibility check
     res = res || this._writeState;
   } while (!this._hadError && handleChunk(res[0], res[1]));
@@ -2202,10 +2306,14 @@ Inflate.prototype._processChunk = function(chunk, flushFlag, asyncCb) {
 
   if (nread >= kMaxLength) {
     _close(this);
-    throw new RangeError('Cannot create final Buffer. It would be larger than 0x' + kMaxLength.toString(16) + ' bytes');
+    throw new RangeError(
+      "Cannot create final Buffer. It would be larger than 0x" +
+        kMaxLength.toString(16) +
+        " bytes"
+    );
   }
 
-  var buf = Buffer.concat(buffers, nread);
+  let buf = Buffer.concat(buffers, nread);
   _close(this);
 
   return buf;
@@ -2214,14 +2322,14 @@ Inflate.prototype._processChunk = function(chunk, flushFlag, asyncCb) {
 util__default['default'].inherits(Inflate, zlib__default['default'].Inflate);
 
 function zlibBufferSync(engine, buffer) {
-  if (typeof buffer === 'string') {
+  if (typeof buffer === "string") {
     buffer = Buffer.from(buffer);
   }
   if (!(buffer instanceof Buffer)) {
-    throw new TypeError('Not a string or buffer');
+    throw new TypeError("Not a string or buffer");
   }
 
-  var flushFlag = engine._finishFlushFlag;
+  let flushFlag = engine._finishFlushFlag;
   if (flushFlag == null) {
     flushFlag = zlib__default['default'].Z_FINISH;
   }
@@ -2241,68 +2349,60 @@ exports.inflateSync = inflateSync;
 
 var syncReader = createCommonjsModule(function (module) {
 
-var SyncReader = module.exports = function(buffer) {
-
+let SyncReader = (module.exports = function (buffer) {
   this._buffer = buffer;
   this._reads = [];
-};
-
-SyncReader.prototype.read = function(length, callback) {
+});
 
+SyncReader.prototype.read = function (length, callback) {
   this._reads.push({
     length: Math.abs(length), // if length < 0 then at most this length
     allowLess: length < 0,
-    func: callback
+    func: callback,
   });
 };
 
-SyncReader.prototype.process = function() {
-
+SyncReader.prototype.process = function () {
   // as long as there is any data and read requests
   while (this._reads.length > 0 && this._buffer.length) {
+    let read = this._reads[0];
 
-    var read = this._reads[0];
-
-    if (this._buffer.length && (this._buffer.length >= read.length || read.allowLess)) {
-
+    if (
+      this._buffer.length &&
+      (this._buffer.length >= read.length || read.allowLess)
+    ) {
       // ok there is any data so that we can satisfy this request
       this._reads.shift(); // == read
 
-      var buf = this._buffer;
+      let buf = this._buffer;
 
       this._buffer = buf.slice(read.length);
 
       read.func.call(this, buf.slice(0, read.length));
-
-    }
-    else {
+    } else {
       break;
     }
-
   }
 
   if (this._reads.length > 0) {
-    return new Error('There are some read requests waitng on finished stream');
+    throw new Error("There are some read requests waitng on finished stream");
   }
 
   if (this._buffer.length > 0) {
-    return new Error('unrecognised content at end of stream');
+    throw new Error("unrecognised content at end of stream");
   }
-
 };
 });
 
-var process_1 = function(inBuffer, bitmapInfo) {
-
-  var outBuffers = [];
-  var reader = new syncReader(inBuffer);
-  var filter = new filterParse(bitmapInfo, {
+var process_1 = function (inBuffer, bitmapInfo) {
+  let outBuffers = [];
+  let reader = new syncReader(inBuffer);
+  let filter = new filterParse(bitmapInfo, {
     read: reader.read.bind(reader),
-    write: function(bufferPart) {
+    write: function (bufferPart) {
       outBuffers.push(bufferPart);
     },
-    complete: function() {
-    }
+    complete: function () {},
   });
 
   filter.start();
@@ -2315,7 +2415,7 @@ var filterParseSync = {
 	process: process_1
 };
 
-var hasSyncZlib$1 = true;
+let hasSyncZlib$1 = true;
 
 
 if (!zlib__default['default'].deflateSync) {
@@ -2327,19 +2427,19 @@ if (!zlib__default['default'].deflateSync) {
 
 
 
-
-var parserSync = function(buffer, options) {
-
+var parserSync = function (buffer, options) {
   if (!hasSyncZlib$1) {
-    throw new Error('To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0');
+    throw new Error(
+      "To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0"
+    );
   }
 
-  var err;
+  let err;
   function handleError(_err_) {
     err = _err_;
   }
 
-  var metaData;
+  let metaData;
   function handleMetaData(_metaData_) {
     metaData = _metaData_;
   }
@@ -2356,19 +2456,19 @@ var parserSync = function(buffer, options) {
     metaData.alpha = true;
   }
 
-  var gamma;
+  let gamma;
   function handleGamma(_gamma_) {
     gamma = _gamma_;
   }
 
-  var inflateDataList = [];
+  let inflateDataList = [];
   function handleInflateData(inflatedData) {
     inflateDataList.push(inflatedData);
   }
 
-  var reader = new syncReader(buffer);
+  let reader = new syncReader(buffer);
 
-  var parser$1 = new parser(options, {
+  let parser$1 = new parser(options, {
     read: reader.read.bind(reader),
     error: handleError,
     metadata: handleMetaData,
@@ -2376,7 +2476,7 @@ var parserSync = function(buffer, options) {
     palette: handlePalette,
     transColor: handleTransColor,
     inflateData: handleInflateData,
-    simpleTransparency: handleSimpleTransparency
+    simpleTransparency: handleSimpleTransparency,
   });
 
   parser$1.start();
@@ -2387,31 +2487,38 @@ var parserSync = function(buffer, options) {
   }
 
   //join together the inflate datas
-  var inflateData = Buffer.concat(inflateDataList);
+  let inflateData = Buffer.concat(inflateDataList);
   inflateDataList.length = 0;
 
-  var inflatedData;
+  let inflatedData;
   if (metaData.interlace) {
     inflatedData = zlib__default['default'].inflateSync(inflateData);
-  }
-  else {
-    var rowSize = ((metaData.width * metaData.bpp * metaData.depth + 7) >> 3) + 1;
-    var imageSize = rowSize * metaData.height;
-    inflatedData = syncInflate(inflateData, { chunkSize: imageSize, maxLength: imageSize });
+  } else {
+    let rowSize =
+      ((metaData.width * metaData.bpp * metaData.depth + 7) >> 3) + 1;
+    let imageSize = rowSize * metaData.height;
+    inflatedData = syncInflate(inflateData, {
+      chunkSize: imageSize,
+      maxLength: imageSize,
+    });
   }
   inflateData = null;
 
   if (!inflatedData || !inflatedData.length) {
-    throw new Error('bad png - invalid inflate data response');
+    throw new Error("bad png - invalid inflate data response");
   }
 
-  var unfilteredData = filterParseSync.process(inflatedData, metaData);
+  let unfilteredData = filterParseSync.process(inflatedData, metaData);
   inflateData = null;
 
-  var bitmapData = bitmapper.dataToBitMap(unfilteredData, metaData);
+  let bitmapData = bitmapper.dataToBitMap(unfilteredData, metaData);
   unfilteredData = null;
 
-  var normalisedBitmapData = formatNormaliser(bitmapData, metaData);
+  let normalisedBitmapData = formatNormaliser(
+    bitmapData,
+    metaData,
+    options.skipRescale
+  );
 
   metaData.data = normalisedBitmapData;
   metaData.gamma = gamma || 0;
@@ -2419,7 +2526,7 @@ var parserSync = function(buffer, options) {
   return metaData;
 };
 
-var hasSyncZlib = true;
+let hasSyncZlib = true;
 
 if (!zlib__default['default'].deflateSync) {
   hasSyncZlib = false;
@@ -2427,20 +2534,21 @@ if (!zlib__default['default'].deflateSync) {
 
 
 
-var packerSync = function(metaData, opt) {
-
+var packerSync = function (metaData, opt) {
   if (!hasSyncZlib) {
-    throw new Error('To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0');
+    throw new Error(
+      "To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0"
+    );
   }
 
-  var options = opt || {};
+  let options = opt || {};
 
-  var packer$1 = new packer(options);
+  let packer$1 = new packer(options);
 
-  var chunks = [];
+  let chunks = [];
 
   // Signature
-  chunks.push(new Buffer(constants.PNG_SIGNATURE));
+  chunks.push(Buffer.from(constants.PNG_SIGNATURE));
 
   // Header
   chunks.push(packer$1.packIHDR(metaData.width, metaData.height));
@@ -2449,14 +2557,21 @@ var packerSync = function(metaData, opt) {
     chunks.push(packer$1.packGAMA(metaData.gamma));
   }
 
-  var filteredData = packer$1.filterData(metaData.data, metaData.width, metaData.height);
+  let filteredData = packer$1.filterData(
+    metaData.data,
+    metaData.width,
+    metaData.height
+  );
 
   // compress it
-  var compressedData = zlib__default['default'].deflateSync(filteredData, packer$1.getDeflateOptions());
+  let compressedData = zlib__default['default'].deflateSync(
+    filteredData,
+    packer$1.getDeflateOptions()
+  );
   filteredData = null;
 
   if (!compressedData || !compressedData.length) {
-    throw new Error('bad png - invalid compressed data response');
+    throw new Error("bad png - invalid compressed data response");
   }
   chunks.push(packer$1.packIDAT(compressedData));
 
@@ -2466,13 +2581,11 @@ var packerSync = function(metaData, opt) {
   return Buffer.concat(chunks);
 };
 
-var read = function(buffer, options) {
-
+var read = function (buffer, options) {
   return parserSync(buffer, options || {});
 };
 
-var write = function(png, options) {
-
+var write = function (png, options) {
   return packerSync(png, options);
 };
 
@@ -2489,8 +2602,7 @@ var png = createCommonjsModule(function (module, exports) {
 
 
 
-
-var PNG = exports.PNG = function(options) {
+let PNG = (exports.PNG = function (options) {
   Stream__default['default'].call(this);
 
   options = options || {}; // eslint-disable-line no-param-reassign
@@ -2499,8 +2611,10 @@ var PNG = exports.PNG = function(options) {
   this.width = options.width | 0;
   this.height = options.height | 0;
 
-  this.data = this.width > 0 && this.height > 0 ?
-    new Buffer(4 * this.width * this.height) : null;
+  this.data =
+    this.width > 0 && this.height > 0
+      ? Buffer.alloc(4 * this.width * this.height)
+      : null;
 
   if (options.fill && this.data) {
     this.data.fill(0);
@@ -2511,95 +2625,96 @@ var PNG = exports.PNG = function(options) {
 
   this._parser = new parserAsync(options);
 
-  this._parser.on('error', this.emit.bind(this, 'error'));
-  this._parser.on('close', this._handleClose.bind(this));
-  this._parser.on('metadata', this._metadata.bind(this));
-  this._parser.on('gamma', this._gamma.bind(this));
-  this._parser.on('parsed', function(data) {
-    this.data = data;
-    this.emit('parsed', data);
-  }.bind(this));
+  this._parser.on("error", this.emit.bind(this, "error"));
+  this._parser.on("close", this._handleClose.bind(this));
+  this._parser.on("metadata", this._metadata.bind(this));
+  this._parser.on("gamma", this._gamma.bind(this));
+  this._parser.on(
+    "parsed",
+    function (data) {
+      this.data = data;
+      this.emit("parsed", data);
+    }.bind(this)
+  );
 
   this._packer = new packerAsync(options);
-  this._packer.on('data', this.emit.bind(this, 'data'));
-  this._packer.on('end', this.emit.bind(this, 'end'));
-  this._parser.on('close', this._handleClose.bind(this));
-  this._packer.on('error', this.emit.bind(this, 'error'));
-
-};
+  this._packer.on("data", this.emit.bind(this, "data"));
+  this._packer.on("end", this.emit.bind(this, "end"));
+  this._parser.on("close", this._handleClose.bind(this));
+  this._packer.on("error", this.emit.bind(this, "error"));
+});
 util__default['default'].inherits(PNG, Stream__default['default']);
 
 PNG.sync = pngSync;
 
-PNG.prototype.pack = function() {
-
+PNG.prototype.pack = function () {
   if (!this.data || !this.data.length) {
-    this.emit('error', 'No data provided');
+    this.emit("error", "No data provided");
     return this;
   }
 
-  process.nextTick(function() {
-    this._packer.pack(this.data, this.width, this.height, this.gamma);
-  }.bind(this));
+  process.nextTick(
+    function () {
+      this._packer.pack(this.data, this.width, this.height, this.gamma);
+    }.bind(this)
+  );
 
   return this;
 };
 
-
-PNG.prototype.parse = function(data, callback) {
-
+PNG.prototype.parse = function (data, callback) {
   if (callback) {
-    var onParsed, onError;
+    let onParsed, onError;
 
-    onParsed = function(parsedData) {
-      this.removeListener('error', onError);
+    onParsed = function (parsedData) {
+      this.removeListener("error", onError);
 
       this.data = parsedData;
       callback(null, this);
     }.bind(this);
 
-    onError = function(err) {
-      this.removeListener('parsed', onParsed);
+    onError = function (err) {
+      this.removeListener("parsed", onParsed);
 
       callback(err, null);
     }.bind(this);
 
-    this.once('parsed', onParsed);
-    this.once('error', onError);
+    this.once("parsed", onParsed);
+    this.once("error", onError);
   }
 
   this.end(data);
   return this;
 };
 
-PNG.prototype.write = function(data) {
+PNG.prototype.write = function (data) {
   this._parser.write(data);
   return true;
 };
 
-PNG.prototype.end = function(data) {
+PNG.prototype.end = function (data) {
   this._parser.end(data);
 };
 
-PNG.prototype._metadata = function(metadata) {
+PNG.prototype._metadata = function (metadata) {
   this.width = metadata.width;
   this.height = metadata.height;
 
-  this.emit('metadata', metadata);
+  this.emit("metadata", metadata);
 };
 
-PNG.prototype._gamma = function(gamma) {
+PNG.prototype._gamma = function (gamma) {
   this.gamma = gamma;
 };
 
-PNG.prototype._handleClose = function() {
+PNG.prototype._handleClose = function () {
   if (!this._parser.writable && !this._packer.readable) {
-    this.emit('close');
+    this.emit("close");
   }
 };
 
-
-PNG.bitblt = function(src, dst, srcX, srcY, width, height, deltaX, deltaY) { // eslint-disable-line max-params
+PNG.bitblt = function (src, dst, srcX, srcY, width, height, deltaX, deltaY) {
+  // eslint-disable-line max-params
   // coerce pixel dimensions to integers (also coerces undefined -> 0):
   /* eslint-disable no-param-reassign */
   srcX |= 0;
@@ -2610,16 +2725,27 @@ PNG.bitblt = function(src, dst, srcX, srcY, width, height, deltaX, deltaY) { //
   deltaY |= 0;
   /* eslint-enable no-param-reassign */
 
-  if (srcX > src.width || srcY > src.height || srcX + width > src.width || srcY + height > src.height) {
-    throw new Error('bitblt reading outside image');
+  if (
+    srcX > src.width ||
+    srcY > src.height ||
+    srcX + width > src.width ||
+    srcY + height > src.height
+  ) {
+    throw new Error("bitblt reading outside image");
   }
 
-  if (deltaX > dst.width || deltaY > dst.height || deltaX + width > dst.width || deltaY + height > dst.height) {
-    throw new Error('bitblt writing outside image');
+  if (
+    deltaX > dst.width ||
+    deltaY > dst.height ||
+    deltaX + width > dst.width ||
+    deltaY + height > dst.height
+  ) {
+    throw new Error("bitblt writing outside image");
   }
 
-  for (var y = 0; y < height; y++) {
-    src.data.copy(dst.data,
+  for (let y = 0; y < height; y++) {
+    src.data.copy(
+      dst.data,
       ((deltaY + y) * dst.width + deltaX) << 2,
       ((srcY + y) * src.width + srcX) << 2,
       ((srcY + y) * src.width + srcX + width) << 2
@@ -2627,21 +2753,29 @@ PNG.bitblt = function(src, dst, srcX, srcY, width, height, deltaX, deltaY) { //
   }
 };
 
-
-PNG.prototype.bitblt = function(dst, srcX, srcY, width, height, deltaX, deltaY) { // eslint-disable-line max-params
+PNG.prototype.bitblt = function (
+  dst,
+  srcX,
+  srcY,
+  width,
+  height,
+  deltaX,
+  deltaY
+) {
+  // eslint-disable-line max-params
 
   PNG.bitblt(this, dst, srcX, srcY, width, height, deltaX, deltaY);
   return this;
 };
 
-PNG.adjustGamma = function(src) {
+PNG.adjustGamma = function (src) {
   if (src.gamma) {
-    for (var y = 0; y < src.height; y++) {
-      for (var x = 0; x < src.width; x++) {
-        var idx = (src.width * y + x) << 2;
+    for (let y = 0; y < src.height; y++) {
+      for (let x = 0; x < src.width; x++) {
+        let idx = (src.width * y + x) << 2;
 
-        for (var i = 0; i < 3; i++) {
-          var sample = src.data[idx + i] / 255;
+        for (let i = 0; i < 3; i++) {
+          let sample = src.data[idx + i] / 255;
           sample = Math.pow(sample, 1 / 2.2 / src.gamma);
           src.data[idx + i] = Math.round(sample * 255);
         }
@@ -2651,7 +2785,7 @@ PNG.adjustGamma = function(src) {
   }
 };
 
-PNG.prototype.adjustGamma = function() {
+PNG.prototype.adjustGamma = function () {
   PNG.adjustGamma(this);
 };
 });