retropilot-server/cabana/66fe2b555037a721fc00.worker.js.map

{"version":3,"sources":["../webpack/bootstrap","workers/dbc-csv-downloader.worker.js","utils/loadnpy.js","../node_modules/int64-buffer/int64-buffer.js","../node_modules/buffer/index.js","../node_modules/webpack/buildin/global.js","../node_modules/base64-js/index.js","../node_modules/ieee754/index.js","../node_modules/isarray/index.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","getDefault","getModuleExports","object","property","prototype","hasOwnProperty","p","s","self","Int64LE","transformAndSend","rawData","totalSize","maxTime","reduce","memo","sourceData","entries","length","sort","a","b","relTime","Math","max","getLastTimeFromEntries","minTime","console","log","curIndexes","forEach","sourceId","id","findFirstEntryIndex","start","round","entryBuffer","totalEntries","nextSource","curEntry","entry","address","bus","push","makeEntry","postMessage","progress","logData","join","shouldClose","hexData","onmessage","e","base","parts","data","canStartTime","prevMsgEntries","maxByteStateChangeCount","close","NumpyLoader","asciiDecode","buf","String","fromCharCode","apply","Uint8Array","fromArrayBuffer","slice","Error","headerLength","readUint16LE","buffer","view","DataView","val","getUint8","headerStr","offsetBytes","info","JSON","parse","toLowerCase","replace","descr","Int8Array","Uint16Array","Int16Array","Uint32Array","Int32Array","Float32Array","Float64Array","shape","fortran_order","open","file","callback","reader","FileReader","onload","ndarray","result","readAsArrayBuffer","promise","url","Promise","resolve","reject","req","XMLHttpRequest","status","response","is404","statusText","onerror","responseType","send","storage","UNDEFINED","BUFFER","Buffer","UINT8ARRAY","ARRAYBUFFER","ArrayBuffer","ZERO","isArray","Array","_isArray","toString","BIT32","BIT24","factory","bigendian","unsigned","posH","posL","pos0","pos1","pos2","pos3","fromPositive","fromPositiveBE","fromPositiveLE","fromNegative","fromNegativeBE","fromNegativeLE","proto","Int64","isName","_isInt64","offset","toNumber","radix","this","high","readInt32","low","str","sign","mod","floor","toJSON","toArray","toBuffer","toArrayBuffer","isInt64","raddix","init","that","newArray","isValidBuffer","_storage","fromString","pos","len","chr","parseInt","writeInt32","fromArray","raw","isBuffer","dest","arrbuf","byteLength","destbuf","destoff","srcbuf","srcoff","end","nodeName","base64","ieee754","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","RangeError","__proto__","arg","encodingOrOffset","allocUnsafe","from","TypeError","array","byteOffset","undefined","fromArrayLike","string","encoding","isEncoding","actual","write","fromObject","obj","checked","copy","isnan","type","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","indexOf","lastIndexOf","arr","indexSize","arrLength","valLength","read","readUInt16BE","foundIndex","found","j","hexWrite","Number","remaining","strLen","parsed","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","byteArray","charCodeAt","latin1Write","base64Write","ucs2Write","utf16leToBytes","units","hi","lo","fromByteArray","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","decodeCodePointsArray","codePoints","MAX_ARGUMENTS_LENGTH","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","typedArraySupport","foo","subarray","poolSize","_augment","species","configurable","fill","allocUnsafeSlow","_isBuffer","compare","x","y","concat","list","swap16","swap32","swap64","arguments","equals","inspect","match","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","_arr","ret","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","code","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","base64clean","stringtrim","trim","src","dst","g","Function","window","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","len2","encodeChunk","lookup","num","output","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","abs","LN2"],"mappings":"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","file":"66fe2b555037a721fc00.worker.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/cabana/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 0);\n","/* eslint-env worker */\n/* eslint-disable no-restricted-globals */\n// import Sentry from '../logging/Sentry';\n\nimport NumpyLoader from '../utils/loadnpy';\n\nconst MAX_CONNECTIONS = 8;\n\nconst window = self;\n\nconst { Int64LE } = require('int64-buffer');\n\nfunction transformAndSend(rawData) {\n  let totalSize = 0;\n  const maxTime = rawData.reduce((memo, sourceData) => {\n    totalSize += sourceData.entries.length;\n    sourceData.entries = sourceData.entries.sort((a, b) => {\n      if (a.relTime > b.relTime) {\n        return 1;\n      }\n      if (a.relTime < b.relTime) {\n        return -1;\n      }\n      return 0;\n    });\n    return Math.max(memo, getLastTimeFromEntries(sourceData.entries));\n  }, 0);\n\n  const minTime = Math.max(0, maxTime - 30);\n  console.log('Time span from', minTime, maxTime);\n  const curIndexes = {};\n  rawData.forEach((sourceData) => {\n    if (!sourceData.entries.length) {\n      return;\n    }\n    const sourceId = sourceData.id;\n    if (minTime === 0 || sourceData.entries[0].relTime > minTime) {\n      curIndexes[sourceId] = 0;\n      return;\n    }\n    curIndexes[sourceId] = findFirstEntryIndex(sourceData.entries, minTime);\n  });\n\n  let entryBuffer = [];\n  let totalEntries = 0;\n\n  while (!isAtEnd()) {\n    const nextSource = rawData.reduce((memo, sourceData) => {\n      const curEntry = sourceData.entries[curIndexes[sourceData.id]];\n      if (!curEntry) {\n        return memo;\n      }\n      if (memo === -1) {\n        return {\n          entry: curEntry,\n          address: sourceData.address,\n          bus: sourceData.bus,\n          id: sourceData.id\n        };\n      }\n      if (curEntry.relTime < memo.entry.relTime) {\n        return {\n          entry: curEntry,\n          address: sourceData.address,\n          bus: sourceData.bus,\n          id: sourceData.id\n        };\n      }\n      return memo;\n    }, -1);\n    if (nextSource === -1) {\n      break;\n    }\n    curIndexes[nextSource.id]++;\n    totalEntries++;\n\n    entryBuffer.push(makeEntry(nextSource));\n\n    if (entryBuffer.length > 5000) {\n      self.postMessage({\n        progress: 100 * (totalEntries / totalSize),\n        logData: entryBuffer.join('\\n'),\n        shouldClose: false\n      });\n      entryBuffer = [];\n    }\n  }\n  if (entryBuffer.length > 0) {\n    self.postMessage({\n      progress: 99,\n      logData: entryBuffer.join('\\n'),\n      shouldClose: false\n    });\n    entryBuffer = [];\n  }\n\n  console.log('Wrote', totalEntries, 'lines of CSV');\n  self.postMessage({\n    progress: 100,\n    shouldClose: true\n  });\n\n  function isAtEnd() {\n    return rawData.reduce(\n      (memo, sourceData) => memo && curIndexes[sourceData.id] >= sourceData.entries.length\n    );\n  }\n}\n\nfunction makeEntry(nextSource) {\n  return [\n    nextSource.entry.relTime,\n    nextSource.address,\n    nextSource.bus,\n    nextSource.entry.hexData\n  ].join(',');\n}\n\nfunction findFirstEntryIndex(entries, minTime, start, length) {\n  start = start || entries.length / 2;\n  start = ~~start; // round down\n  length = length || entries.length / 2;\n  length = Math.round(length); // round up\n\n  if (start === 0) {\n    return 0;\n  }\n  if (start >= entries.length - 1) {\n    return entries.length - 1;\n  }\n\n  if (entries[start].relTime < minTime) {\n    // this entry is too early for the 30s window\n    return findFirstEntryIndex(\n      entries,\n      minTime,\n      ~~(start + length / 2),\n      length / 2\n    );\n  }\n  if (entries[start].relTime >= minTime) {\n    // this entry is within the window! check if it's the first one in the window, else keep searching\n    if (entries[start - 1].relTime >= minTime) {\n      return findFirstEntryIndex(\n        entries,\n        minTime,\n        ~~(start - length / 2),\n        length / 2\n      );\n    }\n    return start;\n  }\n}\n\nfunction getLastTimeFromEntries(entries) {\n  if (!entries.length) {\n    return 0;\n  }\n  return entries[entries.length - 1].relTime;\n}\n\nself.onmessage = function (e) {\n  console.log('onmessage worker');\n  self.postMessage({\n    progress: 0,\n    logData: 'time,addr,bus,data',\n    shouldClose: false\n  });\n  const {\n    base,\n    parts,\n    data,\n    canStartTime,\n    prevMsgEntries,\n    maxByteStateChangeCount\n  } = e.data;\n\n  // const dbc = new DBC(dbcText);\n  // saveDBC(dbc, base, num, canStartTime);\n  if (data) {\n    // has raw data from live mode, process this instead\n    console.log('Using raw data from memory', canStartTime);\n    transformAndSend(data, canStartTime);\n  } else {\n    self.postMessage({\n      progress: 100,\n      shouldClose: true\n    });\n    self.close();\n  }\n};\n","// Client-side parser for .npy files\n// See the specification: http://docs.scipy.org/doc/numpy-dev/neps/npy-format.html\n\nconst NumpyLoader = (function NumpyLoader() {\n  function asciiDecode(buf) {\n    return String.fromCharCode.apply(null, new Uint8Array(buf));\n  }\n\n  function readUint16LE(buffer) {\n    const view = new DataView(buffer);\n    let val = view.getUint8(0);\n    val |= view.getUint8(1) << 8;\n    return val;\n  }\n\n  function fromArrayBuffer(buf) {\n    // Check the magic number\n    const magic = asciiDecode(buf.slice(0, 6));\n    if (magic !== '\\x93NUMPY') {\n      throw new Error('Bad magic number');\n    }\n\n    const version = new Uint8Array(buf.slice(6, 8));\n    const headerLength = readUint16LE(buf.slice(8, 10));\n    const headerStr = asciiDecode(buf.slice(10, 10 + headerLength));\n    const offsetBytes = 10 + headerLength;\n    // rest = buf.slice(10+headerLength);  XXX -- This makes a copy!!! https://www.khronos.org/registry/typedarray/specs/latest/#5\n\n    // Hacky conversion of dict literal string to JS Object\n    const info = JSON.parse(\n      headerStr\n        .toLowerCase()\n        .replace('(', '[')\n        .replace('),', ']')\n        .replace(/'/g, '\"')\n        .replace(',]', ']')\n    );\n\n    // Intepret the bytes according to the specified dtype\n    let data;\n    if (info.descr === '|u1') {\n      data = new Uint8Array(buf, offsetBytes);\n    } else if (info.descr === '|i1') {\n      data = new Int8Array(buf, offsetBytes);\n    } else if (info.descr === '<u2') {\n      data = new Uint16Array(buf, offsetBytes);\n    } else if (info.descr === '<i2') {\n      data = new Int16Array(buf, offsetBytes);\n    } else if (info.descr === '<u4') {\n      data = new Uint32Array(buf, offsetBytes);\n    } else if (info.descr === '<i4') {\n      data = new Int32Array(buf, offsetBytes);\n    } else if (info.descr === '<f4') {\n      data = new Float32Array(buf, offsetBytes);\n    } else if (info.descr === '<f8') {\n      data = new Float64Array(buf, offsetBytes);\n    } else if (info.descr === '<u8') {\n      // 8 byte uint64s\n      data = new Uint8Array(buf, offsetBytes);\n    } else if (info.descr === '<i8') {\n      // 8 byte int64s\n      data = new Uint8Array(buf, offsetBytes);\n    } else if (info.descr === '|s5') {\n      // 5 byte string\n      data = new Uint8Array(buf, offsetBytes);\n    } else if (info.descr === '|s8') {\n      // 8 byte strings\n      data = new Uint8Array(buf, offsetBytes);\n    } else if (info.descr === '|s15') {\n      // 15 byte strings?\n      data = new Uint8Array(buf, offsetBytes);\n    } else {\n      throw new Error(`unknown numeric dtype ${info.descr}`);\n    }\n\n    return {\n      shape: info.shape,\n      fortran_order: info.fortran_order,\n      data\n    };\n  }\n\n  function open(file, callback) {\n    const reader = new FileReader();\n    reader.onload = function () {\n      // the file contents have been read as an array buffer\n      const buf = reader.result;\n      const ndarray = fromArrayBuffer(buf);\n      callback(ndarray);\n    };\n    reader.readAsArrayBuffer(file);\n  }\n\n  function promise(url) {\n    return new Promise((resolve, reject) => {\n      // Do the usual XHR stuff\n      const req = new XMLHttpRequest();\n      req.onload = function () {\n        // This is called even on 404 etc\n        // so check the status\n        if (req.status == 200) {\n          const buf = req.response; // not responseText\n          const ndarray = fromArrayBuffer(buf);\n          resolve(ndarray);\n        } else if (req.status == 404) {\n          console.log('yup');\n          reject({ is404: true });\n        } else {\n          // Otherwise reject with the status text\n          // which will hopefully be a meaningful error\n          reject(Error(req.statusText));\n        }\n      };\n\n      // Handle network errors\n      req.onerror = function () {\n        reject(Error('Network Error'));\n      };\n\n      // Make the request\n      req.open('GET', url, true);\n      req.responseType = 'arraybuffer';\n      req.send(null);\n    });\n  }\n\n  return {\n    open,\n    promise,\n    fromArrayBuffer\n  };\n}());\n\nmodule.exports = NumpyLoader;\n","// int64-buffer.js\n\n/*jshint -W018 */\n// Confusing use of '!'.\n\n/*jshint -W030 */\n// Expected an assignment or function call and instead saw an expression.\n\n/*jshint -W093 */\n// Did you mean to return a conditional instead of an assignment?\nvar Uint64BE, Int64BE, Uint64LE, Int64LE;\n!function (exports) {\n  // constants\n  var UNDEFINED = \"undefined\";\n  var BUFFER = UNDEFINED !== typeof Buffer && Buffer;\n  var UINT8ARRAY = UNDEFINED !== typeof Uint8Array && Uint8Array;\n  var ARRAYBUFFER = UNDEFINED !== typeof ArrayBuffer && ArrayBuffer;\n  var ZERO = [0, 0, 0, 0, 0, 0, 0, 0];\n  var isArray = Array.isArray || _isArray;\n  var BIT32 = 4294967296;\n  var BIT24 = 16777216; // storage class\n\n  var storage; // Array;\n  // generate classes\n\n  Uint64BE = factory(\"Uint64BE\", true, true);\n  Int64BE = factory(\"Int64BE\", true, false);\n  Uint64LE = factory(\"Uint64LE\", false, true);\n  Int64LE = factory(\"Int64LE\", false, false); // class factory\n\n  function factory(name, bigendian, unsigned) {\n    var posH = bigendian ? 0 : 4;\n    var posL = bigendian ? 4 : 0;\n    var pos0 = bigendian ? 0 : 3;\n    var pos1 = bigendian ? 1 : 2;\n    var pos2 = bigendian ? 2 : 1;\n    var pos3 = bigendian ? 3 : 0;\n    var fromPositive = bigendian ? fromPositiveBE : fromPositiveLE;\n    var fromNegative = bigendian ? fromNegativeBE : fromNegativeLE;\n    var proto = Int64.prototype;\n    var isName = \"is\" + name;\n\n    var _isInt64 = \"_\" + isName; // properties\n\n\n    proto.buffer = void 0;\n    proto.offset = 0;\n    proto[_isInt64] = true; // methods\n\n    proto.toNumber = toNumber;\n    proto.toString = toString;\n    proto.toJSON = toNumber;\n    proto.toArray = toArray; // add .toBuffer() method only when Buffer available\n\n    if (BUFFER) proto.toBuffer = toBuffer; // add .toArrayBuffer() method only when Uint8Array available\n\n    if (UINT8ARRAY) proto.toArrayBuffer = toArrayBuffer; // isUint64BE, isInt64BE\n\n    Int64[isName] = isInt64; // CommonJS\n\n    exports[name] = Int64;\n    return Int64; // constructor\n\n    function Int64(buffer, offset, value, raddix) {\n      if (!(this instanceof Int64)) return new Int64(buffer, offset, value, raddix);\n      return init(this, buffer, offset, value, raddix);\n    } // isUint64BE, isInt64BE\n\n\n    function isInt64(b) {\n      return !!(b && b[_isInt64]);\n    } // initializer\n\n\n    function init(that, buffer, offset, value, raddix) {\n      if (UINT8ARRAY && ARRAYBUFFER) {\n        if (buffer instanceof ARRAYBUFFER) buffer = new UINT8ARRAY(buffer);\n        if (value instanceof ARRAYBUFFER) value = new UINT8ARRAY(value);\n      } // Int64BE() style\n\n\n      if (!buffer && !offset && !value && !storage) {\n        // shortcut to initialize with zero\n        that.buffer = newArray(ZERO, 0);\n        return;\n      } // Int64BE(value, raddix) style\n\n\n      if (!isValidBuffer(buffer, offset)) {\n        var _storage = storage || Array;\n\n        raddix = offset;\n        value = buffer;\n        offset = 0;\n        buffer = new _storage(8);\n      }\n\n      that.buffer = buffer;\n      that.offset = offset |= 0; // Int64BE(buffer, offset) style\n\n      if (UNDEFINED === typeof value) return; // Int64BE(buffer, offset, value, raddix) style\n\n      if (\"string\" === typeof value) {\n        fromString(buffer, offset, value, raddix || 10);\n      } else if (isValidBuffer(value, raddix)) {\n        fromArray(buffer, offset, value, raddix);\n      } else if (\"number\" === typeof raddix) {\n        writeInt32(buffer, offset + posH, value); // high\n\n        writeInt32(buffer, offset + posL, raddix); // low\n      } else if (value > 0) {\n        fromPositive(buffer, offset, value); // positive\n      } else if (value < 0) {\n        fromNegative(buffer, offset, value); // negative\n      } else {\n        fromArray(buffer, offset, ZERO, 0); // zero, NaN and others\n      }\n    }\n\n    function fromString(buffer, offset, str, raddix) {\n      var pos = 0;\n      var len = str.length;\n      var high = 0;\n      var low = 0;\n      if (str[0] === \"-\") pos++;\n      var sign = pos;\n\n      while (pos < len) {\n        var chr = parseInt(str[pos++], raddix);\n        if (!(chr >= 0)) break; // NaN\n\n        low = low * raddix + chr;\n        high = high * raddix + Math.floor(low / BIT32);\n        low %= BIT32;\n      }\n\n      if (sign) {\n        high = ~high;\n\n        if (low) {\n          low = BIT32 - low;\n        } else {\n          high++;\n        }\n      }\n\n      writeInt32(buffer, offset + posH, high);\n      writeInt32(buffer, offset + posL, low);\n    }\n\n    function toNumber() {\n      var buffer = this.buffer;\n      var offset = this.offset;\n      var high = readInt32(buffer, offset + posH);\n      var low = readInt32(buffer, offset + posL);\n      if (!unsigned) high |= 0; // a trick to get signed\n\n      return high ? high * BIT32 + low : low;\n    }\n\n    function toString(radix) {\n      var buffer = this.buffer;\n      var offset = this.offset;\n      var high = readInt32(buffer, offset + posH);\n      var low = readInt32(buffer, offset + posL);\n      var str = \"\";\n      var sign = !unsigned && high & 0x80000000;\n\n      if (sign) {\n        high = ~high;\n        low = BIT32 - low;\n      }\n\n      radix = radix || 10;\n\n      while (1) {\n        var mod = high % radix * BIT32 + low;\n        high = Math.floor(high / radix);\n        low = Math.floor(mod / radix);\n        str = (mod % radix).toString(radix) + str;\n        if (!high && !low) break;\n      }\n\n      if (sign) {\n        str = \"-\" + str;\n      }\n\n      return str;\n    }\n\n    function writeInt32(buffer, offset, value) {\n      buffer[offset + pos3] = value & 255;\n      value = value >> 8;\n      buffer[offset + pos2] = value & 255;\n      value = value >> 8;\n      buffer[offset + pos1] = value & 255;\n      value = value >> 8;\n      buffer[offset + pos0] = value & 255;\n    }\n\n    function readInt32(buffer, offset) {\n      return buffer[offset + pos0] * BIT24 + (buffer[offset + pos1] << 16) + (buffer[offset + pos2] << 8) + buffer[offset + pos3];\n    }\n  }\n\n  function toArray(raw) {\n    var buffer = this.buffer;\n    var offset = this.offset;\n    storage = null; // Array\n\n    if (raw !== false && offset === 0 && buffer.length === 8 && isArray(buffer)) return buffer;\n    return newArray(buffer, offset);\n  }\n\n  function toBuffer(raw) {\n    var buffer = this.buffer;\n    var offset = this.offset;\n    storage = BUFFER;\n    if (raw !== false && offset === 0 && buffer.length === 8 && Buffer.isBuffer(buffer)) return buffer;\n    var dest = new BUFFER(8);\n    fromArray(dest, 0, buffer, offset);\n    return dest;\n  }\n\n  function toArrayBuffer(raw) {\n    var buffer = this.buffer;\n    var offset = this.offset;\n    var arrbuf = buffer.buffer;\n    storage = UINT8ARRAY;\n    if (raw !== false && offset === 0 && arrbuf instanceof ARRAYBUFFER && arrbuf.byteLength === 8) return arrbuf;\n    var dest = new UINT8ARRAY(8);\n    fromArray(dest, 0, buffer, offset);\n    return dest.buffer;\n  }\n\n  function isValidBuffer(buffer, offset) {\n    var len = buffer && buffer.length;\n    offset |= 0;\n    return len && offset + 8 <= len && \"string\" !== typeof buffer[offset];\n  }\n\n  function fromArray(destbuf, destoff, srcbuf, srcoff) {\n    destoff |= 0;\n    srcoff |= 0;\n\n    for (var i = 0; i < 8; i++) {\n      destbuf[destoff++] = srcbuf[srcoff++] & 255;\n    }\n  }\n\n  function newArray(buffer, offset) {\n    return Array.prototype.slice.call(buffer, offset, offset + 8);\n  }\n\n  function fromPositiveBE(buffer, offset, value) {\n    var pos = offset + 8;\n\n    while (pos > offset) {\n      buffer[--pos] = value & 255;\n      value /= 256;\n    }\n  }\n\n  function fromNegativeBE(buffer, offset, value) {\n    var pos = offset + 8;\n    value++;\n\n    while (pos > offset) {\n      buffer[--pos] = -value & 255 ^ 255;\n      value /= 256;\n    }\n  }\n\n  function fromPositiveLE(buffer, offset, value) {\n    var end = offset + 8;\n\n    while (offset < end) {\n      buffer[offset++] = value & 255;\n      value /= 256;\n    }\n  }\n\n  function fromNegativeLE(buffer, offset, value) {\n    var end = offset + 8;\n    value++;\n\n    while (offset < end) {\n      buffer[offset++] = -value & 255 ^ 255;\n      value /= 256;\n    }\n  } // https://github.com/retrofox/is-array\n\n\n  function _isArray(val) {\n    return !!val && \"[object Array]\" == Object.prototype.toString.call(val);\n  }\n}(typeof exports === 'object' && typeof exports.nodeName !== 'string' ? exports : this || {});","/*!\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\n/* eslint-disable no-proto */\n'use strict';\n\nvar base64 = require('base64-js');\n\nvar ieee754 = require('ieee754');\n\nvar isArray = require('isarray');\n\nexports.Buffer = Buffer;\nexports.SlowBuffer = SlowBuffer;\nexports.INSPECT_MAX_BYTES = 50;\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 */\n\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined ? global.TYPED_ARRAY_SUPPORT : typedArraySupport();\n/*\n * Export kMaxLength after typed array support is determined.\n */\n\nexports.kMaxLength = kMaxLength();\n\nfunction typedArraySupport() {\n  try {\n    var arr = new Uint8Array(1);\n    arr.__proto__ = {\n      __proto__: Uint8Array.prototype,\n      foo: function foo() {\n        return 42;\n      }\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 ? 0x7fffffff : 0x3fffffff;\n}\n\nfunction createBuffer(that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length');\n  }\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\n    that.length = length;\n  }\n\n  return that;\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\n\nfunction Buffer(arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length);\n  } // Common case.\n\n\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error('If encoding is specified then the first argument must be a string');\n    }\n\n    return allocUnsafe(this, arg);\n  }\n\n  return from(this, arg, encodingOrOffset, length);\n}\n\nBuffer.poolSize = 8192; // not used by this implementation\n// TODO: Legacy, not needed anymore. Remove in next major version.\n\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 * 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 **/\n\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\n  if (typeof Symbol !== 'undefined' && Symbol.species && 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\n  if (size <= 0) {\n    return createBuffer(that, size);\n  }\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' ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill);\n  }\n\n  return createBuffer(that, size);\n}\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\n\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\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0;\n    }\n  }\n\n  return that;\n}\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\n\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 */\n\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  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\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255;\n  }\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\n  return that;\n}\n\nfunction fromObject(that, obj) {\n  if (Buffer.isBuffer(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' && obj.buffer instanceof ArrayBuffer || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0);\n      }\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 ' + 'size: 0x' + kMaxLength().toString(16) + ' bytes');\n  }\n\n  return length | 0;\n}\n\nfunction SlowBuffer(length) {\n  if (+length != length) {\n    // eslint-disable-line eqeqeq\n    length = 0;\n  }\n\n  return Buffer.alloc(+length);\n}\n\nBuffer.isBuffer = function isBuffer(b) {\n  return !!(b != null && b._isBuffer);\n};\n\nBuffer.compare = function compare(a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers');\n  }\n\n  if (a === b) return 0;\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\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\n  if (length === undefined) {\n    length = 0;\n\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\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i];\n\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers');\n    }\n\n    buf.copy(buffer, pos);\n    pos += buf.length;\n  }\n\n  return buffer;\n};\n\nfunction byteLength(string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length;\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength;\n  }\n\n  if (typeof string !== 'string') {\n    string = '' + string;\n  }\n\n  var len = string.length;\n  if (len === 0) return 0; // Use a for loop to avoid recursion\n\n  var loweredCase = false;\n\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len;\n\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length;\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2;\n\n      case 'hex':\n        return len >>> 1;\n\n      case 'base64':\n        return base64ToBytes(string).length;\n\n      default:\n        if (loweredCase) return utf8ToBytes(string).length; // assume utf8\n\n        encoding = ('' + encoding).toLowerCase();\n        loweredCase = true;\n    }\n  }\n}\n\nBuffer.byteLength = byteLength;\n\nfunction slowToString(encoding, start, end) {\n  var loweredCase = false; // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\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\n  if (start === undefined || start < 0) {\n    start = 0;\n  } // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n\n\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  } // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n\n\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} // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\n\n\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\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits');\n  }\n\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1);\n  }\n\n  return this;\n};\n\nBuffer.prototype.swap32 = function swap32() {\n  var len = this.length;\n\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits');\n  }\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\n  return this;\n};\n\nBuffer.prototype.swap64 = function swap64() {\n  var len = this.length;\n\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits');\n  }\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\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 (!Buffer.isBuffer(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 = exports.INSPECT_MAX_BYTES;\n\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');\n    if (this.length > max) str += ' ... ';\n  }\n\n  return '<Buffer ' + str + '>';\n};\n\nBuffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer');\n  }\n\n  if (start === undefined) {\n    start = 0;\n  }\n\n  if (end === undefined) {\n    end = target ? target.length : 0;\n  }\n\n  if (thisStart === undefined) {\n    thisStart = 0;\n  }\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\n  if (thisStart >= thisEnd) {\n    return -1;\n  }\n\n  if (start >= end) {\n    return 1;\n  }\n\n  start >>>= 0;\n  end >>>= 0;\n  thisStart >>>= 0;\n  thisEnd >>>= 0;\n  if (this === target) return 0;\n  var x = thisEnd - thisStart;\n  var y = end - start;\n  var len = Math.min(x, y);\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}; // 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\n\n\nfunction bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1; // Normalize byteOffset\n\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\n  byteOffset = +byteOffset; // Coerce to Number.\n\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  } // Normalize byteOffset: negative offsets start from the end of the buffer\n\n\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset;\n\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1;else byteOffset = buffer.length - 1;\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0;else return -1;\n  } // Normalize val\n\n\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding);\n  } // Finally, search either indexOf (if dir is true) or lastIndexOf\n\n\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1;\n    }\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\n    if (Buffer.TYPED_ARRAY_SUPPORT && 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\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\n    if (encoding === 'ucs2' || encoding === 'ucs-2' || encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1;\n      }\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\n  if (dir) {\n    var foundIndex = -1;\n\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\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true;\n\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\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\n  if (!length) {\n    length = remaining;\n  } else {\n    length = Number(length);\n\n    if (length > remaining) {\n      length = remaining;\n    }\n  } // must be an even number of digits\n\n\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\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\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; // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset;\n    length = this.length;\n    offset = 0; // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0;\n\n    if (isFinite(length)) {\n      length = length | 0;\n      if (encoding === undefined) encoding = 'utf8';\n    } else {\n      encoding = length;\n      length = undefined;\n    } // legacy write(string, encoding, offset, length) - remove in v0.13\n\n  } else {\n    throw new Error('Buffer.write(string, encoding, offset[, length]) is no longer supported');\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  var loweredCase = false;\n\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  var i = start;\n\n  while (i < end) {\n    var firstByte = buf[i];\n    var codePoint = null;\n    var bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 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\n          break;\n\n        case 2:\n          secondByte = buf[i + 1];\n\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | secondByte & 0x3F;\n\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n          break;\n\n        case 3:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | thirdByte & 0x3F;\n\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint;\n            }\n          }\n\n          break;\n\n        case 4:\n          secondByte = buf[i + 1];\n          thirdByte = buf[i + 2];\n          fourthByte = buf[i + 3];\n\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\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint;\n            }\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} // 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\n\n\nvar MAX_ARGUMENTS_LENGTH = 0x1000;\n\nfunction decodeCodePointsArray(codePoints) {\n  var len = codePoints.length;\n\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints); // avoid extra slice()\n  } // Decode in chunks to avoid \"call stack size exceeded\".\n\n\n  var res = '';\n  var i = 0;\n\n  while (i < len) {\n    res += String.fromCharCode.apply(String, 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\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\n  return ret;\n}\n\nfunction hexSlice(buf, start, end) {\n  var len = buf.length;\n  if (!start || start < 0) start = 0;\n  if (!end || end < 0 || end > len) end = len;\n  var out = '';\n\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i]);\n  }\n\n  return out;\n}\n\nfunction utf16leSlice(buf, start, end) {\n  var bytes = buf.slice(start, end);\n  var res = '';\n\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);\n  }\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  var newBuf;\n\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\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start];\n    }\n  }\n\n  return newBuf;\n};\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\n\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  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n\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\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length);\n  }\n\n  var val = this[offset + --byteLength];\n  var mul = 1;\n\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  return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 0x1000000;\n};\n\nBuffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] * 0x1000000 + (this[offset + 1] << 16 | this[offset + 2] << 8 | 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  var val = this[offset];\n  var mul = 1;\n  var i = 0;\n\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul;\n  }\n\n  mul *= 0x80;\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\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  var i = byteLength;\n  var mul = 1;\n  var val = this[offset + --i];\n\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul;\n  }\n\n  mul *= 0x80;\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\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  return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;\n};\n\nBuffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length);\n  return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | 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 (!Buffer.isBuffer(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\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\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\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\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\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)) >>> (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\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\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\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\n  return offset + 2;\n};\n\nfunction objectWriteUInt32(buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1;\n\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\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\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\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\n  return offset + 4;\n};\n\nBuffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {\n  value = +value;\n  offset = offset | 0;\n\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\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\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1;\n    }\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\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1);\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\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1;\n    }\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\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\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\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\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\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\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\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\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\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\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}; // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\n\n\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; // Copy 0 bytes; we're done\n\n  if (end === start) return 0;\n  if (target.length === 0 || this.length === 0) return 0; // Fatal error conditions\n\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds');\n  }\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'); // Are we oob?\n\n  if (end > this.length) end = this.length;\n\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(target, this.subarray(start, start + len), targetStart);\n  }\n\n  return len;\n}; // Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\n\n\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\n    if (val.length === 1) {\n      var code = val.charCodeAt(0);\n\n      if (code < 256) {\n        val = code;\n      }\n    }\n\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string');\n    }\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  } // Invalid ranges are not set to a default, so can range check early.\n\n\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  if (!val) val = 0;\n  var i;\n\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val;\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val) ? val : utf8ToBytes(new Buffer(val, encoding).toString());\n    var len = bytes.length;\n\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len];\n    }\n  }\n\n  return this;\n}; // HELPER FUNCTIONS\n// ================\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, ''); // Node converts strings with length < 2 to ''\n\n  if (str.length < 2) return ''; // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n\n  while (str.length % 4 !== 0) {\n    str = str + '=';\n  }\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); // is surrogate component\n\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        } // valid lead\n\n\n        leadSurrogate = codePoint;\n        continue;\n      } // 2 leads in a row\n\n\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\n        leadSurrogate = codePoint;\n        continue;\n      } // valid surrogate pair\n\n\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; // encode utf8\n\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(codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break;\n      bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break;\n      bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);\n    } else {\n      throw new Error('Invalid code point');\n    }\n  }\n\n  return bytes;\n}\n\nfunction asciiToBytes(str) {\n  var byteArray = [];\n\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\n  return byteArray;\n}\n\nfunction utf16leToBytes(str, units) {\n  var c, hi, lo;\n  var byteArray = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break;\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\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\n  return i;\n}\n\nfunction isnan(val) {\n  return val !== val; // eslint-disable-line no-self-compare\n}","var g; // This works in non-strict mode\n\ng = function () {\n  return this;\n}();\n\ntry {\n  // This works if eval is allowed (see CSP)\n  g = g || new Function(\"return this\")();\n} catch (e) {\n  // This works if the window reference is available\n  if (typeof window === \"object\") g = window;\n} // g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\n\nmodule.exports = g;","'use strict';\n\nexports.byteLength = byteLength;\nexports.toByteArray = toByteArray;\nexports.fromByteArray = fromByteArray;\nvar lookup = [];\nvar revLookup = [];\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i];\n  revLookup[code.charCodeAt(i)] = i;\n} // Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\n\n\nrevLookup['-'.charCodeAt(0)] = 62;\nrevLookup['_'.charCodeAt(0)] = 63;\n\nfunction getLens(b64) {\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  } // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n\n\n  var validLen = b64.indexOf('=');\n  if (validLen === -1) validLen = len;\n  var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;\n  return [validLen, placeHoldersLen];\n} // base64 is 4/3 + up to two characters of the original data\n\n\nfunction byteLength(b64) {\n  var lens = getLens(b64);\n  var validLen = lens[0];\n  var placeHoldersLen = lens[1];\n  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n}\n\nfunction _byteLength(b64, validLen, placeHoldersLen) {\n  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n}\n\nfunction toByteArray(b64) {\n  var tmp;\n  var lens = getLens(b64);\n  var validLen = lens[0];\n  var placeHoldersLen = lens[1];\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));\n  var curByte = 0; // if there are placeholders, only get up to the last complete 4 chars\n\n  var len = placeHoldersLen > 0 ? validLen - 4 : validLen;\n  var i;\n\n  for (i = 0; i < len; i += 4) {\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[curByte++] = tmp >> 16 & 0xFF;\n    arr[curByte++] = tmp >> 8 & 0xFF;\n    arr[curByte++] = tmp & 0xFF;\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;\n    arr[curByte++] = tmp & 0xFF;\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;\n    arr[curByte++] = tmp >> 8 & 0xFF;\n    arr[curByte++] = 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\n  for (var i = start; i < end; i += 3) {\n    tmp = (uint8[i] << 16 & 0xFF0000) + (uint8[i + 1] << 8 & 0xFF00) + (uint8[i + 2] & 0xFF);\n    output.push(tripletToBase64(tmp));\n  }\n\n  return output.join('');\n}\n\nfunction fromByteArray(uint8) {\n  var tmp;\n  var len = uint8.length;\n  var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes\n\n  var parts = [];\n  var maxChunkLength = 16383; // must be multiple of 3\n  // go through the array every three bytes, we'll deal with trailing stuff later\n\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  } // pad the end with zeros, but make sure to not forget the extra bytes\n\n\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1];\n    parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 0x3F] + '==');\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1];\n    parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 0x3F] + lookup[tmp << 2 & 0x3F] + '=');\n  }\n\n  return parts.join('');\n}","exports.read = function (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  i += d;\n  e = s & (1 << -nBits) - 1;\n  s >>= -nBits;\n  nBits += eLen;\n\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\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\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n};\n\nexports.write = function (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  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\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--;\n      c *= 2;\n    }\n\n    if (e + eBias >= 1) {\n      value += rt / c;\n    } else {\n      value += rt * Math.pow(2, 1 - eBias);\n    }\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\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128;\n};","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};"],"sourceRoot":""}