umwd-components 0.1.840 → 0.1.841

package/dist/esm/umwd-components/node_modules/sax/lib/sax.js

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