{"version":3,"sources":["webpack:///./node_modules/xmlbuilder/lib/XMLNodeList.js","webpack:///./node_modules/entities/lib/encode.js","webpack:///./src/components/rssfeed.vue?4110","webpack:///./src/components/rssfeedarticle.vue?fa81","webpack:///src/components/rssfeedarticle.vue","webpack:///./src/components/rssfeedarticle.vue?b23d","webpack:///./src/components/rssfeedarticle.vue","webpack:///src/components/rssfeed.vue","webpack:///./src/components/rssfeed.vue?78fc","webpack:///./src/components/rssfeed.vue","webpack:///./node_modules/xmlbuilder/lib/NodeType.js","webpack:///./node_modules/xml2js/lib/xml2js.js","webpack:///./node_modules/readable-stream/duplex-browser.js","webpack:///./node_modules/xmlbuilder/lib/WriterState.js","webpack:///./node_modules/xmlbuilder/lib/XMLDOMImplementation.js","webpack:///./node_modules/url/url.js","webpack:///./node_modules/xmlbuilder/lib/XMLDummy.js","webpack:///./node_modules/xmlbuilder/lib/XMLDTDEntity.js","webpack:///./node_modules/xmlbuilder/lib/XMLDTDAttList.js","webpack:///./node_modules/node-libs-browser/node_modules/punycode/punycode.js","webpack:///./node_modules/xmlbuilder/lib/XMLDOMStringList.js","webpack:///./node_modules/xmlbuilder/lib/XMLStringWriter.js","webpack:///./node_modules/xmlbuilder/lib/XMLAttribute.js","webpack:///./node_modules/https-browserify/index.js","webpack:///./node_modules/core-js/modules/es.regexp.to-string.js","webpack:///./node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/readable-stream/writable-browser.js","webpack:///./node_modules/sax/lib/sax.js","webpack:///./node_modules/url/util.js","webpack:///./node_modules/core-util-is/lib/util.js","webpack:///./node_modules/xmlbuilder/lib/XMLDTDElement.js","webpack:///./node_modules/inherits/inherits_browser.js","webpack:///./node_modules/xml2js/lib/builder.js","webpack:///./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/xmlbuilder/lib/Utility.js","webpack:///./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/xmlbuilder/lib/XMLRaw.js","webpack:///./node_modules/timers-browserify/main.js","webpack:///./node_modules/xmlbuilder/lib/XMLDeclaration.js","webpack:///./node_modules/xmlbuilder/lib/XMLCData.js","webpack:///./node_modules/xtend/immutable.js","webpack:///./node_modules/xmlbuilder/lib/XMLDocumentCB.js","webpack:///./node_modules/xmlbuilder/lib/XMLCharacterData.js","webpack:///./node_modules/xmlbuilder/lib/XMLStringifier.js","webpack:///./node_modules/xmlbuilder/lib/XMLNamedNodeMap.js","webpack:///./node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack:///./node_modules/setimmediate/setImmediate.js","webpack:///./node_modules/string_decoder/node_modules/safe-buffer/index.js","webpack:///./node_modules/xml2js/lib/bom.js","webpack:///./node_modules/entities/lib/decode_codepoint.js","webpack:///./node_modules/xmlbuilder/lib/index.js","webpack:///./node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./node_modules/xml2js/lib/processors.js","webpack:///./node_modules/core-js/internals/create-html.js","webpack:///./node_modules/xmlbuilder/lib/XMLComment.js","webpack:///./node_modules/entities/lib/index.js","webpack:///./node_modules/xmlbuilder/lib/XMLDOMConfiguration.js","webpack:///./node_modules/builtin-status-codes/browser.js","webpack:///./node_modules/querystring-es3/decode.js","webpack:///./node_modules/stream-http/lib/request.js","webpack:///./node_modules/xmlbuilder/lib/XMLNode.js","webpack:///./node_modules/stream-http/index.js","webpack:///./node_modules/process-nextick-args/index.js","webpack:///./node_modules/core-js/modules/es.string.link.js","webpack:///./node_modules/xmlbuilder/lib/XMLText.js","webpack:///./node_modules/xmlbuilder/lib/XMLDOMErrorHandler.js","webpack:///./node_modules/entities/lib/decode.js","webpack:///./node_modules/xmlbuilder/lib/XMLWriterBase.js","webpack:///./node_modules/xml2js/lib/defaults.js","webpack:///./node_modules/readable-stream/node_modules/safe-buffer/index.js","webpack:///./node_modules/stream-http/lib/capability.js","webpack:///./node_modules/xml2js/lib/parser.js","webpack:///./node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/xmlbuilder/lib/XMLDocument.js","webpack:///./node_modules/core-js/internals/string-html-forced.js","webpack:///./node_modules/rss-parser/lib/fields.js","webpack:///./node_modules/rss-parser/index.js","webpack:///./node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/querystring-es3/index.js","webpack:///./node_modules/xmlbuilder/lib/XMLDTDNotation.js","webpack:///./node_modules/util-deprecate/browser.js","webpack:///./node_modules/xmlbuilder/lib/XMLElement.js","webpack:///./node_modules/readable-stream/passthrough.js","webpack:///./node_modules/xmlbuilder/lib/XMLStreamWriter.js","webpack:///./node_modules/stream-http/lib/response.js","webpack:///./node_modules/readable-stream/transform.js","webpack:///./node_modules/xmlbuilder/lib/DocumentPosition.js","webpack:///./node_modules/stream-browserify/index.js","webpack:///./node_modules/rss-parser/lib/utils.js","webpack:///./node_modules/xmlbuilder/lib/XMLDocType.js","webpack:///./node_modules/to-arraybuffer/index.js","webpack:///./node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/querystring-es3/encode.js","webpack:///./node_modules/readable-stream/readable-browser.js","webpack:///./src/components/rssfeed.vue?5468","webpack:///./node_modules/xmlbuilder/lib/XMLProcessingInstruction.js","webpack:///./node_modules/rss-parser/lib/parser.js","webpack:///./node_modules/events/events.js"],"names":["module","exports","XMLNodeList","nodes","this","Object","defineProperty","prototype","get","length","clone","item","index","call","__importDefault","mod","__esModule","value","escapeUTF8","escape","encodeNonAsciiHTML","encodeHTML","encodeXML","xml_json_1","inverseXML","getInverseObj","default","xmlReplacer","getInverseReplacer","getASCIIEncoder","entities_json_1","inverseHTML","htmlReplacer","obj","keys","sort","reduce","inverse","name","single","multiple","_i","_a","k","push","start","end","charCodeAt","count","splice","unshift","join","RegExp","getInverse","reNonASCII","getCodePoint","String","codePointAt","str","c","singleCharReplacer","toString","toUpperCase","re","data","replace","reEscapeChars","source","render","_vm","_h","$createElement","_c","_self","staticClass","_v","_s","error","feed","title","_e","_l","getArticles","article","key","attrs","staticRenderFns","staticStyle","link","domProps","content","getHostname","getDateTime","diff","Math","round","systemDate","substring","props","methods","urlObj","hostname","console","e","isoDate","parseDate","component","components","Article","feedUrl","limit","Number","loadMore","Boolean","loading","created","fetchData","watch","newVal","oldVal","items","slice","Element","Attribute","Text","CData","EntityReference","EntityDeclaration","ProcessingInstruction","Comment","Document","DocType","DocumentFragment","NotationDeclaration","Declaration","Raw","AttributeDeclaration","ElementDeclaration","Dummy","builder","defaults","parser","processors","extend","child","parent","hasProp","ctor","constructor","__super__","hasOwnProperty","ValidationError","superClass","message","Error","Builder","Parser","parseString","parseStringPromise","None","OpenTag","InsideTag","CloseTag","XMLDOMImplementation","hasFeature","feature","version","createDocumentType","qualifiedName","publicId","systemId","createDocument","namespaceURI","doctype","createHTMLDocument","getFeature","punycode","util","Url","protocol","slashes","auth","host","port","hash","search","query","pathname","path","href","parse","urlParse","resolve","urlResolve","resolveObject","urlResolveObject","format","urlFormat","protocolPattern","portPattern","simplePathPattern","delims","unwise","concat","autoEscape","nonHostChars","hostEndingChars","hostnameMaxLen","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","url","parseQueryString","slashesDenoteHost","isObject","u","isString","relative","TypeError","queryIndex","indexOf","splitter","uSplit","split","slashRegex","rest","trim","simplePath","exec","substr","proto","lowerProto","toLowerCase","match","atSign","hostEnd","i","hec","lastIndexOf","decodeURIComponent","parseHost","ipv6Hostname","hostparts","l","part","newpart","j","validParts","notHost","bit","toASCII","p","h","ae","esc","encodeURIComponent","qm","s","stringify","charAt","rel","result","tkeys","tk","tkey","rkeys","rk","rkey","v","relPath","shift","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","pop","isNullOrUndefined","authInHost","isNull","last","hasTrailingSlash","up","isAbsolute","NodeType","XMLNode","XMLDummy","type","create","options","XMLDTDEntity","pe","debugInfo","pubID","sysID","internal","dtdPubID","dtdSysID","nData","dtdNData","dtdEntityValue","writer","dtdEntity","filterOptions","XMLDTDAttList","elementName","attributeName","attributeType","defaultValueType","defaultValue","dtdAttType","dtdAttDefault","dtdAttList","root","nodeType","freeGlobal","global","window","self","maxInt","base","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexPunycode","regexNonASCII","regexSeparators","errors","baseMinusTMin","floor","stringFromCharCode","fromCharCode","RangeError","map","array","fn","mapDomain","string","parts","labels","encoded","ucs2decode","extra","output","counter","ucs2encode","basicToDigit","codePoint","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","decode","input","out","basic","oldi","w","t","baseMinusT","inputLength","n","bias","encode","handledCPCount","basicLength","m","q","currentValue","handledCPCountPlusOne","qMinusT","toUnicode","test","XMLDOMStringList","arr","contains","XMLWriterBase","XMLStringWriter","document","doc","len","r","ref","children","writeChildNode","pretty","newline","XMLAttribute","attValue","isId","schemaTypeInfo","set","attribute","isEqualNode","node","prefix","localName","http","https","validateParams","params","request","cb","redefine","anObject","fails","flags","TO_STRING","RegExpPrototype","nativeToString","NOT_GENERIC","INCORRECT_NAME","R","rf","f","undefined","unsafe","Transform","Duplex","afterTransform","er","ts","_transformState","transforming","writecb","emit","writechunk","rs","_readableState","reading","needReadable","highWaterMark","_read","bind","needTransform","writeencoding","sync","transform","_transform","flush","_flush","on","prefinish","_this","done","stream","_writableState","inherits","chunk","encoding","_write","_destroy","err","_this2","err2","sax","strict","opt","SAXParser","SAXStream","createStream","MAX_BUFFER_LENGTH","Stream","buffers","clearBuffers","bufferCheckPosition","lowercase","lowercasetags","looseCase","tags","closed","closedRoot","sawRoot","tag","noscript","state","S","BEGIN","strictEntities","ENTITIES","XML_ENTITIES","attribList","xmlns","ns","rootNS","trackPosition","position","line","column","checkBufferLength","maxAllowed","max","maxActual","closeText","emitNode","cdata","script","flushBuffers","EVENTS","o","F","newf","a","write","resume","close","ex","streamWraps","filter","ev","apply","_parser","writable","readable","me","onend","onerror","_decoder","forEach","removeAllListeners","enumerable","configurable","Buffer","isBuffer","SD","StringDecoder","handler","args","arguments","Array","CDATA","DOCTYPE","XML_NAMESPACE","XMLNS_NAMESPACE","xml","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","event","textNode","textopts","text","normalize","strictFail","newTag","tagName","attributes","qname","qualName","local","attrib","attribName","attribValue","qn","openTag","selfClosing","uri","JSON","nv","isSelfClosing","closeTag","closeTo","x","parseEntity","num","entity","entityLC","numStr","parseInt","isNaN","fromCodePoint","beginWhiteSpace","startTagPosition","starti","sgmlDecl","procInstName","procInstBody","pad","comment","body","returnState","buffer","highSurrogate","lowSurrogate","MAX_SIZE","codeUnits","isFinite","arg","isArray","objectToString","isBoolean","isNumber","isSymbol","isUndefined","isRegExp","isDate","d","isError","isFunction","isPrimitive","XMLDTDElement","dtdElementValue","dtdElement","superCtor","super_","TempCtor","escapeCDATA","requiresCDATA","wrapCDATA","entry","opts","buildObject","rootObj","attrkey","charkey","rootElement","rootName","element","attr","raw","txt","ele","att","xmldec","headless","allowSurrogateChars","renderOpts","EventEmitter","assign","getValue","isEmpty","isPlainObject","sources","target","val","getPrototypeOf","Function","valueOf","pna","destroy","readableDestroyed","destroyed","writableDestroyed","errorEmitted","nextTick","emitErrorNT","undestroy","ended","endEmitted","ending","finished","XMLRaw","Timeout","id","clearFn","_id","_clearFn","setTimeout","scope","clearTimeout","setInterval","clearInterval","timeout","unref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","setImmediate","clearImmediate","XMLDeclaration","standalone","xmlVersion","xmlEncoding","xmlStandalone","declaration","XMLCharacterData","XMLCData","WriterState","XMLComment","XMLDTDNotation","XMLDocType","XMLDocument","XMLElement","XMLProcessingInstruction","XMLStringifier","XMLText","XMLDocumentCB","onData","onEnd","writerOptions","onDataCallback","onEndCallback","currentNode","currentLevel","openTags","documentStarted","documentCompleted","createChildNode","attName","ref1","ref2","attribs","dummy","instruction","openCurrent","oldValidationFlag","noValidation","keepNullAttributes","insTarget","insValue","processingInstruction","rootNodeName","attList","pEntity","notation","dtdNotation","closeNode","openNode","isOpen","indent","endline","isClosed","level","nod","dat","com","ins","dec","dtd","ent","pent","not","substringData","offset","appendData","insertData","deleteData","replaceData","assertLegalName","assertLegalChar","textEscape","attEscape","convertAttKey","convertPIKey","convertTextKey","convertCDataKey","convertCommentKey","convertRawKey","res","ampregex","noDoubleEncoding","XMLNamedNodeMap","getNamedItem","setNamedItem","oldNode","nodeName","removeNamedItem","getNamedItemNS","setNamedItemNS","removeNamedItemNS","_classCallCheck","instance","Constructor","copyBuffer","src","copy","BufferList","head","tail","next","ret","clear","alloc","allocUnsafe","inspect","custom","registerImmediate","nextHandle","tasksByHandle","currentlyRunningATask","attachTo","process","installNextTickImplementation","canUsePostMessage","installPostMessageImplementation","MessageChannel","installMessageChannelImplementation","createElement","installReadyStateChangeImplementation","installSetTimeoutImplementation","callback","task","handle","run","runIfPresent","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","messagePrefix","random","onGlobalMessage","addEventListener","attachEvent","channel","port1","port2","html","documentElement","onreadystatechange","removeChild","appendChild","copyProps","dst","SafeBuffer","encodingOrOffset","from","allocUnsafeSlow","size","fill","buf","SlowBuffer","stripBOM","decode_json_1","decodeCodePoint","XMLStreamWriter","begin","stringWriter","streamWriter","implementation","writerState","PassThrough","isEncoding","_normalizeEncoding","enc","retried","normalizeEncoding","nenc","nb","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","utf8CheckIncomplete","utf8CheckExtraBytes","utf8Text","total","utf8End","prefixMatch","firstCharLowerCase","stripPrefix","parseNumbers","parseFloat","parseBooleans","requireObjectCoercible","quot","p1","decodeXMLStrict","decodeHTML5Strict","decodeHTML4Strict","decodeHTML5","decodeHTML4","decodeHTMLStrict","decodeHTML","decodeXML","encodeHTML5","encodeHTML4","decodeStrict","decode_1","encode_1","encode_2","decode_2","XMLDOMErrorHandler","XMLDOMConfiguration","defaultParams","getParameter","canSetParameter","setParameter","prop","qs","sep","eq","regexp","maxKeys","kstr","vstr","idx","xs","response","toArrayBuffer","IncomingMessage","rStates","readyStates","decideMode","preferBinary","useFetch","capability","fetch","mozchunkedarraybuffer","msstream","arraybuffer","vbArray","ClientRequest","Writable","_opts","_body","_headers","setHeader","headers","mode","abortController","overrideMimeType","_mode","_fetchTimer","_onFinish","statusValid","xhr","status","lowerName","unsafeHeaders","getHeader","header","removeHeader","_destroyed","headersObj","method","blobConstructor","Blob","headersList","keyName","signal","controller","AbortController","_fetchAbortController","requestTimeout","abort","credentials","withCredentials","then","_fetchResponse","_connect","reason","_xhr","XMLHttpRequest","open","responseType","ontimeout","setRequestHeader","_response","readyState","LOADING","DONE","_onXHRProgress","onprogress","send","flushHeaders","setNoDelay","setSocketKeepAlive","DocumentPosition","parent1","baseURI","childNodeList","textContent","setParent","results","childNode","lastChild","len1","ref3","ignoreDecorators","separateArrayItems","keepNullNodes","insertBefore","newChild","refChild","removed","isRoot","insertAfter","remove","commentBefore","commentAfter","instructionBefore","instructionAfter","rootObject","prev","importDocument","clonedRoot","importXMLBuilder","replaceChild","oldChild","hasChildNodes","cloneNode","deep","isSupported","hasAttributes","compareDocumentPosition","other","Disconnected","ImplementationSpecific","Preceding","Following","isAncestor","Contains","isDescendant","isPreceding","isSameNode","lookupPrefix","isDefaultNamespace","lookupNamespaceURI","setUserData","getUserData","isDescendantChild","nodePos","thisPos","treePosition","isFollowing","found","pos","foreachTreeNode","func","statusCodes","defaultProtocol","location","req","Agent","defaultMaxSockets","globalAgent","STATUS_CODES","METHODS","arg1","arg2","arg3","$","createHTML","forcedStringHTMLMethod","forced","previousSibling","nextSibling","splitText","replaceWholeText","handleError","legacy_json_1","decode_codepoint_1","strictEntityRe","getStrictDecoder","getReplacer","sorter","b","secondChar","legacy","replacer","filteredOptions","ref4","ref5","ref6","allowEmpty","dontPrettyTextNodes","dontprettytextnodes","spaceBeforeSlash","spacebeforeslash","suppressPrettyCount","user","indentLevel","openAttribute","closeAttribute","docType","childNodeCount","firstChildNode","prettySuppressed","every","explicitCharkey","normalizeTags","explicitArray","ignoreAttrs","mergeAttrs","explicitRoot","validator","explicitChildren","childkey","charsAsChildren","includeWhiteChars","async","attrNameProcessors","attrValueProcessors","tagNameProcessors","valueProcessors","emptyTag","preserveChildrenOrder","chunkSize","writableStream","WritableStream","ArrayBuffer","getXHR","XDomainRequest","checkTypeSupport","haveArrayBuffer","haveSlice","VBArray","bom","events","processItem","thing","reset","assignOrPush","processAsync","xmlnskey","remaining","saxParser","error1","errThrown","newValue","ontext","stack","resultObject","EXPLICIT_CHARKEY","onopentag","processedKey","onclosetag","emptyStr","objClone","old","xpath","getOwnPropertyNames","charChild","oncdata","Promise","reject","Readable","ReadableState","EElistenerCount","emitter","listeners","OurUint8Array","Uint8Array","_uint8ArrayToBuffer","_isUint8Array","debugUtil","debug","debuglog","destroyImpl","kProxyEvents","prependListener","_events","isDuplex","objectMode","readableObjectMode","hwm","readableHwm","readableHighWaterMark","defaultHwm","pipes","pipesCount","flowing","emittedReadable","readableListening","resumeScheduled","defaultEncoding","awaitDrain","readingMore","decoder","read","readableAddChunk","addToFront","skipChunkCheck","onEofChunk","chunkInvalid","addChunk","maybeReadMore","needMoreData","emitReadable","_undestroy","isPaused","setEncoding","MAX_HWM","computeNewHighWaterMark","howMuchToRead","emitReadable_","flow","maybeReadMore_","pipeOnDrain","nReadingNextTick","resume_","fromList","fromListPartial","list","hasStrings","copyFromBufferString","copyFromBuffer","endReadable","endReadableNT","nOrig","doRead","pipe","dest","pipeOpts","doEnd","stdout","stderr","endFn","unpipe","onunpipe","unpipeInfo","hasUnpiped","cleanup","once","ondrain","cleanedUp","removeListener","onclose","onfinish","ondata","needDrain","increasedAwaitDrain","pause","dests","addListener","wrap","paused","_fromList","documentURI","domConfig","createDocumentFragment","createTextNode","createComment","createCDATASection","createProcessingInstruction","createAttribute","createEntityReference","getElementsByTagName","tagname","importNode","importedNode","createElementNS","createAttributeNS","getElementsByTagNameNS","getElementById","elementId","adoptNode","normalizeDocument","renameNode","getElementsByClassName","classNames","createEvent","eventInterface","createRange","createNodeIterator","whatToShow","createTreeWalker","METHOD_NAME","fields","includeSnippet","mapItunesField","podcastFeed","podcastItem","objectKeys","allowHalfOpen","onEndNT","deprecate","msg","config","warned","deprecated","trace","warn","localStorage","_","documentObject","attributeMap","clonedSelf","clonedChild","removeAttribute","getAttribute","setAttribute","getAttributeNode","setAttributeNode","newAttr","removeAttributeNode","oldAttr","getAttributeNS","setAttributeNS","removeAttributeNS","getAttributeNodeNS","setAttributeNodeNS","hasAttribute","hasAttributeNS","setIdAttribute","setIdAttributeNS","setIdAttributeNode","idAttr","isLastRootNode","UNSENT","OPENED","HEADERS_RECEIVED","fetchTimer","rawHeaders","trailers","rawTrailers","statusCode","statusMessage","statusText","_resumeFetch","pipeTo","catch","reader","getReader","_pos","responseURL","getAllResponseHeaders","matches","_charset","mimeType","charsetMatch","responseBody","toArray","responseText","newData","MSStreamReader","byteLength","onload","readAsArrayBuffer","ContainedBy","EE","_isStdio","didOnEnd","listenerCount","utils","entities","xml2js","stripHtml","getSnippet","getLink","links","fallbackIdx","getContent","copyFromXML","to","keepArray","maybePromisify","promise","DEFAULT_ENCODING","ENCODING_REGEX","SUPPORTED_ENCODINGS","ENCODING_ALIASES","getEncodingFromContentType","contentType","byteOffset","arrayCopy","CorkedRequest","finish","onCorkedFinish","asyncWrite","browser","WritableState","internalUtil","realHasInstance","nop","writableObjectMode","writableHwm","writableHighWaterMark","finalCalled","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","bufferedRequestCount","corkedRequestsFree","writev","_writev","final","_final","writeAfterEnd","validChunk","valid","decodeChunk","writeOrBuffer","isBuf","newChunk","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","clearBuffer","afterWrite","onwriteDrain","holder","allBuffers","callFinal","need","endWritable","corkReq","getBuffer","current","Symbol","hasInstance","object","cork","uncork","setDefaultEncoding","stringifyPrimitive","ks","DEFAULT_HEADERS","DEFAULT_MAX_REDIRECTS","DEFAULT_TIMEOUT","customFields","requestOptions","maxRedirects","xmlParser","prom","buildAtomFeed","rss","buildRSS2","buildRSS1","buildRSS0_9","defaultRSS","redirectCount","urlParts","requestOpts","newLocation","parseURL","xmlObj","updated","lastBuildDate","parseItemAtom","published","pubDate","Date","toISOString","author","contentSnippet","summary","setISODate","buildRSS","decorateItunes","feedFields","itemFields","image","width","height","paginationLinks","generatePaginationLinks","xmlItem","parseItemRss","enclosure","description","guid","category","categories","itunes","owner","email","hasImageHref","categoriesWithSubs","subs","subcategory","keywords","keyword","date","paginationRelAttributes","includes","ReflectOwnKeys","Reflect","ReflectApply","receiver","ProcessEmitWarning","warning","ownKeys","getOwnPropertySymbols","NumberIsNaN","init","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","that","_addListener","prepend","existing","newListener","onceWrapper","fired","wrapFn","_onceWrap","wrapped","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","spliceOne","errorListener","resolver","eventTargetAgnosticAddListener","addErrorHandlerIfEventEmitter","wrapListener","removeEventListener","setMaxListeners","getMaxListeners","doError","context","prependOnceListener","originalListener","off","rawListeners","eventNames"],"mappings":"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","file":"js/chunk-2b330bce.eaf9a0e9.js","sourcesContent":["// Generated by CoffeeScript 1.12.7\n(function() {\n  var XMLNodeList;\n\n  module.exports = XMLNodeList = (function() {\n    function XMLNodeList(nodes) {\n      this.nodes = nodes;\n    }\n\n    Object.defineProperty(XMLNodeList.prototype, 'length', {\n      get: function() {\n        return this.nodes.length || 0;\n      }\n    });\n\n    XMLNodeList.prototype.clone = function() {\n      return this.nodes = null;\n    };\n\n    XMLNodeList.prototype.item = function(index) {\n      return this.nodes[index] || null;\n    };\n\n    return XMLNodeList;\n\n  })();\n\n}).call(this);\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.escapeUTF8 = exports.escape = exports.encodeNonAsciiHTML = exports.encodeHTML = exports.encodeXML = void 0;\nvar xml_json_1 = __importDefault(require(\"./maps/xml.json\"));\nvar inverseXML = getInverseObj(xml_json_1.default);\nvar xmlReplacer = getInverseReplacer(inverseXML);\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using XML entities.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nexports.encodeXML = getASCIIEncoder(inverseXML);\nvar entities_json_1 = __importDefault(require(\"./maps/entities.json\"));\nvar inverseHTML = getInverseObj(entities_json_1.default);\nvar htmlReplacer = getInverseReplacer(inverseHTML);\n/**\n * Encodes all entities and non-ASCII characters in the input.\n *\n * This includes characters that are valid ASCII characters in HTML documents.\n * For example `#` will be encoded as `&num;`. To get a more compact output,\n * consider using the `encodeNonAsciiHTML` function.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nexports.encodeHTML = getInverse(inverseHTML, htmlReplacer);\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in HTML\n * documents using HTML entities.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nexports.encodeNonAsciiHTML = getASCIIEncoder(inverseHTML);\nfunction getInverseObj(obj) {\n    return Object.keys(obj)\n        .sort()\n        .reduce(function (inverse, name) {\n        inverse[obj[name]] = \"&\" + name + \";\";\n        return inverse;\n    }, {});\n}\nfunction getInverseReplacer(inverse) {\n    var single = [];\n    var multiple = [];\n    for (var _i = 0, _a = Object.keys(inverse); _i < _a.length; _i++) {\n        var k = _a[_i];\n        if (k.length === 1) {\n            // Add value to single array\n            single.push(\"\\\\\" + k);\n        }\n        else {\n            // Add value to multiple array\n            multiple.push(k);\n        }\n    }\n    // Add ranges to single characters.\n    single.sort();\n    for (var start = 0; start < single.length - 1; start++) {\n        // Find the end of a run of characters\n        var end = start;\n        while (end < single.length - 1 &&\n            single[end].charCodeAt(1) + 1 === single[end + 1].charCodeAt(1)) {\n            end += 1;\n        }\n        var count = 1 + end - start;\n        // We want to replace at least three characters\n        if (count < 3)\n            continue;\n        single.splice(start, count, single[start] + \"-\" + single[end]);\n    }\n    multiple.unshift(\"[\" + single.join(\"\") + \"]\");\n    return new RegExp(multiple.join(\"|\"), \"g\");\n}\n// /[^\\0-\\x7F]/gu\nvar reNonASCII = /(?:[\\x80-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])/g;\nvar getCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\nString.prototype.codePointAt != null\n    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        function (str) { return str.codePointAt(0); }\n    : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n        function (c) {\n            return (c.charCodeAt(0) - 0xd800) * 0x400 +\n                c.charCodeAt(1) -\n                0xdc00 +\n                0x10000;\n        };\nfunction singleCharReplacer(c) {\n    return \"&#x\" + (c.length > 1 ? getCodePoint(c) : c.charCodeAt(0))\n        .toString(16)\n        .toUpperCase() + \";\";\n}\nfunction getInverse(inverse, re) {\n    return function (data) {\n        return data\n            .replace(re, function (name) { return inverse[name]; })\n            .replace(reNonASCII, singleCharReplacer);\n    };\n}\nvar reEscapeChars = new RegExp(xmlReplacer.source + \"|\" + reNonASCII.source, \"g\");\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using numeric hexadecimal reference (eg. `&#xfc;`).\n *\n * Have a look at `escapeUTF8` if you want a more concise output at the expense\n * of reduced transportability.\n *\n * @param data String to escape.\n */\nfunction escape(data) {\n    return data.replace(reEscapeChars, singleCharReplacer);\n}\nexports.escape = escape;\n/**\n * Encodes all characters not valid in XML documents using numeric hexadecimal\n * reference (eg. `&#xfc;`).\n *\n * Note that the output will be character-set dependent.\n *\n * @param data String to escape.\n */\nfunction escapeUTF8(data) {\n    return data.replace(xmlReplacer, singleCharReplacer);\n}\nexports.escapeUTF8 = escapeUTF8;\nfunction getASCIIEncoder(obj) {\n    return function (data) {\n        return data.replace(reEscapeChars, function (c) { return obj[c] || singleCharReplacer(c); });\n    };\n}\n","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return (_vm.error)?_c('div',{staticClass:\"error\"},[_vm._v(_vm._s(_vm.error))]):_c('div',{staticClass:\"feed\"},[(_vm.name)?_c('h1',[_vm._v(_vm._s(_vm.name))]):_c('h1',[_vm._v(_vm._s(_vm.feed.title))]),(_vm.loading)?_c('div',{staticClass:\"spinner\"},[_c('div',{staticClass:\"bounce1\"}),_c('div',{staticClass:\"bounce2\"}),_c('div',{staticClass:\"bounce3\"})]):_vm._e(),_c('div',{staticClass:\"list-group\"},_vm._l((_vm.getArticles()),function(article,index){return _c('Article',{key:index,attrs:{\"article\":article}})}),1)])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"list-group-item\",staticStyle:{\"border\":\"0\"}},[_c('div',{staticClass:\"title\"},[_c('a',{attrs:{\"href\":_vm.article.link,\"target\":\"_blank\"}},[_c('h6',[_vm._v(_vm._s(_vm.article.title))])])]),(_vm.article.content)?_c('div',[_c('p',{staticClass:\"content\",domProps:{\"innerHTML\":_vm._s(_vm.article.content)}})]):_vm._e(),_c('div',{staticClass:\"mt-2\"},[_c('span',{staticClass:\"hostname text-primary\"},[_vm._v(_vm._s(this.getHostname()))]),_c('span',{staticClass:\"datetime text-primary float-right\"},[_vm._v(_vm._s(this.getDateTime()))])])])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","<template>\r\n  <div class=\"list-group-item\" style=\"border: 0\">\r\n    <div class=\"title\">\r\n      <a :href=\"article.link\" target=\"_blank\">\r\n        <h6>{{article.title}}</h6>\r\n      </a>\r\n    </div>\r\n    <div v-if=\"article.content\">\r\n      <p class=\"content\" v-html=\"article.content\"></p>\r\n    </div>\r\n    <div class=\"mt-2\">\r\n      <span class=\"hostname text-primary\">{{this.getHostname()}}</span>\r\n      \r\n      <span class=\"datetime text-primary float-right\">{{this.getDateTime()}}</span>\r\n    </div>\r\n  </div>\r\n</template>\r\n\r\n<script>\r\nconst parseDate = tdate => {\r\n  const systemDate = new Date(Date.parse(tdate));\r\n  const userDate = new Date();\r\n\r\n  const diff = Math.floor((userDate - systemDate) / 1000);\r\n  if (diff < 59) {\r\n    return diff + \"s\";\r\n  }\r\n\r\n  if (diff <= 3540) {\r\n    return Math.round(diff / 60) + \"m\";\r\n  }\r\n\r\n  if (diff <= 86400) {\r\n    return Math.round(diff / 3600) + \"h\";\r\n  }\r\n\r\n  if (diff < 604800) {\r\n    return Math.round(diff / 86400) + \"d\";\r\n  }\r\n\r\n  return systemDate.toString().substring(4, 10);\r\n};\r\n\r\nexport default {\r\n  name: \"Article\",\r\n  props: [\"article\"],\r\n  methods: {\r\n    getHostname() {\r\n      try {\r\n        const urlObj = new URL(this.article.link);\r\n        return urlObj.hostname.replace(\"www.\", \"\").replace(\"ww2.\", \"\");\r\n      } catch (e) {\r\n        console.error(e.toString());\r\n      }\r\n    },\r\n    getDateTime() {\r\n      if (this.article.isoDate) {\r\n        return parseDate(this.article.isoDate);\r\n      }\r\n    }\r\n  }\r\n};\r\n</script>\r\n\r\n<style scoped>\r\n\r\n</style>","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./rssfeedarticle.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./rssfeedarticle.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./rssfeedarticle.vue?vue&type=template&id=4795c477&scoped=true&\"\nimport script from \"./rssfeedarticle.vue?vue&type=script&lang=js&\"\nexport * from \"./rssfeedarticle.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"4795c477\",\n  null\n  \n)\n\nexport default component.exports","<template>\r\n  <div v-if=\"error\" class=\"error\">{{error}}</div>\r\n  <div v-else class=\"feed\">\r\n    <h1 v-if=\"name\">{{name}}</h1>\r\n    <h1 v-else>{{feed.title}}</h1>\r\n    <div v-if=\"loading\" class=\"spinner\">\r\n      <div class=\"bounce1\"></div>\r\n      <div class=\"bounce2\"></div>\r\n      <div class=\"bounce3\"></div>\r\n    </div>\r\n    <div class=\"list-group\">\r\n      <Article\r\n        v-for=\"(article, index) of getArticles()\"\r\n        v-bind:key=\"index\"\r\n        v-bind:article=\"article\"\r\n      />\r\n    </div>\r\n  </div>\r\n</template>\r\n\r\n<script>\r\nimport Article from \"./rssfeedarticle.vue\";\r\nimport RSSParser from \"rss-parser\";\r\n\r\nexport default {\r\n  name: \"Feed\",\r\n  components: {\r\n    Article\r\n  },\r\n  props: {\r\n    feedUrl: String,\r\n    name: String,\r\n    limit: Number,\r\n    loadMore: Boolean\r\n  },\r\n  data() {\r\n    return {\r\n      loading: true,\r\n      error: \"\",\r\n      feed: {}\r\n    };\r\n  },\r\n  created() {\r\n    this.fetchData();\r\n  },\r\n  watch: {\r\n    feedUrl() {\r\n      this.fetchData();\r\n    },\r\n    limit(newVal, oldVal) {\r\n      if (newVal !== oldVal) {\r\n        this.getArticles();\r\n      }\r\n    }\r\n  },\r\n  methods: {\r\n    async fetchData() {\r\n      this.error = \"\";\r\n      this.loading = true;\r\n      this.feed = {};\r\n      try {\r\n        const data = await fetch(this.feedUrl);\r\n        if (data.ok) {\r\n          const text = await data.text();\r\n          const parser = new RSSParser();\r\n          parser.parseString(text, (err, parsed) => {\r\n            this.loading = false;\r\n            if (err) {\r\n              this.error = `Error occured while parsing RSS Feed ${err.toString()}`;\r\n            } else {\r\n              this.feed = parsed;\r\n            }\r\n          });\r\n        } else {\r\n          this.error = \"Error occured while fetching the feed\";\r\n          this.loading = false;\r\n        }\r\n      } catch (e) {\r\n        if (e.toString() === \"TypeError: Failed to fetch\") {\r\n          this.error = \"Error due to CORS policy\";\r\n        } else {\r\n          this.error = e.toString();\r\n        }\r\n        this.loading = false;\r\n      }\r\n    },\r\n    getArticles() {\r\n      if (this.feed.items && this.feed.items) {\r\n        return this.feed.items.slice(0, this.limit);\r\n      }\r\n    }\r\n  }\r\n};\r\n</script>\r\n\r\n<style scoped>\r\nh1 {\r\n display: none;\r\n}\r\n.feed {\r\n  text-align: left;\r\n}\r\na {\r\n  color: #42b983;\r\n}\r\n/* CSS Spinner */\r\n.spinner {\r\n  margin: 40px auto 0;\r\n  width: 150px;\r\n  text-align: center;\r\n}\r\n\r\n.error {\r\n  color: red;\r\n}\r\n\r\n.spinner > div {\r\n  width: 18px;\r\n  height: 18px;\r\n  /* background-color: #ff641b; */\r\n  background-color: #42b983;\r\n  background-color: #777;\r\n  margin-right: 10px;\r\n\r\n  border-radius: 100%;\r\n  display: inline-block;\r\n  -webkit-animation: sk-bouncedelay 1.4s infinite ease-in-out both;\r\n  animation: sk-bouncedelay 1.4s infinite ease-in-out both;\r\n}\r\n\r\n.spinner .bounce1 {\r\n  -webkit-animation-delay: -0.32s;\r\n  animation-delay: -0.32s;\r\n}\r\n\r\n.spinner .bounce2 {\r\n  -webkit-animation-delay: -0.16s;\r\n  animation-delay: -0.16s;\r\n}\r\n\r\n@-webkit-keyframes sk-bouncedelay {\r\n  0%,\r\n  80%,\r\n  100% {\r\n    -webkit-transform: scale(0);\r\n  }\r\n  40% {\r\n    -webkit-transform: scale(1);\r\n  }\r\n}\r\n\r\n@keyframes sk-bouncedelay {\r\n  0%,\r\n  80%,\r\n  100% {\r\n    -webkit-transform: scale(0);\r\n    transform: scale(0);\r\n  }\r\n  40% {\r\n    -webkit-transform: scale(1);\r\n    transform: scale(1);\r\n  }\r\n}\r\n</style>","import mod from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./rssfeed.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../node_modules/thread-loader/dist/cjs.js!../../node_modules/babel-loader/lib/index.js!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./rssfeed.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./rssfeed.vue?vue&type=template&id=c0686364&scoped=true&\"\nimport script from \"./rssfeed.vue?vue&type=script&lang=js&\"\nexport * from \"./rssfeed.vue?vue&type=script&lang=js&\"\nimport style0 from \"./rssfeed.vue?vue&type=style&index=0&id=c0686364&scoped=true&lang=css&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"c0686364\",\n  null\n  \n)\n\nexport default component.exports","// Generated by CoffeeScript 1.12.7\n(function() {\n  module.exports = {\n    Element: 1,\n    Attribute: 2,\n    Text: 3,\n    CData: 4,\n    EntityReference: 5,\n    EntityDeclaration: 6,\n    ProcessingInstruction: 7,\n    Comment: 8,\n    Document: 9,\n    DocType: 10,\n    DocumentFragment: 11,\n    NotationDeclaration: 12,\n    Declaration: 201,\n    Raw: 202,\n    AttributeDeclaration: 203,\n    ElementDeclaration: 204,\n    Dummy: 205\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  exports.parseStringPromise = parser.parseStringPromise;\n\n}).call(this);\n","module.exports = require('./lib/_stream_duplex.js');\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  module.exports = {\n    None: 0,\n    OpenTag: 1,\n    InsideTag: 2,\n    CloseTag: 3\n  };\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var XMLDOMImplementation;\n\n  module.exports = XMLDOMImplementation = (function() {\n    function XMLDOMImplementation() {}\n\n    XMLDOMImplementation.prototype.hasFeature = function(feature, version) {\n      return true;\n    };\n\n    XMLDOMImplementation.prototype.createDocumentType = function(qualifiedName, publicId, systemId) {\n      throw new Error(\"This DOM method is not implemented.\");\n    };\n\n    XMLDOMImplementation.prototype.createDocument = function(namespaceURI, qualifiedName, doctype) {\n      throw new Error(\"This DOM method is not implemented.\");\n    };\n\n    XMLDOMImplementation.prototype.createHTMLDocument = function(title) {\n      throw new Error(\"This DOM method is not implemented.\");\n    };\n\n    XMLDOMImplementation.prototype.getFeature = function(feature, version) {\n      throw new Error(\"This DOM method is not implemented.\");\n    };\n\n    return XMLDOMImplementation;\n\n  })();\n\n}).call(this);\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","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLDummy, XMLNode,\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  XMLNode = require('./XMLNode');\n\n  NodeType = require('./NodeType');\n\n  module.exports = XMLDummy = (function(superClass) {\n    extend(XMLDummy, superClass);\n\n    function XMLDummy(parent) {\n      XMLDummy.__super__.constructor.call(this, parent);\n      this.type = NodeType.Dummy;\n    }\n\n    XMLDummy.prototype.clone = function() {\n      return Object.create(this);\n    };\n\n    XMLDummy.prototype.toString = function(options) {\n      return '';\n    };\n\n    return XMLDummy;\n\n  })(XMLNode);\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLDTDEntity, XMLNode, isObject,\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  isObject = require('./Utility').isObject;\n\n  XMLNode = require('./XMLNode');\n\n  NodeType = require('./NodeType');\n\n  module.exports = XMLDTDEntity = (function(superClass) {\n    extend(XMLDTDEntity, superClass);\n\n    function XMLDTDEntity(parent, pe, name, value) {\n      XMLDTDEntity.__super__.constructor.call(this, parent);\n      if (name == null) {\n        throw new Error(\"Missing DTD entity name. \" + this.debugInfo(name));\n      }\n      if (value == null) {\n        throw new Error(\"Missing DTD entity value. \" + this.debugInfo(name));\n      }\n      this.pe = !!pe;\n      this.name = this.stringify.name(name);\n      this.type = NodeType.EntityDeclaration;\n      if (!isObject(value)) {\n        this.value = this.stringify.dtdEntityValue(value);\n        this.internal = true;\n      } else {\n        if (!value.pubID && !value.sysID) {\n          throw new Error(\"Public and/or system identifiers are required for an external entity. \" + this.debugInfo(name));\n        }\n        if (value.pubID && !value.sysID) {\n          throw new Error(\"System identifier is required for a public external entity. \" + this.debugInfo(name));\n        }\n        this.internal = false;\n        if (value.pubID != null) {\n          this.pubID = this.stringify.dtdPubID(value.pubID);\n        }\n        if (value.sysID != null) {\n          this.sysID = this.stringify.dtdSysID(value.sysID);\n        }\n        if (value.nData != null) {\n          this.nData = this.stringify.dtdNData(value.nData);\n        }\n        if (this.pe && this.nData) {\n          throw new Error(\"Notation declaration is not allowed in a parameter entity. \" + this.debugInfo(name));\n        }\n      }\n    }\n\n    Object.defineProperty(XMLDTDEntity.prototype, 'publicId', {\n      get: function() {\n        return this.pubID;\n      }\n    });\n\n    Object.defineProperty(XMLDTDEntity.prototype, 'systemId', {\n      get: function() {\n        return this.sysID;\n      }\n    });\n\n    Object.defineProperty(XMLDTDEntity.prototype, 'notationName', {\n      get: function() {\n        return this.nData || null;\n      }\n    });\n\n    Object.defineProperty(XMLDTDEntity.prototype, 'inputEncoding', {\n      get: function() {\n        return null;\n      }\n    });\n\n    Object.defineProperty(XMLDTDEntity.prototype, 'xmlEncoding', {\n      get: function() {\n        return null;\n      }\n    });\n\n    Object.defineProperty(XMLDTDEntity.prototype, 'xmlVersion', {\n      get: function() {\n        return null;\n      }\n    });\n\n    XMLDTDEntity.prototype.toString = function(options) {\n      return this.options.writer.dtdEntity(this, this.options.writer.filterOptions(options));\n    };\n\n    return XMLDTDEntity;\n\n  })(XMLNode);\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLDTDAttList, XMLNode,\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  XMLNode = require('./XMLNode');\n\n  NodeType = require('./NodeType');\n\n  module.exports = XMLDTDAttList = (function(superClass) {\n    extend(XMLDTDAttList, superClass);\n\n    function XMLDTDAttList(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {\n      XMLDTDAttList.__super__.constructor.call(this, parent);\n      if (elementName == null) {\n        throw new Error(\"Missing DTD element name. \" + this.debugInfo());\n      }\n      if (attributeName == null) {\n        throw new Error(\"Missing DTD attribute name. \" + this.debugInfo(elementName));\n      }\n      if (!attributeType) {\n        throw new Error(\"Missing DTD attribute type. \" + this.debugInfo(elementName));\n      }\n      if (!defaultValueType) {\n        throw new Error(\"Missing DTD attribute default. \" + this.debugInfo(elementName));\n      }\n      if (defaultValueType.indexOf('#') !== 0) {\n        defaultValueType = '#' + defaultValueType;\n      }\n      if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) {\n        throw new Error(\"Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT. \" + this.debugInfo(elementName));\n      }\n      if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) {\n        throw new Error(\"Default value only applies to #FIXED or #DEFAULT. \" + this.debugInfo(elementName));\n      }\n      this.elementName = this.stringify.name(elementName);\n      this.type = NodeType.AttributeDeclaration;\n      this.attributeName = this.stringify.name(attributeName);\n      this.attributeType = this.stringify.dtdAttType(attributeType);\n      if (defaultValue) {\n        this.defaultValue = this.stringify.dtdAttDefault(defaultValue);\n      }\n      this.defaultValueType = defaultValueType;\n    }\n\n    XMLDTDAttList.prototype.toString = function(options) {\n      return this.options.writer.dtdAttList(this, this.options.writer.filterOptions(options));\n    };\n\n    return XMLDTDAttList;\n\n  })(XMLNode);\n\n}).call(this);\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","// Generated by CoffeeScript 1.12.7\n(function() {\n  var XMLDOMStringList;\n\n  module.exports = XMLDOMStringList = (function() {\n    function XMLDOMStringList(arr) {\n      this.arr = arr || [];\n    }\n\n    Object.defineProperty(XMLDOMStringList.prototype, 'length', {\n      get: function() {\n        return this.arr.length;\n      }\n    });\n\n    XMLDOMStringList.prototype.item = function(index) {\n      return this.arr[index] || null;\n    };\n\n    XMLDOMStringList.prototype.contains = function(str) {\n      return this.arr.indexOf(str) !== -1;\n    };\n\n    return XMLDOMStringList;\n\n  })();\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var XMLStringWriter, XMLWriterBase,\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  XMLWriterBase = require('./XMLWriterBase');\n\n  module.exports = XMLStringWriter = (function(superClass) {\n    extend(XMLStringWriter, superClass);\n\n    function XMLStringWriter(options) {\n      XMLStringWriter.__super__.constructor.call(this, options);\n    }\n\n    XMLStringWriter.prototype.document = function(doc, options) {\n      var child, i, len, r, ref;\n      options = this.filterOptions(options);\n      r = '';\n      ref = doc.children;\n      for (i = 0, len = ref.length; i < len; i++) {\n        child = ref[i];\n        r += this.writeChildNode(child, options, 0);\n      }\n      if (options.pretty && r.slice(-options.newline.length) === options.newline) {\n        r = r.slice(0, -options.newline.length);\n      }\n      return r;\n    };\n\n    return XMLStringWriter;\n\n  })(XMLWriterBase);\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLAttribute, XMLNode;\n\n  NodeType = require('./NodeType');\n\n  XMLNode = require('./XMLNode');\n\n  module.exports = XMLAttribute = (function() {\n    function XMLAttribute(parent, name, value) {\n      this.parent = parent;\n      if (this.parent) {\n        this.options = this.parent.options;\n        this.stringify = this.parent.stringify;\n      }\n      if (name == null) {\n        throw new Error(\"Missing attribute name. \" + this.debugInfo(name));\n      }\n      this.name = this.stringify.name(name);\n      this.value = this.stringify.attValue(value);\n      this.type = NodeType.Attribute;\n      this.isId = false;\n      this.schemaTypeInfo = null;\n    }\n\n    Object.defineProperty(XMLAttribute.prototype, 'nodeType', {\n      get: function() {\n        return this.type;\n      }\n    });\n\n    Object.defineProperty(XMLAttribute.prototype, 'ownerElement', {\n      get: function() {\n        return this.parent;\n      }\n    });\n\n    Object.defineProperty(XMLAttribute.prototype, 'textContent', {\n      get: function() {\n        return this.value;\n      },\n      set: function(value) {\n        return this.value = value || '';\n      }\n    });\n\n    Object.defineProperty(XMLAttribute.prototype, 'namespaceURI', {\n      get: function() {\n        return '';\n      }\n    });\n\n    Object.defineProperty(XMLAttribute.prototype, 'prefix', {\n      get: function() {\n        return '';\n      }\n    });\n\n    Object.defineProperty(XMLAttribute.prototype, 'localName', {\n      get: function() {\n        return this.name;\n      }\n    });\n\n    Object.defineProperty(XMLAttribute.prototype, 'specified', {\n      get: function() {\n        return true;\n      }\n    });\n\n    XMLAttribute.prototype.clone = function() {\n      return Object.create(this);\n    };\n\n    XMLAttribute.prototype.toString = function(options) {\n      return this.options.writer.attribute(this, this.options.writer.filterOptions(options));\n    };\n\n    XMLAttribute.prototype.debugInfo = function(name) {\n      name = name || this.name;\n      if (name == null) {\n        return \"parent: <\" + this.parent.name + \">\";\n      } else {\n        return \"attribute: {\" + name + \"}, parent: <\" + this.parent.name + \">\";\n      }\n    };\n\n    XMLAttribute.prototype.isEqualNode = function(node) {\n      if (node.namespaceURI !== this.namespaceURI) {\n        return false;\n      }\n      if (node.prefix !== this.prefix) {\n        return false;\n      }\n      if (node.localName !== this.localName) {\n        return false;\n      }\n      if (node.value !== this.value) {\n        return false;\n      }\n      return true;\n    };\n\n    return XMLAttribute;\n\n  })();\n\n}).call(this);\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","'use strict';\nvar redefine = require('../internals/redefine');\nvar anObject = require('../internals/an-object');\nvar fails = require('../internals/fails');\nvar flags = require('../internals/regexp-flags');\n\nvar TO_STRING = 'toString';\nvar RegExpPrototype = RegExp.prototype;\nvar nativeToString = RegExpPrototype[TO_STRING];\n\nvar NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });\n// FF44- RegExp#toString has a wrong name\nvar INCORRECT_NAME = nativeToString.name != TO_STRING;\n\n// `RegExp.prototype.toString` method\n// https://tc39.es/ecma262/#sec-regexp.prototype.tostring\nif (NOT_GENERIC || INCORRECT_NAME) {\n  redefine(RegExp.prototype, TO_STRING, function toString() {\n    var R = anObject(this);\n    var p = String(R.source);\n    var rf = R.flags;\n    var f = String(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype) ? flags.call(R) : rf);\n    return '/' + p + '/' + f;\n  }, { unsafe: true });\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}","module.exports = require('./lib/_stream_writable.js');\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","'use strict';\n\nmodule.exports = {\n  isString: function(arg) {\n    return typeof(arg) === 'string';\n  },\n  isObject: function(arg) {\n    return typeof(arg) === 'object' && arg !== null;\n  },\n  isNull: function(arg) {\n    return arg === null;\n  },\n  isNullOrUndefined: function(arg) {\n    return arg == null;\n  }\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLDTDElement, XMLNode,\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  XMLNode = require('./XMLNode');\n\n  NodeType = require('./NodeType');\n\n  module.exports = XMLDTDElement = (function(superClass) {\n    extend(XMLDTDElement, superClass);\n\n    function XMLDTDElement(parent, name, value) {\n      XMLDTDElement.__super__.constructor.call(this, parent);\n      if (name == null) {\n        throw new Error(\"Missing DTD element name. \" + this.debugInfo());\n      }\n      if (!value) {\n        value = '(#PCDATA)';\n      }\n      if (Array.isArray(value)) {\n        value = '(' + value.join(',') + ')';\n      }\n      this.name = this.stringify.name(name);\n      this.type = NodeType.ElementDeclaration;\n      this.value = this.stringify.dtdElementValue(value);\n    }\n\n    XMLDTDElement.prototype.toString = function(options) {\n      return this.options.writer.dtdElement(this, this.options.writer.filterOptions(options));\n    };\n\n    return XMLDTDElement;\n\n  })(XMLNode);\n\n}).call(this);\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","// 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","module.exports = require('events').EventEmitter;\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var assign, getValue, isArray, isEmpty, isFunction, isObject, isPlainObject,\n    slice = [].slice,\n    hasProp = {}.hasOwnProperty;\n\n  assign = function() {\n    var i, key, len, source, sources, target;\n    target = arguments[0], sources = 2 <= arguments.length ? slice.call(arguments, 1) : [];\n    if (isFunction(Object.assign)) {\n      Object.assign.apply(null, arguments);\n    } else {\n      for (i = 0, len = sources.length; i < len; i++) {\n        source = sources[i];\n        if (source != null) {\n          for (key in source) {\n            if (!hasProp.call(source, key)) continue;\n            target[key] = source[key];\n          }\n        }\n      }\n    }\n    return target;\n  };\n\n  isFunction = function(val) {\n    return !!val && Object.prototype.toString.call(val) === '[object Function]';\n  };\n\n  isObject = function(val) {\n    var ref;\n    return !!val && ((ref = typeof val) === 'function' || ref === 'object');\n  };\n\n  isArray = function(val) {\n    if (isFunction(Array.isArray)) {\n      return Array.isArray(val);\n    } else {\n      return Object.prototype.toString.call(val) === '[object Array]';\n    }\n  };\n\n  isEmpty = function(val) {\n    var key;\n    if (isArray(val)) {\n      return !val.length;\n    } else {\n      for (key in val) {\n        if (!hasProp.call(val, key)) continue;\n        return false;\n      }\n      return true;\n    }\n  };\n\n  isPlainObject = function(val) {\n    var ctor, proto;\n    return isObject(val) && (proto = Object.getPrototypeOf(val)) && (ctor = proto.constructor) && (typeof ctor === 'function') && (ctor instanceof ctor) && (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object));\n  };\n\n  getValue = function(obj) {\n    if (isFunction(obj.valueOf)) {\n      return obj.valueOf();\n    } else {\n      return obj;\n    }\n  };\n\n  module.exports.assign = assign;\n\n  module.exports.isFunction = isFunction;\n\n  module.exports.isObject = isObject;\n\n  module.exports.isArray = isArray;\n\n  module.exports.isEmpty = isEmpty;\n\n  module.exports.isPlainObject = isPlainObject;\n\n  module.exports.getValue = getValue;\n\n}).call(this);\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};","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLNode, XMLRaw,\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  NodeType = require('./NodeType');\n\n  XMLNode = require('./XMLNode');\n\n  module.exports = XMLRaw = (function(superClass) {\n    extend(XMLRaw, superClass);\n\n    function XMLRaw(parent, text) {\n      XMLRaw.__super__.constructor.call(this, parent);\n      if (text == null) {\n        throw new Error(\"Missing raw text. \" + this.debugInfo());\n      }\n      this.type = NodeType.Raw;\n      this.value = this.stringify.raw(text);\n    }\n\n    XMLRaw.prototype.clone = function() {\n      return Object.create(this);\n    };\n\n    XMLRaw.prototype.toString = function(options) {\n      return this.options.writer.raw(this, this.options.writer.filterOptions(options));\n    };\n\n    return XMLRaw;\n\n  })(XMLNode);\n\n}).call(this);\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","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLDeclaration, XMLNode, isObject,\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  isObject = require('./Utility').isObject;\n\n  XMLNode = require('./XMLNode');\n\n  NodeType = require('./NodeType');\n\n  module.exports = XMLDeclaration = (function(superClass) {\n    extend(XMLDeclaration, superClass);\n\n    function XMLDeclaration(parent, version, encoding, standalone) {\n      var ref;\n      XMLDeclaration.__super__.constructor.call(this, parent);\n      if (isObject(version)) {\n        ref = version, version = ref.version, encoding = ref.encoding, standalone = ref.standalone;\n      }\n      if (!version) {\n        version = '1.0';\n      }\n      this.type = NodeType.Declaration;\n      this.version = this.stringify.xmlVersion(version);\n      if (encoding != null) {\n        this.encoding = this.stringify.xmlEncoding(encoding);\n      }\n      if (standalone != null) {\n        this.standalone = this.stringify.xmlStandalone(standalone);\n      }\n    }\n\n    XMLDeclaration.prototype.toString = function(options) {\n      return this.options.writer.declaration(this, this.options.writer.filterOptions(options));\n    };\n\n    return XMLDeclaration;\n\n  })(XMLNode);\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLCData, XMLCharacterData,\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  NodeType = require('./NodeType');\n\n  XMLCharacterData = require('./XMLCharacterData');\n\n  module.exports = XMLCData = (function(superClass) {\n    extend(XMLCData, superClass);\n\n    function XMLCData(parent, text) {\n      XMLCData.__super__.constructor.call(this, parent);\n      if (text == null) {\n        throw new Error(\"Missing CDATA text. \" + this.debugInfo());\n      }\n      this.name = \"#cdata-section\";\n      this.type = NodeType.CData;\n      this.value = this.stringify.cdata(text);\n    }\n\n    XMLCData.prototype.clone = function() {\n      return Object.create(this);\n    };\n\n    XMLCData.prototype.toString = function(options) {\n      return this.options.writer.cdata(this, this.options.writer.filterOptions(options));\n    };\n\n    return XMLCData;\n\n  })(XMLCharacterData);\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","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, WriterState, XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocument, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction, isObject, isPlainObject, ref,\n    hasProp = {}.hasOwnProperty;\n\n  ref = require('./Utility'), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject = ref.isPlainObject, getValue = ref.getValue;\n\n  NodeType = require('./NodeType');\n\n  XMLDocument = require('./XMLDocument');\n\n  XMLElement = require('./XMLElement');\n\n  XMLCData = require('./XMLCData');\n\n  XMLComment = require('./XMLComment');\n\n  XMLRaw = require('./XMLRaw');\n\n  XMLText = require('./XMLText');\n\n  XMLProcessingInstruction = require('./XMLProcessingInstruction');\n\n  XMLDeclaration = require('./XMLDeclaration');\n\n  XMLDocType = require('./XMLDocType');\n\n  XMLDTDAttList = require('./XMLDTDAttList');\n\n  XMLDTDEntity = require('./XMLDTDEntity');\n\n  XMLDTDElement = require('./XMLDTDElement');\n\n  XMLDTDNotation = require('./XMLDTDNotation');\n\n  XMLAttribute = require('./XMLAttribute');\n\n  XMLStringifier = require('./XMLStringifier');\n\n  XMLStringWriter = require('./XMLStringWriter');\n\n  WriterState = require('./WriterState');\n\n  module.exports = XMLDocumentCB = (function() {\n    function XMLDocumentCB(options, onData, onEnd) {\n      var writerOptions;\n      this.name = \"?xml\";\n      this.type = NodeType.Document;\n      options || (options = {});\n      writerOptions = {};\n      if (!options.writer) {\n        options.writer = new XMLStringWriter();\n      } else if (isPlainObject(options.writer)) {\n        writerOptions = options.writer;\n        options.writer = new XMLStringWriter();\n      }\n      this.options = options;\n      this.writer = options.writer;\n      this.writerOptions = this.writer.filterOptions(writerOptions);\n      this.stringify = new XMLStringifier(options);\n      this.onDataCallback = onData || function() {};\n      this.onEndCallback = onEnd || function() {};\n      this.currentNode = null;\n      this.currentLevel = -1;\n      this.openTags = {};\n      this.documentStarted = false;\n      this.documentCompleted = false;\n      this.root = null;\n    }\n\n    XMLDocumentCB.prototype.createChildNode = function(node) {\n      var att, attName, attributes, child, i, len, ref1, ref2;\n      switch (node.type) {\n        case NodeType.CData:\n          this.cdata(node.value);\n          break;\n        case NodeType.Comment:\n          this.comment(node.value);\n          break;\n        case NodeType.Element:\n          attributes = {};\n          ref1 = node.attribs;\n          for (attName in ref1) {\n            if (!hasProp.call(ref1, attName)) continue;\n            att = ref1[attName];\n            attributes[attName] = att.value;\n          }\n          this.node(node.name, attributes);\n          break;\n        case NodeType.Dummy:\n          this.dummy();\n          break;\n        case NodeType.Raw:\n          this.raw(node.value);\n          break;\n        case NodeType.Text:\n          this.text(node.value);\n          break;\n        case NodeType.ProcessingInstruction:\n          this.instruction(node.target, node.value);\n          break;\n        default:\n          throw new Error(\"This XML node type is not supported in a JS object: \" + node.constructor.name);\n      }\n      ref2 = node.children;\n      for (i = 0, len = ref2.length; i < len; i++) {\n        child = ref2[i];\n        this.createChildNode(child);\n        if (child.type === NodeType.Element) {\n          this.up();\n        }\n      }\n      return this;\n    };\n\n    XMLDocumentCB.prototype.dummy = function() {\n      return this;\n    };\n\n    XMLDocumentCB.prototype.node = function(name, attributes, text) {\n      var ref1;\n      if (name == null) {\n        throw new Error(\"Missing node name.\");\n      }\n      if (this.root && this.currentLevel === -1) {\n        throw new Error(\"Document can only have one root node. \" + this.debugInfo(name));\n      }\n      this.openCurrent();\n      name = getValue(name);\n      if (attributes == null) {\n        attributes = {};\n      }\n      attributes = getValue(attributes);\n      if (!isObject(attributes)) {\n        ref1 = [attributes, text], text = ref1[0], attributes = ref1[1];\n      }\n      this.currentNode = new XMLElement(this, name, attributes);\n      this.currentNode.children = false;\n      this.currentLevel++;\n      this.openTags[this.currentLevel] = this.currentNode;\n      if (text != null) {\n        this.text(text);\n      }\n      return this;\n    };\n\n    XMLDocumentCB.prototype.element = function(name, attributes, text) {\n      var child, i, len, oldValidationFlag, ref1, root;\n      if (this.currentNode && this.currentNode.type === NodeType.DocType) {\n        this.dtdElement.apply(this, arguments);\n      } else {\n        if (Array.isArray(name) || isObject(name) || isFunction(name)) {\n          oldValidationFlag = this.options.noValidation;\n          this.options.noValidation = true;\n          root = new XMLDocument(this.options).element('TEMP_ROOT');\n          root.element(name);\n          this.options.noValidation = oldValidationFlag;\n          ref1 = root.children;\n          for (i = 0, len = ref1.length; i < len; i++) {\n            child = ref1[i];\n            this.createChildNode(child);\n            if (child.type === NodeType.Element) {\n              this.up();\n            }\n          }\n        } else {\n          this.node(name, attributes, text);\n        }\n      }\n      return this;\n    };\n\n    XMLDocumentCB.prototype.attribute = function(name, value) {\n      var attName, attValue;\n      if (!this.currentNode || this.currentNode.children) {\n        throw new Error(\"att() can only be used immediately after an ele() call in callback mode. \" + this.debugInfo(name));\n      }\n      if (name != null) {\n        name = getValue(name);\n      }\n      if (isObject(name)) {\n        for (attName in name) {\n          if (!hasProp.call(name, attName)) continue;\n          attValue = name[attName];\n          this.attribute(attName, attValue);\n        }\n      } else {\n        if (isFunction(value)) {\n          value = value.apply();\n        }\n        if (this.options.keepNullAttributes && (value == null)) {\n          this.currentNode.attribs[name] = new XMLAttribute(this, name, \"\");\n        } else if (value != null) {\n          this.currentNode.attribs[name] = new XMLAttribute(this, name, value);\n        }\n      }\n      return this;\n    };\n\n    XMLDocumentCB.prototype.text = function(value) {\n      var node;\n      this.openCurrent();\n      node = new XMLText(this, value);\n      this.onData(this.writer.text(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);\n      return this;\n    };\n\n    XMLDocumentCB.prototype.cdata = function(value) {\n      var node;\n      this.openCurrent();\n      node = new XMLCData(this, value);\n      this.onData(this.writer.cdata(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);\n      return this;\n    };\n\n    XMLDocumentCB.prototype.comment = function(value) {\n      var node;\n      this.openCurrent();\n      node = new XMLComment(this, value);\n      this.onData(this.writer.comment(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);\n      return this;\n    };\n\n    XMLDocumentCB.prototype.raw = function(value) {\n      var node;\n      this.openCurrent();\n      node = new XMLRaw(this, value);\n      this.onData(this.writer.raw(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);\n      return this;\n    };\n\n    XMLDocumentCB.prototype.instruction = function(target, value) {\n      var i, insTarget, insValue, len, node;\n      this.openCurrent();\n      if (target != null) {\n        target = getValue(target);\n      }\n      if (value != null) {\n        value = getValue(value);\n      }\n      if (Array.isArray(target)) {\n        for (i = 0, len = target.length; i < len; i++) {\n          insTarget = target[i];\n          this.instruction(insTarget);\n        }\n      } else if (isObject(target)) {\n        for (insTarget in target) {\n          if (!hasProp.call(target, insTarget)) continue;\n          insValue = target[insTarget];\n          this.instruction(insTarget, insValue);\n        }\n      } else {\n        if (isFunction(value)) {\n          value = value.apply();\n        }\n        node = new XMLProcessingInstruction(this, target, value);\n        this.onData(this.writer.processingInstruction(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);\n      }\n      return this;\n    };\n\n    XMLDocumentCB.prototype.declaration = function(version, encoding, standalone) {\n      var node;\n      this.openCurrent();\n      if (this.documentStarted) {\n        throw new Error(\"declaration() must be the first node.\");\n      }\n      node = new XMLDeclaration(this, version, encoding, standalone);\n      this.onData(this.writer.declaration(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);\n      return this;\n    };\n\n    XMLDocumentCB.prototype.doctype = function(root, pubID, sysID) {\n      this.openCurrent();\n      if (root == null) {\n        throw new Error(\"Missing root node name.\");\n      }\n      if (this.root) {\n        throw new Error(\"dtd() must come before the root node.\");\n      }\n      this.currentNode = new XMLDocType(this, pubID, sysID);\n      this.currentNode.rootNodeName = root;\n      this.currentNode.children = false;\n      this.currentLevel++;\n      this.openTags[this.currentLevel] = this.currentNode;\n      return this;\n    };\n\n    XMLDocumentCB.prototype.dtdElement = function(name, value) {\n      var node;\n      this.openCurrent();\n      node = new XMLDTDElement(this, name, value);\n      this.onData(this.writer.dtdElement(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);\n      return this;\n    };\n\n    XMLDocumentCB.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {\n      var node;\n      this.openCurrent();\n      node = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);\n      this.onData(this.writer.dtdAttList(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);\n      return this;\n    };\n\n    XMLDocumentCB.prototype.entity = function(name, value) {\n      var node;\n      this.openCurrent();\n      node = new XMLDTDEntity(this, false, name, value);\n      this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);\n      return this;\n    };\n\n    XMLDocumentCB.prototype.pEntity = function(name, value) {\n      var node;\n      this.openCurrent();\n      node = new XMLDTDEntity(this, true, name, value);\n      this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);\n      return this;\n    };\n\n    XMLDocumentCB.prototype.notation = function(name, value) {\n      var node;\n      this.openCurrent();\n      node = new XMLDTDNotation(this, name, value);\n      this.onData(this.writer.dtdNotation(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);\n      return this;\n    };\n\n    XMLDocumentCB.prototype.up = function() {\n      if (this.currentLevel < 0) {\n        throw new Error(\"The document node has no parent.\");\n      }\n      if (this.currentNode) {\n        if (this.currentNode.children) {\n          this.closeNode(this.currentNode);\n        } else {\n          this.openNode(this.currentNode);\n        }\n        this.currentNode = null;\n      } else {\n        this.closeNode(this.openTags[this.currentLevel]);\n      }\n      delete this.openTags[this.currentLevel];\n      this.currentLevel--;\n      return this;\n    };\n\n    XMLDocumentCB.prototype.end = function() {\n      while (this.currentLevel >= 0) {\n        this.up();\n      }\n      return this.onEnd();\n    };\n\n    XMLDocumentCB.prototype.openCurrent = function() {\n      if (this.currentNode) {\n        this.currentNode.children = true;\n        return this.openNode(this.currentNode);\n      }\n    };\n\n    XMLDocumentCB.prototype.openNode = function(node) {\n      var att, chunk, name, ref1;\n      if (!node.isOpen) {\n        if (!this.root && this.currentLevel === 0 && node.type === NodeType.Element) {\n          this.root = node;\n        }\n        chunk = '';\n        if (node.type === NodeType.Element) {\n          this.writerOptions.state = WriterState.OpenTag;\n          chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '<' + node.name;\n          ref1 = node.attribs;\n          for (name in ref1) {\n            if (!hasProp.call(ref1, name)) continue;\n            att = ref1[name];\n            chunk += this.writer.attribute(att, this.writerOptions, this.currentLevel);\n          }\n          chunk += (node.children ? '>' : '/>') + this.writer.endline(node, this.writerOptions, this.currentLevel);\n          this.writerOptions.state = WriterState.InsideTag;\n        } else {\n          this.writerOptions.state = WriterState.OpenTag;\n          chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '<!DOCTYPE ' + node.rootNodeName;\n          if (node.pubID && node.sysID) {\n            chunk += ' PUBLIC \"' + node.pubID + '\" \"' + node.sysID + '\"';\n          } else if (node.sysID) {\n            chunk += ' SYSTEM \"' + node.sysID + '\"';\n          }\n          if (node.children) {\n            chunk += ' [';\n            this.writerOptions.state = WriterState.InsideTag;\n          } else {\n            this.writerOptions.state = WriterState.CloseTag;\n            chunk += '>';\n          }\n          chunk += this.writer.endline(node, this.writerOptions, this.currentLevel);\n        }\n        this.onData(chunk, this.currentLevel);\n        return node.isOpen = true;\n      }\n    };\n\n    XMLDocumentCB.prototype.closeNode = function(node) {\n      var chunk;\n      if (!node.isClosed) {\n        chunk = '';\n        this.writerOptions.state = WriterState.CloseTag;\n        if (node.type === NodeType.Element) {\n          chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '</' + node.name + '>' + this.writer.endline(node, this.writerOptions, this.currentLevel);\n        } else {\n          chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + ']>' + this.writer.endline(node, this.writerOptions, this.currentLevel);\n        }\n        this.writerOptions.state = WriterState.None;\n        this.onData(chunk, this.currentLevel);\n        return node.isClosed = true;\n      }\n    };\n\n    XMLDocumentCB.prototype.onData = function(chunk, level) {\n      this.documentStarted = true;\n      return this.onDataCallback(chunk, level + 1);\n    };\n\n    XMLDocumentCB.prototype.onEnd = function() {\n      this.documentCompleted = true;\n      return this.onEndCallback();\n    };\n\n    XMLDocumentCB.prototype.debugInfo = function(name) {\n      if (name == null) {\n        return \"\";\n      } else {\n        return \"node: <\" + name + \">\";\n      }\n    };\n\n    XMLDocumentCB.prototype.ele = function() {\n      return this.element.apply(this, arguments);\n    };\n\n    XMLDocumentCB.prototype.nod = function(name, attributes, text) {\n      return this.node(name, attributes, text);\n    };\n\n    XMLDocumentCB.prototype.txt = function(value) {\n      return this.text(value);\n    };\n\n    XMLDocumentCB.prototype.dat = function(value) {\n      return this.cdata(value);\n    };\n\n    XMLDocumentCB.prototype.com = function(value) {\n      return this.comment(value);\n    };\n\n    XMLDocumentCB.prototype.ins = function(target, value) {\n      return this.instruction(target, value);\n    };\n\n    XMLDocumentCB.prototype.dec = function(version, encoding, standalone) {\n      return this.declaration(version, encoding, standalone);\n    };\n\n    XMLDocumentCB.prototype.dtd = function(root, pubID, sysID) {\n      return this.doctype(root, pubID, sysID);\n    };\n\n    XMLDocumentCB.prototype.e = function(name, attributes, text) {\n      return this.element(name, attributes, text);\n    };\n\n    XMLDocumentCB.prototype.n = function(name, attributes, text) {\n      return this.node(name, attributes, text);\n    };\n\n    XMLDocumentCB.prototype.t = function(value) {\n      return this.text(value);\n    };\n\n    XMLDocumentCB.prototype.d = function(value) {\n      return this.cdata(value);\n    };\n\n    XMLDocumentCB.prototype.c = function(value) {\n      return this.comment(value);\n    };\n\n    XMLDocumentCB.prototype.r = function(value) {\n      return this.raw(value);\n    };\n\n    XMLDocumentCB.prototype.i = function(target, value) {\n      return this.instruction(target, value);\n    };\n\n    XMLDocumentCB.prototype.att = function() {\n      if (this.currentNode && this.currentNode.type === NodeType.DocType) {\n        return this.attList.apply(this, arguments);\n      } else {\n        return this.attribute.apply(this, arguments);\n      }\n    };\n\n    XMLDocumentCB.prototype.a = function() {\n      if (this.currentNode && this.currentNode.type === NodeType.DocType) {\n        return this.attList.apply(this, arguments);\n      } else {\n        return this.attribute.apply(this, arguments);\n      }\n    };\n\n    XMLDocumentCB.prototype.ent = function(name, value) {\n      return this.entity(name, value);\n    };\n\n    XMLDocumentCB.prototype.pent = function(name, value) {\n      return this.pEntity(name, value);\n    };\n\n    XMLDocumentCB.prototype.not = function(name, value) {\n      return this.notation(name, value);\n    };\n\n    return XMLDocumentCB;\n\n  })();\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var XMLCharacterData, XMLNode,\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  XMLNode = require('./XMLNode');\n\n  module.exports = XMLCharacterData = (function(superClass) {\n    extend(XMLCharacterData, superClass);\n\n    function XMLCharacterData(parent) {\n      XMLCharacterData.__super__.constructor.call(this, parent);\n      this.value = '';\n    }\n\n    Object.defineProperty(XMLCharacterData.prototype, 'data', {\n      get: function() {\n        return this.value;\n      },\n      set: function(value) {\n        return this.value = value || '';\n      }\n    });\n\n    Object.defineProperty(XMLCharacterData.prototype, 'length', {\n      get: function() {\n        return this.value.length;\n      }\n    });\n\n    Object.defineProperty(XMLCharacterData.prototype, 'textContent', {\n      get: function() {\n        return this.value;\n      },\n      set: function(value) {\n        return this.value = value || '';\n      }\n    });\n\n    XMLCharacterData.prototype.clone = function() {\n      return Object.create(this);\n    };\n\n    XMLCharacterData.prototype.substringData = function(offset, count) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLCharacterData.prototype.appendData = function(arg) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLCharacterData.prototype.insertData = function(offset, arg) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLCharacterData.prototype.deleteData = function(offset, count) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLCharacterData.prototype.replaceData = function(offset, count, arg) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLCharacterData.prototype.isEqualNode = function(node) {\n      if (!XMLCharacterData.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {\n        return false;\n      }\n      if (node.data !== this.data) {\n        return false;\n      }\n      return true;\n    };\n\n    return XMLCharacterData;\n\n  })(XMLNode);\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var XMLStringifier,\n    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },\n    hasProp = {}.hasOwnProperty;\n\n  module.exports = XMLStringifier = (function() {\n    function XMLStringifier(options) {\n      this.assertLegalName = bind(this.assertLegalName, this);\n      this.assertLegalChar = bind(this.assertLegalChar, this);\n      var key, ref, value;\n      options || (options = {});\n      this.options = options;\n      if (!this.options.version) {\n        this.options.version = '1.0';\n      }\n      ref = options.stringify || {};\n      for (key in ref) {\n        if (!hasProp.call(ref, key)) continue;\n        value = ref[key];\n        this[key] = value;\n      }\n    }\n\n    XMLStringifier.prototype.name = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return this.assertLegalName('' + val || '');\n    };\n\n    XMLStringifier.prototype.text = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return this.assertLegalChar(this.textEscape('' + val || ''));\n    };\n\n    XMLStringifier.prototype.cdata = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      val = '' + val || '';\n      val = val.replace(']]>', ']]]]><![CDATA[>');\n      return this.assertLegalChar(val);\n    };\n\n    XMLStringifier.prototype.comment = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      val = '' + val || '';\n      if (val.match(/--/)) {\n        throw new Error(\"Comment text cannot contain double-hypen: \" + val);\n      }\n      return this.assertLegalChar(val);\n    };\n\n    XMLStringifier.prototype.raw = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return '' + val || '';\n    };\n\n    XMLStringifier.prototype.attValue = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return this.assertLegalChar(this.attEscape(val = '' + val || ''));\n    };\n\n    XMLStringifier.prototype.insTarget = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return this.assertLegalChar('' + val || '');\n    };\n\n    XMLStringifier.prototype.insValue = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      val = '' + val || '';\n      if (val.match(/\\?>/)) {\n        throw new Error(\"Invalid processing instruction value: \" + val);\n      }\n      return this.assertLegalChar(val);\n    };\n\n    XMLStringifier.prototype.xmlVersion = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      val = '' + val || '';\n      if (!val.match(/1\\.[0-9]+/)) {\n        throw new Error(\"Invalid version number: \" + val);\n      }\n      return val;\n    };\n\n    XMLStringifier.prototype.xmlEncoding = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      val = '' + val || '';\n      if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-])*$/)) {\n        throw new Error(\"Invalid encoding: \" + val);\n      }\n      return this.assertLegalChar(val);\n    };\n\n    XMLStringifier.prototype.xmlStandalone = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      if (val) {\n        return \"yes\";\n      } else {\n        return \"no\";\n      }\n    };\n\n    XMLStringifier.prototype.dtdPubID = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return this.assertLegalChar('' + val || '');\n    };\n\n    XMLStringifier.prototype.dtdSysID = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return this.assertLegalChar('' + val || '');\n    };\n\n    XMLStringifier.prototype.dtdElementValue = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return this.assertLegalChar('' + val || '');\n    };\n\n    XMLStringifier.prototype.dtdAttType = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return this.assertLegalChar('' + val || '');\n    };\n\n    XMLStringifier.prototype.dtdAttDefault = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return this.assertLegalChar('' + val || '');\n    };\n\n    XMLStringifier.prototype.dtdEntityValue = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return this.assertLegalChar('' + val || '');\n    };\n\n    XMLStringifier.prototype.dtdNData = function(val) {\n      if (this.options.noValidation) {\n        return val;\n      }\n      return this.assertLegalChar('' + val || '');\n    };\n\n    XMLStringifier.prototype.convertAttKey = '@';\n\n    XMLStringifier.prototype.convertPIKey = '?';\n\n    XMLStringifier.prototype.convertTextKey = '#text';\n\n    XMLStringifier.prototype.convertCDataKey = '#cdata';\n\n    XMLStringifier.prototype.convertCommentKey = '#comment';\n\n    XMLStringifier.prototype.convertRawKey = '#raw';\n\n    XMLStringifier.prototype.assertLegalChar = function(str) {\n      var regex, res;\n      if (this.options.noValidation) {\n        return str;\n      }\n      regex = '';\n      if (this.options.version === '1.0') {\n        regex = /[\\0-\\x08\\x0B\\f\\x0E-\\x1F\\uFFFE\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/;\n        if (res = str.match(regex)) {\n          throw new Error(\"Invalid character in string: \" + str + \" at index \" + res.index);\n        }\n      } else if (this.options.version === '1.1') {\n        regex = /[\\0\\uFFFE\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/;\n        if (res = str.match(regex)) {\n          throw new Error(\"Invalid character in string: \" + str + \" at index \" + res.index);\n        }\n      }\n      return str;\n    };\n\n    XMLStringifier.prototype.assertLegalName = function(str) {\n      var regex;\n      if (this.options.noValidation) {\n        return str;\n      }\n      this.assertLegalChar(str);\n      regex = /^([:A-Z_a-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]|[\\uD800-\\uDB7F][\\uDC00-\\uDFFF])([\\x2D\\.0-:A-Z_a-z\\xB7\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u037D\\u037F-\\u1FFF\\u200C\\u200D\\u203F\\u2040\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]|[\\uD800-\\uDB7F][\\uDC00-\\uDFFF])*$/;\n      if (!str.match(regex)) {\n        throw new Error(\"Invalid character in name\");\n      }\n      return str;\n    };\n\n    XMLStringifier.prototype.textEscape = function(str) {\n      var ampregex;\n      if (this.options.noValidation) {\n        return str;\n      }\n      ampregex = this.options.noDoubleEncoding ? /(?!&\\S+;)&/g : /&/g;\n      return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\\r/g, '&#xD;');\n    };\n\n    XMLStringifier.prototype.attEscape = function(str) {\n      var ampregex;\n      if (this.options.noValidation) {\n        return str;\n      }\n      ampregex = this.options.noDoubleEncoding ? /(?!&\\S+;)&/g : /&/g;\n      return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/\"/g, '&quot;').replace(/\\t/g, '&#x9;').replace(/\\n/g, '&#xA;').replace(/\\r/g, '&#xD;');\n    };\n\n    return XMLStringifier;\n\n  })();\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var XMLNamedNodeMap;\n\n  module.exports = XMLNamedNodeMap = (function() {\n    function XMLNamedNodeMap(nodes) {\n      this.nodes = nodes;\n    }\n\n    Object.defineProperty(XMLNamedNodeMap.prototype, 'length', {\n      get: function() {\n        return Object.keys(this.nodes).length || 0;\n      }\n    });\n\n    XMLNamedNodeMap.prototype.clone = function() {\n      return this.nodes = null;\n    };\n\n    XMLNamedNodeMap.prototype.getNamedItem = function(name) {\n      return this.nodes[name];\n    };\n\n    XMLNamedNodeMap.prototype.setNamedItem = function(node) {\n      var oldNode;\n      oldNode = this.nodes[node.nodeName];\n      this.nodes[node.nodeName] = node;\n      return oldNode || null;\n    };\n\n    XMLNamedNodeMap.prototype.removeNamedItem = function(name) {\n      var oldNode;\n      oldNode = this.nodes[name];\n      delete this.nodes[name];\n      return oldNode || null;\n    };\n\n    XMLNamedNodeMap.prototype.item = function(index) {\n      return this.nodes[Object.keys(this.nodes)[index]] || null;\n    };\n\n    XMLNamedNodeMap.prototype.getNamedItemNS = function(namespaceURI, localName) {\n      throw new Error(\"This DOM method is not implemented.\");\n    };\n\n    XMLNamedNodeMap.prototype.setNamedItemNS = function(node) {\n      throw new Error(\"This DOM method is not implemented.\");\n    };\n\n    XMLNamedNodeMap.prototype.removeNamedItemNS = function(namespaceURI, localName) {\n      throw new Error(\"This DOM method is not implemented.\");\n    };\n\n    return XMLNamedNodeMap;\n\n  })();\n\n}).call(this);\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}","(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","/* 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","// 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","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar decode_json_1 = __importDefault(require(\"./maps/decode.json\"));\n// Adapted from https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119\nvar fromCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\nString.fromCodePoint ||\n    function (codePoint) {\n        var output = \"\";\n        if (codePoint > 0xffff) {\n            codePoint -= 0x10000;\n            output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);\n            codePoint = 0xdc00 | (codePoint & 0x3ff);\n        }\n        output += String.fromCharCode(codePoint);\n        return output;\n    };\nfunction decodeCodePoint(codePoint) {\n    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {\n        return \"\\uFFFD\";\n    }\n    if (codePoint in decode_json_1.default) {\n        codePoint = decode_json_1.default[codePoint];\n    }\n    return fromCodePoint(codePoint);\n}\nexports.default = decodeCodePoint;\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, WriterState, XMLDOMImplementation, XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref;\n\n  ref = require('./Utility'), assign = ref.assign, isFunction = ref.isFunction;\n\n  XMLDOMImplementation = require('./XMLDOMImplementation');\n\n  XMLDocument = require('./XMLDocument');\n\n  XMLDocumentCB = require('./XMLDocumentCB');\n\n  XMLStringWriter = require('./XMLStringWriter');\n\n  XMLStreamWriter = require('./XMLStreamWriter');\n\n  NodeType = require('./NodeType');\n\n  WriterState = require('./WriterState');\n\n  module.exports.create = function(name, xmldec, doctype, options) {\n    var doc, root;\n    if (name == null) {\n      throw new Error(\"Root element needs a name.\");\n    }\n    options = assign({}, xmldec, doctype, options);\n    doc = new XMLDocument(options);\n    root = doc.element(name);\n    if (!options.headless) {\n      doc.declaration(options);\n      if ((options.pubID != null) || (options.sysID != null)) {\n        doc.dtd(options);\n      }\n    }\n    return root;\n  };\n\n  module.exports.begin = function(options, onData, onEnd) {\n    var ref1;\n    if (isFunction(options)) {\n      ref1 = [options, onData], onData = ref1[0], onEnd = ref1[1];\n      options = {};\n    }\n    if (onData) {\n      return new XMLDocumentCB(options, onData, onEnd);\n    } else {\n      return new XMLDocument(options);\n    }\n  };\n\n  module.exports.stringWriter = function(options) {\n    return new XMLStringWriter(options);\n  };\n\n  module.exports.streamWriter = function(stream, options) {\n    return new XMLStreamWriter(stream, options);\n  };\n\n  module.exports.implementation = new XMLDOMImplementation();\n\n  module.exports.nodeType = NodeType;\n\n  module.exports.writerState = WriterState;\n\n}).call(this);\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","// 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","var requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar quot = /\"/g;\n\n// B.2.3.2.1 CreateHTML(string, tag, attribute, value)\n// https://tc39.es/ecma262/#sec-createhtml\nmodule.exports = function (string, tag, attribute, value) {\n  var S = String(requireObjectCoercible(string));\n  var p1 = '<' + tag;\n  if (attribute !== '') p1 += ' ' + attribute + '=\"' + String(value).replace(quot, '&quot;') + '\"';\n  return p1 + '>' + S + '</' + tag + '>';\n};\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLCharacterData, XMLComment,\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  NodeType = require('./NodeType');\n\n  XMLCharacterData = require('./XMLCharacterData');\n\n  module.exports = XMLComment = (function(superClass) {\n    extend(XMLComment, superClass);\n\n    function XMLComment(parent, text) {\n      XMLComment.__super__.constructor.call(this, parent);\n      if (text == null) {\n        throw new Error(\"Missing comment text. \" + this.debugInfo());\n      }\n      this.name = \"#comment\";\n      this.type = NodeType.Comment;\n      this.value = this.stringify.comment(text);\n    }\n\n    XMLComment.prototype.clone = function() {\n      return Object.create(this);\n    };\n\n    XMLComment.prototype.toString = function(options) {\n      return this.options.writer.comment(this, this.options.writer.filterOptions(options));\n    };\n\n    return XMLComment;\n\n  })(XMLCharacterData);\n\n}).call(this);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decodeXMLStrict = exports.decodeHTML5Strict = exports.decodeHTML4Strict = exports.decodeHTML5 = exports.decodeHTML4 = exports.decodeHTMLStrict = exports.decodeHTML = exports.decodeXML = exports.encodeHTML5 = exports.encodeHTML4 = exports.escapeUTF8 = exports.escape = exports.encodeNonAsciiHTML = exports.encodeHTML = exports.encodeXML = exports.encode = exports.decodeStrict = exports.decode = void 0;\nvar decode_1 = require(\"./decode\");\nvar encode_1 = require(\"./encode\");\n/**\n * Decodes a string with entities.\n *\n * @param data String to decode.\n * @param level Optional level to decode at. 0 = XML, 1 = HTML. Default is 0.\n * @deprecated Use `decodeXML` or `decodeHTML` directly.\n */\nfunction decode(data, level) {\n    return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTML)(data);\n}\nexports.decode = decode;\n/**\n * Decodes a string with entities. Does not allow missing trailing semicolons for entities.\n *\n * @param data String to decode.\n * @param level Optional level to decode at. 0 = XML, 1 = HTML. Default is 0.\n * @deprecated Use `decodeHTMLStrict` or `decodeXML` directly.\n */\nfunction decodeStrict(data, level) {\n    return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTMLStrict)(data);\n}\nexports.decodeStrict = decodeStrict;\n/**\n * Encodes a string with entities.\n *\n * @param data String to encode.\n * @param level Optional level to encode at. 0 = XML, 1 = HTML. Default is 0.\n * @deprecated Use `encodeHTML`, `encodeXML` or `encodeNonAsciiHTML` directly.\n */\nfunction encode(data, level) {\n    return (!level || level <= 0 ? encode_1.encodeXML : encode_1.encodeHTML)(data);\n}\nexports.encode = encode;\nvar encode_2 = require(\"./encode\");\nObject.defineProperty(exports, \"encodeXML\", { enumerable: true, get: function () { return encode_2.encodeXML; } });\nObject.defineProperty(exports, \"encodeHTML\", { enumerable: true, get: function () { return encode_2.encodeHTML; } });\nObject.defineProperty(exports, \"encodeNonAsciiHTML\", { enumerable: true, get: function () { return encode_2.encodeNonAsciiHTML; } });\nObject.defineProperty(exports, \"escape\", { enumerable: true, get: function () { return encode_2.escape; } });\nObject.defineProperty(exports, \"escapeUTF8\", { enumerable: true, get: function () { return encode_2.escapeUTF8; } });\n// Legacy aliases (deprecated)\nObject.defineProperty(exports, \"encodeHTML4\", { enumerable: true, get: function () { return encode_2.encodeHTML; } });\nObject.defineProperty(exports, \"encodeHTML5\", { enumerable: true, get: function () { return encode_2.encodeHTML; } });\nvar decode_2 = require(\"./decode\");\nObject.defineProperty(exports, \"decodeXML\", { enumerable: true, get: function () { return decode_2.decodeXML; } });\nObject.defineProperty(exports, \"decodeHTML\", { enumerable: true, get: function () { return decode_2.decodeHTML; } });\nObject.defineProperty(exports, \"decodeHTMLStrict\", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });\n// Legacy aliases (deprecated)\nObject.defineProperty(exports, \"decodeHTML4\", { enumerable: true, get: function () { return decode_2.decodeHTML; } });\nObject.defineProperty(exports, \"decodeHTML5\", { enumerable: true, get: function () { return decode_2.decodeHTML; } });\nObject.defineProperty(exports, \"decodeHTML4Strict\", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });\nObject.defineProperty(exports, \"decodeHTML5Strict\", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });\nObject.defineProperty(exports, \"decodeXMLStrict\", { enumerable: true, get: function () { return decode_2.decodeXML; } });\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var XMLDOMConfiguration, XMLDOMErrorHandler, XMLDOMStringList;\n\n  XMLDOMErrorHandler = require('./XMLDOMErrorHandler');\n\n  XMLDOMStringList = require('./XMLDOMStringList');\n\n  module.exports = XMLDOMConfiguration = (function() {\n    function XMLDOMConfiguration() {\n      var clonedSelf;\n      this.defaultParams = {\n        \"canonical-form\": false,\n        \"cdata-sections\": false,\n        \"comments\": false,\n        \"datatype-normalization\": false,\n        \"element-content-whitespace\": true,\n        \"entities\": true,\n        \"error-handler\": new XMLDOMErrorHandler(),\n        \"infoset\": true,\n        \"validate-if-schema\": false,\n        \"namespaces\": true,\n        \"namespace-declarations\": true,\n        \"normalize-characters\": false,\n        \"schema-location\": '',\n        \"schema-type\": '',\n        \"split-cdata-sections\": true,\n        \"validate\": false,\n        \"well-formed\": true\n      };\n      this.params = clonedSelf = Object.create(this.defaultParams);\n    }\n\n    Object.defineProperty(XMLDOMConfiguration.prototype, 'parameterNames', {\n      get: function() {\n        return new XMLDOMStringList(Object.keys(this.defaultParams));\n      }\n    });\n\n    XMLDOMConfiguration.prototype.getParameter = function(name) {\n      if (this.params.hasOwnProperty(name)) {\n        return this.params[name];\n      } else {\n        return null;\n      }\n    };\n\n    XMLDOMConfiguration.prototype.canSetParameter = function(name, value) {\n      return true;\n    };\n\n    XMLDOMConfiguration.prototype.setParameter = function(name, value) {\n      if (value != null) {\n        return this.params[name] = value;\n      } else {\n        return delete this.params[name];\n      }\n    };\n\n    return XMLDOMConfiguration;\n\n  })();\n\n}).call(this);\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'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","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","// Generated by CoffeeScript 1.12.7\n(function() {\n  var DocumentPosition, NodeType, XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLNamedNodeMap, XMLNode, XMLNodeList, XMLProcessingInstruction, XMLRaw, XMLText, getValue, isEmpty, isFunction, isObject, ref1,\n    hasProp = {}.hasOwnProperty;\n\n  ref1 = require('./Utility'), isObject = ref1.isObject, isFunction = ref1.isFunction, isEmpty = ref1.isEmpty, getValue = ref1.getValue;\n\n  XMLElement = null;\n\n  XMLCData = null;\n\n  XMLComment = null;\n\n  XMLDeclaration = null;\n\n  XMLDocType = null;\n\n  XMLRaw = null;\n\n  XMLText = null;\n\n  XMLProcessingInstruction = null;\n\n  XMLDummy = null;\n\n  NodeType = null;\n\n  XMLNodeList = null;\n\n  XMLNamedNodeMap = null;\n\n  DocumentPosition = null;\n\n  module.exports = XMLNode = (function() {\n    function XMLNode(parent1) {\n      this.parent = parent1;\n      if (this.parent) {\n        this.options = this.parent.options;\n        this.stringify = this.parent.stringify;\n      }\n      this.value = null;\n      this.children = [];\n      this.baseURI = null;\n      if (!XMLElement) {\n        XMLElement = require('./XMLElement');\n        XMLCData = require('./XMLCData');\n        XMLComment = require('./XMLComment');\n        XMLDeclaration = require('./XMLDeclaration');\n        XMLDocType = require('./XMLDocType');\n        XMLRaw = require('./XMLRaw');\n        XMLText = require('./XMLText');\n        XMLProcessingInstruction = require('./XMLProcessingInstruction');\n        XMLDummy = require('./XMLDummy');\n        NodeType = require('./NodeType');\n        XMLNodeList = require('./XMLNodeList');\n        XMLNamedNodeMap = require('./XMLNamedNodeMap');\n        DocumentPosition = require('./DocumentPosition');\n      }\n    }\n\n    Object.defineProperty(XMLNode.prototype, 'nodeName', {\n      get: function() {\n        return this.name;\n      }\n    });\n\n    Object.defineProperty(XMLNode.prototype, 'nodeType', {\n      get: function() {\n        return this.type;\n      }\n    });\n\n    Object.defineProperty(XMLNode.prototype, 'nodeValue', {\n      get: function() {\n        return this.value;\n      }\n    });\n\n    Object.defineProperty(XMLNode.prototype, 'parentNode', {\n      get: function() {\n        return this.parent;\n      }\n    });\n\n    Object.defineProperty(XMLNode.prototype, 'childNodes', {\n      get: function() {\n        if (!this.childNodeList || !this.childNodeList.nodes) {\n          this.childNodeList = new XMLNodeList(this.children);\n        }\n        return this.childNodeList;\n      }\n    });\n\n    Object.defineProperty(XMLNode.prototype, 'firstChild', {\n      get: function() {\n        return this.children[0] || null;\n      }\n    });\n\n    Object.defineProperty(XMLNode.prototype, 'lastChild', {\n      get: function() {\n        return this.children[this.children.length - 1] || null;\n      }\n    });\n\n    Object.defineProperty(XMLNode.prototype, 'previousSibling', {\n      get: function() {\n        var i;\n        i = this.parent.children.indexOf(this);\n        return this.parent.children[i - 1] || null;\n      }\n    });\n\n    Object.defineProperty(XMLNode.prototype, 'nextSibling', {\n      get: function() {\n        var i;\n        i = this.parent.children.indexOf(this);\n        return this.parent.children[i + 1] || null;\n      }\n    });\n\n    Object.defineProperty(XMLNode.prototype, 'ownerDocument', {\n      get: function() {\n        return this.document() || null;\n      }\n    });\n\n    Object.defineProperty(XMLNode.prototype, 'textContent', {\n      get: function() {\n        var child, j, len, ref2, str;\n        if (this.nodeType === NodeType.Element || this.nodeType === NodeType.DocumentFragment) {\n          str = '';\n          ref2 = this.children;\n          for (j = 0, len = ref2.length; j < len; j++) {\n            child = ref2[j];\n            if (child.textContent) {\n              str += child.textContent;\n            }\n          }\n          return str;\n        } else {\n          return null;\n        }\n      },\n      set: function(value) {\n        throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n      }\n    });\n\n    XMLNode.prototype.setParent = function(parent) {\n      var child, j, len, ref2, results;\n      this.parent = parent;\n      if (parent) {\n        this.options = parent.options;\n        this.stringify = parent.stringify;\n      }\n      ref2 = this.children;\n      results = [];\n      for (j = 0, len = ref2.length; j < len; j++) {\n        child = ref2[j];\n        results.push(child.setParent(this));\n      }\n      return results;\n    };\n\n    XMLNode.prototype.element = function(name, attributes, text) {\n      var childNode, item, j, k, key, lastChild, len, len1, ref2, ref3, val;\n      lastChild = null;\n      if (attributes === null && (text == null)) {\n        ref2 = [{}, null], attributes = ref2[0], text = ref2[1];\n      }\n      if (attributes == null) {\n        attributes = {};\n      }\n      attributes = getValue(attributes);\n      if (!isObject(attributes)) {\n        ref3 = [attributes, text], text = ref3[0], attributes = ref3[1];\n      }\n      if (name != null) {\n        name = getValue(name);\n      }\n      if (Array.isArray(name)) {\n        for (j = 0, len = name.length; j < len; j++) {\n          item = name[j];\n          lastChild = this.element(item);\n        }\n      } else if (isFunction(name)) {\n        lastChild = this.element(name.apply());\n      } else if (isObject(name)) {\n        for (key in name) {\n          if (!hasProp.call(name, key)) continue;\n          val = name[key];\n          if (isFunction(val)) {\n            val = val.apply();\n          }\n          if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) {\n            lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val);\n          } else if (!this.options.separateArrayItems && Array.isArray(val) && isEmpty(val)) {\n            lastChild = this.dummy();\n          } else if (isObject(val) && isEmpty(val)) {\n            lastChild = this.element(key);\n          } else if (!this.options.keepNullNodes && (val == null)) {\n            lastChild = this.dummy();\n          } else if (!this.options.separateArrayItems && Array.isArray(val)) {\n            for (k = 0, len1 = val.length; k < len1; k++) {\n              item = val[k];\n              childNode = {};\n              childNode[key] = item;\n              lastChild = this.element(childNode);\n            }\n          } else if (isObject(val)) {\n            if (!this.options.ignoreDecorators && this.stringify.convertTextKey && key.indexOf(this.stringify.convertTextKey) === 0) {\n              lastChild = this.element(val);\n            } else {\n              lastChild = this.element(key);\n              lastChild.element(val);\n            }\n          } else {\n            lastChild = this.element(key, val);\n          }\n        }\n      } else if (!this.options.keepNullNodes && text === null) {\n        lastChild = this.dummy();\n      } else {\n        if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) {\n          lastChild = this.text(text);\n        } else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) {\n          lastChild = this.cdata(text);\n        } else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) {\n          lastChild = this.comment(text);\n        } else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) {\n          lastChild = this.raw(text);\n        } else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && name.indexOf(this.stringify.convertPIKey) === 0) {\n          lastChild = this.instruction(name.substr(this.stringify.convertPIKey.length), text);\n        } else {\n          lastChild = this.node(name, attributes, text);\n        }\n      }\n      if (lastChild == null) {\n        throw new Error(\"Could not create any elements with: \" + name + \". \" + this.debugInfo());\n      }\n      return lastChild;\n    };\n\n    XMLNode.prototype.insertBefore = function(name, attributes, text) {\n      var child, i, newChild, refChild, removed;\n      if (name != null ? name.type : void 0) {\n        newChild = name;\n        refChild = attributes;\n        newChild.setParent(this);\n        if (refChild) {\n          i = children.indexOf(refChild);\n          removed = children.splice(i);\n          children.push(newChild);\n          Array.prototype.push.apply(children, removed);\n        } else {\n          children.push(newChild);\n        }\n        return newChild;\n      } else {\n        if (this.isRoot) {\n          throw new Error(\"Cannot insert elements at root level. \" + this.debugInfo(name));\n        }\n        i = this.parent.children.indexOf(this);\n        removed = this.parent.children.splice(i);\n        child = this.parent.element(name, attributes, text);\n        Array.prototype.push.apply(this.parent.children, removed);\n        return child;\n      }\n    };\n\n    XMLNode.prototype.insertAfter = function(name, attributes, text) {\n      var child, i, removed;\n      if (this.isRoot) {\n        throw new Error(\"Cannot insert elements at root level. \" + this.debugInfo(name));\n      }\n      i = this.parent.children.indexOf(this);\n      removed = this.parent.children.splice(i + 1);\n      child = this.parent.element(name, attributes, text);\n      Array.prototype.push.apply(this.parent.children, removed);\n      return child;\n    };\n\n    XMLNode.prototype.remove = function() {\n      var i, ref2;\n      if (this.isRoot) {\n        throw new Error(\"Cannot remove the root element. \" + this.debugInfo());\n      }\n      i = this.parent.children.indexOf(this);\n      [].splice.apply(this.parent.children, [i, i - i + 1].concat(ref2 = [])), ref2;\n      return this.parent;\n    };\n\n    XMLNode.prototype.node = function(name, attributes, text) {\n      var child, ref2;\n      if (name != null) {\n        name = getValue(name);\n      }\n      attributes || (attributes = {});\n      attributes = getValue(attributes);\n      if (!isObject(attributes)) {\n        ref2 = [attributes, text], text = ref2[0], attributes = ref2[1];\n      }\n      child = new XMLElement(this, name, attributes);\n      if (text != null) {\n        child.text(text);\n      }\n      this.children.push(child);\n      return child;\n    };\n\n    XMLNode.prototype.text = function(value) {\n      var child;\n      if (isObject(value)) {\n        this.element(value);\n      }\n      child = new XMLText(this, value);\n      this.children.push(child);\n      return this;\n    };\n\n    XMLNode.prototype.cdata = function(value) {\n      var child;\n      child = new XMLCData(this, value);\n      this.children.push(child);\n      return this;\n    };\n\n    XMLNode.prototype.comment = function(value) {\n      var child;\n      child = new XMLComment(this, value);\n      this.children.push(child);\n      return this;\n    };\n\n    XMLNode.prototype.commentBefore = function(value) {\n      var child, i, removed;\n      i = this.parent.children.indexOf(this);\n      removed = this.parent.children.splice(i);\n      child = this.parent.comment(value);\n      Array.prototype.push.apply(this.parent.children, removed);\n      return this;\n    };\n\n    XMLNode.prototype.commentAfter = function(value) {\n      var child, i, removed;\n      i = this.parent.children.indexOf(this);\n      removed = this.parent.children.splice(i + 1);\n      child = this.parent.comment(value);\n      Array.prototype.push.apply(this.parent.children, removed);\n      return this;\n    };\n\n    XMLNode.prototype.raw = function(value) {\n      var child;\n      child = new XMLRaw(this, value);\n      this.children.push(child);\n      return this;\n    };\n\n    XMLNode.prototype.dummy = function() {\n      var child;\n      child = new XMLDummy(this);\n      return child;\n    };\n\n    XMLNode.prototype.instruction = function(target, value) {\n      var insTarget, insValue, instruction, j, len;\n      if (target != null) {\n        target = getValue(target);\n      }\n      if (value != null) {\n        value = getValue(value);\n      }\n      if (Array.isArray(target)) {\n        for (j = 0, len = target.length; j < len; j++) {\n          insTarget = target[j];\n          this.instruction(insTarget);\n        }\n      } else if (isObject(target)) {\n        for (insTarget in target) {\n          if (!hasProp.call(target, insTarget)) continue;\n          insValue = target[insTarget];\n          this.instruction(insTarget, insValue);\n        }\n      } else {\n        if (isFunction(value)) {\n          value = value.apply();\n        }\n        instruction = new XMLProcessingInstruction(this, target, value);\n        this.children.push(instruction);\n      }\n      return this;\n    };\n\n    XMLNode.prototype.instructionBefore = function(target, value) {\n      var child, i, removed;\n      i = this.parent.children.indexOf(this);\n      removed = this.parent.children.splice(i);\n      child = this.parent.instruction(target, value);\n      Array.prototype.push.apply(this.parent.children, removed);\n      return this;\n    };\n\n    XMLNode.prototype.instructionAfter = function(target, value) {\n      var child, i, removed;\n      i = this.parent.children.indexOf(this);\n      removed = this.parent.children.splice(i + 1);\n      child = this.parent.instruction(target, value);\n      Array.prototype.push.apply(this.parent.children, removed);\n      return this;\n    };\n\n    XMLNode.prototype.declaration = function(version, encoding, standalone) {\n      var doc, xmldec;\n      doc = this.document();\n      xmldec = new XMLDeclaration(doc, version, encoding, standalone);\n      if (doc.children.length === 0) {\n        doc.children.unshift(xmldec);\n      } else if (doc.children[0].type === NodeType.Declaration) {\n        doc.children[0] = xmldec;\n      } else {\n        doc.children.unshift(xmldec);\n      }\n      return doc.root() || doc;\n    };\n\n    XMLNode.prototype.dtd = function(pubID, sysID) {\n      var child, doc, doctype, i, j, k, len, len1, ref2, ref3;\n      doc = this.document();\n      doctype = new XMLDocType(doc, pubID, sysID);\n      ref2 = doc.children;\n      for (i = j = 0, len = ref2.length; j < len; i = ++j) {\n        child = ref2[i];\n        if (child.type === NodeType.DocType) {\n          doc.children[i] = doctype;\n          return doctype;\n        }\n      }\n      ref3 = doc.children;\n      for (i = k = 0, len1 = ref3.length; k < len1; i = ++k) {\n        child = ref3[i];\n        if (child.isRoot) {\n          doc.children.splice(i, 0, doctype);\n          return doctype;\n        }\n      }\n      doc.children.push(doctype);\n      return doctype;\n    };\n\n    XMLNode.prototype.up = function() {\n      if (this.isRoot) {\n        throw new Error(\"The root node has no parent. Use doc() if you need to get the document object.\");\n      }\n      return this.parent;\n    };\n\n    XMLNode.prototype.root = function() {\n      var node;\n      node = this;\n      while (node) {\n        if (node.type === NodeType.Document) {\n          return node.rootObject;\n        } else if (node.isRoot) {\n          return node;\n        } else {\n          node = node.parent;\n        }\n      }\n    };\n\n    XMLNode.prototype.document = function() {\n      var node;\n      node = this;\n      while (node) {\n        if (node.type === NodeType.Document) {\n          return node;\n        } else {\n          node = node.parent;\n        }\n      }\n    };\n\n    XMLNode.prototype.end = function(options) {\n      return this.document().end(options);\n    };\n\n    XMLNode.prototype.prev = function() {\n      var i;\n      i = this.parent.children.indexOf(this);\n      if (i < 1) {\n        throw new Error(\"Already at the first node. \" + this.debugInfo());\n      }\n      return this.parent.children[i - 1];\n    };\n\n    XMLNode.prototype.next = function() {\n      var i;\n      i = this.parent.children.indexOf(this);\n      if (i === -1 || i === this.parent.children.length - 1) {\n        throw new Error(\"Already at the last node. \" + this.debugInfo());\n      }\n      return this.parent.children[i + 1];\n    };\n\n    XMLNode.prototype.importDocument = function(doc) {\n      var clonedRoot;\n      clonedRoot = doc.root().clone();\n      clonedRoot.parent = this;\n      clonedRoot.isRoot = false;\n      this.children.push(clonedRoot);\n      return this;\n    };\n\n    XMLNode.prototype.debugInfo = function(name) {\n      var ref2, ref3;\n      name = name || this.name;\n      if ((name == null) && !((ref2 = this.parent) != null ? ref2.name : void 0)) {\n        return \"\";\n      } else if (name == null) {\n        return \"parent: <\" + this.parent.name + \">\";\n      } else if (!((ref3 = this.parent) != null ? ref3.name : void 0)) {\n        return \"node: <\" + name + \">\";\n      } else {\n        return \"node: <\" + name + \">, parent: <\" + this.parent.name + \">\";\n      }\n    };\n\n    XMLNode.prototype.ele = function(name, attributes, text) {\n      return this.element(name, attributes, text);\n    };\n\n    XMLNode.prototype.nod = function(name, attributes, text) {\n      return this.node(name, attributes, text);\n    };\n\n    XMLNode.prototype.txt = function(value) {\n      return this.text(value);\n    };\n\n    XMLNode.prototype.dat = function(value) {\n      return this.cdata(value);\n    };\n\n    XMLNode.prototype.com = function(value) {\n      return this.comment(value);\n    };\n\n    XMLNode.prototype.ins = function(target, value) {\n      return this.instruction(target, value);\n    };\n\n    XMLNode.prototype.doc = function() {\n      return this.document();\n    };\n\n    XMLNode.prototype.dec = function(version, encoding, standalone) {\n      return this.declaration(version, encoding, standalone);\n    };\n\n    XMLNode.prototype.e = function(name, attributes, text) {\n      return this.element(name, attributes, text);\n    };\n\n    XMLNode.prototype.n = function(name, attributes, text) {\n      return this.node(name, attributes, text);\n    };\n\n    XMLNode.prototype.t = function(value) {\n      return this.text(value);\n    };\n\n    XMLNode.prototype.d = function(value) {\n      return this.cdata(value);\n    };\n\n    XMLNode.prototype.c = function(value) {\n      return this.comment(value);\n    };\n\n    XMLNode.prototype.r = function(value) {\n      return this.raw(value);\n    };\n\n    XMLNode.prototype.i = function(target, value) {\n      return this.instruction(target, value);\n    };\n\n    XMLNode.prototype.u = function() {\n      return this.up();\n    };\n\n    XMLNode.prototype.importXMLBuilder = function(doc) {\n      return this.importDocument(doc);\n    };\n\n    XMLNode.prototype.replaceChild = function(newChild, oldChild) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.removeChild = function(oldChild) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.appendChild = function(newChild) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.hasChildNodes = function() {\n      return this.children.length !== 0;\n    };\n\n    XMLNode.prototype.cloneNode = function(deep) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.normalize = function() {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.isSupported = function(feature, version) {\n      return true;\n    };\n\n    XMLNode.prototype.hasAttributes = function() {\n      return this.attribs.length !== 0;\n    };\n\n    XMLNode.prototype.compareDocumentPosition = function(other) {\n      var ref, res;\n      ref = this;\n      if (ref === other) {\n        return 0;\n      } else if (this.document() !== other.document()) {\n        res = DocumentPosition.Disconnected | DocumentPosition.ImplementationSpecific;\n        if (Math.random() < 0.5) {\n          res |= DocumentPosition.Preceding;\n        } else {\n          res |= DocumentPosition.Following;\n        }\n        return res;\n      } else if (ref.isAncestor(other)) {\n        return DocumentPosition.Contains | DocumentPosition.Preceding;\n      } else if (ref.isDescendant(other)) {\n        return DocumentPosition.Contains | DocumentPosition.Following;\n      } else if (ref.isPreceding(other)) {\n        return DocumentPosition.Preceding;\n      } else {\n        return DocumentPosition.Following;\n      }\n    };\n\n    XMLNode.prototype.isSameNode = function(other) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.lookupPrefix = function(namespaceURI) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.isDefaultNamespace = function(namespaceURI) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.lookupNamespaceURI = function(prefix) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.isEqualNode = function(node) {\n      var i, j, ref2;\n      if (node.nodeType !== this.nodeType) {\n        return false;\n      }\n      if (node.children.length !== this.children.length) {\n        return false;\n      }\n      for (i = j = 0, ref2 = this.children.length - 1; 0 <= ref2 ? j <= ref2 : j >= ref2; i = 0 <= ref2 ? ++j : --j) {\n        if (!this.children[i].isEqualNode(node.children[i])) {\n          return false;\n        }\n      }\n      return true;\n    };\n\n    XMLNode.prototype.getFeature = function(feature, version) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.setUserData = function(key, data, handler) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.getUserData = function(key) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLNode.prototype.contains = function(other) {\n      if (!other) {\n        return false;\n      }\n      return other === this || this.isDescendant(other);\n    };\n\n    XMLNode.prototype.isDescendant = function(node) {\n      var child, isDescendantChild, j, len, ref2;\n      ref2 = this.children;\n      for (j = 0, len = ref2.length; j < len; j++) {\n        child = ref2[j];\n        if (node === child) {\n          return true;\n        }\n        isDescendantChild = child.isDescendant(node);\n        if (isDescendantChild) {\n          return true;\n        }\n      }\n      return false;\n    };\n\n    XMLNode.prototype.isAncestor = function(node) {\n      return node.isDescendant(this);\n    };\n\n    XMLNode.prototype.isPreceding = function(node) {\n      var nodePos, thisPos;\n      nodePos = this.treePosition(node);\n      thisPos = this.treePosition(this);\n      if (nodePos === -1 || thisPos === -1) {\n        return false;\n      } else {\n        return nodePos < thisPos;\n      }\n    };\n\n    XMLNode.prototype.isFollowing = function(node) {\n      var nodePos, thisPos;\n      nodePos = this.treePosition(node);\n      thisPos = this.treePosition(this);\n      if (nodePos === -1 || thisPos === -1) {\n        return false;\n      } else {\n        return nodePos > thisPos;\n      }\n    };\n\n    XMLNode.prototype.treePosition = function(node) {\n      var found, pos;\n      pos = 0;\n      found = false;\n      this.foreachTreeNode(this.document(), function(childNode) {\n        pos++;\n        if (!found && childNode === node) {\n          return found = true;\n        }\n      });\n      if (found) {\n        return pos;\n      } else {\n        return -1;\n      }\n    };\n\n    XMLNode.prototype.foreachTreeNode = function(node, func) {\n      var child, j, len, ref2, res;\n      node || (node = this.document());\n      ref2 = node.children;\n      for (j = 0, len = ref2.length; j < len; j++) {\n        child = ref2[j];\n        if (res = func(child)) {\n          return res;\n        } else {\n          res = this.foreachTreeNode(child, func);\n          if (res) {\n            return res;\n          }\n        }\n      }\n    };\n\n    return XMLNode;\n\n  })();\n\n}).call(this);\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]","'use strict';\n\nif (typeof process === 'undefined' ||\n    !process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = { nextTick: nextTick };\n} else {\n  module.exports = process\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n","'use strict';\nvar $ = require('../internals/export');\nvar createHTML = require('../internals/create-html');\nvar forcedStringHTMLMethod = require('../internals/string-html-forced');\n\n// `String.prototype.link` method\n// https://tc39.es/ecma262/#sec-string.prototype.link\n$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('link') }, {\n  link: function link(url) {\n    return createHTML(this, 'a', 'href', url);\n  }\n});\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLCharacterData, XMLText,\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  NodeType = require('./NodeType');\n\n  XMLCharacterData = require('./XMLCharacterData');\n\n  module.exports = XMLText = (function(superClass) {\n    extend(XMLText, superClass);\n\n    function XMLText(parent, text) {\n      XMLText.__super__.constructor.call(this, parent);\n      if (text == null) {\n        throw new Error(\"Missing element text. \" + this.debugInfo());\n      }\n      this.name = \"#text\";\n      this.type = NodeType.Text;\n      this.value = this.stringify.text(text);\n    }\n\n    Object.defineProperty(XMLText.prototype, 'isElementContentWhitespace', {\n      get: function() {\n        throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n      }\n    });\n\n    Object.defineProperty(XMLText.prototype, 'wholeText', {\n      get: function() {\n        var next, prev, str;\n        str = '';\n        prev = this.previousSibling;\n        while (prev) {\n          str = prev.data + str;\n          prev = prev.previousSibling;\n        }\n        str += this.data;\n        next = this.nextSibling;\n        while (next) {\n          str = str + next.data;\n          next = next.nextSibling;\n        }\n        return str;\n      }\n    });\n\n    XMLText.prototype.clone = function() {\n      return Object.create(this);\n    };\n\n    XMLText.prototype.toString = function(options) {\n      return this.options.writer.text(this, this.options.writer.filterOptions(options));\n    };\n\n    XMLText.prototype.splitText = function(offset) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLText.prototype.replaceWholeText = function(content) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    return XMLText;\n\n  })(XMLCharacterData);\n\n}).call(this);\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var XMLDOMErrorHandler;\n\n  module.exports = XMLDOMErrorHandler = (function() {\n    function XMLDOMErrorHandler() {}\n\n    XMLDOMErrorHandler.prototype.handleError = function(error) {\n      throw new Error(error);\n    };\n\n    return XMLDOMErrorHandler;\n\n  })();\n\n}).call(this);\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decodeHTML = exports.decodeHTMLStrict = exports.decodeXML = void 0;\nvar entities_json_1 = __importDefault(require(\"./maps/entities.json\"));\nvar legacy_json_1 = __importDefault(require(\"./maps/legacy.json\"));\nvar xml_json_1 = __importDefault(require(\"./maps/xml.json\"));\nvar decode_codepoint_1 = __importDefault(require(\"./decode_codepoint\"));\nvar strictEntityRe = /&(?:[a-zA-Z0-9]+|#[xX][\\da-fA-F]+|#\\d+);/g;\nexports.decodeXML = getStrictDecoder(xml_json_1.default);\nexports.decodeHTMLStrict = getStrictDecoder(entities_json_1.default);\nfunction getStrictDecoder(map) {\n    var replace = getReplacer(map);\n    return function (str) { return String(str).replace(strictEntityRe, replace); };\n}\nvar sorter = function (a, b) { return (a < b ? 1 : -1); };\nexports.decodeHTML = (function () {\n    var legacy = Object.keys(legacy_json_1.default).sort(sorter);\n    var keys = Object.keys(entities_json_1.default).sort(sorter);\n    for (var i = 0, j = 0; i < keys.length; i++) {\n        if (legacy[j] === keys[i]) {\n            keys[i] += \";?\";\n            j++;\n        }\n        else {\n            keys[i] += \";\";\n        }\n    }\n    var re = new RegExp(\"&(?:\" + keys.join(\"|\") + \"|#[xX][\\\\da-fA-F]+;?|#\\\\d+;?)\", \"g\");\n    var replace = getReplacer(entities_json_1.default);\n    function replacer(str) {\n        if (str.substr(-1) !== \";\")\n            str += \";\";\n        return replace(str);\n    }\n    // TODO consider creating a merged map\n    return function (str) { return String(str).replace(re, replacer); };\n})();\nfunction getReplacer(map) {\n    return function replace(str) {\n        if (str.charAt(1) === \"#\") {\n            var secondChar = str.charAt(2);\n            if (secondChar === \"X\" || secondChar === \"x\") {\n                return decode_codepoint_1.default(parseInt(str.substr(3), 16));\n            }\n            return decode_codepoint_1.default(parseInt(str.substr(2), 10));\n        }\n        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n        return map[str.slice(1, -1)] || str;\n    };\n}\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, WriterState, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLText, XMLWriterBase, assign,\n    hasProp = {}.hasOwnProperty;\n\n  assign = require('./Utility').assign;\n\n  NodeType = require('./NodeType');\n\n  XMLDeclaration = require('./XMLDeclaration');\n\n  XMLDocType = require('./XMLDocType');\n\n  XMLCData = require('./XMLCData');\n\n  XMLComment = require('./XMLComment');\n\n  XMLElement = require('./XMLElement');\n\n  XMLRaw = require('./XMLRaw');\n\n  XMLText = require('./XMLText');\n\n  XMLProcessingInstruction = require('./XMLProcessingInstruction');\n\n  XMLDummy = require('./XMLDummy');\n\n  XMLDTDAttList = require('./XMLDTDAttList');\n\n  XMLDTDElement = require('./XMLDTDElement');\n\n  XMLDTDEntity = require('./XMLDTDEntity');\n\n  XMLDTDNotation = require('./XMLDTDNotation');\n\n  WriterState = require('./WriterState');\n\n  module.exports = XMLWriterBase = (function() {\n    function XMLWriterBase(options) {\n      var key, ref, value;\n      options || (options = {});\n      this.options = options;\n      ref = options.writer || {};\n      for (key in ref) {\n        if (!hasProp.call(ref, key)) continue;\n        value = ref[key];\n        this[\"_\" + key] = this[key];\n        this[key] = value;\n      }\n    }\n\n    XMLWriterBase.prototype.filterOptions = function(options) {\n      var filteredOptions, ref, ref1, ref2, ref3, ref4, ref5, ref6;\n      options || (options = {});\n      options = assign({}, this.options, options);\n      filteredOptions = {\n        writer: this\n      };\n      filteredOptions.pretty = options.pretty || false;\n      filteredOptions.allowEmpty = options.allowEmpty || false;\n      filteredOptions.indent = (ref = options.indent) != null ? ref : '  ';\n      filteredOptions.newline = (ref1 = options.newline) != null ? ref1 : '\\n';\n      filteredOptions.offset = (ref2 = options.offset) != null ? ref2 : 0;\n      filteredOptions.dontPrettyTextNodes = (ref3 = (ref4 = options.dontPrettyTextNodes) != null ? ref4 : options.dontprettytextnodes) != null ? ref3 : 0;\n      filteredOptions.spaceBeforeSlash = (ref5 = (ref6 = options.spaceBeforeSlash) != null ? ref6 : options.spacebeforeslash) != null ? ref5 : '';\n      if (filteredOptions.spaceBeforeSlash === true) {\n        filteredOptions.spaceBeforeSlash = ' ';\n      }\n      filteredOptions.suppressPrettyCount = 0;\n      filteredOptions.user = {};\n      filteredOptions.state = WriterState.None;\n      return filteredOptions;\n    };\n\n    XMLWriterBase.prototype.indent = function(node, options, level) {\n      var indentLevel;\n      if (!options.pretty || options.suppressPrettyCount) {\n        return '';\n      } else if (options.pretty) {\n        indentLevel = (level || 0) + options.offset + 1;\n        if (indentLevel > 0) {\n          return new Array(indentLevel).join(options.indent);\n        }\n      }\n      return '';\n    };\n\n    XMLWriterBase.prototype.endline = function(node, options, level) {\n      if (!options.pretty || options.suppressPrettyCount) {\n        return '';\n      } else {\n        return options.newline;\n      }\n    };\n\n    XMLWriterBase.prototype.attribute = function(att, options, level) {\n      var r;\n      this.openAttribute(att, options, level);\n      r = ' ' + att.name + '=\"' + att.value + '\"';\n      this.closeAttribute(att, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.cdata = function(node, options, level) {\n      var r;\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r = this.indent(node, options, level) + '<![CDATA[';\n      options.state = WriterState.InsideTag;\n      r += node.value;\n      options.state = WriterState.CloseTag;\n      r += ']]>' + this.endline(node, options, level);\n      options.state = WriterState.None;\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.comment = function(node, options, level) {\n      var r;\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r = this.indent(node, options, level) + '<!-- ';\n      options.state = WriterState.InsideTag;\n      r += node.value;\n      options.state = WriterState.CloseTag;\n      r += ' -->' + this.endline(node, options, level);\n      options.state = WriterState.None;\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.declaration = function(node, options, level) {\n      var r;\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r = this.indent(node, options, level) + '<?xml';\n      options.state = WriterState.InsideTag;\n      r += ' version=\"' + node.version + '\"';\n      if (node.encoding != null) {\n        r += ' encoding=\"' + node.encoding + '\"';\n      }\n      if (node.standalone != null) {\n        r += ' standalone=\"' + node.standalone + '\"';\n      }\n      options.state = WriterState.CloseTag;\n      r += options.spaceBeforeSlash + '?>';\n      r += this.endline(node, options, level);\n      options.state = WriterState.None;\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.docType = function(node, options, level) {\n      var child, i, len, r, ref;\n      level || (level = 0);\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r = this.indent(node, options, level);\n      r += '<!DOCTYPE ' + node.root().name;\n      if (node.pubID && node.sysID) {\n        r += ' PUBLIC \"' + node.pubID + '\" \"' + node.sysID + '\"';\n      } else if (node.sysID) {\n        r += ' SYSTEM \"' + node.sysID + '\"';\n      }\n      if (node.children.length > 0) {\n        r += ' [';\n        r += this.endline(node, options, level);\n        options.state = WriterState.InsideTag;\n        ref = node.children;\n        for (i = 0, len = ref.length; i < len; i++) {\n          child = ref[i];\n          r += this.writeChildNode(child, options, level + 1);\n        }\n        options.state = WriterState.CloseTag;\n        r += ']';\n      }\n      options.state = WriterState.CloseTag;\n      r += options.spaceBeforeSlash + '>';\n      r += this.endline(node, options, level);\n      options.state = WriterState.None;\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.element = function(node, options, level) {\n      var att, child, childNodeCount, firstChildNode, i, j, len, len1, name, prettySuppressed, r, ref, ref1, ref2;\n      level || (level = 0);\n      prettySuppressed = false;\n      r = '';\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r += this.indent(node, options, level) + '<' + node.name;\n      ref = node.attribs;\n      for (name in ref) {\n        if (!hasProp.call(ref, name)) continue;\n        att = ref[name];\n        r += this.attribute(att, options, level);\n      }\n      childNodeCount = node.children.length;\n      firstChildNode = childNodeCount === 0 ? null : node.children[0];\n      if (childNodeCount === 0 || node.children.every(function(e) {\n        return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === '';\n      })) {\n        if (options.allowEmpty) {\n          r += '>';\n          options.state = WriterState.CloseTag;\n          r += '</' + node.name + '>' + this.endline(node, options, level);\n        } else {\n          options.state = WriterState.CloseTag;\n          r += options.spaceBeforeSlash + '/>' + this.endline(node, options, level);\n        }\n      } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && (firstChildNode.value != null)) {\n        r += '>';\n        options.state = WriterState.InsideTag;\n        options.suppressPrettyCount++;\n        prettySuppressed = true;\n        r += this.writeChildNode(firstChildNode, options, level + 1);\n        options.suppressPrettyCount--;\n        prettySuppressed = false;\n        options.state = WriterState.CloseTag;\n        r += '</' + node.name + '>' + this.endline(node, options, level);\n      } else {\n        if (options.dontPrettyTextNodes) {\n          ref1 = node.children;\n          for (i = 0, len = ref1.length; i < len; i++) {\n            child = ref1[i];\n            if ((child.type === NodeType.Text || child.type === NodeType.Raw) && (child.value != null)) {\n              options.suppressPrettyCount++;\n              prettySuppressed = true;\n              break;\n            }\n          }\n        }\n        r += '>' + this.endline(node, options, level);\n        options.state = WriterState.InsideTag;\n        ref2 = node.children;\n        for (j = 0, len1 = ref2.length; j < len1; j++) {\n          child = ref2[j];\n          r += this.writeChildNode(child, options, level + 1);\n        }\n        options.state = WriterState.CloseTag;\n        r += this.indent(node, options, level) + '</' + node.name + '>';\n        if (prettySuppressed) {\n          options.suppressPrettyCount--;\n        }\n        r += this.endline(node, options, level);\n        options.state = WriterState.None;\n      }\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.writeChildNode = function(node, options, level) {\n      switch (node.type) {\n        case NodeType.CData:\n          return this.cdata(node, options, level);\n        case NodeType.Comment:\n          return this.comment(node, options, level);\n        case NodeType.Element:\n          return this.element(node, options, level);\n        case NodeType.Raw:\n          return this.raw(node, options, level);\n        case NodeType.Text:\n          return this.text(node, options, level);\n        case NodeType.ProcessingInstruction:\n          return this.processingInstruction(node, options, level);\n        case NodeType.Dummy:\n          return '';\n        case NodeType.Declaration:\n          return this.declaration(node, options, level);\n        case NodeType.DocType:\n          return this.docType(node, options, level);\n        case NodeType.AttributeDeclaration:\n          return this.dtdAttList(node, options, level);\n        case NodeType.ElementDeclaration:\n          return this.dtdElement(node, options, level);\n        case NodeType.EntityDeclaration:\n          return this.dtdEntity(node, options, level);\n        case NodeType.NotationDeclaration:\n          return this.dtdNotation(node, options, level);\n        default:\n          throw new Error(\"Unknown XML node type: \" + node.constructor.name);\n      }\n    };\n\n    XMLWriterBase.prototype.processingInstruction = function(node, options, level) {\n      var r;\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r = this.indent(node, options, level) + '<?';\n      options.state = WriterState.InsideTag;\n      r += node.target;\n      if (node.value) {\n        r += ' ' + node.value;\n      }\n      options.state = WriterState.CloseTag;\n      r += options.spaceBeforeSlash + '?>';\n      r += this.endline(node, options, level);\n      options.state = WriterState.None;\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.raw = function(node, options, level) {\n      var r;\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r = this.indent(node, options, level);\n      options.state = WriterState.InsideTag;\n      r += node.value;\n      options.state = WriterState.CloseTag;\n      r += this.endline(node, options, level);\n      options.state = WriterState.None;\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.text = function(node, options, level) {\n      var r;\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r = this.indent(node, options, level);\n      options.state = WriterState.InsideTag;\n      r += node.value;\n      options.state = WriterState.CloseTag;\n      r += this.endline(node, options, level);\n      options.state = WriterState.None;\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.dtdAttList = function(node, options, level) {\n      var r;\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r = this.indent(node, options, level) + '<!ATTLIST';\n      options.state = WriterState.InsideTag;\n      r += ' ' + node.elementName + ' ' + node.attributeName + ' ' + node.attributeType;\n      if (node.defaultValueType !== '#DEFAULT') {\n        r += ' ' + node.defaultValueType;\n      }\n      if (node.defaultValue) {\n        r += ' \"' + node.defaultValue + '\"';\n      }\n      options.state = WriterState.CloseTag;\n      r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);\n      options.state = WriterState.None;\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.dtdElement = function(node, options, level) {\n      var r;\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r = this.indent(node, options, level) + '<!ELEMENT';\n      options.state = WriterState.InsideTag;\n      r += ' ' + node.name + ' ' + node.value;\n      options.state = WriterState.CloseTag;\n      r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);\n      options.state = WriterState.None;\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.dtdEntity = function(node, options, level) {\n      var r;\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r = this.indent(node, options, level) + '<!ENTITY';\n      options.state = WriterState.InsideTag;\n      if (node.pe) {\n        r += ' %';\n      }\n      r += ' ' + node.name;\n      if (node.value) {\n        r += ' \"' + node.value + '\"';\n      } else {\n        if (node.pubID && node.sysID) {\n          r += ' PUBLIC \"' + node.pubID + '\" \"' + node.sysID + '\"';\n        } else if (node.sysID) {\n          r += ' SYSTEM \"' + node.sysID + '\"';\n        }\n        if (node.nData) {\n          r += ' NDATA ' + node.nData;\n        }\n      }\n      options.state = WriterState.CloseTag;\n      r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);\n      options.state = WriterState.None;\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.dtdNotation = function(node, options, level) {\n      var r;\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      r = this.indent(node, options, level) + '<!NOTATION';\n      options.state = WriterState.InsideTag;\n      r += ' ' + node.name;\n      if (node.pubID && node.sysID) {\n        r += ' PUBLIC \"' + node.pubID + '\" \"' + node.sysID + '\"';\n      } else if (node.pubID) {\n        r += ' PUBLIC \"' + node.pubID + '\"';\n      } else if (node.sysID) {\n        r += ' SYSTEM \"' + node.sysID + '\"';\n      }\n      options.state = WriterState.CloseTag;\n      r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);\n      options.state = WriterState.None;\n      this.closeNode(node, options, level);\n      return r;\n    };\n\n    XMLWriterBase.prototype.openNode = function(node, options, level) {};\n\n    XMLWriterBase.prototype.closeNode = function(node, options, level) {};\n\n    XMLWriterBase.prototype.openAttribute = function(att, options, level) {};\n\n    XMLWriterBase.prototype.closeAttribute = function(att, options, level) {};\n\n    return XMLWriterBase;\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","/* 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","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","// 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.parseStringPromise = bind(this.parseStringPromise, this);\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    Parser.prototype.parseStringPromise = function(str) {\n      return new Promise((function(_this) {\n        return function(resolve, reject) {\n          return _this.parseString(str, function(err, value) {\n            if (err) {\n              return reject(err);\n            } else {\n              return resolve(value);\n            }\n          });\n        };\n      })(this));\n    };\n\n    return Parser;\n\n  })(events);\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  exports.parseStringPromise = function(str, a) {\n    var options, parser;\n    if (typeof a === 'object') {\n      options = a;\n    }\n    parser = new exports.Parser(options);\n    return parser.parseStringPromise(str);\n  };\n\n}).call(this);\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var readableHwm = options.readableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    pna.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        pna.nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    pna.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._readableState.highWaterMark;\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    pna.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLDOMConfiguration, XMLDOMImplementation, XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject,\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  isPlainObject = require('./Utility').isPlainObject;\n\n  XMLDOMImplementation = require('./XMLDOMImplementation');\n\n  XMLDOMConfiguration = require('./XMLDOMConfiguration');\n\n  XMLNode = require('./XMLNode');\n\n  NodeType = require('./NodeType');\n\n  XMLStringifier = require('./XMLStringifier');\n\n  XMLStringWriter = require('./XMLStringWriter');\n\n  module.exports = XMLDocument = (function(superClass) {\n    extend(XMLDocument, superClass);\n\n    function XMLDocument(options) {\n      XMLDocument.__super__.constructor.call(this, null);\n      this.name = \"#document\";\n      this.type = NodeType.Document;\n      this.documentURI = null;\n      this.domConfig = new XMLDOMConfiguration();\n      options || (options = {});\n      if (!options.writer) {\n        options.writer = new XMLStringWriter();\n      }\n      this.options = options;\n      this.stringify = new XMLStringifier(options);\n    }\n\n    Object.defineProperty(XMLDocument.prototype, 'implementation', {\n      value: new XMLDOMImplementation()\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'doctype', {\n      get: function() {\n        var child, i, len, ref;\n        ref = this.children;\n        for (i = 0, len = ref.length; i < len; i++) {\n          child = ref[i];\n          if (child.type === NodeType.DocType) {\n            return child;\n          }\n        }\n        return null;\n      }\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'documentElement', {\n      get: function() {\n        return this.rootObject || null;\n      }\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'inputEncoding', {\n      get: function() {\n        return null;\n      }\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'strictErrorChecking', {\n      get: function() {\n        return false;\n      }\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'xmlEncoding', {\n      get: function() {\n        if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {\n          return this.children[0].encoding;\n        } else {\n          return null;\n        }\n      }\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'xmlStandalone', {\n      get: function() {\n        if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {\n          return this.children[0].standalone === 'yes';\n        } else {\n          return false;\n        }\n      }\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'xmlVersion', {\n      get: function() {\n        if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {\n          return this.children[0].version;\n        } else {\n          return \"1.0\";\n        }\n      }\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'URL', {\n      get: function() {\n        return this.documentURI;\n      }\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'origin', {\n      get: function() {\n        return null;\n      }\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'compatMode', {\n      get: function() {\n        return null;\n      }\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'characterSet', {\n      get: function() {\n        return null;\n      }\n    });\n\n    Object.defineProperty(XMLDocument.prototype, 'contentType', {\n      get: function() {\n        return null;\n      }\n    });\n\n    XMLDocument.prototype.end = function(writer) {\n      var writerOptions;\n      writerOptions = {};\n      if (!writer) {\n        writer = this.options.writer;\n      } else if (isPlainObject(writer)) {\n        writerOptions = writer;\n        writer = this.options.writer;\n      }\n      return writer.document(this, writer.filterOptions(writerOptions));\n    };\n\n    XMLDocument.prototype.toString = function(options) {\n      return this.options.writer.document(this, this.options.writer.filterOptions(options));\n    };\n\n    XMLDocument.prototype.createElement = function(tagName) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createDocumentFragment = function() {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createTextNode = function(data) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createComment = function(data) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createCDATASection = function(data) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createProcessingInstruction = function(target, data) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createAttribute = function(name) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createEntityReference = function(name) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.getElementsByTagName = function(tagname) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.importNode = function(importedNode, deep) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createElementNS = function(namespaceURI, qualifiedName) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createAttributeNS = function(namespaceURI, qualifiedName) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.getElementById = function(elementId) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.adoptNode = function(source) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.normalizeDocument = function() {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.renameNode = function(node, namespaceURI, qualifiedName) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.getElementsByClassName = function(classNames) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createEvent = function(eventInterface) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createRange = function() {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createNodeIterator = function(root, whatToShow, filter) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLDocument.prototype.createTreeWalker = function(root, whatToShow, filter) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    return XMLDocument;\n\n  })(XMLNode);\n\n}).call(this);\n","var fails = require('../internals/fails');\n\n// check the existence of a method, lowercase\n// of a tag and escaping quotes in arguments\nmodule.exports = function (METHOD_NAME) {\n  return fails(function () {\n    var test = ''[METHOD_NAME]('\"');\n    return test !== test.toLowerCase() || test.split('\"').length > 3;\n  });\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  'summary',\n  ['content:encoded', 'content:encoded', {includeSnippet: true}],\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';\n\nmodule.exports = require('./lib/parser');\n\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\n{\n  // avoid scope creep, the keys array can then be collected\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  pna.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  pna.nextTick(cb, err);\n};","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLDTDNotation, XMLNode,\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  XMLNode = require('./XMLNode');\n\n  NodeType = require('./NodeType');\n\n  module.exports = XMLDTDNotation = (function(superClass) {\n    extend(XMLDTDNotation, superClass);\n\n    function XMLDTDNotation(parent, name, value) {\n      XMLDTDNotation.__super__.constructor.call(this, parent);\n      if (name == null) {\n        throw new Error(\"Missing DTD notation name. \" + this.debugInfo(name));\n      }\n      if (!value.pubID && !value.sysID) {\n        throw new Error(\"Public or system identifiers are required for an external entity. \" + this.debugInfo(name));\n      }\n      this.name = this.stringify.name(name);\n      this.type = NodeType.NotationDeclaration;\n      if (value.pubID != null) {\n        this.pubID = this.stringify.dtdPubID(value.pubID);\n      }\n      if (value.sysID != null) {\n        this.sysID = this.stringify.dtdSysID(value.sysID);\n      }\n    }\n\n    Object.defineProperty(XMLDTDNotation.prototype, 'publicId', {\n      get: function() {\n        return this.pubID;\n      }\n    });\n\n    Object.defineProperty(XMLDTDNotation.prototype, 'systemId', {\n      get: function() {\n        return this.sysID;\n      }\n    });\n\n    XMLDTDNotation.prototype.toString = function(options) {\n      return this.options.writer.dtdNotation(this, this.options.writer.filterOptions(options));\n    };\n\n    return XMLDTDNotation;\n\n  })(XMLNode);\n\n}).call(this);\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","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLAttribute, XMLElement, XMLNamedNodeMap, XMLNode, getValue, isFunction, isObject, ref,\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  ref = require('./Utility'), isObject = ref.isObject, isFunction = ref.isFunction, getValue = ref.getValue;\n\n  XMLNode = require('./XMLNode');\n\n  NodeType = require('./NodeType');\n\n  XMLAttribute = require('./XMLAttribute');\n\n  XMLNamedNodeMap = require('./XMLNamedNodeMap');\n\n  module.exports = XMLElement = (function(superClass) {\n    extend(XMLElement, superClass);\n\n    function XMLElement(parent, name, attributes) {\n      var child, j, len, ref1;\n      XMLElement.__super__.constructor.call(this, parent);\n      if (name == null) {\n        throw new Error(\"Missing element name. \" + this.debugInfo());\n      }\n      this.name = this.stringify.name(name);\n      this.type = NodeType.Element;\n      this.attribs = {};\n      this.schemaTypeInfo = null;\n      if (attributes != null) {\n        this.attribute(attributes);\n      }\n      if (parent.type === NodeType.Document) {\n        this.isRoot = true;\n        this.documentObject = parent;\n        parent.rootObject = this;\n        if (parent.children) {\n          ref1 = parent.children;\n          for (j = 0, len = ref1.length; j < len; j++) {\n            child = ref1[j];\n            if (child.type === NodeType.DocType) {\n              child.name = this.name;\n              break;\n            }\n          }\n        }\n      }\n    }\n\n    Object.defineProperty(XMLElement.prototype, 'tagName', {\n      get: function() {\n        return this.name;\n      }\n    });\n\n    Object.defineProperty(XMLElement.prototype, 'namespaceURI', {\n      get: function() {\n        return '';\n      }\n    });\n\n    Object.defineProperty(XMLElement.prototype, 'prefix', {\n      get: function() {\n        return '';\n      }\n    });\n\n    Object.defineProperty(XMLElement.prototype, 'localName', {\n      get: function() {\n        return this.name;\n      }\n    });\n\n    Object.defineProperty(XMLElement.prototype, 'id', {\n      get: function() {\n        throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n      }\n    });\n\n    Object.defineProperty(XMLElement.prototype, 'className', {\n      get: function() {\n        throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n      }\n    });\n\n    Object.defineProperty(XMLElement.prototype, 'classList', {\n      get: function() {\n        throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n      }\n    });\n\n    Object.defineProperty(XMLElement.prototype, 'attributes', {\n      get: function() {\n        if (!this.attributeMap || !this.attributeMap.nodes) {\n          this.attributeMap = new XMLNamedNodeMap(this.attribs);\n        }\n        return this.attributeMap;\n      }\n    });\n\n    XMLElement.prototype.clone = function() {\n      var att, attName, clonedSelf, ref1;\n      clonedSelf = Object.create(this);\n      if (clonedSelf.isRoot) {\n        clonedSelf.documentObject = null;\n      }\n      clonedSelf.attribs = {};\n      ref1 = this.attribs;\n      for (attName in ref1) {\n        if (!hasProp.call(ref1, attName)) continue;\n        att = ref1[attName];\n        clonedSelf.attribs[attName] = att.clone();\n      }\n      clonedSelf.children = [];\n      this.children.forEach(function(child) {\n        var clonedChild;\n        clonedChild = child.clone();\n        clonedChild.parent = clonedSelf;\n        return clonedSelf.children.push(clonedChild);\n      });\n      return clonedSelf;\n    };\n\n    XMLElement.prototype.attribute = function(name, value) {\n      var attName, attValue;\n      if (name != null) {\n        name = getValue(name);\n      }\n      if (isObject(name)) {\n        for (attName in name) {\n          if (!hasProp.call(name, attName)) continue;\n          attValue = name[attName];\n          this.attribute(attName, attValue);\n        }\n      } else {\n        if (isFunction(value)) {\n          value = value.apply();\n        }\n        if (this.options.keepNullAttributes && (value == null)) {\n          this.attribs[name] = new XMLAttribute(this, name, \"\");\n        } else if (value != null) {\n          this.attribs[name] = new XMLAttribute(this, name, value);\n        }\n      }\n      return this;\n    };\n\n    XMLElement.prototype.removeAttribute = function(name) {\n      var attName, j, len;\n      if (name == null) {\n        throw new Error(\"Missing attribute name. \" + this.debugInfo());\n      }\n      name = getValue(name);\n      if (Array.isArray(name)) {\n        for (j = 0, len = name.length; j < len; j++) {\n          attName = name[j];\n          delete this.attribs[attName];\n        }\n      } else {\n        delete this.attribs[name];\n      }\n      return this;\n    };\n\n    XMLElement.prototype.toString = function(options) {\n      return this.options.writer.element(this, this.options.writer.filterOptions(options));\n    };\n\n    XMLElement.prototype.att = function(name, value) {\n      return this.attribute(name, value);\n    };\n\n    XMLElement.prototype.a = function(name, value) {\n      return this.attribute(name, value);\n    };\n\n    XMLElement.prototype.getAttribute = function(name) {\n      if (this.attribs.hasOwnProperty(name)) {\n        return this.attribs[name].value;\n      } else {\n        return null;\n      }\n    };\n\n    XMLElement.prototype.setAttribute = function(name, value) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.getAttributeNode = function(name) {\n      if (this.attribs.hasOwnProperty(name)) {\n        return this.attribs[name];\n      } else {\n        return null;\n      }\n    };\n\n    XMLElement.prototype.setAttributeNode = function(newAttr) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.removeAttributeNode = function(oldAttr) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.getElementsByTagName = function(name) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.getAttributeNS = function(namespaceURI, localName) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.removeAttributeNS = function(namespaceURI, localName) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.getAttributeNodeNS = function(namespaceURI, localName) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.setAttributeNodeNS = function(newAttr) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.hasAttribute = function(name) {\n      return this.attribs.hasOwnProperty(name);\n    };\n\n    XMLElement.prototype.hasAttributeNS = function(namespaceURI, localName) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.setIdAttribute = function(name, isId) {\n      if (this.attribs.hasOwnProperty(name)) {\n        return this.attribs[name].isId;\n      } else {\n        return isId;\n      }\n    };\n\n    XMLElement.prototype.setIdAttributeNS = function(namespaceURI, localName, isId) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.setIdAttributeNode = function(idAttr, isId) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.getElementsByTagName = function(tagname) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.getElementsByClassName = function(classNames) {\n      throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n    };\n\n    XMLElement.prototype.isEqualNode = function(node) {\n      var i, j, ref1;\n      if (!XMLElement.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {\n        return false;\n      }\n      if (node.namespaceURI !== this.namespaceURI) {\n        return false;\n      }\n      if (node.prefix !== this.prefix) {\n        return false;\n      }\n      if (node.localName !== this.localName) {\n        return false;\n      }\n      if (node.attribs.length !== this.attribs.length) {\n        return false;\n      }\n      for (i = j = 0, ref1 = this.attribs.length - 1; 0 <= ref1 ? j <= ref1 : j >= ref1; i = 0 <= ref1 ? ++j : --j) {\n        if (!this.attribs[i].isEqualNode(node.attribs[i])) {\n          return false;\n        }\n      }\n      return true;\n    };\n\n    return XMLElement;\n\n  })(XMLNode);\n\n}).call(this);\n","module.exports = require('./readable').PassThrough\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, WriterState, XMLStreamWriter, XMLWriterBase,\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  NodeType = require('./NodeType');\n\n  XMLWriterBase = require('./XMLWriterBase');\n\n  WriterState = require('./WriterState');\n\n  module.exports = XMLStreamWriter = (function(superClass) {\n    extend(XMLStreamWriter, superClass);\n\n    function XMLStreamWriter(stream, options) {\n      this.stream = stream;\n      XMLStreamWriter.__super__.constructor.call(this, options);\n    }\n\n    XMLStreamWriter.prototype.endline = function(node, options, level) {\n      if (node.isLastRootNode && options.state === WriterState.CloseTag) {\n        return '';\n      } else {\n        return XMLStreamWriter.__super__.endline.call(this, node, options, level);\n      }\n    };\n\n    XMLStreamWriter.prototype.document = function(doc, options) {\n      var child, i, j, k, len, len1, ref, ref1, results;\n      ref = doc.children;\n      for (i = j = 0, len = ref.length; j < len; i = ++j) {\n        child = ref[i];\n        child.isLastRootNode = i === doc.children.length - 1;\n      }\n      options = this.filterOptions(options);\n      ref1 = doc.children;\n      results = [];\n      for (k = 0, len1 = ref1.length; k < len1; k++) {\n        child = ref1[k];\n        results.push(this.writeChildNode(child, options, 0));\n      }\n      return results;\n    };\n\n    XMLStreamWriter.prototype.attribute = function(att, options, level) {\n      return this.stream.write(XMLStreamWriter.__super__.attribute.call(this, att, options, level));\n    };\n\n    XMLStreamWriter.prototype.cdata = function(node, options, level) {\n      return this.stream.write(XMLStreamWriter.__super__.cdata.call(this, node, options, level));\n    };\n\n    XMLStreamWriter.prototype.comment = function(node, options, level) {\n      return this.stream.write(XMLStreamWriter.__super__.comment.call(this, node, options, level));\n    };\n\n    XMLStreamWriter.prototype.declaration = function(node, options, level) {\n      return this.stream.write(XMLStreamWriter.__super__.declaration.call(this, node, options, level));\n    };\n\n    XMLStreamWriter.prototype.docType = function(node, options, level) {\n      var child, j, len, ref;\n      level || (level = 0);\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      this.stream.write(this.indent(node, options, level));\n      this.stream.write('<!DOCTYPE ' + node.root().name);\n      if (node.pubID && node.sysID) {\n        this.stream.write(' PUBLIC \"' + node.pubID + '\" \"' + node.sysID + '\"');\n      } else if (node.sysID) {\n        this.stream.write(' SYSTEM \"' + node.sysID + '\"');\n      }\n      if (node.children.length > 0) {\n        this.stream.write(' [');\n        this.stream.write(this.endline(node, options, level));\n        options.state = WriterState.InsideTag;\n        ref = node.children;\n        for (j = 0, len = ref.length; j < len; j++) {\n          child = ref[j];\n          this.writeChildNode(child, options, level + 1);\n        }\n        options.state = WriterState.CloseTag;\n        this.stream.write(']');\n      }\n      options.state = WriterState.CloseTag;\n      this.stream.write(options.spaceBeforeSlash + '>');\n      this.stream.write(this.endline(node, options, level));\n      options.state = WriterState.None;\n      return this.closeNode(node, options, level);\n    };\n\n    XMLStreamWriter.prototype.element = function(node, options, level) {\n      var att, child, childNodeCount, firstChildNode, j, len, name, prettySuppressed, ref, ref1;\n      level || (level = 0);\n      this.openNode(node, options, level);\n      options.state = WriterState.OpenTag;\n      this.stream.write(this.indent(node, options, level) + '<' + node.name);\n      ref = node.attribs;\n      for (name in ref) {\n        if (!hasProp.call(ref, name)) continue;\n        att = ref[name];\n        this.attribute(att, options, level);\n      }\n      childNodeCount = node.children.length;\n      firstChildNode = childNodeCount === 0 ? null : node.children[0];\n      if (childNodeCount === 0 || node.children.every(function(e) {\n        return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === '';\n      })) {\n        if (options.allowEmpty) {\n          this.stream.write('>');\n          options.state = WriterState.CloseTag;\n          this.stream.write('</' + node.name + '>');\n        } else {\n          options.state = WriterState.CloseTag;\n          this.stream.write(options.spaceBeforeSlash + '/>');\n        }\n      } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && (firstChildNode.value != null)) {\n        this.stream.write('>');\n        options.state = WriterState.InsideTag;\n        options.suppressPrettyCount++;\n        prettySuppressed = true;\n        this.writeChildNode(firstChildNode, options, level + 1);\n        options.suppressPrettyCount--;\n        prettySuppressed = false;\n        options.state = WriterState.CloseTag;\n        this.stream.write('</' + node.name + '>');\n      } else {\n        this.stream.write('>' + this.endline(node, options, level));\n        options.state = WriterState.InsideTag;\n        ref1 = node.children;\n        for (j = 0, len = ref1.length; j < len; j++) {\n          child = ref1[j];\n          this.writeChildNode(child, options, level + 1);\n        }\n        options.state = WriterState.CloseTag;\n        this.stream.write(this.indent(node, options, level) + '</' + node.name + '>');\n      }\n      this.stream.write(this.endline(node, options, level));\n      options.state = WriterState.None;\n      return this.closeNode(node, options, level);\n    };\n\n    XMLStreamWriter.prototype.processingInstruction = function(node, options, level) {\n      return this.stream.write(XMLStreamWriter.__super__.processingInstruction.call(this, node, options, level));\n    };\n\n    XMLStreamWriter.prototype.raw = function(node, options, level) {\n      return this.stream.write(XMLStreamWriter.__super__.raw.call(this, node, options, level));\n    };\n\n    XMLStreamWriter.prototype.text = function(node, options, level) {\n      return this.stream.write(XMLStreamWriter.__super__.text.call(this, node, options, level));\n    };\n\n    XMLStreamWriter.prototype.dtdAttList = function(node, options, level) {\n      return this.stream.write(XMLStreamWriter.__super__.dtdAttList.call(this, node, options, level));\n    };\n\n    XMLStreamWriter.prototype.dtdElement = function(node, options, level) {\n      return this.stream.write(XMLStreamWriter.__super__.dtdElement.call(this, node, options, level));\n    };\n\n    XMLStreamWriter.prototype.dtdEntity = function(node, options, level) {\n      return this.stream.write(XMLStreamWriter.__super__.dtdEntity.call(this, node, options, level));\n    };\n\n    XMLStreamWriter.prototype.dtdNotation = function(node, options, level) {\n      return this.stream.write(XMLStreamWriter.__super__.dtdNotation.call(this, node, options, level));\n    };\n\n    return XMLStreamWriter;\n\n  })(XMLWriterBase);\n\n}).call(this);\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","module.exports = require('./readable').Transform\n","// Generated by CoffeeScript 1.12.7\n(function() {\n  module.exports = {\n    Disconnected: 1,\n    Preceding: 2,\n    Following: 4,\n    Contains: 8,\n    ContainedBy: 16,\n    ImplementationSpecific: 32\n  };\n\n}).call(this);\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","const utils = module.exports = {};\nconst entities = require('entities');\nconst xml2js = require('xml2js');\n\nutils.stripHtml = function(str) {\n  str = str.replace(/([^\\n])<\\/?(h|br|p|ul|ol|li|blockquote|section|table|tr|div)(?:.|\\n)*?>([^\\n])/gm, '$1\\n$3')\n  str = str.replace(/<(?:.|\\n)*?>/gm, '');\n  return str;\n}\n\nutils.getSnippet = function(str) {\n  return entities.decodeHTML(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, includeSnippet } = 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    if (includeSnippet && dest[to] && typeof dest[to] === 'string') {\n      dest[to + 'Snippet'] = utils.getSnippet(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","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLNamedNodeMap, XMLNode, isObject,\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  isObject = require('./Utility').isObject;\n\n  XMLNode = require('./XMLNode');\n\n  NodeType = require('./NodeType');\n\n  XMLDTDAttList = require('./XMLDTDAttList');\n\n  XMLDTDEntity = require('./XMLDTDEntity');\n\n  XMLDTDElement = require('./XMLDTDElement');\n\n  XMLDTDNotation = require('./XMLDTDNotation');\n\n  XMLNamedNodeMap = require('./XMLNamedNodeMap');\n\n  module.exports = XMLDocType = (function(superClass) {\n    extend(XMLDocType, superClass);\n\n    function XMLDocType(parent, pubID, sysID) {\n      var child, i, len, ref, ref1, ref2;\n      XMLDocType.__super__.constructor.call(this, parent);\n      this.type = NodeType.DocType;\n      if (parent.children) {\n        ref = parent.children;\n        for (i = 0, len = ref.length; i < len; i++) {\n          child = ref[i];\n          if (child.type === NodeType.Element) {\n            this.name = child.name;\n            break;\n          }\n        }\n      }\n      this.documentObject = parent;\n      if (isObject(pubID)) {\n        ref1 = pubID, pubID = ref1.pubID, sysID = ref1.sysID;\n      }\n      if (sysID == null) {\n        ref2 = [pubID, sysID], sysID = ref2[0], pubID = ref2[1];\n      }\n      if (pubID != null) {\n        this.pubID = this.stringify.dtdPubID(pubID);\n      }\n      if (sysID != null) {\n        this.sysID = this.stringify.dtdSysID(sysID);\n      }\n    }\n\n    Object.defineProperty(XMLDocType.prototype, 'entities', {\n      get: function() {\n        var child, i, len, nodes, ref;\n        nodes = {};\n        ref = this.children;\n        for (i = 0, len = ref.length; i < len; i++) {\n          child = ref[i];\n          if ((child.type === NodeType.EntityDeclaration) && !child.pe) {\n            nodes[child.name] = child;\n          }\n        }\n        return new XMLNamedNodeMap(nodes);\n      }\n    });\n\n    Object.defineProperty(XMLDocType.prototype, 'notations', {\n      get: function() {\n        var child, i, len, nodes, ref;\n        nodes = {};\n        ref = this.children;\n        for (i = 0, len = ref.length; i < len; i++) {\n          child = ref[i];\n          if (child.type === NodeType.NotationDeclaration) {\n            nodes[child.name] = child;\n          }\n        }\n        return new XMLNamedNodeMap(nodes);\n      }\n    });\n\n    Object.defineProperty(XMLDocType.prototype, 'publicId', {\n      get: function() {\n        return this.pubID;\n      }\n    });\n\n    Object.defineProperty(XMLDocType.prototype, 'systemId', {\n      get: function() {\n        return this.sysID;\n      }\n    });\n\n    Object.defineProperty(XMLDocType.prototype, 'internalSubset', {\n      get: function() {\n        throw new Error(\"This DOM method is not implemented.\" + this.debugInfo());\n      }\n    });\n\n    XMLDocType.prototype.element = function(name, value) {\n      var child;\n      child = new XMLDTDElement(this, name, value);\n      this.children.push(child);\n      return this;\n    };\n\n    XMLDocType.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {\n      var child;\n      child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);\n      this.children.push(child);\n      return this;\n    };\n\n    XMLDocType.prototype.entity = function(name, value) {\n      var child;\n      child = new XMLDTDEntity(this, false, name, value);\n      this.children.push(child);\n      return this;\n    };\n\n    XMLDocType.prototype.pEntity = function(name, value) {\n      var child;\n      child = new XMLDTDEntity(this, true, name, value);\n      this.children.push(child);\n      return this;\n    };\n\n    XMLDocType.prototype.notation = function(name, value) {\n      var child;\n      child = new XMLDTDNotation(this, name, value);\n      this.children.push(child);\n      return this;\n    };\n\n    XMLDocType.prototype.toString = function(options) {\n      return this.options.writer.docType(this, this.options.writer.filterOptions(options));\n    };\n\n    XMLDocType.prototype.ele = function(name, value) {\n      return this.element(name, value);\n    };\n\n    XMLDocType.prototype.att = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {\n      return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);\n    };\n\n    XMLDocType.prototype.ent = function(name, value) {\n      return this.entity(name, value);\n    };\n\n    XMLDocType.prototype.pent = function(name, value) {\n      return this.pEntity(name, value);\n    };\n\n    XMLDocType.prototype.not = function(name, value) {\n      return this.notation(name, value);\n    };\n\n    XMLDocType.prototype.up = function() {\n      return this.root() || this.documentObject;\n    };\n\n    XMLDocType.prototype.isEqualNode = function(node) {\n      if (!XMLDocType.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {\n        return false;\n      }\n      if (node.name !== this.name) {\n        return false;\n      }\n      if (node.publicId !== this.publicId) {\n        return false;\n      }\n      if (node.systemId !== this.systemId) {\n        return false;\n      }\n      return true;\n    };\n\n    return XMLDocType;\n\n  })(XMLNode);\n\n}).call(this);\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// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    pna.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    pna.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      pna.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar stringifyPrimitive = function(v) {\n  switch (typeof v) {\n    case 'string':\n      return v;\n\n    case 'boolean':\n      return v ? 'true' : 'false';\n\n    case 'number':\n      return isFinite(v) ? v : '';\n\n    default:\n      return '';\n  }\n};\n\nmodule.exports = function(obj, sep, eq, name) {\n  sep = sep || '&';\n  eq = eq || '=';\n  if (obj === null) {\n    obj = undefined;\n  }\n\n  if (typeof obj === 'object') {\n    return map(objectKeys(obj), function(k) {\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n      if (isArray(obj[k])) {\n        return map(obj[k], function(v) {\n          return ks + encodeURIComponent(stringifyPrimitive(v));\n        }).join(sep);\n      } else {\n        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n      }\n    }).join(sep);\n\n  }\n\n  if (!name) return '';\n  return encodeURIComponent(stringifyPrimitive(name)) + eq +\n         encodeURIComponent(stringifyPrimitive(obj));\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n\nfunction map (xs, f) {\n  if (xs.map) return xs.map(f);\n  var res = [];\n  for (var i = 0; i < xs.length; i++) {\n    res.push(f(xs[i], i));\n  }\n  return res;\n}\n\nvar objectKeys = Object.keys || function (obj) {\n  var res = [];\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);\n  }\n  return res;\n};\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--6-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--6-oneOf-1-1!../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--6-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader/lib/index.js??vue-loader-options!./rssfeed.vue?vue&type=style&index=0&id=c0686364&scoped=true&lang=css&\"","// Generated by CoffeeScript 1.12.7\n(function() {\n  var NodeType, XMLCharacterData, XMLProcessingInstruction,\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  NodeType = require('./NodeType');\n\n  XMLCharacterData = require('./XMLCharacterData');\n\n  module.exports = XMLProcessingInstruction = (function(superClass) {\n    extend(XMLProcessingInstruction, superClass);\n\n    function XMLProcessingInstruction(parent, target, value) {\n      XMLProcessingInstruction.__super__.constructor.call(this, parent);\n      if (target == null) {\n        throw new Error(\"Missing instruction target. \" + this.debugInfo());\n      }\n      this.type = NodeType.ProcessingInstruction;\n      this.target = this.stringify.insTarget(target);\n      this.name = this.target;\n      if (value) {\n        this.value = this.stringify.insValue(value);\n      }\n    }\n\n    XMLProcessingInstruction.prototype.clone = function() {\n      return Object.create(this);\n    };\n\n    XMLProcessingInstruction.prototype.toString = function(options) {\n      return this.options.writer.processingInstruction(this, this.options.writer.filterOptions(options));\n    };\n\n    XMLProcessingInstruction.prototype.isEqualNode = function(node) {\n      if (!XMLProcessingInstruction.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {\n        return false;\n      }\n      if (node.target !== this.target) {\n        return false;\n      }\n      return true;\n    };\n\n    return XMLProcessingInstruction;\n\n  })(XMLCharacterData);\n\n}).call(this);\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    feed.items = (xmlObj.feed.entry || []).map(entry => this.parseItemAtom(entry));\n    return feed;\n  }\n\n  parseItemAtom(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.summary && entry.summary.length) {\n      item.summary = utils.getContent(entry.summary[0]);\n    }\n    if (entry.id) {\n      item.id = entry.id[0];\n    }\n    this.setISODate(item);\n    return item;\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    const paginationLinks = this.generatePaginationLinks(channel);\n    if (Object.keys(paginationLinks).length) {\n      feed.paginationLinks = paginationLinks;\n    }\n    utils.copyFromXML(channel, feed, feedFields);\n    feed.items = items.map(xmlItem => this.parseItemRss(xmlItem, itemFields));\n    return feed;\n  }\n\n  parseItemRss(xmlItem, itemFields) {\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    return item;\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      const categoriesWithSubs = channel['itunes:category'].map((category) => {\n        return {\n          name: category.$.text,\n          subs: category['itunes:category'] ?\n            category['itunes:category']\n              .map((subcategory) => ({ name: subcategory.$.text })) : null,\n        };\n      });\n\n      feed.itunes.categories = categoriesWithSubs.map((category) => category.name);\n      feed.itunes.categoriesWithSubs = categoriesWithSubs;\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\n        if (keywords && keywords.$ && keywords.$.text) {\n          feed.itunes.keywords = keywords.$.text.split(',')\n        } else if (typeof keywords === \"string\") {\n          feed.itunes.keywords = keywords.split(',');\n        }\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  /**\n   * Generates a pagination object where the rel attribute is the key and href attribute is the value\n   *  { self: 'self-url', first: 'first-url', ...  }\n   *\n   * @access private\n   * @param {Object} channel parsed XML\n   * @returns {Object}\n   */\n  generatePaginationLinks(channel) {\n    if (!channel['atom:link']) {\n      return {};\n    }\n    const paginationRelAttributes = ['self', 'first', 'next', 'prev', 'last'];\n\n    return channel['atom:link'].reduce((paginationLinks, link) => {\n      if (!link.$ || !paginationRelAttributes.includes(link.$.rel)) {\n        return paginationLinks;\n      }\n      paginationLinks[link.$.rel] = link.$.href;\n      return paginationLinks;\n    }, {});\n  }\n}\n\nmodule.exports = Parser;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n"],"sourceRoot":""}