{"version":3,"sources":["webpack:///./node_modules/xmlbuilder/lib/XMLNodeList.js","webpack:///./node_modules/entities/lib/encode.js","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/xmlbuilder/lib/XMLDummy.js","webpack:///./node_modules/xmlbuilder/lib/XMLDTDEntity.js","webpack:///./node_modules/xmlbuilder/lib/XMLDTDAttList.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:///./src/views/FrontendPages/Components/NLSE/Feed.vue?fa7b","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/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:///./src/views/FrontendPages/Rssfeed.vue","webpack:///./src/views/FrontendPages/Components/NLSE/Feed.vue","webpack:///src/views/FrontendPages/Components/NLSE/Feed.vue","webpack:///./src/views/FrontendPages/Components/NLSE/Feed.vue?bf16","webpack:///./src/views/FrontendPages/Components/NLSE/Feed.vue?aab7","webpack:///src/views/FrontendPages/Rssfeed.vue","webpack:///./src/views/FrontendPages/Rssfeed.vue?a926","webpack:///./src/views/FrontendPages/Rssfeed.vue?b359","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/safe-buffer/index.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/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/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/rss-parser/lib/fields.js","webpack:///./node_modules/rss-parser/index.js","webpack:///./node_modules/readable-stream/lib/_stream_duplex.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/readable-stream/readable-browser.js","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","Element","Attribute","Text","CData","EntityReference","EntityDeclaration","ProcessingInstruction","Comment","Document","DocType","DocumentFragment","NotationDeclaration","Declaration","Raw","AttributeDeclaration","ElementDeclaration","Dummy","builder","defaults","parser","processors","extend","child","parent","key","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","title","getFeature","NodeType","XMLNode","XMLDummy","type","create","options","isObject","XMLDTDEntity","pe","debugInfo","stringify","pubID","sysID","internal","dtdPubID","dtdSysID","nData","dtdNData","dtdEntityValue","writer","dtdEntity","filterOptions","XMLDTDAttList","elementName","attributeName","attributeType","defaultValueType","defaultValue","indexOf","match","dtdAttType","dtdAttDefault","dtdAttList","XMLDOMStringList","arr","contains","XMLWriterBase","XMLStringWriter","document","doc","i","len","r","ref","children","writeChildNode","pretty","slice","newline","XMLAttribute","attValue","isId","schemaTypeInfo","set","attribute","isEqualNode","node","prefix","localName","http","url","https","validateParams","params","parse","protocol","request","cb","Transform","Duplex","util","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","n","_destroy","err","_this2","err2","sax","strict","opt","SAXParser","SAXStream","createStream","MAX_BUFFER_LENGTH","Stream","buffers","clearBuffers","q","bufferCheckPosition","lowercase","lowercasetags","looseCase","tags","closed","closedRoot","sawRoot","tag","error","noscript","state","S","BEGIN","strictEntities","ENTITIES","XML_ENTITIES","attribList","xmlns","ns","rootNS","trackPosition","position","line","column","checkBufferLength","maxAllowed","Math","max","maxActual","l","closeText","emitNode","cdata","script","m","flushBuffers","EVENTS","o","F","newf","a","write","resume","close","ex","streamWraps","filter","ev","apply","_parser","writable","readable","me","onend","onerror","_decoder","forEach","h","removeAllListeners","enumerable","configurable","Buffer","isBuffer","SD","StringDecoder","handler","args","arguments","Array","whitespace","number","letter","quote","attribEnd","CDATA","DOCTYPE","XML_NAMESPACE","XMLNS_NAMESPACE","xml","charClass","nameStart","nameBody","entityStart","entityBody","split","s","isRegExp","is","charclass","not","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","e","fromCharCode","event","nodeType","textNode","textopts","text","trim","normalize","strictFail","newTag","tagName","attributes","qname","qualName","local","attrib","attribName","attribValue","qn","openTag","selfClosing","uri","JSON","p","nv","isSelfClosing","toLowerCase","closeTag","t","closeTo","pop","x","parseEntity","num","entity","entityLC","numStr","charAt","parseInt","fromCodePoint","beginWhiteSpace","startTagPosition","result","starti","substring","sgmlDecl","procInstName","procInstBody","pad","comment","body","returnState","buffer","stringFromCharCode","floor","highSurrogate","lowSurrogate","MAX_SIZE","codeUnits","codePoint","Number","isFinite","RangeError","isArray","arg","objectToString","isBoolean","isNull","isNullOrUndefined","isNumber","isString","isSymbol","isUndefined","isDate","d","isError","isFunction","isPrimitive","XMLDTDElement","dtdElementValue","dtdElement","superCtor","super_","TempCtor","escapeCDATA","requiresCDATA","wrapCDATA","entry","opts","buildObject","rootObj","attrkey","charkey","render","rootElement","rootName","element","attr","raw","txt","ele","up","att","xmldec","headless","allowSurrogateChars","renderOpts","EventEmitter","assign","getValue","isEmpty","isPlainObject","sources","target","val","proto","getPrototypeOf","Function","valueOf","pna","destroy","readableDestroyed","destroyed","writableDestroyed","errorEmitted","nextTick","emitErrorNT","undestroy","ended","endEmitted","ending","finalCalled","prefinished","finished","self","XMLRaw","window","Timeout","id","clearFn","_id","_clearFn","setTimeout","scope","clearTimeout","setInterval","clearInterval","timeout","unref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","setImmediate","global","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","root","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","substringData","offset","appendData","insertData","deleteData","replaceData","fn","assertLegalName","assertLegalChar","textEscape","attEscape","convertAttKey","convertPIKey","convertTextKey","convertCDataKey","convertCommentKey","convertRawKey","regex","res","ampregex","noDoubleEncoding","XMLNamedNodeMap","getNamedItem","setNamedItem","oldNode","nodeName","removeNamedItem","getNamedItemNS","setNamedItemNS","removeNamedItemNS","_classCallCheck","instance","Constructor","TypeError","copyBuffer","src","copy","BufferList","head","tail","v","next","shift","ret","clear","concat","alloc","allocUnsafe","inspect","custom","registerImmediate","nextHandle","tasksByHandle","currentlyRunningATask","attachTo","process","installNextTickImplementation","canUsePostMessage","installPostMessageImplementation","MessageChannel","installMessageChannelImplementation","createElement","installReadyStateChangeImplementation","installSetTimeoutImplementation","callback","task","handle","run","undefined","runIfPresent","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","messagePrefix","random","onGlobalMessage","addEventListener","attachEvent","channel","port1","port2","html","documentElement","onreadystatechange","removeChild","appendChild","_vm","_c","_self","staticClass","attrs","postsnfl","postscollfootball","postsnba","postscollege","postsmlb","staticRenderFns","_v","_s","items","sliderOption","_l","staticStyle","link","pubDate","_e","components","props","dots","arrows","infinite","speed","autoplay","slidesToShow","slidesToScroll","prevArrow","nextArrow","responsive","breakpoint","settings","methods","$refs","dSlick","prev","component","Feed","created","getData","mounted","core","response","$http","RSSParser","parsed","loading","postssoccer","postsboxing","values","stripBOM","decode_json_1","output","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","buf","j","utf8CheckExtraBytes","utf8Text","total","utf8End","prefixMatch","firstCharLowerCase","stripPrefix","parseNumbers","isNaN","parseFloat","parseBooleans","test","copyProps","dst","SafeBuffer","encodingOrOffset","from","allocUnsafeSlow","size","fill","SlowBuffer","decodeXMLStrict","decodeHTML5Strict","decodeHTML4Strict","decodeHTML5","decodeHTML4","decodeHTMLStrict","decodeHTML","decodeXML","encodeHTML5","encodeHTML4","encode","decodeStrict","decode","decode_1","encode_1","encode_2","decode_2","XMLDOMErrorHandler","XMLDOMConfiguration","defaultParams","getParameter","canSetParameter","setParameter","toArrayBuffer","IncomingMessage","rStates","readyStates","decideMode","preferBinary","useFetch","capability","fetch","mozchunkedarraybuffer","msstream","arraybuffer","vbArray","ClientRequest","Writable","_opts","_body","_headers","auth","setHeader","headers","mode","abortController","overrideMimeType","_mode","_fetchTimer","_onFinish","statusValid","xhr","status","lowerName","unsafeHeaders","getHeader","header","removeHeader","_destroyed","headersObj","method","blobConstructor","Blob","map","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","substr","separateArrayItems","keepNullNodes","insertBefore","newChild","refChild","removed","isRoot","insertAfter","remove","commentBefore","commentAfter","instructionBefore","instructionAfter","rootObject","importDocument","clonedRoot","u","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","search","host","hostname","port","path","req","Agent","defaultMaxSockets","globalAgent","STATUS_CODES","METHODS","arg1","arg2","arg3","previousSibling","nextSibling","splitText","replaceWholeText","content","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","resolve","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","xs","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","fields","feed","includeSnippet","mapItunesField","f","podcastFeed","podcastItem","objectKeys","allowHalfOpen","onEndNT","deprecate","msg","config","warned","deprecated","console","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","rel","fallbackIdx","$","href","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","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","bufferedRequest","lastBufferedRequest","pendingcb","bufferedRequestCount","corkedRequestsFree","writev","_writev","final","_final","writeAfterEnd","validChunk","valid","decodeChunk","writeOrBuffer","isBuf","newChunk","last","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","clearBuffer","afterWrite","onwriteDrain","holder","allBuffers","callFinal","need","endWritable","corkReq","getBuffer","current","out","Symbol","hasInstance","object","cork","uncork","setDefaultEncoding","DEFAULT_HEADERS","DEFAULT_MAX_REDIRECTS","DEFAULT_TIMEOUT","customFields","requestOptions","maxRedirects","xmlParser","prom","buildAtomFeed","rss","buildRSS2","buildRSS1","buildRSS0_9","defaultRSS","feedUrl","redirectCount","urlParts","requestOpts","newLocation","parseURL","xmlObj","updated","lastBuildDate","parseItemAtom","published","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","isoDate","paginationRelAttributes","includes","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","ProcessEmitWarning","warning","ownKeys","getOwnPropertySymbols","NumberIsNaN","init","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","that","_addListener","prepend","existing","newListener","w","onceWrapper","fired","wrapFn","_onceWrap","wrapped","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","spliceOne","errorListener","resolver","eventTargetAgnosticAddListener","addErrorHandlerIfEventEmitter","flags","wrapListener","removeEventListener","setMaxListeners","getMaxListeners","doError","context","prependOnceListener","originalListener","off","rawListeners","eventNames"],"mappings":"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","file":"js/chunk-49c0d75a.972f6197.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","// 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","// 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","// 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","export * from \"-!../../../../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--7-oneOf-1-0!../../../../../node_modules/css-loader/dist/cjs.js??ref--7-oneOf-1-1!../../../../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../../../../node_modules/postcss-loader/src/index.js??ref--7-oneOf-1-2!../../../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Feed.vue?vue&type=style&index=0&id=6a7988f4&prod&scoped=true&lang=css&\"","// 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  // character classes and tokens\n  var whitespace = '\\r\\n\\t '\n\n  // this really needs to be replaced with character classes.\n  // XML allows all manner of ridiculous numbers and digits.\n  var number = '0124356789'\n  var letter = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'\n\n  // (Letter | \"_\" | \":\")\n  var quote = '\\'\"'\n  var attribEnd = whitespace + '>'\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  // turn all the string character sets into character class objects.\n  whitespace = charClass(whitespace)\n  number = charClass(number)\n  letter = charClass(letter)\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  quote = charClass(quote)\n  attribEnd = charClass(attribEnd)\n\n  function charClass (str) {\n    return str.split('').reduce(function (s, c) {\n      s[c] = true\n      return s\n    }, {})\n  }\n\n  function isRegExp (c) {\n    return Object.prototype.toString.call(c) === '[object RegExp]'\n  }\n\n  function is (charclass, c) {\n    return isRegExp(charclass) ? !!c.match(charclass) : charclass[c]\n  }\n\n  function not (charclass, c) {\n    return !is(charclass, 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 (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 (not(whitespace, 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      if (!c) {\n        break\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      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 (not(whitespace, 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 (is(whitespace, c)) {\n            // wait for it...\n          } else if (is(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 (is(quote, 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 (is(quote, 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 (is(quote, 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 (is(whitespace, 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 && is(whitespace, 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 (is(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 (not(whitespace, 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 (is(whitespace, c)) {\n            continue\n          } else if (c === '>') {\n            openTag(parser)\n          } else if (c === '/') {\n            parser.state = S.OPEN_TAG_SLASH\n          } else if (is(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 (is(whitespace, c)) {\n            parser.state = S.ATTRIB_NAME_SAW_WHITE\n          } else if (is(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 (is(whitespace, 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 (is(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 (is(whitespace, c)) {\n            continue\n          } else if (is(quote, 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 (is(whitespace, 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 (is(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 (not(attribEnd, 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 (is(whitespace, c)) {\n              continue\n            } else if (not(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 (is(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 (not(whitespace, 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 (is(whitespace, 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 (is(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  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      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","// 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 = require('buffer').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) {\n      if (!this._writableState) {\n        pna.nextTick(emitErrorNT, this, err);\n      } else if (!this._writableState.errorEmitted) {\n        this._writableState.errorEmitted = true;\n        pna.nextTick(emitErrorNT, this, err);\n      }\n    }\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      if (!_this._writableState) {\n        pna.nextTick(emitErrorNT, _this, err);\n      } else if (!_this._writableState.errorEmitted) {\n        _this._writableState.errorEmitted = true;\n        pna.nextTick(emitErrorNT, _this, err);\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.finalCalled = false;\n    this._writableState.prefinished = 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    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","var render = function render(){var _vm=this,_c=_vm._self._c;return _c('main',{staticClass:\"site-main\",attrs:{\"id\":\"main\"}},[_c('Feed',{attrs:{\"items\":_vm.postsnfl,\"name\":\"NFL News\"}}),_c('Feed',{attrs:{\"items\":_vm.postscollfootball,\"name\":\"College Football News\"}}),_c('Feed',{attrs:{\"items\":_vm.postsnba,\"name\":\"NBA News\"}}),_c('Feed',{attrs:{\"items\":_vm.postscollege,\"name\":\"College Basketball News\"}}),_c('Feed',{attrs:{\"items\":_vm.postsmlb,\"name\":\"MLB News\"}})],1)\n}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","var render = function render(){var _vm=this,_c=_vm._self._c;return _c('section',{attrs:{\"id\":\"iq-suggestede\"}},[_c('b-container',[_c('b-row',[_c('b-col',{staticClass:\"overflow-hidden\",attrs:{\"sm\":\"12\"}},[_c('div',{staticClass:\"iq-main-header d-flex align-items-center justify-content-between\"},[_c('h2',{staticClass:\"iq-title text-capitalize\"},[_vm._v(\" \"+_vm._s(_vm.name)+\" \")])]),_c('div',{staticClass:\"favorites-contens\"},[(_vm.items.length)?_c('Slick',{ref:\"dSlick\",staticClass:\"favorites-slider list-inline row p-0 mb-0\",attrs:{\"option\":_vm.sliderOption}},_vm._l((_vm.items),function(item,index){return _c('li',{key:index,staticClass:\"slide-item\"},[_c('v-card',{staticClass:\"rounded-card\",attrs:{\"color\":\"rgb(50, 50, 50, 1.0)\",\"elevation\":\"24\"}},[_c('div',{staticClass:\"blog-item\"},[_c('v-card-text',[_c('div',{staticStyle:{\"color\":\"white\"}},[_vm._v(\"Yahoo! Sports\")]),_c('v-card-title',[_c('a',{staticStyle:{\"color\":\"white\"},attrs:{\"href\":item.link,\"target\":\"_blank\"}},[_c('strong',[_vm._v(\" \"+_vm._s(item.title.length > 70 ? item.title.substring(0,70)+\"...\" : item.title)+\" \")])])]),_c('div',{staticStyle:{\"color\":\"white\"}},[_vm._v(_vm._s(item.pubDate))])],1)],1)])],1)}),0):_vm._e(),_c('svg',{staticStyle:{\"display\":\"none\"},attrs:{\"xmlns\":\"http://www.w3.org/2000/svg\"}},[_c('symbol',{attrs:{\"xmlns\":\"http://www.w3.org/2000/svg\",\"viewBox\":\"0 0 2 2\",\"width\":\"4px\",\"height\":\"4px\",\"id\":\"circle\",\"fill\":\"none\",\"stroke\":\"currentColor\"}},[_c('circle',{attrs:{\"r\":\"2\",\"cy\":\"2\",\"cx\":\"2\",\"id\":\"test\"}})])])],1)])],1)],1)],1)\n}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","<template>\n  <section id=\"iq-suggestede\">\n    <b-container>\n      <b-row>\n        <b-col sm=\"12\" class=\"overflow-hidden\">\n          <div\n            class=\"iq-main-header d-flex align-items-center justify-content-between\"\n          >\n            <h2 class=\"iq-title text-capitalize\">\n              {{ name }}\n            </h2>\n          </div>\n          <div class=\"favorites-contens\">\n            <Slick\n              class=\"favorites-slider list-inline  row p-0 mb-0\"\n              ref=\"dSlick\"\n              :option=\"sliderOption\"\n              v-if=\"items.length\"\n            >\n              <li\n                class=\"slide-item\"\n                v-for=\"(item, index) in items\"\n                :key=\"index\"\n              >\n                <v-card\n                  color=\"rgb(50, 50, 50, 1.0)\"\n                  elevation=\"24\"\n                  class=\"rounded-card\"\n                >\n                  <div class=\"blog-item\">\n                    <v-card-text>\n                      <div style=\"color:white\">Yahoo! Sports</div>\n                      <v-card-title>\n                        <a\n                          :href=\"item.link\"\n                          style=\"color:white\"\n                          target=\"_blank\"\n                        >\n                          <strong> {{ item.title.length > 70 ? item.title.substring(0,70)+\"...\" : item.title  }} </strong>\n                        </a>\n                      </v-card-title>\n                      <div style=\"color:white\">{{ item.pubDate }}</div>\n                    </v-card-text>\n                  </div>\n                </v-card>\n              </li>\n            </Slick>\n            <svg xmlns=\"http://www.w3.org/2000/svg\" style=\"display: none;\">\n              <symbol\n                xmlns=\"http://www.w3.org/2000/svg\"\n                viewBox=\"0 0 2 2\"\n                width=\"4px\"\n                height=\"4px\"\n                id=\"circle\"\n                fill=\"none\"\n                stroke=\"currentColor\"\n              >\n                <circle r=\"2\" cy=\"2\" cx=\"2\" id=\"test\"></circle>\n              </symbol>\n            </svg>\n          </div>\n        </b-col>\n      </b-row>\n    </b-container>\n  </section>\n</template>\n\n<script>\nexport default {\n  name: 'Feed',\n  components: {},\n  props: {\n    items: Array,\n    name: String\n  },\n  data() {\n    return {\n      sliderOption: {\n        dots: false,\n        arrows: true,\n        infinite: true,\n        speed: 300,\n        autoplay: false,\n        slidesToShow: 3,\n        slidesToScroll: 1,\n        prevArrow: '<div class=\"slick-prev slick-arrow\"><i class=\"fa fa-chevron-left\"></i></div>',\n        nextArrow: '<div class=\"slick-next slick-arrow\"><i class=\"fa fa-chevron-right\"></i></div>',\n        responsive: [\n          {\n            breakpoint: 1200,\n            settings: {\n              slidesToShow: 3,\n              slidesToScroll: 1,\n              infinite: true,\n              dots: true\n            }\n          },\n          {\n            breakpoint: 768,\n            settings: {\n              slidesToShow: 2,\n              slidesToScroll: 1\n            }\n          },\n          {\n            breakpoint: 480,\n            settings: {\n              slidesToShow: 1,\n              slidesToScroll: 1\n            }\n          }\n        ]\n      }\n    }\n  },\n  methods: {\n    next() {\n      this.$refs.dSlick.next()\n    },\n    prev() {\n      this.$refs.dSlick.prev()\n    }\n  }\n}\n</script>\n\n<style scoped>\n.v-card__text,\n.v-card__title {\n  word-break: normal; /* maybe !important  */\n}\n.v-card--reveal {\n  bottom: 0;\n  opacity: 1 !important;\n  position: absolute;\n  width: 100%;\n}\n.rounded-card {\n  border-radius: 10px;\n}\n\n.blog-item {\n  position: relative;\n  height: 200px;\n  /*overflow-y: scroll;*/\n}\n\n.blog-post-title {\n  color: #f2b636;\n  font-size: 18px;\n  margin-top: 18px;\n  margin-bottom: 15px;\n}\n\n.blog-post-info p,\n.post-event a {\n  font-size: 14px;\n}\n\n.blog-post-info p {\n  margin-bottom: 14px;\n}\n\n.blog-category {\n  position: relative;\n  padding-left: 15px;\n  margin-left: 10px;\n}\n\n.blog-category::before {\n  content: \"\";\n  position: absolute;\n  top: 5px;\n  left: 0;\n  height: 12px;\n  width: 2px;\n  background-color: #969696;\n}\n\n.blog-btn {\n  padding: 10px 20px;\n}\n\n.blog-post-image {\n  display: block;\n  overflow: hidden;\n  position: relative;\n}\n\n.blog-post-image::after {\n  content: \"\";\n  width: 0;\n  height: 4px;\n  bottom: 0;\n  position: absolute;\n  left: auto;\n  right: 0;\n  -webkit-transition: width 0.6s cubic-bezier(0.25, 0.8, 0.25, 1) 0s;\n  -o-transition: width 0.6s cubic-bezier(0.25, 0.8, 0.25, 1) 0s;\n  transition: width 0.6s cubic-bezier(0.25, 0.8, 0.25, 1) 0s;\n  background: #f2b636;\n}\n\n.blog-item:hover .blog-post-image::after {\n  width: 100%;\n  left: 0;\n  right: auto;\n}\n\n.blog-post-image img {\n  -webkit-transition: all 0.3s cubic-bezier(0.645, 0.045, 0.355, 1);\n  -o-transition: all 0.3s cubic-bezier(0.645, 0.045, 0.355, 1);\n  transition: all 0.3s cubic-bezier(0.645, 0.045, 0.355, 1);\n}\n\n.blog-item:hover .blog-post-image img {\n  width: 100%;\n  -webkit-transform: scale3d(1.1, 1.1, 1.1);\n  transform: scale3d(1.1, 1.1, 1.1);\n}\n\n.pagination li {\n  margin: 0 5px;\n}\n\n.pagination li a {\n  height: 40px;\n  width: 40px;\n  display: flex;\n  vertical-align: top;\n  background: #314584;\n  color: #fff;\n  border: #314584;\n  justify-content: center;\n  align-items: center;\n}\n\n.page-item.active .page-link,\n.page-item:hover .page-link {\n  background: #f2b636;\n  border: #f2b636;\n  color: #fff;\n}\n\n.blog-post-info {\n  padding: 0 20px 10px;\n}\n\n.blog-read-more {\n  position: absolute;\n  bottom: -30px;\n  left: 50%;\n  -webkit-transform: translate(-50%);\n  -ms-transform: translate(-50%);\n  transform: translate(-50%);\n  font-size: 20px;\n  width: 60px;\n  height: 60px;\n  line-height: 60px;\n  border-radius: 50%;\n  background-color: #fff;\n  border: 2px solid #314584;\n  color: #314584;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  -webkit-transition: all 0.3s ease;\n  transition: all 0.3s ease;\n  z-index: 1;\n}\n\n.blog-item:hover .blog-read-more {\n  background-color: #f2b636;\n  border: 2px solid #f2b636;\n  color: #fff;\n}\n</style>\n","import mod from \"-!../../../../../node_modules/cache-loader/dist/cjs.js??ref--13-0!../../../../../node_modules/thread-loader/dist/cjs.js!../../../../../node_modules/babel-loader/lib/index.js!../../../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Feed.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../../../../node_modules/cache-loader/dist/cjs.js??ref--13-0!../../../../../node_modules/thread-loader/dist/cjs.js!../../../../../node_modules/babel-loader/lib/index.js!../../../../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Feed.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./Feed.vue?vue&type=template&id=6a7988f4&scoped=true&\"\nimport script from \"./Feed.vue?vue&type=script&lang=js&\"\nexport * from \"./Feed.vue?vue&type=script&lang=js&\"\nimport style0 from \"./Feed.vue?vue&type=style&index=0&id=6a7988f4&prod&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  \"6a7988f4\",\n  null\n  \n)\n\nexport default component.exports","<template>\n <main id=\"main\" class=\"site-main\">\n <Feed :items=\"postsnfl\" name=\"NFL News\" />\n <Feed :items=\"postscollfootball\" name=\"College Football News\" />\n <Feed :items=\"postsnba\" name=\"NBA News\"/>\n <Feed :items=\"postscollege\" name=\"College Basketball News\" />\n <Feed :items=\"postsmlb\" name=\"MLB News\" />\n </main>\n</template>\n<script>\nimport Feed from './Components/NLSE/Feed.vue'\nimport { core } from '../../config/pluginInit'\nimport RSSParser from 'rss-parser'\nexport default {\n\tname: 'Rssfeed',\n\tcomponents: {\n\t\tFeed\n\t},\n\tcreated() {\n\t\tthis.getData()\n\t},\n\tmounted () {\n    core.index()\n\t},\n\tmethods: {\n\t\tasync getData() {\n\t\t\ttry {\n\t\t\t\tconst response = await this.$http.get('https://dev-rss.nlse.com/nba/rss/')\n\t\t\t\tconst parser = new RSSParser()\n          \t\tparser.parseString(response.data, (err, parsed) => {\n            \t\tthis.loading = false\n           \t\t\tif (err) {\n\t\t\t\t\t\t// console.log(err) \n\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis.postsnba = parsed.items.slice(0, 10)\n\t\t\t\t\t\t\t// console.log(this.postsnba)\t\t\t\t\t\t\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t} catch (error) {\n\t\t\t\t// console.log(error)\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tconst response = await this.$http.get('https://dev-rss.nlse.com/mlb/rss/')\n\t\t\t\tconst parser = new RSSParser()\n          \t\tparser.parseString(response.data, (err, parsed) => {\n            \t\tthis.loading = false\n           \t\t\tif (err) {\n\t\t\t\t\t\t// console.log(err) \n\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis.postsmlb = parsed.items.slice(0, 10)\n\t\t\t\t\t\t\t// console.log(this.posts)\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t} catch (error) {\n\t\t\t\t// console.log(error)\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tconst response = await this.$http.get('https://dev-rss.nlse.com/nfl/rss/')\n\t\t\t\tconst parser = new RSSParser()\n          \t\tparser.parseString(response.data, (err, parsed) => {\n            \t\tthis.loading = false\n           \t\t\tif (err) {\n\t\t\t\t\t\t// console.log(err) \n\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis.postsnfl = parsed.items.slice(0, 10)\n\t\t\t\t\t\t\t// console.log(this.posts)\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t} catch (error) {\n\t\t\t\t// console.log(error)\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tconst response = await this.$http.get('https://dev-rss.nlse.com/college-basketball/rss/')\n\t\t\t\tconst parser = new RSSParser()\n          \t\tparser.parseString(response.data, (err, parsed) => {\n            \t\tthis.loading = false\n           \t\t\tif (err) {\n\t\t\t\t\t\t// console.log(err) \n\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis.postscollege = parsed.items.slice(0, 10)\n\t\t\t\t\t\t\t// console.log(this.postscollege)\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t} catch (error) {\n\t\t\t\t// console.log(error)\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tconst response = await this.$http.get('https://dev-rss.nlse.com/soccer/rss/')\n\t\t\t\tconst parser = new RSSParser()\n          \t\tparser.parseString(response.data, (err, parsed) => {\n            \t\tthis.loading = false\n           \t\t\tif (err) {\n\t\t\t\t\t\t// console.log(err) \n\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis.postssoccer = parsed.items.slice(0, 10)\n\t\t\t\t\t\t\t// console.log(this.postssoccer)\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t} catch (error) {\n\t\t\t\t// console.log(error)\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tconst response = await this.$http.get('http://localhost:3000/college-football/rss/')\n\t\t\t\tconst parser = new RSSParser()\n          \t\tparser.parseString(response.data, (err, parsed) => {\n            \t\tthis.loading = false\n           \t\t\tif (err) {\n\t\t\t\t\t\t// console.log(err) \n\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthis.postscollfootball = parsed.items.slice(0, 10)\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t} catch (error) {\n\t\t\t\t// console.log(error)\n\t\t\t}\n\t\t}\n\t},\n\tdata() {\n    return {\n\t  postsnba: [],\n\t  postsmlb: [],\n\t  postsnfl: [],\n\t  postscollege: [],\n\t  postssoccer: [],\n\t  postsboxing: [],\n\t  postscollfootball: [],\n\t  values: null\n    }\n  }\n}\n</script>\n","import mod from \"-!../../../node_modules/cache-loader/dist/cjs.js??ref--13-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/cache-loader/dist/cjs.js??ref--1-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--13-0!../../../node_modules/thread-loader/dist/cjs.js!../../../node_modules/babel-loader/lib/index.js!../../../node_modules/cache-loader/dist/cjs.js??ref--1-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=df5f6f76&\"\nimport script from \"./Rssfeed.vue?vue&type=script&lang=js&\"\nexport * from \"./Rssfeed.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  null,\n  null\n  \n)\n\nexport default component.exports","// 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","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\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\nSafeBuffer.prototype = Object.create(Buffer.prototype)\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  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","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","// 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 = Object.create(null);\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] = Object.create(null);\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            if (typeof _this.options.emptyTag === 'function') {\n              obj = _this.options.emptyTag();\n            } else {\n              obj = _this.options.emptyTag !== '' ? _this.options.emptyTag : emptyStr;\n            }\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 = Object.create(null);\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 = Object.create(null);\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 = Object.create(null);\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 = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).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', state.awaitDrain);\n        state.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, { hasUnpiped: false });\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","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  'episodeType'\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};","// 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 = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).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.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) 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\n  // reuse the free corkReq.\n  state.corkedRequestsFree.next = corkReq;\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};","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","// 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.$ && xmlItem.$['rdf:about']) {\n      item['rdf:about'] = xmlItem.$['rdf:about']\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 && category.$ && category.$.text,\n          subs: category['itunes:category'] ?\n            category['itunes:category']\n              .map((subcategory) => ({\n                name: subcategory && subcategory.$ && subcategory.$.text\n              })) : 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 && 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":""}