{"version":3,"sources":["jsdelivr-header.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-globals/src/global.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/process-es6/browser.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/buffer-es6/base64.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/buffer-es6/ieee754.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/buffer-es6/isArray.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/buffer-es6/index.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/events.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/inherits.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/util.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/buffer-list.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/string-decoder.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/readable.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/writable.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/duplex.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/transform.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/passthrough.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/stream.js","/npm/@liamdon/pngjs3@6.0.2/lib/chunkstream.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/pack/filterNone.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/pack/filterSub.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/pack/filterUp.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/pack/filterAvg.js","/npm/@liamdon/pngjs3@6.0.2/lib/paeth-predictor.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/pack/filterPaeth.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/pack/filterSumNone.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/pack/filterSumSub.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/pack/filterSumUp.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/pack/filterSumAvg.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/pack/filterSumPaeth.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/pack/index.js","/npm/@liamdon/pngjs3@6.0.2/lib/interlace.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/parse.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/parse-async.js","/npm/@liamdon/pngjs3@6.0.2/lib/sync-reader.js","/npm/@liamdon/pngjs3@6.0.2/lib/filter/parse-sync.js","/npm/@liamdon/pngjs3@6.0.2/lib/dataToBitMap/pixelBppMapper.js","/npm/@liamdon/pngjs3@6.0.2/lib/dataToBitMap/mapImage8Bit.js","/npm/@liamdon/pngjs3@6.0.2/lib/dataToBitMap/pixelBppCustomMapper.js","/npm/@liamdon/pngjs3@6.0.2/lib/dataToBitMap/mapImageCustomBit.js","/npm/@liamdon/pngjs3@6.0.2/lib/dataToBitMap/bitRetriever.js","/npm/@liamdon/pngjs3@6.0.2/lib/dataToBitMap/index.js","/npm/@liamdon/pngjs3@6.0.2/lib/format-normaliser.js","/npm/@liamdon/pngjs3@6.0.2/lib/constants.js","/npm/@liamdon/pngjs3@6.0.2/lib/crc.js","/npm/@liamdon/pngjs3@6.0.2/lib/parser/parser.js","/npm/@liamdon/pngjs3@6.0.2/node_modules/rollup-plugin-node-builtins/src/es6/assert.js","/npm/@liamdon/pngjs3@6.0.2/lib/parser/parser-async.js","/npm/@liamdon/pngjs3@6.0.2/lib/sync-inflate.js","/npm/@liamdon/pngjs3@6.0.2/lib/parser/parser-sync.js","/npm/@liamdon/pngjs3@6.0.2/lib/bitpacker.js","/npm/@liamdon/pngjs3@6.0.2/lib/packer/packer.js","/npm/@liamdon/pngjs3@6.0.2/lib/packer/packer-async.js","/npm/@liamdon/pngjs3@6.0.2/lib/packer/packer-sync.js","/npm/@liamdon/pngjs3@6.0.2/lib/png-sync.js","/npm/@liamdon/pngjs3@6.0.2/lib/propData.js","/npm/@liamdon/pngjs3@6.0.2/lib/adjustGamma.js","/npm/@liamdon/pngjs3@6.0.2/lib/bitblt.js","/npm/@liamdon/pngjs3@6.0.2/lib/png.js","/npm/@liamdon/pngjs3@6.0.2/lib/index.js"],"names":[],"mappings":"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","file":"/npm/@liamdon/pngjs3@6.0.2/dist/pngjs3.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@liamdon/pngjs3@6.0.2/dist/pngjs3.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","export default (typeof global !== \"undefined\" ? global :\n            typeof self !== \"undefined\" ? self :\n            typeof window !== \"undefined\" ? window : {});\n","// shim for using process in browser\n// based off https://github.com/defunctzombie/node-process/blob/master/browser.js\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\nvar cachedSetTimeout = defaultSetTimout;\nvar cachedClearTimeout = defaultClearTimeout;\nif (typeof global.setTimeout === 'function') {\n    cachedSetTimeout = setTimeout;\n}\nif (typeof global.clearTimeout === 'function') {\n    cachedClearTimeout = clearTimeout;\n}\n\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\nexport function nextTick(fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n}\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nexport var title = 'browser';\nexport var platform = 'browser';\nexport var browser = true;\nexport var env = {};\nexport var argv = [];\nexport var version = ''; // empty string to avoid regexp issues\nexport var versions = {};\nexport var release = {};\nexport var config = {};\n\nfunction noop() {}\n\nexport var on = noop;\nexport var addListener = noop;\nexport var once = noop;\nexport var off = noop;\nexport var removeListener = noop;\nexport var removeAllListeners = noop;\nexport var emit = noop;\n\nexport function binding(name) {\n    throw new Error('process.binding is not supported');\n}\n\nexport function cwd () { return '/' }\nexport function chdir (dir) {\n    throw new Error('process.chdir is not supported');\n};\nexport function umask() { return 0; }\n\n// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js\nvar performance = global.performance || {}\nvar performanceNow =\n  performance.now        ||\n  performance.mozNow     ||\n  performance.msNow      ||\n  performance.oNow       ||\n  performance.webkitNow  ||\n  function(){ return (new Date()).getTime() }\n\n// generate timestamp or delta\n// see http://nodejs.org/api/process.html#process_process_hrtime\nexport function hrtime(previousTimestamp){\n  var clocktime = performanceNow.call(performance)*1e-3\n  var seconds = Math.floor(clocktime)\n  var nanoseconds = Math.floor((clocktime%1)*1e9)\n  if (previousTimestamp) {\n    seconds = seconds - previousTimestamp[0]\n    nanoseconds = nanoseconds - previousTimestamp[1]\n    if (nanoseconds<0) {\n      seconds--\n      nanoseconds += 1e9\n    }\n  }\n  return [seconds,nanoseconds]\n}\n\nvar startTime = new Date();\nexport function uptime() {\n  var currentTime = new Date();\n  var dif = currentTime - startTime;\n  return dif / 1000;\n}\n\nexport default {\n  nextTick: nextTick,\n  title: title,\n  browser: browser,\n  env: env,\n  argv: argv,\n  version: version,\n  versions: versions,\n  on: on,\n  addListener: addListener,\n  once: once,\n  off: off,\n  removeListener: removeListener,\n  removeAllListeners: removeAllListeners,\n  emit: emit,\n  binding: binding,\n  cwd: cwd,\n  chdir: chdir,\n  umask: umask,\n  hrtime: hrtime,\n  platform: platform,\n  release: release,\n  config: config,\n  uptime: uptime\n};\n","\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\nvar inited = false;\nfunction init () {\n  inited = true;\n  var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\n  for (var i = 0, len = code.length; i < len; ++i) {\n    lookup[i] = code[i]\n    revLookup[code.charCodeAt(i)] = i\n  }\n\n  revLookup['-'.charCodeAt(0)] = 62\n  revLookup['_'.charCodeAt(0)] = 63\n}\n\nexport function toByteArray (b64) {\n  if (!inited) {\n    init();\n  }\n  var i, j, l, tmp, placeHolders, arr\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // the number of equal signs (place holders)\n  // if there are two placeholders, than the two characters before it\n  // represent one byte\n  // if there is only one, then the three characters before it represent 2 bytes\n  // this is just a cheap hack to not do indexOf twice\n  placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0\n\n  // base64 is 4/3 + up to two characters of the original data\n  arr = new Arr(len * 3 / 4 - placeHolders)\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  l = placeHolders > 0 ? len - 4 : len\n\n  var L = 0\n\n  for (i = 0, j = 0; i < l; i += 4, j += 3) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]\n    arr[L++] = (tmp >> 16) & 0xFF\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  if (placeHolders === 2) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[L++] = tmp & 0xFF\n  } else if (placeHolders === 1) {\n    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[L++] = (tmp >> 8) & 0xFF\n    arr[L++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nexport function fromByteArray (uint8) {\n  if (!inited) {\n    init();\n  }\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var output = ''\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    output += lookup[tmp >> 2]\n    output += lookup[(tmp << 4) & 0x3F]\n    output += '=='\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + (uint8[len - 1])\n    output += lookup[tmp >> 10]\n    output += lookup[(tmp >> 4) & 0x3F]\n    output += lookup[(tmp << 2) & 0x3F]\n    output += '='\n  }\n\n  parts.push(output)\n\n  return parts.join('')\n}\n","\nexport function read (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexport function write (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nexport default Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n\nimport * as base64 from './base64'\nimport * as ieee754 from './ieee754'\nimport isArray from './isArray'\n\nexport var INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : true\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nvar _kMaxLength = kMaxLength()\nexport {_kMaxLength as kMaxLength};\nfunction typedArraySupport () {\n  return true;\n  // rollup issues\n  // try {\n  //   var arr = new Uint8Array(1)\n  //   arr.__proto__ = {\n  //     __proto__: Uint8Array.prototype,\n  //     foo: function () { return 42 }\n  //   }\n  //   return arr.foo() === 42 && // typed array instances can be augmented\n  //       typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n  //       arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  // } catch (e) {\n  //   return false\n  // }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nexport function Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    // Object.defineProperty(Buffer, Symbol.species, {\n    //   value: null,\n    //   configurable: true\n    // })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (internalIsBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nexport function SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\nBuffer.isBuffer = isBuffer;\nfunction internalIsBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!internalIsBuffer(a) || !internalIsBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!internalIsBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (internalIsBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!internalIsBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (internalIsBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!internalIsBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = internalIsBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n\n\n// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nexport function isBuffer(obj) {\n  return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj))\n}\n\nfunction isFastBuffer (obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n\n// For Node v0.10 support. Remove this eventually.\nfunction isSlowBuffer (obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0))\n}\n","'use strict';\n\nvar domain;\n\n// This constructor is used to store event handlers. Instantiating this is\n// faster than explicitly calling `Object.create(null)` to get a \"clean\" empty\n// object (tested with v8 v4.9).\nfunction EventHandlers() {}\nEventHandlers.prototype = Object.create(null);\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nexport default EventEmitter;\nexport {EventEmitter};\n\n// nodejs oddity\n// require('events') === require('events').EventEmitter\nEventEmitter.EventEmitter = EventEmitter\n\nEventEmitter.usingDomains = false;\n\nEventEmitter.prototype.domain = undefined;\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\nEventEmitter.init = function() {\n  this.domain = null;\n  if (EventEmitter.usingDomains) {\n    // if there is an active domain, then attach to it.\n    if (domain.active && !(this instanceof domain.Domain)) {\n      this.domain = domain.active;\n    }\n  }\n\n  if (!this._events || this._events === Object.getPrototypeOf(this)._events) {\n    this._events = new EventHandlers();\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || isNaN(n))\n    throw new TypeError('\"n\" argument must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nfunction $getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return $getMaxListeners(this);\n};\n\n// These standalone emit* functions are used to optimize calling of event\n// handlers for fast cases because emit() itself often has a variable number of\n// arguments and can be deoptimized because of that. These functions always have\n// the same number of arguments and thus do not get deoptimized, so the code\n// inside them can execute faster.\nfunction emitNone(handler, isFn, self) {\n  if (isFn)\n    handler.call(self);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self);\n  }\n}\nfunction emitOne(handler, isFn, self, arg1) {\n  if (isFn)\n    handler.call(self, arg1);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1);\n  }\n}\nfunction emitTwo(handler, isFn, self, arg1, arg2) {\n  if (isFn)\n    handler.call(self, arg1, arg2);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1, arg2);\n  }\n}\nfunction emitThree(handler, isFn, self, arg1, arg2, arg3) {\n  if (isFn)\n    handler.call(self, arg1, arg2, arg3);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1, arg2, arg3);\n  }\n}\n\nfunction emitMany(handler, isFn, self, args) {\n  if (isFn)\n    handler.apply(self, args);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].apply(self, args);\n  }\n}\n\nEventEmitter.prototype.emit = function emit(type) {\n  var er, handler, len, args, i, events, domain;\n  var needDomainExit = false;\n  var doError = (type === 'error');\n\n  events = this._events;\n  if (events)\n    doError = (doError && events.error == null);\n  else if (!doError)\n    return false;\n\n  domain = this.domain;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    er = arguments[1];\n    if (domain) {\n      if (!er)\n        er = new Error('Uncaught, unspecified \"error\" event');\n      er.domainEmitter = this;\n      er.domain = domain;\n      er.domainThrown = false;\n      domain.emit('error', er);\n    } else if (er instanceof Error) {\n      throw er; // Unhandled 'error' event\n    } else {\n      // At least give some kind of context to the user\n      var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n      err.context = er;\n      throw err;\n    }\n    return false;\n  }\n\n  handler = events[type];\n\n  if (!handler)\n    return false;\n\n  var isFn = typeof handler === 'function';\n  len = arguments.length;\n  switch (len) {\n    // fast cases\n    case 1:\n      emitNone(handler, isFn, this);\n      break;\n    case 2:\n      emitOne(handler, isFn, this, arguments[1]);\n      break;\n    case 3:\n      emitTwo(handler, isFn, this, arguments[1], arguments[2]);\n      break;\n    case 4:\n      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);\n      break;\n    // slower\n    default:\n      args = new Array(len - 1);\n      for (i = 1; i < len; i++)\n        args[i - 1] = arguments[i];\n      emitMany(handler, isFn, this, args);\n  }\n\n  if (needDomainExit)\n    domain.exit();\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  if (typeof listener !== 'function')\n    throw new TypeError('\"listener\" argument must be a function');\n\n  events = target._events;\n  if (!events) {\n    events = target._events = new EventHandlers();\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (!existing) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] = prepend ? [listener, existing] :\n                                          [existing, listener];\n    } else {\n      // If we've already got an array, just append.\n      if (prepend) {\n        existing.unshift(listener);\n      } else {\n        existing.push(listener);\n      }\n    }\n\n    // Check for listener leak\n    if (!existing.warned) {\n      m = $getMaxListeners(target);\n      if (m && m > 0 && existing.length > m) {\n        existing.warned = true;\n        var w = new Error('Possible EventEmitter memory leak detected. ' +\n                            existing.length + ' ' + type + ' listeners added. ' +\n                            'Use emitter.setMaxListeners() to increase limit');\n        w.name = 'MaxListenersExceededWarning';\n        w.emitter = target;\n        w.type = type;\n        w.count = existing.length;\n        emitWarning(w);\n      }\n    }\n  }\n\n  return target;\n}\nfunction emitWarning(e) {\n  typeof console.warn === 'function' ? console.warn(e) : console.log(e);\n}\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction _onceWrap(target, type, listener) {\n  var fired = false;\n  function g() {\n    target.removeListener(type, g);\n    if (!fired) {\n      fired = true;\n      listener.apply(target, arguments);\n    }\n  }\n  g.listener = listener;\n  return g;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  if (typeof listener !== 'function')\n    throw new TypeError('\"listener\" argument must be a function');\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      if (typeof listener !== 'function')\n        throw new TypeError('\"listener\" argument must be a function');\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      if (typeof listener !== 'function')\n        throw new TypeError('\"listener\" argument must be a function');\n\n      events = this._events;\n      if (!events)\n        return this;\n\n      list = events[type];\n      if (!list)\n        return this;\n\n      if (list === listener || (list.listener && list.listener === listener)) {\n        if (--this._eventsCount === 0)\n          this._events = new EventHandlers();\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length; i-- > 0;) {\n          if (list[i] === listener ||\n              (list[i].listener && list[i].listener === listener)) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (list.length === 1) {\n          list[0] = undefined;\n          if (--this._eventsCount === 0) {\n            this._events = new EventHandlers();\n            return this;\n          } else {\n            delete events[type];\n          }\n        } else {\n          spliceOne(list, position);\n        }\n\n        if (events.removeListener)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events;\n\n      events = this._events;\n      if (!events)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (!events.removeListener) {\n        if (arguments.length === 0) {\n          this._events = new EventHandlers();\n          this._eventsCount = 0;\n        } else if (events[type]) {\n          if (--this._eventsCount === 0)\n            this._events = new EventHandlers();\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        for (var i = 0, key; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = new EventHandlers();\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners) {\n        // LIFO order\n        do {\n          this.removeListener(type, listeners[listeners.length - 1]);\n        } while (listeners[0]);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  var evlistener;\n  var ret;\n  var events = this._events;\n\n  if (!events)\n    ret = [];\n  else {\n    evlistener = events[type];\n    if (!evlistener)\n      ret = [];\n    else if (typeof evlistener === 'function')\n      ret = [evlistener.listener || evlistener];\n    else\n      ret = unwrapListeners(evlistener);\n  }\n\n  return ret;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];\n};\n\n// About 1.5x faster than the two-arg version of Array#splice().\nfunction spliceOne(list, index) {\n  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)\n    list[i] = list[k];\n  list.pop();\n}\n\nfunction arrayClone(arr, i) {\n  var copy = new Array(i);\n  while (i--)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n","\nvar inherits;\nif (typeof Object.create === 'function'){\n  inherits = function inherits(ctor, superCtor) {\n    // implementation from standard node.js 'util' module\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  inherits = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\nexport default inherits;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\nimport process from 'process';\nvar formatRegExp = /%[sdj%]/g;\nexport function format(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexport function deprecate(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexport function debuglog(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = 0;\n      debugs[set] = function() {\n        var msg = format.apply(null, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nexport function inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    _extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nexport function isArray(ar) {\n  return Array.isArray(ar);\n}\n\nexport function isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\n\nexport function isNull(arg) {\n  return arg === null;\n}\n\nexport function isNullOrUndefined(arg) {\n  return arg == null;\n}\n\nexport function isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nexport function isString(arg) {\n  return typeof arg === 'string';\n}\n\nexport function isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\n\nexport function isUndefined(arg) {\n  return arg === void 0;\n}\n\nexport function isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\n\nexport function isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nexport function isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\n\nexport function isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\n\nexport function isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nexport function isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\n\nexport function isBuffer(maybeBuf) {\n  return Buffer.isBuffer(maybeBuf);\n}\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexport function log() {\n  console.log('%s - %s', timestamp(), format.apply(null, arguments));\n}\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nimport inherits from './inherits';\nexport {inherits}\n\nexport function _extend(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nexport default {\n  inherits: inherits,\n  _extend: _extend,\n  log: log,\n  isBuffer: isBuffer,\n  isPrimitive: isPrimitive,\n  isFunction: isFunction,\n  isError: isError,\n  isDate: isDate,\n  isObject: isObject,\n  isRegExp: isRegExp,\n  isUndefined: isUndefined,\n  isSymbol: isSymbol,\n  isString: isString,\n  isNumber: isNumber,\n  isNullOrUndefined: isNullOrUndefined,\n  isNull: isNull,\n  isBoolean: isBoolean,\n  isArray: isArray,\n  inspect: inspect,\n  deprecate: deprecate,\n  format: format,\n  debuglog: debuglog\n}\n","import {Buffer} from 'buffer';\n\nexport default BufferList;\n\nfunction BufferList() {\n  this.head = null;\n  this.tail = null;\n  this.length = 0;\n}\n\nBufferList.prototype.push = function (v) {\n  var entry = { data: v, next: null };\n  if (this.length > 0) this.tail.next = entry;else this.head = entry;\n  this.tail = entry;\n  ++this.length;\n};\n\nBufferList.prototype.unshift = function (v) {\n  var entry = { data: v, next: this.head };\n  if (this.length === 0) this.tail = entry;\n  this.head = entry;\n  ++this.length;\n};\n\nBufferList.prototype.shift = function () {\n  if (this.length === 0) return;\n  var ret = this.head.data;\n  if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n  --this.length;\n  return ret;\n};\n\nBufferList.prototype.clear = function () {\n  this.head = this.tail = null;\n  this.length = 0;\n};\n\nBufferList.prototype.join = function (s) {\n  if (this.length === 0) return '';\n  var p = this.head;\n  var ret = '' + p.data;\n  while (p = p.next) {\n    ret += s + p.data;\n  }return ret;\n};\n\nBufferList.prototype.concat = function (n) {\n  if (this.length === 0) return Buffer.alloc(0);\n  if (this.length === 1) return this.head.data;\n  var ret = Buffer.allocUnsafe(n >>> 0);\n  var p = this.head;\n  var i = 0;\n  while (p) {\n    p.data.copy(ret, i);\n    i += p.data.length;\n    p = p.next;\n  }\n  return ret;\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nimport {Buffer} from 'buffer';\nvar isBufferEncoding = Buffer.isEncoding\n  || function(encoding) {\n       switch (encoding && encoding.toLowerCase()) {\n         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;\n         default: return false;\n       }\n     }\n\n\nfunction assertEncoding(encoding) {\n  if (encoding && !isBufferEncoding(encoding)) {\n    throw new Error('Unknown encoding: ' + encoding);\n  }\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters. CESU-8 is handled as part of the UTF-8 encoding.\n//\n// @TODO Handling all encodings inside a single object makes it very difficult\n// to reason about this code, so it should be split up in the future.\n// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code\n// points as used by CESU-8.\nexport function StringDecoder(encoding) {\n  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');\n  assertEncoding(encoding);\n  switch (this.encoding) {\n    case 'utf8':\n      // CESU-8 represents each of Surrogate Pair by 3-bytes\n      this.surrogateSize = 3;\n      break;\n    case 'ucs2':\n    case 'utf16le':\n      // UTF-16 represents each of Surrogate Pair by 2-bytes\n      this.surrogateSize = 2;\n      this.detectIncompleteChar = utf16DetectIncompleteChar;\n      break;\n    case 'base64':\n      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.\n      this.surrogateSize = 3;\n      this.detectIncompleteChar = base64DetectIncompleteChar;\n      break;\n    default:\n      this.write = passThroughWrite;\n      return;\n  }\n\n  // Enough space to store all bytes of a single character. UTF-8 needs 4\n  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).\n  this.charBuffer = new Buffer(6);\n  // Number of bytes received for the current incomplete multi-byte character.\n  this.charReceived = 0;\n  // Number of bytes expected for the current incomplete multi-byte character.\n  this.charLength = 0;\n};\n\n\n// write decodes the given buffer and returns it as JS string that is\n// guaranteed to not contain any partial multi-byte characters. Any partial\n// character found at the end of the buffer is buffered up, and will be\n// returned when calling write again with the remaining bytes.\n//\n// Note: Converting a Buffer containing an orphan surrogate to a String\n// currently works, but converting a String to a Buffer (via `new Buffer`, or\n// Buffer#write) will replace incomplete surrogates with the unicode\n// replacement character. See https://codereview.chromium.org/121173009/ .\nStringDecoder.prototype.write = function(buffer) {\n  var charStr = '';\n  // if our last write ended with an incomplete multibyte character\n  while (this.charLength) {\n    // determine how many remaining bytes this buffer has to offer for this char\n    var available = (buffer.length >= this.charLength - this.charReceived) ?\n        this.charLength - this.charReceived :\n        buffer.length;\n\n    // add the new bytes to the char buffer\n    buffer.copy(this.charBuffer, this.charReceived, 0, available);\n    this.charReceived += available;\n\n    if (this.charReceived < this.charLength) {\n      // still not enough chars in this buffer? wait for more ...\n      return '';\n    }\n\n    // remove bytes belonging to the current character from the buffer\n    buffer = buffer.slice(available, buffer.length);\n\n    // get the character that was split\n    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);\n\n    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\n    var charCode = charStr.charCodeAt(charStr.length - 1);\n    if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n      this.charLength += this.surrogateSize;\n      charStr = '';\n      continue;\n    }\n    this.charReceived = this.charLength = 0;\n\n    // if there are no more bytes in this buffer, just emit our char\n    if (buffer.length === 0) {\n      return charStr;\n    }\n    break;\n  }\n\n  // determine and set charLength / charReceived\n  this.detectIncompleteChar(buffer);\n\n  var end = buffer.length;\n  if (this.charLength) {\n    // buffer the incomplete character bytes we got\n    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);\n    end -= this.charReceived;\n  }\n\n  charStr += buffer.toString(this.encoding, 0, end);\n\n  var end = charStr.length - 1;\n  var charCode = charStr.charCodeAt(end);\n  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\n  if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n    var size = this.surrogateSize;\n    this.charLength += size;\n    this.charReceived += size;\n    this.charBuffer.copy(this.charBuffer, size, 0, size);\n    buffer.copy(this.charBuffer, 0, 0, size);\n    return charStr.substring(0, end);\n  }\n\n  // or just emit the charStr\n  return charStr;\n};\n\n// detectIncompleteChar determines if there is an incomplete UTF-8 character at\n// the end of the given buffer. If so, it sets this.charLength to the byte\n// length that character, and sets this.charReceived to the number of bytes\n// that are available for this character.\nStringDecoder.prototype.detectIncompleteChar = function(buffer) {\n  // determine how many bytes we have to check at the end of this buffer\n  var i = (buffer.length >= 3) ? 3 : buffer.length;\n\n  // Figure out if one of the last i bytes of our buffer announces an\n  // incomplete char.\n  for (; i > 0; i--) {\n    var c = buffer[buffer.length - i];\n\n    // See http://en.wikipedia.org/wiki/UTF-8#Description\n\n    // 110XXXXX\n    if (i == 1 && c >> 5 == 0x06) {\n      this.charLength = 2;\n      break;\n    }\n\n    // 1110XXXX\n    if (i <= 2 && c >> 4 == 0x0E) {\n      this.charLength = 3;\n      break;\n    }\n\n    // 11110XXX\n    if (i <= 3 && c >> 3 == 0x1E) {\n      this.charLength = 4;\n      break;\n    }\n  }\n  this.charReceived = i;\n};\n\nStringDecoder.prototype.end = function(buffer) {\n  var res = '';\n  if (buffer && buffer.length)\n    res = this.write(buffer);\n\n  if (this.charReceived) {\n    var cr = this.charReceived;\n    var buf = this.charBuffer;\n    var enc = this.encoding;\n    res += buf.slice(0, cr).toString(enc);\n  }\n\n  return res;\n};\n\nfunction passThroughWrite(buffer) {\n  return buffer.toString(this.encoding);\n}\n\nfunction utf16DetectIncompleteChar(buffer) {\n  this.charReceived = buffer.length % 2;\n  this.charLength = this.charReceived ? 2 : 0;\n}\n\nfunction base64DetectIncompleteChar(buffer) {\n  this.charReceived = buffer.length % 3;\n  this.charLength = this.charReceived ? 3 : 0;\n}\n","'use strict';\n\n\nReadable.ReadableState = ReadableState;\nimport EventEmitter from 'events';\nimport {inherits, debuglog} from 'util';\nimport BufferList from './buffer-list';\nimport {StringDecoder} from 'string_decoder';\nimport {Duplex} from './duplex';\nimport {nextTick} from 'process';\n\nvar debug = debuglog('stream');\ninherits(Readable, EventEmitter);\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') {\n    return emitter.prependListener(event, fn);\n  } else {\n    // This is a hack to make sure that our error handler is attached before any\n    // userland ones.  NEVER DO THIS. This is here only because this code needs\n    // to continue to work with older versions of Node.js that do not include\n    // the prependListener() method. The goal is to eventually remove this hack.\n    if (!emitter._events || !emitter._events[event])\n      emitter.on(event, fn);\n    else if (Array.isArray(emitter._events[event]))\n      emitter._events[event].unshift(fn);\n    else\n      emitter._events[event] = [fn, emitter._events[event]];\n  }\n}\nfunction listenerCount (emitter, type) {\n  return emitter.listeners(type).length;\n}\nfunction ReadableState(options, stream) {\n\n  options = options || {};\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = ~ ~this.highWaterMark;\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // when piping, we only care about 'readable' events that happen\n  // after read()ing all the bytes and not getting any pushback.\n  this.ranOut = false;\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\nexport default Readable;\nexport function Readable(options) {\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options && typeof options.read === 'function') this._read = options.read;\n\n  EventEmitter.call(this);\n}\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n\n  if (!state.objectMode && typeof chunk === 'string') {\n    encoding = encoding || state.defaultEncoding;\n    if (encoding !== state.encoding) {\n      chunk = Buffer.from(chunk, encoding);\n      encoding = '';\n    }\n  }\n\n  return readableAddChunk(this, state, chunk, encoding, false);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  var state = this._readableState;\n  return readableAddChunk(this, state, chunk, '', true);\n};\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\nfunction readableAddChunk(stream, state, chunk, encoding, addToFront) {\n  var er = chunkInvalid(state, chunk);\n  if (er) {\n    stream.emit('error', er);\n  } else if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else if (state.objectMode || chunk && chunk.length > 0) {\n    if (state.ended && !addToFront) {\n      var e = new Error('stream.push() after EOF');\n      stream.emit('error', e);\n    } else if (state.endEmitted && addToFront) {\n      var _e = new Error('stream.unshift() after end event');\n      stream.emit('error', _e);\n    } else {\n      var skipAdd;\n      if (state.decoder && !addToFront && !encoding) {\n        chunk = state.decoder.write(chunk);\n        skipAdd = !state.objectMode && chunk.length === 0;\n      }\n\n      if (!addToFront) state.reading = false;\n\n      // Don't add to the buffer if we've decoded to an empty string chunk and\n      // we're not in object mode\n      if (!skipAdd) {\n        // if we want the data now, just emit it.\n        if (state.flowing && state.length === 0 && !state.sync) {\n          stream.emit('data', chunk);\n          stream.read(0);\n        } else {\n          // update the buffer info.\n          state.length += state.objectMode ? 1 : chunk.length;\n          if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n          if (state.needReadable) emitReadable(stream);\n        }\n      }\n\n      maybeReadMore(stream, state);\n    }\n  } else if (!addToFront) {\n    state.reading = false;\n  }\n\n  return needMoreData(state);\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction chunkInvalid(state, chunk) {\n  var er = null;\n  if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false);\n\n  var endFn = doEnd ? onend : cleanup;\n  if (state.endEmitted) nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable) {\n    debug('onunpipe');\n    if (readable === src) {\n      cleanup();\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', cleanup);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (listenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && src.listeners('data').length) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var _i = 0; _i < len; _i++) {\n      dests[_i].emit('unpipe', this);\n    }return this;\n  }\n\n  // try to find the right one.\n  var i = indexOf(state.pipes, dest);\n  if (i === -1) return this;\n\n  state.pipes.splice(i, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = EventEmitter.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this, state);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var state = this._readableState;\n  var paused = false;\n\n  var self = this;\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) self.push(chunk);\n    }\n\n    self.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = self.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  var events = ['error', 'close', 'destroy', 'pause', 'resume'];\n  forEach(events, function (ev) {\n    stream.on(ev, self.emit.bind(self, ev));\n  });\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  self._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return self;\n};\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction forEach(xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}\n","// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n\nimport {inherits, deprecate} from 'util';\nimport {Buffer} from 'buffer';\nWritable.WritableState = WritableState;\nimport {EventEmitter} from 'events';\nimport {Duplex} from './duplex';\nimport {nextTick} from 'process';\ninherits(Writable, EventEmitter);\n\nfunction nop() {}\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\nfunction WritableState(options, stream) {\n  Object.defineProperty(this, 'buffer', {\n    get: deprecate(function () {\n      return this.getBuffer();\n    }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')\n  });\n  options = options || {};\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = ~ ~this.highWaterMark;\n\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function writableStateGetBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\nexport default Writable;\nexport function Writable(options) {\n\n  // Writable ctor is applied to Duplexes, though they're not\n  // instanceof Writable, they're instanceof Readable.\n  if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options);\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n  }\n\n  EventEmitter.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  nextTick(cb, er);\n}\n\n// If we get something that is not a buffer, string, null, or undefined,\n// and we're not in objectMode, then that's an error.\n// Otherwise stream chunks are all considered to be of length=1, and the\n// watermarks determine how many objects to keep in the buffer, rather than\n// how many bytes or characters.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n  // Always throw error if a null is written\n  // if we are not in object mode then throw\n  // if it is not a buffer, string, or undefined.\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, chunk, encoding, cb) {\n  chunk = decodeChunk(state, chunk, encoding);\n\n  if (Buffer.isBuffer(chunk)) encoding = 'buffer';\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = new WriteReq(chunk, encoding, cb);\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n  if (sync) nextTick(cb, er);else cb(er);\n\n  stream._writableState.errorEmitted = true;\n  stream.emit('error', er);\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n        nextTick(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n        afterWrite(stream, state, finished, cb);\n      }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    while (entry) {\n      buffer[count] = entry;\n      entry = entry.next;\n      count += 1;\n    }\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequestCount = 0;\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction prefinish(stream, state) {\n  if (!state.prefinished) {\n    state.prefinished = true;\n    stream.emit('prefinish');\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    if (state.pendingcb === 0) {\n      prefinish(stream, state);\n      state.finished = true;\n      stream.emit('finish');\n    } else {\n      prefinish(stream, state);\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n\n  this.finish = function (err) {\n    var entry = _this.entry;\n    _this.entry = null;\n    while (entry) {\n      var cb = entry.callback;\n      state.pendingcb--;\n      cb(err);\n      entry = entry.next;\n    }\n    if (state.corkedRequestsFree) {\n      state.corkedRequestsFree.next = _this;\n    } else {\n      state.corkedRequestsFree = _this;\n    }\n  };\n}\n","\nimport {inherits} from 'util';\nimport {nextTick} from 'process';\nimport {Readable} from './readable';\nimport {Writable} from './writable';\n\n\ninherits(Duplex, Readable);\n\nvar keys = Object.keys(Writable.prototype);\nfor (var v = 0; v < keys.length; v++) {\n  var method = keys[v];\n  if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n}\nexport default Duplex;\nexport function Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n","// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n\nimport {Duplex} from './duplex';\n\n\nimport {inherits} from 'util';\ninherits(Transform, Duplex);\n\nfunction TransformState(stream) {\n  this.afterTransform = function (er, data) {\n    return afterTransform(stream, er, data);\n  };\n\n  this.needTransform = false;\n  this.transforming = false;\n  this.writecb = null;\n  this.writechunk = null;\n  this.writeencoding = null;\n}\n\nfunction afterTransform(stream, er, data) {\n  var ts = stream._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) return stream.emit('error', new Error('no writecb in Transform class'));\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data !== null && data !== undefined) stream.push(data);\n\n  cb(er);\n\n  var rs = stream._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    stream._read(rs.highWaterMark);\n  }\n}\nexport default Transform;\nexport function Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = new TransformState(this);\n\n  // when the writable side finishes, then flush out anything remaining.\n  var stream = this;\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  this.once('prefinish', function () {\n    if (typeof this._flush === 'function') this._flush(function (er) {\n      done(stream, er);\n    });else done(stream);\n  });\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('Not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nfunction done(stream, er) {\n  if (er) return stream.emit('error', er);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  var ws = stream._writableState;\n  var ts = stream._transformState;\n\n  if (ws.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (ts.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}\n","\nimport {Transform} from './transform';\n\nimport {inherits} from 'util';\ninherits(PassThrough, Transform);\nexport default PassThrough;\nexport function PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};\n","import EE from 'events';\nimport {inherits} from 'util';\n\nimport {Duplex} from './readable-stream/duplex.js';\nimport {Readable} from './readable-stream/readable.js';\nimport {Writable} from './readable-stream/writable.js';\nimport {Transform} from './readable-stream/transform.js';\nimport {PassThrough} from './readable-stream/passthrough.js';\ninherits(Stream, EE);\nStream.Readable = Readable;\nStream.Writable = Writable;\nStream.Duplex = Duplex;\nStream.Transform = Transform;\nStream.PassThrough = PassThrough;\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\nexport default Stream;\nexport {Readable,Writable,Duplex,Transform,PassThrough,Stream}\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","import Stream from 'stream';\n\nexport default class ChunkStream extends Stream {\n  constructor() {\n    super();\n\n    this._buffers = [];\n    this._buffered = 0;\n\n    this._reads = [];\n    this._paused = false;\n\n    this._encoding = 'utf8';\n    this.writable = true;\n    this._hasErrd = false;\n    this._setError = this._setError.bind(this);\n    this._runLoop = this._runLoop.bind(this);\n    this.on('error', () => this._setError(true));\n  }\n\n  _setError(status) {\n    this._hasErrd = status;\n  }\n\n  _runLoop() {\n    this._process();\n\n    // its paused and there is not enought data then ask for more\n    if (this._paused && this._reads && this._reads.length > 0) {\n      this._paused = false;\n\n      this.emit('drain');\n    }\n  }\n\n  read(length, callback) {\n    this._reads.push({\n      length: Math.abs(length), // if length < 0 then at most this length\n      allowLess: length < 0,\n      func: callback,\n    });\n\n    process.nextTick(this._runLoop);\n  }\n\n  write(data, encoding) {\n    if (!this.writable) {\n      this.emit('error', new Error('Stream not writable'));\n      return false;\n    }\n\n    var dataBuffer;\n    if (Buffer.isBuffer(data)) {\n      dataBuffer = data;\n    } else {\n      dataBuffer = Buffer.from(data, encoding || this._encoding);\n    }\n\n    this._buffers.push(dataBuffer);\n    this._buffered += dataBuffer.length;\n\n    this._process();\n\n    // ok if there are no more read requests\n    if (this._reads && this._reads.length === 0) {\n      this._paused = true;\n    }\n\n    return this.writable && !this._paused;\n  }\n\n  end(data, encoding) {\n    if (data) {\n      this.write(data, encoding);\n    }\n\n    this.writable = false;\n\n    // already destroyed\n    if (!this._buffers) {\n      return;\n    }\n\n    // enqueue or handle end\n    if (this._buffers.length === 0) {\n      this._end();\n    } else {\n      this._buffers.push(null);\n      this._process();\n    }\n  }\n\n  _end() {\n    if (this._reads.length > 0 && !this._hasErrd) {\n      this.emit('error', new Error('Unexpected end of input'));\n    }\n\n    this.destroy();\n  }\n\n  destroy() {\n    if (!this._buffers) {\n      return;\n    }\n\n    this.writable = false;\n    this._reads = null;\n    this._buffers = null;\n\n    this.emit('close');\n  }\n\n  _processReadAllowingLess(read) {\n    // ok there is any data so that we can satisfy this request\n    this._reads.shift(); // == read\n\n    // first we need to peek into first buffer\n    var smallerBuf = this._buffers[0];\n\n    // ok there is more data than we need\n    if (smallerBuf.length > read.length) {\n      this._buffered -= read.length;\n      this._buffers[0] = smallerBuf.slice(read.length);\n\n      read.func.call(this, smallerBuf.slice(0, read.length));\n    } else {\n      // ok this is less than maximum length so use it all\n      this._buffered -= smallerBuf.length;\n      this._buffers.shift(); // == smallerBuf\n\n      read.func.call(this, smallerBuf);\n    }\n  }\n\n  _processRead(read) {\n    this._reads.shift(); // == read\n\n    var pos = 0;\n    var count = 0;\n    var data = Buffer.alloc(read.length);\n\n    // create buffer for all data\n    while (pos < read.length) {\n      var buf = this._buffers[count++];\n      var len = Math.min(buf.length, read.length - pos);\n\n      buf.copy(data, pos, 0, len);\n      pos += len;\n\n      // last buffer wasn't used all so just slice it and leave\n      if (len !== buf.length) {\n        this._buffers[--count] = buf.slice(len);\n      }\n    }\n\n    // remove all used buffers\n    if (count > 0) {\n      this._buffers.splice(0, count);\n    }\n\n    this._buffered -= read.length;\n\n    read.func.call(this, data);\n  }\n\n  _process() {\n    try {\n      // as long as there is any data and read requests\n      while (this._buffered > 0 && this._reads && this._reads.length > 0) {\n        var read = this._reads[0];\n\n        // read any data (but no more than length)\n        if (read.allowLess) {\n          this._processReadAllowingLess(read);\n        } else if (this._buffered >= read.length) {\n          // ok we can meet some expectations\n\n          this._processRead(read);\n        } else {\n          // not enought data to satisfy first request in queue\n          // so we need to wait for more\n          break;\n        }\n      }\n\n      if (this._buffers && !this.writable) {\n        this._end();\n      }\n    } catch (ex) {\n      this.emit('error', ex);\n    }\n  }\n}\n\nChunkStream.prototype.destroySoon = ChunkStream.prototype.end;\n","export default function filterNone(pxData, pxPos, byteWidth, rawData, rawPos) {\n  for (var x = 0; x < byteWidth; x++) {\n    rawData[rawPos + x] = pxData[pxPos + x];\n  }\n}\n","export default function filterSub(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {\n  for (var x = 0; x < byteWidth; x++) {\n    var left = x >= bpp ? pxData[pxPos + x - bpp] : 0;\n    var val = pxData[pxPos + x] - left;\n\n    rawData[rawPos + x] = val;\n  }\n}\n","export default function filterUp(pxData, pxPos, byteWidth, rawData, rawPos) {\n  for (var x = 0; x < byteWidth; x++) {\n    var up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;\n    var val = pxData[pxPos + x] - up;\n\n    rawData[rawPos + x] = val;\n  }\n}\n","export default function filterAvg(\n  pxData,\n  pxPos,\n  byteWidth,\n  rawData,\n  rawPos,\n  bpp,\n) {\n  for (var x = 0; x < byteWidth; x++) {\n    var left = x >= bpp ? pxData[pxPos + x - bpp] : 0;\n    var up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;\n    var val = pxData[pxPos + x] - ((left + up) >> 1);\n\n    rawData[rawPos + x] = val;\n  }\n}\n","export default function paethPredictor(left, above, upLeft) {\r\n  var paeth = left + above - upLeft;\r\n  var pLeft = Math.abs(paeth - left);\r\n  var pAbove = Math.abs(paeth - above);\r\n  var pUpLeft = Math.abs(paeth - upLeft);\r\n\r\n  if (pLeft <= pAbove && pLeft <= pUpLeft) {\r\n    return left;\r\n  }\r\n  if (pAbove <= pUpLeft) {\r\n    return above;\r\n  }\r\n  return upLeft;\r\n}\r\n","import paethPredictor from '../../paeth-predictor';\n\nexport default function filterPaeth(\n  pxData,\n  pxPos,\n  byteWidth,\n  rawData,\n  rawPos,\n  bpp,\n) {\n  for (let x = 0; x < byteWidth; x++) {\n    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;\n    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;\n    let upleft = pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;\n    let val = pxData[pxPos + x] - paethPredictor(left, up, upleft);\n\n    rawData[rawPos + x] = val;\n  }\n  return rawData;\n}\n","export default function filterSumNone(pxData, pxPos, byteWidth) {\n  var sum = 0;\n  var length = pxPos + byteWidth;\n  for (var i = pxPos; i < length; i++) {\n    sum += Math.abs(pxData[i]);\n  }\n  return sum;\n}\n","export default function filterSumSub(pxData, pxPos, byteWidth, bpp) {\n  var sum = 0;\n  for (var x = 0; x < byteWidth; x++) {\n    var left = x >= bpp ? pxData[pxPos + x - bpp] : 0;\n    var val = pxData[pxPos + x] - left;\n\n    sum += Math.abs(val);\n  }\n\n  return sum;\n}\n","export default function filterSumUp(pxData, pxPos, byteWidth) {\n  var sum = 0;\n  var length = pxPos + byteWidth;\n  for (var x = pxPos; x < length; x++) {\n    var up = pxPos > 0 ? pxData[x - byteWidth] : 0;\n    var val = pxData[x] - up;\n\n    sum += Math.abs(val);\n  }\n\n  return sum;\n}\n","export default function filterSumAvg(pxData, pxPos, byteWidth, bpp) {\n  let sum = 0;\n  for (let x = 0; x < byteWidth; x++) {\n\n    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;\n    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;\n    let val = pxData[pxPos + x] - ((left + up) >> 1);\n\n    sum += Math.abs(val);\n  }\n\n  return sum;\n}\n","import paethPredictor from '../../paeth-predictor';\n\nexport default function filterSumPaeth(pxData, pxPos, byteWidth, bpp) {\n  let sum = 0;\n  for (let x = 0; x < byteWidth; x++) {\n    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;\n    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;\n    let upleft = pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;\n    let val = pxData[pxPos + x] - paethPredictor(left, up, upleft);\n\n    sum += Math.abs(val);\n  }\n\n  return sum;\n}\n","// @flow\nimport filterNone from './filterNone';\nimport filterSub from './filterSub';\nimport filterUp from './filterUp';\nimport filterAvg from './filterAvg';\nimport filterPaeth from './filterPaeth';\nimport filterSumNone from './filterSumNone';\nimport filterSumSub from './filterSumSub';\nimport filterSumUp from './filterSumUp';\nimport filterSumAvg from './filterSumAvg';\nimport filterSumPaeth from './filterSumPaeth';\n\nvar filters = {\n  '0': filterNone,\n  '1': filterSub,\n  '2': filterUp,\n  '3': filterAvg,\n  '4': filterPaeth,\n};\n\nvar filterSums = {\n  '0': filterSumNone,\n  '1': filterSumSub,\n  '2': filterSumUp,\n  '3': filterSumAvg,\n  '4': filterSumPaeth,\n};\n\nexport default function(\n  pxData: Buffer,\n  width: number,\n  height: number,\n  options: Object,\n  bpp: number,\n) {\n  var filterTypes;\n  if (!('filterType' in options) || options.filterType === -1) {\n    filterTypes = ['0', '1', '2', '3', '4'];\n  } else if (typeof options.filterType === 'number') {\n    filterTypes = [options.filterType];\n  } else {\n    throw new Error('unrecognised filter types');\n  }\n\n  if (options.bitDepth === 16) {\n    bpp *= 2; // eslint-disable-line\n  }\n  var byteWidth = width * bpp;\n  var rawPos = 0;\n  var pxPos = 0;\n  var rawData = Buffer.alloc((byteWidth + 1) * height);\n\n  var sel = filterTypes[0];\n\n  for (var y = 0; y < height; y++) {\n    if (filterTypes.length > 1) {\n      // find best filter for this line (with lowest sum of values)\n      var min = Infinity;\n\n      for (var i = 0; i < filterTypes.length; i++) {\n        var sum = filterSums[filterTypes[i]](pxData, pxPos, byteWidth, bpp);\n        if (sum < min) {\n          sel = filterTypes[i];\n          min = sum;\n        }\n      }\n    }\n\n    rawData[rawPos] = parseInt(sel, 10);\n    rawPos++;\n    filters[sel](pxData, pxPos, byteWidth, rawData, rawPos, bpp);\n    rawPos += byteWidth;\n    pxPos += byteWidth;\n  }\n  return rawData;\n}\n","// Adam 7\n//   0 1 2 3 4 5 6 7\n// 0 x 6 4 6 x 6 4 6\n// 1 7 7 7 7 7 7 7 7\n// 2 5 6 5 6 5 6 5 6\n// 3 7 7 7 7 7 7 7 7\n// 4 3 6 4 6 3 6 4 6\n// 5 7 7 7 7 7 7 7 7\n// 6 5 6 5 6 5 6 5 6\n// 7 7 7 7 7 7 7 7 7\n\nconst imagePasses = [\n  {\n    // pass 1 - 1px\n    x: [0],\n    y: [0],\n  },\n  {\n    // pass 2 - 1px\n    x: [4],\n    y: [0],\n  },\n  {\n    // pass 3 - 2px\n    x: [0, 4],\n    y: [4],\n  },\n  {\n    // pass 4 - 4px\n    x: [2, 6],\n    y: [0, 4],\n  },\n  {\n    // pass 5 - 8px\n    x: [0, 2, 4, 6],\n    y: [2, 6],\n  },\n  {\n    // pass 6 - 16px\n    x: [1, 3, 5, 7],\n    y: [0, 2, 4, 6],\n  },\n  {\n    // pass 7 - 32px\n    x: [0, 1, 2, 3, 4, 5, 6, 7],\n    y: [1, 3, 5, 7],\n  },\n];\n\nexport const getImagePasses = function (width, height) {\n  var images = [];\n  var xLeftOver = width % 8;\n  var yLeftOver = height % 8;\n  var xRepeats = (width - xLeftOver) / 8;\n  var yRepeats = (height - yLeftOver) / 8;\n  for (var i = 0; i < imagePasses.length; i++) {\n    var pass = imagePasses[i];\n    var passWidth = xRepeats * pass.x.length;\n    var passHeight = yRepeats * pass.y.length;\n    for (var j = 0; j < pass.x.length; j++) {\n      if (pass.x[j] < xLeftOver) {\n        passWidth++;\n      } else {\n        break;\n      }\n    }\n    for (j = 0; j < pass.y.length; j++) {\n      if (pass.y[j] < yLeftOver) {\n        passHeight++;\n      } else {\n        break;\n      }\n    }\n    if (passWidth > 0 && passHeight > 0) {\n      images.push({ width: passWidth, height: passHeight, index: i });\n    }\n  }\n  return images;\n};\n\nexport const getInterlaceIterator = function (width) {\n  return function (x, y, pass) {\n    var outerXLeftOver = x % imagePasses[pass].x.length;\n    var outerX =\n      ((x - outerXLeftOver) / imagePasses[pass].x.length) * 8 + imagePasses[pass].x[outerXLeftOver];\n    var outerYLeftOver = y % imagePasses[pass].y.length;\n    var outerY =\n      ((y - outerYLeftOver) / imagePasses[pass].y.length) * 8 + imagePasses[pass].y[outerYLeftOver];\n    return outerX * 4 + outerY * width * 4;\n  };\n};\n","import * as interlaceUtils from '../interlace';\nimport paethPredictor from '../paeth-predictor';\n\nfunction getByteWidth(width, bpp, depth) {\n  var byteWidth = width * bpp;\n  if (depth !== 8) {\n    byteWidth = Math.ceil(byteWidth / (8 / depth));\n  }\n  return byteWidth;\n}\n\nexport default class Filter {\n  constructor(bitmapInfo, dependencies) {\n    var width = bitmapInfo.width;\n    var height = bitmapInfo.height;\n    var interlace = bitmapInfo.interlace;\n    var bpp = bitmapInfo.bpp;\n    var depth = bitmapInfo.depth;\n\n    this.read = dependencies.read;\n    this.write = dependencies.write;\n    this.complete = dependencies.complete;\n\n    this._imageIndex = 0;\n    this._images = [];\n    if (interlace) {\n      var passes = interlaceUtils.getImagePasses(width, height);\n      for (var i = 0; i < passes.length; i++) {\n        this._images.push({\n          byteWidth: getByteWidth(passes[i].width, bpp, depth),\n          height: passes[i].height,\n          lineIndex: 0,\n        });\n      }\n    } else {\n      this._images.push({\n        byteWidth: getByteWidth(width, bpp, depth),\n        height: height,\n        lineIndex: 0,\n      });\n    }\n\n    // when filtering the line we look at the pixel to the left\n    // the spec also says it is done on a byte level regardless of the number of pixels\n    // so if the depth is byte compatible (8 or 16) we subtract the bpp in order to compare back\n    // a pixel rather than just a different byte part. However if we are sub byte, we ignore.\n    if (depth === 8) {\n      this._xComparison = bpp;\n    } else if (depth === 16) {\n      this._xComparison = bpp * 2;\n    } else {\n      this._xComparison = 1;\n    }\n  }\n\n  start() {\n    this.read(this._images[this._imageIndex].byteWidth + 1, this._reverseFilterLine.bind(this));\n  }\n\n  _unFilterType1(rawData, unfilteredLine, byteWidth) {\n    var xComparison = this._xComparison;\n    var xBiggerThan = xComparison - 1;\n\n    for (var x = 0; x < byteWidth; x++) {\n      var rawByte = rawData[1 + x];\n      var f1Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;\n      unfilteredLine[x] = rawByte + f1Left;\n    }\n  }\n\n  _unFilterType2(rawData, unfilteredLine, byteWidth) {\n    var lastLine = this._lastLine;\n\n    for (var x = 0; x < byteWidth; x++) {\n      var rawByte = rawData[1 + x];\n      var f2Up = lastLine ? lastLine[x] : 0;\n      unfilteredLine[x] = rawByte + f2Up;\n    }\n  }\n\n  _unFilterType3(rawData, unfilteredLine, byteWidth) {\n    var xComparison = this._xComparison;\n    var xBiggerThan = xComparison - 1;\n    var lastLine = this._lastLine;\n\n    for (var x = 0; x < byteWidth; x++) {\n      var rawByte = rawData[1 + x];\n      var f3Up = lastLine ? lastLine[x] : 0;\n      var f3Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;\n      var f3Add = Math.floor((f3Left + f3Up) / 2);\n      unfilteredLine[x] = rawByte + f3Add;\n    }\n  }\n\n  _unFilterType4(rawData, unfilteredLine, byteWidth) {\n    var xComparison = this._xComparison;\n    var xBiggerThan = xComparison - 1;\n    var lastLine = this._lastLine;\n\n    for (var x = 0; x < byteWidth; x++) {\n      var rawByte = rawData[1 + x];\n      var f4Up = lastLine ? lastLine[x] : 0;\n      var f4Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;\n      var f4UpLeft = x > xBiggerThan && lastLine ? lastLine[x - xComparison] : 0;\n      var f4Add = paethPredictor(f4Left, f4Up, f4UpLeft);\n      unfilteredLine[x] = rawByte + f4Add;\n    }\n  }\n\n  _reverseFilterLine(rawData) {\n    var filter = rawData[0];\n    var unfilteredLine;\n    var currentImage = this._images[this._imageIndex];\n    var byteWidth = currentImage.byteWidth;\n\n    if (filter === 0) {\n      unfilteredLine = rawData.slice(1, byteWidth + 1);\n    } else {\n      unfilteredLine = Buffer.alloc(byteWidth);\n\n      switch (filter) {\n        case 1:\n          this._unFilterType1(rawData, unfilteredLine, byteWidth);\n          break;\n        case 2:\n          this._unFilterType2(rawData, unfilteredLine, byteWidth);\n          break;\n        case 3:\n          this._unFilterType3(rawData, unfilteredLine, byteWidth);\n          break;\n        case 4:\n          this._unFilterType4(rawData, unfilteredLine, byteWidth);\n          break;\n        default:\n          throw new Error('Unrecognised filter type - ' + filter);\n      }\n    }\n\n    this.write(unfilteredLine);\n\n    currentImage.lineIndex++;\n    if (currentImage.lineIndex >= currentImage.height) {\n      this._lastLine = null;\n      this._imageIndex++;\n      currentImage = this._images[this._imageIndex];\n    } else {\n      this._lastLine = unfilteredLine;\n    }\n\n    if (currentImage) {\n      // read, using the byte width that may be from the new current image\n      this.read(currentImage.byteWidth + 1, this._reverseFilterLine.bind(this));\n    } else {\n      this._lastLine = null;\n      this.complete();\n    }\n  }\n}\n","import ChunkStream from '../chunkstream';\nimport Filter from './parse';\n\nexport default class FilterAsync extends ChunkStream {\n  constructor(bitmapInfo) {\n    super();\n\n    var buffers = [];\n    var that = this;\n    this._filter = new Filter(bitmapInfo, {\n      read: this.read.bind(this),\n      write: function(buffer) {\n        buffers.push(buffer);\n      },\n      complete: function() {\n        that.emit('complete', Buffer.concat(buffers));\n      },\n    });\n\n    this._filter.start();\n  }\n}\n","const SyncReader = function (buffer) {\n  this._buffer = buffer;\n  this._reads = [];\n};\n\nSyncReader.prototype.read = function (length, callback) {\n  this._reads.push({\n    length: Math.abs(length), // if length < 0 then at most this length\n    allowLess: length < 0,\n    func: callback,\n  });\n};\n\nSyncReader.prototype.process = function () {\n  // as long as there is any data and read requests\n  while (this._reads.length > 0 && this._buffer.length) {\n    var read = this._reads[0];\n\n    if (this._buffer.length && (this._buffer.length >= read.length || read.allowLess)) {\n      // ok there is any data so that we can satisfy this request\n      this._reads.shift(); // == read\n\n      var buf = this._buffer;\n\n      this._buffer = buf.slice(read.length);\n\n      read.func.call(this, buf.slice(0, read.length));\n    } else {\n      break;\n    }\n  }\n\n  if (this._reads.length > 0) {\n    throw new Error('There are some read requests waitng on finished stream');\n  }\n\n  if (this._buffer.length > 0) {\n    throw new Error('unrecognised content at end of stream');\n  }\n};\n\nexport default SyncReader;\n","import SyncReader from '../sync-reader';\nimport Filter from './parse';\n\nexport default function(inBuffer, bitmapInfo) {\n  var outBuffers = [];\n  var reader = new SyncReader(inBuffer);\n  var filter = new Filter(bitmapInfo, {\n    read: reader.read.bind(reader),\n    write: function(bufferPart) {\n      outBuffers.push(bufferPart);\n    },\n    complete: function() {},\n  });\n\n  filter.start();\n  reader.process();\n\n  return Buffer.concat(outBuffers);\n}\n","export default [\n  // 0 - dummy entry\n  () => {},\n\n  // 1 - L\n  // 0: 0, 1: 0, 2: 0, 3: 0xff\n  (pxData, data, pxPos, rawPos) => {\n    if (rawPos === data.length) {\n      throw new Error('Ran out of data');\n    }\n\n    var pixel = data[rawPos];\n    pxData[pxPos] = pixel;\n    pxData[pxPos + 1] = pixel;\n    pxData[pxPos + 2] = pixel;\n    pxData[pxPos + 3] = 0xff;\n  },\n\n  // 2 - LA\n  // 0: 0, 1: 0, 2: 0, 3: 1\n  (pxData, data, pxPos, rawPos) => {\n    if (rawPos + 1 >= data.length) {\n      throw new Error('Ran out of data');\n    }\n\n    var pixel = data[rawPos];\n    pxData[pxPos] = pixel;\n    pxData[pxPos + 1] = pixel;\n    pxData[pxPos + 2] = pixel;\n    pxData[pxPos + 3] = data[rawPos + 1];\n  },\n\n  // 3 - RGB\n  // 0: 0, 1: 1, 2: 2, 3: 0xff\n  (pxData, data, pxPos, rawPos) => {\n    if (rawPos + 2 >= data.length) {\n      throw new Error('Ran out of data');\n    }\n\n    pxData[pxPos] = data[rawPos];\n    pxData[pxPos + 1] = data[rawPos + 1];\n    pxData[pxPos + 2] = data[rawPos + 2];\n    pxData[pxPos + 3] = 0xff;\n  },\n\n  // 4 - RGBA\n  // 0: 0, 1: 1, 2: 2, 3: 3\n  (pxData, data, pxPos, rawPos) => {\n    if (rawPos + 3 >= data.length) {\n      throw new Error('Ran out of data');\n    }\n\n    pxData[pxPos] = data[rawPos];\n    pxData[pxPos + 1] = data[rawPos + 1];\n    pxData[pxPos + 2] = data[rawPos + 2];\n    pxData[pxPos + 3] = data[rawPos + 3];\n  },\n];\n","import pixelBppCustomMapper from './pixelBppMapper';\n\nexport default function mapImage8Bit({ image, pxData, getPxPos, bpp, data, rawPos }) {\n  const imageWidth = image.width;\n  const imageHeight = image.height;\n  let imagePass = image.index;\n  for (let y = 0; y < imageHeight; y++) {\n    for (let x = 0; x < imageWidth; x++) {\n      let pxPos = getPxPos(x, y, imagePass);\n\n      pixelBppCustomMapper[bpp](pxData, data, pxPos, rawPos);\n      rawPos += bpp; //eslint-disable-line no-param-reassign\n    }\n  }\n  return rawPos;\n}\n","export default [\n  // 0 - dummy entry\n  () => {},\n\n  // 1 - L\n  // 0: 0, 1: 0, 2: 0, 3: 0xff\n  (pxData, pixelData, pxPos, maxBit) => {\n    var pixel = pixelData[0];\n    pxData[pxPos] = pixel;\n    pxData[pxPos + 1] = pixel;\n    pxData[pxPos + 2] = pixel;\n    pxData[pxPos + 3] = maxBit;\n  },\n\n  // 2 - LA\n  // 0: 0, 1: 0, 2: 0, 3: 1\n  (pxData, pixelData, pxPos) => {\n    var pixel = pixelData[0];\n    pxData[pxPos] = pixel;\n    pxData[pxPos + 1] = pixel;\n    pxData[pxPos + 2] = pixel;\n    pxData[pxPos + 3] = pixelData[1];\n  },\n\n  // 3 - RGB\n  // 0: 0, 1: 1, 2: 2, 3: 0xff\n  (pxData, pixelData, pxPos, maxBit) => {\n    pxData[pxPos] = pixelData[0];\n    pxData[pxPos + 1] = pixelData[1];\n    pxData[pxPos + 2] = pixelData[2];\n    pxData[pxPos + 3] = maxBit;\n  },\n\n  // 4 - RGBA\n  // 0: 0, 1: 1, 2: 2, 3: 3\n  (pxData, pixelData, pxPos) => {\n    pxData[pxPos] = pixelData[0];\n    pxData[pxPos + 1] = pixelData[1];\n    pxData[pxPos + 2] = pixelData[2];\n    pxData[pxPos + 3] = pixelData[3];\n  },\n];\n","import pixelBppCustomMapper from './pixelBppCustomMapper';\n\n// Used for non 8 bit images\nexport default function mapImageCustomBit({ image, pxData, getPxPos, bpp, bits, maxBit }) {\n  const { width: imageWidth, height: imageHeight } = image;\n  let imagePass = image.index;\n  for (let y = 0; y < imageHeight; y++) {\n    for (let x = 0; x < imageWidth; x++) {\n      let pixelData = bits.get(bpp);\n      let pxPos = getPxPos(x, y, imagePass);\n      pixelBppCustomMapper[bpp](pxData, pixelData, pxPos, maxBit);\n    }\n    bits.resetAfterLine();\n  }\n}\n","export default function bitRetriever(data, depth) {\n  let leftOver = [];\n  let i = 0;\n\n  function split() {\n    if (i === data.length) {\n      throw new Error('Ran out of data');\n    }\n    let byte = data[i];\n    i++;\n    let byte8, byte7, byte6, byte5, byte4, byte3, byte2, byte1;\n    switch (depth) {\n      default:\n        throw new Error('unrecognised depth');\n      case 16:\n        byte2 = data[i];\n        i++;\n        leftOver.push((byte << 8) + byte2);\n        break;\n      case 4:\n        byte2 = byte & 0x0f;\n        byte1 = byte >> 4;\n        leftOver.push(byte1, byte2);\n        break;\n      case 2:\n        byte4 = byte & 3;\n        byte3 = (byte >> 2) & 3;\n        byte2 = (byte >> 4) & 3;\n        byte1 = (byte >> 6) & 3;\n        leftOver.push(byte1, byte2, byte3, byte4);\n        break;\n      case 1:\n        byte8 = byte & 1;\n        byte7 = (byte >> 1) & 1;\n        byte6 = (byte >> 2) & 1;\n        byte5 = (byte >> 3) & 1;\n        byte4 = (byte >> 4) & 1;\n        byte3 = (byte >> 5) & 1;\n        byte2 = (byte >> 6) & 1;\n        byte1 = (byte >> 7) & 1;\n        leftOver.push(byte1, byte2, byte3, byte4, byte5, byte6, byte7, byte8);\n        break;\n    }\n  }\n\n  return {\n    get: function(count) {\n      while (leftOver.length < count) {\n        split();\n      }\n      let returner = leftOver.slice(0, count);\n      leftOver = leftOver.slice(count);\n      return returner;\n    },\n    resetAfterLine: function() {\n      leftOver.length = 0;\n    },\n    end: function() {\n      if (i !== data.length) {\n        throw new Error('extra data found');\n      }\n    },\n  };\n}\n","import * as interlaceUtils from '../interlace';\nimport mapImage8Bit from './mapImage8Bit';\nimport mapImageCustomBit from './mapImageCustomBit';\nimport bitRetriever from './bitRetriever';\n\nexport default function(data, bitmapInfo) {\n  const { width, height, depth, bpp, interlace } = bitmapInfo;\n\n  if (depth !== 8) {\n    var bits = bitRetriever(data, depth);\n  }\n  var pxData;\n  if (depth <= 8) {\n    pxData = Buffer.alloc(width * height * 4);\n  } else {\n    pxData = new Uint16Array(width * height * 4);\n  }\n  let rawPos = 0;\n  let images;\n  let getPxPos;\n\n  if (interlace) {\n    images = interlaceUtils.getImagePasses(width, height);\n    getPxPos = interlaceUtils.getInterlaceIterator(width, height);\n  } else {\n    var nonInterlacedPxPos = 0;\n    getPxPos = function() {\n      var returner = nonInterlacedPxPos;\n      nonInterlacedPxPos += 4;\n      return returner;\n    };\n    images = [{ width: width, height: height }];\n  }\n\n  for (var imageIndex = 0; imageIndex < images.length; imageIndex++) {\n    if (depth === 8) {\n      rawPos = mapImage8Bit({\n        image: images[imageIndex],\n        pxData,\n        getPxPos,\n        bpp,\n        data,\n        rawPos,\n      });\n    } else {\n      const maxBit = Math.pow(2, depth) - 1;\n      rawPos = mapImageCustomBit({\n        image: images[imageIndex],\n        pxData,\n        getPxPos,\n        bpp,\n        bits,\n        maxBit,\n      });\n    }\n  }\n  if (depth === 8) {\n    if (rawPos !== data.length) {\n      throw new Error('extra data found');\n    }\n  } else {\n    bits.end();\n  }\n\n  return pxData;\n}\n","function dePalette(indata, outdata, width, height, palette) {\n  var pxPos = 0;\n  // use values from palette\n  for (var y = 0; y < height; y++) {\n    for (var x = 0; x < width; x++) {\n      var color = palette[indata[pxPos]];\n\n      if (!color) {\n        throw new Error('index ' + indata[pxPos] + ' not in palette');\n      }\n\n      for (var i = 0; i < 4; i++) {\n        outdata[pxPos + i] = color[i];\n      }\n      pxPos += 4;\n    }\n  }\n}\n\nfunction replaceTransparentColor(indata, outdata, width, height, transColor) {\n  var pxPos = 0;\n  for (var y = 0; y < height; y++) {\n    for (var x = 0; x < width; x++) {\n      var makeTrans = false;\n\n      if (transColor.length === 1) {\n        if (transColor[0] === indata[pxPos]) {\n          makeTrans = true;\n        }\n      } else if (\n        transColor[0] === indata[pxPos] &&\n        transColor[1] === indata[pxPos + 1] &&\n        transColor[2] === indata[pxPos + 2]\n      ) {\n        makeTrans = true;\n      }\n      if (makeTrans) {\n        for (var i = 0; i < 4; i++) {\n          outdata[pxPos + i] = 0;\n        }\n      }\n      pxPos += 4;\n    }\n  }\n}\n\nfunction scaleDepth(indata, outdata, width, height, depth) {\n  var maxOutSample = 255;\n  var maxInSample = Math.pow(2, depth) - 1;\n  var pxPos = 0;\n\n  for (var y = 0; y < height; y++) {\n    for (var x = 0; x < width; x++) {\n      for (var i = 0; i < 4; i++) {\n        outdata[pxPos + i] = Math.floor((indata[pxPos + i] * maxOutSample) / maxInSample + 0.5);\n      }\n      pxPos += 4;\n    }\n  }\n}\n\nexport default function(indata, imageData, skipRescale = false) {\n  var depth = imageData.depth;\n  var width = imageData.width;\n  var height = imageData.height;\n  var colorType = imageData.colorType;\n  var transColor = imageData.transColor;\n  var palette = imageData.palette;\n\n  var outdata = indata; // only different for 16 bits\n\n  if (colorType === 3) {\n    // paletted\n    dePalette(indata, outdata, width, height, palette);\n  } else {\n    if (transColor) {\n      replaceTransparentColor(indata, outdata, width, height, transColor);\n    }\n    // if it needs scaling\n    if (depth !== 8 && !skipRescale) {\n      // if we need to change the buffer size\n      if (depth === 16) {\n        outdata = Buffer.alloc(width * height * 4);\n      }\n      scaleDepth(indata, outdata, width, height, depth);\n    }\n  }\n  return outdata;\n}\n","export const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];\n\nexport const TYPE_IHDR = 0x49484452;\nexport const TYPE_IEND = 0x49454e44;\nexport const TYPE_IDAT = 0x49444154;\nexport const TYPE_PLTE = 0x504c5445;\nexport const TYPE_tRNS = 0x74524e53; // eslint-disable-line camelcase\nexport const TYPE_gAMA = 0x67414d41; // eslint-disable-line camelcase\n\n// color-type bits\nexport const COLORTYPE_GRAYSCALE = 0;\nexport const COLORTYPE_PALETTE = 1;\nexport const COLORTYPE_COLOR = 2;\nexport const COLORTYPE_ALPHA = 4; // e.g. grayscale and alpha\n\n// color-type combinations\nexport const COLORTYPE_PALETTE_COLOR = 3;\nexport const COLORTYPE_COLOR_ALPHA = 6;\n\nexport const COLORTYPE_TO_BPP_MAP = {\n  0: 1,\n  2: 3,\n  3: 1,\n  4: 2,\n  6: 4,\n};\n\nexport const GAMMA_DIVISION = 100000;\n","var crcTable = [];\n\n(function () {\n  for (var i = 0; i < 256; i++) {\n    var currentCrc = i;\n    for (var j = 0; j < 8; j++) {\n      if (currentCrc & 1) {\n        currentCrc = 0xedb88320 ^ (currentCrc >>> 1);\n      } else {\n        currentCrc = currentCrc >>> 1;\n      }\n    }\n    crcTable[i] = currentCrc;\n  }\n})();\n\nconst CrcCalculator = function () {\n  this._crc = -1;\n};\n\nCrcCalculator.prototype.write = function (data) {\n  for (var i = 0; i < data.length; i++) {\n    this._crc = crcTable[(this._crc ^ data[i]) & 0xff] ^ (this._crc >>> 8);\n  }\n  return true;\n};\n\nCrcCalculator.prototype.crc32 = function () {\n  return this._crc ^ -1;\n};\n\nCrcCalculator.crc32 = function (buf) {\n  var crc = -1;\n  for (var i = 0; i < buf.length; i++) {\n    crc = crcTable[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);\n  }\n  return crc ^ -1;\n};\n\nexport default CrcCalculator;\n","import * as constants from '../constants';\nimport CrcCalculator from '../crc';\n\nexport default class Parser {\n  constructor(options, dependencies) {\n    this._options = options;\n    options.checkCRC = options.checkCRC !== false;\n\n    this._hasIHDR = false;\n    this._hasIEND = false;\n    this._emittedHeadersFinished = false;\n\n    // input flags/metadata\n    this._palette = [];\n    this._colorType = 0;\n\n    this._chunks = {};\n    this._chunks[constants.TYPE_IHDR] = this._handleIHDR.bind(this);\n    this._chunks[constants.TYPE_IEND] = this._handleIEND.bind(this);\n    this._chunks[constants.TYPE_IDAT] = this._handleIDAT.bind(this);\n    this._chunks[constants.TYPE_PLTE] = this._handlePLTE.bind(this);\n    this._chunks[constants.TYPE_tRNS] = this._handleTRNS.bind(this);\n    this._chunks[constants.TYPE_gAMA] = this._handleGAMA.bind(this);\n\n    this.read = dependencies.read;\n    this.error = dependencies.error;\n    this.metadata = dependencies.metadata;\n    this.gamma = dependencies.gamma;\n    this.transColor = dependencies.transColor;\n    this.palette = dependencies.palette;\n    this.parsed = dependencies.parsed;\n    this.inflateData = dependencies.inflateData;\n    this.finished = dependencies.finished;\n    this.simpleTransparency = dependencies.simpleTransparency;\n    this.headersFinished = dependencies.headersFinished || function () {};\n  }\n\n  start() {\n    this.read(constants.PNG_SIGNATURE.length, this._parseSignature.bind(this));\n  }\n\n  _parseSignature(data) {\n    var signature = constants.PNG_SIGNATURE;\n\n    for (var i = 0; i < signature.length; i++) {\n      if (data[i] !== signature[i]) {\n        this.error(\n          new Error(`Invalid file signature, at position ${i}: ${data[i]} !== ${signature[i]}`),\n        );\n        return;\n      }\n    }\n    this.read(8, this._parseChunkBegin.bind(this));\n  }\n\n  _parseChunkBegin(data) {\n    // chunk content length\n    var length = data.readUInt32BE(0);\n\n    // chunk type\n    var type = data.readUInt32BE(4);\n    var name = '';\n    for (var i = 4; i < 8; i++) {\n      name += String.fromCharCode(data[i]);\n    }\n\n    //console.log('chunk ', name, length);\n\n    // chunk flags\n    var ancillary = Boolean(data[4] & 0x20); // or critical\n    //    priv = Boolean(data[5] & 0x20), // or public\n    //    safeToCopy = Boolean(data[7] & 0x20); // or unsafe\n\n    if (!this._hasIHDR && type !== constants.TYPE_IHDR) {\n      this.error(new Error('Expected IHDR on beggining'));\n      return;\n    }\n\n    this._crc = new CrcCalculator();\n    this._crc.write(Buffer.from(name));\n\n    if (this._chunks[type]) {\n      return this._chunks[type](length);\n    }\n\n    if (!ancillary) {\n      this.error(new Error('Unsupported critical chunk type ' + name));\n      return;\n    }\n\n    this.read(length + 4, this._skipChunk.bind(this));\n  }\n\n  _skipChunk(/*data*/) {\n    this.read(8, this._parseChunkBegin.bind(this));\n  }\n\n  _handleChunkEnd() {\n    this.read(4, this._parseChunkEnd.bind(this));\n  }\n\n  _parseChunkEnd(data) {\n    var fileCrc = data.readInt32BE(0);\n    var calcCrc = this._crc.crc32();\n\n    // check CRC\n    if (this._options.checkCRC && calcCrc !== fileCrc) {\n      this.error(new Error('Crc error - ' + fileCrc + ' - ' + calcCrc));\n      return;\n    }\n\n    if (!this._hasIEND) {\n      this.read(8, this._parseChunkBegin.bind(this));\n    }\n  }\n\n  _handleIHDR(length) {\n    this.read(length, this._parseIHDR.bind(this));\n  }\n  _parseIHDR(data) {\n    this._crc.write(data);\n\n    var width = data.readUInt32BE(0);\n    var height = data.readUInt32BE(4);\n    var depth = data[8];\n    var colorType = data[9]; // bits: 1 palette, 2 color, 4 alpha\n    var compr = data[10];\n    var filter = data[11];\n    var interlace = data[12];\n\n    // console.log('    width', width, 'height', height,\n    //     'depth', depth, 'colorType', colorType,\n    //     'compr', compr, 'filter', filter, 'interlace', interlace\n    // );\n\n    if (depth !== 8 && depth !== 4 && depth !== 2 && depth !== 1 && depth !== 16) {\n      this.error(new Error('Unsupported bit depth ' + depth));\n      return;\n    }\n    if (!(colorType in constants.COLORTYPE_TO_BPP_MAP)) {\n      this.error(new Error('Unsupported color type'));\n      return;\n    }\n    if (compr !== 0) {\n      this.error(new Error('Unsupported compression method'));\n      return;\n    }\n    if (filter !== 0) {\n      this.error(new Error('Unsupported filter method'));\n      return;\n    }\n    if (interlace !== 0 && interlace !== 1) {\n      this.error(new Error('Unsupported interlace method'));\n      return;\n    }\n\n    this._colorType = colorType;\n\n    var bpp = constants.COLORTYPE_TO_BPP_MAP[this._colorType];\n\n    this._hasIHDR = true;\n\n    this.metadata({\n      width: width,\n      height: height,\n      depth: depth,\n      interlace: Boolean(interlace),\n      palette: Boolean(colorType & constants.COLORTYPE_PALETTE),\n      color: Boolean(colorType & constants.COLORTYPE_COLOR),\n      alpha: Boolean(colorType & constants.COLORTYPE_ALPHA),\n      bpp: bpp,\n      colorType: colorType,\n    });\n\n    this._handleChunkEnd();\n  }\n\n  _handlePLTE(length) {\n    this.read(length, this._parsePLTE.bind(this));\n  }\n\n  _parsePLTE(data) {\n    this._crc.write(data);\n\n    var entries = Math.floor(data.length / 3);\n    // console.log('Palette:', entries);\n\n    for (var i = 0; i < entries; i++) {\n      this._palette.push([data[i * 3], data[i * 3 + 1], data[i * 3 + 2], 0xff]);\n    }\n\n    this.palette(this._palette);\n\n    this._handleChunkEnd();\n  }\n\n  _handleTRNS(length) {\n    this.simpleTransparency();\n    this.read(length, this._parseTRNS.bind(this));\n  }\n\n  _parseTRNS(data) {\n    this._crc.write(data);\n\n    // palette\n    if (this._colorType === constants.COLORTYPE_PALETTE_COLOR) {\n      if (this._palette.length === 0) {\n        this.error(new Error('Transparency chunk must be after palette'));\n        return;\n      }\n      if (data.length > this._palette.length) {\n        this.error(new Error('More transparent colors than palette size'));\n        return;\n      }\n      for (var i = 0; i < data.length; i++) {\n        this._palette[i][3] = data[i];\n      }\n      this.palette(this._palette);\n    }\n\n    // for colorType 0 (grayscale) and 2 (rgb)\n    // there might be one gray/color defined as transparent\n    if (this._colorType === constants.COLORTYPE_GRAYSCALE) {\n      // grey, 2 bytes\n      this.transColor([data.readUInt16BE(0)]);\n    }\n    if (this._colorType === constants.COLORTYPE_COLOR) {\n      this.transColor([data.readUInt16BE(0), data.readUInt16BE(2), data.readUInt16BE(4)]);\n    }\n\n    this._handleChunkEnd();\n  }\n\n  _handleGAMA(length) {\n    this.read(length, this._parseGAMA.bind(this));\n  }\n\n  _parseGAMA(data) {\n    this._crc.write(data);\n    this.gamma(data.readUInt32BE(0) / constants.GAMMA_DIVISION);\n\n    this._handleChunkEnd();\n  }\n\n  _handleIDAT(length) {\n    if (!this._emittedHeadersFinished) {\n      this._emittedHeadersFinished = true;\n      this.headersFinished();\n    }\n    this.read(-length, this._parseIDAT.bind(this, length));\n  }\n\n  _parseIDAT(length, data) {\n    this._crc.write(data);\n\n    if (this._colorType === constants.COLORTYPE_PALETTE_COLOR && this._palette.length === 0) {\n      throw new Error('Expected palette not found');\n    }\n\n    this.inflateData(data);\n    var leftOverLength = length - data.length;\n\n    if (leftOverLength > 0) {\n      this._handleIDAT(leftOverLength);\n    } else {\n      this._handleChunkEnd();\n    }\n  }\n\n  _handleIEND(length) {\n    this.read(length, this._parseIEND.bind(this));\n  }\n\n  _parseIEND(data) {\n    this._crc.write(data);\n\n    this._hasIEND = true;\n    this._handleChunkEnd();\n\n    if (this.finished) {\n      this.finished();\n    }\n  }\n}\n","\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nvar hasOwn = Object.prototype.hasOwnProperty;\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n// based on node assert, original notice:\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\nimport {isBuffer} from 'buffer';\nimport {isPrimitive, inherits, isError, isFunction, isRegExp, isDate, inspect as utilInspect} from 'util';\nvar pSlice = Array.prototype.slice;\nvar _functionsHaveNames;\nfunction functionsHaveNames() {\n  if (typeof _functionsHaveNames !== 'undefined') {\n    return _functionsHaveNames;\n  }\n  return _functionsHaveNames = (function () {\n    return function foo() {}.name === 'foo';\n  }());\n}\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nfunction assert(value, message) {\n  if (!value) fail(value, true, message, '==', ok);\n}\nexport default assert;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames()) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = AssertionError;\nexport function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n}\n\n// assert.AssertionError instanceof Error\ninherits(AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames() || !isFunction(something)) {\n    return utilInspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nexport function fail(actual, expected, message, operator, stackStartFunction) {\n  throw new AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nexport function ok(value, message) {\n  if (!value) fail(value, true, message, '==', ok);\n}\nassert.ok = ok;\nexport {ok as assert};\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\nassert.equal = equal;\nexport function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', equal);\n}\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\nassert.notEqual = notEqual;\nexport function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', notEqual);\n  }\n}\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\nassert.deepEqual = deepEqual;\nexport function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', deepEqual);\n  }\n}\nassert.deepStrictEqual = deepStrictEqual;\nexport function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', deepStrictEqual);\n  }\n}\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (isDate(actual) && isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (isRegExp(actual) && isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (isPrimitive(a) || isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\nassert.notDeepEqual = notDeepEqual;\nexport function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', notDeepEqual);\n  }\n}\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nexport function notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\nassert.strictEqual = strictEqual;\nexport function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', strictEqual);\n  }\n}\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\nassert.notStrictEqual = notStrictEqual;\nexport function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', notStrictEqual);\n  }\n}\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\nassert.throws = throws;\nexport function throws(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n}\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = doesNotThrow;\nexport function doesNotThrow(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n}\n\nassert.ifError = ifError;\nexport function ifError(err) {\n  if (err) throw err;\n}\n","import zlib from 'browserify-zlib';\nimport ChunkStream from '../chunkstream';\nimport { ParseAsync as FilterAsync } from '../filter';\nimport dataToBitMap from '../dataToBitMap';\nimport formatNormaliser from '../format-normaliser';\nimport Parser from './parser';\n\nexport default class ParserAsync extends ChunkStream {\n  constructor(options) {\n    super(options);\n\n    this._parser = new Parser(options, {\n      read: this.read.bind(this),\n      error: this._handleError.bind(this),\n      metadata: this._handleMetaData.bind(this),\n      gamma: this.emit.bind(this, 'gamma'),\n      palette: this._handlePalette.bind(this),\n      transColor: this._handleTransColor.bind(this),\n      finished: this._finished.bind(this),\n      inflateData: this._inflateData.bind(this),\n      simpleTransparency: this._simpleTransparency.bind(this),\n      headersFinished: this._headersFinished.bind(this),\n    });\n    this._options = options;\n    this.writable = true;\n\n    this._parser.start();\n  }\n\n  _handleError(err) {\n    this.emit('error', err);\n\n    this.writable = false;\n\n    this.destroy();\n\n    if (this._inflate && this._inflate.destroy) {\n      this._inflate.destroy();\n    }\n\n    if (this._filter) {\n      this._filter.destroy();\n      // For backward compatibility with Node 7 and below.\n      // Suppress errors due to _inflate calling write() even after\n      // it's destroy()'ed.\n      this._filter.on('error', function () {});\n    }\n\n    this.errord = true;\n  }\n\n  _inflateData(data) {\n    if (!this._inflate) {\n      if (this._bitmapInfo.interlace) {\n        this._inflate = zlib.createInflate();\n\n        this._inflate.on('error', this.emit.bind(this, 'error'));\n        this._filter.on('complete', this._complete.bind(this));\n\n        this._inflate.pipe(this._filter);\n      } else {\n        var rowSize =\n          ((this._bitmapInfo.width * this._bitmapInfo.bpp * this._bitmapInfo.depth + 7) >> 3) + 1;\n        var imageSize = rowSize * this._bitmapInfo.height;\n        var chunkSize = Math.max(imageSize, zlib.Z_MIN_CHUNK);\n\n        this._inflate = zlib.createInflate({ chunkSize: chunkSize });\n        var leftToInflate = imageSize;\n\n        var emitError = this.emit.bind(this, 'error');\n        this._inflate.on('error', function (err) {\n          if (!leftToInflate) {\n            return;\n          }\n\n          emitError(err);\n        });\n        this._filter.on('complete', this._complete.bind(this));\n\n        var filterWrite = this._filter.write.bind(this._filter);\n        this._inflate.on('data', function (chunk) {\n          if (!leftToInflate) {\n            return;\n          }\n\n          if (chunk.length > leftToInflate) {\n            chunk = chunk.slice(0, leftToInflate); // eslint-disable-line\n          }\n\n          leftToInflate -= chunk.length;\n\n          filterWrite(chunk);\n        });\n\n        this._inflate.on('end', this._filter.end.bind(this._filter));\n      }\n    }\n    this._inflate.write(data);\n  }\n\n  _handleMetaData(metaData) {\n    this._metaData = metaData;\n    this._bitmapInfo = Object.create(metaData);\n\n    this._filter = new FilterAsync(this._bitmapInfo);\n  }\n\n  _handleTransColor(transColor) {\n    this._bitmapInfo.transColor = transColor;\n  }\n\n  _handlePalette(palette) {\n    this._bitmapInfo.palette = palette;\n  }\n\n  _simpleTransparency = function () {\n    this._metaData.alpha = true;\n  };\n\n  _headersFinished = function () {\n    // Up until this point, we don't know if we have a tRNS chunk (alpha)\n    // so we can't emit metadata any earlier\n    this.emit('metadata', this._metaData);\n  };\n\n  _finished() {\n    if (this.errord) {\n      return;\n    }\n\n    if (!this._inflate) {\n      this.emit('error', 'No Inflate block');\n    } else {\n      // no more data to inflate\n      this._inflate.end();\n    }\n  }\n\n  _complete(filteredData) {\n    if (this.errord) {\n      return;\n    }\n\n    try {\n      var bitmapData = dataToBitMap(filteredData, this._bitmapInfo);\n\n      var normalisedBitmapData = formatNormaliser(\n        bitmapData,\n        this._bitmapInfo,\n        this._options.skipRescale,\n      );\n      bitmapData = null;\n    } catch (ex) {\n      this._handleError(ex);\n      return;\n    }\n\n    this.emit('parsed', normalisedBitmapData);\n  }\n}\n","import { ok as assert } from 'assert';\nimport zlib from 'browserify-zlib';\nimport { kMaxLength } from 'buffer';\n\nexport class Inflate extends zlib.Inflate {\n  constructor(opts) {\n    super();\n    if (!(this instanceof Inflate)) {\n      return new Inflate(opts);\n    }\n\n    if (opts && opts.chunkSize < zlib.Z_MIN_CHUNK) {\n      opts.chunkSize = zlib.Z_MIN_CHUNK;\n    }\n\n    zlib.Inflate.call(this, opts);\n\n    // Node 8 --> 9 compatibility check\n    this._offset = this._offset === undefined ? this._outOffset : this._offset;\n    this._buffer = this._buffer || this._outBuffer;\n\n    if (opts && opts.maxLength) {\n      this._maxLength = opts.maxLength;\n    }\n  }\n\n  _close(callback) {\n    if (callback) {\n      process.nextTick(callback);\n    }\n\n    // Caller may invoke .close after a zlib error (which will null _handle).\n    if (!this._handle) {\n      return;\n    }\n\n    this._handle.close();\n    this._handle = null;\n  }\n\n  _processChunk(chunk, flushFlag, asyncCb) {\n    if (typeof asyncCb === 'function') {\n      return zlib.Inflate._processChunk.call(this, chunk, flushFlag, asyncCb);\n    }\n\n    var self = this;\n\n    var availInBefore = chunk && chunk.length;\n    var availOutBefore = this._chunkSize - this._offset;\n    var leftToInflate = this._maxLength;\n    var inOff = 0;\n\n    var buffers = [];\n    var nread = 0;\n\n    var error;\n    this.on('error', function (err) {\n      error = err;\n    });\n\n    function handleChunk(availInAfter, availOutAfter) {\n      if (self._hadError) {\n        return;\n      }\n\n      var have = availOutBefore - availOutAfter;\n      assert(have >= 0, 'have should not go down');\n\n      if (have > 0) {\n        var out = self._buffer.slice(self._offset, self._offset + have);\n        self._offset += have;\n\n        if (out.length > leftToInflate) {\n          out = out.slice(0, leftToInflate);\n        }\n\n        buffers.push(out);\n        nread += out.length;\n        leftToInflate -= out.length;\n\n        if (leftToInflate === 0) {\n          return false;\n        }\n      }\n\n      if (availOutAfter === 0 || self._offset >= self._chunkSize) {\n        availOutBefore = self._chunkSize;\n        self._offset = 0;\n        self._buffer = Buffer.allocUnsafe(self._chunkSize);\n      }\n\n      if (availOutAfter === 0) {\n        inOff += availInBefore - availInAfter;\n        availInBefore = availInAfter;\n\n        return true;\n      }\n\n      return false;\n    }\n\n    assert(this._handle, 'zlib binding closed');\n    do {\n      var res = this._handle.writeSync(\n        flushFlag,\n        chunk, // in\n        inOff, // in_off\n        availInBefore, // in_len\n        this._buffer, // out\n        this._offset, //out_off\n        availOutBefore, // out_len\n      );\n      // Node 8 --> 9 compatibility check\n      res = res || this._writeState;\n    } while (!this._hadError && handleChunk(res[0], res[1]));\n\n    if (this._hadError) {\n      throw error;\n    }\n\n    if (nread >= kMaxLength) {\n      this._close();\n      throw new RangeError(\n        'Cannot create final Buffer. It would be larger than 0x' +\n          kMaxLength.toString(16) +\n          ' bytes',\n      );\n    }\n\n    var buf = Buffer.concat(buffers, nread);\n    this._close();\n\n    return buf;\n  }\n}\n\nexport function createInflate(opts) {\n  return new Inflate(opts);\n}\n\nexport function zlibBufferSync(engine, buffer) {\n  if (typeof buffer === 'string') {\n    // eslint-disable-next-line\n    buffer = Buffer.from(buffer);\n  }\n  if (!(buffer instanceof Buffer)) {\n    throw new TypeError('Not a string or buffer');\n  }\n\n  var flushFlag = engine._finishFlushFlag || zlib.Z_FINISH;\n\n  return engine._processChunk(buffer, flushFlag);\n}\n\nexport default function inflateSync(buffer, opts) {\n  return zlibBufferSync(new Inflate(opts), buffer);\n}\n","import zlib from 'browserify-zlib';\nimport inflateSync from '../sync-inflate';\nimport SyncReader from '../sync-reader';\nimport { parseSync as filterSync } from '../filter';\nimport dataToBitMap from '../dataToBitMap';\nimport formatNormaliser from '../format-normaliser';\nimport Parser from './parser';\n\n/* eslint-disable max-statements */\nlet hasSyncZlib = true;\nif (!zlib.deflateSync) {\n  hasSyncZlib = false;\n}\n\nexport default function (buffer, options = {}) {\n  if (!hasSyncZlib) {\n    throw new Error(\n      'To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0',\n    );\n  }\n\n  let err;\n  function handleError(_err_) {\n    err = _err_;\n  }\n\n  let metaData;\n  function handleMetaData(_metaData_) {\n    metaData = _metaData_;\n  }\n\n  function handleTransColor(transColor) {\n    metaData.transColor = transColor;\n  }\n\n  function handlePalette(palette) {\n    metaData.palette = palette;\n  }\n\n  function handleSimpleTransparency() {\n    metaData.alpha = true;\n  }\n\n  let gamma;\n  function handleGamma(_gamma_) {\n    gamma = _gamma_;\n  }\n\n  let inflateDataList = [];\n  function handleInflateData(inflatedData) {\n    inflateDataList.push(inflatedData);\n  }\n\n  let reader = new SyncReader(buffer);\n\n  let parser = new Parser(options, {\n    read: reader.read.bind(reader),\n    error: handleError,\n    metadata: handleMetaData,\n    gamma: handleGamma,\n    palette: handlePalette,\n    transColor: handleTransColor,\n    inflateData: handleInflateData,\n    simpleTransparency: handleSimpleTransparency,\n  });\n\n  parser.start();\n  reader.process();\n\n  if (err) {\n    throw err;\n  }\n\n  //join together the inflate datas\n  let inflateData = Buffer.concat(inflateDataList);\n  inflateDataList.length = 0;\n\n  let inflatedData;\n  if (metaData.interlace) {\n    inflatedData = zlib.inflateSync(inflateData);\n  } else {\n    let rowSize = ((metaData.width * metaData.bpp * metaData.depth + 7) >> 3) + 1;\n    let imageSize = rowSize * metaData.height;\n    inflatedData = inflateSync(inflateData, { chunkSize: imageSize, maxLength: imageSize });\n  }\n  inflateData = null;\n\n  if (!inflatedData || !inflatedData.length) {\n    throw new Error('bad png - invalid inflate data response');\n  }\n\n  let unfilteredData = filterSync(inflatedData, metaData);\n  inflateData = null;\n\n  let bitmapData = dataToBitMap(unfilteredData, metaData);\n  unfilteredData = null;\n\n  let normalisedBitmapData = formatNormaliser(bitmapData, metaData, options.skipRescale);\n\n  metaData.data = normalisedBitmapData;\n  metaData.gamma = gamma || 0;\n\n  return metaData;\n}\n","// @flow\nimport * as constants from './constants';\n\ntype Options = {\n  colorType?: number,\n  inputColorType: number,\n  inputHasAlpha: boolean,\n  bitDepth?: 1 | 2 | 4 | 8 | 16,\n  bgColor?: {\n    red?: number,\n    green?: number,\n    blue?: number,\n  },\n};\n\n// eslint-disable-next-line\nexport default function(dataIn: Buffer, width: number, height: number, options: Options): Buffer {\n  var outHasAlpha =\n    [constants.COLORTYPE_COLOR_ALPHA, constants.COLORTYPE_ALPHA].indexOf(options.colorType) !== -1;\n  if (options.colorType === options.inputColorType) {\n    var bigEndian = (function() {\n      var buffer = new ArrayBuffer(2);\n      new DataView(buffer).setInt16(0, 256, true /* littleEndian */);\n      // Int16Array uses the platform's endianness.\n      return new Int16Array(buffer)[0] !== 256;\n    })();\n    // If no need to convert to grayscale and alpha is present/absent in both, take a fast route\n    if (options.bitDepth === 8 || (options.bitDepth === 16 && bigEndian)) {\n      return dataIn;\n    }\n  }\n\n  // map to a UInt16 array if data is 16bit, fix endianness below\n  var data = options.bitDepth !== 16 ? dataIn : new Uint16Array(dataIn.buffer);\n\n  var maxValue = 255;\n  var inBpp = constants.COLORTYPE_TO_BPP_MAP[options.inputColorType];\n  if (inBpp === 4 && !options.inputHasAlpha) {\n    inBpp = 3;\n  }\n  var outBpp = constants.COLORTYPE_TO_BPP_MAP[options.colorType];\n  if (options.bitDepth === 16) {\n    maxValue = 65535;\n    outBpp *= 2;\n  }\n\n  var outData = Buffer.alloc(width * height * outBpp);\n\n  var inIndex = 0;\n  var outIndex = 0;\n\n  var bgColor = Object.assign(\n    {\n      red: maxValue,\n      green: maxValue,\n      blue: maxValue,\n    },\n    options.bgColor,\n  );\n\n  function getRGBA() {\n    let red = maxValue;\n    let green = maxValue;\n    let blue = maxValue;\n    let alpha = maxValue;\n    switch (options.inputColorType) {\n      case constants.COLORTYPE_COLOR_ALPHA:\n        alpha = data[inIndex + 3];\n        red = data[inIndex];\n        green = data[inIndex + 1];\n        blue = data[inIndex + 2];\n        break;\n      case constants.COLORTYPE_COLOR:\n        red = data[inIndex];\n        green = data[inIndex + 1];\n        blue = data[inIndex + 2];\n        break;\n      case constants.COLORTYPE_ALPHA:\n        alpha = data[inIndex + 1];\n        red = data[inIndex];\n        green = red;\n        blue = red;\n        break;\n      case constants.COLORTYPE_GRAYSCALE:\n        red = data[inIndex];\n        green = red;\n        blue = red;\n        break;\n      default:\n        throw new Error(\n          'input color type:' + options.inputColorType + ' is not supported at present',\n        );\n    }\n\n    if (options.inputHasAlpha) {\n      if (!outHasAlpha) {\n        alpha /= maxValue;\n        red = Math.min(Math.max(Math.round((1 - alpha) * bgColor.red + alpha * red), 0), maxValue);\n        green = Math.min(\n          Math.max(Math.round((1 - alpha) * bgColor.green + alpha * green), 0),\n          maxValue,\n        );\n        blue = Math.min(\n          Math.max(Math.round((1 - alpha) * bgColor.blue + alpha * blue), 0),\n          maxValue,\n        );\n      }\n    }\n    return { red: red, green: green, blue: blue, alpha: alpha };\n  }\n\n  for (var y = 0; y < height; y++) {\n    for (var x = 0; x < width; x++) {\n      var rgba = getRGBA();\n\n      switch (options.colorType) {\n        case constants.COLORTYPE_COLOR_ALPHA:\n        case constants.COLORTYPE_COLOR:\n          if (options.bitDepth === 8) {\n            outData[outIndex] = rgba.red;\n            outData[outIndex + 1] = rgba.green;\n            outData[outIndex + 2] = rgba.blue;\n            if (outHasAlpha) {\n              outData[outIndex + 3] = rgba.alpha;\n            }\n          } else {\n            outData.writeUInt16BE(rgba.red, outIndex);\n            outData.writeUInt16BE(rgba.green, outIndex + 2);\n            outData.writeUInt16BE(rgba.blue, outIndex + 4);\n            if (outHasAlpha) {\n              outData.writeUInt16BE(rgba.alpha, outIndex + 6);\n            }\n          }\n          break;\n        case constants.COLORTYPE_ALPHA:\n        case constants.COLORTYPE_GRAYSCALE:\n          // Convert to grayscale and alpha\n          var grayscale = (rgba.red + rgba.green + rgba.blue) / 3;\n          if (options.bitDepth === 8) {\n            outData[outIndex] = grayscale;\n            if (outHasAlpha) {\n              outData[outIndex + 1] = rgba.alpha;\n            }\n          } else {\n            outData.writeUInt16BE(grayscale, outIndex);\n            if (outHasAlpha) {\n              outData.writeUInt16BE(rgba.alpha, outIndex + 2);\n            }\n          }\n          break;\n        default:\n          break;\n      }\n\n      inIndex += inBpp;\n      outIndex += outBpp;\n    }\n  }\n\n  return outData;\n}\n","import * as constants from '../constants';\nimport CrcStream from '../crc';\nimport bitPacker from '../bitpacker';\nimport { Pack as filter } from '../filter';\nimport zlib from 'browserify-zlib';\n\nexport default class Packer {\n  constructor(options) {\n    this._options = options;\n\n    options.deflateChunkSize = options.deflateChunkSize || 32 * 1024;\n    options.deflateLevel = options.deflateLevel ? options.deflateLevel : 9;\n    options.deflateStrategy = options.deflateStrategy ? options.deflateStrategy : 3;\n    options.inputHasAlpha = options.inputHasAlpha ? options.inputHasAlpha : true;\n    options.deflateFactory = options.deflateFactory || zlib.createDeflate;\n    options.bitDepth = options.bitDepth || 8;\n    // This is outputColorType\n    options.colorType =\n      typeof options.colorType === 'number' ? options.colorType : constants.COLORTYPE_COLOR_ALPHA;\n    options.inputColorType =\n      typeof options.inputColorType === 'number'\n        ? options.inputColorType\n        : constants.COLORTYPE_COLOR_ALPHA;\n\n    if (\n      [\n        constants.COLORTYPE_GRAYSCALE,\n        constants.COLORTYPE_COLOR,\n        constants.COLORTYPE_COLOR_ALPHA,\n        constants.COLORTYPE_ALPHA,\n      ].indexOf(options.colorType) === -1\n    ) {\n      throw new Error('option color type:' + options.colorType + ' is not supported at present');\n    }\n    if (\n      [\n        constants.COLORTYPE_GRAYSCALE,\n        constants.COLORTYPE_COLOR,\n        constants.COLORTYPE_COLOR_ALPHA,\n        constants.COLORTYPE_ALPHA,\n      ].indexOf(options.inputColorType) === -1\n    ) {\n      throw new Error(\n        'option input color type:' + options.inputColorType + ' is not supported at present',\n      );\n    }\n    if (options.bitDepth !== 8 && options.bitDepth !== 16) {\n      throw new Error('option bit depth:' + options.bitDepth + ' is not supported at present');\n    }\n  }\n\n  getDeflateOptions() {\n    return {\n      chunkSize: this._options.deflateChunkSize,\n      level: this._options.deflateLevel,\n      strategy: this._options.deflateStrategy,\n    };\n  }\n\n  createDeflate() {\n    return this._options.deflateFactory(this.getDeflateOptions());\n  }\n\n  filterData(data, width, height) {\n    // convert to correct format for filtering (e.g. right bpp and bit depth)\n    var packedData = bitPacker(data, width, height, this._options);\n\n    // filter pixel data\n    var bpp = constants.COLORTYPE_TO_BPP_MAP[this._options.colorType];\n    var filteredData = filter(packedData, width, height, this._options, bpp);\n    return filteredData;\n  }\n\n  _packChunk(type, data) {\n    var len = data ? data.length : 0;\n    var buf = Buffer.alloc(len + 12);\n\n    buf.writeUInt32BE(len, 0);\n    buf.writeUInt32BE(type, 4);\n\n    if (data) {\n      data.copy(buf, 8);\n    }\n\n    buf.writeInt32BE(CrcStream.crc32(buf.slice(4, buf.length - 4)), buf.length - 4);\n    return buf;\n  }\n\n  packGAMA(gamma) {\n    var buf = Buffer.alloc(4);\n    buf.writeUInt32BE(Math.floor(gamma * constants.GAMMA_DIVISION), 0);\n    return this._packChunk(constants.TYPE_gAMA, buf);\n  }\n\n  packIHDR(width, height) {\n    var buf = Buffer.alloc(13);\n    buf.writeUInt32BE(width, 0);\n    buf.writeUInt32BE(height, 4);\n    buf[8] = this._options.bitDepth; // Bit depth\n    buf[9] = this._options.colorType; // colorType\n    buf[10] = 0; // compression\n    buf[11] = 0; // filter\n    buf[12] = 0; // interlace\n\n    return this._packChunk(constants.TYPE_IHDR, buf);\n  }\n\n  packIDAT(data) {\n    return this._packChunk(constants.TYPE_IDAT, data);\n  }\n\n  packIEND() {\n    return this._packChunk(constants.TYPE_IEND, null);\n  }\n}\n","import Stream from 'stream';\nimport * as constants from '../constants';\nimport Packer from './packer';\n\nexport default class PackerAsync extends Stream {\n  constructor(opt) {\n    super();\n\n    var options = opt || {};\n\n    this._packer = new Packer(options);\n    // create deflater\n    this._deflate = this._packer.createDeflate();\n\n    this.readable = true;\n  }\n\n  pack(data, width, height, gamma) {\n    // Signature\n    this.emit('data', Buffer.from(constants.PNG_SIGNATURE));\n    this.emit('data', this._packer.packIHDR(width, height));\n\n    if (gamma) {\n      this.emit('data', this._packer.packGAMA(gamma));\n    }\n\n    const filteredData = this._packer.filterData(data, width, height);\n    this.deflate(filteredData);\n  }\n\n  deflate(filteredData) {\n    // Bind this error to the deflater\n    this._deflate.on('error', this.emit.bind(this, 'error'));\n\n    this._deflate.on(\n      'data',\n      function (compressedData) {\n        this.emit('data', this._packer.packIDAT(compressedData));\n      }.bind(this),\n    );\n\n    this._deflate.on(\n      'end',\n      function () {\n        this.emit('data', this._packer.packIEND());\n        this.emit('end');\n      }.bind(this),\n    );\n\n    this._deflate.end(filteredData);\n  }\n}\n","import zlib from 'browserify-zlib';\nimport * as constants from '../constants';\nimport Packer from './packer';\n\nvar hasSyncZlib = true;\nif (!zlib.deflateSync) {\n  hasSyncZlib = false;\n}\n\nexport default function (metaData, opt) {\n  if (!hasSyncZlib) {\n    throw new Error(\n      'To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0',\n    );\n  }\n\n  var options = opt || {};\n\n  var packer = new Packer(options);\n\n  var chunks = [];\n\n  // Signature\n  chunks.push(Buffer.from(constants.PNG_SIGNATURE));\n\n  // Header\n  chunks.push(packer.packIHDR(metaData.width, metaData.height));\n\n  if (metaData.gamma) {\n    chunks.push(packer.packGAMA(metaData.gamma));\n  }\n\n  var filteredData = packer.filterData(metaData.data, metaData.width, metaData.height);\n\n  // compress it\n  var compressedData = zlib.deflateSync(filteredData, packer.getDeflateOptions());\n  filteredData = null;\n\n  if (!compressedData || !compressedData.length) {\n    throw new Error('bad png - invalid compressed data response');\n  }\n  chunks.push(packer.packIDAT(compressedData));\n\n  // End\n  chunks.push(packer.packIEND());\n\n  return Buffer.concat(chunks);\n}\n","import { ParserSync as parse } from './parser';\nimport { PackerSync as pack } from './packer';\n\nexport const read = function(buffer, options) {\n  return parse(buffer, options || {});\n};\n\nexport const write = function(png, options) {\n  return pack(png, options);\n};\n","// @flow\nconst clr2prop = (clr, minValue, maxValue) => Math.min(1, Math.max(0, (clr - minValue) / maxValue));\n\ntype ImgProps = {\n  depth: number,\n  width: number,\n  height: number,\n};\nexport const color = (indata: Buffer | Uint8Array | Uint16Array, shrinkMax: boolean, shrinkMin: boolean, { depth, width, height }: ImgProps): Float32Array => {\n  let maxValue = Math.pow(2, depth) - 1;\n  let minValue = 0;\n\n  if (shrinkMin) {\n    minValue = maxValue;\n    for (let i = 0; i < indata.length; i += 1) {\n      // Alpha channel\n      if ((i + 1) % 4 !== 0) {\n        const clr = indata[i];\n        if (minValue > clr) {\n          minValue = clr;\n          if (minValue === 0) {\n            break;\n          }\n        }\n      }\n    }\n  }\n\n  if (shrinkMax) {\n    let newMaxValue = -1;\n    for (let i = 0; i < indata.length; i += 1) {\n      // Alpha channel\n      if ((i + 1) % 4 !== 0) {\n        const clr = indata[i];\n        if (newMaxValue < clr) {\n          newMaxValue = clr;\n          if (newMaxValue === maxValue) {\n            break;\n          }\n        }\n      }\n    }\n    maxValue = newMaxValue;\n  }\n\n  const outData = new Float32Array(width * height * 3);\n  for (let i = 0; i < indata.length / 4; i += 1) {\n    const inPos = i << 2; // Same as * 4\n    const outPos = i * 3;\n\n    outData[outPos] = clr2prop(indata[inPos], minValue, maxValue);\n    outData[outPos + 1] = clr2prop(indata[inPos + 1], minValue, maxValue);\n    outData[outPos + 2] = clr2prop(indata[inPos + 2], minValue, maxValue);\n  }\n  return outData;\n};\n\nexport const grayscale = (indata: Buffer | Uint8Array | Uint16Array, shrinkMax: boolean, shrinkMin: boolean, { depth }: { depth: number }): Float32Array => {\n  let maxValue = Math.pow(2, depth) - 1;\n  let minValue = 0;\n\n  if (shrinkMin) {\n    minValue = maxValue;\n    for (let i = 0; i < indata.length; i += 1) {\n      const clr = indata[i];\n      if (minValue > clr) {\n        minValue = clr;\n        if (minValue === 0) {\n          break;\n        }\n      }\n    }\n  }\n\n  if (shrinkMax) {\n    let newMaxValue = -1;\n    for (let i = 0; i < indata.length; i += 1) {\n      const clr = indata[i];\n      if (newMaxValue < clr) {\n        newMaxValue = clr;\n        if (newMaxValue === maxValue) {\n          break;\n        }\n      }\n    }\n    maxValue = newMaxValue;\n  }\n\n  const outData = new Float32Array(indata.length);\n  for (let i = 0; i < indata.length; i += 1) {\n    outData[i] = clr2prop(indata[i], minValue, maxValue);\n  }\n  return outData;\n};\n","// @flow\nimport { type PNGInterface } from './types';\n\nexport default (src: PNGInterface) => {\n  if (src.gamma) {\n    const { data } = src;\n    if (!data) {\n      throw new Error('No data available for object');\n    }\n\n    for (var y = 0; y < src.height; y++) {\n      for (var x = 0; x < src.width; x++) {\n        var idx = (src.width * y + x) << 2;\n\n        for (var i = 0; i < 3; i++) {\n          var sample = data[idx + i] / 255;\n          sample = Math.pow(sample, 1 / 2.2 / src.gamma);\n          data[idx + i] = Math.round(sample * 255);\n        }\n      }\n    }\n    src.data = data;\n    src.gamma = 0;\n  }\n};\n","// @flow\nimport { type PNGInterface } from './types';\n\ntype Props = {|\n  src: PNGInterface,\n  dst: PNGInterface,\n  srcX?: number | void,\n  srcY?: number | void,\n  width?: number | void,\n  height?: number | void,\n  deltaX?: number | void,\n  deltaY?: number | void,\n|};\n\nexport default (props: Props) => {\n  const { src, dst, srcX = 0, srcY = 0, width = 0, height = 0, deltaX = 0, deltaY = 0 } = props;\n  // coerce pixel dimensions to integers (also coerces undefined -> 0):\n\n  if (\n    srcX > src.width ||\n    srcY > src.height ||\n    srcX + width > src.width ||\n    srcY + height > src.height\n  ) {\n    throw new Error('bitblt reading outside image');\n  }\n\n  if (\n    deltaX > dst.width ||\n    deltaY > dst.height ||\n    deltaX + width > dst.width ||\n    deltaY + height > dst.height\n  ) {\n    throw new Error('bitblt writing outside image');\n  }\n\n  const { data } = src;\n  if (!data) {\n    throw new Error('No data available in src');\n  }\n  const { data: outData } = dst;\n  if (!outData) {\n    throw new Error('No data available in dst');\n  }\n\n  for (var y = 0; y < height; y++) {\n    data.copy(\n      outData,\n      ((deltaY + y) * dst.width + deltaX) << 2,\n      ((srcY + y) * src.width + srcX) << 2,\n      ((srcY + y) * src.width + srcX + width) << 2,\n    );\n  }\n};\n","// @flow\nimport Stream, { type Readable, type Writable } from 'stream';\nimport { produce } from 'immer';\nimport { ParserAsync as Parser } from './parser';\nimport { PackerAsync as Packer } from './packer';\nimport * as propData from './propData';\nimport _adjustGamma from './adjustGamma';\nimport _bitblt from './bitblt';\n\nexport interface Metadata {\n  width: number;\n  height: number;\n  depth: 1 | 2 | 4 | 8 | 16;\n  interlace: boolean;\n  palette: boolean;\n  color: boolean;\n  alpha: boolean;\n  bpp: 1 | 2 | 3 | 4;\n  colorType: 0 | 2 | 3 | 4 | 6;\n}\n\nexport type Props = {|\n  skipRescale?: boolean,\n  width?: number,\n  height?: number,\n  initGrayscaleData?: boolean,\n  initPropData?: {| shrinkMax?: boolean, shrinkMin?: boolean |},\n  fill?: boolean,\n|};\n\nexport type Shape = {|\n  width: number,\n  height: number,\n|};\nexport type Store = {|\n  data: ?Buffer,\n  shape: Shape,\n  gamma: number,\n  color: boolean | void,\n  depth: number | void,\n  grayscaleData: Uint8Array | Uint16Array | void,\n  propData: Float32Array | void,\n  config: {|\n    postParse: {|\n      initGrayscaleData: ?boolean,\n      initPropData?: {| shrinkMax?: boolean, shrinkMin?: boolean |},\n    |},\n  |},\n|};\n\n// $FlowFixMe\nclass PNG extends Stream {\n  store: Store;\n\n  constructor(options: Props = ({}: any)) {\n    super(options);\n    const { width, height, fill = false, initGrayscaleData, initPropData } = options;\n\n    let data: ?Buffer;\n    if (width && width > 0 && height && height > 0) {\n      const bufferSize = 4 * width * height;\n      if (fill) {\n        data = Buffer.alloc(bufferSize, 0);\n      } else {\n        data = Buffer.alloc(bufferSize);\n      }\n    }\n\n    this.store = {\n      data,\n      shape: {\n        // coerce pixel dimensions to integers (also coerces undefined -> 0):\n        width: Math.floor(width || 0),\n        height: Math.floor(height || 0),\n      },\n      gamma: 0,\n      color: undefined,\n      depth: undefined,\n      grayscaleData: undefined,\n      propData: undefined,\n      config: {\n        postParse: { initGrayscaleData, initPropData },\n      },\n    };\n\n    this.readable = this.writable = true;\n\n    this._parser = new Parser(options);\n\n    this._parser.on('error', this.emit.bind(this, 'error'));\n    this._parser.on('close', this._handleClose.bind(this));\n    this._parser.on('metadata', this._metadata.bind(this));\n    this._parser.on('gamma', this._gamma.bind(this));\n    this._parser.on(\n      'parsed',\n      function (parsedData: Buffer) {\n        this.store = produce<Store>(this.store, (draft) => {\n          draft.data = parsedData;\n        });\n\n        this._postParsed();\n        this.emit('parsed', parsedData);\n      }.bind(this),\n    );\n\n    this._packer = new Packer(options);\n    this._packer.on('data', this.emit.bind(this, 'data'));\n    this._packer.on('end', this.emit.bind(this, 'end'));\n    this._parser.on('close', this._handleClose.bind(this));\n    this._packer.on('error', this.emit.bind(this, 'error'));\n  }\n\n  serialize(): Store {\n    return this.store;\n  }\n\n  static deserialize(storeData: Store): PNG {\n    const recreated = new PNG();\n    recreated.store = storeData;\n    return recreated;\n  }\n\n  get width(): number {\n    return this.store.shape.width;\n  }\n\n  set width(width: number) {\n    this.store = produce<Store>(this.store, (draft) => {\n      draft.shape.width = width;\n    });\n  }\n\n  get height(): number {\n    return this.store.shape.height;\n  }\n\n  set height(height: number) {\n    this.store = produce<Store>(this.store, (draft) => {\n      draft.shape.height = height;\n    });\n  }\n\n  get shape(): Shape {\n    return this.store.shape;\n  }\n\n  get data(): Buffer | null | void {\n    return this.store.data;\n  }\n\n  set data(newData: ?Buffer) {\n    this.store = produce<Store>(this.store, (draft) => {\n      draft.data = newData;\n      draft.propData = undefined;\n      draft.grayscaleData = undefined;\n    });\n  }\n\n  get gamma(): number {\n    return this.store.gamma;\n  }\n\n  set gamma(newGamma: number) {\n    this.store = produce<Store>(this.store, (draft) => {\n      draft.gamma = newGamma;\n    });\n  }\n\n  get color(): boolean | void {\n    return this.store.color;\n  }\n\n  get depth(): number | void {\n    return this.store.depth;\n  }\n\n  _postParsed: () => void = () => {\n    this.store = produce<Store>(this.store, (draft) => {\n      draft.grayscaleData = undefined;\n      draft.propData = undefined;\n    });\n\n    const { initGrayscaleData, initPropData } = this.store.config.postParse;\n    if (initGrayscaleData) {\n      this.initGrayscaleData();\n    }\n    if (initPropData) {\n      const shrinkMin = initPropData.shrinkMin || false;\n      const shrinkMax = initPropData.shrinkMax || false;\n      this.initPropData(shrinkMin, shrinkMax);\n    }\n  };\n\n  pack(): PNG {\n    if (!this.data || !this.data.length) {\n      this.emit('error', 'No data provided');\n      return this;\n    }\n\n    process.nextTick(\n      function () {\n        this._packer.pack(this.data, this.width, this.height, this.gamma);\n      }.bind(this),\n    );\n\n    return this;\n  }\n\n  parse(data: ArrayBuffer | Readable, callback: Function): PNG {\n    if (callback) {\n      let onParsed, onError;\n\n      onParsed = function () {\n        this.removeListener('error', onError);\n\n        callback(null, this);\n      }.bind(this);\n\n      onError = function (err) {\n        this.removeListener('parsed', onParsed);\n\n        callback(err, null);\n      }.bind(this);\n\n      this.once('parsed', onParsed);\n      this.once('error', onError);\n    }\n\n    this.end(data);\n    return this;\n  }\n\n  write(data: Writable): true {\n    this._parser.write(data);\n    return true;\n  }\n\n  end(data: Readable | ArrayBuffer) {\n    this._parser.end(data);\n  }\n\n  _metadata(metadata: Metadata) {\n    const { width, height, color, depth } = metadata;\n    this.store = produce<Store>(this.store, (draft) => {\n      draft.shape.width = width;\n      draft.shape.height = height;\n      draft.color = color;\n      draft.depth = depth;\n    });\n\n    this.emit('metadata', metadata);\n  }\n\n  _gamma(gamma: number) {\n    this.store = produce<Store>(this.store, (draft) => {\n      draft.gamma = gamma;\n    });\n  }\n\n  _handleClose() {\n    if (!this._parser.writable && !this._packer.readable) {\n      this.emit('close');\n    }\n  }\n\n  bitblt(props: {|\n    dst: PNG,\n    srcX?: number | void,\n    srcY?: number | void,\n    width?: number | void,\n    height?: number | void,\n    deltaX?: number | void,\n    deltaY?: number | void,\n  |}): PNG {\n    _bitblt({ src: this, ...props });\n    return this;\n  }\n\n  adjustGamma(): PNG {\n    _adjustGamma(this);\n    return this;\n  }\n\n  initGrayscaleData() {\n    const { data, depth, color } = this;\n    if (!data) {\n      throw new Error('The initGrayscaleData() called before receiving data');\n    }\n\n    if (depth === undefined) {\n      throw new Error('Unknown depth');\n    }\n\n    if (color === undefined) {\n      throw new Error('Unknown color status');\n    }\n\n    const destLen = data.length / 4;\n    let outData;\n    if (depth <= 8) {\n      outData = new Uint8Array(destLen);\n    } else {\n      outData = new Uint16Array(destLen);\n    }\n    if (color) {\n      const mono = ({ red, green, blue }) => 0.2125 * red + 0.7154 * green + 0.0721 * blue;\n      for (let i = 0; i < outData.length; i += 1) {\n        const pxPos = i * 4;\n        outData[i] = mono({\n          red: data[pxPos + 0],\n          green: data[pxPos + 1],\n          blue: data[pxPos + 2],\n        });\n      }\n    } else {\n      outData = data.filter((clr, i) => i % 4 === 0);\n    }\n\n    this.store = produce<Store>(this.store, (draft) => {\n      draft.grayscaleData = outData;\n    });\n  }\n\n  // Retrieve mono data without alpha channel\n  grayscaleData(): Uint8Array | Uint16Array | void {\n    const { data } = this;\n    if (!data) {\n      throw new Error('Invalid call - no data to convert');\n    }\n\n    if (!this.store.grayscaleData) {\n      this.initGrayscaleData();\n    }\n\n    return this.store.grayscaleData;\n  }\n\n  initPropData(shrinkMin: boolean = false, shrinkMax: boolean = false) {\n    let propDataOutput: ?Float32Array;\n    const { width, height, depth } = this;\n    if (depth === undefined) {\n      throw new Error('Unknown image depth');\n    }\n\n    if (this.color) {\n      const { data } = this;\n      if (!data) {\n        throw new Error('No data to init proportions for');\n      }\n\n      propDataOutput = propData.color(data, shrinkMin, shrinkMax, {\n        width,\n        height,\n        depth,\n      });\n    } else {\n      const data = this.grayscaleData();\n      if (!data) {\n        throw new Error('No data to init proportions for');\n      }\n      propDataOutput = propData.grayscale(data, shrinkMin, shrinkMax, {\n        width,\n        height,\n        depth,\n      });\n    }\n\n    this.store = produce<Store>(this.store, (draft) => {\n      // $FlowFixMe - for some reasone Flow doesn't get that propDataOutput cannot be null :-(\n      draft.propData = propDataOutput;\n    });\n  }\n\n  // Retrieve colors as proportions instead of integers\n  // if you want to limit the max proporiton to the bufferEqual\n  // max/min value then set the shrinkMax/shrinkMin.\n  propData(shrinkMin: boolean = false, shrinkMax: boolean = false): Float32Array | void {\n    const { data } = this;\n    if (!data) {\n      throw new Error('Invalid call - no data to convert');\n    }\n\n    if (!this.store.propData) {\n      this.initPropData(shrinkMin, shrinkMax);\n    }\n\n    return this.store.propData;\n  }\n\n  // Move propData into a threshold clamped outData\n  propData2ImageClamped(\n    clampedDataArray: Uint8ClampedArray,\n    lowerThreshold: number = 0,\n    upperThreshold: number = 1,\n    maxValue: number = 255,\n  ): Uint8ClampedArray {\n    if (lowerThreshold < 0) {\n      throw new Error(\"Invalid lower threshold, can't be less than 0\");\n    }\n\n    if (lowerThreshold > upperThreshold) {\n      throw new Error('lower threshold should be below the upper threshold');\n    }\n\n    const pData = this.propData();\n    if (!pData) {\n      throw Error('No propData');\n    }\n\n    const inflateBy = maxValue / (1 - lowerThreshold - (1 - upperThreshold));\n    if (clampedDataArray.length === pData.length) {\n      for (let pos = 0; pos < pData.length; pos += 1) {\n        if ((pos + 1) % 4 === 0) {\n          clampedDataArray[pos + 3] = 255; // Alpha channel\n        } else {\n          const clr = (pData[pos] - lowerThreshold) * inflateBy;\n          clampedDataArray[pos] = clr;\n        }\n      }\n    } else if (clampedDataArray.length === pData.length * (4 / 3)) {\n      for (let i = 0; i < pData.length; i += 1) {\n        const pos = i * 4;\n        const propPos = i * 3;\n        clampedDataArray[pos] = (pData[propPos] - lowerThreshold) * inflateBy;\n        clampedDataArray[pos + 1] = (pData[propPos + 1] - lowerThreshold) * inflateBy;\n        clampedDataArray[pos + 2] = (pData[propPos + 2] - lowerThreshold) * inflateBy;\n        clampedDataArray[pos + 3] = 255; // Alpha channel\n      }\n    } else if (clampedDataArray.length === pData.length * 4) {\n      for (let i = 0; i < pData.length; i += 1) {\n        const pos = i * 4;\n        const clr = (pData[i] - lowerThreshold) * inflateBy;\n        clampedDataArray[pos] = clr;\n        clampedDataArray[pos + 1] = clr;\n        clampedDataArray[pos + 2] = clr;\n        clampedDataArray[pos + 3] = 255; // Alpha channel\n      }\n    } else {\n      throw new Error(\n        `Invalid buffer lenghts, expected ${clampedDataArray.length} but got ${pData.length}`,\n      );\n    }\n    return clampedDataArray;\n  }\n}\n\nexport default PNG;\n","// @flow\nimport * as _sync from './png-sync';\nimport * as _PNG from './png';\n\nexport default _PNG.default;\nexport const PNG = _PNG.default;\nexport { default as adjustGamma } from './adjustGamma';\nexport { default as bitblt } from './bitblt';\n\nexport const sync = _sync;\n\n// Flow types to export\nexport interface Metadata extends _PNG.Metadata {}\nexport type Props = _PNG.Props;\nexport type Store = _PNG.Store;\n"]}