webshell

Ghost Exploiter Team Official

Directory >> /home/softsuitetech/nodevenv/public_html/DEMO/gotem-platform-backend/14/lib/node_modules/pngjs/lib/

File / Folder	Size	Action
.	-
bitmapper.js	6.179KB	edt ren
bitpacker.js	4.418KB	edt ren
chunkstream.js	4.142KB	edt ren
constants.js	0.646KB	edt ren
crc.js	0.835KB	edt ren
filter-pack.js	4.185KB	edt ren
filter-parse-async.js	0.54KB	edt ren
filter-parse-sync.js	0.474KB	edt ren
filter-parse.js	4.648KB	edt ren
format-normaliser.js	2.226KB	edt ren
interlace.js	1.911KB	edt ren
packer-async.js	1.096KB	edt ren
packer-sync.js	1.125KB	edt ren
packer.js	3.483KB	edt ren
paeth-predictor.js	0.379KB	edt ren
parser-async.js	4.153KB	edt ren
parser-sync.js	2.451KB	edt ren
parser.js	7.506KB	edt ren
png-sync.js	0.248KB	edt ren
png.js	4.195KB	edt ren
sync-inflate.js	3.617KB	edt ren
sync-reader.js	1.078KB	edt ren

'use strict';

var util = require('util');
var zlib = require('zlib');
var ChunkStream = require('./chunkstream');
var FilterAsync = require('./filter-parse-async');
var Parser = require('./parser');
var bitmapper = require('./bitmapper');
var formatNormaliser = require('./format-normaliser');

var 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.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.createInflate();

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

this._inflate.pipe(this._filter);
    }
    else {
      var rowSize = ((this._bitmapInfo.width * this._bitmapInfo.bpp * this._bitmapInfo.depth + 7) >> 3) + 1;
      var imageSize = rowSize * this._bitmapInfo.height;
      var chunkSize = Math.max(imageSize, zlib.Z_MIN_CHUNK);

this._inflate = zlib.createInflate({ chunkSize: chunkSize });
      var leftToInflate = imageSize;

var 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));

var 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 FilterAsync(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();
  }
  this.destroySoon();
};

ParserAsync.prototype._complete = function(filteredData) {

if (this.errord) {
    return;
  }

try {
    var bitmapData = bitmapper.dataToBitMap(filteredData, this._bitmapInfo);

var normalisedBitmapData = formatNormaliser(bitmapData, this._bitmapInfo);
    bitmapData = null;
  }
  catch (ex) {
    this._handleError(ex);
    return;
  }

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

<=Back