{"version":3,"sources":["webpack:///./node_modules/omit.js/es/index.js","webpack:///./node_modules/multiformats/cjs/src/bases/base16.js","webpack:///./node_modules/mutationobserver-shim/dist/mutationobserver.min.js","webpack:///./node_modules/multiformats/cjs/src/bases/base8.js","webpack:///./node_modules/node-libs-browser/node_modules/inherits/inherits_browser.js","webpack:///./node_modules/multiformats/cjs/src/bases/base32.js","webpack:///./node_modules/multiformats/cjs/src/bases/base64.js","webpack:///./node_modules/node-libs-browser/node_modules/buffer/index.js","webpack:///./node_modules/multiformats/cjs/src/hashes/identity.js","webpack:///./node_modules/multiformats/cjs/src/hashes/digest.js","webpack:///./node_modules/object-assign/index.js","webpack:///./node_modules/multiformats/cjs/src/bases/base36.js","webpack:///./node_modules/multiformats/cjs/vendor/varint.js","webpack:///./node_modules/multiformats/cjs/vendor/base-x.js","webpack:///./node_modules/multiformats/cjs/src/bases/base256emoji.js","webpack:///./node_modules/multiformats/cjs/src/codecs/json.js","webpack:///./node_modules/multiformats/cjs/src/hashes/sha2-browser.js","webpack:///./node_modules/node-libs-browser/node_modules/util/support/isBufferBrowser.js","webpack:///./node_modules/multiformats/cjs/src/bases/identity.js","webpack:///./node_modules/multiformats/cjs/src/codecs/raw.js","webpack:///./node_modules/multiformats/cjs/src/hashes/hasher.js","webpack:///./node_modules/multiformats/cjs/src/varint.js","webpack:///./node_modules/node-polyfill-webpack-plugin/node_modules/buffer/index.js","webpack:///./node_modules/multiformats/cjs/src/basics.js","webpack:///./node_modules/multiformats/cjs/src/bases/base10.js","webpack:///./node_modules/multiformats/cjs/src/bases/base2.js","webpack:///./node_modules/multiformats/cjs/src/index.js","webpack:///./node_modules/multiformats/cjs/src/bases/base.js","webpack:///./node_modules/multiformats/cjs/src/bytes.js","webpack:///./node_modules/multiformats/cjs/src/bases/base58.js","webpack:///./node_modules/nanoid/non-secure/index.js","webpack:///./node_modules/node-libs-browser/node_modules/assert/assert.js","webpack:///./node_modules/node-libs-browser/node_modules/util/util.js","webpack:///./node_modules/multiformats/cjs/src/cid.js"],"names":["i","obj","fields","shallowCopy","length","key","Object","defineProperty","exports","value","base","r","base16","rfc4648","prefix","name","alphabet","bitsPerChar","base16upper","window","MutationObserver","y","z","a","this","m","K","c","d","takeRecords","h","setTimeout","_period","b","type","target","addedNodes","removedNodes","previousSibling","nextSibling","attributeName","attributeNamespace","oldValue","L","E","f","nodeType","nodeValue","push","C","g","M","k","attributes","p","F","namespaceURI","t","q","x","l","e","A","pop","j","Math","abs","n","v","childNodes","B","w","u","node","G","H","I","P","id","mo_id","J","prototype","observe","attributeFilter","attributeOldValue","childList","subtree","characterData","characterDataOldValue","s","splice","o","disconnect","clearTimeout","D","document","createElement","style","top","cssText","base8","create","module","ctor","superCtor","super_","constructor","enumerable","writable","configurable","TempCtor","base32","base32upper","base32pad","base32padupper","base32hex","base32hexupper","base32hexpad","base32hexpadupper","base32z","base64","base64pad","base64url","base64urlpad","ieee754","isArray","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","Uint8Array","__proto__","arg","encodingOrOffset","Error","allocUnsafe","from","TypeError","ArrayBuffer","array","byteOffset","byteLength","fromArrayLike","fromArrayBuffer","string","encoding","isEncoding","actual","write","slice","fromString","isBuffer","len","checked","copy","buffer","val","isnan","data","fromObject","assertSize","size","toString","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","indexOf","call","lastIndexOf","arr","indexSize","arrLength","valLength","String","read","buf","readUInt16BE","foundIndex","found","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","charCodeAt","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","fromByteArray","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","foo","subarray","typedArraySupport","poolSize","_augment","Symbol","species","fill","allocUnsafeSlow","_isBuffer","compare","concat","list","pos","swap16","swap32","swap64","arguments","equals","inspect","max","match","join","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","undefined","toJSON","Array","_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","floor","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","trim","replace","stringtrim","base64clean","src","dst","digest$1","encode","coerce","identity","digest","input","varint","Digest","sizeOffset","encodingLength","digestOffset","encodeTo","decode","multihash","bytes$1","getOwnPropertySymbols","hasOwnProperty","propIsEnumerable","propertyIsEnumerable","assign","test1","getOwnPropertyNames","test2","order2","map","test3","split","forEach","letter","keys","err","shouldUseNative","source","symbols","to","toObject","base36","baseX","base36upper","encode_1","num","oldOffset","INT","MSB","MSBALL","shift","counter","REST$1","MSB$1","N1","N2","N3","N4","N5","N6","N7","N8","N9","varint$1","ALPHABET","BASE_MAP","charAt","xc","BASE","LEADER","FACTOR","log","iFACTOR","decodeUnsafe","psz","zeroes","b256","carry","it3","it4","vch","pbegin","pend","b58","it1","it2","repeat","_brrp__multiformats_scope_baseX","alphabetBytesToChars","reduce","alphabetCharsToBytes","codePointAt","base256emoji","byts","char","byt","textEncoder","TextEncoder","textDecoder","TextDecoder","JSON","parse","stringify","hasher","sha","async","crypto","subtle","sha256","sha512","Hasher","result","then","int","customInspectSymbol","K_MAX_LENGTH","setPrototypeOf","arrayView","isInstance","fromArrayView","SharedArrayBuffer","valueOf","numberIsNaN","toPrimitive","mustMatch","proto","console","error","get","toLocaleString","hexSliceLookupTable","wrtBigUInt64LE","checkIntBI","BigInt","wrtBigUInt64BE","readUintLE","readUintBE","readUint8","readUint16LE","readUint16BE","readUint32LE","readUint32BE","readBigUInt64LE","defineBigIntMethod","validateNumber","first","last","boundsError","readBigUInt64BE","readBigInt64LE","readBigInt64BE","writeUintLE","writeUintBE","writeUint8","writeUint16LE","writeUint16BE","writeUint32LE","writeUint32BE","writeBigUInt64LE","writeBigUInt64BE","writeBigInt64LE","writeBigInt64BE","copyWithin","errors","sym","getMessage","Base","super","stack","message","addNumericalSeparator","range","ERR_OUT_OF_RANGE","checkBounds","ERR_INVALID_ARG_TYPE","ERR_BUFFER_OUT_OF_BOUNDS","msg","received","isInteger","table","i16","fn","BufferBigIntNotDefined","base2","base10","base58","sha2","identity$1","raw","json","cid","bases","hashes","codecs","CID","baseX$1","Encoder","baseEncode","Decoder","baseDecode","prefixCodePoint","text","or","decoder","ComposedDecoder","decoders","left","right","Codec","encoder","pad","mask","bits","codes","written","SyntaxError","empty","aa","bb","ii","fromHex","hex","hexes","isBinary","byte","padStart","base58btc","base58flickr","customAlphabet","defaultSize","random","nanoid","objectAssign","util","hasOwn","pSlice","functionsHaveNames","pToString","arrbuf","DataView","assert","ok","regex","getName","func","isFunction","truncate","something","rawname","fail","expected","operator","stackStartFunction","AssertionError","_deepEqual","strict","memos","isDate","getTime","isRegExp","multiline","lastIndex","ignoreCase","Float32Array","Float64Array","actualIndex","actualVisitedObjects","isPrimitive","getPrototypeOf","aIsArgs","isArguments","bIsArgs","ka","objectKeys","kb","sort","objEquiv","object","expectedException","test","isPrototypeOf","_throws","shouldThrow","block","_tryBlock","userProvidedMessage","isUnexpectedException","isError","options","generatedMessage","self","captureStackTrace","fn_name","idx","next_line","substring","inherits","equal","notEqual","deepEqual","deepStrictEqual","notDeepEqual","notDeepStrictEqual","strictEqual","notStrictEqual","throws","doesNotThrow","ifError","getOwnPropertyDescriptors","descriptors","getOwnPropertyDescriptor","formatRegExp","format","isString","objects","args","_","isNull","isObject","deprecate","process","noDeprecation","warned","throwDeprecation","traceDeprecation","trace","deprecated","debugEnviron","debugs","opts","ctx","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","isUndefined","customInspect","stylizeWithColor","formatValue","styleType","styles","recurseTimes","primitive","formatPrimitive","visibleKeys","hash","arrayToHash","formatError","RegExp","Date","output","braces","toUTCString","formatProperty","formatArray","prev","cur","reduceToSingleString","simple","isNumber","desc","line","ar","re","objectToString","debuglog","NODE_DEBUG","toUpperCase","pid","isNullOrUndefined","isSymbol","months","prop","time","getHours","getMinutes","getSeconds","getDate","getMonth","timestamp","origin","add","kCustomPromisifiedSymbol","callbackifyOnRejected","reason","cb","newReason","promisify","original","promiseResolve","promiseReject","promise","Promise","resolve","reject","defineProperties","custom","callbackify","callbackified","maybeCb","nextTick","rej","version","asCID","_baseCache","Map","hidden","readonly","toV0","DAG_PB_CODE","SHA_256_CODE","createV0","toV1","createV1","other","toStringV0","toStringV1","toStringTag","for","static","IS_CID_DEPRECATION","cidSymbol","toBaseEncodedString","codec","multibaseName","encodeCID","remainder","decodeFirst","specs","inspectBytes","prefixSize","multihashSize","multihashBytes","digestBytes","digestSize","multihashCode","initialBytes","next","parseCIDtoBytes","cache","codeOffset","hashOffset","warn"],"mappings":"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","file":"js/chunk-vendors~9c5b28f6.751bb504.js","sourcesContent":["import _extends from \"babel-runtime/helpers/extends\";\nfunction omit(obj, fields) {\n  var shallowCopy = _extends({}, obj);\n  for (var i = 0; i < fields.length; i++) {\n    var key = fields[i];\n    delete shallowCopy[key];\n  }\n  return shallowCopy;\n}\n\nexport default omit;","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base16 = base.rfc4648({\n  prefix: 'f',\n  name: 'base16',\n  alphabet: '0123456789abcdef',\n  bitsPerChar: 4\n});\nconst base16upper = base.rfc4648({\n  prefix: 'F',\n  name: 'base16upper',\n  alphabet: '0123456789ABCDEF',\n  bitsPerChar: 4\n});\n\nexports.base16 = base16;\nexports.base16upper = base16upper;\n","// mutationobserver-shim v0.3.3 (github.com/megawac/MutationObserver.js)\n// Authors: Graeme Yeates (github.com/megawac) \n/*\n Shim for MutationObserver interface\n Author: Graeme Yeates (github.com/megawac)\n Repository: https://github.com/megawac/MutationObserver.js\n License: WTFPL V2, 2004 (wtfpl.net).\n Though credit and staring the repo will make me feel pretty, you can modify and redistribute as you please.\n Attempts to follow spec (https://www.w3.org/TR/dom/#mutation-observers) as closely as possible for native javascript\n See https://github.com/WebKit/webkit/blob/master/Source/WebCore/dom/MutationObserver.cpp for current webkit source c++ implementation\n*/\nwindow.MutationObserver||(window.MutationObserver=function(y){function z(a){this.i=[];this.m=a}function K(a){(function c(){var d=a.takeRecords();d.length&&a.m(d,a);a.h=setTimeout(c,z._period)})()}function r(a){var b={type:null,target:null,addedNodes:[],removedNodes:[],previousSibling:null,nextSibling:null,attributeName:null,attributeNamespace:null,oldValue:null},c;for(c in a)b[c]!==y&&a[c]!==y&&(b[c]=a[c]);return b}function L(a,b){var c=E(a,b);return function(d){var f=d.length;b.a&&3===a.nodeType&&\na.nodeValue!==c.a&&d.push(new r({type:\"characterData\",target:a,oldValue:c.a}));b.b&&c.b&&C(d,a,c.b,b.f);if(b.c||b.g)var m=M(d,a,c,b);if(m||d.length!==f)c=E(a,b)}}function N(a,b){return b.value}function O(a,b){return\"style\"!==b.name?b.value:a.style.cssText}function C(a,b,c,d){for(var f={},m=b.attributes,k,g,p=m.length;p--;)k=m[p],g=k.name,d&&d[g]===y||(F(b,k)!==c[g]&&a.push(r({type:\"attributes\",target:b,attributeName:g,oldValue:c[g],attributeNamespace:k.namespaceURI})),f[g]=!0);for(g in c)f[g]||a.push(r({target:b,\ntype:\"attributes\",attributeName:g,oldValue:c[g]}))}function M(a,b,c,d){function f(g,p,t,q,x){var A=g.length-1;x=-~((A-x)/2);for(var h,l,e;e=g.pop();)h=t[e.j],l=q[e.l],d.c&&x&&Math.abs(e.j-e.l)>=A&&(a.push(r({type:\"childList\",target:p,addedNodes:[h],removedNodes:[h],nextSibling:h.nextSibling,previousSibling:h.previousSibling})),x--),d.b&&l.b&&C(a,h,l.b,d.f),d.a&&3===h.nodeType&&h.nodeValue!==l.a&&a.push(r({type:\"characterData\",target:h,oldValue:l.a})),d.g&&m(h,l)}function m(g,p){for(var t=g.childNodes,\nq=p.c,x=t.length,A=q?q.length:0,h,l,e,n,v,B=0,w=0,u=0;w<x||u<A;)n=t[w],v=(e=q[u])&&e.node,n===v?(d.b&&e.b&&C(a,n,e.b,d.f),d.a&&e.a!==y&&n.nodeValue!==e.a&&a.push(r({type:\"characterData\",target:n,oldValue:e.a})),l&&f(l,g,t,q,B),d.g&&(n.childNodes.length||e.c&&e.c.length)&&m(n,e),w++,u++):(k=!0,h||(h={},l=[]),n&&(h[e=G(n)]||(h[e]=!0,-1===(e=H(q,n,u,\"node\"))?d.c&&(a.push(r({type:\"childList\",target:g,addedNodes:[n],nextSibling:n.nextSibling,previousSibling:n.previousSibling})),B++):l.push({j:w,l:e})),\nw++),v&&v!==t[w]&&(h[e=G(v)]||(h[e]=!0,-1===(e=H(t,v,w))?d.c&&(a.push(r({type:\"childList\",target:p.node,removedNodes:[v],nextSibling:q[u+1],previousSibling:q[u-1]})),B--):l.push({j:e,l:u})),u++));l&&f(l,g,t,q,B)}var k;m(b,c);return k}function E(a,b){var c=!0;return function m(f){var k={node:f};!b.a||3!==f.nodeType&&8!==f.nodeType?(b.b&&c&&1===f.nodeType&&(k.b=I(f.attributes,function(g,p){if(!b.f||b.f[p.name])g[p.name]=F(f,p);return g},{})),c&&(b.c||b.a||b.b&&b.g)&&(k.c=P(f.childNodes,m)),c=b.g):k.a=\nf.nodeValue;return k}(a)}function G(a){try{return a.id||(a.mo_id=a.mo_id||J++)}catch(b){try{return a.nodeValue}catch(c){return J++}}}function P(a,b){for(var c=[],d=0;d<a.length;d++)c[d]=b(a[d],d,a);return c}function I(a,b,c){for(var d=0;d<a.length;d++)c=b(c,a[d],d,a);return c}function H(a,b,c,d){for(;c<a.length;c++)if((d?a[c][d]:a[c])===b)return c;return-1}z._period=30;z.prototype={observe:function(a,b){for(var c={b:!!(b.attributes||b.attributeFilter||b.attributeOldValue),c:!!b.childList,g:!!b.subtree,\na:!(!b.characterData&&!b.characterDataOldValue)},d=this.i,f=0;f<d.length;f++)d[f].s===a&&d.splice(f,1);b.attributeFilter&&(c.f=I(b.attributeFilter,function(m,k){m[k]=!0;return m},{}));d.push({s:a,o:L(a,c)});this.h||K(this)},takeRecords:function(){for(var a=[],b=this.i,c=0;c<b.length;c++)b[c].o(a);return a},disconnect:function(){this.i=[];clearTimeout(this.h);this.h=null}};var D=document.createElement(\"i\");D.style.top=0;var F=(D=\"null\"!=D.attributes.style.value)?N:O,J=1;return z}(void 0));\n//# sourceMappingURL=mutationobserver.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base8 = base.rfc4648({\n  prefix: '7',\n  name: 'base8',\n  alphabet: '01234567',\n  bitsPerChar: 3\n});\n\nexports.base8 = base8;\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\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  // old school shim for old browsers\n  module.exports = 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}\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base32 = base.rfc4648({\n  prefix: 'b',\n  name: 'base32',\n  alphabet: 'abcdefghijklmnopqrstuvwxyz234567',\n  bitsPerChar: 5\n});\nconst base32upper = base.rfc4648({\n  prefix: 'B',\n  name: 'base32upper',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',\n  bitsPerChar: 5\n});\nconst base32pad = base.rfc4648({\n  prefix: 'c',\n  name: 'base32pad',\n  alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',\n  bitsPerChar: 5\n});\nconst base32padupper = base.rfc4648({\n  prefix: 'C',\n  name: 'base32padupper',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',\n  bitsPerChar: 5\n});\nconst base32hex = base.rfc4648({\n  prefix: 'v',\n  name: 'base32hex',\n  alphabet: '0123456789abcdefghijklmnopqrstuv',\n  bitsPerChar: 5\n});\nconst base32hexupper = base.rfc4648({\n  prefix: 'V',\n  name: 'base32hexupper',\n  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',\n  bitsPerChar: 5\n});\nconst base32hexpad = base.rfc4648({\n  prefix: 't',\n  name: 'base32hexpad',\n  alphabet: '0123456789abcdefghijklmnopqrstuv=',\n  bitsPerChar: 5\n});\nconst base32hexpadupper = base.rfc4648({\n  prefix: 'T',\n  name: 'base32hexpadupper',\n  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',\n  bitsPerChar: 5\n});\nconst base32z = base.rfc4648({\n  prefix: 'h',\n  name: 'base32z',\n  alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',\n  bitsPerChar: 5\n});\n\nexports.base32 = base32;\nexports.base32hex = base32hex;\nexports.base32hexpad = base32hexpad;\nexports.base32hexpadupper = base32hexpadupper;\nexports.base32hexupper = base32hexupper;\nexports.base32pad = base32pad;\nexports.base32padupper = base32padupper;\nexports.base32upper = base32upper;\nexports.base32z = base32z;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base64 = base.rfc4648({\n  prefix: 'm',\n  name: 'base64',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',\n  bitsPerChar: 6\n});\nconst base64pad = base.rfc4648({\n  prefix: 'M',\n  name: 'base64pad',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',\n  bitsPerChar: 6\n});\nconst base64url = base.rfc4648({\n  prefix: 'u',\n  name: 'base64url',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',\n  bitsPerChar: 6\n});\nconst base64urlpad = base.rfc4648({\n  prefix: 'U',\n  name: 'base64urlpad',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',\n  bitsPerChar: 6\n});\n\nexports.base64 = base64;\nexports.base64pad = base64pad;\nexports.base64url = base64url;\nexports.base64urlpad = base64urlpad;\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.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  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\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\nfunction 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 (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' &&\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\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\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\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 (!Buffer.isBuffer(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 (Buffer.isBuffer(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 (!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  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 (!Buffer.isBuffer(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 (Buffer.isBuffer(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 (!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  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 = Buffer.isBuffer(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\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","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar bytes = require('../bytes.js');\nvar digest$1 = require('./digest.js');\n\nconst code = 0;\nconst name = 'identity';\nconst encode = bytes.coerce;\nconst digest = input => digest$1.create(code, encode(input));\nconst identity = {\n  code,\n  name,\n  encode,\n  digest\n};\n\nexports.identity = identity;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar bytes = require('../bytes.js');\nvar varint = require('../varint.js');\n\nconst create = (code, digest) => {\n  const size = digest.byteLength;\n  const sizeOffset = varint.encodingLength(code);\n  const digestOffset = sizeOffset + varint.encodingLength(size);\n  const bytes = new Uint8Array(digestOffset + size);\n  varint.encodeTo(code, bytes, 0);\n  varint.encodeTo(size, bytes, sizeOffset);\n  bytes.set(digest, digestOffset);\n  return new Digest(code, size, digest, bytes);\n};\nconst decode = multihash => {\n  const bytes$1 = bytes.coerce(multihash);\n  const [code, sizeOffset] = varint.decode(bytes$1);\n  const [size, digestOffset] = varint.decode(bytes$1.subarray(sizeOffset));\n  const digest = bytes$1.subarray(sizeOffset + digestOffset);\n  if (digest.byteLength !== size) {\n    throw new Error('Incorrect length');\n  }\n  return new Digest(code, size, digest, bytes$1);\n};\nconst equals = (a, b) => {\n  if (a === b) {\n    return true;\n  } else {\n    return a.code === b.code && a.size === b.size && bytes.equals(a.bytes, b.bytes);\n  }\n};\nclass Digest {\n  constructor(code, size, digest, bytes) {\n    this.code = code;\n    this.size = size;\n    this.digest = digest;\n    this.bytes = bytes;\n  }\n}\n\nexports.Digest = Digest;\nexports.create = create;\nexports.decode = decode;\nexports.equals = equals;\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base36 = base.baseX({\n  prefix: 'k',\n  name: 'base36',\n  alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'\n});\nconst base36upper = base.baseX({\n  prefix: 'K',\n  name: 'base36upper',\n  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n});\n\nexports.base36 = base36;\nexports.base36upper = base36upper;\n","'use strict';\n\nvar encode_1 = encode;\nvar MSB = 128, REST = 127, MSBALL = ~REST, INT = Math.pow(2, 31);\nfunction encode(num, out, offset) {\n  out = out || [];\n  offset = offset || 0;\n  var oldOffset = offset;\n  while (num >= INT) {\n    out[offset++] = num & 255 | MSB;\n    num /= 128;\n  }\n  while (num & MSBALL) {\n    out[offset++] = num & 255 | MSB;\n    num >>>= 7;\n  }\n  out[offset] = num | 0;\n  encode.bytes = offset - oldOffset + 1;\n  return out;\n}\nvar decode = read;\nvar MSB$1 = 128, REST$1 = 127;\nfunction read(buf, offset) {\n  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;\n  do {\n    if (counter >= l) {\n      read.bytes = 0;\n      throw new RangeError('Could not decode varint');\n    }\n    b = buf[counter++];\n    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);\n    shift += 7;\n  } while (b >= MSB$1);\n  read.bytes = counter - offset;\n  return res;\n}\nvar N1 = Math.pow(2, 7);\nvar N2 = Math.pow(2, 14);\nvar N3 = Math.pow(2, 21);\nvar N4 = Math.pow(2, 28);\nvar N5 = Math.pow(2, 35);\nvar N6 = Math.pow(2, 42);\nvar N7 = Math.pow(2, 49);\nvar N8 = Math.pow(2, 56);\nvar N9 = Math.pow(2, 63);\nvar length = function (value) {\n  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;\n};\nvar varint = {\n  encode: encode_1,\n  decode: decode,\n  encodingLength: length\n};\nvar _brrp_varint = varint;\nvar varint$1 = _brrp_varint;\n\nmodule.exports = varint$1;\n","'use strict';\n\nfunction base(ALPHABET, name) {\n  if (ALPHABET.length >= 255) {\n    throw new TypeError('Alphabet too long');\n  }\n  var BASE_MAP = new Uint8Array(256);\n  for (var j = 0; j < BASE_MAP.length; j++) {\n    BASE_MAP[j] = 255;\n  }\n  for (var i = 0; i < ALPHABET.length; i++) {\n    var x = ALPHABET.charAt(i);\n    var xc = x.charCodeAt(0);\n    if (BASE_MAP[xc] !== 255) {\n      throw new TypeError(x + ' is ambiguous');\n    }\n    BASE_MAP[xc] = i;\n  }\n  var BASE = ALPHABET.length;\n  var LEADER = ALPHABET.charAt(0);\n  var FACTOR = Math.log(BASE) / Math.log(256);\n  var iFACTOR = Math.log(256) / Math.log(BASE);\n  function encode(source) {\n    if (source instanceof Uint8Array);\n    else if (ArrayBuffer.isView(source)) {\n      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);\n    } else if (Array.isArray(source)) {\n      source = Uint8Array.from(source);\n    }\n    if (!(source instanceof Uint8Array)) {\n      throw new TypeError('Expected Uint8Array');\n    }\n    if (source.length === 0) {\n      return '';\n    }\n    var zeroes = 0;\n    var length = 0;\n    var pbegin = 0;\n    var pend = source.length;\n    while (pbegin !== pend && source[pbegin] === 0) {\n      pbegin++;\n      zeroes++;\n    }\n    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;\n    var b58 = new Uint8Array(size);\n    while (pbegin !== pend) {\n      var carry = source[pbegin];\n      var i = 0;\n      for (var it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {\n        carry += 256 * b58[it1] >>> 0;\n        b58[it1] = carry % BASE >>> 0;\n        carry = carry / BASE >>> 0;\n      }\n      if (carry !== 0) {\n        throw new Error('Non-zero carry');\n      }\n      length = i;\n      pbegin++;\n    }\n    var it2 = size - length;\n    while (it2 !== size && b58[it2] === 0) {\n      it2++;\n    }\n    var str = LEADER.repeat(zeroes);\n    for (; it2 < size; ++it2) {\n      str += ALPHABET.charAt(b58[it2]);\n    }\n    return str;\n  }\n  function decodeUnsafe(source) {\n    if (typeof source !== 'string') {\n      throw new TypeError('Expected String');\n    }\n    if (source.length === 0) {\n      return new Uint8Array();\n    }\n    var psz = 0;\n    if (source[psz] === ' ') {\n      return;\n    }\n    var zeroes = 0;\n    var length = 0;\n    while (source[psz] === LEADER) {\n      zeroes++;\n      psz++;\n    }\n    var size = (source.length - psz) * FACTOR + 1 >>> 0;\n    var b256 = new Uint8Array(size);\n    while (source[psz]) {\n      var carry = BASE_MAP[source.charCodeAt(psz)];\n      if (carry === 255) {\n        return;\n      }\n      var i = 0;\n      for (var it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {\n        carry += BASE * b256[it3] >>> 0;\n        b256[it3] = carry % 256 >>> 0;\n        carry = carry / 256 >>> 0;\n      }\n      if (carry !== 0) {\n        throw new Error('Non-zero carry');\n      }\n      length = i;\n      psz++;\n    }\n    if (source[psz] === ' ') {\n      return;\n    }\n    var it4 = size - length;\n    while (it4 !== size && b256[it4] === 0) {\n      it4++;\n    }\n    var vch = new Uint8Array(zeroes + (size - it4));\n    var j = zeroes;\n    while (it4 !== size) {\n      vch[j++] = b256[it4++];\n    }\n    return vch;\n  }\n  function decode(string) {\n    var buffer = decodeUnsafe(string);\n    if (buffer) {\n      return buffer;\n    }\n    throw new Error(`Non-${ name } character`);\n  }\n  return {\n    encode: encode,\n    decodeUnsafe: decodeUnsafe,\n    decode: decode\n  };\n}\nvar src = base;\nvar _brrp__multiformats_scope_baseX = src;\n\nmodule.exports = _brrp__multiformats_scope_baseX;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst alphabet = Array.from('\\uD83D\\uDE80\\uD83E\\uDE90\\u2604\\uD83D\\uDEF0\\uD83C\\uDF0C\\uD83C\\uDF11\\uD83C\\uDF12\\uD83C\\uDF13\\uD83C\\uDF14\\uD83C\\uDF15\\uD83C\\uDF16\\uD83C\\uDF17\\uD83C\\uDF18\\uD83C\\uDF0D\\uD83C\\uDF0F\\uD83C\\uDF0E\\uD83D\\uDC09\\u2600\\uD83D\\uDCBB\\uD83D\\uDDA5\\uD83D\\uDCBE\\uD83D\\uDCBF\\uD83D\\uDE02\\u2764\\uD83D\\uDE0D\\uD83E\\uDD23\\uD83D\\uDE0A\\uD83D\\uDE4F\\uD83D\\uDC95\\uD83D\\uDE2D\\uD83D\\uDE18\\uD83D\\uDC4D\\uD83D\\uDE05\\uD83D\\uDC4F\\uD83D\\uDE01\\uD83D\\uDD25\\uD83E\\uDD70\\uD83D\\uDC94\\uD83D\\uDC96\\uD83D\\uDC99\\uD83D\\uDE22\\uD83E\\uDD14\\uD83D\\uDE06\\uD83D\\uDE44\\uD83D\\uDCAA\\uD83D\\uDE09\\u263A\\uD83D\\uDC4C\\uD83E\\uDD17\\uD83D\\uDC9C\\uD83D\\uDE14\\uD83D\\uDE0E\\uD83D\\uDE07\\uD83C\\uDF39\\uD83E\\uDD26\\uD83C\\uDF89\\uD83D\\uDC9E\\u270C\\u2728\\uD83E\\uDD37\\uD83D\\uDE31\\uD83D\\uDE0C\\uD83C\\uDF38\\uD83D\\uDE4C\\uD83D\\uDE0B\\uD83D\\uDC97\\uD83D\\uDC9A\\uD83D\\uDE0F\\uD83D\\uDC9B\\uD83D\\uDE42\\uD83D\\uDC93\\uD83E\\uDD29\\uD83D\\uDE04\\uD83D\\uDE00\\uD83D\\uDDA4\\uD83D\\uDE03\\uD83D\\uDCAF\\uD83D\\uDE48\\uD83D\\uDC47\\uD83C\\uDFB6\\uD83D\\uDE12\\uD83E\\uDD2D\\u2763\\uD83D\\uDE1C\\uD83D\\uDC8B\\uD83D\\uDC40\\uD83D\\uDE2A\\uD83D\\uDE11\\uD83D\\uDCA5\\uD83D\\uDE4B\\uD83D\\uDE1E\\uD83D\\uDE29\\uD83D\\uDE21\\uD83E\\uDD2A\\uD83D\\uDC4A\\uD83E\\uDD73\\uD83D\\uDE25\\uD83E\\uDD24\\uD83D\\uDC49\\uD83D\\uDC83\\uD83D\\uDE33\\u270B\\uD83D\\uDE1A\\uD83D\\uDE1D\\uD83D\\uDE34\\uD83C\\uDF1F\\uD83D\\uDE2C\\uD83D\\uDE43\\uD83C\\uDF40\\uD83C\\uDF37\\uD83D\\uDE3B\\uD83D\\uDE13\\u2B50\\u2705\\uD83E\\uDD7A\\uD83C\\uDF08\\uD83D\\uDE08\\uD83E\\uDD18\\uD83D\\uDCA6\\u2714\\uD83D\\uDE23\\uD83C\\uDFC3\\uD83D\\uDC90\\u2639\\uD83C\\uDF8A\\uD83D\\uDC98\\uD83D\\uDE20\\u261D\\uD83D\\uDE15\\uD83C\\uDF3A\\uD83C\\uDF82\\uD83C\\uDF3B\\uD83D\\uDE10\\uD83D\\uDD95\\uD83D\\uDC9D\\uD83D\\uDE4A\\uD83D\\uDE39\\uD83D\\uDDE3\\uD83D\\uDCAB\\uD83D\\uDC80\\uD83D\\uDC51\\uD83C\\uDFB5\\uD83E\\uDD1E\\uD83D\\uDE1B\\uD83D\\uDD34\\uD83D\\uDE24\\uD83C\\uDF3C\\uD83D\\uDE2B\\u26BD\\uD83E\\uDD19\\u2615\\uD83C\\uDFC6\\uD83E\\uDD2B\\uD83D\\uDC48\\uD83D\\uDE2E\\uD83D\\uDE46\\uD83C\\uDF7B\\uD83C\\uDF43\\uD83D\\uDC36\\uD83D\\uDC81\\uD83D\\uDE32\\uD83C\\uDF3F\\uD83E\\uDDE1\\uD83C\\uDF81\\u26A1\\uD83C\\uDF1E\\uD83C\\uDF88\\u274C\\u270A\\uD83D\\uDC4B\\uD83D\\uDE30\\uD83E\\uDD28\\uD83D\\uDE36\\uD83E\\uDD1D\\uD83D\\uDEB6\\uD83D\\uDCB0\\uD83C\\uDF53\\uD83D\\uDCA2\\uD83E\\uDD1F\\uD83D\\uDE41\\uD83D\\uDEA8\\uD83D\\uDCA8\\uD83E\\uDD2C\\u2708\\uD83C\\uDF80\\uD83C\\uDF7A\\uD83E\\uDD13\\uD83D\\uDE19\\uD83D\\uDC9F\\uD83C\\uDF31\\uD83D\\uDE16\\uD83D\\uDC76\\uD83E\\uDD74\\u25B6\\u27A1\\u2753\\uD83D\\uDC8E\\uD83D\\uDCB8\\u2B07\\uD83D\\uDE28\\uD83C\\uDF1A\\uD83E\\uDD8B\\uD83D\\uDE37\\uD83D\\uDD7A\\u26A0\\uD83D\\uDE45\\uD83D\\uDE1F\\uD83D\\uDE35\\uD83D\\uDC4E\\uD83E\\uDD32\\uD83E\\uDD20\\uD83E\\uDD27\\uD83D\\uDCCC\\uD83D\\uDD35\\uD83D\\uDC85\\uD83E\\uDDD0\\uD83D\\uDC3E\\uD83C\\uDF52\\uD83D\\uDE17\\uD83E\\uDD11\\uD83C\\uDF0A\\uD83E\\uDD2F\\uD83D\\uDC37\\u260E\\uD83D\\uDCA7\\uD83D\\uDE2F\\uD83D\\uDC86\\uD83D\\uDC46\\uD83C\\uDFA4\\uD83D\\uDE47\\uD83C\\uDF51\\u2744\\uD83C\\uDF34\\uD83D\\uDCA3\\uD83D\\uDC38\\uD83D\\uDC8C\\uD83D\\uDCCD\\uD83E\\uDD40\\uD83E\\uDD22\\uD83D\\uDC45\\uD83D\\uDCA1\\uD83D\\uDCA9\\uD83D\\uDC50\\uD83D\\uDCF8\\uD83D\\uDC7B\\uD83E\\uDD10\\uD83E\\uDD2E\\uD83C\\uDFBC\\uD83E\\uDD75\\uD83D\\uDEA9\\uD83C\\uDF4E\\uD83C\\uDF4A\\uD83D\\uDC7C\\uD83D\\uDC8D\\uD83D\\uDCE3\\uD83E\\uDD42');\nconst alphabetBytesToChars = alphabet.reduce((p, c, i) => {\n  p[i] = c;\n  return p;\n}, []);\nconst alphabetCharsToBytes = alphabet.reduce((p, c, i) => {\n  p[c.codePointAt(0)] = i;\n  return p;\n}, []);\nfunction encode(data) {\n  return data.reduce((p, c) => {\n    p += alphabetBytesToChars[c];\n    return p;\n  }, '');\n}\nfunction decode(str) {\n  const byts = [];\n  for (const char of str) {\n    const byt = alphabetCharsToBytes[char.codePointAt(0)];\n    if (byt === undefined) {\n      throw new Error(`Non-base256emoji character: ${ char }`);\n    }\n    byts.push(byt);\n  }\n  return new Uint8Array(byts);\n}\nconst base256emoji = base.from({\n  prefix: '\\uD83D\\uDE80',\n  name: 'base256emoji',\n  encode,\n  decode\n});\n\nexports.base256emoji = base256emoji;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst textEncoder = new TextEncoder();\nconst textDecoder = new TextDecoder();\nconst name = 'json';\nconst code = 512;\nconst encode = node => textEncoder.encode(JSON.stringify(node));\nconst decode = data => JSON.parse(textDecoder.decode(data));\n\nexports.code = code;\nexports.decode = decode;\nexports.encode = encode;\nexports.name = name;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar hasher = require('./hasher.js');\n\nconst sha = name => async data => new Uint8Array(await crypto.subtle.digest(name, data));\nconst sha256 = hasher.from({\n  name: 'sha2-256',\n  code: 18,\n  encode: sha('SHA-256')\n});\nconst sha512 = hasher.from({\n  name: 'sha2-512',\n  code: 19,\n  encode: sha('SHA-512')\n});\n\nexports.sha256 = sha256;\nexports.sha512 = sha512;\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\nvar bytes = require('../bytes.js');\n\nconst identity = base.from({\n  prefix: '\\0',\n  name: 'identity',\n  encode: buf => bytes.toString(buf),\n  decode: str => bytes.fromString(str)\n});\n\nexports.identity = identity;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar bytes = require('../bytes.js');\n\nconst name = 'raw';\nconst code = 85;\nconst encode = node => bytes.coerce(node);\nconst decode = data => bytes.coerce(data);\n\nexports.code = code;\nexports.decode = decode;\nexports.encode = encode;\nexports.name = name;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar digest = require('./digest.js');\n\nconst from = ({name, code, encode}) => new Hasher(name, code, encode);\nclass Hasher {\n  constructor(name, code, encode) {\n    this.name = name;\n    this.code = code;\n    this.encode = encode;\n  }\n  digest(input) {\n    if (input instanceof Uint8Array) {\n      const result = this.encode(input);\n      return result instanceof Uint8Array ? digest.create(this.code, result) : result.then(digest$1 => digest.create(this.code, digest$1));\n    } else {\n      throw Error('Unknown type, must be binary type');\n    }\n  }\n}\n\nexports.Hasher = Hasher;\nexports.from = from;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar varint$1 = require('../vendor/varint.js');\n\nconst decode = (data, offset = 0) => {\n  const code = varint$1.decode(data, offset);\n  return [\n    code,\n    varint$1.decode.bytes\n  ];\n};\nconst encodeTo = (int, target, offset = 0) => {\n  varint$1.encode(int, target, offset);\n  return target;\n};\nconst encodingLength = int => {\n  return varint$1.encodingLength(int);\n};\n\nexports.decode = decode;\nexports.encodeTo = encodeTo;\nexports.encodingLength = encodingLength;\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nconst base64 = require('base64-js')\nconst ieee754 = require('ieee754')\nconst customInspectSymbol =\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n    : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nconst K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               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 * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    const arr = new Uint8Array(1)\n    const proto = { foo: function () { return 42 } }\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\n    Object.setPrototypeOf(arr, proto)\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  const buf = new Uint8Array(length)\n  Object.setPrototypeOf(buf, Buffer.prototype)\n  return buf\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\nfunction Buffer (arg, encodingOrOffset, length) {\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayView(value)\n  }\n\n  if (value == null) {\n    throw new TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof SharedArrayBuffer !== 'undefined' &&\n      (isInstance(value, SharedArrayBuffer) ||\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  const valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  const b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\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(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(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 interpreted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(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(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\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(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(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  const length = byteLength(string, encoding) | 0\n  let buf = createBuffer(length)\n\n  const actual = buf.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    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  const length = array.length < 0 ? 0 : checked(array.length) | 0\n  const buf = createBuffer(length)\n  for (let i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayView (arrayView) {\n  if (isInstance(arrayView, Uint8Array)) {\n    const copy = new Uint8Array(arrayView)\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n  }\n  return fromArrayLike(arrayView)\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  let buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(buf, Buffer.prototype)\n\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    const len = checked(obj.length) | 0\n    const buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return b != null && b._isBuffer === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\n  }\n\n  if (a === b) return 0\n\n  let x = a.length\n  let y = b.length\n\n  for (let 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 (!Array.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  let 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  const buffer = Buffer.allocUnsafe(length)\n  let pos = 0\n  for (i = 0; i < list.length; ++i) {\n    let buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      if (pos + buf.length > buffer.length) {\n        if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\n        buf.copy(buffer, pos)\n      } else {\n        Uint8Array.prototype.set.call(\n          buffer,\n          buf,\n          pos\n        )\n      }\n    } else if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    } else {\n      buf.copy(buffer, pos)\n    }\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  const len = string.length\n  const mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  let 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        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) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  let 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 coercion 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// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  const i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  const len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (let i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  const len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (let 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  const len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (let 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  const length = this.length\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.toLocaleString = Buffer.prototype.toString\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  let str = ''\n  const max = exports.INSPECT_MAX_BYTES\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\nif (customInspectSymbol) {\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\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  let x = thisEnd - thisStart\n  let y = end - start\n  const len = Math.min(x, y)\n\n  const thisCopy = this.slice(thisStart, thisEnd)\n  const targetCopy = target.slice(start, end)\n\n  for (let 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 (numberIsNaN(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 (Buffer.isBuffer(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 (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  let indexSize = 1\n  let arrLength = arr.length\n  let 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  let i\n  if (dir) {\n    let 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      let found = true\n      for (let 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  const 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  const strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  let i\n  for (i = 0; i < length; ++i) {\n    const parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (numberIsNaN(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 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  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  const 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  let 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      case 'latin1':\n      case 'binary':\n        return asciiWrite(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  const res = []\n\n  let i = start\n  while (i < end) {\n    const firstByte = buf[i]\n    let codePoint = null\n    let bytesPerSequence = (firstByte > 0xEF)\n      ? 4\n      : (firstByte > 0xDF)\n          ? 3\n          : (firstByte > 0xBF)\n              ? 2\n              : 1\n\n    if (i + bytesPerSequence <= end) {\n      let 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\nconst MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  const 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  let res = ''\n  let 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  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  const len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  let out = ''\n  for (let i = start; i < end; ++i) {\n    out += hexSliceLookupTable[buf[i]]\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  const bytes = buf.slice(start, end)\n  let res = ''\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n  for (let i = 0; i < bytes.length - 1; 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  const 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  const newBuf = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\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 =\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  let val = this[offset]\n  let mul = 1\n  let i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUintBE =\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  let val = this[offset + --byteLength]\n  let mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUint8 =\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUint16LE =\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUint16BE =\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUint32LE =\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  offset = offset >>> 0\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 =\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  offset = offset >>> 0\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.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const lo = first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24\n\n  const hi = this[++offset] +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    last * 2 ** 24\n\n  return BigInt(lo) + (BigInt(hi) << BigInt(32))\n})\n\nBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const hi = first * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  const lo = this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last\n\n  return (BigInt(hi) << BigInt(32)) + BigInt(lo)\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  let val = this[offset]\n  let mul = 1\n  let 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  let i = byteLength\n  let mul = 1\n  let 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  offset = offset >>> 0\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  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  offset = offset >>> 0\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  offset = offset >>> 0\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.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = this[offset + 4] +\n    this[offset + 5] * 2 ** 8 +\n    this[offset + 6] * 2 ** 16 +\n    (last << 24) // Overflow\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24)\n})\n\nBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = (first << 24) + // Overflow\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last)\n})\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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 =\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let mul = 1\n  let 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 =\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let i = byteLength - 1\n  let 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 =\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  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeUint16LE =\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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint16BE =\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  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint32LE =\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  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeUint32BE =\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  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nfunction wrtBigUInt64LE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  return offset\n}\n\nfunction wrtBigUInt64BE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset + 7] = lo\n  lo = lo >> 8\n  buf[offset + 6] = lo\n  lo = lo >> 8\n  buf[offset + 5] = lo\n  lo = lo >> 8\n  buf[offset + 4] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset + 3] = hi\n  hi = hi >> 8\n  buf[offset + 2] = hi\n  hi = hi >> 8\n  buf[offset + 1] = hi\n  hi = hi >> 8\n  buf[offset] = hi\n  return offset + 8\n}\n\nBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = 0\n  let mul = 1\n  let 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    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = byteLength - 1\n  let mul = 1\n  let 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 (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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\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  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\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  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\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  value = +value\n  offset = offset >>> 0\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  value = +value\n  offset = offset >>> 0\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 (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\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('Index out of range')\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  const len = end - start\n\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\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 (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    if (val.length === 1) {\n      const code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  } else if (typeof val === 'boolean') {\n    val = Number(val)\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  let i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    const bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    const len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// CUSTOM ERRORS\n// =============\n\n// Simplified versions from Node, changed for Buffer-only usage\nconst errors = {}\nfunction E (sym, getMessage, Base) {\n  errors[sym] = class NodeError extends Base {\n    constructor () {\n      super()\n\n      Object.defineProperty(this, 'message', {\n        value: getMessage.apply(this, arguments),\n        writable: true,\n        configurable: true\n      })\n\n      // Add the error code to the name to include it in the stack trace.\n      this.name = `${this.name} [${sym}]`\n      // Access the stack to generate the error message including the error code\n      // from the name.\n      this.stack // eslint-disable-line no-unused-expressions\n      // Reset the name to the actual name.\n      delete this.name\n    }\n\n    get code () {\n      return sym\n    }\n\n    set code (value) {\n      Object.defineProperty(this, 'code', {\n        configurable: true,\n        enumerable: true,\n        value,\n        writable: true\n      })\n    }\n\n    toString () {\n      return `${this.name} [${sym}]: ${this.message}`\n    }\n  }\n}\n\nE('ERR_BUFFER_OUT_OF_BOUNDS',\n  function (name) {\n    if (name) {\n      return `${name} is outside of buffer bounds`\n    }\n\n    return 'Attempt to access memory outside buffer bounds'\n  }, RangeError)\nE('ERR_INVALID_ARG_TYPE',\n  function (name, actual) {\n    return `The \"${name}\" argument must be of type number. Received type ${typeof actual}`\n  }, TypeError)\nE('ERR_OUT_OF_RANGE',\n  function (str, range, input) {\n    let msg = `The value of \"${str}\" is out of range.`\n    let received = input\n    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n      received = addNumericalSeparator(String(input))\n    } else if (typeof input === 'bigint') {\n      received = String(input)\n      if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\n        received = addNumericalSeparator(received)\n      }\n      received += 'n'\n    }\n    msg += ` It must be ${range}. Received ${received}`\n    return msg\n  }, RangeError)\n\nfunction addNumericalSeparator (val) {\n  let res = ''\n  let i = val.length\n  const start = val[0] === '-' ? 1 : 0\n  for (; i >= start + 4; i -= 3) {\n    res = `_${val.slice(i - 3, i)}${res}`\n  }\n  return `${val.slice(0, i)}${res}`\n}\n\n// CHECK FUNCTIONS\n// ===============\n\nfunction checkBounds (buf, offset, byteLength) {\n  validateNumber(offset, 'offset')\n  if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\n    boundsError(offset, buf.length - (byteLength + 1))\n  }\n}\n\nfunction checkIntBI (value, min, max, buf, offset, byteLength) {\n  if (value > max || value < min) {\n    const n = typeof min === 'bigint' ? 'n' : ''\n    let range\n    if (byteLength > 3) {\n      if (min === 0 || min === BigInt(0)) {\n        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`\n      } else {\n        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\n                `${(byteLength + 1) * 8 - 1}${n}`\n      }\n    } else {\n      range = `>= ${min}${n} and <= ${max}${n}`\n    }\n    throw new errors.ERR_OUT_OF_RANGE('value', range, value)\n  }\n  checkBounds(buf, offset, byteLength)\n}\n\nfunction validateNumber (value, name) {\n  if (typeof value !== 'number') {\n    throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\n  }\n}\n\nfunction boundsError (value, length, type) {\n  if (Math.floor(value) !== value) {\n    validateNumber(value, type)\n    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\n  }\n\n  if (length < 0) {\n    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\n  }\n\n  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\n                                    `>= ${type ? 1 : 0} and <= ${length}`,\n                                    value)\n}\n\n// HELPER FUNCTIONS\n// ================\n\nconst INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().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 utf8ToBytes (string, units) {\n  units = units || Infinity\n  let codePoint\n  const length = string.length\n  let leadSurrogate = null\n  const bytes = []\n\n  for (let 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  const byteArray = []\n  for (let 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  let c, hi, lo\n  const byteArray = []\n  for (let 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\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  let i\n  for (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\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nconst hexSliceLookupTable = (function () {\n  const alphabet = '0123456789abcdef'\n  const table = new Array(256)\n  for (let i = 0; i < 16; ++i) {\n    const i16 = i * 16\n    for (let j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j]\n    }\n  }\n  return table\n})()\n\n// Return not function with Error if BigInt not supported\nfunction defineBigIntMethod (fn) {\n  return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\n}\n\nfunction BufferBigIntNotDefined () {\n  throw new Error('BigInt not supported')\n}\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar identity = require('./bases/identity.js');\nvar base2 = require('./bases/base2.js');\nvar base8 = require('./bases/base8.js');\nvar base10 = require('./bases/base10.js');\nvar base16 = require('./bases/base16.js');\nvar base32 = require('./bases/base32.js');\nvar base36 = require('./bases/base36.js');\nvar base58 = require('./bases/base58.js');\nvar base64 = require('./bases/base64.js');\nvar base256emoji = require('./bases/base256emoji.js');\nvar sha2 = require('./hashes/sha2.js');\nvar identity$1 = require('./hashes/identity.js');\nvar raw = require('./codecs/raw.js');\nvar json = require('./codecs/json.js');\nrequire('./index.js');\nvar cid = require('./cid.js');\nvar hasher = require('./hashes/hasher.js');\nvar digest = require('./hashes/digest.js');\nvar varint = require('./varint.js');\nvar bytes = require('./bytes.js');\n\nconst bases = {\n  ...identity,\n  ...base2,\n  ...base8,\n  ...base10,\n  ...base16,\n  ...base32,\n  ...base36,\n  ...base58,\n  ...base64,\n  ...base256emoji\n};\nconst hashes = {\n  ...sha2,\n  ...identity$1\n};\nconst codecs = {\n  raw,\n  json\n};\n\nexports.CID = cid.CID;\nexports.hasher = hasher;\nexports.digest = digest;\nexports.varint = varint;\nexports.bytes = bytes;\nexports.bases = bases;\nexports.codecs = codecs;\nexports.hashes = hashes;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base10 = base.baseX({\n  prefix: '9',\n  name: 'base10',\n  alphabet: '0123456789'\n});\n\nexports.base10 = base10;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base2 = base.rfc4648({\n  prefix: '0',\n  name: 'base2',\n  alphabet: '01',\n  bitsPerChar: 1\n});\n\nexports.base2 = base2;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar cid = require('./cid.js');\nvar varint = require('./varint.js');\nvar bytes = require('./bytes.js');\nvar hasher = require('./hashes/hasher.js');\nvar digest = require('./hashes/digest.js');\n\n\n\nexports.CID = cid.CID;\nexports.varint = varint;\nexports.bytes = bytes;\nexports.hasher = hasher;\nexports.digest = digest;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar baseX$1 = require('../../vendor/base-x.js');\nvar bytes = require('../bytes.js');\n\nclass Encoder {\n  constructor(name, prefix, baseEncode) {\n    this.name = name;\n    this.prefix = prefix;\n    this.baseEncode = baseEncode;\n  }\n  encode(bytes) {\n    if (bytes instanceof Uint8Array) {\n      return `${ this.prefix }${ this.baseEncode(bytes) }`;\n    } else {\n      throw Error('Unknown type, must be binary type');\n    }\n  }\n}\nclass Decoder {\n  constructor(name, prefix, baseDecode) {\n    this.name = name;\n    this.prefix = prefix;\n    if (prefix.codePointAt(0) === undefined) {\n      throw new Error('Invalid prefix character');\n    }\n    this.prefixCodePoint = prefix.codePointAt(0);\n    this.baseDecode = baseDecode;\n  }\n  decode(text) {\n    if (typeof text === 'string') {\n      if (text.codePointAt(0) !== this.prefixCodePoint) {\n        throw Error(`Unable to decode multibase string ${ JSON.stringify(text) }, ${ this.name } decoder only supports inputs prefixed with ${ this.prefix }`);\n      }\n      return this.baseDecode(text.slice(this.prefix.length));\n    } else {\n      throw Error('Can only multibase decode strings');\n    }\n  }\n  or(decoder) {\n    return or(this, decoder);\n  }\n}\nclass ComposedDecoder {\n  constructor(decoders) {\n    this.decoders = decoders;\n  }\n  or(decoder) {\n    return or(this, decoder);\n  }\n  decode(input) {\n    const prefix = input[0];\n    const decoder = this.decoders[prefix];\n    if (decoder) {\n      return decoder.decode(input);\n    } else {\n      throw RangeError(`Unable to decode multibase string ${ JSON.stringify(input) }, only inputs prefixed with ${ Object.keys(this.decoders) } are supported`);\n    }\n  }\n}\nconst or = (left, right) => new ComposedDecoder({\n  ...left.decoders || { [left.prefix]: left },\n  ...right.decoders || { [right.prefix]: right }\n});\nclass Codec {\n  constructor(name, prefix, baseEncode, baseDecode) {\n    this.name = name;\n    this.prefix = prefix;\n    this.baseEncode = baseEncode;\n    this.baseDecode = baseDecode;\n    this.encoder = new Encoder(name, prefix, baseEncode);\n    this.decoder = new Decoder(name, prefix, baseDecode);\n  }\n  encode(input) {\n    return this.encoder.encode(input);\n  }\n  decode(input) {\n    return this.decoder.decode(input);\n  }\n}\nconst from = ({name, prefix, encode, decode}) => new Codec(name, prefix, encode, decode);\nconst baseX = ({prefix, name, alphabet}) => {\n  const {encode, decode} = baseX$1(alphabet, name);\n  return from({\n    prefix,\n    name,\n    encode,\n    decode: text => bytes.coerce(decode(text))\n  });\n};\nconst decode = (string, alphabet, bitsPerChar, name) => {\n  const codes = {};\n  for (let i = 0; i < alphabet.length; ++i) {\n    codes[alphabet[i]] = i;\n  }\n  let end = string.length;\n  while (string[end - 1] === '=') {\n    --end;\n  }\n  const out = new Uint8Array(end * bitsPerChar / 8 | 0);\n  let bits = 0;\n  let buffer = 0;\n  let written = 0;\n  for (let i = 0; i < end; ++i) {\n    const value = codes[string[i]];\n    if (value === undefined) {\n      throw new SyntaxError(`Non-${ name } character`);\n    }\n    buffer = buffer << bitsPerChar | value;\n    bits += bitsPerChar;\n    if (bits >= 8) {\n      bits -= 8;\n      out[written++] = 255 & buffer >> bits;\n    }\n  }\n  if (bits >= bitsPerChar || 255 & buffer << 8 - bits) {\n    throw new SyntaxError('Unexpected end of data');\n  }\n  return out;\n};\nconst encode = (data, alphabet, bitsPerChar) => {\n  const pad = alphabet[alphabet.length - 1] === '=';\n  const mask = (1 << bitsPerChar) - 1;\n  let out = '';\n  let bits = 0;\n  let buffer = 0;\n  for (let i = 0; i < data.length; ++i) {\n    buffer = buffer << 8 | data[i];\n    bits += 8;\n    while (bits > bitsPerChar) {\n      bits -= bitsPerChar;\n      out += alphabet[mask & buffer >> bits];\n    }\n  }\n  if (bits) {\n    out += alphabet[mask & buffer << bitsPerChar - bits];\n  }\n  if (pad) {\n    while (out.length * bitsPerChar & 7) {\n      out += '=';\n    }\n  }\n  return out;\n};\nconst rfc4648 = ({name, prefix, bitsPerChar, alphabet}) => {\n  return from({\n    prefix,\n    name,\n    encode(input) {\n      return encode(input, alphabet, bitsPerChar);\n    },\n    decode(input) {\n      return decode(input, alphabet, bitsPerChar, name);\n    }\n  });\n};\n\nexports.Codec = Codec;\nexports.baseX = baseX;\nexports.from = from;\nexports.or = or;\nexports.rfc4648 = rfc4648;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst empty = new Uint8Array(0);\nconst toHex = d => d.reduce((hex, byte) => hex + byte.toString(16).padStart(2, '0'), '');\nconst fromHex = hex => {\n  const hexes = hex.match(/../g);\n  return hexes ? new Uint8Array(hexes.map(b => parseInt(b, 16))) : empty;\n};\nconst equals = (aa, bb) => {\n  if (aa === bb)\n    return true;\n  if (aa.byteLength !== bb.byteLength) {\n    return false;\n  }\n  for (let ii = 0; ii < aa.byteLength; ii++) {\n    if (aa[ii] !== bb[ii]) {\n      return false;\n    }\n  }\n  return true;\n};\nconst coerce = o => {\n  if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')\n    return o;\n  if (o instanceof ArrayBuffer)\n    return new Uint8Array(o);\n  if (ArrayBuffer.isView(o)) {\n    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);\n  }\n  throw new Error('Unknown type, must be binary type');\n};\nconst isBinary = o => o instanceof ArrayBuffer || ArrayBuffer.isView(o);\nconst fromString = str => new TextEncoder().encode(str);\nconst toString = b => new TextDecoder().decode(b);\n\nexports.coerce = coerce;\nexports.empty = empty;\nexports.equals = equals;\nexports.fromHex = fromHex;\nexports.fromString = fromString;\nexports.isBinary = isBinary;\nexports.toHex = toHex;\nexports.toString = toString;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar base = require('./base.js');\n\nconst base58btc = base.baseX({\n  name: 'base58btc',\n  prefix: 'z',\n  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n});\nconst base58flickr = base.baseX({\n  name: 'base58flickr',\n  prefix: 'Z',\n  alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'\n});\n\nexports.base58btc = base58btc;\nexports.base58flickr = base58flickr;\n","let urlAlphabet =\n  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'\nlet customAlphabet = (alphabet, defaultSize = 21) => {\n  return (size = defaultSize) => {\n    let id = ''\n    let i = size\n    while (i--) {\n      id += alphabet[(Math.random() * alphabet.length) | 0]\n    }\n    return id\n  }\n}\nlet nanoid = (size = 21) => {\n  let id = ''\n  let i = size\n  while (i--) {\n    id += urlAlphabet[(Math.random() * 64) | 0]\n  }\n  return id\n}\nexport { nanoid, customAlphabet }\n","'use strict';\n\nvar objectAssign = require('object-assign');\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\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 */\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}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n// NB: The URL to the CommonJS spec is kept just for tradition.\n//     node-assert has evolved a lot since then, both in API and behavior.\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.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\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\nvar assert = module.exports = ok;\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 (!util.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 = 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\nutil.inherits(assert.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 || !util.isFunction(something)) {\n    return util.inspect(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\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.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\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.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);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.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 (util.isDate(actual) && util.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 (util.isRegExp(actual) && util.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 (util.isPrimitive(a) || util.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);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction 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);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.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);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.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 && util.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);\n\nassert.throws = function(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 = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\n// Expose a strict only variant of assert\nfunction strict(value, message) {\n  if (!value) fail(value, true, message, '==', strict);\n}\nassert.strict = objectAssign(strict, assert, {\n  equal: assert.strictEqual,\n  deepEqual: assert.deepStrictEqual,\n  notEqual: assert.notStrictEqual,\n  notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;\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","// 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\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n  function getOwnPropertyDescriptors(obj) {\n    var keys = Object.keys(obj);\n    var descriptors = {};\n    for (var i = 0; i < keys.length; i++) {\n      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n    }\n    return descriptors;\n  };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(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.\nexports.deprecate = function(fn, msg) {\n  if (typeof process !== 'undefined' && process.noDeprecation === true) {\n    return fn;\n  }\n\n  // Allow for deprecating things in the process of starting up.\n  if (typeof process === 'undefined') {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\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;\nexports.debuglog = function(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 = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, 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*/\nfunction 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    exports._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}\nexports.inspect = inspect;\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 !== exports.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()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction 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}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\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\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, 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 */\nexports.inherits = require('inherits');\n\nexports._extend = function(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\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n  if (typeof original !== 'function')\n    throw new TypeError('The \"original\" argument must be of type Function');\n\n  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n    var fn = original[kCustomPromisifiedSymbol];\n    if (typeof fn !== 'function') {\n      throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n    }\n    Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n      value: fn, enumerable: false, writable: false, configurable: true\n    });\n    return fn;\n  }\n\n  function fn() {\n    var promiseResolve, promiseReject;\n    var promise = new Promise(function (resolve, reject) {\n      promiseResolve = resolve;\n      promiseReject = reject;\n    });\n\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n    args.push(function (err, value) {\n      if (err) {\n        promiseReject(err);\n      } else {\n        promiseResolve(value);\n      }\n    });\n\n    try {\n      original.apply(this, args);\n    } catch (err) {\n      promiseReject(err);\n    }\n\n    return promise;\n  }\n\n  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n\n  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n    value: fn, enumerable: false, writable: false, configurable: true\n  });\n  return Object.defineProperties(\n    fn,\n    getOwnPropertyDescriptors(original)\n  );\n}\n\nexports.promisify.custom = kCustomPromisifiedSymbol\n\nfunction callbackifyOnRejected(reason, cb) {\n  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n  // Because `null` is a special error value in callbacks which means \"no error\n  // occurred\", we error-wrap so the callback consumer can distinguish between\n  // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n  if (!reason) {\n    var newReason = new Error('Promise was rejected with a falsy value');\n    newReason.reason = reason;\n    reason = newReason;\n  }\n  return cb(reason);\n}\n\nfunction callbackify(original) {\n  if (typeof original !== 'function') {\n    throw new TypeError('The \"original\" argument must be of type Function');\n  }\n\n  // We DO NOT return the promise as it gives the user a false sense that\n  // the promise is actually somehow related to the callback's execution\n  // and that the callback throwing will reject the promise.\n  function callbackified() {\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    var maybeCb = args.pop();\n    if (typeof maybeCb !== 'function') {\n      throw new TypeError('The last argument must be of type Function');\n    }\n    var self = this;\n    var cb = function() {\n      return maybeCb.apply(self, arguments);\n    };\n    // In true node style we process the callback on `nextTick` with all the\n    // implications (stack, `uncaughtException`, `async_hooks`)\n    original.apply(this, args)\n      .then(function(ret) { process.nextTick(cb, null, ret) },\n            function(rej) { process.nextTick(callbackifyOnRejected, rej, cb) });\n  }\n\n  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n  Object.defineProperties(callbackified,\n                          getOwnPropertyDescriptors(original));\n  return callbackified;\n}\nexports.callbackify = callbackify;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar varint = require('./varint.js');\nvar digest = require('./hashes/digest.js');\nvar base58 = require('./bases/base58.js');\nvar base32 = require('./bases/base32.js');\nvar bytes = require('./bytes.js');\n\nclass CID {\n  constructor(version, code, multihash, bytes) {\n    this.code = code;\n    this.version = version;\n    this.multihash = multihash;\n    this.bytes = bytes;\n    this.byteOffset = bytes.byteOffset;\n    this.byteLength = bytes.byteLength;\n    this.asCID = this;\n    this._baseCache = new Map();\n    Object.defineProperties(this, {\n      byteOffset: hidden,\n      byteLength: hidden,\n      code: readonly,\n      version: readonly,\n      multihash: readonly,\n      bytes: readonly,\n      _baseCache: hidden,\n      asCID: hidden\n    });\n  }\n  toV0() {\n    switch (this.version) {\n    case 0: {\n        return this;\n      }\n    default: {\n        const {code, multihash} = this;\n        if (code !== DAG_PB_CODE) {\n          throw new Error('Cannot convert a non dag-pb CID to CIDv0');\n        }\n        if (multihash.code !== SHA_256_CODE) {\n          throw new Error('Cannot convert non sha2-256 multihash CID to CIDv0');\n        }\n        return CID.createV0(multihash);\n      }\n    }\n  }\n  toV1() {\n    switch (this.version) {\n    case 0: {\n        const {code, digest: digest$1} = this.multihash;\n        const multihash = digest.create(code, digest$1);\n        return CID.createV1(this.code, multihash);\n      }\n    case 1: {\n        return this;\n      }\n    default: {\n        throw Error(`Can not convert CID version ${ this.version } to version 0. This is a bug please report`);\n      }\n    }\n  }\n  equals(other) {\n    return other && this.code === other.code && this.version === other.version && digest.equals(this.multihash, other.multihash);\n  }\n  toString(base) {\n    const {bytes, version, _baseCache} = this;\n    switch (version) {\n    case 0:\n      return toStringV0(bytes, _baseCache, base || base58.base58btc.encoder);\n    default:\n      return toStringV1(bytes, _baseCache, base || base32.base32.encoder);\n    }\n  }\n  toJSON() {\n    return {\n      code: this.code,\n      version: this.version,\n      hash: this.multihash.bytes\n    };\n  }\n  get [Symbol.toStringTag]() {\n    return 'CID';\n  }\n  [Symbol.for('nodejs.util.inspect.custom')]() {\n    return 'CID(' + this.toString() + ')';\n  }\n  static isCID(value) {\n    deprecate(/^0\\.0/, IS_CID_DEPRECATION);\n    return !!(value && (value[cidSymbol] || value.asCID === value));\n  }\n  get toBaseEncodedString() {\n    throw new Error('Deprecated, use .toString()');\n  }\n  get codec() {\n    throw new Error('\"codec\" property is deprecated, use integer \"code\" property instead');\n  }\n  get buffer() {\n    throw new Error('Deprecated .buffer property, use .bytes to get Uint8Array instead');\n  }\n  get multibaseName() {\n    throw new Error('\"multibaseName\" property is deprecated');\n  }\n  get prefix() {\n    throw new Error('\"prefix\" property is deprecated');\n  }\n  static asCID(value) {\n    if (value instanceof CID) {\n      return value;\n    } else if (value != null && value.asCID === value) {\n      const {version, code, multihash, bytes} = value;\n      return new CID(version, code, multihash, bytes || encodeCID(version, code, multihash.bytes));\n    } else if (value != null && value[cidSymbol] === true) {\n      const {version, multihash, code} = value;\n      const digest$1 = digest.decode(multihash);\n      return CID.create(version, code, digest$1);\n    } else {\n      return null;\n    }\n  }\n  static create(version, code, digest) {\n    if (typeof code !== 'number') {\n      throw new Error('String codecs are no longer supported');\n    }\n    switch (version) {\n    case 0: {\n        if (code !== DAG_PB_CODE) {\n          throw new Error(`Version 0 CID must use dag-pb (code: ${ DAG_PB_CODE }) block encoding`);\n        } else {\n          return new CID(version, code, digest, digest.bytes);\n        }\n      }\n    case 1: {\n        const bytes = encodeCID(version, code, digest.bytes);\n        return new CID(version, code, digest, bytes);\n      }\n    default: {\n        throw new Error('Invalid version');\n      }\n    }\n  }\n  static createV0(digest) {\n    return CID.create(0, DAG_PB_CODE, digest);\n  }\n  static createV1(code, digest) {\n    return CID.create(1, code, digest);\n  }\n  static decode(bytes) {\n    const [cid, remainder] = CID.decodeFirst(bytes);\n    if (remainder.length) {\n      throw new Error('Incorrect length');\n    }\n    return cid;\n  }\n  static decodeFirst(bytes$1) {\n    const specs = CID.inspectBytes(bytes$1);\n    const prefixSize = specs.size - specs.multihashSize;\n    const multihashBytes = bytes.coerce(bytes$1.subarray(prefixSize, prefixSize + specs.multihashSize));\n    if (multihashBytes.byteLength !== specs.multihashSize) {\n      throw new Error('Incorrect length');\n    }\n    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);\n    const digest$1 = new digest.Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);\n    const cid = specs.version === 0 ? CID.createV0(digest$1) : CID.createV1(specs.codec, digest$1);\n    return [\n      cid,\n      bytes$1.subarray(specs.size)\n    ];\n  }\n  static inspectBytes(initialBytes) {\n    let offset = 0;\n    const next = () => {\n      const [i, length] = varint.decode(initialBytes.subarray(offset));\n      offset += length;\n      return i;\n    };\n    let version = next();\n    let codec = DAG_PB_CODE;\n    if (version === 18) {\n      version = 0;\n      offset = 0;\n    } else if (version === 1) {\n      codec = next();\n    }\n    if (version !== 0 && version !== 1) {\n      throw new RangeError(`Invalid CID version ${ version }`);\n    }\n    const prefixSize = offset;\n    const multihashCode = next();\n    const digestSize = next();\n    const size = offset + digestSize;\n    const multihashSize = size - prefixSize;\n    return {\n      version,\n      codec,\n      multihashCode,\n      digestSize,\n      multihashSize,\n      size\n    };\n  }\n  static parse(source, base) {\n    const [prefix, bytes] = parseCIDtoBytes(source, base);\n    const cid = CID.decode(bytes);\n    cid._baseCache.set(prefix, source);\n    return cid;\n  }\n}\nconst parseCIDtoBytes = (source, base) => {\n  switch (source[0]) {\n  case 'Q': {\n      const decoder = base || base58.base58btc;\n      return [\n        base58.base58btc.prefix,\n        decoder.decode(`${ base58.base58btc.prefix }${ source }`)\n      ];\n    }\n  case base58.base58btc.prefix: {\n      const decoder = base || base58.base58btc;\n      return [\n        base58.base58btc.prefix,\n        decoder.decode(source)\n      ];\n    }\n  case base32.base32.prefix: {\n      const decoder = base || base32.base32;\n      return [\n        base32.base32.prefix,\n        decoder.decode(source)\n      ];\n    }\n  default: {\n      if (base == null) {\n        throw Error('To parse non base32 or base58btc encoded CID multibase decoder must be provided');\n      }\n      return [\n        source[0],\n        base.decode(source)\n      ];\n    }\n  }\n};\nconst toStringV0 = (bytes, cache, base) => {\n  const {prefix} = base;\n  if (prefix !== base58.base58btc.prefix) {\n    throw Error(`Cannot string encode V0 in ${ base.name } encoding`);\n  }\n  const cid = cache.get(prefix);\n  if (cid == null) {\n    const cid = base.encode(bytes).slice(1);\n    cache.set(prefix, cid);\n    return cid;\n  } else {\n    return cid;\n  }\n};\nconst toStringV1 = (bytes, cache, base) => {\n  const {prefix} = base;\n  const cid = cache.get(prefix);\n  if (cid == null) {\n    const cid = base.encode(bytes);\n    cache.set(prefix, cid);\n    return cid;\n  } else {\n    return cid;\n  }\n};\nconst DAG_PB_CODE = 112;\nconst SHA_256_CODE = 18;\nconst encodeCID = (version, code, multihash) => {\n  const codeOffset = varint.encodingLength(version);\n  const hashOffset = codeOffset + varint.encodingLength(code);\n  const bytes = new Uint8Array(hashOffset + multihash.byteLength);\n  varint.encodeTo(version, bytes, 0);\n  varint.encodeTo(code, bytes, codeOffset);\n  bytes.set(multihash, hashOffset);\n  return bytes;\n};\nconst cidSymbol = Symbol.for('@ipld/js-cid/CID');\nconst readonly = {\n  writable: false,\n  configurable: false,\n  enumerable: true\n};\nconst hidden = {\n  writable: false,\n  enumerable: false,\n  configurable: false\n};\nconst version = '0.0.0-dev';\nconst deprecate = (range, message) => {\n  if (range.test(version)) {\n    console.warn(message);\n  } else {\n    throw new Error(message);\n  }\n};\nconst IS_CID_DEPRECATION = `CID.isCID(v) is deprecated and will be removed in the next major release.\nFollowing code pattern:\n\nif (CID.isCID(value)) {\n  doSomethingWithCID(value)\n}\n\nIs replaced with:\n\nconst cid = CID.asCID(value)\nif (cid) {\n  // Make sure to use cid instead of value\n  doSomethingWithCID(cid)\n}\n`;\n\nexports.CID = CID;\n"],"sourceRoot":""}