{"version":3,"sources":["webpack://RSSParser/webpack/universalModuleDefinition","webpack://RSSParser/webpack/bootstrap","webpack://RSSParser/./index.js","webpack://RSSParser/./lib/fields.js","webpack://RSSParser/./lib/parser.js","webpack://RSSParser/./lib/utils.js","webpack://RSSParser/./node_modules/base64-js/index.js","webpack://RSSParser/./node_modules/buffer/index.js","webpack://RSSParser/./node_modules/builtin-status-codes/browser.js","webpack://RSSParser/./node_modules/core-util-is/lib/util.js","webpack://RSSParser/./node_modules/entities/index.js","webpack://RSSParser/./node_modules/entities/lib/decode.js","webpack://RSSParser/./node_modules/entities/lib/decode_codepoint.js","webpack://RSSParser/./node_modules/entities/lib/encode.js","webpack://RSSParser/./node_modules/events/events.js","webpack://RSSParser/./node_modules/https-browserify/index.js","webpack://RSSParser/./node_modules/ieee754/index.js","webpack://RSSParser/./node_modules/inherits/inherits_browser.js","webpack://RSSParser/./node_modules/isarray/index.js","webpack://RSSParser/./node_modules/node-libs-browser/node_modules/punycode/punycode.js","webpack://RSSParser/./node_modules/process-nextick-args/index.js","webpack://RSSParser/./node_modules/process/browser.js","webpack://RSSParser/./node_modules/querystring-es3/decode.js","webpack://RSSParser/./node_modules/querystring-es3/encode.js","webpack://RSSParser/./node_modules/querystring-es3/index.js","webpack://RSSParser/./node_modules/readable-stream/duplex-browser.js","webpack://RSSParser/./node_modules/readable-stream/lib/_stream_duplex.js","webpack://RSSParser/./node_modules/readable-stream/lib/_stream_passthrough.js","webpack://RSSParser/./node_modules/readable-stream/lib/_stream_readable.js","webpack://RSSParser/./node_modules/readable-stream/lib/_stream_transform.js","webpack://RSSParser/./node_modules/readable-stream/lib/_stream_writable.js","webpack://RSSParser/./node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack://RSSParser/./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack://RSSParser/./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack://RSSParser/./node_modules/readable-stream/passthrough.js","webpack://RSSParser/./node_modules/readable-stream/readable-browser.js","webpack://RSSParser/./node_modules/readable-stream/transform.js","webpack://RSSParser/./node_modules/readable-stream/writable-browser.js","webpack://RSSParser/./node_modules/safe-buffer/index.js","webpack://RSSParser/./node_modules/sax/lib/sax.js","webpack://RSSParser/./node_modules/setimmediate/setImmediate.js","webpack://RSSParser/./node_modules/stream-browserify/index.js","webpack://RSSParser/./node_modules/stream-http/index.js","webpack://RSSParser/./node_modules/stream-http/lib/capability.js","webpack://RSSParser/./node_modules/stream-http/lib/request.js","webpack://RSSParser/./node_modules/stream-http/lib/response.js","webpack://RSSParser/./node_modules/string_decoder/lib/string_decoder.js","webpack://RSSParser/./node_modules/timers-browserify/main.js","webpack://RSSParser/./node_modules/to-arraybuffer/index.js","webpack://RSSParser/./node_modules/url/url.js","webpack://RSSParser/./node_modules/url/util.js","webpack://RSSParser/./node_modules/util-deprecate/browser.js","webpack://RSSParser/(webpack)/buildin/amd-options.js","webpack://RSSParser/(webpack)/buildin/global.js","webpack://RSSParser/(webpack)/buildin/module.js","webpack://RSSParser/./node_modules/xml2js/lib/bom.js","webpack://RSSParser/./node_modules/xml2js/lib/builder.js","webpack://RSSParser/./node_modules/xml2js/lib/defaults.js","webpack://RSSParser/./node_modules/xml2js/lib/parser.js","webpack://RSSParser/./node_modules/xml2js/lib/processors.js","webpack://RSSParser/./node_modules/xml2js/lib/xml2js.js","webpack://RSSParser/./node_modules/xtend/immutable.js","webpack://RSSParser/util (ignored)","webpack://RSSParser/util (ignored)?f534","webpack://RSSParser/external \"xmlbuilder\""],"names":["module","exports","require","fields","feed","item","mapItunesField","f","podcastFeed","map","podcastItem","http","https","xml2js","url","utils","DEFAULT_HEADERS","DEFAULT_MAX_REDIRECTS","DEFAULT_TIMEOUT","Parser","options","headers","customFields","requestOptions","maxRedirects","timeout","xmlParser","xml","callback","prom","Promise","resolve","reject","parseString","err","result","Error","buildAtomFeed","rss","$","version","match","buildRSS2","buildRSS1","buildRSS0_9","defaultRSS","maybePromisify","feedUrl","redirectCount","get","indexOf","urlParts","parse","Object","assign","requestOpts","req","res","statusCode","newLocation","parseURL","then","encoding","getEncodingFromContentType","setEncoding","on","chunk","setTimeout","clearTimeout","data","e","xmlObj","items","copyFromXML","link","getLink","title","_","updated","lastBuildDate","entry","forEach","length","published","pubDate","Date","toISOString","author","name","content","getContent","contentSnippet","getSnippet","id","setISODate","push","channel","buildRSS","decorateItunes","feedFields","concat","itemFields","href","image","width","height","xmlItem","enclosure","description","guid","category","categories","itunes","owner","email","hasImageHref","text","keywords","keyword","split","index","date","isoDate","trim","entities","stripHtml","str","replace","decode","links","rel","fallbackIdx","i","builder","Builder","headless","explicitRoot","rootName","renderOpts","pretty","buildObject","dest","from","to","Array","isArray","keepArray","undefined","promise","DEFAULT_ENCODING","ENCODING_REGEX","SUPPORTED_ENCODINGS","ENCODING_ALIASES","contentType","toLowerCase","byteLength","toByteArray","fromByteArray","lookup","revLookup","Arr","Uint8Array","code","len","charCodeAt","getLens","b64","validLen","placeHoldersLen","lens","_byteLength","tmp","arr","curByte","tripletToBase64","num","encodeChunk","uint8","start","end","output","join","extraBytes","parts","maxChunkLength","len2","base64","ieee754","Buffer","SlowBuffer","INSPECT_MAX_BYTES","TYPED_ARRAY_SUPPORT","global","typedArraySupport","kMaxLength","__proto__","prototype","foo","subarray","createBuffer","that","RangeError","arg","encodingOrOffset","allocUnsafe","poolSize","_augment","value","TypeError","ArrayBuffer","fromArrayBuffer","fromString","fromObject","Symbol","species","defineProperty","configurable","assertSize","size","alloc","fill","checked","allocUnsafeSlow","string","isEncoding","actual","write","slice","fromArrayLike","array","byteOffset","obj","isBuffer","copy","buffer","isnan","type","toString","b","_isBuffer","compare","a","x","y","Math","min","String","list","pos","buf","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","m","swap16","swap32","swap64","arguments","apply","equals","inspect","max","target","thisStart","thisEnd","thisCopy","targetCopy","bidirectionalIndexOf","val","dir","isNaN","arrayIndexOf","call","lastIndexOf","indexSize","arrLength","valLength","read","readUInt16BE","foundIndex","found","j","includes","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","isFinite","toJSON","_arr","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","decodeCodePointsArray","MAX_ARGUMENTS_LENGTH","codePoints","fromCharCode","ret","out","toHex","bytes","newBuf","sliceLen","checkOffset","ext","readUIntLE","noAssert","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","checkInt","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","floor","objectWriteUInt16","littleEndian","writeUInt16LE","writeUInt16BE","objectWriteUInt32","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","checkIEEE754","writeFloat","writeFloatLE","writeFloatBE","writeDouble","writeDoubleLE","writeDoubleBE","targetStart","set","INVALID_BASE64_RE","base64clean","stringtrim","units","Infinity","leadSurrogate","byteArray","c","hi","lo","src","dst","objectToString","isBoolean","isNull","isNullOrUndefined","isNumber","isString","isSymbol","isUndefined","isRegExp","re","isObject","isDate","d","isError","isFunction","isPrimitive","o","encode","level","XML","HTML","decodeStrict","HTMLStrict","encodeXML","encodeHTML4","encodeHTML5","encodeHTML","decodeXML","decodeXMLStrict","decodeHTML4","decodeHTML5","decodeHTML","decodeHTML4Strict","decodeHTML5Strict","decodeHTMLStrict","escape","entityMap","legacyMap","xmlMap","decodeCodePoint","getStrictDecoder","keys","getReplacer","RegExp","legacy","sort","sorter","replacer","charAt","decodeMap","inverseXML","getInverseObj","xmlReplacer","getInverseReplacer","getInverse","inverseHTML","htmlReplacer","reduce","inverse","single","multiple","k","unshift","re_nonASCII","re_astralSymbols","singleCharReplacer","toUpperCase","astralReplacer","high","low","func","re_xmlChars","escapeXML","R","Reflect","ReflectApply","receiver","args","Function","ReflectOwnKeys","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","ProcessEmitWarning","warning","console","warn","NumberIsNaN","EventEmitter","init","_events","_eventsCount","_maxListeners","defaultMaxListeners","enumerable","getPrototypeOf","create","setMaxListeners","$getMaxListeners","getMaxListeners","emit","doError","events","error","er","message","context","handler","listeners","arrayClone","_addListener","listener","prepend","existing","newListener","warned","w","emitter","count","addListener","prependListener","onceWrapper","fired","removeListener","wrapFn","_onceWrap","state","wrapped","bind","once","prependOnceListener","position","originalListener","shift","spliceOne","off","removeAllListeners","key","_listeners","unwrap","evlistener","unwrapListeners","rawListeners","listenerCount","eventNames","pop","hasOwnProperty","request","params","cb","validateParams","protocol","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","s","NaN","rt","abs","log","LN2","inherits","ctor","superCtor","super_","constructor","writable","TempCtor","root","freeExports","nodeType","freeModule","freeGlobal","window","self","punycode","maxInt","base","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexPunycode","regexNonASCII","regexSeparators","errors","baseMinusTMin","stringFromCharCode","fn","mapDomain","labels","encoded","ucs2decode","counter","extra","ucs2encode","basicToDigit","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","input","inputLength","bias","basic","oldi","t","baseMinusT","splice","handledCPCount","basicLength","q","currentValue","handledCPCountPlusOne","qMinusT","toUnicode","test","toASCII","define","process","nextTick","arg1","arg2","arg3","afterTickOne","afterTickTwo","afterTickThree","afterTick","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","runClearTimeout","marker","queue","draining","currentQueue","queueIndex","cleanUpNextTick","drainQueue","run","Item","browser","env","argv","versions","noop","binding","cwd","chdir","umask","prop","qs","sep","eq","regexp","maxKeys","idx","kstr","vstr","v","decodeURIComponent","xs","stringifyPrimitive","objectKeys","ks","encodeURIComponent","stringify","pna","Duplex","util","Readable","Writable","method","readable","allowHalfOpen","onend","_writableState","highWaterMark","ended","onEndNT","_readableState","destroyed","_destroy","PassThrough","Transform","_transform","ReadableState","EE","EElistenerCount","Stream","OurUint8Array","_uint8ArrayToBuffer","_isUint8Array","debugUtil","debug","debuglog","BufferList","destroyImpl","StringDecoder","kProxyEvents","event","stream","isDuplex","objectMode","readableObjectMode","hwm","readableHwm","readableHighWaterMark","defaultHwm","pipes","pipesCount","flowing","endEmitted","reading","sync","needReadable","emittedReadable","readableListening","resumeScheduled","defaultEncoding","awaitDrain","readingMore","decoder","_read","destroy","_undestroy","undestroy","skipChunkCheck","readableAddChunk","addToFront","onEofChunk","chunkInvalid","addChunk","maybeReadMore","needMoreData","emitReadable","isPaused","enc","MAX_HWM","computeNewHighWaterMark","howMuchToRead","head","nOrig","endReadable","doRead","fromList","emitReadable_","flow","maybeReadMore_","pipe","pipeOpts","doEnd","stdout","stderr","endFn","unpipe","onunpipe","unpipeInfo","hasUnpiped","cleanup","ondrain","pipeOnDrain","cleanedUp","onclose","onfinish","onerror","ondata","needDrain","increasedAwaitDrain","pause","resume","dests","ev","nReadingNextTick","resume_","wrap","_this","paused","_fromList","clear","fromListPartial","hasStrings","copyFromBufferString","copyFromBuffer","p","next","nb","tail","endReadableNT","l","afterTransform","ts","_transformState","transforming","writecb","writechunk","rs","needTransform","writeencoding","transform","flush","_flush","prefinish","done","_write","_this2","err2","WriteReq","CorkedRequest","finish","onCorkedFinish","asyncWrite","setImmediate","WritableState","internalUtil","deprecate","nop","writableObjectMode","writableHwm","writableHighWaterMark","finalCalled","ending","finished","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","errorEmitted","bufferedRequestCount","corkedRequestsFree","getBuffer","current","realHasInstance","hasInstance","object","writev","_writev","final","_final","writeAfterEnd","validChunk","valid","isBuf","writeOrBuffer","cork","uncork","clearBuffer","setDefaultEncoding","decodeChunk","newChunk","last","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","afterWrite","onwriteDrain","holder","allBuffers","endWritable","callFinal","need","corkReq","_classCallCheck","instance","Constructor","copyBuffer","custom","readableDestroyed","writableDestroyed","emitErrorNT","copyProps","SafeBuffer","sax","parser","strict","opt","SAXParser","SAXStream","createStream","MAX_BUFFER_LENGTH","buffers","EVENTS","clearBuffers","bufferCheckPosition","lowercase","lowercasetags","looseCase","tags","closed","closedRoot","sawRoot","tag","noscript","S","BEGIN","strictEntities","ENTITIES","XML_ENTITIES","attribList","xmlns","ns","rootNS","trackPosition","line","column","F","newf","checkBufferLength","maxAllowed","maxActual","closeText","emitNode","cdata","script","flushBuffers","close","ex","streamWraps","filter","_parser","me","_decoder","h","SD","CDATA","DOCTYPE","XML_NAMESPACE","XMLNS_NAMESPACE","nameStart","nameBody","entityStart","entityBody","isWhitespace","isQuote","isAttribEnd","isMatch","regex","notMatch","STATE","BEGIN_WHITESPACE","TEXT","TEXT_ENTITY","OPEN_WAKA","SGML_DECL","SGML_DECL_QUOTED","DOCTYPE_QUOTED","DOCTYPE_DTD","DOCTYPE_DTD_QUOTED","COMMENT_STARTING","COMMENT","COMMENT_ENDING","COMMENT_ENDED","CDATA_ENDING","CDATA_ENDING_2","PROC_INST","PROC_INST_BODY","PROC_INST_ENDING","OPEN_TAG","OPEN_TAG_SLASH","ATTRIB","ATTRIB_NAME","ATTRIB_NAME_SAW_WHITE","ATTRIB_VALUE","ATTRIB_VALUE_QUOTED","ATTRIB_VALUE_CLOSED","ATTRIB_VALUE_UNQUOTED","ATTRIB_VALUE_ENTITY_Q","ATTRIB_VALUE_ENTITY_U","CLOSE_TAG","CLOSE_TAG_SAW_WHITE","SCRIPT","SCRIPT_ENDING","textNode","textopts","normalize","strictFail","newTag","tagName","parent","attributes","qname","attribute","qualName","prefix","local","attrib","attribName","attribValue","qn","openTag","selfClosing","uri","JSON","nv","isSelfClosing","closeTag","closeTo","parseEntity","entity","entityLC","numStr","fromCodePoint","beginWhiteSpace","startTagPosition","starti","substring","sgmlDecl","procInstName","procInstBody","pad","comment","doctype","body","returnState","MAX_SIZE","codeUnits","highSurrogate","lowSurrogate","nextHandle","tasksByHandle","currentlyRunningATask","doc","document","registerImmediate","task","clearImmediate","handle","runIfPresent","installNextTickImplementation","canUsePostMessage","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","installPostMessageImplementation","messagePrefix","random","onGlobalMessage","source","addEventListener","attachEvent","installMessageChannelImplementation","MessageChannel","port1","port2","installReadyStateChangeImplementation","html","documentElement","createElement","onreadystatechange","removeChild","appendChild","installSetTimeoutImplementation","attachTo","_isStdio","didOnEnd","ClientRequest","response","extend","statusCodes","opts","defaultProtocol","location","search","host","hostname","port","path","IncomingMessage","Agent","defaultMaxSockets","globalAgent","STATUS_CODES","METHODS","fetch","ReadableStream","writableStream","WritableStream","abortController","AbortController","blobConstructor","Blob","xhr","getXHR","XMLHttpRequest","open","XDomainRequest","checkTypeSupport","responseType","haveArrayBuffer","haveSlice","arraybuffer","msstream","mozchunkedarraybuffer","overrideMimeType","vbArray","VBArray","capability","toArrayBuffer","rStates","readyStates","decideMode","preferBinary","useFetch","_opts","_body","_headers","auth","setHeader","mode","_mode","_fetchTimer","_onFinish","lowerName","unsafeHeaders","getHeader","header","removeHeader","_destroyed","headersObj","headersList","keyName","signal","fetchTimer","controller","_fetchAbortController","requestTimeout","abort","credentials","withCredentials","_fetchResponse","_connect","reason","_xhr","ontimeout","setRequestHeader","_response","readyState","LOADING","DONE","_onXHRProgress","onprogress","send","statusValid","status","flushHeaders","setNoDelay","setSocketKeepAlive","UNSENT","OPENED","HEADERS_RECEIVED","rawHeaders","trailers","rawTrailers","reader","catch","statusMessage","statusText","_resumeFetch","pipeTo","getReader","_pos","responseURL","getAllResponseHeaders","matches","_charset","mimeType","charsetMatch","responseBody","toArray","responseText","newData","MSStreamReader","onload","readAsArrayBuffer","_normalizeEncoding","retried","normalizeEncoding","nenc","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","r","utf8End","utf8Text","utf8CheckByte","byte","utf8CheckIncomplete","utf8CheckExtraBytes","total","scope","Timeout","setInterval","clearInterval","clearFn","_id","_clearFn","unref","ref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","onTimeout","_onTimeout","arrayCopy","urlParse","urlResolve","resolveObject","urlResolveObject","format","urlFormat","Url","slashes","hash","query","pathname","protocolPattern","portPattern","simplePathPattern","delims","unwise","autoEscape","nonHostChars","hostEndingChars","hostnameMaxLen","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","parseQueryString","slashesDenoteHost","u","queryIndex","splitter","uSplit","slashRegex","rest","simplePath","exec","proto","lowerProto","hostEnd","hec","atSign","parseHost","ipv6Hostname","hostparts","part","newpart","validParts","notHost","bit","ae","esc","qm","relative","tkeys","tk","tkey","rkeys","rk","rkey","relPath","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","authInHost","hasTrailingSlash","up","isAbsolute","msg","config","deprecated","trace","localStorage","g","webpackPolyfill","paths","children","stripBOM","defaults","escapeCDATA","requiresCDATA","wrapCDATA","hasProp","rootObj","attrkey","charkey","render","rootElement","element","attr","child","raw","txt","ele","att","xmldec","allowSurrogateChars","explicitCharkey","normalizeTags","explicitArray","ignoreAttrs","mergeAttrs","validator","explicitChildren","childkey","charsAsChildren","includeWhiteChars","async","attrNameProcessors","attrValueProcessors","tagNameProcessors","valueProcessors","emptyTag","preserveChildrenOrder","chunkSize","bom","isEmpty","processItem","processors","__super__","thing","superClass","reset","assignOrPush","processAsync","xmlnskey","saxParser","error1","errThrown","newValue","ontext","stack","resultObject","EXPLICIT_CHARKEY","onopentag","node","processedKey","onclosetag","emptyStr","nodeName","objClone","old","xpath","results","charChild","oncdata","prefixMatch","firstCharLowerCase","stripPrefix","parseNumbers","parseFloat","parseBooleans","ValidationError"],"mappings":"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","file":"dist/rss-parser.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"xmlbuilder\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"xmlbuilder\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"RSSParser\"] = factory(require(\"xmlbuilder\"));\n\telse\n\t\troot[\"RSSParser\"] = factory(root[\"xmlbuilder\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_xmlbuilder__) {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./index.js\");\n","'use strict';\n\nmodule.exports = require('./lib/parser');\n\n","const fields = module.exports = {};\n\nfields.feed = [\n  ['author', 'creator'],\n  ['dc:publisher', 'publisher'],\n  ['dc:creator', 'creator'],\n  ['dc:source', 'source'],\n  ['dc:title', 'title'],\n  ['dc:type', 'type'],\n  'title',\n  'description',\n  'author',\n  'pubDate',\n  'webMaster',\n  'managingEditor',\n  'generator',\n  'link',\n  'language',\n  'copyright',\n  'lastBuildDate',\n  'docs',\n  'generator',\n  'ttl',\n  'rating',\n  'skipHours',\n  'skipDays',\n];\n\nfields.item = [\n  ['author', 'creator'],\n  ['dc:creator', 'creator'],\n  ['dc:date', 'date'],\n  ['dc:language', 'language'],\n  ['dc:rights', 'rights'],\n  ['dc:source', 'source'],\n  ['dc:title', 'title'],\n  'title',\n  'link',\n  'pubDate',\n  'author',\n  'content:encoded',\n  'enclosure',\n  'dc:creator',\n  'dc:date',\n  'comments',\n];\n\nvar mapItunesField = function(f) {\n  return ['itunes:' + f, f];\n}\n\nfields.podcastFeed = ([\n  'author',\n  'subtitle',\n  'summary',\n  'explicit'\n]).map(mapItunesField);\n\nfields.podcastItem = ([\n  'author',\n  'subtitle',\n  'summary',\n  'explicit',\n  'duration',\n  'image',\n  'episode',\n  'image',\n  'season',\n  'keywords',\n]).map(mapItunesField);\n\n","\"use strict\";\nconst http = require('http');\nconst https = require('https');\nconst xml2js = require('xml2js');\nconst url = require('url');\n\nconst fields = require('./fields');\nconst utils = require('./utils');\n\nconst DEFAULT_HEADERS = {\n  'User-Agent': 'rss-parser',\n  'Accept': 'application/rss+xml',\n}\nconst DEFAULT_MAX_REDIRECTS = 5;\nconst DEFAULT_TIMEOUT = 60000;\n\nclass Parser {\n  constructor(options={}) {\n    options.headers = options.headers || {};\n    options.xml2js = options.xml2js || {};\n    options.customFields = options.customFields || {};\n    options.customFields.item = options.customFields.item || [];\n    options.customFields.feed = options.customFields.feed || [];\n    options.requestOptions = options.requestOptions || {};\n    if (!options.maxRedirects) options.maxRedirects = DEFAULT_MAX_REDIRECTS;\n    if (!options.timeout) options.timeout = DEFAULT_TIMEOUT;\n    this.options = options;\n    this.xmlParser = new xml2js.Parser(this.options.xml2js);\n  }\n\n  parseString(xml, callback) {\n    let prom = new Promise((resolve, reject) => {\n      this.xmlParser.parseString(xml, (err, result) => {\n        if (err) return reject(err);\n        if (!result) {\n          return reject(new Error('Unable to parse XML.'));\n        }\n        let feed = null;\n        if (result.feed) {\n          feed = this.buildAtomFeed(result);\n        } else if (result.rss && result.rss.$ && result.rss.$.version && result.rss.$.version.match(/^2/)) {\n          feed = this.buildRSS2(result);\n        } else if (result['rdf:RDF']) {\n          feed = this.buildRSS1(result);\n        } else if (result.rss && result.rss.$ && result.rss.$.version && result.rss.$.version.match(/0\\.9/)) {\n          feed = this.buildRSS0_9(result);\n        } else if (result.rss && this.options.defaultRSS) {\n          switch(this.options.defaultRSS) {\n            case 0.9:\n              feed = this.buildRSS0_9(result);\n              break;\n            case 1:\n              feed = this.buildRSS1(result);\n              break;\n            case 2:\n              feed = this.buildRSS2(result);\n              break;\n            default:\n              return reject(new Error(\"default RSS version not recognized.\"))\n          }\n        } else {\n          return reject(new Error(\"Feed not recognized as RSS 1 or 2.\"))\n        }\n        resolve(feed);\n      });\n    });\n    prom = utils.maybePromisify(callback, prom);\n    return prom;\n  }\n\n  parseURL(feedUrl, callback, redirectCount=0) {\n    let xml = '';\n    let get = feedUrl.indexOf('https') === 0 ? https.get : http.get;\n    let urlParts = url.parse(feedUrl);\n    let headers = Object.assign({}, DEFAULT_HEADERS, this.options.headers);\n    let timeout = null;\n    let prom = new Promise((resolve, reject) => {\n      const requestOpts = Object.assign({headers}, urlParts, this.options.requestOptions);\n      let req = get(requestOpts, (res) => {\n        if (this.options.maxRedirects && res.statusCode >= 300 && res.statusCode < 400 && res.headers['location']) {\n          if (redirectCount === this.options.maxRedirects) {\n            return reject(new Error(\"Too many redirects\"));\n          } else {\n            const newLocation = url.resolve(feedUrl, res.headers['location']);\n            return this.parseURL(newLocation, null, redirectCount + 1).then(resolve, reject);\n          }\n        } else if (res.statusCode >= 300) {\n          return reject(new Error(\"Status code \" + res.statusCode))\n        }\n        let encoding = utils.getEncodingFromContentType(res.headers['content-type']);\n        res.setEncoding(encoding);\n        res.on('data', (chunk) => {\n          xml += chunk;\n        });\n        res.on('end', () => {\n          return this.parseString(xml).then(resolve, reject);\n        });\n      })\n      req.on('error', reject);\n      timeout = setTimeout(() => {\n        return reject(new Error(\"Request timed out after \" + this.options.timeout + \"ms\"));\n      }, this.options.timeout);\n    }).then(data => {\n      clearTimeout(timeout);\n      return Promise.resolve(data);\n    }, e => {\n      clearTimeout(timeout);\n      return Promise.reject(e);\n    });\n    prom = utils.maybePromisify(callback, prom);\n    return prom;\n  }\n\n  buildAtomFeed(xmlObj) {\n    let feed = {items: []};\n    utils.copyFromXML(xmlObj.feed, feed, this.options.customFields.feed);\n    if (xmlObj.feed.link) {\n      feed.link = utils.getLink(xmlObj.feed.link, 'alternate', 0);\n      feed.feedUrl = utils.getLink(xmlObj.feed.link, 'self', 1);\n    }\n    if (xmlObj.feed.title) {\n      let title = xmlObj.feed.title[0] || '';\n      if (title._) title = title._\n      if (title) feed.title = title;\n    }\n    if (xmlObj.feed.updated) {\n      feed.lastBuildDate = xmlObj.feed.updated[0];\n    }\n    (xmlObj.feed.entry || []).forEach(entry => {\n      let item = {};\n      utils.copyFromXML(entry, item, this.options.customFields.item);\n      if (entry.title) {\n        let title = entry.title[0] || '';\n        if (title._) title = title._;\n        if (title) item.title = title;\n      }\n      if (entry.link && entry.link.length) {\n        item.link = utils.getLink(entry.link, 'alternate', 0);\n      }\n      if (entry.published && entry.published.length && entry.published[0].length) item.pubDate = new Date(entry.published[0]).toISOString();\n      if (!item.pubDate && entry.updated && entry.updated.length && entry.updated[0].length) item.pubDate = new Date(entry.updated[0]).toISOString();\n      if (entry.author && entry.author.length && entry.author[0].name && entry.author[0].name.length) item.author = entry.author[0].name[0];\n      if (entry.content && entry.content.length) {\n        item.content = utils.getContent(entry.content[0]);\n        item.contentSnippet = utils.getSnippet(item.content)\n      }\n      if (entry.id) {\n        item.id = entry.id[0];\n      }\n      this.setISODate(item);\n      feed.items.push(item);\n    });\n    return feed;\n  }\n\n  buildRSS0_9(xmlObj) {\n    var channel = xmlObj.rss.channel[0];\n    var items = channel.item;\n    return this.buildRSS(channel, items);\n  }\n\n  buildRSS1(xmlObj) {\n    xmlObj = xmlObj['rdf:RDF'];\n    let channel = xmlObj.channel[0];\n    let items = xmlObj.item;\n    return this.buildRSS(channel, items);\n  }\n\n  buildRSS2(xmlObj) {\n    let channel = xmlObj.rss.channel[0];\n    let items = channel.item;\n    let feed = this.buildRSS(channel, items);\n    if (xmlObj.rss.$ && xmlObj.rss.$['xmlns:itunes']) {\n      this.decorateItunes(feed, channel);\n    }\n    return feed;\n  }\n\n  buildRSS(channel, items) {\n    items = items || [];\n    let feed = {items: []};\n    let feedFields = fields.feed.concat(this.options.customFields.feed);\n    let itemFields = fields.item.concat(this.options.customFields.item);\n    if (channel['atom:link'] && channel['atom:link'][0] && channel['atom:link'][0].$) {\n      feed.feedUrl = channel['atom:link'][0].$.href;\n    }\n    if (channel.image && channel.image[0] && channel.image[0].url) {\n      feed.image = {};\n      let image = channel.image[0];\n      if (image.link) feed.image.link = image.link[0];\n      if (image.url) feed.image.url = image.url[0];\n      if (image.title) feed.image.title = image.title[0];\n      if (image.width) feed.image.width = image.width[0];\n      if (image.height) feed.image.height = image.height[0];\n    }\n    utils.copyFromXML(channel, feed, feedFields);\n    items.forEach(xmlItem => {\n      let item = {};\n      utils.copyFromXML(xmlItem, item, itemFields);\n      if (xmlItem.enclosure) {\n        item.enclosure = xmlItem.enclosure[0].$;\n      }\n      if (xmlItem.description) {\n        item.content = utils.getContent(xmlItem.description[0]);\n        item.contentSnippet = utils.getSnippet(item.content);\n      }\n      if (xmlItem.guid) {\n        item.guid = xmlItem.guid[0];\n        if (item.guid._) item.guid = item.guid._;\n      }\n      if (xmlItem.category) item.categories = xmlItem.category;\n      this.setISODate(item);\n      feed.items.push(item);\n    });\n    return feed;\n  }\n\n  /**\n   * Add iTunes specific fields from XML to extracted JSON\n   *\n   * @access public\n   * @param {object} feed extracted\n   * @param {object} channel parsed XML\n   */\n  decorateItunes(feed, channel) {\n    let items = channel.item || [];\n    let categories = [];\n    feed.itunes = {}\n\n    if (channel['itunes:owner']) {\n      let owner = {};\n\n      if(channel['itunes:owner'][0]['itunes:name']) {\n        owner.name = channel['itunes:owner'][0]['itunes:name'][0];\n      }\n      if(channel['itunes:owner'][0]['itunes:email']) {\n        owner.email = channel['itunes:owner'][0]['itunes:email'][0];\n      }\n      feed.itunes.owner = owner;\n    }\n\n    if (channel['itunes:image']) {\n      let image;\n      let hasImageHref = (channel['itunes:image'][0] &&\n        channel['itunes:image'][0].$ &&\n        channel['itunes:image'][0].$.href);\n      image = hasImageHref ? channel['itunes:image'][0].$.href : null;\n      if (image) {\n        feed.itunes.image = image;\n      }\n    }\n\n    if(channel['itunes:category']) {\n      channel['itunes:category'].forEach((category) => {\n        categories.push(category.$.text);\n      });\n      feed.itunes.categories = categories;\n    }\n\n    if (channel['itunes:keywords']) {\n      if (channel['itunes:keywords'].length > 1) {\n        feed.itunes.keywords = channel['itunes:keywords'].map(\n          keyword => keyword.$.text\n        );\n      } else {\n        let keywords = channel['itunes:keywords'][0];\n        if (keywords && typeof keywords._ === 'string') {\n          keywords = keywords._;\n        }\n        if (keywords) feed.itunes.keywords = keywords.split(',');\n      }\n    }\n\n    utils.copyFromXML(channel, feed.itunes, fields.podcastFeed);\n    items.forEach((item, index) => {\n      let entry = feed.items[index];\n      entry.itunes = {};\n      utils.copyFromXML(item, entry.itunes, fields.podcastItem);\n      let image = item['itunes:image'];\n      if (image && image[0] && image[0].$ && image[0].$.href) {\n        entry.itunes.image = image[0].$.href;\n      }\n    });\n  }\n\n  setISODate(item) {\n    let date = item.pubDate || item.date;\n    if (date) {\n      try {\n        item.isoDate = new Date(date.trim()).toISOString();\n      } catch (e) {\n        // Ignore bad date format\n      }\n    }\n  }\n}\n\nmodule.exports = Parser;\n","const utils = module.exports = {};\nconst entities = require('entities');\nconst xml2js = require('xml2js');\n\nutils.stripHtml = function(str) {\n  return str.replace(/<(?:.|\\n)*?>/gm, '');\n}\n\nutils.getSnippet = function(str) {\n  return entities.decode(utils.stripHtml(str)).trim();\n}\n\nutils.getLink = function(links, rel, fallbackIdx) {\n  if (!links) return;\n  for (let i = 0; i < links.length; ++i) {\n    if (links[i].$.rel === rel) return links[i].$.href;\n  }\n  if (links[fallbackIdx]) return links[fallbackIdx].$.href;\n}\n\nutils.getContent = function(content) {\n  if (typeof content._ === 'string') {\n    return content._;\n  } else if (typeof content === 'object') {\n    let builder = new xml2js.Builder({headless: true, explicitRoot: true, rootName: 'div', renderOpts: {pretty: false}});\n    return builder.buildObject(content);\n  } else {\n    return content;\n  }\n}\n\nutils.copyFromXML = function(xml, dest, fields) {\n  fields.forEach(function(f) {\n    let from = f;\n    let to = f;\n    let options = {};\n    if (Array.isArray(f)) {\n      from = f[0];\n      to = f[1];\n      if (f.length > 2) {\n        options = f[2];\n      }\n    }\n    const { keepArray } = options;\n    if (xml[from] !== undefined){\n      dest[to] = keepArray ? xml[from] : xml[from][0];\n    }\n    if (dest[to] && typeof dest[to]._ === 'string') {\n      dest[to]=dest[to]._;\n    }\n  })\n}\n\nutils.maybePromisify = function(callback, promise) {\n  if (!callback) return promise;\n  return promise.then(\n    data => setTimeout(() => callback(null, data)),\n    err => setTimeout(() => callback(err))\n  );\n}\n\nconst DEFAULT_ENCODING = 'utf8';\nconst ENCODING_REGEX = /(encoding|charset)\\s*=\\s*(\\S+)/;\nconst SUPPORTED_ENCODINGS = ['ascii', 'utf8', 'utf16le', 'ucs2', 'base64', 'latin1', 'binary', 'hex'];\nconst ENCODING_ALIASES = {\n  'utf-8': 'utf8',\n  'iso-8859-1': 'latin1',\n}\n\nutils.getEncodingFromContentType = function(contentType) {\n  contentType = contentType || '';\n  let match = contentType.match(ENCODING_REGEX);\n  let encoding = (match || [])[2] || '';\n  encoding = encoding.toLowerCase();\n  encoding = ENCODING_ALIASES[encoding] || encoding;\n  if (!encoding || SUPPORTED_ENCODINGS.indexOf(encoding) === -1) {\n    encoding = DEFAULT_ENCODING;\n  }\n  return encoding;\n}\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","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'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","module.exports = {\n  \"100\": \"Continue\",\n  \"101\": \"Switching Protocols\",\n  \"102\": \"Processing\",\n  \"200\": \"OK\",\n  \"201\": \"Created\",\n  \"202\": \"Accepted\",\n  \"203\": \"Non-Authoritative Information\",\n  \"204\": \"No Content\",\n  \"205\": \"Reset Content\",\n  \"206\": \"Partial Content\",\n  \"207\": \"Multi-Status\",\n  \"208\": \"Already Reported\",\n  \"226\": \"IM Used\",\n  \"300\": \"Multiple Choices\",\n  \"301\": \"Moved Permanently\",\n  \"302\": \"Found\",\n  \"303\": \"See Other\",\n  \"304\": \"Not Modified\",\n  \"305\": \"Use Proxy\",\n  \"307\": \"Temporary Redirect\",\n  \"308\": \"Permanent Redirect\",\n  \"400\": \"Bad Request\",\n  \"401\": \"Unauthorized\",\n  \"402\": \"Payment Required\",\n  \"403\": \"Forbidden\",\n  \"404\": \"Not Found\",\n  \"405\": \"Method Not Allowed\",\n  \"406\": \"Not Acceptable\",\n  \"407\": \"Proxy Authentication Required\",\n  \"408\": \"Request Timeout\",\n  \"409\": \"Conflict\",\n  \"410\": \"Gone\",\n  \"411\": \"Length Required\",\n  \"412\": \"Precondition Failed\",\n  \"413\": \"Payload Too Large\",\n  \"414\": \"URI Too Long\",\n  \"415\": \"Unsupported Media Type\",\n  \"416\": \"Range Not Satisfiable\",\n  \"417\": \"Expectation Failed\",\n  \"418\": \"I'm a teapot\",\n  \"421\": \"Misdirected Request\",\n  \"422\": \"Unprocessable Entity\",\n  \"423\": \"Locked\",\n  \"424\": \"Failed Dependency\",\n  \"425\": \"Unordered Collection\",\n  \"426\": \"Upgrade Required\",\n  \"428\": \"Precondition Required\",\n  \"429\": \"Too Many Requests\",\n  \"431\": \"Request Header Fields Too Large\",\n  \"451\": \"Unavailable For Legal Reasons\",\n  \"500\": \"Internal Server Error\",\n  \"501\": \"Not Implemented\",\n  \"502\": \"Bad Gateway\",\n  \"503\": \"Service Unavailable\",\n  \"504\": \"Gateway Timeout\",\n  \"505\": \"HTTP Version Not Supported\",\n  \"506\": \"Variant Also Negotiates\",\n  \"507\": \"Insufficient Storage\",\n  \"508\": \"Loop Detected\",\n  \"509\": \"Bandwidth Limit Exceeded\",\n  \"510\": \"Not Extended\",\n  \"511\": \"Network Authentication Required\"\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","var encode = require(\"./lib/encode.js\"),\n    decode = require(\"./lib/decode.js\");\n\nexports.decode = function(data, level){\n\treturn (!level || level <= 0 ? decode.XML : decode.HTML)(data);\n};\n\nexports.decodeStrict = function(data, level){\n\treturn (!level || level <= 0 ? decode.XML : decode.HTMLStrict)(data);\n};\n\nexports.encode = function(data, level){\n\treturn (!level || level <= 0 ? encode.XML : encode.HTML)(data);\n};\n\nexports.encodeXML = encode.XML;\n\nexports.encodeHTML4 =\nexports.encodeHTML5 =\nexports.encodeHTML  = encode.HTML;\n\nexports.decodeXML =\nexports.decodeXMLStrict = decode.XML;\n\nexports.decodeHTML4 =\nexports.decodeHTML5 =\nexports.decodeHTML = decode.HTML;\n\nexports.decodeHTML4Strict =\nexports.decodeHTML5Strict =\nexports.decodeHTMLStrict = decode.HTMLStrict;\n\nexports.escape = encode.escape;\n","var entityMap = require(\"../maps/entities.json\"),\n    legacyMap = require(\"../maps/legacy.json\"),\n    xmlMap    = require(\"../maps/xml.json\"),\n    decodeCodePoint = require(\"./decode_codepoint.js\");\n\nvar decodeXMLStrict  = getStrictDecoder(xmlMap),\n    decodeHTMLStrict = getStrictDecoder(entityMap);\n\nfunction getStrictDecoder(map){\n\tvar keys = Object.keys(map).join(\"|\"),\n\t    replace = getReplacer(map);\n\n\tkeys += \"|#[xX][\\\\da-fA-F]+|#\\\\d+\";\n\n\tvar re = new RegExp(\"&(?:\" + keys + \");\", \"g\");\n\n\treturn function(str){\n\t\treturn String(str).replace(re, replace);\n\t};\n}\n\nvar decodeHTML = (function(){\n\tvar legacy = Object.keys(legacyMap)\n\t\t.sort(sorter);\n\n\tvar keys = Object.keys(entityMap)\n\t\t.sort(sorter);\n\n\tfor(var i = 0, j = 0; i < keys.length; i++){\n\t\tif(legacy[j] === keys[i]){\n\t\t\tkeys[i] += \";?\";\n\t\t\tj++;\n\t\t} else {\n\t\t\tkeys[i] += \";\";\n\t\t}\n\t}\n\n\tvar re = new RegExp(\"&(?:\" + keys.join(\"|\") + \"|#[xX][\\\\da-fA-F]+;?|#\\\\d+;?)\", \"g\"),\n\t    replace = getReplacer(entityMap);\n\n\tfunction replacer(str){\n\t\tif(str.substr(-1) !== \";\") str += \";\";\n\t\treturn replace(str);\n\t}\n\n\t//TODO consider creating a merged map\n\treturn function(str){\n\t\treturn String(str).replace(re, replacer);\n\t};\n}());\n\nfunction sorter(a, b){\n\treturn a < b ? 1 : -1;\n}\n\nfunction getReplacer(map){\n\treturn function replace(str){\n\t\tif(str.charAt(1) === \"#\"){\n\t\t\tif(str.charAt(2) === \"X\" || str.charAt(2) === \"x\"){\n\t\t\t\treturn decodeCodePoint(parseInt(str.substr(3), 16));\n\t\t\t}\n\t\t\treturn decodeCodePoint(parseInt(str.substr(2), 10));\n\t\t}\n\t\treturn map[str.slice(1, -1)];\n\t};\n}\n\nmodule.exports = {\n\tXML: decodeXMLStrict,\n\tHTML: decodeHTML,\n\tHTMLStrict: decodeHTMLStrict\n};","var decodeMap = require(\"../maps/decode.json\");\n\nmodule.exports = decodeCodePoint;\n\n// modified version of https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119\nfunction decodeCodePoint(codePoint){\n\n\tif((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF){\n\t\treturn \"\\uFFFD\";\n\t}\n\n\tif(codePoint in decodeMap){\n\t\tcodePoint = decodeMap[codePoint];\n\t}\n\n\tvar output = \"\";\n\n\tif(codePoint > 0xFFFF){\n\t\tcodePoint -= 0x10000;\n\t\toutput += String.fromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);\n\t\tcodePoint = 0xDC00 | codePoint & 0x3FF;\n\t}\n\n\toutput += String.fromCharCode(codePoint);\n\treturn output;\n}\n","var inverseXML = getInverseObj(require(\"../maps/xml.json\")),\n    xmlReplacer = getInverseReplacer(inverseXML);\n\nexports.XML = getInverse(inverseXML, xmlReplacer);\n\nvar inverseHTML = getInverseObj(require(\"../maps/entities.json\")),\n    htmlReplacer = getInverseReplacer(inverseHTML);\n\nexports.HTML = getInverse(inverseHTML, htmlReplacer);\n\nfunction getInverseObj(obj){\n\treturn Object.keys(obj).sort().reduce(function(inverse, name){\n\t\tinverse[obj[name]] = \"&\" + name + \";\";\n\t\treturn inverse;\n\t}, {});\n}\n\nfunction getInverseReplacer(inverse){\n\tvar single = [],\n\t    multiple = [];\n\n\tObject.keys(inverse).forEach(function(k){\n\t\tif(k.length === 1){\n\t\t\tsingle.push(\"\\\\\" + k);\n\t\t} else {\n\t\t\tmultiple.push(k);\n\t\t}\n\t});\n\n\t//TODO add ranges\n\tmultiple.unshift(\"[\" + single.join(\"\") + \"]\");\n\n\treturn new RegExp(multiple.join(\"|\"), \"g\");\n}\n\nvar re_nonASCII = /[^\\0-\\x7F]/g,\n    re_astralSymbols = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/g;\n\nfunction singleCharReplacer(c){\n\treturn \"&#x\" + c.charCodeAt(0).toString(16).toUpperCase() + \";\";\n}\n\nfunction astralReplacer(c){\n\t// http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n\tvar high = c.charCodeAt(0);\n\tvar low  = c.charCodeAt(1);\n\tvar codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;\n\treturn \"&#x\" + codePoint.toString(16).toUpperCase() + \";\";\n}\n\nfunction getInverse(inverse, re){\n\tfunction func(name){\n\t\treturn inverse[name];\n\t}\n\n\treturn function(data){\n\t\treturn data\n\t\t\t\t.replace(re, func)\n\t\t\t\t.replace(re_astralSymbols, astralReplacer)\n\t\t\t\t.replace(re_nonASCII, singleCharReplacer);\n\t};\n}\n\nvar re_xmlChars = getInverseReplacer(inverseXML);\n\nfunction escapeXML(data){\n\treturn data\n\t\t\t.replace(re_xmlChars, singleCharReplacer)\n\t\t\t.replace(re_astralSymbols, astralReplacer)\n\t\t\t.replace(re_nonASCII, singleCharReplacer);\n}\n\nexports.escape = escapeXML;\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;\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\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  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\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  var args = [];\n  for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    ReflectApply(this.listener, this.target, args);\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  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      if (typeof listener !== 'function') {\n        throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n      }\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      if (typeof listener !== 'function') {\n        throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n      }\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","var http = require('http')\nvar url = require('url')\n\nvar https = module.exports\n\nfor (var key in http) {\n  if (http.hasOwnProperty(key)) https[key] = http[key]\n}\n\nhttps.request = function (params, cb) {\n  params = validateParams(params)\n  return http.request.call(this, params, cb)\n}\n\nhttps.get = function (params, cb) {\n  params = validateParams(params)\n  return http.get.call(this, params, cb)\n}\n\nfunction validateParams (params) {\n  if (typeof params === 'string') {\n    params = url.parse(params)\n  }\n  if (!params.protocol) {\n    params.protocol = 'https:'\n  }\n  if (params.protocol !== 'https:') {\n    throw new Error('Protocol \"' + params.protocol + '\" not supported. Expected \"https:\"')\n  }\n  return params\n}\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","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","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\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","'use strict';\n\nif (!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","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\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","// 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","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n","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// 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 = 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};","// 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 = 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 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 = 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 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 = 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}","// 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 = 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};","'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}","'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};","module.exports = require('events').EventEmitter;\n","module.exports = require('./readable').PassThrough\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","module.exports = require('./readable').Transform\n","module.exports = require('./lib/_stream_writable.js');\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",";(function (sax) { // wrapper for non-node envs\n  sax.parser = function (strict, opt) { return new SAXParser(strict, opt) }\n  sax.SAXParser = SAXParser\n  sax.SAXStream = SAXStream\n  sax.createStream = createStream\n\n  // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.\n  // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),\n  // since that's the earliest that a buffer overrun could occur.  This way, checks are\n  // as rare as required, but as often as necessary to ensure never crossing this bound.\n  // Furthermore, buffers are only tested at most once per write(), so passing a very\n  // large string into write() might have undesirable effects, but this is manageable by\n  // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme\n  // edge case, result in creating at most one complete copy of the string passed in.\n  // Set to Infinity to have unlimited buffers.\n  sax.MAX_BUFFER_LENGTH = 64 * 1024\n\n  var buffers = [\n    'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',\n    'procInstName', 'procInstBody', 'entity', 'attribName',\n    'attribValue', 'cdata', 'script'\n  ]\n\n  sax.EVENTS = [\n    'text',\n    'processinginstruction',\n    'sgmldeclaration',\n    'doctype',\n    'comment',\n    'opentagstart',\n    'attribute',\n    'opentag',\n    'closetag',\n    'opencdata',\n    'cdata',\n    'closecdata',\n    'error',\n    'end',\n    'ready',\n    'script',\n    'opennamespace',\n    'closenamespace'\n  ]\n\n  function SAXParser (strict, opt) {\n    if (!(this instanceof SAXParser)) {\n      return new SAXParser(strict, opt)\n    }\n\n    var parser = this\n    clearBuffers(parser)\n    parser.q = parser.c = ''\n    parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH\n    parser.opt = opt || {}\n    parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags\n    parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase'\n    parser.tags = []\n    parser.closed = parser.closedRoot = parser.sawRoot = false\n    parser.tag = parser.error = null\n    parser.strict = !!strict\n    parser.noscript = !!(strict || parser.opt.noscript)\n    parser.state = S.BEGIN\n    parser.strictEntities = parser.opt.strictEntities\n    parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES)\n    parser.attribList = []\n\n    // namespaces form a prototype chain.\n    // it always points at the current tag,\n    // which protos to its parent tag.\n    if (parser.opt.xmlns) {\n      parser.ns = Object.create(rootNS)\n    }\n\n    // mostly just for error reporting\n    parser.trackPosition = parser.opt.position !== false\n    if (parser.trackPosition) {\n      parser.position = parser.line = parser.column = 0\n    }\n    emit(parser, 'onready')\n  }\n\n  if (!Object.create) {\n    Object.create = function (o) {\n      function F () {}\n      F.prototype = o\n      var newf = new F()\n      return newf\n    }\n  }\n\n  if (!Object.keys) {\n    Object.keys = function (o) {\n      var a = []\n      for (var i in o) if (o.hasOwnProperty(i)) a.push(i)\n      return a\n    }\n  }\n\n  function checkBufferLength (parser) {\n    var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10)\n    var maxActual = 0\n    for (var i = 0, l = buffers.length; i < l; i++) {\n      var len = parser[buffers[i]].length\n      if (len > maxAllowed) {\n        // Text/cdata nodes can get big, and since they're buffered,\n        // we can get here under normal conditions.\n        // Avoid issues by emitting the text node now,\n        // so at least it won't get any bigger.\n        switch (buffers[i]) {\n          case 'textNode':\n            closeText(parser)\n            break\n\n          case 'cdata':\n            emitNode(parser, 'oncdata', parser.cdata)\n            parser.cdata = ''\n            break\n\n          case 'script':\n            emitNode(parser, 'onscript', parser.script)\n            parser.script = ''\n            break\n\n          default:\n            error(parser, 'Max buffer length exceeded: ' + buffers[i])\n        }\n      }\n      maxActual = Math.max(maxActual, len)\n    }\n    // schedule the next check for the earliest possible buffer overrun.\n    var m = sax.MAX_BUFFER_LENGTH - maxActual\n    parser.bufferCheckPosition = m + parser.position\n  }\n\n  function clearBuffers (parser) {\n    for (var i = 0, l = buffers.length; i < l; i++) {\n      parser[buffers[i]] = ''\n    }\n  }\n\n  function flushBuffers (parser) {\n    closeText(parser)\n    if (parser.cdata !== '') {\n      emitNode(parser, 'oncdata', parser.cdata)\n      parser.cdata = ''\n    }\n    if (parser.script !== '') {\n      emitNode(parser, 'onscript', parser.script)\n      parser.script = ''\n    }\n  }\n\n  SAXParser.prototype = {\n    end: function () { end(this) },\n    write: write,\n    resume: function () { this.error = null; return this },\n    close: function () { return this.write(null) },\n    flush: function () { flushBuffers(this) }\n  }\n\n  var Stream\n  try {\n    Stream = require('stream').Stream\n  } catch (ex) {\n    Stream = function () {}\n  }\n\n  var streamWraps = sax.EVENTS.filter(function (ev) {\n    return ev !== 'error' && ev !== 'end'\n  })\n\n  function createStream (strict, opt) {\n    return new SAXStream(strict, opt)\n  }\n\n  function SAXStream (strict, opt) {\n    if (!(this instanceof SAXStream)) {\n      return new SAXStream(strict, opt)\n    }\n\n    Stream.apply(this)\n\n    this._parser = new SAXParser(strict, opt)\n    this.writable = true\n    this.readable = true\n\n    var me = this\n\n    this._parser.onend = function () {\n      me.emit('end')\n    }\n\n    this._parser.onerror = function (er) {\n      me.emit('error', er)\n\n      // if didn't throw, then means error was handled.\n      // go ahead and clear error, so we can write again.\n      me._parser.error = null\n    }\n\n    this._decoder = null\n\n    streamWraps.forEach(function (ev) {\n      Object.defineProperty(me, 'on' + ev, {\n        get: function () {\n          return me._parser['on' + ev]\n        },\n        set: function (h) {\n          if (!h) {\n            me.removeAllListeners(ev)\n            me._parser['on' + ev] = h\n            return h\n          }\n          me.on(ev, h)\n        },\n        enumerable: true,\n        configurable: false\n      })\n    })\n  }\n\n  SAXStream.prototype = Object.create(Stream.prototype, {\n    constructor: {\n      value: SAXStream\n    }\n  })\n\n  SAXStream.prototype.write = function (data) {\n    if (typeof Buffer === 'function' &&\n      typeof Buffer.isBuffer === 'function' &&\n      Buffer.isBuffer(data)) {\n      if (!this._decoder) {\n        var SD = require('string_decoder').StringDecoder\n        this._decoder = new SD('utf8')\n      }\n      data = this._decoder.write(data)\n    }\n\n    this._parser.write(data.toString())\n    this.emit('data', data)\n    return true\n  }\n\n  SAXStream.prototype.end = function (chunk) {\n    if (chunk && chunk.length) {\n      this.write(chunk)\n    }\n    this._parser.end()\n    return true\n  }\n\n  SAXStream.prototype.on = function (ev, handler) {\n    var me = this\n    if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) {\n      me._parser['on' + ev] = function () {\n        var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments)\n        args.splice(0, 0, ev)\n        me.emit.apply(me, args)\n      }\n    }\n\n    return Stream.prototype.on.call(me, ev, handler)\n  }\n\n  // this really needs to be replaced with character classes.\n  // XML allows all manner of ridiculous numbers and digits.\n  var CDATA = '[CDATA['\n  var DOCTYPE = 'DOCTYPE'\n  var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace'\n  var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/'\n  var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }\n\n  // http://www.w3.org/TR/REC-xml/#NT-NameStartChar\n  // This implementation works on strings, a single character at a time\n  // as such, it cannot ever support astral-plane characters (10000-EFFFF)\n  // without a significant breaking change to either this  parser, or the\n  // JavaScript language.  Implementation of an emoji-capable xml parser\n  // is left as an exercise for the reader.\n  var nameStart = /[:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]/\n\n  var nameBody = /[:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u00B7\\u0300-\\u036F\\u203F-\\u2040.\\d-]/\n\n  var entityStart = /[#:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]/\n  var entityBody = /[#:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u00B7\\u0300-\\u036F\\u203F-\\u2040.\\d-]/\n\n  function isWhitespace (c) {\n    return c === ' ' || c === '\\n' || c === '\\r' || c === '\\t'\n  }\n\n  function isQuote (c) {\n    return c === '\"' || c === '\\''\n  }\n\n  function isAttribEnd (c) {\n    return c === '>' || isWhitespace(c)\n  }\n\n  function isMatch (regex, c) {\n    return regex.test(c)\n  }\n\n  function notMatch (regex, c) {\n    return !isMatch(regex, c)\n  }\n\n  var S = 0\n  sax.STATE = {\n    BEGIN: S++, // leading byte order mark or whitespace\n    BEGIN_WHITESPACE: S++, // leading whitespace\n    TEXT: S++, // general stuff\n    TEXT_ENTITY: S++, // &amp and such.\n    OPEN_WAKA: S++, // <\n    SGML_DECL: S++, // <!BLARG\n    SGML_DECL_QUOTED: S++, // <!BLARG foo \"bar\n    DOCTYPE: S++, // <!DOCTYPE\n    DOCTYPE_QUOTED: S++, // <!DOCTYPE \"//blah\n    DOCTYPE_DTD: S++, // <!DOCTYPE \"//blah\" [ ...\n    DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE \"//blah\" [ \"foo\n    COMMENT_STARTING: S++, // <!-\n    COMMENT: S++, // <!--\n    COMMENT_ENDING: S++, // <!-- blah -\n    COMMENT_ENDED: S++, // <!-- blah --\n    CDATA: S++, // <![CDATA[ something\n    CDATA_ENDING: S++, // ]\n    CDATA_ENDING_2: S++, // ]]\n    PROC_INST: S++, // <?hi\n    PROC_INST_BODY: S++, // <?hi there\n    PROC_INST_ENDING: S++, // <?hi \"there\" ?\n    OPEN_TAG: S++, // <strong\n    OPEN_TAG_SLASH: S++, // <strong /\n    ATTRIB: S++, // <a\n    ATTRIB_NAME: S++, // <a foo\n    ATTRIB_NAME_SAW_WHITE: S++, // <a foo _\n    ATTRIB_VALUE: S++, // <a foo=\n    ATTRIB_VALUE_QUOTED: S++, // <a foo=\"bar\n    ATTRIB_VALUE_CLOSED: S++, // <a foo=\"bar\"\n    ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar\n    ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar=\"&quot;\"\n    ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot\n    CLOSE_TAG: S++, // </a\n    CLOSE_TAG_SAW_WHITE: S++, // </a   >\n    SCRIPT: S++, // <script> ...\n    SCRIPT_ENDING: S++ // <script> ... <\n  }\n\n  sax.XML_ENTITIES = {\n    'amp': '&',\n    'gt': '>',\n    'lt': '<',\n    'quot': '\"',\n    'apos': \"'\"\n  }\n\n  sax.ENTITIES = {\n    'amp': '&',\n    'gt': '>',\n    'lt': '<',\n    'quot': '\"',\n    'apos': \"'\",\n    'AElig': 198,\n    'Aacute': 193,\n    'Acirc': 194,\n    'Agrave': 192,\n    'Aring': 197,\n    'Atilde': 195,\n    'Auml': 196,\n    'Ccedil': 199,\n    'ETH': 208,\n    'Eacute': 201,\n    'Ecirc': 202,\n    'Egrave': 200,\n    'Euml': 203,\n    'Iacute': 205,\n    'Icirc': 206,\n    'Igrave': 204,\n    'Iuml': 207,\n    'Ntilde': 209,\n    'Oacute': 211,\n    'Ocirc': 212,\n    'Ograve': 210,\n    'Oslash': 216,\n    'Otilde': 213,\n    'Ouml': 214,\n    'THORN': 222,\n    'Uacute': 218,\n    'Ucirc': 219,\n    'Ugrave': 217,\n    'Uuml': 220,\n    'Yacute': 221,\n    'aacute': 225,\n    'acirc': 226,\n    'aelig': 230,\n    'agrave': 224,\n    'aring': 229,\n    'atilde': 227,\n    'auml': 228,\n    'ccedil': 231,\n    'eacute': 233,\n    'ecirc': 234,\n    'egrave': 232,\n    'eth': 240,\n    'euml': 235,\n    'iacute': 237,\n    'icirc': 238,\n    'igrave': 236,\n    'iuml': 239,\n    'ntilde': 241,\n    'oacute': 243,\n    'ocirc': 244,\n    'ograve': 242,\n    'oslash': 248,\n    'otilde': 245,\n    'ouml': 246,\n    'szlig': 223,\n    'thorn': 254,\n    'uacute': 250,\n    'ucirc': 251,\n    'ugrave': 249,\n    'uuml': 252,\n    'yacute': 253,\n    'yuml': 255,\n    'copy': 169,\n    'reg': 174,\n    'nbsp': 160,\n    'iexcl': 161,\n    'cent': 162,\n    'pound': 163,\n    'curren': 164,\n    'yen': 165,\n    'brvbar': 166,\n    'sect': 167,\n    'uml': 168,\n    'ordf': 170,\n    'laquo': 171,\n    'not': 172,\n    'shy': 173,\n    'macr': 175,\n    'deg': 176,\n    'plusmn': 177,\n    'sup1': 185,\n    'sup2': 178,\n    'sup3': 179,\n    'acute': 180,\n    'micro': 181,\n    'para': 182,\n    'middot': 183,\n    'cedil': 184,\n    'ordm': 186,\n    'raquo': 187,\n    'frac14': 188,\n    'frac12': 189,\n    'frac34': 190,\n    'iquest': 191,\n    'times': 215,\n    'divide': 247,\n    'OElig': 338,\n    'oelig': 339,\n    'Scaron': 352,\n    'scaron': 353,\n    'Yuml': 376,\n    'fnof': 402,\n    'circ': 710,\n    'tilde': 732,\n    'Alpha': 913,\n    'Beta': 914,\n    'Gamma': 915,\n    'Delta': 916,\n    'Epsilon': 917,\n    'Zeta': 918,\n    'Eta': 919,\n    'Theta': 920,\n    'Iota': 921,\n    'Kappa': 922,\n    'Lambda': 923,\n    'Mu': 924,\n    'Nu': 925,\n    'Xi': 926,\n    'Omicron': 927,\n    'Pi': 928,\n    'Rho': 929,\n    'Sigma': 931,\n    'Tau': 932,\n    'Upsilon': 933,\n    'Phi': 934,\n    'Chi': 935,\n    'Psi': 936,\n    'Omega': 937,\n    'alpha': 945,\n    'beta': 946,\n    'gamma': 947,\n    'delta': 948,\n    'epsilon': 949,\n    'zeta': 950,\n    'eta': 951,\n    'theta': 952,\n    'iota': 953,\n    'kappa': 954,\n    'lambda': 955,\n    'mu': 956,\n    'nu': 957,\n    'xi': 958,\n    'omicron': 959,\n    'pi': 960,\n    'rho': 961,\n    'sigmaf': 962,\n    'sigma': 963,\n    'tau': 964,\n    'upsilon': 965,\n    'phi': 966,\n    'chi': 967,\n    'psi': 968,\n    'omega': 969,\n    'thetasym': 977,\n    'upsih': 978,\n    'piv': 982,\n    'ensp': 8194,\n    'emsp': 8195,\n    'thinsp': 8201,\n    'zwnj': 8204,\n    'zwj': 8205,\n    'lrm': 8206,\n    'rlm': 8207,\n    'ndash': 8211,\n    'mdash': 8212,\n    'lsquo': 8216,\n    'rsquo': 8217,\n    'sbquo': 8218,\n    'ldquo': 8220,\n    'rdquo': 8221,\n    'bdquo': 8222,\n    'dagger': 8224,\n    'Dagger': 8225,\n    'bull': 8226,\n    'hellip': 8230,\n    'permil': 8240,\n    'prime': 8242,\n    'Prime': 8243,\n    'lsaquo': 8249,\n    'rsaquo': 8250,\n    'oline': 8254,\n    'frasl': 8260,\n    'euro': 8364,\n    'image': 8465,\n    'weierp': 8472,\n    'real': 8476,\n    'trade': 8482,\n    'alefsym': 8501,\n    'larr': 8592,\n    'uarr': 8593,\n    'rarr': 8594,\n    'darr': 8595,\n    'harr': 8596,\n    'crarr': 8629,\n    'lArr': 8656,\n    'uArr': 8657,\n    'rArr': 8658,\n    'dArr': 8659,\n    'hArr': 8660,\n    'forall': 8704,\n    'part': 8706,\n    'exist': 8707,\n    'empty': 8709,\n    'nabla': 8711,\n    'isin': 8712,\n    'notin': 8713,\n    'ni': 8715,\n    'prod': 8719,\n    'sum': 8721,\n    'minus': 8722,\n    'lowast': 8727,\n    'radic': 8730,\n    'prop': 8733,\n    'infin': 8734,\n    'ang': 8736,\n    'and': 8743,\n    'or': 8744,\n    'cap': 8745,\n    'cup': 8746,\n    'int': 8747,\n    'there4': 8756,\n    'sim': 8764,\n    'cong': 8773,\n    'asymp': 8776,\n    'ne': 8800,\n    'equiv': 8801,\n    'le': 8804,\n    'ge': 8805,\n    'sub': 8834,\n    'sup': 8835,\n    'nsub': 8836,\n    'sube': 8838,\n    'supe': 8839,\n    'oplus': 8853,\n    'otimes': 8855,\n    'perp': 8869,\n    'sdot': 8901,\n    'lceil': 8968,\n    'rceil': 8969,\n    'lfloor': 8970,\n    'rfloor': 8971,\n    'lang': 9001,\n    'rang': 9002,\n    'loz': 9674,\n    'spades': 9824,\n    'clubs': 9827,\n    'hearts': 9829,\n    'diams': 9830\n  }\n\n  Object.keys(sax.ENTITIES).forEach(function (key) {\n    var e = sax.ENTITIES[key]\n    var s = typeof e === 'number' ? String.fromCharCode(e) : e\n    sax.ENTITIES[key] = s\n  })\n\n  for (var s in sax.STATE) {\n    sax.STATE[sax.STATE[s]] = s\n  }\n\n  // shorthand\n  S = sax.STATE\n\n  function emit (parser, event, data) {\n    parser[event] && parser[event](data)\n  }\n\n  function emitNode (parser, nodeType, data) {\n    if (parser.textNode) closeText(parser)\n    emit(parser, nodeType, data)\n  }\n\n  function closeText (parser) {\n    parser.textNode = textopts(parser.opt, parser.textNode)\n    if (parser.textNode) emit(parser, 'ontext', parser.textNode)\n    parser.textNode = ''\n  }\n\n  function textopts (opt, text) {\n    if (opt.trim) text = text.trim()\n    if (opt.normalize) text = text.replace(/\\s+/g, ' ')\n    return text\n  }\n\n  function error (parser, er) {\n    closeText(parser)\n    if (parser.trackPosition) {\n      er += '\\nLine: ' + parser.line +\n        '\\nColumn: ' + parser.column +\n        '\\nChar: ' + parser.c\n    }\n    er = new Error(er)\n    parser.error = er\n    emit(parser, 'onerror', er)\n    return parser\n  }\n\n  function end (parser) {\n    if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag')\n    if ((parser.state !== S.BEGIN) &&\n      (parser.state !== S.BEGIN_WHITESPACE) &&\n      (parser.state !== S.TEXT)) {\n      error(parser, 'Unexpected end')\n    }\n    closeText(parser)\n    parser.c = ''\n    parser.closed = true\n    emit(parser, 'onend')\n    SAXParser.call(parser, parser.strict, parser.opt)\n    return parser\n  }\n\n  function strictFail (parser, message) {\n    if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {\n      throw new Error('bad call to strictFail')\n    }\n    if (parser.strict) {\n      error(parser, message)\n    }\n  }\n\n  function newTag (parser) {\n    if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()\n    var parent = parser.tags[parser.tags.length - 1] || parser\n    var tag = parser.tag = { name: parser.tagName, attributes: {} }\n\n    // will be overridden if tag contails an xmlns=\"foo\" or xmlns:foo=\"bar\"\n    if (parser.opt.xmlns) {\n      tag.ns = parent.ns\n    }\n    parser.attribList.length = 0\n    emitNode(parser, 'onopentagstart', tag)\n  }\n\n  function qname (name, attribute) {\n    var i = name.indexOf(':')\n    var qualName = i < 0 ? [ '', name ] : name.split(':')\n    var prefix = qualName[0]\n    var local = qualName[1]\n\n    // <x \"xmlns\"=\"http://foo\">\n    if (attribute && name === 'xmlns') {\n      prefix = 'xmlns'\n      local = ''\n    }\n\n    return { prefix: prefix, local: local }\n  }\n\n  function attrib (parser) {\n    if (!parser.strict) {\n      parser.attribName = parser.attribName[parser.looseCase]()\n    }\n\n    if (parser.attribList.indexOf(parser.attribName) !== -1 ||\n      parser.tag.attributes.hasOwnProperty(parser.attribName)) {\n      parser.attribName = parser.attribValue = ''\n      return\n    }\n\n    if (parser.opt.xmlns) {\n      var qn = qname(parser.attribName, true)\n      var prefix = qn.prefix\n      var local = qn.local\n\n      if (prefix === 'xmlns') {\n        // namespace binding attribute. push the binding into scope\n        if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {\n          strictFail(parser,\n            'xml: prefix must be bound to ' + XML_NAMESPACE + '\\n' +\n            'Actual: ' + parser.attribValue)\n        } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) {\n          strictFail(parser,\n            'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\\n' +\n            'Actual: ' + parser.attribValue)\n        } else {\n          var tag = parser.tag\n          var parent = parser.tags[parser.tags.length - 1] || parser\n          if (tag.ns === parent.ns) {\n            tag.ns = Object.create(parent.ns)\n          }\n          tag.ns[local] = parser.attribValue\n        }\n      }\n\n      // defer onattribute events until all attributes have been seen\n      // so any new bindings can take effect. preserve attribute order\n      // so deferred events can be emitted in document order\n      parser.attribList.push([parser.attribName, parser.attribValue])\n    } else {\n      // in non-xmlns mode, we can emit the event right away\n      parser.tag.attributes[parser.attribName] = parser.attribValue\n      emitNode(parser, 'onattribute', {\n        name: parser.attribName,\n        value: parser.attribValue\n      })\n    }\n\n    parser.attribName = parser.attribValue = ''\n  }\n\n  function openTag (parser, selfClosing) {\n    if (parser.opt.xmlns) {\n      // emit namespace binding events\n      var tag = parser.tag\n\n      // add namespace info to tag\n      var qn = qname(parser.tagName)\n      tag.prefix = qn.prefix\n      tag.local = qn.local\n      tag.uri = tag.ns[qn.prefix] || ''\n\n      if (tag.prefix && !tag.uri) {\n        strictFail(parser, 'Unbound namespace prefix: ' +\n          JSON.stringify(parser.tagName))\n        tag.uri = qn.prefix\n      }\n\n      var parent = parser.tags[parser.tags.length - 1] || parser\n      if (tag.ns && parent.ns !== tag.ns) {\n        Object.keys(tag.ns).forEach(function (p) {\n          emitNode(parser, 'onopennamespace', {\n            prefix: p,\n            uri: tag.ns[p]\n          })\n        })\n      }\n\n      // handle deferred onattribute events\n      // Note: do not apply default ns to attributes:\n      //   http://www.w3.org/TR/REC-xml-names/#defaulting\n      for (var i = 0, l = parser.attribList.length; i < l; i++) {\n        var nv = parser.attribList[i]\n        var name = nv[0]\n        var value = nv[1]\n        var qualName = qname(name, true)\n        var prefix = qualName.prefix\n        var local = qualName.local\n        var uri = prefix === '' ? '' : (tag.ns[prefix] || '')\n        var a = {\n          name: name,\n          value: value,\n          prefix: prefix,\n          local: local,\n          uri: uri\n        }\n\n        // if there's any attributes with an undefined namespace,\n        // then fail on them now.\n        if (prefix && prefix !== 'xmlns' && !uri) {\n          strictFail(parser, 'Unbound namespace prefix: ' +\n            JSON.stringify(prefix))\n          a.uri = prefix\n        }\n        parser.tag.attributes[name] = a\n        emitNode(parser, 'onattribute', a)\n      }\n      parser.attribList.length = 0\n    }\n\n    parser.tag.isSelfClosing = !!selfClosing\n\n    // process the tag\n    parser.sawRoot = true\n    parser.tags.push(parser.tag)\n    emitNode(parser, 'onopentag', parser.tag)\n    if (!selfClosing) {\n      // special case for <script> in non-strict mode.\n      if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {\n        parser.state = S.SCRIPT\n      } else {\n        parser.state = S.TEXT\n      }\n      parser.tag = null\n      parser.tagName = ''\n    }\n    parser.attribName = parser.attribValue = ''\n    parser.attribList.length = 0\n  }\n\n  function closeTag (parser) {\n    if (!parser.tagName) {\n      strictFail(parser, 'Weird empty close tag.')\n      parser.textNode += '</>'\n      parser.state = S.TEXT\n      return\n    }\n\n    if (parser.script) {\n      if (parser.tagName !== 'script') {\n        parser.script += '</' + parser.tagName + '>'\n        parser.tagName = ''\n        parser.state = S.SCRIPT\n        return\n      }\n      emitNode(parser, 'onscript', parser.script)\n      parser.script = ''\n    }\n\n    // first make sure that the closing tag actually exists.\n    // <a><b></c></b></a> will close everything, otherwise.\n    var t = parser.tags.length\n    var tagName = parser.tagName\n    if (!parser.strict) {\n      tagName = tagName[parser.looseCase]()\n    }\n    var closeTo = tagName\n    while (t--) {\n      var close = parser.tags[t]\n      if (close.name !== closeTo) {\n        // fail the first time in strict mode\n        strictFail(parser, 'Unexpected close tag')\n      } else {\n        break\n      }\n    }\n\n    // didn't find it.  we already failed for strict, so just abort.\n    if (t < 0) {\n      strictFail(parser, 'Unmatched closing tag: ' + parser.tagName)\n      parser.textNode += '</' + parser.tagName + '>'\n      parser.state = S.TEXT\n      return\n    }\n    parser.tagName = tagName\n    var s = parser.tags.length\n    while (s-- > t) {\n      var tag = parser.tag = parser.tags.pop()\n      parser.tagName = parser.tag.name\n      emitNode(parser, 'onclosetag', parser.tagName)\n\n      var x = {}\n      for (var i in tag.ns) {\n        x[i] = tag.ns[i]\n      }\n\n      var parent = parser.tags[parser.tags.length - 1] || parser\n      if (parser.opt.xmlns && tag.ns !== parent.ns) {\n        // remove namespace bindings introduced by tag\n        Object.keys(tag.ns).forEach(function (p) {\n          var n = tag.ns[p]\n          emitNode(parser, 'onclosenamespace', { prefix: p, uri: n })\n        })\n      }\n    }\n    if (t === 0) parser.closedRoot = true\n    parser.tagName = parser.attribValue = parser.attribName = ''\n    parser.attribList.length = 0\n    parser.state = S.TEXT\n  }\n\n  function parseEntity (parser) {\n    var entity = parser.entity\n    var entityLC = entity.toLowerCase()\n    var num\n    var numStr = ''\n\n    if (parser.ENTITIES[entity]) {\n      return parser.ENTITIES[entity]\n    }\n    if (parser.ENTITIES[entityLC]) {\n      return parser.ENTITIES[entityLC]\n    }\n    entity = entityLC\n    if (entity.charAt(0) === '#') {\n      if (entity.charAt(1) === 'x') {\n        entity = entity.slice(2)\n        num = parseInt(entity, 16)\n        numStr = num.toString(16)\n      } else {\n        entity = entity.slice(1)\n        num = parseInt(entity, 10)\n        numStr = num.toString(10)\n      }\n    }\n    entity = entity.replace(/^0+/, '')\n    if (isNaN(num) || numStr.toLowerCase() !== entity) {\n      strictFail(parser, 'Invalid character entity')\n      return '&' + parser.entity + ';'\n    }\n\n    return String.fromCodePoint(num)\n  }\n\n  function beginWhiteSpace (parser, c) {\n    if (c === '<') {\n      parser.state = S.OPEN_WAKA\n      parser.startTagPosition = parser.position\n    } else if (!isWhitespace(c)) {\n      // have to process this as a text node.\n      // weird, but happens.\n      strictFail(parser, 'Non-whitespace before first tag.')\n      parser.textNode = c\n      parser.state = S.TEXT\n    }\n  }\n\n  function charAt (chunk, i) {\n    var result = ''\n    if (i < chunk.length) {\n      result = chunk.charAt(i)\n    }\n    return result\n  }\n\n  function write (chunk) {\n    var parser = this\n    if (this.error) {\n      throw this.error\n    }\n    if (parser.closed) {\n      return error(parser,\n        'Cannot write after close. Assign an onready handler.')\n    }\n    if (chunk === null) {\n      return end(parser)\n    }\n    if (typeof chunk === 'object') {\n      chunk = chunk.toString()\n    }\n    var i = 0\n    var c = ''\n    while (true) {\n      c = charAt(chunk, i++)\n      parser.c = c\n\n      if (!c) {\n        break\n      }\n\n      if (parser.trackPosition) {\n        parser.position++\n        if (c === '\\n') {\n          parser.line++\n          parser.column = 0\n        } else {\n          parser.column++\n        }\n      }\n\n      switch (parser.state) {\n        case S.BEGIN:\n          parser.state = S.BEGIN_WHITESPACE\n          if (c === '\\uFEFF') {\n            continue\n          }\n          beginWhiteSpace(parser, c)\n          continue\n\n        case S.BEGIN_WHITESPACE:\n          beginWhiteSpace(parser, c)\n          continue\n\n        case S.TEXT:\n          if (parser.sawRoot && !parser.closedRoot) {\n            var starti = i - 1\n            while (c && c !== '<' && c !== '&') {\n              c = charAt(chunk, i++)\n              if (c && parser.trackPosition) {\n                parser.position++\n                if (c === '\\n') {\n                  parser.line++\n                  parser.column = 0\n                } else {\n                  parser.column++\n                }\n              }\n            }\n            parser.textNode += chunk.substring(starti, i - 1)\n          }\n          if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {\n            parser.state = S.OPEN_WAKA\n            parser.startTagPosition = parser.position\n          } else {\n            if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {\n              strictFail(parser, 'Text data outside of root node.')\n            }\n            if (c === '&') {\n              parser.state = S.TEXT_ENTITY\n            } else {\n              parser.textNode += c\n            }\n          }\n          continue\n\n        case S.SCRIPT:\n          // only non-strict\n          if (c === '<') {\n            parser.state = S.SCRIPT_ENDING\n          } else {\n            parser.script += c\n          }\n          continue\n\n        case S.SCRIPT_ENDING:\n          if (c === '/') {\n            parser.state = S.CLOSE_TAG\n          } else {\n            parser.script += '<' + c\n            parser.state = S.SCRIPT\n          }\n          continue\n\n        case S.OPEN_WAKA:\n          // either a /, ?, !, or text is coming next.\n          if (c === '!') {\n            parser.state = S.SGML_DECL\n            parser.sgmlDecl = ''\n          } else if (isWhitespace(c)) {\n            // wait for it...\n          } else if (isMatch(nameStart, c)) {\n            parser.state = S.OPEN_TAG\n            parser.tagName = c\n          } else if (c === '/') {\n            parser.state = S.CLOSE_TAG\n            parser.tagName = ''\n          } else if (c === '?') {\n            parser.state = S.PROC_INST\n            parser.procInstName = parser.procInstBody = ''\n          } else {\n            strictFail(parser, 'Unencoded <')\n            // if there was some whitespace, then add that in.\n            if (parser.startTagPosition + 1 < parser.position) {\n              var pad = parser.position - parser.startTagPosition\n              c = new Array(pad).join(' ') + c\n            }\n            parser.textNode += '<' + c\n            parser.state = S.TEXT\n          }\n          continue\n\n        case S.SGML_DECL:\n          if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {\n            emitNode(parser, 'onopencdata')\n            parser.state = S.CDATA\n            parser.sgmlDecl = ''\n            parser.cdata = ''\n          } else if (parser.sgmlDecl + c === '--') {\n            parser.state = S.COMMENT\n            parser.comment = ''\n            parser.sgmlDecl = ''\n          } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {\n            parser.state = S.DOCTYPE\n            if (parser.doctype || parser.sawRoot) {\n              strictFail(parser,\n                'Inappropriately located doctype declaration')\n            }\n            parser.doctype = ''\n            parser.sgmlDecl = ''\n          } else if (c === '>') {\n            emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl)\n            parser.sgmlDecl = ''\n            parser.state = S.TEXT\n          } else if (isQuote(c)) {\n            parser.state = S.SGML_DECL_QUOTED\n            parser.sgmlDecl += c\n          } else {\n            parser.sgmlDecl += c\n          }\n          continue\n\n        case S.SGML_DECL_QUOTED:\n          if (c === parser.q) {\n            parser.state = S.SGML_DECL\n            parser.q = ''\n          }\n          parser.sgmlDecl += c\n          continue\n\n        case S.DOCTYPE:\n          if (c === '>') {\n            parser.state = S.TEXT\n            emitNode(parser, 'ondoctype', parser.doctype)\n            parser.doctype = true // just remember that we saw it.\n          } else {\n            parser.doctype += c\n            if (c === '[') {\n              parser.state = S.DOCTYPE_DTD\n            } else if (isQuote(c)) {\n              parser.state = S.DOCTYPE_QUOTED\n              parser.q = c\n            }\n          }\n          continue\n\n        case S.DOCTYPE_QUOTED:\n          parser.doctype += c\n          if (c === parser.q) {\n            parser.q = ''\n            parser.state = S.DOCTYPE\n          }\n          continue\n\n        case S.DOCTYPE_DTD:\n          parser.doctype += c\n          if (c === ']') {\n            parser.state = S.DOCTYPE\n          } else if (isQuote(c)) {\n            parser.state = S.DOCTYPE_DTD_QUOTED\n            parser.q = c\n          }\n          continue\n\n        case S.DOCTYPE_DTD_QUOTED:\n          parser.doctype += c\n          if (c === parser.q) {\n            parser.state = S.DOCTYPE_DTD\n            parser.q = ''\n          }\n          continue\n\n        case S.COMMENT:\n          if (c === '-') {\n            parser.state = S.COMMENT_ENDING\n          } else {\n            parser.comment += c\n          }\n          continue\n\n        case S.COMMENT_ENDING:\n          if (c === '-') {\n            parser.state = S.COMMENT_ENDED\n            parser.comment = textopts(parser.opt, parser.comment)\n            if (parser.comment) {\n              emitNode(parser, 'oncomment', parser.comment)\n            }\n            parser.comment = ''\n          } else {\n            parser.comment += '-' + c\n            parser.state = S.COMMENT\n          }\n          continue\n\n        case S.COMMENT_ENDED:\n          if (c !== '>') {\n            strictFail(parser, 'Malformed comment')\n            // allow <!-- blah -- bloo --> in non-strict mode,\n            // which is a comment of \" blah -- bloo \"\n            parser.comment += '--' + c\n            parser.state = S.COMMENT\n          } else {\n            parser.state = S.TEXT\n          }\n          continue\n\n        case S.CDATA:\n          if (c === ']') {\n            parser.state = S.CDATA_ENDING\n          } else {\n            parser.cdata += c\n          }\n          continue\n\n        case S.CDATA_ENDING:\n          if (c === ']') {\n            parser.state = S.CDATA_ENDING_2\n          } else {\n            parser.cdata += ']' + c\n            parser.state = S.CDATA\n          }\n          continue\n\n        case S.CDATA_ENDING_2:\n          if (c === '>') {\n            if (parser.cdata) {\n              emitNode(parser, 'oncdata', parser.cdata)\n            }\n            emitNode(parser, 'onclosecdata')\n            parser.cdata = ''\n            parser.state = S.TEXT\n          } else if (c === ']') {\n            parser.cdata += ']'\n          } else {\n            parser.cdata += ']]' + c\n            parser.state = S.CDATA\n          }\n          continue\n\n        case S.PROC_INST:\n          if (c === '?') {\n            parser.state = S.PROC_INST_ENDING\n          } else if (isWhitespace(c)) {\n            parser.state = S.PROC_INST_BODY\n          } else {\n            parser.procInstName += c\n          }\n          continue\n\n        case S.PROC_INST_BODY:\n          if (!parser.procInstBody && isWhitespace(c)) {\n            continue\n          } else if (c === '?') {\n            parser.state = S.PROC_INST_ENDING\n          } else {\n            parser.procInstBody += c\n          }\n          continue\n\n        case S.PROC_INST_ENDING:\n          if (c === '>') {\n            emitNode(parser, 'onprocessinginstruction', {\n              name: parser.procInstName,\n              body: parser.procInstBody\n            })\n            parser.procInstName = parser.procInstBody = ''\n            parser.state = S.TEXT\n          } else {\n            parser.procInstBody += '?' + c\n            parser.state = S.PROC_INST_BODY\n          }\n          continue\n\n        case S.OPEN_TAG:\n          if (isMatch(nameBody, c)) {\n            parser.tagName += c\n          } else {\n            newTag(parser)\n            if (c === '>') {\n              openTag(parser)\n            } else if (c === '/') {\n              parser.state = S.OPEN_TAG_SLASH\n            } else {\n              if (!isWhitespace(c)) {\n                strictFail(parser, 'Invalid character in tag name')\n              }\n              parser.state = S.ATTRIB\n            }\n          }\n          continue\n\n        case S.OPEN_TAG_SLASH:\n          if (c === '>') {\n            openTag(parser, true)\n            closeTag(parser)\n          } else {\n            strictFail(parser, 'Forward-slash in opening tag not followed by >')\n            parser.state = S.ATTRIB\n          }\n          continue\n\n        case S.ATTRIB:\n          // haven't read the attribute name yet.\n          if (isWhitespace(c)) {\n            continue\n          } else if (c === '>') {\n            openTag(parser)\n          } else if (c === '/') {\n            parser.state = S.OPEN_TAG_SLASH\n          } else if (isMatch(nameStart, c)) {\n            parser.attribName = c\n            parser.attribValue = ''\n            parser.state = S.ATTRIB_NAME\n          } else {\n            strictFail(parser, 'Invalid attribute name')\n          }\n          continue\n\n        case S.ATTRIB_NAME:\n          if (c === '=') {\n            parser.state = S.ATTRIB_VALUE\n          } else if (c === '>') {\n            strictFail(parser, 'Attribute without value')\n            parser.attribValue = parser.attribName\n            attrib(parser)\n            openTag(parser)\n          } else if (isWhitespace(c)) {\n            parser.state = S.ATTRIB_NAME_SAW_WHITE\n          } else if (isMatch(nameBody, c)) {\n            parser.attribName += c\n          } else {\n            strictFail(parser, 'Invalid attribute name')\n          }\n          continue\n\n        case S.ATTRIB_NAME_SAW_WHITE:\n          if (c === '=') {\n            parser.state = S.ATTRIB_VALUE\n          } else if (isWhitespace(c)) {\n            continue\n          } else {\n            strictFail(parser, 'Attribute without value')\n            parser.tag.attributes[parser.attribName] = ''\n            parser.attribValue = ''\n            emitNode(parser, 'onattribute', {\n              name: parser.attribName,\n              value: ''\n            })\n            parser.attribName = ''\n            if (c === '>') {\n              openTag(parser)\n            } else if (isMatch(nameStart, c)) {\n              parser.attribName = c\n              parser.state = S.ATTRIB_NAME\n            } else {\n              strictFail(parser, 'Invalid attribute name')\n              parser.state = S.ATTRIB\n            }\n          }\n          continue\n\n        case S.ATTRIB_VALUE:\n          if (isWhitespace(c)) {\n            continue\n          } else if (isQuote(c)) {\n            parser.q = c\n            parser.state = S.ATTRIB_VALUE_QUOTED\n          } else {\n            strictFail(parser, 'Unquoted attribute value')\n            parser.state = S.ATTRIB_VALUE_UNQUOTED\n            parser.attribValue = c\n          }\n          continue\n\n        case S.ATTRIB_VALUE_QUOTED:\n          if (c !== parser.q) {\n            if (c === '&') {\n              parser.state = S.ATTRIB_VALUE_ENTITY_Q\n            } else {\n              parser.attribValue += c\n            }\n            continue\n          }\n          attrib(parser)\n          parser.q = ''\n          parser.state = S.ATTRIB_VALUE_CLOSED\n          continue\n\n        case S.ATTRIB_VALUE_CLOSED:\n          if (isWhitespace(c)) {\n            parser.state = S.ATTRIB\n          } else if (c === '>') {\n            openTag(parser)\n          } else if (c === '/') {\n            parser.state = S.OPEN_TAG_SLASH\n          } else if (isMatch(nameStart, c)) {\n            strictFail(parser, 'No whitespace between attributes')\n            parser.attribName = c\n            parser.attribValue = ''\n            parser.state = S.ATTRIB_NAME\n          } else {\n            strictFail(parser, 'Invalid attribute name')\n          }\n          continue\n\n        case S.ATTRIB_VALUE_UNQUOTED:\n          if (!isAttribEnd(c)) {\n            if (c === '&') {\n              parser.state = S.ATTRIB_VALUE_ENTITY_U\n            } else {\n              parser.attribValue += c\n            }\n            continue\n          }\n          attrib(parser)\n          if (c === '>') {\n            openTag(parser)\n          } else {\n            parser.state = S.ATTRIB\n          }\n          continue\n\n        case S.CLOSE_TAG:\n          if (!parser.tagName) {\n            if (isWhitespace(c)) {\n              continue\n            } else if (notMatch(nameStart, c)) {\n              if (parser.script) {\n                parser.script += '</' + c\n                parser.state = S.SCRIPT\n              } else {\n                strictFail(parser, 'Invalid tagname in closing tag.')\n              }\n            } else {\n              parser.tagName = c\n            }\n          } else if (c === '>') {\n            closeTag(parser)\n          } else if (isMatch(nameBody, c)) {\n            parser.tagName += c\n          } else if (parser.script) {\n            parser.script += '</' + parser.tagName\n            parser.tagName = ''\n            parser.state = S.SCRIPT\n          } else {\n            if (!isWhitespace(c)) {\n              strictFail(parser, 'Invalid tagname in closing tag')\n            }\n            parser.state = S.CLOSE_TAG_SAW_WHITE\n          }\n          continue\n\n        case S.CLOSE_TAG_SAW_WHITE:\n          if (isWhitespace(c)) {\n            continue\n          }\n          if (c === '>') {\n            closeTag(parser)\n          } else {\n            strictFail(parser, 'Invalid characters in closing tag')\n          }\n          continue\n\n        case S.TEXT_ENTITY:\n        case S.ATTRIB_VALUE_ENTITY_Q:\n        case S.ATTRIB_VALUE_ENTITY_U:\n          var returnState\n          var buffer\n          switch (parser.state) {\n            case S.TEXT_ENTITY:\n              returnState = S.TEXT\n              buffer = 'textNode'\n              break\n\n            case S.ATTRIB_VALUE_ENTITY_Q:\n              returnState = S.ATTRIB_VALUE_QUOTED\n              buffer = 'attribValue'\n              break\n\n            case S.ATTRIB_VALUE_ENTITY_U:\n              returnState = S.ATTRIB_VALUE_UNQUOTED\n              buffer = 'attribValue'\n              break\n          }\n\n          if (c === ';') {\n            parser[buffer] += parseEntity(parser)\n            parser.entity = ''\n            parser.state = returnState\n          } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {\n            parser.entity += c\n          } else {\n            strictFail(parser, 'Invalid character in entity name')\n            parser[buffer] += '&' + parser.entity + c\n            parser.entity = ''\n            parser.state = returnState\n          }\n\n          continue\n\n        default:\n          throw new Error(parser, 'Unknown state: ' + parser.state)\n      }\n    } // while\n\n    if (parser.position >= parser.bufferCheckPosition) {\n      checkBufferLength(parser)\n    }\n    return parser\n  }\n\n  /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */\n  /* istanbul ignore next */\n  if (!String.fromCodePoint) {\n    (function () {\n      var stringFromCharCode = String.fromCharCode\n      var floor = Math.floor\n      var fromCodePoint = function () {\n        var MAX_SIZE = 0x4000\n        var codeUnits = []\n        var highSurrogate\n        var lowSurrogate\n        var index = -1\n        var length = arguments.length\n        if (!length) {\n          return ''\n        }\n        var result = ''\n        while (++index < length) {\n          var codePoint = Number(arguments[index])\n          if (\n            !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`\n            codePoint < 0 || // not a valid Unicode code point\n            codePoint > 0x10FFFF || // not a valid Unicode code point\n            floor(codePoint) !== codePoint // not an integer\n          ) {\n            throw RangeError('Invalid code point: ' + codePoint)\n          }\n          if (codePoint <= 0xFFFF) { // BMP code point\n            codeUnits.push(codePoint)\n          } else { // Astral code point; split in surrogate halves\n            // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n            codePoint -= 0x10000\n            highSurrogate = (codePoint >> 10) + 0xD800\n            lowSurrogate = (codePoint % 0x400) + 0xDC00\n            codeUnits.push(highSurrogate, lowSurrogate)\n          }\n          if (index + 1 === length || codeUnits.length > MAX_SIZE) {\n            result += stringFromCharCode.apply(null, codeUnits)\n            codeUnits.length = 0\n          }\n        }\n        return result\n      }\n      /* istanbul ignore next */\n      if (Object.defineProperty) {\n        Object.defineProperty(String, 'fromCodePoint', {\n          value: fromCodePoint,\n          configurable: true,\n          writable: true\n        })\n      } else {\n        String.fromCodePoint = fromCodePoint\n      }\n    }())\n  }\n})(typeof exports === 'undefined' ? this.sax = {} : exports)\n","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\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","var ClientRequest = require('./lib/request')\nvar response = require('./lib/response')\nvar extend = require('xtend')\nvar statusCodes = require('builtin-status-codes')\nvar url = require('url')\n\nvar http = exports\n\nhttp.request = function (opts, cb) {\n\tif (typeof opts === 'string')\n\t\topts = url.parse(opts)\n\telse\n\t\topts = extend(opts)\n\n\t// Normally, the page is loaded from http or https, so not specifying a protocol\n\t// will result in a (valid) protocol-relative url. However, this won't work if\n\t// the protocol is something else, like 'file:'\n\tvar defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : ''\n\n\tvar protocol = opts.protocol || defaultProtocol\n\tvar host = opts.hostname || opts.host\n\tvar port = opts.port\n\tvar path = opts.path || '/'\n\n\t// Necessary for IPv6 addresses\n\tif (host && host.indexOf(':') !== -1)\n\t\thost = '[' + host + ']'\n\n\t// This may be a relative url. The browser should always be able to interpret it correctly.\n\topts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path\n\topts.method = (opts.method || 'GET').toUpperCase()\n\topts.headers = opts.headers || {}\n\n\t// Also valid opts.auth, opts.mode\n\n\tvar req = new ClientRequest(opts)\n\tif (cb)\n\t\treq.on('response', cb)\n\treturn req\n}\n\nhttp.get = function get (opts, cb) {\n\tvar req = http.request(opts, cb)\n\treq.end()\n\treturn req\n}\n\nhttp.ClientRequest = ClientRequest\nhttp.IncomingMessage = response.IncomingMessage\n\nhttp.Agent = function () {}\nhttp.Agent.defaultMaxSockets = 4\n\nhttp.globalAgent = new http.Agent()\n\nhttp.STATUS_CODES = statusCodes\n\nhttp.METHODS = [\n\t'CHECKOUT',\n\t'CONNECT',\n\t'COPY',\n\t'DELETE',\n\t'GET',\n\t'HEAD',\n\t'LOCK',\n\t'M-SEARCH',\n\t'MERGE',\n\t'MKACTIVITY',\n\t'MKCOL',\n\t'MOVE',\n\t'NOTIFY',\n\t'OPTIONS',\n\t'PATCH',\n\t'POST',\n\t'PROPFIND',\n\t'PROPPATCH',\n\t'PURGE',\n\t'PUT',\n\t'REPORT',\n\t'SEARCH',\n\t'SUBSCRIBE',\n\t'TRACE',\n\t'UNLOCK',\n\t'UNSUBSCRIBE'\n]","exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)\n\nexports.writableStream = isFunction(global.WritableStream)\n\nexports.abortController = isFunction(global.AbortController)\n\nexports.blobConstructor = false\ntry {\n\tnew Blob([new ArrayBuffer(1)])\n\texports.blobConstructor = true\n} catch (e) {}\n\n// The xhr request to example.com may violate some restrictive CSP configurations,\n// so if we're running in a browser that supports `fetch`, avoid calling getXHR()\n// and assume support for certain features below.\nvar xhr\nfunction getXHR () {\n\t// Cache the xhr value\n\tif (xhr !== undefined) return xhr\n\n\tif (global.XMLHttpRequest) {\n\t\txhr = new global.XMLHttpRequest()\n\t\t// If XDomainRequest is available (ie only, where xhr might not work\n\t\t// cross domain), use the page location. Otherwise use example.com\n\t\t// Note: this doesn't actually make an http request.\n\t\ttry {\n\t\t\txhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')\n\t\t} catch(e) {\n\t\t\txhr = null\n\t\t}\n\t} else {\n\t\t// Service workers don't have XHR\n\t\txhr = null\n\t}\n\treturn xhr\n}\n\nfunction checkTypeSupport (type) {\n\tvar xhr = getXHR()\n\tif (!xhr) return false\n\ttry {\n\t\txhr.responseType = type\n\t\treturn xhr.responseType === type\n\t} catch (e) {}\n\treturn false\n}\n\n// For some strange reason, Safari 7.0 reports typeof global.ArrayBuffer === 'object'.\n// Safari 7.1 appears to have fixed this bug.\nvar haveArrayBuffer = typeof global.ArrayBuffer !== 'undefined'\nvar haveSlice = haveArrayBuffer && isFunction(global.ArrayBuffer.prototype.slice)\n\n// If fetch is supported, then arraybuffer will be supported too. Skip calling\n// checkTypeSupport(), since that calls getXHR().\nexports.arraybuffer = exports.fetch || (haveArrayBuffer && checkTypeSupport('arraybuffer'))\n\n// These next two tests unavoidably show warnings in Chrome. Since fetch will always\n// be used if it's available, just return false for these to avoid the warnings.\nexports.msstream = !exports.fetch && haveSlice && checkTypeSupport('ms-stream')\nexports.mozchunkedarraybuffer = !exports.fetch && haveArrayBuffer &&\n\tcheckTypeSupport('moz-chunked-arraybuffer')\n\n// If fetch is supported, then overrideMimeType will be supported too. Skip calling\n// getXHR().\nexports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)\n\nexports.vbArray = isFunction(global.VBArray)\n\nfunction isFunction (value) {\n\treturn typeof value === 'function'\n}\n\nxhr = null // Help gc\n","var capability = require('./capability')\nvar inherits = require('inherits')\nvar response = require('./response')\nvar stream = require('readable-stream')\nvar toArrayBuffer = require('to-arraybuffer')\n\nvar IncomingMessage = response.IncomingMessage\nvar rStates = response.readyStates\n\nfunction decideMode (preferBinary, useFetch) {\n\tif (capability.fetch && useFetch) {\n\t\treturn 'fetch'\n\t} else if (capability.mozchunkedarraybuffer) {\n\t\treturn 'moz-chunked-arraybuffer'\n\t} else if (capability.msstream) {\n\t\treturn 'ms-stream'\n\t} else if (capability.arraybuffer && preferBinary) {\n\t\treturn 'arraybuffer'\n\t} else if (capability.vbArray && preferBinary) {\n\t\treturn 'text:vbarray'\n\t} else {\n\t\treturn 'text'\n\t}\n}\n\nvar ClientRequest = module.exports = function (opts) {\n\tvar self = this\n\tstream.Writable.call(self)\n\n\tself._opts = opts\n\tself._body = []\n\tself._headers = {}\n\tif (opts.auth)\n\t\tself.setHeader('Authorization', 'Basic ' + new Buffer(opts.auth).toString('base64'))\n\tObject.keys(opts.headers).forEach(function (name) {\n\t\tself.setHeader(name, opts.headers[name])\n\t})\n\n\tvar preferBinary\n\tvar useFetch = true\n\tif (opts.mode === 'disable-fetch' || ('requestTimeout' in opts && !capability.abortController)) {\n\t\t// If the use of XHR should be preferred. Not typically needed.\n\t\tuseFetch = false\n\t\tpreferBinary = true\n\t} else if (opts.mode === 'prefer-streaming') {\n\t\t// If streaming is a high priority but binary compatibility and\n\t\t// the accuracy of the 'content-type' header aren't\n\t\tpreferBinary = false\n\t} else if (opts.mode === 'allow-wrong-content-type') {\n\t\t// If streaming is more important than preserving the 'content-type' header\n\t\tpreferBinary = !capability.overrideMimeType\n\t} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {\n\t\t// Use binary if text streaming may corrupt data or the content-type header, or for speed\n\t\tpreferBinary = true\n\t} else {\n\t\tthrow new Error('Invalid value for opts.mode')\n\t}\n\tself._mode = decideMode(preferBinary, useFetch)\n\tself._fetchTimer = null\n\n\tself.on('finish', function () {\n\t\tself._onFinish()\n\t})\n}\n\ninherits(ClientRequest, stream.Writable)\n\nClientRequest.prototype.setHeader = function (name, value) {\n\tvar self = this\n\tvar lowerName = name.toLowerCase()\n\t// This check is not necessary, but it prevents warnings from browsers about setting unsafe\n\t// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but\n\t// http-browserify did it, so I will too.\n\tif (unsafeHeaders.indexOf(lowerName) !== -1)\n\t\treturn\n\n\tself._headers[lowerName] = {\n\t\tname: name,\n\t\tvalue: value\n\t}\n}\n\nClientRequest.prototype.getHeader = function (name) {\n\tvar header = this._headers[name.toLowerCase()]\n\tif (header)\n\t\treturn header.value\n\treturn null\n}\n\nClientRequest.prototype.removeHeader = function (name) {\n\tvar self = this\n\tdelete self._headers[name.toLowerCase()]\n}\n\nClientRequest.prototype._onFinish = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\tvar opts = self._opts\n\n\tvar headersObj = self._headers\n\tvar body = null\n\tif (opts.method !== 'GET' && opts.method !== 'HEAD') {\n\t\tif (capability.arraybuffer) {\n\t\t\tbody = toArrayBuffer(Buffer.concat(self._body))\n\t\t} else if (capability.blobConstructor) {\n\t\t\tbody = new global.Blob(self._body.map(function (buffer) {\n\t\t\t\treturn toArrayBuffer(buffer)\n\t\t\t}), {\n\t\t\t\ttype: (headersObj['content-type'] || {}).value || ''\n\t\t\t})\n\t\t} else {\n\t\t\t// get utf8 string\n\t\t\tbody = Buffer.concat(self._body).toString()\n\t\t}\n\t}\n\n\t// create flattened list of headers\n\tvar headersList = []\n\tObject.keys(headersObj).forEach(function (keyName) {\n\t\tvar name = headersObj[keyName].name\n\t\tvar value = headersObj[keyName].value\n\t\tif (Array.isArray(value)) {\n\t\t\tvalue.forEach(function (v) {\n\t\t\t\theadersList.push([name, v])\n\t\t\t})\n\t\t} else {\n\t\t\theadersList.push([name, value])\n\t\t}\n\t})\n\n\tif (self._mode === 'fetch') {\n\t\tvar signal = null\n\t\tvar fetchTimer = null\n\t\tif (capability.abortController) {\n\t\t\tvar controller = new AbortController()\n\t\t\tsignal = controller.signal\n\t\t\tself._fetchAbortController = controller\n\n\t\t\tif ('requestTimeout' in opts && opts.requestTimeout !== 0) {\n\t\t\t\tself._fetchTimer = global.setTimeout(function () {\n\t\t\t\t\tself.emit('requestTimeout')\n\t\t\t\t\tif (self._fetchAbortController)\n\t\t\t\t\t\tself._fetchAbortController.abort()\n\t\t\t\t}, opts.requestTimeout)\n\t\t\t}\n\t\t}\n\n\t\tglobal.fetch(self._opts.url, {\n\t\t\tmethod: self._opts.method,\n\t\t\theaders: headersList,\n\t\t\tbody: body || undefined,\n\t\t\tmode: 'cors',\n\t\t\tcredentials: opts.withCredentials ? 'include' : 'same-origin',\n\t\t\tsignal: signal\n\t\t}).then(function (response) {\n\t\t\tself._fetchResponse = response\n\t\t\tself._connect()\n\t\t}, function (reason) {\n\t\t\tglobal.clearTimeout(self._fetchTimer)\n\t\t\tif (!self._destroyed)\n\t\t\t\tself.emit('error', reason)\n\t\t})\n\t} else {\n\t\tvar xhr = self._xhr = new global.XMLHttpRequest()\n\t\ttry {\n\t\t\txhr.open(self._opts.method, self._opts.url, true)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\n\t\t// Can't set responseType on really old browsers\n\t\tif ('responseType' in xhr)\n\t\t\txhr.responseType = self._mode.split(':')[0]\n\n\t\tif ('withCredentials' in xhr)\n\t\t\txhr.withCredentials = !!opts.withCredentials\n\n\t\tif (self._mode === 'text' && 'overrideMimeType' in xhr)\n\t\t\txhr.overrideMimeType('text/plain; charset=x-user-defined')\n\n\t\tif ('requestTimeout' in opts) {\n\t\t\txhr.timeout = opts.requestTimeout\n\t\t\txhr.ontimeout = function () {\n\t\t\t\tself.emit('requestTimeout')\n\t\t\t}\n\t\t}\n\n\t\theadersList.forEach(function (header) {\n\t\t\txhr.setRequestHeader(header[0], header[1])\n\t\t})\n\n\t\tself._response = null\n\t\txhr.onreadystatechange = function () {\n\t\t\tswitch (xhr.readyState) {\n\t\t\t\tcase rStates.LOADING:\n\t\t\t\tcase rStates.DONE:\n\t\t\t\t\tself._onXHRProgress()\n\t\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\t// Necessary for streaming in Firefox, since xhr.response is ONLY defined\n\t\t// in onprogress, not in onreadystatechange with xhr.readyState = 3\n\t\tif (self._mode === 'moz-chunked-arraybuffer') {\n\t\t\txhr.onprogress = function () {\n\t\t\t\tself._onXHRProgress()\n\t\t\t}\n\t\t}\n\n\t\txhr.onerror = function () {\n\t\t\tif (self._destroyed)\n\t\t\t\treturn\n\t\t\tself.emit('error', new Error('XHR error'))\n\t\t}\n\n\t\ttry {\n\t\t\txhr.send(body)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\t}\n}\n\n/**\n * Checks if xhr.status is readable and non-zero, indicating no error.\n * Even though the spec says it should be available in readyState 3,\n * accessing it throws an exception in IE8\n */\nfunction statusValid (xhr) {\n\ttry {\n\t\tvar status = xhr.status\n\t\treturn (status !== null && status !== 0)\n\t} catch (e) {\n\t\treturn false\n\t}\n}\n\nClientRequest.prototype._onXHRProgress = function () {\n\tvar self = this\n\n\tif (!statusValid(self._xhr) || self._destroyed)\n\t\treturn\n\n\tif (!self._response)\n\t\tself._connect()\n\n\tself._response._onXHRProgress()\n}\n\nClientRequest.prototype._connect = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\n\tself._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._fetchTimer)\n\tself._response.on('error', function(err) {\n\t\tself.emit('error', err)\n\t})\n\n\tself.emit('response', self._response)\n}\n\nClientRequest.prototype._write = function (chunk, encoding, cb) {\n\tvar self = this\n\n\tself._body.push(chunk)\n\tcb()\n}\n\nClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {\n\tvar self = this\n\tself._destroyed = true\n\tglobal.clearTimeout(self._fetchTimer)\n\tif (self._response)\n\t\tself._response._destroyed = true\n\tif (self._xhr)\n\t\tself._xhr.abort()\n\telse if (self._fetchAbortController)\n\t\tself._fetchAbortController.abort()\n}\n\nClientRequest.prototype.end = function (data, encoding, cb) {\n\tvar self = this\n\tif (typeof data === 'function') {\n\t\tcb = data\n\t\tdata = undefined\n\t}\n\n\tstream.Writable.prototype.end.call(self, data, encoding, cb)\n}\n\nClientRequest.prototype.flushHeaders = function () {}\nClientRequest.prototype.setTimeout = function () {}\nClientRequest.prototype.setNoDelay = function () {}\nClientRequest.prototype.setSocketKeepAlive = function () {}\n\n// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method\nvar unsafeHeaders = [\n\t'accept-charset',\n\t'accept-encoding',\n\t'access-control-request-headers',\n\t'access-control-request-method',\n\t'connection',\n\t'content-length',\n\t'cookie',\n\t'cookie2',\n\t'date',\n\t'dnt',\n\t'expect',\n\t'host',\n\t'keep-alive',\n\t'origin',\n\t'referer',\n\t'te',\n\t'trailer',\n\t'transfer-encoding',\n\t'upgrade',\n\t'via'\n]\n","var capability = require('./capability')\nvar inherits = require('inherits')\nvar stream = require('readable-stream')\n\nvar rStates = exports.readyStates = {\n\tUNSENT: 0,\n\tOPENED: 1,\n\tHEADERS_RECEIVED: 2,\n\tLOADING: 3,\n\tDONE: 4\n}\n\nvar IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, fetchTimer) {\n\tvar self = this\n\tstream.Readable.call(self)\n\n\tself._mode = mode\n\tself.headers = {}\n\tself.rawHeaders = []\n\tself.trailers = {}\n\tself.rawTrailers = []\n\n\t// Fake the 'close' event, but only once 'end' fires\n\tself.on('end', function () {\n\t\t// The nextTick is necessary to prevent the 'request' module from causing an infinite loop\n\t\tprocess.nextTick(function () {\n\t\t\tself.emit('close')\n\t\t})\n\t})\n\n\tif (mode === 'fetch') {\n\t\tself._fetchResponse = response\n\n\t\tself.url = response.url\n\t\tself.statusCode = response.status\n\t\tself.statusMessage = response.statusText\n\t\t\n\t\tresponse.headers.forEach(function (header, key){\n\t\t\tself.headers[key.toLowerCase()] = header\n\t\t\tself.rawHeaders.push(key, header)\n\t\t})\n\n\t\tif (capability.writableStream) {\n\t\t\tvar writable = new WritableStream({\n\t\t\t\twrite: function (chunk) {\n\t\t\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t\t\tif (self._destroyed) {\n\t\t\t\t\t\t\treject()\n\t\t\t\t\t\t} else if(self.push(new Buffer(chunk))) {\n\t\t\t\t\t\t\tresolve()\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tself._resumeFetch = resolve\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t\t},\n\t\t\t\tclose: function () {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.push(null)\n\t\t\t\t},\n\t\t\t\tabort: function (err) {\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t}\n\t\t\t})\n\n\t\t\ttry {\n\t\t\t\tresponse.body.pipeTo(writable).catch(function (err) {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t})\n\t\t\t\treturn\n\t\t\t} catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this\n\t\t}\n\t\t// fallback for when writableStream or pipeTo aren't available\n\t\tvar reader = response.body.getReader()\n\t\tfunction read () {\n\t\t\treader.read().then(function (result) {\n\t\t\t\tif (self._destroyed)\n\t\t\t\t\treturn\n\t\t\t\tif (result.done) {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tself.push(null)\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tself.push(new Buffer(result.value))\n\t\t\t\tread()\n\t\t\t}).catch(function (err) {\n\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\tif (!self._destroyed)\n\t\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t}\n\t\tread()\n\t} else {\n\t\tself._xhr = xhr\n\t\tself._pos = 0\n\n\t\tself.url = xhr.responseURL\n\t\tself.statusCode = xhr.status\n\t\tself.statusMessage = xhr.statusText\n\t\tvar headers = xhr.getAllResponseHeaders().split(/\\r?\\n/)\n\t\theaders.forEach(function (header) {\n\t\t\tvar matches = header.match(/^([^:]+):\\s*(.*)/)\n\t\t\tif (matches) {\n\t\t\t\tvar key = matches[1].toLowerCase()\n\t\t\t\tif (key === 'set-cookie') {\n\t\t\t\t\tif (self.headers[key] === undefined) {\n\t\t\t\t\t\tself.headers[key] = []\n\t\t\t\t\t}\n\t\t\t\t\tself.headers[key].push(matches[2])\n\t\t\t\t} else if (self.headers[key] !== undefined) {\n\t\t\t\t\tself.headers[key] += ', ' + matches[2]\n\t\t\t\t} else {\n\t\t\t\t\tself.headers[key] = matches[2]\n\t\t\t\t}\n\t\t\t\tself.rawHeaders.push(matches[1], matches[2])\n\t\t\t}\n\t\t})\n\n\t\tself._charset = 'x-user-defined'\n\t\tif (!capability.overrideMimeType) {\n\t\t\tvar mimeType = self.rawHeaders['mime-type']\n\t\t\tif (mimeType) {\n\t\t\t\tvar charsetMatch = mimeType.match(/;\\s*charset=([^;])(;|$)/)\n\t\t\t\tif (charsetMatch) {\n\t\t\t\t\tself._charset = charsetMatch[1].toLowerCase()\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!self._charset)\n\t\t\t\tself._charset = 'utf-8' // best guess\n\t\t}\n\t}\n}\n\ninherits(IncomingMessage, stream.Readable)\n\nIncomingMessage.prototype._read = function () {\n\tvar self = this\n\n\tvar resolve = self._resumeFetch\n\tif (resolve) {\n\t\tself._resumeFetch = null\n\t\tresolve()\n\t}\n}\n\nIncomingMessage.prototype._onXHRProgress = function () {\n\tvar self = this\n\n\tvar xhr = self._xhr\n\n\tvar response = null\n\tswitch (self._mode) {\n\t\tcase 'text:vbarray': // For IE9\n\t\t\tif (xhr.readyState !== rStates.DONE)\n\t\t\t\tbreak\n\t\t\ttry {\n\t\t\t\t// This fails in IE8\n\t\t\t\tresponse = new global.VBArray(xhr.responseBody).toArray()\n\t\t\t} catch (e) {}\n\t\t\tif (response !== null) {\n\t\t\t\tself.push(new Buffer(response))\n\t\t\t\tbreak\n\t\t\t}\n\t\t\t// Falls through in IE8\t\n\t\tcase 'text':\n\t\t\ttry { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4\n\t\t\t\tresponse = xhr.responseText\n\t\t\t} catch (e) {\n\t\t\t\tself._mode = 'text:vbarray'\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tif (response.length > self._pos) {\n\t\t\t\tvar newData = response.substr(self._pos)\n\t\t\t\tif (self._charset === 'x-user-defined') {\n\t\t\t\t\tvar buffer = new Buffer(newData.length)\n\t\t\t\t\tfor (var i = 0; i < newData.length; i++)\n\t\t\t\t\t\tbuffer[i] = newData.charCodeAt(i) & 0xff\n\n\t\t\t\t\tself.push(buffer)\n\t\t\t\t} else {\n\t\t\t\t\tself.push(newData, self._charset)\n\t\t\t\t}\n\t\t\t\tself._pos = response.length\n\t\t\t}\n\t\t\tbreak\n\t\tcase 'arraybuffer':\n\t\t\tif (xhr.readyState !== rStates.DONE || !xhr.response)\n\t\t\t\tbreak\n\t\t\tresponse = xhr.response\n\t\t\tself.push(new Buffer(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'moz-chunked-arraybuffer': // take whole\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING || !response)\n\t\t\t\tbreak\n\t\t\tself.push(new Buffer(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'ms-stream':\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING)\n\t\t\t\tbreak\n\t\t\tvar reader = new global.MSStreamReader()\n\t\t\treader.onprogress = function () {\n\t\t\t\tif (reader.result.byteLength > self._pos) {\n\t\t\t\t\tself.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))))\n\t\t\t\t\tself._pos = reader.result.byteLength\n\t\t\t\t}\n\t\t\t}\n\t\t\treader.onload = function () {\n\t\t\t\tself.push(null)\n\t\t\t}\n\t\t\t// reader.onerror = ??? // TODO: this\n\t\t\treader.readAsArrayBuffer(response)\n\t\t\tbreak\n\t}\n\n\t// The ms-stream case handles end separately in reader.onload()\n\tif (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {\n\t\tself.push(null)\n\t}\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/*<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}","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n","var Buffer = require('buffer').Buffer\n\nmodule.exports = function (buf) {\n\t// If the buffer is backed by a Uint8Array, a faster version will work\n\tif (buf instanceof Uint8Array) {\n\t\t// If the buffer isn't a subarray, return the underlying ArrayBuffer\n\t\tif (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {\n\t\t\treturn buf.buffer\n\t\t} else if (typeof buf.buffer.slice === 'function') {\n\t\t\t// Otherwise we need to get a proper copy\n\t\t\treturn buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)\n\t\t}\n\t}\n\n\tif (Buffer.isBuffer(buf)) {\n\t\t// This is the slow version that will work with any Buffer\n\t\t// implementation (even in old browsers)\n\t\tvar arrayCopy = new Uint8Array(buf.length)\n\t\tvar len = buf.length\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tarrayCopy[i] = buf[i]\n\t\t}\n\t\treturn arrayCopy.buffer\n\t} else {\n\t\tthrow new Error('Argument must be a Buffer')\n\t}\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 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\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","\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","/* globals __webpack_amd_options__ */\nmodule.exports = __webpack_amd_options__;\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","module.exports = function(module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function() {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  \"use strict\";\n  exports.stripBOM = function(str) {\n    if (str[0] === '\\uFEFF') {\n      return str.substring(1);\n    } else {\n      return str;\n    }\n  };\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  \"use strict\";\n  var builder, defaults, escapeCDATA, requiresCDATA, wrapCDATA,\n    hasProp = {}.hasOwnProperty;\n\n  builder = require('xmlbuilder');\n\n  defaults = require('./defaults').defaults;\n\n  requiresCDATA = function(entry) {\n    return typeof entry === \"string\" && (entry.indexOf('&') >= 0 || entry.indexOf('>') >= 0 || entry.indexOf('<') >= 0);\n  };\n\n  wrapCDATA = function(entry) {\n    return \"<![CDATA[\" + (escapeCDATA(entry)) + \"]]>\";\n  };\n\n  escapeCDATA = function(entry) {\n    return entry.replace(']]>', ']]]]><![CDATA[>');\n  };\n\n  exports.Builder = (function() {\n    function Builder(opts) {\n      var key, ref, value;\n      this.options = {};\n      ref = defaults[\"0.2\"];\n      for (key in ref) {\n        if (!hasProp.call(ref, key)) continue;\n        value = ref[key];\n        this.options[key] = value;\n      }\n      for (key in opts) {\n        if (!hasProp.call(opts, key)) continue;\n        value = opts[key];\n        this.options[key] = value;\n      }\n    }\n\n    Builder.prototype.buildObject = function(rootObj) {\n      var attrkey, charkey, render, rootElement, rootName;\n      attrkey = this.options.attrkey;\n      charkey = this.options.charkey;\n      if ((Object.keys(rootObj).length === 1) && (this.options.rootName === defaults['0.2'].rootName)) {\n        rootName = Object.keys(rootObj)[0];\n        rootObj = rootObj[rootName];\n      } else {\n        rootName = this.options.rootName;\n      }\n      render = (function(_this) {\n        return function(element, obj) {\n          var attr, child, entry, index, key, value;\n          if (typeof obj !== 'object') {\n            if (_this.options.cdata && requiresCDATA(obj)) {\n              element.raw(wrapCDATA(obj));\n            } else {\n              element.txt(obj);\n            }\n          } else if (Array.isArray(obj)) {\n            for (index in obj) {\n              if (!hasProp.call(obj, index)) continue;\n              child = obj[index];\n              for (key in child) {\n                entry = child[key];\n                element = render(element.ele(key), entry).up();\n              }\n            }\n          } else {\n            for (key in obj) {\n              if (!hasProp.call(obj, key)) continue;\n              child = obj[key];\n              if (key === attrkey) {\n                if (typeof child === \"object\") {\n                  for (attr in child) {\n                    value = child[attr];\n                    element = element.att(attr, value);\n                  }\n                }\n              } else if (key === charkey) {\n                if (_this.options.cdata && requiresCDATA(child)) {\n                  element = element.raw(wrapCDATA(child));\n                } else {\n                  element = element.txt(child);\n                }\n              } else if (Array.isArray(child)) {\n                for (index in child) {\n                  if (!hasProp.call(child, index)) continue;\n                  entry = child[index];\n                  if (typeof entry === 'string') {\n                    if (_this.options.cdata && requiresCDATA(entry)) {\n                      element = element.ele(key).raw(wrapCDATA(entry)).up();\n                    } else {\n                      element = element.ele(key, entry).up();\n                    }\n                  } else {\n                    element = render(element.ele(key), entry).up();\n                  }\n                }\n              } else if (typeof child === \"object\") {\n                element = render(element.ele(key), child).up();\n              } else {\n                if (typeof child === 'string' && _this.options.cdata && requiresCDATA(child)) {\n                  element = element.ele(key).raw(wrapCDATA(child)).up();\n                } else {\n                  if (child == null) {\n                    child = '';\n                  }\n                  element = element.ele(key, child.toString()).up();\n                }\n              }\n            }\n          }\n          return element;\n        };\n      })(this);\n      rootElement = builder.create(rootName, this.options.xmldec, this.options.doctype, {\n        headless: this.options.headless,\n        allowSurrogateChars: this.options.allowSurrogateChars\n      });\n      return render(rootElement, rootObj).end(this.options.renderOpts);\n    };\n\n    return Builder;\n\n  })();\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  exports.defaults = {\n    \"0.1\": {\n      explicitCharkey: false,\n      trim: true,\n      normalize: true,\n      normalizeTags: false,\n      attrkey: \"@\",\n      charkey: \"#\",\n      explicitArray: false,\n      ignoreAttrs: false,\n      mergeAttrs: false,\n      explicitRoot: false,\n      validator: null,\n      xmlns: false,\n      explicitChildren: false,\n      childkey: '@@',\n      charsAsChildren: false,\n      includeWhiteChars: false,\n      async: false,\n      strict: true,\n      attrNameProcessors: null,\n      attrValueProcessors: null,\n      tagNameProcessors: null,\n      valueProcessors: null,\n      emptyTag: ''\n    },\n    \"0.2\": {\n      explicitCharkey: false,\n      trim: false,\n      normalize: false,\n      normalizeTags: false,\n      attrkey: \"$\",\n      charkey: \"_\",\n      explicitArray: true,\n      ignoreAttrs: false,\n      mergeAttrs: false,\n      explicitRoot: true,\n      validator: null,\n      xmlns: false,\n      explicitChildren: false,\n      preserveChildrenOrder: false,\n      childkey: '$$',\n      charsAsChildren: false,\n      includeWhiteChars: false,\n      async: false,\n      strict: true,\n      attrNameProcessors: null,\n      attrValueProcessors: null,\n      tagNameProcessors: null,\n      valueProcessors: null,\n      rootName: 'root',\n      xmldec: {\n        'version': '1.0',\n        'encoding': 'UTF-8',\n        'standalone': true\n      },\n      doctype: null,\n      renderOpts: {\n        'pretty': true,\n        'indent': '  ',\n        'newline': '\\n'\n      },\n      headless: false,\n      chunkSize: 10000,\n      emptyTag: '',\n      cdata: false\n    }\n  };\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  \"use strict\";\n  var bom, defaults, events, isEmpty, processItem, processors, sax, setImmediate,\n    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },\n    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n    hasProp = {}.hasOwnProperty;\n\n  sax = require('sax');\n\n  events = require('events');\n\n  bom = require('./bom');\n\n  processors = require('./processors');\n\n  setImmediate = require('timers').setImmediate;\n\n  defaults = require('./defaults').defaults;\n\n  isEmpty = function(thing) {\n    return typeof thing === \"object\" && (thing != null) && Object.keys(thing).length === 0;\n  };\n\n  processItem = function(processors, item, key) {\n    var i, len, process;\n    for (i = 0, len = processors.length; i < len; i++) {\n      process = processors[i];\n      item = process(item, key);\n    }\n    return item;\n  };\n\n  exports.Parser = (function(superClass) {\n    extend(Parser, superClass);\n\n    function Parser(opts) {\n      this.parseString = bind(this.parseString, this);\n      this.reset = bind(this.reset, this);\n      this.assignOrPush = bind(this.assignOrPush, this);\n      this.processAsync = bind(this.processAsync, this);\n      var key, ref, value;\n      if (!(this instanceof exports.Parser)) {\n        return new exports.Parser(opts);\n      }\n      this.options = {};\n      ref = defaults[\"0.2\"];\n      for (key in ref) {\n        if (!hasProp.call(ref, key)) continue;\n        value = ref[key];\n        this.options[key] = value;\n      }\n      for (key in opts) {\n        if (!hasProp.call(opts, key)) continue;\n        value = opts[key];\n        this.options[key] = value;\n      }\n      if (this.options.xmlns) {\n        this.options.xmlnskey = this.options.attrkey + \"ns\";\n      }\n      if (this.options.normalizeTags) {\n        if (!this.options.tagNameProcessors) {\n          this.options.tagNameProcessors = [];\n        }\n        this.options.tagNameProcessors.unshift(processors.normalize);\n      }\n      this.reset();\n    }\n\n    Parser.prototype.processAsync = function() {\n      var chunk, err;\n      try {\n        if (this.remaining.length <= this.options.chunkSize) {\n          chunk = this.remaining;\n          this.remaining = '';\n          this.saxParser = this.saxParser.write(chunk);\n          return this.saxParser.close();\n        } else {\n          chunk = this.remaining.substr(0, this.options.chunkSize);\n          this.remaining = this.remaining.substr(this.options.chunkSize, this.remaining.length);\n          this.saxParser = this.saxParser.write(chunk);\n          return setImmediate(this.processAsync);\n        }\n      } catch (error1) {\n        err = error1;\n        if (!this.saxParser.errThrown) {\n          this.saxParser.errThrown = true;\n          return this.emit(err);\n        }\n      }\n    };\n\n    Parser.prototype.assignOrPush = function(obj, key, newValue) {\n      if (!(key in obj)) {\n        if (!this.options.explicitArray) {\n          return obj[key] = newValue;\n        } else {\n          return obj[key] = [newValue];\n        }\n      } else {\n        if (!(obj[key] instanceof Array)) {\n          obj[key] = [obj[key]];\n        }\n        return obj[key].push(newValue);\n      }\n    };\n\n    Parser.prototype.reset = function() {\n      var attrkey, charkey, ontext, stack;\n      this.removeAllListeners();\n      this.saxParser = sax.parser(this.options.strict, {\n        trim: false,\n        normalize: false,\n        xmlns: this.options.xmlns\n      });\n      this.saxParser.errThrown = false;\n      this.saxParser.onerror = (function(_this) {\n        return function(error) {\n          _this.saxParser.resume();\n          if (!_this.saxParser.errThrown) {\n            _this.saxParser.errThrown = true;\n            return _this.emit(\"error\", error);\n          }\n        };\n      })(this);\n      this.saxParser.onend = (function(_this) {\n        return function() {\n          if (!_this.saxParser.ended) {\n            _this.saxParser.ended = true;\n            return _this.emit(\"end\", _this.resultObject);\n          }\n        };\n      })(this);\n      this.saxParser.ended = false;\n      this.EXPLICIT_CHARKEY = this.options.explicitCharkey;\n      this.resultObject = null;\n      stack = [];\n      attrkey = this.options.attrkey;\n      charkey = this.options.charkey;\n      this.saxParser.onopentag = (function(_this) {\n        return function(node) {\n          var key, newValue, obj, processedKey, ref;\n          obj = {};\n          obj[charkey] = \"\";\n          if (!_this.options.ignoreAttrs) {\n            ref = node.attributes;\n            for (key in ref) {\n              if (!hasProp.call(ref, key)) continue;\n              if (!(attrkey in obj) && !_this.options.mergeAttrs) {\n                obj[attrkey] = {};\n              }\n              newValue = _this.options.attrValueProcessors ? processItem(_this.options.attrValueProcessors, node.attributes[key], key) : node.attributes[key];\n              processedKey = _this.options.attrNameProcessors ? processItem(_this.options.attrNameProcessors, key) : key;\n              if (_this.options.mergeAttrs) {\n                _this.assignOrPush(obj, processedKey, newValue);\n              } else {\n                obj[attrkey][processedKey] = newValue;\n              }\n            }\n          }\n          obj[\"#name\"] = _this.options.tagNameProcessors ? processItem(_this.options.tagNameProcessors, node.name) : node.name;\n          if (_this.options.xmlns) {\n            obj[_this.options.xmlnskey] = {\n              uri: node.uri,\n              local: node.local\n            };\n          }\n          return stack.push(obj);\n        };\n      })(this);\n      this.saxParser.onclosetag = (function(_this) {\n        return function() {\n          var cdata, emptyStr, key, node, nodeName, obj, objClone, old, s, xpath;\n          obj = stack.pop();\n          nodeName = obj[\"#name\"];\n          if (!_this.options.explicitChildren || !_this.options.preserveChildrenOrder) {\n            delete obj[\"#name\"];\n          }\n          if (obj.cdata === true) {\n            cdata = obj.cdata;\n            delete obj.cdata;\n          }\n          s = stack[stack.length - 1];\n          if (obj[charkey].match(/^\\s*$/) && !cdata) {\n            emptyStr = obj[charkey];\n            delete obj[charkey];\n          } else {\n            if (_this.options.trim) {\n              obj[charkey] = obj[charkey].trim();\n            }\n            if (_this.options.normalize) {\n              obj[charkey] = obj[charkey].replace(/\\s{2,}/g, \" \").trim();\n            }\n            obj[charkey] = _this.options.valueProcessors ? processItem(_this.options.valueProcessors, obj[charkey], nodeName) : obj[charkey];\n            if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {\n              obj = obj[charkey];\n            }\n          }\n          if (isEmpty(obj)) {\n            obj = _this.options.emptyTag !== '' ? _this.options.emptyTag : emptyStr;\n          }\n          if (_this.options.validator != null) {\n            xpath = \"/\" + ((function() {\n              var i, len, results;\n              results = [];\n              for (i = 0, len = stack.length; i < len; i++) {\n                node = stack[i];\n                results.push(node[\"#name\"]);\n              }\n              return results;\n            })()).concat(nodeName).join(\"/\");\n            (function() {\n              var err;\n              try {\n                return obj = _this.options.validator(xpath, s && s[nodeName], obj);\n              } catch (error1) {\n                err = error1;\n                return _this.emit(\"error\", err);\n              }\n            })();\n          }\n          if (_this.options.explicitChildren && !_this.options.mergeAttrs && typeof obj === 'object') {\n            if (!_this.options.preserveChildrenOrder) {\n              node = {};\n              if (_this.options.attrkey in obj) {\n                node[_this.options.attrkey] = obj[_this.options.attrkey];\n                delete obj[_this.options.attrkey];\n              }\n              if (!_this.options.charsAsChildren && _this.options.charkey in obj) {\n                node[_this.options.charkey] = obj[_this.options.charkey];\n                delete obj[_this.options.charkey];\n              }\n              if (Object.getOwnPropertyNames(obj).length > 0) {\n                node[_this.options.childkey] = obj;\n              }\n              obj = node;\n            } else if (s) {\n              s[_this.options.childkey] = s[_this.options.childkey] || [];\n              objClone = {};\n              for (key in obj) {\n                if (!hasProp.call(obj, key)) continue;\n                objClone[key] = obj[key];\n              }\n              s[_this.options.childkey].push(objClone);\n              delete obj[\"#name\"];\n              if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {\n                obj = obj[charkey];\n              }\n            }\n          }\n          if (stack.length > 0) {\n            return _this.assignOrPush(s, nodeName, obj);\n          } else {\n            if (_this.options.explicitRoot) {\n              old = obj;\n              obj = {};\n              obj[nodeName] = old;\n            }\n            _this.resultObject = obj;\n            _this.saxParser.ended = true;\n            return _this.emit(\"end\", _this.resultObject);\n          }\n        };\n      })(this);\n      ontext = (function(_this) {\n        return function(text) {\n          var charChild, s;\n          s = stack[stack.length - 1];\n          if (s) {\n            s[charkey] += text;\n            if (_this.options.explicitChildren && _this.options.preserveChildrenOrder && _this.options.charsAsChildren && (_this.options.includeWhiteChars || text.replace(/\\\\n/g, '').trim() !== '')) {\n              s[_this.options.childkey] = s[_this.options.childkey] || [];\n              charChild = {\n                '#name': '__text__'\n              };\n              charChild[charkey] = text;\n              if (_this.options.normalize) {\n                charChild[charkey] = charChild[charkey].replace(/\\s{2,}/g, \" \").trim();\n              }\n              s[_this.options.childkey].push(charChild);\n            }\n            return s;\n          }\n        };\n      })(this);\n      this.saxParser.ontext = ontext;\n      return this.saxParser.oncdata = (function(_this) {\n        return function(text) {\n          var s;\n          s = ontext(text);\n          if (s) {\n            return s.cdata = true;\n          }\n        };\n      })(this);\n    };\n\n    Parser.prototype.parseString = function(str, cb) {\n      var err;\n      if ((cb != null) && typeof cb === \"function\") {\n        this.on(\"end\", function(result) {\n          this.reset();\n          return cb(null, result);\n        });\n        this.on(\"error\", function(err) {\n          this.reset();\n          return cb(err);\n        });\n      }\n      try {\n        str = str.toString();\n        if (str.trim() === '') {\n          this.emit(\"end\", null);\n          return true;\n        }\n        str = bom.stripBOM(str);\n        if (this.options.async) {\n          this.remaining = str;\n          setImmediate(this.processAsync);\n          return this.saxParser;\n        }\n        return this.saxParser.write(str).close();\n      } catch (error1) {\n        err = error1;\n        if (!(this.saxParser.errThrown || this.saxParser.ended)) {\n          this.emit('error', err);\n          return this.saxParser.errThrown = true;\n        } else if (this.saxParser.ended) {\n          throw err;\n        }\n      }\n    };\n\n    return Parser;\n\n  })(events.EventEmitter);\n\n  exports.parseString = function(str, a, b) {\n    var cb, options, parser;\n    if (b != null) {\n      if (typeof b === 'function') {\n        cb = b;\n      }\n      if (typeof a === 'object') {\n        options = a;\n      }\n    } else {\n      if (typeof a === 'function') {\n        cb = a;\n      }\n      options = {};\n    }\n    parser = new exports.Parser(options);\n    return parser.parseString(str, cb);\n  };\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  \"use strict\";\n  var prefixMatch;\n\n  prefixMatch = new RegExp(/(?!xmlns)^.*:/);\n\n  exports.normalize = function(str) {\n    return str.toLowerCase();\n  };\n\n  exports.firstCharLowerCase = function(str) {\n    return str.charAt(0).toLowerCase() + str.slice(1);\n  };\n\n  exports.stripPrefix = function(str) {\n    return str.replace(prefixMatch, '');\n  };\n\n  exports.parseNumbers = function(str) {\n    if (!isNaN(str)) {\n      str = str % 1 === 0 ? parseInt(str, 10) : parseFloat(str);\n    }\n    return str;\n  };\n\n  exports.parseBooleans = function(str) {\n    if (/^(?:true|false)$/i.test(str)) {\n      str = str.toLowerCase() === 'true';\n    }\n    return str;\n  };\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  \"use strict\";\n  var builder, defaults, parser, processors,\n    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n    hasProp = {}.hasOwnProperty;\n\n  defaults = require('./defaults');\n\n  builder = require('./builder');\n\n  parser = require('./parser');\n\n  processors = require('./processors');\n\n  exports.defaults = defaults.defaults;\n\n  exports.processors = processors;\n\n  exports.ValidationError = (function(superClass) {\n    extend(ValidationError, superClass);\n\n    function ValidationError(message) {\n      this.message = message;\n    }\n\n    return ValidationError;\n\n  })(Error);\n\n  exports.Builder = builder.Builder;\n\n  exports.Parser = parser.Parser;\n\n  exports.parseString = parser.parseString;\n\n}).call(this);\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n","/* (ignored) */","/* (ignored) */","module.exports = __WEBPACK_EXTERNAL_MODULE_xmlbuilder__;"],"sourceRoot":""}