@streamlayer/react 1.23.2 → 1.24.1

package/lib/classic/es/index-ByUNFvMk.js

@@ -0,0 +1,3775 @@
+import { t as ir } from "./useStreamLayerApp2.js";
+function sr(A, S) {
+  for (var G = 0; G < S.length; G++) {
+    const X = S[G];
+    if (typeof X != "string" && !Array.isArray(X)) {
+      for (const V in X)
+        if (V !== "default" && !(V in A)) {
+          const g = Object.getOwnPropertyDescriptor(X, V);
+          g && Object.defineProperty(A, V, g.get ? g : {
+            enumerable: !0,
+            get: () => X[V]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(A, Symbol.toStringTag, { value: "Module" }));
+}
+var xe = {}, ie = {}, he = {}, Ke;
+function Ie() {
+  if (Ke) return he;
+  Ke = 1;
+  function A(g, O, H) {
+    if (H === void 0 && (H = Array.prototype), g && typeof H.find == "function")
+      return H.find.call(g, O);
+    for (var M = 0; M < g.length; M++)
+      if (Object.prototype.hasOwnProperty.call(g, M)) {
+        var q = g[M];
+        if (O.call(void 0, q, M, g))
+          return q;
+      }
+  }
+  function S(g, O) {
+    return O === void 0 && (O = Object), O && typeof O.freeze == "function" ? O.freeze(g) : g;
+  }
+  function G(g, O) {
+    if (g === null || typeof g != "object")
+      throw new TypeError("target is not an object");
+    for (var H in O)
+      Object.prototype.hasOwnProperty.call(O, H) && (g[H] = O[H]);
+    return g;
+  }
+  var X = S({
+    /**
+     * `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 === X.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"
+  }), V = S({
+    /**
+     * 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 === V.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 he.assign = G, he.find = A, he.freeze = S, he.MIME_TYPE = X, he.NAMESPACE = V, he;
+}
+var Ze;
+function ar() {
+  if (Ze) return ie;
+  Ze = 1;
+  var A = Ie(), S = A.find, G = A.NAMESPACE;
+  function X(e) {
+    return e !== "";
+  }
+  function V(e) {
+    return e ? e.split(/[\t\n\f\r ]+/).filter(X) : [];
+  }
+  function g(e, r) {
+    return e.hasOwnProperty(r) || (e[r] = !0), e;
+  }
+  function O(e) {
+    if (!e) return [];
+    var r = V(e);
+    return Object.keys(r.reduce(g, {}));
+  }
+  function H(e) {
+    return function(r) {
+      return e && e.indexOf(r) !== -1;
+    };
+  }
+  function M(e, r) {
+    for (var t in e)
+      Object.prototype.hasOwnProperty.call(e, t) && (r[t] = e[t]);
+  }
+  function q(e, r) {
+    var t = e.prototype;
+    if (!(t instanceof r)) {
+      let n = function() {
+      };
+      n.prototype = r.prototype, n = new n(), M(t, n), e.prototype = t = n;
+    }
+    t.constructor != e && (typeof e != "function" && console.error("unknown Class:" + e), t.constructor = e);
+  }
+  var k = {}, C = k.ELEMENT_NODE = 1, _ = k.ATTRIBUTE_NODE = 2, J = k.TEXT_NODE = 3, ue = k.CDATA_SECTION_NODE = 4, re = k.ENTITY_REFERENCE_NODE = 5, s = k.ENTITY_NODE = 6, N = k.PROCESSING_INSTRUCTION_NODE = 7, T = k.COMMENT_NODE = 8, y = k.DOCUMENT_NODE = 9, B = k.DOCUMENT_TYPE_NODE = 10, I = k.DOCUMENT_FRAGMENT_NODE = 11, W = k.NOTATION_NODE = 12, b = {}, D = {};
+  b.INDEX_SIZE_ERR = (D[1] = "Index size error", 1), b.DOMSTRING_SIZE_ERR = (D[2] = "DOMString size error", 2);
+  var a = b.HIERARCHY_REQUEST_ERR = (D[3] = "Hierarchy request error", 3);
+  b.WRONG_DOCUMENT_ERR = (D[4] = "Wrong document", 4), b.INVALID_CHARACTER_ERR = (D[5] = "Invalid character", 5), b.NO_DATA_ALLOWED_ERR = (D[6] = "No data allowed", 6), b.NO_MODIFICATION_ALLOWED_ERR = (D[7] = "No modification allowed", 7);
+  var i = b.NOT_FOUND_ERR = (D[8] = "Not found", 8);
+  b.NOT_SUPPORTED_ERR = (D[9] = "Not supported", 9);
+  var c = b.INUSE_ATTRIBUTE_ERR = (D[10] = "Attribute in use", 10);
+  b.INVALID_STATE_ERR = (D[11] = "Invalid state", 11), b.SYNTAX_ERR = (D[12] = "Syntax error", 12), b.INVALID_MODIFICATION_ERR = (D[13] = "Invalid modification", 13), b.NAMESPACE_ERR = (D[14] = "Invalid namespace", 14), b.INVALID_ACCESS_ERR = (D[15] = "Invalid access", 15);
+  function l(e, r) {
+    if (r instanceof Error)
+      var t = r;
+    else
+      t = this, Error.call(this, D[e]), this.message = D[e], Error.captureStackTrace && Error.captureStackTrace(this, l);
+    return t.code = e, r && (this.message = this.message + ": " + r), t;
+  }
+  l.prototype = Error.prototype, M(b, l);
+  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(e) {
+      return e >= 0 && e < this.length ? this[e] : null;
+    },
+    toString: function(e, r) {
+      for (var t = [], n = 0; n < this.length; n++)
+        Ne(this[n], t, e, r);
+      return t.join("");
+    },
+    /**
+     * @private
+     * @param {function (Node):boolean} predicate
+     * @returns {Node[]}
+     */
+    filter: function(e) {
+      return Array.prototype.filter.call(this, e);
+    },
+    /**
+     * @private
+     * @param {Node} item
+     * @returns {number}
+     */
+    indexOf: function(e) {
+      return Array.prototype.indexOf.call(this, e);
+    }
+  };
+  function v(e, r) {
+    this._node = e, this._refresh = r, m(this);
+  }
+  function m(e) {
+    var r = e._node._inc || e._node.ownerDocument._inc;
+    if (e._inc !== r) {
+      var t = e._refresh(e._node);
+      if (Qe(e, "length", t.length), !e.$$length || t.length < e.$$length)
+        for (var n = t.length; n in e; n++)
+          Object.prototype.hasOwnProperty.call(e, n) && delete e[n];
+      M(t, e), e._inc = r;
+    }
+  }
+  v.prototype.item = function(e) {
+    return m(this), this[e] || null;
+  }, q(v, p);
+  function w() {
+  }
+  function E(e, r) {
+    for (var t = e.length; t--; )
+      if (e[t] === r)
+        return t;
+  }
+  function f(e, r, t, n) {
+    if (n ? r[E(r, n)] = t : r[r.length++] = t, e) {
+      t.ownerElement = e;
+      var o = e.ownerDocument;
+      o && (n && Ee(o, e, n), z(o, e, t));
+    }
+  }
+  function h(e, r, t) {
+    var n = E(r, t);
+    if (n >= 0) {
+      for (var o = r.length - 1; n < o; )
+        r[n] = r[++n];
+      if (r.length = o, e) {
+        var d = e.ownerDocument;
+        d && (Ee(d, e, t), t.ownerElement = null);
+      }
+    } else
+      throw new l(i, new Error(e.tagName + "@" + t));
+  }
+  w.prototype = {
+    length: 0,
+    item: p.prototype.item,
+    getNamedItem: function(e) {
+      for (var r = this.length; r--; ) {
+        var t = this[r];
+        if (t.nodeName == e)
+          return t;
+      }
+    },
+    setNamedItem: function(e) {
+      var r = e.ownerElement;
+      if (r && r != this._ownerElement)
+        throw new l(c);
+      var t = this.getNamedItem(e.nodeName);
+      return f(this._ownerElement, this, e, t), t;
+    },
+    /* returns Node */
+    setNamedItemNS: function(e) {
+      var r = e.ownerElement, t;
+      if (r && r != this._ownerElement)
+        throw new l(c);
+      return t = this.getNamedItemNS(e.namespaceURI, e.localName), f(this._ownerElement, this, e, t), t;
+    },
+    /* returns Node */
+    removeNamedItem: function(e) {
+      var r = this.getNamedItem(e);
+      return h(this._ownerElement, this, r), r;
+    },
+    // raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
+    //for level2
+    removeNamedItemNS: function(e, r) {
+      var t = this.getNamedItemNS(e, r);
+      return h(this._ownerElement, this, t), t;
+    },
+    getNamedItemNS: function(e, r) {
+      for (var t = this.length; t--; ) {
+        var n = this[t];
+        if (n.localName == r && n.namespaceURI == e)
+          return n;
+      }
+      return null;
+    }
+  };
+  function U() {
+  }
+  U.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(e, r) {
+      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(e, r, t) {
+      var n = new F();
+      if (n.implementation = this, n.childNodes = new p(), n.doctype = t || null, t && n.appendChild(t), r) {
+        var o = n.createElementNS(e, r);
+        n.appendChild(o);
+      }
+      return n;
+    },
+    /**
+     * 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(e, r, t) {
+      var n = new Oe();
+      return n.name = e, n.nodeName = e, n.publicId = r || "", n.systemId = t || "", n;
+    }
+  };
+  function u() {
+  }
+  u.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(e, r) {
+      return se(this, e, r);
+    },
+    replaceChild: function(e, r) {
+      se(this, e, r, Ae), r && this.removeChild(r);
+    },
+    removeChild: function(e) {
+      return Q(this, e);
+    },
+    appendChild: function(e) {
+      return this.insertBefore(e, null);
+    },
+    hasChildNodes: function() {
+      return this.firstChild != null;
+    },
+    cloneNode: function(e) {
+      return He(this.ownerDocument || this, this, e);
+    },
+    // Modified in DOM Level 2:
+    normalize: function() {
+      for (var e = this.firstChild; e; ) {
+        var r = e.nextSibling;
+        r && r.nodeType == J && e.nodeType == J ? (this.removeChild(r), e.appendData(r.data)) : (e.normalize(), e = r);
+      }
+    },
+    // Introduced in DOM Level 2:
+    isSupported: function(e, r) {
+      return this.ownerDocument.implementation.hasFeature(e, r);
+    },
+    // 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(e) {
+      for (var r = this; r; ) {
+        var t = r._nsMap;
+        if (t) {
+          for (var n in t)
+            if (Object.prototype.hasOwnProperty.call(t, n) && t[n] === e)
+              return n;
+        }
+        r = r.nodeType == _ ? r.ownerDocument : r.parentNode;
+      }
+      return null;
+    },
+    // Introduced in DOM Level 3:
+    lookupNamespaceURI: function(e) {
+      for (var r = this; r; ) {
+        var t = r._nsMap;
+        if (t && Object.prototype.hasOwnProperty.call(t, e))
+          return t[e];
+        r = r.nodeType == _ ? r.ownerDocument : r.parentNode;
+      }
+      return null;
+    },
+    // Introduced in DOM Level 3:
+    isDefaultNamespace: function(e) {
+      var r = this.lookupPrefix(e);
+      return r == null;
+    }
+  };
+  function Y(e) {
+    return e == "<" && "&lt;" || e == ">" && "&gt;" || e == "&" && "&amp;" || e == '"' && "&quot;" || "&#" + e.charCodeAt() + ";";
+  }
+  M(k, u), M(k, u.prototype);
+  function ne(e, r) {
+    if (r(e))
+      return !0;
+    if (e = e.firstChild)
+      do
+        if (ne(e, r))
+          return !0;
+      while (e = e.nextSibling);
+  }
+  function F() {
+    this.ownerDocument = this;
+  }
+  function z(e, r, t) {
+    e && e._inc++;
+    var n = t.namespaceURI;
+    n === G.XMLNS && (r._nsMap[t.prefix ? t.localName : ""] = t.value);
+  }
+  function Ee(e, r, t, n) {
+    e && e._inc++;
+    var o = t.namespaceURI;
+    o === G.XMLNS && delete r._nsMap[t.prefix ? t.localName : ""];
+  }
+  function ge(e, r, t) {
+    if (e && e._inc) {
+      e._inc++;
+      var n = r.childNodes;
+      if (t)
+        n[n.length++] = t;
+      else {
+        for (var o = r.firstChild, d = 0; o; )
+          n[d++] = o, o = o.nextSibling;
+        n.length = d, delete n[n.length];
+      }
+    }
+  }
+  function Q(e, r) {
+    var t = r.previousSibling, n = r.nextSibling;
+    return t ? t.nextSibling = n : e.firstChild = n, n ? n.previousSibling = t : e.lastChild = t, r.parentNode = null, r.previousSibling = null, r.nextSibling = null, ge(e.ownerDocument, e), r;
+  }
+  function ee(e) {
+    return e && (e.nodeType === u.DOCUMENT_NODE || e.nodeType === u.DOCUMENT_FRAGMENT_NODE || e.nodeType === u.ELEMENT_NODE);
+  }
+  function Te(e) {
+    return e && (Z(e) || be(e) || K(e) || e.nodeType === u.DOCUMENT_FRAGMENT_NODE || e.nodeType === u.COMMENT_NODE || e.nodeType === u.PROCESSING_INSTRUCTION_NODE);
+  }
+  function K(e) {
+    return e && e.nodeType === u.DOCUMENT_TYPE_NODE;
+  }
+  function Z(e) {
+    return e && e.nodeType === u.ELEMENT_NODE;
+  }
+  function be(e) {
+    return e && e.nodeType === u.TEXT_NODE;
+  }
+  function $(e, r) {
+    var t = e.childNodes || [];
+    if (S(t, Z) || K(r))
+      return !1;
+    var n = S(t, K);
+    return !(r && n && t.indexOf(n) > t.indexOf(r));
+  }
+  function ve(e, r) {
+    var t = e.childNodes || [];
+    function n(d) {
+      return Z(d) && d !== r;
+    }
+    if (S(t, n))
+      return !1;
+    var o = S(t, K);
+    return !(r && o && t.indexOf(o) > t.indexOf(r));
+  }
+  function j(e, r, t) {
+    if (!ee(e))
+      throw new l(a, "Unexpected parent node type " + e.nodeType);
+    if (t && t.parentNode !== e)
+      throw new l(i, "child not in parent");
+    if (
+      // 4. If `node` is not a DocumentFragment, DocumentType, Element, or CharacterData node, then throw a "HierarchyRequestError" DOMException.
+      !Te(r) || // 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.
+      K(r) && e.nodeType !== u.DOCUMENT_NODE
+    )
+      throw new l(
+        a,
+        "Unexpected node type " + r.nodeType + " for parent node type " + e.nodeType
+      );
+  }
+  function Le(e, r, t) {
+    var n = e.childNodes || [], o = r.childNodes || [];
+    if (r.nodeType === u.DOCUMENT_FRAGMENT_NODE) {
+      var d = o.filter(Z);
+      if (d.length > 1 || S(o, be))
+        throw new l(a, "More than one element or text in fragment");
+      if (d.length === 1 && !$(e, t))
+        throw new l(a, "Element in fragment can not be inserted before doctype");
+    }
+    if (Z(r) && !$(e, t))
+      throw new l(a, "Only one element can be added and only after doctype");
+    if (K(r)) {
+      if (S(n, K))
+        throw new l(a, "Only one doctype is allowed");
+      var L = S(n, Z);
+      if (t && n.indexOf(L) < n.indexOf(t))
+        throw new l(a, "Doctype can only be inserted before an element");
+      if (!t && L)
+        throw new l(a, "Doctype can not be appended since element is present");
+    }
+  }
+  function Ae(e, r, t) {
+    var n = e.childNodes || [], o = r.childNodes || [];
+    if (r.nodeType === u.DOCUMENT_FRAGMENT_NODE) {
+      var d = o.filter(Z);
+      if (d.length > 1 || S(o, be))
+        throw new l(a, "More than one element or text in fragment");
+      if (d.length === 1 && !ve(e, t))
+        throw new l(a, "Element in fragment can not be inserted before doctype");
+    }
+    if (Z(r) && !ve(e, t))
+      throw new l(a, "Only one element can be added and only after doctype");
+    if (K(r)) {
+      if (S(n, function(x) {
+        return K(x) && x !== t;
+      }))
+        throw new l(a, "Only one doctype is allowed");
+      var L = S(n, Z);
+      if (t && n.indexOf(L) < n.indexOf(t))
+        throw new l(a, "Doctype can only be inserted before an element");
+    }
+  }
+  function se(e, r, t, n) {
+    j(e, r, t), e.nodeType === u.DOCUMENT_NODE && (n || Le)(e, r, t);
+    var o = r.parentNode;
+    if (o && o.removeChild(r), r.nodeType === I) {
+      var d = r.firstChild;
+      if (d == null)
+        return r;
+      var L = r.lastChild;
+    } else
+      d = L = r;
+    var x = t ? t.previousSibling : e.lastChild;
+    d.previousSibling = x, L.nextSibling = t, x ? x.nextSibling = d : e.firstChild = d, t == null ? e.lastChild = L : t.previousSibling = L;
+    do {
+      d.parentNode = e;
+      var ae = e.ownerDocument || e;
+      le(d, ae);
+    } while (d !== L && (d = d.nextSibling));
+    return ge(e.ownerDocument || e, e), r.nodeType == I && (r.firstChild = r.lastChild = null), r;
+  }
+  function le(e, r) {
+    if (e.ownerDocument !== r) {
+      if (e.ownerDocument = r, e.nodeType === C && e.attributes)
+        for (var t = 0; t < e.attributes.length; t++) {
+          var n = e.attributes.item(t);
+          n && (n.ownerDocument = r);
+        }
+      for (var o = e.firstChild; o; )
+        le(o, r), o = o.nextSibling;
+    }
+  }
+  function R(e, r) {
+    r.parentNode && r.parentNode.removeChild(r), r.parentNode = e, r.previousSibling = e.lastChild, r.nextSibling = null, r.previousSibling ? r.previousSibling.nextSibling = r : e.firstChild = r, e.lastChild = r, ge(e.ownerDocument, e, r);
+    var t = e.ownerDocument || e;
+    return le(r, t), r;
+  }
+  F.prototype = {
+    //implementation : null,
+    nodeName: "#document",
+    nodeType: y,
+    /**
+     * The DocumentType node of the document.
+     *
+     * @readonly
+     * @type DocumentType
+     */
+    doctype: null,
+    documentElement: null,
+    _inc: 1,
+    insertBefore: function(e, r) {
+      if (e.nodeType == I) {
+        for (var t = e.firstChild; t; ) {
+          var n = t.nextSibling;
+          this.insertBefore(t, r), t = n;
+        }
+        return e;
+      }
+      return se(this, e, r), le(e, this), this.documentElement === null && e.nodeType === C && (this.documentElement = e), e;
+    },
+    removeChild: function(e) {
+      return this.documentElement == e && (this.documentElement = null), Q(this, e);
+    },
+    replaceChild: function(e, r) {
+      se(this, e, r, Ae), le(e, this), r && this.removeChild(r), Z(e) && (this.documentElement = e);
+    },
+    // Introduced in DOM Level 2:
+    importNode: function(e, r) {
+      return $e(this, e, r);
+    },
+    // Introduced in DOM Level 2:
+    getElementById: function(e) {
+      var r = null;
+      return ne(this.documentElement, function(t) {
+        if (t.nodeType == C && t.getAttribute("id") == e)
+          return r = t, !0;
+      }), r;
+    },
+    /**
+     * 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(e) {
+      var r = O(e);
+      return new v(this, function(t) {
+        var n = [];
+        return r.length > 0 && ne(t.documentElement, function(o) {
+          if (o !== t && o.nodeType === C) {
+            var d = o.getAttribute("class");
+            if (d) {
+              var L = e === d;
+              if (!L) {
+                var x = O(d);
+                L = r.every(H(x));
+              }
+              L && n.push(o);
+            }
+          }
+        }), n;
+      });
+    },
+    //document factory method:
+    createElement: function(e) {
+      var r = new P();
+      r.ownerDocument = this, r.nodeName = e, r.tagName = e, r.localName = e, r.childNodes = new p();
+      var t = r.attributes = new w();
+      return t._ownerElement = r, r;
+    },
+    createDocumentFragment: function() {
+      var e = new Ce();
+      return e.ownerDocument = this, e.childNodes = new p(), e;
+    },
+    createTextNode: function(e) {
+      var r = new Me();
+      return r.ownerDocument = this, r.appendData(e), r;
+    },
+    createComment: function(e) {
+      var r = new _e();
+      return r.ownerDocument = this, r.appendData(e), r;
+    },
+    createCDATASection: function(e) {
+      var r = new Ue();
+      return r.ownerDocument = this, r.appendData(e), r;
+    },
+    createProcessingInstruction: function(e, r) {
+      var t = new Be();
+      return t.ownerDocument = this, t.tagName = t.nodeName = t.target = e, t.nodeValue = t.data = r, t;
+    },
+    createAttribute: function(e) {
+      var r = new we();
+      return r.ownerDocument = this, r.name = e, r.nodeName = e, r.localName = e, r.specified = !0, r;
+    },
+    createEntityReference: function(e) {
+      var r = new Pe();
+      return r.ownerDocument = this, r.nodeName = e, r;
+    },
+    // Introduced in DOM Level 2:
+    createElementNS: function(e, r) {
+      var t = new P(), n = r.split(":"), o = t.attributes = new w();
+      return t.childNodes = new p(), t.ownerDocument = this, t.nodeName = r, t.tagName = r, t.namespaceURI = e, n.length == 2 ? (t.prefix = n[0], t.localName = n[1]) : t.localName = r, o._ownerElement = t, t;
+    },
+    // Introduced in DOM Level 2:
+    createAttributeNS: function(e, r) {
+      var t = new we(), n = r.split(":");
+      return t.ownerDocument = this, t.nodeName = r, t.name = r, t.namespaceURI = e, t.specified = !0, n.length == 2 ? (t.prefix = n[0], t.localName = n[1]) : t.localName = r, t;
+    }
+  }, q(F, u);
+  function P() {
+    this._nsMap = {};
+  }
+  P.prototype = {
+    nodeType: C,
+    hasAttribute: function(e) {
+      return this.getAttributeNode(e) != null;
+    },
+    getAttribute: function(e) {
+      var r = this.getAttributeNode(e);
+      return r && r.value || "";
+    },
+    getAttributeNode: function(e) {
+      return this.attributes.getNamedItem(e);
+    },
+    setAttribute: function(e, r) {
+      var t = this.ownerDocument.createAttribute(e);
+      t.value = t.nodeValue = "" + r, this.setAttributeNode(t);
+    },
+    removeAttribute: function(e) {
+      var r = this.getAttributeNode(e);
+      r && this.removeAttributeNode(r);
+    },
+    //four real opeartion method
+    appendChild: function(e) {
+      return e.nodeType === I ? this.insertBefore(e, null) : R(this, e);
+    },
+    setAttributeNode: function(e) {
+      return this.attributes.setNamedItem(e);
+    },
+    setAttributeNodeNS: function(e) {
+      return this.attributes.setNamedItemNS(e);
+    },
+    removeAttributeNode: function(e) {
+      return this.attributes.removeNamedItem(e.nodeName);
+    },
+    //get real attribute name,and remove it by removeAttributeNode
+    removeAttributeNS: function(e, r) {
+      var t = this.getAttributeNodeNS(e, r);
+      t && this.removeAttributeNode(t);
+    },
+    hasAttributeNS: function(e, r) {
+      return this.getAttributeNodeNS(e, r) != null;
+    },
+    getAttributeNS: function(e, r) {
+      var t = this.getAttributeNodeNS(e, r);
+      return t && t.value || "";
+    },
+    setAttributeNS: function(e, r, t) {
+      var n = this.ownerDocument.createAttributeNS(e, r);
+      n.value = n.nodeValue = "" + t, this.setAttributeNode(n);
+    },
+    getAttributeNodeNS: function(e, r) {
+      return this.attributes.getNamedItemNS(e, r);
+    },
+    getElementsByTagName: function(e) {
+      return new v(this, function(r) {
+        var t = [];
+        return ne(r, function(n) {
+          n !== r && n.nodeType == C && (e === "*" || n.tagName == e) && t.push(n);
+        }), t;
+      });
+    },
+    getElementsByTagNameNS: function(e, r) {
+      return new v(this, function(t) {
+        var n = [];
+        return ne(t, function(o) {
+          o !== t && o.nodeType === C && (e === "*" || o.namespaceURI === e) && (r === "*" || o.localName == r) && n.push(o);
+        }), n;
+      });
+    }
+  }, F.prototype.getElementsByTagName = P.prototype.getElementsByTagName, F.prototype.getElementsByTagNameNS = P.prototype.getElementsByTagNameNS, q(P, u);
+  function we() {
+  }
+  we.prototype.nodeType = _, q(we, u);
+  function De() {
+  }
+  De.prototype = {
+    data: "",
+    substringData: function(e, r) {
+      return this.data.substring(e, e + r);
+    },
+    appendData: function(e) {
+      e = this.data + e, this.nodeValue = this.data = e, this.length = e.length;
+    },
+    insertData: function(e, r) {
+      this.replaceData(e, 0, r);
+    },
+    appendChild: function(e) {
+      throw new Error(D[a]);
+    },
+    deleteData: function(e, r) {
+      this.replaceData(e, r, "");
+    },
+    replaceData: function(e, r, t) {
+      var n = this.data.substring(0, e), o = this.data.substring(e + r);
+      t = n + t + o, this.nodeValue = this.data = t, this.length = t.length;
+    }
+  }, q(De, u);
+  function Me() {
+  }
+  Me.prototype = {
+    nodeName: "#text",
+    nodeType: J,
+    splitText: function(e) {
+      var r = this.data, t = r.substring(e);
+      r = r.substring(0, e), this.data = this.nodeValue = r, this.length = r.length;
+      var n = this.ownerDocument.createTextNode(t);
+      return this.parentNode && this.parentNode.insertBefore(n, this.nextSibling), n;
+    }
+  }, q(Me, De);
+  function _e() {
+  }
+  _e.prototype = {
+    nodeName: "#comment",
+    nodeType: T
+  }, q(_e, De);
+  function Ue() {
+  }
+  Ue.prototype = {
+    nodeName: "#cdata-section",
+    nodeType: ue
+  }, q(Ue, De);
+  function Oe() {
+  }
+  Oe.prototype.nodeType = B, q(Oe, u);
+  function Fe() {
+  }
+  Fe.prototype.nodeType = W, q(Fe, u);
+  function ze() {
+  }
+  ze.prototype.nodeType = s, q(ze, u);
+  function Pe() {
+  }
+  Pe.prototype.nodeType = re, q(Pe, u);
+  function Ce() {
+  }
+  Ce.prototype.nodeName = "#document-fragment", Ce.prototype.nodeType = I, q(Ce, u);
+  function Be() {
+  }
+  Be.prototype.nodeType = N, q(Be, u);
+  function Ge() {
+  }
+  Ge.prototype.serializeToString = function(e, r, t) {
+    return je.call(e, r, t);
+  }, u.prototype.toString = je;
+  function je(e, r) {
+    var t = [], n = this.nodeType == 9 && this.documentElement || this, o = n.prefix, d = n.namespaceURI;
+    if (d && o == null) {
+      var o = n.lookupPrefix(d);
+      if (o == null)
+        var L = [
+          { namespace: d, prefix: null }
+          //{namespace:uri,prefix:''}
+        ];
+    }
+    return Ne(this, t, e, r, L), t.join("");
+  }
+  function Xe(e, r, t) {
+    var n = e.prefix || "", o = e.namespaceURI;
+    if (!o || n === "xml" && o === G.XML || o === G.XMLNS)
+      return !1;
+    for (var d = t.length; d--; ) {
+      var L = t[d];
+      if (L.prefix === n)
+        return L.namespace !== o;
+    }
+    return !0;
+  }
+  function Ve(e, r, t) {
+    e.push(" ", r, '="', t.replace(/[<>&"\t\n\r]/g, Y), '"');
+  }
+  function Ne(e, r, t, n, o) {
+    if (o || (o = []), n)
+      if (e = n(e), e) {
+        if (typeof e == "string") {
+          r.push(e);
+          return;
+        }
+      } else
+        return;
+    switch (e.nodeType) {
+      case C:
+        var d = e.attributes, L = d.length, x = e.firstChild, ae = e.tagName;
+        t = G.isHTML(e.namespaceURI) || t;
+        var ce = ae;
+        if (!t && !e.prefix && e.namespaceURI) {
+          for (var oe, Re = 0; Re < d.length; Re++)
+            if (d.item(Re).name === "xmlns") {
+              oe = d.item(Re).value;
+              break;
+            }
+          if (!oe)
+            for (var pe = o.length - 1; pe >= 0; pe--) {
+              var de = o[pe];
+              if (de.prefix === "" && de.namespace === e.namespaceURI) {
+                oe = de.namespace;
+                break;
+              }
+            }
+          if (oe !== e.namespaceURI)
+            for (var pe = o.length - 1; pe >= 0; pe--) {
+              var de = o[pe];
+              if (de.namespace === e.namespaceURI) {
+                de.prefix && (ce = de.prefix + ":" + ae);
+                break;
+              }
+            }
+        }
+        r.push("<", ce);
+        for (var fe = 0; fe < L; fe++) {
+          var te = d.item(fe);
+          te.prefix == "xmlns" ? o.push({ prefix: te.localName, namespace: te.value }) : te.nodeName == "xmlns" && o.push({ prefix: "", namespace: te.value });
+        }
+        for (var fe = 0; fe < L; fe++) {
+          var te = d.item(fe);
+          if (Xe(te, t, o)) {
+            var me = te.prefix || "", qe = te.namespaceURI;
+            Ve(r, me ? "xmlns:" + me : "xmlns", qe), o.push({ prefix: me, namespace: qe });
+          }
+          Ne(te, r, t, n, o);
+        }
+        if (ae === ce && Xe(e, t, o)) {
+          var me = e.prefix || "", qe = e.namespaceURI;
+          Ve(r, me ? "xmlns:" + me : "xmlns", qe), o.push({ prefix: me, namespace: qe });
+        }
+        if (x || t && !/^(?:meta|link|img|br|hr|input)$/i.test(ae)) {
+          if (r.push(">"), t && /^script$/i.test(ae))
+            for (; x; )
+              x.data ? r.push(x.data) : Ne(x, r, t, n, o.slice()), x = x.nextSibling;
+          else
+            for (; x; )
+              Ne(x, r, t, n, o.slice()), x = x.nextSibling;
+          r.push("</", ce, ">");
+        } else
+          r.push("/>");
+        return;
+      case y:
+      case I:
+        for (var x = e.firstChild; x; )
+          Ne(x, r, t, n, o.slice()), x = x.nextSibling;
+        return;
+      case _:
+        return Ve(r, e.name, e.value);
+      case J:
+        return r.push(
+          e.data.replace(/[<&>]/g, Y)
+        );
+      case ue:
+        return r.push("<![CDATA[", e.data, "]]>");
+      case T:
+        return r.push("<!--", e.data, "-->");
+      case B:
+        var We = e.publicId, ye = e.systemId;
+        if (r.push("<!DOCTYPE ", e.name), We)
+          r.push(" PUBLIC ", We), ye && ye != "." && r.push(" ", ye), r.push(">");
+        else if (ye && ye != ".")
+          r.push(" SYSTEM ", ye, ">");
+        else {
+          var Ye = e.internalSubset;
+          Ye && r.push(" [", Ye, "]"), r.push(">");
+        }
+        return;
+      case N:
+        return r.push("<?", e.target, " ", e.data, "?>");
+      case re:
+        return r.push("&", e.nodeName, ";");
+      //case ENTITY_NODE:
+      //case NOTATION_NODE:
+      default:
+        r.push("??", e.nodeName);
+    }
+  }
+  function $e(e, r, t) {
+    var n;
+    switch (r.nodeType) {
+      case C:
+        n = r.cloneNode(!1), n.ownerDocument = e;
+      //var attrs = node2.attributes;
+      //var len = attrs.length;
+      //for(var i=0;i<len;i++){
+      //node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
+      //}
+      case I:
+        break;
+      case _:
+        t = !0;
+        break;
+    }
+    if (n || (n = r.cloneNode(!1)), n.ownerDocument = e, n.parentNode = null, t)
+      for (var o = r.firstChild; o; )
+        n.appendChild($e(e, o, t)), o = o.nextSibling;
+    return n;
+  }
+  function He(e, r, t) {
+    var n = new r.constructor();
+    for (var o in r)
+      if (Object.prototype.hasOwnProperty.call(r, o)) {
+        var d = r[o];
+        typeof d != "object" && d != n[o] && (n[o] = d);
+      }
+    switch (r.childNodes && (n.childNodes = new p()), n.ownerDocument = e, n.nodeType) {
+      case C:
+        var L = r.attributes, x = n.attributes = new w(), ae = L.length;
+        x._ownerElement = n;
+        for (var ce = 0; ce < ae; ce++)
+          n.setAttributeNode(He(e, L.item(ce), !0));
+        break;
+      case _:
+        t = !0;
+    }
+    if (t)
+      for (var oe = r.firstChild; oe; )
+        n.appendChild(He(e, oe, t)), oe = oe.nextSibling;
+    return n;
+  }
+  function Qe(e, r, t) {
+    e[r] = t;
+  }
+  try {
+    if (Object.defineProperty) {
+      let e = function(r) {
+        switch (r.nodeType) {
+          case C:
+          case I:
+            var t = [];
+            for (r = r.firstChild; r; )
+              r.nodeType !== 7 && r.nodeType !== 8 && t.push(e(r)), r = r.nextSibling;
+            return t.join("");
+          default:
+            return r.nodeValue;
+        }
+      };
+      Object.defineProperty(v.prototype, "length", {
+        get: function() {
+          return m(this), this.$$length;
+        }
+      }), Object.defineProperty(u.prototype, "textContent", {
+        get: function() {
+          return e(this);
+        },
+        set: function(r) {
+          switch (this.nodeType) {
+            case C:
+            case I:
+              for (; this.firstChild; )
+                this.removeChild(this.firstChild);
+              (r || String(r)) && this.appendChild(this.ownerDocument.createTextNode(r));
+              break;
+            default:
+              this.data = r, this.value = r, this.nodeValue = r;
+          }
+        }
+      }), Qe = function(r, t, n) {
+        r["$$" + t] = n;
+      };
+    }
+  } catch {
+  }
+  return ie.DocumentType = Oe, ie.DOMException = l, ie.DOMImplementation = U, ie.Element = P, ie.Node = u, ie.NodeList = p, ie.XMLSerializer = Ge, ie;
+}
+var Se = {}, Je = {}, er;
+function lr() {
+  return er || (er = 1, (function(A) {
+    var S = Ie().freeze;
+    A.XML_ENTITIES = S({
+      amp: "&",
+      apos: "'",
+      gt: ">",
+      lt: "<",
+      quot: '"'
+    }), A.HTML_ENTITIES = S({
+      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: "‌"
+    }), A.entityMap = A.HTML_ENTITIES;
+  })(Je)), Je;
+}
+var ke = {}, rr;
+function cr() {
+  if (rr) return ke;
+  rr = 1;
+  var A = Ie().NAMESPACE, S = /[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]/, G = new RegExp("[\\-\\.0-9" + S.source.slice(1, -1) + "\\u00B7\\u0300-\\u036F\\u203F-\\u2040]"), X = new RegExp("^" + S.source + G.source + "*(?::" + S.source + G.source + "*)?$"), V = 0, g = 1, O = 2, H = 3, M = 4, q = 5, k = 6, C = 7;
+  function _(a, i) {
+    this.message = a, this.locator = i, Error.captureStackTrace && Error.captureStackTrace(this, _);
+  }
+  _.prototype = new Error(), _.prototype.name = _.name;
+  function J() {
+  }
+  J.prototype = {
+    parse: function(a, i, c) {
+      var l = this.domBuilder;
+      l.startDocument(), B(i, i = {}), ue(
+        a,
+        i,
+        c,
+        l,
+        this.errorHandler
+      ), l.endDocument();
+    }
+  };
+  function ue(a, i, c, l, p) {
+    function v(R) {
+      if (R > 65535) {
+        R -= 65536;
+        var P = 55296 + (R >> 10), we = 56320 + (R & 1023);
+        return String.fromCharCode(P, we);
+      } else
+        return String.fromCharCode(R);
+    }
+    function m(R) {
+      var P = R.slice(1, -1);
+      return Object.hasOwnProperty.call(c, P) ? c[P] : P.charAt(0) === "#" ? v(parseInt(P.substr(1).replace("x", "0x"))) : (p.error("entity not found:" + R), R);
+    }
+    function w(R) {
+      if (R > F) {
+        var P = a.substring(F, R).replace(/&#?\w+;/g, m);
+        u && E(F), l.characters(P, 0, R - F), F = R;
+      }
+    }
+    function E(R, P) {
+      for (; R >= h && (P = U.exec(a)); )
+        f = P.index, h = f + P[0].length, u.lineNumber++;
+      u.columnNumber = R - f + 1;
+    }
+    for (var f = 0, h = 0, U = /.*(?:\r\n?|\n)|.*$/g, u = l.locator, Y = [{ currentNSMap: i }], ne = {}, F = 0; ; ) {
+      try {
+        var z = a.indexOf("<", F);
+        if (z < 0) {
+          if (!a.substr(F).match(/^\s*$/)) {
+            var Ee = l.doc, ge = Ee.createTextNode(a.substr(F));
+            Ee.appendChild(ge), l.currentElement = ge;
+          }
+          return;
+        }
+        switch (z > F && w(z), a.charAt(z + 1)) {
+          case "/":
+            var j = a.indexOf(">", z + 3), Q = a.substring(z + 2, j).replace(/[ \t\n\r]+$/g, ""), ee = Y.pop();
+            j < 0 ? (Q = a.substring(z + 2).replace(/[\s<].*/, ""), p.error("end tag name: " + Q + " is not complete:" + ee.tagName), j = z + 1 + Q.length) : Q.match(/\s</) && (Q = Q.replace(/[\s<].*/, ""), p.error("end tag name: " + Q + " maybe not complete"), j = z + 1 + Q.length);
+            var Te = ee.localNSMap, K = ee.tagName == Q, Z = K || ee.tagName && ee.tagName.toLowerCase() == Q.toLowerCase();
+            if (Z) {
+              if (l.endElement(ee.uri, ee.localName, Q), Te)
+                for (var be in Te)
+                  Object.prototype.hasOwnProperty.call(Te, be) && l.endPrefixMapping(be);
+              K || p.fatalError("end tag name: " + Q + " is not match the current start tagName:" + ee.tagName);
+            } else
+              Y.push(ee);
+            j++;
+            break;
+          // end elment
+          case "?":
+            u && E(z), j = W(a, z, l);
+            break;
+          case "!":
+            u && E(z), j = I(a, z, l, p);
+            break;
+          default:
+            u && E(z);
+            var $ = new b(), ve = Y[Y.length - 1].currentNSMap, j = s(a, z, $, ve, m, p), Le = $.length;
+            if (!$.closed && y(a, j, $.tagName, ne) && ($.closed = !0, c.nbsp || p.warning("unclosed xml attribute")), u && Le) {
+              for (var Ae = re(u, {}), se = 0; se < Le; se++) {
+                var le = $[se];
+                E(le.offset), le.locator = re(u, {});
+              }
+              l.locator = Ae, N($, l, ve) && Y.push($), l.locator = u;
+            } else
+              N($, l, ve) && Y.push($);
+            A.isHTML($.uri) && !$.closed ? j = T(a, j, $.tagName, m, l) : j++;
+        }
+      } catch (R) {
+        if (R instanceof _)
+          throw R;
+        p.error("element parse error: " + R), j = -1;
+      }
+      j > F ? F = j : w(Math.max(z, F) + 1);
+    }
+  }
+  function re(a, i) {
+    return i.lineNumber = a.lineNumber, i.columnNumber = a.columnNumber, i;
+  }
+  function s(a, i, c, l, p, v) {
+    function m(u, Y, ne) {
+      c.attributeNames.hasOwnProperty(u) && v.fatalError("Attribute " + u + " redefined"), c.addValue(
+        u,
+        // @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
+        Y.replace(/[\t\n\r]/g, " ").replace(/&#?\w+;/g, p),
+        ne
+      );
+    }
+    for (var w, E, f = ++i, h = V; ; ) {
+      var U = a.charAt(f);
+      switch (U) {
+        case "=":
+          if (h === g)
+            w = a.slice(i, f), h = H;
+          else if (h === O)
+            h = H;
+          else
+            throw new Error("attribute equal must after attrName");
+          break;
+        case "'":
+        case '"':
+          if (h === H || h === g)
+            if (h === g && (v.warning('attribute value must after "="'), w = a.slice(i, f)), i = f + 1, f = a.indexOf(U, i), f > 0)
+              E = a.slice(i, f), m(w, E, i - 1), h = q;
+            else
+              throw new Error("attribute value no end '" + U + "' match");
+          else if (h == M)
+            E = a.slice(i, f), m(w, E, i), v.warning('attribute "' + w + '" missed start quot(' + U + ")!!"), i = f + 1, h = q;
+          else
+            throw new Error('attribute value must after "="');
+          break;
+        case "/":
+          switch (h) {
+            case V:
+              c.setTagName(a.slice(i, f));
+            case q:
+            case k:
+            case C:
+              h = C, c.closed = !0;
+            case M:
+            case g:
+              break;
+            case O:
+              c.closed = !0;
+              break;
+            //case S_EQ:
+            default:
+              throw new Error("attribute invalid close char('/')");
+          }
+          break;
+        case "":
+          return v.error("unexpected end of input"), h == V && c.setTagName(a.slice(i, f)), f;
+        case ">":
+          switch (h) {
+            case V:
+              c.setTagName(a.slice(i, f));
+            case q:
+            case k:
+            case C:
+              break;
+            //normal
+            case M:
+            //Compatible state
+            case g:
+              E = a.slice(i, f), E.slice(-1) === "/" && (c.closed = !0, E = E.slice(0, -1));
+            case O:
+              h === O && (E = w), h == M ? (v.warning('attribute "' + E + '" missed quot(")!'), m(w, E, i)) : ((!A.isHTML(l[""]) || !E.match(/^(?:disabled|checked|selected)$/i)) && v.warning('attribute "' + E + '" missed value!! "' + E + '" instead!!'), m(E, E, i));
+              break;
+            case H:
+              throw new Error("attribute value missed!!");
+          }
+          return f;
+        /*xml space '\x20' | #x9 | #xD | #xA; */
+        case "€":
+          U = " ";
+        default:
+          if (U <= " ")
+            switch (h) {
+              case V:
+                c.setTagName(a.slice(i, f)), h = k;
+                break;
+              case g:
+                w = a.slice(i, f), h = O;
+                break;
+              case M:
+                var E = a.slice(i, f);
+                v.warning('attribute "' + E + '" missed quot(")!!'), m(w, E, i);
+              case q:
+                h = k;
+                break;
+            }
+          else
+            switch (h) {
+              //case S_TAG:void();break;
+              //case S_ATTR:void();break;
+              //case S_ATTR_NOQUOT_VALUE:void();break;
+              case O:
+                c.tagName, (!A.isHTML(l[""]) || !w.match(/^(?:disabled|checked|selected)$/i)) && v.warning('attribute "' + w + '" missed value!! "' + w + '" instead2!!'), m(w, w, i), i = f, h = g;
+                break;
+              case q:
+                v.warning('attribute space is required"' + w + '"!!');
+              case k:
+                h = g, i = f;
+                break;
+              case H:
+                h = M, i = f;
+                break;
+              case C:
+                throw new Error("elements closed character '/' and '>' must be connected to");
+            }
+      }
+      f++;
+    }
+  }
+  function N(a, i, c) {
+    for (var l = a.tagName, p = null, v = a.length; v--; ) {
+      var m = a[v], w = m.qName, E = m.value, u = w.indexOf(":");
+      if (u > 0)
+        var f = m.prefix = w.slice(0, u), h = w.slice(u + 1), U = f === "xmlns" && h;
+      else
+        h = w, f = null, U = w === "xmlns" && "";
+      m.localName = h, U !== !1 && (p == null && (p = {}, B(c, c = {})), c[U] = p[U] = E, m.uri = A.XMLNS, i.startPrefixMapping(U, E));
+    }
+    for (var v = a.length; v--; ) {
+      m = a[v];
+      var f = m.prefix;
+      f && (f === "xml" && (m.uri = A.XML), f !== "xmlns" && (m.uri = c[f || ""]));
+    }
+    var u = l.indexOf(":");
+    u > 0 ? (f = a.prefix = l.slice(0, u), h = a.localName = l.slice(u + 1)) : (f = null, h = a.localName = l);
+    var Y = a.uri = c[f || ""];
+    if (i.startElement(Y, h, l, a), a.closed) {
+      if (i.endElement(Y, h, l), p)
+        for (f in p)
+          Object.prototype.hasOwnProperty.call(p, f) && i.endPrefixMapping(f);
+    } else
+      return a.currentNSMap = c, a.localNSMap = p, !0;
+  }
+  function T(a, i, c, l, p) {
+    if (/^(?:script|textarea)$/i.test(c)) {
+      var v = a.indexOf("</" + c + ">", i), m = a.substring(i + 1, v);
+      if (/[&<]/.test(m))
+        return /^script$/i.test(c) ? (p.characters(m, 0, m.length), v) : (m = m.replace(/&#?\w+;/g, l), p.characters(m, 0, m.length), v);
+    }
+    return i + 1;
+  }
+  function y(a, i, c, l) {
+    var p = l[c];
+    return p == null && (p = a.lastIndexOf("</" + c + ">"), p < i && (p = a.lastIndexOf("</" + c)), l[c] = p), p < i;
+  }
+  function B(a, i) {
+    for (var c in a)
+      Object.prototype.hasOwnProperty.call(a, c) && (i[c] = a[c]);
+  }
+  function I(a, i, c, l) {
+    var p = a.charAt(i + 2);
+    switch (p) {
+      case "-":
+        if (a.charAt(i + 3) === "-") {
+          var v = a.indexOf("-->", i + 4);
+          return v > i ? (c.comment(a, i + 4, v - i - 4), v + 3) : (l.error("Unclosed comment"), -1);
+        } else
+          return -1;
+      default:
+        if (a.substr(i + 3, 6) == "CDATA[") {
+          var v = a.indexOf("]]>", i + 9);
+          return c.startCDATA(), c.characters(a, i + 9, v - i - 9), c.endCDATA(), v + 3;
+        }
+        var m = D(a, i), w = m.length;
+        if (w > 1 && /!doctype/i.test(m[0][0])) {
+          var E = m[1][0], f = !1, h = !1;
+          w > 3 && (/^public$/i.test(m[2][0]) ? (f = m[3][0], h = w > 4 && m[4][0]) : /^system$/i.test(m[2][0]) && (h = m[3][0]));
+          var U = m[w - 1];
+          return c.startDTD(E, f, h), c.endDTD(), U.index + U[0].length;
+        }
+    }
+    return -1;
+  }
+  function W(a, i, c) {
+    var l = a.indexOf("?>", i);
+    if (l) {
+      var p = a.substring(i, l).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
+      return p ? (p[0].length, c.processingInstruction(p[1], p[2]), l + 2) : -1;
+    }
+    return -1;
+  }
+  function b() {
+    this.attributeNames = {};
+  }
+  b.prototype = {
+    setTagName: function(a) {
+      if (!X.test(a))
+        throw new Error("invalid tagName:" + a);
+      this.tagName = a;
+    },
+    addValue: function(a, i, c) {
+      if (!X.test(a))
+        throw new Error("invalid attribute:" + a);
+      this.attributeNames[a] = this.length, this[this.length++] = { qName: a, value: i, offset: c };
+    },
+    length: 0,
+    getLocalName: function(a) {
+      return this[a].localName;
+    },
+    getLocator: function(a) {
+      return this[a].locator;
+    },
+    getQName: function(a) {
+      return this[a].qName;
+    },
+    getURI: function(a) {
+      return this[a].uri;
+    },
+    getValue: function(a) {
+      return this[a].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 D(a, i) {
+    var c, l = [], p = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
+    for (p.lastIndex = i, p.exec(a); c = p.exec(a); )
+      if (l.push(c), c[1]) return l;
+  }
+  return ke.XMLReader = J, ke.ParseError = _, ke;
+}
+var tr;
+function ur() {
+  if (tr) return Se;
+  tr = 1;
+  var A = Ie(), S = ar(), G = lr(), X = cr(), V = S.DOMImplementation, g = A.NAMESPACE, O = X.ParseError, H = X.XMLReader;
+  function M(s) {
+    return s.replace(/\r[\n\u0085]/g, `
+`).replace(/[\r\u0085\u2028]/g, `
+`);
+  }
+  function q(s) {
+    this.options = s || { locator: {} };
+  }
+  q.prototype.parseFromString = function(s, N) {
+    var T = this.options, y = new H(), B = T.domBuilder || new C(), I = T.errorHandler, W = T.locator, b = T.xmlns || {}, D = /\/x?html?$/.test(N), a = D ? G.HTML_ENTITIES : G.XML_ENTITIES;
+    W && B.setDocumentLocator(W), y.errorHandler = k(I, B, W), y.domBuilder = T.domBuilder || B, D && (b[""] = g.HTML), b.xml = b.xml || g.XML;
+    var i = T.normalizeLineEndings || M;
+    return s && typeof s == "string" ? y.parse(
+      i(s),
+      b,
+      a
+    ) : y.errorHandler.error("invalid doc source"), B.doc;
+  };
+  function k(s, N, T) {
+    if (!s) {
+      if (N instanceof C)
+        return N;
+      s = N;
+    }
+    var y = {}, B = s instanceof Function;
+    T = T || {};
+    function I(W) {
+      var b = s[W];
+      !b && B && (b = s.length == 2 ? function(D) {
+        s(W, D);
+      } : s), y[W] = b && function(D) {
+        b("[xmldom " + W + "]	" + D + J(T));
+      } || function() {
+      };
+    }
+    return I("warning"), I("error"), I("fatalError"), y;
+  }
+  function C() {
+    this.cdata = !1;
+  }
+  function _(s, N) {
+    N.lineNumber = s.lineNumber, N.columnNumber = s.columnNumber;
+  }
+  C.prototype = {
+    startDocument: function() {
+      this.doc = new V().createDocument(null, null, null), this.locator && (this.doc.documentURI = this.locator.systemId);
+    },
+    startElement: function(s, N, T, y) {
+      var B = this.doc, I = B.createElementNS(s, T || N), W = y.length;
+      re(this, I), this.currentElement = I, this.locator && _(this.locator, I);
+      for (var b = 0; b < W; b++) {
+        var s = y.getURI(b), D = y.getValue(b), T = y.getQName(b), a = B.createAttributeNS(s, T);
+        this.locator && _(y.getLocator(b), a), a.value = a.nodeValue = D, I.setAttributeNode(a);
+      }
+    },
+    endElement: function(s, N, T) {
+      var y = this.currentElement;
+      y.tagName, this.currentElement = y.parentNode;
+    },
+    startPrefixMapping: function(s, N) {
+    },
+    endPrefixMapping: function(s) {
+    },
+    processingInstruction: function(s, N) {
+      var T = this.doc.createProcessingInstruction(s, N);
+      this.locator && _(this.locator, T), re(this, T);
+    },
+    ignorableWhitespace: function(s, N, T) {
+    },
+    characters: function(s, N, T) {
+      if (s = ue.apply(this, arguments), s) {
+        if (this.cdata)
+          var y = this.doc.createCDATASection(s);
+        else
+          var y = this.doc.createTextNode(s);
+        this.currentElement ? this.currentElement.appendChild(y) : /^\s*$/.test(s) && this.doc.appendChild(y), this.locator && _(this.locator, y);
+      }
+    },
+    skippedEntity: function(s) {
+    },
+    endDocument: function() {
+      this.doc.normalize();
+    },
+    setDocumentLocator: function(s) {
+      (this.locator = s) && (s.lineNumber = 0);
+    },
+    //LexicalHandler
+    comment: function(s, N, T) {
+      s = ue.apply(this, arguments);
+      var y = this.doc.createComment(s);
+      this.locator && _(this.locator, y), re(this, y);
+    },
+    startCDATA: function() {
+      this.cdata = !0;
+    },
+    endCDATA: function() {
+      this.cdata = !1;
+    },
+    startDTD: function(s, N, T) {
+      var y = this.doc.implementation;
+      if (y && y.createDocumentType) {
+        var B = y.createDocumentType(s, N, T);
+        this.locator && _(this.locator, B), re(this, B), this.doc.doctype = B;
+      }
+    },
+    /**
+     * @see org.xml.sax.ErrorHandler
+     * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
+     */
+    warning: function(s) {
+      console.warn("[xmldom warning]	" + s, J(this.locator));
+    },
+    error: function(s) {
+      console.error("[xmldom error]	" + s, J(this.locator));
+    },
+    fatalError: function(s) {
+      throw new O(s, this.locator);
+    }
+  };
+  function J(s) {
+    if (s)
+      return `
+@` + (s.systemId || "") + "#[line:" + s.lineNumber + ",col:" + s.columnNumber + "]";
+  }
+  function ue(s, N, T) {
+    return typeof s == "string" ? s.substr(N, T) : s.length >= N + T || N ? new java.lang.String(s, N, T) + "" : s;
+  }
+  "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g, function(s) {
+    C.prototype[s] = function() {
+      return null;
+    };
+  });
+  function re(s, N) {
+    s.currentElement ? s.currentElement.appendChild(N) : s.doc.appendChild(N);
+  }
+  return Se.__DOMHandler = C, Se.normalizeLineEndings = M, Se.DOMParser = q, Se;
+}
+var nr;
+function pr() {
+  if (nr) return xe;
+  nr = 1;
+  var A = ar();
+  return xe.DOMImplementation = A.DOMImplementation, xe.XMLSerializer = A.XMLSerializer, xe.DOMParser = ur().DOMParser, xe;
+}
+var or = pr();
+const dr = /* @__PURE__ */ ir(or), mr = /* @__PURE__ */ sr({
+  __proto__: null,
+  default: dr
+}, [or]);
+export {
+  mr as i
+};