umwd-components 0.1.838 → 0.1.839

package/dist/esm/node_modules/sax/lib/sax.js

@@ -7,9 +7,12 @@
 import { __exports as sax } from '../../../_virtual/sax.js';
 import { __require as requireString_decoder } from '../../string_decoder/lib/string_decoder.js';
 
-(function (exports) {
-(function (sax) { // wrapper for non-node envs
-	  sax.parser = function (strict, opt) { return new SAXParser(strict, opt) };
+(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;
@@ -26,9 +29,18 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	  sax.MAX_BUFFER_LENGTH = 64 * 1024;
 
 	  var buffers = [
-	    'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',
-	    'procInstName', 'procInstBody', 'entity', 'attribName',
-	    'attribValue', 'cdata', 'script'
+	    'comment',
+	    'sgmlDecl',
+	    'textNode',
+	    'tagName',
+	    'doctype',
+	    'procInstName',
+	    'procInstBody',
+	    'entity',
+	    'attribName',
+	    'attribValue',
+	    'cdata',
+	    'script',
 	  ];
 
 	  sax.EVENTS = [
@@ -49,10 +61,10 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    'ready',
 	    'script',
 	    'opennamespace',
-	    'closenamespace'
+	    'closenamespace',
 	  ];
 
-	  function SAXParser (strict, opt) {
+	  function SAXParser(strict, opt) {
 	    if (!(this instanceof SAXParser)) {
 	      return new SAXParser(strict, opt)
 	    }
@@ -71,7 +83,10 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    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.ENTITIES =
+	      parser.strictEntities ?
+	        Object.create(sax.XML_ENTITIES)
+	      : Object.create(sax.ENTITIES);
 	    parser.attribList = [];
 
 	    // namespaces form a prototype chain.
@@ -97,7 +112,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 
 	  if (!Object.create) {
 	    Object.create = function (o) {
-	      function F () {}
+	      function F() {}
 	      F.prototype = o;
 	      var newf = new F();
 	      return newf
@@ -112,7 +127,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    };
 	  }
 
-	  function checkBufferLength (parser) {
+	  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++) {
@@ -148,13 +163,13 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    parser.bufferCheckPosition = m + parser.position;
 	  }
 
-	  function clearBuffers (parser) {
+	  function clearBuffers(parser) {
 	    for (var i = 0, l = buffers.length; i < l; i++) {
 	      parser[buffers[i]] = '';
 	    }
 	  }
 
-	  function flushBuffers (parser) {
+	  function flushBuffers(parser) {
 	    closeText(parser);
 	    if (parser.cdata !== '') {
 	      emitNode(parser, 'oncdata', parser.cdata);
@@ -167,11 +182,20 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	  }
 
 	  SAXParser.prototype = {
-	    end: function () { end(this); },
+	    end: function () {
+	      end(this);
+	    },
 	    write: write,
-	    resume: function () { this.error = null; return this },
-	    close: function () { return this.write(null) },
-	    flush: function () { flushBuffers(this); }
+	    resume: function () {
+	      this.error = null;
+	      return this
+	    },
+	    close: function () {
+	      return this.write(null)
+	    },
+	    flush: function () {
+	      flushBuffers(this);
+	    },
 	  };
 
 	  var Stream;
@@ -186,11 +210,11 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    return ev !== 'error' && ev !== 'end'
 	  });
 
-	  function createStream (strict, opt) {
+	  function createStream(strict, opt) {
 	    return new SAXStream(strict, opt)
 	  }
 
-	  function SAXStream (strict, opt) {
+	  function SAXStream(strict, opt) {
 	    if (!(this instanceof SAXStream)) {
 	      return new SAXStream(strict, opt)
 	    }
@@ -231,21 +255,23 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	          me.on(ev, h);
 	        },
 	        enumerable: true,
-	        configurable: false
+	        configurable: false,
 	      });
 	    });
 	  }
 
 	  SAXStream.prototype = Object.create(Stream.prototype, {
 	    constructor: {
-	      value: SAXStream
-	    }
+	      value: SAXStream,
+	    },
 	  });
 
 	  SAXStream.prototype.write = function (data) {
-	    if (typeof Buffer === 'function' &&
+	    if (
+	      typeof Buffer === 'function' &&
 	      typeof Buffer.isBuffer === 'function' &&
-	      Buffer.isBuffer(data)) {
+	      Buffer.isBuffer(data)
+	    ) {
 	      if (!this._decoder) {
 	        var SD = requireString_decoder().StringDecoder;
 	        this._decoder = new SD('utf8');
@@ -270,7 +296,10 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    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);
+	        var args =
+	          arguments.length === 1 ?
+	            [arguments[0]]
+	          : Array.apply(null, arguments);
 	        args.splice(0, 0, ev);
 	        me.emit.apply(me, args);
 	      };
@@ -293,30 +322,34 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	  // 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 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 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-]/;
+	  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) {
+	  function isWhitespace(c) {
 	    return c === ' ' || c === '\n' || c === '\r' || c === '\t'
 	  }
 
-	  function isQuote (c) {
-	    return c === '"' || c === '\''
+	  function isQuote(c) {
+	    return c === '"' || c === "'"
 	  }
 
-	  function isAttribEnd (c) {
+	  function isAttribEnd(c) {
 	    return c === '>' || isWhitespace(c)
 	  }
 
-	  function isMatch (regex, c) {
+	  function isMatch(regex, c) {
 	    return regex.test(c)
 	  }
 
-	  function notMatch (regex, c) {
+	  function notMatch(regex, c) {
 	    return !isMatch(regex, c)
 	  }
 
@@ -357,271 +390,271 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    CLOSE_TAG: S++, // </a
 	    CLOSE_TAG_SAW_WHITE: S++, // </a   >
 	    SCRIPT: S++, // <script> ...
-	    SCRIPT_ENDING: S++ // <script> ... <
+	    SCRIPT_ENDING: S++, // <script> ... <
 	  };
 
 	  sax.XML_ENTITIES = {
-	    'amp': '&',
-	    'gt': '>',
-	    'lt': '<',
-	    'quot': '"',
-	    'apos': "'"
+	    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
+	    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) {
@@ -637,33 +670,37 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	  // shorthand
 	  S = sax.STATE;
 
-	  function emit (parser, event, data) {
+	  function emit(parser, event, data) {
 	    parser[event] && parser[event](data);
 	  }
 
-	  function emitNode (parser, nodeType, data) {
+	  function emitNode(parser, nodeType, data) {
 	    if (parser.textNode) closeText(parser);
 	    emit(parser, nodeType, data);
 	  }
 
-	  function closeText (parser) {
+	  function closeText(parser) {
 	    parser.textNode = textopts(parser.opt, parser.textNode);
 	    if (parser.textNode) emit(parser, 'ontext', parser.textNode);
 	    parser.textNode = '';
 	  }
 
-	  function textopts (opt, text) {
+	  function textopts(opt, text) {
 	    if (opt.trim) text = text.trim();
 	    if (opt.normalize) text = text.replace(/\s+/g, ' ');
 	    return text
 	  }
 
-	  function error (parser, er) {
+	  function error(parser, er) {
 	    closeText(parser);
 	    if (parser.trackPosition) {
-	      er += '\nLine: ' + parser.line +
-	        '\nColumn: ' + parser.column +
-	        '\nChar: ' + parser.c;
+	      er +=
+	        '\nLine: ' +
+	        parser.line +
+	        '\nColumn: ' +
+	        parser.column +
+	        '\nChar: ' +
+	        parser.c;
 	    }
 	    er = new Error(er);
 	    parser.error = er;
@@ -671,11 +708,14 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    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)) {
+	  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);
@@ -686,7 +726,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    return parser
 	  }
 
-	  function strictFail (parser, message) {
+	  function strictFail(parser, message) {
 	    if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {
 	      throw new Error('bad call to strictFail')
 	    }
@@ -695,10 +735,10 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    }
 	  }
 
-	  function newTag (parser) {
+	  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: {} };
+	    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) {
@@ -708,9 +748,9 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    emitNode(parser, 'onopentagstart', tag);
 	  }
 
-	  function qname (name, attribute) {
+	  function qname(name, attribute) {
 	    var i = name.indexOf(':');
-	    var qualName = i < 0 ? [ '', name ] : name.split(':');
+	    var qualName = i < 0 ? ['', name] : name.split(':');
 	    var prefix = qualName[0];
 	    var local = qualName[1];
 
@@ -723,13 +763,15 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    return { prefix: prefix, local: local }
 	  }
 
-	  function attrib (parser) {
+	  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)) {
+	    if (
+	      parser.attribList.indexOf(parser.attribName) !== -1 ||
+	      parser.tag.attributes.hasOwnProperty(parser.attribName)
+	    ) {
 	      parser.attribName = parser.attribValue = '';
 	      return
 	    }
@@ -742,13 +784,26 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	      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);
+	          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;
@@ -768,14 +823,14 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	      parser.tag.attributes[parser.attribName] = parser.attribValue;
 	      emitNode(parser, 'onattribute', {
 	        name: parser.attribName,
-	        value: parser.attribValue
+	        value: parser.attribValue,
 	      });
 	    }
 
 	    parser.attribName = parser.attribValue = '';
 	  }
 
-	  function openTag (parser, selfClosing) {
+	  function openTag(parser, selfClosing) {
 	    if (parser.opt.xmlns) {
 	      // emit namespace binding events
 	      var tag = parser.tag;
@@ -787,8 +842,10 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	      tag.uri = tag.ns[qn.prefix] || '';
 
 	      if (tag.prefix && !tag.uri) {
-	        strictFail(parser, 'Unbound namespace prefix: ' +
-	          JSON.stringify(parser.tagName));
+	        strictFail(
+	          parser,
+	          'Unbound namespace prefix: ' + JSON.stringify(parser.tagName)
+	        );
 	        tag.uri = qn.prefix;
 	      }
 
@@ -797,7 +854,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	        Object.keys(tag.ns).forEach(function (p) {
 	          emitNode(parser, 'onopennamespace', {
 	            prefix: p,
-	            uri: tag.ns[p]
+	            uri: tag.ns[p],
 	          });
 	        });
 	      }
@@ -812,20 +869,22 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	        var qualName = qname(name, true);
 	        var prefix = qualName.prefix;
 	        var local = qualName.local;
-	        var uri = prefix === '' ? '' : (tag.ns[prefix] || '');
+	        var uri = prefix === '' ? '' : tag.ns[prefix] || '';
 	        var a = {
 	          name: name,
 	          value: value,
 	          prefix: prefix,
 	          local: local,
-	          uri: uri
+	          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));
+	          strictFail(
+	            parser,
+	            'Unbound namespace prefix: ' + JSON.stringify(prefix)
+	          );
 	          a.uri = prefix;
 	        }
 	        parser.tag.attributes[name] = a;
@@ -854,7 +913,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    parser.attribList.length = 0;
 	  }
 
-	  function closeTag (parser) {
+	  function closeTag(parser) {
 	    if (!parser.tagName) {
 	      strictFail(parser, 'Weird empty close tag.');
 	      parser.textNode += '</>';
@@ -901,7 +960,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    parser.tagName = tagName;
 	    var s = parser.tags.length;
 	    while (s-- > t) {
-	      var tag = parser.tag = parser.tags.pop();
+	      var tag = (parser.tag = parser.tags.pop());
 	      parser.tagName = parser.tag.name;
 	      emitNode(parser, 'onclosetag', parser.tagName);
 
@@ -925,7 +984,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    parser.state = S.TEXT;
 	  }
 
-	  function parseEntity (parser) {
+	  function parseEntity(parser) {
 	    var entity = parser.entity;
 	    var entityLC = entity.toLowerCase();
 	    var num;
@@ -950,7 +1009,12 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	      }
 	    }
 	    entity = entity.replace(/^0+/, '');
-	    if (isNaN(num) || numStr.toLowerCase() !== entity) {
+	    if (
+	      isNaN(num) ||
+	      numStr.toLowerCase() !== entity ||
+	      num < 0 ||
+	      num > 0x10ffff
+	    ) {
 	      strictFail(parser, 'Invalid character entity');
 	      return '&' + parser.entity + ';'
 	    }
@@ -958,7 +1022,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    return String.fromCodePoint(num)
 	  }
 
-	  function beginWhiteSpace (parser, c) {
+	  function beginWhiteSpace(parser, c) {
 	    if (c === '<') {
 	      parser.state = S.OPEN_WAKA;
 	      parser.startTagPosition = parser.position;
@@ -971,7 +1035,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    }
 	  }
 
-	  function charAt (chunk, i) {
+	  function charAt(chunk, i) {
 	    var result = '';
 	    if (i < chunk.length) {
 	      result = chunk.charAt(i);
@@ -979,14 +1043,16 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	    return result
 	  }
 
-	  function write (chunk) {
+	  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.')
+	      return error(
+	        parser,
+	        'Cannot write after close. Assign an onready handler.'
+	      )
 	    }
 	    if (chunk === null) {
 	      return end(parser)
@@ -1044,11 +1110,17 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	            }
 	            parser.textNode += chunk.substring(starti, i - 1);
 	          }
-	          if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
+	          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)) {
+	            if (
+	              !isWhitespace(c) &&
+	              (!parser.sawRoot || parser.closedRoot)
+	            ) {
 	              strictFail(parser, 'Text data outside of root node.');
 	            }
 	            if (c === '&') {
@@ -1108,10 +1180,14 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	            parser.state = S.COMMENT;
 	            parser.comment = '';
 	            parser.sgmlDecl = '';
-	            continue;
+	            continue
 	          }
 
-	          if (parser.doctype && parser.doctype !== true && parser.sgmlDecl) {
+	          if (
+	            parser.doctype &&
+	            parser.doctype !== true &&
+	            parser.sgmlDecl
+	          ) {
 	            parser.state = S.DOCTYPE_DTD;
 	            parser.doctype += '<!' + parser.sgmlDecl + c;
 	            parser.sgmlDecl = '';
@@ -1123,8 +1199,10 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	          } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
 	            parser.state = S.DOCTYPE;
 	            if (parser.doctype || parser.sawRoot) {
-	              strictFail(parser,
-	                'Inappropriately located doctype declaration');
+	              strictFail(
+	                parser,
+	                'Inappropriately located doctype declaration'
+	              );
 	            }
 	            parser.doctype = '';
 	            parser.sgmlDecl = '';
@@ -1233,10 +1311,22 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	          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;
-	          } else {
-	            parser.cdata += c;
 	          }
 	          continue
 
@@ -1289,7 +1379,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	          if (c === '>') {
 	            emitNode(parser, 'onprocessinginstruction', {
 	              name: parser.procInstName,
-	              body: parser.procInstBody
+	              body: parser.procInstBody,
 	            });
 	            parser.procInstName = parser.procInstBody = '';
 	            parser.state = S.TEXT;
@@ -1322,7 +1412,10 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	            openTag(parser, true);
 	            closeTag(parser);
 	          } else {
-	            strictFail(parser, 'Forward-slash in opening tag not followed by >');
+	            strictFail(
+	              parser,
+	              'Forward-slash in opening tag not followed by >'
+	            );
 	            parser.state = S.ATTRIB;
 	          }
 	          continue
@@ -1372,7 +1465,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	            parser.attribValue = '';
 	            emitNode(parser, 'onattribute', {
 	              name: parser.attribName,
-	              value: ''
+	              value: '',
 	            });
 	            parser.attribName = '';
 	            if (c === '>') {
@@ -1515,7 +1608,10 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 
 	          if (c === ';') {
 	            var parsedEntity = parseEntity(parser);
-	            if (parser.opt.unparsedEntities && !Object.values(sax.XML_ENTITIES).includes(parsedEntity)) {
+	            if (
+	              parser.opt.unparsedEntities &&
+	              !Object.values(sax.XML_ENTITIES).includes(parsedEntity)
+	            ) {
 	              parser.entity = '';
 	              parser.state = returnState;
 	              parser.write(parsedEntity);
@@ -1524,7 +1620,9 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	              parser.entity = '';
 	              parser.state = returnState;
 	            }
-	          } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {
+	          } else if (
+	            isMatch(parser.entity.length ? entityBody : entityStart, c)
+	          ) {
 	            parser.entity += c;
 	          } else {
 	            strictFail(parser, 'Invalid character in entity name');
@@ -1550,7 +1648,7 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	  /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
 	  /* istanbul ignore next */
 	  if (!String.fromCodePoint) {
-	    (function () {
+(function () {
 	      var stringFromCharCode = String.fromCharCode;
 	      var floor = Math.floor;
 	      var fromCodePoint = function () {
@@ -1569,18 +1667,20 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	          if (
 	            !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
 	            codePoint < 0 || // not a valid Unicode code point
-	            codePoint > 0x10FFFF || // 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
+	          if (codePoint <= 0xffff) {
+	            // BMP code point
 	            codeUnits.push(codePoint);
-	          } else { // Astral code point; split in surrogate halves
+	          } 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;
+	            highSurrogate = (codePoint >> 10) + 0xd800;
+	            lowSurrogate = (codePoint % 0x400) + 0xdc00;
 	            codeUnits.push(highSurrogate, lowSurrogate);
 	          }
 	          if (index + 1 === length || codeUnits.length > MAX_SIZE) {
@@ -1595,12 +1695,12 @@ import { __require as requireString_decoder } from '../../string_decoder/lib/str
 	        Object.defineProperty(String, 'fromCodePoint', {
 	          value: fromCodePoint,
 	          configurable: true,
-	          writable: true
+	          writable: true,
 	        });
 	      } else {
 	        String.fromCodePoint = fromCodePoint;
 	      }
-	    }());
+	    })();
 	  }
-	})(exports); 
+	})(exports$1); 
 } (sax));