@streamlayer/sdk-web 1.17.7 → 1.18.1

package/lib/index-ByUNFvMk.js

@@ -0,0 +1,3775 @@
+import { g as ae } from "./index-D7fJzYpJ.js";
+function oe(F, N) {
+  for (var z = 0; z < N.length; z++) {
+    const H = N[z];
+    if (typeof H != "string" && !Array.isArray(H)) {
+      for (const U in H)
+        if (U !== "default" && !(U in F)) {
+          const g = Object.getOwnPropertyDescriptor(H, U);
+          g && Object.defineProperty(F, U, g.get ? g : {
+            enumerable: !0,
+            get: () => H[U]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(F, Symbol.toStringTag, { value: "Module" }));
+}
+var Tu = {}, ou = {}, mu = {}, Wu;
+function _u() {
+  if (Wu) return mu;
+  Wu = 1;
+  function F(g, x, P) {
+    if (P === void 0 && (P = Array.prototype), g && typeof P.find == "function")
+      return P.find.call(g, x);
+    for (var _ = 0; _ < g.length; _++)
+      if (Object.prototype.hasOwnProperty.call(g, _)) {
+        var y = g[_];
+        if (x.call(void 0, y, _, g))
+          return y;
+      }
+  }
+  function N(g, x) {
+    return x === void 0 && (x = Object), x && typeof x.freeze == "function" ? x.freeze(g) : g;
+  }
+  function z(g, x) {
+    if (g === null || typeof g != "object")
+      throw new TypeError("target is not an object");
+    for (var P in x)
+      Object.prototype.hasOwnProperty.call(x, P) && (g[P] = x[P]);
+    return g;
+  }
+  var H = N({
+    /**
+     * `text/html`, the only mime type that triggers treating an XML document as HTML.
+     *
+     * @see DOMParser.SupportedType.isHTML
+     * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+     * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+     * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring WHATWG HTML Spec
+     */
+    HTML: "text/html",
+    /**
+     * Helper method to check a mime type if it indicates an HTML document
+     *
+     * @param {string} [value]
+     * @returns {boolean}
+     *
+     * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+     * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+     * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring 	 */
+    isHTML: function(g) {
+      return g === H.HTML;
+    },
+    /**
+     * `application/xml`, the standard mime type for XML documents.
+     *
+     * @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType registration
+     * @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303
+     * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+     */
+    XML_APPLICATION: "application/xml",
+    /**
+     * `text/html`, an alias for `application/xml`.
+     *
+     * @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303
+     * @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration
+     * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+     */
+    XML_TEXT: "text/xml",
+    /**
+     * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,
+     * but is parsed as an XML document.
+     *
+     * @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType registration
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec
+     * @see https://en.wikipedia.org/wiki/XHTML Wikipedia
+     */
+    XML_XHTML_APPLICATION: "application/xhtml+xml",
+    /**
+     * `image/svg+xml`,
+     *
+     * @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration
+     * @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1
+     * @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia
+     */
+    XML_SVG_IMAGE: "image/svg+xml"
+  }), U = N({
+    /**
+     * The XHTML namespace.
+     *
+     * @see http://www.w3.org/1999/xhtml
+     */
+    HTML: "http://www.w3.org/1999/xhtml",
+    /**
+     * Checks if `uri` equals `NAMESPACE.HTML`.
+     *
+     * @param {string} [uri]
+     *
+     * @see NAMESPACE.HTML
+     */
+    isHTML: function(g) {
+      return g === U.HTML;
+    },
+    /**
+     * The SVG namespace.
+     *
+     * @see http://www.w3.org/2000/svg
+     */
+    SVG: "http://www.w3.org/2000/svg",
+    /**
+     * The `xml:` namespace.
+     *
+     * @see http://www.w3.org/XML/1998/namespace
+     */
+    XML: "http://www.w3.org/XML/1998/namespace",
+    /**
+     * The `xmlns:` namespace
+     *
+     * @see https://www.w3.org/2000/xmlns/
+     */
+    XMLNS: "http://www.w3.org/2000/xmlns/"
+  });
+  return mu.assign = z, mu.find = F, mu.freeze = N, mu.MIME_TYPE = H, mu.NAMESPACE = U, mu;
+}
+var Ku;
+function ne() {
+  if (Ku) return ou;
+  Ku = 1;
+  var F = _u(), N = F.find, z = F.NAMESPACE;
+  function H(u) {
+    return u !== "";
+  }
+  function U(u) {
+    return u ? u.split(/[\t\n\f\r ]+/).filter(H) : [];
+  }
+  function g(u, e) {
+    return u.hasOwnProperty(e) || (u[e] = !0), u;
+  }
+  function x(u) {
+    if (!u) return [];
+    var e = U(u);
+    return Object.keys(e.reduce(g, {}));
+  }
+  function P(u) {
+    return function(e) {
+      return u && u.indexOf(e) !== -1;
+    };
+  }
+  function _(u, e) {
+    for (var r in u)
+      Object.prototype.hasOwnProperty.call(u, r) && (e[r] = u[r]);
+  }
+  function y(u, e) {
+    var r = u.prototype;
+    if (!(r instanceof e)) {
+      let t = function() {
+      };
+      t.prototype = e.prototype, t = new t(), _(r, t), u.prototype = r = t;
+    }
+    r.constructor != u && (typeof u != "function" && console.error("unknown Class:" + u), r.constructor = u);
+  }
+  var O = {}, q = O.ELEMENT_NODE = 1, L = O.ATTRIBUTE_NODE = 2, uu = O.TEXT_NODE = 3, pu = O.CDATA_SECTION_NODE = 4, tu = O.ENTITY_REFERENCE_NODE = 5, o = O.ENTITY_NODE = 6, C = O.PROCESSING_INSTRUCTION_NODE = 7, b = O.COMMENT_NODE = 8, v = O.DOCUMENT_NODE = 9, M = O.DOCUMENT_TYPE_NODE = 10, R = O.DOCUMENT_FRAGMENT_NODE = 11, Q = O.NOTATION_NODE = 12, d = {}, B = {};
+  d.INDEX_SIZE_ERR = (B[1] = "Index size error", 1), d.DOMSTRING_SIZE_ERR = (B[2] = "DOMString size error", 2);
+  var n = d.HIERARCHY_REQUEST_ERR = (B[3] = "Hierarchy request error", 3);
+  d.WRONG_DOCUMENT_ERR = (B[4] = "Wrong document", 4), d.INVALID_CHARACTER_ERR = (B[5] = "Invalid character", 5), d.NO_DATA_ALLOWED_ERR = (B[6] = "No data allowed", 6), d.NO_MODIFICATION_ALLOWED_ERR = (B[7] = "No modification allowed", 7);
+  var a = d.NOT_FOUND_ERR = (B[8] = "Not found", 8);
+  d.NOT_SUPPORTED_ERR = (B[9] = "Not supported", 9);
+  var l = d.INUSE_ATTRIBUTE_ERR = (B[10] = "Attribute in use", 10);
+  d.INVALID_STATE_ERR = (B[11] = "Invalid state", 11), d.SYNTAX_ERR = (B[12] = "Syntax error", 12), d.INVALID_MODIFICATION_ERR = (B[13] = "Invalid modification", 13), d.NAMESPACE_ERR = (B[14] = "Invalid namespace", 14), d.INVALID_ACCESS_ERR = (B[15] = "Invalid access", 15);
+  function s(u, e) {
+    if (e instanceof Error)
+      var r = e;
+    else
+      r = this, Error.call(this, B[u]), this.message = B[u], Error.captureStackTrace && Error.captureStackTrace(this, s);
+    return r.code = u, e && (this.message = this.message + ": " + e), r;
+  }
+  s.prototype = Error.prototype, _(d, s);
+  function p() {
+  }
+  p.prototype = {
+    /**
+     * The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.
+     * @standard level1
+     */
+    length: 0,
+    /**
+     * Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.
+     * @standard level1
+     * @param index  unsigned long
+     *   Index into the collection.
+     * @return Node
+     * 	The node at the indexth position in the NodeList, or null if that is not a valid index.
+     */
+    item: function(u) {
+      return u >= 0 && u < this.length ? this[u] : null;
+    },
+    toString: function(u, e) {
+      for (var r = [], t = 0; t < this.length; t++)
+        vu(this[t], r, u, e);
+      return r.join("");
+    },
+    /**
+     * @private
+     * @param {function (Node):boolean} predicate
+     * @returns {Node[]}
+     */
+    filter: function(u) {
+      return Array.prototype.filter.call(this, u);
+    },
+    /**
+     * @private
+     * @param {Node} item
+     * @returns {number}
+     */
+    indexOf: function(u) {
+      return Array.prototype.indexOf.call(this, u);
+    }
+  };
+  function m(u, e) {
+    this._node = u, this._refresh = e, E(this);
+  }
+  function E(u) {
+    var e = u._node._inc || u._node.ownerDocument._inc;
+    if (u._inc !== e) {
+      var r = u._refresh(u._node);
+      if (Qu(u, "length", r.length), !u.$$length || r.length < u.$$length)
+        for (var t = r.length; t in u; t++)
+          Object.prototype.hasOwnProperty.call(u, t) && delete u[t];
+      _(r, u), u._inc = e;
+    }
+  }
+  m.prototype.item = function(u) {
+    return E(this), this[u] || null;
+  }, y(m, p);
+  function w() {
+  }
+  function f(u, e) {
+    for (var r = u.length; r--; )
+      if (u[r] === e)
+        return r;
+  }
+  function A(u, e, r, t) {
+    if (t ? e[f(e, t)] = r : e[e.length++] = r, u) {
+      r.ownerElement = u;
+      var i = u.ownerDocument;
+      i && (t && wu(i, u, t), G(i, u, r));
+    }
+  }
+  function h(u, e, r) {
+    var t = f(e, r);
+    if (t >= 0) {
+      for (var i = e.length - 1; t < i; )
+        e[t] = e[++t];
+      if (e.length = i, u) {
+        var D = u.ownerDocument;
+        D && (wu(D, u, r), r.ownerElement = null);
+      }
+    } else
+      throw new s(a, new Error(u.tagName + "@" + r));
+  }
+  w.prototype = {
+    length: 0,
+    item: p.prototype.item,
+    getNamedItem: function(u) {
+      for (var e = this.length; e--; ) {
+        var r = this[e];
+        if (r.nodeName == u)
+          return r;
+      }
+    },
+    setNamedItem: function(u) {
+      var e = u.ownerElement;
+      if (e && e != this._ownerElement)
+        throw new s(l);
+      var r = this.getNamedItem(u.nodeName);
+      return A(this._ownerElement, this, u, r), r;
+    },
+    /* returns Node */
+    setNamedItemNS: function(u) {
+      var e = u.ownerElement, r;
+      if (e && e != this._ownerElement)
+        throw new s(l);
+      return r = this.getNamedItemNS(u.namespaceURI, u.localName), A(this._ownerElement, this, u, r), r;
+    },
+    /* returns Node */
+    removeNamedItem: function(u) {
+      var e = this.getNamedItem(u);
+      return h(this._ownerElement, this, e), e;
+    },
+    // raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
+    //for level2
+    removeNamedItemNS: function(u, e) {
+      var r = this.getNamedItemNS(u, e);
+      return h(this._ownerElement, this, r), r;
+    },
+    getNamedItemNS: function(u, e) {
+      for (var r = this.length; r--; ) {
+        var t = this[r];
+        if (t.localName == e && t.namespaceURI == u)
+          return t;
+      }
+      return null;
+    }
+  };
+  function I() {
+  }
+  I.prototype = {
+    /**
+     * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given feature is supported.
+     * The different implementations fairly diverged in what kind of features were reported.
+     * The latest version of the spec settled to force this method to always return true, where the functionality was accurate and in use.
+     *
+     * @deprecated It is deprecated and modern browsers return true in all cases.
+     *
+     * @param {string} feature
+     * @param {string} [version]
+     * @returns {boolean} always true
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/hasFeature MDN
+     * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-5CED94D7 DOM Level 1 Core
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature DOM Living Standard
+     */
+    hasFeature: function(u, e) {
+      return !0;
+    },
+    /**
+     * Creates an XML Document object of the specified type with its document element.
+     *
+     * __It behaves slightly different from the description in the living standard__:
+     * - There is no interface/class `XMLDocument`, it returns a `Document` instance.
+     * - `contentType`, `encoding`, `mode`, `origin`, `url` fields are currently not declared.
+     * - this implementation is not validating names or qualified names
+     *   (when parsing XML strings, the SAX parser takes care of that)
+     *
+     * @param {string|null} namespaceURI
+     * @param {string} qualifiedName
+     * @param {DocumentType=null} doctype
+     * @returns {Document}
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocument MDN
+     * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocument DOM Level 2 Core (initial)
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument  DOM Level 2 Core
+     *
+     * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract
+     * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names
+     * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
+     */
+    createDocument: function(u, e, r) {
+      var t = new V();
+      if (t.implementation = this, t.childNodes = new p(), t.doctype = r || null, r && t.appendChild(r), e) {
+        var i = t.createElementNS(u, e);
+        t.appendChild(i);
+      }
+      return t;
+    },
+    /**
+     * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.
+     *
+     * __This behavior is slightly different from the in the specs__:
+     * - this implementation is not validating names or qualified names
+     *   (when parsing XML strings, the SAX parser takes care of that)
+     *
+     * @param {string} qualifiedName
+     * @param {string} [publicId]
+     * @param {string} [systemId]
+     * @returns {DocumentType} which can either be used with `DOMImplementation.createDocument` upon document creation
+     * 				  or can be put into the document via methods like `Node.insertBefore()` or `Node.replaceChild()`
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocumentType MDN
+     * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocType DOM Level 2 Core
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype DOM Living Standard
+     *
+     * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract
+     * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names
+     * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
+     */
+    createDocumentType: function(u, e, r) {
+      var t = new Su();
+      return t.name = u, t.nodeName = u, t.publicId = e || "", t.systemId = r || "", t;
+    }
+  };
+  function c() {
+  }
+  c.prototype = {
+    firstChild: null,
+    lastChild: null,
+    previousSibling: null,
+    nextSibling: null,
+    attributes: null,
+    parentNode: null,
+    childNodes: null,
+    ownerDocument: null,
+    nodeValue: null,
+    namespaceURI: null,
+    prefix: null,
+    localName: null,
+    // Modified in DOM Level 2:
+    insertBefore: function(u, e) {
+      return su(this, u, e);
+    },
+    replaceChild: function(u, e) {
+      su(this, u, e, qu), e && this.removeChild(e);
+    },
+    removeChild: function(u) {
+      return $(this, u);
+    },
+    appendChild: function(u) {
+      return this.insertBefore(u, null);
+    },
+    hasChildNodes: function() {
+      return this.firstChild != null;
+    },
+    cloneNode: function(u) {
+      return Vu(this.ownerDocument || this, this, u);
+    },
+    // Modified in DOM Level 2:
+    normalize: function() {
+      for (var u = this.firstChild; u; ) {
+        var e = u.nextSibling;
+        e && e.nodeType == uu && u.nodeType == uu ? (this.removeChild(e), u.appendData(e.data)) : (u.normalize(), u = e);
+      }
+    },
+    // Introduced in DOM Level 2:
+    isSupported: function(u, e) {
+      return this.ownerDocument.implementation.hasFeature(u, e);
+    },
+    // Introduced in DOM Level 2:
+    hasAttributes: function() {
+      return this.attributes.length > 0;
+    },
+    /**
+     * Look up the prefix associated to the given namespace URI, starting from this node.
+     * **The default namespace declarations are ignored by this method.**
+     * See Namespace Prefix Lookup for details on the algorithm used by this method.
+     *
+     * _Note: The implementation seems to be incomplete when compared to the algorithm described in the specs._
+     *
+     * @param {string | null} namespaceURI
+     * @returns {string | null}
+     * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespacePrefix
+     * @see https://www.w3.org/TR/DOM-Level-3-Core/namespaces-algorithms.html#lookupNamespacePrefixAlgo
+     * @see https://dom.spec.whatwg.org/#dom-node-lookupprefix
+     * @see https://github.com/xmldom/xmldom/issues/322
+     */
+    lookupPrefix: function(u) {
+      for (var e = this; e; ) {
+        var r = e._nsMap;
+        if (r) {
+          for (var t in r)
+            if (Object.prototype.hasOwnProperty.call(r, t) && r[t] === u)
+              return t;
+        }
+        e = e.nodeType == L ? e.ownerDocument : e.parentNode;
+      }
+      return null;
+    },
+    // Introduced in DOM Level 3:
+    lookupNamespaceURI: function(u) {
+      for (var e = this; e; ) {
+        var r = e._nsMap;
+        if (r && Object.prototype.hasOwnProperty.call(r, u))
+          return r[u];
+        e = e.nodeType == L ? e.ownerDocument : e.parentNode;
+      }
+      return null;
+    },
+    // Introduced in DOM Level 3:
+    isDefaultNamespace: function(u) {
+      var e = this.lookupPrefix(u);
+      return e == null;
+    }
+  };
+  function Z(u) {
+    return u == "<" && "&lt;" || u == ">" && "&gt;" || u == "&" && "&amp;" || u == '"' && "&quot;" || "&#" + u.charCodeAt() + ";";
+  }
+  _(O, c), _(O, c.prototype);
+  function iu(u, e) {
+    if (e(u))
+      return !0;
+    if (u = u.firstChild)
+      do
+        if (iu(u, e))
+          return !0;
+      while (u = u.nextSibling);
+  }
+  function V() {
+    this.ownerDocument = this;
+  }
+  function G(u, e, r) {
+    u && u._inc++;
+    var t = r.namespaceURI;
+    t === z.XMLNS && (e._nsMap[r.prefix ? r.localName : ""] = r.value);
+  }
+  function wu(u, e, r, t) {
+    u && u._inc++;
+    var i = r.namespaceURI;
+    i === z.XMLNS && delete e._nsMap[r.prefix ? r.localName : ""];
+  }
+  function Eu(u, e, r) {
+    if (u && u._inc) {
+      u._inc++;
+      var t = e.childNodes;
+      if (r)
+        t[t.length++] = r;
+      else {
+        for (var i = e.firstChild, D = 0; i; )
+          t[D++] = i, i = i.nextSibling;
+        t.length = D, delete t[t.length];
+      }
+    }
+  }
+  function $(u, e) {
+    var r = e.previousSibling, t = e.nextSibling;
+    return r ? r.nextSibling = t : u.firstChild = t, t ? t.previousSibling = r : u.lastChild = r, e.parentNode = null, e.previousSibling = null, e.nextSibling = null, Eu(u.ownerDocument, u), e;
+  }
+  function eu(u) {
+    return u && (u.nodeType === c.DOCUMENT_NODE || u.nodeType === c.DOCUMENT_FRAGMENT_NODE || u.nodeType === c.ELEMENT_NODE);
+  }
+  function Bu(u) {
+    return u && (K(u) || gu(u) || W(u) || u.nodeType === c.DOCUMENT_FRAGMENT_NODE || u.nodeType === c.COMMENT_NODE || u.nodeType === c.PROCESSING_INSTRUCTION_NODE);
+  }
+  function W(u) {
+    return u && u.nodeType === c.DOCUMENT_TYPE_NODE;
+  }
+  function K(u) {
+    return u && u.nodeType === c.ELEMENT_NODE;
+  }
+  function gu(u) {
+    return u && u.nodeType === c.TEXT_NODE;
+  }
+  function X(u, e) {
+    var r = u.childNodes || [];
+    if (N(r, K) || W(e))
+      return !1;
+    var t = N(r, W);
+    return !(e && t && r.indexOf(t) > r.indexOf(e));
+  }
+  function du(u, e) {
+    var r = u.childNodes || [];
+    function t(D) {
+      return K(D) && D !== e;
+    }
+    if (N(r, t))
+      return !1;
+    var i = N(r, W);
+    return !(e && i && r.indexOf(i) > r.indexOf(e));
+  }
+  function j(u, e, r) {
+    if (!eu(u))
+      throw new s(n, "Unexpected parent node type " + u.nodeType);
+    if (r && r.parentNode !== u)
+      throw new s(a, "child not in parent");
+    if (
+      // 4. If `node` is not a DocumentFragment, DocumentType, Element, or CharacterData node, then throw a "HierarchyRequestError" DOMException.
+      !Bu(e) || // 5. If either `node` is a Text node and `parent` is a document,
+      // the sax parser currently adds top level text nodes, this will be fixed in 0.9.0
+      // || (node.nodeType === Node.TEXT_NODE && parent.nodeType === Node.DOCUMENT_NODE)
+      // or `node` is a doctype and `parent` is not a document, then throw a "HierarchyRequestError" DOMException.
+      W(e) && u.nodeType !== c.DOCUMENT_NODE
+    )
+      throw new s(
+        n,
+        "Unexpected node type " + e.nodeType + " for parent node type " + u.nodeType
+      );
+  }
+  function xu(u, e, r) {
+    var t = u.childNodes || [], i = e.childNodes || [];
+    if (e.nodeType === c.DOCUMENT_FRAGMENT_NODE) {
+      var D = i.filter(K);
+      if (D.length > 1 || N(i, gu))
+        throw new s(n, "More than one element or text in fragment");
+      if (D.length === 1 && !X(u, r))
+        throw new s(n, "Element in fragment can not be inserted before doctype");
+    }
+    if (K(e) && !X(u, r))
+      throw new s(n, "Only one element can be added and only after doctype");
+    if (W(e)) {
+      if (N(t, W))
+        throw new s(n, "Only one doctype is allowed");
+      var T = N(t, K);
+      if (r && t.indexOf(T) < t.indexOf(r))
+        throw new s(n, "Doctype can only be inserted before an element");
+      if (!r && T)
+        throw new s(n, "Doctype can not be appended since element is present");
+    }
+  }
+  function qu(u, e, r) {
+    var t = u.childNodes || [], i = e.childNodes || [];
+    if (e.nodeType === c.DOCUMENT_FRAGMENT_NODE) {
+      var D = i.filter(K);
+      if (D.length > 1 || N(i, gu))
+        throw new s(n, "More than one element or text in fragment");
+      if (D.length === 1 && !du(u, r))
+        throw new s(n, "Element in fragment can not be inserted before doctype");
+    }
+    if (K(e) && !du(u, r))
+      throw new s(n, "Only one element can be added and only after doctype");
+    if (W(e)) {
+      if (N(t, function(ru) {
+        return W(ru) && ru !== r;
+      }))
+        throw new s(n, "Only one doctype is allowed");
+      var T = N(t, K);
+      if (r && t.indexOf(T) < t.indexOf(r))
+        throw new s(n, "Doctype can only be inserted before an element");
+    }
+  }
+  function su(u, e, r, t) {
+    j(u, e, r), u.nodeType === c.DOCUMENT_NODE && (t || xu)(u, e, r);
+    var i = e.parentNode;
+    if (i && i.removeChild(e), e.nodeType === R) {
+      var D = e.firstChild;
+      if (D == null)
+        return e;
+      var T = e.lastChild;
+    } else
+      D = T = e;
+    var J = r ? r.previousSibling : u.lastChild;
+    D.previousSibling = J, T.nextSibling = r, J ? J.nextSibling = D : u.firstChild = D, r == null ? u.lastChild = T : r.previousSibling = T;
+    do {
+      D.parentNode = u;
+      var ru = u.ownerDocument || u;
+      lu(D, ru);
+    } while (D !== T && (D = D.nextSibling));
+    return Eu(u.ownerDocument || u, u), e.nodeType == R && (e.firstChild = e.lastChild = null), e;
+  }
+  function lu(u, e) {
+    if (u.ownerDocument !== e) {
+      if (u.ownerDocument = e, u.nodeType === q && u.attributes)
+        for (var r = 0; r < u.attributes.length; r++) {
+          var t = u.attributes.item(r);
+          t && (t.ownerDocument = e);
+        }
+      for (var i = u.firstChild; i; )
+        lu(i, e), i = i.nextSibling;
+    }
+  }
+  function S(u, e) {
+    e.parentNode && e.parentNode.removeChild(e), e.parentNode = u, e.previousSibling = u.lastChild, e.nextSibling = null, e.previousSibling ? e.previousSibling.nextSibling = e : u.firstChild = e, u.lastChild = e, Eu(u.ownerDocument, u, e);
+    var r = u.ownerDocument || u;
+    return lu(e, r), e;
+  }
+  V.prototype = {
+    //implementation : null,
+    nodeName: "#document",
+    nodeType: v,
+    /**
+     * The DocumentType node of the document.
+     *
+     * @readonly
+     * @type DocumentType
+     */
+    doctype: null,
+    documentElement: null,
+    _inc: 1,
+    insertBefore: function(u, e) {
+      if (u.nodeType == R) {
+        for (var r = u.firstChild; r; ) {
+          var t = r.nextSibling;
+          this.insertBefore(r, e), r = t;
+        }
+        return u;
+      }
+      return su(this, u, e), lu(u, this), this.documentElement === null && u.nodeType === q && (this.documentElement = u), u;
+    },
+    removeChild: function(u) {
+      return this.documentElement == u && (this.documentElement = null), $(this, u);
+    },
+    replaceChild: function(u, e) {
+      su(this, u, e, qu), lu(u, this), e && this.removeChild(e), K(u) && (this.documentElement = u);
+    },
+    // Introduced in DOM Level 2:
+    importNode: function(u, e) {
+      return $u(this, u, e);
+    },
+    // Introduced in DOM Level 2:
+    getElementById: function(u) {
+      var e = null;
+      return iu(this.documentElement, function(r) {
+        if (r.nodeType == q && r.getAttribute("id") == u)
+          return e = r, !0;
+      }), e;
+    },
+    /**
+     * The `getElementsByClassName` method of `Document` interface returns an array-like object
+     * of all child elements which have **all** of the given class name(s).
+     *
+     * Returns an empty list if `classeNames` is an empty string or only contains HTML white space characters.
+     *
+     *
+     * Warning: This is a live LiveNodeList.
+     * Changes in the DOM will reflect in the array as the changes occur.
+     * If an element selected by this array no longer qualifies for the selector,
+     * it will automatically be removed. Be aware of this for iteration purposes.
+     *
+     * @param {string} classNames is a string representing the class name(s) to match; multiple class names are separated by (ASCII-)whitespace
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByClassName
+     * @see https://dom.spec.whatwg.org/#concept-getelementsbyclassname
+     */
+    getElementsByClassName: function(u) {
+      var e = x(u);
+      return new m(this, function(r) {
+        var t = [];
+        return e.length > 0 && iu(r.documentElement, function(i) {
+          if (i !== r && i.nodeType === q) {
+            var D = i.getAttribute("class");
+            if (D) {
+              var T = u === D;
+              if (!T) {
+                var J = x(D);
+                T = e.every(P(J));
+              }
+              T && t.push(i);
+            }
+          }
+        }), t;
+      });
+    },
+    //document factory method:
+    createElement: function(u) {
+      var e = new k();
+      e.ownerDocument = this, e.nodeName = u, e.tagName = u, e.localName = u, e.childNodes = new p();
+      var r = e.attributes = new w();
+      return r._ownerElement = e, e;
+    },
+    createDocumentFragment: function() {
+      var u = new Ou();
+      return u.ownerDocument = this, u.childNodes = new p(), u;
+    },
+    createTextNode: function(u) {
+      var e = new Lu();
+      return e.ownerDocument = this, e.appendData(u), e;
+    },
+    createComment: function(u) {
+      var e = new Iu();
+      return e.ownerDocument = this, e.appendData(u), e;
+    },
+    createCDATASection: function(u) {
+      var e = new ku();
+      return e.ownerDocument = this, e.appendData(u), e;
+    },
+    createProcessingInstruction: function(u, e) {
+      var r = new Uu();
+      return r.ownerDocument = this, r.tagName = r.nodeName = r.target = u, r.nodeValue = r.data = e, r;
+    },
+    createAttribute: function(u) {
+      var e = new Cu();
+      return e.ownerDocument = this, e.name = u, e.nodeName = u, e.localName = u, e.specified = !0, e;
+    },
+    createEntityReference: function(u) {
+      var e = new Mu();
+      return e.ownerDocument = this, e.nodeName = u, e;
+    },
+    // Introduced in DOM Level 2:
+    createElementNS: function(u, e) {
+      var r = new k(), t = e.split(":"), i = r.attributes = new w();
+      return r.childNodes = new p(), r.ownerDocument = this, r.nodeName = e, r.tagName = e, r.namespaceURI = u, t.length == 2 ? (r.prefix = t[0], r.localName = t[1]) : r.localName = e, i._ownerElement = r, r;
+    },
+    // Introduced in DOM Level 2:
+    createAttributeNS: function(u, e) {
+      var r = new Cu(), t = e.split(":");
+      return r.ownerDocument = this, r.nodeName = e, r.name = e, r.namespaceURI = u, r.specified = !0, t.length == 2 ? (r.prefix = t[0], r.localName = t[1]) : r.localName = e, r;
+    }
+  }, y(V, c);
+  function k() {
+    this._nsMap = {};
+  }
+  k.prototype = {
+    nodeType: q,
+    hasAttribute: function(u) {
+      return this.getAttributeNode(u) != null;
+    },
+    getAttribute: function(u) {
+      var e = this.getAttributeNode(u);
+      return e && e.value || "";
+    },
+    getAttributeNode: function(u) {
+      return this.attributes.getNamedItem(u);
+    },
+    setAttribute: function(u, e) {
+      var r = this.ownerDocument.createAttribute(u);
+      r.value = r.nodeValue = "" + e, this.setAttributeNode(r);
+    },
+    removeAttribute: function(u) {
+      var e = this.getAttributeNode(u);
+      e && this.removeAttributeNode(e);
+    },
+    //four real opeartion method
+    appendChild: function(u) {
+      return u.nodeType === R ? this.insertBefore(u, null) : S(this, u);
+    },
+    setAttributeNode: function(u) {
+      return this.attributes.setNamedItem(u);
+    },
+    setAttributeNodeNS: function(u) {
+      return this.attributes.setNamedItemNS(u);
+    },
+    removeAttributeNode: function(u) {
+      return this.attributes.removeNamedItem(u.nodeName);
+    },
+    //get real attribute name,and remove it by removeAttributeNode
+    removeAttributeNS: function(u, e) {
+      var r = this.getAttributeNodeNS(u, e);
+      r && this.removeAttributeNode(r);
+    },
+    hasAttributeNS: function(u, e) {
+      return this.getAttributeNodeNS(u, e) != null;
+    },
+    getAttributeNS: function(u, e) {
+      var r = this.getAttributeNodeNS(u, e);
+      return r && r.value || "";
+    },
+    setAttributeNS: function(u, e, r) {
+      var t = this.ownerDocument.createAttributeNS(u, e);
+      t.value = t.nodeValue = "" + r, this.setAttributeNode(t);
+    },
+    getAttributeNodeNS: function(u, e) {
+      return this.attributes.getNamedItemNS(u, e);
+    },
+    getElementsByTagName: function(u) {
+      return new m(this, function(e) {
+        var r = [];
+        return iu(e, function(t) {
+          t !== e && t.nodeType == q && (u === "*" || t.tagName == u) && r.push(t);
+        }), r;
+      });
+    },
+    getElementsByTagNameNS: function(u, e) {
+      return new m(this, function(r) {
+        var t = [];
+        return iu(r, function(i) {
+          i !== r && i.nodeType === q && (u === "*" || i.namespaceURI === u) && (e === "*" || i.localName == e) && t.push(i);
+        }), t;
+      });
+    }
+  }, V.prototype.getElementsByTagName = k.prototype.getElementsByTagName, V.prototype.getElementsByTagNameNS = k.prototype.getElementsByTagNameNS, y(k, c);
+  function Cu() {
+  }
+  Cu.prototype.nodeType = L, y(Cu, c);
+  function yu() {
+  }
+  yu.prototype = {
+    data: "",
+    substringData: function(u, e) {
+      return this.data.substring(u, u + e);
+    },
+    appendData: function(u) {
+      u = this.data + u, this.nodeValue = this.data = u, this.length = u.length;
+    },
+    insertData: function(u, e) {
+      this.replaceData(u, 0, e);
+    },
+    appendChild: function(u) {
+      throw new Error(B[n]);
+    },
+    deleteData: function(u, e) {
+      this.replaceData(u, e, "");
+    },
+    replaceData: function(u, e, r) {
+      var t = this.data.substring(0, u), i = this.data.substring(u + e);
+      r = t + r + i, this.nodeValue = this.data = r, this.length = r.length;
+    }
+  }, y(yu, c);
+  function Lu() {
+  }
+  Lu.prototype = {
+    nodeName: "#text",
+    nodeType: uu,
+    splitText: function(u) {
+      var e = this.data, r = e.substring(u);
+      e = e.substring(0, u), this.data = this.nodeValue = e, this.length = e.length;
+      var t = this.ownerDocument.createTextNode(r);
+      return this.parentNode && this.parentNode.insertBefore(t, this.nextSibling), t;
+    }
+  }, y(Lu, yu);
+  function Iu() {
+  }
+  Iu.prototype = {
+    nodeName: "#comment",
+    nodeType: b
+  }, y(Iu, yu);
+  function ku() {
+  }
+  ku.prototype = {
+    nodeName: "#cdata-section",
+    nodeType: pu
+  }, y(ku, yu);
+  function Su() {
+  }
+  Su.prototype.nodeType = M, y(Su, c);
+  function zu() {
+  }
+  zu.prototype.nodeType = Q, y(zu, c);
+  function ju() {
+  }
+  ju.prototype.nodeType = o, y(ju, c);
+  function Mu() {
+  }
+  Mu.prototype.nodeType = tu, y(Mu, c);
+  function Ou() {
+  }
+  Ou.prototype.nodeName = "#document-fragment", Ou.prototype.nodeType = R, y(Ou, c);
+  function Uu() {
+  }
+  Uu.prototype.nodeType = C, y(Uu, c);
+  function Hu() {
+  }
+  Hu.prototype.serializeToString = function(u, e, r) {
+    return Xu.call(u, e, r);
+  }, c.prototype.toString = Xu;
+  function Xu(u, e) {
+    var r = [], t = this.nodeType == 9 && this.documentElement || this, i = t.prefix, D = t.namespaceURI;
+    if (D && i == null) {
+      var i = t.lookupPrefix(D);
+      if (i == null)
+        var T = [
+          { namespace: D, prefix: null }
+          //{namespace:uri,prefix:''}
+        ];
+    }
+    return vu(this, r, u, e, T), r.join("");
+  }
+  function Yu(u, e, r) {
+    var t = u.prefix || "", i = u.namespaceURI;
+    if (!i || t === "xml" && i === z.XML || i === z.XMLNS)
+      return !1;
+    for (var D = r.length; D--; ) {
+      var T = r[D];
+      if (T.prefix === t)
+        return T.namespace !== i;
+    }
+    return !0;
+  }
+  function Pu(u, e, r) {
+    u.push(" ", e, '="', r.replace(/[<>&"\t\n\r]/g, Z), '"');
+  }
+  function vu(u, e, r, t, i) {
+    if (i || (i = []), t)
+      if (u = t(u), u) {
+        if (typeof u == "string") {
+          e.push(u);
+          return;
+        }
+      } else
+        return;
+    switch (u.nodeType) {
+      case q:
+        var D = u.attributes, T = D.length, Y = u.firstChild, J = u.tagName;
+        r = z.isHTML(u.namespaceURI) || r;
+        var ru = J;
+        if (!r && !u.prefix && u.namespaceURI) {
+          for (var cu, au = 0; au < D.length; au++)
+            if (D.item(au).name === "xmlns") {
+              cu = D.item(au).value;
+              break;
+            }
+          if (!cu)
+            for (var Du = i.length - 1; Du >= 0; Du--) {
+              var fu = i[Du];
+              if (fu.prefix === "" && fu.namespace === u.namespaceURI) {
+                cu = fu.namespace;
+                break;
+              }
+            }
+          if (cu !== u.namespaceURI)
+            for (var Du = i.length - 1; Du >= 0; Du--) {
+              var fu = i[Du];
+              if (fu.namespace === u.namespaceURI) {
+                fu.prefix && (ru = fu.prefix + ":" + J);
+                break;
+              }
+            }
+        }
+        e.push("<", ru);
+        for (var Au = 0; Au < T; Au++) {
+          var nu = D.item(Au);
+          nu.prefix == "xmlns" ? i.push({ prefix: nu.localName, namespace: nu.value }) : nu.nodeName == "xmlns" && i.push({ prefix: "", namespace: nu.value });
+        }
+        for (var Au = 0; Au < T; Au++) {
+          var nu = D.item(Au);
+          if (Yu(nu, r, i)) {
+            var hu = nu.prefix || "", Nu = nu.namespaceURI;
+            Pu(e, hu ? "xmlns:" + hu : "xmlns", Nu), i.push({ prefix: hu, namespace: Nu });
+          }
+          vu(nu, e, r, t, i);
+        }
+        if (J === ru && Yu(u, r, i)) {
+          var hu = u.prefix || "", Nu = u.namespaceURI;
+          Pu(e, hu ? "xmlns:" + hu : "xmlns", Nu), i.push({ prefix: hu, namespace: Nu });
+        }
+        if (Y || r && !/^(?:meta|link|img|br|hr|input)$/i.test(J)) {
+          if (e.push(">"), r && /^script$/i.test(J))
+            for (; Y; )
+              Y.data ? e.push(Y.data) : vu(Y, e, r, t, i.slice()), Y = Y.nextSibling;
+          else
+            for (; Y; )
+              vu(Y, e, r, t, i.slice()), Y = Y.nextSibling;
+          e.push("</", ru, ">");
+        } else
+          e.push("/>");
+        return;
+      case v:
+      case R:
+        for (var Y = u.firstChild; Y; )
+          vu(Y, e, r, t, i.slice()), Y = Y.nextSibling;
+        return;
+      case L:
+        return Pu(e, u.name, u.value);
+      case uu:
+        return e.push(
+          u.data.replace(/[<&>]/g, Z)
+        );
+      case pu:
+        return e.push("<![CDATA[", u.data, "]]>");
+      case b:
+        return e.push("<!--", u.data, "-->");
+      case M:
+        var Zu = u.publicId, bu = u.systemId;
+        if (e.push("<!DOCTYPE ", u.name), Zu)
+          e.push(" PUBLIC ", Zu), bu && bu != "." && e.push(" ", bu), e.push(">");
+        else if (bu && bu != ".")
+          e.push(" SYSTEM ", bu, ">");
+        else {
+          var Ju = u.internalSubset;
+          Ju && e.push(" [", Ju, "]"), e.push(">");
+        }
+        return;
+      case C:
+        return e.push("<?", u.target, " ", u.data, "?>");
+      case tu:
+        return e.push("&", u.nodeName, ";");
+      //case ENTITY_NODE:
+      //case NOTATION_NODE:
+      default:
+        e.push("??", u.nodeName);
+    }
+  }
+  function $u(u, e, r) {
+    var t;
+    switch (e.nodeType) {
+      case q:
+        t = e.cloneNode(!1), t.ownerDocument = u;
+      //var attrs = node2.attributes;
+      //var len = attrs.length;
+      //for(var i=0;i<len;i++){
+      //node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
+      //}
+      case R:
+        break;
+      case L:
+        r = !0;
+        break;
+    }
+    if (t || (t = e.cloneNode(!1)), t.ownerDocument = u, t.parentNode = null, r)
+      for (var i = e.firstChild; i; )
+        t.appendChild($u(u, i, r)), i = i.nextSibling;
+    return t;
+  }
+  function Vu(u, e, r) {
+    var t = new e.constructor();
+    for (var i in e)
+      if (Object.prototype.hasOwnProperty.call(e, i)) {
+        var D = e[i];
+        typeof D != "object" && D != t[i] && (t[i] = D);
+      }
+    switch (e.childNodes && (t.childNodes = new p()), t.ownerDocument = u, t.nodeType) {
+      case q:
+        var T = e.attributes, J = t.attributes = new w(), ru = T.length;
+        J._ownerElement = t;
+        for (var cu = 0; cu < ru; cu++)
+          t.setAttributeNode(Vu(u, T.item(cu), !0));
+        break;
+      case L:
+        r = !0;
+    }
+    if (r)
+      for (var au = e.firstChild; au; )
+        t.appendChild(Vu(u, au, r)), au = au.nextSibling;
+    return t;
+  }
+  function Qu(u, e, r) {
+    u[e] = r;
+  }
+  try {
+    if (Object.defineProperty) {
+      let u = function(e) {
+        switch (e.nodeType) {
+          case q:
+          case R:
+            var r = [];
+            for (e = e.firstChild; e; )
+              e.nodeType !== 7 && e.nodeType !== 8 && r.push(u(e)), e = e.nextSibling;
+            return r.join("");
+          default:
+            return e.nodeValue;
+        }
+      };
+      Object.defineProperty(m.prototype, "length", {
+        get: function() {
+          return E(this), this.$$length;
+        }
+      }), Object.defineProperty(c.prototype, "textContent", {
+        get: function() {
+          return u(this);
+        },
+        set: function(e) {
+          switch (this.nodeType) {
+            case q:
+            case R:
+              for (; this.firstChild; )
+                this.removeChild(this.firstChild);
+              (e || String(e)) && this.appendChild(this.ownerDocument.createTextNode(e));
+              break;
+            default:
+              this.data = e, this.value = e, this.nodeValue = e;
+          }
+        }
+      }), Qu = function(e, r, t) {
+        e["$$" + r] = t;
+      };
+    }
+  } catch {
+  }
+  return ou.DocumentType = Su, ou.DOMException = s, ou.DOMImplementation = I, ou.Element = k, ou.Node = c, ou.NodeList = p, ou.XMLSerializer = Hu, ou;
+}
+var Fu = {}, Gu = {}, ue;
+function se() {
+  return ue || (ue = 1, (function(F) {
+    var N = _u().freeze;
+    F.XML_ENTITIES = N({
+      amp: "&",
+      apos: "'",
+      gt: ">",
+      lt: "<",
+      quot: '"'
+    }), F.HTML_ENTITIES = N({
+      Aacute: "Á",
+      aacute: "á",
+      Abreve: "Ă",
+      abreve: "ă",
+      ac: "∾",
+      acd: "∿",
+      acE: "∾̳",
+      Acirc: "Â",
+      acirc: "â",
+      acute: "´",
+      Acy: "А",
+      acy: "а",
+      AElig: "Æ",
+      aelig: "æ",
+      af: "⁡",
+      Afr: "𝔄",
+      afr: "𝔞",
+      Agrave: "À",
+      agrave: "à",
+      alefsym: "ℵ",
+      aleph: "ℵ",
+      Alpha: "Α",
+      alpha: "α",
+      Amacr: "Ā",
+      amacr: "ā",
+      amalg: "⨿",
+      AMP: "&",
+      amp: "&",
+      And: "⩓",
+      and: "∧",
+      andand: "⩕",
+      andd: "⩜",
+      andslope: "⩘",
+      andv: "⩚",
+      ang: "∠",
+      ange: "⦤",
+      angle: "∠",
+      angmsd: "∡",
+      angmsdaa: "⦨",
+      angmsdab: "⦩",
+      angmsdac: "⦪",
+      angmsdad: "⦫",
+      angmsdae: "⦬",
+      angmsdaf: "⦭",
+      angmsdag: "⦮",
+      angmsdah: "⦯",
+      angrt: "∟",
+      angrtvb: "⊾",
+      angrtvbd: "⦝",
+      angsph: "∢",
+      angst: "Å",
+      angzarr: "⍼",
+      Aogon: "Ą",
+      aogon: "ą",
+      Aopf: "𝔸",
+      aopf: "𝕒",
+      ap: "≈",
+      apacir: "⩯",
+      apE: "⩰",
+      ape: "≊",
+      apid: "≋",
+      apos: "'",
+      ApplyFunction: "⁡",
+      approx: "≈",
+      approxeq: "≊",
+      Aring: "Å",
+      aring: "å",
+      Ascr: "𝒜",
+      ascr: "𝒶",
+      Assign: "≔",
+      ast: "*",
+      asymp: "≈",
+      asympeq: "≍",
+      Atilde: "Ã",
+      atilde: "ã",
+      Auml: "Ä",
+      auml: "ä",
+      awconint: "∳",
+      awint: "⨑",
+      backcong: "≌",
+      backepsilon: "϶",
+      backprime: "‵",
+      backsim: "∽",
+      backsimeq: "⋍",
+      Backslash: "∖",
+      Barv: "⫧",
+      barvee: "⊽",
+      Barwed: "⌆",
+      barwed: "⌅",
+      barwedge: "⌅",
+      bbrk: "⎵",
+      bbrktbrk: "⎶",
+      bcong: "≌",
+      Bcy: "Б",
+      bcy: "б",
+      bdquo: "„",
+      becaus: "∵",
+      Because: "∵",
+      because: "∵",
+      bemptyv: "⦰",
+      bepsi: "϶",
+      bernou: "ℬ",
+      Bernoullis: "ℬ",
+      Beta: "Β",
+      beta: "β",
+      beth: "ℶ",
+      between: "≬",
+      Bfr: "𝔅",
+      bfr: "𝔟",
+      bigcap: "⋂",
+      bigcirc: "◯",
+      bigcup: "⋃",
+      bigodot: "⨀",
+      bigoplus: "⨁",
+      bigotimes: "⨂",
+      bigsqcup: "⨆",
+      bigstar: "★",
+      bigtriangledown: "▽",
+      bigtriangleup: "△",
+      biguplus: "⨄",
+      bigvee: "⋁",
+      bigwedge: "⋀",
+      bkarow: "⤍",
+      blacklozenge: "⧫",
+      blacksquare: "▪",
+      blacktriangle: "▴",
+      blacktriangledown: "▾",
+      blacktriangleleft: "◂",
+      blacktriangleright: "▸",
+      blank: "␣",
+      blk12: "▒",
+      blk14: "░",
+      blk34: "▓",
+      block: "█",
+      bne: "=⃥",
+      bnequiv: "≡⃥",
+      bNot: "⫭",
+      bnot: "⌐",
+      Bopf: "𝔹",
+      bopf: "𝕓",
+      bot: "⊥",
+      bottom: "⊥",
+      bowtie: "⋈",
+      boxbox: "⧉",
+      boxDL: "╗",
+      boxDl: "╖",
+      boxdL: "╕",
+      boxdl: "┐",
+      boxDR: "╔",
+      boxDr: "╓",
+      boxdR: "╒",
+      boxdr: "┌",
+      boxH: "═",
+      boxh: "─",
+      boxHD: "╦",
+      boxHd: "╤",
+      boxhD: "╥",
+      boxhd: "┬",
+      boxHU: "╩",
+      boxHu: "╧",
+      boxhU: "╨",
+      boxhu: "┴",
+      boxminus: "⊟",
+      boxplus: "⊞",
+      boxtimes: "⊠",
+      boxUL: "╝",
+      boxUl: "╜",
+      boxuL: "╛",
+      boxul: "┘",
+      boxUR: "╚",
+      boxUr: "╙",
+      boxuR: "╘",
+      boxur: "└",
+      boxV: "║",
+      boxv: "│",
+      boxVH: "╬",
+      boxVh: "╫",
+      boxvH: "╪",
+      boxvh: "┼",
+      boxVL: "╣",
+      boxVl: "╢",
+      boxvL: "╡",
+      boxvl: "┤",
+      boxVR: "╠",
+      boxVr: "╟",
+      boxvR: "╞",
+      boxvr: "├",
+      bprime: "‵",
+      Breve: "˘",
+      breve: "˘",
+      brvbar: "¦",
+      Bscr: "ℬ",
+      bscr: "𝒷",
+      bsemi: "⁏",
+      bsim: "∽",
+      bsime: "⋍",
+      bsol: "\\",
+      bsolb: "⧅",
+      bsolhsub: "⟈",
+      bull: "•",
+      bullet: "•",
+      bump: "≎",
+      bumpE: "⪮",
+      bumpe: "≏",
+      Bumpeq: "≎",
+      bumpeq: "≏",
+      Cacute: "Ć",
+      cacute: "ć",
+      Cap: "⋒",
+      cap: "∩",
+      capand: "⩄",
+      capbrcup: "⩉",
+      capcap: "⩋",
+      capcup: "⩇",
+      capdot: "⩀",
+      CapitalDifferentialD: "ⅅ",
+      caps: "∩︀",
+      caret: "⁁",
+      caron: "ˇ",
+      Cayleys: "ℭ",
+      ccaps: "⩍",
+      Ccaron: "Č",
+      ccaron: "č",
+      Ccedil: "Ç",
+      ccedil: "ç",
+      Ccirc: "Ĉ",
+      ccirc: "ĉ",
+      Cconint: "∰",
+      ccups: "⩌",
+      ccupssm: "⩐",
+      Cdot: "Ċ",
+      cdot: "ċ",
+      cedil: "¸",
+      Cedilla: "¸",
+      cemptyv: "⦲",
+      cent: "¢",
+      CenterDot: "·",
+      centerdot: "·",
+      Cfr: "ℭ",
+      cfr: "𝔠",
+      CHcy: "Ч",
+      chcy: "ч",
+      check: "✓",
+      checkmark: "✓",
+      Chi: "Χ",
+      chi: "χ",
+      cir: "○",
+      circ: "ˆ",
+      circeq: "≗",
+      circlearrowleft: "↺",
+      circlearrowright: "↻",
+      circledast: "⊛",
+      circledcirc: "⊚",
+      circleddash: "⊝",
+      CircleDot: "⊙",
+      circledR: "®",
+      circledS: "Ⓢ",
+      CircleMinus: "⊖",
+      CirclePlus: "⊕",
+      CircleTimes: "⊗",
+      cirE: "⧃",
+      cire: "≗",
+      cirfnint: "⨐",
+      cirmid: "⫯",
+      cirscir: "⧂",
+      ClockwiseContourIntegral: "∲",
+      CloseCurlyDoubleQuote: "”",
+      CloseCurlyQuote: "’",
+      clubs: "♣",
+      clubsuit: "♣",
+      Colon: "∷",
+      colon: ":",
+      Colone: "⩴",
+      colone: "≔",
+      coloneq: "≔",
+      comma: ",",
+      commat: "@",
+      comp: "∁",
+      compfn: "∘",
+      complement: "∁",
+      complexes: "ℂ",
+      cong: "≅",
+      congdot: "⩭",
+      Congruent: "≡",
+      Conint: "∯",
+      conint: "∮",
+      ContourIntegral: "∮",
+      Copf: "ℂ",
+      copf: "𝕔",
+      coprod: "∐",
+      Coproduct: "∐",
+      COPY: "©",
+      copy: "©",
+      copysr: "℗",
+      CounterClockwiseContourIntegral: "∳",
+      crarr: "↵",
+      Cross: "⨯",
+      cross: "✗",
+      Cscr: "𝒞",
+      cscr: "𝒸",
+      csub: "⫏",
+      csube: "⫑",
+      csup: "⫐",
+      csupe: "⫒",
+      ctdot: "⋯",
+      cudarrl: "⤸",
+      cudarrr: "⤵",
+      cuepr: "⋞",
+      cuesc: "⋟",
+      cularr: "↶",
+      cularrp: "⤽",
+      Cup: "⋓",
+      cup: "∪",
+      cupbrcap: "⩈",
+      CupCap: "≍",
+      cupcap: "⩆",
+      cupcup: "⩊",
+      cupdot: "⊍",
+      cupor: "⩅",
+      cups: "∪︀",
+      curarr: "↷",
+      curarrm: "⤼",
+      curlyeqprec: "⋞",
+      curlyeqsucc: "⋟",
+      curlyvee: "⋎",
+      curlywedge: "⋏",
+      curren: "¤",
+      curvearrowleft: "↶",
+      curvearrowright: "↷",
+      cuvee: "⋎",
+      cuwed: "⋏",
+      cwconint: "∲",
+      cwint: "∱",
+      cylcty: "⌭",
+      Dagger: "‡",
+      dagger: "†",
+      daleth: "ℸ",
+      Darr: "↡",
+      dArr: "⇓",
+      darr: "↓",
+      dash: "‐",
+      Dashv: "⫤",
+      dashv: "⊣",
+      dbkarow: "⤏",
+      dblac: "˝",
+      Dcaron: "Ď",
+      dcaron: "ď",
+      Dcy: "Д",
+      dcy: "д",
+      DD: "ⅅ",
+      dd: "ⅆ",
+      ddagger: "‡",
+      ddarr: "⇊",
+      DDotrahd: "⤑",
+      ddotseq: "⩷",
+      deg: "°",
+      Del: "∇",
+      Delta: "Δ",
+      delta: "δ",
+      demptyv: "⦱",
+      dfisht: "⥿",
+      Dfr: "𝔇",
+      dfr: "𝔡",
+      dHar: "⥥",
+      dharl: "⇃",
+      dharr: "⇂",
+      DiacriticalAcute: "´",
+      DiacriticalDot: "˙",
+      DiacriticalDoubleAcute: "˝",
+      DiacriticalGrave: "`",
+      DiacriticalTilde: "˜",
+      diam: "⋄",
+      Diamond: "⋄",
+      diamond: "⋄",
+      diamondsuit: "♦",
+      diams: "♦",
+      die: "¨",
+      DifferentialD: "ⅆ",
+      digamma: "ϝ",
+      disin: "⋲",
+      div: "÷",
+      divide: "÷",
+      divideontimes: "⋇",
+      divonx: "⋇",
+      DJcy: "Ђ",
+      djcy: "ђ",
+      dlcorn: "⌞",
+      dlcrop: "⌍",
+      dollar: "$",
+      Dopf: "𝔻",
+      dopf: "𝕕",
+      Dot: "¨",
+      dot: "˙",
+      DotDot: "⃜",
+      doteq: "≐",
+      doteqdot: "≑",
+      DotEqual: "≐",
+      dotminus: "∸",
+      dotplus: "∔",
+      dotsquare: "⊡",
+      doublebarwedge: "⌆",
+      DoubleContourIntegral: "∯",
+      DoubleDot: "¨",
+      DoubleDownArrow: "⇓",
+      DoubleLeftArrow: "⇐",
+      DoubleLeftRightArrow: "⇔",
+      DoubleLeftTee: "⫤",
+      DoubleLongLeftArrow: "⟸",
+      DoubleLongLeftRightArrow: "⟺",
+      DoubleLongRightArrow: "⟹",
+      DoubleRightArrow: "⇒",
+      DoubleRightTee: "⊨",
+      DoubleUpArrow: "⇑",
+      DoubleUpDownArrow: "⇕",
+      DoubleVerticalBar: "∥",
+      DownArrow: "↓",
+      Downarrow: "⇓",
+      downarrow: "↓",
+      DownArrowBar: "⤓",
+      DownArrowUpArrow: "⇵",
+      DownBreve: "̑",
+      downdownarrows: "⇊",
+      downharpoonleft: "⇃",
+      downharpoonright: "⇂",
+      DownLeftRightVector: "⥐",
+      DownLeftTeeVector: "⥞",
+      DownLeftVector: "↽",
+      DownLeftVectorBar: "⥖",
+      DownRightTeeVector: "⥟",
+      DownRightVector: "⇁",
+      DownRightVectorBar: "⥗",
+      DownTee: "⊤",
+      DownTeeArrow: "↧",
+      drbkarow: "⤐",
+      drcorn: "⌟",
+      drcrop: "⌌",
+      Dscr: "𝒟",
+      dscr: "𝒹",
+      DScy: "Ѕ",
+      dscy: "ѕ",
+      dsol: "⧶",
+      Dstrok: "Đ",
+      dstrok: "đ",
+      dtdot: "⋱",
+      dtri: "▿",
+      dtrif: "▾",
+      duarr: "⇵",
+      duhar: "⥯",
+      dwangle: "⦦",
+      DZcy: "Џ",
+      dzcy: "џ",
+      dzigrarr: "⟿",
+      Eacute: "É",
+      eacute: "é",
+      easter: "⩮",
+      Ecaron: "Ě",
+      ecaron: "ě",
+      ecir: "≖",
+      Ecirc: "Ê",
+      ecirc: "ê",
+      ecolon: "≕",
+      Ecy: "Э",
+      ecy: "э",
+      eDDot: "⩷",
+      Edot: "Ė",
+      eDot: "≑",
+      edot: "ė",
+      ee: "ⅇ",
+      efDot: "≒",
+      Efr: "𝔈",
+      efr: "𝔢",
+      eg: "⪚",
+      Egrave: "È",
+      egrave: "è",
+      egs: "⪖",
+      egsdot: "⪘",
+      el: "⪙",
+      Element: "∈",
+      elinters: "⏧",
+      ell: "ℓ",
+      els: "⪕",
+      elsdot: "⪗",
+      Emacr: "Ē",
+      emacr: "ē",
+      empty: "∅",
+      emptyset: "∅",
+      EmptySmallSquare: "◻",
+      emptyv: "∅",
+      EmptyVerySmallSquare: "▫",
+      emsp: " ",
+      emsp13: " ",
+      emsp14: " ",
+      ENG: "Ŋ",
+      eng: "ŋ",
+      ensp: " ",
+      Eogon: "Ę",
+      eogon: "ę",
+      Eopf: "𝔼",
+      eopf: "𝕖",
+      epar: "⋕",
+      eparsl: "⧣",
+      eplus: "⩱",
+      epsi: "ε",
+      Epsilon: "Ε",
+      epsilon: "ε",
+      epsiv: "ϵ",
+      eqcirc: "≖",
+      eqcolon: "≕",
+      eqsim: "≂",
+      eqslantgtr: "⪖",
+      eqslantless: "⪕",
+      Equal: "⩵",
+      equals: "=",
+      EqualTilde: "≂",
+      equest: "≟",
+      Equilibrium: "⇌",
+      equiv: "≡",
+      equivDD: "⩸",
+      eqvparsl: "⧥",
+      erarr: "⥱",
+      erDot: "≓",
+      Escr: "ℰ",
+      escr: "ℯ",
+      esdot: "≐",
+      Esim: "⩳",
+      esim: "≂",
+      Eta: "Η",
+      eta: "η",
+      ETH: "Ð",
+      eth: "ð",
+      Euml: "Ë",
+      euml: "ë",
+      euro: "€",
+      excl: "!",
+      exist: "∃",
+      Exists: "∃",
+      expectation: "ℰ",
+      ExponentialE: "ⅇ",
+      exponentiale: "ⅇ",
+      fallingdotseq: "≒",
+      Fcy: "Ф",
+      fcy: "ф",
+      female: "♀",
+      ffilig: "ffi",
+      fflig: "ff",
+      ffllig: "ffl",
+      Ffr: "𝔉",
+      ffr: "𝔣",
+      filig: "fi",
+      FilledSmallSquare: "◼",
+      FilledVerySmallSquare: "▪",
+      fjlig: "fj",
+      flat: "♭",
+      fllig: "fl",
+      fltns: "▱",
+      fnof: "ƒ",
+      Fopf: "𝔽",
+      fopf: "𝕗",
+      ForAll: "∀",
+      forall: "∀",
+      fork: "⋔",
+      forkv: "⫙",
+      Fouriertrf: "ℱ",
+      fpartint: "⨍",
+      frac12: "½",
+      frac13: "⅓",
+      frac14: "¼",
+      frac15: "⅕",
+      frac16: "⅙",
+      frac18: "⅛",
+      frac23: "⅔",
+      frac25: "⅖",
+      frac34: "¾",
+      frac35: "⅗",
+      frac38: "⅜",
+      frac45: "⅘",
+      frac56: "⅚",
+      frac58: "⅝",
+      frac78: "⅞",
+      frasl: "⁄",
+      frown: "⌢",
+      Fscr: "ℱ",
+      fscr: "𝒻",
+      gacute: "ǵ",
+      Gamma: "Γ",
+      gamma: "γ",
+      Gammad: "Ϝ",
+      gammad: "ϝ",
+      gap: "⪆",
+      Gbreve: "Ğ",
+      gbreve: "ğ",
+      Gcedil: "Ģ",
+      Gcirc: "Ĝ",
+      gcirc: "ĝ",
+      Gcy: "Г",
+      gcy: "г",
+      Gdot: "Ġ",
+      gdot: "ġ",
+      gE: "≧",
+      ge: "≥",
+      gEl: "⪌",
+      gel: "⋛",
+      geq: "≥",
+      geqq: "≧",
+      geqslant: "⩾",
+      ges: "⩾",
+      gescc: "⪩",
+      gesdot: "⪀",
+      gesdoto: "⪂",
+      gesdotol: "⪄",
+      gesl: "⋛︀",
+      gesles: "⪔",
+      Gfr: "𝔊",
+      gfr: "𝔤",
+      Gg: "⋙",
+      gg: "≫",
+      ggg: "⋙",
+      gimel: "ℷ",
+      GJcy: "Ѓ",
+      gjcy: "ѓ",
+      gl: "≷",
+      gla: "⪥",
+      glE: "⪒",
+      glj: "⪤",
+      gnap: "⪊",
+      gnapprox: "⪊",
+      gnE: "≩",
+      gne: "⪈",
+      gneq: "⪈",
+      gneqq: "≩",
+      gnsim: "⋧",
+      Gopf: "𝔾",
+      gopf: "𝕘",
+      grave: "`",
+      GreaterEqual: "≥",
+      GreaterEqualLess: "⋛",
+      GreaterFullEqual: "≧",
+      GreaterGreater: "⪢",
+      GreaterLess: "≷",
+      GreaterSlantEqual: "⩾",
+      GreaterTilde: "≳",
+      Gscr: "𝒢",
+      gscr: "ℊ",
+      gsim: "≳",
+      gsime: "⪎",
+      gsiml: "⪐",
+      Gt: "≫",
+      GT: ">",
+      gt: ">",
+      gtcc: "⪧",
+      gtcir: "⩺",
+      gtdot: "⋗",
+      gtlPar: "⦕",
+      gtquest: "⩼",
+      gtrapprox: "⪆",
+      gtrarr: "⥸",
+      gtrdot: "⋗",
+      gtreqless: "⋛",
+      gtreqqless: "⪌",
+      gtrless: "≷",
+      gtrsim: "≳",
+      gvertneqq: "≩︀",
+      gvnE: "≩︀",
+      Hacek: "ˇ",
+      hairsp: " ",
+      half: "½",
+      hamilt: "ℋ",
+      HARDcy: "Ъ",
+      hardcy: "ъ",
+      hArr: "⇔",
+      harr: "↔",
+      harrcir: "⥈",
+      harrw: "↭",
+      Hat: "^",
+      hbar: "ℏ",
+      Hcirc: "Ĥ",
+      hcirc: "ĥ",
+      hearts: "♥",
+      heartsuit: "♥",
+      hellip: "…",
+      hercon: "⊹",
+      Hfr: "ℌ",
+      hfr: "𝔥",
+      HilbertSpace: "ℋ",
+      hksearow: "⤥",
+      hkswarow: "⤦",
+      hoarr: "⇿",
+      homtht: "∻",
+      hookleftarrow: "↩",
+      hookrightarrow: "↪",
+      Hopf: "ℍ",
+      hopf: "𝕙",
+      horbar: "―",
+      HorizontalLine: "─",
+      Hscr: "ℋ",
+      hscr: "𝒽",
+      hslash: "ℏ",
+      Hstrok: "Ħ",
+      hstrok: "ħ",
+      HumpDownHump: "≎",
+      HumpEqual: "≏",
+      hybull: "⁃",
+      hyphen: "‐",
+      Iacute: "Í",
+      iacute: "í",
+      ic: "⁣",
+      Icirc: "Î",
+      icirc: "î",
+      Icy: "И",
+      icy: "и",
+      Idot: "İ",
+      IEcy: "Е",
+      iecy: "е",
+      iexcl: "¡",
+      iff: "⇔",
+      Ifr: "ℑ",
+      ifr: "𝔦",
+      Igrave: "Ì",
+      igrave: "ì",
+      ii: "ⅈ",
+      iiiint: "⨌",
+      iiint: "∭",
+      iinfin: "⧜",
+      iiota: "℩",
+      IJlig: "IJ",
+      ijlig: "ij",
+      Im: "ℑ",
+      Imacr: "Ī",
+      imacr: "ī",
+      image: "ℑ",
+      ImaginaryI: "ⅈ",
+      imagline: "ℐ",
+      imagpart: "ℑ",
+      imath: "ı",
+      imof: "⊷",
+      imped: "Ƶ",
+      Implies: "⇒",
+      in: "∈",
+      incare: "℅",
+      infin: "∞",
+      infintie: "⧝",
+      inodot: "ı",
+      Int: "∬",
+      int: "∫",
+      intcal: "⊺",
+      integers: "ℤ",
+      Integral: "∫",
+      intercal: "⊺",
+      Intersection: "⋂",
+      intlarhk: "⨗",
+      intprod: "⨼",
+      InvisibleComma: "⁣",
+      InvisibleTimes: "⁢",
+      IOcy: "Ё",
+      iocy: "ё",
+      Iogon: "Į",
+      iogon: "į",
+      Iopf: "𝕀",
+      iopf: "𝕚",
+      Iota: "Ι",
+      iota: "ι",
+      iprod: "⨼",
+      iquest: "¿",
+      Iscr: "ℐ",
+      iscr: "𝒾",
+      isin: "∈",
+      isindot: "⋵",
+      isinE: "⋹",
+      isins: "⋴",
+      isinsv: "⋳",
+      isinv: "∈",
+      it: "⁢",
+      Itilde: "Ĩ",
+      itilde: "ĩ",
+      Iukcy: "І",
+      iukcy: "і",
+      Iuml: "Ï",
+      iuml: "ï",
+      Jcirc: "Ĵ",
+      jcirc: "ĵ",
+      Jcy: "Й",
+      jcy: "й",
+      Jfr: "𝔍",
+      jfr: "𝔧",
+      jmath: "ȷ",
+      Jopf: "𝕁",
+      jopf: "𝕛",
+      Jscr: "𝒥",
+      jscr: "𝒿",
+      Jsercy: "Ј",
+      jsercy: "ј",
+      Jukcy: "Є",
+      jukcy: "є",
+      Kappa: "Κ",
+      kappa: "κ",
+      kappav: "ϰ",
+      Kcedil: "Ķ",
+      kcedil: "ķ",
+      Kcy: "К",
+      kcy: "к",
+      Kfr: "𝔎",
+      kfr: "𝔨",
+      kgreen: "ĸ",
+      KHcy: "Х",
+      khcy: "х",
+      KJcy: "Ќ",
+      kjcy: "ќ",
+      Kopf: "𝕂",
+      kopf: "𝕜",
+      Kscr: "𝒦",
+      kscr: "𝓀",
+      lAarr: "⇚",
+      Lacute: "Ĺ",
+      lacute: "ĺ",
+      laemptyv: "⦴",
+      lagran: "ℒ",
+      Lambda: "Λ",
+      lambda: "λ",
+      Lang: "⟪",
+      lang: "⟨",
+      langd: "⦑",
+      langle: "⟨",
+      lap: "⪅",
+      Laplacetrf: "ℒ",
+      laquo: "«",
+      Larr: "↞",
+      lArr: "⇐",
+      larr: "←",
+      larrb: "⇤",
+      larrbfs: "⤟",
+      larrfs: "⤝",
+      larrhk: "↩",
+      larrlp: "↫",
+      larrpl: "⤹",
+      larrsim: "⥳",
+      larrtl: "↢",
+      lat: "⪫",
+      lAtail: "⤛",
+      latail: "⤙",
+      late: "⪭",
+      lates: "⪭︀",
+      lBarr: "⤎",
+      lbarr: "⤌",
+      lbbrk: "❲",
+      lbrace: "{",
+      lbrack: "[",
+      lbrke: "⦋",
+      lbrksld: "⦏",
+      lbrkslu: "⦍",
+      Lcaron: "Ľ",
+      lcaron: "ľ",
+      Lcedil: "Ļ",
+      lcedil: "ļ",
+      lceil: "⌈",
+      lcub: "{",
+      Lcy: "Л",
+      lcy: "л",
+      ldca: "⤶",
+      ldquo: "“",
+      ldquor: "„",
+      ldrdhar: "⥧",
+      ldrushar: "⥋",
+      ldsh: "↲",
+      lE: "≦",
+      le: "≤",
+      LeftAngleBracket: "⟨",
+      LeftArrow: "←",
+      Leftarrow: "⇐",
+      leftarrow: "←",
+      LeftArrowBar: "⇤",
+      LeftArrowRightArrow: "⇆",
+      leftarrowtail: "↢",
+      LeftCeiling: "⌈",
+      LeftDoubleBracket: "⟦",
+      LeftDownTeeVector: "⥡",
+      LeftDownVector: "⇃",
+      LeftDownVectorBar: "⥙",
+      LeftFloor: "⌊",
+      leftharpoondown: "↽",
+      leftharpoonup: "↼",
+      leftleftarrows: "⇇",
+      LeftRightArrow: "↔",
+      Leftrightarrow: "⇔",
+      leftrightarrow: "↔",
+      leftrightarrows: "⇆",
+      leftrightharpoons: "⇋",
+      leftrightsquigarrow: "↭",
+      LeftRightVector: "⥎",
+      LeftTee: "⊣",
+      LeftTeeArrow: "↤",
+      LeftTeeVector: "⥚",
+      leftthreetimes: "⋋",
+      LeftTriangle: "⊲",
+      LeftTriangleBar: "⧏",
+      LeftTriangleEqual: "⊴",
+      LeftUpDownVector: "⥑",
+      LeftUpTeeVector: "⥠",
+      LeftUpVector: "↿",
+      LeftUpVectorBar: "⥘",
+      LeftVector: "↼",
+      LeftVectorBar: "⥒",
+      lEg: "⪋",
+      leg: "⋚",
+      leq: "≤",
+      leqq: "≦",
+      leqslant: "⩽",
+      les: "⩽",
+      lescc: "⪨",
+      lesdot: "⩿",
+      lesdoto: "⪁",
+      lesdotor: "⪃",
+      lesg: "⋚︀",
+      lesges: "⪓",
+      lessapprox: "⪅",
+      lessdot: "⋖",
+      lesseqgtr: "⋚",
+      lesseqqgtr: "⪋",
+      LessEqualGreater: "⋚",
+      LessFullEqual: "≦",
+      LessGreater: "≶",
+      lessgtr: "≶",
+      LessLess: "⪡",
+      lesssim: "≲",
+      LessSlantEqual: "⩽",
+      LessTilde: "≲",
+      lfisht: "⥼",
+      lfloor: "⌊",
+      Lfr: "𝔏",
+      lfr: "𝔩",
+      lg: "≶",
+      lgE: "⪑",
+      lHar: "⥢",
+      lhard: "↽",
+      lharu: "↼",
+      lharul: "⥪",
+      lhblk: "▄",
+      LJcy: "Љ",
+      ljcy: "љ",
+      Ll: "⋘",
+      ll: "≪",
+      llarr: "⇇",
+      llcorner: "⌞",
+      Lleftarrow: "⇚",
+      llhard: "⥫",
+      lltri: "◺",
+      Lmidot: "Ŀ",
+      lmidot: "ŀ",
+      lmoust: "⎰",
+      lmoustache: "⎰",
+      lnap: "⪉",
+      lnapprox: "⪉",
+      lnE: "≨",
+      lne: "⪇",
+      lneq: "⪇",
+      lneqq: "≨",
+      lnsim: "⋦",
+      loang: "⟬",
+      loarr: "⇽",
+      lobrk: "⟦",
+      LongLeftArrow: "⟵",
+      Longleftarrow: "⟸",
+      longleftarrow: "⟵",
+      LongLeftRightArrow: "⟷",
+      Longleftrightarrow: "⟺",
+      longleftrightarrow: "⟷",
+      longmapsto: "⟼",
+      LongRightArrow: "⟶",
+      Longrightarrow: "⟹",
+      longrightarrow: "⟶",
+      looparrowleft: "↫",
+      looparrowright: "↬",
+      lopar: "⦅",
+      Lopf: "𝕃",
+      lopf: "𝕝",
+      loplus: "⨭",
+      lotimes: "⨴",
+      lowast: "∗",
+      lowbar: "_",
+      LowerLeftArrow: "↙",
+      LowerRightArrow: "↘",
+      loz: "◊",
+      lozenge: "◊",
+      lozf: "⧫",
+      lpar: "(",
+      lparlt: "⦓",
+      lrarr: "⇆",
+      lrcorner: "⌟",
+      lrhar: "⇋",
+      lrhard: "⥭",
+      lrm: "‎",
+      lrtri: "⊿",
+      lsaquo: "‹",
+      Lscr: "ℒ",
+      lscr: "𝓁",
+      Lsh: "↰",
+      lsh: "↰",
+      lsim: "≲",
+      lsime: "⪍",
+      lsimg: "⪏",
+      lsqb: "[",
+      lsquo: "‘",
+      lsquor: "‚",
+      Lstrok: "Ł",
+      lstrok: "ł",
+      Lt: "≪",
+      LT: "<",
+      lt: "<",
+      ltcc: "⪦",
+      ltcir: "⩹",
+      ltdot: "⋖",
+      lthree: "⋋",
+      ltimes: "⋉",
+      ltlarr: "⥶",
+      ltquest: "⩻",
+      ltri: "◃",
+      ltrie: "⊴",
+      ltrif: "◂",
+      ltrPar: "⦖",
+      lurdshar: "⥊",
+      luruhar: "⥦",
+      lvertneqq: "≨︀",
+      lvnE: "≨︀",
+      macr: "¯",
+      male: "♂",
+      malt: "✠",
+      maltese: "✠",
+      Map: "⤅",
+      map: "↦",
+      mapsto: "↦",
+      mapstodown: "↧",
+      mapstoleft: "↤",
+      mapstoup: "↥",
+      marker: "▮",
+      mcomma: "⨩",
+      Mcy: "М",
+      mcy: "м",
+      mdash: "—",
+      mDDot: "∺",
+      measuredangle: "∡",
+      MediumSpace: " ",
+      Mellintrf: "ℳ",
+      Mfr: "𝔐",
+      mfr: "𝔪",
+      mho: "℧",
+      micro: "µ",
+      mid: "∣",
+      midast: "*",
+      midcir: "⫰",
+      middot: "·",
+      minus: "−",
+      minusb: "⊟",
+      minusd: "∸",
+      minusdu: "⨪",
+      MinusPlus: "∓",
+      mlcp: "⫛",
+      mldr: "…",
+      mnplus: "∓",
+      models: "⊧",
+      Mopf: "𝕄",
+      mopf: "𝕞",
+      mp: "∓",
+      Mscr: "ℳ",
+      mscr: "𝓂",
+      mstpos: "∾",
+      Mu: "Μ",
+      mu: "μ",
+      multimap: "⊸",
+      mumap: "⊸",
+      nabla: "∇",
+      Nacute: "Ń",
+      nacute: "ń",
+      nang: "∠⃒",
+      nap: "≉",
+      napE: "⩰̸",
+      napid: "≋̸",
+      napos: "ʼn",
+      napprox: "≉",
+      natur: "♮",
+      natural: "♮",
+      naturals: "ℕ",
+      nbsp: " ",
+      nbump: "≎̸",
+      nbumpe: "≏̸",
+      ncap: "⩃",
+      Ncaron: "Ň",
+      ncaron: "ň",
+      Ncedil: "Ņ",
+      ncedil: "ņ",
+      ncong: "≇",
+      ncongdot: "⩭̸",
+      ncup: "⩂",
+      Ncy: "Н",
+      ncy: "н",
+      ndash: "–",
+      ne: "≠",
+      nearhk: "⤤",
+      neArr: "⇗",
+      nearr: "↗",
+      nearrow: "↗",
+      nedot: "≐̸",
+      NegativeMediumSpace: "​",
+      NegativeThickSpace: "​",
+      NegativeThinSpace: "​",
+      NegativeVeryThinSpace: "​",
+      nequiv: "≢",
+      nesear: "⤨",
+      nesim: "≂̸",
+      NestedGreaterGreater: "≫",
+      NestedLessLess: "≪",
+      NewLine: `
+`,
+      nexist: "∄",
+      nexists: "∄",
+      Nfr: "𝔑",
+      nfr: "𝔫",
+      ngE: "≧̸",
+      nge: "≱",
+      ngeq: "≱",
+      ngeqq: "≧̸",
+      ngeqslant: "⩾̸",
+      nges: "⩾̸",
+      nGg: "⋙̸",
+      ngsim: "≵",
+      nGt: "≫⃒",
+      ngt: "≯",
+      ngtr: "≯",
+      nGtv: "≫̸",
+      nhArr: "⇎",
+      nharr: "↮",
+      nhpar: "⫲",
+      ni: "∋",
+      nis: "⋼",
+      nisd: "⋺",
+      niv: "∋",
+      NJcy: "Њ",
+      njcy: "њ",
+      nlArr: "⇍",
+      nlarr: "↚",
+      nldr: "‥",
+      nlE: "≦̸",
+      nle: "≰",
+      nLeftarrow: "⇍",
+      nleftarrow: "↚",
+      nLeftrightarrow: "⇎",
+      nleftrightarrow: "↮",
+      nleq: "≰",
+      nleqq: "≦̸",
+      nleqslant: "⩽̸",
+      nles: "⩽̸",
+      nless: "≮",
+      nLl: "⋘̸",
+      nlsim: "≴",
+      nLt: "≪⃒",
+      nlt: "≮",
+      nltri: "⋪",
+      nltrie: "⋬",
+      nLtv: "≪̸",
+      nmid: "∤",
+      NoBreak: "⁠",
+      NonBreakingSpace: " ",
+      Nopf: "ℕ",
+      nopf: "𝕟",
+      Not: "⫬",
+      not: "¬",
+      NotCongruent: "≢",
+      NotCupCap: "≭",
+      NotDoubleVerticalBar: "∦",
+      NotElement: "∉",
+      NotEqual: "≠",
+      NotEqualTilde: "≂̸",
+      NotExists: "∄",
+      NotGreater: "≯",
+      NotGreaterEqual: "≱",
+      NotGreaterFullEqual: "≧̸",
+      NotGreaterGreater: "≫̸",
+      NotGreaterLess: "≹",
+      NotGreaterSlantEqual: "⩾̸",
+      NotGreaterTilde: "≵",
+      NotHumpDownHump: "≎̸",
+      NotHumpEqual: "≏̸",
+      notin: "∉",
+      notindot: "⋵̸",
+      notinE: "⋹̸",
+      notinva: "∉",
+      notinvb: "⋷",
+      notinvc: "⋶",
+      NotLeftTriangle: "⋪",
+      NotLeftTriangleBar: "⧏̸",
+      NotLeftTriangleEqual: "⋬",
+      NotLess: "≮",
+      NotLessEqual: "≰",
+      NotLessGreater: "≸",
+      NotLessLess: "≪̸",
+      NotLessSlantEqual: "⩽̸",
+      NotLessTilde: "≴",
+      NotNestedGreaterGreater: "⪢̸",
+      NotNestedLessLess: "⪡̸",
+      notni: "∌",
+      notniva: "∌",
+      notnivb: "⋾",
+      notnivc: "⋽",
+      NotPrecedes: "⊀",
+      NotPrecedesEqual: "⪯̸",
+      NotPrecedesSlantEqual: "⋠",
+      NotReverseElement: "∌",
+      NotRightTriangle: "⋫",
+      NotRightTriangleBar: "⧐̸",
+      NotRightTriangleEqual: "⋭",
+      NotSquareSubset: "⊏̸",
+      NotSquareSubsetEqual: "⋢",
+      NotSquareSuperset: "⊐̸",
+      NotSquareSupersetEqual: "⋣",
+      NotSubset: "⊂⃒",
+      NotSubsetEqual: "⊈",
+      NotSucceeds: "⊁",
+      NotSucceedsEqual: "⪰̸",
+      NotSucceedsSlantEqual: "⋡",
+      NotSucceedsTilde: "≿̸",
+      NotSuperset: "⊃⃒",
+      NotSupersetEqual: "⊉",
+      NotTilde: "≁",
+      NotTildeEqual: "≄",
+      NotTildeFullEqual: "≇",
+      NotTildeTilde: "≉",
+      NotVerticalBar: "∤",
+      npar: "∦",
+      nparallel: "∦",
+      nparsl: "⫽⃥",
+      npart: "∂̸",
+      npolint: "⨔",
+      npr: "⊀",
+      nprcue: "⋠",
+      npre: "⪯̸",
+      nprec: "⊀",
+      npreceq: "⪯̸",
+      nrArr: "⇏",
+      nrarr: "↛",
+      nrarrc: "⤳̸",
+      nrarrw: "↝̸",
+      nRightarrow: "⇏",
+      nrightarrow: "↛",
+      nrtri: "⋫",
+      nrtrie: "⋭",
+      nsc: "⊁",
+      nsccue: "⋡",
+      nsce: "⪰̸",
+      Nscr: "𝒩",
+      nscr: "𝓃",
+      nshortmid: "∤",
+      nshortparallel: "∦",
+      nsim: "≁",
+      nsime: "≄",
+      nsimeq: "≄",
+      nsmid: "∤",
+      nspar: "∦",
+      nsqsube: "⋢",
+      nsqsupe: "⋣",
+      nsub: "⊄",
+      nsubE: "⫅̸",
+      nsube: "⊈",
+      nsubset: "⊂⃒",
+      nsubseteq: "⊈",
+      nsubseteqq: "⫅̸",
+      nsucc: "⊁",
+      nsucceq: "⪰̸",
+      nsup: "⊅",
+      nsupE: "⫆̸",
+      nsupe: "⊉",
+      nsupset: "⊃⃒",
+      nsupseteq: "⊉",
+      nsupseteqq: "⫆̸",
+      ntgl: "≹",
+      Ntilde: "Ñ",
+      ntilde: "ñ",
+      ntlg: "≸",
+      ntriangleleft: "⋪",
+      ntrianglelefteq: "⋬",
+      ntriangleright: "⋫",
+      ntrianglerighteq: "⋭",
+      Nu: "Ν",
+      nu: "ν",
+      num: "#",
+      numero: "№",
+      numsp: " ",
+      nvap: "≍⃒",
+      nVDash: "⊯",
+      nVdash: "⊮",
+      nvDash: "⊭",
+      nvdash: "⊬",
+      nvge: "≥⃒",
+      nvgt: ">⃒",
+      nvHarr: "⤄",
+      nvinfin: "⧞",
+      nvlArr: "⤂",
+      nvle: "≤⃒",
+      nvlt: "<⃒",
+      nvltrie: "⊴⃒",
+      nvrArr: "⤃",
+      nvrtrie: "⊵⃒",
+      nvsim: "∼⃒",
+      nwarhk: "⤣",
+      nwArr: "⇖",
+      nwarr: "↖",
+      nwarrow: "↖",
+      nwnear: "⤧",
+      Oacute: "Ó",
+      oacute: "ó",
+      oast: "⊛",
+      ocir: "⊚",
+      Ocirc: "Ô",
+      ocirc: "ô",
+      Ocy: "О",
+      ocy: "о",
+      odash: "⊝",
+      Odblac: "Ő",
+      odblac: "ő",
+      odiv: "⨸",
+      odot: "⊙",
+      odsold: "⦼",
+      OElig: "Œ",
+      oelig: "œ",
+      ofcir: "⦿",
+      Ofr: "𝔒",
+      ofr: "𝔬",
+      ogon: "˛",
+      Ograve: "Ò",
+      ograve: "ò",
+      ogt: "⧁",
+      ohbar: "⦵",
+      ohm: "Ω",
+      oint: "∮",
+      olarr: "↺",
+      olcir: "⦾",
+      olcross: "⦻",
+      oline: "‾",
+      olt: "⧀",
+      Omacr: "Ō",
+      omacr: "ō",
+      Omega: "Ω",
+      omega: "ω",
+      Omicron: "Ο",
+      omicron: "ο",
+      omid: "⦶",
+      ominus: "⊖",
+      Oopf: "𝕆",
+      oopf: "𝕠",
+      opar: "⦷",
+      OpenCurlyDoubleQuote: "“",
+      OpenCurlyQuote: "‘",
+      operp: "⦹",
+      oplus: "⊕",
+      Or: "⩔",
+      or: "∨",
+      orarr: "↻",
+      ord: "⩝",
+      order: "ℴ",
+      orderof: "ℴ",
+      ordf: "ª",
+      ordm: "º",
+      origof: "⊶",
+      oror: "⩖",
+      orslope: "⩗",
+      orv: "⩛",
+      oS: "Ⓢ",
+      Oscr: "𝒪",
+      oscr: "ℴ",
+      Oslash: "Ø",
+      oslash: "ø",
+      osol: "⊘",
+      Otilde: "Õ",
+      otilde: "õ",
+      Otimes: "⨷",
+      otimes: "⊗",
+      otimesas: "⨶",
+      Ouml: "Ö",
+      ouml: "ö",
+      ovbar: "⌽",
+      OverBar: "‾",
+      OverBrace: "⏞",
+      OverBracket: "⎴",
+      OverParenthesis: "⏜",
+      par: "∥",
+      para: "¶",
+      parallel: "∥",
+      parsim: "⫳",
+      parsl: "⫽",
+      part: "∂",
+      PartialD: "∂",
+      Pcy: "П",
+      pcy: "п",
+      percnt: "%",
+      period: ".",
+      permil: "‰",
+      perp: "⊥",
+      pertenk: "‱",
+      Pfr: "𝔓",
+      pfr: "𝔭",
+      Phi: "Φ",
+      phi: "φ",
+      phiv: "ϕ",
+      phmmat: "ℳ",
+      phone: "☎",
+      Pi: "Π",
+      pi: "π",
+      pitchfork: "⋔",
+      piv: "ϖ",
+      planck: "ℏ",
+      planckh: "ℎ",
+      plankv: "ℏ",
+      plus: "+",
+      plusacir: "⨣",
+      plusb: "⊞",
+      pluscir: "⨢",
+      plusdo: "∔",
+      plusdu: "⨥",
+      pluse: "⩲",
+      PlusMinus: "±",
+      plusmn: "±",
+      plussim: "⨦",
+      plustwo: "⨧",
+      pm: "±",
+      Poincareplane: "ℌ",
+      pointint: "⨕",
+      Popf: "ℙ",
+      popf: "𝕡",
+      pound: "£",
+      Pr: "⪻",
+      pr: "≺",
+      prap: "⪷",
+      prcue: "≼",
+      prE: "⪳",
+      pre: "⪯",
+      prec: "≺",
+      precapprox: "⪷",
+      preccurlyeq: "≼",
+      Precedes: "≺",
+      PrecedesEqual: "⪯",
+      PrecedesSlantEqual: "≼",
+      PrecedesTilde: "≾",
+      preceq: "⪯",
+      precnapprox: "⪹",
+      precneqq: "⪵",
+      precnsim: "⋨",
+      precsim: "≾",
+      Prime: "″",
+      prime: "′",
+      primes: "ℙ",
+      prnap: "⪹",
+      prnE: "⪵",
+      prnsim: "⋨",
+      prod: "∏",
+      Product: "∏",
+      profalar: "⌮",
+      profline: "⌒",
+      profsurf: "⌓",
+      prop: "∝",
+      Proportion: "∷",
+      Proportional: "∝",
+      propto: "∝",
+      prsim: "≾",
+      prurel: "⊰",
+      Pscr: "𝒫",
+      pscr: "𝓅",
+      Psi: "Ψ",
+      psi: "ψ",
+      puncsp: " ",
+      Qfr: "𝔔",
+      qfr: "𝔮",
+      qint: "⨌",
+      Qopf: "ℚ",
+      qopf: "𝕢",
+      qprime: "⁗",
+      Qscr: "𝒬",
+      qscr: "𝓆",
+      quaternions: "ℍ",
+      quatint: "⨖",
+      quest: "?",
+      questeq: "≟",
+      QUOT: '"',
+      quot: '"',
+      rAarr: "⇛",
+      race: "∽̱",
+      Racute: "Ŕ",
+      racute: "ŕ",
+      radic: "√",
+      raemptyv: "⦳",
+      Rang: "⟫",
+      rang: "⟩",
+      rangd: "⦒",
+      range: "⦥",
+      rangle: "⟩",
+      raquo: "»",
+      Rarr: "↠",
+      rArr: "⇒",
+      rarr: "→",
+      rarrap: "⥵",
+      rarrb: "⇥",
+      rarrbfs: "⤠",
+      rarrc: "⤳",
+      rarrfs: "⤞",
+      rarrhk: "↪",
+      rarrlp: "↬",
+      rarrpl: "⥅",
+      rarrsim: "⥴",
+      Rarrtl: "⤖",
+      rarrtl: "↣",
+      rarrw: "↝",
+      rAtail: "⤜",
+      ratail: "⤚",
+      ratio: "∶",
+      rationals: "ℚ",
+      RBarr: "⤐",
+      rBarr: "⤏",
+      rbarr: "⤍",
+      rbbrk: "❳",
+      rbrace: "}",
+      rbrack: "]",
+      rbrke: "⦌",
+      rbrksld: "⦎",
+      rbrkslu: "⦐",
+      Rcaron: "Ř",
+      rcaron: "ř",
+      Rcedil: "Ŗ",
+      rcedil: "ŗ",
+      rceil: "⌉",
+      rcub: "}",
+      Rcy: "Р",
+      rcy: "р",
+      rdca: "⤷",
+      rdldhar: "⥩",
+      rdquo: "”",
+      rdquor: "”",
+      rdsh: "↳",
+      Re: "ℜ",
+      real: "ℜ",
+      realine: "ℛ",
+      realpart: "ℜ",
+      reals: "ℝ",
+      rect: "▭",
+      REG: "®",
+      reg: "®",
+      ReverseElement: "∋",
+      ReverseEquilibrium: "⇋",
+      ReverseUpEquilibrium: "⥯",
+      rfisht: "⥽",
+      rfloor: "⌋",
+      Rfr: "ℜ",
+      rfr: "𝔯",
+      rHar: "⥤",
+      rhard: "⇁",
+      rharu: "⇀",
+      rharul: "⥬",
+      Rho: "Ρ",
+      rho: "ρ",
+      rhov: "ϱ",
+      RightAngleBracket: "⟩",
+      RightArrow: "→",
+      Rightarrow: "⇒",
+      rightarrow: "→",
+      RightArrowBar: "⇥",
+      RightArrowLeftArrow: "⇄",
+      rightarrowtail: "↣",
+      RightCeiling: "⌉",
+      RightDoubleBracket: "⟧",
+      RightDownTeeVector: "⥝",
+      RightDownVector: "⇂",
+      RightDownVectorBar: "⥕",
+      RightFloor: "⌋",
+      rightharpoondown: "⇁",
+      rightharpoonup: "⇀",
+      rightleftarrows: "⇄",
+      rightleftharpoons: "⇌",
+      rightrightarrows: "⇉",
+      rightsquigarrow: "↝",
+      RightTee: "⊢",
+      RightTeeArrow: "↦",
+      RightTeeVector: "⥛",
+      rightthreetimes: "⋌",
+      RightTriangle: "⊳",
+      RightTriangleBar: "⧐",
+      RightTriangleEqual: "⊵",
+      RightUpDownVector: "⥏",
+      RightUpTeeVector: "⥜",
+      RightUpVector: "↾",
+      RightUpVectorBar: "⥔",
+      RightVector: "⇀",
+      RightVectorBar: "⥓",
+      ring: "˚",
+      risingdotseq: "≓",
+      rlarr: "⇄",
+      rlhar: "⇌",
+      rlm: "‏",
+      rmoust: "⎱",
+      rmoustache: "⎱",
+      rnmid: "⫮",
+      roang: "⟭",
+      roarr: "⇾",
+      robrk: "⟧",
+      ropar: "⦆",
+      Ropf: "ℝ",
+      ropf: "𝕣",
+      roplus: "⨮",
+      rotimes: "⨵",
+      RoundImplies: "⥰",
+      rpar: ")",
+      rpargt: "⦔",
+      rppolint: "⨒",
+      rrarr: "⇉",
+      Rrightarrow: "⇛",
+      rsaquo: "›",
+      Rscr: "ℛ",
+      rscr: "𝓇",
+      Rsh: "↱",
+      rsh: "↱",
+      rsqb: "]",
+      rsquo: "’",
+      rsquor: "’",
+      rthree: "⋌",
+      rtimes: "⋊",
+      rtri: "▹",
+      rtrie: "⊵",
+      rtrif: "▸",
+      rtriltri: "⧎",
+      RuleDelayed: "⧴",
+      ruluhar: "⥨",
+      rx: "℞",
+      Sacute: "Ś",
+      sacute: "ś",
+      sbquo: "‚",
+      Sc: "⪼",
+      sc: "≻",
+      scap: "⪸",
+      Scaron: "Š",
+      scaron: "š",
+      sccue: "≽",
+      scE: "⪴",
+      sce: "⪰",
+      Scedil: "Ş",
+      scedil: "ş",
+      Scirc: "Ŝ",
+      scirc: "ŝ",
+      scnap: "⪺",
+      scnE: "⪶",
+      scnsim: "⋩",
+      scpolint: "⨓",
+      scsim: "≿",
+      Scy: "С",
+      scy: "с",
+      sdot: "⋅",
+      sdotb: "⊡",
+      sdote: "⩦",
+      searhk: "⤥",
+      seArr: "⇘",
+      searr: "↘",
+      searrow: "↘",
+      sect: "§",
+      semi: ";",
+      seswar: "⤩",
+      setminus: "∖",
+      setmn: "∖",
+      sext: "✶",
+      Sfr: "𝔖",
+      sfr: "𝔰",
+      sfrown: "⌢",
+      sharp: "♯",
+      SHCHcy: "Щ",
+      shchcy: "щ",
+      SHcy: "Ш",
+      shcy: "ш",
+      ShortDownArrow: "↓",
+      ShortLeftArrow: "←",
+      shortmid: "∣",
+      shortparallel: "∥",
+      ShortRightArrow: "→",
+      ShortUpArrow: "↑",
+      shy: "­",
+      Sigma: "Σ",
+      sigma: "σ",
+      sigmaf: "ς",
+      sigmav: "ς",
+      sim: "∼",
+      simdot: "⩪",
+      sime: "≃",
+      simeq: "≃",
+      simg: "⪞",
+      simgE: "⪠",
+      siml: "⪝",
+      simlE: "⪟",
+      simne: "≆",
+      simplus: "⨤",
+      simrarr: "⥲",
+      slarr: "←",
+      SmallCircle: "∘",
+      smallsetminus: "∖",
+      smashp: "⨳",
+      smeparsl: "⧤",
+      smid: "∣",
+      smile: "⌣",
+      smt: "⪪",
+      smte: "⪬",
+      smtes: "⪬︀",
+      SOFTcy: "Ь",
+      softcy: "ь",
+      sol: "/",
+      solb: "⧄",
+      solbar: "⌿",
+      Sopf: "𝕊",
+      sopf: "𝕤",
+      spades: "♠",
+      spadesuit: "♠",
+      spar: "∥",
+      sqcap: "⊓",
+      sqcaps: "⊓︀",
+      sqcup: "⊔",
+      sqcups: "⊔︀",
+      Sqrt: "√",
+      sqsub: "⊏",
+      sqsube: "⊑",
+      sqsubset: "⊏",
+      sqsubseteq: "⊑",
+      sqsup: "⊐",
+      sqsupe: "⊒",
+      sqsupset: "⊐",
+      sqsupseteq: "⊒",
+      squ: "□",
+      Square: "□",
+      square: "□",
+      SquareIntersection: "⊓",
+      SquareSubset: "⊏",
+      SquareSubsetEqual: "⊑",
+      SquareSuperset: "⊐",
+      SquareSupersetEqual: "⊒",
+      SquareUnion: "⊔",
+      squarf: "▪",
+      squf: "▪",
+      srarr: "→",
+      Sscr: "𝒮",
+      sscr: "𝓈",
+      ssetmn: "∖",
+      ssmile: "⌣",
+      sstarf: "⋆",
+      Star: "⋆",
+      star: "☆",
+      starf: "★",
+      straightepsilon: "ϵ",
+      straightphi: "ϕ",
+      strns: "¯",
+      Sub: "⋐",
+      sub: "⊂",
+      subdot: "⪽",
+      subE: "⫅",
+      sube: "⊆",
+      subedot: "⫃",
+      submult: "⫁",
+      subnE: "⫋",
+      subne: "⊊",
+      subplus: "⪿",
+      subrarr: "⥹",
+      Subset: "⋐",
+      subset: "⊂",
+      subseteq: "⊆",
+      subseteqq: "⫅",
+      SubsetEqual: "⊆",
+      subsetneq: "⊊",
+      subsetneqq: "⫋",
+      subsim: "⫇",
+      subsub: "⫕",
+      subsup: "⫓",
+      succ: "≻",
+      succapprox: "⪸",
+      succcurlyeq: "≽",
+      Succeeds: "≻",
+      SucceedsEqual: "⪰",
+      SucceedsSlantEqual: "≽",
+      SucceedsTilde: "≿",
+      succeq: "⪰",
+      succnapprox: "⪺",
+      succneqq: "⪶",
+      succnsim: "⋩",
+      succsim: "≿",
+      SuchThat: "∋",
+      Sum: "∑",
+      sum: "∑",
+      sung: "♪",
+      Sup: "⋑",
+      sup: "⊃",
+      sup1: "¹",
+      sup2: "²",
+      sup3: "³",
+      supdot: "⪾",
+      supdsub: "⫘",
+      supE: "⫆",
+      supe: "⊇",
+      supedot: "⫄",
+      Superset: "⊃",
+      SupersetEqual: "⊇",
+      suphsol: "⟉",
+      suphsub: "⫗",
+      suplarr: "⥻",
+      supmult: "⫂",
+      supnE: "⫌",
+      supne: "⊋",
+      supplus: "⫀",
+      Supset: "⋑",
+      supset: "⊃",
+      supseteq: "⊇",
+      supseteqq: "⫆",
+      supsetneq: "⊋",
+      supsetneqq: "⫌",
+      supsim: "⫈",
+      supsub: "⫔",
+      supsup: "⫖",
+      swarhk: "⤦",
+      swArr: "⇙",
+      swarr: "↙",
+      swarrow: "↙",
+      swnwar: "⤪",
+      szlig: "ß",
+      Tab: "	",
+      target: "⌖",
+      Tau: "Τ",
+      tau: "τ",
+      tbrk: "⎴",
+      Tcaron: "Ť",
+      tcaron: "ť",
+      Tcedil: "Ţ",
+      tcedil: "ţ",
+      Tcy: "Т",
+      tcy: "т",
+      tdot: "⃛",
+      telrec: "⌕",
+      Tfr: "𝔗",
+      tfr: "𝔱",
+      there4: "∴",
+      Therefore: "∴",
+      therefore: "∴",
+      Theta: "Θ",
+      theta: "θ",
+      thetasym: "ϑ",
+      thetav: "ϑ",
+      thickapprox: "≈",
+      thicksim: "∼",
+      ThickSpace: "  ",
+      thinsp: " ",
+      ThinSpace: " ",
+      thkap: "≈",
+      thksim: "∼",
+      THORN: "Þ",
+      thorn: "þ",
+      Tilde: "∼",
+      tilde: "˜",
+      TildeEqual: "≃",
+      TildeFullEqual: "≅",
+      TildeTilde: "≈",
+      times: "×",
+      timesb: "⊠",
+      timesbar: "⨱",
+      timesd: "⨰",
+      tint: "∭",
+      toea: "⤨",
+      top: "⊤",
+      topbot: "⌶",
+      topcir: "⫱",
+      Topf: "𝕋",
+      topf: "𝕥",
+      topfork: "⫚",
+      tosa: "⤩",
+      tprime: "‴",
+      TRADE: "™",
+      trade: "™",
+      triangle: "▵",
+      triangledown: "▿",
+      triangleleft: "◃",
+      trianglelefteq: "⊴",
+      triangleq: "≜",
+      triangleright: "▹",
+      trianglerighteq: "⊵",
+      tridot: "◬",
+      trie: "≜",
+      triminus: "⨺",
+      TripleDot: "⃛",
+      triplus: "⨹",
+      trisb: "⧍",
+      tritime: "⨻",
+      trpezium: "⏢",
+      Tscr: "𝒯",
+      tscr: "𝓉",
+      TScy: "Ц",
+      tscy: "ц",
+      TSHcy: "Ћ",
+      tshcy: "ћ",
+      Tstrok: "Ŧ",
+      tstrok: "ŧ",
+      twixt: "≬",
+      twoheadleftarrow: "↞",
+      twoheadrightarrow: "↠",
+      Uacute: "Ú",
+      uacute: "ú",
+      Uarr: "↟",
+      uArr: "⇑",
+      uarr: "↑",
+      Uarrocir: "⥉",
+      Ubrcy: "Ў",
+      ubrcy: "ў",
+      Ubreve: "Ŭ",
+      ubreve: "ŭ",
+      Ucirc: "Û",
+      ucirc: "û",
+      Ucy: "У",
+      ucy: "у",
+      udarr: "⇅",
+      Udblac: "Ű",
+      udblac: "ű",
+      udhar: "⥮",
+      ufisht: "⥾",
+      Ufr: "𝔘",
+      ufr: "𝔲",
+      Ugrave: "Ù",
+      ugrave: "ù",
+      uHar: "⥣",
+      uharl: "↿",
+      uharr: "↾",
+      uhblk: "▀",
+      ulcorn: "⌜",
+      ulcorner: "⌜",
+      ulcrop: "⌏",
+      ultri: "◸",
+      Umacr: "Ū",
+      umacr: "ū",
+      uml: "¨",
+      UnderBar: "_",
+      UnderBrace: "⏟",
+      UnderBracket: "⎵",
+      UnderParenthesis: "⏝",
+      Union: "⋃",
+      UnionPlus: "⊎",
+      Uogon: "Ų",
+      uogon: "ų",
+      Uopf: "𝕌",
+      uopf: "𝕦",
+      UpArrow: "↑",
+      Uparrow: "⇑",
+      uparrow: "↑",
+      UpArrowBar: "⤒",
+      UpArrowDownArrow: "⇅",
+      UpDownArrow: "↕",
+      Updownarrow: "⇕",
+      updownarrow: "↕",
+      UpEquilibrium: "⥮",
+      upharpoonleft: "↿",
+      upharpoonright: "↾",
+      uplus: "⊎",
+      UpperLeftArrow: "↖",
+      UpperRightArrow: "↗",
+      Upsi: "ϒ",
+      upsi: "υ",
+      upsih: "ϒ",
+      Upsilon: "Υ",
+      upsilon: "υ",
+      UpTee: "⊥",
+      UpTeeArrow: "↥",
+      upuparrows: "⇈",
+      urcorn: "⌝",
+      urcorner: "⌝",
+      urcrop: "⌎",
+      Uring: "Ů",
+      uring: "ů",
+      urtri: "◹",
+      Uscr: "𝒰",
+      uscr: "𝓊",
+      utdot: "⋰",
+      Utilde: "Ũ",
+      utilde: "ũ",
+      utri: "▵",
+      utrif: "▴",
+      uuarr: "⇈",
+      Uuml: "Ü",
+      uuml: "ü",
+      uwangle: "⦧",
+      vangrt: "⦜",
+      varepsilon: "ϵ",
+      varkappa: "ϰ",
+      varnothing: "∅",
+      varphi: "ϕ",
+      varpi: "ϖ",
+      varpropto: "∝",
+      vArr: "⇕",
+      varr: "↕",
+      varrho: "ϱ",
+      varsigma: "ς",
+      varsubsetneq: "⊊︀",
+      varsubsetneqq: "⫋︀",
+      varsupsetneq: "⊋︀",
+      varsupsetneqq: "⫌︀",
+      vartheta: "ϑ",
+      vartriangleleft: "⊲",
+      vartriangleright: "⊳",
+      Vbar: "⫫",
+      vBar: "⫨",
+      vBarv: "⫩",
+      Vcy: "В",
+      vcy: "в",
+      VDash: "⊫",
+      Vdash: "⊩",
+      vDash: "⊨",
+      vdash: "⊢",
+      Vdashl: "⫦",
+      Vee: "⋁",
+      vee: "∨",
+      veebar: "⊻",
+      veeeq: "≚",
+      vellip: "⋮",
+      Verbar: "‖",
+      verbar: "|",
+      Vert: "‖",
+      vert: "|",
+      VerticalBar: "∣",
+      VerticalLine: "|",
+      VerticalSeparator: "❘",
+      VerticalTilde: "≀",
+      VeryThinSpace: " ",
+      Vfr: "𝔙",
+      vfr: "𝔳",
+      vltri: "⊲",
+      vnsub: "⊂⃒",
+      vnsup: "⊃⃒",
+      Vopf: "𝕍",
+      vopf: "𝕧",
+      vprop: "∝",
+      vrtri: "⊳",
+      Vscr: "𝒱",
+      vscr: "𝓋",
+      vsubnE: "⫋︀",
+      vsubne: "⊊︀",
+      vsupnE: "⫌︀",
+      vsupne: "⊋︀",
+      Vvdash: "⊪",
+      vzigzag: "⦚",
+      Wcirc: "Ŵ",
+      wcirc: "ŵ",
+      wedbar: "⩟",
+      Wedge: "⋀",
+      wedge: "∧",
+      wedgeq: "≙",
+      weierp: "℘",
+      Wfr: "𝔚",
+      wfr: "𝔴",
+      Wopf: "𝕎",
+      wopf: "𝕨",
+      wp: "℘",
+      wr: "≀",
+      wreath: "≀",
+      Wscr: "𝒲",
+      wscr: "𝓌",
+      xcap: "⋂",
+      xcirc: "◯",
+      xcup: "⋃",
+      xdtri: "▽",
+      Xfr: "𝔛",
+      xfr: "𝔵",
+      xhArr: "⟺",
+      xharr: "⟷",
+      Xi: "Ξ",
+      xi: "ξ",
+      xlArr: "⟸",
+      xlarr: "⟵",
+      xmap: "⟼",
+      xnis: "⋻",
+      xodot: "⨀",
+      Xopf: "𝕏",
+      xopf: "𝕩",
+      xoplus: "⨁",
+      xotime: "⨂",
+      xrArr: "⟹",
+      xrarr: "⟶",
+      Xscr: "𝒳",
+      xscr: "𝓍",
+      xsqcup: "⨆",
+      xuplus: "⨄",
+      xutri: "△",
+      xvee: "⋁",
+      xwedge: "⋀",
+      Yacute: "Ý",
+      yacute: "ý",
+      YAcy: "Я",
+      yacy: "я",
+      Ycirc: "Ŷ",
+      ycirc: "ŷ",
+      Ycy: "Ы",
+      ycy: "ы",
+      yen: "¥",
+      Yfr: "𝔜",
+      yfr: "𝔶",
+      YIcy: "Ї",
+      yicy: "ї",
+      Yopf: "𝕐",
+      yopf: "𝕪",
+      Yscr: "𝒴",
+      yscr: "𝓎",
+      YUcy: "Ю",
+      yucy: "ю",
+      Yuml: "Ÿ",
+      yuml: "ÿ",
+      Zacute: "Ź",
+      zacute: "ź",
+      Zcaron: "Ž",
+      zcaron: "ž",
+      Zcy: "З",
+      zcy: "з",
+      Zdot: "Ż",
+      zdot: "ż",
+      zeetrf: "ℨ",
+      ZeroWidthSpace: "​",
+      Zeta: "Ζ",
+      zeta: "ζ",
+      Zfr: "ℨ",
+      zfr: "𝔷",
+      ZHcy: "Ж",
+      zhcy: "ж",
+      zigrarr: "⇝",
+      Zopf: "ℤ",
+      zopf: "𝕫",
+      Zscr: "𝒵",
+      zscr: "𝓏",
+      zwj: "‍",
+      zwnj: "‌"
+    }), F.entityMap = F.HTML_ENTITIES;
+  })(Gu)), Gu;
+}
+var Ru = {}, ee;
+function le() {
+  if (ee) return Ru;
+  ee = 1;
+  var F = _u().NAMESPACE, N = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/, z = new RegExp("[\\-\\.0-9" + N.source.slice(1, -1) + "\\u00B7\\u0300-\\u036F\\u203F-\\u2040]"), H = new RegExp("^" + N.source + z.source + "*(?::" + N.source + z.source + "*)?$"), U = 0, g = 1, x = 2, P = 3, _ = 4, y = 5, O = 6, q = 7;
+  function L(n, a) {
+    this.message = n, this.locator = a, Error.captureStackTrace && Error.captureStackTrace(this, L);
+  }
+  L.prototype = new Error(), L.prototype.name = L.name;
+  function uu() {
+  }
+  uu.prototype = {
+    parse: function(n, a, l) {
+      var s = this.domBuilder;
+      s.startDocument(), M(a, a = {}), pu(
+        n,
+        a,
+        l,
+        s,
+        this.errorHandler
+      ), s.endDocument();
+    }
+  };
+  function pu(n, a, l, s, p) {
+    function m(S) {
+      if (S > 65535) {
+        S -= 65536;
+        var k = 55296 + (S >> 10), Cu = 56320 + (S & 1023);
+        return String.fromCharCode(k, Cu);
+      } else
+        return String.fromCharCode(S);
+    }
+    function E(S) {
+      var k = S.slice(1, -1);
+      return Object.hasOwnProperty.call(l, k) ? l[k] : k.charAt(0) === "#" ? m(parseInt(k.substr(1).replace("x", "0x"))) : (p.error("entity not found:" + S), S);
+    }
+    function w(S) {
+      if (S > V) {
+        var k = n.substring(V, S).replace(/&#?\w+;/g, E);
+        c && f(V), s.characters(k, 0, S - V), V = S;
+      }
+    }
+    function f(S, k) {
+      for (; S >= h && (k = I.exec(n)); )
+        A = k.index, h = A + k[0].length, c.lineNumber++;
+      c.columnNumber = S - A + 1;
+    }
+    for (var A = 0, h = 0, I = /.*(?:\r\n?|\n)|.*$/g, c = s.locator, Z = [{ currentNSMap: a }], iu = {}, V = 0; ; ) {
+      try {
+        var G = n.indexOf("<", V);
+        if (G < 0) {
+          if (!n.substr(V).match(/^\s*$/)) {
+            var wu = s.doc, Eu = wu.createTextNode(n.substr(V));
+            wu.appendChild(Eu), s.currentElement = Eu;
+          }
+          return;
+        }
+        switch (G > V && w(G), n.charAt(G + 1)) {
+          case "/":
+            var j = n.indexOf(">", G + 3), $ = n.substring(G + 2, j).replace(/[ \t\n\r]+$/g, ""), eu = Z.pop();
+            j < 0 ? ($ = n.substring(G + 2).replace(/[\s<].*/, ""), p.error("end tag name: " + $ + " is not complete:" + eu.tagName), j = G + 1 + $.length) : $.match(/\s</) && ($ = $.replace(/[\s<].*/, ""), p.error("end tag name: " + $ + " maybe not complete"), j = G + 1 + $.length);
+            var Bu = eu.localNSMap, W = eu.tagName == $, K = W || eu.tagName && eu.tagName.toLowerCase() == $.toLowerCase();
+            if (K) {
+              if (s.endElement(eu.uri, eu.localName, $), Bu)
+                for (var gu in Bu)
+                  Object.prototype.hasOwnProperty.call(Bu, gu) && s.endPrefixMapping(gu);
+              W || p.fatalError("end tag name: " + $ + " is not match the current start tagName:" + eu.tagName);
+            } else
+              Z.push(eu);
+            j++;
+            break;
+          // end elment
+          case "?":
+            c && f(G), j = Q(n, G, s);
+            break;
+          case "!":
+            c && f(G), j = R(n, G, s, p);
+            break;
+          default:
+            c && f(G);
+            var X = new d(), du = Z[Z.length - 1].currentNSMap, j = o(n, G, X, du, E, p), xu = X.length;
+            if (!X.closed && v(n, j, X.tagName, iu) && (X.closed = !0, l.nbsp || p.warning("unclosed xml attribute")), c && xu) {
+              for (var qu = tu(c, {}), su = 0; su < xu; su++) {
+                var lu = X[su];
+                f(lu.offset), lu.locator = tu(c, {});
+              }
+              s.locator = qu, C(X, s, du) && Z.push(X), s.locator = c;
+            } else
+              C(X, s, du) && Z.push(X);
+            F.isHTML(X.uri) && !X.closed ? j = b(n, j, X.tagName, E, s) : j++;
+        }
+      } catch (S) {
+        if (S instanceof L)
+          throw S;
+        p.error("element parse error: " + S), j = -1;
+      }
+      j > V ? V = j : w(Math.max(G, V) + 1);
+    }
+  }
+  function tu(n, a) {
+    return a.lineNumber = n.lineNumber, a.columnNumber = n.columnNumber, a;
+  }
+  function o(n, a, l, s, p, m) {
+    function E(c, Z, iu) {
+      l.attributeNames.hasOwnProperty(c) && m.fatalError("Attribute " + c + " redefined"), l.addValue(
+        c,
+        // @see https://www.w3.org/TR/xml/#AVNormalize
+        // since the xmldom sax parser does not "interpret" DTD the following is not implemented:
+        // - recursive replacement of (DTD) entity references
+        // - trimming and collapsing multiple spaces into a single one for attributes that are not of type CDATA
+        Z.replace(/[\t\n\r]/g, " ").replace(/&#?\w+;/g, p),
+        iu
+      );
+    }
+    for (var w, f, A = ++a, h = U; ; ) {
+      var I = n.charAt(A);
+      switch (I) {
+        case "=":
+          if (h === g)
+            w = n.slice(a, A), h = P;
+          else if (h === x)
+            h = P;
+          else
+            throw new Error("attribute equal must after attrName");
+          break;
+        case "'":
+        case '"':
+          if (h === P || h === g)
+            if (h === g && (m.warning('attribute value must after "="'), w = n.slice(a, A)), a = A + 1, A = n.indexOf(I, a), A > 0)
+              f = n.slice(a, A), E(w, f, a - 1), h = y;
+            else
+              throw new Error("attribute value no end '" + I + "' match");
+          else if (h == _)
+            f = n.slice(a, A), E(w, f, a), m.warning('attribute "' + w + '" missed start quot(' + I + ")!!"), a = A + 1, h = y;
+          else
+            throw new Error('attribute value must after "="');
+          break;
+        case "/":
+          switch (h) {
+            case U:
+              l.setTagName(n.slice(a, A));
+            case y:
+            case O:
+            case q:
+              h = q, l.closed = !0;
+            case _:
+            case g:
+              break;
+            case x:
+              l.closed = !0;
+              break;
+            //case S_EQ:
+            default:
+              throw new Error("attribute invalid close char('/')");
+          }
+          break;
+        case "":
+          return m.error("unexpected end of input"), h == U && l.setTagName(n.slice(a, A)), A;
+        case ">":
+          switch (h) {
+            case U:
+              l.setTagName(n.slice(a, A));
+            case y:
+            case O:
+            case q:
+              break;
+            //normal
+            case _:
+            //Compatible state
+            case g:
+              f = n.slice(a, A), f.slice(-1) === "/" && (l.closed = !0, f = f.slice(0, -1));
+            case x:
+              h === x && (f = w), h == _ ? (m.warning('attribute "' + f + '" missed quot(")!'), E(w, f, a)) : ((!F.isHTML(s[""]) || !f.match(/^(?:disabled|checked|selected)$/i)) && m.warning('attribute "' + f + '" missed value!! "' + f + '" instead!!'), E(f, f, a));
+              break;
+            case P:
+              throw new Error("attribute value missed!!");
+          }
+          return A;
+        /*xml space '\x20' | #x9 | #xD | #xA; */
+        case "€":
+          I = " ";
+        default:
+          if (I <= " ")
+            switch (h) {
+              case U:
+                l.setTagName(n.slice(a, A)), h = O;
+                break;
+              case g:
+                w = n.slice(a, A), h = x;
+                break;
+              case _:
+                var f = n.slice(a, A);
+                m.warning('attribute "' + f + '" missed quot(")!!'), E(w, f, a);
+              case y:
+                h = O;
+                break;
+            }
+          else
+            switch (h) {
+              //case S_TAG:void();break;
+              //case S_ATTR:void();break;
+              //case S_ATTR_NOQUOT_VALUE:void();break;
+              case x:
+                l.tagName, (!F.isHTML(s[""]) || !w.match(/^(?:disabled|checked|selected)$/i)) && m.warning('attribute "' + w + '" missed value!! "' + w + '" instead2!!'), E(w, w, a), a = A, h = g;
+                break;
+              case y:
+                m.warning('attribute space is required"' + w + '"!!');
+              case O:
+                h = g, a = A;
+                break;
+              case P:
+                h = _, a = A;
+                break;
+              case q:
+                throw new Error("elements closed character '/' and '>' must be connected to");
+            }
+      }
+      A++;
+    }
+  }
+  function C(n, a, l) {
+    for (var s = n.tagName, p = null, I = n.length; I--; ) {
+      var m = n[I], E = m.qName, w = m.value, c = E.indexOf(":");
+      if (c > 0)
+        var f = m.prefix = E.slice(0, c), A = E.slice(c + 1), h = f === "xmlns" && A;
+      else
+        A = E, f = null, h = E === "xmlns" && "";
+      m.localName = A, h !== !1 && (p == null && (p = {}, M(l, l = {})), l[h] = p[h] = w, m.uri = F.XMLNS, a.startPrefixMapping(h, w));
+    }
+    for (var I = n.length; I--; ) {
+      m = n[I];
+      var f = m.prefix;
+      f && (f === "xml" && (m.uri = F.XML), f !== "xmlns" && (m.uri = l[f || ""]));
+    }
+    var c = s.indexOf(":");
+    c > 0 ? (f = n.prefix = s.slice(0, c), A = n.localName = s.slice(c + 1)) : (f = null, A = n.localName = s);
+    var Z = n.uri = l[f || ""];
+    if (a.startElement(Z, A, s, n), n.closed) {
+      if (a.endElement(Z, A, s), p)
+        for (f in p)
+          Object.prototype.hasOwnProperty.call(p, f) && a.endPrefixMapping(f);
+    } else
+      return n.currentNSMap = l, n.localNSMap = p, !0;
+  }
+  function b(n, a, l, s, p) {
+    if (/^(?:script|textarea)$/i.test(l)) {
+      var m = n.indexOf("</" + l + ">", a), E = n.substring(a + 1, m);
+      if (/[&<]/.test(E))
+        return /^script$/i.test(l) ? (p.characters(E, 0, E.length), m) : (E = E.replace(/&#?\w+;/g, s), p.characters(E, 0, E.length), m);
+    }
+    return a + 1;
+  }
+  function v(n, a, l, s) {
+    var p = s[l];
+    return p == null && (p = n.lastIndexOf("</" + l + ">"), p < a && (p = n.lastIndexOf("</" + l)), s[l] = p), p < a;
+  }
+  function M(n, a) {
+    for (var l in n)
+      Object.prototype.hasOwnProperty.call(n, l) && (a[l] = n[l]);
+  }
+  function R(n, a, l, s) {
+    var p = n.charAt(a + 2);
+    switch (p) {
+      case "-":
+        if (n.charAt(a + 3) === "-") {
+          var m = n.indexOf("-->", a + 4);
+          return m > a ? (l.comment(n, a + 4, m - a - 4), m + 3) : (s.error("Unclosed comment"), -1);
+        } else
+          return -1;
+      default:
+        if (n.substr(a + 3, 6) == "CDATA[") {
+          var m = n.indexOf("]]>", a + 9);
+          return l.startCDATA(), l.characters(n, a + 9, m - a - 9), l.endCDATA(), m + 3;
+        }
+        var E = B(n, a), w = E.length;
+        if (w > 1 && /!doctype/i.test(E[0][0])) {
+          var f = E[1][0], A = !1, h = !1;
+          w > 3 && (/^public$/i.test(E[2][0]) ? (A = E[3][0], h = w > 4 && E[4][0]) : /^system$/i.test(E[2][0]) && (h = E[3][0]));
+          var I = E[w - 1];
+          return l.startDTD(f, A, h), l.endDTD(), I.index + I[0].length;
+        }
+    }
+    return -1;
+  }
+  function Q(n, a, l) {
+    var s = n.indexOf("?>", a);
+    if (s) {
+      var p = n.substring(a, s).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
+      return p ? (p[0].length, l.processingInstruction(p[1], p[2]), s + 2) : -1;
+    }
+    return -1;
+  }
+  function d() {
+    this.attributeNames = {};
+  }
+  d.prototype = {
+    setTagName: function(n) {
+      if (!H.test(n))
+        throw new Error("invalid tagName:" + n);
+      this.tagName = n;
+    },
+    addValue: function(n, a, l) {
+      if (!H.test(n))
+        throw new Error("invalid attribute:" + n);
+      this.attributeNames[n] = this.length, this[this.length++] = { qName: n, value: a, offset: l };
+    },
+    length: 0,
+    getLocalName: function(n) {
+      return this[n].localName;
+    },
+    getLocator: function(n) {
+      return this[n].locator;
+    },
+    getQName: function(n) {
+      return this[n].qName;
+    },
+    getURI: function(n) {
+      return this[n].uri;
+    },
+    getValue: function(n) {
+      return this[n].value;
+    }
+    //	,getIndex:function(uri, localName)){
+    //		if(localName){
+    //
+    //		}else{
+    //			var qName = uri
+    //		}
+    //	},
+    //	getValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},
+    //	getType:function(uri,localName){}
+    //	getType:function(i){},
+  };
+  function B(n, a) {
+    var l, s = [], p = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
+    for (p.lastIndex = a, p.exec(n); l = p.exec(n); )
+      if (s.push(l), l[1]) return s;
+  }
+  return Ru.XMLReader = uu, Ru.ParseError = L, Ru;
+}
+var re;
+function ce() {
+  if (re) return Fu;
+  re = 1;
+  var F = _u(), N = ne(), z = se(), H = le(), U = N.DOMImplementation, g = F.NAMESPACE, x = H.ParseError, P = H.XMLReader;
+  function _(o) {
+    return o.replace(/\r[\n\u0085]/g, `
+`).replace(/[\r\u0085\u2028]/g, `
+`);
+  }
+  function y(o) {
+    this.options = o || { locator: {} };
+  }
+  y.prototype.parseFromString = function(o, C) {
+    var b = this.options, v = new P(), M = b.domBuilder || new q(), R = b.errorHandler, Q = b.locator, d = b.xmlns || {}, B = /\/x?html?$/.test(C), n = B ? z.HTML_ENTITIES : z.XML_ENTITIES;
+    Q && M.setDocumentLocator(Q), v.errorHandler = O(R, M, Q), v.domBuilder = b.domBuilder || M, B && (d[""] = g.HTML), d.xml = d.xml || g.XML;
+    var a = b.normalizeLineEndings || _;
+    return o && typeof o == "string" ? v.parse(
+      a(o),
+      d,
+      n
+    ) : v.errorHandler.error("invalid doc source"), M.doc;
+  };
+  function O(o, C, b) {
+    if (!o) {
+      if (C instanceof q)
+        return C;
+      o = C;
+    }
+    var v = {}, M = o instanceof Function;
+    b = b || {};
+    function R(Q) {
+      var d = o[Q];
+      !d && M && (d = o.length == 2 ? function(B) {
+        o(Q, B);
+      } : o), v[Q] = d && function(B) {
+        d("[xmldom " + Q + "]	" + B + uu(b));
+      } || function() {
+      };
+    }
+    return R("warning"), R("error"), R("fatalError"), v;
+  }
+  function q() {
+    this.cdata = !1;
+  }
+  function L(o, C) {
+    C.lineNumber = o.lineNumber, C.columnNumber = o.columnNumber;
+  }
+  q.prototype = {
+    startDocument: function() {
+      this.doc = new U().createDocument(null, null, null), this.locator && (this.doc.documentURI = this.locator.systemId);
+    },
+    startElement: function(o, C, b, v) {
+      var M = this.doc, R = M.createElementNS(o, b || C), Q = v.length;
+      tu(this, R), this.currentElement = R, this.locator && L(this.locator, R);
+      for (var d = 0; d < Q; d++) {
+        var o = v.getURI(d), B = v.getValue(d), b = v.getQName(d), n = M.createAttributeNS(o, b);
+        this.locator && L(v.getLocator(d), n), n.value = n.nodeValue = B, R.setAttributeNode(n);
+      }
+    },
+    endElement: function(o, C, b) {
+      var v = this.currentElement;
+      v.tagName, this.currentElement = v.parentNode;
+    },
+    startPrefixMapping: function(o, C) {
+    },
+    endPrefixMapping: function(o) {
+    },
+    processingInstruction: function(o, C) {
+      var b = this.doc.createProcessingInstruction(o, C);
+      this.locator && L(this.locator, b), tu(this, b);
+    },
+    ignorableWhitespace: function(o, C, b) {
+    },
+    characters: function(o, C, b) {
+      if (o = pu.apply(this, arguments), o) {
+        if (this.cdata)
+          var v = this.doc.createCDATASection(o);
+        else
+          var v = this.doc.createTextNode(o);
+        this.currentElement ? this.currentElement.appendChild(v) : /^\s*$/.test(o) && this.doc.appendChild(v), this.locator && L(this.locator, v);
+      }
+    },
+    skippedEntity: function(o) {
+    },
+    endDocument: function() {
+      this.doc.normalize();
+    },
+    setDocumentLocator: function(o) {
+      (this.locator = o) && (o.lineNumber = 0);
+    },
+    //LexicalHandler
+    comment: function(o, C, b) {
+      o = pu.apply(this, arguments);
+      var v = this.doc.createComment(o);
+      this.locator && L(this.locator, v), tu(this, v);
+    },
+    startCDATA: function() {
+      this.cdata = !0;
+    },
+    endCDATA: function() {
+      this.cdata = !1;
+    },
+    startDTD: function(o, C, b) {
+      var v = this.doc.implementation;
+      if (v && v.createDocumentType) {
+        var M = v.createDocumentType(o, C, b);
+        this.locator && L(this.locator, M), tu(this, M), this.doc.doctype = M;
+      }
+    },
+    /**
+     * @see org.xml.sax.ErrorHandler
+     * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
+     */
+    warning: function(o) {
+      console.warn("[xmldom warning]	" + o, uu(this.locator));
+    },
+    error: function(o) {
+      console.error("[xmldom error]	" + o, uu(this.locator));
+    },
+    fatalError: function(o) {
+      throw new x(o, this.locator);
+    }
+  };
+  function uu(o) {
+    if (o)
+      return `
+@` + (o.systemId || "") + "#[line:" + o.lineNumber + ",col:" + o.columnNumber + "]";
+  }
+  function pu(o, C, b) {
+    return typeof o == "string" ? o.substr(C, b) : o.length >= C + b || C ? new java.lang.String(o, C, b) + "" : o;
+  }
+  "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g, function(o) {
+    q.prototype[o] = function() {
+      return null;
+    };
+  });
+  function tu(o, C) {
+    o.currentElement ? o.currentElement.appendChild(C) : o.doc.appendChild(C);
+  }
+  return Fu.__DOMHandler = q, Fu.normalizeLineEndings = _, Fu.DOMParser = y, Fu;
+}
+var te;
+function pe() {
+  if (te) return Tu;
+  te = 1;
+  var F = ne();
+  return Tu.DOMImplementation = F.DOMImplementation, Tu.XMLSerializer = F.XMLSerializer, Tu.DOMParser = ce().DOMParser, Tu;
+}
+var ie = pe();
+const De = /* @__PURE__ */ ae(ie), Ae = /* @__PURE__ */ oe({
+  __proto__: null,
+  default: De
+}, [ie]);
+export {
+  Ae as i
+};