{"mappings":"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","names":["require_sax","__commonJSMin","exports","sax","strict","opt","SAXParser","SAXStream","createStream","buffers","parser","clearBuffers","S","rootNS","emit","o","F","newf","a","i","checkBufferLength","maxAllowed","maxActual","l","len","closeText","emitNode","error","m","flushBuffers","end","write","Stream","streamWraps","ev","me","er","h","data","SD","chunk","handler","args","CDATA","DOCTYPE","XML_NAMESPACE","XMLNS_NAMESPACE","nameStart","nameBody","entityStart","entityBody","isWhitespace","c","isQuote","isAttribEnd","isMatch","regex","notMatch","key","e","s","event","nodeType","textopts","text","strictFail","message","newTag","parent","tag","qname","name","attribute","qualName","prefix","local","attrib","qn","openTag","selfClosing","p","nv","value","uri","closeTag","tagName","closeTo","close","x","n","parseEntity","entity","entityLC","num","numStr","beginWhiteSpace","charAt","result","starti","pad","returnState","buffer","parsedEntity","stringFromCharCode","floor","fromCodePoint","MAX_SIZE","codeUnits","highSurrogate","lowSurrogate","index","length","codePoint","build_exports","__export","build_default","__module","__reExport","__default","__rest"],"sourceRoot":"/","sources":["../esmd/npm/sax@1.3.0/node_modules/.pnpm/sax@1.3.0/node_modules/sax/lib/sax.js","../esmd/npm/sax@1.3.0/build.js"],"sourcesContent":[";(function (sax) { // wrapper for non-node envs\n  sax.parser = function (strict, opt) { return new SAXParser(strict, opt) }\n  sax.SAXParser = SAXParser\n  sax.SAXStream = SAXStream\n  sax.createStream = createStream\n\n  // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.\n  // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),\n  // since that's the earliest that a buffer overrun could occur.  This way, checks are\n  // as rare as required, but as often as necessary to ensure never crossing this bound.\n  // Furthermore, buffers are only tested at most once per write(), so passing a very\n  // large string into write() might have undesirable effects, but this is manageable by\n  // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme\n  // edge case, result in creating at most one complete copy of the string passed in.\n  // Set to Infinity to have unlimited buffers.\n  sax.MAX_BUFFER_LENGTH = 64 * 1024\n\n  var buffers = [\n    'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',\n    'procInstName', 'procInstBody', 'entity', 'attribName',\n    'attribValue', 'cdata', 'script'\n  ]\n\n  sax.EVENTS = [\n    'text',\n    'processinginstruction',\n    'sgmldeclaration',\n    'doctype',\n    'comment',\n    'opentagstart',\n    'attribute',\n    'opentag',\n    'closetag',\n    'opencdata',\n    'cdata',\n    'closecdata',\n    'error',\n    'end',\n    'ready',\n    'script',\n    'opennamespace',\n    'closenamespace'\n  ]\n\n  function SAXParser (strict, opt) {\n    if (!(this instanceof SAXParser)) {\n      return new SAXParser(strict, opt)\n    }\n\n    var parser = this\n    clearBuffers(parser)\n    parser.q = parser.c = ''\n    parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH\n    parser.opt = opt || {}\n    parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags\n    parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase'\n    parser.tags = []\n    parser.closed = parser.closedRoot = parser.sawRoot = false\n    parser.tag = parser.error = null\n    parser.strict = !!strict\n    parser.noscript = !!(strict || parser.opt.noscript)\n    parser.state = S.BEGIN\n    parser.strictEntities = parser.opt.strictEntities\n    parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES)\n    parser.attribList = []\n\n    // namespaces form a prototype chain.\n    // it always points at the current tag,\n    // which protos to its parent tag.\n    if (parser.opt.xmlns) {\n      parser.ns = Object.create(rootNS)\n    }\n\n    // mostly just for error reporting\n    parser.trackPosition = parser.opt.position !== false\n    if (parser.trackPosition) {\n      parser.position = parser.line = parser.column = 0\n    }\n    emit(parser, 'onready')\n  }\n\n  if (!Object.create) {\n    Object.create = function (o) {\n      function F () {}\n      F.prototype = o\n      var newf = new F()\n      return newf\n    }\n  }\n\n  if (!Object.keys) {\n    Object.keys = function (o) {\n      var a = []\n      for (var i in o) if (o.hasOwnProperty(i)) a.push(i)\n      return a\n    }\n  }\n\n  function checkBufferLength (parser) {\n    var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10)\n    var maxActual = 0\n    for (var i = 0, l = buffers.length; i \u003c l; i++) {\n      var len = parser[buffers[i]].length\n      if (len \u003e maxAllowed) {\n        // Text/cdata nodes can get big, and since they're buffered,\n        // we can get here under normal conditions.\n        // Avoid issues by emitting the text node now,\n        // so at least it won't get any bigger.\n        switch (buffers[i]) {\n          case 'textNode':\n            closeText(parser)\n            break\n\n          case 'cdata':\n            emitNode(parser, 'oncdata', parser.cdata)\n            parser.cdata = ''\n            break\n\n          case 'script':\n            emitNode(parser, 'onscript', parser.script)\n            parser.script = ''\n            break\n\n          default:\n            error(parser, 'Max buffer length exceeded: ' + buffers[i])\n        }\n      }\n      maxActual = Math.max(maxActual, len)\n    }\n    // schedule the next check for the earliest possible buffer overrun.\n    var m = sax.MAX_BUFFER_LENGTH - maxActual\n    parser.bufferCheckPosition = m + parser.position\n  }\n\n  function clearBuffers (parser) {\n    for (var i = 0, l = buffers.length; i \u003c l; i++) {\n      parser[buffers[i]] = ''\n    }\n  }\n\n  function flushBuffers (parser) {\n    closeText(parser)\n    if (parser.cdata !== '') {\n      emitNode(parser, 'oncdata', parser.cdata)\n      parser.cdata = ''\n    }\n    if (parser.script !== '') {\n      emitNode(parser, 'onscript', parser.script)\n      parser.script = ''\n    }\n  }\n\n  SAXParser.prototype = {\n    end: function () { end(this) },\n    write: write,\n    resume: function () { this.error = null; return this },\n    close: function () { return this.write(null) },\n    flush: function () { flushBuffers(this) }\n  }\n\n  var Stream\n  try {\n    Stream = require('stream').Stream\n  } catch (ex) {\n    Stream = function () {}\n  }\n  if (!Stream) Stream = function () {}\n\n  var streamWraps = sax.EVENTS.filter(function (ev) {\n    return ev !== 'error' \u0026\u0026 ev !== 'end'\n  })\n\n  function createStream (strict, opt) {\n    return new SAXStream(strict, opt)\n  }\n\n  function SAXStream (strict, opt) {\n    if (!(this instanceof SAXStream)) {\n      return new SAXStream(strict, opt)\n    }\n\n    Stream.apply(this)\n\n    this._parser = new SAXParser(strict, opt)\n    this.writable = true\n    this.readable = true\n\n    var me = this\n\n    this._parser.onend = function () {\n      me.emit('end')\n    }\n\n    this._parser.onerror = function (er) {\n      me.emit('error', er)\n\n      // if didn't throw, then means error was handled.\n      // go ahead and clear error, so we can write again.\n      me._parser.error = null\n    }\n\n    this._decoder = null\n\n    streamWraps.forEach(function (ev) {\n      Object.defineProperty(me, 'on' + ev, {\n        get: function () {\n          return me._parser['on' + ev]\n        },\n        set: function (h) {\n          if (!h) {\n            me.removeAllListeners(ev)\n            me._parser['on' + ev] = h\n            return h\n          }\n          me.on(ev, h)\n        },\n        enumerable: true,\n        configurable: false\n      })\n    })\n  }\n\n  SAXStream.prototype = Object.create(Stream.prototype, {\n    constructor: {\n      value: SAXStream\n    }\n  })\n\n  SAXStream.prototype.write = function (data) {\n    if (typeof Buffer === 'function' \u0026\u0026\n      typeof Buffer.isBuffer === 'function' \u0026\u0026\n      Buffer.isBuffer(data)) {\n      if (!this._decoder) {\n        var SD = require('string_decoder').StringDecoder\n        this._decoder = new SD('utf8')\n      }\n      data = this._decoder.write(data)\n    }\n\n    this._parser.write(data.toString())\n    this.emit('data', data)\n    return true\n  }\n\n  SAXStream.prototype.end = function (chunk) {\n    if (chunk \u0026\u0026 chunk.length) {\n      this.write(chunk)\n    }\n    this._parser.end()\n    return true\n  }\n\n  SAXStream.prototype.on = function (ev, handler) {\n    var me = this\n    if (!me._parser['on' + ev] \u0026\u0026 streamWraps.indexOf(ev) !== -1) {\n      me._parser['on' + ev] = function () {\n        var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments)\n        args.splice(0, 0, ev)\n        me.emit.apply(me, args)\n      }\n    }\n\n    return Stream.prototype.on.call(me, ev, handler)\n  }\n\n  // this really needs to be replaced with character classes.\n  // XML allows all manner of ridiculous numbers and digits.\n  var CDATA = '[CDATA['\n  var DOCTYPE = 'DOCTYPE'\n  var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace'\n  var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/'\n  var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }\n\n  // http://www.w3.org/TR/REC-xml/#NT-NameStartChar\n  // This implementation works on strings, a single character at a time\n  // as such, it cannot ever support astral-plane characters (10000-EFFFF)\n  // without a significant breaking change to either this  parser, or the\n  // JavaScript language.  Implementation of an emoji-capable xml parser\n  // is left as an exercise for the reader.\n  var nameStart = /[:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]/\n\n  var nameBody = /[:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u00B7\\u0300-\\u036F\\u203F-\\u2040.\\d-]/\n\n  var entityStart = /[#:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD]/\n  var entityBody = /[#:_A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u00B7\\u0300-\\u036F\\u203F-\\u2040.\\d-]/\n\n  function isWhitespace (c) {\n    return c === ' ' || c === '\\n' || c === '\\r' || c === '\\t'\n  }\n\n  function isQuote (c) {\n    return c === '\"' || c === '\\''\n  }\n\n  function isAttribEnd (c) {\n    return c === '\u003e' || isWhitespace(c)\n  }\n\n  function isMatch (regex, c) {\n    return regex.test(c)\n  }\n\n  function notMatch (regex, c) {\n    return !isMatch(regex, c)\n  }\n\n  var S = 0\n  sax.STATE = {\n    BEGIN: S++, // leading byte order mark or whitespace\n    BEGIN_WHITESPACE: S++, // leading whitespace\n    TEXT: S++, // general stuff\n    TEXT_ENTITY: S++, // \u0026amp and such.\n    OPEN_WAKA: S++, // \u003c\n    SGML_DECL: S++, // \u003c!BLARG\n    SGML_DECL_QUOTED: S++, // \u003c!BLARG foo \"bar\n    DOCTYPE: S++, // \u003c!DOCTYPE\n    DOCTYPE_QUOTED: S++, // \u003c!DOCTYPE \"//blah\n    DOCTYPE_DTD: S++, // \u003c!DOCTYPE \"//blah\" [ ...\n    DOCTYPE_DTD_QUOTED: S++, // \u003c!DOCTYPE \"//blah\" [ \"foo\n    COMMENT_STARTING: S++, // \u003c!-\n    COMMENT: S++, // \u003c!--\n    COMMENT_ENDING: S++, // \u003c!-- blah -\n    COMMENT_ENDED: S++, // \u003c!-- blah --\n    CDATA: S++, // \u003c![CDATA[ something\n    CDATA_ENDING: S++, // ]\n    CDATA_ENDING_2: S++, // ]]\n    PROC_INST: S++, // \u003c?hi\n    PROC_INST_BODY: S++, // \u003c?hi there\n    PROC_INST_ENDING: S++, // \u003c?hi \"there\" ?\n    OPEN_TAG: S++, // \u003cstrong\n    OPEN_TAG_SLASH: S++, // \u003cstrong /\n    ATTRIB: S++, // \u003ca\n    ATTRIB_NAME: S++, // \u003ca foo\n    ATTRIB_NAME_SAW_WHITE: S++, // \u003ca foo _\n    ATTRIB_VALUE: S++, // \u003ca foo=\n    ATTRIB_VALUE_QUOTED: S++, // \u003ca foo=\"bar\n    ATTRIB_VALUE_CLOSED: S++, // \u003ca foo=\"bar\"\n    ATTRIB_VALUE_UNQUOTED: S++, // \u003ca foo=bar\n    ATTRIB_VALUE_ENTITY_Q: S++, // \u003cfoo bar=\"\u0026quot;\"\n    ATTRIB_VALUE_ENTITY_U: S++, // \u003cfoo bar=\u0026quot\n    CLOSE_TAG: S++, // \u003c/a\n    CLOSE_TAG_SAW_WHITE: S++, // \u003c/a   \u003e\n    SCRIPT: S++, // \u003cscript\u003e ...\n    SCRIPT_ENDING: S++ // \u003cscript\u003e ... \u003c\n  }\n\n  sax.XML_ENTITIES = {\n    'amp': '\u0026',\n    'gt': '\u003e',\n    'lt': '\u003c',\n    'quot': '\"',\n    'apos': \"'\"\n  }\n\n  sax.ENTITIES = {\n    'amp': '\u0026',\n    'gt': '\u003e',\n    'lt': '\u003c',\n    'quot': '\"',\n    'apos': \"'\",\n    'AElig': 198,\n    'Aacute': 193,\n    'Acirc': 194,\n    'Agrave': 192,\n    'Aring': 197,\n    'Atilde': 195,\n    'Auml': 196,\n    'Ccedil': 199,\n    'ETH': 208,\n    'Eacute': 201,\n    'Ecirc': 202,\n    'Egrave': 200,\n    'Euml': 203,\n    'Iacute': 205,\n    'Icirc': 206,\n    'Igrave': 204,\n    'Iuml': 207,\n    'Ntilde': 209,\n    'Oacute': 211,\n    'Ocirc': 212,\n    'Ograve': 210,\n    'Oslash': 216,\n    'Otilde': 213,\n    'Ouml': 214,\n    'THORN': 222,\n    'Uacute': 218,\n    'Ucirc': 219,\n    'Ugrave': 217,\n    'Uuml': 220,\n    'Yacute': 221,\n    'aacute': 225,\n    'acirc': 226,\n    'aelig': 230,\n    'agrave': 224,\n    'aring': 229,\n    'atilde': 227,\n    'auml': 228,\n    'ccedil': 231,\n    'eacute': 233,\n    'ecirc': 234,\n    'egrave': 232,\n    'eth': 240,\n    'euml': 235,\n    'iacute': 237,\n    'icirc': 238,\n    'igrave': 236,\n    'iuml': 239,\n    'ntilde': 241,\n    'oacute': 243,\n    'ocirc': 244,\n    'ograve': 242,\n    'oslash': 248,\n    'otilde': 245,\n    'ouml': 246,\n    'szlig': 223,\n    'thorn': 254,\n    'uacute': 250,\n    'ucirc': 251,\n    'ugrave': 249,\n    'uuml': 252,\n    'yacute': 253,\n    'yuml': 255,\n    'copy': 169,\n    'reg': 174,\n    'nbsp': 160,\n    'iexcl': 161,\n    'cent': 162,\n    'pound': 163,\n    'curren': 164,\n    'yen': 165,\n    'brvbar': 166,\n    'sect': 167,\n    'uml': 168,\n    'ordf': 170,\n    'laquo': 171,\n    'not': 172,\n    'shy': 173,\n    'macr': 175,\n    'deg': 176,\n    'plusmn': 177,\n    'sup1': 185,\n    'sup2': 178,\n    'sup3': 179,\n    'acute': 180,\n    'micro': 181,\n    'para': 182,\n    'middot': 183,\n    'cedil': 184,\n    'ordm': 186,\n    'raquo': 187,\n    'frac14': 188,\n    'frac12': 189,\n    'frac34': 190,\n    'iquest': 191,\n    'times': 215,\n    'divide': 247,\n    'OElig': 338,\n    'oelig': 339,\n    'Scaron': 352,\n    'scaron': 353,\n    'Yuml': 376,\n    'fnof': 402,\n    'circ': 710,\n    'tilde': 732,\n    'Alpha': 913,\n    'Beta': 914,\n    'Gamma': 915,\n    'Delta': 916,\n    'Epsilon': 917,\n    'Zeta': 918,\n    'Eta': 919,\n    'Theta': 920,\n    'Iota': 921,\n    'Kappa': 922,\n    'Lambda': 923,\n    'Mu': 924,\n    'Nu': 925,\n    'Xi': 926,\n    'Omicron': 927,\n    'Pi': 928,\n    'Rho': 929,\n    'Sigma': 931,\n    'Tau': 932,\n    'Upsilon': 933,\n    'Phi': 934,\n    'Chi': 935,\n    'Psi': 936,\n    'Omega': 937,\n    'alpha': 945,\n    'beta': 946,\n    'gamma': 947,\n    'delta': 948,\n    'epsilon': 949,\n    'zeta': 950,\n    'eta': 951,\n    'theta': 952,\n    'iota': 953,\n    'kappa': 954,\n    'lambda': 955,\n    'mu': 956,\n    'nu': 957,\n    'xi': 958,\n    'omicron': 959,\n    'pi': 960,\n    'rho': 961,\n    'sigmaf': 962,\n    'sigma': 963,\n    'tau': 964,\n    'upsilon': 965,\n    'phi': 966,\n    'chi': 967,\n    'psi': 968,\n    'omega': 969,\n    'thetasym': 977,\n    'upsih': 978,\n    'piv': 982,\n    'ensp': 8194,\n    'emsp': 8195,\n    'thinsp': 8201,\n    'zwnj': 8204,\n    'zwj': 8205,\n    'lrm': 8206,\n    'rlm': 8207,\n    'ndash': 8211,\n    'mdash': 8212,\n    'lsquo': 8216,\n    'rsquo': 8217,\n    'sbquo': 8218,\n    'ldquo': 8220,\n    'rdquo': 8221,\n    'bdquo': 8222,\n    'dagger': 8224,\n    'Dagger': 8225,\n    'bull': 8226,\n    'hellip': 8230,\n    'permil': 8240,\n    'prime': 8242,\n    'Prime': 8243,\n    'lsaquo': 8249,\n    'rsaquo': 8250,\n    'oline': 8254,\n    'frasl': 8260,\n    'euro': 8364,\n    'image': 8465,\n    'weierp': 8472,\n    'real': 8476,\n    'trade': 8482,\n    'alefsym': 8501,\n    'larr': 8592,\n    'uarr': 8593,\n    'rarr': 8594,\n    'darr': 8595,\n    'harr': 8596,\n    'crarr': 8629,\n    'lArr': 8656,\n    'uArr': 8657,\n    'rArr': 8658,\n    'dArr': 8659,\n    'hArr': 8660,\n    'forall': 8704,\n    'part': 8706,\n    'exist': 8707,\n    'empty': 8709,\n    'nabla': 8711,\n    'isin': 8712,\n    'notin': 8713,\n    'ni': 8715,\n    'prod': 8719,\n    'sum': 8721,\n    'minus': 8722,\n    'lowast': 8727,\n    'radic': 8730,\n    'prop': 8733,\n    'infin': 8734,\n    'ang': 8736,\n    'and': 8743,\n    'or': 8744,\n    'cap': 8745,\n    'cup': 8746,\n    'int': 8747,\n    'there4': 8756,\n    'sim': 8764,\n    'cong': 8773,\n    'asymp': 8776,\n    'ne': 8800,\n    'equiv': 8801,\n    'le': 8804,\n    'ge': 8805,\n    'sub': 8834,\n    'sup': 8835,\n    'nsub': 8836,\n    'sube': 8838,\n    'supe': 8839,\n    'oplus': 8853,\n    'otimes': 8855,\n    'perp': 8869,\n    'sdot': 8901,\n    'lceil': 8968,\n    'rceil': 8969,\n    'lfloor': 8970,\n    'rfloor': 8971,\n    'lang': 9001,\n    'rang': 9002,\n    'loz': 9674,\n    'spades': 9824,\n    'clubs': 9827,\n    'hearts': 9829,\n    'diams': 9830\n  }\n\n  Object.keys(sax.ENTITIES).forEach(function (key) {\n    var e = sax.ENTITIES[key]\n    var s = typeof e === 'number' ? String.fromCharCode(e) : e\n    sax.ENTITIES[key] = s\n  })\n\n  for (var s in sax.STATE) {\n    sax.STATE[sax.STATE[s]] = s\n  }\n\n  // shorthand\n  S = sax.STATE\n\n  function emit (parser, event, data) {\n    parser[event] \u0026\u0026 parser[event](data)\n  }\n\n  function emitNode (parser, nodeType, data) {\n    if (parser.textNode) closeText(parser)\n    emit(parser, nodeType, data)\n  }\n\n  function closeText (parser) {\n    parser.textNode = textopts(parser.opt, parser.textNode)\n    if (parser.textNode) emit(parser, 'ontext', parser.textNode)\n    parser.textNode = ''\n  }\n\n  function textopts (opt, text) {\n    if (opt.trim) text = text.trim()\n    if (opt.normalize) text = text.replace(/\\s+/g, ' ')\n    return text\n  }\n\n  function error (parser, er) {\n    closeText(parser)\n    if (parser.trackPosition) {\n      er += '\\nLine: ' + parser.line +\n        '\\nColumn: ' + parser.column +\n        '\\nChar: ' + parser.c\n    }\n    er = new Error(er)\n    parser.error = er\n    emit(parser, 'onerror', er)\n    return parser\n  }\n\n  function end (parser) {\n    if (parser.sawRoot \u0026\u0026 !parser.closedRoot) strictFail(parser, 'Unclosed root tag')\n    if ((parser.state !== S.BEGIN) \u0026\u0026\n      (parser.state !== S.BEGIN_WHITESPACE) \u0026\u0026\n      (parser.state !== S.TEXT)) {\n      error(parser, 'Unexpected end')\n    }\n    closeText(parser)\n    parser.c = ''\n    parser.closed = true\n    emit(parser, 'onend')\n    SAXParser.call(parser, parser.strict, parser.opt)\n    return parser\n  }\n\n  function strictFail (parser, message) {\n    if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {\n      throw new Error('bad call to strictFail')\n    }\n    if (parser.strict) {\n      error(parser, message)\n    }\n  }\n\n  function newTag (parser) {\n    if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()\n    var parent = parser.tags[parser.tags.length - 1] || parser\n    var tag = parser.tag = { name: parser.tagName, attributes: {} }\n\n    // will be overridden if tag contails an xmlns=\"foo\" or xmlns:foo=\"bar\"\n    if (parser.opt.xmlns) {\n      tag.ns = parent.ns\n    }\n    parser.attribList.length = 0\n    emitNode(parser, 'onopentagstart', tag)\n  }\n\n  function qname (name, attribute) {\n    var i = name.indexOf(':')\n    var qualName = i \u003c 0 ? [ '', name ] : name.split(':')\n    var prefix = qualName[0]\n    var local = qualName[1]\n\n    // \u003cx \"xmlns\"=\"http://foo\"\u003e\n    if (attribute \u0026\u0026 name === 'xmlns') {\n      prefix = 'xmlns'\n      local = ''\n    }\n\n    return { prefix: prefix, local: local }\n  }\n\n  function attrib (parser) {\n    if (!parser.strict) {\n      parser.attribName = parser.attribName[parser.looseCase]()\n    }\n\n    if (parser.attribList.indexOf(parser.attribName) !== -1 ||\n      parser.tag.attributes.hasOwnProperty(parser.attribName)) {\n      parser.attribName = parser.attribValue = ''\n      return\n    }\n\n    if (parser.opt.xmlns) {\n      var qn = qname(parser.attribName, true)\n      var prefix = qn.prefix\n      var local = qn.local\n\n      if (prefix === 'xmlns') {\n        // namespace binding attribute. push the binding into scope\n        if (local === 'xml' \u0026\u0026 parser.attribValue !== XML_NAMESPACE) {\n          strictFail(parser,\n            'xml: prefix must be bound to ' + XML_NAMESPACE + '\\n' +\n            'Actual: ' + parser.attribValue)\n        } else if (local === 'xmlns' \u0026\u0026 parser.attribValue !== XMLNS_NAMESPACE) {\n          strictFail(parser,\n            'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\\n' +\n            'Actual: ' + parser.attribValue)\n        } else {\n          var tag = parser.tag\n          var parent = parser.tags[parser.tags.length - 1] || parser\n          if (tag.ns === parent.ns) {\n            tag.ns = Object.create(parent.ns)\n          }\n          tag.ns[local] = parser.attribValue\n        }\n      }\n\n      // defer onattribute events until all attributes have been seen\n      // so any new bindings can take effect. preserve attribute order\n      // so deferred events can be emitted in document order\n      parser.attribList.push([parser.attribName, parser.attribValue])\n    } else {\n      // in non-xmlns mode, we can emit the event right away\n      parser.tag.attributes[parser.attribName] = parser.attribValue\n      emitNode(parser, 'onattribute', {\n        name: parser.attribName,\n        value: parser.attribValue\n      })\n    }\n\n    parser.attribName = parser.attribValue = ''\n  }\n\n  function openTag (parser, selfClosing) {\n    if (parser.opt.xmlns) {\n      // emit namespace binding events\n      var tag = parser.tag\n\n      // add namespace info to tag\n      var qn = qname(parser.tagName)\n      tag.prefix = qn.prefix\n      tag.local = qn.local\n      tag.uri = tag.ns[qn.prefix] || ''\n\n      if (tag.prefix \u0026\u0026 !tag.uri) {\n        strictFail(parser, 'Unbound namespace prefix: ' +\n          JSON.stringify(parser.tagName))\n        tag.uri = qn.prefix\n      }\n\n      var parent = parser.tags[parser.tags.length - 1] || parser\n      if (tag.ns \u0026\u0026 parent.ns !== tag.ns) {\n        Object.keys(tag.ns).forEach(function (p) {\n          emitNode(parser, 'onopennamespace', {\n            prefix: p,\n            uri: tag.ns[p]\n          })\n        })\n      }\n\n      // handle deferred onattribute events\n      // Note: do not apply default ns to attributes:\n      //   http://www.w3.org/TR/REC-xml-names/#defaulting\n      for (var i = 0, l = parser.attribList.length; i \u003c l; i++) {\n        var nv = parser.attribList[i]\n        var name = nv[0]\n        var value = nv[1]\n        var qualName = qname(name, true)\n        var prefix = qualName.prefix\n        var local = qualName.local\n        var uri = prefix === '' ? '' : (tag.ns[prefix] || '')\n        var a = {\n          name: name,\n          value: value,\n          prefix: prefix,\n          local: local,\n          uri: uri\n        }\n\n        // if there's any attributes with an undefined namespace,\n        // then fail on them now.\n        if (prefix \u0026\u0026 prefix !== 'xmlns' \u0026\u0026 !uri) {\n          strictFail(parser, 'Unbound namespace prefix: ' +\n            JSON.stringify(prefix))\n          a.uri = prefix\n        }\n        parser.tag.attributes[name] = a\n        emitNode(parser, 'onattribute', a)\n      }\n      parser.attribList.length = 0\n    }\n\n    parser.tag.isSelfClosing = !!selfClosing\n\n    // process the tag\n    parser.sawRoot = true\n    parser.tags.push(parser.tag)\n    emitNode(parser, 'onopentag', parser.tag)\n    if (!selfClosing) {\n      // special case for \u003cscript\u003e in non-strict mode.\n      if (!parser.noscript \u0026\u0026 parser.tagName.toLowerCase() === 'script') {\n        parser.state = S.SCRIPT\n      } else {\n        parser.state = S.TEXT\n      }\n      parser.tag = null\n      parser.tagName = ''\n    }\n    parser.attribName = parser.attribValue = ''\n    parser.attribList.length = 0\n  }\n\n  function closeTag (parser) {\n    if (!parser.tagName) {\n      strictFail(parser, 'Weird empty close tag.')\n      parser.textNode += '\u003c/\u003e'\n      parser.state = S.TEXT\n      return\n    }\n\n    if (parser.script) {\n      if (parser.tagName !== 'script') {\n        parser.script += '\u003c/' + parser.tagName + '\u003e'\n        parser.tagName = ''\n        parser.state = S.SCRIPT\n        return\n      }\n      emitNode(parser, 'onscript', parser.script)\n      parser.script = ''\n    }\n\n    // first make sure that the closing tag actually exists.\n    // \u003ca\u003e\u003cb\u003e\u003c/c\u003e\u003c/b\u003e\u003c/a\u003e will close everything, otherwise.\n    var t = parser.tags.length\n    var tagName = parser.tagName\n    if (!parser.strict) {\n      tagName = tagName[parser.looseCase]()\n    }\n    var closeTo = tagName\n    while (t--) {\n      var close = parser.tags[t]\n      if (close.name !== closeTo) {\n        // fail the first time in strict mode\n        strictFail(parser, 'Unexpected close tag')\n      } else {\n        break\n      }\n    }\n\n    // didn't find it.  we already failed for strict, so just abort.\n    if (t \u003c 0) {\n      strictFail(parser, 'Unmatched closing tag: ' + parser.tagName)\n      parser.textNode += '\u003c/' + parser.tagName + '\u003e'\n      parser.state = S.TEXT\n      return\n    }\n    parser.tagName = tagName\n    var s = parser.tags.length\n    while (s-- \u003e t) {\n      var tag = parser.tag = parser.tags.pop()\n      parser.tagName = parser.tag.name\n      emitNode(parser, 'onclosetag', parser.tagName)\n\n      var x = {}\n      for (var i in tag.ns) {\n        x[i] = tag.ns[i]\n      }\n\n      var parent = parser.tags[parser.tags.length - 1] || parser\n      if (parser.opt.xmlns \u0026\u0026 tag.ns !== parent.ns) {\n        // remove namespace bindings introduced by tag\n        Object.keys(tag.ns).forEach(function (p) {\n          var n = tag.ns[p]\n          emitNode(parser, 'onclosenamespace', { prefix: p, uri: n })\n        })\n      }\n    }\n    if (t === 0) parser.closedRoot = true\n    parser.tagName = parser.attribValue = parser.attribName = ''\n    parser.attribList.length = 0\n    parser.state = S.TEXT\n  }\n\n  function parseEntity (parser) {\n    var entity = parser.entity\n    var entityLC = entity.toLowerCase()\n    var num\n    var numStr = ''\n\n    if (parser.ENTITIES[entity]) {\n      return parser.ENTITIES[entity]\n    }\n    if (parser.ENTITIES[entityLC]) {\n      return parser.ENTITIES[entityLC]\n    }\n    entity = entityLC\n    if (entity.charAt(0) === '#') {\n      if (entity.charAt(1) === 'x') {\n        entity = entity.slice(2)\n        num = parseInt(entity, 16)\n        numStr = num.toString(16)\n      } else {\n        entity = entity.slice(1)\n        num = parseInt(entity, 10)\n        numStr = num.toString(10)\n      }\n    }\n    entity = entity.replace(/^0+/, '')\n    if (isNaN(num) || numStr.toLowerCase() !== entity) {\n      strictFail(parser, 'Invalid character entity')\n      return '\u0026' + parser.entity + ';'\n    }\n\n    return String.fromCodePoint(num)\n  }\n\n  function beginWhiteSpace (parser, c) {\n    if (c === '\u003c') {\n      parser.state = S.OPEN_WAKA\n      parser.startTagPosition = parser.position\n    } else if (!isWhitespace(c)) {\n      // have to process this as a text node.\n      // weird, but happens.\n      strictFail(parser, 'Non-whitespace before first tag.')\n      parser.textNode = c\n      parser.state = S.TEXT\n    }\n  }\n\n  function charAt (chunk, i) {\n    var result = ''\n    if (i \u003c chunk.length) {\n      result = chunk.charAt(i)\n    }\n    return result\n  }\n\n  function write (chunk) {\n    var parser = this\n    if (this.error) {\n      throw this.error\n    }\n    if (parser.closed) {\n      return error(parser,\n        'Cannot write after close. Assign an onready handler.')\n    }\n    if (chunk === null) {\n      return end(parser)\n    }\n    if (typeof chunk === 'object') {\n      chunk = chunk.toString()\n    }\n    var i = 0\n    var c = ''\n    while (true) {\n      c = charAt(chunk, i++)\n      parser.c = c\n\n      if (!c) {\n        break\n      }\n\n      if (parser.trackPosition) {\n        parser.position++\n        if (c === '\\n') {\n          parser.line++\n          parser.column = 0\n        } else {\n          parser.column++\n        }\n      }\n\n      switch (parser.state) {\n        case S.BEGIN:\n          parser.state = S.BEGIN_WHITESPACE\n          if (c === '\\uFEFF') {\n            continue\n          }\n          beginWhiteSpace(parser, c)\n          continue\n\n        case S.BEGIN_WHITESPACE:\n          beginWhiteSpace(parser, c)\n          continue\n\n        case S.TEXT:\n          if (parser.sawRoot \u0026\u0026 !parser.closedRoot) {\n            var starti = i - 1\n            while (c \u0026\u0026 c !== '\u003c' \u0026\u0026 c !== '\u0026') {\n              c = charAt(chunk, i++)\n              if (c \u0026\u0026 parser.trackPosition) {\n                parser.position++\n                if (c === '\\n') {\n                  parser.line++\n                  parser.column = 0\n                } else {\n                  parser.column++\n                }\n              }\n            }\n            parser.textNode += chunk.substring(starti, i - 1)\n          }\n          if (c === '\u003c' \u0026\u0026 !(parser.sawRoot \u0026\u0026 parser.closedRoot \u0026\u0026 !parser.strict)) {\n            parser.state = S.OPEN_WAKA\n            parser.startTagPosition = parser.position\n          } else {\n            if (!isWhitespace(c) \u0026\u0026 (!parser.sawRoot || parser.closedRoot)) {\n              strictFail(parser, 'Text data outside of root node.')\n            }\n            if (c === '\u0026') {\n              parser.state = S.TEXT_ENTITY\n            } else {\n              parser.textNode += c\n            }\n          }\n          continue\n\n        case S.SCRIPT:\n          // only non-strict\n          if (c === '\u003c') {\n            parser.state = S.SCRIPT_ENDING\n          } else {\n            parser.script += c\n          }\n          continue\n\n        case S.SCRIPT_ENDING:\n          if (c === '/') {\n            parser.state = S.CLOSE_TAG\n          } else {\n            parser.script += '\u003c' + c\n            parser.state = S.SCRIPT\n          }\n          continue\n\n        case S.OPEN_WAKA:\n          // either a /, ?, !, or text is coming next.\n          if (c === '!') {\n            parser.state = S.SGML_DECL\n            parser.sgmlDecl = ''\n          } else if (isWhitespace(c)) {\n            // wait for it...\n          } else if (isMatch(nameStart, c)) {\n            parser.state = S.OPEN_TAG\n            parser.tagName = c\n          } else if (c === '/') {\n            parser.state = S.CLOSE_TAG\n            parser.tagName = ''\n          } else if (c === '?') {\n            parser.state = S.PROC_INST\n            parser.procInstName = parser.procInstBody = ''\n          } else {\n            strictFail(parser, 'Unencoded \u003c')\n            // if there was some whitespace, then add that in.\n            if (parser.startTagPosition + 1 \u003c parser.position) {\n              var pad = parser.position - parser.startTagPosition\n              c = new Array(pad).join(' ') + c\n            }\n            parser.textNode += '\u003c' + c\n            parser.state = S.TEXT\n          }\n          continue\n\n        case S.SGML_DECL:\n          if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {\n            emitNode(parser, 'onopencdata')\n            parser.state = S.CDATA\n            parser.sgmlDecl = ''\n            parser.cdata = ''\n          } else if (parser.sgmlDecl + c === '--') {\n            parser.state = S.COMMENT\n            parser.comment = ''\n            parser.sgmlDecl = ''\n          } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {\n            parser.state = S.DOCTYPE\n            if (parser.doctype || parser.sawRoot) {\n              strictFail(parser,\n                'Inappropriately located doctype declaration')\n            }\n            parser.doctype = ''\n            parser.sgmlDecl = ''\n          } else if (c === '\u003e') {\n            emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl)\n            parser.sgmlDecl = ''\n            parser.state = S.TEXT\n          } else if (isQuote(c)) {\n            parser.state = S.SGML_DECL_QUOTED\n            parser.sgmlDecl += c\n          } else {\n            parser.sgmlDecl += c\n          }\n          continue\n\n        case S.SGML_DECL_QUOTED:\n          if (c === parser.q) {\n            parser.state = S.SGML_DECL\n            parser.q = ''\n          }\n          parser.sgmlDecl += c\n          continue\n\n        case S.DOCTYPE:\n          if (c === '\u003e') {\n            parser.state = S.TEXT\n            emitNode(parser, 'ondoctype', parser.doctype)\n            parser.doctype = true // just remember that we saw it.\n          } else {\n            parser.doctype += c\n            if (c === '[') {\n              parser.state = S.DOCTYPE_DTD\n            } else if (isQuote(c)) {\n              parser.state = S.DOCTYPE_QUOTED\n              parser.q = c\n            }\n          }\n          continue\n\n        case S.DOCTYPE_QUOTED:\n          parser.doctype += c\n          if (c === parser.q) {\n            parser.q = ''\n            parser.state = S.DOCTYPE\n          }\n          continue\n\n        case S.DOCTYPE_DTD:\n          parser.doctype += c\n          if (c === ']') {\n            parser.state = S.DOCTYPE\n          } else if (isQuote(c)) {\n            parser.state = S.DOCTYPE_DTD_QUOTED\n            parser.q = c\n          }\n          continue\n\n        case S.DOCTYPE_DTD_QUOTED:\n          parser.doctype += c\n          if (c === parser.q) {\n            parser.state = S.DOCTYPE_DTD\n            parser.q = ''\n          }\n          continue\n\n        case S.COMMENT:\n          if (c === '-') {\n            parser.state = S.COMMENT_ENDING\n          } else {\n            parser.comment += c\n          }\n          continue\n\n        case S.COMMENT_ENDING:\n          if (c === '-') {\n            parser.state = S.COMMENT_ENDED\n            parser.comment = textopts(parser.opt, parser.comment)\n            if (parser.comment) {\n              emitNode(parser, 'oncomment', parser.comment)\n            }\n            parser.comment = ''\n          } else {\n            parser.comment += '-' + c\n            parser.state = S.COMMENT\n          }\n          continue\n\n        case S.COMMENT_ENDED:\n          if (c !== '\u003e') {\n            strictFail(parser, 'Malformed comment')\n            // allow \u003c!-- blah -- bloo --\u003e in non-strict mode,\n            // which is a comment of \" blah -- bloo \"\n            parser.comment += '--' + c\n            parser.state = S.COMMENT\n          } else {\n            parser.state = S.TEXT\n          }\n          continue\n\n        case S.CDATA:\n          if (c === ']') {\n            parser.state = S.CDATA_ENDING\n          } else {\n            parser.cdata += c\n          }\n          continue\n\n        case S.CDATA_ENDING:\n          if (c === ']') {\n            parser.state = S.CDATA_ENDING_2\n          } else {\n            parser.cdata += ']' + c\n            parser.state = S.CDATA\n          }\n          continue\n\n        case S.CDATA_ENDING_2:\n          if (c === '\u003e') {\n            if (parser.cdata) {\n              emitNode(parser, 'oncdata', parser.cdata)\n            }\n            emitNode(parser, 'onclosecdata')\n            parser.cdata = ''\n            parser.state = S.TEXT\n          } else if (c === ']') {\n            parser.cdata += ']'\n          } else {\n            parser.cdata += ']]' + c\n            parser.state = S.CDATA\n          }\n          continue\n\n        case S.PROC_INST:\n          if (c === '?') {\n            parser.state = S.PROC_INST_ENDING\n          } else if (isWhitespace(c)) {\n            parser.state = S.PROC_INST_BODY\n          } else {\n            parser.procInstName += c\n          }\n          continue\n\n        case S.PROC_INST_BODY:\n          if (!parser.procInstBody \u0026\u0026 isWhitespace(c)) {\n            continue\n          } else if (c === '?') {\n            parser.state = S.PROC_INST_ENDING\n          } else {\n            parser.procInstBody += c\n          }\n          continue\n\n        case S.PROC_INST_ENDING:\n          if (c === '\u003e') {\n            emitNode(parser, 'onprocessinginstruction', {\n              name: parser.procInstName,\n              body: parser.procInstBody\n            })\n            parser.procInstName = parser.procInstBody = ''\n            parser.state = S.TEXT\n          } else {\n            parser.procInstBody += '?' + c\n            parser.state = S.PROC_INST_BODY\n          }\n          continue\n\n        case S.OPEN_TAG:\n          if (isMatch(nameBody, c)) {\n            parser.tagName += c\n          } else {\n            newTag(parser)\n            if (c === '\u003e') {\n              openTag(parser)\n            } else if (c === '/') {\n              parser.state = S.OPEN_TAG_SLASH\n            } else {\n              if (!isWhitespace(c)) {\n                strictFail(parser, 'Invalid character in tag name')\n              }\n              parser.state = S.ATTRIB\n            }\n          }\n          continue\n\n        case S.OPEN_TAG_SLASH:\n          if (c === '\u003e') {\n            openTag(parser, true)\n            closeTag(parser)\n          } else {\n            strictFail(parser, 'Forward-slash in opening tag not followed by \u003e')\n            parser.state = S.ATTRIB\n          }\n          continue\n\n        case S.ATTRIB:\n          // haven't read the attribute name yet.\n          if (isWhitespace(c)) {\n            continue\n          } else if (c === '\u003e') {\n            openTag(parser)\n          } else if (c === '/') {\n            parser.state = S.OPEN_TAG_SLASH\n          } else if (isMatch(nameStart, c)) {\n            parser.attribName = c\n            parser.attribValue = ''\n            parser.state = S.ATTRIB_NAME\n          } else {\n            strictFail(parser, 'Invalid attribute name')\n          }\n          continue\n\n        case S.ATTRIB_NAME:\n          if (c === '=') {\n            parser.state = S.ATTRIB_VALUE\n          } else if (c === '\u003e') {\n            strictFail(parser, 'Attribute without value')\n            parser.attribValue = parser.attribName\n            attrib(parser)\n            openTag(parser)\n          } else if (isWhitespace(c)) {\n            parser.state = S.ATTRIB_NAME_SAW_WHITE\n          } else if (isMatch(nameBody, c)) {\n            parser.attribName += c\n          } else {\n            strictFail(parser, 'Invalid attribute name')\n          }\n          continue\n\n        case S.ATTRIB_NAME_SAW_WHITE:\n          if (c === '=') {\n            parser.state = S.ATTRIB_VALUE\n          } else if (isWhitespace(c)) {\n            continue\n          } else {\n            strictFail(parser, 'Attribute without value')\n            parser.tag.attributes[parser.attribName] = ''\n            parser.attribValue = ''\n            emitNode(parser, 'onattribute', {\n              name: parser.attribName,\n              value: ''\n            })\n            parser.attribName = ''\n            if (c === '\u003e') {\n              openTag(parser)\n            } else if (isMatch(nameStart, c)) {\n              parser.attribName = c\n              parser.state = S.ATTRIB_NAME\n            } else {\n              strictFail(parser, 'Invalid attribute name')\n              parser.state = S.ATTRIB\n            }\n          }\n          continue\n\n        case S.ATTRIB_VALUE:\n          if (isWhitespace(c)) {\n            continue\n          } else if (isQuote(c)) {\n            parser.q = c\n            parser.state = S.ATTRIB_VALUE_QUOTED\n          } else {\n            strictFail(parser, 'Unquoted attribute value')\n            parser.state = S.ATTRIB_VALUE_UNQUOTED\n            parser.attribValue = c\n          }\n          continue\n\n        case S.ATTRIB_VALUE_QUOTED:\n          if (c !== parser.q) {\n            if (c === '\u0026') {\n              parser.state = S.ATTRIB_VALUE_ENTITY_Q\n            } else {\n              parser.attribValue += c\n            }\n            continue\n          }\n          attrib(parser)\n          parser.q = ''\n          parser.state = S.ATTRIB_VALUE_CLOSED\n          continue\n\n        case S.ATTRIB_VALUE_CLOSED:\n          if (isWhitespace(c)) {\n            parser.state = S.ATTRIB\n          } else if (c === '\u003e') {\n            openTag(parser)\n          } else if (c === '/') {\n            parser.state = S.OPEN_TAG_SLASH\n          } else if (isMatch(nameStart, c)) {\n            strictFail(parser, 'No whitespace between attributes')\n            parser.attribName = c\n            parser.attribValue = ''\n            parser.state = S.ATTRIB_NAME\n          } else {\n            strictFail(parser, 'Invalid attribute name')\n          }\n          continue\n\n        case S.ATTRIB_VALUE_UNQUOTED:\n          if (!isAttribEnd(c)) {\n            if (c === '\u0026') {\n              parser.state = S.ATTRIB_VALUE_ENTITY_U\n            } else {\n              parser.attribValue += c\n            }\n            continue\n          }\n          attrib(parser)\n          if (c === '\u003e') {\n            openTag(parser)\n          } else {\n            parser.state = S.ATTRIB\n          }\n          continue\n\n        case S.CLOSE_TAG:\n          if (!parser.tagName) {\n            if (isWhitespace(c)) {\n              continue\n            } else if (notMatch(nameStart, c)) {\n              if (parser.script) {\n                parser.script += '\u003c/' + c\n                parser.state = S.SCRIPT\n              } else {\n                strictFail(parser, 'Invalid tagname in closing tag.')\n              }\n            } else {\n              parser.tagName = c\n            }\n          } else if (c === '\u003e') {\n            closeTag(parser)\n          } else if (isMatch(nameBody, c)) {\n            parser.tagName += c\n          } else if (parser.script) {\n            parser.script += '\u003c/' + parser.tagName\n            parser.tagName = ''\n            parser.state = S.SCRIPT\n          } else {\n            if (!isWhitespace(c)) {\n              strictFail(parser, 'Invalid tagname in closing tag')\n            }\n            parser.state = S.CLOSE_TAG_SAW_WHITE\n          }\n          continue\n\n        case S.CLOSE_TAG_SAW_WHITE:\n          if (isWhitespace(c)) {\n            continue\n          }\n          if (c === '\u003e') {\n            closeTag(parser)\n          } else {\n            strictFail(parser, 'Invalid characters in closing tag')\n          }\n          continue\n\n        case S.TEXT_ENTITY:\n        case S.ATTRIB_VALUE_ENTITY_Q:\n        case S.ATTRIB_VALUE_ENTITY_U:\n          var returnState\n          var buffer\n          switch (parser.state) {\n            case S.TEXT_ENTITY:\n              returnState = S.TEXT\n              buffer = 'textNode'\n              break\n\n            case S.ATTRIB_VALUE_ENTITY_Q:\n              returnState = S.ATTRIB_VALUE_QUOTED\n              buffer = 'attribValue'\n              break\n\n            case S.ATTRIB_VALUE_ENTITY_U:\n              returnState = S.ATTRIB_VALUE_UNQUOTED\n              buffer = 'attribValue'\n              break\n          }\n\n          if (c === ';') {\n            if (parser.opt.unparsedEntities) {\n              var parsedEntity = parseEntity(parser)\n              parser.entity = ''\n              parser.state = returnState\n              parser.write(parsedEntity)\n            } else {\n              parser[buffer] += parseEntity(parser)\n              parser.entity = ''\n              parser.state = returnState\n            }\n          } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {\n            parser.entity += c\n          } else {\n            strictFail(parser, 'Invalid character in entity name')\n            parser[buffer] += '\u0026' + parser.entity + c\n            parser.entity = ''\n            parser.state = returnState\n          }\n\n          continue\n\n        default: /* istanbul ignore next */ {\n          throw new Error(parser, 'Unknown state: ' + parser.state)\n        }\n      }\n    } // while\n\n    if (parser.position \u003e= parser.bufferCheckPosition) {\n      checkBufferLength(parser)\n    }\n    return parser\n  }\n\n  /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */\n  /* istanbul ignore next */\n  if (!String.fromCodePoint) {\n    (function () {\n      var stringFromCharCode = String.fromCharCode\n      var floor = Math.floor\n      var fromCodePoint = function () {\n        var MAX_SIZE = 0x4000\n        var codeUnits = []\n        var highSurrogate\n        var lowSurrogate\n        var index = -1\n        var length = arguments.length\n        if (!length) {\n          return ''\n        }\n        var result = ''\n        while (++index \u003c length) {\n          var codePoint = Number(arguments[index])\n          if (\n            !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`\n            codePoint \u003c 0 || // not a valid Unicode code point\n            codePoint \u003e 0x10FFFF || // not a valid Unicode code point\n            floor(codePoint) !== codePoint // not an integer\n          ) {\n            throw RangeError('Invalid code point: ' + codePoint)\n          }\n          if (codePoint \u003c= 0xFFFF) { // BMP code point\n            codeUnits.push(codePoint)\n          } else { // Astral code point; split in surrogate halves\n            // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n            codePoint -= 0x10000\n            highSurrogate = (codePoint \u003e\u003e 10) + 0xD800\n            lowSurrogate = (codePoint % 0x400) + 0xDC00\n            codeUnits.push(highSurrogate, lowSurrogate)\n          }\n          if (index + 1 === length || codeUnits.length \u003e MAX_SIZE) {\n            result += stringFromCharCode.apply(null, codeUnits)\n            codeUnits.length = 0\n          }\n        }\n        return result\n      }\n      /* istanbul ignore next */\n      if (Object.defineProperty) {\n        Object.defineProperty(String, 'fromCodePoint', {\n          value: fromCodePoint,\n          configurable: true,\n          writable: true\n        })\n      } else {\n        String.fromCodePoint = fromCodePoint\n      }\n    }())\n  }\n})(typeof exports === 'undefined' ? this.sax = {} : exports)\n","import * as __module from \"sax\";const { default: __default, ...__rest } = __module;export default (__default !== undefined ? __default : __rest);export * from \"sax\";"],"version":3}