pngjs - npm Package Compare versions

.eslintrc

.idea/.name

.idea/jsLibraryMappings.xml

.idea/libraries/node_pngjs2_node_modules.xml

.idea/misc.xml

.idea/modules.xml

.idea/node-pngjs2.iml

.idea/vcs.xml

.idea/workspace.xml

lib/bitmapper.js

lib/bitpacker.js

lib/filter-pack.js

lib/filter-parse-async.js

lib/filter-parse-sync.js

lib/filter-parse.js

lib/format-normaliser.js

lib/interlace.js

lib/paeth-predictor.js

lib/parser-async.js

lib/parser-sync.js

lib/png-sync.js

lib/sync-reader.js

251

lib/chunkstream.js

		@@ -1,39 +0,19 @@
		// Copyright (c) 2012 Kuba Niegowski
		//
		// Permission is hereby granted, free of charge, to any person obtaining a copy
		// of this software and associated documentation files (the "Software"), to deal
		// in the Software without restriction, including without limitation the rights
		// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		// copies of the Software, and to permit persons to whom the Software is
		// furnished to do so, subject to the following conditions:
		//
		// The above copyright notice and this permission notice shall be included in
		// all copies or substantial portions of the Software.
		//
		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
		// THE SOFTWARE.

		'use strict';


		var util = require('util'),
		Stream = require('stream');
		var util = require('util');
		var Stream = require('stream');


		var ChunkStream = module.exports = function() {
		Stream.call(this);
		Stream.call(this);

		this._buffers = [];
		this._buffered = 0;
		this._buffers = [];
		this._buffered = 0;

		this._reads = [];
		this._paused = false;
		this._reads = [];
		this._paused = false;

		this._encoding = 'utf8';
		this.writable = true;
		this._encoding = 'utf8';
		this.writable = true;
		};
		@@ -45,8 +25,9 @@ util.inherits(ChunkStream, Stream);

		this._reads.push({
		length: Math.abs(length), // if length < 0 then at most this length
		allowLess: length < 0,
		func: 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();
		@@ -56,6 +37,7 @@
		if (this._paused && this._reads.length > 0) {
		this._paused = false;
		this._paused = false;

		this.emit('drain');
		this.emit('drain');
		}
		}.bind(this));
		};
		@@ -65,20 +47,26 @@

		if (!this.writable) {
		this.emit('error', new Error('Stream not writable'));
		return false;
		}
		if (!this.writable) {
		this.emit('error', new Error('Stream not writable'));
		return false;
		}

		if (!Buffer.isBuffer(data))
		data = new Buffer(data, encoding \|\| this._encoding);
		var dataBuffer;
		if (Buffer.isBuffer(data)) {
		dataBuffer = data;
		}
		else {
		dataBuffer = new Buffer(data, encoding \|\| this._encoding);
		}

		this._buffers.push(data);
		this._buffered += data.length;
		this._buffers.push(dataBuffer);
		this._buffered += dataBuffer.length;

		this._process();
		this._process();

		// ok if there are no more read requests
		if (this._reads && this._reads.length == 0)
		this._paused = true;
		// ok if there are no more read requests
		if (this._reads && this._reads.length === 0) {
		this._paused = true;
		}

		return this.writable && !this._paused;
		return this.writable && !this._paused;
		};
		@@ -88,16 +76,21 @@

		if (data) this.write(data, encoding);
		if (data) {
		this.write(data, encoding);
		}

		this.writable = false;
		this.writable = false;

		// already destroyed
		if (!this._buffers) return;
		// already destroyed
		if (!this._buffers) {
		return;
		}

		// enqueue or handle end
		if (this._buffers.length == 0) {
		this._end();
		} else {
		this._buffers.push(null);
		this._process();
		}
		// enqueue or handle end
		if (this._buffers.length === 0) {
		this._end();
		}
		else {
		this._buffers.push(null);
		this._process();
		}
		};
		@@ -109,9 +102,9 @@

		if (this._reads.length > 0) {
		this.emit('error',
		new Error('There are some read requests waitng on finished stream')
		);
		}
		if (this._reads.length > 0) {
		this.emit('error',
		new Error('There are some read requests waitng on finished stream')
		);
		}

		this.destroy();
		this.destroy();
		};
		@@ -121,84 +114,102 @@

		if (!this._buffers) return;
		if (!this._buffers) {
		return;
		}

		this.writable = false;
		this._reads = null;
		this._buffers = null;
		this.writable = false;
		this._reads = null;
		this._buffers = null;

		this.emit('close');
		this.emit('close');
		};

		ChunkStream.prototype._process = function() {
		ChunkStream.prototype._processReadAllowingLess = function(read) {
		// ok there is any data so that we can satisfy this request
		this._reads.shift(); // == read

		// as long as there is any data and read requests
		while (this._buffered > 0 && this._reads && this._reads.length > 0) {
		// first we need to peek into first buffer
		var smallerBuf = this._buffers[0];

		var read = this._reads[0];
		// ok there is more data than we need
		if (smallerBuf.length > read.length) {

		// read any data (but no more than length)
		if (read.allowLess) {
		this._buffered -= read.length;
		this._buffers[0] = smallerBuf.slice(read.length);

		// ok there is any data so that we can satisfy this request
		this._reads.shift(); // == read
		read.func.call(this, smallerBuf.slice(0, read.length));

		// first we need to peek into first buffer
		var buf = this._buffers[0];
		}
		else {
		// ok this is less than maximum length so use it all
		this._buffered -= smallerBuf.length;
		this._buffers.shift(); // == smallerBuf

		// ok there is more data than we need
		if (buf.length > read.length) {
		read.func.call(this, smallerBuf);
		}
		};

		this._buffered -= read.length;
		this._buffers[0] = buf.slice(read.length);
		ChunkStream.prototype._processRead = function(read) {
		this._reads.shift(); // == read

		read.func.call(this, buf.slice(0, read.length));
		var pos = 0;
		var count = 0;
		var data = new Buffer(read.length);

		} else {
		// ok this is less than maximum length so use it all
		this._buffered -= buf.length;
		this._buffers.shift(); // == buf
		// create buffer for all data
		while (pos < read.length) {

		read.func.call(this, buf);
		}
		var buf = this._buffers[count++];
		var len = Math.min(buf.length, read.length - pos);

		} else if (this._buffered >= read.length) {
		// ok we can meet some expectations
		buf.copy(data, pos, 0, len);
		pos += len;

		this._reads.shift(); // == read
		// last buffer wasn't used all so just slice it and leave
		if (len !== buf.length) {
		this._buffers[--count] = buf.slice(len);
		}
		}

		var pos = 0,
		count = 0,
		data = new Buffer(read.length);
		// remove all used buffers
		if (count > 0) {
		this._buffers.splice(0, count);
		}

		// create buffer for all data
		while (pos < read.length) {
		this._buffered -= read.length;

		var buf = this._buffers[count++],
		len = Math.min(buf.length, read.length - pos);
		read.func.call(this, data);
		};

		buf.copy(data, pos, 0, len);
		pos += len;
		ChunkStream.prototype._process = function() {

		// last buffer wasn't used all so just slice it and leave
		if (len != buf.length)
		this._buffers[--count] = buf.slice(len);
		}
		try {
		// as long as there is any data and read requests
		while (this._buffered > 0 && this._reads && this._reads.length > 0) {

		// remove all used buffers
		if (count > 0)
		this._buffers.splice(0, count);
		var read = this._reads[0];

		this._buffered -= read.length;
		// read any data (but no more than length)
		if (read.allowLess) {
		this._processReadAllowingLess(read);

		read.func.call(this, data);
		}
		else if (this._buffered >= read.length) {
		// ok we can meet some expectations

		} else {
		// not enought data to satisfy first request in queue
		// so we need to wait for more
		break;
		}
		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._buffers.length > 0 && this._buffers[0] == null) {
		this._end();
		if (this._buffers && this._buffers.length > 0 && this._buffers[0] === null) {
		this._end();
		}
		}
		catch (ex) {
		this.emit('error', ex);
		}
		};

56

lib/constants.js

		@@ -1,21 +0,1 @@
		// Copyright (c) 2012 Kuba Niegowski
		//
		// Permission is hereby granted, free of charge, to any person obtaining a copy
		// of this software and associated documentation files (the "Software"), to deal
		// in the Software without restriction, including without limitation the rights
		// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		// copies of the Software, and to permit persons to whom the Software is
		// furnished to do so, subject to the following conditions:
		//
		// The above copyright notice and this permission notice shall be included in
		// all copies or substantial portions of the Software.
		//
		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
		// THE SOFTWARE.

		'use strict';
		@@ -26,14 +6,30 @@

		PNG_SIGNATURE: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a],
		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,
		TYPE_gAMA: 0x67414d41,
		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_PALETTE: 1,
		COLOR_COLOR: 2,
		COLOR_ALPHA: 4
		// 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
		};

95

lib/crc.js

		@@ -1,79 +0,44 @@
		// Copyright (c) 2012 Kuba Niegowski
		//
		// Permission is hereby granted, free of charge, to any person obtaining a copy
		// of this software and associated documentation files (the "Software"), to deal
		// in the Software without restriction, including without limitation the rights
		// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		// copies of the Software, and to permit persons to whom the Software is
		// furnished to do so, subject to the following conditions:
		//
		// The above copyright notice and this permission notice shall be included in
		// all copies or substantial portions of the Software.
		//
		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
		// THE SOFTWARE.

		'use strict';

		var util = require('util'),
		Stream = require('stream');
		var crcTable = [];

		(function() {
		for (var i = 0; i < 256; i++) {
		var currentCrc = i;
		for (var j = 0; j < 8; j++) {
		if (currentCrc & 1) {
		currentCrc = 0xedb88320 ^ (currentCrc >>> 1);
		}
		else {
		currentCrc = currentCrc >>> 1;
		}
		}
		crcTable[i] = currentCrc;
		}
		}());

		var CrcStream = module.exports = function() {
		Stream.call(this);

		this._crc = -1;

		this.writable = true;
		var CrcCalculator = module.exports = function() {
		this._crc = -1;
		};
		util.inherits(CrcStream, Stream);

		CrcCalculator.prototype.write = function(data) {

		CrcStream.prototype.write = function(data) {

		for (var i = 0; i < data.length; i++) {
		this._crc = crcTable[(this._crc ^ data[i]) & 0xff] ^ (this._crc >>> 8);
		}
		return true;
		for (var i = 0; i < data.length; i++) {
		this._crc = crcTable[(this._crc ^ data[i]) & 0xff] ^ (this._crc >>> 8);
		}
		return true;
		};

		CrcStream.prototype.end = function(data) {
		if (data) this.write(data);

		this.emit('crc', this.crc32());
		CrcCalculator.prototype.crc32 = function() {
		return this._crc ^ -1;
		};

		CrcStream.prototype.crc32 = function() {
		return this._crc ^ -1;
		};

		CrcCalculator.crc32 = function(buf) {

		CrcStream.crc32 = function(buf) {

		var crc = -1;
		for (var i = 0; i < buf.length; i++) {
		crc = crcTable[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
		}
		return crc ^ -1;
		var crc = -1;
		for (var i = 0; i < buf.length; i++) {
		crc = crcTable[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
		}
		return crc ^ -1;
		};



		var crcTable = [];

		for (var i = 0; i < 256; i++) {
		var c = i;
		for (var j = 0; j < 8; j++) {
		if (c & 1) {
		c = 0xedb88320 ^ (c >>> 1);
		} else {
		c = c >>> 1;
		}
		}
		crcTable[i] = c;
		}

154

lib/packer.js

		@@ -1,42 +0,32 @@
		// Copyright (c) 2012 Kuba Niegowski
		//
		// Permission is hereby granted, free of charge, to any person obtaining a copy
		// of this software and associated documentation files (the "Software"), to deal
		// in the Software without restriction, including without limitation the rights
		// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		// copies of the Software, and to permit persons to whom the Software is
		// furnished to do so, subject to the following conditions:
		//
		// The above copyright notice and this permission notice shall be included in
		// all copies or substantial portions of the Software.
		//
		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
		// THE SOFTWARE.

		'use strict';

		var util = require('util');
		var Stream = require('stream');
		var zlib = require('zlib');
		var filter = require('./filter-pack');
		var CrcStream = require('./crc');
		var constants = require('./constants');
		var bitPacker = require('./bitpacker');

		var util = require('util'),
		Stream = require('stream'),
		zlib = require('zlib'),
		Filter = require('./filter'),
		CrcStream = require('./crc'),
		constants = require('./constants');
		var Packer = module.exports = function(options) {
		Stream.call(this);

		this._options = options;

		var Packer = module.exports = function(options) {
		Stream.call(this);
		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.createDeflate;
		options.bitDepth = options.bitDepth \|\| 8;
		options.colorType = (typeof options.colorType === 'number') ? options.colorType : constants.COLORTYPE_COLOR_ALPHA;

		this._options = options;
		if (options.colorType !== constants.COLORTYPE_COLOR && options.colorType !== constants.COLORTYPE_COLOR_ALPHA) {
		throw new Error('option color type:' + options.colorType + ' is not supported at present');
		}
		if (options.bitDepth !== 8) {
		throw new Error('option bit depth:' + options.bitDepth + ' is not supported at present');
		}

		options.deflateChunkSize = options.deflateChunkSize \|\| 32 * 1024;
		options.deflateLevel = options.deflateLevel \|\| 9;
		options.deflateStrategy = options.deflateStrategy \|\| 3;

		this.readable = true;
		this.readable = true;
		};
		@@ -46,30 +36,36 @@ util.inherits(Packer, Stream);

		Packer.prototype.pack = function(data, width, height) {
		Packer.prototype.pack = function(data, width, height, gamma) {
		// Signature
		this.emit('data', new Buffer(constants.PNG_SIGNATURE));
		this.emit('data', this._packIHDR(width, height, this._options.bitDepth, this._options.colorType));

		// Signature
		this.emit('data', new Buffer(constants.PNG_SIGNATURE));
		this.emit('data', this._packIHDR(width, height));
		if (gamma) {
		this.emit('data', this._packGAMA(gamma));
		}

		// filter pixel data
		var filter = new Filter(width, height, 4, data, this._options);
		var data = filter.filter();
		// convert to correct format for filtering (e.g. right bpp and bit depth)
		var packedData = bitPacker(data, width, height, this._options);

		// compress it
		var deflate = zlib.createDeflate({
		chunkSize: this._options.deflateChunkSize,
		level: this._options.deflateLevel,
		strategy: this._options.deflateStrategy
		});
		deflate.on('error', this.emit.bind(this, 'error'));
		// filter pixel data
		var bpp = constants.COLORTYPE_TO_BPP_MAP[this._options.colorType];
		var filteredData = filter(packedData, width, height, this._options, bpp);

		deflate.on('data', function(data) {
		this.emit('data', this._packIDAT(data));
		}.bind(this));
		// compress it
		var deflate = this._options.deflateFactory({
		chunkSize: this._options.deflateChunkSize,
		level: this._options.deflateLevel,
		strategy: this._options.deflateStrategy
		});
		deflate.on('error', this.emit.bind(this, 'error'));

		deflate.on('end', function() {
		this.emit('data', this._packIEND());
		this.emit('end');
		}.bind(this));
		deflate.on('data', function(compressedData) {
		this.emit('data', this._packIDAT(compressedData));
		}.bind(this));

		deflate.end(data);
		deflate.on('end', function() {
		this.emit('data', this._packIEND());
		this.emit('end');
		}.bind(this));

		deflate.end(filteredData);
		};
		@@ -79,34 +75,42 @@

		var len = (data ? data.length : 0),
		buf = new Buffer(len + 12);
		var len = (data ? data.length : 0);
		var buf = new Buffer(len + 12);

		buf.writeUInt32BE(len, 0);
		buf.writeUInt32BE(type, 4);
		buf.writeUInt32BE(len, 0);
		buf.writeUInt32BE(type, 4);

		if (data) data.copy(buf, 8);
		if (data) {
		data.copy(buf, 8);
		}

		buf.writeInt32BE(CrcStream.crc32(buf.slice(4, buf.length - 4)), buf.length - 4);
		return buf;
		buf.writeInt32BE(CrcStream.crc32(buf.slice(4, buf.length - 4)), buf.length - 4);
		return buf;
		};

		Packer.prototype._packIHDR = function(width, height) {
		Packer.prototype._packGAMA = function(gamma) {
		var buf = new Buffer(4);
		buf.writeUInt32BE(Math.floor(gamma * constants.GAMMA_DIVISION), 0);
		return this._packChunk(constants.TYPE_gAMA, buf);
		};

		var buf = new Buffer(13);
		buf.writeUInt32BE(width, 0);
		buf.writeUInt32BE(height, 4);
		buf[8] = 8;
		buf[9] = 6; // colorType
		buf[10] = 0; // compression
		buf[11] = 0; // filter
		buf[12] = 0; // interlace
		Packer.prototype._packIHDR = function(width, height, bitDepth, colorType) {

		return this._packChunk(constants.TYPE_IHDR, buf);
		var buf = new Buffer(13);
		buf.writeUInt32BE(width, 0);
		buf.writeUInt32BE(height, 4);
		buf[8] = bitDepth; // Bit depth
		buf[9] = 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);
		return this._packChunk(constants.TYPE_IDAT, data);
		};

		Packer.prototype._packIEND = function() {
		return this._packChunk(constants.TYPE_IEND, null);
		return this._packChunk(constants.TYPE_IEND, null);
		};

453

lib/parser.js

		@@ -1,92 +0,56 @@
		// Copyright (c) 2012 Kuba Niegowski
		//
		// Permission is hereby granted, free of charge, to any person obtaining a copy
		// of this software and associated documentation files (the "Software"), to deal
		// in the Software without restriction, including without limitation the rights
		// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		// copies of the Software, and to permit persons to whom the Software is
		// furnished to do so, subject to the following conditions:
		//
		// The above copyright notice and this permission notice shall be included in
		// all copies or substantial portions of the Software.
		//
		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
		// THE SOFTWARE.

		'use strict';

		var constants = require('./constants');
		var CrcCalculator = require('./crc');

		var util = require('util'),
		zlib = require('zlib'),
		CrcStream = require('./crc'),
		ChunkStream = require('./chunkstream'),
		constants = require('./constants'),
		Filter = require('./filter');

		var Parser = module.exports = function(options, dependencies) {

		var Parser = module.exports = function(options) {
		ChunkStream.call(this);
		this._options = options;
		options.checkCRC = options.checkCRC !== false;

		this._options = options;
		options.checkCRC = options.checkCRC !== false;
		this._hasIHDR = false;
		this._hasIEND = false;

		this._hasIHDR = false;
		this._hasIEND = false;
		// input flags/metadata
		this._palette = [];
		this._colorType = 0;

		this._inflate = null;
		this._filter = null;
		this._crc = null;
		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);

		// 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.writable = true;

		this.on('error', this._handleError.bind(this));
		this._handleSignature();
		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.inflateData = dependencies.inflateData;
		this.finished = dependencies.finished;
		};
		util.inherits(Parser, ChunkStream);


		Parser.prototype._handleError = function() {

		this.writable = false;

		this.destroy();

		if (this._inflate)
		this._inflate.destroy();
		Parser.prototype.start = function() {
		this.read(constants.PNG_SIGNATURE.length,
		this._parseSignature.bind(this)
		);
		};

		Parser.prototype._handleSignature = function() {
		this.read(constants.PNG_SIGNATURE.length,
		this._parseSignature.bind(this)
		);
		};

		Parser.prototype._parseSignature = function(data) {

		var signature = constants.PNG_SIGNATURE;
		var signature = constants.PNG_SIGNATURE;

		for (var i = 0; i < signature.length; i++) {
		if (data[i] != signature[i]) {
		this.emit('error', new Error('Invalid file signature'));
		return;
		}
		for (var 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));
		}
		this.read(8, this._parseChunkBegin.bind(this));
		};
		@@ -96,43 +60,45 @@

		// chunk content length
		var length = data.readUInt32BE(0);
		// chunk content length
		var length = data.readUInt32BE(0);

		// chunk type
		var type = data.readUInt32BE(4),
		name = '';
		for (var i = 4; i < 8; i++)
		name += String.fromCharCode(data[i]);
		// chunk type
		var type = data.readUInt32BE(4);
		var name = '';
		for (var i = 4; i < 8; i++) {
		name += String.fromCharCode(data[i]);
		}

		// console.log('chunk ', name, length);
		//console.log('chunk ', name, length);

		// chunk flags
		var ancillary = !!(data[4] & 0x20), // or critical
		priv = !!(data[5] & 0x20), // or public
		safeToCopy = !!(data[7] & 0x20); // or unsafe
		// chunk flags
		var 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.emit('error', new Error('Expected IHDR on beggining'));
		return;
		}
		if (!this._hasIHDR && type !== constants.TYPE_IHDR) {
		this.error(new Error('Expected IHDR on beggining'));
		return;
		}

		this._crc = new CrcStream();
		this._crc.write(new Buffer(name));
		this._crc = new CrcCalculator();
		this._crc.write(new Buffer(name));

		if (this._chunks[type]) {
		return this._chunks[type](length);
		if (this._chunks[type]) {
		return this._chunks[type](length);
		}

		} else if (!ancillary) {
		this.emit('error', new Error('Unsupported critical chunk type ' + name));
		return;
		} else {
		this.read(length + 4, this._skipChunk.bind(this));
		}
		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._skipChunk = function(/data/) {
		this.read(8, this._parseChunkBegin.bind(this));
		};

		Parser.prototype._handleChunkEnd = function() {
		this.read(4, this._parseChunkEnd.bind(this));
		this.read(4, this._parseChunkEnd.bind(this));
		};
		@@ -142,83 +108,76 @@

		var fileCrc = data.readInt32BE(0),
		calcCrc = this._crc.crc32();
		var fileCrc = data.readInt32BE(0);
		var calcCrc = this._crc.crc32();

		// check CRC
		if (this._options.checkCRC && calcCrc != fileCrc) {
		this.emit('error', new Error('Crc error'));
		return;
		}
		// check CRC
		if (this._options.checkCRC && calcCrc !== fileCrc) {
		this.error(new Error('Crc error - ' + fileCrc + ' - ' + calcCrc));
		return;
		}

		if (this._hasIEND) {
		this.destroySoon();

		} else {
		this.read(8, this._parseChunkBegin.bind(this));
		}
		if (!this._hasIEND) {
		this.read(8, this._parseChunkBegin.bind(this));
		}
		};


		Parser.prototype._handleIHDR = function(length) {
		this.read(length, this._parseIHDR.bind(this));
		this.read(length, this._parseIHDR.bind(this));
		};
		Parser.prototype._parseIHDR = function(data) {

		this._crc.write(data);
		this._crc.write(data);

		var width = data.readUInt32BE(0),
		height = data.readUInt32BE(4),
		depth = data[8],
		colorType = data[9], // bits: 1 palette, 2 color, 4 alpha
		compr = data[10],
		filter = data[11],
		interlace = data[12];
		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];

		// console.log(' width', width, 'height', height,
		// 'depth', depth, 'colorType', colorType,
		// 'compr', compr, 'filter', filter, 'interlace', interlace
		// );
		// console.log(' width', width, 'height', height,
		// 'depth', depth, 'colorType', colorType,
		// 'compr', compr, 'filter', filter, 'interlace', interlace
		// );

		if (depth != 8) {
		this.emit('error', new Error('Unsupported bit depth ' + depth));
		return;
		}
		if (!(colorType in colorTypeToBppMap)) {
		this.emit('error', new Error('Unsupported color type'));
		return;
		}
		if (compr != 0) {
		this.emit('error', new Error('Unsupported compression method'));
		return;
		}
		if (filter != 0) {
		this.emit('error', new Error('Unsupported filter method'));
		return;
		}
		if (interlace != 0) {
		this.emit('error', new Error('Unsupported interlace method'));
		return;
		}
		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;
		this._colorType = colorType;

		this._data = new Buffer(width * height * 4);
		this._filter = new Filter(
		width, height,
		colorTypeToBppMap[this._colorType],
		this._data,
		this._options
		);
		var bpp = constants.COLORTYPE_TO_BPP_MAP[this._colorType];

		this._hasIHDR = true;
		this._hasIHDR = true;

		this.emit('metadata', {
		width: width,
		height: height,
		palette: !!(colorType & constants.COLOR_PALETTE),
		color: !!(colorType & constants.COLOR_COLOR),
		alpha: !!(colorType & constants.COLOR_ALPHA),
		data: this._data
		});
		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();
		this._handleChunkEnd();
		};
		@@ -228,135 +187,107 @@
		Parser.prototype._handlePLTE = function(length) {
		this.read(length, this._parsePLTE.bind(this));
		this.read(length, this._parsePLTE.bind(this));
		};
		Parser.prototype._parsePLTE = function(data) {

		this._crc.write(data);
		this._crc.write(data);

		var entries = Math.floor(data.length / 3);
		// console.log('Palette:', entries);
		var entries = Math.floor(data.length / 3);
		// console.log('Palette:', entries);

		for (var i = 0; i < entries; i++) {
		this._palette.push([
		data.readUInt8(i * 3),
		data.readUInt8(i * 3 + 1),
		data.readUInt8(i * 3 + 2 ),
		0xff
		]);
		}
		for (var i = 0; i < entries; i++) {
		this._palette.push([
		data[i * 3],
		data[i * 3 + 1],
		data[i * 3 + 2],
		0xff
		]);
		}

		this._handleChunkEnd();
		this.palette(this._palette);

		this._handleChunkEnd();
		};

		Parser.prototype._handleTRNS = function(length) {
		this.read(length, this._parseTRNS.bind(this));
		this.read(length, this._parseTRNS.bind(this));
		};
		Parser.prototype._parseTRNS = function(data) {

		this._crc.write(data);
		this._crc.write(data);

		// palette
		if (this._colorType == 3) {
		if (this._palette.length == 0) {
		this.emit('error', new Error('Transparency chunk must be after palette'));
		return;
		}
		if (data.length > this._palette.length) {
		this.emit('error', new Error('More transparent colors than palette size'));
		return;
		}
		for (var i = 0; i < this._palette.length; i++) {
		this._palette[i][3] = i < data.length ? data.readUInt8(i) : 0xff;
		}
		// 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 (var 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
		// 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();
		this._handleChunkEnd();
		};

		Parser.prototype._handleGAMA = function(length) {
		this.read(length, this._parseGAMA.bind(this));
		this.read(length, this._parseGAMA.bind(this));
		};
		Parser.prototype._parseGAMA = function(data) {

		this._crc.write(data);
		this.emit('gamma', data.readUInt32BE(0) / 100000);
		this._crc.write(data);
		this.gamma(data.readUInt32BE(0) / constants.GAMMA_DIVISION);

		this._handleChunkEnd();
		this._handleChunkEnd();
		};

		Parser.prototype._handleIDAT = function(length) {
		this.read(-length, this._parseIDAT.bind(this, length));
		this.read(-length, this._parseIDAT.bind(this, length));
		};
		Parser.prototype._parseIDAT = function(length, data) {

		this._crc.write(data);
		this._crc.write(data);

		if (this._colorType == 3 && 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');
		}

		if (!this._inflate) {
		this._inflate = zlib.createInflate();
		this.inflateData(data);
		var leftOverLength = length - data.length;

		this._inflate.on('error', this.emit.bind(this, 'error'));
		this._filter.on('complete', this._reverseFiltered.bind(this));

		this._inflate.pipe(this._filter);
		}

		this._inflate.write(data);
		length -= data.length;

		if (length > 0)
		this._handleIDAT(length);
		else
		this._handleChunkEnd();
		if (leftOverLength > 0) {
		this._handleIDAT(leftOverLength);
		}
		else {
		this._handleChunkEnd();
		}
		};


		Parser.prototype._handleIEND = function(length) {
		this.read(length, this._parseIEND.bind(this));
		this.read(length, this._parseIEND.bind(this));
		};
		Parser.prototype._parseIEND = function(data) {

		this._crc.write(data);
		this._crc.write(data);

		// no more data to inflate
		this._inflate.end();
		this._hasIEND = true;
		this._handleChunkEnd();

		this._hasIEND = true;
		this._handleChunkEnd();
		if (this.finished) {
		this.finished();
		}
		};


		var colorTypeToBppMap = {
		0: 1,
		2: 3,
		3: 1,
		4: 2,
		6: 4
		};

		Parser.prototype._reverseFiltered = function(data, width, height) {

		if (this._colorType == 3) { // paletted

		// use values from palette
		var pxLineLength = width << 2;

		for (var y = 0; y < height; y++) {
		var pxRowPos = y * pxLineLength;

		for (var x = 0; x < width; x++) {
		var pxPos = pxRowPos + (x << 2),
		color = this._palette[data[pxPos]];

		for (var i = 0; i < 4; i++)
		data[pxPos + i] = color[i];
		}
		}
		}

		this.emit('parsed', data);
		};

198

lib/png.js

		@@ -1,72 +0,62 @@
		// Copyright (c) 2012 Kuba Niegowski
		//
		// Permission is hereby granted, free of charge, to any person obtaining a copy
		// of this software and associated documentation files (the "Software"), to deal
		// in the Software without restriction, including without limitation the rights
		// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		// copies of the Software, and to permit persons to whom the Software is
		// furnished to do so, subject to the following conditions:
		//
		// The above copyright notice and this permission notice shall be included in
		// all copies or substantial portions of the Software.
		//
		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
		// THE SOFTWARE.

		'use strict';

		var util = require('util');
		var Stream = require('stream');
		var Parser = require('./parser-async');
		var Packer = require('./packer');
		var PNGSync = require('./png-sync');

		var util = require('util'),
		Stream = require('stream'),
		Parser = require('./parser'),
		Packer = require('./packer');


		var PNG = exports.PNG = function(options) {
		Stream.call(this);
		Stream.call(this);

		options = options \|\| {};
		options = options \|\| {}; // eslint-disable-line no-param-reassign

		this.width = options.width \|\| 0;
		this.height = options.height \|\| 0;
		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 ?
		new Buffer(4 * this.width * this.height) : null;

		this.gamma = 0;
		this.readable = this.writable = true;
		if (options.fill && this.data) {
		this.data.fill(0);
		}

		this._parser = new Parser(options \|\| {});
		this.gamma = 0;
		this.readable = this.writable = true;

		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 = new Parser(options);

		this._packer = new Packer(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._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 Packer(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.inherits(PNG, Stream);

		PNG.sync = PNGSync;

		PNG.prototype.pack = function() {

		process.nextTick(function() {
		this._packer.pack(this.data, this.width, this.height);
		}.bind(this));
		if (!this.data \|\| !this.data.length) {
		this.emit('error', 'No data provided');
		return this;
		}

		return this;
		process.nextTick(function() {
		this._packer.pack(this.data, this.width, this.height, this.gamma);
		}.bind(this));

		return this;
		};
		@@ -77,72 +67,98 @@

		if (callback) {
		var onParsed = null, onError = null;
		if (callback) {
		var onParsed, onError;

		this.once('parsed', onParsed = function(data) {
		this.removeListener('error', onError);
		onParsed = function(parsedData) {
		this.removeListener('error', onError);

		this.data = data;
		callback(null, this);
		this.data = parsedData;
		callback(null, this);
		}.bind(this);

		}.bind(this));
		onError = function(err) {
		this.removeListener('parsed', onParsed);

		this.once('error', onError = function(err) {
		this.removeListener('parsed', onParsed);
		callback(err, null);
		}.bind(this);

		callback(err, null);
		}.bind(this));
		}
		this.once('parsed', onParsed);
		this.once('error', onError);
		}

		this.end(data);
		return this;
		this.end(data);
		return this;
		};

		PNG.prototype.write = function(data) {
		this._parser.write(data);
		return true;
		this._parser.write(data);
		return true;
		};

		PNG.prototype.end = function(data) {
		this._parser.end(data);
		this._parser.end(data);
		};

		PNG.prototype._metadata = function(metadata) {
		this.width = metadata.width;
		this.height = metadata.height;
		this.data = metadata.data;
		this.width = metadata.width;
		this.height = metadata.height;

		delete metadata.data;
		this.emit('metadata', metadata);
		this.emit('metadata', metadata);
		};

		PNG.prototype._gamma = function(gamma) {
		this.gamma = gamma;
		this.gamma = gamma;
		};

		PNG.prototype._handleClose = function() {
		if (!this._parser.writable && !this._packer.readable)
		this.emit('close');
		if (!this._parser.writable && !this._packer.readable) {
		this.emit('close');
		}
		};


		PNG.prototype.bitblt = function(dst, sx, sy, w, h, dx, dy) {
		PNG.bitblt = function(src, dst, srcX, srcY, width, height, deltaX, deltaY) { // eslint-disable-line max-params

		var src = this;
		if (srcX > src.width \|\| srcY > src.height \|\| srcX + width > src.width \|\| srcY + height > src.height) {
		throw new Error('bitblt reading outside image');
		}

		if (sx > src.width \|\| sy > src.height
		\|\| sx + w > src.width \|\| sy + h > src.height)
		throw new Error('bitblt reading outside image');
		if (dx > dst.width \|\| dy > dst.height
		\|\| dx + w > dst.width \|\| dy + h > 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 < h; y++) {
		src.data.copy(dst.data,
		((dy + y) * dst.width + dx) << 2,
		((sy + y) * src.width + sx) << 2,
		((sy + y) * src.width + sx + w) << 2
		);
		for (var 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 (var y = 0; y < src.height; y++) {
		for (var x = 0; x < src.width; x++) {
		var idx = (src.width * y + x) << 2;

		for (var i = 0; i < 3; i++) {
		var 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;
		}
		};

		return this;
		PNG.prototype.adjustGamma = function() {
		PNG.adjustGamma(this);
		};

72

package.json

		{
		"name": "pngjs",
		"version": "0.4.0",
		"description": "Simple PNG encoder/decoder",
		"author": "Kuba Niegowski",
		"contributors": [],
		"homepage": "https://github.com/niegowski/node-pngjs/",
		"keywords" : [
		"png"
		],
		"engines": {
		"node": "0.8.x"
		},
		"main": "./lib/png.js"
		"name": "pngjs",
		"version": "2.0.0",
		"description": "PNG encoder/decoder in pure JS, supporting any bit size & interlace, async & sync with full test suite.",
		"contributors": [
		"Alexandre Paré",
		"Gaurav Mali",
		"Kuba Niegowski",
		"Luke Page",
		"Pietajan De Potter",
		"Steven Sojka",
		"liangzeng",
		"Michael Vogt"
		],
		"homepage": "https://github.com/lukeapage/pngjs",
		"keywords": [
		"PNG",
		"decoder",
		"encoder",
		"js-png",
		"node-png",
		"parser",
		"png",
		"png-js",
		"png-parse",
		"pngjs"
		],
		"engines": {
		"node": ">=0.10.0",
		"iojs": ">= 1.0.0"
		},
		"main": "./lib/png.js",
		"directories": {
		"example": "examples"
		},
		"scripts": {
		"coverage": "istanbul -- cover node_modules/tape/bin/tape test/*-spec.js nolarge",
		"coverage-report": "npm run coverage && istanbul report html",
		"coveralls": "cat ./coverage/lcov.info \| coveralls",
		"test": "npm run lint && tape test/*-spec.js \| tap-dot && node test/run-compare",
		"lint": "eslint lib"
		},
		"repository": {
		"type": "git",
		"url": "git://github.com/lukeapage/pngjs2.git"
		},
		"license": "MIT",
		"bugs": {
		"url": "https://github.com/lukeapage/pngjs2/issues"
		},
		"devDependencies": {
		"buffer-equal": "0.0.1",
		"connect": "^3.4.0",
		"eslint": "^1.0.0",
		"istanbul": "^0.3.17",
		"phantomjs": "^1.9.17",
		"serve-static": "^1.10.0",
		"tap-dot": "^1.0.0",
		"tape": "^4.0.2"
		}
		}

177

README.md

		@@ -1,9 +0,65 @@
		About
		[![Build Status](https://travis-ci.org/lukeapage/pngjs2.svg?branch=master)](https://travis-ci.org/lukeapage/pngjs2) [![Build status](https://ci.appveyor.com/api/projects/status/tb8418jql1trkntd/branch/master?svg=true)](https://ci.appveyor.com/project/lukeapage/pngjs2/branch/master) [![Coverage Status](https://coveralls.io/repos/lukeapage/pngjs2/badge.svg?branch=master&service=github)](https://coveralls.io/github/lukeapage/pngjs2?branch=master) [![npm version](https://badge.fury.io/js/pngjs2.svg)](http://badge.fury.io/js/pngjs2)

		pngjs
		========
		Simple PNG encoder/decoder for Node.js with no native dependencies.
		Simple PNG encoder/decoder for Node.js with no dependencies.

		Based on the original [pngjs](https://github.com/niegowski/node-pngjs) with the follow enhancements.

		* Support for reading 1,2,4 & 16 bit files
		* Support for reading interlace files
		* Support for reading `tTRNS` transparent colours
		* Support for writing colortype 2 (RGB) and colortype 6 (RGBA)
		* Sync interface as well as async
		* API compatible with pngjs and node-pngjs

		Known lack of support for:

		* Extended PNG e.g. Animation
		* Writing in different formats, colortype 0 (greyscale), colortype 3 (indexed color), colortype 4 (greyscale with alpha)
		* Synchronous write

		Requirements
		============

		* Async - Node.js 0.10 / 0.12 / IO.js
		* Sync - Node.js 0.12 / IO.js

		Comparison Table
		================

		Name \| Forked From \| Sync \| Async \| 16 Bit \| 1/2/4 Bit \| Interlace \| Gamma \| Encodes \| Tested
		---------\|--------------\|------\|-------\|--------\|-----------\|-----------\|-------\|---------\|--------
		pngjs v2 \| pngjs \| Read \| Yes \| Yes \| Yes \| Yes \| Yes \| Yes \| Yes
		node-png \| pngjs \| No \| Yes \| No \| No \| No \| Hidden\| Yes \| Manual
		pngjs \| \| No \| Yes \| No \| No \| No \| Hidden\| Yes \| Manual
		png-coder\| pngjs \| No \| Yes \| Yes \| No \| No \| Hidden\| Yes \| Manual
		pngparse \| \| No \| Yes \| No \| Yes \| No \| No \| No \| Yes
		pngparse-sync \| pngparse\| Yes \| No \| No \| Yes \| No \| No \| No \| Yes
		png-async\| \| No \| Yes \| No \| No \| No \| No \| Yes \| Yes
		png-js \| \| No \| Yes \| No \| No \| No \| No \| No \| No


		Native C++ node decoders:
		* png
		* png-sync (sync version of above)
		* pixel-png
		* png-img

		Tests
		=====

		Tested using [PNG Suite](http://www.schaik.com/pngsuite/). We read every file into pngjs, output it in standard 8bit colour, synchronously and asynchronously, then compare the original
		with the newly saved images.

		To run the tests, run `node test`.

		The only thing not converted is gamma correction - this is because multiple vendors will do gamma correction differently, so the tests will have different results on different browsers.

		In addition we use a tolerance of 3 for 16 bit images in PhantomJS because PhantomJS seems to have non-compliant rules for downscaling 16 bit images.

		Installation
		===============
		```
		$ npm install pngjs
		$ npm install pngjs --save
		```
		@@ -42,3 +98,3 @@

		Documentation
		Async API
		================
		@@ -48,7 +104,2 @@

		### Supported ancillary chunks
		- `gAMA` - gamma,
		- `tRNS` - transparency (but only for paletted image)


		## Class: PNG
		@@ -65,3 +116,6 @@ `PNG` is readable and writable `Stream`.
		- `deflateStrategy` - compression strategy for delate (default: 3)
		- `deflateFactory` - deflate stream factory (default: `zlib.createDeflate`)
		- `filterType` - png filtering method for scanlines (default: -1 => auto, accepts array of numbers 0-4)
		- `colorType` - the output colorType - see constants. 2 = color, no alpha, 6 = color & alpha. Default currently 6, but in the future may calculate best mode.
		- `inputHasAlpha` - whether the input bitmap has 4 bits per pixel (rgb and alpha) or 3 (rgb - no alpha).

		@@ -77,2 +131,3 @@
		- `alpha` image contains alpha channel
		- `interlace` image is interlaced

		@@ -90,3 +145,3 @@
		### png.parse(data, [callback])
		Parses PNG file data. Alternatively you can stream data to instance of PNG.
		Parses PNG file data. Can be `String` or `Buffer`. Alternatively you can stream data to instance of PNG.

		@@ -98,2 +153,9 @@ Optional `callback` is once called on `error` or `parsed`. The callback gets

		#### Example
		```js
		new PNG({ filterType:4 }).parse( imageData, function(error, data)
		{
		console.log(error, data)
		});
		```

		@@ -107,7 +169,33 @@ ### png.pack()
		### png.bitblt(dst, sx, sy, w, h, dx, dy)
		Helper for image manipulation, copies rectangle of pixels from current image (`sx`, `sy`, `w`, `h`) to `dst` image (at `dx`, `dy`).
		Helper for image manipulation, copies a rectangle of pixels from current (i.e. the source) image (`sx`, `sy`, `w`, `h`) to `dst` image (at `dx`, `dy`).

		Returns `this` for method chaining.

		For example, the following code copies the top-left 100x50 px of `in.png` into dst and writes it to `out.png`:
		```js
		var dst = new PNG({width: 100, height: 50});
		fs.createReadStream('in.png')
		.pipe(new PNG())
		.on('parsed', function() {
		this.bitblt(dst, 0, 0, 100, 50, 0, 0);
		dst.pack().pipe(fs.createWriteStream('out.png'));
		});
		```

		### Property: adjustGamma()
		Helper that takes data and adjusts it to be gamma corrected. Note that it is not 100% reliable with transparent colours because that requires knowing the background colour the bitmap is rendered on to.

		In tests against PNG suite it compared 100% with chrome on all 8 bit and below images. On IE there were some differences.

		The following example reads a file, adjusts the gamma (which sets the gamma to 0) and writes it out again, effectively removing any gamma correction from the image.

		```js
		fs.createReadStream('in.png')
		.pipe(new PNG())
		.on('parsed', function() {
		this.adjustGamma();
		this.pack().pipe(fs.createWriteStream('out.png'));
		});
		```

		### Property: width
		@@ -128,22 +216,63 @@ Width of image in pixels

		# Sync API

		## PNG.sync

		### PNG.sync.read(buffer)

		Take a buffer and returns a PNG image. The properties on the image include the meta data and `data` as per the async API above.

		```
		var data = fs.readFileSync('in.png');
		var png = PNG.sync.read(data);
		```

		### PNG.adjustGamma(src)

		Adjusts the gamma of a sync image. See the async adjustGamma.

		```
		var data = fs.readFileSync('in.png');
		var png = PNG.sync.read(data);
		PNG.adjustGamma(png);
		```


		Changelog
		============

		### 0.4.0 - Jun 05 2013
		- fixed reading of destroyed input stream
		### 2.0.0 - 08/10/2015
		- fixes to readme
		- breaking change - bitblt on the png prototype now doesn't take a unused, unnecessary src first argument

		### 0.4.0-alpha - 29 Nov 2012
		- added zlib deflateStrategy option, default to Z_RLE (by pdpotter)
		- added possibility to use multiple filters (by pdpotter, modified by niegowski)
		### 1.2.0 - 13/09/2015
		- support passing colorType to write PNG's and writing bitmaps without alpha information

		### 0.3.0-alpha - 23 Aug 2012
		- Processing data as Streams, not complete Buffers of data
		### 1.1.0 - 07/09/2015
		- support passing a deflate factory for controlled compression

		### 0.2.0-alpha - 21 Aug 2012
		- Input added palette, grayscale, no alpha support
		- Better scanline filter selection
		### 1.0.2 - 22/08/2015
		- Expose all PNG creation info

		### 0.1.0-alpha - 19 Aug 2012
		- First version
		### 1.0.1 - 21/08/2015
		- Fix non square interlaced files

		### 1.0.0 - 08/08/2015
		- More tests
		- source linted
		- maintainability refactorings
		- async API - exceptions in reading now emit warnings
		- documentation improvement - sync api now documented, adjustGamma documented
		- breaking change - gamma chunk is now written. previously a read then write would destroy gamma information, now it is persisted.

		### 0.0.3 - 03/08/2015
		- Error handling fixes
		- ignore files for smaller npm footprint

		### 0.0.2 - 02/08/2015
		- Bugfixes to interlacing, support for transparent colours

		### 0.0.1 - 02/08/2015
		- Initial release, see pngjs for older changelog.

		License
		@@ -154,4 +283,2 @@ =========

		Copyright (c) 2012 Kuba Niegowski

		Permission is hereby granted, free of charge, to any person obtaining a copy
		@@ -158,0 +285,0 @@ of this software and associated documentation files (the "Software"), to deal

examples/fromdocs.js

examples/simple.js

examples/test/bg.js

examples/test/bg.png

examples/test/img/basn0g08.png

examples/test/img/basn2c08.png

examples/test/img/basn3p08.png

examples/test/img/basn4a08.png

examples/test/img/basn6a08.png

examples/test/img/f00n0g08.png

examples/test/img/f00n2c08.png

examples/test/img/f01n0g08.png

examples/test/img/f01n2c08.png

examples/test/img/f02n0g08.png

examples/test/img/f02n2c08.png

examples/test/img/f03n0g08.png

examples/test/img/f03n2c08.png

examples/test/img/f04n0g08.png

examples/test/img/f04n2c08.png

examples/test/img/PngSuite.LICENSE

examples/test/img/PngSuite.README

examples/test/img/tbrn2c08.png

examples/test/img/tp0n0g08.png

examples/test/img/tp0n2c08.png

examples/test/img/tp0n3p08.png

examples/test/img/tp1n3p08.png

examples/test/list.html

examples/test/out/.npmignore

examples/test/test.js

lib/filter.js

.npmignore

Sorry, the diff of this file is not supported yet

LICENSE

Sorry, the diff of this file is not supported yet

pngjs - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics