{"version":3,"sources":["../node_modules/htmlparser2/lib/index.js","../node_modules/domelementtype/index.js","../node_modules/inherits/inherits_browser.js","../node_modules/react-html-parser/lib/processNodes.js","../node_modules/react-html-parser/lib/convertNodeToElement.js","../node_modules/htmlparser2/lib/Parser.js","../node_modules/htmlparser2/lib/Tokenizer.js","../node_modules/domhandler/index.js","../node_modules/domhandler/lib/node.js","../node_modules/domutils/index.js","../node_modules/dom-serializer/node_modules/entities/lib/decode.js","../node_modules/dom-serializer/node_modules/entities/lib/encode.js","../node_modules/htmlparser2/lib/WritableStream.js","../node_modules/node-libs-browser/node_modules/buffer/index.js","../node_modules/react-html-parser/lib/utils/generatePropsFromAttributes.js","../node_modules/react-html-parser/lib/utils/isValidTagOrAttributeName.js","../node_modules/react-html-parser/lib/index.js","../node_modules/react-html-parser/lib/utils/isEmptyTextNode.js","../node_modules/react-html-parser/lib/elementTypes/index.js","../node_modules/entities/lib/decode_codepoint.js","../node_modules/events/events.js","../node_modules/domhandler/lib/element.js","../node_modules/htmlparser2/lib/FeedHandler.js","../node_modules/domutils/lib/stringify.js","../node_modules/dom-serializer/index.js","../node_modules/dom-serializer/node_modules/domelementtype/lib/index.js","../node_modules/dom-serializer/node_modules/entities/lib/index.js","../node_modules/dom-serializer/node_modules/entities/lib/decode_codepoint.js","../node_modules/domutils/lib/traversal.js","../node_modules/domutils/lib/manipulation.js","../node_modules/domutils/lib/querying.js","../node_modules/domutils/lib/legacy.js","../node_modules/domutils/lib/helpers.js","../node_modules/htmlparser2/lib/Stream.js","../node_modules/string_decoder/lib/string_decoder.js","../node_modules/safe-buffer/index.js","../node_modules/base64-js/index.js","../node_modules/ieee754/index.js","../node_modules/node-libs-browser/node_modules/isarray/index.js","../node_modules/htmlparser2/lib/ProxyHandler.js","../node_modules/htmlparser2/lib/CollectingHandler.js","../node_modules/react-html-parser/lib/elementTypes/TextElementType.js","../node_modules/react-html-parser/lib/elementTypes/TagElementType.js","../node_modules/react-html-parser/lib/utils/htmlAttributesToReact.js","../node_modules/react-html-parser/lib/dom/attributes/BooleanAttributes.js","../node_modules/react-html-parser/lib/dom/attributes/ReactAttributes.js","../node_modules/react-html-parser/lib/utils/inlineStyleToObject.js","../node_modules/react-html-parser/lib/dom/elements/VoidElements.js","../node_modules/react-html-parser/lib/elementTypes/StyleElementType.js","../node_modules/react-html-parser/lib/elementTypes/UnsupportedElementType.js","../node_modules/react-html-parser/lib/HtmlParser.js"],"names":["Parser","DomHandler","defineProp","name","value","module","exports","Tokenizer","ElementType","DefaultHandler","this","FeedHandler","parseDOM","data","options","handler","end","dom","parseFeed","feed","createDomStream","cb","elementCb","EVENTS","attribute","cdatastart","cdataend","text","processinginstruction","comment","commentend","closetag","opentag","opentagname","error","Text","Directive","Comment","Script","Style","Tag","CDATA","Doctype","isTag","elem","type","Object","create","ctor","superCtor","super_","prototype","constructor","enumerable","writable","configurable","TempCtor","defineProperty","default","nodes","transform","filter","node","_isEmptyTextNode2","map","index","transformed","_convertNodeToElement2","_interopRequireDefault","obj","__esModule","_elementTypes2","_elementTypes","formTags","input","option","optgroup","select","button","datalist","textarea","openImpliesClose","tr","th","td","thead","body","head","link","script","li","p","h1","h2","h3","h4","h5","h6","output","voidElements","__proto__","area","base","basefont","br","col","command","embed","frame","hr","img","isindex","keygen","meta","param","source","track","wbr","foreignContextElements","math","svg","htmlIntegrationElements","mi","mo","mn","ms","mtext","foreignObject","desc","title","re_nameEnd","cbs","_options","_cbs","_tagname","_attribname","_attribvalue","_attribs","_stack","_foreignContext","startIndex","endIndex","_lowerCaseTagNames","lowerCaseTags","xmlMode","_lowerCaseAttributeNames","lowerCaseAttributeNames","_tokenizer","onparserinit","EventEmitter","_updatePosition","initialOffset","_sectionStart","getAbsoluteIndex","ontext","onopentagname","toLowerCase","el","length","onclosetag","push","onopentag","onopentagend","pop","_closeCurrentTag","pos","lastIndexOf","onselfclosingtag","recognizeSelfClosing","onattribname","onattribdata","onattribend","onattribute","hasOwnProperty","call","_getInstructionName","idx","search","substr","ondeclaration","onprocessinginstruction","oncomment","oncommentend","oncdata","recognizeCDATA","oncdatastart","oncdataend","onerror","err","onend","i","reset","onreset","parseComplete","write","chunk","pause","resume","parseChunk","done","decodeCodePoint","entityMap","legacyMap","xmlMap","TEXT","BEFORE_TAG_NAME","IN_TAG_NAME","IN_SELF_CLOSING_TAG","BEFORE_CLOSING_TAG_NAME","IN_CLOSING_TAG_NAME","AFTER_CLOSING_TAG_NAME","BEFORE_ATTRIBUTE_NAME","IN_ATTRIBUTE_NAME","AFTER_ATTRIBUTE_NAME","BEFORE_ATTRIBUTE_VALUE","IN_ATTRIBUTE_VALUE_DQ","IN_ATTRIBUTE_VALUE_SQ","IN_ATTRIBUTE_VALUE_NQ","BEFORE_DECLARATION","IN_DECLARATION","IN_PROCESSING_INSTRUCTION","BEFORE_COMMENT","IN_COMMENT","AFTER_COMMENT_1","AFTER_COMMENT_2","BEFORE_CDATA_1","BEFORE_CDATA_2","BEFORE_CDATA_3","BEFORE_CDATA_4","BEFORE_CDATA_5","BEFORE_CDATA_6","IN_CDATA","AFTER_CDATA_1","AFTER_CDATA_2","BEFORE_SPECIAL","BEFORE_SPECIAL_END","BEFORE_SCRIPT_1","BEFORE_SCRIPT_2","BEFORE_SCRIPT_3","BEFORE_SCRIPT_4","BEFORE_SCRIPT_5","AFTER_SCRIPT_1","AFTER_SCRIPT_2","AFTER_SCRIPT_3","AFTER_SCRIPT_4","AFTER_SCRIPT_5","BEFORE_STYLE_1","BEFORE_STYLE_2","BEFORE_STYLE_3","BEFORE_STYLE_4","AFTER_STYLE_1","AFTER_STYLE_2","AFTER_STYLE_3","AFTER_STYLE_4","BEFORE_ENTITY","BEFORE_NUMERIC_ENTITY","IN_NAMED_ENTITY","IN_NUMERIC_ENTITY","IN_HEX_ENTITY","j","SPECIAL_NONE","SPECIAL_SCRIPT","SPECIAL_STYLE","whitespace","c","ifElseState","upper","SUCCESS","FAILURE","lower","_state","_index","consumeSpecialNameChar","NEXT_STATE","_buffer","_bufferOffset","_baseState","_special","_running","_ended","_xmlMode","_decodeEntities","decodeEntities","_stateText","_getSection","_stateBeforeTagName","_stateInTagName","_emitToken","_stateBeforeCloseingTagName","_stateInCloseingTagName","_stateAfterCloseingTagName","_stateBeforeAttributeName","_stateInSelfClosingTag","_stateInAttributeName","_stateAfterAttributeName","_stateBeforeAttributeValue","_stateInAttributeValueDoubleQuotes","_stateInAttributeValueSingleQuotes","_stateInAttributeValueNoQuotes","_stateBeforeDeclaration","_stateInDeclaration","_stateInProcessingInstruction","_stateBeforeComment","_stateInComment","_stateAfterComment1","_stateAfterComment2","substring","_stateBeforeCdata1","_stateBeforeCdata2","_stateBeforeCdata3","_stateBeforeCdata4","_stateBeforeCdata5","_stateBeforeCdata6","_stateInCdata","_stateAfterCdata1","_stateAfterCdata2","_stateBeforeSpecial","_stateBeforeSpecialEnd","_stateBeforeScript1","_stateBeforeScript2","_stateBeforeScript3","_stateBeforeScript4","_stateBeforeScript5","_stateAfterScript1","_stateAfterScript2","_stateAfterScript3","_stateAfterScript4","_stateAfterScript5","_stateBeforeStyle1","_stateBeforeStyle2","_stateBeforeStyle3","_stateBeforeStyle4","_stateAfterStyle1","_stateAfterStyle2","_stateAfterStyle3","_stateAfterStyle4","_stateBeforeEntity","_stateBeforeNumericEntity","_parseNamedEntityStrict","entity","_emitPartial","_parseLegacyEntity","start","limit","_stateInNamedEntity","_decodeNumericEntity","offset","sectionStart","parsed","parseInt","_stateInNumericEntity","_stateInHexEntity","_cleanup","Error","_parse","charAt","_finish","_handleTrailingData","re_whitespace","NodePrototype","ElementPrototype","callback","elementCB","defaultOpts","_callback","_elementCB","_done","_tagStack","_parser","normalizeWhitespace","withStartIndices","withEndIndices","parser","_handleCallback","_createDomElement","properties","withDomLvl1","element","key","_addDomElement","parent","siblings","children","previousSibling","next","prev","attribs","lastTag","normalize","ignoreWhitespace","replace","nodeTypes","domLvl1","tagName","childNodes","parentNode","nextSibling","nodeValue","cdata","keys","forEach","shorthand","get","set","val","DomUtils","ext","bind","__importDefault","mod","entities_json_1","legacy_json_1","xml_json_1","decode_codepoint_1","getStrictDecoder","join","getReplacer","re","RegExp","str","String","decodeXML","decodeHTMLStrict","sorter","a","b","slice","decodeHTML","legacy","sort","replacer","inverseXML","getInverseObj","xmlReplacer","getInverseReplacer","encodeXML","getInverse","inverseHTML","htmlReplacer","reduce","inverse","single","multiple","k","unshift","encodeHTML","reNonASCII","reAstralSymbols","singleCharReplacer","charCodeAt","toString","toUpperCase","astralReplacer","_","reXmlChars","escape","Stream","WritableStream","Writable","StringDecoder","Buffer","decoder","_decoder","decodeStrings","once","_write","encoding","base64","ieee754","isArray","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","Uint8Array","arg","encodingOrOffset","allocUnsafe","from","TypeError","ArrayBuffer","array","byteOffset","byteLength","undefined","fromArrayLike","fromArrayBuffer","string","isEncoding","actual","fromString","isBuffer","len","checked","copy","buffer","fromObject","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","m","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","indexOf","arr","indexSize","arrLength","valLength","read","buf","readUInt16BE","foundIndex","found","hexWrite","Number","remaining","strLen","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","fromByteArray","Math","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","fromCharCode","apply","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","foo","subarray","e","typedArraySupport","poolSize","_augment","Symbol","species","fill","allocUnsafeSlow","_isBuffer","compare","x","y","concat","list","swap16","swap32","swap64","arguments","equals","inspect","max","match","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","Array","_arr","ret","out","toHex","bytes","checkOffset","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","code","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","trim","stringtrim","base64clean","src","dst","_extends","assign","attributes","props","_htmlAttributesToReact2","style","_inlineStyleToObject2","nameCache","VALID_TAG_REGEX","test","htmlparser2","convertNodeToElement","processNodes","_processNodes","_convertNodeToElement","_htmlparser","_HtmlParser2","_ElementType$Text$Ele","_TextElementType2","_TagElementType2","_StyleElementType2","_UnsupportedElementType2","_defineProperty","decodeMap","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","args","Function","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","init","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","_addListener","prepend","events","existing","warning","newListener","emit","warned","w","emitter","count","console","warn","onceWrapper","fired","removeListener","wrapFn","_onceWrap","state","wrapped","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","getPrototypeOf","setMaxListeners","getMaxListeners","doError","er","message","context","listeners","addListener","on","prependListener","prependOnceListener","position","originalListener","shift","spliceOne","off","removeAllListeners","rawListeners","eventNames","getElements","what","where","getElementsByTagName","getOneElement","fetch","recurse","getText","addConditionally","prop","tmp","isValidFeed","childs","feedRoot","href","updated","Date","items","item","entry","description","pubDate","id","getOuterHTML","getInnerHTML","opts","entities","foreignNames","elementNames","attributeNames","unencodedElements","xmp","iframe","noembed","noframes","plaintext","noscript","singleTag","render","cheerio","renderTag","renderDirective","renderComment","renderCdata","renderText","foreignModeIntegrationPoints","tag","formatAttrs","decode_1","encode_1","decode","level","decodeStrict","encode","encode_2","encodeHTML4","encodeHTML5","decode_2","decodeHTML4","decodeHTML5","decodeHTML4Strict","decodeHTML5Strict","decodeXMLStrict","decode_json_1","getChildren","getParent","getSiblings","getAttributeValue","hasAttrib","getName","removeElement","splice","replaceElement","replacement","appendChild","child","sibling","append","currNext","find","elems","result","findOneChild","l","findOne","existsOne","findAll","rootElems","stack","testElement","tag_name","tag_type","tag_contains","Checks","getAttribCheck","attrib","combineFuncs","funcs","getElementById","getElementsByTagType","removeSubsets","ancestor","POSITION","comparePos","compareDocumentPosition","nodeA","nodeB","current","sharedParent","aSibling","bSibling","aParents","bParents","uniqueSort","relative","Cbs","scope","readable","nb","enc","nenc","retried","_normalizeEncoding","normalizeEncoding","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","r","self","utf8CheckExtraBytes","total","utf8CheckIncomplete","copyProps","SafeBuffer","b64","lens","getLens","validLen","placeHoldersLen","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","parts","len2","encodeChunk","lookup","num","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","d","s","NaN","rt","abs","log","LN2","ProxyHandler","CollectingHandler","restart","_isValidTagOrAttributeName2","_generatePropsFromAttributes2","_VoidElements2","_processNodes2","_react2","createElement","attr","mappedAttributes","lowerCaseAttribute","_ReactAttributes2","_BooleanAttributes2","getParsedAttributeValue","accept","accesskey","action","allowfullscreen","allowtransparency","alt","as","async","autocomplete","autoplay","capture","cellpadding","cellspacing","charset","challenge","cite","classid","class","cols","colspan","content","contenteditable","contextmenu","controls","controlsList","coords","crossorigin","datetime","defer","disabled","download","draggable","enctype","form","formaction","formenctype","formmethod","formnovalidate","formtarget","frameborder","headers","height","hidden","high","hreflang","for","icon","inputmode","integrity","is","keyparams","keytype","kind","label","lang","loop","low","manifest","marginheight","marginwidth","maxlength","media","mediagroup","method","minlength","muted","nonce","novalidate","open","optimum","pattern","placeholder","playsinline","poster","preload","profile","radiogroup","readonly","referrerpolicy","rel","required","reversed","role","rows","rowspan","sandbox","scoped","scrolling","seamless","selected","shape","sizes","slot","span","spellcheck","srcdoc","srclang","srcset","step","summary","tabindex","usemap","width","wmode","wrap","about","datatype","inlist","prefix","property","resource","typeof","vocab","autocapitalize","autocorrect","autosave","color","itemprop","itemscope","itemtype","itemid","itemref","results","security","unselectable","_slicedToArray","iterator","_n","_d","_e","_s","_i","sliceIterator","inlineStyle","split","styleObject","stylePropertyValue","_stylePropertyValue$s","_stylePropertyValue$s2","character","styles","html","_ref","_ref$decodeEntities","_ref$preprocessNodes","preprocessNodes","_htmlparser2"],"mappings":"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","file":"assets/js/vendors-pages-ArticleListingPage.chunk.js?cb=77c5d8e469257b445f81","sourcesContent":["var Parser = require(\"./Parser.js\");\nvar DomHandler = require(\"domhandler\");\n\nfunction defineProp(name, value) {\n    delete module.exports[name];\n    module.exports[name] = value;\n    return value;\n}\n\nmodule.exports = {\n    Parser: Parser,\n    Tokenizer: require(\"./Tokenizer.js\"),\n    ElementType: require(\"domelementtype\"),\n    DomHandler: DomHandler,\n    get FeedHandler() {\n        return defineProp(\"FeedHandler\", require(\"./FeedHandler.js\"));\n    },\n    get Stream() {\n        return defineProp(\"Stream\", require(\"./Stream.js\"));\n    },\n    get WritableStream() {\n        return defineProp(\"WritableStream\", require(\"./WritableStream.js\"));\n    },\n    get ProxyHandler() {\n        return defineProp(\"ProxyHandler\", require(\"./ProxyHandler.js\"));\n    },\n    get DomUtils() {\n        return defineProp(\"DomUtils\", require(\"domutils\"));\n    },\n    get CollectingHandler() {\n        return defineProp(\n            \"CollectingHandler\",\n            require(\"./CollectingHandler.js\")\n        );\n    },\n    // For legacy support\n    DefaultHandler: DomHandler,\n    get RssHandler() {\n        return defineProp(\"RssHandler\", this.FeedHandler);\n    },\n    //helper methods\n    parseDOM: function(data, options) {\n        var handler = new DomHandler(options);\n        new Parser(handler, options).end(data);\n        return handler.dom;\n    },\n    parseFeed: function(feed, options) {\n        var handler = new module.exports.FeedHandler(options);\n        new Parser(handler, options).end(feed);\n        return handler.dom;\n    },\n    createDomStream: function(cb, options, elementCb) {\n        var handler = new DomHandler(cb, options, elementCb);\n        return new Parser(handler, options);\n    },\n    // List of all events that the parser emits\n    EVENTS: {\n        /* Format: eventname: number of arguments */\n        attribute: 2,\n        cdatastart: 0,\n        cdataend: 0,\n        text: 1,\n        processinginstruction: 2,\n        comment: 1,\n        commentend: 0,\n        closetag: 1,\n        opentag: 2,\n        opentagname: 1,\n        error: 1,\n        end: 0\n    }\n};\n","//Types of elements found in the DOM\nmodule.exports = {\n\tText: \"text\", //Text\n\tDirective: \"directive\", //<? ... ?>\n\tComment: \"comment\", //<!-- ... -->\n\tScript: \"script\", //<script> tags\n\tStyle: \"style\", //<style> tags\n\tTag: \"tag\", //Any tag\n\tCDATA: \"cdata\", //<![CDATA[ ... ]]>\n\tDoctype: \"doctype\",\n\n\tisTag: function(elem){\n\t\treturn elem.type === \"tag\" || elem.type === \"script\" || elem.type === \"style\";\n\t}\n};\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = processNodes;\n\nvar _isEmptyTextNode = require('./utils/isEmptyTextNode');\n\nvar _isEmptyTextNode2 = _interopRequireDefault(_isEmptyTextNode);\n\nvar _convertNodeToElement = require('./convertNodeToElement');\n\nvar _convertNodeToElement2 = _interopRequireDefault(_convertNodeToElement);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Processes the nodes generated by htmlparser2 and convert them all into React elements\n *\n * @param {Object[]} nodes List of nodes to process\n * @param {Function} transform Transform function to optionally apply to nodes\n * @returns {React.Element[]} The list of processed React elements\n */\nfunction processNodes(nodes, transform) {\n\n  return nodes.filter(function (node) {\n    return !(0, _isEmptyTextNode2.default)(node);\n  }).map(function (node, index) {\n\n    // return the result of the transform function if applicable\n    var transformed = void 0;\n    if (typeof transform === 'function') {\n      transformed = transform(node, index);\n      if (transformed === null || !!transformed) {\n        return transformed;\n      }\n    }\n\n    // otherwise convert the node as standard\n    return (0, _convertNodeToElement2.default)(node, index, transform);\n  });\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = convertNodeToElement;\n\nvar _elementTypes = require('./elementTypes');\n\nvar _elementTypes2 = _interopRequireDefault(_elementTypes);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Converts a htmlparser2 node to a React element\n *\n * @param {Object} node The htmlparser2 node to convert\n * @param {Number} index The index of the current node\n * @param {Function} transform Transform function to apply to children of the node\n * @returns {React.Element}\n */\nfunction convertNodeToElement(node, index, transform) {\n  return _elementTypes2.default[node.type](node, index, transform);\n}","var Tokenizer = require(\"./Tokenizer.js\");\n\n/*\n\tOptions:\n\n\txmlMode: Disables the special behavior for script/style tags (false by default)\n\tlowerCaseAttributeNames: call .toLowerCase for each attribute name (true if xmlMode is `false`)\n\tlowerCaseTags: call .toLowerCase for each tag name (true if xmlMode is `false`)\n*/\n\n/*\n\tCallbacks:\n\n\toncdataend,\n\toncdatastart,\n\tonclosetag,\n\toncomment,\n\toncommentend,\n\tonerror,\n\tonopentag,\n\tonprocessinginstruction,\n\tonreset,\n\tontext\n*/\n\nvar formTags = {\n    input: true,\n    option: true,\n    optgroup: true,\n    select: true,\n    button: true,\n    datalist: true,\n    textarea: true\n};\n\nvar openImpliesClose = {\n    tr: { tr: true, th: true, td: true },\n    th: { th: true },\n    td: { thead: true, th: true, td: true },\n    body: { head: true, link: true, script: true },\n    li: { li: true },\n    p: { p: true },\n    h1: { p: true },\n    h2: { p: true },\n    h3: { p: true },\n    h4: { p: true },\n    h5: { p: true },\n    h6: { p: true },\n    select: formTags,\n    input: formTags,\n    output: formTags,\n    button: formTags,\n    datalist: formTags,\n    textarea: formTags,\n    option: { option: true },\n    optgroup: { optgroup: true }\n};\n\nvar voidElements = {\n    __proto__: null,\n    area: true,\n    base: true,\n    basefont: true,\n    br: true,\n    col: true,\n    command: true,\n    embed: true,\n    frame: true,\n    hr: true,\n    img: true,\n    input: true,\n    isindex: true,\n    keygen: true,\n    link: true,\n    meta: true,\n    param: true,\n    source: true,\n    track: true,\n    wbr: true\n};\n\nvar foreignContextElements = {\n    __proto__: null,\n    math: true,\n    svg: true\n};\nvar htmlIntegrationElements = {\n    __proto__: null,\n    mi: true,\n    mo: true,\n    mn: true,\n    ms: true,\n    mtext: true,\n    \"annotation-xml\": true,\n    foreignObject: true,\n    desc: true,\n    title: true\n};\n\nvar re_nameEnd = /\\s|\\//;\n\nfunction Parser(cbs, options) {\n    this._options = options || {};\n    this._cbs = cbs || {};\n\n    this._tagname = \"\";\n    this._attribname = \"\";\n    this._attribvalue = \"\";\n    this._attribs = null;\n    this._stack = [];\n    this._foreignContext = [];\n\n    this.startIndex = 0;\n    this.endIndex = null;\n\n    this._lowerCaseTagNames =\n        \"lowerCaseTags\" in this._options\n            ? !!this._options.lowerCaseTags\n            : !this._options.xmlMode;\n    this._lowerCaseAttributeNames =\n        \"lowerCaseAttributeNames\" in this._options\n            ? !!this._options.lowerCaseAttributeNames\n            : !this._options.xmlMode;\n\n    if (this._options.Tokenizer) {\n        Tokenizer = this._options.Tokenizer;\n    }\n    this._tokenizer = new Tokenizer(this._options, this);\n\n    if (this._cbs.onparserinit) this._cbs.onparserinit(this);\n}\n\nrequire(\"inherits\")(Parser, require(\"events\").EventEmitter);\n\nParser.prototype._updatePosition = function(initialOffset) {\n    if (this.endIndex === null) {\n        if (this._tokenizer._sectionStart <= initialOffset) {\n            this.startIndex = 0;\n        } else {\n            this.startIndex = this._tokenizer._sectionStart - initialOffset;\n        }\n    } else this.startIndex = this.endIndex + 1;\n    this.endIndex = this._tokenizer.getAbsoluteIndex();\n};\n\n//Tokenizer event handlers\nParser.prototype.ontext = function(data) {\n    this._updatePosition(1);\n    this.endIndex--;\n\n    if (this._cbs.ontext) this._cbs.ontext(data);\n};\n\nParser.prototype.onopentagname = function(name) {\n    if (this._lowerCaseTagNames) {\n        name = name.toLowerCase();\n    }\n\n    this._tagname = name;\n\n    if (!this._options.xmlMode && name in openImpliesClose) {\n        for (\n            var el;\n            (el = this._stack[this._stack.length - 1]) in\n            openImpliesClose[name];\n            this.onclosetag(el)\n        );\n    }\n\n    if (this._options.xmlMode || !(name in voidElements)) {\n        this._stack.push(name);\n        if (name in foreignContextElements) this._foreignContext.push(true);\n        else if (name in htmlIntegrationElements)\n            this._foreignContext.push(false);\n    }\n\n    if (this._cbs.onopentagname) this._cbs.onopentagname(name);\n    if (this._cbs.onopentag) this._attribs = {};\n};\n\nParser.prototype.onopentagend = function() {\n    this._updatePosition(1);\n\n    if (this._attribs) {\n        if (this._cbs.onopentag)\n            this._cbs.onopentag(this._tagname, this._attribs);\n        this._attribs = null;\n    }\n\n    if (\n        !this._options.xmlMode &&\n        this._cbs.onclosetag &&\n        this._tagname in voidElements\n    ) {\n        this._cbs.onclosetag(this._tagname);\n    }\n\n    this._tagname = \"\";\n};\n\nParser.prototype.onclosetag = function(name) {\n    this._updatePosition(1);\n\n    if (this._lowerCaseTagNames) {\n        name = name.toLowerCase();\n    }\n    \n    if (name in foreignContextElements || name in htmlIntegrationElements) {\n        this._foreignContext.pop();\n    }\n\n    if (\n        this._stack.length &&\n        (!(name in voidElements) || this._options.xmlMode)\n    ) {\n        var pos = this._stack.lastIndexOf(name);\n        if (pos !== -1) {\n            if (this._cbs.onclosetag) {\n                pos = this._stack.length - pos;\n                while (pos--) this._cbs.onclosetag(this._stack.pop());\n            } else this._stack.length = pos;\n        } else if (name === \"p\" && !this._options.xmlMode) {\n            this.onopentagname(name);\n            this._closeCurrentTag();\n        }\n    } else if (!this._options.xmlMode && (name === \"br\" || name === \"p\")) {\n        this.onopentagname(name);\n        this._closeCurrentTag();\n    }\n};\n\nParser.prototype.onselfclosingtag = function() {\n    if (\n        this._options.xmlMode ||\n        this._options.recognizeSelfClosing ||\n        this._foreignContext[this._foreignContext.length - 1]\n    ) {\n        this._closeCurrentTag();\n    } else {\n        this.onopentagend();\n    }\n};\n\nParser.prototype._closeCurrentTag = function() {\n    var name = this._tagname;\n\n    this.onopentagend();\n\n    //self-closing tags will be on the top of the stack\n    //(cheaper check than in onclosetag)\n    if (this._stack[this._stack.length - 1] === name) {\n        if (this._cbs.onclosetag) {\n            this._cbs.onclosetag(name);\n        }\n        this._stack.pop();\n        \n    }\n};\n\nParser.prototype.onattribname = function(name) {\n    if (this._lowerCaseAttributeNames) {\n        name = name.toLowerCase();\n    }\n    this._attribname = name;\n};\n\nParser.prototype.onattribdata = function(value) {\n    this._attribvalue += value;\n};\n\nParser.prototype.onattribend = function() {\n    if (this._cbs.onattribute)\n        this._cbs.onattribute(this._attribname, this._attribvalue);\n    if (\n        this._attribs &&\n        !Object.prototype.hasOwnProperty.call(this._attribs, this._attribname)\n    ) {\n        this._attribs[this._attribname] = this._attribvalue;\n    }\n    this._attribname = \"\";\n    this._attribvalue = \"\";\n};\n\nParser.prototype._getInstructionName = function(value) {\n    var idx = value.search(re_nameEnd),\n        name = idx < 0 ? value : value.substr(0, idx);\n\n    if (this._lowerCaseTagNames) {\n        name = name.toLowerCase();\n    }\n\n    return name;\n};\n\nParser.prototype.ondeclaration = function(value) {\n    if (this._cbs.onprocessinginstruction) {\n        var name = this._getInstructionName(value);\n        this._cbs.onprocessinginstruction(\"!\" + name, \"!\" + value);\n    }\n};\n\nParser.prototype.onprocessinginstruction = function(value) {\n    if (this._cbs.onprocessinginstruction) {\n        var name = this._getInstructionName(value);\n        this._cbs.onprocessinginstruction(\"?\" + name, \"?\" + value);\n    }\n};\n\nParser.prototype.oncomment = function(value) {\n    this._updatePosition(4);\n\n    if (this._cbs.oncomment) this._cbs.oncomment(value);\n    if (this._cbs.oncommentend) this._cbs.oncommentend();\n};\n\nParser.prototype.oncdata = function(value) {\n    this._updatePosition(1);\n\n    if (this._options.xmlMode || this._options.recognizeCDATA) {\n        if (this._cbs.oncdatastart) this._cbs.oncdatastart();\n        if (this._cbs.ontext) this._cbs.ontext(value);\n        if (this._cbs.oncdataend) this._cbs.oncdataend();\n    } else {\n        this.oncomment(\"[CDATA[\" + value + \"]]\");\n    }\n};\n\nParser.prototype.onerror = function(err) {\n    if (this._cbs.onerror) this._cbs.onerror(err);\n};\n\nParser.prototype.onend = function() {\n    if (this._cbs.onclosetag) {\n        for (\n            var i = this._stack.length;\n            i > 0;\n            this._cbs.onclosetag(this._stack[--i])\n        );\n    }\n    if (this._cbs.onend) this._cbs.onend();\n};\n\n//Resets the parser to a blank state, ready to parse a new HTML document\nParser.prototype.reset = function() {\n    if (this._cbs.onreset) this._cbs.onreset();\n    this._tokenizer.reset();\n\n    this._tagname = \"\";\n    this._attribname = \"\";\n    this._attribs = null;\n    this._stack = [];\n\n    if (this._cbs.onparserinit) this._cbs.onparserinit(this);\n};\n\n//Parses a complete HTML document and pushes it to the handler\nParser.prototype.parseComplete = function(data) {\n    this.reset();\n    this.end(data);\n};\n\nParser.prototype.write = function(chunk) {\n    this._tokenizer.write(chunk);\n};\n\nParser.prototype.end = function(chunk) {\n    this._tokenizer.end(chunk);\n};\n\nParser.prototype.pause = function() {\n    this._tokenizer.pause();\n};\n\nParser.prototype.resume = function() {\n    this._tokenizer.resume();\n};\n\n//alias for backwards compat\nParser.prototype.parseChunk = Parser.prototype.write;\nParser.prototype.done = Parser.prototype.end;\n\nmodule.exports = Parser;\n","module.exports = Tokenizer;\n\nvar decodeCodePoint = require(\"entities/lib/decode_codepoint.js\");\nvar entityMap = require(\"entities/maps/entities.json\");\nvar legacyMap = require(\"entities/maps/legacy.json\");\nvar xmlMap = require(\"entities/maps/xml.json\");\n\nvar i = 0;\n\nvar TEXT = i++;\nvar BEFORE_TAG_NAME = i++; //after <\nvar IN_TAG_NAME = i++;\nvar IN_SELF_CLOSING_TAG = i++;\nvar BEFORE_CLOSING_TAG_NAME = i++;\nvar IN_CLOSING_TAG_NAME = i++;\nvar AFTER_CLOSING_TAG_NAME = i++;\n\n//attributes\nvar BEFORE_ATTRIBUTE_NAME = i++;\nvar IN_ATTRIBUTE_NAME = i++;\nvar AFTER_ATTRIBUTE_NAME = i++;\nvar BEFORE_ATTRIBUTE_VALUE = i++;\nvar IN_ATTRIBUTE_VALUE_DQ = i++; // \"\nvar IN_ATTRIBUTE_VALUE_SQ = i++; // '\nvar IN_ATTRIBUTE_VALUE_NQ = i++;\n\n//declarations\nvar BEFORE_DECLARATION = i++; // !\nvar IN_DECLARATION = i++;\n\n//processing instructions\nvar IN_PROCESSING_INSTRUCTION = i++; // ?\n\n//comments\nvar BEFORE_COMMENT = i++;\nvar IN_COMMENT = i++;\nvar AFTER_COMMENT_1 = i++;\nvar AFTER_COMMENT_2 = i++;\n\n//cdata\nvar BEFORE_CDATA_1 = i++; // [\nvar BEFORE_CDATA_2 = i++; // C\nvar BEFORE_CDATA_3 = i++; // D\nvar BEFORE_CDATA_4 = i++; // A\nvar BEFORE_CDATA_5 = i++; // T\nvar BEFORE_CDATA_6 = i++; // A\nvar IN_CDATA = i++; // [\nvar AFTER_CDATA_1 = i++; // ]\nvar AFTER_CDATA_2 = i++; // ]\n\n//special tags\nvar BEFORE_SPECIAL = i++; //S\nvar BEFORE_SPECIAL_END = i++; //S\n\nvar BEFORE_SCRIPT_1 = i++; //C\nvar BEFORE_SCRIPT_2 = i++; //R\nvar BEFORE_SCRIPT_3 = i++; //I\nvar BEFORE_SCRIPT_4 = i++; //P\nvar BEFORE_SCRIPT_5 = i++; //T\nvar AFTER_SCRIPT_1 = i++; //C\nvar AFTER_SCRIPT_2 = i++; //R\nvar AFTER_SCRIPT_3 = i++; //I\nvar AFTER_SCRIPT_4 = i++; //P\nvar AFTER_SCRIPT_5 = i++; //T\n\nvar BEFORE_STYLE_1 = i++; //T\nvar BEFORE_STYLE_2 = i++; //Y\nvar BEFORE_STYLE_3 = i++; //L\nvar BEFORE_STYLE_4 = i++; //E\nvar AFTER_STYLE_1 = i++; //T\nvar AFTER_STYLE_2 = i++; //Y\nvar AFTER_STYLE_3 = i++; //L\nvar AFTER_STYLE_4 = i++; //E\n\nvar BEFORE_ENTITY = i++; //&\nvar BEFORE_NUMERIC_ENTITY = i++; //#\nvar IN_NAMED_ENTITY = i++;\nvar IN_NUMERIC_ENTITY = i++;\nvar IN_HEX_ENTITY = i++; //X\n\nvar j = 0;\n\nvar SPECIAL_NONE = j++;\nvar SPECIAL_SCRIPT = j++;\nvar SPECIAL_STYLE = j++;\n\nfunction whitespace(c) {\n    return c === \" \" || c === \"\\n\" || c === \"\\t\" || c === \"\\f\" || c === \"\\r\";\n}\n\nfunction ifElseState(upper, SUCCESS, FAILURE) {\n    var lower = upper.toLowerCase();\n\n    if (upper === lower) {\n        return function(c) {\n            if (c === lower) {\n                this._state = SUCCESS;\n            } else {\n                this._state = FAILURE;\n                this._index--;\n            }\n        };\n    } else {\n        return function(c) {\n            if (c === lower || c === upper) {\n                this._state = SUCCESS;\n            } else {\n                this._state = FAILURE;\n                this._index--;\n            }\n        };\n    }\n}\n\nfunction consumeSpecialNameChar(upper, NEXT_STATE) {\n    var lower = upper.toLowerCase();\n\n    return function(c) {\n        if (c === lower || c === upper) {\n            this._state = NEXT_STATE;\n        } else {\n            this._state = IN_TAG_NAME;\n            this._index--; //consume the token again\n        }\n    };\n}\n\nfunction Tokenizer(options, cbs) {\n    this._state = TEXT;\n    this._buffer = \"\";\n    this._sectionStart = 0;\n    this._index = 0;\n    this._bufferOffset = 0; //chars removed from _buffer\n    this._baseState = TEXT;\n    this._special = SPECIAL_NONE;\n    this._cbs = cbs;\n    this._running = true;\n    this._ended = false;\n    this._xmlMode = !!(options && options.xmlMode);\n    this._decodeEntities = !!(options && options.decodeEntities);\n}\n\nTokenizer.prototype._stateText = function(c) {\n    if (c === \"<\") {\n        if (this._index > this._sectionStart) {\n            this._cbs.ontext(this._getSection());\n        }\n        this._state = BEFORE_TAG_NAME;\n        this._sectionStart = this._index;\n    } else if (\n        this._decodeEntities &&\n        this._special === SPECIAL_NONE &&\n        c === \"&\"\n    ) {\n        if (this._index > this._sectionStart) {\n            this._cbs.ontext(this._getSection());\n        }\n        this._baseState = TEXT;\n        this._state = BEFORE_ENTITY;\n        this._sectionStart = this._index;\n    }\n};\n\nTokenizer.prototype._stateBeforeTagName = function(c) {\n    if (c === \"/\") {\n        this._state = BEFORE_CLOSING_TAG_NAME;\n    } else if (c === \"<\") {\n        this._cbs.ontext(this._getSection());\n        this._sectionStart = this._index;\n    } else if (c === \">\" || this._special !== SPECIAL_NONE || whitespace(c)) {\n        this._state = TEXT;\n    } else if (c === \"!\") {\n        this._state = BEFORE_DECLARATION;\n        this._sectionStart = this._index + 1;\n    } else if (c === \"?\") {\n        this._state = IN_PROCESSING_INSTRUCTION;\n        this._sectionStart = this._index + 1;\n    } else {\n        this._state =\n            !this._xmlMode && (c === \"s\" || c === \"S\")\n                ? BEFORE_SPECIAL\n                : IN_TAG_NAME;\n        this._sectionStart = this._index;\n    }\n};\n\nTokenizer.prototype._stateInTagName = function(c) {\n    if (c === \"/\" || c === \">\" || whitespace(c)) {\n        this._emitToken(\"onopentagname\");\n        this._state = BEFORE_ATTRIBUTE_NAME;\n        this._index--;\n    }\n};\n\nTokenizer.prototype._stateBeforeCloseingTagName = function(c) {\n    if (whitespace(c));\n    else if (c === \">\") {\n        this._state = TEXT;\n    } else if (this._special !== SPECIAL_NONE) {\n        if (c === \"s\" || c === \"S\") {\n            this._state = BEFORE_SPECIAL_END;\n        } else {\n            this._state = TEXT;\n            this._index--;\n        }\n    } else {\n        this._state = IN_CLOSING_TAG_NAME;\n        this._sectionStart = this._index;\n    }\n};\n\nTokenizer.prototype._stateInCloseingTagName = function(c) {\n    if (c === \">\" || whitespace(c)) {\n        this._emitToken(\"onclosetag\");\n        this._state = AFTER_CLOSING_TAG_NAME;\n        this._index--;\n    }\n};\n\nTokenizer.prototype._stateAfterCloseingTagName = function(c) {\n    //skip everything until \">\"\n    if (c === \">\") {\n        this._state = TEXT;\n        this._sectionStart = this._index + 1;\n    }\n};\n\nTokenizer.prototype._stateBeforeAttributeName = function(c) {\n    if (c === \">\") {\n        this._cbs.onopentagend();\n        this._state = TEXT;\n        this._sectionStart = this._index + 1;\n    } else if (c === \"/\") {\n        this._state = IN_SELF_CLOSING_TAG;\n    } else if (!whitespace(c)) {\n        this._state = IN_ATTRIBUTE_NAME;\n        this._sectionStart = this._index;\n    }\n};\n\nTokenizer.prototype._stateInSelfClosingTag = function(c) {\n    if (c === \">\") {\n        this._cbs.onselfclosingtag();\n        this._state = TEXT;\n        this._sectionStart = this._index + 1;\n    } else if (!whitespace(c)) {\n        this._state = BEFORE_ATTRIBUTE_NAME;\n        this._index--;\n    }\n};\n\nTokenizer.prototype._stateInAttributeName = function(c) {\n    if (c === \"=\" || c === \"/\" || c === \">\" || whitespace(c)) {\n        this._cbs.onattribname(this._getSection());\n        this._sectionStart = -1;\n        this._state = AFTER_ATTRIBUTE_NAME;\n        this._index--;\n    }\n};\n\nTokenizer.prototype._stateAfterAttributeName = function(c) {\n    if (c === \"=\") {\n        this._state = BEFORE_ATTRIBUTE_VALUE;\n    } else if (c === \"/\" || c === \">\") {\n        this._cbs.onattribend();\n        this._state = BEFORE_ATTRIBUTE_NAME;\n        this._index--;\n    } else if (!whitespace(c)) {\n        this._cbs.onattribend();\n        this._state = IN_ATTRIBUTE_NAME;\n        this._sectionStart = this._index;\n    }\n};\n\nTokenizer.prototype._stateBeforeAttributeValue = function(c) {\n    if (c === '\"') {\n        this._state = IN_ATTRIBUTE_VALUE_DQ;\n        this._sectionStart = this._index + 1;\n    } else if (c === \"'\") {\n        this._state = IN_ATTRIBUTE_VALUE_SQ;\n        this._sectionStart = this._index + 1;\n    } else if (!whitespace(c)) {\n        this._state = IN_ATTRIBUTE_VALUE_NQ;\n        this._sectionStart = this._index;\n        this._index--; //reconsume token\n    }\n};\n\nTokenizer.prototype._stateInAttributeValueDoubleQuotes = function(c) {\n    if (c === '\"') {\n        this._emitToken(\"onattribdata\");\n        this._cbs.onattribend();\n        this._state = BEFORE_ATTRIBUTE_NAME;\n    } else if (this._decodeEntities && c === \"&\") {\n        this._emitToken(\"onattribdata\");\n        this._baseState = this._state;\n        this._state = BEFORE_ENTITY;\n        this._sectionStart = this._index;\n    }\n};\n\nTokenizer.prototype._stateInAttributeValueSingleQuotes = function(c) {\n    if (c === \"'\") {\n        this._emitToken(\"onattribdata\");\n        this._cbs.onattribend();\n        this._state = BEFORE_ATTRIBUTE_NAME;\n    } else if (this._decodeEntities && c === \"&\") {\n        this._emitToken(\"onattribdata\");\n        this._baseState = this._state;\n        this._state = BEFORE_ENTITY;\n        this._sectionStart = this._index;\n    }\n};\n\nTokenizer.prototype._stateInAttributeValueNoQuotes = function(c) {\n    if (whitespace(c) || c === \">\") {\n        this._emitToken(\"onattribdata\");\n        this._cbs.onattribend();\n        this._state = BEFORE_ATTRIBUTE_NAME;\n        this._index--;\n    } else if (this._decodeEntities && c === \"&\") {\n        this._emitToken(\"onattribdata\");\n        this._baseState = this._state;\n        this._state = BEFORE_ENTITY;\n        this._sectionStart = this._index;\n    }\n};\n\nTokenizer.prototype._stateBeforeDeclaration = function(c) {\n    this._state =\n        c === \"[\"\n            ? BEFORE_CDATA_1\n            : c === \"-\"\n                ? BEFORE_COMMENT\n                : IN_DECLARATION;\n};\n\nTokenizer.prototype._stateInDeclaration = function(c) {\n    if (c === \">\") {\n        this._cbs.ondeclaration(this._getSection());\n        this._state = TEXT;\n        this._sectionStart = this._index + 1;\n    }\n};\n\nTokenizer.prototype._stateInProcessingInstruction = function(c) {\n    if (c === \">\") {\n        this._cbs.onprocessinginstruction(this._getSection());\n        this._state = TEXT;\n        this._sectionStart = this._index + 1;\n    }\n};\n\nTokenizer.prototype._stateBeforeComment = function(c) {\n    if (c === \"-\") {\n        this._state = IN_COMMENT;\n        this._sectionStart = this._index + 1;\n    } else {\n        this._state = IN_DECLARATION;\n    }\n};\n\nTokenizer.prototype._stateInComment = function(c) {\n    if (c === \"-\") this._state = AFTER_COMMENT_1;\n};\n\nTokenizer.prototype._stateAfterComment1 = function(c) {\n    if (c === \"-\") {\n        this._state = AFTER_COMMENT_2;\n    } else {\n        this._state = IN_COMMENT;\n    }\n};\n\nTokenizer.prototype._stateAfterComment2 = function(c) {\n    if (c === \">\") {\n        //remove 2 trailing chars\n        this._cbs.oncomment(\n            this._buffer.substring(this._sectionStart, this._index - 2)\n        );\n        this._state = TEXT;\n        this._sectionStart = this._index + 1;\n    } else if (c !== \"-\") {\n        this._state = IN_COMMENT;\n    }\n    // else: stay in AFTER_COMMENT_2 (`--->`)\n};\n\nTokenizer.prototype._stateBeforeCdata1 = ifElseState(\n    \"C\",\n    BEFORE_CDATA_2,\n    IN_DECLARATION\n);\nTokenizer.prototype._stateBeforeCdata2 = ifElseState(\n    \"D\",\n    BEFORE_CDATA_3,\n    IN_DECLARATION\n);\nTokenizer.prototype._stateBeforeCdata3 = ifElseState(\n    \"A\",\n    BEFORE_CDATA_4,\n    IN_DECLARATION\n);\nTokenizer.prototype._stateBeforeCdata4 = ifElseState(\n    \"T\",\n    BEFORE_CDATA_5,\n    IN_DECLARATION\n);\nTokenizer.prototype._stateBeforeCdata5 = ifElseState(\n    \"A\",\n    BEFORE_CDATA_6,\n    IN_DECLARATION\n);\n\nTokenizer.prototype._stateBeforeCdata6 = function(c) {\n    if (c === \"[\") {\n        this._state = IN_CDATA;\n        this._sectionStart = this._index + 1;\n    } else {\n        this._state = IN_DECLARATION;\n        this._index--;\n    }\n};\n\nTokenizer.prototype._stateInCdata = function(c) {\n    if (c === \"]\") this._state = AFTER_CDATA_1;\n};\n\nTokenizer.prototype._stateAfterCdata1 = function(c) {\n    if (c === \"]\") this._state = AFTER_CDATA_2;\n    else this._state = IN_CDATA;\n};\n\nTokenizer.prototype._stateAfterCdata2 = function(c) {\n    if (c === \">\") {\n        //remove 2 trailing chars\n        this._cbs.oncdata(\n            this._buffer.substring(this._sectionStart, this._index - 2)\n        );\n        this._state = TEXT;\n        this._sectionStart = this._index + 1;\n    } else if (c !== \"]\") {\n        this._state = IN_CDATA;\n    }\n    //else: stay in AFTER_CDATA_2 (`]]]>`)\n};\n\nTokenizer.prototype._stateBeforeSpecial = function(c) {\n    if (c === \"c\" || c === \"C\") {\n        this._state = BEFORE_SCRIPT_1;\n    } else if (c === \"t\" || c === \"T\") {\n        this._state = BEFORE_STYLE_1;\n    } else {\n        this._state = IN_TAG_NAME;\n        this._index--; //consume the token again\n    }\n};\n\nTokenizer.prototype._stateBeforeSpecialEnd = function(c) {\n    if (this._special === SPECIAL_SCRIPT && (c === \"c\" || c === \"C\")) {\n        this._state = AFTER_SCRIPT_1;\n    } else if (this._special === SPECIAL_STYLE && (c === \"t\" || c === \"T\")) {\n        this._state = AFTER_STYLE_1;\n    } else this._state = TEXT;\n};\n\nTokenizer.prototype._stateBeforeScript1 = consumeSpecialNameChar(\n    \"R\",\n    BEFORE_SCRIPT_2\n);\nTokenizer.prototype._stateBeforeScript2 = consumeSpecialNameChar(\n    \"I\",\n    BEFORE_SCRIPT_3\n);\nTokenizer.prototype._stateBeforeScript3 = consumeSpecialNameChar(\n    \"P\",\n    BEFORE_SCRIPT_4\n);\nTokenizer.prototype._stateBeforeScript4 = consumeSpecialNameChar(\n    \"T\",\n    BEFORE_SCRIPT_5\n);\n\nTokenizer.prototype._stateBeforeScript5 = function(c) {\n    if (c === \"/\" || c === \">\" || whitespace(c)) {\n        this._special = SPECIAL_SCRIPT;\n    }\n    this._state = IN_TAG_NAME;\n    this._index--; //consume the token again\n};\n\nTokenizer.prototype._stateAfterScript1 = ifElseState(\"R\", AFTER_SCRIPT_2, TEXT);\nTokenizer.prototype._stateAfterScript2 = ifElseState(\"I\", AFTER_SCRIPT_3, TEXT);\nTokenizer.prototype._stateAfterScript3 = ifElseState(\"P\", AFTER_SCRIPT_4, TEXT);\nTokenizer.prototype._stateAfterScript4 = ifElseState(\"T\", AFTER_SCRIPT_5, TEXT);\n\nTokenizer.prototype._stateAfterScript5 = function(c) {\n    if (c === \">\" || whitespace(c)) {\n        this._special = SPECIAL_NONE;\n        this._state = IN_CLOSING_TAG_NAME;\n        this._sectionStart = this._index - 6;\n        this._index--; //reconsume the token\n    } else this._state = TEXT;\n};\n\nTokenizer.prototype._stateBeforeStyle1 = consumeSpecialNameChar(\n    \"Y\",\n    BEFORE_STYLE_2\n);\nTokenizer.prototype._stateBeforeStyle2 = consumeSpecialNameChar(\n    \"L\",\n    BEFORE_STYLE_3\n);\nTokenizer.prototype._stateBeforeStyle3 = consumeSpecialNameChar(\n    \"E\",\n    BEFORE_STYLE_4\n);\n\nTokenizer.prototype._stateBeforeStyle4 = function(c) {\n    if (c === \"/\" || c === \">\" || whitespace(c)) {\n        this._special = SPECIAL_STYLE;\n    }\n    this._state = IN_TAG_NAME;\n    this._index--; //consume the token again\n};\n\nTokenizer.prototype._stateAfterStyle1 = ifElseState(\"Y\", AFTER_STYLE_2, TEXT);\nTokenizer.prototype._stateAfterStyle2 = ifElseState(\"L\", AFTER_STYLE_3, TEXT);\nTokenizer.prototype._stateAfterStyle3 = ifElseState(\"E\", AFTER_STYLE_4, TEXT);\n\nTokenizer.prototype._stateAfterStyle4 = function(c) {\n    if (c === \">\" || whitespace(c)) {\n        this._special = SPECIAL_NONE;\n        this._state = IN_CLOSING_TAG_NAME;\n        this._sectionStart = this._index - 5;\n        this._index--; //reconsume the token\n    } else this._state = TEXT;\n};\n\nTokenizer.prototype._stateBeforeEntity = ifElseState(\n    \"#\",\n    BEFORE_NUMERIC_ENTITY,\n    IN_NAMED_ENTITY\n);\nTokenizer.prototype._stateBeforeNumericEntity = ifElseState(\n    \"X\",\n    IN_HEX_ENTITY,\n    IN_NUMERIC_ENTITY\n);\n\n//for entities terminated with a semicolon\nTokenizer.prototype._parseNamedEntityStrict = function() {\n    //offset = 1\n    if (this._sectionStart + 1 < this._index) {\n        var entity = this._buffer.substring(\n                this._sectionStart + 1,\n                this._index\n            ),\n            map = this._xmlMode ? xmlMap : entityMap;\n\n        if (map.hasOwnProperty(entity)) {\n            this._emitPartial(map[entity]);\n            this._sectionStart = this._index + 1;\n        }\n    }\n};\n\n//parses legacy entities (without trailing semicolon)\nTokenizer.prototype._parseLegacyEntity = function() {\n    var start = this._sectionStart + 1,\n        limit = this._index - start;\n\n    if (limit > 6) limit = 6; //the max length of legacy entities is 6\n\n    while (limit >= 2) {\n        //the min length of legacy entities is 2\n        var entity = this._buffer.substr(start, limit);\n\n        if (legacyMap.hasOwnProperty(entity)) {\n            this._emitPartial(legacyMap[entity]);\n            this._sectionStart += limit + 1;\n            return;\n        } else {\n            limit--;\n        }\n    }\n};\n\nTokenizer.prototype._stateInNamedEntity = function(c) {\n    if (c === \";\") {\n        this._parseNamedEntityStrict();\n        if (this._sectionStart + 1 < this._index && !this._xmlMode) {\n            this._parseLegacyEntity();\n        }\n        this._state = this._baseState;\n    } else if (\n        (c < \"a\" || c > \"z\") &&\n        (c < \"A\" || c > \"Z\") &&\n        (c < \"0\" || c > \"9\")\n    ) {\n        if (this._xmlMode);\n        else if (this._sectionStart + 1 === this._index);\n        else if (this._baseState !== TEXT) {\n            if (c !== \"=\") {\n                this._parseNamedEntityStrict();\n            }\n        } else {\n            this._parseLegacyEntity();\n        }\n\n        this._state = this._baseState;\n        this._index--;\n    }\n};\n\nTokenizer.prototype._decodeNumericEntity = function(offset, base) {\n    var sectionStart = this._sectionStart + offset;\n\n    if (sectionStart !== this._index) {\n        //parse entity\n        var entity = this._buffer.substring(sectionStart, this._index);\n        var parsed = parseInt(entity, base);\n\n        this._emitPartial(decodeCodePoint(parsed));\n        this._sectionStart = this._index;\n    } else {\n        this._sectionStart--;\n    }\n\n    this._state = this._baseState;\n};\n\nTokenizer.prototype._stateInNumericEntity = function(c) {\n    if (c === \";\") {\n        this._decodeNumericEntity(2, 10);\n        this._sectionStart++;\n    } else if (c < \"0\" || c > \"9\") {\n        if (!this._xmlMode) {\n            this._decodeNumericEntity(2, 10);\n        } else {\n            this._state = this._baseState;\n        }\n        this._index--;\n    }\n};\n\nTokenizer.prototype._stateInHexEntity = function(c) {\n    if (c === \";\") {\n        this._decodeNumericEntity(3, 16);\n        this._sectionStart++;\n    } else if (\n        (c < \"a\" || c > \"f\") &&\n        (c < \"A\" || c > \"F\") &&\n        (c < \"0\" || c > \"9\")\n    ) {\n        if (!this._xmlMode) {\n            this._decodeNumericEntity(3, 16);\n        } else {\n            this._state = this._baseState;\n        }\n        this._index--;\n    }\n};\n\nTokenizer.prototype._cleanup = function() {\n    if (this._sectionStart < 0) {\n        this._buffer = \"\";\n        this._bufferOffset += this._index;\n        this._index = 0;\n    } else if (this._running) {\n        if (this._state === TEXT) {\n            if (this._sectionStart !== this._index) {\n                this._cbs.ontext(this._buffer.substr(this._sectionStart));\n            }\n            this._buffer = \"\";\n            this._bufferOffset += this._index;\n            this._index = 0;\n        } else if (this._sectionStart === this._index) {\n            //the section just started\n            this._buffer = \"\";\n            this._bufferOffset += this._index;\n            this._index = 0;\n        } else {\n            //remove everything unnecessary\n            this._buffer = this._buffer.substr(this._sectionStart);\n            this._index -= this._sectionStart;\n            this._bufferOffset += this._sectionStart;\n        }\n\n        this._sectionStart = 0;\n    }\n};\n\n//TODO make events conditional\nTokenizer.prototype.write = function(chunk) {\n    if (this._ended) this._cbs.onerror(Error(\".write() after done!\"));\n\n    this._buffer += chunk;\n    this._parse();\n};\n\nTokenizer.prototype._parse = function() {\n    while (this._index < this._buffer.length && this._running) {\n        var c = this._buffer.charAt(this._index);\n        if (this._state === TEXT) {\n            this._stateText(c);\n        } else if (this._state === BEFORE_TAG_NAME) {\n            this._stateBeforeTagName(c);\n        } else if (this._state === IN_TAG_NAME) {\n            this._stateInTagName(c);\n        } else if (this._state === BEFORE_CLOSING_TAG_NAME) {\n            this._stateBeforeCloseingTagName(c);\n        } else if (this._state === IN_CLOSING_TAG_NAME) {\n            this._stateInCloseingTagName(c);\n        } else if (this._state === AFTER_CLOSING_TAG_NAME) {\n            this._stateAfterCloseingTagName(c);\n        } else if (this._state === IN_SELF_CLOSING_TAG) {\n            this._stateInSelfClosingTag(c);\n        } else if (this._state === BEFORE_ATTRIBUTE_NAME) {\n\n        /*\n\t\t*\tattributes\n\t\t*/\n            this._stateBeforeAttributeName(c);\n        } else if (this._state === IN_ATTRIBUTE_NAME) {\n            this._stateInAttributeName(c);\n        } else if (this._state === AFTER_ATTRIBUTE_NAME) {\n            this._stateAfterAttributeName(c);\n        } else if (this._state === BEFORE_ATTRIBUTE_VALUE) {\n            this._stateBeforeAttributeValue(c);\n        } else if (this._state === IN_ATTRIBUTE_VALUE_DQ) {\n            this._stateInAttributeValueDoubleQuotes(c);\n        } else if (this._state === IN_ATTRIBUTE_VALUE_SQ) {\n            this._stateInAttributeValueSingleQuotes(c);\n        } else if (this._state === IN_ATTRIBUTE_VALUE_NQ) {\n            this._stateInAttributeValueNoQuotes(c);\n        } else if (this._state === BEFORE_DECLARATION) {\n\n        /*\n\t\t*\tdeclarations\n\t\t*/\n            this._stateBeforeDeclaration(c);\n        } else if (this._state === IN_DECLARATION) {\n            this._stateInDeclaration(c);\n        } else if (this._state === IN_PROCESSING_INSTRUCTION) {\n\n        /*\n\t\t*\tprocessing instructions\n\t\t*/\n            this._stateInProcessingInstruction(c);\n        } else if (this._state === BEFORE_COMMENT) {\n\n        /*\n\t\t*\tcomments\n\t\t*/\n            this._stateBeforeComment(c);\n        } else if (this._state === IN_COMMENT) {\n            this._stateInComment(c);\n        } else if (this._state === AFTER_COMMENT_1) {\n            this._stateAfterComment1(c);\n        } else if (this._state === AFTER_COMMENT_2) {\n            this._stateAfterComment2(c);\n        } else if (this._state === BEFORE_CDATA_1) {\n\n        /*\n\t\t*\tcdata\n\t\t*/\n            this._stateBeforeCdata1(c);\n        } else if (this._state === BEFORE_CDATA_2) {\n            this._stateBeforeCdata2(c);\n        } else if (this._state === BEFORE_CDATA_3) {\n            this._stateBeforeCdata3(c);\n        } else if (this._state === BEFORE_CDATA_4) {\n            this._stateBeforeCdata4(c);\n        } else if (this._state === BEFORE_CDATA_5) {\n            this._stateBeforeCdata5(c);\n        } else if (this._state === BEFORE_CDATA_6) {\n            this._stateBeforeCdata6(c);\n        } else if (this._state === IN_CDATA) {\n            this._stateInCdata(c);\n        } else if (this._state === AFTER_CDATA_1) {\n            this._stateAfterCdata1(c);\n        } else if (this._state === AFTER_CDATA_2) {\n            this._stateAfterCdata2(c);\n        } else if (this._state === BEFORE_SPECIAL) {\n\n        /*\n\t\t* special tags\n\t\t*/\n            this._stateBeforeSpecial(c);\n        } else if (this._state === BEFORE_SPECIAL_END) {\n            this._stateBeforeSpecialEnd(c);\n        } else if (this._state === BEFORE_SCRIPT_1) {\n\n        /*\n\t\t* script\n\t\t*/\n            this._stateBeforeScript1(c);\n        } else if (this._state === BEFORE_SCRIPT_2) {\n            this._stateBeforeScript2(c);\n        } else if (this._state === BEFORE_SCRIPT_3) {\n            this._stateBeforeScript3(c);\n        } else if (this._state === BEFORE_SCRIPT_4) {\n            this._stateBeforeScript4(c);\n        } else if (this._state === BEFORE_SCRIPT_5) {\n            this._stateBeforeScript5(c);\n        } else if (this._state === AFTER_SCRIPT_1) {\n            this._stateAfterScript1(c);\n        } else if (this._state === AFTER_SCRIPT_2) {\n            this._stateAfterScript2(c);\n        } else if (this._state === AFTER_SCRIPT_3) {\n            this._stateAfterScript3(c);\n        } else if (this._state === AFTER_SCRIPT_4) {\n            this._stateAfterScript4(c);\n        } else if (this._state === AFTER_SCRIPT_5) {\n            this._stateAfterScript5(c);\n        } else if (this._state === BEFORE_STYLE_1) {\n\n        /*\n\t\t* style\n\t\t*/\n            this._stateBeforeStyle1(c);\n        } else if (this._state === BEFORE_STYLE_2) {\n            this._stateBeforeStyle2(c);\n        } else if (this._state === BEFORE_STYLE_3) {\n            this._stateBeforeStyle3(c);\n        } else if (this._state === BEFORE_STYLE_4) {\n            this._stateBeforeStyle4(c);\n        } else if (this._state === AFTER_STYLE_1) {\n            this._stateAfterStyle1(c);\n        } else if (this._state === AFTER_STYLE_2) {\n            this._stateAfterStyle2(c);\n        } else if (this._state === AFTER_STYLE_3) {\n            this._stateAfterStyle3(c);\n        } else if (this._state === AFTER_STYLE_4) {\n            this._stateAfterStyle4(c);\n        } else if (this._state === BEFORE_ENTITY) {\n\n        /*\n\t\t* entities\n\t\t*/\n            this._stateBeforeEntity(c);\n        } else if (this._state === BEFORE_NUMERIC_ENTITY) {\n            this._stateBeforeNumericEntity(c);\n        } else if (this._state === IN_NAMED_ENTITY) {\n            this._stateInNamedEntity(c);\n        } else if (this._state === IN_NUMERIC_ENTITY) {\n            this._stateInNumericEntity(c);\n        } else if (this._state === IN_HEX_ENTITY) {\n            this._stateInHexEntity(c);\n        } else {\n            this._cbs.onerror(Error(\"unknown _state\"), this._state);\n        }\n\n        this._index++;\n    }\n\n    this._cleanup();\n};\n\nTokenizer.prototype.pause = function() {\n    this._running = false;\n};\nTokenizer.prototype.resume = function() {\n    this._running = true;\n\n    if (this._index < this._buffer.length) {\n        this._parse();\n    }\n    if (this._ended) {\n        this._finish();\n    }\n};\n\nTokenizer.prototype.end = function(chunk) {\n    if (this._ended) this._cbs.onerror(Error(\".end() after done!\"));\n    if (chunk) this.write(chunk);\n\n    this._ended = true;\n\n    if (this._running) this._finish();\n};\n\nTokenizer.prototype._finish = function() {\n    //if there is remaining data, emit it in a reasonable way\n    if (this._sectionStart < this._index) {\n        this._handleTrailingData();\n    }\n\n    this._cbs.onend();\n};\n\nTokenizer.prototype._handleTrailingData = function() {\n    var data = this._buffer.substr(this._sectionStart);\n\n    if (\n        this._state === IN_CDATA ||\n        this._state === AFTER_CDATA_1 ||\n        this._state === AFTER_CDATA_2\n    ) {\n        this._cbs.oncdata(data);\n    } else if (\n        this._state === IN_COMMENT ||\n        this._state === AFTER_COMMENT_1 ||\n        this._state === AFTER_COMMENT_2\n    ) {\n        this._cbs.oncomment(data);\n    } else if (this._state === IN_NAMED_ENTITY && !this._xmlMode) {\n        this._parseLegacyEntity();\n        if (this._sectionStart < this._index) {\n            this._state = this._baseState;\n            this._handleTrailingData();\n        }\n    } else if (this._state === IN_NUMERIC_ENTITY && !this._xmlMode) {\n        this._decodeNumericEntity(2, 10);\n        if (this._sectionStart < this._index) {\n            this._state = this._baseState;\n            this._handleTrailingData();\n        }\n    } else if (this._state === IN_HEX_ENTITY && !this._xmlMode) {\n        this._decodeNumericEntity(3, 16);\n        if (this._sectionStart < this._index) {\n            this._state = this._baseState;\n            this._handleTrailingData();\n        }\n    } else if (\n        this._state !== IN_TAG_NAME &&\n        this._state !== BEFORE_ATTRIBUTE_NAME &&\n        this._state !== BEFORE_ATTRIBUTE_VALUE &&\n        this._state !== AFTER_ATTRIBUTE_NAME &&\n        this._state !== IN_ATTRIBUTE_NAME &&\n        this._state !== IN_ATTRIBUTE_VALUE_SQ &&\n        this._state !== IN_ATTRIBUTE_VALUE_DQ &&\n        this._state !== IN_ATTRIBUTE_VALUE_NQ &&\n        this._state !== IN_CLOSING_TAG_NAME\n    ) {\n        this._cbs.ontext(data);\n    }\n    //else, ignore remaining data\n    //TODO add a way to remove current tag\n};\n\nTokenizer.prototype.reset = function() {\n    Tokenizer.call(\n        this,\n        { xmlMode: this._xmlMode, decodeEntities: this._decodeEntities },\n        this._cbs\n    );\n};\n\nTokenizer.prototype.getAbsoluteIndex = function() {\n    return this._bufferOffset + this._index;\n};\n\nTokenizer.prototype._getSection = function() {\n    return this._buffer.substring(this._sectionStart, this._index);\n};\n\nTokenizer.prototype._emitToken = function(name) {\n    this._cbs[name](this._getSection());\n    this._sectionStart = -1;\n};\n\nTokenizer.prototype._emitPartial = function(value) {\n    if (this._baseState !== TEXT) {\n        this._cbs.onattribdata(value); //TODO implement the new event\n    } else {\n        this._cbs.ontext(value);\n    }\n};\n","var ElementType = require(\"domelementtype\");\n\nvar re_whitespace = /\\s+/g;\nvar NodePrototype = require(\"./lib/node\");\nvar ElementPrototype = require(\"./lib/element\");\n\nfunction DomHandler(callback, options, elementCB){\n\tif(typeof callback === \"object\"){\n\t\telementCB = options;\n\t\toptions = callback;\n\t\tcallback = null;\n\t} else if(typeof options === \"function\"){\n\t\telementCB = options;\n\t\toptions = defaultOpts;\n\t}\n\tthis._callback = callback;\n\tthis._options = options || defaultOpts;\n\tthis._elementCB = elementCB;\n\tthis.dom = [];\n\tthis._done = false;\n\tthis._tagStack = [];\n\tthis._parser = this._parser || null;\n}\n\n//default options\nvar defaultOpts = {\n\tnormalizeWhitespace: false, //Replace all whitespace with single spaces\n\twithStartIndices: false, //Add startIndex properties to nodes\n\twithEndIndices: false, //Add endIndex properties to nodes\n};\n\nDomHandler.prototype.onparserinit = function(parser){\n\tthis._parser = parser;\n};\n\n//Resets the handler back to starting state\nDomHandler.prototype.onreset = function(){\n\tDomHandler.call(this, this._callback, this._options, this._elementCB);\n};\n\n//Signals the handler that parsing is done\nDomHandler.prototype.onend = function(){\n\tif(this._done) return;\n\tthis._done = true;\n\tthis._parser = null;\n\tthis._handleCallback(null);\n};\n\nDomHandler.prototype._handleCallback =\nDomHandler.prototype.onerror = function(error){\n\tif(typeof this._callback === \"function\"){\n\t\tthis._callback(error, this.dom);\n\t} else {\n\t\tif(error) throw error;\n\t}\n};\n\nDomHandler.prototype.onclosetag = function(){\n\t//if(this._tagStack.pop().name !== name) this._handleCallback(Error(\"Tagname didn't match!\"));\n\t\n\tvar elem = this._tagStack.pop();\n\n\tif(this._options.withEndIndices && elem){\n\t\telem.endIndex = this._parser.endIndex;\n\t}\n\n\tif(this._elementCB) this._elementCB(elem);\n};\n\nDomHandler.prototype._createDomElement = function(properties){\n\tif (!this._options.withDomLvl1) return properties;\n\n\tvar element;\n\tif (properties.type === \"tag\") {\n\t\telement = Object.create(ElementPrototype);\n\t} else {\n\t\telement = Object.create(NodePrototype);\n\t}\n\n\tfor (var key in properties) {\n\t\tif (properties.hasOwnProperty(key)) {\n\t\t\telement[key] = properties[key];\n\t\t}\n\t}\n\n\treturn element;\n};\n\nDomHandler.prototype._addDomElement = function(element){\n\tvar parent = this._tagStack[this._tagStack.length - 1];\n\tvar siblings = parent ? parent.children : this.dom;\n\tvar previousSibling = siblings[siblings.length - 1];\n\n\telement.next = null;\n\n\tif(this._options.withStartIndices){\n\t\telement.startIndex = this._parser.startIndex;\n\t}\n\tif(this._options.withEndIndices){\n\t\telement.endIndex = this._parser.endIndex;\n\t}\n\n\tif(previousSibling){\n\t\telement.prev = previousSibling;\n\t\tpreviousSibling.next = element;\n\t} else {\n\t\telement.prev = null;\n\t}\n\n\tsiblings.push(element);\n\telement.parent = parent || null;\n};\n\nDomHandler.prototype.onopentag = function(name, attribs){\n\tvar properties = {\n\t\ttype: name === \"script\" ? ElementType.Script : name === \"style\" ? ElementType.Style : ElementType.Tag,\n\t\tname: name,\n\t\tattribs: attribs,\n\t\tchildren: []\n\t};\n\n\tvar element = this._createDomElement(properties);\n\n\tthis._addDomElement(element);\n\n\tthis._tagStack.push(element);\n};\n\nDomHandler.prototype.ontext = function(data){\n\t//the ignoreWhitespace is officially dropped, but for now,\n\t//it's an alias for normalizeWhitespace\n\tvar normalize = this._options.normalizeWhitespace || this._options.ignoreWhitespace;\n\n\tvar lastTag;\n\n\tif(!this._tagStack.length && this.dom.length && (lastTag = this.dom[this.dom.length-1]).type === ElementType.Text){\n\t\tif(normalize){\n\t\t\tlastTag.data = (lastTag.data + data).replace(re_whitespace, \" \");\n\t\t} else {\n\t\t\tlastTag.data += data;\n\t\t}\n\t} else {\n\t\tif(\n\t\t\tthis._tagStack.length &&\n\t\t\t(lastTag = this._tagStack[this._tagStack.length - 1]) &&\n\t\t\t(lastTag = lastTag.children[lastTag.children.length - 1]) &&\n\t\t\tlastTag.type === ElementType.Text\n\t\t){\n\t\t\tif(normalize){\n\t\t\t\tlastTag.data = (lastTag.data + data).replace(re_whitespace, \" \");\n\t\t\t} else {\n\t\t\t\tlastTag.data += data;\n\t\t\t}\n\t\t} else {\n\t\t\tif(normalize){\n\t\t\t\tdata = data.replace(re_whitespace, \" \");\n\t\t\t}\n\n\t\t\tvar element = this._createDomElement({\n\t\t\t\tdata: data,\n\t\t\t\ttype: ElementType.Text\n\t\t\t});\n\n\t\t\tthis._addDomElement(element);\n\t\t}\n\t}\n};\n\nDomHandler.prototype.oncomment = function(data){\n\tvar lastTag = this._tagStack[this._tagStack.length - 1];\n\n\tif(lastTag && lastTag.type === ElementType.Comment){\n\t\tlastTag.data += data;\n\t\treturn;\n\t}\n\n\tvar properties = {\n\t\tdata: data,\n\t\ttype: ElementType.Comment\n\t};\n\n\tvar element = this._createDomElement(properties);\n\n\tthis._addDomElement(element);\n\tthis._tagStack.push(element);\n};\n\nDomHandler.prototype.oncdatastart = function(){\n\tvar properties = {\n\t\tchildren: [{\n\t\t\tdata: \"\",\n\t\t\ttype: ElementType.Text\n\t\t}],\n\t\ttype: ElementType.CDATA\n\t};\n\n\tvar element = this._createDomElement(properties);\n\n\tthis._addDomElement(element);\n\tthis._tagStack.push(element);\n};\n\nDomHandler.prototype.oncommentend = DomHandler.prototype.oncdataend = function(){\n\tthis._tagStack.pop();\n};\n\nDomHandler.prototype.onprocessinginstruction = function(name, data){\n\tvar element = this._createDomElement({\n\t\tname: name,\n\t\tdata: data,\n\t\ttype: ElementType.Directive\n\t});\n\n\tthis._addDomElement(element);\n};\n\nmodule.exports = DomHandler;\n","// This object will be used as the prototype for Nodes when creating a\n// DOM-Level-1-compliant structure.\nvar NodePrototype = module.exports = {\n\tget firstChild() {\n\t\tvar children = this.children;\n\t\treturn children && children[0] || null;\n\t},\n\tget lastChild() {\n\t\tvar children = this.children;\n\t\treturn children && children[children.length - 1] || null;\n\t},\n\tget nodeType() {\n\t\treturn nodeTypes[this.type] || nodeTypes.element;\n\t}\n};\n\nvar domLvl1 = {\n\ttagName: \"name\",\n\tchildNodes: \"children\",\n\tparentNode: \"parent\",\n\tpreviousSibling: \"prev\",\n\tnextSibling: \"next\",\n\tnodeValue: \"data\"\n};\n\nvar nodeTypes = {\n\telement: 1,\n\ttext: 3,\n\tcdata: 4,\n\tcomment: 8\n};\n\nObject.keys(domLvl1).forEach(function(key) {\n\tvar shorthand = domLvl1[key];\n\tObject.defineProperty(NodePrototype, key, {\n\t\tget: function() {\n\t\t\treturn this[shorthand] || null;\n\t\t},\n\t\tset: function(val) {\n\t\t\tthis[shorthand] = val;\n\t\t\treturn val;\n\t\t}\n\t});\n});\n","var DomUtils = module.exports;\n\n[\n\trequire(\"./lib/stringify\"),\n\trequire(\"./lib/traversal\"),\n\trequire(\"./lib/manipulation\"),\n\trequire(\"./lib/querying\"),\n\trequire(\"./lib/legacy\"),\n\trequire(\"./lib/helpers\")\n].forEach(function(ext){\n\tObject.keys(ext).forEach(function(key){\n\t\tDomUtils[key] = ext[key].bind(DomUtils);\n\t});\n});\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 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\"));\nexports.decodeXML = getStrictDecoder(xml_json_1.default);\nexports.decodeHTMLStrict = getStrictDecoder(entities_json_1.default);\nfunction getStrictDecoder(map) {\n    var keys = Object.keys(map).join(\"|\");\n    var replace = getReplacer(map);\n    keys += \"|#[xX][\\\\da-fA-F]+|#\\\\d+\";\n    var re = new RegExp(\"&(?:\" + keys + \");\", \"g\");\n    return function (str) { return String(str).replace(re, 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) {\n        return String(str).replace(re, replacer);\n    };\n})();\nfunction getReplacer(map) {\n    return function replace(str) {\n        if (str.charAt(1) === \"#\") {\n            if (str.charAt(2) === \"X\" || str.charAt(2) === \"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        return map[str.slice(1, -1)];\n    };\n}\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 xml_json_1 = __importDefault(require(\"./maps/xml.json\"));\nvar inverseXML = getInverseObj(xml_json_1.default);\nvar xmlReplacer = getInverseReplacer(inverseXML);\nexports.encodeXML = getInverse(inverseXML, xmlReplacer);\nvar entities_json_1 = __importDefault(require(\"./maps/entities.json\"));\nvar inverseHTML = getInverseObj(entities_json_1.default);\nvar htmlReplacer = getInverseReplacer(inverseHTML);\nexports.encodeHTML = getInverse(inverseHTML, htmlReplacer);\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    Object.keys(inverse).forEach(function (k) {\n        return k.length === 1\n            ? // Add value to single array\n                single.push(\"\\\\\" + k)\n            : // Add value to multiple array\n                multiple.push(k);\n    });\n    //TODO add ranges\n    multiple.unshift(\"[\" + single.join(\"\") + \"]\");\n    return new RegExp(multiple.join(\"|\"), \"g\");\n}\nvar reNonASCII = /[^\\0-\\x7F]/g;\nvar reAstralSymbols = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/g;\nfunction singleCharReplacer(c) {\n    return \"&#x\" + c\n        .charCodeAt(0)\n        .toString(16)\n        .toUpperCase() + \";\";\n}\n// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any\nfunction astralReplacer(c, _) {\n    // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n    var high = c.charCodeAt(0);\n    var low = c.charCodeAt(1);\n    var codePoint = (high - 0xd800) * 0x400 + low - 0xdc00 + 0x10000;\n    return \"&#x\" + codePoint.toString(16).toUpperCase() + \";\";\n}\nfunction getInverse(inverse, re) {\n    return function (data) {\n        return data\n            .replace(re, function (name) { return inverse[name]; })\n            .replace(reAstralSymbols, astralReplacer)\n            .replace(reNonASCII, singleCharReplacer);\n    };\n}\nvar reXmlChars = getInverseReplacer(inverseXML);\nfunction escape(data) {\n    return data\n        .replace(reXmlChars, singleCharReplacer)\n        .replace(reAstralSymbols, astralReplacer)\n        .replace(reNonASCII, singleCharReplacer);\n}\nexports.escape = escape;\n","module.exports = Stream;\n\nvar Parser = require(\"./Parser.js\");\nvar WritableStream = require(\"readable-stream\").Writable;\nvar StringDecoder = require(\"string_decoder\").StringDecoder;\nvar Buffer = require(\"buffer\").Buffer;\n\nfunction Stream(cbs, options) {\n    var parser = (this._parser = new Parser(cbs, options));\n    var decoder = (this._decoder = new StringDecoder());\n\n    WritableStream.call(this, { decodeStrings: false });\n\n    this.once(\"finish\", function() {\n        parser.end(decoder.end());\n    });\n}\n\nrequire(\"inherits\")(Stream, WritableStream);\n\nStream.prototype._write = function(chunk, encoding, cb) {\n    if (chunk instanceof Buffer) chunk = this._decoder.write(chunk);\n    this._parser.write(chunk);\n    cb();\n};\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nexports.default = generatePropsFromAttributes;\n\nvar _htmlAttributesToReact = require('./htmlAttributesToReact');\n\nvar _htmlAttributesToReact2 = _interopRequireDefault(_htmlAttributesToReact);\n\nvar _inlineStyleToObject = require('./inlineStyleToObject');\n\nvar _inlineStyleToObject2 = _interopRequireDefault(_inlineStyleToObject);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Generates props for a React element from an object of HTML attributes\n *\n * @param {Object} attributes The HTML attributes\n * @param {String} key The key to give the react element\n */\nfunction generatePropsFromAttributes(attributes, key) {\n\n  // generate props\n  var props = _extends({}, (0, _htmlAttributesToReact2.default)(attributes), { key: key });\n\n  // if there is an inline/string style prop then convert it to a React style object\n  // otherwise, it is invalid and omitted\n  if (typeof props.style === 'string' || props.style instanceof String) {\n    props.style = (0, _inlineStyleToObject2.default)(props.style);\n  } else {\n    delete props.style;\n  }\n\n  return props;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = isValidTagOrAttributeName;\nvar VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\\.\\-\\d]*$/;\n\nvar nameCache = {};\n\nfunction isValidTagOrAttributeName(tagName) {\n  if (!nameCache.hasOwnProperty(tagName)) {\n    nameCache[tagName] = VALID_TAG_REGEX.test(tagName);\n  }\n  return nameCache[tagName];\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.htmlparser2 = exports.convertNodeToElement = exports.processNodes = undefined;\n\nvar _processNodes = require('./processNodes');\n\nObject.defineProperty(exports, 'processNodes', {\n  enumerable: true,\n  get: function get() {\n    return _interopRequireDefault(_processNodes).default;\n  }\n});\n\nvar _convertNodeToElement = require('./convertNodeToElement');\n\nObject.defineProperty(exports, 'convertNodeToElement', {\n  enumerable: true,\n  get: function get() {\n    return _interopRequireDefault(_convertNodeToElement).default;\n  }\n});\n\nvar _htmlparser = require('htmlparser2');\n\nObject.defineProperty(exports, 'htmlparser2', {\n  enumerable: true,\n  get: function get() {\n    return _interopRequireDefault(_htmlparser).default;\n  }\n});\n\nvar _HtmlParser = require('./HtmlParser');\n\nvar _HtmlParser2 = _interopRequireDefault(_HtmlParser);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = _HtmlParser2.default;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = isEmptyTextNode;\n/**\n * Tests a htmlparser2 node and returns whether is it a text node at the start and end of the line containing only\n * white space. This allows these node types to be excluded from the rendering because they are unnecessary.\n *\n * @param {Object} node The element object as created by htmlparser2\n * @returns {boolean} Whether the node is an empty text node\n */\nfunction isEmptyTextNode(node) {\n  return node.type === 'text' && /\\r?\\n/.test(node.data) && node.data.trim() === '';\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _ElementType$Text$Ele;\n\nvar _htmlparser = require('htmlparser2');\n\nvar _TextElementType = require('./TextElementType');\n\nvar _TextElementType2 = _interopRequireDefault(_TextElementType);\n\nvar _TagElementType = require('./TagElementType');\n\nvar _TagElementType2 = _interopRequireDefault(_TagElementType);\n\nvar _StyleElementType = require('./StyleElementType');\n\nvar _StyleElementType2 = _interopRequireDefault(_StyleElementType);\n\nvar _UnsupportedElementType = require('./UnsupportedElementType');\n\nvar _UnsupportedElementType2 = _interopRequireDefault(_UnsupportedElementType);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } /*\n                                                                                                                                                                                                                   * Map each htmlparser2 element type to a function which will convert that element type to a React element\n                                                                                                                                                                                                                   * Not all of the element types are supported so the UnsupportedElementType is used for them which will not return any\n                                                                                                                                                                                                                   * value\n                                                                                                                                                                                                                   */\n\nexports.default = (_ElementType$Text$Ele = {}, _defineProperty(_ElementType$Text$Ele, _htmlparser.ElementType.Text, _TextElementType2.default), _defineProperty(_ElementType$Text$Ele, _htmlparser.ElementType.Tag, _TagElementType2.default), _defineProperty(_ElementType$Text$Ele, _htmlparser.ElementType.Style, _StyleElementType2.default), _defineProperty(_ElementType$Text$Ele, _htmlparser.ElementType.Directive, _UnsupportedElementType2.default), _defineProperty(_ElementType$Text$Ele, _htmlparser.ElementType.Comment, _UnsupportedElementType2.default), _defineProperty(_ElementType$Text$Ele, _htmlparser.ElementType.Script, _UnsupportedElementType2.default), _defineProperty(_ElementType$Text$Ele, _htmlparser.ElementType.CDATA, _UnsupportedElementType2.default), _defineProperty(_ElementType$Text$Ele, _htmlparser.ElementType.Doctype, _UnsupportedElementType2.default), _ElementType$Text$Ele);","var decodeMap = require(\"../maps/decode.json\");\n\nmodule.exports = decodeCodePoint;\n\n// modified version of https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119\nfunction decodeCodePoint(codePoint) {\n    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {\n        return \"\\uFFFD\";\n    }\n\n    if (codePoint in decodeMap) {\n        codePoint = decodeMap[codePoint];\n    }\n\n    var output = \"\";\n\n    if (codePoint > 0xffff) {\n        codePoint -= 0x10000;\n        output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);\n        codePoint = 0xdc00 | (codePoint & 0x3ff);\n    }\n\n    output += String.fromCharCode(codePoint);\n    return output;\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\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","// DOM-Level-1-compliant structure\nvar NodePrototype = require('./node');\nvar ElementPrototype = module.exports = Object.create(NodePrototype);\n\nvar domLvl1 = {\n\ttagName: \"name\"\n};\n\nObject.keys(domLvl1).forEach(function(key) {\n\tvar shorthand = domLvl1[key];\n\tObject.defineProperty(ElementPrototype, key, {\n\t\tget: function() {\n\t\t\treturn this[shorthand] || null;\n\t\t},\n\t\tset: function(val) {\n\t\t\tthis[shorthand] = val;\n\t\t\treturn val;\n\t\t}\n\t});\n});\n","var DomHandler = require(\"domhandler\");\nvar DomUtils = require(\"domutils\");\n\n//TODO: make this a streamable handler\nfunction FeedHandler(callback, options) {\n    this.init(callback, options);\n}\n\nrequire(\"inherits\")(FeedHandler, DomHandler);\n\nFeedHandler.prototype.init = DomHandler;\n\nfunction getElements(what, where) {\n    return DomUtils.getElementsByTagName(what, where, true);\n}\nfunction getOneElement(what, where) {\n    return DomUtils.getElementsByTagName(what, where, true, 1)[0];\n}\nfunction fetch(what, where, recurse) {\n    return DomUtils.getText(\n        DomUtils.getElementsByTagName(what, where, recurse, 1)\n    ).trim();\n}\n\nfunction addConditionally(obj, prop, what, where, recurse) {\n    var tmp = fetch(what, where, recurse);\n    if (tmp) obj[prop] = tmp;\n}\n\nvar isValidFeed = function(value) {\n    return value === \"rss\" || value === \"feed\" || value === \"rdf:RDF\";\n};\n\nFeedHandler.prototype.onend = function() {\n    var feed = {},\n        feedRoot = getOneElement(isValidFeed, this.dom),\n        tmp,\n        childs;\n\n    if (feedRoot) {\n        if (feedRoot.name === \"feed\") {\n            childs = feedRoot.children;\n\n            feed.type = \"atom\";\n            addConditionally(feed, \"id\", \"id\", childs);\n            addConditionally(feed, \"title\", \"title\", childs);\n            if (\n                (tmp = getOneElement(\"link\", childs)) &&\n                (tmp = tmp.attribs) &&\n                (tmp = tmp.href)\n            )\n                feed.link = tmp;\n            addConditionally(feed, \"description\", \"subtitle\", childs);\n            if ((tmp = fetch(\"updated\", childs))) feed.updated = new Date(tmp);\n            addConditionally(feed, \"author\", \"email\", childs, true);\n\n            feed.items = getElements(\"entry\", childs).map(function(item) {\n                var entry = {},\n                    tmp;\n\n                item = item.children;\n\n                addConditionally(entry, \"id\", \"id\", item);\n                addConditionally(entry, \"title\", \"title\", item);\n                if (\n                    (tmp = getOneElement(\"link\", item)) &&\n                    (tmp = tmp.attribs) &&\n                    (tmp = tmp.href)\n                )\n                    entry.link = tmp;\n                if ((tmp = fetch(\"summary\", item) || fetch(\"content\", item)))\n                    entry.description = tmp;\n                if ((tmp = fetch(\"updated\", item)))\n                    entry.pubDate = new Date(tmp);\n                return entry;\n            });\n        } else {\n            childs = getOneElement(\"channel\", feedRoot.children).children;\n\n            feed.type = feedRoot.name.substr(0, 3);\n            feed.id = \"\";\n            addConditionally(feed, \"title\", \"title\", childs);\n            addConditionally(feed, \"link\", \"link\", childs);\n            addConditionally(feed, \"description\", \"description\", childs);\n            if ((tmp = fetch(\"lastBuildDate\", childs)))\n                feed.updated = new Date(tmp);\n            addConditionally(feed, \"author\", \"managingEditor\", childs, true);\n\n            feed.items = getElements(\"item\", feedRoot.children).map(function(\n                item\n            ) {\n                var entry = {},\n                    tmp;\n\n                item = item.children;\n\n                addConditionally(entry, \"id\", \"guid\", item);\n                addConditionally(entry, \"title\", \"title\", item);\n                addConditionally(entry, \"link\", \"link\", item);\n                addConditionally(entry, \"description\", \"description\", item);\n                if ((tmp = fetch(\"pubDate\", item)))\n                    entry.pubDate = new Date(tmp);\n                return entry;\n            });\n        }\n    }\n    this.dom = feed;\n    DomHandler.prototype._handleCallback.call(\n        this,\n        feedRoot ? null : Error(\"couldn't find root of feed\")\n    );\n};\n\nmodule.exports = FeedHandler;\n","var ElementType = require(\"domelementtype\"),\n    getOuterHTML = require(\"dom-serializer\"),\n    isTag = ElementType.isTag;\n\nmodule.exports = {\n\tgetInnerHTML: getInnerHTML,\n\tgetOuterHTML: getOuterHTML,\n\tgetText: getText\n};\n\nfunction getInnerHTML(elem, opts){\n\treturn elem.children ? elem.children.map(function(elem){\n\t\treturn getOuterHTML(elem, opts);\n\t}).join(\"\") : \"\";\n}\n\nfunction getText(elem){\n\tif(Array.isArray(elem)) return elem.map(getText).join(\"\");\n\tif(isTag(elem)) return elem.name === \"br\" ? \"\\n\" : getText(elem.children);\n\tif(elem.type === ElementType.CDATA) return getText(elem.children);\n\tif(elem.type === ElementType.Text) return elem.data;\n\treturn \"\";\n}\n","/*\n  Module dependencies\n*/\nvar ElementType = require('domelementtype');\nvar entities = require('entities');\n\n/* mixed-case SVG and MathML tags & attributes\n   recognized by the HTML parser, see\n   https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign\n*/\nvar foreignNames = require('./foreignNames.json');\nforeignNames.elementNames.__proto__ = null; /* use as a simple dictionary */\nforeignNames.attributeNames.__proto__ = null;\n\nvar unencodedElements = {\n  __proto__: null,\n  style: true,\n  script: true,\n  xmp: true,\n  iframe: true,\n  noembed: true,\n  noframes: true,\n  plaintext: true,\n  noscript: true\n};\n\n/*\n  Format attributes\n*/\nfunction formatAttrs(attributes, opts) {\n  if (!attributes) return;\n\n  var output = '';\n  var value;\n\n  // Loop through the attributes\n  for (var key in attributes) {\n    value = attributes[key];\n    if (output) {\n      output += ' ';\n    }\n\n    if (opts.xmlMode === 'foreign') {\n      /* fix up mixed-case attribute names */\n      key = foreignNames.attributeNames[key] || key;\n    }\n    output += key;\n    if ((value !== null && value !== '') || opts.xmlMode) {\n      output +=\n        '=\"' +\n        (opts.decodeEntities\n          ? entities.encodeXML(value)\n          : value.replace(/\\\"/g, '&quot;')) +\n        '\"';\n    }\n  }\n\n  return output;\n}\n\n/*\n  Self-enclosing tags (stolen from node-htmlparser)\n*/\nvar singleTag = {\n  __proto__: null,\n  area: true,\n  base: true,\n  basefont: true,\n  br: true,\n  col: true,\n  command: true,\n  embed: true,\n  frame: true,\n  hr: true,\n  img: true,\n  input: true,\n  isindex: true,\n  keygen: true,\n  link: true,\n  meta: true,\n  param: true,\n  source: true,\n  track: true,\n  wbr: true\n};\n\nvar render = (module.exports = function(dom, opts) {\n  if (!Array.isArray(dom) && !dom.cheerio) dom = [dom];\n  opts = opts || {};\n\n  var output = '';\n\n  for (var i = 0; i < dom.length; i++) {\n    var elem = dom[i];\n\n    if (elem.type === 'root') output += render(elem.children, opts);\n    else if (ElementType.isTag(elem)) output += renderTag(elem, opts);\n    else if (elem.type === ElementType.Directive)\n      output += renderDirective(elem);\n    else if (elem.type === ElementType.Comment) output += renderComment(elem);\n    else if (elem.type === ElementType.CDATA) output += renderCdata(elem);\n    else output += renderText(elem, opts);\n  }\n\n  return output;\n});\n\nvar foreignModeIntegrationPoints = [\n  'mi',\n  'mo',\n  'mn',\n  'ms',\n  'mtext',\n  'annotation-xml',\n  'foreignObject',\n  'desc',\n  'title'\n];\n\nfunction renderTag(elem, opts) {\n  // Handle SVG / MathML in HTML\n  if (opts.xmlMode === 'foreign') {\n    /* fix up mixed-case element names */\n    elem.name = foreignNames.elementNames[elem.name] || elem.name;\n    /* exit foreign mode at integration points */\n    if (\n      elem.parent &&\n      foreignModeIntegrationPoints.indexOf(elem.parent.name) >= 0\n    )\n      opts = Object.assign({}, opts, { xmlMode: false });\n  }\n  if (!opts.xmlMode && ['svg', 'math'].indexOf(elem.name) >= 0) {\n    opts = Object.assign({}, opts, { xmlMode: 'foreign' });\n  }\n\n  var tag = '<' + elem.name;\n  var attribs = formatAttrs(elem.attribs, opts);\n\n  if (attribs) {\n    tag += ' ' + attribs;\n  }\n\n  if (opts.xmlMode && (!elem.children || elem.children.length === 0)) {\n    tag += '/>';\n  } else {\n    tag += '>';\n    if (elem.children) {\n      tag += render(elem.children, opts);\n    }\n\n    if (!singleTag[elem.name] || opts.xmlMode) {\n      tag += '</' + elem.name + '>';\n    }\n  }\n\n  return tag;\n}\n\nfunction renderDirective(elem) {\n  return '<' + elem.data + '>';\n}\n\nfunction renderText(elem, opts) {\n  var data = elem.data || '';\n\n  // if entities weren't decoded, no need to encode them back\n  if (\n    opts.decodeEntities &&\n    !(elem.parent && elem.parent.name in unencodedElements)\n  ) {\n    data = entities.encodeXML(data);\n  }\n\n  return data;\n}\n\nfunction renderCdata(elem) {\n  return '<![CDATA[' + elem.children[0].data + ']]>';\n}\n\nfunction renderComment(elem) {\n  return '<!--' + elem.data + '-->';\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Tests whether an element is a tag or not.\n *\n * @param elem Element to test\n */\nfunction isTag(elem) {\n    return (elem.type === \"tag\" /* Tag */ ||\n        elem.type === \"script\" /* Script */ ||\n        elem.type === \"style\" /* Style */);\n}\nexports.isTag = isTag;\n// Exports for backwards compatibility\nexports.Text = \"text\" /* Text */; //Text\nexports.Directive = \"directive\" /* Directive */; //<? ... ?>\nexports.Comment = \"comment\" /* Comment */; //<!-- ... -->\nexports.Script = \"script\" /* Script */; //<script> tags\nexports.Style = \"style\" /* Style */; //<style> tags\nexports.Tag = \"tag\" /* Tag */; //Any tag\nexports.CDATA = \"cdata\" /* CDATA */; //<![CDATA[ ... ]]>\nexports.Doctype = \"doctype\" /* Doctype */;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar decode_1 = require(\"./decode\");\nvar encode_1 = require(\"./encode\");\nfunction decode(data, level) {\n    return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTML)(data);\n}\nexports.decode = decode;\nfunction decodeStrict(data, level) {\n    return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTMLStrict)(data);\n}\nexports.decodeStrict = decodeStrict;\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\");\nexports.encodeXML = encode_2.encodeXML;\nexports.encodeHTML = encode_2.encodeHTML;\nexports.escape = encode_2.escape;\n// Legacy aliases\nexports.encodeHTML4 = encode_2.encodeHTML;\nexports.encodeHTML5 = encode_2.encodeHTML;\nvar decode_2 = require(\"./decode\");\nexports.decodeXML = decode_2.decodeXML;\nexports.decodeHTML = decode_2.decodeHTML;\nexports.decodeHTMLStrict = decode_2.decodeHTMLStrict;\n// Legacy aliases\nexports.decodeHTML4 = decode_2.decodeHTML;\nexports.decodeHTML5 = decode_2.decodeHTML;\nexports.decodeHTML4Strict = decode_2.decodeHTMLStrict;\nexports.decodeHTML5Strict = decode_2.decodeHTMLStrict;\nexports.decodeXMLStrict = decode_2.decodeXML;\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// modified version of https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119\nfunction decodeCodePoint(codePoint) {\n    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {\n        return \"\\uFFFD\";\n    }\n    if (codePoint in decode_json_1.default) {\n        // @ts-ignore\n        codePoint = decode_json_1.default[codePoint];\n    }\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}\nexports.default = decodeCodePoint;\n","var getChildren = exports.getChildren = function(elem){\n\treturn elem.children;\n};\n\nvar getParent = exports.getParent = function(elem){\n\treturn elem.parent;\n};\n\nexports.getSiblings = function(elem){\n\tvar parent = getParent(elem);\n\treturn parent ? getChildren(parent) : [elem];\n};\n\nexports.getAttributeValue = function(elem, name){\n\treturn elem.attribs && elem.attribs[name];\n};\n\nexports.hasAttrib = function(elem, name){\n\treturn !!elem.attribs && hasOwnProperty.call(elem.attribs, name);\n};\n\nexports.getName = function(elem){\n\treturn elem.name;\n};\n","exports.removeElement = function(elem){\n\tif(elem.prev) elem.prev.next = elem.next;\n\tif(elem.next) elem.next.prev = elem.prev;\n\n\tif(elem.parent){\n\t\tvar childs = elem.parent.children;\n\t\tchilds.splice(childs.lastIndexOf(elem), 1);\n\t}\n};\n\nexports.replaceElement = function(elem, replacement){\n\tvar prev = replacement.prev = elem.prev;\n\tif(prev){\n\t\tprev.next = replacement;\n\t}\n\n\tvar next = replacement.next = elem.next;\n\tif(next){\n\t\tnext.prev = replacement;\n\t}\n\n\tvar parent = replacement.parent = elem.parent;\n\tif(parent){\n\t\tvar childs = parent.children;\n\t\tchilds[childs.lastIndexOf(elem)] = replacement;\n\t}\n};\n\nexports.appendChild = function(elem, child){\n\tchild.parent = elem;\n\n\tif(elem.children.push(child) !== 1){\n\t\tvar sibling = elem.children[elem.children.length - 2];\n\t\tsibling.next = child;\n\t\tchild.prev = sibling;\n\t\tchild.next = null;\n\t}\n};\n\nexports.append = function(elem, next){\n\tvar parent = elem.parent,\n\t\tcurrNext = elem.next;\n\n\tnext.next = currNext;\n\tnext.prev = elem;\n\telem.next = next;\n\tnext.parent = parent;\n\n\tif(currNext){\n\t\tcurrNext.prev = next;\n\t\tif(parent){\n\t\t\tvar childs = parent.children;\n\t\t\tchilds.splice(childs.lastIndexOf(currNext), 0, next);\n\t\t}\n\t} else if(parent){\n\t\tparent.children.push(next);\n\t}\n};\n\nexports.prepend = function(elem, prev){\n\tvar parent = elem.parent;\n\tif(parent){\n\t\tvar childs = parent.children;\n\t\tchilds.splice(childs.lastIndexOf(elem), 0, prev);\n\t}\n\n\tif(elem.prev){\n\t\telem.prev.next = prev;\n\t}\n\t\n\tprev.parent = parent;\n\tprev.prev = elem.prev;\n\tprev.next = elem;\n\telem.prev = prev;\n};\n\n\n","var isTag = require(\"domelementtype\").isTag;\n\nmodule.exports = {\n\tfilter: filter,\n\tfind: find,\n\tfindOneChild: findOneChild,\n\tfindOne: findOne,\n\texistsOne: existsOne,\n\tfindAll: findAll\n};\n\nfunction filter(test, element, recurse, limit){\n\tif(!Array.isArray(element)) element = [element];\n\n\tif(typeof limit !== \"number\" || !isFinite(limit)){\n\t\tlimit = Infinity;\n\t}\n\treturn find(test, element, recurse !== false, limit);\n}\n\nfunction find(test, elems, recurse, limit){\n\tvar result = [], childs;\n\n\tfor(var i = 0, j = elems.length; i < j; i++){\n\t\tif(test(elems[i])){\n\t\t\tresult.push(elems[i]);\n\t\t\tif(--limit <= 0) break;\n\t\t}\n\n\t\tchilds = elems[i].children;\n\t\tif(recurse && childs && childs.length > 0){\n\t\t\tchilds = find(test, childs, recurse, limit);\n\t\t\tresult = result.concat(childs);\n\t\t\tlimit -= childs.length;\n\t\t\tif(limit <= 0) break;\n\t\t}\n\t}\n\n\treturn result;\n}\n\nfunction findOneChild(test, elems){\n\tfor(var i = 0, l = elems.length; i < l; i++){\n\t\tif(test(elems[i])) return elems[i];\n\t}\n\n\treturn null;\n}\n\nfunction findOne(test, elems){\n\tvar elem = null;\n\n\tfor(var i = 0, l = elems.length; i < l && !elem; i++){\n\t\tif(!isTag(elems[i])){\n\t\t\tcontinue;\n\t\t} else if(test(elems[i])){\n\t\t\telem = elems[i];\n\t\t} else if(elems[i].children.length > 0){\n\t\t\telem = findOne(test, elems[i].children);\n\t\t}\n\t}\n\n\treturn elem;\n}\n\nfunction existsOne(test, elems){\n\tfor(var i = 0, l = elems.length; i < l; i++){\n\t\tif(\n\t\t\tisTag(elems[i]) && (\n\t\t\t\ttest(elems[i]) || (\n\t\t\t\t\telems[i].children.length > 0 &&\n\t\t\t\t\texistsOne(test, elems[i].children)\n\t\t\t\t)\n\t\t\t)\n\t\t){\n\t\t\treturn true;\n\t\t}\n\t}\n\n\treturn false;\n}\n\nfunction findAll(test, rootElems){\n\tvar result = [];\n\tvar stack = rootElems.slice();\n\twhile(stack.length){\n\t\tvar elem = stack.shift();\n\t\tif(!isTag(elem)) continue;\n\t\tif (elem.children && elem.children.length > 0) {\n\t\t\tstack.unshift.apply(stack, elem.children);\n\t\t}\n\t\tif(test(elem)) result.push(elem);\n\t}\n\treturn result;\n}\n","var ElementType = require(\"domelementtype\");\nvar isTag = exports.isTag = ElementType.isTag;\n\nexports.testElement = function(options, element){\n\tfor(var key in options){\n\t\tif(!options.hasOwnProperty(key));\n\t\telse if(key === \"tag_name\"){\n\t\t\tif(!isTag(element) || !options.tag_name(element.name)){\n\t\t\t\treturn false;\n\t\t\t}\n\t\t} else if(key === \"tag_type\"){\n\t\t\tif(!options.tag_type(element.type)) return false;\n\t\t} else if(key === \"tag_contains\"){\n\t\t\tif(isTag(element) || !options.tag_contains(element.data)){\n\t\t\t\treturn false;\n\t\t\t}\n\t\t} else if(!element.attribs || !options[key](element.attribs[key])){\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n};\n\nvar Checks = {\n\ttag_name: function(name){\n\t\tif(typeof name === \"function\"){\n\t\t\treturn function(elem){ return isTag(elem) && name(elem.name); };\n\t\t} else if(name === \"*\"){\n\t\t\treturn isTag;\n\t\t} else {\n\t\t\treturn function(elem){ return isTag(elem) && elem.name === name; };\n\t\t}\n\t},\n\ttag_type: function(type){\n\t\tif(typeof type === \"function\"){\n\t\t\treturn function(elem){ return type(elem.type); };\n\t\t} else {\n\t\t\treturn function(elem){ return elem.type === type; };\n\t\t}\n\t},\n\ttag_contains: function(data){\n\t\tif(typeof data === \"function\"){\n\t\t\treturn function(elem){ return !isTag(elem) && data(elem.data); };\n\t\t} else {\n\t\t\treturn function(elem){ return !isTag(elem) && elem.data === data; };\n\t\t}\n\t}\n};\n\nfunction getAttribCheck(attrib, value){\n\tif(typeof value === \"function\"){\n\t\treturn function(elem){ return elem.attribs && value(elem.attribs[attrib]); };\n\t} else {\n\t\treturn function(elem){ return elem.attribs && elem.attribs[attrib] === value; };\n\t}\n}\n\nfunction combineFuncs(a, b){\n\treturn function(elem){\n\t\treturn a(elem) || b(elem);\n\t};\n}\n\nexports.getElements = function(options, element, recurse, limit){\n\tvar funcs = Object.keys(options).map(function(key){\n\t\tvar value = options[key];\n\t\treturn key in Checks ? Checks[key](value) : getAttribCheck(key, value);\n\t});\n\n\treturn funcs.length === 0 ? [] : this.filter(\n\t\tfuncs.reduce(combineFuncs),\n\t\telement, recurse, limit\n\t);\n};\n\nexports.getElementById = function(id, element, recurse){\n\tif(!Array.isArray(element)) element = [element];\n\treturn this.findOne(getAttribCheck(\"id\", id), element, recurse !== false);\n};\n\nexports.getElementsByTagName = function(name, element, recurse, limit){\n\treturn this.filter(Checks.tag_name(name), element, recurse, limit);\n};\n\nexports.getElementsByTagType = function(type, element, recurse, limit){\n\treturn this.filter(Checks.tag_type(type), element, recurse, limit);\n};\n","// removeSubsets\n// Given an array of nodes, remove any member that is contained by another.\nexports.removeSubsets = function(nodes) {\n\tvar idx = nodes.length, node, ancestor, replace;\n\n\t// Check if each node (or one of its ancestors) is already contained in the\n\t// array.\n\twhile (--idx > -1) {\n\t\tnode = ancestor = nodes[idx];\n\n\t\t// Temporarily remove the node under consideration\n\t\tnodes[idx] = null;\n\t\treplace = true;\n\n\t\twhile (ancestor) {\n\t\t\tif (nodes.indexOf(ancestor) > -1) {\n\t\t\t\treplace = false;\n\t\t\t\tnodes.splice(idx, 1);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tancestor = ancestor.parent;\n\t\t}\n\n\t\t// If the node has been found to be unique, re-insert it.\n\t\tif (replace) {\n\t\t\tnodes[idx] = node;\n\t\t}\n\t}\n\n\treturn nodes;\n};\n\n// Source: http://dom.spec.whatwg.org/#dom-node-comparedocumentposition\nvar POSITION = {\n\tDISCONNECTED: 1,\n\tPRECEDING: 2,\n\tFOLLOWING: 4,\n\tCONTAINS: 8,\n\tCONTAINED_BY: 16\n};\n\n// Compare the position of one node against another node in any other document.\n// The return value is a bitmask with the following values:\n//\n// document order:\n// > There is an ordering, document order, defined on all the nodes in the\n// > document corresponding to the order in which the first character of the\n// > XML representation of each node occurs in the XML representation of the\n// > document after expansion of general entities. Thus, the document element\n// > node will be the first node. Element nodes occur before their children.\n// > Thus, document order orders element nodes in order of the occurrence of\n// > their start-tag in the XML (after expansion of entities). The attribute\n// > nodes of an element occur after the element and before its children. The\n// > relative order of attribute nodes is implementation-dependent./\n// Source:\n// http://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-document-order\n//\n// @argument {Node} nodaA The first node to use in the comparison\n// @argument {Node} nodeB The second node to use in the comparison\n//\n// @return {Number} A bitmask describing the input nodes' relative position.\n//         See http://dom.spec.whatwg.org/#dom-node-comparedocumentposition for\n//         a description of these values.\nvar comparePos = exports.compareDocumentPosition = function(nodeA, nodeB) {\n\tvar aParents = [];\n\tvar bParents = [];\n\tvar current, sharedParent, siblings, aSibling, bSibling, idx;\n\n\tif (nodeA === nodeB) {\n\t\treturn 0;\n\t}\n\n\tcurrent = nodeA;\n\twhile (current) {\n\t\taParents.unshift(current);\n\t\tcurrent = current.parent;\n\t}\n\tcurrent = nodeB;\n\twhile (current) {\n\t\tbParents.unshift(current);\n\t\tcurrent = current.parent;\n\t}\n\n\tidx = 0;\n\twhile (aParents[idx] === bParents[idx]) {\n\t\tidx++;\n\t}\n\n\tif (idx === 0) {\n\t\treturn POSITION.DISCONNECTED;\n\t}\n\n\tsharedParent = aParents[idx - 1];\n\tsiblings = sharedParent.children;\n\taSibling = aParents[idx];\n\tbSibling = bParents[idx];\n\n\tif (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {\n\t\tif (sharedParent === nodeB) {\n\t\t\treturn POSITION.FOLLOWING | POSITION.CONTAINED_BY;\n\t\t}\n\t\treturn POSITION.FOLLOWING;\n\t} else {\n\t\tif (sharedParent === nodeA) {\n\t\t\treturn POSITION.PRECEDING | POSITION.CONTAINS;\n\t\t}\n\t\treturn POSITION.PRECEDING;\n\t}\n};\n\n// Sort an array of nodes based on their relative position in the document and\n// remove any duplicate nodes. If the array contains nodes that do not belong\n// to the same document, sort order is unspecified.\n//\n// @argument {Array} nodes Array of DOM nodes\n//\n// @returns {Array} collection of unique nodes, sorted in document order\nexports.uniqueSort = function(nodes) {\n\tvar idx = nodes.length, node, position;\n\n\tnodes = nodes.slice();\n\n\twhile (--idx > -1) {\n\t\tnode = nodes[idx];\n\t\tposition = nodes.indexOf(node);\n\t\tif (position > -1 && position < idx) {\n\t\t\tnodes.splice(idx, 1);\n\t\t}\n\t}\n\tnodes.sort(function(a, b) {\n\t\tvar relative = comparePos(a, b);\n\t\tif (relative & POSITION.PRECEDING) {\n\t\t\treturn -1;\n\t\t} else if (relative & POSITION.FOLLOWING) {\n\t\t\treturn 1;\n\t\t}\n\t\treturn 0;\n\t});\n\n\treturn nodes;\n};\n","module.exports = Stream;\n\nvar Parser = require(\"./WritableStream.js\");\n\nfunction Stream(options) {\n    Parser.call(this, new Cbs(this), options);\n}\n\nrequire(\"inherits\")(Stream, Parser);\n\nStream.prototype.readable = true;\n\nfunction Cbs(scope) {\n    this.scope = scope;\n}\n\nvar EVENTS = require(\"../\").EVENTS;\n\nObject.keys(EVENTS).forEach(function(name) {\n    if (EVENTS[name] === 0) {\n        Cbs.prototype[\"on\" + name] = function() {\n            this.scope.emit(name);\n        };\n    } else if (EVENTS[name] === 1) {\n        Cbs.prototype[\"on\" + name] = function(a) {\n            this.scope.emit(name, a);\n        };\n    } else if (EVENTS[name] === 2) {\n        Cbs.prototype[\"on\" + name] = function(a, b) {\n            this.scope.emit(name, a, b);\n        };\n    } else {\n        throw Error(\"wrong number of arguments!\");\n    }\n});\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'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}","/* 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","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","module.exports = ProxyHandler;\n\nfunction ProxyHandler(cbs) {\n    this._cbs = cbs || {};\n}\n\nvar EVENTS = require(\"./\").EVENTS;\nObject.keys(EVENTS).forEach(function(name) {\n    if (EVENTS[name] === 0) {\n        name = \"on\" + name;\n        ProxyHandler.prototype[name] = function() {\n            if (this._cbs[name]) this._cbs[name]();\n        };\n    } else if (EVENTS[name] === 1) {\n        name = \"on\" + name;\n        ProxyHandler.prototype[name] = function(a) {\n            if (this._cbs[name]) this._cbs[name](a);\n        };\n    } else if (EVENTS[name] === 2) {\n        name = \"on\" + name;\n        ProxyHandler.prototype[name] = function(a, b) {\n            if (this._cbs[name]) this._cbs[name](a, b);\n        };\n    } else {\n        throw Error(\"wrong number of arguments\");\n    }\n});\n","module.exports = CollectingHandler;\n\nfunction CollectingHandler(cbs) {\n    this._cbs = cbs || {};\n    this.events = [];\n}\n\nvar EVENTS = require(\"./\").EVENTS;\nObject.keys(EVENTS).forEach(function(name) {\n    if (EVENTS[name] === 0) {\n        name = \"on\" + name;\n        CollectingHandler.prototype[name] = function() {\n            this.events.push([name]);\n            if (this._cbs[name]) this._cbs[name]();\n        };\n    } else if (EVENTS[name] === 1) {\n        name = \"on\" + name;\n        CollectingHandler.prototype[name] = function(a) {\n            this.events.push([name, a]);\n            if (this._cbs[name]) this._cbs[name](a);\n        };\n    } else if (EVENTS[name] === 2) {\n        name = \"on\" + name;\n        CollectingHandler.prototype[name] = function(a, b) {\n            this.events.push([name, a, b]);\n            if (this._cbs[name]) this._cbs[name](a, b);\n        };\n    } else {\n        throw Error(\"wrong number of arguments\");\n    }\n});\n\nCollectingHandler.prototype.onreset = function() {\n    this.events = [];\n    if (this._cbs.onreset) this._cbs.onreset();\n};\n\nCollectingHandler.prototype.restart = function() {\n    if (this._cbs.onreset) this._cbs.onreset();\n\n    for (var i = 0, len = this.events.length; i < len; i++) {\n        if (this._cbs[this.events[i][0]]) {\n            var num = this.events[i].length;\n\n            if (num === 1) {\n                this._cbs[this.events[i][0]]();\n            } else if (num === 2) {\n                this._cbs[this.events[i][0]](this.events[i][1]);\n            } else {\n                this._cbs[this.events[i][0]](\n                    this.events[i][1],\n                    this.events[i][2]\n                );\n            }\n        }\n    }\n};\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = TextElementType;\n/**\n * Converts a text node to a React text element\n *\n * @param {Object} node The text node\n * @returns {String} The text\n */\nfunction TextElementType(node) {\n\n  // React will accept plain text for rendering so just return the node data\n  return node.data;\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = TagElementType;\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _processNodes = require('../processNodes');\n\nvar _processNodes2 = _interopRequireDefault(_processNodes);\n\nvar _generatePropsFromAttributes = require('../utils/generatePropsFromAttributes');\n\nvar _generatePropsFromAttributes2 = _interopRequireDefault(_generatePropsFromAttributes);\n\nvar _VoidElements = require('../dom/elements/VoidElements');\n\nvar _VoidElements2 = _interopRequireDefault(_VoidElements);\n\nvar _isValidTagOrAttributeName = require('../utils/isValidTagOrAttributeName');\n\nvar _isValidTagOrAttributeName2 = _interopRequireDefault(_isValidTagOrAttributeName);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Converts any element (excluding style - see StyleElementType - and script) to a react element.\n *\n * @param {Object} node The tag node\n * @param {String} index The index of the React element relative to it's parent\n * @param {Function} transform The transform function to apply to all children\n * @returns {React.Element} The React tag element\n */\nfunction TagElementType(node, index, transform) {\n\n  var tagName = node.name;\n\n  // validate tag name\n  if (!(0, _isValidTagOrAttributeName2.default)(tagName)) {\n    return null;\n  }\n\n  // generate props\n  var props = (0, _generatePropsFromAttributes2.default)(node.attribs, index);\n\n  // If the node is not a void element and has children then process them\n  var children = null;\n  if (_VoidElements2.default.indexOf(tagName) === -1) {\n    children = (0, _processNodes2.default)(node.children, transform);\n  }\n\n  // create and return the element\n  return _react2.default.createElement(tagName, props, children);\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = htmlAttributesToReact;\n\nvar _BooleanAttributes = require('../dom/attributes/BooleanAttributes');\n\nvar _BooleanAttributes2 = _interopRequireDefault(_BooleanAttributes);\n\nvar _ReactAttributes = require('../dom/attributes/ReactAttributes');\n\nvar _ReactAttributes2 = _interopRequireDefault(_ReactAttributes);\n\nvar _isValidTagOrAttributeName = require('./isValidTagOrAttributeName');\n\nvar _isValidTagOrAttributeName2 = _interopRequireDefault(_isValidTagOrAttributeName);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Returns the parsed attribute value taking into account things like boolean attributes\n *\n * @param {String} attribute The name of the attribute\n * @param {*} value The value of the attribute from the HTML\n * @returns {*} The parsed attribute value\n */\nvar getParsedAttributeValue = function getParsedAttributeValue(attribute, value) {\n\n  // if the attribute if a boolean then it's value should be the same as it's name\n  // e.g. disabled=\"disabled\"\n  var lowerBooleanAttributes = _BooleanAttributes2.default.map(function (attr) {\n    return attr.toLowerCase();\n  });\n  if (lowerBooleanAttributes.indexOf(attribute.toLowerCase()) >= 0) {\n    value = attribute;\n  }\n\n  return value;\n};\n\n/**\n * Takes an object of standard HTML property names and converts them to their React counterpart. If the react\n * version does not exist for an attribute then just use it as it is\n *\n * @param {Object} attributes The HTML attributes to convert\n * @returns {Object} The React attributes\n */\nfunction htmlAttributesToReact(attributes) {\n\n  return Object.keys(attributes).filter(function (attr) {\n    return (0, _isValidTagOrAttributeName2.default)(attr);\n  }).reduce(function (mappedAttributes, attribute) {\n\n    // lowercase the attribute name and find it in the react attribute map\n    var lowerCaseAttribute = attribute.toLowerCase();\n\n    // format the attribute name\n    var name = _ReactAttributes2.default[lowerCaseAttribute] || lowerCaseAttribute;\n\n    // add the parsed attribute value to the mapped attributes\n    mappedAttributes[name] = getParsedAttributeValue(name, attributes[attribute]);\n\n    return mappedAttributes;\n  }, {});\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n/**\n * List of boolean attributes\n * These attributes should have their React attribute value set to be the same as their name\n * E.g. <input disabled> = <input disabled>\n *      <input disabled=\"\"> = <input disabled>\n *      <input disabled=\"disabled\"> = <input disabled>\n * @type {Array}\n */\nexports.default = ['allowfullScreen', 'async', 'autoplay', 'capture', 'checked', 'controls', 'default', 'defer', 'disabled', 'formnovalidate', 'hidden', 'loop', 'multiple', 'muted', 'novalidate', 'open', 'playsinline', 'readonly', 'required', 'reversed', 'scoped', 'seamless', 'selected', 'itemscope'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n/**\n * Mapping of standard HTML attributes to their React counterparts\n * List taken and reversed from react/src/renderers/dom/shared/HTMLDOMPropertyConfig.js\n * https://github.com/facebook/react/blob/c9c3c339b757682f1154f1c915eb55e6a8766933/src/renderers/dom/shared/HTMLDOMPropertyConfig.js\n * @type {Object}\n */\nexports.default = {\n  /**\n   * Standard Properties\n   */\n  accept: 'accept',\n  'accept-charset': 'acceptCharset',\n  accesskey: 'accessKey',\n  action: 'action',\n  allowfullscreen: 'allowFullScreen',\n  allowtransparency: 'allowTransparency',\n  alt: 'alt',\n  as: 'as',\n  async: 'async',\n  autocomplete: 'autoComplete',\n  autoplay: 'autoPlay',\n  capture: 'capture',\n  cellpadding: 'cellPadding',\n  cellspacing: 'cellSpacing',\n  charset: 'charSet',\n  challenge: 'challenge',\n  checked: 'checked',\n  cite: 'cite',\n  classid: 'classID',\n  class: 'className',\n  cols: 'cols',\n  colspan: 'colSpan',\n  content: 'content',\n  contenteditable: 'contentEditable',\n  contextmenu: 'contextMenu',\n  controls: 'controls',\n  controlsList: 'controlsList',\n  coords: 'coords',\n  crossorigin: 'crossOrigin',\n  data: 'data',\n  datetime: 'dateTime',\n  default: 'default',\n  defer: 'defer',\n  dir: 'dir',\n  disabled: 'disabled',\n  download: 'download',\n  draggable: 'draggable',\n  enctype: 'encType',\n  form: 'form',\n  formaction: 'formAction',\n  formenctype: 'formEncType',\n  formmethod: 'formMethod',\n  formnovalidate: 'formNoValidate',\n  formtarget: 'formTarget',\n  frameborder: 'frameBorder',\n  headers: 'headers',\n  height: 'height',\n  hidden: 'hidden',\n  high: 'high',\n  href: 'href',\n  hreflang: 'hrefLang',\n  for: 'htmlFor',\n  'http-equiv': 'httpEquiv',\n  icon: 'icon',\n  id: 'id',\n  inputmode: 'inputMode',\n  integrity: 'integrity',\n  is: 'is',\n  keyparams: 'keyParams',\n  keytype: 'keyType',\n  kind: 'kind',\n  label: 'label',\n  lang: 'lang',\n  list: 'list',\n  loop: 'loop',\n  low: 'low',\n  manifest: 'manifest',\n  marginheight: 'marginHeight',\n  marginwidth: 'marginWidth',\n  max: 'max',\n  maxlength: 'maxLength',\n  media: 'media',\n  mediagroup: 'mediaGroup',\n  method: 'method',\n  min: 'min',\n  minlength: 'minLength',\n  multiple: 'multiple',\n  muted: 'muted',\n  name: 'name',\n  nonce: 'nonce',\n  novalidate: 'noValidate',\n  open: 'open',\n  optimum: 'optimum',\n  pattern: 'pattern',\n  placeholder: 'placeholder',\n  playsinline: 'playsInline',\n  poster: 'poster',\n  preload: 'preload',\n  profile: 'profile',\n  radiogroup: 'radioGroup',\n  readonly: 'readOnly',\n  referrerpolicy: 'referrerPolicy',\n  rel: 'rel',\n  required: 'required',\n  reversed: 'reversed',\n  role: 'role',\n  rows: 'rows',\n  rowspan: 'rowSpan',\n  sandbox: 'sandbox',\n  scope: 'scope',\n  scoped: 'scoped',\n  scrolling: 'scrolling',\n  seamless: 'seamless',\n  selected: 'selected',\n  shape: 'shape',\n  size: 'size',\n  sizes: 'sizes',\n  slot: 'slot',\n  span: 'span',\n  spellcheck: 'spellCheck',\n  src: 'src',\n  srcdoc: 'srcDoc',\n  srclang: 'srcLang',\n  srcset: 'srcSet',\n  start: 'start',\n  step: 'step',\n  style: 'style',\n  summary: 'summary',\n  tabindex: 'tabIndex',\n  target: 'target',\n  title: 'title',\n  type: 'type',\n  usemap: 'useMap',\n  value: 'value',\n  width: 'width',\n  wmode: 'wmode',\n  wrap: 'wrap',\n  /**\n   * RDFa Properties\n   */\n  about: 'about',\n  datatype: 'datatype',\n  inlist: 'inlist',\n  prefix: 'prefix',\n  property: 'property',\n  resource: 'resource',\n  typeof: 'typeof',\n  vocab: 'vocab',\n  /**\n   * Non-standard Properties\n   */\n  autocapitalize: 'autoCapitalize',\n  autocorrect: 'autoCorrect',\n  autosave: 'autoSave',\n  color: 'color',\n  itemprop: 'itemProp',\n  itemscope: 'itemScope',\n  itemtype: 'itemType',\n  itemid: 'itemID',\n  itemref: 'itemRef',\n  results: 'results',\n  security: 'security',\n  unselectable: 'unselectable'\n};","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nexports.default = InlineStyleToObject;\n/**\n * Converts an inline style string into an object of React style properties\n *\n * @param {String} inlineStyle='' The inline style to convert\n * @returns {Object} The converted style\n */\nfunction InlineStyleToObject() {\n  var inlineStyle = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n\n\n  // just return empty object if the inlineStyle is empty\n  if (inlineStyle === '') {\n    return {};\n  }\n\n  return inlineStyle.split(';').reduce(function (styleObject, stylePropertyValue) {\n\n    // extract the style property name and value\n    var _stylePropertyValue$s = stylePropertyValue.split(/^([^:]+):/).filter(function (val, i) {\n      return i > 0;\n    }).map(function (item) {\n      return item.trim().toLowerCase();\n    }),\n        _stylePropertyValue$s2 = _slicedToArray(_stylePropertyValue$s, 2),\n        property = _stylePropertyValue$s2[0],\n        value = _stylePropertyValue$s2[1];\n\n    // if there is no value (i.e. no : in the style) then ignore it\n\n\n    if (value === undefined) {\n      return styleObject;\n    }\n\n    // convert the property name into the correct React format\n    // remove all hyphens and convert the letter immediately after each hyphen to upper case\n    // additionally don't uppercase any -ms- prefix\n    // e.g. -ms-style-property = msStyleProperty\n    //      -webkit-style-property = WebkitStyleProperty\n    property = property.replace(/^-ms-/, 'ms-').replace(/-(.)/g, function (_, character) {\n      return character.toUpperCase();\n    });\n\n    // add the new style property and value to the style object\n    styleObject[property] = value;\n\n    return styleObject;\n  }, {});\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n/**\n * List of void elements\n * These elements are not allowed to have children\n * @type {Array}\n */\nexports.default = ['area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = StyleElementType;\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _generatePropsFromAttributes = require('../utils/generatePropsFromAttributes');\n\nvar _generatePropsFromAttributes2 = _interopRequireDefault(_generatePropsFromAttributes);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Converts a <style> element to a React element\n *\n * @param {Object} node The style node\n * @param {String} index The index of the React element relative to it's parent\n * @returns {React.Element} The React style element\n */\nfunction StyleElementType(node, index) {\n\n  // The style element only ever has a single child which is the styles so try and find this to add as\n  // a child to the style element that will be created\n  var styles = void 0;\n  if (node.children.length > 0) {\n    styles = node.children[0].data;\n  }\n\n  // generate props\n  var props = (0, _generatePropsFromAttributes2.default)(node.attribs, index);\n\n  // create and return the element\n  return _react2.default.createElement('style', props, styles);\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = UnsupportedElementType;\n/**\n * Handles an unsupported element type by returning null so nothing is rendered\n * @returns {null}\n */\nfunction UnsupportedElementType() {\n\n  // do nothing because the element type is unsupported\n  // comment, directive, script, cdata, doctype are all currently unsupported\n  return null;\n}","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = HtmlParser;\n\nvar _htmlparser = require('htmlparser2');\n\nvar _htmlparser2 = _interopRequireDefault(_htmlparser);\n\nvar _processNodes = require('./processNodes');\n\nvar _processNodes2 = _interopRequireDefault(_processNodes);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Parses a HTML string and returns a list of React components generated from it\n *\n * @param {String} html The HTML to convert into React component\n * @param {Object} options Options to pass\n * @returns {Array} List of top level React elements\n */\nfunction HtmlParser(html) {\n  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n      _ref$decodeEntities = _ref.decodeEntities,\n      decodeEntities = _ref$decodeEntities === undefined ? true : _ref$decodeEntities,\n      transform = _ref.transform,\n      _ref$preprocessNodes = _ref.preprocessNodes,\n      preprocessNodes = _ref$preprocessNodes === undefined ? function (nodes) {\n    return nodes;\n  } : _ref$preprocessNodes;\n\n  var nodes = preprocessNodes(_htmlparser2.default.parseDOM(html, { decodeEntities: decodeEntities }));\n  return (0, _processNodes2.default)(nodes, transform);\n}"],"sourceRoot":""}