signaling_server/service/node_modules/pngjs/lib/sync-inflate.js

   1 'use strict';
   2
   3 var assert = require('assert').ok;
   4 var zlib = require('zlib');
   5 var util = require('util');
   6
   7 var kMaxLength = require('buffer').kMaxLength;
   8
   9 function Inflate(opts) {
  10   if (!(this instanceof Inflate)) {
  11     return new Inflate(opts);
  12   }
  13
  14   if (opts && opts.chunkSize < zlib.Z_MIN_CHUNK) {
  15     opts.chunkSize = zlib.Z_MIN_CHUNK;
  16   }
  17
  18   zlib.Inflate.call(this, opts);
  19
  20   // Node 8 --> 9 compatibility check
  21   this._offset = this._offset === undefined ? this._outOffset : this._offset;
  22   this._buffer = this._buffer || this._outBuffer;
  23
  24   if (opts && opts.maxLength != null) {
  25     this._maxLength = opts.maxLength;
  26   }
  27 }
  28
  29 function createInflate(opts) {
  30   return new Inflate(opts);
  31 }
  32
  33 function _close(engine, callback) {
  34   if (callback) {
  35     process.nextTick(callback);
  36   }
  37
  38   // Caller may invoke .close after a zlib error (which will null _handle).
  39   if (!engine._handle) {
  40     return;
  41   }
  42
  43   engine._handle.close();
  44   engine._handle = null;
  45 }
  46
  47 Inflate.prototype._processChunk = function(chunk, flushFlag, asyncCb) {
  48   if (typeof asyncCb === 'function') {
  49     return zlib.Inflate._processChunk.call(this, chunk, flushFlag, asyncCb);
  50   }
  51
  52   var self = this;
  53
  54   var availInBefore = chunk && chunk.length;
  55   var availOutBefore = this._chunkSize - this._offset;
  56   var leftToInflate = this._maxLength;
  57   var inOff = 0;
  58
  59   var buffers = [];
  60   var nread = 0;
  61
  62   var error;
  63   this.on('error', function(err) {
  64     error = err;
  65   });
  66
  67   function handleChunk(availInAfter, availOutAfter) {
  68     if (self._hadError) {
  69       return;
  70     }
  71
  72     var have = availOutBefore - availOutAfter;
  73     assert(have >= 0, 'have should not go down');
  74
  75     if (have > 0) {
  76       var out = self._buffer.slice(self._offset, self._offset + have);
  77       self._offset += have;
  78
  79       if (out.length > leftToInflate) {
  80         out = out.slice(0, leftToInflate);
  81       }
  82
  83       buffers.push(out);
  84       nread += out.length;
  85       leftToInflate -= out.length;
  86
  87       if (leftToInflate === 0) {
  88         return false;
  89       }
  90     }
  91
  92     if (availOutAfter === 0 || self._offset >= self._chunkSize) {
  93       availOutBefore = self._chunkSize;
  94       self._offset = 0;
  95       self._buffer = Buffer.allocUnsafe(self._chunkSize);
  96     }
  97
  98     if (availOutAfter === 0) {
  99       inOff += (availInBefore - availInAfter);
 100       availInBefore = availInAfter;
 101
 102       return true;
 103     }
 104
 105     return false;
 106   }
 107
 108   assert(this._handle, 'zlib binding closed');
 109   do {
 110     var res = this._handle.writeSync(flushFlag,
 111       chunk, // in
 112       inOff, // in_off
 113       availInBefore, // in_len
 114       this._buffer, // out
 115       this._offset, //out_off
 116       availOutBefore); // out_len
 117     // Node 8 --> 9 compatibility check
 118     res = res || this._writeState;
 119   } while (!this._hadError && handleChunk(res[0], res[1]));
 120
 121   if (this._hadError) {
 122     throw error;
 123   }
 124
 125   if (nread >= kMaxLength) {
 126     _close(this);
 127     throw new RangeError('Cannot create final Buffer. It would be larger than 0x' + kMaxLength.toString(16) + ' bytes');
 128   }
 129
 130   var buf = Buffer.concat(buffers, nread);
 131   _close(this);
 132
 133   return buf;
 134 };
 135
 136 util.inherits(Inflate, zlib.Inflate);
 137
 138 function zlibBufferSync(engine, buffer) {
 139   if (typeof buffer === 'string') {
 140     buffer = Buffer.from(buffer);
 141   }
 142   if (!(buffer instanceof Buffer)) {
 143     throw new TypeError('Not a string or buffer');
 144   }
 145
 146   var flushFlag = engine._finishFlushFlag;
 147   if (flushFlag == null) {
 148     flushFlag = zlib.Z_FINISH;
 149   }
 150
 151   return engine._processChunk(buffer, flushFlag);
 152 }
 153
 154 function inflateSync(buffer, opts) {
 155   return zlibBufferSync(new Inflate(opts), buffer);
 156 }
 157
 158 module.exports = exports = inflateSync;
 159 exports.Inflate = Inflate;
 160 exports.createInflate = createInflate;
 161 exports.inflateSync = inflateSync;