'use strict'; var fs = require('fs'); var util = require('util'); var Stream = require('stream'); var zlib = require('zlib'); var require$$0 = require('assert'); var require$$1 = require('buffer'); function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs); var util__default = /*#__PURE__*/_interopDefaultLegacy(util); var Stream__default = /*#__PURE__*/_interopDefaultLegacy(Stream); var zlib__default = /*#__PURE__*/_interopDefaultLegacy(zlib); var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0); 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 (!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.'); 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 const maxDelta = 35215 * options.threshold * options.threshold; let diff = 0; // compare each pixel of one image against the other one for (let y = 0; y < height; y++) { for (let x = 0; x < width; x++) { const pos = (y * width + x) * 4; // 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 (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))) { // one of the pixels is anti-aliasing; draw as yellow and do not count as difference // 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 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 if (!options.diffMask) drawGrayPixel(img1, pos, options.alpha, output); } } } // return the number of different pixels 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) { 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 (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 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++; // if found more than 2 equal siblings, it's definitely not anti-aliasing if (zeroes > 2) return false; // remember the darkest pixel } else if (delta < min) { min = delta; minX = x; minY = y; // remember the brightest pixel } else if (delta > max) { max = delta; maxX = x; maxY = y; } } } // if there are no both darker and brighter pixels among siblings, it's not anti-aliasing if (min === 0 || max === 0) return false; // 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 (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) { 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); } if (a2 < 255) { a2 /= 255; r2 = blend(r2, a2); g2 = blend(g2, a2); b2 = blend(b2, a2); } const y1 = rgb2y(r1, g1, b1); const y2 = rgb2y(r2, g2, b2); const y = y1 - y2; if (yOnly) return y; // brightness difference only 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; // 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; } function rgb2i(r, g, b) { return r * 0.59597799 - g * 0.27417610 - b * 0.32180189; } function rgb2q(r, g, b) { return r * 0.21147017 - g * 0.52261711 + b * 0.31114694; } // blend semi-transparent color with white function blend(c, a) { return 255 + (c - 255) * a; } function drawPixel(output, pos, r, g, b) { output[pos + 0] = r; output[pos + 1] = g; output[pos + 2] = b; output[pos + 3] = 255; } 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) { return module = { path: basedir, exports: {}, require: function (path, base) { return commonjsRequire(path, (base === undefined || base === null) ? module.path : base); } }, fn(module, module.exports), module.exports; } function commonjsRequire () { throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs'); } var chunkstream = createCommonjsModule(function (module) { let ChunkStream = (module.exports = function () { Stream__default['default'].call(this); this._buffers = []; this._buffered = 0; this._reads = []; this._paused = false; this._encoding = "utf8"; this.writable = true; }); util__default['default'].inherits(ChunkStream, Stream__default['default']); 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, }); process.nextTick( function () { this._process(); // 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) ); }; ChunkStream.prototype.write = function (data, encoding) { if (!this.writable) { this.emit("error", new Error("Stream not writable")); return false; } let dataBuffer; if (Buffer.isBuffer(data)) { dataBuffer = data; } else { dataBuffer = Buffer.from(data, encoding || this._encoding); } this._buffers.push(dataBuffer); this._buffered += dataBuffer.length; this._process(); // ok if there are no more read requests if (this._reads && this._reads.length === 0) { this._paused = true; } return this.writable && !this._paused; }; ChunkStream.prototype.end = function (data, encoding) { if (data) { this.write(data, encoding); } this.writable = false; // already destroyed if (!this._buffers) { return; } // enqueue or handle end if (this._buffers.length === 0) { this._end(); } else { this._buffers.push(null); this._process(); } }; ChunkStream.prototype.destroySoon = ChunkStream.prototype.end; ChunkStream.prototype._end = function () { if (this._reads.length > 0) { this.emit("error", new Error("Unexpected end of input")); } this.destroy(); }; ChunkStream.prototype.destroy = function () { if (!this._buffers) { return; } this.writable = false; this._reads = null; this._buffers = null; this.emit("close"); }; 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 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 { // ok this is less than maximum length so use it all this._buffered -= smallerBuf.length; this._buffers.shift(); // == smallerBuf read.func.call(this, smallerBuf); } }; ChunkStream.prototype._processRead = function (read) { this._reads.shift(); // == read let pos = 0; let count = 0; let data = Buffer.alloc(read.length); // create buffer for all data while (pos < read.length) { let buf = this._buffers[count++]; let len = Math.min(buf.length, read.length - pos); buf.copy(data, pos, 0, len); pos += len; // last buffer wasn't used all so just slice it and leave if (len !== buf.length) { this._buffers[--count] = buf.slice(len); } } // remove all used buffers if (count > 0) { this._buffers.splice(0, count); } this._buffered -= read.length; read.func.call(this, data); }; 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) { 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) { // ok we can meet some expectations this._processRead(read); } else { // not enought data to satisfy first request in queue // so we need to wait for more break; } } if (this._buffers && !this.writable) { this._end(); } } catch (ex) { this.emit("error", ex); } }; }); // Adam 7 // 0 1 2 3 4 5 6 7 // 0 x 6 4 6 x 6 4 6 // 1 7 7 7 7 7 7 7 7 // 2 5 6 5 6 5 6 5 6 // 3 7 7 7 7 7 7 7 7 // 4 3 6 4 6 3 6 4 6 // 5 7 7 7 7 7 7 7 7 // 6 5 6 5 6 5 6 5 6 // 7 7 7 7 7 7 7 7 7 let imagePasses = [ { // pass 1 - 1px x: [0], y: [0], }, { // pass 2 - 1px x: [4], y: [0], }, { // pass 3 - 2px x: [0, 4], y: [4], }, { // pass 4 - 4px x: [2, 6], y: [0, 4], }, { // pass 5 - 8px x: [0, 2, 4, 6], y: [2, 6], }, { // pass 6 - 16px x: [1, 3, 5, 7], y: [0, 2, 4, 6], }, { // pass 7 - 32px x: [0, 1, 2, 3, 4, 5, 6, 7], y: [1, 3, 5, 7], }, ]; 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 { break; } } for (let j = 0; j < pass.y.length; j++) { if (pass.y[j] < yLeftOver) { passHeight++; } else { break; } } if (passWidth > 0 && passHeight > 0) { images.push({ width: passWidth, height: passHeight, index: i }); } } return images; }; 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; }; }; var interlace = { getImagePasses: getImagePasses, getInterlaceIterator: getInterlaceIterator }; 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) { function getByteWidth(width, bpp, depth) { let byteWidth = width * bpp; if (depth !== 8) { byteWidth = Math.ceil(byteWidth / (8 / depth)); } return byteWidth; } 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; this.complete = dependencies.complete; this._imageIndex = 0; this._images = []; if (interlace$1) { 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, }); } } else { this._images.push({ byteWidth: getByteWidth(width, bpp, depth), height: height, lineIndex: 0, }); } // when filtering the line we look at the pixel to the left // the spec also says it is done on a byte level regardless of the number of pixels // so if the depth is byte compatible (8 or 16) we subtract the bpp in order to compare back // 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) { this._xComparison = bpp * 2; } else { this._xComparison = 1; } }); Filter.prototype.start = function () { this.read( this._images[this._imageIndex].byteWidth + 1, this._reverseFilterLine.bind(this) ); }; Filter.prototype._unFilterType1 = function ( rawData, unfilteredLine, byteWidth ) { let xComparison = this._xComparison; let xBiggerThan = xComparison - 1; 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 ) { let lastLine = this._lastLine; 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 ) { let xComparison = this._xComparison; let xBiggerThan = xComparison - 1; let lastLine = this._lastLine; 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 ) { let xComparison = this._xComparison; let xBiggerThan = xComparison - 1; let lastLine = this._lastLine; 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) { 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 = Buffer.alloc(byteWidth); switch (filter) { case 1: this._unFilterType1(rawData, unfilteredLine, byteWidth); break; case 2: this._unFilterType2(rawData, unfilteredLine, byteWidth); break; case 3: this._unFilterType3(rawData, unfilteredLine, byteWidth); break; case 4: this._unFilterType4(rawData, unfilteredLine, byteWidth); break; default: throw new Error("Unrecognised filter type - " + filter); } } this.write(unfilteredLine); currentImage.lineIndex++; if (currentImage.lineIndex >= currentImage.height) { this._lastLine = null; this._imageIndex++; currentImage = this._images[this._imageIndex]; } 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 { this._lastLine = null; this.complete(); } }; }); var filterParseAsync = createCommonjsModule(function (module) { let FilterAsync = (module.exports = function (bitmapInfo) { chunkstream.call(this); let buffers = []; let that = this; this._filter = new filterParse(bitmapInfo, { read: this.read.bind(this), write: function (buffer) { buffers.push(buffer); }, 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, TYPE_IEND: 0x49454e44, TYPE_IDAT: 0x49444154, TYPE_PLTE: 0x504c5445, TYPE_tRNS: 0x74524e53, // eslint-disable-line camelcase TYPE_gAMA: 0x67414d41, // eslint-disable-line camelcase // color-type bits COLORTYPE_GRAYSCALE: 0, COLORTYPE_PALETTE: 1, COLORTYPE_COLOR: 2, COLORTYPE_ALPHA: 4, // e.g. grayscale and alpha // color-type combinations COLORTYPE_PALETTE_COLOR: 3, COLORTYPE_COLOR_ALPHA: 6, COLORTYPE_TO_BPP_MAP: { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4, }, GAMMA_DIVISION: 100000, }; var crc = createCommonjsModule(function (module) { let crcTable = []; (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 { currentCrc = currentCrc >>> 1; } } crcTable[i] = currentCrc; } })(); let CrcCalculator = (module.exports = function () { this._crc = -1; }); 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 () { return this._crc ^ -1; }; 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; }; }); var parser = createCommonjsModule(function (module) { let Parser = (module.exports = function (options, dependencies) { this._options = options; options.checkCRC = options.checkCRC !== false; this._hasIHDR = false; this._hasIEND = false; this._emittedHeadersFinished = false; // input flags/metadata this._palette = []; this._colorType = 0; this._chunks = {}; this._chunks[constants.TYPE_IHDR] = this._handleIHDR.bind(this); this._chunks[constants.TYPE_IEND] = this._handleIEND.bind(this); this._chunks[constants.TYPE_IDAT] = this._handleIDAT.bind(this); this._chunks[constants.TYPE_PLTE] = this._handlePLTE.bind(this); this._chunks[constants.TYPE_tRNS] = this._handleTRNS.bind(this); this._chunks[constants.TYPE_gAMA] = this._handleGAMA.bind(this); this.read = dependencies.read; this.error = dependencies.error; this.metadata = dependencies.metadata; this.gamma = dependencies.gamma; this.transColor = dependencies.transColor; this.palette = dependencies.palette; this.parsed = dependencies.parsed; this.inflateData = dependencies.inflateData; this.finished = dependencies.finished; this.simpleTransparency = dependencies.simpleTransparency; this.headersFinished = dependencies.headersFinished || function () {}; }); Parser.prototype.start = function () { this.read(constants.PNG_SIGNATURE.length, this._parseSignature.bind(this)); }; Parser.prototype._parseSignature = function (data) { let signature = constants.PNG_SIGNATURE; for (let i = 0; i < signature.length; i++) { if (data[i] !== signature[i]) { this.error(new Error("Invalid file signature")); return; } } this.read(8, this._parseChunkBegin.bind(this)); }; Parser.prototype._parseChunkBegin = function (data) { // chunk content length let length = data.readUInt32BE(0); // chunk type 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 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")); return; } this._crc = new crc(); 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)); return; } this.read(length + 4, this._skipChunk.bind(this)); }; Parser.prototype._skipChunk = function (/*data*/) { this.read(8, this._parseChunkBegin.bind(this)); }; Parser.prototype._handleChunkEnd = function () { this.read(4, this._parseChunkEnd.bind(this)); }; 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)); return; } if (!this._hasIEND) { this.read(8, this._parseChunkBegin.bind(this)); } }; Parser.prototype._handleIHDR = function (length) { this.read(length, this._parseIHDR.bind(this)); }; Parser.prototype._parseIHDR = function (data) { this._crc.write(data); 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)); return; } if (!(colorType in constants.COLORTYPE_TO_BPP_MAP)) { this.error(new Error("Unsupported color type")); return; } if (compr !== 0) { this.error(new Error("Unsupported compression method")); return; } if (filter !== 0) { this.error(new Error("Unsupported filter method")); return; } if (interlace !== 0 && interlace !== 1) { this.error(new Error("Unsupported interlace method")); return; } this._colorType = colorType; let bpp = constants.COLORTYPE_TO_BPP_MAP[this._colorType]; this._hasIHDR = true; this.metadata({ width: width, height: height, depth: depth, interlace: Boolean(interlace), palette: Boolean(colorType & constants.COLORTYPE_PALETTE), color: Boolean(colorType & constants.COLORTYPE_COLOR), alpha: Boolean(colorType & constants.COLORTYPE_ALPHA), bpp: bpp, colorType: colorType, }); this._handleChunkEnd(); }; Parser.prototype._handlePLTE = function (length) { this.read(length, this._parsePLTE.bind(this)); }; Parser.prototype._parsePLTE = function (data) { this._crc.write(data); let entries = Math.floor(data.length / 3); // console.log('Palette:', entries); 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); this._handleChunkEnd(); }; Parser.prototype._handleTRNS = function (length) { this.simpleTransparency(); this.read(length, this._parseTRNS.bind(this)); }; 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")); return; } if (data.length > this._palette.length) { this.error(new Error("More transparent colors than palette size")); return; } for (let i = 0; i < data.length; i++) { this._palette[i][3] = data[i]; } this.palette(this._palette); } // for colorType 0 (grayscale) and 2 (rgb) // there might be one gray/color defined as transparent if (this._colorType === constants.COLORTYPE_GRAYSCALE) { // grey, 2 bytes this.transColor([data.readUInt16BE(0)]); } if (this._colorType === constants.COLORTYPE_COLOR) { this.transColor([ data.readUInt16BE(0), data.readUInt16BE(2), data.readUInt16BE(4), ]); } this._handleChunkEnd(); }; Parser.prototype._handleGAMA = function (length) { this.read(length, this._parseGAMA.bind(this)); }; Parser.prototype._parseGAMA = function (data) { this._crc.write(data); this.gamma(data.readUInt32BE(0) / constants.GAMMA_DIVISION); this._handleChunkEnd(); }; 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) { this._crc.write(data); if ( this._colorType === constants.COLORTYPE_PALETTE_COLOR && this._palette.length === 0 ) { throw new Error("Expected palette not found"); } this.inflateData(data); let leftOverLength = length - data.length; if (leftOverLength > 0) { this._handleIDAT(leftOverLength); } else { this._handleChunkEnd(); } }; Parser.prototype._handleIEND = function (length) { this.read(length, this._parseIEND.bind(this)); }; Parser.prototype._parseIEND = function (data) { this._crc.write(data); this._hasIEND = true; this._handleChunkEnd(); if (this.finished) { this.finished(); } }; }); let pixelBppMapper = [ // 0 - dummy entry function () {}, // 1 - L // 0: 0, 1: 0, 2: 0, 3: 0xff function (pxData, data, pxPos, rawPos) { if (rawPos === data.length) { throw new Error("Ran out of data"); } let pixel = data[rawPos]; pxData[pxPos] = pixel; pxData[pxPos + 1] = pixel; pxData[pxPos + 2] = pixel; pxData[pxPos + 3] = 0xff; }, // 2 - LA // 0: 0, 1: 0, 2: 0, 3: 1 function (pxData, data, pxPos, rawPos) { if (rawPos + 1 >= data.length) { throw new Error("Ran out of data"); } let pixel = data[rawPos]; pxData[pxPos] = pixel; pxData[pxPos + 1] = pixel; pxData[pxPos + 2] = pixel; pxData[pxPos + 3] = data[rawPos + 1]; }, // 3 - RGB // 0: 0, 1: 1, 2: 2, 3: 0xff function (pxData, data, pxPos, rawPos) { if (rawPos + 2 >= data.length) { 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] = 0xff; }, // 4 - RGBA // 0: 0, 1: 1, 2: 2, 3: 3 function (pxData, data, pxPos, rawPos) { if (rawPos + 3 >= data.length) { 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]; }, ]; let pixelBppCustomMapper = [ // 0 - dummy entry function () {}, // 1 - L // 0: 0, 1: 0, 2: 0, 3: 0xff function (pxData, pixelData, pxPos, maxBit) { let pixel = pixelData[0]; pxData[pxPos] = pixel; pxData[pxPos + 1] = pixel; pxData[pxPos + 2] = pixel; pxData[pxPos + 3] = maxBit; }, // 2 - LA // 0: 0, 1: 0, 2: 0, 3: 1 function (pxData, pixelData, pxPos) { let pixel = pixelData[0]; pxData[pxPos] = pixel; pxData[pxPos + 1] = pixel; pxData[pxPos + 2] = pixel; pxData[pxPos + 3] = pixelData[1]; }, // 3 - RGB // 0: 0, 1: 1, 2: 2, 3: 0xff function (pxData, pixelData, pxPos, maxBit) { pxData[pxPos] = pixelData[0]; pxData[pxPos + 1] = pixelData[1]; pxData[pxPos + 2] = pixelData[2]; pxData[pxPos + 3] = maxBit; }, // 4 - RGBA // 0: 0, 1: 1, 2: 2, 3: 3 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) { let leftOver = []; let i = 0; function split() { if (i === data.length) { throw new Error("Ran out of data"); } let byte = data[i]; i++; let byte8, byte7, byte6, byte5, byte4, byte3, byte2, byte1; switch (depth) { default: throw new Error("unrecognised depth"); case 16: byte2 = data[i]; i++; leftOver.push((byte << 8) + byte2); break; case 4: byte2 = byte & 0x0f; byte1 = byte >> 4; leftOver.push(byte1, byte2); break; case 2: byte4 = byte & 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; leftOver.push(byte1, byte2, byte3, byte4, byte5, byte6, byte7, byte8); break; } } return { get: function (count) { while (leftOver.length < count) { split(); } let returner = leftOver.slice(0, count); leftOver = leftOver.slice(count); return returner; }, resetAfterLine: function () { leftOver.length = 0; }, end: function () { if (i !== data.length) { throw new Error("extra data found"); } }, }; } 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 } } return rawPos; } 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) { 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) { bits = bitRetriever(data, depth); } let pxData; if (depth <= 8) { pxData = Buffer.alloc(width * height * 4); } else { pxData = new Uint16Array(width * height * 4); } 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 { let nonInterlacedPxPos = 0; getPxPos = function () { let returner = nonInterlacedPxPos; nonInterlacedPxPos += 4; return returner; }; images = [{ width: width, height: height }]; } 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 ); } } if (depth === 8) { if (rawPos !== data.length) { throw new Error("extra data found"); } } else { bits.end(); } return pxData; }; var bitmapper = { dataToBitMap: dataToBitMap }; function dePalette(indata, outdata, width, height, palette) { let pxPos = 0; // use values from palette 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"); } for (let i = 0; i < 4; i++) { outdata[pxPos + i] = color[i]; } pxPos += 4; } } } function replaceTransparentColor(indata, outdata, width, height, transColor) { 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] ) { makeTrans = true; } if (makeTrans) { for (let i = 0; i < 4; i++) { outdata[pxPos + i] = 0; } } pxPos += 4; } } } function scaleDepth(indata, outdata, width, height, depth) { 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, 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; let outdata = indata; // only different for 16 bits if (colorType === 3) { // paletted dePalette(indata, outdata, width, height, palette); } else { if (transColor) { replaceTransparentColor(indata, outdata, width, height, transColor); } // if it needs scaling if (depth !== 8 && !skipRescale) { // if we need to change the buffer size if (depth === 16) { outdata = Buffer.alloc(width * height * 4); } scaleDepth(indata, outdata, width, height, depth); } } return outdata; }; var parserAsync = createCommonjsModule(function (module) { 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"), 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), }); this._options = options; this.writable = true; this._parser.start(); }); util__default['default'].inherits(ParserAsync, chunkstream); ParserAsync.prototype._handleError = function (err) { this.emit("error", err); this.writable = false; this.destroy(); if (this._inflate && this._inflate.destroy) { this._inflate.destroy(); } if (this._filter) { this._filter.destroy(); // 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.errord = true; }; 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.pipe(this._filter); } 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 }); let leftToInflate = imageSize; 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)); let filterWrite = this._filter.write.bind(this._filter); this._inflate.on("data", function (chunk) { if (!leftToInflate) { return; } if (chunk.length > leftToInflate) { chunk = chunk.slice(0, leftToInflate); } leftToInflate -= chunk.length; filterWrite(chunk); }); this._inflate.on("end", this._filter.end.bind(this._filter)); } } this._inflate.write(data); }; ParserAsync.prototype._handleMetaData = function (metaData) { this._metaData = metaData; this._bitmapInfo = Object.create(metaData); this._filter = new filterParseAsync(this._bitmapInfo); }; ParserAsync.prototype._handleTransColor = function (transColor) { this._bitmapInfo.transColor = transColor; }; ParserAsync.prototype._handlePalette = function (palette) { this._bitmapInfo.palette = palette; }; ParserAsync.prototype._simpleTransparency = function () { this._metaData.alpha = true; }; 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); }; ParserAsync.prototype._finished = function () { if (this.errord) { return; } if (!this._inflate) { this.emit("error", "No Inflate block"); } else { // no more data to inflate this._inflate.end(); } }; ParserAsync.prototype._complete = function (filteredData) { if (this.errord) { return; } let normalisedBitmapData; try { let bitmapData = bitmapper.dataToBitMap(filteredData, this._bitmapInfo); normalisedBitmapData = formatNormaliser( bitmapData, this._bitmapInfo, this._options.skipRescale ); bitmapData = null; } catch (ex) { this._handleError(ex); return; } this.emit("parsed", normalisedBitmapData); }; }); 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) { 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; })(); // If no need to convert to grayscale and alpha is present/absent in both, take a fast route if (options.bitDepth === 8 || (options.bitDepth === 16 && bigEndian)) { return dataIn; } } // map to a UInt16 array if data is 16bit, fix endianness below let data = options.bitDepth !== 16 ? dataIn : new Uint16Array(dataIn.buffer); let maxValue = 255; let inBpp = constants.COLORTYPE_TO_BPP_MAP[options.inputColorType]; if (inBpp === 4 && !options.inputHasAlpha) { inBpp = 3; } let outBpp = constants.COLORTYPE_TO_BPP_MAP[options.colorType]; if (options.bitDepth === 16) { maxValue = 65535; outBpp *= 2; } let outData = Buffer.alloc(width * height * outBpp); let inIndex = 0; let outIndex = 0; let bgColor = options.bgColor || {}; if (bgColor.red === undefined) { bgColor.red = maxValue; } if (bgColor.green === undefined) { bgColor.green = maxValue; } if (bgColor.blue === undefined) { bgColor.blue = maxValue; } function getRGBA() { let red; let green; let blue; let alpha = maxValue; switch (options.inputColorType) { case constants.COLORTYPE_COLOR_ALPHA: alpha = data[inIndex + 3]; red = data[inIndex]; green = data[inIndex + 1]; blue = data[inIndex + 2]; break; case constants.COLORTYPE_COLOR: red = data[inIndex]; green = data[inIndex + 1]; blue = data[inIndex + 2]; break; case constants.COLORTYPE_ALPHA: alpha = data[inIndex + 1]; red = data[inIndex]; green = red; blue = red; break; case constants.COLORTYPE_GRAYSCALE: red = data[inIndex]; green = red; blue = red; break; default: 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 ); } } return { red: red, green: green, blue: blue, alpha: alpha }; } 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: case constants.COLORTYPE_COLOR: if (options.bitDepth === 8) { outData[outIndex] = rgba.red; outData[outIndex + 1] = rgba.green; outData[outIndex + 2] = rgba.blue; if (outHasAlpha) { outData[outIndex + 3] = rgba.alpha; } } else { outData.writeUInt16BE(rgba.red, outIndex); outData.writeUInt16BE(rgba.green, outIndex + 2); outData.writeUInt16BE(rgba.blue, outIndex + 4); if (outHasAlpha) { outData.writeUInt16BE(rgba.alpha, outIndex + 6); } } break; case constants.COLORTYPE_ALPHA: case constants.COLORTYPE_GRAYSCALE: { // Convert to grayscale and alpha let grayscale = (rgba.red + rgba.green + rgba.blue) / 3; if (options.bitDepth === 8) { outData[outIndex] = grayscale; if (outHasAlpha) { outData[outIndex + 1] = rgba.alpha; } } else { outData.writeUInt16BE(grayscale, outIndex); if (outHasAlpha) { outData.writeUInt16BE(rgba.alpha, outIndex + 2); } } break; } default: throw new Error("unrecognised color Type " + options.colorType); } inIndex += inBpp; outIndex += outBpp; } } return outData; }; function filterNone(pxData, pxPos, byteWidth, rawData, rawPos) { 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; for (let i = pxPos; i < length; i++) { sum += Math.abs(pxData[i]); } return sum; } function filterSub(pxData, pxPos, byteWidth, rawData, rawPos, bpp) { 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) { 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); } return sum; } function filterUp(pxData, pxPos, byteWidth, rawData, rawPos) { 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) { 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); } return sum; } function filterAvg(pxData, pxPos, byteWidth, rawData, rawPos, bpp) { 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) { 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); } return sum; } function filterPaeth(pxData, pxPos, byteWidth, rawData, rawPos, bpp) { 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) { 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); } return sum; } let filters = { 0: filterNone, 1: filterSub, 2: filterUp, 3: filterAvg, 4: filterPaeth, }; let filterSums = { 0: filterSumNone, 1: filterSumSub, 2: filterSumUp, 3: filterSumAvg, 4: filterSumPaeth, }; 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") { filterTypes = [options.filterType]; } else { throw new Error("unrecognised filter types"); } if (options.bitDepth === 16) { bpp *= 2; } let byteWidth = width * bpp; let rawPos = 0; let pxPos = 0; let rawData = Buffer.alloc((byteWidth + 1) * height); 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) let min = Infinity; 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; } } } rawData[rawPos] = sel; rawPos++; filters[sel](pxData, pxPos, byteWidth, rawData, rawPos, bpp); rawPos += byteWidth; pxPos += byteWidth; } return rawData; }; var packer = createCommonjsModule(function (module) { 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.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" ); } if (options.bitDepth !== 8 && options.bitDepth !== 16) { throw new Error( "option bit depth:" + options.bitDepth + " is not supported at present" ); } }); Packer.prototype.getDeflateOptions = function () { return { chunkSize: this._options.deflateChunkSize, level: this._options.deflateLevel, strategy: this._options.deflateStrategy, }; }; Packer.prototype.createDeflate = function () { return this._options.deflateFactory(this.getDeflateOptions()); }; Packer.prototype.filterData = function (data, width, height) { // convert to correct format for filtering (e.g. right bpp and bit depth) let packedData = bitpacker(data, width, height, this._options); // filter pixel data 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) { let len = data ? data.length : 0; let buf = Buffer.alloc(len + 12); buf.writeUInt32BE(len, 0); buf.writeUInt32BE(type, 4); if (data) { data.copy(buf, 8); } buf.writeInt32BE( crc.crc32(buf.slice(4, buf.length - 4)), buf.length - 4 ); return buf; }; 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) { let buf = Buffer.alloc(13); buf.writeUInt32BE(width, 0); buf.writeUInt32BE(height, 4); buf[8] = this._options.bitDepth; // Bit depth buf[9] = this._options.colorType; // colorType buf[10] = 0; // compression buf[11] = 0; // filter buf[12] = 0; // interlace return this._packChunk(constants.TYPE_IHDR, buf); }; Packer.prototype.packIDAT = function (data) { return this._packChunk(constants.TYPE_IDAT, data); }; Packer.prototype.packIEND = function () { return this._packChunk(constants.TYPE_IEND, null); }; }); var packerAsync = createCommonjsModule(function (module) { let PackerAsync = (module.exports = function (opt) { Stream__default['default'].call(this); 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) { // Signature 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)); } let filteredData = this._packer.filterData(data, width, height); // compress it 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( "end", function () { this.emit("data", this._packer.packIEND()); this.emit("end"); }.bind(this) ); this._deflate.end(filteredData); }; }); var syncInflate = createCommonjsModule(function (module, exports) { let assert = require$$0__default['default'].ok; let kMaxLength = require$$1__default['default'].kMaxLength; function Inflate(opts) { if (!(this instanceof Inflate)) { return new Inflate(opts); } if (opts && opts.chunkSize < zlib__default['default'].Z_MIN_CHUNK) { opts.chunkSize = zlib__default['default'].Z_MIN_CHUNK; } zlib__default['default'].Inflate.call(this, opts); // Node 8 --> 9 compatibility check this._offset = this._offset === undefined ? this._outOffset : this._offset; this._buffer = this._buffer || this._outBuffer; if (opts && opts.maxLength != null) { this._maxLength = opts.maxLength; } } function createInflate(opts) { return new Inflate(opts); } function _close(engine, callback) { if (callback) { process.nextTick(callback); } // Caller may invoke .close after a zlib error (which will null _handle). if (!engine._handle) { return; } engine._handle.close(); engine._handle = null; } Inflate.prototype._processChunk = function (chunk, flushFlag, asyncCb) { if (typeof asyncCb === "function") { return zlib__default['default'].Inflate._processChunk.call(this, chunk, flushFlag, asyncCb); } let self = this; let availInBefore = chunk && chunk.length; let availOutBefore = this._chunkSize - this._offset; let leftToInflate = this._maxLength; let inOff = 0; let buffers = []; let nread = 0; let error; this.on("error", function (err) { error = err; }); function handleChunk(availInAfter, availOutAfter) { if (self._hadError) { return; } let have = availOutBefore - availOutAfter; assert(have >= 0, "have should not go down"); if (have > 0) { let out = self._buffer.slice(self._offset, self._offset + have); self._offset += have; if (out.length > leftToInflate) { out = out.slice(0, leftToInflate); } buffers.push(out); nread += out.length; leftToInflate -= out.length; if (leftToInflate === 0) { return false; } } if (availOutAfter === 0 || self._offset >= self._chunkSize) { availOutBefore = self._chunkSize; self._offset = 0; self._buffer = Buffer.allocUnsafe(self._chunkSize); } if (availOutAfter === 0) { inOff += availInBefore - availInAfter; availInBefore = availInAfter; return true; } return false; } assert(this._handle, "zlib binding closed"); let res; do { res = this._handle.writeSync( flushFlag, chunk, // in inOff, // in_off availInBefore, // in_len this._buffer, // out this._offset, //out_off availOutBefore ); // out_len // Node 8 --> 9 compatibility check res = res || this._writeState; } while (!this._hadError && handleChunk(res[0], res[1])); if (this._hadError) { throw error; } if (nread >= kMaxLength) { _close(this); throw new RangeError( "Cannot create final Buffer. It would be larger than 0x" + kMaxLength.toString(16) + " bytes" ); } let buf = Buffer.concat(buffers, nread); _close(this); return buf; }; util__default['default'].inherits(Inflate, zlib__default['default'].Inflate); function zlibBufferSync(engine, buffer) { if (typeof buffer === "string") { buffer = Buffer.from(buffer); } if (!(buffer instanceof Buffer)) { throw new TypeError("Not a string or buffer"); } let flushFlag = engine._finishFlushFlag; if (flushFlag == null) { flushFlag = zlib__default['default'].Z_FINISH; } return engine._processChunk(buffer, flushFlag); } function inflateSync(buffer, opts) { return zlibBufferSync(new Inflate(opts), buffer); } module.exports = exports = inflateSync; exports.Inflate = Inflate; exports.createInflate = createInflate; exports.inflateSync = inflateSync; }); var syncReader = createCommonjsModule(function (module) { let SyncReader = (module.exports = function (buffer) { this._buffer = buffer; this._reads = []; }); 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, }); }; 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]; 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 let buf = this._buffer; this._buffer = buf.slice(read.length); read.func.call(this, buf.slice(0, read.length)); } else { break; } } if (this._reads.length > 0) { throw new Error("There are some read requests waitng on finished stream"); } if (this._buffer.length > 0) { throw new Error("unrecognised content at end of stream"); } }; }); 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) { outBuffers.push(bufferPart); }, complete: function () {}, }); filter.start(); reader.process(); return Buffer.concat(outBuffers); }; var filterParseSync = { process: process_1 }; let hasSyncZlib$1 = true; if (!zlib__default['default'].deflateSync) { hasSyncZlib$1 = false; } 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" ); } let err; function handleError(_err_) { err = _err_; } let metaData; function handleMetaData(_metaData_) { metaData = _metaData_; } function handleTransColor(transColor) { metaData.transColor = transColor; } function handlePalette(palette) { metaData.palette = palette; } function handleSimpleTransparency() { metaData.alpha = true; } let gamma; function handleGamma(_gamma_) { gamma = _gamma_; } let inflateDataList = []; function handleInflateData(inflatedData) { inflateDataList.push(inflatedData); } let reader = new syncReader(buffer); let parser$1 = new parser(options, { read: reader.read.bind(reader), error: handleError, metadata: handleMetaData, gamma: handleGamma, palette: handlePalette, transColor: handleTransColor, inflateData: handleInflateData, simpleTransparency: handleSimpleTransparency, }); parser$1.start(); reader.process(); if (err) { throw err; } //join together the inflate datas let inflateData = Buffer.concat(inflateDataList); inflateDataList.length = 0; let inflatedData; if (metaData.interlace) { inflatedData = zlib__default['default'].inflateSync(inflateData); } 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"); } let unfilteredData = filterParseSync.process(inflatedData, metaData); inflateData = null; let bitmapData = bitmapper.dataToBitMap(unfilteredData, metaData); unfilteredData = null; let normalisedBitmapData = formatNormaliser( bitmapData, metaData, options.skipRescale ); metaData.data = normalisedBitmapData; metaData.gamma = gamma || 0; return metaData; }; let hasSyncZlib = true; if (!zlib__default['default'].deflateSync) { hasSyncZlib = false; } 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" ); } let options = opt || {}; let packer$1 = new packer(options); let chunks = []; // Signature chunks.push(Buffer.from(constants.PNG_SIGNATURE)); // Header chunks.push(packer$1.packIHDR(metaData.width, metaData.height)); if (metaData.gamma) { chunks.push(packer$1.packGAMA(metaData.gamma)); } let filteredData = packer$1.filterData( metaData.data, metaData.width, metaData.height ); // compress it 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"); } chunks.push(packer$1.packIDAT(compressedData)); // End chunks.push(packer$1.packIEND()); return Buffer.concat(chunks); }; var read = function (buffer, options) { return parserSync(buffer, options || {}); }; var write = function (png, options) { return packerSync(png, options); }; var pngSync = { read: read, write: write }; var png = createCommonjsModule(function (module, exports) { let PNG = (exports.PNG = function (options) { Stream__default['default'].call(this); options = options || {}; // eslint-disable-line no-param-reassign // coerce pixel dimensions to integers (also coerces undefined -> 0): this.width = options.width | 0; this.height = options.height | 0; 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); } this.gamma = 0; this.readable = this.writable = true; 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._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")); }); util__default['default'].inherits(PNG, Stream__default['default']); PNG.sync = pngSync; PNG.prototype.pack = function () { if (!this.data || !this.data.length) { this.emit("error", "No data provided"); return 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) { if (callback) { let onParsed, onError; onParsed = function (parsedData) { this.removeListener("error", onError); this.data = parsedData; callback(null, this); }.bind(this); onError = function (err) { this.removeListener("parsed", onParsed); callback(err, null); }.bind(this); this.once("parsed", onParsed); this.once("error", onError); } this.end(data); return this; }; PNG.prototype.write = function (data) { this._parser.write(data); return true; }; PNG.prototype.end = function (data) { this._parser.end(data); }; PNG.prototype._metadata = function (metadata) { this.width = metadata.width; this.height = metadata.height; this.emit("metadata", metadata); }; PNG.prototype._gamma = function (gamma) { this.gamma = gamma; }; PNG.prototype._handleClose = function () { if (!this._parser.writable && !this._packer.readable) { this.emit("close"); } }; 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; srcY |= 0; width |= 0; height |= 0; deltaX |= 0; 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 ( deltaX > dst.width || deltaY > dst.height || deltaX + width > dst.width || deltaY + height > dst.height ) { throw new Error("bitblt writing outside image"); } 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 ); } }; 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) { if (src.gamma) { for (let y = 0; y < src.height; y++) { for (let x = 0; x < src.width; x++) { let idx = (src.width * y + x) << 2; 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); } } } src.gamma = 0; } }; PNG.prototype.adjustGamma = function () { PNG.adjustGamma(this); }; }); function getMismatchedPixels(pixelMatchInput) { const imgA = fs__default['default'].createReadStream(pixelMatchInput.imageAPath).pipe(new png.PNG()).on('parsed', doneReading); const imgB = fs__default['default'].createReadStream(pixelMatchInput.imageBPath).pipe(new png.PNG()).on('parsed', doneReading); let filesRead = 0; function doneReading() { if (++filesRead < 2) return; const mismatchedPixels = pixelmatch_1(imgA.data, imgB.data, null, pixelMatchInput.width, pixelMatchInput.height, { threshold: pixelMatchInput.pixelmatchThreshold, includeAA: false, }); process.send(mismatchedPixels); } } process.on('message', getMismatchedPixels);