{"version":3,"sources":["webpack:///./node_modules/readable-stream/duplex-browser.js","webpack:///./node_modules/url/url.js","webpack:///./node_modules/cbor/lib/tagged.js","webpack:///../../../src/components/VDialog/VDialog.ts","webpack:///./node_modules/cbor/lib/commented.js","webpack:///./node_modules/node-libs-browser/node_modules/punycode/punycode.js","webpack:///../../../src/components/VOverlay/index.ts","webpack:///./node_modules/base64-js/index.js","webpack:///./node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/util/node_modules/inherits/inherits_browser.js","webpack:///./node_modules/readable-stream/writable-browser.js","webpack:///./src/utils/helpers.js","webpack:///./node_modules/util/util.js","webpack:///./node_modules/url/util.js","webpack:///./node_modules/core-util-is/lib/util.js","webpack:///./node_modules/inherits/inherits_browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///../../../src/components/VRadioGroup/VRadioGroup.ts","webpack:///./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/cbor/lib/diagnose.js","webpack:///./node_modules/cbor/vendor/binary-parse-stream/index.js","webpack:///../../../src/mixins/rippleable/index.ts","webpack:///./node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack:///../../../src/components/VRadioGroup/VRadio.ts","webpack:///./node_modules/cbor/lib/utils.js","webpack:///./node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./node_modules/cbor/lib/encoder.js","webpack:///./node_modules/nofilter/lib/index.js","webpack:///./node_modules/safe-buffer/index.js","webpack:///./node_modules/cbor/lib/cbor.js","webpack:///./node_modules/bignumber.js/bignumber.js","webpack:///./node_modules/ieee754/index.js","webpack:///./node_modules/querystring-es3/decode.js","webpack:///./node_modules/process-nextick-args/index.js","webpack:///../../../src/components/VGrid/grid.ts","webpack:///../../../src/components/VGrid/VContainer.ts","webpack:///../../../src/components/VOverlay/VOverlay.ts","webpack:///./node_modules/cbor/lib/decoder.js","webpack:///./node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/querystring-es3/index.js","webpack:///./node_modules/buffer/index.js","webpack:///./node_modules/util-deprecate/browser.js","webpack:///./node_modules/cbor/lib/map.js","webpack:///./node_modules/cbor/lib/simple.js","webpack:///./node_modules/readable-stream/passthrough.js","webpack:///./node_modules/readable-stream/transform.js","webpack:///./node_modules/stream-browserify/index.js","webpack:///./node_modules/util/support/isBufferBrowser.js","webpack:///./node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/querystring-es3/encode.js","webpack:///./node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/isarray/index.js","webpack:///./src/utils/base64url-arraybuffer.js","webpack:///../../../src/mixins/overlayable/index.ts","webpack:///./node_modules/cbor/lib/constants.js","webpack:///./node_modules/events/events.js","webpack:///../../../src/mixins/selectable/index.ts"],"names":["module","exports","punycode","util","Url","this","protocol","slashes","auth","host","port","hostname","hash","search","query","pathname","path","href","parse","urlParse","resolve","urlResolve","resolveObject","urlResolveObject","format","urlFormat","protocolPattern","portPattern","simplePathPattern","delims","unwise","concat","autoEscape","nonHostChars","hostEndingChars","hostnameMaxLen","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","url","parseQueryString","slashesDenoteHost","isObject","u","obj","isString","prototype","call","source","relative","TypeError","queryIndex","indexOf","splitter","uSplit","split","slashRegex","replace","join","rest","trim","length","simplePath","exec","substr","proto","lowerProto","toLowerCase","match","atSign","hostEnd","i","hec","lastIndexOf","slice","decodeURIComponent","parseHost","ipv6Hostname","hostparts","l","part","newpart","j","k","charCodeAt","validParts","notHost","bit","push","unshift","toASCII","p","h","ae","esc","encodeURIComponent","escape","qm","s","Object","keys","stringify","charAt","rel","result","tkeys","tk","tkey","rkeys","rk","rkey","v","relPath","shift","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","pop","isNullOrUndefined","authInHost","isNull","last","hasTrailingSlash","up","splice","isAbsolute","bignumber","BigNumber","utils","MINUS_ONE","TWO","Tagged","tag","value","err","Error","JSON","gen","_pushTag","pushAny","converters","f","error","Date","bufferToBignumber","minus","shiftedBy","pow","times","RegExp","baseMixins","name","directives","ClickOutside","props","dark","disabled","fullscreen","light","maxWidth","type","String","default","noClickAnimation","origin","persistent","retainFocus","scrollable","transition","width","activatedBy","animate","animateTimeout","isActive","stackMinZIndex","previousActiveElement","computed","contentClass","Boolean","$slots","$scopedSlots","watch","$attrs","hasOwnProperty","window","unbind","methods","target","e","_isDestroyed","$refs","content","contains","overlay","$el","activeZIndex","document","getOpenDependents","activator","getOpenDependentElements","some","el","focusable","querySelectorAll","showLazyContent","$createElement","root","class","attrs","role","tabindex","getScopeIdAttrs","on","keydown","onKeydown","style","zIndex","ref","appear","data","handler","closeConditional","include","transformOrigin","undefined","staticClass","attach","stream","Decoder","constants","NoFilter","MT","NUMBYTES","SYMS","plural","c","Commented","Transform","options","opts","assign","depth","max_depth","no_summary","readableObjectMode","writableObjectMode","super","all","tags","24","_tag_24","bind","parser","_on_value","_on_start","_on_start_string","_on_stop","_on_more","_on_error","_on_data","bs","_on_read","b","er","emit","end","fresh","encoding","cb","write","_flush","input","ref1","ref2","d","toString","Promise","reject","pipe","buf","hex","Array","ind","mt","len","parent_mt","pos","desc","POS_INT","NEG_INT","ARRAY","MAP","BYTE_STRING","UTF8_STRING","SIMPLE_FLOAT","BREAK","Math","floor","TAG","STREAM","val","ai","NULL","UNDEFINED","Buffer","isBuffer","inspect","ONE","FOUR","EIGHT","read","nodeType","freeGlobal","global","self","maxInt","base","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexPunycode","regexNonASCII","regexSeparators","errors","baseMinusTMin","stringFromCharCode","fromCharCode","RangeError","map","array","fn","mapDomain","string","parts","labels","encoded","ucs2decode","extra","output","counter","ucs2encode","basicToDigit","codePoint","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","decode","out","basic","index","oldi","w","t","baseMinusT","inputLength","n","bias","encode","handledCPCount","basicLength","m","q","currentValue","handledCPCountPlusOne","qMinusT","toUnicode","test","byteLength","toByteArray","fromByteArray","lookup","revLookup","Arr","Uint8Array","code","getLens","b64","validLen","placeHoldersLen","lens","_byteLength","tmp","arr","curByte","tripletToBase64","num","encodeChunk","uint8","start","extraBytes","maxChunkLength","len2","Duplex","create","afterTransform","ts","_transformState","transforming","writecb","writechunk","rs","_readableState","reading","needReadable","highWaterMark","_read","needTransform","writeencoding","sync","transform","_transform","flush","prefinish","_this","done","_writableState","inherits","chunk","_write","_destroy","_this2","err2","ctor","superCtor","super_","constructor","enumerable","writable","configurable","TempCtor","preformatMakeCredReq","makeCredReq","challenge","base64url","user","id","excludeCredentials","publicKeyCredentialToJSON","pubKeyCred","ArrayBuffer","key","getOwnPropertyDescriptors","descriptors","getOwnPropertyDescriptor","formatRegExp","objects","arguments","args","str","x","Number","_","deprecate","msg","process","noDeprecation","apply","warned","deprecated","throwDeprecation","traceDeprecation","console","trace","debugEnviron","debugs","ctx","seen","stylize","stylizeNoColor","colors","isBoolean","showHidden","_extend","isUndefined","customInspect","stylizeWithColor","formatValue","styleType","styles","arrayToHash","forEach","idx","recurseTimes","isFunction","ret","primitive","formatPrimitive","visibleKeys","getOwnPropertyNames","isError","formatError","isRegExp","isDate","braces","isArray","toUTCString","formatArray","formatProperty","reduceToSingleString","simple","isNumber","get","set","line","reduce","prev","cur","numLinesEst","ar","arg","isSymbol","re","objectToString","isPrimitive","o","pad","debuglog","NODE_DEBUG","toUpperCase","pid","months","timestamp","time","getHours","getMinutes","getSeconds","getDate","getMonth","prop","log","add","kCustomPromisifiedSymbol","Symbol","callbackifyOnRejected","reason","newReason","callbackify","original","callbackified","maybeCb","then","nextTick","rej","setPrototypeOf","getPrototypeOf","defineProperties","promisify","defineProperty","promiseResolve","promiseReject","promise","custom","EventEmitter","radioGroup","column","height","row","computedId","render","label","onClick","pna","destroy","readableDestroyed","destroyed","writableDestroyed","errorEmitted","emitErrorNT","undestroy","ended","endEmitted","ending","finished","Diagnose","separator","stream_errors","float_bytes","encod","guessEncoding","extend","2","4","8","_fore","fb","Stream","TransformStream","BinaryParseStream","objectMode","__restart","__needed","__parser","next","__fresh","_parse","ripple","center","_classCallCheck","instance","Constructor","copyBuffer","src","offset","copy","BufferList","head","tail","entry","clear","alloc","allocUnsafe","inheritAttrs","offIcon","onIcon","readonly","isFocused","groupClasses","hasLabel","_uid","click","for","color","focused","hasState","setTextColor","dense","genInput","attrs$","genRipple","isDisabled","onChange","SHIFT32","MAX_SAFE_HIGH","hasBigInt","BigInt","TD","TextDecoder","td","fatal","ignoreBOM","utf8","checksUTF8","parseCBORint","readUInt8","readUInt16BE","readUInt32BE","g","plus","writeHalf","half","u32","writeFloatBE","s16","exp","mant","writeUInt16BE","parseHalf","sign","parseCBORfloat","readFloatBE","readDoubleBE","from","bin","chunks","parseInt","old","adds","a","arrayEqual","every","elem","bufferEqual","byte","toBigInt","bigIntize","bufferToBigInt","PassThrough","isEncoding","_normalizeEncoding","enc","retried","normalizeEncoding","nenc","StringDecoder","nb","text","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","utf8CheckIncomplete","utf8CheckExtraBytes","r","utf8Text","total","utf8End","HALF","FLOAT","DOUBLE","TRUE","SIMPLE","FALSE","BI","BN","BUF_NAN","BUF_INF_NEG","BUF_INF_POS","BUF_NEG_ZERO","LOOP_DETECT","Encoder","canonical","encodeUndefined","disallowUndefinedKeys","dateType","collapseBigIntegers","detectLoops","semanticTypes","_pushArray","_pushDate","_pushBuffer","Map","_pushMap","_pushNoFilter","_pushRegexp","Set","_pushSet","_pushBigNumber","_pushUint8Array","Uint8ClampedArray","Uint16Array","Uint32Array","Int8Array","Int16Array","Int32Array","Float32Array","_pushFloat32Array","Float64Array","_pushFloat64Array","addSemanticType","_pushUrl","_pushURL","addTypes","genTypes","fun","typeName","writeUInt8","writeUInt32BE","writeDoubleBE","b2","_pushUInt8","fround","_pushFloatBE","_pushDoubleBE","orig","_pushUInt16BE","_pushUInt32BE","MAX_SAFE_INTEGER","_pushFloat","is","_pushInt","isNaN","_pushNaN","isFinite","_pushInfinity","round","_pushIntNum","indefinite","INDEFINITE","DATE_STRING","_pushString","toISOString","DATE_EPOCH","REGEXP","size","URI","POS_BIGINT","isNegative","negated","NEG_BIGINT","lte","MAXINT64","MAXINT32","toNumber","dividedToIntegerBy","mod","Infinity","isInteger","_pushBigint","DECIMAL_FRAC","dec","decimalPlaces","slide","abs","isLessThan","MAXINT","entries","readableHighWaterMark","sort","a_cbor","b_cbor","compare","removeLoopDetectors","detector","dl","_pushNull","skipTypes","encodeCBOR","converter","filter","cbor_keys","ck","_pushNumber","_pushJSBigint","_pushBoolean","_pushUndefined","_pushObject","objs","chunkSize","objType","endIndex","_encodeAll","bufs","inputEncoding","inp","inpE","watchPipe","readError","readable","om","nf1","nf2","list","tot","nf","allBufs","allObjs","callback","buffer","other","buf1","buf2","_bufArray","toJSON","sz","mask","_read_gen","meth","_write_gen","writeUInt16LE","writeUInt32LE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeDoubleLE","readUInt16LE","readUInt32LE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readDoubleLE","copyProps","dst","SafeBuffer","encodingOrOffset","allocUnsafeSlow","fill","SlowBuffer","Simple","comment","decodeAll","decodeFirst","decodeAllSync","decodeFirstSync","diagnose","encodeCanonical","encodeOne","encodeAsync","leveldb","globalObject","isNumeric","mathceil","ceil","mathfloor","bignumberError","tooManyDigits","BASE","LOG_BASE","POWS_TEN","SQRT_BASE","MAX","clone","configObject","div","convertBase","parseNumeric","P","valueOf","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","prefix","groupSize","secondaryGroupSize","groupSeparator","decimalSeparator","fractionGroupSize","fractionGroupSeparator","suffix","ALPHABET","alphabet","caseChanged","isNum","_isBigNumber","substring","intCheck","DEBUG","rm","c0","ne","coeffToString","toExponential","toFixedPoint","maxOrMin","method","normalise","sd","ni","rd","xc","pows10","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","max","lt","minimum","min","gt","random","pow2_53","random53bitInt","dp","rand","sum","decimal","toBaseOut","baseIn","baseOut","arrL","reverse","callerIsToString","y","multiply","temp","xlo","xhi","carry","klo","khi","aL","bL","cmp","subtract","more","prod","prodL","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","yc","NaN","bitFloor","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","p1","p2","absoluteValue","comparedTo","dividedBy","idiv","exponentiatedBy","isModExp","nIsBig","nIsNeg","nIsOdd","isOdd","integerValue","isEqualTo","eq","isGreaterThan","isGreaterThanOrEqualTo","gte","isLessThanOrEqualTo","isPositive","isZero","xLTy","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","precision","squareRoot","sqrt","rep","toFixed","toFormat","g1","g2","intPart","fractionPart","isNeg","intDigits","toFraction","md","d0","d1","d2","n0","n1","toPrecision","z","zs","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","rt","LN2","qs","sep","regexp","maxKeys","kstr","vstr","xs","arg1","arg2","arg3","version","functional","children","classes","fluid","mergeData","absolute","opacity","setBackgroundColor","computedOpacity","themeClasses","COUNT","MAJOR","ERROR","NOT_FOUND","parentArray","parent","typ","count","PARENT","parentBufferStream","_tag_2","_tag_3","bigI","bigint","running","Readable","state","nullcheck","nextByte","res","required","close","once","vals","octet","parent_major","parent_length","numbytes","NEG_MAX","hasParent","again","pm","allstrings","convert","ReadableState","EElistenerCount","emitter","listeners","OurUint8Array","_uint8ArrayToBuffer","_isUint8Array","debugUtil","debug","destroyImpl","kProxyEvents","prependListener","event","_events","isDuplex","hwm","readableHwm","defaultHwm","pipes","pipesCount","flowing","emittedReadable","readableListening","resumeScheduled","defaultEncoding","awaitDrain","readingMore","decoder","readableAddChunk","addToFront","skipChunkCheck","onEofChunk","chunkInvalid","addChunk","maybeReadMore","needMoreData","emitReadable","_undestroy","isPaused","setEncoding","MAX_HWM","computeNewHighWaterMark","howMuchToRead","emitReadable_","flow","maybeReadMore_","pipeOnDrain","nReadingNextTick","resume","resume_","fromList","fromListPartial","hasStrings","copyFromBufferString","copyFromBuffer","endReadable","endReadableNT","nOrig","doRead","dest","pipeOpts","doEnd","stdout","stderr","endFn","onend","unpipe","onunpipe","unpipeInfo","hasUnpiped","cleanup","ondrain","cleanedUp","removeListener","onclose","onfinish","onerror","ondata","needDrain","increasedAwaitDrain","pause","dests","ev","addListener","wrap","paused","_fromList","objectKeys","Writable","allowHalfOpen","onEndNT","base64","ieee754","typedArraySupport","__proto__","foo","subarray","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","fromArrayBuffer","fromString","fromObject","assertSize","checked","actual","fromArrayLike","byteOffset","isnan","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","dir","arrayIndexOf","indexSize","arrLength","valLength","foundIndex","found","hexWrite","remaining","strLen","parsed","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","bytesPerSequence","decodeCodePointsArray","INSPECT_MAX_BYTES","poolSize","_augment","species","_isBuffer","swap16","swap32","swap64","equals","thisStart","thisEnd","thisCopy","targetCopy","includes","_arr","MAX_ARGUMENTS_LENGTH","codePoints","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readIntLE","readIntBE","writeUIntLE","maxBytes","writeUIntBE","writeIntLE","limit","sub","writeIntBE","targetStart","INVALID_BASE64_RE","base64clean","stringtrim","units","leadSurrogate","byteArray","hi","lo","warn","localStorage","encoder","CborMap","iterable","_encode","delete","has","_decode","kv","iterator","thisArg","has_parent","parent_indefinite","EE","_isStdio","didOnEnd","listenerCount","CorkedRequest","finish","onCorkedFinish","asyncWrite","browser","setImmediate","WritableState","internalUtil","realHasInstance","nop","writableHwm","writableHighWaterMark","finalCalled","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","bufferedRequestCount","corkedRequestsFree","writev","_writev","final","_final","writeAfterEnd","validChunk","valid","decodeChunk","writeOrBuffer","isBuf","newChunk","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","clearBuffer","afterWrite","onwriteDrain","holder","allBuffers","callFinal","need","endWritable","corkReq","getBuffer","current","hasInstance","Function","object","cork","uncork","setDefaultEncoding","stringifyPrimitive","ks","chars","arraybuffer","encoded1","encoded2","encoded3","encoded4","bufferLength","hideOverlay","overlayColor","overlayOpacity","animationFrame","genOverlay","propsData","createOverlay","requestAnimationFrame","showScroll","cancelAnimationFrame","down","checkPath","Node","isInside","composedPath","dialog","selected","hasScrollbar","shouldScroll","$vuetify","breakpoint","passive","BIGFLOAT","BASE64URL_EXPECTED","BASE64_EXPECTED","BASE16_EXPECTED","CBOR","BASE64URL","BASE64","MIME","ZERO","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","ProcessEmitWarning","warning","ownKeys","getOwnPropertySymbols","NumberIsNaN","init","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","_addListener","prepend","events","existing","newListener","onceWrapper","fired","wrapFn","_onceWrap","wrapped","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","spliceOne","eventListener","errorListener","setMaxListeners","getMaxListeners","doError","message","context","prependOnceListener","position","originalListener","off","removeAllListeners","rawListeners","eventNames","model","inputValue","falseValue","trueValue","multiple","hasColor","lazyValue","isDark","item","valueComparator","prevent","domProps","blur","change","focus"],"mappings":"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","file":"js/chunk-1a5a34d4.c42c5c39.js","sourcesContent":["module.exports = require('./lib/_stream_duplex.js');\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\n'use strict';\n\nvar punycode = require('punycode');\nvar util = require('./util');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\nexports.Url = Url;\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.host = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.query = null;\n  this.pathname = null;\n  this.path = null;\n  this.href = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n\n    // Special case for a simple path URL\n    simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n    // RFC 2396: characters reserved for delimiting URLs.\n    // We actually just auto-escape these.\n    delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n\n    // RFC 2396: characters not allowed for various reasons.\n    unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\n    autoEscape = ['\\''].concat(unwise),\n    // Characters that are never ever allowed in a hostname.\n    // Note that any invalid chars are also handled, but these\n    // are the ones that are *expected* to be seen, so we fast-path\n    // them.\n    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\n    hostEndingChars = ['/', '?', '#'],\n    hostnameMaxLen = 255,\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n    // protocols that can allow \"unsafe\" and \"unwise\" chars.\n    unsafeProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that never have a hostname.\n    hostlessProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that always contain a // bit.\n    slashedProtocol = {\n      'http': true,\n      'https': true,\n      'ftp': true,\n      'gopher': true,\n      'file': true,\n      'http:': true,\n      'https:': true,\n      'ftp:': true,\n      'gopher:': true,\n      'file:': true\n    },\n    querystring = require('querystring');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url && util.isObject(url) && url instanceof Url) return url;\n\n  var u = new Url;\n  u.parse(url, parseQueryString, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\n  if (!util.isString(url)) {\n    throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n  }\n\n  // Copy chrome, IE, opera backslash-handling behavior.\n  // Back slashes before the query string get converted to forward slashes\n  // See: https://code.google.com/p/chromium/issues/detail?id=25916\n  var queryIndex = url.indexOf('?'),\n      splitter =\n          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',\n      uSplit = url.split(splitter),\n      slashRegex = /\\\\/g;\n  uSplit[0] = uSplit[0].replace(slashRegex, '/');\n  url = uSplit.join(splitter);\n\n  var rest = url;\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.path = rest;\n      this.href = rest;\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n        if (parseQueryString) {\n          this.query = querystring.parse(this.search.substr(1));\n        } else {\n          this.query = this.search.substr(1);\n        }\n      } else if (parseQueryString) {\n        this.search = '';\n        this.query = {};\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    var lowerProto = proto.toLowerCase();\n    this.protocol = lowerProto;\n    rest = rest.substr(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    var slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n    for (var i = 0; i < hostEndingChars.length; i++) {\n      var hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    var auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = decodeURIComponent(auth);\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (var i = 0; i < nonHostChars.length; i++) {\n      var hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1)\n      hostEnd = rest.length;\n\n    this.host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost();\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || '';\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    var ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n      for (var i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) continue;\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = '/' + notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    } else {\n      // hostnames are always lower case.\n      this.hostname = this.hostname.toLowerCase();\n    }\n\n    if (!ipv6Hostname) {\n      // IDNA Support: Returns a punycoded representation of \"domain\".\n      // It only converts parts of the domain name that\n      // have non-ASCII characters, i.e. it doesn't matter if\n      // you call it with a domain that already is ASCII-only.\n      this.hostname = punycode.toASCII(this.hostname);\n    }\n\n    var p = this.port ? ':' + this.port : '';\n    var h = this.hostname || '';\n    this.host = h + p;\n    this.href += this.host;\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n      if (rest[0] !== '/') {\n        rest = '/' + rest;\n      }\n    }\n  }\n\n  // now rest is set to the post-host stuff.\n  // chop off any delim chars.\n  if (!unsafeProtocol[lowerProto]) {\n\n    // First, make 100% sure that any \"autoEscape\" chars get\n    // escaped, even if encodeURIComponent doesn't think they\n    // need to be.\n    for (var i = 0, l = autoEscape.length; i < l; i++) {\n      var ae = autoEscape[i];\n      if (rest.indexOf(ae) === -1)\n        continue;\n      var esc = encodeURIComponent(ae);\n      if (esc === ae) {\n        esc = escape(ae);\n      }\n      rest = rest.split(ae).join(esc);\n    }\n  }\n\n\n  // chop off from the tail first.\n  var hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  var qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    this.query = rest.substr(qm + 1);\n    if (parseQueryString) {\n      this.query = querystring.parse(this.query);\n    }\n    rest = rest.slice(0, qm);\n  } else if (parseQueryString) {\n    // no query string, but parseQueryString still requested\n    this.search = '';\n    this.query = {};\n  }\n  if (rest) this.pathname = rest;\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '/';\n  }\n\n  //to support http.request\n  if (this.pathname || this.search) {\n    var p = this.pathname || '';\n    var s = this.search || '';\n    this.path = p + s;\n  }\n\n  // finally, reconstruct the href based on what has been validated.\n  this.href = this.format();\n  return this;\n};\n\n// format a parsed object into a url string\nfunction urlFormat(obj) {\n  // ensure it's an object, and not a string url.\n  // If it's an obj, this is a no-op.\n  // this way, you can call url_format() on strings\n  // to clean up potentially wonky urls.\n  if (util.isString(obj)) obj = urlParse(obj);\n  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);\n  return obj.format();\n}\n\nUrl.prototype.format = function() {\n  var auth = this.auth || '';\n  if (auth) {\n    auth = encodeURIComponent(auth);\n    auth = auth.replace(/%3A/i, ':');\n    auth += '@';\n  }\n\n  var protocol = this.protocol || '',\n      pathname = this.pathname || '',\n      hash = this.hash || '',\n      host = false,\n      query = '';\n\n  if (this.host) {\n    host = auth + this.host;\n  } else if (this.hostname) {\n    host = auth + (this.hostname.indexOf(':') === -1 ?\n        this.hostname :\n        '[' + this.hostname + ']');\n    if (this.port) {\n      host += ':' + this.port;\n    }\n  }\n\n  if (this.query &&\n      util.isObject(this.query) &&\n      Object.keys(this.query).length) {\n    query = querystring.stringify(this.query);\n  }\n\n  var search = this.search || (query && ('?' + query)) || '';\n\n  if (protocol && protocol.substr(-1) !== ':') protocol += ':';\n\n  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\n  // unless they had them to begin with.\n  if (this.slashes ||\n      (!protocol || slashedProtocol[protocol]) && host !== false) {\n    host = '//' + (host || '');\n    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;\n  } else if (!host) {\n    host = '';\n  }\n\n  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;\n  if (search && search.charAt(0) !== '?') search = '?' + search;\n\n  pathname = pathname.replace(/[?#]/g, function(match) {\n    return encodeURIComponent(match);\n  });\n  search = search.replace('#', '%23');\n\n  return protocol + host + pathname + search + hash;\n};\n\nfunction urlResolve(source, relative) {\n  return urlParse(source, false, true).resolve(relative);\n}\n\nUrl.prototype.resolve = function(relative) {\n  return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\nfunction urlResolveObject(source, relative) {\n  if (!source) return relative;\n  return urlParse(source, false, true).resolveObject(relative);\n}\n\nUrl.prototype.resolveObject = function(relative) {\n  if (util.isString(relative)) {\n    var rel = new Url();\n    rel.parse(relative, false, true);\n    relative = rel;\n  }\n\n  var result = new Url();\n  var tkeys = Object.keys(this);\n  for (var tk = 0; tk < tkeys.length; tk++) {\n    var tkey = tkeys[tk];\n    result[tkey] = this[tkey];\n  }\n\n  // hash is always overridden, no matter what.\n  // even href=\"\" will remove it.\n  result.hash = relative.hash;\n\n  // if the relative url is empty, then there's nothing left to do here.\n  if (relative.href === '') {\n    result.href = result.format();\n    return result;\n  }\n\n  // hrefs like //foo/bar always cut to the protocol.\n  if (relative.slashes && !relative.protocol) {\n    // take everything except the protocol from relative\n    var rkeys = Object.keys(relative);\n    for (var rk = 0; rk < rkeys.length; rk++) {\n      var rkey = rkeys[rk];\n      if (rkey !== 'protocol')\n        result[rkey] = relative[rkey];\n    }\n\n    //urlParse appends trailing / to urls like http://www.example.com\n    if (slashedProtocol[result.protocol] &&\n        result.hostname && !result.pathname) {\n      result.path = result.pathname = '/';\n    }\n\n    result.href = result.format();\n    return result;\n  }\n\n  if (relative.protocol && relative.protocol !== result.protocol) {\n    // if it's a known url protocol, then changing\n    // the protocol does weird things\n    // first, if it's not file:, then we MUST have a host,\n    // and if there was a path\n    // to begin with, then we MUST have a path.\n    // if it is file:, then the host is dropped,\n    // because that's known to be hostless.\n    // anything else is assumed to be absolute.\n    if (!slashedProtocol[relative.protocol]) {\n      var keys = Object.keys(relative);\n      for (var v = 0; v < keys.length; v++) {\n        var k = keys[v];\n        result[k] = relative[k];\n      }\n      result.href = result.format();\n      return result;\n    }\n\n    result.protocol = relative.protocol;\n    if (!relative.host && !hostlessProtocol[relative.protocol]) {\n      var relPath = (relative.pathname || '').split('/');\n      while (relPath.length && !(relative.host = relPath.shift()));\n      if (!relative.host) relative.host = '';\n      if (!relative.hostname) relative.hostname = '';\n      if (relPath[0] !== '') relPath.unshift('');\n      if (relPath.length < 2) relPath.unshift('');\n      result.pathname = relPath.join('/');\n    } else {\n      result.pathname = relative.pathname;\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    result.host = relative.host || '';\n    result.auth = relative.auth;\n    result.hostname = relative.hostname || relative.host;\n    result.port = relative.port;\n    // to support http.request\n    if (result.pathname || result.search) {\n      var p = result.pathname || '';\n      var s = result.search || '';\n      result.path = p + s;\n    }\n    result.slashes = result.slashes || relative.slashes;\n    result.href = result.format();\n    return result;\n  }\n\n  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),\n      isRelAbs = (\n          relative.host ||\n          relative.pathname && relative.pathname.charAt(0) === '/'\n      ),\n      mustEndAbs = (isRelAbs || isSourceAbs ||\n                    (result.host && relative.pathname)),\n      removeAllDots = mustEndAbs,\n      srcPath = result.pathname && result.pathname.split('/') || [],\n      relPath = relative.pathname && relative.pathname.split('/') || [],\n      psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n  // if the url is a non-slashed url, then relative\n  // links like ../.. should be able\n  // to crawl up to the hostname, as well.  This is strange.\n  // result.protocol has already been set by now.\n  // Later on, put the first path part into the host field.\n  if (psychotic) {\n    result.hostname = '';\n    result.port = null;\n    if (result.host) {\n      if (srcPath[0] === '') srcPath[0] = result.host;\n      else srcPath.unshift(result.host);\n    }\n    result.host = '';\n    if (relative.protocol) {\n      relative.hostname = null;\n      relative.port = null;\n      if (relative.host) {\n        if (relPath[0] === '') relPath[0] = relative.host;\n        else relPath.unshift(relative.host);\n      }\n      relative.host = null;\n    }\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n  }\n\n  if (isRelAbs) {\n    // it's absolute.\n    result.host = (relative.host || relative.host === '') ?\n                  relative.host : result.host;\n    result.hostname = (relative.hostname || relative.hostname === '') ?\n                      relative.hostname : result.hostname;\n    result.search = relative.search;\n    result.query = relative.query;\n    srcPath = relPath;\n    // fall through to the dot-handling below.\n  } else if (relPath.length) {\n    // it's relative\n    // throw away the existing file, and take the new path instead.\n    if (!srcPath) srcPath = [];\n    srcPath.pop();\n    srcPath = srcPath.concat(relPath);\n    result.search = relative.search;\n    result.query = relative.query;\n  } else if (!util.isNullOrUndefined(relative.search)) {\n    // just pull out the search.\n    // like href='?foo'.\n    // Put this after the other two cases because it simplifies the booleans\n    if (psychotic) {\n      result.hostname = result.host = srcPath.shift();\n      //occationaly the auth can get stuck only in host\n      //this especially happens in cases like\n      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n      var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                       result.host.split('@') : false;\n      if (authInHost) {\n        result.auth = authInHost.shift();\n        result.host = result.hostname = authInHost.shift();\n      }\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    //to support http.request\n    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n      result.path = (result.pathname ? result.pathname : '') +\n                    (result.search ? result.search : '');\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  if (!srcPath.length) {\n    // no path at all.  easy.\n    // we've already handled the other stuff above.\n    result.pathname = null;\n    //to support http.request\n    if (result.search) {\n      result.path = '/' + result.search;\n    } else {\n      result.path = null;\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  // if a url ENDs in . or .., then it must get a trailing slash.\n  // however, if it ends in anything else non-slashy,\n  // then it must NOT get a trailing slash.\n  var last = srcPath.slice(-1)[0];\n  var hasTrailingSlash = (\n      (result.host || relative.host || srcPath.length > 1) &&\n      (last === '.' || last === '..') || last === '');\n\n  // strip single dots, resolve double dots to parent dir\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = srcPath.length; i >= 0; i--) {\n    last = srcPath[i];\n    if (last === '.') {\n      srcPath.splice(i, 1);\n    } else if (last === '..') {\n      srcPath.splice(i, 1);\n      up++;\n    } else if (up) {\n      srcPath.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (!mustEndAbs && !removeAllDots) {\n    for (; up--; up) {\n      srcPath.unshift('..');\n    }\n  }\n\n  if (mustEndAbs && srcPath[0] !== '' &&\n      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n    srcPath.unshift('');\n  }\n\n  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n    srcPath.push('');\n  }\n\n  var isAbsolute = srcPath[0] === '' ||\n      (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n  // put the host back\n  if (psychotic) {\n    result.hostname = result.host = isAbsolute ? '' :\n                                    srcPath.length ? srcPath.shift() : '';\n    //occationaly the auth can get stuck only in host\n    //this especially happens in cases like\n    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n    var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                     result.host.split('@') : false;\n    if (authInHost) {\n      result.auth = authInHost.shift();\n      result.host = result.hostname = authInHost.shift();\n    }\n  }\n\n  mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n  if (mustEndAbs && !isAbsolute) {\n    srcPath.unshift('');\n  }\n\n  if (!srcPath.length) {\n    result.pathname = null;\n    result.path = null;\n  } else {\n    result.pathname = srcPath.join('/');\n  }\n\n  //to support request.http\n  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n    result.path = (result.pathname ? result.pathname : '') +\n                  (result.search ? result.search : '');\n  }\n  result.auth = relative.auth || result.auth;\n  result.slashes = result.slashes || relative.slashes;\n  result.href = result.format();\n  return result;\n};\n\nUrl.prototype.parseHost = function() {\n  var host = this.host;\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) this.hostname = host;\n};\n","'use strict'\n\nconst bignumber = require('bignumber.js').BigNumber\nconst utils = require('./utils')\nconst url = require('url')\n\nconst MINUS_ONE = new bignumber(-1)\nconst TWO = new bignumber(2)\n\n/**\n * A CBOR tagged item, where the tag does not have semantics specified at the\n * moment, or those semantics threw an error during parsing. Typically this will\n * be an extension point you're not yet expecting.\n */\nclass Tagged {\n\n  /**\n   * Creates an instance of Tagged.\n   *\n   * @param {number} tag - the number of the tag\n   * @param {any} value - the value inside the tag\n   * @param {Error} [err] - the error that was thrown parsing the tag, or null\n   */\n  constructor(tag, value, err) {\n    this.tag = tag\n    this.value = value\n    this.err = err\n    if (typeof this.tag !== 'number') {\n      throw new Error('Invalid tag type (' + (typeof this.tag) + ')')\n    }\n    if ((this.tag < 0) || ((this.tag | 0) !== this.tag)) {\n      throw new Error('Tag must be a positive integer: ' + this.tag)\n    }\n  }\n\n  /**\n   * Convert to a String\n   *\n   * @returns {string} string of the form '1(2)'\n   */\n  toString() {\n    return `${this.tag}(${JSON.stringify(this.value)})`\n  }\n\n  /**\n   * Push the simple value onto the CBOR stream\n   *\n   * @param {Object} gen The generator to push onto\n   */\n  encodeCBOR(gen) {\n    gen._pushTag(this.tag)\n    return gen.pushAny(this.value)\n  }\n\n  /**\n   * If we have a converter for this type, do the conversion.  Some converters\n   * are built-in.  Additional ones can be passed in.  If you want to remove\n   * a built-in converter, pass a converter in whose value is 'null' instead\n   * of a function.\n   *\n   * @param {Object} converters - keys in the object are a tag number, the value\n   *   is a function that takes the decoded CBOR and returns a JavaScript value\n   *   of the appropriate type.  Throw an exception in the function on errors.\n   * @returns {any} - the converted item\n   */\n  convert(converters) {\n    let f = converters != null ? converters[this.tag] : void 0\n    if (typeof f !== 'function') {\n      f = Tagged['_tag_' + this.tag]\n      if (typeof f !== 'function') {\n        return this\n      }\n    }\n    try {\n      return f.call(Tagged, this.value)\n    } catch (error) {\n      this.err = error\n      return this\n    }\n  }\n\n  static _tag_0(v) {\n    return new Date(v)\n  }\n\n  static _tag_1(v) {\n    return new Date(v * 1000)\n  }\n\n  static _tag_2(v) {\n    return utils.bufferToBignumber(v)\n  }\n\n  static _tag_3(v) {\n    return MINUS_ONE.minus(utils.bufferToBignumber(v))\n  }\n\n  static _tag_4(v) {\n    return bignumber(v[1]).shiftedBy(v[0])\n  }\n\n  static _tag_5(v) {\n    return TWO.pow(v[0]).times(v[1])\n  }\n\n  static _tag_32(v) {\n    return url.parse(v)\n  }\n\n  static _tag_35(v) {\n    return new RegExp(v)\n  }\n}\n\nmodule.exports = Tagged\n","// Styles\nimport './VDialog.sass'\n\n// Components\nimport { VThemeProvider } from '../VThemeProvider'\n\n// Mixins\nimport Activatable from '../../mixins/activatable'\nimport Dependent from '../../mixins/dependent'\nimport Detachable from '../../mixins/detachable'\nimport Overlayable from '../../mixins/overlayable'\nimport Returnable from '../../mixins/returnable'\nimport Stackable from '../../mixins/stackable'\nimport Toggleable from '../../mixins/toggleable'\n\n// Directives\nimport ClickOutside from '../../directives/click-outside'\n\n// Helpers\nimport mixins from '../../util/mixins'\nimport { removed } from '../../util/console'\nimport {\n  convertToUnit,\n  keyCodes,\n} from '../../util/helpers'\n\n// Types\nimport { VNode, VNodeData } from 'vue'\n\nconst baseMixins = mixins(\n  Activatable,\n  Dependent,\n  Detachable,\n  Overlayable,\n  Returnable,\n  Stackable,\n  Toggleable\n)\n\n/* @vue/component */\nexport default baseMixins.extend({\n  name: 'v-dialog',\n\n  directives: { ClickOutside },\n\n  props: {\n    dark: Boolean,\n    disabled: Boolean,\n    fullscreen: Boolean,\n    light: Boolean,\n    maxWidth: {\n      type: [String, Number],\n      default: 'none',\n    },\n    noClickAnimation: Boolean,\n    origin: {\n      type: String,\n      default: 'center center',\n    },\n    persistent: Boolean,\n    retainFocus: {\n      type: Boolean,\n      default: true,\n    },\n    scrollable: Boolean,\n    transition: {\n      type: [String, Boolean],\n      default: 'dialog-transition',\n    },\n    width: {\n      type: [String, Number],\n      default: 'auto',\n    },\n  },\n\n  data () {\n    return {\n      activatedBy: null as EventTarget | null,\n      animate: false,\n      animateTimeout: -1,\n      isActive: !!this.value,\n      stackMinZIndex: 200,\n      previousActiveElement: null as HTMLElement | null,\n    }\n  },\n\n  computed: {\n    classes (): object {\n      return {\n        [(`v-dialog ${this.contentClass}`).trim()]: true,\n        'v-dialog--active': this.isActive,\n        'v-dialog--persistent': this.persistent,\n        'v-dialog--fullscreen': this.fullscreen,\n        'v-dialog--scrollable': this.scrollable,\n        'v-dialog--animated': this.animate,\n      }\n    },\n    contentClasses (): object {\n      return {\n        'v-dialog__content': true,\n        'v-dialog__content--active': this.isActive,\n      }\n    },\n    hasActivator (): boolean {\n      return Boolean(\n        !!this.$slots.activator ||\n        !!this.$scopedSlots.activator\n      )\n    },\n  },\n\n  watch: {\n    isActive (val) {\n      if (val) {\n        this.show()\n        this.hideScroll()\n      } else {\n        this.removeOverlay()\n        this.unbind()\n        this.previousActiveElement?.focus()\n      }\n    },\n    fullscreen (val) {\n      if (!this.isActive) return\n\n      if (val) {\n        this.hideScroll()\n        this.removeOverlay(false)\n      } else {\n        this.showScroll()\n        this.genOverlay()\n      }\n    },\n  },\n\n  created () {\n    /* istanbul ignore next */\n    if (this.$attrs.hasOwnProperty('full-width')) {\n      removed('full-width', this)\n    }\n  },\n\n  beforeMount () {\n    this.$nextTick(() => {\n      this.isBooted = this.isActive\n      this.isActive && this.show()\n    })\n  },\n\n  beforeDestroy () {\n    if (typeof window !== 'undefined') this.unbind()\n  },\n\n  methods: {\n    animateClick () {\n      this.animate = false\n      // Needed for when clicking very fast\n      // outside of the dialog\n      this.$nextTick(() => {\n        this.animate = true\n        window.clearTimeout(this.animateTimeout)\n        this.animateTimeout = window.setTimeout(() => (this.animate = false), 150)\n      })\n    },\n    closeConditional (e: Event) {\n      const target = e.target as HTMLElement\n      // Ignore the click if the dialog is closed or destroyed,\n      // if it was on an element inside the content,\n      // if it was dragged onto the overlay (#6969),\n      // or if this isn't the topmost dialog (#9907)\n      return !(\n        this._isDestroyed ||\n        !this.isActive ||\n        this.$refs.content.contains(target) ||\n        (this.overlay && target && !this.overlay.$el.contains(target))\n      ) && this.activeZIndex >= this.getMaxZIndex()\n    },\n    hideScroll () {\n      if (this.fullscreen) {\n        document.documentElement.classList.add('overflow-y-hidden')\n      } else {\n        Overlayable.options.methods.hideScroll.call(this)\n      }\n    },\n    show () {\n      !this.fullscreen && !this.hideOverlay && this.genOverlay()\n      // Double nextTick to wait for lazy content to be generated\n      this.$nextTick(() => {\n        this.$nextTick(() => {\n          this.previousActiveElement = document.activeElement as HTMLElement\n          this.$refs.content.focus()\n          this.bind()\n        })\n      })\n    },\n    bind () {\n      window.addEventListener('focusin', this.onFocusin)\n    },\n    unbind () {\n      window.removeEventListener('focusin', this.onFocusin)\n    },\n    onClickOutside (e: Event) {\n      this.$emit('click:outside', e)\n\n      if (this.persistent) {\n        this.noClickAnimation || this.animateClick()\n      } else {\n        this.isActive = false\n      }\n    },\n    onKeydown (e: KeyboardEvent) {\n      if (e.keyCode === keyCodes.esc && !this.getOpenDependents().length) {\n        if (!this.persistent) {\n          this.isActive = false\n          const activator = this.getActivator()\n          this.$nextTick(() => activator && (activator as HTMLElement).focus())\n        } else if (!this.noClickAnimation) {\n          this.animateClick()\n        }\n      }\n      this.$emit('keydown', e)\n    },\n    // On focus change, wrap focus to stay inside the dialog\n    // https://github.com/vuetifyjs/vuetify/issues/6892\n    onFocusin (e: Event) {\n      if (!e || !this.retainFocus) return\n\n      const target = e.target as HTMLElement\n\n      if (\n        !!target &&\n        // It isn't the document or the dialog body\n        ![document, this.$refs.content].includes(target) &&\n        // It isn't inside the dialog body\n        !this.$refs.content.contains(target) &&\n        // We're the topmost dialog\n        this.activeZIndex >= this.getMaxZIndex() &&\n        // It isn't inside a dependent element (like a menu)\n        !this.getOpenDependentElements().some(el => el.contains(target))\n        // So we must have focused something outside the dialog and its children\n      ) {\n        // Find and focus the first available element inside the dialog\n        const focusable = this.$refs.content.querySelectorAll('button, [href], input, select, textarea, [tabindex]:not([tabindex=\"-1\"])')\n        const el = [...focusable].find(el => !el.hasAttribute('disabled')) as HTMLElement | undefined\n        el && el.focus()\n      }\n    },\n    genContent () {\n      return this.showLazyContent(() => [\n        this.$createElement(VThemeProvider, {\n          props: {\n            root: true,\n            light: this.light,\n            dark: this.dark,\n          },\n        }, [\n          this.$createElement('div', {\n            class: this.contentClasses,\n            attrs: {\n              role: 'document',\n              tabindex: this.isActive ? 0 : undefined,\n              ...this.getScopeIdAttrs(),\n            },\n            on: { keydown: this.onKeydown },\n            style: { zIndex: this.activeZIndex },\n            ref: 'content',\n          }, [this.genTransition()]),\n        ]),\n      ])\n    },\n    genTransition () {\n      const content = this.genInnerContent()\n\n      if (!this.transition) return content\n\n      return this.$createElement('transition', {\n        props: {\n          name: this.transition,\n          origin: this.origin,\n          appear: true,\n        },\n      }, [content])\n    },\n    genInnerContent () {\n      const data: VNodeData = {\n        class: this.classes,\n        ref: 'dialog',\n        directives: [\n          {\n            name: 'click-outside',\n            value: {\n              handler: this.onClickOutside,\n              closeConditional: this.closeConditional,\n              include: this.getOpenDependentElements,\n            },\n          },\n          { name: 'show', value: this.isActive },\n        ],\n        style: {\n          transformOrigin: this.origin,\n        },\n      }\n\n      if (!this.fullscreen) {\n        data.style = {\n          ...data.style as object,\n          maxWidth: this.maxWidth === 'none' ? undefined : convertToUnit(this.maxWidth),\n          width: this.width === 'auto' ? undefined : convertToUnit(this.width),\n        }\n      }\n\n      return this.$createElement('div', data, this.getContentSlot())\n    },\n  },\n\n  render (h): VNode {\n    return h('div', {\n      staticClass: 'v-dialog__container',\n      class: {\n        'v-dialog__container--attached':\n          this.attach === '' ||\n          this.attach === true ||\n          this.attach === 'attach',\n      },\n      attrs: { role: 'dialog' },\n    }, [\n      this.genActivator(),\n      this.genContent(),\n    ])\n  },\n})\n","'use strict'\n\nconst stream = require('stream')\nconst util = require('util')\nconst utils = require('./utils')\nconst Simple = require('./simple')\nconst Decoder = require('./decoder')\nconst constants = require('./constants')\nconst bignumber = require('bignumber.js').BigNumber\nconst NoFilter = require('nofilter')\n\nconst MT = constants.MT\nconst NUMBYTES = constants.NUMBYTES\nconst SYMS = constants.SYMS\n\nfunction plural(c) {\n  if (c > 1) {\n    return 's'\n  } else {\n    return ''\n  }\n}\n\n/**\n * Generate the expanded format of RFC 7049, section 2.2.1\n *\n * @extends {stream.Transform}\n */\nclass Commented extends stream.Transform {\n  /**\n   * Create a CBOR commenter.\n   *\n   * @param {object} [options={}] - Stream options\n   * @param {number} [options.max_depth=10] - how many times to indent\n   *   the dashes\n   * @param {number} [options.depth=1] - initial indentation depth\n   * @param {boolean} [options.no_summary=false] - if true, omit the summary\n   *   of the full bytes read at the end\n   */\n  constructor(options) {\n    const opts = Object.assign({\n      depth: 1,\n      max_depth: 10,\n      no_summary: false\n    }, options, {\n      readableObjectMode: false,\n      writableObjectMode: false\n    })\n    const max_depth = opts.max_depth\n    delete opts.max_depth\n    const depth = opts.depth\n    delete opts.depth\n    super(opts)\n\n    this.depth = depth\n    this.max_depth = max_depth\n    this.all = new NoFilter()\n\n    opts.tags = {\n      24: this._tag_24.bind(this)\n    }\n    this.parser = new Decoder(opts)\n    this.parser.on('value', this._on_value.bind(this))\n    this.parser.on('start', this._on_start.bind(this))\n    this.parser.on('start-string', this._on_start_string.bind(this))\n    this.parser.on('stop', this._on_stop.bind(this))\n    this.parser.on('more-bytes', this._on_more.bind(this))\n    this.parser.on('error', this._on_error.bind(this))\n    if (!opts.no_summary) {\n      this.parser.on('data', this._on_data.bind(this))\n    }\n    this.parser.bs.on('read', this._on_read.bind(this))\n  }\n\n  /**\n   * @private\n   */\n  _tag_24(v) {\n    const c = new Commented({depth: this.depth+1, no_summary: true})\n    c.on('data', b => this.push(b))\n    c.on('error', er => this.emit('error', er))\n    c.end(v)\n  }\n\n  _transform(fresh, encoding, cb) {\n    this.parser.write(fresh, encoding, cb)\n  }\n\n  /**\n   * @private\n   */\n  _flush(cb) {\n    // TODO: find the test that covers this, and look at the return value\n    return this.parser._flush(cb)\n  }\n\n  /**\n   * @callback commentCallback\n   * @param {Error} [error] - if one was generated\n   * @param {string} [commented] - the comment string\n   */\n\n  /**\n   * @typedef CommentOptions\n   * @property {number} [max_depth=10] how many times to indent the dashes\n   * @property {string} [encoding='hex'] encoding of the input\n   */\n  /**\n   * Comment on an input Buffer or string, creating a string passed to the\n   * callback.  If callback not specified, a promise is returned.\n   *\n   * @static\n   * @param {string|Buffer} input\n   * @param {CommentOptions|commentCallback|string} [options] or callback\n   * @param {commentCallback=} cb\n   * @returns {Promise} if cb not specified\n   */\n  static comment(input, options, cb) {\n    if (input == null) {\n      throw new Error('input required')\n    }\n    let encoding = (typeof input === 'string') ? 'hex' : void 0\n    let max_depth = 10\n    switch (typeof options) {\n      case 'function':\n        cb = options\n        break\n      case 'string':\n        encoding = options\n        break\n      case 'number':\n        max_depth = options\n        break\n      case 'object':\n        const ref1 = options.encoding\n        const ref2 = options.max_depth\n        encoding = (ref1 != null) ? ref1 : encoding\n        max_depth = (ref2 != null) ? ref2 : max_depth\n        break\n      case 'undefined':\n        break\n      default:\n        throw new Error('Unknown option type')\n    }\n    const bs = new NoFilter()\n    const d = new Commented({\n      max_depth\n    })\n    let p = null\n    if (typeof cb === 'function') {\n      d.on('end', () => {\n        cb(null, bs.toString('utf8'))\n      })\n      d.on('error', cb)\n    } else {\n      p = new Promise((resolve, reject) => {\n        d.on('end', () => {\n          resolve(bs.toString('utf8'))\n        })\n        return d.on('error', reject)\n      })\n    }\n    d.pipe(bs)\n    d.end(input, encoding)\n    return p\n  }\n\n  /**\n   * @private\n   */\n  _on_error(er) {\n    this.push('ERROR: ')\n    this.push(er.toString())\n    this.push('\\n')\n  }\n\n  /**\n   * @private\n   */\n  _on_read(buf) {\n    this.all.write(buf)\n    const hex = buf.toString('hex')\n    this.push(new Array(this.depth + 1).join('  '))\n    this.push(hex)\n    let ind = (this.max_depth - this.depth) * 2\n    ind -= hex.length\n    if (ind < 1) {\n      ind = 1\n    }\n    this.push(new Array(ind + 1).join(' '))\n    return this.push('-- ')\n  }\n\n  /**\n   * @private\n   */\n  _on_more(mt, len, parent_mt, pos) {\n    this.depth++\n    let desc = ''\n    switch (mt) {\n      case MT.POS_INT:\n        desc = 'Positive number,'\n        break\n      case MT.NEG_INT:\n        desc = 'Negative number,'\n        break\n      case MT.ARRAY:\n        desc = 'Array, length'\n        break\n      case MT.MAP:\n        desc = 'Map, count'\n        break\n      case MT.BYTE_STRING:\n        desc = 'Bytes, length'\n        break\n      case MT.UTF8_STRING:\n        desc = 'String, length'\n        break\n      case MT.SIMPLE_FLOAT:\n        if (len === 1) {\n          desc = 'Simple value,'\n        } else {\n          desc = 'Float,'\n        }\n        break\n    }\n    return this.push(desc + ' next ' + len + ' byte' + (plural(len)) + '\\n')\n  }\n\n  /**\n   * @private\n   */\n  _on_start_string(mt, tag, parent_mt, pos) {\n    this.depth++\n    let desc = ''\n    switch (mt) {\n      case MT.BYTE_STRING:\n        desc = 'Bytes, length: ' + tag\n        break\n      case MT.UTF8_STRING:\n        desc = 'String, length: ' + (tag.toString())\n        break\n    }\n    return this.push(desc + '\\n')\n  }\n\n  /**\n   * @private\n   */\n  _on_start(mt, tag, parent_mt, pos) {\n    this.depth++\n    if (tag !== SYMS.BREAK) {\n      switch (parent_mt) {\n        case MT.ARRAY:\n          this.push(`[${pos}], `)\n          break\n        case MT.MAP:\n          if (pos % 2) {\n            this.push(`{Val:${Math.floor(pos / 2)}}, `)\n          } else {\n            this.push(`{Key:${Math.floor(pos / 2)}}, `)\n          }\n          break\n      }\n    }\n    switch (mt) {\n      case MT.TAG:\n        this.push(`Tag #${tag}`)\n        if (tag == 24) {\n          this.push(' Encoded CBOR data item')\n        }\n        break\n      case MT.ARRAY:\n        if (tag === SYMS.STREAM) {\n          this.push('Array (streaming)')\n        } else {\n          this.push(`Array, ${tag} item${plural(tag)}`)\n        }\n        break\n      case MT.MAP:\n        if (tag === SYMS.STREAM) {\n          this.push('Map (streaming)')\n        } else {\n          this.push(`Map, ${tag} pair${plural(tag)}`)\n        }\n        break\n      case MT.BYTE_STRING:\n        this.push('Bytes (streaming)')\n        break\n      case MT.UTF8_STRING:\n        this.push('String (streaming)')\n        break\n    }\n    return this.push('\\n')\n  }\n\n  /**\n   * @private\n   */\n  _on_stop(mt) {\n    return this.depth--\n  }\n\n  /**\n   * @private\n   */\n  _on_value(val, parent_mt, pos, ai) {\n    if (val !== SYMS.BREAK) {\n      switch (parent_mt) {\n        case MT.ARRAY:\n          this.push(`[${pos}], `)\n          break\n        case MT.MAP:\n          if (pos % 2) {\n            this.push(`{Val:${Math.floor(pos / 2)}}, `)\n          } else {\n            this.push(`{Key:${Math.floor(pos / 2)}}, `)\n          }\n          break\n      }\n    }\n\n    if (val === SYMS.BREAK) {\n      this.push('BREAK\\n')\n    } else if (val === SYMS.NULL) {\n      this.push('null\\n')\n    } else if (val === SYMS.UNDEFINED) {\n      this.push('undefined\\n')\n    } else if (typeof val === 'string') {\n      this.depth--\n      if (val.length > 0 ) {\n        this.push(JSON.stringify(val))\n        this.push('\\n')\n      }\n    } else if (Buffer.isBuffer(val)) {\n      this.depth--\n      if (val.length > 0) {\n        this.push(val.toString('hex'))\n        this.push('\\n')\n      }\n    } else if (val instanceof bignumber) {\n      this.push(val.toString())\n      this.push('\\n')\n    } else {\n      this.push(util.inspect(val))\n      this.push('\\n')\n    }\n\n    switch (ai) {\n      case NUMBYTES.ONE:\n      case NUMBYTES.TWO:\n      case NUMBYTES.FOUR:\n      case NUMBYTES.EIGHT:\n        this.depth--\n    }\n  }\n\n  /**\n   * @private\n   */\n  _on_data() {\n    this.push('0x')\n    this.push(this.all.read().toString('hex'))\n    return this.push('\\n')\n  }\n}\n\nmodule.exports = Commented\n","/*! https://mths.be/punycode v1.4.1 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow new RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.4.1',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) {\n\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else {\n\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n","import VOverlay from './VOverlay'\n\nexport { VOverlay }\n\nexport default VOverlay\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\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\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\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","module.exports = require('./lib/_stream_writable.js');\n","import CBOR from 'cbor'\n// import * as base64url from \"cbor/lib/encoder\";\nimport base64url from './base64url-arraybuffer'\n\nexport function ab2str (buf) {\n    return String.fromCharCode.apply(null, new Uint8Array(buf))\n}\n\nexport function ab2b64 (buf) {\n    return btoa(ab2str(buf))\n}\n\nexport function ab2json (buf) {\n    return JSON.parse(ab2str(buf))\n}\n\nexport function ab2hex (buf) {\n    return Array.prototype.map\n        .call(new Uint8Array(buf), x => ('00' + x.toString(16)).slice(-2))\n        .join('')\n}\n\nexport function cbor2json (buf) {\n    return CBOR.decode(ab2hex(buf))\n}\n\nexport function decodeCredential (savedCred) {\n    return {\n        ...savedCred,\n        rawId: ab2hex(savedCred.rawId),\n        response: {\n            ...savedCred.response,\n            // It is CBOR object but it's not really that useful to see it\n            // attestationObjectCbor: cbor2json(savedCred.response.attestationObject),\n            attestationObjectHex: ab2hex(savedCred.response.attestationObject),\n            clientDataJSON: ab2json(savedCred.response.clientDataJSON),\n        },\n    }\n}\n\nexport function decodeAssertion (assertion) {\n    return {\n        ...assertion,\n        rawId: ab2hex(assertion.rawId),\n        response: {\n            ...assertion.response,\n            authenticatorDataHex: ab2hex(assertion.response.authenticatorData),\n            clientDataJSON: ab2json(assertion.response.clientDataJSON),\n            signatureHex: ab2hex(assertion.response.signature),\n        },\n    }\n}\n\n// Don't do this in production, generate something sutably random on the server\nexport function generateId () {\n    const ab = new Uint8Array(16)\n\n    for (let i = 0; i < 16; i++) {\n        ab[i] = Math.round(Math.random() * 255)\n    }\n\n    return ab\n}\n\n// Don't do this in production, generate something cryptographically safe on the server\nexport function generateChallenge () {\n    const ab = new Uint8Array(32)\n\n    for (let i = 0; i < 32; i++) {\n        ab[i] = Math.round(Math.random() * 255)\n    }\n\n    return ab.buffer\n}\n\nexport function preformatMakeCredReq (makeCredReq) {\n    makeCredReq.challenge = base64url.decode(makeCredReq.challenge)\n    makeCredReq.user.id = base64url.decode(makeCredReq.user.id)\n    for (let i = 0; i < makeCredReq.excludeCredentials.length; i++) {\n        makeCredReq.excludeCredentials[i].id = base64url.decode(makeCredReq.excludeCredentials[i].id)\n    }\n\n    return makeCredReq\n}\n\nexport function preformatGetAssertReq (getAssert) {\n  getAssert.challenge = base64url.decode(getAssert.challenge)\n\n  if (getAssert.allowCredentials) {\n    for (let i = 0; i < getAssert.allowCredentials.length; i++) {\n      getAssert.allowCredentials[i].id = base64url.decode(getAssert.allowCredentials[i].id)\n    }\n  }\n\n  return getAssert\n};\n\nexport function publicKeyCredentialToJSON (pubKeyCred) {\n    if (pubKeyCred instanceof Array) {\n        const arr = []\n        for (const i of pubKeyCred) { arr.push(publicKeyCredentialToJSON(i)) }\n\n        return arr\n    }\n\n    if (pubKeyCred instanceof ArrayBuffer) {\n        return base64url.encode(pubKeyCred)\n    }\n\n    if (pubKeyCred instanceof Object) {\n        const obj = {}\n\n        for (const key in pubKeyCred) {\n            obj[key] = publicKeyCredentialToJSON(pubKeyCred[key])\n        }\n\n        return obj\n    }\n\n    return pubKeyCred\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\nmodule.exports = {\n  isString: function(arg) {\n    return typeof(arg) === 'string';\n  },\n  isObject: function(arg) {\n    return typeof(arg) === 'object' && arg !== null;\n  },\n  isNull: function(arg) {\n    return arg === null;\n  },\n  isNullOrUndefined: function(arg) {\n    return arg == null;\n  }\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\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\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 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 objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return (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 = Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (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  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (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}\n","module.exports = require('events').EventEmitter;\n","// Styles\nimport '../../styles/components/_selection-controls.sass'\nimport './VRadioGroup.sass'\n\n// Extensions\nimport VInput from '../VInput'\nimport { BaseItemGroup } from '../VItemGroup/VItemGroup'\n\n// Mixins\nimport Comparable from '../../mixins/comparable'\n\n// Types\nimport mixins from '../../util/mixins'\nimport { PropType } from 'vue'\n\nconst baseMixins = mixins(\n  Comparable,\n  BaseItemGroup,\n  VInput\n)\n\n/* @vue/component */\nexport default baseMixins.extend({\n  name: 'v-radio-group',\n\n  provide () {\n    return {\n      radioGroup: this,\n    }\n  },\n\n  props: {\n    column: {\n      type: Boolean,\n      default: true,\n    },\n    height: {\n      type: [Number, String],\n      default: 'auto',\n    },\n    name: String,\n    row: Boolean,\n    // If no value set on VRadio\n    // will match valueComparator\n    // force default to null\n    value: null as unknown as PropType<any>,\n  },\n\n  computed: {\n    classes (): object {\n      return {\n        ...VInput.options.computed.classes.call(this),\n        'v-input--selection-controls v-input--radio-group': true,\n        'v-input--radio-group--column': this.column && !this.row,\n        'v-input--radio-group--row': this.row,\n      }\n    },\n  },\n\n  methods: {\n    genDefaultSlot () {\n      return this.$createElement('div', {\n        staticClass: 'v-input--radio-group__input',\n        attrs: {\n          id: this.id,\n          role: 'radiogroup',\n          'aria-labelledby': this.computedId,\n        },\n      }, VInput.options.methods.genDefaultSlot.call(this))\n    },\n    genInputSlot () {\n      const render = VInput.options.methods.genInputSlot.call(this)\n\n      delete render.data!.on!.click\n\n      return render\n    },\n    genLabel () {\n      const label = VInput.options.methods.genLabel.call(this)\n\n      if (!label) return null\n\n      label.data!.attrs!.id = this.computedId\n      // WAI considers this an orphaned label\n      delete label.data!.attrs!.for\n      label.tag = 'legend'\n\n      return label\n    },\n    onClick: BaseItemGroup.options.methods.onClick,\n  },\n})\n","'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n      pna.nextTick(emitErrorNT, this, err);\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      pna.nextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n\n  return this;\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\n};","'use strict'\n\nconst stream = require('stream')\nconst util = require('util')\nconst Decoder = require('./decoder')\nconst Simple = require('./simple')\nconst utils = require('./utils')\nconst constants = require('./constants')\nconst bignumber = require('bignumber.js').BigNumber\nconst NoFilter = require('nofilter')\n\nconst MT = constants.MT\nconst SYMS = constants.SYMS\n\n/**\n * Output the diagnostic format from a stream of CBOR bytes.\n *\n * @extends {stream.Transform}\n */\nclass Diagnose extends stream.Transform {\n\n  /**\n   * Creates an instance of Diagnose.\n   *\n   * @param {Object} [options={}] - options for creation\n   * @param {string} [options.separator='\\n'] - output between detected objects\n   * @param {boolean} [options.stream_errors=false] - put error info into the\n   *   output stream\n   * @param {number} [options.max_depth=-1] - -1 for \"until you run out of\n   *   memory\".  Set this to a finite positive number for un-trusted inputs.\n   *   Most standard inputs won't nest more than 100 or so levels; I've tested\n   *   into the millions before running out of memory.\n   */\n  constructor(options) {\n    const opts = Object.assign({\n      separator: '\\n',\n      stream_errors: false\n    }, options, {\n      readableObjectMode: false,\n      writableObjectMode: false\n    })\n    const separator = opts.separator\n    delete opts.separator\n    const stream_errors = opts.stream_errors\n    delete opts.stream_errors\n    super(opts)\n\n    this.float_bytes = -1\n    this.separator = separator\n    this.stream_errors = stream_errors\n    this.parser = new Decoder(opts)\n    this.parser.on('more-bytes', this._on_more.bind(this))\n    this.parser.on('value', this._on_value.bind(this))\n    this.parser.on('start', this._on_start.bind(this))\n    this.parser.on('stop', this._on_stop.bind(this))\n    this.parser.on('data', this._on_data.bind(this))\n    this.parser.on('error', this._on_error.bind(this))\n  }\n\n  _transform(fresh, encoding, cb) {\n    return this.parser.write(fresh, encoding, cb)\n  }\n\n  _flush(cb) {\n    return this.parser._flush((er) => {\n      if (this.stream_errors) {\n        if (er) {\n          this._on_error(er)\n        }\n        return cb()\n      } else {\n        return cb(er)\n      }\n    })\n  }\n\n  /**\n   * Convenience function to return a string in diagnostic format.\n   *\n   * @param {(Buffer|string)} input - the CBOR bytes to format\n   * @param {string} [encoding='hex'] - the encoding of input, ignored if\n   *   input is Buffer\n   * @param {function(Error, string): undefined} cb - callback\n   * @returns {Promise} if callback not specified\n   */\n  static diagnose(input, encoding, cb) {\n    if (input == null) {\n      throw new Error('input required')\n    }\n    let opts = {}\n    let encod = 'hex'\n    switch (typeof encoding) {\n      case 'function':\n        cb = encoding\n        encod = utils.guessEncoding(input)\n        break\n      case 'object':\n        opts = utils.extend({}, encoding)\n        encod = (opts.encoding != null) ?\n          opts.encoding : utils.guessEncoding(input)\n        delete opts.encoding\n        break\n      default:\n        encod = (encoding != null) ? encoding : 'hex'\n    }\n    const bs = new NoFilter()\n    const d = new Diagnose(opts)\n    let p = null\n    if (typeof cb === 'function') {\n      d.on('end', () => cb(null, bs.toString('utf8')))\n      d.on('error', cb)\n    } else {\n      p = new Promise((resolve, reject) => {\n        d.on('end', () => resolve(bs.toString('utf8')))\n        return d.on('error', reject)\n      })\n    }\n    d.pipe(bs)\n    d.end(input, encod)\n    return p\n  }\n\n  _on_error(er) {\n    if (this.stream_errors) {\n      return this.push(er.toString())\n    } else {\n      return this.emit('error', er)\n    }\n  }\n\n  _on_more(mt, len, parent_mt, pos) {\n    if (mt === MT.SIMPLE_FLOAT) {\n      return this.float_bytes = {\n        2: 1,\n        4: 2,\n        8: 3\n      }[len]\n    }\n  }\n\n  _fore(parent_mt, pos) {\n    switch (parent_mt) {\n      case MT.BYTE_STRING:\n      case MT.UTF8_STRING:\n      case MT.ARRAY:\n        if (pos > 0) {\n          return this.push(', ')\n        }\n        break\n      case MT.MAP:\n        if (pos > 0) {\n          if (pos % 2) {\n            return this.push(': ')\n          } else {\n            return this.push(', ')\n          }\n        }\n    }\n  }\n\n  _on_value(val, parent_mt, pos) {\n    if (val === SYMS.BREAK) {\n      return\n    }\n    this._fore(parent_mt, pos)\n    return this.push((() => {\n      switch (false) {\n        case val !== SYMS.NULL:\n          return 'null'\n        case val !== SYMS.UNDEFINED:\n          return 'undefined'\n        case typeof val !== 'string':\n          return JSON.stringify(val)\n        case !(this.float_bytes > 0):\n          const fb = this.float_bytes\n          this.float_bytes = -1\n          return (util.inspect(val)) + '_' + fb\n        case !Buffer.isBuffer(val):\n          return 'h\\'' + (val.toString('hex')) + '\\''\n        case !(val instanceof bignumber):\n          return val.toString()\n        default:\n          return util.inspect(val)\n      }\n    })())\n  }\n\n  _on_start(mt, tag, parent_mt, pos) {\n    this._fore(parent_mt, pos)\n    switch (mt) {\n      case MT.TAG:\n        this.push(`${tag}(`)\n        break\n      case MT.ARRAY:\n        this.push('[')\n        break\n      case MT.MAP:\n        this.push('{')\n        break\n      case MT.BYTE_STRING:\n      case MT.UTF8_STRING:\n        this.push('(')\n        break\n    }\n    if (tag === SYMS.STREAM) {\n      return this.push('_ ')\n    }\n  }\n\n  _on_stop(mt) {\n    switch (mt) {\n      case MT.TAG:\n        return this.push(')')\n      case MT.ARRAY:\n        return this.push(']')\n      case MT.MAP:\n        return this.push('}')\n      case MT.BYTE_STRING:\n      case MT.UTF8_STRING:\n        return this.push(')')\n    }\n  }\n\n  _on_data() {\n    return this.push(this.separator)\n  }\n}\n\nmodule.exports = Diagnose\n","// Tweaked version of nathan7's binary-parse-stream\n// (see https://github.com/nathan7/binary-parse-stream)\n// Uses NoFilter instead of the readable in the original.  Removes\n// the ability to read -1, which was odd and un-needed.\n// License for binary-parse-stream: MIT\n\n// binary-parse-stream is now unmaintained, so I'm going to rewrite it as\n// more modern JS so I can get tsc to help check types.\n\n'use strict'\nconst Stream = require('stream')\nconst NoFilter = require('nofilter')\nconst TransformStream = Stream.Transform\n\n/**\n * BinaryParseStream is a TransformStream that consumes buffers and outputs\n * objects on the other end.  It expects your subclass to implement a `_parse`\n * method that is a generator.  When your generator yields a number, it'll be\n * fed a buffer of that length from the input.  When your generator returns,\n * the return value will be pushed to the output side.\n *\n * @class BinaryParseStream\n * @extends {TransformStream}\n */\nclass BinaryParseStream extends TransformStream {\n  constructor(options) {\n    super(options)\n    // doesn't work to pass these in as opts, for some reason\n    this['_writableState'].objectMode = false\n    this['_readableState'].objectMode = true\n\n    this.bs = new NoFilter()\n    this.__restart()\n  }\n\n  _transform(fresh, encoding, cb) {\n    this.bs.write(fresh)\n\n    while (this.bs.length >= this.__needed) {\n      let ret\n      const chunk = (this.__needed === null) ?\n        undefined : this.bs.read(this.__needed)\n\n      try {\n        ret = this.__parser.next(chunk)\n      } catch (e) {\n        return cb(e)\n      }\n  \n      if (this.__needed) {\n        this.__fresh = false\n      }\n\n      if (!ret.done) {\n        this.__needed = ret.value || 0\n      } else {\n        this.push(ret.value)\n        this.__restart()\n      }\n    }\n  \n    return cb()\n  }\n\n  /**\n   * @abstract\n   */\n  /* istanbul ignore next */\n  *_parse() {\n    throw new Error('Must be implemented in subclass')\n  }\n\n  __restart() {\n    this.__needed = null\n    this.__parser = this._parse()\n    this.__fresh = true\n  }\n\n  _flush(cb) {\n    cb(this.__fresh ? null : new Error('unexpected end of input'))\n  }\n}\n\nmodule.exports = BinaryParseStream\n","// Directives\nimport ripple from '../../directives/ripple'\n\n// Types\nimport Vue, { VNode, VNodeData, VNodeDirective } from 'vue'\n\nexport default Vue.extend({\n  name: 'rippleable',\n\n  directives: { ripple },\n\n  props: {\n    ripple: {\n      type: [Boolean, Object],\n      default: true,\n    },\n  },\n\n  methods: {\n    genRipple (data: VNodeData = {}): VNode | null {\n      if (!this.ripple) return null\n\n      data.staticClass = 'v-input--selection-controls__ripple'\n\n      data.directives = data.directives || []\n      data.directives.push({\n        name: 'ripple',\n        value: { center: true },\n      } as VNodeDirective)\n\n      return this.$createElement('div', data)\n    },\n  },\n})\n","'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require('safe-buffer').Buffer;\nvar util = require('util');\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = function shift() {\n    if (this.length === 0) return;\n    var ret = this.head.data;\n    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n    --this.length;\n    return ret;\n  };\n\n  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\n}();\n\nif (util && util.inspect && util.inspect.custom) {\n  module.exports.prototype[util.inspect.custom] = function () {\n    var obj = util.inspect({ length: this.length });\n    return this.constructor.name + ' ' + obj;\n  };\n}","// Styles\nimport './VRadio.sass'\n\n// Components\nimport VRadioGroup from './VRadioGroup'\nimport VLabel from '../VLabel'\nimport VIcon from '../VIcon'\nimport VInput from '../VInput'\n\n// Mixins\nimport BindsAttrs from '../../mixins/binds-attrs'\nimport Colorable from '../../mixins/colorable'\nimport { factory as GroupableFactory } from '../../mixins/groupable'\nimport Rippleable from '../../mixins/rippleable'\nimport Themeable from '../../mixins/themeable'\nimport Selectable, { prevent } from '../../mixins/selectable'\n\n// Utilities\nimport { getSlot } from '../../util/helpers'\n\n// Types\nimport { VNode, VNodeData } from 'vue'\nimport mixins from '../../util/mixins'\nimport { mergeListeners } from '../../util/mergeData'\n\nconst baseMixins = mixins(\n  BindsAttrs,\n  Colorable,\n  Rippleable,\n  GroupableFactory('radioGroup'),\n  Themeable\n)\n\ninterface options extends InstanceType<typeof baseMixins> {\n  radioGroup: InstanceType<typeof VRadioGroup>\n}\n\n/* @vue/component */\nexport default baseMixins.extend<options>().extend({\n  name: 'v-radio',\n\n  inheritAttrs: false,\n\n  props: {\n    disabled: Boolean,\n    id: String,\n    label: String,\n    name: String,\n    offIcon: {\n      type: String,\n      default: '$radioOff',\n    },\n    onIcon: {\n      type: String,\n      default: '$radioOn',\n    },\n    readonly: Boolean,\n    value: {\n      default: null,\n    },\n  },\n\n  data: () => ({\n    isFocused: false,\n  }),\n\n  computed: {\n    classes (): object {\n      return {\n        'v-radio--is-disabled': this.isDisabled,\n        'v-radio--is-focused': this.isFocused,\n        ...this.themeClasses,\n        ...this.groupClasses,\n      }\n    },\n    computedColor (): string | undefined {\n      return Selectable.options.computed.computedColor.call(this)\n    },\n    computedIcon (): string {\n      return this.isActive\n        ? this.onIcon\n        : this.offIcon\n    },\n    computedId (): string {\n      return VInput.options.computed.computedId.call(this)\n    },\n    hasLabel: VInput.options.computed.hasLabel,\n    hasState (): boolean {\n      return (this.radioGroup || {}).hasState\n    },\n    isDisabled (): boolean {\n      return this.disabled || (\n        !!this.radioGroup &&\n        this.radioGroup.isDisabled\n      )\n    },\n    isReadonly (): boolean {\n      return this.readonly || (\n        !!this.radioGroup &&\n        this.radioGroup.isReadonly\n      )\n    },\n    computedName (): string {\n      if (this.name || !this.radioGroup) {\n        return this.name\n      }\n\n      return this.radioGroup.name || `radio-${this.radioGroup._uid}`\n    },\n    rippleState (): string | undefined {\n      return Selectable.options.computed.rippleState.call(this)\n    },\n    validationState (): string | undefined {\n      return (this.radioGroup || {}).validationState || this.computedColor\n    },\n  },\n\n  methods: {\n    genInput (args: any) {\n      // We can't actually use the mixin directly because\n      // it's made for standalone components, but its\n      // genInput method is exactly what we need\n      return Selectable.options.methods.genInput.call(this, 'radio', args)\n    },\n    genLabel () {\n      if (!this.hasLabel) return null\n\n      return this.$createElement(VLabel, {\n        on: {\n          // Label shouldn't cause the input to focus\n          click: prevent,\n        },\n        attrs: {\n          for: this.computedId,\n        },\n        props: {\n          color: this.validationState,\n          focused: this.hasState,\n        },\n      }, getSlot(this, 'label') || this.label)\n    },\n    genRadio () {\n      return this.$createElement('div', {\n        staticClass: 'v-input--selection-controls__input',\n      }, [\n        this.$createElement(VIcon, this.setTextColor(this.validationState, {\n          props: {\n            dense: this.radioGroup && this.radioGroup.dense,\n          },\n        }), this.computedIcon),\n        this.genInput({\n          name: this.computedName,\n          value: this.value,\n          ...this.attrs$,\n        }),\n        this.genRipple(this.setTextColor(this.rippleState)),\n      ])\n    },\n    onFocus (e: Event) {\n      this.isFocused = true\n      this.$emit('focus', e)\n    },\n    onBlur (e: Event) {\n      this.isFocused = false\n      this.$emit('blur', e)\n    },\n    onChange () {\n      if (this.isDisabled || this.isReadonly || this.isActive) return\n\n      this.toggle()\n    },\n    onKeydown: () => {}, // Override default with noop\n  },\n\n  render (h): VNode {\n    const data: VNodeData = {\n      staticClass: 'v-radio',\n      class: this.classes,\n      on: mergeListeners({\n        click: this.onChange,\n      }, this.listeners$),\n    }\n\n    return h('div', data, [\n      this.genRadio(),\n      this.genLabel(),\n    ])\n  },\n})\n","'use strict'\n\nconst util = require('util')\nconst bignumber = require('bignumber.js').BigNumber\n\nconst constants = require('./constants')\nconst NUMBYTES = constants.NUMBYTES\nconst SHIFT32 = constants.SHIFT32\nconst MAX_SAFE_HIGH = 0x1fffff\n\nexports.hasBigInt = (typeof BigInt === 'function')\n\n/**\n * Convert a UTF8-encoded Buffer to a JS string.  If possible, throw an error\n * on invalid UTF8.  Byte Order Marks are not looked at or stripped.\n */\nconst TD = (typeof TextDecoder === 'function') ? TextDecoder : util.TextDecoder\n/* istanbul ignore else */\nif (TD) {\n  // node 11+, browsers : node 8.3+\n  const td = new TD('utf8', {fatal: true, ignoreBOM: true})\n  exports.utf8 = (buf) => td.decode(buf)\n  exports.utf8.checksUTF8 = true\n} else {\n  // TODO: polyfill a slow one or wait for node6 to die\n  exports.utf8 = (buf) => buf.toString('utf8') \n  exports.utf8.checksUTF8 = false  \n}\n\nexports.parseCBORint = function(ai, buf) {\n  switch (ai) {\n    case NUMBYTES.ONE:\n      return buf.readUInt8(0)\n    case NUMBYTES.TWO:\n      return buf.readUInt16BE(0)\n    case NUMBYTES.FOUR:\n      return buf.readUInt32BE(0)\n    case NUMBYTES.EIGHT:\n      const f = buf.readUInt32BE(0)\n      const g = buf.readUInt32BE(4)\n      if (f > MAX_SAFE_HIGH) {\n        return new bignumber(f).times(SHIFT32).plus(g)\n      } else {\n        return (f * SHIFT32) + g\n      }\n    default:\n      throw new Error('Invalid additional info for int: ' + ai)\n  }\n}\n\nexports.writeHalf = function writeHalf(buf, half) {\n  // assume 0, -0, NaN, Infinity, and -Infinity have already been caught\n\n  // HACK: everyone settle in.  This isn't going to be pretty.\n  // Translate cn-cbor's C code (from Carsten Borman):\n\n  // uint32_t be32;\n  // uint16_t be16, u16;\n  // union {\n  //   float f;\n  //   uint32_t u;\n  // } u32;\n  // u32.f = float_val;\n\n  const u32 = Buffer.allocUnsafe(4)\n  u32.writeFloatBE(half, 0)\n  const u = u32.readUInt32BE(0)\n\n  // if ((u32.u & 0x1FFF) == 0) { /* worth trying half */\n\n  // hildjj: If the lower 13 bits aren't 0,\n  // we will lose precision in the conversion.\n  // mant32 = 24bits, mant16 = 11bits, 24-11 = 13\n  if ((u & 0x1FFF) !== 0) {\n    return false\n  }\n\n  //   int s16 = (u32.u >> 16) & 0x8000;\n  //   int exp = (u32.u >> 23) & 0xff;\n  //   int mant = u32.u & 0x7fffff;\n\n  let s16 = (u >> 16) & 0x8000 // top bit is sign\n  const exp = (u >> 23) & 0xff // then 5 bits of exponent\n  const mant = u & 0x7fffff\n\n  //   if (exp == 0 && mant == 0)\n  //     ;              /* 0.0, -0.0 */\n\n  // hildjj: zeros already handled.  Assert if you don't believe me.\n\n  //   else if (exp >= 113 && exp <= 142) /* normalized */\n  //     s16 += ((exp - 112) << 10) + (mant >> 13);\n\n  if ((exp >= 113) && (exp <= 142)) {\n    s16 += ((exp - 112) << 10) + (mant >> 13)\n  } else if ((exp >= 103) && (exp < 113)) {\n    //   else if (exp >= 103 && exp < 113) { /* denorm, exp16 = 0 */\n    //     if (mant & ((1 << (126 - exp)) - 1))\n    //       goto float32;         /* loss of precision */\n    //     s16 += ((mant + 0x800000) >> (126 - exp));\n\n    if (mant & ((1 << (126 - exp)) - 1)) {\n      return false\n    }\n    s16 += ((mant + 0x800000) >> (126 - exp))\n  } else {\n  //   } else if (exp == 255 && mant == 0) { /* Inf */\n  //     s16 += 0x7c00;\n\n    // hildjj: Infinity already handled\n\n    //   } else\n    //     goto float32;           /* loss of range */\n\n    return false\n  }\n\n  //   ensure_writable(3);\n  //   u16 = s16;\n  //   be16 = hton16p((const uint8_t*)&u16);\n  buf.writeUInt16BE(s16)\n  return true\n}\n\nexports.parseHalf = function parseHalf(buf) {\n  const sign = buf[0] & 0x80 ? -1 : 1\n  const exp = (buf[0] & 0x7C) >> 2\n  const mant = ((buf[0] & 0x03) << 8) | buf[1]\n  if (!exp) {\n    return sign * 5.9604644775390625e-8 * mant\n  } else if (exp === 0x1f) {\n    return sign * (mant ? 0 / 0 : 2e308)\n  } else {\n    return sign * Math.pow(2, exp - 25) * (1024 + mant)\n  }\n}\n\nexports.parseCBORfloat = function parseCBORfloat(buf) {\n  switch (buf.length) {\n    case 2:\n      return exports.parseHalf(buf)\n    case 4:\n      return buf.readFloatBE(0)\n    case 8:\n      return buf.readDoubleBE(0)\n    default:\n      throw new Error('Invalid float size: ' + buf.length)\n  }\n}\n\nexports.hex = function hex(s) {\n  return Buffer.from(s.replace(/^0x/, ''), 'hex')\n}\n\nexports.bin = function bin(s) {\n  s = s.replace(/\\s/g, '')\n  let start = 0\n  let end = (s.length % 8) || 8\n  const chunks = []\n  while (end <= s.length) {\n    chunks.push(parseInt(s.slice(start, end), 2))\n    start = end\n    end += 8\n  }\n  return Buffer.from(chunks)\n}\n\nexports.extend = function extend(old={}, ...adds) {\n  const len = adds.length\n  for (let j = 0; j < len; j++) {\n    const a = adds[j]\n    for (const k in a) {\n      const v = a[k]\n      old[k] = v\n    }\n  }\n  return old\n}\n\nexports.arrayEqual = function arrayEqual(a, b) {\n  if ((a == null) && (b == null)) {\n    return true\n  }\n  if ((a == null) || (b == null)) {\n    return false\n  }\n  return (a.length === b.length) && a.every((elem, i) => elem === b[i])\n}\n\nexports.bufferEqual = function bufferEqual(a, b) {\n  if ((a == null) && (b == null)) {\n    return true\n  }\n  if ((a == null) || (b == null)) {\n    return false\n  }\n  if (!(Buffer.isBuffer(a) && Buffer.isBuffer(b) && (a.length === b.length))) {\n    return false\n  }\n  const len = a.length\n  let ret = true\n  let i\n  let j\n  for (i = j = 0; j < len; i = ++j) {\n    const byte = a[i]\n    ret = ret && (b[i] === byte)\n  }\n  return !!ret\n}\n\nexports.bufferToBignumber = function bufferToBignumber(buf) {\n  return new bignumber(buf.toString('hex'), 16)\n}\n\nexports.toBigInt = function toBigInt(num) {\n  if (!exports.hasBigInt) {\n    return Number(num) // lossy.  Better than nothing?\n  }\n  return BigInt(num)\n}\n\nexports.bigIntize = function bigIntize(obj) {\n  const ret = {}\n  for (const k in obj) { // stupid node 6\n    ret[k] = exports.toBigInt(obj[k])\n  }\n  return ret\n}\n\nexports.bufferToBigInt = function bufferToBigInt(buf) {\n  return exports.toBigInt('0x' + buf.toString('hex'))\n}\n\nexports.guessEncoding = function guessEncoding(input) {\n  if (typeof input == 'string') {\n    return 'hex'\n  } else if (Buffer.isBuffer(input)) {\n    return undefined\n  }\n  throw new Error('Unknown input type')\n}\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\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// 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\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","'use strict'\n\nconst stream = require('stream')\nconst url = require('url')\nconst bignumber = require('bignumber.js').BigNumber\nconst NoFilter = require('nofilter')\nconst Tagged = require('./tagged')\nconst Simple = require('./simple')\nconst utils = require('./utils')\n\nconst constants = require('./constants')\nconst MT = constants.MT\nconst NUMBYTES = constants.NUMBYTES\nconst SHIFT32 = constants.SHIFT32\nconst SYMS = constants.SYMS\nconst TAG = constants.TAG\nconst HALF = (constants.MT.SIMPLE_FLOAT << 5) | constants.NUMBYTES.TWO\nconst FLOAT = (constants.MT.SIMPLE_FLOAT << 5) | constants.NUMBYTES.FOUR\nconst DOUBLE = (constants.MT.SIMPLE_FLOAT << 5) | constants.NUMBYTES.EIGHT\nconst TRUE = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.TRUE\nconst FALSE = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.FALSE\nconst UNDEFINED = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.UNDEFINED\nconst NULL = (constants.MT.SIMPLE_FLOAT << 5) | constants.SIMPLE.NULL\nconst BREAK = Buffer.from([0xff])\n\nconst BI = utils.bigIntize(constants.BI)\nconst BN = constants.BN\nconst BUF_NAN = Buffer.from('f97e00', 'hex')\nconst BUF_INF_NEG = Buffer.from('f9fc00', 'hex')\nconst BUF_INF_POS = Buffer.from('f97c00', 'hex')\nconst BUF_NEG_ZERO = Buffer.from('f98000', 'hex')\nconst LOOP_DETECT = Symbol('CBOR_LOOP_DETECT')\n\n/**\n * Transform JavaScript values into CBOR bytes.  The `Writable` side of\n * the stream is in object mode.\n *\n * @extends {stream.Transform}\n */\nclass Encoder extends stream.Transform {\n\n  /**\n   * Creates an instance of Encoder.\n   *\n   * @param {Object} [options={}] - options for the encoder\n   * @param {any[]} [options.genTypes=[]] - array of pairs of `type`,\n   *   `function(Encoder)` for semantic types to be encoded.  Not needed\n   *   for Array, Date, Buffer, Map, RegExp, Set, Url, or bignumber.\n   * @param {boolean} [options.canonical=false] - should the output be\n   *   canonicalized\n   * @param {boolean|Symbol} [options.detectLoops=false] - should object loops\n   *   be detected?  This will currently modify the encoded object graph\n   *   by adding a Symbol property to each object.  If this bothers you,\n   *   call `removeLoopDetectors` on the encoded object when done.  Do not\n   *   encode the same object twice on the same encoder, without calling\n   *   `removeLoopDetectors` in between.\n   * @param {(\"number\"|\"float\"|\"int\"|\"string\")} [options.dateType=\"number\"] -\n   *   how should dates be encoded?  \"number\" means float or int, if no\n   *   fractional seconds.\n   * @param {any} [options.encodeUndefined=undefined] - How should an \n   *   \"undefined\" in the input be encoded.  By default, just encode a CBOR\n   *   undefined.  If this is a buffer, use those bytes without re-encoding\n   *   them.  If this is a function, the function will be called (which is\n   *   a good time to throw an exception, if that's what you want), and the\n   *   return value will be used according to these rules.  Anything\n   *   else will be encoded as CBOR.\n   * @param {boolean} [options.disallowUndefinedKeys=false] - Should \"undefined\"\n   *   be disallowed as a key in a Map that is serialized?  If this is true,\n   *   encode(new Map([[undefined, 1]])) will throw an exception.  Note that\n   *   it is impossible to get a key of undefined in a normal JS object.\n   * @param {boolean} [options.collapseBigIntegers=false] - Should integers\n   *   that come in as BigNumber integers and ECMAscript bigint's be encoded\n   *   as normal CBOR integers if they fit, discarding type information?\n   */\n  constructor(options) {\n    const opts = Object.assign({}, options, {\n      readableObjectMode: false,\n      writableObjectMode: true\n    })\n    super(opts)\n\n    this.canonical = opts.canonical\n    this.encodeUndefined = opts.encodeUndefined\n    this.disallowUndefinedKeys = !!opts.disallowUndefinedKeys\n    this.dateType = (opts.dateType != null) ?\n      opts.dateType.toLowerCase() : 'number'\n    this.collapseBigIntegers = !!opts.collapseBigIntegers\n\n    // new Symbol for each instance.  Note: means we can't re-use the same\n    // encoder and encoded object\n    if (typeof(opts.detectLoops) === 'symbol') {\n      this.detectLoops = opts.detectLoops\n    } else {\n      this.detectLoops = !!opts.detectLoops ? Symbol('CBOR_DETECT') : null\n    }\n\n    this.semanticTypes = {\n      Array: this._pushArray,\n      Date: this._pushDate,\n      Buffer: this._pushBuffer,\n      Map: this._pushMap,\n      NoFilter: this._pushNoFilter,\n      RegExp: this._pushRegexp,\n      Set: this._pushSet,\n      BigNumber: this._pushBigNumber,\n      ArrayBuffer: this._pushUint8Array,\n      Uint8ClampedArray: this._pushUint8Array,\n      Uint8Array: this._pushUint8Array,\n      Uint16Array: this._pushArray,\n      Uint32Array: this._pushArray,\n      Int8Array: this._pushArray,\n      Int16Array: this._pushArray,\n      Int32Array: this._pushArray,\n      Float32Array: this._pushFloat32Array,\n      Float64Array: this._pushFloat64Array\n    }\n\n    // tsc doesn't know about old Url\n    if (url['Url']) {\n      this.addSemanticType('Url', this._pushUrl)\n    }\n    if (url['URL']) {\n      this.addSemanticType('URL', this._pushURL)\n    }\n\n    const addTypes = opts.genTypes || []\n    for (let i = 0, len = addTypes.length; i < len; i += 2) {\n      this.addSemanticType(addTypes[i], addTypes[i + 1])\n    }\n  }\n\n  _transform(fresh, encoding, cb) {\n    const ret = this.pushAny(fresh)\n    // Old transformers might not return bool.  undefined !== false\n    return cb((ret === false) ? new Error('Push Error') : undefined)\n  }\n\n  _flush(cb) {\n    return cb()\n  }\n\n  /**\n   * @callback encodeFunction\n   * @param {Encoder} encoder - the encoder to serialize into.  Call \"write\"\n   *   on the encoder as needed.\n   * @return {bool} - true on success, else false\n   */\n\n  /**\n   * Add an encoding function to the list of supported semantic types.  This is\n   * useful for objects for which you can't add an encodeCBOR method\n   *\n   * @param {any} type\n   * @param {any} fun\n   * @returns {encodeFunction}\n   */\n  addSemanticType(type, fun) {\n    if (typeof fun !== 'function') {\n      throw new TypeError('fun must be of type function')\n    }\n    const typeName = (typeof type === 'string') ? type : type.name\n    const old = this.semanticTypes[typeName]\n    this.semanticTypes[typeName] = fun\n    return old\n  }\n\n  _pushUInt8(val) {\n    const b = Buffer.allocUnsafe(1)\n    b.writeUInt8(val, 0)\n    return this.push(b)\n  }\n\n  _pushUInt16BE(val) {\n    const b = Buffer.allocUnsafe(2)\n    b.writeUInt16BE(val, 0)\n    return this.push(b)\n  }\n\n  _pushUInt32BE(val) {\n    const b = Buffer.allocUnsafe(4)\n    b.writeUInt32BE(val, 0)\n    return this.push(b)\n  }\n\n  _pushFloatBE(val) {\n    const b = Buffer.allocUnsafe(4)\n    b.writeFloatBE(val, 0)\n    return this.push(b)\n  }\n\n  _pushDoubleBE(val) {\n    const b = Buffer.allocUnsafe(8)\n    b.writeDoubleBE(val, 0)\n    return this.push(b)\n  }\n\n  _pushNaN() {\n    return this.push(BUF_NAN)\n  }\n\n  _pushInfinity(obj) {\n    const half = (obj < 0) ? BUF_INF_NEG : BUF_INF_POS\n    return this.push(half)\n  }\n\n  _pushFloat(obj) {\n    if (this.canonical) {\n      // TODO: is this enough slower to hide behind canonical?\n      // It's certainly enough of a hack (see utils.parseHalf)\n\n      // From section 3.9:\n      // If a protocol allows for IEEE floats, then additional canonicalization\n      // rules might need to be added.  One example rule might be to have all\n      // floats start as a 64-bit float, then do a test conversion to a 32-bit\n      // float; if the result is the same numeric value, use the shorter value\n      // and repeat the process with a test conversion to a 16-bit float.  (This\n      // rule selects 16-bit float for positive and negative Infinity as well.)\n\n      // which seems pretty much backwards to me.\n      const b2 = Buffer.allocUnsafe(2)\n      if (utils.writeHalf(b2, obj)) {\n        // I have convinced myself that there are no cases where writeHalf\n        // will return true but `utils.parseHalf(b2) !== obj)`\n        return this._pushUInt8(HALF) && this.push(b2)\n      }\n    }\n    if (Math.fround(obj) === obj) {\n      return this._pushUInt8(FLOAT) && this._pushFloatBE(obj)\n    }\n\n    return this._pushUInt8(DOUBLE) && this._pushDoubleBE(obj)\n  }\n\n  _pushInt(obj, mt, orig) {\n    const m = mt << 5\n    switch (false) {\n      case !(obj < 24):\n        return this._pushUInt8(m | obj)\n      case !(obj <= 0xff):\n        return this._pushUInt8(m | NUMBYTES.ONE) && this._pushUInt8(obj)\n      case !(obj <= 0xffff):\n        return this._pushUInt8(m | NUMBYTES.TWO) && this._pushUInt16BE(obj)\n      case !(obj <= 0xffffffff):\n        return this._pushUInt8(m | NUMBYTES.FOUR) && this._pushUInt32BE(obj)\n      case !(obj <= Number.MAX_SAFE_INTEGER):\n        return this._pushUInt8(m | NUMBYTES.EIGHT) &&\n          this._pushUInt32BE(Math.floor(obj / SHIFT32)) &&\n          this._pushUInt32BE(obj % SHIFT32)\n      default:\n        if (mt === MT.NEG_INT) {\n          return this._pushFloat(orig)\n        } else {\n          return this._pushFloat(obj)\n        }\n    }\n  }\n\n  _pushIntNum(obj) {\n    if (Object.is(obj, -0)) {\n      return this.push(BUF_NEG_ZERO)\n    }\n\n    if (obj < 0) {\n      return this._pushInt(-obj - 1, MT.NEG_INT, obj)\n    } else {\n      return this._pushInt(obj, MT.POS_INT)\n    }\n  }\n\n  _pushNumber(obj) {\n    switch (false) {\n      case !isNaN(obj):\n        return this._pushNaN()\n      case isFinite(obj):\n        return this._pushInfinity(obj)\n      case Math.round(obj) !== obj:\n        return this._pushIntNum(obj)\n      default:\n        return this._pushFloat(obj)\n    }\n  }\n\n  _pushString(obj) {\n    const len = Buffer.byteLength(obj, 'utf8')\n    return this._pushInt(len, MT.UTF8_STRING) && this.push(obj, 'utf8')\n  }\n\n  _pushBoolean(obj) {\n    return this._pushUInt8(obj ? TRUE : FALSE)\n  }\n\n  _pushUndefined(obj) {\n    switch (typeof this.encodeUndefined) {\n      case 'undefined':\n        return this._pushUInt8(UNDEFINED)\n      case 'function':\n        return this.pushAny(this.encodeUndefined.call(this, obj))\n      case 'object':\n        if (Buffer.isBuffer(this.encodeUndefined)) {\n          return this.push(this.encodeUndefined)\n        }\n    }\n    return this.pushAny(this.encodeUndefined)\n  }\n\n  _pushNull(obj) {\n    return this._pushUInt8(NULL)\n  }\n\n  _pushArray(gen, obj, opts) {\n    opts = Object.assign({\n      indefinite: false\n    }, opts)\n    const len = obj.length\n    if (opts.indefinite) {\n      if (!gen._pushUInt8((MT.ARRAY << 5) | NUMBYTES.INDEFINITE)) {\n        return false\n      }\n    } else if (!gen._pushInt(len, MT.ARRAY)) {\n      return false\n    }\n    for (let j = 0; j < len; j++) {\n      if (!gen.pushAny(obj[j])) {\n        return false\n      }\n    }\n    if (opts.indefinite) {\n      if (!gen.push(BREAK)) {\n        return false\n      }\n    }\n    return true\n  }\n\n  _pushTag(tag) {\n    return this._pushInt(tag, MT.TAG)\n  }\n\n  _pushDate(gen, obj) {\n    switch (gen.dateType) {\n      case 'string':\n        return gen._pushTag(TAG.DATE_STRING) &&\n          gen._pushString(obj.toISOString())\n      case 'int':\n      case 'integer':\n        return gen._pushTag(TAG.DATE_EPOCH) &&\n          gen._pushIntNum(Math.round(obj / 1000))\n      case 'float':\n        // force float\n        return gen._pushTag(TAG.DATE_EPOCH) &&\n          gen._pushFloat(obj / 1000)\n      case 'number':\n      default:\n        // if we happen to have an integral number of seconds,\n        // use integer.  Otherwise, use float.\n        return gen._pushTag(TAG.DATE_EPOCH) &&\n          gen.pushAny(obj / 1000)\n    }\n  }\n\n  _pushBuffer(gen, obj) {\n    return gen._pushInt(obj.length, MT.BYTE_STRING) && gen.push(obj)\n  }\n\n  _pushNoFilter(gen, obj) {\n    return gen._pushBuffer(gen, obj.slice())\n  }\n\n  _pushRegexp(gen, obj) {\n    return gen._pushTag(TAG.REGEXP) && gen.pushAny(obj.source)\n  }\n\n  _pushSet(gen, obj) {\n    if (!gen._pushInt(obj.size, MT.ARRAY)) {\n      return false\n    }\n    for (const x of obj) {\n      if (!gen.pushAny(x)) {\n        return false\n      }\n    }\n    return true\n  }\n\n  _pushUrl(gen, obj) {\n    return gen._pushTag(TAG.URI) && gen.pushAny(obj.format())\n  }\n\n  _pushURL(gen, obj) {\n    return gen._pushTag(TAG.URI) && gen.pushAny(obj.toString())\n  }\n\n  /**\n   * @param {bignumber} obj\n   * @private\n   */\n  _pushBigint(obj) {\n    let m = MT.POS_INT\n    let tag = TAG.POS_BIGINT\n\n    if (obj.isNegative()) {\n      obj = obj.negated().minus(1)\n      m = MT.NEG_INT\n      tag = TAG.NEG_BIGINT\n    }\n\n    if (this.collapseBigIntegers &&\n        obj.lte(BN.MAXINT64)) {\n      //  special handiling for 64bits\n      if (obj.lte(BN.MAXINT32)) {\n        return this._pushInt(obj.toNumber(), m)\n      }\n      return this._pushUInt8((m << 5) | NUMBYTES.EIGHT) &&\n        this._pushUInt32BE(obj.dividedToIntegerBy(BN.SHIFT32).toNumber()) &&\n        this._pushUInt32BE(obj.mod(BN.SHIFT32).toNumber())\n    }\n    let str = obj.toString(16)\n    if (str.length % 2) {\n      str = '0' + str\n    }\n    const buf = Buffer.from(str, 'hex')\n    return this._pushTag(tag) && this._pushBuffer(this, buf)\n  }\n\n  /**\n   * @param {bigint} obj\n   * @private\n   */\n  _pushJSBigint(obj) {\n    let m = MT.POS_INT\n    let tag = TAG.POS_BIGINT\n    // BigInt doesn't have -0\n    if (obj < 0) {\n      obj = -obj + BI.MINUS_ONE\n      m = MT.NEG_INT\n      tag = TAG.NEG_BIGINT\n    }\n\n    if (this.collapseBigIntegers &&\n        (obj <= BI.MAXINT64)) {\n      //  special handiling for 64bits\n      if (obj <= 0xffffffff) {\n        return this._pushInt(Number(obj), m)\n      }\n      return this._pushUInt8((m << 5) | NUMBYTES.EIGHT) &&\n        this._pushUInt32BE(Number(obj / BI.SHIFT32)) &&\n        this._pushUInt32BE(Number(obj % BI.SHIFT32))\n    }\n\n    let str = obj.toString(16)\n    if (str.length % 2) {\n      str = '0' + str\n    }\n    const buf = Buffer.from(str, 'hex')\n    return this._pushTag(tag) && this._pushBuffer(this, buf)\n  }\n\n  _pushBigNumber(gen, obj) {\n    if (obj.isNaN()) {\n      return gen._pushNaN()\n    }\n    if (!obj.isFinite()) {\n      return gen._pushInfinity(obj.isNegative() ? -Infinity : Infinity)\n    }\n    if (obj.isInteger()) {\n      return gen._pushBigint(obj)\n    }\n    if (!(gen._pushTag(TAG.DECIMAL_FRAC) &&\n      gen._pushInt(2, MT.ARRAY))) {\n      return false\n    }\n\n    const dec = obj.decimalPlaces()\n    const slide = obj.shiftedBy(dec)\n    if (!gen._pushIntNum(-dec)) {\n      return false\n    }\n    if (slide.abs().isLessThan(BN.MAXINT)) {\n      return gen._pushIntNum(slide.toNumber())\n    } else {\n      return gen._pushBigint(slide)\n    }\n  }\n\n  _pushMap(gen, obj, opts) {\n    opts = Object.assign({\n      indefinite: false\n    }, opts)\n    if (opts.indefinite) {\n      if (!gen._pushUInt8((MT.MAP << 5) | NUMBYTES.INDEFINITE)) {\n        return false\n      }\n    } else if (!gen._pushInt(obj.size, MT.MAP)) {\n      return false\n    }\n    // memoizing the cbor only helps in certain cases, and hurts in most\n    // others.  Just avoid it.\n    if (gen.canonical) {\n      // keep the key/value pairs together, so we don't have to do odd\n      // gets with object keys later\n      const entries = [...obj.entries()]\n      const enc = new Encoder(this) // TODO: fix genTypes\n      const bs = new NoFilter({highWaterMark:this.readableHighWaterMark})\n      enc.pipe(bs)\n      entries.sort(([a], [b]) => {\n        // a, b are the keys\n        enc.pushAny(a)\n        const a_cbor = bs.read()\n        enc.pushAny(b)\n        const b_cbor = bs.read()\n        return a_cbor.compare(b_cbor)\n      })\n      for (const [k, v] of entries) {\n        if (gen.disallowUndefinedKeys && (typeof k === 'undefined')) {\n          throw new Error('Invalid Map key: undefined')\n        }\n        if (!(gen.pushAny(k) && gen.pushAny(v))) {\n          return false\n        }\n      }\n    } else {\n      for (const [k, v] of obj) {\n        if (gen.disallowUndefinedKeys && (typeof k === 'undefined')) {\n          throw new Error('Invalid Map key: undefined')\n        }\n        if (!(gen.pushAny(k) && gen.pushAny(v))) {\n          return false\n        }\n      }\n    }\n    if (opts.indefinite) {\n      if (!gen.push(BREAK)) {\n        return false\n      }\n    }\n    return true\n  }\n\n  _pushUint8Array(gen, obj) {\n    return gen._pushBuffer(gen, Buffer.from(obj))\n  }\n\n  _pushFloat32Array(gen, obj) {\n    const len = obj.length\n    if (!gen._pushInt(len, MT.ARRAY)) {\n      return false\n    }\n    for (let j = 0; j < len; j++) {\n      if (!gen._pushUInt8(FLOAT) || !gen._pushFloatBE(obj[j])) {\n        return false\n      }\n    }\n    return true\n  }\n\n  _pushFloat64Array(gen, obj) {\n    const len = obj.length\n    if (!gen._pushInt(len, MT.ARRAY)) {\n      return false\n    }\n    for (let j = 0; j < len; j++) {\n      if (!gen._pushUInt8(DOUBLE) || !gen._pushDoubleBE(obj[j])) {\n        return false\n      }\n    }\n    return true\n  }\n\n  /**\n   * Remove all of the loop detector additions to the given object.\n   *\n   * @param {Object} obj - object to clean\n   * @returns {bool} - true when the object was cleaned, else false\n   */\n  removeLoopDetectors(obj) {\n    if (!this.detectLoops) {\n      return false\n    }\n    return Encoder.removeLoopDetectors(obj, this.detectLoops)\n  }\n\n  /**\n   * Remove all of the loop detector additions to the given object.\n   * The static version is easier to call when you don't have a full\n   * encoder instance available; it uses a good heuristic to figure\n   * out the loop detector symbol.\n   *\n   * @param {Object} obj - object to clean\n   * @param {Symbol} [detector=null] - the symbol to clean, or null\n   *   to use the first detected symbol\n   * @returns {bool} - true when the object was cleaned, else false\n   */\n  static removeLoopDetectors(obj, detector=null) {\n    if ((typeof(obj) !== 'object') || !obj) {\n      return false\n    }\n    const dl = obj[LOOP_DETECT]\n    if (!dl) {\n      // ironically, use loop marking to detect loops on removal as well\n      return false\n    }\n    if (detector == null) {\n      detector = dl\n    } else {\n      if (detector !== dl) {\n        return false\n      }\n    }\n    delete obj[LOOP_DETECT]\n    if (Array.isArray(obj)) {\n      for (const i of obj) {\n        this.removeLoopDetectors(i, detector)\n      }\n    } else {\n      for (const k in obj) {\n        this.removeLoopDetectors(obj[k], detector)\n      }\n    }\n    return true\n  }\n\n  _pushObject(obj, opts) {\n    if (!obj) {\n      return this._pushNull(obj)\n    }\n    opts = Object.assign({\n      indefinite: false,\n      skipTypes: false\n    }, opts)\n    if (!opts.indefinite) {\n      // this will only happen the first time through for indefinite encoding\n      if (this.detectLoops) {\n        if (obj[LOOP_DETECT] === this.detectLoops) {\n          throw new Error('Loop detected while CBOR encoding')\n        } else {\n          obj[LOOP_DETECT] = this.detectLoops\n        }\n      }\n    }\n    if (!opts.skipTypes) {\n      const f = obj.encodeCBOR\n      if (typeof f === 'function') {\n        return f.call(obj, this)\n      }\n      const converter = this.semanticTypes[obj.constructor.name]\n      if (converter) {\n        return converter.call(obj, this, obj)\n      }\n    }\n    const keys = Object.keys(obj).filter(k => typeof obj[k] !== 'function')\n    const cbor_keys = {}\n    if (this.canonical) {\n      // note: this can't be a normal sort, because 'b' needs to sort before\n      // 'aa'\n      keys.sort((a, b) => {\n        // Always strings, so don't bother to pass options.\n        // hold on to the cbor versions, since there's no need\n        // to encode more than once\n        const a_cbor = cbor_keys[a] || (cbor_keys[a] = Encoder.encode(a))\n        const b_cbor = cbor_keys[b] || (cbor_keys[b] = Encoder.encode(b))\n\n        return a_cbor.compare(b_cbor)\n      })\n    }\n    if (opts.indefinite) {\n      if (!this._pushUInt8((MT.MAP << 5) | NUMBYTES.INDEFINITE)) {\n        return false\n      }\n    } else if (!this._pushInt(keys.length, MT.MAP)) {\n      return false\n    }\n    let ck\n    for (let j = 0, len2 = keys.length; j < len2; j++) {\n      const k = keys[j]\n      if (this.canonical && ((ck = cbor_keys[k]))) {\n        if (!this.push(ck)) { // already a Buffer\n          return false\n        }\n      } else {\n        if (!this._pushString(k)) {\n          return false\n        }\n      }\n      if (!this.pushAny(obj[k])) {\n        return false\n      }\n    }\n    if (opts.indefinite) {\n      if (!this.push(BREAK)) {\n        return false\n      }\n    }\n    return true\n  }\n\n  /**\n   * Push any supported type onto the encoded stream\n   *\n   * @param {any} obj\n   * @returns {boolean} true on success\n   */\n  pushAny(obj) {\n    switch (typeof obj) {\n      case 'number':\n        return this._pushNumber(obj)\n      case 'bigint':\n        return this._pushJSBigint(obj)\n      case 'string':\n        return this._pushString(obj)\n      case 'boolean':\n        return this._pushBoolean(obj)\n      case 'undefined':\n        return this._pushUndefined(obj)\n      case 'object':\n        return this._pushObject(obj)\n      case 'symbol':\n        switch (obj) {\n          case SYMS.NULL:\n            return this._pushNull(null)\n          case SYMS.UNDEFINED:\n            return this._pushUndefined(void 0)\n          // TODO: Add pluggable support for other symbols\n          default:\n            throw new Error('Unknown symbol: ' + obj.toString())\n        }\n      default:\n        throw new Error(\n          'Unknown type: ' + typeof obj + ', ' +\n          (!!obj.toString ? obj.toString() : ''))\n    }\n  }\n\n  /* backwards-compat wrapper */\n  _pushAny(obj) {\n    // TODO: write deprecation warning\n    return this.pushAny(obj)\n  }\n\n  _encodeAll(objs) {\n    const bs = new NoFilter({ highWaterMark:this.readableHighWaterMark })\n    this.pipe(bs)\n    for (const o of objs) {\n      this.pushAny(o)\n    }\n    this.end()\n    return bs.read()\n  }\n\n  /**\n   * Encode the given object with indefinite length.  There are apparently\n   * some (IMO) broken implementations of poorly-specified protocols that\n   * REQUIRE indefinite-encoding.  Add this to an object or class as the\n   * `encodeCBOR` function to get indefinite encoding:\n   * @example\n   * const o = {\n   *   a: true,\n   *   encodeCBOR: cbor.Encoder.encodeIndefinite\n   * }\n   * const m = []\n   * m.encodeCBOR = cbor.Encoder.encodeIndefinite\n   * cbor.encodeOne([o, m])\n   *\n   * @param {Encoder} - the encoder to use\n   * @param {String|Buffer|Array|Map|Object} [obj] - the object to encode.  If\n   *   null, use \"this\" instead.\n   * @param {Object} [opts=null] - Options for encoding\n   * @param {boolean} [opts.chunkSize=4096] - Number of characters or bytes\n   *  for each chunk, if obj is a string or Buffer\n   * @returns {boolean} - true on success\n   */\n  static encodeIndefinite(gen, obj, opts) {\n    if (obj == null) {\n      if (this == null) {\n        throw new Error('No object to encode')\n      }\n      obj = this\n    }\n    opts = Object.assign({\n      chunkSize: 4096\n    }, opts)\n\n    let ret = true\n    const objType = typeof obj\n    if (objType === 'string') {\n      // TODO: make sure not to split surrogate pairs at the edges of chunks,\n      // since such half-surrogates cannot be legally encoded as UTF-8.\n      ret = ret && gen._pushUInt8((MT.UTF8_STRING << 5) | NUMBYTES.INDEFINITE)\n      let offset = 0\n      while (offset < obj.length) {\n        const endIndex = offset + opts.chunkSize\n        ret = ret && gen._pushString(obj.slice(offset, endIndex))\n        offset = endIndex\n      }\n      ret = ret && gen.push(BREAK)\n    } else if (Buffer.isBuffer(obj)) {\n      ret = ret && gen._pushUInt8((MT.BYTE_STRING << 5) | NUMBYTES.INDEFINITE)\n      let offset = 0\n      while (offset < obj.length) {\n        const endIndex = offset + opts.chunkSize\n        ret = ret && gen._pushBuffer(gen, obj.slice(offset, endIndex))\n        offset = endIndex\n      }\n      ret = ret && gen.push(BREAK)\n    } else if (Array.isArray(obj)) {\n      ret = ret && gen._pushArray(gen, obj, {\n        indefinite: true\n      })\n    } else if (obj instanceof Map) {\n      ret = ret && gen._pushMap(gen, obj, {\n        indefinite: true\n      })\n    } else {\n      if (objType !== 'object') {\n        throw new Error('Invalid indefinite encoding')\n      }\n      ret = ret && gen._pushObject(obj, {\n        indefinite: true,\n        skipTypes: true\n      })\n    }\n    return ret\n  }\n\n  /**\n   * Encode one or more JavaScript objects, and return a Buffer containing the\n   * CBOR bytes.\n   *\n   * @param {...any} objs - the objects to encode\n   * @returns {Buffer} - the encoded objects\n   */\n  static encode(...objs) {\n    return new Encoder()._encodeAll(objs)\n  }\n\n  /**\n   * Encode one or more JavaScript objects canonically (slower!), and return\n   * a Buffer containing the CBOR bytes.\n   *\n   * @param {...any} objs - the objects to encode\n   * @returns {Buffer} - the encoded objects\n   */\n  static encodeCanonical(...objs) {\n    return new Encoder({canonical: true})._encodeAll(objs)\n  }\n\n  /**\n   * Encode one JavaScript object using the given options.\n   *\n   * @static\n   * @param {any} obj - the object to encode\n   * @param {Object?} options - passed to the Encoder constructor\n   * @returns {Buffer} - the encoded objects\n   */\n  static encodeOne(obj, options) {\n    return new Encoder(options)._encodeAll([obj])\n  }\n\n  /**\n   * Encode one JavaScript object using the given options in a way that\n   * is more resilient to objects being larger than the highWaterMark\n   * number of bytes.  As with the other static encode functions, this \n   * will still use a large amount of memory.  Use a stream-based approach\n   * directly if you need to process large and complicated inputs.\n   *\n   * @param {any} obj - the object to encode\n   * @param {Object?} options - passed to the Encoder constructor\n   */\n  static encodeAsync(obj, options) {\n    return new Promise((resolve, reject) => {\n      const bufs = []\n      const enc = new Encoder(options)\n      enc.on('data', buf => bufs.push(buf))\n      enc.on('error', reject)\n      enc.on('finish', () => resolve(Buffer.concat(bufs)))\n      enc.pushAny(obj)\n      enc.end()\n    })\n  }\n}\n\nmodule.exports = Encoder\n","'use strict'\n\nconst stream = require('stream')\nconst util = require('util')\n\n/**\n * NoFilter stream.  Can be used to sink or source data to and from\n * other node streams.  Implemented as the \"identity\" Transform stream\n * (hence the name), but allows for inspecting data that is in-flight.\n *\n * Allows passing in source data (input, inputEncoding) at creation\n * time.  Source data can also be passed in the options object.\n *\n * @example <caption>source</caption>\n * const n = new NoFilter('Zm9v', 'base64');\n * n.pipe(process.stdout);\n *\n * @example <caption>sink</caption>\n * const n = new Nofilter();\n * // NOTE: 'finish' fires when the input is done writing\n * n.on('finish', function() { console.log(n.toString('base64')); });\n * process.stdin.pipe(n);\n */\nclass NoFilter extends stream.Transform {\n  /**\n   * Create an instance of NoFilter.\n   *\n   * @param {string|Buffer} [input] - Source data\n   * @param {string} [inputEncoding=null] - Encoding name for input,\n   *   ignored if input is not a String\n   * @param {Object} [options={}] - Other options\n   * @param {string|Buffer} [options.input=null] - Input source data\n   * @param {string} [options.inputEncoding=null] - Encoding name for input,\n   *   ignored if input is not a String\n   * @param {number} [options.highWaterMark=16384] - The maximum number of bytes\n   *   to store in the internal buffer before ceasing to read from the\n   *   underlying resource. Default=16kb, or 16 for objectMode streams\n   * @param {string} [options.encoding=null] - If specified, then buffers will\n   *   be decoded to strings using the specified encoding\n   * @param {boolean} [options.objectMode=false] - Whether this stream should\n   *   behave as a stream of objects. Meaning that stream.read(n) returns a\n   *   single value instead of a Buffer of size n\n   * @param {boolean} [options.decodeStrings=true] - Whether or not to decode\n   *   strings into Buffers before passing them to _write()\n   * @param {boolean} [options.watchPipe=true] - Whether to watch for 'pipe'\n   *   events, setting this stream's objectMode based on the objectMode of the\n   *   input stream\n   * @param {boolean} [options.readError=false] - If true, when a read()\n   *   underflows, throw an error.\n   */\n  constructor(input, inputEncoding, options) {\n    if (options == null) {\n      options = {}\n    }\n    let inp\n    let inpE\n    switch (typeof(input)) {\n      case 'object':\n        if (Buffer.isBuffer(input)) {\n          inp = input\n          if ((inputEncoding != null) && (typeof(inputEncoding) === 'object')) {\n            options = inputEncoding\n          }\n        } else {\n          options = input\n        }\n        break\n      case 'string':\n        inp = input\n        if ((inputEncoding != null) && (typeof(inputEncoding) === 'object')) {\n          options = inputEncoding\n        } else {\n          inpE = inputEncoding\n        }\n        break\n    }\n\n    if ((options == null)) {\n      options = {}\n    }\n    if (inp == null) {\n      inp = options.input\n    }\n    if (inpE == null) {\n      inpE = options.inputEncoding\n    }\n    delete options.input\n    delete options.inputEncoding\n    const watchPipe = options.watchPipe != null ? options.watchPipe : true\n    delete options.watchPipe\n    const readError = !! options.readError\n    delete options.readError\n    super(options)\n\n    this.readError = readError\n\n    if (watchPipe) {\n      this.on('pipe', readable => {\n        const om = readable._readableState.objectMode\n        if ((this.length > 0) && (om !== this._readableState.objectMode)) {\n          throw new Error(\n            'Do not switch objectMode in the middle of the stream')\n        }\n\n        this._readableState.objectMode = om\n        return this._writableState.objectMode = om\n      })\n    }\n\n    if (inp != null) {\n      this.end(inp, inpE)\n    }\n  }\n\n  /**\n   * Is the given object a {NoFilter}?\n   *\n   * @param {Object} obj The object to test.\n   * @returns {boolean} true if obj is a NoFilter\n   */\n  static isNoFilter(obj) {\n    return obj instanceof this\n  }\n\n  /**\n   * The same as nf1.compare(nf2). Useful for sorting an Array of NoFilters.\n   *\n   * @param {NoFilter} nf1 - The first object to compare\n   * @param {NoFilter} nf2 - The second object to compare\n   * @returns {number} -1, 0, 1 for less, equal, greater\n   *\n   * @example\n   * const arr = [new NoFilter('1234'), new NoFilter('0123')];\n   * arr.sort(NoFilter.compare);\n   */\n  static compare(nf1, nf2) {\n    if (!(nf1 instanceof this)) {\n      throw new TypeError('Arguments must be NoFilters')\n    }\n    if (nf1 === nf2) {\n      return 0\n    } else {\n      return nf1.compare(nf2)\n    }\n  }\n\n  /**\n   * Returns a buffer which is the result of concatenating all the\n   * NoFilters in the list together. If the list has no items, or if\n   * the totalLength is 0, then it returns a zero-length buffer.\n   *\n   * If length is not provided, it is read from the buffers in the\n   * list. However, this adds an additional loop to the function, so\n   * it is faster to provide the length explicitly if you already know it.\n   *\n   * @param {Array<NoFilter>} list Inputs.  Must not be all either in object\n   *   mode, or all not in object mode.\n   * @param {number} [length=null] Number of bytes or objects to read\n   * @returns {Buffer|Array} The concatenated values as an array if in object\n   *   mode, otherwise a Buffer\n   */\n  static concat(list, length) {\n    if (!Array.isArray(list)) {\n      throw new TypeError('list argument must be an Array of NoFilters')\n    }\n    if ((list.length === 0) || (length === 0)) {\n      return Buffer.alloc(0)\n    }\n    if ((length == null)) {\n      length = list.reduce((tot, nf) => {\n        if (!(nf instanceof NoFilter)) {\n          throw new TypeError('list argument must be an Array of NoFilters')\n        }\n        return tot + nf.length\n      }, 0)\n    }\n    let allBufs = true\n    let allObjs = true\n    const bufs = list.map(nf => {\n      if (!(nf instanceof NoFilter)) {\n        throw new TypeError('list argument must be an Array of NoFilters')\n      }\n      const buf = nf.slice()\n      if (Buffer.isBuffer(buf)) {\n        allObjs = false\n      } else {\n        allBufs = false\n      }\n      return buf\n    })\n    if (allBufs) {\n      return Buffer.concat(bufs, length)\n    }\n    if (allObjs) {\n      return [].concat(...bufs).slice(0, length)\n    }\n    // TODO: maybe coalesce buffers, counting bytes, and flatten in arrays\n    // counting objects?  I can't imagine why that would be useful.\n    throw new Error('Concatenating mixed object and byte streams not supported')\n  }\n\n  /**\n   * @private\n   */\n  _transform(chunk, encoding, callback) {\n    if (!this._readableState.objectMode && !Buffer.isBuffer(chunk)) {\n      chunk = Buffer.from(chunk, encoding)\n    }\n    this.push(chunk)\n    callback()\n  }\n\n  /**\n   * @private\n   */\n  _bufArray() {\n    let bufs = this._readableState.buffer\n    // HACK: replace with something else one day.  This is what I get for\n    // relying on internals.\n    if (!Array.isArray(bufs)) {\n      let b = bufs.head\n      bufs = []\n      while (b != null) {\n        bufs.push(b.data)\n        b = b.next\n      }\n    }\n    return bufs\n  }\n\n  /**\n   * Pulls some data out of the internal buffer and returns it.\n   * If there is no data available, then it will return null.\n   *\n   * If you pass in a size argument, then it will return that many bytes. If\n   * size bytes are not available, then it will return null, unless we've\n   * ended, in which case it will return the data remaining in the buffer.\n   *\n   * If you do not specify a size argument, then it will return all the data in\n   * the internal buffer.\n   *\n   * @param {number} [size=null] - Number of bytes to read.\n   * @returns {string|Buffer|null} If no data or not enough data, null.  If\n   *   decoding output a string, otherwise a Buffer\n   * @throws Error - if readError is true and there was underflow\n   * @fires NoFilter#read\n   */\n  read(size) {\n    const buf = super.read(size)\n    if (buf != null) {\n      /*\n       * Read event. Fired whenever anything is read from the stream.\n       *\n       * @event NoFilter#read\n       * @type {Buffer|string|Object}\n       *\n       */\n      this.emit('read', buf)\n      if (this.readError && (buf.length < size)) {\n        throw new Error(`Read ${buf.length}, wanted ${size}`)\n      }\n    } else if (this.readError) {\n      throw new Error(`No data available, wanted ${size}`)\n    }\n    return buf\n  }\n\n  /**\n   * Return a promise fulfilled with the full contents, after the 'finish'\n   * event fires.  Errors on the stream cause the promise to be rejected.\n   *\n   * @param {function} [cb=null] - finished/error callback used in *addition*\n   *   to the promise\n   * @returns {Promise<Buffer|String>} fulfilled when complete\n   */\n  promise(cb) {\n    let done = false\n    return new Promise((resolve, reject) => {\n      this.on('finish', () => {\n        const data = this.read()\n        if ((cb != null) && !done) {\n          done = true\n          cb(null, data)\n        }\n        resolve(data)\n      })\n      this.on('error', (er) => {\n        if ((cb != null) && !done) {\n          done = true\n          cb(er)\n        }\n        reject(er)\n      })\n    })\n  }\n\n  /**\n   * Returns a number indicating whether this comes before or after or is the\n   * same as the other NoFilter in sort order.\n   *\n   * @param {NoFilter} other - The other object to compare\n   * @returns {Number} -1, 0, 1 for less, equal, greater\n   */\n  compare(other) {\n    if (!(other instanceof NoFilter)) {\n      throw new TypeError('Arguments must be NoFilters')\n    }\n    if (this === other) {\n      return 0\n    } else {\n      const buf1 = this.slice()\n      const buf2 = other.slice()\n      // these will both be buffers because of the check above.\n      if (Buffer.isBuffer(buf1) && Buffer.isBuffer(buf2)) {\n        return buf1.compare(buf2)\n      }\n      throw new Error('Cannot compare streams in object mode')\n    }\n  }\n\n  /**\n   * Do these NoFilter's contain the same bytes?  Doesn't work if either is\n   * in object mode.\n   *\n   * @param {NoFilter} other\n   * @returns {boolean} Equal?\n   */\n  equals(other) {\n    return this.compare(other) === 0\n  }\n\n  /**\n   * Read bytes or objects without consuming them.  Useful for diagnostics.\n   * Note: as a side-effect, concatenates multiple writes together into what\n   * looks like a single write, so that this concat doesn't have to happen\n   * multiple times when you're futzing with the same NoFilter.\n   *\n   * @param {Number} [start=0] - beginning offset\n   * @param {Number} [end=length] - ending offset\n   * @returns {Buffer|Array} if in object mode, an array of objects.  Otherwise,\n   *   concatenated array of contents.\n   */\n  slice(start, end) {\n    if (this._readableState.objectMode) {\n      return this._bufArray().slice(start, end)\n    }\n    const bufs = this._bufArray()\n    switch (bufs.length) {\n      case 0: return Buffer.alloc(0)\n      case 1: return bufs[0].slice(start, end)\n      default:\n        const b = Buffer.concat(bufs)\n        // TODO: store the concatented bufs back\n        // @_readableState.buffer = [b]\n        return b.slice(start, end)\n    }\n  }\n\n  /**\n    * Get a byte by offset.  I didn't want to get into metaprogramming\n    * to give you the `NoFilter[0]` syntax.\n    *\n    * @param {Number} index - The byte to retrieve\n    * @returns {Number} 0-255\n    */\n  get(index) {\n    return this.slice()[index]\n  }\n\n  /**\n   * Return an object compatible with Buffer's toJSON implementation, so\n   * that round-tripping will produce a Buffer.\n   *\n   * @returns {Object}\n   *\n   * @example output for 'foo'\n   *   { type: 'Buffer', data: [ 102, 111, 111 ] }\n   */\n  toJSON() {\n    const b = this.slice()\n    if (Buffer.isBuffer(b)) {\n      return b.toJSON()\n    } else {\n      return b\n    }\n  }\n\n  /**\n   * Decodes and returns a string from buffer data encoded using the specified\n   * character set encoding. If encoding is undefined or null, then encoding\n   * defaults to 'utf8'. The start and end parameters default to 0 and\n   * NoFilter.length when undefined.\n   *\n   * @param {String} [encoding='utf8'] - Which to use for decoding?\n   * @param {Number} [start=0] - Start offset\n   * @param {Number} [end=length] - End offset\n   * @returns {String}\n   */\n  toString(encoding, start, end) {\n    const buf = this.slice(start, end)\n    if (!Buffer.isBuffer(buf)) {\n      return JSON.stringify(buf)\n    }\n    if ((!encoding || (encoding === 'utf8')) && util.TextDecoder) {\n      const td = new util.TextDecoder('utf8', {\n        fatal: true,\n        ignoreBOM: true\n      })\n      return td.decode(buf)\n    }\n    return buf.toString(encoding, start, end)\n  }\n\n  /**\n   * @private\n   * @deprecated\n   */\n  inspect(depth, options) {\n    return this[util.inspect.custom](depth, options)\n  }\n\n  /**\n   * @private\n   */\n  [util.inspect.custom](depth, options) {\n    const bufs = this._bufArray()\n    const hex = bufs.map((b) => {\n      if (Buffer.isBuffer(b)) {\n        if ((options != null ? options.stylize : undefined)) {\n          return options.stylize(b.toString('hex'), 'string')\n        } else {\n          return b.toString('hex')\n        }\n      } else {\n        return util.inspect(b, options)\n      }\n    }).join(', ')\n    return `${this.constructor.name} [${hex}]`\n  }\n\n  /**\n   * Current readable length, in bytes.\n   *\n   * @member {number}\n   * @readonly\n   */\n  get length() {\n    return this._readableState.length\n  }\n\n  /**\n   * Write a JavaScript BigInt to the stream.  Negative numbers will be\n   * written as their 2's complement version.\n   *\n   * @param {bigint} val - The value to write\n   * @returns {boolean} true on success\n   */\n  writeBigInt(val) {\n    let str = val.toString(16)\n    if (val < 0) {\n      // two's complement\n      // Note: str always starts with '-' here.\n      const sz = BigInt(Math.floor(str.length / 2))\n      const mask = BigInt(1) << (sz * BigInt(8))\n      val = mask + val\n      str = val.toString(16)\n    }\n    if (str.length % 2) {\n      str = '0' + str\n    }\n    return this.push(Buffer.from(str, 'hex'))\n  }\n\n  /**\n   * Read a variable-sized JavaScript unsigned BigInt from the stream.\n   *\n   * @param {number}  [len=null] - number of bytes to read or all remaining\n   *   if null\n   * @returns {bigint}\n   */\n  readUBigInt(len) {\n    const b = this.read(len)\n    if (!Buffer.isBuffer(b)) {\n      return null\n    }\n    return BigInt('0x' + b.toString('hex'))\n  }\n\n  /**\n   * Read a variable-sized JavaScript signed BigInt from the stream in 2's\n   * complement format.\n   *\n   * @param {number} [len=null] - number of bytes to read or all remaining\n   *   if null\n   * @returns {bigint}\n   */\n  readBigInt(len) {\n    const b = this.read(len)\n    if (!Buffer.isBuffer(b)) {\n      return null\n    }\n    let ret = BigInt('0x' + b.toString('hex'))\n    // negative?\n    if (b[0] & 0x80) {\n      // two's complement\n      const mask = BigInt(1) << (BigInt(b.length) * BigInt(8))\n      ret = ret - mask\n    }\n    return ret\n  }\n}\n\n/**\n * @param {string} meth - method to call\n * @param {number} len - number of bytes to write\n * @private\n */\nfunction _read_gen(meth, len) {\n  return function(val) {\n    const b = this.read(len)\n    if (!Buffer.isBuffer(b)) {\n      return null\n    }\n    return b[meth].call(b, 0, true)\n  }\n}\n\n/**\n * @param {string} meth - method to call\n * @param {number} len - number of bytes to write\n * @private\n */\nfunction _write_gen(meth, len) {\n  return function(val) {\n    const b = Buffer.alloc(len)\n    b[meth].call(b, val, 0, true)\n    return this.push(b)\n  }\n}\n\nObject.assign(NoFilter.prototype, {\n  /**\n   * Write an 8-bit unsigned integer to the stream.  Adds 1 byte.\n   *\n   * @function writeUInt8\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value - 0-255\n   * @returns {boolean} true on success\n   */\n  writeUInt8: _write_gen('writeUInt8', 1),\n\n  /**\n   * Write a little-endian 16-bit unsigned integer to the stream.  Adds\n   * 2 bytes.\n   *\n   * @function writeUInt16LE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeUInt16LE: _write_gen('writeUInt16LE', 2),\n\n  /**\n   * Write a big-endian 16-bit unsigned integer to the stream.  Adds\n   * 2 bytes.\n   *\n   * @function writeUInt16BE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeUInt16BE: _write_gen('writeUInt16BE', 2),\n\n  /**\n   * Write a little-endian 32-bit unsigned integer to the stream.  Adds\n   * 4 bytes.\n   *\n   * @function writeUInt32LE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeUInt32LE: _write_gen('writeUInt32LE', 4),\n\n  /**\n   * Write a big-endian 32-bit unsigned integer to the stream.  Adds\n   * 4 bytes.\n   *\n   * @function writeUInt32BE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeUInt32BE: _write_gen('writeUInt32BE', 4),\n\n  /**\n   * Write a signed 8-bit integer to the stream.  Adds 1 byte.\n   *\n   * @function writeInt8\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeInt8: _write_gen('writeInt8', 1),\n\n  /**\n   * Write a signed little-endian 16-bit integer to the stream.  Adds 2 bytes.\n   *\n   * @function writeInt16LE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeInt16LE: _write_gen('writeInt16LE', 2),\n\n  /**\n   * Write a signed big-endian 16-bit integer to the stream.  Adds 2 bytes.\n   *\n   * @function writeInt16BE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeInt16BE: _write_gen('writeInt16BE', 2),\n\n  /**\n   * Write a signed little-endian 32-bit integer to the stream.  Adds 4 bytes.\n   *\n   * @function writeInt32LE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeInt32LE: _write_gen('writeInt32LE', 4),\n\n  /**\n   * Write a signed big-endian 32-bit integer to the stream.  Adds 4 bytes.\n   *\n   * @function writeInt32BE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeInt32BE: _write_gen('writeInt32BE', 4),\n\n  /**\n   * Write a little-endian 32-bit float to the stream.  Adds 4 bytes.\n   *\n   * @function writeFloatLE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeFloatLE: _write_gen('writeFloatLE', 4),\n\n  /**\n   * Write a big-endian 32-bit float to the stream.  Adds 4 bytes.\n   *\n   * @function writeFloatBE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeFloatBE: _write_gen('writeFloatBE', 4),\n\n  /**\n   * Write a little-endian 64-bit float to the stream.  Adds 8 bytes.\n   *\n   * @function writeDoubleLE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeDoubleLE: _write_gen('writeDoubleLE', 8),\n\n  /**\n   * Write a big-endian 64-bit float to the stream.  Adds 8 bytes.\n   *\n   * @function writeDoubleBE\n   * @memberOf NoFilter\n   * @instance\n   * @param {Number} value\n   * @returns {boolean} true on success\n   */\n  writeDoubleBE: _write_gen('writeDoubleBE', 8),\n\n  /**\n   * Read an unsigned 8-bit integer from the stream.  Consumes 1 byte.\n   *\n   * @function readUInt8\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readUInt8: _read_gen('readUInt8', 1),\n\n  /**\n   * Read a little-endian unsigned 16-bit integer from the stream.\n   * Consumes 2 bytes.\n   *\n   * @function readUInt16LE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readUInt16LE: _read_gen('readUInt16LE', 2),\n\n  /**\n   * Read a big-endian unsigned 16-bit integer from the stream.\n   * Consumes 2 bytes.\n   *\n   * @function readUInt16BE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readUInt16BE: _read_gen('readUInt16BE', 2),\n\n  /**\n   * Read a little-endian unsigned 32-bit integer from the stream.\n   * Consumes 4 bytes.\n   *\n   * @function readUInt32LE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readUInt32LE: _read_gen('readUInt32LE', 4),\n\n  /**\n   * Read a big-endian unsigned 16-bit integer from the stream.\n   * Consumes 4 bytes.\n   *\n   * @function readUInt32BE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readUInt32BE: _read_gen('readUInt32BE', 4),\n\n  /**\n   * Read a signed 8-bit integer from the stream.\n   * Consumes 1 byte.\n   *\n   * @function readInt8\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readInt8: _read_gen('readInt8', 1),\n\n  /**\n   * Read a signed 16-bit little-endian integer from the stream.\n   * Consumes 2 bytes.\n   *\n   * @function readInt16LE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readInt16LE: _read_gen('readInt16LE', 2),\n\n  /**\n   * Read a signed 16-bit big-endian integer from the stream.\n   * Consumes 2 bytes.\n   *\n   * @function readInt16BE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readInt16BE: _read_gen('readInt16BE', 2),\n\n  /**\n   * Read a signed 32-bit little-endian integer from the stream.\n   * Consumes 4 bytes.\n   *\n   * @function readInt32LE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readInt32LE: _read_gen('readInt32LE', 4),\n\n  /**\n   * Read a signed 32-bit big-endian integer from the stream.\n   * Consumes 4 bytes.\n   *\n   * @function readInt32BE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readInt32BE: _read_gen('readInt32BE', 4),\n\n  /**\n   * Read a 32-bit little-endian float from the stream.\n   * Consumes 4 bytes.\n   *\n   * @function readFloatLE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readFloatLE: _read_gen('readFloatLE', 4),\n\n  /**\n   * Read a 32-bit big-endian float from the stream.\n   * Consumes 4 bytes.\n   *\n   * @function readFloatBE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readFloatBE: _read_gen('readFloatBE', 4),\n\n  /**\n   * Read a 64-bit little-endian float from the stream.\n   * Consumes 8 bytes.\n   *\n   * @function readDoubleLE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readDoubleLE: _read_gen('readDoubleLE', 8),\n\n  /**\n   * Read a 64-bit big-endian float from the stream.\n   * Consumes 8 bytes.\n   *\n   * @function readDoubleBE\n   * @memberOf NoFilter\n   * @instance\n   * @returns {Number} value\n   */\n  readDoubleBE: _read_gen('readDoubleBE', 8)\n})\n\nmodule.exports = NoFilter\n","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","'use strict'\n\nexports.BigNumber = require('bignumber.js').BigNumber\nexports.Commented = require('./commented')\nexports.Diagnose = require('./diagnose')\nexports.Decoder = require('./decoder')\nexports.Encoder = require('./encoder')\nexports.Simple = require('./simple')\nexports.Tagged = require('./tagged')\nexports.Map = require('./map')\n\nexports.comment = exports.Commented.comment\nexports.decodeAll = exports.Decoder.decodeAll\nexports.decodeFirst = exports.Decoder.decodeFirst\nexports.decodeAllSync = exports.Decoder.decodeAllSync\nexports.decodeFirstSync = exports.Decoder.decodeFirstSync\nexports.diagnose = exports.Diagnose.diagnose\nexports.encode = exports.Encoder.encode\nexports.encodeCanonical = exports.Encoder.encodeCanonical\nexports.encodeOne = exports.Encoder.encodeOne\nexports.encodeAsync = exports.Encoder.encodeAsync\nexports.decode = exports.Decoder.decodeFirstSync\n\nexports.leveldb = {\n  decode: exports.Decoder.decodeAllSync,\n  encode: exports.Encoder.encode,\n  buffer: true,\n  name: 'cbor'\n}\n\nexports.hasBigInt = require('./utils').hasBigInt\n",";(function (globalObject) {\r\n  'use strict';\r\n\r\n/*\r\n *      bignumber.js v9.0.1\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2020 Michael Mclaughlin <M8ch88l@gmail.com>\r\n *      MIT Licensed.\r\n *\r\n *      BigNumber.prototype methods     |  BigNumber methods\r\n *                                      |\r\n *      absoluteValue            abs    |  clone\r\n *      comparedTo                      |  config               set\r\n *      decimalPlaces            dp     |      DECIMAL_PLACES\r\n *      dividedBy                div    |      ROUNDING_MODE\r\n *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT\r\n *      exponentiatedBy          pow    |      RANGE\r\n *      integerValue                    |      CRYPTO\r\n *      isEqualTo                eq     |      MODULO_MODE\r\n *      isFinite                        |      POW_PRECISION\r\n *      isGreaterThan            gt     |      FORMAT\r\n *      isGreaterThanOrEqualTo   gte    |      ALPHABET\r\n *      isInteger                       |  isBigNumber\r\n *      isLessThan               lt     |  maximum              max\r\n *      isLessThanOrEqualTo      lte    |  minimum              min\r\n *      isNaN                           |  random\r\n *      isNegative                      |  sum\r\n *      isPositive                      |\r\n *      isZero                          |\r\n *      minus                           |\r\n *      modulo                   mod    |\r\n *      multipliedBy             times  |\r\n *      negated                         |\r\n *      plus                            |\r\n *      precision                sd     |\r\n *      shiftedBy                       |\r\n *      squareRoot               sqrt   |\r\n *      toExponential                   |\r\n *      toFixed                         |\r\n *      toFormat                        |\r\n *      toFraction                      |\r\n *      toJSON                          |\r\n *      toNumber                        |\r\n *      toPrecision                     |\r\n *      toString                        |\r\n *      valueOf                         |\r\n *\r\n */\r\n\r\n\r\n  var BigNumber,\r\n    isNumeric = /^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i,\r\n    mathceil = Math.ceil,\r\n    mathfloor = Math.floor,\r\n\r\n    bignumberError = '[BigNumber Error] ',\r\n    tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\r\n\r\n    BASE = 1e14,\r\n    LOG_BASE = 14,\r\n    MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\r\n    // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\r\n    POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n    SQRT_BASE = 1e7,\r\n\r\n    // EDITABLE\r\n    // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n    // the arguments to toExponential, toFixed, toFormat, and toPrecision.\r\n    MAX = 1E9;                                   // 0 to MAX_INT32\r\n\r\n\r\n  /*\r\n   * Create and return a BigNumber constructor.\r\n   */\r\n  function clone(configObject) {\r\n    var div, convertBase, parseNumeric,\r\n      P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\r\n      ONE = new BigNumber(1),\r\n\r\n\r\n      //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\r\n\r\n\r\n      // The default values below must be integers within the inclusive ranges stated.\r\n      // The values can also be changed at run-time using BigNumber.set.\r\n\r\n      // The maximum number of decimal places for operations involving division.\r\n      DECIMAL_PLACES = 20,                     // 0 to MAX\r\n\r\n      // The rounding mode used when rounding to the above decimal places, and when using\r\n      // toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n      // UP         0 Away from zero.\r\n      // DOWN       1 Towards zero.\r\n      // CEIL       2 Towards +Infinity.\r\n      // FLOOR      3 Towards -Infinity.\r\n      // HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n      // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n      // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n      // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n      // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n      ROUNDING_MODE = 4,                       // 0 to 8\r\n\r\n      // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n      // The exponent value at and beneath which toString returns exponential notation.\r\n      // Number type: -7\r\n      TO_EXP_NEG = -7,                         // 0 to -MAX\r\n\r\n      // The exponent value at and above which toString returns exponential notation.\r\n      // Number type: 21\r\n      TO_EXP_POS = 21,                         // 0 to MAX\r\n\r\n      // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n      // The minimum exponent value, beneath which underflow to zero occurs.\r\n      // Number type: -324  (5e-324)\r\n      MIN_EXP = -1e7,                          // -1 to -MAX\r\n\r\n      // The maximum exponent value, above which overflow to Infinity occurs.\r\n      // Number type:  308  (1.7976931348623157e+308)\r\n      // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n      MAX_EXP = 1e7,                           // 1 to MAX\r\n\r\n      // Whether to use cryptographically-secure random number generation, if available.\r\n      CRYPTO = false,                          // true or false\r\n\r\n      // The modulo mode used when calculating the modulus: a mod n.\r\n      // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n      // The remainder (r) is calculated as: r = a - n * q.\r\n      //\r\n      // UP        0 The remainder is positive if the dividend is negative, else is negative.\r\n      // DOWN      1 The remainder has the same sign as the dividend.\r\n      //             This modulo mode is commonly known as 'truncated division' and is\r\n      //             equivalent to (a % n) in JavaScript.\r\n      // FLOOR     3 The remainder has the same sign as the divisor (Python %).\r\n      // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n      // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n      //             The remainder is always positive.\r\n      //\r\n      // The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n      // modes are commonly used for the modulus operation.\r\n      // Although the other rounding modes can also be used, they may not give useful results.\r\n      MODULO_MODE = 1,                         // 0 to 9\r\n\r\n      // The maximum number of significant digits of the result of the exponentiatedBy operation.\r\n      // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n      POW_PRECISION = 0,                    // 0 to MAX\r\n\r\n      // The format specification used by the BigNumber.prototype.toFormat method.\r\n      FORMAT = {\r\n        prefix: '',\r\n        groupSize: 3,\r\n        secondaryGroupSize: 0,\r\n        groupSeparator: ',',\r\n        decimalSeparator: '.',\r\n        fractionGroupSize: 0,\r\n        fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n        suffix: ''\r\n      },\r\n\r\n      // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\r\n      // '-', '.', whitespace, or repeated character.\r\n      // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\r\n      ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';\r\n\r\n\r\n    //------------------------------------------------------------------------------------------\r\n\r\n\r\n    // CONSTRUCTOR\r\n\r\n\r\n    /*\r\n     * The BigNumber constructor and exported function.\r\n     * Create and return a new instance of a BigNumber object.\r\n     *\r\n     * v {number|string|BigNumber} A numeric value.\r\n     * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\r\n     */\r\n    function BigNumber(v, b) {\r\n      var alphabet, c, caseChanged, e, i, isNum, len, str,\r\n        x = this;\r\n\r\n      // Enable constructor call without `new`.\r\n      if (!(x instanceof BigNumber)) return new BigNumber(v, b);\r\n\r\n      if (b == null) {\r\n\r\n        if (v && v._isBigNumber === true) {\r\n          x.s = v.s;\r\n\r\n          if (!v.c || v.e > MAX_EXP) {\r\n            x.c = x.e = null;\r\n          } else if (v.e < MIN_EXP) {\r\n            x.c = [x.e = 0];\r\n          } else {\r\n            x.e = v.e;\r\n            x.c = v.c.slice();\r\n          }\r\n\r\n          return;\r\n        }\r\n\r\n        if ((isNum = typeof v == 'number') && v * 0 == 0) {\r\n\r\n          // Use `1 / n` to handle minus zero also.\r\n          x.s = 1 / v < 0 ? (v = -v, -1) : 1;\r\n\r\n          // Fast path for integers, where n < 2147483648 (2**31).\r\n          if (v === ~~v) {\r\n            for (e = 0, i = v; i >= 10; i /= 10, e++);\r\n\r\n            if (e > MAX_EXP) {\r\n              x.c = x.e = null;\r\n            } else {\r\n              x.e = e;\r\n              x.c = [v];\r\n            }\r\n\r\n            return;\r\n          }\r\n\r\n          str = String(v);\r\n        } else {\r\n\r\n          if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\r\n\r\n          x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n        }\r\n\r\n        // Decimal point?\r\n        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n        // Exponential form?\r\n        if ((i = str.search(/e/i)) > 0) {\r\n\r\n          // Determine exponent.\r\n          if (e < 0) e = i;\r\n          e += +str.slice(i + 1);\r\n          str = str.substring(0, i);\r\n        } else if (e < 0) {\r\n\r\n          // Integer.\r\n          e = str.length;\r\n        }\r\n\r\n      } else {\r\n\r\n        // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n        intCheck(b, 2, ALPHABET.length, 'Base');\r\n\r\n        // Allow exponential notation to be used with base 10 argument, while\r\n        // also rounding to DECIMAL_PLACES as with other bases.\r\n        if (b == 10) {\r\n          x = new BigNumber(v);\r\n          return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n        }\r\n\r\n        str = String(v);\r\n\r\n        if (isNum = typeof v == 'number') {\r\n\r\n          // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n          if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n          x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n          // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n          if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n            throw Error\r\n             (tooManyDigits + v);\r\n          }\r\n        } else {\r\n          x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n        }\r\n\r\n        alphabet = ALPHABET.slice(0, b);\r\n        e = i = 0;\r\n\r\n        // Check that str is a valid base b number.\r\n        // Don't use RegExp, so alphabet can contain special characters.\r\n        for (len = str.length; i < len; i++) {\r\n          if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n            if (c == '.') {\r\n\r\n              // If '.' is not the first character and it has not be found before.\r\n              if (i > e) {\r\n                e = len;\r\n                continue;\r\n              }\r\n            } else if (!caseChanged) {\r\n\r\n              // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n              if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\r\n                  str == str.toLowerCase() && (str = str.toUpperCase())) {\r\n                caseChanged = true;\r\n                i = -1;\r\n                e = 0;\r\n                continue;\r\n              }\r\n            }\r\n\r\n            return parseNumeric(x, String(v), isNum, b);\r\n          }\r\n        }\r\n\r\n        // Prevent later check for length on converted number.\r\n        isNum = false;\r\n        str = convertBase(str, b, 10, x.s);\r\n\r\n        // Decimal point?\r\n        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n        else e = str.length;\r\n      }\r\n\r\n      // Determine leading zeros.\r\n      for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n      // Determine trailing zeros.\r\n      for (len = str.length; str.charCodeAt(--len) === 48;);\r\n\r\n      if (str = str.slice(i, ++len)) {\r\n        len -= i;\r\n\r\n        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n        if (isNum && BigNumber.DEBUG &&\r\n          len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\r\n            throw Error\r\n             (tooManyDigits + (x.s * v));\r\n        }\r\n\r\n         // Overflow?\r\n        if ((e = e - i - 1) > MAX_EXP) {\r\n\r\n          // Infinity.\r\n          x.c = x.e = null;\r\n\r\n        // Underflow?\r\n        } else if (e < MIN_EXP) {\r\n\r\n          // Zero.\r\n          x.c = [x.e = 0];\r\n        } else {\r\n          x.e = e;\r\n          x.c = [];\r\n\r\n          // Transform base\r\n\r\n          // e is the base 10 exponent.\r\n          // i is where to slice str to get the first element of the coefficient array.\r\n          i = (e + 1) % LOG_BASE;\r\n          if (e < 0) i += LOG_BASE;  // i < 1\r\n\r\n          if (i < len) {\r\n            if (i) x.c.push(+str.slice(0, i));\r\n\r\n            for (len -= LOG_BASE; i < len;) {\r\n              x.c.push(+str.slice(i, i += LOG_BASE));\r\n            }\r\n\r\n            i = LOG_BASE - (str = str.slice(i)).length;\r\n          } else {\r\n            i -= len;\r\n          }\r\n\r\n          for (; i--; str += '0');\r\n          x.c.push(+str);\r\n        }\r\n      } else {\r\n\r\n        // Zero.\r\n        x.c = [x.e = 0];\r\n      }\r\n    }\r\n\r\n\r\n    // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n    BigNumber.clone = clone;\r\n\r\n    BigNumber.ROUND_UP = 0;\r\n    BigNumber.ROUND_DOWN = 1;\r\n    BigNumber.ROUND_CEIL = 2;\r\n    BigNumber.ROUND_FLOOR = 3;\r\n    BigNumber.ROUND_HALF_UP = 4;\r\n    BigNumber.ROUND_HALF_DOWN = 5;\r\n    BigNumber.ROUND_HALF_EVEN = 6;\r\n    BigNumber.ROUND_HALF_CEIL = 7;\r\n    BigNumber.ROUND_HALF_FLOOR = 8;\r\n    BigNumber.EUCLID = 9;\r\n\r\n\r\n    /*\r\n     * Configure infrequently-changing library-wide settings.\r\n     *\r\n     * Accept an object with the following optional properties (if the value of a property is\r\n     * a number, it must be an integer within the inclusive range stated):\r\n     *\r\n     *   DECIMAL_PLACES   {number}           0 to MAX\r\n     *   ROUNDING_MODE    {number}           0 to 8\r\n     *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]\r\n     *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]\r\n     *   CRYPTO           {boolean}          true or false\r\n     *   MODULO_MODE      {number}           0 to 9\r\n     *   POW_PRECISION       {number}           0 to MAX\r\n     *   ALPHABET         {string}           A string of two or more unique characters which does\r\n     *                                       not contain '.'.\r\n     *   FORMAT           {object}           An object with some of the following properties:\r\n     *     prefix                 {string}\r\n     *     groupSize              {number}\r\n     *     secondaryGroupSize     {number}\r\n     *     groupSeparator         {string}\r\n     *     decimalSeparator       {string}\r\n     *     fractionGroupSize      {number}\r\n     *     fractionGroupSeparator {string}\r\n     *     suffix                 {string}\r\n     *\r\n     * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n     *\r\n     * E.g.\r\n     * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n     *\r\n     * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n     *\r\n     * Return an object with the properties current values.\r\n     */\r\n    BigNumber.config = BigNumber.set = function (obj) {\r\n      var p, v;\r\n\r\n      if (obj != null) {\r\n\r\n        if (typeof obj == 'object') {\r\n\r\n          // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            DECIMAL_PLACES = v;\r\n          }\r\n\r\n          // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n          // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 8, p);\r\n            ROUNDING_MODE = v;\r\n          }\r\n\r\n          // EXPONENTIAL_AT {number|number[]}\r\n          // Integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n          // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, 0, p);\r\n              intCheck(v[1], 0, MAX, p);\r\n              TO_EXP_NEG = v[0];\r\n              TO_EXP_POS = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n            }\r\n          }\r\n\r\n          // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n          // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n          // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n          if (obj.hasOwnProperty(p = 'RANGE')) {\r\n            v = obj[p];\r\n            if (v && v.pop) {\r\n              intCheck(v[0], -MAX, -1, p);\r\n              intCheck(v[1], 1, MAX, p);\r\n              MIN_EXP = v[0];\r\n              MAX_EXP = v[1];\r\n            } else {\r\n              intCheck(v, -MAX, MAX, p);\r\n              if (v) {\r\n                MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n              } else {\r\n                throw Error\r\n                 (bignumberError + p + ' cannot be zero: ' + v);\r\n              }\r\n            }\r\n          }\r\n\r\n          // CRYPTO {boolean} true or false.\r\n          // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n          // '[BigNumber Error] crypto unavailable'\r\n          if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n            v = obj[p];\r\n            if (v === !!v) {\r\n              if (v) {\r\n                if (typeof crypto != 'undefined' && crypto &&\r\n                 (crypto.getRandomValues || crypto.randomBytes)) {\r\n                  CRYPTO = v;\r\n                } else {\r\n                  CRYPTO = !v;\r\n                  throw Error\r\n                   (bignumberError + 'crypto unavailable');\r\n                }\r\n              } else {\r\n                CRYPTO = v;\r\n              }\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' not true or false: ' + v);\r\n            }\r\n          }\r\n\r\n          // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n          // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, 9, p);\r\n            MODULO_MODE = v;\r\n          }\r\n\r\n          // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n          // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n          if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n            v = obj[p];\r\n            intCheck(v, 0, MAX, p);\r\n            POW_PRECISION = v;\r\n          }\r\n\r\n          // FORMAT {object}\r\n          // '[BigNumber Error] FORMAT not an object: {v}'\r\n          if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n            v = obj[p];\r\n            if (typeof v == 'object') FORMAT = v;\r\n            else throw Error\r\n             (bignumberError + p + ' not an object: ' + v);\r\n          }\r\n\r\n          // ALPHABET {string}\r\n          // '[BigNumber Error] ALPHABET invalid: {v}'\r\n          if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n            v = obj[p];\r\n\r\n            // Disallow if less than two characters,\r\n            // or if it contains '+', '-', '.', whitespace, or a repeated character.\r\n            if (typeof v == 'string' && !/^.?$|[+\\-.\\s]|(.).*\\1/.test(v)) {\r\n              ALPHABET = v;\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' invalid: ' + v);\r\n            }\r\n          }\r\n\r\n        } else {\r\n\r\n          // '[BigNumber Error] Object expected: {v}'\r\n          throw Error\r\n           (bignumberError + 'Object expected: ' + obj);\r\n        }\r\n      }\r\n\r\n      return {\r\n        DECIMAL_PLACES: DECIMAL_PLACES,\r\n        ROUNDING_MODE: ROUNDING_MODE,\r\n        EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n        RANGE: [MIN_EXP, MAX_EXP],\r\n        CRYPTO: CRYPTO,\r\n        MODULO_MODE: MODULO_MODE,\r\n        POW_PRECISION: POW_PRECISION,\r\n        FORMAT: FORMAT,\r\n        ALPHABET: ALPHABET\r\n      };\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if v is a BigNumber instance, otherwise return false.\r\n     *\r\n     * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\r\n     *\r\n     * v {any}\r\n     *\r\n     * '[BigNumber Error] Invalid BigNumber: {v}'\r\n     */\r\n    BigNumber.isBigNumber = function (v) {\r\n      if (!v || v._isBigNumber !== true) return false;\r\n      if (!BigNumber.DEBUG) return true;\r\n\r\n      var i, n,\r\n        c = v.c,\r\n        e = v.e,\r\n        s = v.s;\r\n\r\n      out: if ({}.toString.call(c) == '[object Array]') {\r\n\r\n        if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\r\n\r\n          // If the first element is zero, the BigNumber value must be zero.\r\n          if (c[0] === 0) {\r\n            if (e === 0 && c.length === 1) return true;\r\n            break out;\r\n          }\r\n\r\n          // Calculate number of digits that c[0] should have, based on the exponent.\r\n          i = (e + 1) % LOG_BASE;\r\n          if (i < 1) i += LOG_BASE;\r\n\r\n          // Calculate number of digits of c[0].\r\n          //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\r\n          if (String(c[0]).length == i) {\r\n\r\n            for (i = 0; i < c.length; i++) {\r\n              n = c[i];\r\n              if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\r\n            }\r\n\r\n            // Last element cannot be zero, unless it is the only element.\r\n            if (n !== 0) return true;\r\n          }\r\n        }\r\n\r\n      // Infinity/NaN\r\n      } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\r\n        return true;\r\n      }\r\n\r\n      throw Error\r\n        (bignumberError + 'Invalid BigNumber: ' + v);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the maximum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.maximum = BigNumber.max = function () {\r\n      return maxOrMin(arguments, P.lt);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the minimum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.minimum = BigNumber.min = function () {\r\n      return maxOrMin(arguments, P.gt);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n     * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n     * zeros are produced).\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n     * '[BigNumber Error] crypto unavailable'\r\n     */\r\n    BigNumber.random = (function () {\r\n      var pow2_53 = 0x20000000000000;\r\n\r\n      // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n      // Check if Math.random() produces more than 32 bits of randomness.\r\n      // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n      // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n      var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n       ? function () { return mathfloor(Math.random() * pow2_53); }\r\n       : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n         (Math.random() * 0x800000 | 0); };\r\n\r\n      return function (dp) {\r\n        var a, b, e, k, v,\r\n          i = 0,\r\n          c = [],\r\n          rand = new BigNumber(ONE);\r\n\r\n        if (dp == null) dp = DECIMAL_PLACES;\r\n        else intCheck(dp, 0, MAX);\r\n\r\n        k = mathceil(dp / LOG_BASE);\r\n\r\n        if (CRYPTO) {\r\n\r\n          // Browsers supporting crypto.getRandomValues.\r\n          if (crypto.getRandomValues) {\r\n\r\n            a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n            for (; i < k;) {\r\n\r\n              // 53 bits:\r\n              // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n              // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n              // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n              //                                     11111 11111111 11111111\r\n              // 0x20000 is 2^21.\r\n              v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n              // Rejection sampling:\r\n              // 0 <= v < 9007199254740992\r\n              // Probability that v >= 9e15, is\r\n              // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n              if (v >= 9e15) {\r\n                b = crypto.getRandomValues(new Uint32Array(2));\r\n                a[i] = b[0];\r\n                a[i + 1] = b[1];\r\n              } else {\r\n\r\n                // 0 <= v <= 8999999999999999\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 2;\r\n              }\r\n            }\r\n            i = k / 2;\r\n\r\n          // Node.js supporting crypto.randomBytes.\r\n          } else if (crypto.randomBytes) {\r\n\r\n            // buffer\r\n            a = crypto.randomBytes(k *= 7);\r\n\r\n            for (; i < k;) {\r\n\r\n              // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n              // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n              // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n              // 0 <= v < 9007199254740992\r\n              v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n                 (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n                 (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n              if (v >= 9e15) {\r\n                crypto.randomBytes(7).copy(a, i);\r\n              } else {\r\n\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 7;\r\n              }\r\n            }\r\n            i = k / 7;\r\n          } else {\r\n            CRYPTO = false;\r\n            throw Error\r\n             (bignumberError + 'crypto unavailable');\r\n          }\r\n        }\r\n\r\n        // Use Math.random.\r\n        if (!CRYPTO) {\r\n\r\n          for (; i < k;) {\r\n            v = random53bitInt();\r\n            if (v < 9e15) c[i++] = v % 1e14;\r\n          }\r\n        }\r\n\r\n        k = c[--i];\r\n        dp %= LOG_BASE;\r\n\r\n        // Convert trailing digits to zeros according to dp.\r\n        if (k && dp) {\r\n          v = POWS_TEN[LOG_BASE - dp];\r\n          c[i] = mathfloor(k / v) * v;\r\n        }\r\n\r\n        // Remove trailing elements which are zero.\r\n        for (; c[i] === 0; c.pop(), i--);\r\n\r\n        // Zero?\r\n        if (i < 0) {\r\n          c = [e = 0];\r\n        } else {\r\n\r\n          // Remove leading elements which are zero and adjust exponent accordingly.\r\n          for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n          // Count the digits of the first element of c to determine leading zeros, and...\r\n          for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n          // adjust the exponent accordingly.\r\n          if (i < LOG_BASE) e -= LOG_BASE - i;\r\n        }\r\n\r\n        rand.e = e;\r\n        rand.c = c;\r\n        return rand;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the sum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.sum = function () {\r\n      var i = 1,\r\n        args = arguments,\r\n        sum = new BigNumber(args[0]);\r\n      for (; i < args.length;) sum = sum.plus(args[i++]);\r\n      return sum;\r\n    };\r\n\r\n\r\n    // PRIVATE FUNCTIONS\r\n\r\n\r\n    // Called by BigNumber and BigNumber.prototype.toString.\r\n    convertBase = (function () {\r\n      var decimal = '0123456789';\r\n\r\n      /*\r\n       * Convert string of baseIn to an array of numbers of baseOut.\r\n       * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n       * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n       */\r\n      function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n        var j,\r\n          arr = [0],\r\n          arrL,\r\n          i = 0,\r\n          len = str.length;\r\n\r\n        for (; i < len;) {\r\n          for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n          arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n          for (j = 0; j < arr.length; j++) {\r\n\r\n            if (arr[j] > baseOut - 1) {\r\n              if (arr[j + 1] == null) arr[j + 1] = 0;\r\n              arr[j + 1] += arr[j] / baseOut | 0;\r\n              arr[j] %= baseOut;\r\n            }\r\n          }\r\n        }\r\n\r\n        return arr.reverse();\r\n      }\r\n\r\n      // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n      // If the caller is toString, we are converting from base 10 to baseOut.\r\n      // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n      return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n        var alphabet, d, e, k, r, x, xc, y,\r\n          i = str.indexOf('.'),\r\n          dp = DECIMAL_PLACES,\r\n          rm = ROUNDING_MODE;\r\n\r\n        // Non-integer.\r\n        if (i >= 0) {\r\n          k = POW_PRECISION;\r\n\r\n          // Unlimited precision.\r\n          POW_PRECISION = 0;\r\n          str = str.replace('.', '');\r\n          y = new BigNumber(baseIn);\r\n          x = y.pow(str.length - i);\r\n          POW_PRECISION = k;\r\n\r\n          // Convert str as if an integer, then restore the fraction part by dividing the\r\n          // result by its base raised to a power.\r\n\r\n          y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n           10, baseOut, decimal);\r\n          y.e = y.c.length;\r\n        }\r\n\r\n        // Convert the number as integer.\r\n\r\n        xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n         ? (alphabet = ALPHABET, decimal)\r\n         : (alphabet = decimal, ALPHABET));\r\n\r\n        // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n        e = k = xc.length;\r\n\r\n        // Remove trailing zeros.\r\n        for (; xc[--k] == 0; xc.pop());\r\n\r\n        // Zero?\r\n        if (!xc[0]) return alphabet.charAt(0);\r\n\r\n        // Does str represent an integer? If so, no need for the division.\r\n        if (i < 0) {\r\n          --e;\r\n        } else {\r\n          x.c = xc;\r\n          x.e = e;\r\n\r\n          // The sign is needed for correct rounding.\r\n          x.s = sign;\r\n          x = div(x, y, dp, rm, baseOut);\r\n          xc = x.c;\r\n          r = x.r;\r\n          e = x.e;\r\n        }\r\n\r\n        // xc now represents str converted to baseOut.\r\n\r\n        // THe index of the rounding digit.\r\n        d = e + dp + 1;\r\n\r\n        // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n        i = xc[d];\r\n\r\n        // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n        k = baseOut / 2;\r\n        r = r || d < 0 || xc[d + 1] != null;\r\n\r\n        r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n              : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n               rm == (x.s < 0 ? 8 : 7));\r\n\r\n        // If the index of the rounding digit is not greater than zero, or xc represents\r\n        // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n        // such as 0.00001.\r\n        if (d < 1 || !xc[0]) {\r\n\r\n          // 1^-dp or 0\r\n          str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n        } else {\r\n\r\n          // Truncate xc to the required number of decimal places.\r\n          xc.length = d;\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            // Rounding up may mean the previous digit has to be rounded up and so on.\r\n            for (--baseOut; ++xc[--d] > baseOut;) {\r\n              xc[d] = 0;\r\n\r\n              if (!d) {\r\n                ++e;\r\n                xc = [1].concat(xc);\r\n              }\r\n            }\r\n          }\r\n\r\n          // Determine trailing zeros.\r\n          for (k = xc.length; !xc[--k];);\r\n\r\n          // E.g. [4, 11, 15] becomes 4bf.\r\n          for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n          // Add leading zeros, decimal point and trailing zeros as required.\r\n          str = toFixedPoint(str, e, alphabet.charAt(0));\r\n        }\r\n\r\n        // The caller will add the sign.\r\n        return str;\r\n      };\r\n    })();\r\n\r\n\r\n    // Perform division in the specified base. Called by div and convertBase.\r\n    div = (function () {\r\n\r\n      // Assume non-zero x and k.\r\n      function multiply(x, k, base) {\r\n        var m, temp, xlo, xhi,\r\n          carry = 0,\r\n          i = x.length,\r\n          klo = k % SQRT_BASE,\r\n          khi = k / SQRT_BASE | 0;\r\n\r\n        for (x = x.slice(); i--;) {\r\n          xlo = x[i] % SQRT_BASE;\r\n          xhi = x[i] / SQRT_BASE | 0;\r\n          m = khi * xlo + xhi * klo;\r\n          temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n          carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n          x[i] = temp % base;\r\n        }\r\n\r\n        if (carry) x = [carry].concat(x);\r\n\r\n        return x;\r\n      }\r\n\r\n      function compare(a, b, aL, bL) {\r\n        var i, cmp;\r\n\r\n        if (aL != bL) {\r\n          cmp = aL > bL ? 1 : -1;\r\n        } else {\r\n\r\n          for (i = cmp = 0; i < aL; i++) {\r\n\r\n            if (a[i] != b[i]) {\r\n              cmp = a[i] > b[i] ? 1 : -1;\r\n              break;\r\n            }\r\n          }\r\n        }\r\n\r\n        return cmp;\r\n      }\r\n\r\n      function subtract(a, b, aL, base) {\r\n        var i = 0;\r\n\r\n        // Subtract b from a.\r\n        for (; aL--;) {\r\n          a[aL] -= i;\r\n          i = a[aL] < b[aL] ? 1 : 0;\r\n          a[aL] = i * base + a[aL] - b[aL];\r\n        }\r\n\r\n        // Remove leading zeros.\r\n        for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n      }\r\n\r\n      // x: dividend, y: divisor.\r\n      return function (x, y, dp, rm, base) {\r\n        var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n          yL, yz,\r\n          s = x.s == y.s ? 1 : -1,\r\n          xc = x.c,\r\n          yc = y.c;\r\n\r\n        // Either NaN, Infinity or 0?\r\n        if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n          return new BigNumber(\r\n\r\n           // Return NaN if either NaN, or both Infinity or 0.\r\n           !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n            // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n            xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n         );\r\n        }\r\n\r\n        q = new BigNumber(s);\r\n        qc = q.c = [];\r\n        e = x.e - y.e;\r\n        s = dp + e + 1;\r\n\r\n        if (!base) {\r\n          base = BASE;\r\n          e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n          s = s / LOG_BASE | 0;\r\n        }\r\n\r\n        // Result exponent may be one less then the current value of e.\r\n        // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n        for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n        if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n        if (s < 0) {\r\n          qc.push(1);\r\n          more = true;\r\n        } else {\r\n          xL = xc.length;\r\n          yL = yc.length;\r\n          i = 0;\r\n          s += 2;\r\n\r\n          // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n          n = mathfloor(base / (yc[0] + 1));\r\n\r\n          // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n          // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n          if (n > 1) {\r\n            yc = multiply(yc, n, base);\r\n            xc = multiply(xc, n, base);\r\n            yL = yc.length;\r\n            xL = xc.length;\r\n          }\r\n\r\n          xi = yL;\r\n          rem = xc.slice(0, yL);\r\n          remL = rem.length;\r\n\r\n          // Add zeros to make remainder as long as divisor.\r\n          for (; remL < yL; rem[remL++] = 0);\r\n          yz = yc.slice();\r\n          yz = [0].concat(yz);\r\n          yc0 = yc[0];\r\n          if (yc[1] >= base / 2) yc0++;\r\n          // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n          // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n          do {\r\n            n = 0;\r\n\r\n            // Compare divisor and remainder.\r\n            cmp = compare(yc, rem, yL, remL);\r\n\r\n            // If divisor < remainder.\r\n            if (cmp < 0) {\r\n\r\n              // Calculate trial digit, n.\r\n\r\n              rem0 = rem[0];\r\n              if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n              // n is how many times the divisor goes into the current remainder.\r\n              n = mathfloor(rem0 / yc0);\r\n\r\n              //  Algorithm:\r\n              //  product = divisor multiplied by trial digit (n).\r\n              //  Compare product and remainder.\r\n              //  If product is greater than remainder:\r\n              //    Subtract divisor from product, decrement trial digit.\r\n              //  Subtract product from remainder.\r\n              //  If product was less than remainder at the last compare:\r\n              //    Compare new remainder and divisor.\r\n              //    If remainder is greater than divisor:\r\n              //      Subtract divisor from remainder, increment trial digit.\r\n\r\n              if (n > 1) {\r\n\r\n                // n may be > base only when base is 3.\r\n                if (n >= base) n = base - 1;\r\n\r\n                // product = divisor * trial digit.\r\n                prod = multiply(yc, n, base);\r\n                prodL = prod.length;\r\n                remL = rem.length;\r\n\r\n                // Compare product and remainder.\r\n                // If product > remainder then trial digit n too high.\r\n                // n is 1 too high about 5% of the time, and is not known to have\r\n                // ever been more than 1 too high.\r\n                while (compare(prod, rem, prodL, remL) == 1) {\r\n                  n--;\r\n\r\n                  // Subtract divisor from product.\r\n                  subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n                  prodL = prod.length;\r\n                  cmp = 1;\r\n                }\r\n              } else {\r\n\r\n                // n is 0 or 1, cmp is -1.\r\n                // If n is 0, there is no need to compare yc and rem again below,\r\n                // so change cmp to 1 to avoid it.\r\n                // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n                if (n == 0) {\r\n\r\n                  // divisor < remainder, so n must be at least 1.\r\n                  cmp = n = 1;\r\n                }\r\n\r\n                // product = divisor\r\n                prod = yc.slice();\r\n                prodL = prod.length;\r\n              }\r\n\r\n              if (prodL < remL) prod = [0].concat(prod);\r\n\r\n              // Subtract product from remainder.\r\n              subtract(rem, prod, remL, base);\r\n              remL = rem.length;\r\n\r\n               // If product was < remainder.\r\n              if (cmp == -1) {\r\n\r\n                // Compare divisor and new remainder.\r\n                // If divisor < new remainder, subtract divisor from remainder.\r\n                // Trial digit n too low.\r\n                // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n                while (compare(yc, rem, yL, remL) < 1) {\r\n                  n++;\r\n\r\n                  // Subtract divisor from remainder.\r\n                  subtract(rem, yL < remL ? yz : yc, remL, base);\r\n                  remL = rem.length;\r\n                }\r\n              }\r\n            } else if (cmp === 0) {\r\n              n++;\r\n              rem = [0];\r\n            } // else cmp === 1 and n will be 0\r\n\r\n            // Add the next digit, n, to the result array.\r\n            qc[i++] = n;\r\n\r\n            // Update the remainder.\r\n            if (rem[0]) {\r\n              rem[remL++] = xc[xi] || 0;\r\n            } else {\r\n              rem = [xc[xi]];\r\n              remL = 1;\r\n            }\r\n          } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n          more = rem[0] != null;\r\n\r\n          // Leading zero?\r\n          if (!qc[0]) qc.splice(0, 1);\r\n        }\r\n\r\n        if (base == BASE) {\r\n\r\n          // To calculate q.e, first get the number of digits of qc[0].\r\n          for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n          round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n        // Caller is convertBase.\r\n        } else {\r\n          q.e = e;\r\n          q.r = +more;\r\n        }\r\n\r\n        return q;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n     * notation rounded to the specified decimal places or significant digits.\r\n     *\r\n     * n: a BigNumber.\r\n     * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n     * rm: the rounding mode.\r\n     * id: 1 (toExponential) or 2 (toPrecision).\r\n     */\r\n    function format(n, i, rm, id) {\r\n      var c0, e, ne, len, str;\r\n\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      if (!n.c) return n.toString();\r\n\r\n      c0 = n.c[0];\r\n      ne = n.e;\r\n\r\n      if (i == null) {\r\n        str = coeffToString(n.c);\r\n        str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n         ? toExponential(str, ne)\r\n         : toFixedPoint(str, ne, '0');\r\n      } else {\r\n        n = round(new BigNumber(n), i, rm);\r\n\r\n        // n.e may have changed if the value was rounded up.\r\n        e = n.e;\r\n\r\n        str = coeffToString(n.c);\r\n        len = str.length;\r\n\r\n        // toPrecision returns exponential notation if the number of significant digits\r\n        // specified is less than the number of digits necessary to represent the integer\r\n        // part of the value in fixed-point notation.\r\n\r\n        // Exponential notation.\r\n        if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n          // Append zeros?\r\n          for (; len < i; str += '0', len++);\r\n          str = toExponential(str, e);\r\n\r\n        // Fixed-point notation.\r\n        } else {\r\n          i -= ne;\r\n          str = toFixedPoint(str, e, '0');\r\n\r\n          // Append zeros?\r\n          if (e + 1 > len) {\r\n            if (--i > 0) for (str += '.'; i--; str += '0');\r\n          } else {\r\n            i += e - len;\r\n            if (i > 0) {\r\n              if (e + 1 == len) str += '.';\r\n              for (; i--; str += '0');\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return n.s < 0 && c0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // Handle BigNumber.max and BigNumber.min.\r\n    function maxOrMin(args, method) {\r\n      var n,\r\n        i = 1,\r\n        m = new BigNumber(args[0]);\r\n\r\n      for (; i < args.length; i++) {\r\n        n = new BigNumber(args[i]);\r\n\r\n        // If any number is NaN, return NaN.\r\n        if (!n.s) {\r\n          m = n;\r\n          break;\r\n        } else if (method.call(m, n)) {\r\n          m = n;\r\n        }\r\n      }\r\n\r\n      return m;\r\n    }\r\n\r\n\r\n    /*\r\n     * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n     * Called by minus, plus and times.\r\n     */\r\n    function normalise(n, c, e) {\r\n      var i = 1,\r\n        j = c.length;\r\n\r\n       // Remove trailing zeros.\r\n      for (; !c[--j]; c.pop());\r\n\r\n      // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n      for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n      // Overflow?\r\n      if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n        // Infinity.\r\n        n.c = n.e = null;\r\n\r\n      // Underflow?\r\n      } else if (e < MIN_EXP) {\r\n\r\n        // Zero.\r\n        n.c = [n.e = 0];\r\n      } else {\r\n        n.e = e;\r\n        n.c = c;\r\n      }\r\n\r\n      return n;\r\n    }\r\n\r\n\r\n    // Handle values that fail the validity test in BigNumber.\r\n    parseNumeric = (function () {\r\n      var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n        dotAfter = /^([^.]+)\\.$/,\r\n        dotBefore = /^\\.([^.]+)$/,\r\n        isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n        whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n      return function (x, str, isNum, b) {\r\n        var base,\r\n          s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n        // No exception on ±Infinity or NaN.\r\n        if (isInfinityOrNaN.test(s)) {\r\n          x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n        } else {\r\n          if (!isNum) {\r\n\r\n            // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n            s = s.replace(basePrefix, function (m, p1, p2) {\r\n              base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n              return !b || b == base ? p1 : m;\r\n            });\r\n\r\n            if (b) {\r\n              base = b;\r\n\r\n              // E.g. '1.' to '1', '.1' to '0.1'\r\n              s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n            }\r\n\r\n            if (str != s) return new BigNumber(s, base);\r\n          }\r\n\r\n          // '[BigNumber Error] Not a number: {n}'\r\n          // '[BigNumber Error] Not a base {b} number: {n}'\r\n          if (BigNumber.DEBUG) {\r\n            throw Error\r\n              (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n          }\r\n\r\n          // NaN\r\n          x.s = null;\r\n        }\r\n\r\n        x.c = x.e = null;\r\n      }\r\n    })();\r\n\r\n\r\n    /*\r\n     * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n     * If r is truthy, it is known that there are more digits after the rounding digit.\r\n     */\r\n    function round(x, sd, rm, r) {\r\n      var d, i, j, k, n, ni, rd,\r\n        xc = x.c,\r\n        pows10 = POWS_TEN;\r\n\r\n      // if x is not Infinity or NaN...\r\n      if (xc) {\r\n\r\n        // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n        // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n        // ni is the index of n within x.c.\r\n        // d is the number of digits of n.\r\n        // i is the index of rd within n including leading zeros.\r\n        // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n        out: {\r\n\r\n          // Get the number of digits of the first element of xc.\r\n          for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n          i = sd - d;\r\n\r\n          // If the rounding digit is in the first element of xc...\r\n          if (i < 0) {\r\n            i += LOG_BASE;\r\n            j = sd;\r\n            n = xc[ni = 0];\r\n\r\n            // Get the rounding digit at index j of n.\r\n            rd = n / pows10[d - j - 1] % 10 | 0;\r\n          } else {\r\n            ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n            if (ni >= xc.length) {\r\n\r\n              if (r) {\r\n\r\n                // Needed by sqrt.\r\n                for (; xc.length <= ni; xc.push(0));\r\n                n = rd = 0;\r\n                d = 1;\r\n                i %= LOG_BASE;\r\n                j = i - LOG_BASE + 1;\r\n              } else {\r\n                break out;\r\n              }\r\n            } else {\r\n              n = k = xc[ni];\r\n\r\n              // Get the number of digits of n.\r\n              for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n              // Get the index of rd within n.\r\n              i %= LOG_BASE;\r\n\r\n              // Get the index of rd within n, adjusted for leading zeros.\r\n              // The number of leading zeros of n is given by LOG_BASE - d.\r\n              j = i - LOG_BASE + d;\r\n\r\n              // Get the rounding digit at index j of n.\r\n              rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;\r\n            }\r\n          }\r\n\r\n          r = r || sd < 0 ||\r\n\r\n          // Are there any non-zero digits after the rounding digit?\r\n          // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\r\n          // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n           xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n          r = rm < 4\r\n           ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n           : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n            // Check whether the digit to the left of the rounding digit is odd.\r\n            ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n             rm == (x.s < 0 ? 8 : 7));\r\n\r\n          if (sd < 1 || !xc[0]) {\r\n            xc.length = 0;\r\n\r\n            if (r) {\r\n\r\n              // Convert sd to decimal places.\r\n              sd -= x.e + 1;\r\n\r\n              // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n              xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n              x.e = -sd || 0;\r\n            } else {\r\n\r\n              // Zero.\r\n              xc[0] = x.e = 0;\r\n            }\r\n\r\n            return x;\r\n          }\r\n\r\n          // Remove excess digits.\r\n          if (i == 0) {\r\n            xc.length = ni;\r\n            k = 1;\r\n            ni--;\r\n          } else {\r\n            xc.length = ni + 1;\r\n            k = pows10[LOG_BASE - i];\r\n\r\n            // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n            // j > 0 means i > number of leading zeros of n.\r\n            xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n          }\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            for (; ;) {\r\n\r\n              // If the digit to be rounded up is in the first element of xc...\r\n              if (ni == 0) {\r\n\r\n                // i will be the length of xc[0] before k is added.\r\n                for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n                j = xc[0] += k;\r\n                for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n                // if i != k the length has increased.\r\n                if (i != k) {\r\n                  x.e++;\r\n                  if (xc[0] == BASE) xc[0] = 1;\r\n                }\r\n\r\n                break;\r\n              } else {\r\n                xc[ni] += k;\r\n                if (xc[ni] != BASE) break;\r\n                xc[ni--] = 0;\r\n                k = 1;\r\n              }\r\n            }\r\n          }\r\n\r\n          // Remove trailing zeros.\r\n          for (i = xc.length; xc[--i] === 0; xc.pop());\r\n        }\r\n\r\n        // Overflow? Infinity.\r\n        if (x.e > MAX_EXP) {\r\n          x.c = x.e = null;\r\n\r\n        // Underflow? Zero.\r\n        } else if (x.e < MIN_EXP) {\r\n          x.c = [x.e = 0];\r\n        }\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n\r\n    function valueOf(n) {\r\n      var str,\r\n        e = n.e;\r\n\r\n      if (e === null) return n.toString();\r\n\r\n      str = coeffToString(n.c);\r\n\r\n      str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n        ? toExponential(str, e)\r\n        : toFixedPoint(str, e, '0');\r\n\r\n      return n.s < 0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n     */\r\n    P.absoluteValue = P.abs = function () {\r\n      var x = new BigNumber(this);\r\n      if (x.s < 0) x.s = 1;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return\r\n     *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     *   0 if they have the same value,\r\n     *   or null if the value of either is NaN.\r\n     */\r\n    P.comparedTo = function (y, b) {\r\n      return compare(this, new BigNumber(y, b));\r\n    };\r\n\r\n\r\n    /*\r\n     * If dp is undefined or null or true or false, return the number of decimal places of the\r\n     * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     *\r\n     * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.decimalPlaces = P.dp = function (dp, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), dp + x.e + 1, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n      // Subtract the number of trailing zeros of the last number.\r\n      if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n      if (n < 0) n = 0;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n / 0 = I\r\n     *  n / N = N\r\n     *  n / I = 0\r\n     *  0 / n = 0\r\n     *  0 / 0 = N\r\n     *  0 / N = N\r\n     *  0 / I = 0\r\n     *  N / n = N\r\n     *  N / 0 = N\r\n     *  N / N = N\r\n     *  N / I = N\r\n     *  I / n = I\r\n     *  I / 0 = I\r\n     *  I / N = N\r\n     *  I / I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n     * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.dividedBy = P.div = function (y, b) {\r\n      return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n     * BigNumber by the value of BigNumber(y, b).\r\n     */\r\n    P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n      return div(this, new BigNumber(y, b), 0, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n     *\r\n     * If m is present, return the result modulo m.\r\n     * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n     *\r\n     * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n     * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n     *\r\n     * n {number|string|BigNumber} The exponent. An integer.\r\n     * [m] {number|string|BigNumber} The modulus.\r\n     *\r\n     * '[BigNumber Error] Exponent not an integer: {n}'\r\n     */\r\n    P.exponentiatedBy = P.pow = function (n, m) {\r\n      var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n        x = this;\r\n\r\n      n = new BigNumber(n);\r\n\r\n      // Allow NaN and ±Infinity, but not other non-integers.\r\n      if (n.c && !n.isInteger()) {\r\n        throw Error\r\n          (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n      }\r\n\r\n      if (m != null) m = new BigNumber(m);\r\n\r\n      // Exponent of MAX_SAFE_INTEGER is 15.\r\n      nIsBig = n.e > 14;\r\n\r\n      // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n      if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n        // The sign of the result of pow when x is negative depends on the evenness of n.\r\n        // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n        y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? 2 - isOdd(n) : +valueOf(n)));\r\n        return m ? y.mod(m) : y;\r\n      }\r\n\r\n      nIsNeg = n.s < 0;\r\n\r\n      if (m) {\r\n\r\n        // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n        if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n        isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n        if (isModExp) x = x.mod(m);\r\n\r\n      // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n      // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n      } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n        // [1, 240000000]\r\n        ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n        // [80000000000000]  [99999750000000]\r\n        : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n        // If x is negative and n is odd, k = -0, else k = 0.\r\n        k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n        // If x >= 1, k = ±Infinity.\r\n        if (x.e > -1) k = 1 / k;\r\n\r\n        // If n is negative return ±0, else return ±Infinity.\r\n        return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n      } else if (POW_PRECISION) {\r\n\r\n        // Truncating each coefficient array to a length of k after each multiplication\r\n        // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n        // i.e. there will be a minimum of 28 guard digits retained.\r\n        k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n      }\r\n\r\n      if (nIsBig) {\r\n        half = new BigNumber(0.5);\r\n        if (nIsNeg) n.s = 1;\r\n        nIsOdd = isOdd(n);\r\n      } else {\r\n        i = Math.abs(+valueOf(n));\r\n        nIsOdd = i % 2;\r\n      }\r\n\r\n      y = new BigNumber(ONE);\r\n\r\n      // Performs 54 loop iterations for n of 9007199254740991.\r\n      for (; ;) {\r\n\r\n        if (nIsOdd) {\r\n          y = y.times(x);\r\n          if (!y.c) break;\r\n\r\n          if (k) {\r\n            if (y.c.length > k) y.c.length = k;\r\n          } else if (isModExp) {\r\n            y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n          }\r\n        }\r\n\r\n        if (i) {\r\n          i = mathfloor(i / 2);\r\n          if (i === 0) break;\r\n          nIsOdd = i % 2;\r\n        } else {\r\n          n = n.times(half);\r\n          round(n, n.e + 1, 1);\r\n\r\n          if (n.e > 14) {\r\n            nIsOdd = isOdd(n);\r\n          } else {\r\n            i = +valueOf(n);\r\n            if (i === 0) break;\r\n            nIsOdd = i % 2;\r\n          }\r\n        }\r\n\r\n        x = x.times(x);\r\n\r\n        if (k) {\r\n          if (x.c && x.c.length > k) x.c.length = k;\r\n        } else if (isModExp) {\r\n          x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n        }\r\n      }\r\n\r\n      if (isModExp) return y;\r\n      if (nIsNeg) y = ONE.div(y);\r\n\r\n      return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n     * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n     */\r\n    P.integerValue = function (rm) {\r\n      var n = new BigNumber(this);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n      return round(n, n.e + 1, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isEqualTo = P.eq = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n     */\r\n    P.isFinite = function () {\r\n      return !!this.c;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isGreaterThan = P.gt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n     */\r\n    P.isInteger = function () {\r\n      return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isLessThan = P.lt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n     */\r\n    P.isNaN = function () {\r\n      return !this.s;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is negative, otherwise return false.\r\n     */\r\n    P.isNegative = function () {\r\n      return this.s < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is positive, otherwise return false.\r\n     */\r\n    P.isPositive = function () {\r\n      return this.s > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n     */\r\n    P.isZero = function () {\r\n      return !!this.c && this.c[0] == 0;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n - 0 = n\r\n     *  n - N = N\r\n     *  n - I = -I\r\n     *  0 - n = -n\r\n     *  0 - 0 = 0\r\n     *  0 - N = N\r\n     *  0 - I = -I\r\n     *  N - n = N\r\n     *  N - 0 = N\r\n     *  N - N = N\r\n     *  N - I = N\r\n     *  I - n = I\r\n     *  I - 0 = I\r\n     *  I - N = N\r\n     *  I - I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.minus = function (y, b) {\r\n      var i, j, t, xLTy,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n      if (a != b) {\r\n        y.s = -b;\r\n        return x.plus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Either Infinity?\r\n        if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n        // Either zero?\r\n        if (!xc[0] || !yc[0]) {\r\n\r\n          // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n          return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n           // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n           ROUNDING_MODE == 3 ? -0 : 0);\r\n        }\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Determine which is the bigger number.\r\n      if (a = xe - ye) {\r\n\r\n        if (xLTy = a < 0) {\r\n          a = -a;\r\n          t = xc;\r\n        } else {\r\n          ye = xe;\r\n          t = yc;\r\n        }\r\n\r\n        t.reverse();\r\n\r\n        // Prepend zeros to equalise exponents.\r\n        for (b = a; b--; t.push(0));\r\n        t.reverse();\r\n      } else {\r\n\r\n        // Exponents equal. Check digit by digit.\r\n        j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n        for (a = b = 0; b < j; b++) {\r\n\r\n          if (xc[b] != yc[b]) {\r\n            xLTy = xc[b] < yc[b];\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      // x < y? Point xc to the array of the bigger number.\r\n      if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;\r\n\r\n      b = (j = yc.length) - (i = xc.length);\r\n\r\n      // Append zeros to xc if shorter.\r\n      // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n      if (b > 0) for (; b--; xc[i++] = 0);\r\n      b = BASE - 1;\r\n\r\n      // Subtract yc from xc.\r\n      for (; j > a;) {\r\n\r\n        if (xc[--j] < yc[j]) {\r\n          for (i = j; i && !xc[--i]; xc[i] = b);\r\n          --xc[i];\r\n          xc[j] += BASE;\r\n        }\r\n\r\n        xc[j] -= yc[j];\r\n      }\r\n\r\n      // Remove leading zeros and adjust exponent accordingly.\r\n      for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n      // Zero?\r\n      if (!xc[0]) {\r\n\r\n        // Following IEEE 754 (2008) 6.3,\r\n        // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n        y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n        y.c = [y.e = 0];\r\n        return y;\r\n      }\r\n\r\n      // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n      // for finite x and y.\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     *   n % 0 =  N\r\n     *   n % N =  N\r\n     *   n % I =  n\r\n     *   0 % n =  0\r\n     *  -0 % n = -0\r\n     *   0 % 0 =  N\r\n     *   0 % N =  N\r\n     *   0 % I =  0\r\n     *   N % n =  N\r\n     *   N % 0 =  N\r\n     *   N % N =  N\r\n     *   N % I =  N\r\n     *   I % n =  N\r\n     *   I % 0 =  N\r\n     *   I % N =  N\r\n     *   I % I =  N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n     * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n     */\r\n    P.modulo = P.mod = function (y, b) {\r\n      var q, s,\r\n        x = this;\r\n\r\n      y = new BigNumber(y, b);\r\n\r\n      // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n      if (!x.c || !y.s || y.c && !y.c[0]) {\r\n        return new BigNumber(NaN);\r\n\r\n      // Return x if y is Infinity or x is zero.\r\n      } else if (!y.c || x.c && !x.c[0]) {\r\n        return new BigNumber(x);\r\n      }\r\n\r\n      if (MODULO_MODE == 9) {\r\n\r\n        // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n        // r = x - qy    where  0 <= r < abs(y)\r\n        s = y.s;\r\n        y.s = 1;\r\n        q = div(x, y, 0, 3);\r\n        y.s = s;\r\n        q.s *= s;\r\n      } else {\r\n        q = div(x, y, 0, MODULO_MODE);\r\n      }\r\n\r\n      y = x.minus(q.times(y));\r\n\r\n      // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n      if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n      return y;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n * 0 = 0\r\n     *  n * N = N\r\n     *  n * I = I\r\n     *  0 * n = 0\r\n     *  0 * 0 = 0\r\n     *  0 * N = N\r\n     *  0 * I = N\r\n     *  N * n = N\r\n     *  N * 0 = N\r\n     *  N * N = N\r\n     *  N * I = N\r\n     *  I * n = I\r\n     *  I * 0 = N\r\n     *  I * N = N\r\n     *  I * I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n     * of BigNumber(y, b).\r\n     */\r\n    P.multipliedBy = P.times = function (y, b) {\r\n      var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n        base, sqrtBase,\r\n        x = this,\r\n        xc = x.c,\r\n        yc = (y = new BigNumber(y, b)).c;\r\n\r\n      // Either NaN, ±Infinity or ±0?\r\n      if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n        // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n        if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n          y.c = y.e = y.s = null;\r\n        } else {\r\n          y.s *= x.s;\r\n\r\n          // Return ±Infinity if either is ±Infinity.\r\n          if (!xc || !yc) {\r\n            y.c = y.e = null;\r\n\r\n          // Return ±0 if either is ±0.\r\n          } else {\r\n            y.c = [0];\r\n            y.e = 0;\r\n          }\r\n        }\r\n\r\n        return y;\r\n      }\r\n\r\n      e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n      y.s *= x.s;\r\n      xcL = xc.length;\r\n      ycL = yc.length;\r\n\r\n      // Ensure xc points to longer array and xcL to its length.\r\n      if (xcL < ycL) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;\r\n\r\n      // Initialise the result array with zeros.\r\n      for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n      base = BASE;\r\n      sqrtBase = SQRT_BASE;\r\n\r\n      for (i = ycL; --i >= 0;) {\r\n        c = 0;\r\n        ylo = yc[i] % sqrtBase;\r\n        yhi = yc[i] / sqrtBase | 0;\r\n\r\n        for (k = xcL, j = i + k; j > i;) {\r\n          xlo = xc[--k] % sqrtBase;\r\n          xhi = xc[k] / sqrtBase | 0;\r\n          m = yhi * xlo + xhi * ylo;\r\n          xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n          c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n          zc[j--] = xlo % base;\r\n        }\r\n\r\n        zc[j] = c;\r\n      }\r\n\r\n      if (c) {\r\n        ++e;\r\n      } else {\r\n        zc.splice(0, 1);\r\n      }\r\n\r\n      return normalise(y, zc, e);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n     * i.e. multiplied by -1.\r\n     */\r\n    P.negated = function () {\r\n      var x = new BigNumber(this);\r\n      x.s = -x.s || null;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n + 0 = n\r\n     *  n + N = N\r\n     *  n + I = I\r\n     *  0 + n = n\r\n     *  0 + 0 = 0\r\n     *  0 + N = N\r\n     *  0 + I = I\r\n     *  N + n = N\r\n     *  N + 0 = N\r\n     *  N + N = N\r\n     *  N + I = N\r\n     *  I + n = I\r\n     *  I + 0 = I\r\n     *  I + N = N\r\n     *  I + I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.plus = function (y, b) {\r\n      var t,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n       if (a != b) {\r\n        y.s = -b;\r\n        return x.minus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Return ±Infinity if either ±Infinity.\r\n        if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n        // Either zero?\r\n        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n        if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n      if (a = xe - ye) {\r\n        if (a > 0) {\r\n          ye = xe;\r\n          t = yc;\r\n        } else {\r\n          a = -a;\r\n          t = xc;\r\n        }\r\n\r\n        t.reverse();\r\n        for (; a--; t.push(0));\r\n        t.reverse();\r\n      }\r\n\r\n      a = xc.length;\r\n      b = yc.length;\r\n\r\n      // Point xc to the longer array, and b to the shorter length.\r\n      if (a - b < 0) t = yc, yc = xc, xc = t, b = a;\r\n\r\n      // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n      for (a = 0; b;) {\r\n        a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n        xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n      }\r\n\r\n      if (a) {\r\n        xc = [a].concat(xc);\r\n        ++ye;\r\n      }\r\n\r\n      // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n      // ye = MAX_EXP + 1 possible\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     * If sd is undefined or null or true or false, return the number of significant digits of\r\n     * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     * If sd is true include integer-part trailing zeros in the count.\r\n     *\r\n     * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n     *                     boolean: whether to count integer-part trailing zeros: true or false.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.precision = P.sd = function (sd, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (sd != null && sd !== !!sd) {\r\n        intCheck(sd, 1, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), sd, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      v = c.length - 1;\r\n      n = v * LOG_BASE + 1;\r\n\r\n      if (v = c[v]) {\r\n\r\n        // Subtract the number of trailing zeros of the last element.\r\n        for (; v % 10 == 0; v /= 10, n--);\r\n\r\n        // Add the number of digits of the first element.\r\n        for (v = c[0]; v >= 10; v /= 10, n++);\r\n      }\r\n\r\n      if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n     * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n     *\r\n     * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n     */\r\n    P.shiftedBy = function (k) {\r\n      intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n      return this.times('1e' + k);\r\n    };\r\n\r\n\r\n    /*\r\n     *  sqrt(-n) =  N\r\n     *  sqrt(N) =  N\r\n     *  sqrt(-I) =  N\r\n     *  sqrt(I) =  I\r\n     *  sqrt(0) =  0\r\n     *  sqrt(-0) = -0\r\n     *\r\n     * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n     * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.squareRoot = P.sqrt = function () {\r\n      var m, n, r, rep, t,\r\n        x = this,\r\n        c = x.c,\r\n        s = x.s,\r\n        e = x.e,\r\n        dp = DECIMAL_PLACES + 4,\r\n        half = new BigNumber('0.5');\r\n\r\n      // Negative/NaN/Infinity/zero?\r\n      if (s !== 1 || !c || !c[0]) {\r\n        return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n      }\r\n\r\n      // Initial estimate.\r\n      s = Math.sqrt(+valueOf(x));\r\n\r\n      // Math.sqrt underflow/overflow?\r\n      // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n      if (s == 0 || s == 1 / 0) {\r\n        n = coeffToString(c);\r\n        if ((n.length + e) % 2 == 0) n += '0';\r\n        s = Math.sqrt(+n);\r\n        e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n        if (s == 1 / 0) {\r\n          n = '5e' + e;\r\n        } else {\r\n          n = s.toExponential();\r\n          n = n.slice(0, n.indexOf('e') + 1) + e;\r\n        }\r\n\r\n        r = new BigNumber(n);\r\n      } else {\r\n        r = new BigNumber(s + '');\r\n      }\r\n\r\n      // Check for zero.\r\n      // r could be zero if MIN_EXP is changed after the this value was created.\r\n      // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n      // coeffToString to throw.\r\n      if (r.c[0]) {\r\n        e = r.e;\r\n        s = e + dp;\r\n        if (s < 3) s = 0;\r\n\r\n        // Newton-Raphson iteration.\r\n        for (; ;) {\r\n          t = r;\r\n          r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n          if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n            // The exponent of r may here be one less than the final result exponent,\r\n            // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n            // are indexed correctly.\r\n            if (r.e < e) --s;\r\n            n = n.slice(s - 3, s + 1);\r\n\r\n            // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n            // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n            // iteration.\r\n            if (n == '9999' || !rep && n == '4999') {\r\n\r\n              // On the first iteration only, check to see if rounding up gives the\r\n              // exact result as the nines may infinitely repeat.\r\n              if (!rep) {\r\n                round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n                if (t.times(t).eq(x)) {\r\n                  r = t;\r\n                  break;\r\n                }\r\n              }\r\n\r\n              dp += 4;\r\n              s += 4;\r\n              rep = 1;\r\n            } else {\r\n\r\n              // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n              // result. If not, then there are further digits and m will be truthy.\r\n              if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n                // Truncate to the first rounding digit.\r\n                round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n                m = !r.times(r).eq(x);\r\n              }\r\n\r\n              break;\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in exponential notation and\r\n     * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toExponential = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp++;\r\n      }\r\n      return format(this, dp, rm, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n     * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n     * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toFixed = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp = dp + this.e + 1;\r\n      }\r\n      return format(this, dp, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n     * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n     * of the format or FORMAT object (see BigNumber.set).\r\n     *\r\n     * The formatting object may contain some or all of the properties shown below.\r\n     *\r\n     * FORMAT = {\r\n     *   prefix: '',\r\n     *   groupSize: 3,\r\n     *   secondaryGroupSize: 0,\r\n     *   groupSeparator: ',',\r\n     *   decimalSeparator: '.',\r\n     *   fractionGroupSize: 0,\r\n     *   fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n     *   suffix: ''\r\n     * };\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     * [format] {object} Formatting options. See FORMAT pbject above.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     * '[BigNumber Error] Argument not an object: {format}'\r\n     */\r\n    P.toFormat = function (dp, rm, format) {\r\n      var str,\r\n        x = this;\r\n\r\n      if (format == null) {\r\n        if (dp != null && rm && typeof rm == 'object') {\r\n          format = rm;\r\n          rm = null;\r\n        } else if (dp && typeof dp == 'object') {\r\n          format = dp;\r\n          dp = rm = null;\r\n        } else {\r\n          format = FORMAT;\r\n        }\r\n      } else if (typeof format != 'object') {\r\n        throw Error\r\n          (bignumberError + 'Argument not an object: ' + format);\r\n      }\r\n\r\n      str = x.toFixed(dp, rm);\r\n\r\n      if (x.c) {\r\n        var i,\r\n          arr = str.split('.'),\r\n          g1 = +format.groupSize,\r\n          g2 = +format.secondaryGroupSize,\r\n          groupSeparator = format.groupSeparator || '',\r\n          intPart = arr[0],\r\n          fractionPart = arr[1],\r\n          isNeg = x.s < 0,\r\n          intDigits = isNeg ? intPart.slice(1) : intPart,\r\n          len = intDigits.length;\r\n\r\n        if (g2) i = g1, g1 = g2, g2 = i, len -= i;\r\n\r\n        if (g1 > 0 && len > 0) {\r\n          i = len % g1 || g1;\r\n          intPart = intDigits.substr(0, i);\r\n          for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n          if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n          if (isNeg) intPart = '-' + intPart;\r\n        }\r\n\r\n        str = fractionPart\r\n         ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n          ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n           '$&' + (format.fractionGroupSeparator || ''))\r\n          : fractionPart)\r\n         : intPart;\r\n      }\r\n\r\n      return (format.prefix || '') + str + (format.suffix || '');\r\n    };\r\n\r\n\r\n    /*\r\n     * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n     * fraction with an integer numerator and an integer denominator.\r\n     * The denominator will be a positive non-zero value less than or equal to the specified\r\n     * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n     * the lowest value necessary to represent the number exactly.\r\n     *\r\n     * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n     *\r\n     * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n     */\r\n    P.toFraction = function (md) {\r\n      var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n        x = this,\r\n        xc = x.c;\r\n\r\n      if (md != null) {\r\n        n = new BigNumber(md);\r\n\r\n        // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n        if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n          throw Error\r\n            (bignumberError + 'Argument ' +\r\n              (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n        }\r\n      }\r\n\r\n      if (!xc) return new BigNumber(x);\r\n\r\n      d = new BigNumber(ONE);\r\n      n1 = d0 = new BigNumber(ONE);\r\n      d1 = n0 = new BigNumber(ONE);\r\n      s = coeffToString(xc);\r\n\r\n      // Determine initial denominator.\r\n      // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n      e = d.e = s.length - x.e - 1;\r\n      d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n      md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n      exp = MAX_EXP;\r\n      MAX_EXP = 1 / 0;\r\n      n = new BigNumber(s);\r\n\r\n      // n0 = d1 = 0\r\n      n0.c[0] = 0;\r\n\r\n      for (; ;)  {\r\n        q = div(n, d, 0, 1);\r\n        d2 = d0.plus(q.times(d1));\r\n        if (d2.comparedTo(md) == 1) break;\r\n        d0 = d1;\r\n        d1 = d2;\r\n        n1 = n0.plus(q.times(d2 = n1));\r\n        n0 = d2;\r\n        d = n.minus(q.times(d2 = d));\r\n        n = d2;\r\n      }\r\n\r\n      d2 = div(md.minus(d0), d1, 0, 1);\r\n      n0 = n0.plus(d2.times(n1));\r\n      d0 = d0.plus(d2.times(d1));\r\n      n0.s = n1.s = x.s;\r\n      e = e * 2;\r\n\r\n      // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n      r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n          div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n      MAX_EXP = exp;\r\n\r\n      return r;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return the value of this BigNumber converted to a number primitive.\r\n     */\r\n    P.toNumber = function () {\r\n      return +valueOf(this);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n     * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n     * necessary to represent the integer part of the value in fixed-point notation, then use\r\n     * exponential notation.\r\n     *\r\n     * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.toPrecision = function (sd, rm) {\r\n      if (sd != null) intCheck(sd, 1, MAX);\r\n      return format(this, sd, rm, 2);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n     * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n     * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n     * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n     * TO_EXP_NEG, return exponential notation.\r\n     *\r\n     * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n     *\r\n     * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n     */\r\n    P.toString = function (b) {\r\n      var str,\r\n        n = this,\r\n        s = n.s,\r\n        e = n.e;\r\n\r\n      // Infinity or NaN?\r\n      if (e === null) {\r\n        if (s) {\r\n          str = 'Infinity';\r\n          if (s < 0) str = '-' + str;\r\n        } else {\r\n          str = 'NaN';\r\n        }\r\n      } else {\r\n        if (b == null) {\r\n          str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n           ? toExponential(coeffToString(n.c), e)\r\n           : toFixedPoint(coeffToString(n.c), e, '0');\r\n        } else if (b === 10) {\r\n          n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n          str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n        } else {\r\n          intCheck(b, 2, ALPHABET.length, 'Base');\r\n          str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n        }\r\n\r\n        if (s < 0 && n.c[0]) str = '-' + str;\r\n      }\r\n\r\n      return str;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return as toString, but do not accept a base argument, and include the minus sign for\r\n     * negative zero.\r\n     */\r\n    P.valueOf = P.toJSON = function () {\r\n      return valueOf(this);\r\n    };\r\n\r\n\r\n    P._isBigNumber = true;\r\n\r\n    if (configObject != null) BigNumber.set(configObject);\r\n\r\n    return BigNumber;\r\n  }\r\n\r\n\r\n  // PRIVATE HELPER FUNCTIONS\r\n\r\n  // These functions don't need access to variables,\r\n  // e.g. DECIMAL_PLACES, in the scope of the `clone` function above.\r\n\r\n\r\n  function bitFloor(n) {\r\n    var i = n | 0;\r\n    return n > 0 || n === i ? i : i - 1;\r\n  }\r\n\r\n\r\n  // Return a coefficient array as a string of base 10 digits.\r\n  function coeffToString(a) {\r\n    var s, z,\r\n      i = 1,\r\n      j = a.length,\r\n      r = a[0] + '';\r\n\r\n    for (; i < j;) {\r\n      s = a[i++] + '';\r\n      z = LOG_BASE - s.length;\r\n      for (; z--; s = '0' + s);\r\n      r += s;\r\n    }\r\n\r\n    // Determine trailing zeros.\r\n    for (j = r.length; r.charCodeAt(--j) === 48;);\r\n\r\n    return r.slice(0, j + 1 || 1);\r\n  }\r\n\r\n\r\n  // Compare the value of BigNumbers x and y.\r\n  function compare(x, y) {\r\n    var a, b,\r\n      xc = x.c,\r\n      yc = y.c,\r\n      i = x.s,\r\n      j = y.s,\r\n      k = x.e,\r\n      l = y.e;\r\n\r\n    // Either NaN?\r\n    if (!i || !j) return null;\r\n\r\n    a = xc && !xc[0];\r\n    b = yc && !yc[0];\r\n\r\n    // Either zero?\r\n    if (a || b) return a ? b ? 0 : -j : i;\r\n\r\n    // Signs differ?\r\n    if (i != j) return i;\r\n\r\n    a = i < 0;\r\n    b = k == l;\r\n\r\n    // Either Infinity?\r\n    if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\r\n\r\n    // Compare exponents.\r\n    if (!b) return k > l ^ a ? 1 : -1;\r\n\r\n    j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n    // Compare digit by digit.\r\n    for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\r\n\r\n    // Compare lengths.\r\n    return k == l ? 0 : k > l ^ a ? 1 : -1;\r\n  }\r\n\r\n\r\n  /*\r\n   * Check that n is a primitive number, an integer, and in range, otherwise throw.\r\n   */\r\n  function intCheck(n, min, max, name) {\r\n    if (n < min || n > max || n !== mathfloor(n)) {\r\n      throw Error\r\n       (bignumberError + (name || 'Argument') + (typeof n == 'number'\r\n         ? n < min || n > max ? ' out of range: ' : ' not an integer: '\r\n         : ' not a primitive number: ') + String(n));\r\n    }\r\n  }\r\n\r\n\r\n  // Assumes finite n.\r\n  function isOdd(n) {\r\n    var k = n.c.length - 1;\r\n    return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\r\n  }\r\n\r\n\r\n  function toExponential(str, e) {\r\n    return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +\r\n     (e < 0 ? 'e' : 'e+') + e;\r\n  }\r\n\r\n\r\n  function toFixedPoint(str, e, z) {\r\n    var len, zs;\r\n\r\n    // Negative exponent?\r\n    if (e < 0) {\r\n\r\n      // Prepend zeros.\r\n      for (zs = z + '.'; ++e; zs += z);\r\n      str = zs + str;\r\n\r\n    // Positive exponent\r\n    } else {\r\n      len = str.length;\r\n\r\n      // Append zeros.\r\n      if (++e > len) {\r\n        for (zs = z, e -= len; --e; zs += z);\r\n        str += zs;\r\n      } else if (e < len) {\r\n        str = str.slice(0, e) + '.' + str.slice(e);\r\n      }\r\n    }\r\n\r\n    return str;\r\n  }\r\n\r\n\r\n  // EXPORT\r\n\r\n\r\n  BigNumber = clone();\r\n  BigNumber['default'] = BigNumber.BigNumber = BigNumber;\r\n\r\n  // AMD.\r\n  if (typeof define == 'function' && define.amd) {\r\n    define(function () { return BigNumber; });\r\n\r\n  // Node.js and other environments that support module.exports.\r\n  } else if (typeof module != 'undefined' && module.exports) {\r\n    module.exports = BigNumber;\r\n\r\n  // Browser.\r\n  } else {\r\n    if (!globalObject) {\r\n      globalObject = typeof self != 'undefined' && self ? self : window;\r\n    }\r\n\r\n    globalObject.BigNumber = BigNumber;\r\n  }\r\n})(this);\r\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","// 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\n'use strict';\n\n// If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = function(qs, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n  var obj = {};\n\n  if (typeof qs !== 'string' || qs.length === 0) {\n    return obj;\n  }\n\n  var regexp = /\\+/g;\n  qs = qs.split(sep);\n\n  var maxKeys = 1000;\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var len = qs.length;\n  // maxKeys <= 0 means that we should not limit keys count\n  if (maxKeys > 0 && len > maxKeys) {\n    len = maxKeys;\n  }\n\n  for (var i = 0; i < len; ++i) {\n    var x = qs[i].replace(regexp, '%20'),\n        idx = x.indexOf(eq),\n        kstr, vstr, k, v;\n\n    if (idx >= 0) {\n      kstr = x.substr(0, idx);\n      vstr = x.substr(idx + 1);\n    } else {\n      kstr = x;\n      vstr = '';\n    }\n\n    k = decodeURIComponent(kstr);\n    v = decodeURIComponent(vstr);\n\n    if (!hasOwnProperty(obj, k)) {\n      obj[k] = v;\n    } else if (isArray(obj[k])) {\n      obj[k].push(v);\n    } else {\n      obj[k] = [obj[k], v];\n    }\n  }\n\n  return obj;\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n","'use strict';\n\nif (typeof process === 'undefined' ||\n    !process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = { nextTick: nextTick };\n} else {\n  module.exports = process\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n","// Types\nimport Vue, { VNode } from 'vue'\n\nexport default function VGrid (name: string) {\n  /* @vue/component */\n  return Vue.extend({\n    name: `v-${name}`,\n\n    functional: true,\n\n    props: {\n      id: String,\n      tag: {\n        type: String,\n        default: 'div',\n      },\n    },\n\n    render (h, { props, data, children }): VNode {\n      data.staticClass = (`${name} ${data.staticClass || ''}`).trim()\n\n      const { attrs } = data\n      if (attrs) {\n        // reset attrs to extract utility clases like pa-3\n        data.attrs = {}\n        const classes = Object.keys(attrs).filter(key => {\n          // TODO: Remove once resolved\n          // https://github.com/vuejs/vue/issues/7841\n          if (key === 'slot') return false\n\n          const value = attrs[key]\n\n          // add back data attributes like data-test=\"foo\" but do not\n          // add them as classes\n          if (key.startsWith('data-')) {\n            data.attrs![key] = value\n            return false\n          }\n\n          return value || typeof value === 'string'\n        })\n\n        if (classes.length) data.staticClass += ` ${classes.join(' ')}`\n      }\n\n      if (props.id) {\n        data.domProps = data.domProps || {}\n        data.domProps.id = props.id\n      }\n\n      return h(props.tag, data, children)\n    },\n  })\n}\n","import './_grid.sass'\nimport './VGrid.sass'\n\nimport Grid from './grid'\n\nimport mergeData from '../../util/mergeData'\n\n/* @vue/component */\nexport default Grid('container').extend({\n  name: 'v-container',\n  functional: true,\n  props: {\n    id: String,\n    tag: {\n      type: String,\n      default: 'div',\n    },\n    fluid: {\n      type: Boolean,\n      default: false,\n    },\n  },\n  render (h, { props, data, children }) {\n    let classes\n    const { attrs } = data\n    if (attrs) {\n      // reset attrs to extract utility clases like pa-3\n      data.attrs = {}\n      classes = Object.keys(attrs).filter(key => {\n        // TODO: Remove once resolved\n        // https://github.com/vuejs/vue/issues/7841\n        if (key === 'slot') return false\n\n        const value = attrs[key]\n\n        // add back data attributes like data-test=\"foo\" but do not\n        // add them as classes\n        if (key.startsWith('data-')) {\n          data.attrs![key] = value\n          return false\n        }\n\n        return value || typeof value === 'string'\n      })\n    }\n\n    if (props.id) {\n      data.domProps = data.domProps || {}\n      data.domProps.id = props.id\n    }\n\n    return h(\n      props.tag,\n      mergeData(data, {\n        staticClass: 'container',\n        class: Array<any>({\n          'container--fluid': props.fluid,\n        }).concat(classes || []),\n      }),\n      children\n    )\n  },\n})\n","// Styles\nimport './VOverlay.sass'\n\n// Mixins\nimport Colorable from './../../mixins/colorable'\nimport Themeable from '../../mixins/themeable'\nimport Toggleable from './../../mixins/toggleable'\n\n// Utilities\nimport mixins from '../../util/mixins'\n\n// Types\nimport { VNode } from 'vue'\n\n/* @vue/component */\nexport default mixins(\n  Colorable,\n  Themeable,\n  Toggleable\n).extend({\n  name: 'v-overlay',\n\n  props: {\n    absolute: Boolean,\n    color: {\n      type: String,\n      default: '#212121',\n    },\n    dark: {\n      type: Boolean,\n      default: true,\n    },\n    opacity: {\n      type: [Number, String],\n      default: 0.46,\n    },\n    value: {\n      default: true,\n    },\n    zIndex: {\n      type: [Number, String],\n      default: 5,\n    },\n  },\n\n  computed: {\n    __scrim (): VNode {\n      const data = this.setBackgroundColor(this.color, {\n        staticClass: 'v-overlay__scrim',\n        style: {\n          opacity: this.computedOpacity,\n        },\n      })\n\n      return this.$createElement('div', data)\n    },\n    classes (): object {\n      return {\n        'v-overlay--absolute': this.absolute,\n        'v-overlay--active': this.isActive,\n        ...this.themeClasses,\n      }\n    },\n    computedOpacity (): number {\n      return Number(this.isActive ? this.opacity : 0)\n    },\n    styles (): object {\n      return {\n        zIndex: this.zIndex,\n      }\n    },\n  },\n\n  methods: {\n    genContent () {\n      return this.$createElement('div', {\n        staticClass: 'v-overlay__content',\n      }, this.$slots.default)\n    },\n  },\n\n  render (h): VNode {\n    const children = [this.__scrim]\n\n    if (this.isActive) children.push(this.genContent())\n\n    return h('div', {\n      staticClass: 'v-overlay',\n      class: this.classes,\n      style: this.styles,\n    }, children)\n  },\n})\n","'use strict'\n\nconst stream = require('stream')\nconst BinaryParseStream = require('../vendor/binary-parse-stream')\nconst Tagged = require('./tagged')\nconst Simple = require('./simple')\nconst utils = require('./utils')\nconst bignumber = require('bignumber.js').BigNumber\nconst NoFilter = require('nofilter')\nconst constants = require('./constants')\n// Do not fix this if you want to support node v4\nconst MT = constants.MT\nconst NUMBYTES = constants.NUMBYTES\nconst SIMPLE = constants.SIMPLE\nconst SYMS = constants.SYMS\n\nconst BI = utils.bigIntize(constants.BI)\nconst BN = constants.BN\nconst COUNT = Symbol('count')\nconst PENDING_KEY = Symbol('pending_key')\nconst MAJOR = Symbol('major type')\nconst ERROR = Symbol('error')\nconst NOT_FOUND = Symbol('not found')\n\nfunction parentArray(parent, typ, count) {\n  const a = []\n  a[COUNT] = count\n  a[SYMS.PARENT] = parent\n  a[MAJOR] = typ\n  return a\n}\n\nfunction parentBufferStream(parent, typ) {\n  const b = new NoFilter()\n  b[COUNT] = -1\n  b[SYMS.PARENT] = parent\n  b[MAJOR] = typ\n  return b\n}\n\n/**\n * @param {Buffer} v\n * @private\n */\nfunction _tag_2(v) {\n  return utils.bufferToBigInt(v)\n}\n\n/**\n * @param {BigInt} v\n * @private\n */\nfunction _tag_3(v) {\n  // avoid syntax error on old runtimes\n  return BI.MINUS_ONE - utils.bufferToBigInt(v)\n}\n\n/**\n * Decode a stream of CBOR bytes by transforming them into equivalent\n * JavaScript data.  Because of the limitations of Node object streams,\n * special symbols are emitted instead of NULL or UNDEFINED.  Fix those\n * up by calling {@link Decoder.nullcheck}.\n *\n * @extends {BinaryParseStream}\n */\nclass Decoder extends BinaryParseStream {\n\n  /**\n   * Create a parsing stream.\n   *\n   * @param {object} [options={}]\n   * @param {number} [options.max_depth=-1] - the maximum depth to parse.\n   *   Use -1 for \"until you run out of memory\".  Set this to a finite\n   *   positive number for un-trusted inputs.  Most standard inputs won't nest\n   *   more than 100 or so levels; I've tested into the millions before\n   *   running out of memory.\n   * @param {object} [options.tags] - mapping from tag number to function(v),\n   *   where v is the decoded value that comes after the tag, and where the\n   *   function returns the correctly-created value for that tag.\n   * @param {boolean} [options.bigint=false] generate JavaScript BigInt's\n   *   instead of BigNumbers, when possible.  TODO: when BigInt's are\n   *   more prevalent, change this to default to the value of cbor.hasBigInt.\n   */\n  constructor(options) {\n    options = options || {}\n    const tags = options.tags\n    delete options.tags\n    const max_depth = (options.max_depth != null) ? options.max_depth : -1\n    delete options.max_depth\n    const bigI = utils.hasBigInt ? (!!options.bigint) : false\n    delete options.bigint\n    super(options)\n\n    this.running = true\n    this.max_depth = max_depth\n    this.tags = tags\n    if (bigI) {\n      if (this.tags == null) {\n        this.tags = {}\n      }\n      if (this.tags[2] == null) {\n        this.tags[2] = _tag_2\n      }\n      if (this.tags[3] == null) {\n        this.tags[3] = _tag_3\n      }\n    }\n  }\n\n  /**\n   * Check the given value for a symbol encoding a NULL or UNDEFINED value in\n   * the CBOR stream.\n   *\n   * @static\n   * @param {any} val - the value to check\n   * @returns {any} the corrected value\n   *\n   * @example\n   * myDecoder.on('data', function(val) {\n   *   val = Decoder.nullcheck(val);\n   *   ...\n   * });\n   */\n  static nullcheck(val) {\n    switch (val) {\n      case SYMS.NULL:\n        return null\n      case SYMS.UNDEFINED:\n        return undefined\n      case NOT_FOUND:\n        throw new Error('Value not found')\n      default:\n        return val\n    }\n  }\n\n  /**\n   * @typedef DecodeOptions\n   * @property {string} [encoding='hex'] - The encoding of the input.\n   *   Ignored if input is a Buffer.\n   */\n\n  /**\n   * Decode the first CBOR item in the input, synchronously.  This will throw an\n   * exception if the input is not valid CBOR.\n   *\n   * @static\n   * @param {string|Buffer|stream.Readable} input\n   * @param {DecodeOptions|string} [options] Options\n   * @returns {any} - the decoded value\n   */\n  static decodeFirstSync(input, options) {\n    options = options || { encoding: 'hex' }\n    let opts = {}\n    let encod\n    switch (typeof options) {\n      case 'string':\n        encod = options\n        break\n      case 'object':\n        opts = utils.extend({}, options)\n        encod = opts.encoding\n        delete opts.encoding\n        break\n    }\n    const c = new Decoder(opts)\n    const s = (input instanceof stream.Readable) ? input : new NoFilter(\n      input,\n      encod != null ? encod : utils.guessEncoding(input))\n\n    // for/of doesn't work when you need to call next() with a value\n    // generator created by parser will be \"done\" after each CBOR entity\n    // parser will yield numbers of bytes that it wants\n    const parser = c._parse()\n    let state = parser.next()\n    while (!state.done) {\n      const b = s.read(state.value)\n      if ((b == null) || (b.length !== state.value)) {\n        throw new Error('Insufficient data')\n      }\n      state = parser.next(b)\n    }\n    const val = Decoder.nullcheck(state.value)\n    if (s.length > 0) {\n      const nextByte = s.read(1)\n      s.unshift(nextByte)\n      const er = new Error(\n        'Unexpected data: 0x' + nextByte[0].toString(16))\n      er.value = val\n      throw er\n    }\n    return val\n  }\n\n  /**\n   * Decode all of the CBOR items in the input into an array.  This will throw\n   * an exception if the input is not valid CBOR; a zero-length input will\n   * return an empty array.\n   *\n   * @static\n   * @param {string|Buffer|stream.Readable} input\n   * @param {DecodeOptions|string} [options] Options or encoding string\n   * @returns {Array} - Array of all found items\n   */\n  static decodeAllSync(input, options) {\n    options = options || { encoding: 'hex' }\n    let opts = {}\n    let encod\n    switch (typeof options) {\n      case 'string':\n        encod = options\n        break\n      case 'object':\n        opts = utils.extend({}, options)\n        encod = opts.encoding\n        delete opts.encoding\n    }\n    const c = new Decoder(opts)\n    const s = (input instanceof stream.Readable) ? input : new NoFilter(\n      input,\n      encod != null ? encod : utils.guessEncoding(input))\n    const res = []\n    while (s.length > 0) {\n      const parser = c._parse()\n      let state = parser.next()\n      while (!state.done) {\n        const b = s.read(state.value)\n        if ((b == null) || (b.length !== state.value)) {\n          throw new Error('Insufficient data')\n        }\n        state = parser.next(b)\n      }\n      res.push(Decoder.nullcheck(state.value))\n    }\n    return res\n  }\n\n  /**\n   * @callback decodeCallback\n   * @param {Error} [error] - if one was generated\n   * @param {any} [value] - the decoded value\n   */\n\n  /**\n   * Decode the first CBOR item in the input.  This will error if there are more\n   * bytes left over at the end, and optionally if there were no valid CBOR\n   * bytes in the input.  Emits the {Decoder.NOT_FOUND} Symbol in the callback\n   * if no data was found and the `required` option is false.\n   *\n   * @static\n   * @param {string|Buffer} input - the input to parse\n   * @param {DecodeOptions|decodeCallback|string} [options] - options\n   * @param {decodeCallback} [cb] callback\n   * @returns {Promise<any>} returned even if callback is specified\n   */\n  static decodeFirst(input, options, cb) {\n    let opts = {}\n    let required = false\n    let encod = 'hex'\n    switch (typeof options) {\n      case 'function':\n        cb = options\n        encod = utils.guessEncoding(input)\n        break\n      case 'string':\n        encod = options\n        break\n      case 'object':\n        opts = utils.extend({}, options)\n        encod = (opts.encoding != null) ?\n          opts.encoding : utils.guessEncoding(input)\n        delete opts.encoding\n        required = (opts.required != null) ? opts.required : false\n        delete opts.required\n    }\n    const c = new Decoder(opts)\n    let v = NOT_FOUND\n    const p = new Promise((resolve, reject) => {\n      c.on('data', (val) => {\n        v = Decoder.nullcheck(val)\n        c.close()\n      })\n      c.once('error', (er) => {\n        if (v !== NOT_FOUND) {\n          er.value = v\n        }\n        v = ERROR\n        c.close()\n        return reject(er)\n      })\n      c.once('end', () => {\n        switch (v) {\n          case NOT_FOUND:\n            if (required) {\n              return reject(new Error('No CBOR found'))\n            } else {\n              return resolve(v)\n            }\n          case ERROR:\n            return void 0\n          default:\n            return resolve(v)\n        }\n      })\n    })\n\n    if (typeof cb === 'function') {\n      p.then(v => cb(null, v), cb)\n    }\n    c.end(input, encod)\n    return p\n  }\n\n  /**\n   * @callback decodeAllCallback\n   * @param {Error} error - if one was generated\n   * @param {Array} value - all of the decoded values, wrapped in an Array\n   */\n\n  /**\n   * Decode all of the CBOR items in the input.  This will error if there are\n   * more bytes left over at the end.\n   *\n   * @static\n   * @param {(string|Buffer)} input - the input to parse\n   * @param {(string|Object)} options - Decoding options.\n   *   If string, the input encoding.\n   * @param {decodeAllCallback} cb callback\n   * @returns {Promise<Array>} even if callback is specified\n   */\n  static decodeAll(input, options, cb) {\n    let opts = {}\n    let encod = 'hex'\n    switch (typeof options) {\n      case 'function':\n        cb = options\n        encod = utils.guessEncoding(input)\n        break\n      case 'string':\n        encod = options\n        break\n      case 'object':\n        opts = utils.extend({}, options)\n        encod = (opts.encoding != null) ?\n          opts.encoding : utils.guessEncoding(input)\n        delete opts.encoding\n    }\n    const c = new Decoder(opts)\n    const vals = []\n    c.on('data', (val) => {\n      return vals.push(Decoder.nullcheck(val))\n    })\n    const p = new Promise((resolve, reject) => {\n      c.on('error', reject)\n      c.on('end', () => resolve(vals))\n    })\n    if (typeof cb === 'function') {\n      p.then(v => cb(null, v), cb)\n    }\n    c.end(input, encod)\n    return p\n  }\n\n  /**\n   * Stop processing\n   */\n  close() {\n    this.running = false\n    this.__fresh = true\n  }\n\n  *_parse() {\n    let parent = null\n    let depth = 0\n    let val = null\n    while (true) {\n      if ((this.max_depth >= 0) && (depth > this.max_depth)) {\n        throw new Error('Maximum depth ' + this.max_depth + ' exceeded')\n      }\n      const octet = (yield 1)[0]\n      if (!this.running) {\n        throw new Error('Unexpected data: 0x' + (octet.toString(16)))\n      }\n      const mt = octet >> 5\n      const ai = octet & 0x1f\n      const parent_major = (parent != null) ? parent[MAJOR] : undefined\n      const parent_length = (parent != null) ? parent.length : undefined\n      switch (ai) {\n        case NUMBYTES.ONE:\n          this.emit('more-bytes', mt, 1, parent_major, parent_length)\n          val = (yield 1)[0]\n          break\n        case NUMBYTES.TWO:\n        case NUMBYTES.FOUR:\n        case NUMBYTES.EIGHT:\n          const numbytes = 1 << (ai - 24)\n          this.emit('more-bytes', mt, numbytes, parent_major, parent_length)\n          const buf = yield numbytes\n          val = (mt === MT.SIMPLE_FLOAT) ? buf : utils.parseCBORint(ai, buf)\n          break\n        case 28:\n        case 29:\n        case 30:\n          this.running = false\n          throw new Error('Additional info not implemented: ' + ai)\n        case NUMBYTES.INDEFINITE:\n          switch (mt) {\n            case MT.POS_INT:\n            case MT.NEG_INT:\n            case MT.TAG:\n              throw new Error(`Invalid indefinite encoding for MT ${mt}`)\n          }\n          val = -1\n          break\n        default:\n          val = ai\n      }\n      switch (mt) {\n        case MT.POS_INT:\n          // val already decoded\n          break\n        case MT.NEG_INT:\n          if (val === Number.MAX_SAFE_INTEGER) {\n            val = BN.NEG_MAX\n          } else if (val instanceof bignumber) {\n            val = BN.MINUS_ONE.minus(val)\n          } else {\n            val = -1 - val\n          }\n          break\n        case MT.BYTE_STRING:\n        case MT.UTF8_STRING:\n          switch (val) {\n            case 0:\n              this.emit('start-string', mt, val, parent_major, parent_length)\n              val = (mt === MT.BYTE_STRING) ? Buffer.allocUnsafe(0) : ''\n              break\n            case -1:\n              this.emit('start', mt, SYMS.STREAM, parent_major, parent_length)\n              parent = parentBufferStream(parent, mt)\n              depth++\n              continue\n            default:\n              this.emit('start-string', mt, val, parent_major, parent_length)\n              val = yield val\n              if (mt === MT.UTF8_STRING) {\n                val = utils.utf8(val)\n              }\n          }\n          break\n        case MT.ARRAY:\n        case MT.MAP:\n          switch (val) {\n            case 0:\n              val = (mt === MT.MAP) ? {} : []\n              break\n            case -1:\n              this.emit('start', mt, SYMS.STREAM, parent_major, parent_length)\n              parent = parentArray(parent, mt, -1)\n              depth++\n              continue\n            default:\n              this.emit('start', mt, val, parent_major, parent_length)\n              parent = parentArray(parent, mt, val * (mt - 3))\n              depth++\n              continue\n          }\n          break\n        case MT.TAG:\n          this.emit('start', mt, val, parent_major, parent_length)\n          parent = parentArray(parent, mt, 1)\n          parent.push(val)\n          depth++\n          continue\n        case MT.SIMPLE_FLOAT:\n          if (typeof val === 'number') {\n            if ((ai === NUMBYTES.ONE) && (val < 32)) {\n              throw new Error(\n                `Invalid two-byte encoding of simple value ${val}`\n              )\n            }\n            const hasParent = (parent != null)\n            val = Simple.decode(\n              val,\n              hasParent,\n              hasParent && (parent[COUNT] < 0))\n          } else {\n            val = utils.parseCBORfloat(val)\n          }\n      }\n      this.emit('value', val, parent_major, parent_length, ai)\n      let again = false\n      while (parent != null) {\n        switch (false) {\n          case val !== SYMS.BREAK:\n            parent[COUNT] = 1\n            break\n          case !Array.isArray(parent):\n            parent.push(val)\n            break\n          case !(parent instanceof NoFilter):\n            const pm = parent[MAJOR]\n            if ((pm != null) && (pm !== mt)) {\n              this.running = false\n              throw new Error('Invalid major type in indefinite encoding')\n            }\n            parent.write(val)\n        }\n        if ((--parent[COUNT]) !== 0) {\n          again = true\n          break\n        }\n        --depth\n        delete parent[COUNT]\n\n        if (Array.isArray(parent)) {\n          switch (parent[MAJOR]) {\n            case MT.ARRAY:\n              val = parent\n              break\n            case MT.MAP:\n              let allstrings = true\n              if ((parent.length % 2) !== 0) {\n                throw new Error('Invalid map length: ' + parent.length)\n              }\n              for (let i = 0, len = parent.length; i < len; i += 2) {\n                if (typeof parent[i] !== 'string') {\n                  allstrings = false\n                  break\n                }\n              }\n              if (allstrings) {\n                val = {}\n                for (let i = 0, len = parent.length; i < len; i += 2) {\n                  val[parent[i]] = parent[i + 1]\n                }\n              } else {\n                val = new Map\n                for (let i = 0, len = parent.length; i < len; i += 2) {\n                  val.set(parent[i], parent[i + 1])\n                }\n              }\n              break\n            case MT.TAG:\n              const t = new Tagged(parent[0], parent[1])\n              val = t.convert(this.tags)\n              break\n          }\n        } else if (parent instanceof NoFilter) {\n          switch (parent[MAJOR]) {\n            case MT.BYTE_STRING:\n              val = parent.slice()\n              break\n            case MT.UTF8_STRING:\n              val = parent.toString('utf-8')\n              break\n          }\n        }\n        this.emit('stop', parent[MAJOR])\n\n        const old = parent\n        parent = parent[SYMS.PARENT]\n        delete old[SYMS.PARENT]\n        delete old[MAJOR]\n      }\n      if (!again) {\n        return val\n      }\n    }\n  }\n}\n\nDecoder.NOT_FOUND = NOT_FOUND\nmodule.exports = Decoder\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\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var readableHwm = options.readableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    pna.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        pna.nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    pna.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._readableState.highWaterMark;\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    pna.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// 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\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\n{\n  // avoid scope creep, the keys array can then be collected\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  pna.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  pna.nextTick(cb, err);\n};","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\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","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","'use strict'\n\nconst encoder = require('./encoder')\nconst decoder = require('./decoder')\nconst constants = require('./constants')\nconst MT = constants.MT\n\n/**\n * Wrapper around a JavaScript Map object that allows the keys to be\n * any complex type.  The base Map object allows this, but will only\n * compare the keys by identity, not by value.  CborMap translates keys\n * to CBOR first (and base64's them to ensure by-value comparison).\n *\n * This is not a subclass of Object, because it would be tough to get\n * the semantics to be an exact match.\n *\n * @class CborMap\n * @extends {Map}\n */\nclass CborMap extends Map {\n  /**\n   * Creates an instance of CborMap.\n   * @param {Iterable<any, any>} [iterable] An Array or other iterable\n   *   object whose elements are key-value pairs (arrays with two elements, e.g.\n   *   <code>[[ 1, 'one' ],[ 2, 'two' ]]</code>). Each key-value pair is added\n   *   to the new CborMap; null values are treated as undefined.\n   */\n  constructor(iterable) {\n    super(iterable)\n  }\n\n  /**\n   * @private\n   */\n  static _encode(key) {\n    return encoder.encodeCanonical(key).toString('base64')\n  }\n\n  /**\n   * @private\n   */\n  static _decode(key) {\n    return decoder.decodeFirstSync(key, 'base64')\n  }\n\n  /**\n   * Retrieve a specified element.\n   *\n   * @param {any} key The key identifying the element to retrieve.\n   *   Can be any type, which will be serialized into CBOR and compared by\n   *   value.\n   * @returns {any} The element if it exists, or <code>undefined</code>.\n   */\n  get(key) {\n    return super.get(CborMap._encode(key))\n  }\n\n  /**\n   * Adds or updates an element with a specified key and value.\n   *\n   * @param {any} key The key identifying the element to store.\n   *   Can be any type, which will be serialized into CBOR and compared by\n   *   value.\n   * @param {any} val The element to store\n   */\n  set(key, val) {\n    return super.set(CborMap._encode(key), val)\n  }\n\n  /**\n   * Removes the specified element.\n   *\n   * @param {any} key The key identifying the element to delete.\n   *   Can be any type, which will be serialized into CBOR and compared by\n   *   value.\n   * @returns {boolean}\n   */\n  delete(key) {\n    return super.delete(CborMap._encode(key))\n  }\n\n  /**\n   * Does an element with the specified key exist?\n   *\n   * @param {any} key The key identifying the element to check.\n   *   Can be any type, which will be serialized into CBOR and compared by\n   *   value.\n   * @returns {boolean}\n   */\n  has(key) {\n    return super.has(CborMap._encode(key))\n  }\n\n  /**\n   * Returns a new Iterator object that contains the keys for each element\n   * in the Map object in insertion order.  The keys are decoded into their\n   * original format.\n   *\n   * @returns {IterableIterator<any>}\n   */\n  *keys() {\n    for (const k of super.keys()) {\n      yield CborMap._decode(k)\n    }\n  }\n\n  /**\n   * Returns a new Iterator object that contains the [key, value] pairs for\n   * each element in the Map object in insertion order.\n   *\n   * @returns {IterableIterator}\n   */\n  *entries() {\n    for (const kv of super.entries()) {\n      yield [CborMap._decode(kv[0]), kv[1]]\n    }\n  }\n\n  /**\n   * Returns a new Iterator object that contains the [key, value] pairs for\n   * each element in the Map object in insertion order.\n   *\n   * @returns {IterableIterator}\n   */\n  [Symbol.iterator]() {\n    return this.entries()\n  }\n\n  /**\n   * Executes a provided function once per each key/value pair in the Map\n   * object, in insertion order.\n   *\n   * @param {function(any, any, Map): undefined} fun Function to execute for\n   *  each element, which takes a value, a key, and the Map being traversed.\n   * @param {any} thisArg Value to use as this when executing callback\n   */\n  forEach(fun, thisArg) {\n    if (typeof(fun) !== 'function') {\n      throw new TypeError('Must be function')\n    }\n    for (const kv of super.entries()) {\n      fun.call(this, kv[1], CborMap._decode(kv[0]), this)\n    }\n  }\n\n  /**\n   * Push the simple value onto the CBOR stream\n   *\n   * @param {Object} gen The generator to push onto\n   * @returns {boolean} true on success\n   */\n  encodeCBOR(gen) {\n    if (!gen._pushInt(this.size, MT.MAP)) {\n      return false\n    }\n    if (gen.canonical) {\n      const entries = Array.from(super.entries())\n        .map((kv) => [Buffer.from(kv[0], 'base64'), kv[1]])\n      entries.sort((a, b) => a[0].compare(b[0]))\n      for (const kv of entries) {\n        if (!(gen.push(kv[0]) && gen.pushAny(kv[1]))) {\n          return false\n        }\n      }\n    } else {\n      for (const kv of super.entries()) {\n        if (!(gen.push(Buffer.from(kv[0], 'base64')) && gen.pushAny(kv[1]))) {\n          return false\n        }\n      }\n    }\n    return true\n  }\n}\n\nmodule.exports = CborMap\n","'use strict'\n\nconst util = require('util')\nconst constants = require('./constants')\nconst MT = constants.MT\nconst SIMPLE = constants.SIMPLE\nconst SYMS = constants.SYMS\n\n/**\n * A CBOR Simple Value that does not map onto a known constant.\n */\nclass Simple {\n  /**\n   * Creates an instance of Simple.\n   *\n   * @param {number} value - the simple value's integer value\n   */\n  constructor(value) {\n    if (typeof value !== 'number') {\n      throw new Error('Invalid Simple type: ' + (typeof value))\n    }\n    if ((value < 0) || (value > 255) || ((value|0) !== value)) {\n      throw new Error('value must be a small positive integer: ' + value)\n    }\n    this.value = value\n  }\n\n  /**\n   * Debug string for simple value\n   *\n   * @returns {string} simple(value)\n   */\n  toString() {\n    return 'simple(' + this.value + ')'\n  }\n\n  /**\n   * Debug string for simple value\n   *\n   * @returns {string} simple(value)\n   */\n  [util.inspect.custom](depth, opts) {\n    return 'simple(' + this.value + ')'\n  }\n\n  /**\n   * Debug string for simple value (backward-compatibility version)\n   *\n   * @returns {string} simple(value)\n   */\n  inspect(depth, opts) {\n    return 'simple(' + this.value + ')'\n  }\n\n  /**\n   * Push the simple value onto the CBOR stream\n   *\n   * @param {Object} gen The generator to push onto\n   */\n  encodeCBOR(gen) {\n    return gen._pushInt(this.value, MT.SIMPLE_FLOAT)\n  }\n\n  /**\n   * Is the given object a Simple?\n   *\n   * @param {any} obj - object to test\n   * @returns {boolean} - is it Simple?\n   */\n  static isSimple(obj) {\n    return obj instanceof Simple\n  }\n\n  /**\n   * Decode from the CBOR additional information into a JavaScript value.\n   * If the CBOR item has no parent, return a \"safe\" symbol instead of\n   * `null` or `undefined`, so that the value can be passed through a\n   * stream in object mode.\n   *\n   * @param {number} val - the CBOR additional info to convert\n   * @param {boolean} [has_parent=true] - Does the CBOR item have a parent?\n   * @param {boolean} [parent_indefinite=false] - Is the parent element\n   *   indefinitely encoded?\n   * @returns {(null|undefined|boolean|Symbol|Simple)} - the decoded value\n   */\n  static decode(val, has_parent=true, parent_indefinite=false) {\n    switch (val) {\n      case SIMPLE.FALSE:\n        return false\n      case SIMPLE.TRUE:\n        return true\n      case SIMPLE.NULL:\n        if (has_parent) {\n          return null\n        } else {\n          return SYMS.NULL\n        }\n      case SIMPLE.UNDEFINED:\n        if (has_parent) {\n          return void 0\n        } else {\n          return SYMS.UNDEFINED\n        }\n      case -1:\n        if (!has_parent || !parent_indefinite) {\n          throw new Error('Invalid BREAK')\n        }\n        return SYMS.BREAK\n      default:\n        return new Simple(val)\n    }\n  }\n}\n\nmodule.exports = Simple\n","module.exports = require('./readable').PassThrough\n","module.exports = require('./readable').Transform\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\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","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}","// 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\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    pna.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    pna.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      pna.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\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\n'use strict';\n\nvar stringifyPrimitive = function(v) {\n  switch (typeof v) {\n    case 'string':\n      return v;\n\n    case 'boolean':\n      return v ? 'true' : 'false';\n\n    case 'number':\n      return isFinite(v) ? v : '';\n\n    default:\n      return '';\n  }\n};\n\nmodule.exports = function(obj, sep, eq, name) {\n  sep = sep || '&';\n  eq = eq || '=';\n  if (obj === null) {\n    obj = undefined;\n  }\n\n  if (typeof obj === 'object') {\n    return map(objectKeys(obj), function(k) {\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n      if (isArray(obj[k])) {\n        return map(obj[k], function(v) {\n          return ks + encodeURIComponent(stringifyPrimitive(v));\n        }).join(sep);\n      } else {\n        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n      }\n    }).join(sep);\n\n  }\n\n  if (!name) return '';\n  return encodeURIComponent(stringifyPrimitive(name)) + eq +\n         encodeURIComponent(stringifyPrimitive(obj));\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n\nfunction map (xs, f) {\n  if (xs.map) return xs.map(f);\n  var res = [];\n  for (var i = 0; i < xs.length; i++) {\n    res.push(f(xs[i], i));\n  }\n  return res;\n}\n\nvar objectKeys = Object.keys || function (obj) {\n  var res = [];\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);\n  }\n  return res;\n};\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*\n * Base64URL-ArrayBuffer\n * https://github.com/herrjemand/Base64URL-ArrayBuffer\n *\n * Copyright (c) 2017 Yuriy Ackermann <ackermann.yuriy@gmail.com>\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n *\n */\n(function () {\n    'use strict'\n\n    var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'\n\n    // Use a lookup table to find the index.\n    var lookup = new Uint8Array(256)\n    for (var i = 0; i < chars.length; i++) {\n        lookup[chars.charCodeAt(i)] = i\n    }\n\n    var encode = function (arraybuffer) {\n        var bytes = new Uint8Array(arraybuffer)\n            var i; var len = bytes.length; var base64 = ''\n\n        for (i = 0; i < len; i += 3) {\n            base64 += chars[bytes[i] >> 2]\n            base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)]\n            base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)]\n            base64 += chars[bytes[i + 2] & 63]\n        }\n\n        if ((len % 3) === 2) {\n            base64 = base64.substring(0, base64.length - 1)\n        } else if (len % 3 === 1) {\n            base64 = base64.substring(0, base64.length - 2)\n        }\n\n        return base64\n    }\n\n    var decode = function (base64) {\n        var bufferLength = base64.length * 0.75\n            var len = base64.length; var i; var p = 0\n            var encoded1; var encoded2; var encoded3; var encoded4\n\n        var arraybuffer = new ArrayBuffer(bufferLength)\n            var bytes = new Uint8Array(arraybuffer)\n\n        for (i = 0; i < len; i += 4) {\n            encoded1 = lookup[base64.charCodeAt(i)]\n            encoded2 = lookup[base64.charCodeAt(i + 1)]\n            encoded3 = lookup[base64.charCodeAt(i + 2)]\n            encoded4 = lookup[base64.charCodeAt(i + 3)]\n\n            bytes[p++] = (encoded1 << 2) | (encoded2 >> 4)\n            bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2)\n            bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63)\n        }\n\n        return arraybuffer\n    }\n\n    /**\n     * Exporting and stuff\n     */\n    if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {\n        module.exports = {\n            encode: encode,\n            decode: decode,\n        }\n    } /* else {\n        if (typeof define === 'function' && define.amd) {\n            define([], function () {\n                return {\n                    'encode': encode,\n                    'decode': decode\n                }\n            });\n        } else {\n            window.base64url = {\n                'encode': encode,\n                'decode': decode\n            }\n        }\n    } */\n})()\n","// Components\nimport VOverlay from '../../components/VOverlay'\n\n// Utilities\nimport {\n  keyCodes,\n  addOnceEventListener,\n  addPassiveEventListener,\n  getZIndex,\n} from '../../util/helpers'\n\n// Types\nimport Vue from 'vue'\n\ninterface Toggleable extends Vue {\n  isActive?: boolean\n}\n\ninterface Stackable extends Vue {\n  activeZIndex: number\n}\n\ninterface options {\n  absolute?: boolean\n  $refs: {\n    dialog?: HTMLElement\n    content?: HTMLElement\n  }\n}\n\n/* @vue/component */\nexport default Vue.extend<Vue & Toggleable & Stackable & options>().extend({\n  name: 'overlayable',\n\n  props: {\n    hideOverlay: Boolean,\n    overlayColor: String,\n    overlayOpacity: [Number, String],\n  },\n\n  data () {\n    return {\n      animationFrame: 0,\n      overlay: null as InstanceType<typeof VOverlay> | null,\n    }\n  },\n\n  watch: {\n    hideOverlay (value) {\n      if (!this.isActive) return\n\n      if (value) this.removeOverlay()\n      else this.genOverlay()\n    },\n  },\n\n  beforeDestroy () {\n    this.removeOverlay()\n  },\n\n  methods: {\n    createOverlay () {\n      const overlay = new VOverlay({\n        propsData: {\n          absolute: this.absolute,\n          value: false,\n          color: this.overlayColor,\n          opacity: this.overlayOpacity,\n        },\n      })\n\n      overlay.$mount()\n\n      const parent = this.absolute\n        ? this.$el.parentNode\n        : document.querySelector('[data-app]')\n\n      parent && parent.insertBefore(overlay.$el, parent.firstChild)\n\n      this.overlay = overlay\n    },\n    genOverlay () {\n      this.hideScroll()\n\n      if (this.hideOverlay) return\n\n      if (!this.overlay) this.createOverlay()\n\n      this.animationFrame = requestAnimationFrame(() => {\n        if (!this.overlay) return\n\n        if (this.activeZIndex !== undefined) {\n          this.overlay.zIndex = String(this.activeZIndex - 1)\n        } else if (this.$el) {\n          this.overlay.zIndex = getZIndex(this.$el)\n        }\n\n        this.overlay.value = true\n      })\n\n      return true\n    },\n    /** removeOverlay(false) will not restore the scollbar afterwards */\n    removeOverlay (showScroll = true) {\n      if (this.overlay) {\n        addOnceEventListener(this.overlay.$el, 'transitionend', () => {\n          if (\n            !this.overlay ||\n            !this.overlay.$el ||\n            !this.overlay.$el.parentNode ||\n            this.overlay.value\n          ) return\n\n          this.overlay.$el.parentNode.removeChild(this.overlay.$el)\n          this.overlay.$destroy()\n          this.overlay = null\n        })\n\n        // Cancel animation frame in case\n        // overlay is removed before it\n        // has finished its animation\n        cancelAnimationFrame(this.animationFrame)\n\n        this.overlay.value = false\n      }\n\n      showScroll && this.showScroll()\n    },\n    scrollListener (e: WheelEvent & KeyboardEvent) {\n      if (e.type === 'keydown') {\n        if (\n          ['INPUT', 'TEXTAREA', 'SELECT'].includes((e.target as Element).tagName) ||\n          // https://github.com/vuetifyjs/vuetify/issues/4715\n          (e.target as HTMLElement).isContentEditable\n        ) return\n\n        const up = [keyCodes.up, keyCodes.pageup]\n        const down = [keyCodes.down, keyCodes.pagedown]\n\n        if (up.includes(e.keyCode)) {\n          (e as any).deltaY = -1\n        } else if (down.includes(e.keyCode)) {\n          (e as any).deltaY = 1\n        } else {\n          return\n        }\n      }\n\n      if (e.target === this.overlay ||\n        (e.type !== 'keydown' && e.target === document.body) ||\n        this.checkPath(e)) e.preventDefault()\n    },\n    hasScrollbar (el?: Element) {\n      if (!el || el.nodeType !== Node.ELEMENT_NODE) return false\n\n      const style = window.getComputedStyle(el)\n      return ['auto', 'scroll'].includes(style.overflowY!) && el.scrollHeight > el.clientHeight\n    },\n    shouldScroll (el: Element, delta: number) {\n      if (el.scrollTop === 0 && delta < 0) return true\n      return el.scrollTop + el.clientHeight === el.scrollHeight && delta > 0\n    },\n    isInside (el: Element, parent: Element): boolean {\n      if (el === parent) {\n        return true\n      } else if (el === null || el === document.body) {\n        return false\n      } else {\n        return this.isInside(el.parentNode as Element, parent)\n      }\n    },\n    checkPath (e: WheelEvent) {\n      const path = e.path || this.composedPath(e)\n      const delta = e.deltaY\n\n      if (e.type === 'keydown' && path[0] === document.body) {\n        const dialog = this.$refs.dialog\n        // getSelection returns null in firefox in some edge cases, can be ignored\n        const selected = window.getSelection()!.anchorNode as Element\n        if (dialog && this.hasScrollbar(dialog) && this.isInside(selected, dialog)) {\n          return this.shouldScroll(dialog, delta)\n        }\n        return true\n      }\n\n      for (let index = 0; index < path.length; index++) {\n        const el = path[index]\n\n        if (el === document) return true\n        if (el === document.documentElement) return true\n        if (el === this.$refs.content) return true\n\n        if (this.hasScrollbar(el as Element)) return this.shouldScroll(el as Element, delta)\n      }\n\n      return true\n    },\n    /**\n     * Polyfill for Event.prototype.composedPath\n     */\n    composedPath (e: WheelEvent): EventTarget[] {\n      if (e.composedPath) return e.composedPath()\n\n      const path = []\n      let el = e.target as Element\n\n      while (el) {\n        path.push(el)\n\n        if (el.tagName === 'HTML') {\n          path.push(document)\n          path.push(window)\n\n          return path\n        }\n\n        el = el.parentElement!\n      }\n      return path\n    },\n    hideScroll () {\n      if (this.$vuetify.breakpoint.smAndDown) {\n        document.documentElement!.classList.add('overflow-y-hidden')\n      } else {\n        addPassiveEventListener(window, 'wheel', this.scrollListener as EventHandlerNonNull, { passive: false })\n        window.addEventListener('keydown', this.scrollListener as EventHandlerNonNull)\n      }\n    },\n    showScroll () {\n      document.documentElement!.classList.remove('overflow-y-hidden')\n      window.removeEventListener('wheel', this.scrollListener as EventHandlerNonNull)\n      window.removeEventListener('keydown', this.scrollListener as EventHandlerNonNull)\n    },\n  },\n})\n","'use strict'\nconst bignumber = require('bignumber.js').BigNumber\n\nexports.MT = {\n  POS_INT: 0,\n  NEG_INT: 1,\n  BYTE_STRING: 2,\n  UTF8_STRING: 3,\n  ARRAY: 4,\n  MAP: 5,\n  TAG: 6,\n  SIMPLE_FLOAT: 7\n}\n\nexports.TAG = {\n  DATE_STRING: 0,\n  DATE_EPOCH: 1,\n  POS_BIGINT: 2,\n  NEG_BIGINT: 3,\n  DECIMAL_FRAC: 4,\n  BIGFLOAT: 5,\n  BASE64URL_EXPECTED: 21,\n  BASE64_EXPECTED: 22,\n  BASE16_EXPECTED: 23,\n  CBOR: 24,\n  URI: 32,\n  BASE64URL: 33,\n  BASE64: 34,\n  REGEXP: 35,\n  MIME: 36\n}\n\nexports.NUMBYTES = {\n  ZERO: 0,\n  ONE: 24,\n  TWO: 25,\n  FOUR: 26,\n  EIGHT: 27,\n  INDEFINITE: 31\n}\n\nexports.SIMPLE = {\n  FALSE: 20,\n  TRUE: 21,\n  NULL: 22,\n  UNDEFINED: 23\n}\n\nexports.SYMS = {\n  NULL: Symbol('null'),\n  UNDEFINED: Symbol('undef'),\n  PARENT: Symbol('parent'),\n  BREAK: Symbol('break'),\n  STREAM: Symbol('stream')\n}\n\nexports.SHIFT32 = 0x100000000\n\nexports.BI = {\n  MINUS_ONE: -1,\n  MAXINT32: 0xffffffff,\n  MAXINT64: '0xffffffffffffffff',\n  SHIFT32: exports.SHIFT32\n}\n\nconst MINUS_ONE = new bignumber(-1)\nexports.BN = {\n  MINUS_ONE,\n  NEG_MAX: MINUS_ONE.minus(\n    new bignumber(Number.MAX_SAFE_INTEGER.toString(16), 16)),\n  MAXINT: new bignumber('0x20000000000000'),\n  MAXINT32: new bignumber(0xffffffff),\n  MAXINT64: new bignumber('0xffffffffffffffff'),\n  SHIFT32: new bignumber(exports.SHIFT32)\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\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function eventListener() {\n      if (errorListener !== undefined) {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n    var errorListener;\n\n    // Adding an error listener is not optional because\n    // if an error is thrown on an event emitter we cannot\n    // guarantee that the actual event we are waiting will\n    // be fired. The result could be a silent way to create\n    // memory or file descriptor leaks, which is something\n    // we should avoid.\n    if (name !== 'error') {\n      errorListener = function errorListener(err) {\n        emitter.removeListener(name, eventListener);\n        reject(err);\n      };\n\n      emitter.once('error', errorListener);\n    }\n\n    emitter.once(name, eventListener);\n  });\n}\n","// Components\nimport VInput from '../../components/VInput'\n\n// Mixins\nimport Rippleable from '../rippleable'\nimport Comparable from '../comparable'\n\n// Utilities\nimport mixins from '../../util/mixins'\n\nexport function prevent (e: Event) {\n  e.preventDefault()\n}\n\n/* @vue/component */\nexport default mixins(\n  VInput,\n  Rippleable,\n  Comparable\n).extend({\n  name: 'selectable',\n\n  model: {\n    prop: 'inputValue',\n    event: 'change',\n  },\n\n  props: {\n    id: String,\n    inputValue: null as any,\n    falseValue: null as any,\n    trueValue: null as any,\n    multiple: {\n      type: Boolean,\n      default: null,\n    },\n    label: String,\n  },\n\n  data () {\n    return {\n      hasColor: this.inputValue,\n      lazyValue: this.inputValue,\n    }\n  },\n\n  computed: {\n    computedColor (): string | undefined {\n      if (!this.isActive) return undefined\n      if (this.color) return this.color\n      if (this.isDark && !this.appIsDark) return 'white'\n      return 'primary'\n    },\n    isMultiple (): boolean {\n      return this.multiple === true || (this.multiple === null && Array.isArray(this.internalValue))\n    },\n    isActive (): boolean {\n      const value = this.value\n      const input = this.internalValue\n\n      if (this.isMultiple) {\n        if (!Array.isArray(input)) return false\n\n        return input.some(item => this.valueComparator(item, value))\n      }\n\n      if (this.trueValue === undefined || this.falseValue === undefined) {\n        return value\n          ? this.valueComparator(value, input)\n          : Boolean(input)\n      }\n\n      return this.valueComparator(input, this.trueValue)\n    },\n    isDirty (): boolean {\n      return this.isActive\n    },\n    rippleState (): string | undefined {\n      return !this.isDisabled && !this.validationState\n        ? undefined\n        : this.validationState\n    },\n  },\n\n  watch: {\n    inputValue (val) {\n      this.lazyValue = val\n      this.hasColor = val\n    },\n  },\n\n  methods: {\n    genLabel () {\n      const label = VInput.options.methods.genLabel.call(this)\n\n      if (!label) return label\n\n      label!.data!.on = {\n        // Label shouldn't cause the input to focus\n        click: prevent,\n      }\n\n      return label\n    },\n    genInput (type: string, attrs: object) {\n      return this.$createElement('input', {\n        attrs: Object.assign({\n          'aria-checked': this.isActive.toString(),\n          disabled: this.isDisabled,\n          id: this.computedId,\n          role: type,\n          type,\n        }, attrs),\n        domProps: {\n          value: this.value,\n          checked: this.isActive,\n        },\n        on: {\n          blur: this.onBlur,\n          change: this.onChange,\n          focus: this.onFocus,\n          keydown: this.onKeydown,\n          click: prevent,\n        },\n        ref: 'input',\n      })\n    },\n    onBlur () {\n      this.isFocused = false\n    },\n    onClick (e: Event) {\n      this.onChange()\n      this.$emit('click', e)\n    },\n    onChange () {\n      if (!this.isInteractive) return\n\n      const value = this.value\n      let input = this.internalValue\n\n      if (this.isMultiple) {\n        if (!Array.isArray(input)) {\n          input = []\n        }\n\n        const length = input.length\n\n        input = input.filter((item: any) => !this.valueComparator(item, value))\n\n        if (input.length === length) {\n          input.push(value)\n        }\n      } else if (this.trueValue !== undefined && this.falseValue !== undefined) {\n        input = this.valueComparator(input, this.trueValue) ? this.falseValue : this.trueValue\n      } else if (value) {\n        input = this.valueComparator(input, value) ? null : value\n      } else {\n        input = !input\n      }\n\n      this.validate(true, input)\n      this.internalValue = input\n      this.hasColor = input\n    },\n    onFocus () {\n      this.isFocused = true\n    },\n    /** @abstract */\n    onKeydown (e: Event) {},\n  },\n})\n"],"sourceRoot":""}