@loaders.gl/polyfills 3.1.0-alpha.2 → 3.1.0-beta.1

package/dist/bundle.js

@@ -1,7 +1,3994 @@
-const moduleExports = require('./index');
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
+  };
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __reExport = (target, module, desc) => {
+    if (module && typeof module === "object" || typeof module === "function") {
+      for (let key of __getOwnPropNames(module))
+        if (!__hasOwnProp.call(target, key) && key !== "default")
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+    }
+    return target;
+  };
+  var __toModule = (module) => {
+    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  };
 
-const _global = typeof window === 'undefined' ? global : window;
+  // ../../node_modules/@xmldom/xmldom/lib/conventions.js
+  var require_conventions = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/conventions.js"(exports) {
+      "use strict";
+      function freeze(object, oc) {
+        if (oc === void 0) {
+          oc = Object;
+        }
+        return oc && typeof oc.freeze === "function" ? oc.freeze(object) : object;
+      }
+      var MIME_TYPE = freeze({
+        HTML: "text/html",
+        isHTML: function(value) {
+          return value === MIME_TYPE.HTML;
+        },
+        XML_APPLICATION: "application/xml",
+        XML_TEXT: "text/xml",
+        XML_XHTML_APPLICATION: "application/xhtml+xml",
+        XML_SVG_IMAGE: "image/svg+xml"
+      });
+      var NAMESPACE = freeze({
+        HTML: "http://www.w3.org/1999/xhtml",
+        isHTML: function(uri) {
+          return uri === NAMESPACE.HTML;
+        },
+        SVG: "http://www.w3.org/2000/svg",
+        XML: "http://www.w3.org/XML/1998/namespace",
+        XMLNS: "http://www.w3.org/2000/xmlns/"
+      });
+      exports.freeze = freeze;
+      exports.MIME_TYPE = MIME_TYPE;
+      exports.NAMESPACE = NAMESPACE;
+    }
+  });
 
-_global.loaders = _global.loaders || {};
-module.exports = Object.assign(_global.loaders, moduleExports);
-//# sourceMappingURL=bundle.js.map
+  // ../../node_modules/@xmldom/xmldom/lib/dom.js
+  var require_dom = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/dom.js"(exports) {
+      var conventions = require_conventions();
+      var NAMESPACE = conventions.NAMESPACE;
+      function notEmptyString(input) {
+        return input !== "";
+      }
+      function splitOnASCIIWhitespace(input) {
+        return input ? input.split(/[\t\n\f\r ]+/).filter(notEmptyString) : [];
+      }
+      function orderedSetReducer(current, element) {
+        if (!current.hasOwnProperty(element)) {
+          current[element] = true;
+        }
+        return current;
+      }
+      function toOrderedSet(input) {
+        if (!input)
+          return [];
+        var list = splitOnASCIIWhitespace(input);
+        return Object.keys(list.reduce(orderedSetReducer, {}));
+      }
+      function arrayIncludes(list) {
+        return function(element) {
+          return list && list.indexOf(element) !== -1;
+        };
+      }
+      function copy(src, dest) {
+        for (var p in src) {
+          dest[p] = src[p];
+        }
+      }
+      function _extends(Class, Super) {
+        var pt = Class.prototype;
+        if (!(pt instanceof Super)) {
+          let t2 = function() {
+          };
+          var t = t2;
+          ;
+          t2.prototype = Super.prototype;
+          t2 = new t2();
+          copy(pt, t2);
+          Class.prototype = pt = t2;
+        }
+        if (pt.constructor != Class) {
+          if (typeof Class != "function") {
+            console.error("unknown Class:" + Class);
+          }
+          pt.constructor = Class;
+        }
+      }
+      var NodeType = {};
+      var ELEMENT_NODE = NodeType.ELEMENT_NODE = 1;
+      var ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE = 2;
+      var TEXT_NODE = NodeType.TEXT_NODE = 3;
+      var CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE = 4;
+      var ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE = 5;
+      var ENTITY_NODE = NodeType.ENTITY_NODE = 6;
+      var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;
+      var COMMENT_NODE = NodeType.COMMENT_NODE = 8;
+      var DOCUMENT_NODE = NodeType.DOCUMENT_NODE = 9;
+      var DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE = 10;
+      var DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE = 11;
+      var NOTATION_NODE = NodeType.NOTATION_NODE = 12;
+      var ExceptionCode = {};
+      var ExceptionMessage = {};
+      var INDEX_SIZE_ERR = ExceptionCode.INDEX_SIZE_ERR = (ExceptionMessage[1] = "Index size error", 1);
+      var DOMSTRING_SIZE_ERR = ExceptionCode.DOMSTRING_SIZE_ERR = (ExceptionMessage[2] = "DOMString size error", 2);
+      var HIERARCHY_REQUEST_ERR = ExceptionCode.HIERARCHY_REQUEST_ERR = (ExceptionMessage[3] = "Hierarchy request error", 3);
+      var WRONG_DOCUMENT_ERR = ExceptionCode.WRONG_DOCUMENT_ERR = (ExceptionMessage[4] = "Wrong document", 4);
+      var INVALID_CHARACTER_ERR = ExceptionCode.INVALID_CHARACTER_ERR = (ExceptionMessage[5] = "Invalid character", 5);
+      var NO_DATA_ALLOWED_ERR = ExceptionCode.NO_DATA_ALLOWED_ERR = (ExceptionMessage[6] = "No data allowed", 6);
+      var NO_MODIFICATION_ALLOWED_ERR = ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = (ExceptionMessage[7] = "No modification allowed", 7);
+      var NOT_FOUND_ERR = ExceptionCode.NOT_FOUND_ERR = (ExceptionMessage[8] = "Not found", 8);
+      var NOT_SUPPORTED_ERR = ExceptionCode.NOT_SUPPORTED_ERR = (ExceptionMessage[9] = "Not supported", 9);
+      var INUSE_ATTRIBUTE_ERR = ExceptionCode.INUSE_ATTRIBUTE_ERR = (ExceptionMessage[10] = "Attribute in use", 10);
+      var INVALID_STATE_ERR = ExceptionCode.INVALID_STATE_ERR = (ExceptionMessage[11] = "Invalid state", 11);
+      var SYNTAX_ERR = ExceptionCode.SYNTAX_ERR = (ExceptionMessage[12] = "Syntax error", 12);
+      var INVALID_MODIFICATION_ERR = ExceptionCode.INVALID_MODIFICATION_ERR = (ExceptionMessage[13] = "Invalid modification", 13);
+      var NAMESPACE_ERR = ExceptionCode.NAMESPACE_ERR = (ExceptionMessage[14] = "Invalid namespace", 14);
+      var INVALID_ACCESS_ERR = ExceptionCode.INVALID_ACCESS_ERR = (ExceptionMessage[15] = "Invalid access", 15);
+      function DOMException(code, message) {
+        if (message instanceof Error) {
+          var error = message;
+        } else {
+          error = this;
+          Error.call(this, ExceptionMessage[code]);
+          this.message = ExceptionMessage[code];
+          if (Error.captureStackTrace)
+            Error.captureStackTrace(this, DOMException);
+        }
+        error.code = code;
+        if (message)
+          this.message = this.message + ": " + message;
+        return error;
+      }
+      DOMException.prototype = Error.prototype;
+      copy(ExceptionCode, DOMException);
+      function NodeList() {
+      }
+      NodeList.prototype = {
+        length: 0,
+        item: function(index2) {
+          return this[index2] || null;
+        },
+        toString: function(isHTML, nodeFilter) {
+          for (var buf = [], i = 0; i < this.length; i++) {
+            serializeToString(this[i], buf, isHTML, nodeFilter);
+          }
+          return buf.join("");
+        }
+      };
+      function LiveNodeList(node, refresh) {
+        this._node = node;
+        this._refresh = refresh;
+        _updateLiveList(this);
+      }
+      function _updateLiveList(list) {
+        var inc = list._node._inc || list._node.ownerDocument._inc;
+        if (list._inc != inc) {
+          var ls = list._refresh(list._node);
+          __set__(list, "length", ls.length);
+          copy(ls, list);
+          list._inc = inc;
+        }
+      }
+      LiveNodeList.prototype.item = function(i) {
+        _updateLiveList(this);
+        return this[i];
+      };
+      _extends(LiveNodeList, NodeList);
+      function NamedNodeMap() {
+      }
+      function _findNodeIndex(list, node) {
+        var i = list.length;
+        while (i--) {
+          if (list[i] === node) {
+            return i;
+          }
+        }
+      }
+      function _addNamedNode(el, list, newAttr, oldAttr) {
+        if (oldAttr) {
+          list[_findNodeIndex(list, oldAttr)] = newAttr;
+        } else {
+          list[list.length++] = newAttr;
+        }
+        if (el) {
+          newAttr.ownerElement = el;
+          var doc = el.ownerDocument;
+          if (doc) {
+            oldAttr && _onRemoveAttribute(doc, el, oldAttr);
+            _onAddAttribute(doc, el, newAttr);
+          }
+        }
+      }
+      function _removeNamedNode(el, list, attr) {
+        var i = _findNodeIndex(list, attr);
+        if (i >= 0) {
+          var lastIndex = list.length - 1;
+          while (i < lastIndex) {
+            list[i] = list[++i];
+          }
+          list.length = lastIndex;
+          if (el) {
+            var doc = el.ownerDocument;
+            if (doc) {
+              _onRemoveAttribute(doc, el, attr);
+              attr.ownerElement = null;
+            }
+          }
+        } else {
+          throw DOMException(NOT_FOUND_ERR, new Error(el.tagName + "@" + attr));
+        }
+      }
+      NamedNodeMap.prototype = {
+        length: 0,
+        item: NodeList.prototype.item,
+        getNamedItem: function(key) {
+          var i = this.length;
+          while (i--) {
+            var attr = this[i];
+            if (attr.nodeName == key) {
+              return attr;
+            }
+          }
+        },
+        setNamedItem: function(attr) {
+          var el = attr.ownerElement;
+          if (el && el != this._ownerElement) {
+            throw new DOMException(INUSE_ATTRIBUTE_ERR);
+          }
+          var oldAttr = this.getNamedItem(attr.nodeName);
+          _addNamedNode(this._ownerElement, this, attr, oldAttr);
+          return oldAttr;
+        },
+        setNamedItemNS: function(attr) {
+          var el = attr.ownerElement, oldAttr;
+          if (el && el != this._ownerElement) {
+            throw new DOMException(INUSE_ATTRIBUTE_ERR);
+          }
+          oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);
+          _addNamedNode(this._ownerElement, this, attr, oldAttr);
+          return oldAttr;
+        },
+        removeNamedItem: function(key) {
+          var attr = this.getNamedItem(key);
+          _removeNamedNode(this._ownerElement, this, attr);
+          return attr;
+        },
+        removeNamedItemNS: function(namespaceURI, localName) {
+          var attr = this.getNamedItemNS(namespaceURI, localName);
+          _removeNamedNode(this._ownerElement, this, attr);
+          return attr;
+        },
+        getNamedItemNS: function(namespaceURI, localName) {
+          var i = this.length;
+          while (i--) {
+            var node = this[i];
+            if (node.localName == localName && node.namespaceURI == namespaceURI) {
+              return node;
+            }
+          }
+          return null;
+        }
+      };
+      function DOMImplementation() {
+      }
+      DOMImplementation.prototype = {
+        hasFeature: function(feature, version) {
+          return true;
+        },
+        createDocument: function(namespaceURI, qualifiedName, doctype) {
+          var doc = new Document();
+          doc.implementation = this;
+          doc.childNodes = new NodeList();
+          doc.doctype = doctype || null;
+          if (doctype) {
+            doc.appendChild(doctype);
+          }
+          if (qualifiedName) {
+            var root = doc.createElementNS(namespaceURI, qualifiedName);
+            doc.appendChild(root);
+          }
+          return doc;
+        },
+        createDocumentType: function(qualifiedName, publicId, systemId) {
+          var node = new DocumentType();
+          node.name = qualifiedName;
+          node.nodeName = qualifiedName;
+          node.publicId = publicId || "";
+          node.systemId = systemId || "";
+          return node;
+        }
+      };
+      function Node() {
+      }
+      Node.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,
+        insertBefore: function(newChild, refChild) {
+          return _insertBefore(this, newChild, refChild);
+        },
+        replaceChild: function(newChild, oldChild) {
+          this.insertBefore(newChild, oldChild);
+          if (oldChild) {
+            this.removeChild(oldChild);
+          }
+        },
+        removeChild: function(oldChild) {
+          return _removeChild(this, oldChild);
+        },
+        appendChild: function(newChild) {
+          return this.insertBefore(newChild, null);
+        },
+        hasChildNodes: function() {
+          return this.firstChild != null;
+        },
+        cloneNode: function(deep) {
+          return cloneNode(this.ownerDocument || this, this, deep);
+        },
+        normalize: function() {
+          var child = this.firstChild;
+          while (child) {
+            var next = child.nextSibling;
+            if (next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE) {
+              this.removeChild(next);
+              child.appendData(next.data);
+            } else {
+              child.normalize();
+              child = next;
+            }
+          }
+        },
+        isSupported: function(feature, version) {
+          return this.ownerDocument.implementation.hasFeature(feature, version);
+        },
+        hasAttributes: function() {
+          return this.attributes.length > 0;
+        },
+        lookupPrefix: function(namespaceURI) {
+          var el = this;
+          while (el) {
+            var map = el._nsMap;
+            if (map) {
+              for (var n in map) {
+                if (map[n] == namespaceURI) {
+                  return n;
+                }
+              }
+            }
+            el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
+          }
+          return null;
+        },
+        lookupNamespaceURI: function(prefix) {
+          var el = this;
+          while (el) {
+            var map = el._nsMap;
+            if (map) {
+              if (prefix in map) {
+                return map[prefix];
+              }
+            }
+            el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
+          }
+          return null;
+        },
+        isDefaultNamespace: function(namespaceURI) {
+          var prefix = this.lookupPrefix(namespaceURI);
+          return prefix == null;
+        }
+      };
+      function _xmlEncoder(c) {
+        return c == "<" && "&lt;" || c == ">" && "&gt;" || c == "&" && "&amp;" || c == '"' && "&quot;" || "&#" + c.charCodeAt() + ";";
+      }
+      copy(NodeType, Node);
+      copy(NodeType, Node.prototype);
+      function _visitNode(node, callback) {
+        if (callback(node)) {
+          return true;
+        }
+        if (node = node.firstChild) {
+          do {
+            if (_visitNode(node, callback)) {
+              return true;
+            }
+          } while (node = node.nextSibling);
+        }
+      }
+      function Document() {
+      }
+      function _onAddAttribute(doc, el, newAttr) {
+        doc && doc._inc++;
+        var ns = newAttr.namespaceURI;
+        if (ns === NAMESPACE.XMLNS) {
+          el._nsMap[newAttr.prefix ? newAttr.localName : ""] = newAttr.value;
+        }
+      }
+      function _onRemoveAttribute(doc, el, newAttr, remove) {
+        doc && doc._inc++;
+        var ns = newAttr.namespaceURI;
+        if (ns === NAMESPACE.XMLNS) {
+          delete el._nsMap[newAttr.prefix ? newAttr.localName : ""];
+        }
+      }
+      function _onUpdateChild(doc, el, newChild) {
+        if (doc && doc._inc) {
+          doc._inc++;
+          var cs = el.childNodes;
+          if (newChild) {
+            cs[cs.length++] = newChild;
+          } else {
+            var child = el.firstChild;
+            var i = 0;
+            while (child) {
+              cs[i++] = child;
+              child = child.nextSibling;
+            }
+            cs.length = i;
+          }
+        }
+      }
+      function _removeChild(parentNode, child) {
+        var previous = child.previousSibling;
+        var next = child.nextSibling;
+        if (previous) {
+          previous.nextSibling = next;
+        } else {
+          parentNode.firstChild = next;
+        }
+        if (next) {
+          next.previousSibling = previous;
+        } else {
+          parentNode.lastChild = previous;
+        }
+        _onUpdateChild(parentNode.ownerDocument, parentNode);
+        return child;
+      }
+      function _insertBefore(parentNode, newChild, nextChild) {
+        var cp = newChild.parentNode;
+        if (cp) {
+          cp.removeChild(newChild);
+        }
+        if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {
+          var newFirst = newChild.firstChild;
+          if (newFirst == null) {
+            return newChild;
+          }
+          var newLast = newChild.lastChild;
+        } else {
+          newFirst = newLast = newChild;
+        }
+        var pre = nextChild ? nextChild.previousSibling : parentNode.lastChild;
+        newFirst.previousSibling = pre;
+        newLast.nextSibling = nextChild;
+        if (pre) {
+          pre.nextSibling = newFirst;
+        } else {
+          parentNode.firstChild = newFirst;
+        }
+        if (nextChild == null) {
+          parentNode.lastChild = newLast;
+        } else {
+          nextChild.previousSibling = newLast;
+        }
+        do {
+          newFirst.parentNode = parentNode;
+        } while (newFirst !== newLast && (newFirst = newFirst.nextSibling));
+        _onUpdateChild(parentNode.ownerDocument || parentNode, parentNode);
+        if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
+          newChild.firstChild = newChild.lastChild = null;
+        }
+        return newChild;
+      }
+      function _appendSingleChild(parentNode, newChild) {
+        var cp = newChild.parentNode;
+        if (cp) {
+          var pre = parentNode.lastChild;
+          cp.removeChild(newChild);
+          var pre = parentNode.lastChild;
+        }
+        var pre = parentNode.lastChild;
+        newChild.parentNode = parentNode;
+        newChild.previousSibling = pre;
+        newChild.nextSibling = null;
+        if (pre) {
+          pre.nextSibling = newChild;
+        } else {
+          parentNode.firstChild = newChild;
+        }
+        parentNode.lastChild = newChild;
+        _onUpdateChild(parentNode.ownerDocument, parentNode, newChild);
+        return newChild;
+      }
+      Document.prototype = {
+        nodeName: "#document",
+        nodeType: DOCUMENT_NODE,
+        doctype: null,
+        documentElement: null,
+        _inc: 1,
+        insertBefore: function(newChild, refChild) {
+          if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
+            var child = newChild.firstChild;
+            while (child) {
+              var next = child.nextSibling;
+              this.insertBefore(child, refChild);
+              child = next;
+            }
+            return newChild;
+          }
+          if (this.documentElement == null && newChild.nodeType == ELEMENT_NODE) {
+            this.documentElement = newChild;
+          }
+          return _insertBefore(this, newChild, refChild), newChild.ownerDocument = this, newChild;
+        },
+        removeChild: function(oldChild) {
+          if (this.documentElement == oldChild) {
+            this.documentElement = null;
+          }
+          return _removeChild(this, oldChild);
+        },
+        importNode: function(importedNode, deep) {
+          return importNode(this, importedNode, deep);
+        },
+        getElementById: function(id) {
+          var rtv = null;
+          _visitNode(this.documentElement, function(node) {
+            if (node.nodeType == ELEMENT_NODE) {
+              if (node.getAttribute("id") == id) {
+                rtv = node;
+                return true;
+              }
+            }
+          });
+          return rtv;
+        },
+        getElementsByClassName: function(classNames) {
+          var classNamesSet = toOrderedSet(classNames);
+          return new LiveNodeList(this, function(base) {
+            var ls = [];
+            if (classNamesSet.length > 0) {
+              _visitNode(base.documentElement, function(node) {
+                if (node !== base && node.nodeType === ELEMENT_NODE) {
+                  var nodeClassNames = node.getAttribute("class");
+                  if (nodeClassNames) {
+                    var matches = classNames === nodeClassNames;
+                    if (!matches) {
+                      var nodeClassNamesSet = toOrderedSet(nodeClassNames);
+                      matches = classNamesSet.every(arrayIncludes(nodeClassNamesSet));
+                    }
+                    if (matches) {
+                      ls.push(node);
+                    }
+                  }
+                }
+              });
+            }
+            return ls;
+          });
+        },
+        createElement: function(tagName) {
+          var node = new Element();
+          node.ownerDocument = this;
+          node.nodeName = tagName;
+          node.tagName = tagName;
+          node.localName = tagName;
+          node.childNodes = new NodeList();
+          var attrs = node.attributes = new NamedNodeMap();
+          attrs._ownerElement = node;
+          return node;
+        },
+        createDocumentFragment: function() {
+          var node = new DocumentFragment();
+          node.ownerDocument = this;
+          node.childNodes = new NodeList();
+          return node;
+        },
+        createTextNode: function(data) {
+          var node = new Text();
+          node.ownerDocument = this;
+          node.appendData(data);
+          return node;
+        },
+        createComment: function(data) {
+          var node = new Comment();
+          node.ownerDocument = this;
+          node.appendData(data);
+          return node;
+        },
+        createCDATASection: function(data) {
+          var node = new CDATASection();
+          node.ownerDocument = this;
+          node.appendData(data);
+          return node;
+        },
+        createProcessingInstruction: function(target, data) {
+          var node = new ProcessingInstruction();
+          node.ownerDocument = this;
+          node.tagName = node.target = target;
+          node.nodeValue = node.data = data;
+          return node;
+        },
+        createAttribute: function(name) {
+          var node = new Attr();
+          node.ownerDocument = this;
+          node.name = name;
+          node.nodeName = name;
+          node.localName = name;
+          node.specified = true;
+          return node;
+        },
+        createEntityReference: function(name) {
+          var node = new EntityReference();
+          node.ownerDocument = this;
+          node.nodeName = name;
+          return node;
+        },
+        createElementNS: function(namespaceURI, qualifiedName) {
+          var node = new Element();
+          var pl = qualifiedName.split(":");
+          var attrs = node.attributes = new NamedNodeMap();
+          node.childNodes = new NodeList();
+          node.ownerDocument = this;
+          node.nodeName = qualifiedName;
+          node.tagName = qualifiedName;
+          node.namespaceURI = namespaceURI;
+          if (pl.length == 2) {
+            node.prefix = pl[0];
+            node.localName = pl[1];
+          } else {
+            node.localName = qualifiedName;
+          }
+          attrs._ownerElement = node;
+          return node;
+        },
+        createAttributeNS: function(namespaceURI, qualifiedName) {
+          var node = new Attr();
+          var pl = qualifiedName.split(":");
+          node.ownerDocument = this;
+          node.nodeName = qualifiedName;
+          node.name = qualifiedName;
+          node.namespaceURI = namespaceURI;
+          node.specified = true;
+          if (pl.length == 2) {
+            node.prefix = pl[0];
+            node.localName = pl[1];
+          } else {
+            node.localName = qualifiedName;
+          }
+          return node;
+        }
+      };
+      _extends(Document, Node);
+      function Element() {
+        this._nsMap = {};
+      }
+      Element.prototype = {
+        nodeType: ELEMENT_NODE,
+        hasAttribute: function(name) {
+          return this.getAttributeNode(name) != null;
+        },
+        getAttribute: function(name) {
+          var attr = this.getAttributeNode(name);
+          return attr && attr.value || "";
+        },
+        getAttributeNode: function(name) {
+          return this.attributes.getNamedItem(name);
+        },
+        setAttribute: function(name, value) {
+          var attr = this.ownerDocument.createAttribute(name);
+          attr.value = attr.nodeValue = "" + value;
+          this.setAttributeNode(attr);
+        },
+        removeAttribute: function(name) {
+          var attr = this.getAttributeNode(name);
+          attr && this.removeAttributeNode(attr);
+        },
+        appendChild: function(newChild) {
+          if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {
+            return this.insertBefore(newChild, null);
+          } else {
+            return _appendSingleChild(this, newChild);
+          }
+        },
+        setAttributeNode: function(newAttr) {
+          return this.attributes.setNamedItem(newAttr);
+        },
+        setAttributeNodeNS: function(newAttr) {
+          return this.attributes.setNamedItemNS(newAttr);
+        },
+        removeAttributeNode: function(oldAttr) {
+          return this.attributes.removeNamedItem(oldAttr.nodeName);
+        },
+        removeAttributeNS: function(namespaceURI, localName) {
+          var old = this.getAttributeNodeNS(namespaceURI, localName);
+          old && this.removeAttributeNode(old);
+        },
+        hasAttributeNS: function(namespaceURI, localName) {
+          return this.getAttributeNodeNS(namespaceURI, localName) != null;
+        },
+        getAttributeNS: function(namespaceURI, localName) {
+          var attr = this.getAttributeNodeNS(namespaceURI, localName);
+          return attr && attr.value || "";
+        },
+        setAttributeNS: function(namespaceURI, qualifiedName, value) {
+          var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
+          attr.value = attr.nodeValue = "" + value;
+          this.setAttributeNode(attr);
+        },
+        getAttributeNodeNS: function(namespaceURI, localName) {
+          return this.attributes.getNamedItemNS(namespaceURI, localName);
+        },
+        getElementsByTagName: function(tagName) {
+          return new LiveNodeList(this, function(base) {
+            var ls = [];
+            _visitNode(base, function(node) {
+              if (node !== base && node.nodeType == ELEMENT_NODE && (tagName === "*" || node.tagName == tagName)) {
+                ls.push(node);
+              }
+            });
+            return ls;
+          });
+        },
+        getElementsByTagNameNS: function(namespaceURI, localName) {
+          return new LiveNodeList(this, function(base) {
+            var ls = [];
+            _visitNode(base, function(node) {
+              if (node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === "*" || node.namespaceURI === namespaceURI) && (localName === "*" || node.localName == localName)) {
+                ls.push(node);
+              }
+            });
+            return ls;
+          });
+        }
+      };
+      Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;
+      Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
+      _extends(Element, Node);
+      function Attr() {
+      }
+      Attr.prototype.nodeType = ATTRIBUTE_NODE;
+      _extends(Attr, Node);
+      function CharacterData() {
+      }
+      CharacterData.prototype = {
+        data: "",
+        substringData: function(offset, count) {
+          return this.data.substring(offset, offset + count);
+        },
+        appendData: function(text) {
+          text = this.data + text;
+          this.nodeValue = this.data = text;
+          this.length = text.length;
+        },
+        insertData: function(offset, text) {
+          this.replaceData(offset, 0, text);
+        },
+        appendChild: function(newChild) {
+          throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR]);
+        },
+        deleteData: function(offset, count) {
+          this.replaceData(offset, count, "");
+        },
+        replaceData: function(offset, count, text) {
+          var start = this.data.substring(0, offset);
+          var end = this.data.substring(offset + count);
+          text = start + text + end;
+          this.nodeValue = this.data = text;
+          this.length = text.length;
+        }
+      };
+      _extends(CharacterData, Node);
+      function Text() {
+      }
+      Text.prototype = {
+        nodeName: "#text",
+        nodeType: TEXT_NODE,
+        splitText: function(offset) {
+          var text = this.data;
+          var newText = text.substring(offset);
+          text = text.substring(0, offset);
+          this.data = this.nodeValue = text;
+          this.length = text.length;
+          var newNode = this.ownerDocument.createTextNode(newText);
+          if (this.parentNode) {
+            this.parentNode.insertBefore(newNode, this.nextSibling);
+          }
+          return newNode;
+        }
+      };
+      _extends(Text, CharacterData);
+      function Comment() {
+      }
+      Comment.prototype = {
+        nodeName: "#comment",
+        nodeType: COMMENT_NODE
+      };
+      _extends(Comment, CharacterData);
+      function CDATASection() {
+      }
+      CDATASection.prototype = {
+        nodeName: "#cdata-section",
+        nodeType: CDATA_SECTION_NODE
+      };
+      _extends(CDATASection, CharacterData);
+      function DocumentType() {
+      }
+      DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
+      _extends(DocumentType, Node);
+      function Notation() {
+      }
+      Notation.prototype.nodeType = NOTATION_NODE;
+      _extends(Notation, Node);
+      function Entity() {
+      }
+      Entity.prototype.nodeType = ENTITY_NODE;
+      _extends(Entity, Node);
+      function EntityReference() {
+      }
+      EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
+      _extends(EntityReference, Node);
+      function DocumentFragment() {
+      }
+      DocumentFragment.prototype.nodeName = "#document-fragment";
+      DocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;
+      _extends(DocumentFragment, Node);
+      function ProcessingInstruction() {
+      }
+      ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
+      _extends(ProcessingInstruction, Node);
+      function XMLSerializer() {
+      }
+      XMLSerializer.prototype.serializeToString = function(node, isHtml, nodeFilter) {
+        return nodeSerializeToString.call(node, isHtml, nodeFilter);
+      };
+      Node.prototype.toString = nodeSerializeToString;
+      function nodeSerializeToString(isHtml, nodeFilter) {
+        var buf = [];
+        var refNode = this.nodeType == 9 && this.documentElement || this;
+        var prefix = refNode.prefix;
+        var uri = refNode.namespaceURI;
+        if (uri && prefix == null) {
+          var prefix = refNode.lookupPrefix(uri);
+          if (prefix == null) {
+            var visibleNamespaces = [
+              { namespace: uri, prefix: null }
+            ];
+          }
+        }
+        serializeToString(this, buf, isHtml, nodeFilter, visibleNamespaces);
+        return buf.join("");
+      }
+      function needNamespaceDefine(node, isHTML, visibleNamespaces) {
+        var prefix = node.prefix || "";
+        var uri = node.namespaceURI;
+        if (!uri) {
+          return false;
+        }
+        if (prefix === "xml" && uri === NAMESPACE.XML || uri === NAMESPACE.XMLNS) {
+          return false;
+        }
+        var i = visibleNamespaces.length;
+        while (i--) {
+          var ns = visibleNamespaces[i];
+          if (ns.prefix === prefix) {
+            return ns.namespace !== uri;
+          }
+        }
+        return true;
+      }
+      function addSerializedAttribute(buf, qualifiedName, value) {
+        buf.push(" ", qualifiedName, '="', value.replace(/[<&"]/g, _xmlEncoder), '"');
+      }
+      function serializeToString(node, buf, isHTML, nodeFilter, visibleNamespaces) {
+        if (!visibleNamespaces) {
+          visibleNamespaces = [];
+        }
+        if (nodeFilter) {
+          node = nodeFilter(node);
+          if (node) {
+            if (typeof node == "string") {
+              buf.push(node);
+              return;
+            }
+          } else {
+            return;
+          }
+        }
+        switch (node.nodeType) {
+          case ELEMENT_NODE:
+            var attrs = node.attributes;
+            var len = attrs.length;
+            var child = node.firstChild;
+            var nodeName = node.tagName;
+            isHTML = NAMESPACE.isHTML(node.namespaceURI) || isHTML;
+            var prefixedNodeName = nodeName;
+            if (!isHTML && !node.prefix && node.namespaceURI) {
+              var defaultNS;
+              for (var ai = 0; ai < attrs.length; ai++) {
+                if (attrs.item(ai).name === "xmlns") {
+                  defaultNS = attrs.item(ai).value;
+                  break;
+                }
+              }
+              if (!defaultNS) {
+                for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
+                  var namespace = visibleNamespaces[nsi];
+                  if (namespace.prefix === "" && namespace.namespace === node.namespaceURI) {
+                    defaultNS = namespace.namespace;
+                    break;
+                  }
+                }
+              }
+              if (defaultNS !== node.namespaceURI) {
+                for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
+                  var namespace = visibleNamespaces[nsi];
+                  if (namespace.namespace === node.namespaceURI) {
+                    if (namespace.prefix) {
+                      prefixedNodeName = namespace.prefix + ":" + nodeName;
+                    }
+                    break;
+                  }
+                }
+              }
+            }
+            buf.push("<", prefixedNodeName);
+            for (var i = 0; i < len; i++) {
+              var attr = attrs.item(i);
+              if (attr.prefix == "xmlns") {
+                visibleNamespaces.push({ prefix: attr.localName, namespace: attr.value });
+              } else if (attr.nodeName == "xmlns") {
+                visibleNamespaces.push({ prefix: "", namespace: attr.value });
+              }
+            }
+            for (var i = 0; i < len; i++) {
+              var attr = attrs.item(i);
+              if (needNamespaceDefine(attr, isHTML, visibleNamespaces)) {
+                var prefix = attr.prefix || "";
+                var uri = attr.namespaceURI;
+                addSerializedAttribute(buf, prefix ? "xmlns:" + prefix : "xmlns", uri);
+                visibleNamespaces.push({ prefix, namespace: uri });
+              }
+              serializeToString(attr, buf, isHTML, nodeFilter, visibleNamespaces);
+            }
+            if (nodeName === prefixedNodeName && needNamespaceDefine(node, isHTML, visibleNamespaces)) {
+              var prefix = node.prefix || "";
+              var uri = node.namespaceURI;
+              addSerializedAttribute(buf, prefix ? "xmlns:" + prefix : "xmlns", uri);
+              visibleNamespaces.push({ prefix, namespace: uri });
+            }
+            if (child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)) {
+              buf.push(">");
+              if (isHTML && /^script$/i.test(nodeName)) {
+                while (child) {
+                  if (child.data) {
+                    buf.push(child.data);
+                  } else {
+                    serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+                  }
+                  child = child.nextSibling;
+                }
+              } else {
+                while (child) {
+                  serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+                  child = child.nextSibling;
+                }
+              }
+              buf.push("</", prefixedNodeName, ">");
+            } else {
+              buf.push("/>");
+            }
+            return;
+          case DOCUMENT_NODE:
+          case DOCUMENT_FRAGMENT_NODE:
+            var child = node.firstChild;
+            while (child) {
+              serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+              child = child.nextSibling;
+            }
+            return;
+          case ATTRIBUTE_NODE:
+            return addSerializedAttribute(buf, node.name, node.value);
+          case TEXT_NODE:
+            return buf.push(node.data.replace(/[<&]/g, _xmlEncoder).replace(/]]>/g, "]]&gt;"));
+          case CDATA_SECTION_NODE:
+            return buf.push("<![CDATA[", node.data, "]]>");
+          case COMMENT_NODE:
+            return buf.push("<!--", node.data, "-->");
+          case DOCUMENT_TYPE_NODE:
+            var pubid = node.publicId;
+            var sysid = node.systemId;
+            buf.push("<!DOCTYPE ", node.name);
+            if (pubid) {
+              buf.push(" PUBLIC ", pubid);
+              if (sysid && sysid != ".") {
+                buf.push(" ", sysid);
+              }
+              buf.push(">");
+            } else if (sysid && sysid != ".") {
+              buf.push(" SYSTEM ", sysid, ">");
+            } else {
+              var sub = node.internalSubset;
+              if (sub) {
+                buf.push(" [", sub, "]");
+              }
+              buf.push(">");
+            }
+            return;
+          case PROCESSING_INSTRUCTION_NODE:
+            return buf.push("<?", node.target, " ", node.data, "?>");
+          case ENTITY_REFERENCE_NODE:
+            return buf.push("&", node.nodeName, ";");
+          default:
+            buf.push("??", node.nodeName);
+        }
+      }
+      function importNode(doc, node, deep) {
+        var node2;
+        switch (node.nodeType) {
+          case ELEMENT_NODE:
+            node2 = node.cloneNode(false);
+            node2.ownerDocument = doc;
+          case DOCUMENT_FRAGMENT_NODE:
+            break;
+          case ATTRIBUTE_NODE:
+            deep = true;
+            break;
+        }
+        if (!node2) {
+          node2 = node.cloneNode(false);
+        }
+        node2.ownerDocument = doc;
+        node2.parentNode = null;
+        if (deep) {
+          var child = node.firstChild;
+          while (child) {
+            node2.appendChild(importNode(doc, child, deep));
+            child = child.nextSibling;
+          }
+        }
+        return node2;
+      }
+      function cloneNode(doc, node, deep) {
+        var node2 = new node.constructor();
+        for (var n in node) {
+          var v = node[n];
+          if (typeof v != "object") {
+            if (v != node2[n]) {
+              node2[n] = v;
+            }
+          }
+        }
+        if (node.childNodes) {
+          node2.childNodes = new NodeList();
+        }
+        node2.ownerDocument = doc;
+        switch (node2.nodeType) {
+          case ELEMENT_NODE:
+            var attrs = node.attributes;
+            var attrs2 = node2.attributes = new NamedNodeMap();
+            var len = attrs.length;
+            attrs2._ownerElement = node2;
+            for (var i = 0; i < len; i++) {
+              node2.setAttributeNode(cloneNode(doc, attrs.item(i), true));
+            }
+            break;
+            ;
+          case ATTRIBUTE_NODE:
+            deep = true;
+        }
+        if (deep) {
+          var child = node.firstChild;
+          while (child) {
+            node2.appendChild(cloneNode(doc, child, deep));
+            child = child.nextSibling;
+          }
+        }
+        return node2;
+      }
+      function __set__(object, key, value) {
+        object[key] = value;
+      }
+      try {
+        if (Object.defineProperty) {
+          let getTextContent2 = function(node) {
+            switch (node.nodeType) {
+              case ELEMENT_NODE:
+              case DOCUMENT_FRAGMENT_NODE:
+                var buf = [];
+                node = node.firstChild;
+                while (node) {
+                  if (node.nodeType !== 7 && node.nodeType !== 8) {
+                    buf.push(getTextContent2(node));
+                  }
+                  node = node.nextSibling;
+                }
+                return buf.join("");
+              default:
+                return node.nodeValue;
+            }
+          };
+          getTextContent = getTextContent2;
+          Object.defineProperty(LiveNodeList.prototype, "length", {
+            get: function() {
+              _updateLiveList(this);
+              return this.$$length;
+            }
+          });
+          Object.defineProperty(Node.prototype, "textContent", {
+            get: function() {
+              return getTextContent2(this);
+            },
+            set: function(data) {
+              switch (this.nodeType) {
+                case ELEMENT_NODE:
+                case DOCUMENT_FRAGMENT_NODE:
+                  while (this.firstChild) {
+                    this.removeChild(this.firstChild);
+                  }
+                  if (data || String(data)) {
+                    this.appendChild(this.ownerDocument.createTextNode(data));
+                  }
+                  break;
+                default:
+                  this.data = data;
+                  this.value = data;
+                  this.nodeValue = data;
+              }
+            }
+          });
+          __set__ = function(object, key, value) {
+            object["$$" + key] = value;
+          };
+        }
+      } catch (e) {
+      }
+      var getTextContent;
+      exports.DocumentType = DocumentType;
+      exports.DOMException = DOMException;
+      exports.DOMImplementation = DOMImplementation;
+      exports.Element = Element;
+      exports.Node = Node;
+      exports.NodeList = NodeList;
+      exports.XMLSerializer = XMLSerializer;
+    }
+  });
+
+  // ../../node_modules/@xmldom/xmldom/lib/entities.js
+  var require_entities = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/entities.js"(exports) {
+      var freeze = require_conventions().freeze;
+      exports.XML_ENTITIES = freeze({ amp: "&", apos: "'", gt: ">", lt: "<", quot: '"' });
+      exports.HTML_ENTITIES = freeze({
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        Agrave: "\xC0",
+        Aacute: "\xC1",
+        Acirc: "\xC2",
+        Atilde: "\xC3",
+        Auml: "\xC4",
+        Aring: "\xC5",
+        AElig: "\xC6",
+        Ccedil: "\xC7",
+        Egrave: "\xC8",
+        Eacute: "\xC9",
+        Ecirc: "\xCA",
+        Euml: "\xCB",
+        Igrave: "\xCC",
+        Iacute: "\xCD",
+        Icirc: "\xCE",
+        Iuml: "\xCF",
+        ETH: "\xD0",
+        Ntilde: "\xD1",
+        Ograve: "\xD2",
+        Oacute: "\xD3",
+        Ocirc: "\xD4",
+        Otilde: "\xD5",
+        Ouml: "\xD6",
+        Oslash: "\xD8",
+        Ugrave: "\xD9",
+        Uacute: "\xDA",
+        Ucirc: "\xDB",
+        Uuml: "\xDC",
+        Yacute: "\xDD",
+        THORN: "\xDE",
+        szlig: "\xDF",
+        agrave: "\xE0",
+        aacute: "\xE1",
+        acirc: "\xE2",
+        atilde: "\xE3",
+        auml: "\xE4",
+        aring: "\xE5",
+        aelig: "\xE6",
+        ccedil: "\xE7",
+        egrave: "\xE8",
+        eacute: "\xE9",
+        ecirc: "\xEA",
+        euml: "\xEB",
+        igrave: "\xEC",
+        iacute: "\xED",
+        icirc: "\xEE",
+        iuml: "\xEF",
+        eth: "\xF0",
+        ntilde: "\xF1",
+        ograve: "\xF2",
+        oacute: "\xF3",
+        ocirc: "\xF4",
+        otilde: "\xF5",
+        ouml: "\xF6",
+        oslash: "\xF8",
+        ugrave: "\xF9",
+        uacute: "\xFA",
+        ucirc: "\xFB",
+        uuml: "\xFC",
+        yacute: "\xFD",
+        thorn: "\xFE",
+        yuml: "\xFF",
+        nbsp: "\xA0",
+        iexcl: "\xA1",
+        cent: "\xA2",
+        pound: "\xA3",
+        curren: "\xA4",
+        yen: "\xA5",
+        brvbar: "\xA6",
+        sect: "\xA7",
+        uml: "\xA8",
+        copy: "\xA9",
+        ordf: "\xAA",
+        laquo: "\xAB",
+        not: "\xAC",
+        shy: "\xAD\xAD",
+        reg: "\xAE",
+        macr: "\xAF",
+        deg: "\xB0",
+        plusmn: "\xB1",
+        sup2: "\xB2",
+        sup3: "\xB3",
+        acute: "\xB4",
+        micro: "\xB5",
+        para: "\xB6",
+        middot: "\xB7",
+        cedil: "\xB8",
+        sup1: "\xB9",
+        ordm: "\xBA",
+        raquo: "\xBB",
+        frac14: "\xBC",
+        frac12: "\xBD",
+        frac34: "\xBE",
+        iquest: "\xBF",
+        times: "\xD7",
+        divide: "\xF7",
+        forall: "\u2200",
+        part: "\u2202",
+        exist: "\u2203",
+        empty: "\u2205",
+        nabla: "\u2207",
+        isin: "\u2208",
+        notin: "\u2209",
+        ni: "\u220B",
+        prod: "\u220F",
+        sum: "\u2211",
+        minus: "\u2212",
+        lowast: "\u2217",
+        radic: "\u221A",
+        prop: "\u221D",
+        infin: "\u221E",
+        ang: "\u2220",
+        and: "\u2227",
+        or: "\u2228",
+        cap: "\u2229",
+        cup: "\u222A",
+        "int": "\u222B",
+        there4: "\u2234",
+        sim: "\u223C",
+        cong: "\u2245",
+        asymp: "\u2248",
+        ne: "\u2260",
+        equiv: "\u2261",
+        le: "\u2264",
+        ge: "\u2265",
+        sub: "\u2282",
+        sup: "\u2283",
+        nsub: "\u2284",
+        sube: "\u2286",
+        supe: "\u2287",
+        oplus: "\u2295",
+        otimes: "\u2297",
+        perp: "\u22A5",
+        sdot: "\u22C5",
+        Alpha: "\u0391",
+        Beta: "\u0392",
+        Gamma: "\u0393",
+        Delta: "\u0394",
+        Epsilon: "\u0395",
+        Zeta: "\u0396",
+        Eta: "\u0397",
+        Theta: "\u0398",
+        Iota: "\u0399",
+        Kappa: "\u039A",
+        Lambda: "\u039B",
+        Mu: "\u039C",
+        Nu: "\u039D",
+        Xi: "\u039E",
+        Omicron: "\u039F",
+        Pi: "\u03A0",
+        Rho: "\u03A1",
+        Sigma: "\u03A3",
+        Tau: "\u03A4",
+        Upsilon: "\u03A5",
+        Phi: "\u03A6",
+        Chi: "\u03A7",
+        Psi: "\u03A8",
+        Omega: "\u03A9",
+        alpha: "\u03B1",
+        beta: "\u03B2",
+        gamma: "\u03B3",
+        delta: "\u03B4",
+        epsilon: "\u03B5",
+        zeta: "\u03B6",
+        eta: "\u03B7",
+        theta: "\u03B8",
+        iota: "\u03B9",
+        kappa: "\u03BA",
+        lambda: "\u03BB",
+        mu: "\u03BC",
+        nu: "\u03BD",
+        xi: "\u03BE",
+        omicron: "\u03BF",
+        pi: "\u03C0",
+        rho: "\u03C1",
+        sigmaf: "\u03C2",
+        sigma: "\u03C3",
+        tau: "\u03C4",
+        upsilon: "\u03C5",
+        phi: "\u03C6",
+        chi: "\u03C7",
+        psi: "\u03C8",
+        omega: "\u03C9",
+        thetasym: "\u03D1",
+        upsih: "\u03D2",
+        piv: "\u03D6",
+        OElig: "\u0152",
+        oelig: "\u0153",
+        Scaron: "\u0160",
+        scaron: "\u0161",
+        Yuml: "\u0178",
+        fnof: "\u0192",
+        circ: "\u02C6",
+        tilde: "\u02DC",
+        ensp: "\u2002",
+        emsp: "\u2003",
+        thinsp: "\u2009",
+        zwnj: "\u200C",
+        zwj: "\u200D",
+        lrm: "\u200E",
+        rlm: "\u200F",
+        ndash: "\u2013",
+        mdash: "\u2014",
+        lsquo: "\u2018",
+        rsquo: "\u2019",
+        sbquo: "\u201A",
+        ldquo: "\u201C",
+        rdquo: "\u201D",
+        bdquo: "\u201E",
+        dagger: "\u2020",
+        Dagger: "\u2021",
+        bull: "\u2022",
+        hellip: "\u2026",
+        permil: "\u2030",
+        prime: "\u2032",
+        Prime: "\u2033",
+        lsaquo: "\u2039",
+        rsaquo: "\u203A",
+        oline: "\u203E",
+        euro: "\u20AC",
+        trade: "\u2122",
+        larr: "\u2190",
+        uarr: "\u2191",
+        rarr: "\u2192",
+        darr: "\u2193",
+        harr: "\u2194",
+        crarr: "\u21B5",
+        lceil: "\u2308",
+        rceil: "\u2309",
+        lfloor: "\u230A",
+        rfloor: "\u230B",
+        loz: "\u25CA",
+        spades: "\u2660",
+        clubs: "\u2663",
+        hearts: "\u2665",
+        diams: "\u2666"
+      });
+      exports.entityMap = exports.HTML_ENTITIES;
+    }
+  });
+
+  // ../../node_modules/@xmldom/xmldom/lib/sax.js
+  var require_sax = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/sax.js"(exports) {
+      var NAMESPACE = require_conventions().NAMESPACE;
+      var nameStartChar = /[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]/;
+      var nameChar = new RegExp("[\\-\\.0-9" + nameStartChar.source.slice(1, -1) + "\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
+      var tagNamePattern = new RegExp("^" + nameStartChar.source + nameChar.source + "*(?::" + nameStartChar.source + nameChar.source + "*)?$");
+      var S_TAG = 0;
+      var S_ATTR = 1;
+      var S_ATTR_SPACE = 2;
+      var S_EQ = 3;
+      var S_ATTR_NOQUOT_VALUE = 4;
+      var S_ATTR_END = 5;
+      var S_TAG_SPACE = 6;
+      var S_TAG_CLOSE = 7;
+      function ParseError(message, locator) {
+        this.message = message;
+        this.locator = locator;
+        if (Error.captureStackTrace)
+          Error.captureStackTrace(this, ParseError);
+      }
+      ParseError.prototype = new Error();
+      ParseError.prototype.name = ParseError.name;
+      function XMLReader() {
+      }
+      XMLReader.prototype = {
+        parse: function(source, defaultNSMap, entityMap) {
+          var domBuilder = this.domBuilder;
+          domBuilder.startDocument();
+          _copy(defaultNSMap, defaultNSMap = {});
+          parse(source, defaultNSMap, entityMap, domBuilder, this.errorHandler);
+          domBuilder.endDocument();
+        }
+      };
+      function parse(source, defaultNSMapCopy, entityMap, domBuilder, errorHandler) {
+        function fixedFromCharCode(code) {
+          if (code > 65535) {
+            code -= 65536;
+            var surrogate1 = 55296 + (code >> 10), surrogate2 = 56320 + (code & 1023);
+            return String.fromCharCode(surrogate1, surrogate2);
+          } else {
+            return String.fromCharCode(code);
+          }
+        }
+        function entityReplacer(a2) {
+          var k = a2.slice(1, -1);
+          if (k in entityMap) {
+            return entityMap[k];
+          } else if (k.charAt(0) === "#") {
+            return fixedFromCharCode(parseInt(k.substr(1).replace("x", "0x")));
+          } else {
+            errorHandler.error("entity not found:" + a2);
+            return a2;
+          }
+        }
+        function appendText(end2) {
+          if (end2 > start) {
+            var xt = source.substring(start, end2).replace(/&#?\w+;/g, entityReplacer);
+            locator && position(start);
+            domBuilder.characters(xt, 0, end2 - start);
+            start = end2;
+          }
+        }
+        function position(p, m) {
+          while (p >= lineEnd && (m = linePattern.exec(source))) {
+            lineStart = m.index;
+            lineEnd = lineStart + m[0].length;
+            locator.lineNumber++;
+          }
+          locator.columnNumber = p - lineStart + 1;
+        }
+        var lineStart = 0;
+        var lineEnd = 0;
+        var linePattern = /.*(?:\r\n?|\n)|.*$/g;
+        var locator = domBuilder.locator;
+        var parseStack = [{ currentNSMap: defaultNSMapCopy }];
+        var closeMap = {};
+        var start = 0;
+        while (true) {
+          try {
+            var tagStart = source.indexOf("<", start);
+            if (tagStart < 0) {
+              if (!source.substr(start).match(/^\s*$/)) {
+                var doc = domBuilder.doc;
+                var text = doc.createTextNode(source.substr(start));
+                doc.appendChild(text);
+                domBuilder.currentElement = text;
+              }
+              return;
+            }
+            if (tagStart > start) {
+              appendText(tagStart);
+            }
+            switch (source.charAt(tagStart + 1)) {
+              case "/":
+                var end = source.indexOf(">", tagStart + 3);
+                var tagName = source.substring(tagStart + 2, end).replace(/[ \t\n\r]+$/g, "");
+                var config = parseStack.pop();
+                if (end < 0) {
+                  tagName = source.substring(tagStart + 2).replace(/[\s<].*/, "");
+                  errorHandler.error("end tag name: " + tagName + " is not complete:" + config.tagName);
+                  end = tagStart + 1 + tagName.length;
+                } else if (tagName.match(/\s</)) {
+                  tagName = tagName.replace(/[\s<].*/, "");
+                  errorHandler.error("end tag name: " + tagName + " maybe not complete");
+                  end = tagStart + 1 + tagName.length;
+                }
+                var localNSMap = config.localNSMap;
+                var endMatch = config.tagName == tagName;
+                var endIgnoreCaseMach = endMatch || config.tagName && config.tagName.toLowerCase() == tagName.toLowerCase();
+                if (endIgnoreCaseMach) {
+                  domBuilder.endElement(config.uri, config.localName, tagName);
+                  if (localNSMap) {
+                    for (var prefix in localNSMap) {
+                      domBuilder.endPrefixMapping(prefix);
+                    }
+                  }
+                  if (!endMatch) {
+                    errorHandler.fatalError("end tag name: " + tagName + " is not match the current start tagName:" + config.tagName);
+                  }
+                } else {
+                  parseStack.push(config);
+                }
+                end++;
+                break;
+              case "?":
+                locator && position(tagStart);
+                end = parseInstruction(source, tagStart, domBuilder);
+                break;
+              case "!":
+                locator && position(tagStart);
+                end = parseDCC(source, tagStart, domBuilder, errorHandler);
+                break;
+              default:
+                locator && position(tagStart);
+                var el = new ElementAttributes();
+                var currentNSMap = parseStack[parseStack.length - 1].currentNSMap;
+                var end = parseElementStartPart(source, tagStart, el, currentNSMap, entityReplacer, errorHandler);
+                var len = el.length;
+                if (!el.closed && fixSelfClosed(source, end, el.tagName, closeMap)) {
+                  el.closed = true;
+                  if (!entityMap.nbsp) {
+                    errorHandler.warning("unclosed xml attribute");
+                  }
+                }
+                if (locator && len) {
+                  var locator2 = copyLocator(locator, {});
+                  for (var i = 0; i < len; i++) {
+                    var a = el[i];
+                    position(a.offset);
+                    a.locator = copyLocator(locator, {});
+                  }
+                  domBuilder.locator = locator2;
+                  if (appendElement(el, domBuilder, currentNSMap)) {
+                    parseStack.push(el);
+                  }
+                  domBuilder.locator = locator;
+                } else {
+                  if (appendElement(el, domBuilder, currentNSMap)) {
+                    parseStack.push(el);
+                  }
+                }
+                if (NAMESPACE.isHTML(el.uri) && !el.closed) {
+                  end = parseHtmlSpecialContent(source, end, el.tagName, entityReplacer, domBuilder);
+                } else {
+                  end++;
+                }
+            }
+          } catch (e) {
+            if (e instanceof ParseError) {
+              throw e;
+            }
+            errorHandler.error("element parse error: " + e);
+            end = -1;
+          }
+          if (end > start) {
+            start = end;
+          } else {
+            appendText(Math.max(tagStart, start) + 1);
+          }
+        }
+      }
+      function copyLocator(f, t) {
+        t.lineNumber = f.lineNumber;
+        t.columnNumber = f.columnNumber;
+        return t;
+      }
+      function parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler) {
+        function addAttribute(qname, value2, startIndex) {
+          if (el.attributeNames.hasOwnProperty(qname)) {
+            errorHandler.fatalError("Attribute " + qname + " redefined");
+          }
+          el.addValue(qname, value2, startIndex);
+        }
+        var attrName;
+        var value;
+        var p = ++start;
+        var s = S_TAG;
+        while (true) {
+          var c = source.charAt(p);
+          switch (c) {
+            case "=":
+              if (s === S_ATTR) {
+                attrName = source.slice(start, p);
+                s = S_EQ;
+              } else if (s === S_ATTR_SPACE) {
+                s = S_EQ;
+              } else {
+                throw new Error("attribute equal must after attrName");
+              }
+              break;
+            case "'":
+            case '"':
+              if (s === S_EQ || s === S_ATTR) {
+                if (s === S_ATTR) {
+                  errorHandler.warning('attribute value must after "="');
+                  attrName = source.slice(start, p);
+                }
+                start = p + 1;
+                p = source.indexOf(c, start);
+                if (p > 0) {
+                  value = source.slice(start, p).replace(/&#?\w+;/g, entityReplacer);
+                  addAttribute(attrName, value, start - 1);
+                  s = S_ATTR_END;
+                } else {
+                  throw new Error("attribute value no end '" + c + "' match");
+                }
+              } else if (s == S_ATTR_NOQUOT_VALUE) {
+                value = source.slice(start, p).replace(/&#?\w+;/g, entityReplacer);
+                addAttribute(attrName, value, start);
+                errorHandler.warning('attribute "' + attrName + '" missed start quot(' + c + ")!!");
+                start = p + 1;
+                s = S_ATTR_END;
+              } else {
+                throw new Error('attribute value must after "="');
+              }
+              break;
+            case "/":
+              switch (s) {
+                case S_TAG:
+                  el.setTagName(source.slice(start, p));
+                case S_ATTR_END:
+                case S_TAG_SPACE:
+                case S_TAG_CLOSE:
+                  s = S_TAG_CLOSE;
+                  el.closed = true;
+                case S_ATTR_NOQUOT_VALUE:
+                case S_ATTR:
+                case S_ATTR_SPACE:
+                  break;
+                default:
+                  throw new Error("attribute invalid close char('/')");
+              }
+              break;
+            case "":
+              errorHandler.error("unexpected end of input");
+              if (s == S_TAG) {
+                el.setTagName(source.slice(start, p));
+              }
+              return p;
+            case ">":
+              switch (s) {
+                case S_TAG:
+                  el.setTagName(source.slice(start, p));
+                case S_ATTR_END:
+                case S_TAG_SPACE:
+                case S_TAG_CLOSE:
+                  break;
+                case S_ATTR_NOQUOT_VALUE:
+                case S_ATTR:
+                  value = source.slice(start, p);
+                  if (value.slice(-1) === "/") {
+                    el.closed = true;
+                    value = value.slice(0, -1);
+                  }
+                case S_ATTR_SPACE:
+                  if (s === S_ATTR_SPACE) {
+                    value = attrName;
+                  }
+                  if (s == S_ATTR_NOQUOT_VALUE) {
+                    errorHandler.warning('attribute "' + value + '" missed quot(")!');
+                    addAttribute(attrName, value.replace(/&#?\w+;/g, entityReplacer), start);
+                  } else {
+                    if (!NAMESPACE.isHTML(currentNSMap[""]) || !value.match(/^(?:disabled|checked|selected)$/i)) {
+                      errorHandler.warning('attribute "' + value + '" missed value!! "' + value + '" instead!!');
+                    }
+                    addAttribute(value, value, start);
+                  }
+                  break;
+                case S_EQ:
+                  throw new Error("attribute value missed!!");
+              }
+              return p;
+            case "\x80":
+              c = " ";
+            default:
+              if (c <= " ") {
+                switch (s) {
+                  case S_TAG:
+                    el.setTagName(source.slice(start, p));
+                    s = S_TAG_SPACE;
+                    break;
+                  case S_ATTR:
+                    attrName = source.slice(start, p);
+                    s = S_ATTR_SPACE;
+                    break;
+                  case S_ATTR_NOQUOT_VALUE:
+                    var value = source.slice(start, p).replace(/&#?\w+;/g, entityReplacer);
+                    errorHandler.warning('attribute "' + value + '" missed quot(")!!');
+                    addAttribute(attrName, value, start);
+                  case S_ATTR_END:
+                    s = S_TAG_SPACE;
+                    break;
+                }
+              } else {
+                switch (s) {
+                  case S_ATTR_SPACE:
+                    var tagName = el.tagName;
+                    if (!NAMESPACE.isHTML(currentNSMap[""]) || !attrName.match(/^(?:disabled|checked|selected)$/i)) {
+                      errorHandler.warning('attribute "' + attrName + '" missed value!! "' + attrName + '" instead2!!');
+                    }
+                    addAttribute(attrName, attrName, start);
+                    start = p;
+                    s = S_ATTR;
+                    break;
+                  case S_ATTR_END:
+                    errorHandler.warning('attribute space is required"' + attrName + '"!!');
+                  case S_TAG_SPACE:
+                    s = S_ATTR;
+                    start = p;
+                    break;
+                  case S_EQ:
+                    s = S_ATTR_NOQUOT_VALUE;
+                    start = p;
+                    break;
+                  case S_TAG_CLOSE:
+                    throw new Error("elements closed character '/' and '>' must be connected to");
+                }
+              }
+          }
+          p++;
+        }
+      }
+      function appendElement(el, domBuilder, currentNSMap) {
+        var tagName = el.tagName;
+        var localNSMap = null;
+        var i = el.length;
+        while (i--) {
+          var a = el[i];
+          var qName = a.qName;
+          var value = a.value;
+          var nsp = qName.indexOf(":");
+          if (nsp > 0) {
+            var prefix = a.prefix = qName.slice(0, nsp);
+            var localName = qName.slice(nsp + 1);
+            var nsPrefix = prefix === "xmlns" && localName;
+          } else {
+            localName = qName;
+            prefix = null;
+            nsPrefix = qName === "xmlns" && "";
+          }
+          a.localName = localName;
+          if (nsPrefix !== false) {
+            if (localNSMap == null) {
+              localNSMap = {};
+              _copy(currentNSMap, currentNSMap = {});
+            }
+            currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
+            a.uri = NAMESPACE.XMLNS;
+            domBuilder.startPrefixMapping(nsPrefix, value);
+          }
+        }
+        var i = el.length;
+        while (i--) {
+          a = el[i];
+          var prefix = a.prefix;
+          if (prefix) {
+            if (prefix === "xml") {
+              a.uri = NAMESPACE.XML;
+            }
+            if (prefix !== "xmlns") {
+              a.uri = currentNSMap[prefix || ""];
+            }
+          }
+        }
+        var nsp = tagName.indexOf(":");
+        if (nsp > 0) {
+          prefix = el.prefix = tagName.slice(0, nsp);
+          localName = el.localName = tagName.slice(nsp + 1);
+        } else {
+          prefix = null;
+          localName = el.localName = tagName;
+        }
+        var ns = el.uri = currentNSMap[prefix || ""];
+        domBuilder.startElement(ns, localName, tagName, el);
+        if (el.closed) {
+          domBuilder.endElement(ns, localName, tagName);
+          if (localNSMap) {
+            for (prefix in localNSMap) {
+              domBuilder.endPrefixMapping(prefix);
+            }
+          }
+        } else {
+          el.currentNSMap = currentNSMap;
+          el.localNSMap = localNSMap;
+          return true;
+        }
+      }
+      function parseHtmlSpecialContent(source, elStartEnd, tagName, entityReplacer, domBuilder) {
+        if (/^(?:script|textarea)$/i.test(tagName)) {
+          var elEndStart = source.indexOf("</" + tagName + ">", elStartEnd);
+          var text = source.substring(elStartEnd + 1, elEndStart);
+          if (/[&<]/.test(text)) {
+            if (/^script$/i.test(tagName)) {
+              domBuilder.characters(text, 0, text.length);
+              return elEndStart;
+            }
+            text = text.replace(/&#?\w+;/g, entityReplacer);
+            domBuilder.characters(text, 0, text.length);
+            return elEndStart;
+          }
+        }
+        return elStartEnd + 1;
+      }
+      function fixSelfClosed(source, elStartEnd, tagName, closeMap) {
+        var pos = closeMap[tagName];
+        if (pos == null) {
+          pos = source.lastIndexOf("</" + tagName + ">");
+          if (pos < elStartEnd) {
+            pos = source.lastIndexOf("</" + tagName);
+          }
+          closeMap[tagName] = pos;
+        }
+        return pos < elStartEnd;
+      }
+      function _copy(source, target) {
+        for (var n in source) {
+          target[n] = source[n];
+        }
+      }
+      function parseDCC(source, start, domBuilder, errorHandler) {
+        var next = source.charAt(start + 2);
+        switch (next) {
+          case "-":
+            if (source.charAt(start + 3) === "-") {
+              var end = source.indexOf("-->", start + 4);
+              if (end > start) {
+                domBuilder.comment(source, start + 4, end - start - 4);
+                return end + 3;
+              } else {
+                errorHandler.error("Unclosed comment");
+                return -1;
+              }
+            } else {
+              return -1;
+            }
+          default:
+            if (source.substr(start + 3, 6) == "CDATA[") {
+              var end = source.indexOf("]]>", start + 9);
+              domBuilder.startCDATA();
+              domBuilder.characters(source, start + 9, end - start - 9);
+              domBuilder.endCDATA();
+              return end + 3;
+            }
+            var matchs = split(source, start);
+            var len = matchs.length;
+            if (len > 1 && /!doctype/i.test(matchs[0][0])) {
+              var name = matchs[1][0];
+              var pubid = false;
+              var sysid = false;
+              if (len > 3) {
+                if (/^public$/i.test(matchs[2][0])) {
+                  pubid = matchs[3][0];
+                  sysid = len > 4 && matchs[4][0];
+                } else if (/^system$/i.test(matchs[2][0])) {
+                  sysid = matchs[3][0];
+                }
+              }
+              var lastMatch = matchs[len - 1];
+              domBuilder.startDTD(name, pubid, sysid);
+              domBuilder.endDTD();
+              return lastMatch.index + lastMatch[0].length;
+            }
+        }
+        return -1;
+      }
+      function parseInstruction(source, start, domBuilder) {
+        var end = source.indexOf("?>", start);
+        if (end) {
+          var match = source.substring(start, end).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
+          if (match) {
+            var len = match[0].length;
+            domBuilder.processingInstruction(match[1], match[2]);
+            return end + 2;
+          } else {
+            return -1;
+          }
+        }
+        return -1;
+      }
+      function ElementAttributes() {
+        this.attributeNames = {};
+      }
+      ElementAttributes.prototype = {
+        setTagName: function(tagName) {
+          if (!tagNamePattern.test(tagName)) {
+            throw new Error("invalid tagName:" + tagName);
+          }
+          this.tagName = tagName;
+        },
+        addValue: function(qName, value, offset) {
+          if (!tagNamePattern.test(qName)) {
+            throw new Error("invalid attribute:" + qName);
+          }
+          this.attributeNames[qName] = this.length;
+          this[this.length++] = { qName, value, offset };
+        },
+        length: 0,
+        getLocalName: function(i) {
+          return this[i].localName;
+        },
+        getLocator: function(i) {
+          return this[i].locator;
+        },
+        getQName: function(i) {
+          return this[i].qName;
+        },
+        getURI: function(i) {
+          return this[i].uri;
+        },
+        getValue: function(i) {
+          return this[i].value;
+        }
+      };
+      function split(source, start) {
+        var match;
+        var buf = [];
+        var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
+        reg.lastIndex = start;
+        reg.exec(source);
+        while (match = reg.exec(source)) {
+          buf.push(match);
+          if (match[1])
+            return buf;
+        }
+      }
+      exports.XMLReader = XMLReader;
+      exports.ParseError = ParseError;
+    }
+  });
+
+  // ../../node_modules/@xmldom/xmldom/lib/dom-parser.js
+  var require_dom_parser = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/dom-parser.js"(exports) {
+      var conventions = require_conventions();
+      var dom = require_dom();
+      var entities = require_entities();
+      var sax = require_sax();
+      var DOMImplementation = dom.DOMImplementation;
+      var NAMESPACE = conventions.NAMESPACE;
+      var ParseError = sax.ParseError;
+      var XMLReader = sax.XMLReader;
+      function DOMParser2(options) {
+        this.options = options || { locator: {} };
+      }
+      DOMParser2.prototype.parseFromString = function(source, mimeType) {
+        var options = this.options;
+        var sax2 = new XMLReader();
+        var domBuilder = options.domBuilder || new DOMHandler();
+        var errorHandler = options.errorHandler;
+        var locator = options.locator;
+        var defaultNSMap = options.xmlns || {};
+        var isHTML = /\/x?html?$/.test(mimeType);
+        var entityMap = isHTML ? entities.HTML_ENTITIES : entities.XML_ENTITIES;
+        if (locator) {
+          domBuilder.setDocumentLocator(locator);
+        }
+        sax2.errorHandler = buildErrorHandler(errorHandler, domBuilder, locator);
+        sax2.domBuilder = options.domBuilder || domBuilder;
+        if (isHTML) {
+          defaultNSMap[""] = NAMESPACE.HTML;
+        }
+        defaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;
+        if (source && typeof source === "string") {
+          sax2.parse(source, defaultNSMap, entityMap);
+        } else {
+          sax2.errorHandler.error("invalid doc source");
+        }
+        return domBuilder.doc;
+      };
+      function buildErrorHandler(errorImpl, domBuilder, locator) {
+        if (!errorImpl) {
+          if (domBuilder instanceof DOMHandler) {
+            return domBuilder;
+          }
+          errorImpl = domBuilder;
+        }
+        var errorHandler = {};
+        var isCallback = errorImpl instanceof Function;
+        locator = locator || {};
+        function build(key) {
+          var fn = errorImpl[key];
+          if (!fn && isCallback) {
+            fn = errorImpl.length == 2 ? function(msg) {
+              errorImpl(key, msg);
+            } : errorImpl;
+          }
+          errorHandler[key] = fn && function(msg) {
+            fn("[xmldom " + key + "]	" + msg + _locator(locator));
+          } || function() {
+          };
+        }
+        build("warning");
+        build("error");
+        build("fatalError");
+        return errorHandler;
+      }
+      function DOMHandler() {
+        this.cdata = false;
+      }
+      function position(locator, node) {
+        node.lineNumber = locator.lineNumber;
+        node.columnNumber = locator.columnNumber;
+      }
+      DOMHandler.prototype = {
+        startDocument: function() {
+          this.doc = new DOMImplementation().createDocument(null, null, null);
+          if (this.locator) {
+            this.doc.documentURI = this.locator.systemId;
+          }
+        },
+        startElement: function(namespaceURI, localName, qName, attrs) {
+          var doc = this.doc;
+          var el = doc.createElementNS(namespaceURI, qName || localName);
+          var len = attrs.length;
+          appendElement(this, el);
+          this.currentElement = el;
+          this.locator && position(this.locator, el);
+          for (var i = 0; i < len; i++) {
+            var namespaceURI = attrs.getURI(i);
+            var value = attrs.getValue(i);
+            var qName = attrs.getQName(i);
+            var attr = doc.createAttributeNS(namespaceURI, qName);
+            this.locator && position(attrs.getLocator(i), attr);
+            attr.value = attr.nodeValue = value;
+            el.setAttributeNode(attr);
+          }
+        },
+        endElement: function(namespaceURI, localName, qName) {
+          var current = this.currentElement;
+          var tagName = current.tagName;
+          this.currentElement = current.parentNode;
+        },
+        startPrefixMapping: function(prefix, uri) {
+        },
+        endPrefixMapping: function(prefix) {
+        },
+        processingInstruction: function(target, data) {
+          var ins = this.doc.createProcessingInstruction(target, data);
+          this.locator && position(this.locator, ins);
+          appendElement(this, ins);
+        },
+        ignorableWhitespace: function(ch, start, length) {
+        },
+        characters: function(chars, start, length) {
+          chars = _toString.apply(this, arguments);
+          if (chars) {
+            if (this.cdata) {
+              var charNode = this.doc.createCDATASection(chars);
+            } else {
+              var charNode = this.doc.createTextNode(chars);
+            }
+            if (this.currentElement) {
+              this.currentElement.appendChild(charNode);
+            } else if (/^\s*$/.test(chars)) {
+              this.doc.appendChild(charNode);
+            }
+            this.locator && position(this.locator, charNode);
+          }
+        },
+        skippedEntity: function(name) {
+        },
+        endDocument: function() {
+          this.doc.normalize();
+        },
+        setDocumentLocator: function(locator) {
+          if (this.locator = locator) {
+            locator.lineNumber = 0;
+          }
+        },
+        comment: function(chars, start, length) {
+          chars = _toString.apply(this, arguments);
+          var comm = this.doc.createComment(chars);
+          this.locator && position(this.locator, comm);
+          appendElement(this, comm);
+        },
+        startCDATA: function() {
+          this.cdata = true;
+        },
+        endCDATA: function() {
+          this.cdata = false;
+        },
+        startDTD: function(name, publicId, systemId) {
+          var impl = this.doc.implementation;
+          if (impl && impl.createDocumentType) {
+            var dt = impl.createDocumentType(name, publicId, systemId);
+            this.locator && position(this.locator, dt);
+            appendElement(this, dt);
+            this.doc.doctype = dt;
+          }
+        },
+        warning: function(error) {
+          console.warn("[xmldom warning]	" + error, _locator(this.locator));
+        },
+        error: function(error) {
+          console.error("[xmldom error]	" + error, _locator(this.locator));
+        },
+        fatalError: function(error) {
+          throw new ParseError(error, this.locator);
+        }
+      };
+      function _locator(l) {
+        if (l) {
+          return "\n@" + (l.systemId || "") + "#[line:" + l.lineNumber + ",col:" + l.columnNumber + "]";
+        }
+      }
+      function _toString(chars, start, length) {
+        if (typeof chars == "string") {
+          return chars.substr(start, length);
+        } else {
+          if (chars.length >= start + length || start) {
+            return new java.lang.String(chars, start, length) + "";
+          }
+          return chars;
+        }
+      }
+      "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g, function(key) {
+        DOMHandler.prototype[key] = function() {
+          return null;
+        };
+      });
+      function appendElement(hander, node) {
+        if (!hander.currentElement) {
+          hander.doc.appendChild(node);
+        } else {
+          hander.currentElement.appendChild(node);
+        }
+      }
+      exports.__DOMHandler = DOMHandler;
+      exports.DOMParser = DOMParser2;
+      exports.DOMImplementation = dom.DOMImplementation;
+      exports.XMLSerializer = dom.XMLSerializer;
+    }
+  });
+
+  // ../../node_modules/@xmldom/xmldom/lib/index.js
+  var require_lib = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/index.js"(exports) {
+      var dom = require_dom();
+      exports.DOMImplementation = dom.DOMImplementation;
+      exports.XMLSerializer = dom.XMLSerializer;
+      exports.DOMParser = require_dom_parser().DOMParser;
+    }
+  });
+
+  // src/utils/globals.ts
+  var isBrowser, globals, global_;
+  var init_globals = __esm({
+    "src/utils/globals.ts"() {
+      isBrowser = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+      globals = {
+        self: typeof self !== "undefined" && self,
+        window: typeof window !== "undefined" && window,
+        global: typeof global !== "undefined" && global
+      };
+      global_ = globals.global || globals.self || globals.window;
+    }
+  });
+
+  // src/lib/encoding-indexes.ts
+  var encoding_indexes_default;
+  var init_encoding_indexes = __esm({
+    "src/lib/encoding-indexes.ts"() {
+      encoding_indexes_default = {
+        "ibm866": [1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 9617, 9618, 9619, 9474, 9508, 9569, 9570, 9558, 9557, 9571, 9553, 9559, 9565, 9564, 9563, 9488, 9492, 9524, 9516, 9500, 9472, 9532, 9566, 9567, 9562, 9556, 9577, 9574, 9568, 9552, 9580, 9575, 9576, 9572, 9573, 9561, 9560, 9554, 9555, 9579, 9578, 9496, 9484, 9608, 9604, 9612, 9616, 9600, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1025, 1105, 1028, 1108, 1031, 1111, 1038, 1118, 176, 8729, 183, 8730, 8470, 164, 9632, 160],
+        "iso-8859-2": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 260, 728, 321, 164, 317, 346, 167, 168, 352, 350, 356, 377, 173, 381, 379, 176, 261, 731, 322, 180, 318, 347, 711, 184, 353, 351, 357, 378, 733, 382, 380, 340, 193, 194, 258, 196, 313, 262, 199, 268, 201, 280, 203, 282, 205, 206, 270, 272, 323, 327, 211, 212, 336, 214, 215, 344, 366, 218, 368, 220, 221, 354, 223, 341, 225, 226, 259, 228, 314, 263, 231, 269, 233, 281, 235, 283, 237, 238, 271, 273, 324, 328, 243, 244, 337, 246, 247, 345, 367, 250, 369, 252, 253, 355, 729],
+        "iso-8859-3": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 294, 728, 163, 164, null, 292, 167, 168, 304, 350, 286, 308, 173, null, 379, 176, 295, 178, 179, 180, 181, 293, 183, 184, 305, 351, 287, 309, 189, null, 380, 192, 193, 194, null, 196, 266, 264, 199, 200, 201, 202, 203, 204, 205, 206, 207, null, 209, 210, 211, 212, 288, 214, 215, 284, 217, 218, 219, 220, 364, 348, 223, 224, 225, 226, null, 228, 267, 265, 231, 232, 233, 234, 235, 236, 237, 238, 239, null, 241, 242, 243, 244, 289, 246, 247, 285, 249, 250, 251, 252, 365, 349, 729],
+        "iso-8859-4": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 260, 312, 342, 164, 296, 315, 167, 168, 352, 274, 290, 358, 173, 381, 175, 176, 261, 731, 343, 180, 297, 316, 711, 184, 353, 275, 291, 359, 330, 382, 331, 256, 193, 194, 195, 196, 197, 198, 302, 268, 201, 280, 203, 278, 205, 206, 298, 272, 325, 332, 310, 212, 213, 214, 215, 216, 370, 218, 219, 220, 360, 362, 223, 257, 225, 226, 227, 228, 229, 230, 303, 269, 233, 281, 235, 279, 237, 238, 299, 273, 326, 333, 311, 244, 245, 246, 247, 248, 371, 250, 251, 252, 361, 363, 729],
+        "iso-8859-5": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 173, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 8470, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 167, 1118, 1119],
+        "iso-8859-6": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, null, null, null, 164, null, null, null, null, null, null, null, 1548, 173, null, null, null, null, null, null, null, null, null, null, null, null, null, 1563, null, null, null, 1567, null, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, null, null, null, null, null, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, null, null, null, null, null, null, null, null, null, null, null, null, null],
+        "iso-8859-7": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 8216, 8217, 163, 8364, 8367, 166, 167, 168, 169, 890, 171, 172, 173, null, 8213, 176, 177, 178, 179, 900, 901, 902, 183, 904, 905, 906, 187, 908, 189, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, null, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, null],
+        "iso-8859-8": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, null, 162, 163, 164, 165, 166, 167, 168, 169, 215, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 247, 187, 188, 189, 190, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, 8215, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, null, null, 8206, 8207, null],
+        "iso-8859-10": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 260, 274, 290, 298, 296, 310, 167, 315, 272, 352, 358, 381, 173, 362, 330, 176, 261, 275, 291, 299, 297, 311, 183, 316, 273, 353, 359, 382, 8213, 363, 331, 256, 193, 194, 195, 196, 197, 198, 302, 268, 201, 280, 203, 278, 205, 206, 207, 208, 325, 332, 211, 212, 213, 214, 360, 216, 370, 218, 219, 220, 221, 222, 223, 257, 225, 226, 227, 228, 229, 230, 303, 269, 233, 281, 235, 279, 237, 238, 239, 240, 326, 333, 243, 244, 245, 246, 361, 248, 371, 250, 251, 252, 253, 254, 312],
+        "iso-8859-13": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 8221, 162, 163, 164, 8222, 166, 167, 216, 169, 342, 171, 172, 173, 174, 198, 176, 177, 178, 179, 8220, 181, 182, 183, 248, 185, 343, 187, 188, 189, 190, 230, 260, 302, 256, 262, 196, 197, 280, 274, 268, 201, 377, 278, 290, 310, 298, 315, 352, 323, 325, 211, 332, 213, 214, 215, 370, 321, 346, 362, 220, 379, 381, 223, 261, 303, 257, 263, 228, 229, 281, 275, 269, 233, 378, 279, 291, 311, 299, 316, 353, 324, 326, 243, 333, 245, 246, 247, 371, 322, 347, 363, 252, 380, 382, 8217],
+        "iso-8859-14": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 7682, 7683, 163, 266, 267, 7690, 167, 7808, 169, 7810, 7691, 7922, 173, 174, 376, 7710, 7711, 288, 289, 7744, 7745, 182, 7766, 7809, 7767, 7811, 7776, 7923, 7812, 7813, 7777, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 372, 209, 210, 211, 212, 213, 214, 7786, 216, 217, 218, 219, 220, 221, 374, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 373, 241, 242, 243, 244, 245, 246, 7787, 248, 249, 250, 251, 252, 253, 375, 255],
+        "iso-8859-15": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 8364, 165, 352, 167, 353, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 381, 181, 182, 183, 382, 185, 186, 187, 338, 339, 376, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255],
+        "iso-8859-16": [128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 260, 261, 321, 8364, 8222, 352, 167, 353, 169, 536, 171, 377, 173, 378, 379, 176, 177, 268, 322, 381, 8221, 182, 183, 382, 269, 537, 187, 338, 339, 376, 380, 192, 193, 194, 258, 196, 262, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 272, 323, 210, 211, 212, 336, 214, 346, 368, 217, 218, 219, 220, 280, 538, 223, 224, 225, 226, 259, 228, 263, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 273, 324, 242, 243, 244, 337, 246, 347, 369, 249, 250, 251, 252, 281, 539, 255],
+        "koi8-r": [9472, 9474, 9484, 9488, 9492, 9496, 9500, 9508, 9516, 9524, 9532, 9600, 9604, 9608, 9612, 9616, 9617, 9618, 9619, 8992, 9632, 8729, 8730, 8776, 8804, 8805, 160, 8993, 176, 178, 183, 247, 9552, 9553, 9554, 1105, 9555, 9556, 9557, 9558, 9559, 9560, 9561, 9562, 9563, 9564, 9565, 9566, 9567, 9568, 9569, 1025, 9570, 9571, 9572, 9573, 9574, 9575, 9576, 9577, 9578, 9579, 9580, 169, 1102, 1072, 1073, 1094, 1076, 1077, 1092, 1075, 1093, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1103, 1088, 1089, 1090, 1091, 1078, 1074, 1100, 1099, 1079, 1096, 1101, 1097, 1095, 1098, 1070, 1040, 1041, 1062, 1044, 1045, 1060, 1043, 1061, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1071, 1056, 1057, 1058, 1059, 1046, 1042, 1068, 1067, 1047, 1064, 1069, 1065, 1063, 1066],
+        "koi8-u": [9472, 9474, 9484, 9488, 9492, 9496, 9500, 9508, 9516, 9524, 9532, 9600, 9604, 9608, 9612, 9616, 9617, 9618, 9619, 8992, 9632, 8729, 8730, 8776, 8804, 8805, 160, 8993, 176, 178, 183, 247, 9552, 9553, 9554, 1105, 1108, 9556, 1110, 1111, 9559, 9560, 9561, 9562, 9563, 1169, 1118, 9566, 9567, 9568, 9569, 1025, 1028, 9571, 1030, 1031, 9574, 9575, 9576, 9577, 9578, 1168, 1038, 169, 1102, 1072, 1073, 1094, 1076, 1077, 1092, 1075, 1093, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1103, 1088, 1089, 1090, 1091, 1078, 1074, 1100, 1099, 1079, 1096, 1101, 1097, 1095, 1098, 1070, 1040, 1041, 1062, 1044, 1045, 1060, 1043, 1061, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1071, 1056, 1057, 1058, 1059, 1046, 1042, 1068, 1067, 1047, 1064, 1069, 1065, 1063, 1066],
+        "macintosh": [196, 197, 199, 201, 209, 214, 220, 225, 224, 226, 228, 227, 229, 231, 233, 232, 234, 235, 237, 236, 238, 239, 241, 243, 242, 244, 246, 245, 250, 249, 251, 252, 8224, 176, 162, 163, 167, 8226, 182, 223, 174, 169, 8482, 180, 168, 8800, 198, 216, 8734, 177, 8804, 8805, 165, 181, 8706, 8721, 8719, 960, 8747, 170, 186, 937, 230, 248, 191, 161, 172, 8730, 402, 8776, 8710, 171, 187, 8230, 160, 192, 195, 213, 338, 339, 8211, 8212, 8220, 8221, 8216, 8217, 247, 9674, 255, 376, 8260, 8364, 8249, 8250, 64257, 64258, 8225, 183, 8218, 8222, 8240, 194, 202, 193, 203, 200, 205, 206, 207, 204, 211, 212, 63743, 210, 218, 219, 217, 305, 710, 732, 175, 728, 729, 730, 184, 733, 731, 711],
+        "windows-874": [8364, 129, 130, 131, 132, 8230, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 153, 154, 155, 156, 157, 158, 159, 160, 3585, 3586, 3587, 3588, 3589, 3590, 3591, 3592, 3593, 3594, 3595, 3596, 3597, 3598, 3599, 3600, 3601, 3602, 3603, 3604, 3605, 3606, 3607, 3608, 3609, 3610, 3611, 3612, 3613, 3614, 3615, 3616, 3617, 3618, 3619, 3620, 3621, 3622, 3623, 3624, 3625, 3626, 3627, 3628, 3629, 3630, 3631, 3632, 3633, 3634, 3635, 3636, 3637, 3638, 3639, 3640, 3641, 3642, null, null, null, null, 3647, 3648, 3649, 3650, 3651, 3652, 3653, 3654, 3655, 3656, 3657, 3658, 3659, 3660, 3661, 3662, 3663, 3664, 3665, 3666, 3667, 3668, 3669, 3670, 3671, 3672, 3673, 3674, 3675, null, null, null, null],
+        "windows-1250": [8364, 129, 8218, 131, 8222, 8230, 8224, 8225, 136, 8240, 352, 8249, 346, 356, 381, 377, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 353, 8250, 347, 357, 382, 378, 160, 711, 728, 321, 164, 260, 166, 167, 168, 169, 350, 171, 172, 173, 174, 379, 176, 177, 731, 322, 180, 181, 182, 183, 184, 261, 351, 187, 317, 733, 318, 380, 340, 193, 194, 258, 196, 313, 262, 199, 268, 201, 280, 203, 282, 205, 206, 270, 272, 323, 327, 211, 212, 336, 214, 215, 344, 366, 218, 368, 220, 221, 354, 223, 341, 225, 226, 259, 228, 314, 263, 231, 269, 233, 281, 235, 283, 237, 238, 271, 273, 324, 328, 243, 244, 337, 246, 247, 345, 367, 250, 369, 252, 253, 355, 729],
+        "windows-1251": [1026, 1027, 8218, 1107, 8222, 8230, 8224, 8225, 8364, 8240, 1033, 8249, 1034, 1036, 1035, 1039, 1106, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 1113, 8250, 1114, 1116, 1115, 1119, 160, 1038, 1118, 1032, 164, 1168, 166, 167, 1025, 169, 1028, 171, 172, 173, 174, 1031, 176, 177, 1030, 1110, 1169, 181, 182, 183, 1105, 8470, 1108, 187, 1112, 1029, 1109, 1111, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103],
+        "windows-1252": [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 141, 381, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, 157, 382, 376, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255],
+        "windows-1253": [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 136, 8240, 138, 8249, 140, 141, 142, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 154, 8250, 156, 157, 158, 159, 160, 901, 902, 163, 164, 165, 166, 167, 168, 169, null, 171, 172, 173, 174, 8213, 176, 177, 178, 179, 900, 181, 182, 183, 904, 905, 906, 187, 908, 189, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, null, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, null],
+        "windows-1254": [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 141, 142, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, 157, 158, 376, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 286, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 304, 350, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 287, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 305, 351, 255],
+        "windows-1255": [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 138, 8249, 140, 141, 142, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 154, 8250, 156, 157, 158, 159, 160, 161, 162, 163, 8362, 165, 166, 167, 168, 169, 215, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 247, 187, 188, 189, 190, 191, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1520, 1521, 1522, 1523, 1524, null, null, null, null, null, null, null, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, null, null, 8206, 8207, null],
+        "windows-1256": [8364, 1662, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 1657, 8249, 338, 1670, 1688, 1672, 1711, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 1705, 8482, 1681, 8250, 339, 8204, 8205, 1722, 160, 1548, 162, 163, 164, 165, 166, 167, 168, 169, 1726, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 1563, 187, 188, 189, 190, 1567, 1729, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 215, 1591, 1592, 1593, 1594, 1600, 1601, 1602, 1603, 224, 1604, 226, 1605, 1606, 1607, 1608, 231, 232, 233, 234, 235, 1609, 1610, 238, 239, 1611, 1612, 1613, 1614, 244, 1615, 1616, 247, 1617, 249, 1618, 251, 252, 8206, 8207, 1746],
+        "windows-1257": [8364, 129, 8218, 131, 8222, 8230, 8224, 8225, 136, 8240, 138, 8249, 140, 168, 711, 184, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 152, 8482, 154, 8250, 156, 175, 731, 159, 160, null, 162, 163, 164, null, 166, 167, 216, 169, 342, 171, 172, 173, 174, 198, 176, 177, 178, 179, 180, 181, 182, 183, 248, 185, 343, 187, 188, 189, 190, 230, 260, 302, 256, 262, 196, 197, 280, 274, 268, 201, 377, 278, 290, 310, 298, 315, 352, 323, 325, 211, 332, 213, 214, 215, 370, 321, 346, 362, 220, 379, 381, 223, 261, 303, 257, 263, 228, 229, 281, 275, 269, 233, 378, 279, 291, 311, 299, 316, 353, 324, 326, 243, 333, 245, 246, 247, 371, 322, 347, 363, 252, 380, 382, 729],
+        "windows-1258": [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 138, 8249, 338, 141, 142, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 154, 8250, 339, 157, 158, 376, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 258, 196, 197, 198, 199, 200, 201, 202, 203, 768, 205, 206, 207, 272, 209, 777, 211, 212, 416, 214, 215, 216, 217, 218, 219, 220, 431, 771, 223, 224, 225, 226, 259, 228, 229, 230, 231, 232, 233, 234, 235, 769, 237, 238, 239, 273, 241, 803, 243, 244, 417, 246, 247, 248, 249, 250, 251, 252, 432, 8363, 255],
+        "x-mac-cyrillic": [1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 8224, 176, 1168, 163, 167, 8226, 182, 1030, 174, 169, 8482, 1026, 1106, 8800, 1027, 1107, 8734, 177, 8804, 8805, 1110, 181, 1169, 1032, 1028, 1108, 1031, 1111, 1033, 1113, 1034, 1114, 1112, 1029, 172, 8730, 402, 8776, 8710, 171, 187, 8230, 160, 1035, 1115, 1036, 1116, 1109, 8211, 8212, 8220, 8221, 8216, 8217, 247, 8222, 1038, 1118, 1039, 1119, 8470, 1025, 1105, 1103, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 8364]
+      };
+    }
+  });
+
+  // src/lib/encoding.ts
+  function inRange(a, min, max) {
+    return min <= a && a <= max;
+  }
+  function includes(array, item) {
+    return array.indexOf(item) !== -1;
+  }
+  function ToDictionary(o) {
+    if (o === void 0)
+      return {};
+    if (o === Object(o))
+      return o;
+    throw TypeError("Could not convert argument to dictionary");
+  }
+  function stringToCodePoints(string) {
+    var s = String(string);
+    var n = s.length;
+    var i = 0;
+    var u = [];
+    while (i < n) {
+      var c = s.charCodeAt(i);
+      if (c < 55296 || c > 57343) {
+        u.push(c);
+      } else if (56320 <= c && c <= 57343) {
+        u.push(65533);
+      } else if (55296 <= c && c <= 56319) {
+        if (i === n - 1) {
+          u.push(65533);
+        } else {
+          var d = s.charCodeAt(i + 1);
+          if (56320 <= d && d <= 57343) {
+            var a = c & 1023;
+            var b = d & 1023;
+            u.push(65536 + (a << 10) + b);
+            i += 1;
+          } else {
+            u.push(65533);
+          }
+        }
+      }
+      i += 1;
+    }
+    return u;
+  }
+  function codePointsToString(code_points) {
+    var s = "";
+    for (var i = 0; i < code_points.length; ++i) {
+      var cp = code_points[i];
+      if (cp <= 65535) {
+        s += String.fromCharCode(cp);
+      } else {
+        cp -= 65536;
+        s += String.fromCharCode((cp >> 10) + 55296, (cp & 1023) + 56320);
+      }
+    }
+    return s;
+  }
+  function isASCIIByte(a) {
+    return 0 <= a && a <= 127;
+  }
+  function Stream(tokens) {
+    this.tokens = [].slice.call(tokens);
+    this.tokens.reverse();
+  }
+  function decoderError(fatal, opt_code_point) {
+    if (fatal)
+      throw TypeError("Decoder error");
+    return opt_code_point || 65533;
+  }
+  function encoderError(code_point) {
+    throw TypeError("The code point " + code_point + " could not be encoded.");
+  }
+  function Decoder() {
+  }
+  function Encoder() {
+  }
+  function getEncoding(label) {
+    label = String(label).trim().toLowerCase();
+    if (Object.prototype.hasOwnProperty.call(label_to_encoding, label)) {
+      return label_to_encoding[label];
+    }
+    return null;
+  }
+  function indexCodePointFor(pointer, index2) {
+    if (!index2)
+      return null;
+    return index2[pointer] || null;
+  }
+  function indexPointerFor(code_point, index2) {
+    var pointer = index2.indexOf(code_point);
+    return pointer === -1 ? null : pointer;
+  }
+  function index(name) {
+    if (!("encoding-indexes" in global)) {
+      throw Error("Indexes missing. Did you forget to include encoding-indexes.js first?");
+    }
+    return global["encoding-indexes"][name];
+  }
+  function indexGB18030RangesCodePointFor(pointer) {
+    if (pointer > 39419 && pointer < 189e3 || pointer > 1237575)
+      return null;
+    if (pointer === 7457)
+      return 59335;
+    var offset = 0;
+    var code_point_offset = 0;
+    var idx = index("gb18030-ranges");
+    var i;
+    for (i = 0; i < idx.length; ++i) {
+      var entry = idx[i];
+      if (entry[0] <= pointer) {
+        offset = entry[0];
+        code_point_offset = entry[1];
+      } else {
+        break;
+      }
+    }
+    return code_point_offset + pointer - offset;
+  }
+  function indexGB18030RangesPointerFor(code_point) {
+    if (code_point === 59335)
+      return 7457;
+    var offset = 0;
+    var pointer_offset = 0;
+    var idx = index("gb18030-ranges");
+    var i;
+    for (i = 0; i < idx.length; ++i) {
+      var entry = idx[i];
+      if (entry[1] <= code_point) {
+        offset = entry[1];
+        pointer_offset = entry[0];
+      } else {
+        break;
+      }
+    }
+    return pointer_offset + code_point - offset;
+  }
+  function indexShiftJISPointerFor(code_point) {
+    shift_jis_index = shift_jis_index || index("jis0208").map(function(code_point2, pointer) {
+      return inRange(pointer, 8272, 8835) ? null : code_point2;
+    });
+    var index_ = shift_jis_index;
+    return index_.indexOf(code_point);
+  }
+  function indexBig5PointerFor(code_point) {
+    big5_index_no_hkscs = big5_index_no_hkscs || index("big5").map(function(code_point2, pointer) {
+      return pointer < (161 - 129) * 157 ? null : code_point2;
+    });
+    var index_ = big5_index_no_hkscs;
+    if (code_point === 9552 || code_point === 9566 || code_point === 9569 || code_point === 9578 || code_point === 21313 || code_point === 21317) {
+      return index_.lastIndexOf(code_point);
+    }
+    return indexPointerFor(code_point, index_);
+  }
+  function TextDecoder(label, options) {
+    if (!(this instanceof TextDecoder))
+      throw TypeError("Called as a function. Did you forget 'new'?");
+    label = label !== void 0 ? String(label) : DEFAULT_ENCODING;
+    options = ToDictionary(options);
+    this._encoding = null;
+    this._decoder = null;
+    this._ignoreBOM = false;
+    this._BOMseen = false;
+    this._error_mode = "replacement";
+    this._do_not_flush = false;
+    var encoding = getEncoding(label);
+    if (encoding === null || encoding.name === "replacement")
+      throw RangeError("Unknown encoding: " + label);
+    if (!decoders[encoding.name]) {
+      throw Error("Decoder not present. Did you forget to include encoding-indexes.js first?");
+    }
+    var dec = this;
+    dec._encoding = encoding;
+    if (Boolean(options["fatal"]))
+      dec._error_mode = "fatal";
+    if (Boolean(options["ignoreBOM"]))
+      dec._ignoreBOM = true;
+    if (!Object.defineProperty) {
+      this.encoding = dec._encoding.name.toLowerCase();
+      this.fatal = dec._error_mode === "fatal";
+      this.ignoreBOM = dec._ignoreBOM;
+    }
+    return dec;
+  }
+  function TextEncoder(label, options) {
+    if (!(this instanceof TextEncoder))
+      throw TypeError("Called as a function. Did you forget 'new'?");
+    options = ToDictionary(options);
+    this._encoding = null;
+    this._encoder = null;
+    this._do_not_flush = false;
+    this._fatal = Boolean(options["fatal"]) ? "fatal" : "replacement";
+    var enc = this;
+    if (Boolean(options["NONSTANDARD_allowLegacyEncoding"])) {
+      label = label !== void 0 ? String(label) : DEFAULT_ENCODING;
+      var encoding = getEncoding(label);
+      if (encoding === null || encoding.name === "replacement")
+        throw RangeError("Unknown encoding: " + label);
+      if (!encoders[encoding.name]) {
+        throw Error("Encoder not present. Did you forget to include encoding-indexes.js first?");
+      }
+      enc._encoding = encoding;
+    } else {
+      enc._encoding = getEncoding("utf-8");
+      if (label !== void 0 && "console" in global) {
+        console.warn("TextEncoder constructor called with encoding label, which is ignored.");
+      }
+    }
+    if (!Object.defineProperty)
+      this.encoding = enc._encoding.name.toLowerCase();
+    return enc;
+  }
+  function UTF8Decoder(options) {
+    var fatal = options.fatal;
+    var utf8_code_point = 0, utf8_bytes_seen = 0, utf8_bytes_needed = 0, utf8_lower_boundary = 128, utf8_upper_boundary = 191;
+    this.handler = function(stream, bite) {
+      if (bite === end_of_stream && utf8_bytes_needed !== 0) {
+        utf8_bytes_needed = 0;
+        return decoderError(fatal);
+      }
+      if (bite === end_of_stream)
+        return finished;
+      if (utf8_bytes_needed === 0) {
+        if (inRange(bite, 0, 127)) {
+          return bite;
+        } else if (inRange(bite, 194, 223)) {
+          utf8_bytes_needed = 1;
+          utf8_code_point = bite & 31;
+        } else if (inRange(bite, 224, 239)) {
+          if (bite === 224)
+            utf8_lower_boundary = 160;
+          if (bite === 237)
+            utf8_upper_boundary = 159;
+          utf8_bytes_needed = 2;
+          utf8_code_point = bite & 15;
+        } else if (inRange(bite, 240, 244)) {
+          if (bite === 240)
+            utf8_lower_boundary = 144;
+          if (bite === 244)
+            utf8_upper_boundary = 143;
+          utf8_bytes_needed = 3;
+          utf8_code_point = bite & 7;
+        } else {
+          return decoderError(fatal);
+        }
+        return null;
+      }
+      if (!inRange(bite, utf8_lower_boundary, utf8_upper_boundary)) {
+        utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
+        utf8_lower_boundary = 128;
+        utf8_upper_boundary = 191;
+        stream.prepend(bite);
+        return decoderError(fatal);
+      }
+      utf8_lower_boundary = 128;
+      utf8_upper_boundary = 191;
+      utf8_code_point = utf8_code_point << 6 | bite & 63;
+      utf8_bytes_seen += 1;
+      if (utf8_bytes_seen !== utf8_bytes_needed)
+        return null;
+      var code_point = utf8_code_point;
+      utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
+      return code_point;
+    };
+  }
+  function UTF8Encoder(options) {
+    var fatal = options.fatal;
+    this.handler = function(stream, code_point) {
+      if (code_point === end_of_stream)
+        return finished;
+      if (isASCIICodePoint(code_point))
+        return code_point;
+      var count, offset;
+      if (inRange(code_point, 128, 2047)) {
+        count = 1;
+        offset = 192;
+      } else if (inRange(code_point, 2048, 65535)) {
+        count = 2;
+        offset = 224;
+      } else if (inRange(code_point, 65536, 1114111)) {
+        count = 3;
+        offset = 240;
+      }
+      var bytes = [(code_point >> 6 * count) + offset];
+      while (count > 0) {
+        var temp = code_point >> 6 * (count - 1);
+        bytes.push(128 | temp & 63);
+        count -= 1;
+      }
+      return bytes;
+    };
+  }
+  function SingleByteDecoder(index2, options) {
+    var fatal = options.fatal;
+    this.handler = function(stream, bite) {
+      if (bite === end_of_stream)
+        return finished;
+      if (isASCIIByte(bite))
+        return bite;
+      var code_point = index2[bite - 128];
+      if (code_point === null)
+        return decoderError(fatal);
+      return code_point;
+    };
+  }
+  function SingleByteEncoder(index2, options) {
+    var fatal = options.fatal;
+    this.handler = function(stream, code_point) {
+      if (code_point === end_of_stream)
+        return finished;
+      if (isASCIICodePoint(code_point))
+        return code_point;
+      var pointer = indexPointerFor(code_point, index2);
+      if (pointer === null)
+        encoderError(code_point);
+      return pointer + 128;
+    };
+  }
+  function GB18030Decoder(options) {
+    var fatal = options.fatal;
+    var gb18030_first = 0, gb18030_second = 0, gb18030_third = 0;
+    this.handler = function(stream, bite) {
+      if (bite === end_of_stream && gb18030_first === 0 && gb18030_second === 0 && gb18030_third === 0) {
+        return finished;
+      }
+      if (bite === end_of_stream && (gb18030_first !== 0 || gb18030_second !== 0 || gb18030_third !== 0)) {
+        gb18030_first = 0;
+        gb18030_second = 0;
+        gb18030_third = 0;
+        decoderError(fatal);
+      }
+      var code_point;
+      if (gb18030_third !== 0) {
+        code_point = null;
+        if (inRange(bite, 48, 57)) {
+          code_point = indexGB18030RangesCodePointFor((((gb18030_first - 129) * 10 + gb18030_second - 48) * 126 + gb18030_third - 129) * 10 + bite - 48);
+        }
+        var buffer = [gb18030_second, gb18030_third, bite];
+        gb18030_first = 0;
+        gb18030_second = 0;
+        gb18030_third = 0;
+        if (code_point === null) {
+          stream.prepend(buffer);
+          return decoderError(fatal);
+        }
+        return code_point;
+      }
+      if (gb18030_second !== 0) {
+        if (inRange(bite, 129, 254)) {
+          gb18030_third = bite;
+          return null;
+        }
+        stream.prepend([gb18030_second, bite]);
+        gb18030_first = 0;
+        gb18030_second = 0;
+        return decoderError(fatal);
+      }
+      if (gb18030_first !== 0) {
+        if (inRange(bite, 48, 57)) {
+          gb18030_second = bite;
+          return null;
+        }
+        var lead = gb18030_first;
+        var pointer = null;
+        gb18030_first = 0;
+        var offset = bite < 127 ? 64 : 65;
+        if (inRange(bite, 64, 126) || inRange(bite, 128, 254))
+          pointer = (lead - 129) * 190 + (bite - offset);
+        code_point = pointer === null ? null : indexCodePointFor(pointer, index("gb18030"));
+        if (code_point === null && isASCIIByte(bite))
+          stream.prepend(bite);
+        if (code_point === null)
+          return decoderError(fatal);
+        return code_point;
+      }
+      if (isASCIIByte(bite))
+        return bite;
+      if (bite === 128)
+        return 8364;
+      if (inRange(bite, 129, 254)) {
+        gb18030_first = bite;
+        return null;
+      }
+      return decoderError(fatal);
+    };
+  }
+  function GB18030Encoder(options, gbk_flag) {
+    var fatal = options.fatal;
+    this.handler = function(stream, code_point) {
+      if (code_point === end_of_stream)
+        return finished;
+      if (isASCIICodePoint(code_point))
+        return code_point;
+      if (code_point === 58853)
+        return encoderError(code_point);
+      if (gbk_flag && code_point === 8364)
+        return 128;
+      var pointer = indexPointerFor(code_point, index("gb18030"));
+      if (pointer !== null) {
+        var lead = floor(pointer / 190) + 129;
+        var trail = pointer % 190;
+        var offset = trail < 63 ? 64 : 65;
+        return [lead, trail + offset];
+      }
+      if (gbk_flag)
+        return encoderError(code_point);
+      pointer = indexGB18030RangesPointerFor(code_point);
+      var byte1 = floor(pointer / 10 / 126 / 10);
+      pointer = pointer - byte1 * 10 * 126 * 10;
+      var byte2 = floor(pointer / 10 / 126);
+      pointer = pointer - byte2 * 10 * 126;
+      var byte3 = floor(pointer / 10);
+      var byte4 = pointer - byte3 * 10;
+      return [byte1 + 129, byte2 + 48, byte3 + 129, byte4 + 48];
+    };
+  }
+  function Big5Decoder(options) {
+    var fatal = options.fatal;
+    var Big5_lead = 0;
+    this.handler = function(stream, bite) {
+      if (bite === end_of_stream && Big5_lead !== 0) {
+        Big5_lead = 0;
+        return decoderError(fatal);
+      }
+      if (bite === end_of_stream && Big5_lead === 0)
+        return finished;
+      if (Big5_lead !== 0) {
+        var lead = Big5_lead;
+        var pointer = null;
+        Big5_lead = 0;
+        var offset = bite < 127 ? 64 : 98;
+        if (inRange(bite, 64, 126) || inRange(bite, 161, 254))
+          pointer = (lead - 129) * 157 + (bite - offset);
+        switch (pointer) {
+          case 1133:
+            return [202, 772];
+          case 1135:
+            return [202, 780];
+          case 1164:
+            return [234, 772];
+          case 1166:
+            return [234, 780];
+        }
+        var code_point = pointer === null ? null : indexCodePointFor(pointer, index("big5"));
+        if (code_point === null && isASCIIByte(bite))
+          stream.prepend(bite);
+        if (code_point === null)
+          return decoderError(fatal);
+        return code_point;
+      }
+      if (isASCIIByte(bite))
+        return bite;
+      if (inRange(bite, 129, 254)) {
+        Big5_lead = bite;
+        return null;
+      }
+      return decoderError(fatal);
+    };
+  }
+  function Big5Encoder(options) {
+    var fatal = options.fatal;
+    this.handler = function(stream, code_point) {
+      if (code_point === end_of_stream)
+        return finished;
+      if (isASCIICodePoint(code_point))
+        return code_point;
+      var pointer = indexBig5PointerFor(code_point);
+      if (pointer === null)
+        return encoderError(code_point);
+      var lead = floor(pointer / 157) + 129;
+      if (lead < 161)
+        return encoderError(code_point);
+      var trail = pointer % 157;
+      var offset = trail < 63 ? 64 : 98;
+      return [lead, trail + offset];
+    };
+  }
+  function EUCJPDecoder(options) {
+    var fatal = options.fatal;
+    var eucjp_jis0212_flag = false, eucjp_lead = 0;
+    this.handler = function(stream, bite) {
+      if (bite === end_of_stream && eucjp_lead !== 0) {
+        eucjp_lead = 0;
+        return decoderError(fatal);
+      }
+      if (bite === end_of_stream && eucjp_lead === 0)
+        return finished;
+      if (eucjp_lead === 142 && inRange(bite, 161, 223)) {
+        eucjp_lead = 0;
+        return 65377 - 161 + bite;
+      }
+      if (eucjp_lead === 143 && inRange(bite, 161, 254)) {
+        eucjp_jis0212_flag = true;
+        eucjp_lead = bite;
+        return null;
+      }
+      if (eucjp_lead !== 0) {
+        var lead = eucjp_lead;
+        eucjp_lead = 0;
+        var code_point = null;
+        if (inRange(lead, 161, 254) && inRange(bite, 161, 254)) {
+          code_point = indexCodePointFor((lead - 161) * 94 + (bite - 161), index(!eucjp_jis0212_flag ? "jis0208" : "jis0212"));
+        }
+        eucjp_jis0212_flag = false;
+        if (!inRange(bite, 161, 254))
+          stream.prepend(bite);
+        if (code_point === null)
+          return decoderError(fatal);
+        return code_point;
+      }
+      if (isASCIIByte(bite))
+        return bite;
+      if (bite === 142 || bite === 143 || inRange(bite, 161, 254)) {
+        eucjp_lead = bite;
+        return null;
+      }
+      return decoderError(fatal);
+    };
+  }
+  function EUCJPEncoder(options) {
+    var fatal = options.fatal;
+    this.handler = function(stream, code_point) {
+      if (code_point === end_of_stream)
+        return finished;
+      if (isASCIICodePoint(code_point))
+        return code_point;
+      if (code_point === 165)
+        return 92;
+      if (code_point === 8254)
+        return 126;
+      if (inRange(code_point, 65377, 65439))
+        return [142, code_point - 65377 + 161];
+      if (code_point === 8722)
+        code_point = 65293;
+      var pointer = indexPointerFor(code_point, index("jis0208"));
+      if (pointer === null)
+        return encoderError(code_point);
+      var lead = floor(pointer / 94) + 161;
+      var trail = pointer % 94 + 161;
+      return [lead, trail];
+    };
+  }
+  function ISO2022JPDecoder(options) {
+    var fatal = options.fatal;
+    var states = {
+      ASCII: 0,
+      Roman: 1,
+      Katakana: 2,
+      LeadByte: 3,
+      TrailByte: 4,
+      EscapeStart: 5,
+      Escape: 6
+    };
+    var iso2022jp_decoder_state = states.ASCII, iso2022jp_decoder_output_state = states.ASCII, iso2022jp_lead = 0, iso2022jp_output_flag = false;
+    this.handler = function(stream, bite) {
+      switch (iso2022jp_decoder_state) {
+        default:
+        case states.ASCII:
+          if (bite === 27) {
+            iso2022jp_decoder_state = states.EscapeStart;
+            return null;
+          }
+          if (inRange(bite, 0, 127) && bite !== 14 && bite !== 15 && bite !== 27) {
+            iso2022jp_output_flag = false;
+            return bite;
+          }
+          if (bite === end_of_stream) {
+            return finished;
+          }
+          iso2022jp_output_flag = false;
+          return decoderError(fatal);
+        case states.Roman:
+          if (bite === 27) {
+            iso2022jp_decoder_state = states.EscapeStart;
+            return null;
+          }
+          if (bite === 92) {
+            iso2022jp_output_flag = false;
+            return 165;
+          }
+          if (bite === 126) {
+            iso2022jp_output_flag = false;
+            return 8254;
+          }
+          if (inRange(bite, 0, 127) && bite !== 14 && bite !== 15 && bite !== 27 && bite !== 92 && bite !== 126) {
+            iso2022jp_output_flag = false;
+            return bite;
+          }
+          if (bite === end_of_stream) {
+            return finished;
+          }
+          iso2022jp_output_flag = false;
+          return decoderError(fatal);
+        case states.Katakana:
+          if (bite === 27) {
+            iso2022jp_decoder_state = states.EscapeStart;
+            return null;
+          }
+          if (inRange(bite, 33, 95)) {
+            iso2022jp_output_flag = false;
+            return 65377 - 33 + bite;
+          }
+          if (bite === end_of_stream) {
+            return finished;
+          }
+          iso2022jp_output_flag = false;
+          return decoderError(fatal);
+        case states.LeadByte:
+          if (bite === 27) {
+            iso2022jp_decoder_state = states.EscapeStart;
+            return null;
+          }
+          if (inRange(bite, 33, 126)) {
+            iso2022jp_output_flag = false;
+            iso2022jp_lead = bite;
+            iso2022jp_decoder_state = states.TrailByte;
+            return null;
+          }
+          if (bite === end_of_stream) {
+            return finished;
+          }
+          iso2022jp_output_flag = false;
+          return decoderError(fatal);
+        case states.TrailByte:
+          if (bite === 27) {
+            iso2022jp_decoder_state = states.EscapeStart;
+            return decoderError(fatal);
+          }
+          if (inRange(bite, 33, 126)) {
+            iso2022jp_decoder_state = states.LeadByte;
+            var pointer = (iso2022jp_lead - 33) * 94 + bite - 33;
+            var code_point = indexCodePointFor(pointer, index("jis0208"));
+            if (code_point === null)
+              return decoderError(fatal);
+            return code_point;
+          }
+          if (bite === end_of_stream) {
+            iso2022jp_decoder_state = states.LeadByte;
+            stream.prepend(bite);
+            return decoderError(fatal);
+          }
+          iso2022jp_decoder_state = states.LeadByte;
+          return decoderError(fatal);
+        case states.EscapeStart:
+          if (bite === 36 || bite === 40) {
+            iso2022jp_lead = bite;
+            iso2022jp_decoder_state = states.Escape;
+            return null;
+          }
+          stream.prepend(bite);
+          iso2022jp_output_flag = false;
+          iso2022jp_decoder_state = iso2022jp_decoder_output_state;
+          return decoderError(fatal);
+        case states.Escape:
+          var lead = iso2022jp_lead;
+          iso2022jp_lead = 0;
+          var state = null;
+          if (lead === 40 && bite === 66)
+            state = states.ASCII;
+          if (lead === 40 && bite === 74)
+            state = states.Roman;
+          if (lead === 40 && bite === 73)
+            state = states.Katakana;
+          if (lead === 36 && (bite === 64 || bite === 66))
+            state = states.LeadByte;
+          if (state !== null) {
+            iso2022jp_decoder_state = iso2022jp_decoder_state = state;
+            var output_flag = iso2022jp_output_flag;
+            iso2022jp_output_flag = true;
+            return !output_flag ? null : decoderError(fatal);
+          }
+          stream.prepend([lead, bite]);
+          iso2022jp_output_flag = false;
+          iso2022jp_decoder_state = iso2022jp_decoder_output_state;
+          return decoderError(fatal);
+      }
+    };
+  }
+  function ISO2022JPEncoder(options) {
+    var fatal = options.fatal;
+    var states = {
+      ASCII: 0,
+      Roman: 1,
+      jis0208: 2
+    };
+    var iso2022jp_state = states.ASCII;
+    this.handler = function(stream, code_point) {
+      if (code_point === end_of_stream && iso2022jp_state !== states.ASCII) {
+        stream.prepend(code_point);
+        iso2022jp_state = states.ASCII;
+        return [27, 40, 66];
+      }
+      if (code_point === end_of_stream && iso2022jp_state === states.ASCII)
+        return finished;
+      if ((iso2022jp_state === states.ASCII || iso2022jp_state === states.Roman) && (code_point === 14 || code_point === 15 || code_point === 27)) {
+        return encoderError(65533);
+      }
+      if (iso2022jp_state === states.ASCII && isASCIICodePoint(code_point))
+        return code_point;
+      if (iso2022jp_state === states.Roman && (isASCIICodePoint(code_point) && code_point !== 92 && code_point !== 126 || code_point == 165 || code_point == 8254)) {
+        if (isASCIICodePoint(code_point))
+          return code_point;
+        if (code_point === 165)
+          return 92;
+        if (code_point === 8254)
+          return 126;
+      }
+      if (isASCIICodePoint(code_point) && iso2022jp_state !== states.ASCII) {
+        stream.prepend(code_point);
+        iso2022jp_state = states.ASCII;
+        return [27, 40, 66];
+      }
+      if ((code_point === 165 || code_point === 8254) && iso2022jp_state !== states.Roman) {
+        stream.prepend(code_point);
+        iso2022jp_state = states.Roman;
+        return [27, 40, 74];
+      }
+      if (code_point === 8722)
+        code_point = 65293;
+      var pointer = indexPointerFor(code_point, index("jis0208"));
+      if (pointer === null)
+        return encoderError(code_point);
+      if (iso2022jp_state !== states.jis0208) {
+        stream.prepend(code_point);
+        iso2022jp_state = states.jis0208;
+        return [27, 36, 66];
+      }
+      var lead = floor(pointer / 94) + 33;
+      var trail = pointer % 94 + 33;
+      return [lead, trail];
+    };
+  }
+  function ShiftJISDecoder(options) {
+    var fatal = options.fatal;
+    var Shift_JIS_lead = 0;
+    this.handler = function(stream, bite) {
+      if (bite === end_of_stream && Shift_JIS_lead !== 0) {
+        Shift_JIS_lead = 0;
+        return decoderError(fatal);
+      }
+      if (bite === end_of_stream && Shift_JIS_lead === 0)
+        return finished;
+      if (Shift_JIS_lead !== 0) {
+        var lead = Shift_JIS_lead;
+        var pointer = null;
+        Shift_JIS_lead = 0;
+        var offset = bite < 127 ? 64 : 65;
+        var lead_offset = lead < 160 ? 129 : 193;
+        if (inRange(bite, 64, 126) || inRange(bite, 128, 252))
+          pointer = (lead - lead_offset) * 188 + bite - offset;
+        if (inRange(pointer, 8836, 10715))
+          return 57344 - 8836 + pointer;
+        var code_point = pointer === null ? null : indexCodePointFor(pointer, index("jis0208"));
+        if (code_point === null && isASCIIByte(bite))
+          stream.prepend(bite);
+        if (code_point === null)
+          return decoderError(fatal);
+        return code_point;
+      }
+      if (isASCIIByte(bite) || bite === 128)
+        return bite;
+      if (inRange(bite, 161, 223))
+        return 65377 - 161 + bite;
+      if (inRange(bite, 129, 159) || inRange(bite, 224, 252)) {
+        Shift_JIS_lead = bite;
+        return null;
+      }
+      return decoderError(fatal);
+    };
+  }
+  function ShiftJISEncoder(options) {
+    var fatal = options.fatal;
+    this.handler = function(stream, code_point) {
+      if (code_point === end_of_stream)
+        return finished;
+      if (isASCIICodePoint(code_point) || code_point === 128)
+        return code_point;
+      if (code_point === 165)
+        return 92;
+      if (code_point === 8254)
+        return 126;
+      if (inRange(code_point, 65377, 65439))
+        return code_point - 65377 + 161;
+      if (code_point === 8722)
+        code_point = 65293;
+      var pointer = indexShiftJISPointerFor(code_point);
+      if (pointer === null)
+        return encoderError(code_point);
+      var lead = floor(pointer / 188);
+      var lead_offset = lead < 31 ? 129 : 193;
+      var trail = pointer % 188;
+      var offset = trail < 63 ? 64 : 65;
+      return [lead + lead_offset, trail + offset];
+    };
+  }
+  function EUCKRDecoder(options) {
+    var fatal = options.fatal;
+    var euckr_lead = 0;
+    this.handler = function(stream, bite) {
+      if (bite === end_of_stream && euckr_lead !== 0) {
+        euckr_lead = 0;
+        return decoderError(fatal);
+      }
+      if (bite === end_of_stream && euckr_lead === 0)
+        return finished;
+      if (euckr_lead !== 0) {
+        var lead = euckr_lead;
+        var pointer = null;
+        euckr_lead = 0;
+        if (inRange(bite, 65, 254))
+          pointer = (lead - 129) * 190 + (bite - 65);
+        var code_point = pointer === null ? null : indexCodePointFor(pointer, index("euc-kr"));
+        if (pointer === null && isASCIIByte(bite))
+          stream.prepend(bite);
+        if (code_point === null)
+          return decoderError(fatal);
+        return code_point;
+      }
+      if (isASCIIByte(bite))
+        return bite;
+      if (inRange(bite, 129, 254)) {
+        euckr_lead = bite;
+        return null;
+      }
+      return decoderError(fatal);
+    };
+  }
+  function EUCKREncoder(options) {
+    var fatal = options.fatal;
+    this.handler = function(stream, code_point) {
+      if (code_point === end_of_stream)
+        return finished;
+      if (isASCIICodePoint(code_point))
+        return code_point;
+      var pointer = indexPointerFor(code_point, index("euc-kr"));
+      if (pointer === null)
+        return encoderError(code_point);
+      var lead = floor(pointer / 190) + 129;
+      var trail = pointer % 190 + 65;
+      return [lead, trail];
+    };
+  }
+  function convertCodeUnitToBytes(code_unit, utf16be) {
+    var byte1 = code_unit >> 8;
+    var byte2 = code_unit & 255;
+    if (utf16be)
+      return [byte1, byte2];
+    return [byte2, byte1];
+  }
+  function UTF16Decoder(utf16_be, options) {
+    var fatal = options.fatal;
+    var utf16_lead_byte = null, utf16_lead_surrogate = null;
+    this.handler = function(stream, bite) {
+      if (bite === end_of_stream && (utf16_lead_byte !== null || utf16_lead_surrogate !== null)) {
+        return decoderError(fatal);
+      }
+      if (bite === end_of_stream && utf16_lead_byte === null && utf16_lead_surrogate === null) {
+        return finished;
+      }
+      if (utf16_lead_byte === null) {
+        utf16_lead_byte = bite;
+        return null;
+      }
+      var code_unit;
+      if (utf16_be) {
+        code_unit = (utf16_lead_byte << 8) + bite;
+      } else {
+        code_unit = (bite << 8) + utf16_lead_byte;
+      }
+      utf16_lead_byte = null;
+      if (utf16_lead_surrogate !== null) {
+        var lead_surrogate = utf16_lead_surrogate;
+        utf16_lead_surrogate = null;
+        if (inRange(code_unit, 56320, 57343)) {
+          return 65536 + (lead_surrogate - 55296) * 1024 + (code_unit - 56320);
+        }
+        stream.prepend(convertCodeUnitToBytes(code_unit, utf16_be));
+        return decoderError(fatal);
+      }
+      if (inRange(code_unit, 55296, 56319)) {
+        utf16_lead_surrogate = code_unit;
+        return null;
+      }
+      if (inRange(code_unit, 56320, 57343))
+        return decoderError(fatal);
+      return code_unit;
+    };
+  }
+  function UTF16Encoder(utf16_be, options) {
+    var fatal = options.fatal;
+    this.handler = function(stream, code_point) {
+      if (code_point === end_of_stream)
+        return finished;
+      if (inRange(code_point, 0, 65535))
+        return convertCodeUnitToBytes(code_point, utf16_be);
+      var lead = convertCodeUnitToBytes((code_point - 65536 >> 10) + 55296, utf16_be);
+      var trail = convertCodeUnitToBytes((code_point - 65536 & 1023) + 56320, utf16_be);
+      return lead.concat(trail);
+    };
+  }
+  function XUserDefinedDecoder(options) {
+    var fatal = options.fatal;
+    this.handler = function(stream, bite) {
+      if (bite === end_of_stream)
+        return finished;
+      if (isASCIIByte(bite))
+        return bite;
+      return 63360 + bite - 128;
+    };
+  }
+  function XUserDefinedEncoder(options) {
+    var fatal = options.fatal;
+    this.handler = function(stream, code_point) {
+      if (code_point === end_of_stream)
+        return finished;
+      if (isASCIICodePoint(code_point))
+        return code_point;
+      if (inRange(code_point, 63360, 63487))
+        return code_point - 63360 + 128;
+      return encoderError(code_point);
+    };
+  }
+  var floor, isASCIICodePoint, end_of_stream, finished, encodings, label_to_encoding, encoders, decoders, shift_jis_index, big5_index_no_hkscs, DEFAULT_ENCODING;
+  var init_encoding = __esm({
+    "src/lib/encoding.ts"() {
+      init_encoding_indexes();
+      global["encoding-indexes"] = encoding_indexes_default || {};
+      floor = Math.floor;
+      isASCIICodePoint = isASCIIByte;
+      end_of_stream = -1;
+      Stream.prototype = {
+        endOfStream: function() {
+          return !this.tokens.length;
+        },
+        read: function() {
+          if (!this.tokens.length)
+            return end_of_stream;
+          return this.tokens.pop();
+        },
+        prepend: function(token) {
+          if (Array.isArray(token)) {
+            var tokens = token;
+            while (tokens.length)
+              this.tokens.push(tokens.pop());
+          } else {
+            this.tokens.push(token);
+          }
+        },
+        push: function(token) {
+          if (Array.isArray(token)) {
+            var tokens = token;
+            while (tokens.length)
+              this.tokens.unshift(tokens.shift());
+          } else {
+            this.tokens.unshift(token);
+          }
+        }
+      };
+      finished = -1;
+      Decoder.prototype = {
+        handler: function(stream, bite) {
+        }
+      };
+      Encoder.prototype = {
+        handler: function(stream, code_point) {
+        }
+      };
+      encodings = [
+        {
+          encodings: [
+            {
+              labels: ["unicode-1-1-utf-8", "utf-8", "utf8"],
+              name: "UTF-8"
+            }
+          ],
+          heading: "The Encoding"
+        },
+        {
+          encodings: [
+            {
+              labels: ["866", "cp866", "csibm866", "ibm866"],
+              name: "IBM866"
+            },
+            {
+              labels: [
+                "csisolatin2",
+                "iso-8859-2",
+                "iso-ir-101",
+                "iso8859-2",
+                "iso88592",
+                "iso_8859-2",
+                "iso_8859-2:1987",
+                "l2",
+                "latin2"
+              ],
+              name: "ISO-8859-2"
+            },
+            {
+              labels: [
+                "csisolatin3",
+                "iso-8859-3",
+                "iso-ir-109",
+                "iso8859-3",
+                "iso88593",
+                "iso_8859-3",
+                "iso_8859-3:1988",
+                "l3",
+                "latin3"
+              ],
+              name: "ISO-8859-3"
+            },
+            {
+              labels: [
+                "csisolatin4",
+                "iso-8859-4",
+                "iso-ir-110",
+                "iso8859-4",
+                "iso88594",
+                "iso_8859-4",
+                "iso_8859-4:1988",
+                "l4",
+                "latin4"
+              ],
+              name: "ISO-8859-4"
+            },
+            {
+              labels: [
+                "csisolatincyrillic",
+                "cyrillic",
+                "iso-8859-5",
+                "iso-ir-144",
+                "iso8859-5",
+                "iso88595",
+                "iso_8859-5",
+                "iso_8859-5:1988"
+              ],
+              name: "ISO-8859-5"
+            },
+            {
+              labels: [
+                "arabic",
+                "asmo-708",
+                "csiso88596e",
+                "csiso88596i",
+                "csisolatinarabic",
+                "ecma-114",
+                "iso-8859-6",
+                "iso-8859-6-e",
+                "iso-8859-6-i",
+                "iso-ir-127",
+                "iso8859-6",
+                "iso88596",
+                "iso_8859-6",
+                "iso_8859-6:1987"
+              ],
+              name: "ISO-8859-6"
+            },
+            {
+              labels: [
+                "csisolatingreek",
+                "ecma-118",
+                "elot_928",
+                "greek",
+                "greek8",
+                "iso-8859-7",
+                "iso-ir-126",
+                "iso8859-7",
+                "iso88597",
+                "iso_8859-7",
+                "iso_8859-7:1987",
+                "sun_eu_greek"
+              ],
+              name: "ISO-8859-7"
+            },
+            {
+              labels: [
+                "csiso88598e",
+                "csisolatinhebrew",
+                "hebrew",
+                "iso-8859-8",
+                "iso-8859-8-e",
+                "iso-ir-138",
+                "iso8859-8",
+                "iso88598",
+                "iso_8859-8",
+                "iso_8859-8:1988",
+                "visual"
+              ],
+              name: "ISO-8859-8"
+            },
+            {
+              labels: ["csiso88598i", "iso-8859-8-i", "logical"],
+              name: "ISO-8859-8-I"
+            },
+            {
+              labels: [
+                "csisolatin6",
+                "iso-8859-10",
+                "iso-ir-157",
+                "iso8859-10",
+                "iso885910",
+                "l6",
+                "latin6"
+              ],
+              name: "ISO-8859-10"
+            },
+            {
+              labels: ["iso-8859-13", "iso8859-13", "iso885913"],
+              name: "ISO-8859-13"
+            },
+            {
+              labels: ["iso-8859-14", "iso8859-14", "iso885914"],
+              name: "ISO-8859-14"
+            },
+            {
+              labels: ["csisolatin9", "iso-8859-15", "iso8859-15", "iso885915", "iso_8859-15", "l9"],
+              name: "ISO-8859-15"
+            },
+            {
+              labels: ["iso-8859-16"],
+              name: "ISO-8859-16"
+            },
+            {
+              labels: ["cskoi8r", "koi", "koi8", "koi8-r", "koi8_r"],
+              name: "KOI8-R"
+            },
+            {
+              labels: ["koi8-ru", "koi8-u"],
+              name: "KOI8-U"
+            },
+            {
+              labels: ["csmacintosh", "mac", "macintosh", "x-mac-roman"],
+              name: "macintosh"
+            },
+            {
+              labels: ["dos-874", "iso-8859-11", "iso8859-11", "iso885911", "tis-620", "windows-874"],
+              name: "windows-874"
+            },
+            {
+              labels: ["cp1250", "windows-1250", "x-cp1250"],
+              name: "windows-1250"
+            },
+            {
+              labels: ["cp1251", "windows-1251", "x-cp1251"],
+              name: "windows-1251"
+            },
+            {
+              labels: [
+                "ansi_x3.4-1968",
+                "ascii",
+                "cp1252",
+                "cp819",
+                "csisolatin1",
+                "ibm819",
+                "iso-8859-1",
+                "iso-ir-100",
+                "iso8859-1",
+                "iso88591",
+                "iso_8859-1",
+                "iso_8859-1:1987",
+                "l1",
+                "latin1",
+                "us-ascii",
+                "windows-1252",
+                "x-cp1252"
+              ],
+              name: "windows-1252"
+            },
+            {
+              labels: ["cp1253", "windows-1253", "x-cp1253"],
+              name: "windows-1253"
+            },
+            {
+              labels: [
+                "cp1254",
+                "csisolatin5",
+                "iso-8859-9",
+                "iso-ir-148",
+                "iso8859-9",
+                "iso88599",
+                "iso_8859-9",
+                "iso_8859-9:1989",
+                "l5",
+                "latin5",
+                "windows-1254",
+                "x-cp1254"
+              ],
+              name: "windows-1254"
+            },
+            {
+              labels: ["cp1255", "windows-1255", "x-cp1255"],
+              name: "windows-1255"
+            },
+            {
+              labels: ["cp1256", "windows-1256", "x-cp1256"],
+              name: "windows-1256"
+            },
+            {
+              labels: ["cp1257", "windows-1257", "x-cp1257"],
+              name: "windows-1257"
+            },
+            {
+              labels: ["cp1258", "windows-1258", "x-cp1258"],
+              name: "windows-1258"
+            },
+            {
+              labels: ["x-mac-cyrillic", "x-mac-ukrainian"],
+              name: "x-mac-cyrillic"
+            }
+          ],
+          heading: "Legacy single-byte encodings"
+        },
+        {
+          encodings: [
+            {
+              labels: [
+                "chinese",
+                "csgb2312",
+                "csiso58gb231280",
+                "gb2312",
+                "gb_2312",
+                "gb_2312-80",
+                "gbk",
+                "iso-ir-58",
+                "x-gbk"
+              ],
+              name: "GBK"
+            },
+            {
+              labels: ["gb18030"],
+              name: "gb18030"
+            }
+          ],
+          heading: "Legacy multi-byte Chinese (simplified) encodings"
+        },
+        {
+          encodings: [
+            {
+              labels: ["big5", "big5-hkscs", "cn-big5", "csbig5", "x-x-big5"],
+              name: "Big5"
+            }
+          ],
+          heading: "Legacy multi-byte Chinese (traditional) encodings"
+        },
+        {
+          encodings: [
+            {
+              labels: ["cseucpkdfmtjapanese", "euc-jp", "x-euc-jp"],
+              name: "EUC-JP"
+            },
+            {
+              labels: ["csiso2022jp", "iso-2022-jp"],
+              name: "ISO-2022-JP"
+            },
+            {
+              labels: [
+                "csshiftjis",
+                "ms932",
+                "ms_kanji",
+                "shift-jis",
+                "shift_jis",
+                "sjis",
+                "windows-31j",
+                "x-sjis"
+              ],
+              name: "Shift_JIS"
+            }
+          ],
+          heading: "Legacy multi-byte Japanese encodings"
+        },
+        {
+          encodings: [
+            {
+              labels: [
+                "cseuckr",
+                "csksc56011987",
+                "euc-kr",
+                "iso-ir-149",
+                "korean",
+                "ks_c_5601-1987",
+                "ks_c_5601-1989",
+                "ksc5601",
+                "ksc_5601",
+                "windows-949"
+              ],
+              name: "EUC-KR"
+            }
+          ],
+          heading: "Legacy multi-byte Korean encodings"
+        },
+        {
+          encodings: [
+            {
+              labels: ["csiso2022kr", "hz-gb-2312", "iso-2022-cn", "iso-2022-cn-ext", "iso-2022-kr"],
+              name: "replacement"
+            },
+            {
+              labels: ["utf-16be"],
+              name: "UTF-16BE"
+            },
+            {
+              labels: ["utf-16", "utf-16le"],
+              name: "UTF-16LE"
+            },
+            {
+              labels: ["x-user-defined"],
+              name: "x-user-defined"
+            }
+          ],
+          heading: "Legacy miscellaneous encodings"
+        }
+      ];
+      label_to_encoding = {};
+      encodings.forEach(function(category) {
+        category.encodings.forEach(function(encoding) {
+          encoding.labels.forEach(function(label) {
+            label_to_encoding[label] = encoding;
+          });
+        });
+      });
+      encoders = {};
+      decoders = {};
+      DEFAULT_ENCODING = "utf-8";
+      if (Object.defineProperty) {
+        Object.defineProperty(TextDecoder.prototype, "encoding", {
+          get: function() {
+            return this._encoding.name.toLowerCase();
+          }
+        });
+        Object.defineProperty(TextDecoder.prototype, "fatal", {
+          get: function() {
+            return this._error_mode === "fatal";
+          }
+        });
+        Object.defineProperty(TextDecoder.prototype, "ignoreBOM", {
+          get: function() {
+            return this._ignoreBOM;
+          }
+        });
+      }
+      TextDecoder.prototype.decode = function decode(input, options) {
+        var bytes;
+        if (typeof input === "object" && input instanceof ArrayBuffer) {
+          bytes = new Uint8Array(input);
+        } else if (typeof input === "object" && "buffer" in input && input.buffer instanceof ArrayBuffer) {
+          bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+        } else {
+          bytes = new Uint8Array(0);
+        }
+        options = ToDictionary(options);
+        if (!this._do_not_flush) {
+          this._decoder = decoders[this._encoding.name]({
+            fatal: this._error_mode === "fatal"
+          });
+          this._BOMseen = false;
+        }
+        this._do_not_flush = Boolean(options["stream"]);
+        var input_stream = new Stream(bytes);
+        var output = [];
+        var result;
+        while (true) {
+          var token = input_stream.read();
+          if (token === end_of_stream)
+            break;
+          result = this._decoder.handler(input_stream, token);
+          if (result === finished)
+            break;
+          if (result !== null) {
+            if (Array.isArray(result))
+              output.push.apply(output, result);
+            else
+              output.push(result);
+          }
+        }
+        if (!this._do_not_flush) {
+          do {
+            result = this._decoder.handler(input_stream, input_stream.read());
+            if (result === finished)
+              break;
+            if (result === null)
+              continue;
+            if (Array.isArray(result))
+              output.push.apply(output, result);
+            else
+              output.push(result);
+          } while (!input_stream.endOfStream());
+          this._decoder = null;
+        }
+        function serializeStream(stream) {
+          if (includes(["UTF-8", "UTF-16LE", "UTF-16BE"], this._encoding.name) && !this._ignoreBOM && !this._BOMseen) {
+            if (stream.length > 0 && stream[0] === 65279) {
+              this._BOMseen = true;
+              stream.shift();
+            } else if (stream.length > 0) {
+              this._BOMseen = true;
+            } else {
+            }
+          }
+          return codePointsToString(stream);
+        }
+        return serializeStream.call(this, output);
+      };
+      if (Object.defineProperty) {
+        Object.defineProperty(TextEncoder.prototype, "encoding", {
+          get: function() {
+            return this._encoding.name.toLowerCase();
+          }
+        });
+      }
+      TextEncoder.prototype.encode = function encode(opt_string, options) {
+        opt_string = opt_string === void 0 ? "" : String(opt_string);
+        options = ToDictionary(options);
+        if (!this._do_not_flush)
+          this._encoder = encoders[this._encoding.name]({
+            fatal: this._fatal === "fatal"
+          });
+        this._do_not_flush = Boolean(options["stream"]);
+        var input = new Stream(stringToCodePoints(opt_string));
+        var output = [];
+        var result;
+        while (true) {
+          var token = input.read();
+          if (token === end_of_stream)
+            break;
+          result = this._encoder.handler(input, token);
+          if (result === finished)
+            break;
+          if (Array.isArray(result))
+            output.push.apply(output, result);
+          else
+            output.push(result);
+        }
+        if (!this._do_not_flush) {
+          while (true) {
+            result = this._encoder.handler(input, input.read());
+            if (result === finished)
+              break;
+            if (Array.isArray(result))
+              output.push.apply(output, result);
+            else
+              output.push(result);
+          }
+          this._encoder = null;
+        }
+        return new Uint8Array(output);
+      };
+      encoders["UTF-8"] = function(options) {
+        return new UTF8Encoder(options);
+      };
+      decoders["UTF-8"] = function(options) {
+        return new UTF8Decoder(options);
+      };
+      (function() {
+        if (!("encoding-indexes" in global))
+          return;
+        encodings.forEach(function(category) {
+          if (category.heading !== "Legacy single-byte encodings")
+            return;
+          category.encodings.forEach(function(encoding) {
+            var name = encoding.name;
+            var idx = index(name.toLowerCase());
+            decoders[name] = function(options) {
+              return new SingleByteDecoder(idx, options);
+            };
+            encoders[name] = function(options) {
+              return new SingleByteEncoder(idx, options);
+            };
+          });
+        });
+      })();
+      decoders["GBK"] = function(options) {
+        return new GB18030Decoder(options);
+      };
+      encoders["GBK"] = function(options) {
+        return new GB18030Encoder(options, true);
+      };
+      encoders["gb18030"] = function(options) {
+        return new GB18030Encoder(options);
+      };
+      decoders["gb18030"] = function(options) {
+        return new GB18030Decoder(options);
+      };
+      encoders["Big5"] = function(options) {
+        return new Big5Encoder(options);
+      };
+      decoders["Big5"] = function(options) {
+        return new Big5Decoder(options);
+      };
+      encoders["EUC-JP"] = function(options) {
+        return new EUCJPEncoder(options);
+      };
+      decoders["EUC-JP"] = function(options) {
+        return new EUCJPDecoder(options);
+      };
+      encoders["ISO-2022-JP"] = function(options) {
+        return new ISO2022JPEncoder(options);
+      };
+      decoders["ISO-2022-JP"] = function(options) {
+        return new ISO2022JPDecoder(options);
+      };
+      encoders["Shift_JIS"] = function(options) {
+        return new ShiftJISEncoder(options);
+      };
+      decoders["Shift_JIS"] = function(options) {
+        return new ShiftJISDecoder(options);
+      };
+      encoders["EUC-KR"] = function(options) {
+        return new EUCKREncoder(options);
+      };
+      decoders["EUC-KR"] = function(options) {
+        return new EUCKRDecoder(options);
+      };
+      encoders["UTF-16BE"] = function(options) {
+        return new UTF16Encoder(true, options);
+      };
+      decoders["UTF-16BE"] = function(options) {
+        return new UTF16Decoder(true, options);
+      };
+      encoders["UTF-16LE"] = function(options) {
+        return new UTF16Encoder(false, options);
+      };
+      decoders["UTF-16LE"] = function(options) {
+        return new UTF16Decoder(false, options);
+      };
+      encoders["x-user-defined"] = function(options) {
+        return new XUserDefinedEncoder(options);
+      };
+      decoders["x-user-defined"] = function(options) {
+        return new XUserDefinedDecoder(options);
+      };
+    }
+  });
+
+  // src/promise/all-settled.ts
+  function allSettled(promises) {
+    const mappedPromises = promises.map((promise) => {
+      return promise.then((value) => {
+        return { status: FULFILLED_STATUS, value };
+      }).catch((reason) => {
+        return { status: REJECTED_STATUS, reason };
+      });
+    });
+    return Promise.all(mappedPromises);
+  }
+  var REJECTED_STATUS, FULFILLED_STATUS;
+  var init_all_settled = __esm({
+    "src/promise/all-settled.ts"() {
+      REJECTED_STATUS = "rejected";
+      FULFILLED_STATUS = "fulfilled";
+    }
+  });
+
+  // (disabled):src/node/buffer/btoa.node
+  var init_btoa = __esm({
+    "(disabled):src/node/buffer/btoa.node"() {
+    }
+  });
+
+  // (disabled):src/node/fetch/headers.node
+  var require_headers = __commonJS({
+    "(disabled):src/node/fetch/headers.node"() {
+    }
+  });
+
+  // (disabled):src/node/fetch/response.node
+  var require_response = __commonJS({
+    "(disabled):src/node/fetch/response.node"() {
+    }
+  });
+
+  // (disabled):src/node/fetch/fetch.node
+  var require_fetch = __commonJS({
+    "(disabled):src/node/fetch/fetch.node"() {
+    }
+  });
+
+  // (disabled):src/node/images/encode-image.node
+  var init_encode_image = __esm({
+    "(disabled):src/node/images/encode-image.node"() {
+    }
+  });
+
+  // (disabled):src/node/images/parse-image.node
+  var init_parse_image = __esm({
+    "(disabled):src/node/images/parse-image.node"() {
+    }
+  });
+
+  // (disabled):src/node/file/readable-stream
+  var init_readable_stream = __esm({
+    "(disabled):src/node/file/readable-stream"() {
+    }
+  });
+
+  // (disabled):src/node/file/blob
+  var init_blob = __esm({
+    "(disabled):src/node/file/blob"() {
+    }
+  });
+
+  // src/node/file/file-reader.ts
+  var FileReaderPolyfill;
+  var init_file_reader = __esm({
+    "src/node/file/file-reader.ts"() {
+      init_btoa();
+      FileReaderPolyfill = class {
+        constructor() {
+          this.onload = null;
+        }
+        abort() {
+          return;
+        }
+        async readAsArrayBuffer(blob) {
+          const arrayBuffer = await blob.arrayBuffer();
+          if (this.onload) {
+            this.onload({ target: { result: arrayBuffer } });
+          }
+        }
+        async readAsBinaryString(blob) {
+          throw Error("Not implemented");
+        }
+        async readAsDataURL(blob) {
+          const text = await blob.text();
+          const dataUrl = `data://;base64,${(0, import_btoa.atob)(text)}`;
+          if (this.onload) {
+            this.onload({ target: { result: dataUrl } });
+          }
+        }
+        async readAsText(blob) {
+          const text = await blob.text();
+          if (this.onload) {
+            this.onload({ target: { result: text } });
+          }
+        }
+      };
+    }
+  });
+
+  // (disabled):src/node/file/file
+  var init_file = __esm({
+    "(disabled):src/node/file/file"() {
+    }
+  });
+
+  // src/node/file/install-file-polyfills.ts
+  function installFilePolyfills() {
+    if (typeof ReadableStream === "undefined" && global) {
+      global.ReadableStream = import_readable_stream.ReadableStreamPolyfill;
+    }
+    if (typeof Blob === "undefined" && global) {
+      global.Blob = import_blob.BlobPolyfill;
+    }
+    if (typeof FileReader === "undefined" && global) {
+      global.FileReader = FileReaderPolyfill;
+    }
+    if (typeof File === "undefined" && global) {
+      global.File = import_file.FilePolyfill;
+    }
+  }
+  var init_install_file_polyfills = __esm({
+    "src/node/file/install-file-polyfills.ts"() {
+      init_readable_stream();
+      init_blob();
+      init_file_reader();
+      init_file();
+    }
+  });
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    BlobPolyfill: () => import_blob2.BlobPolyfill,
+    FilePolyfill: () => import_file2.FilePolyfill,
+    FileReaderPolyfill: () => FileReaderPolyfill,
+    ReadableStreamPolyfill: () => import_readable_stream2.ReadableStreamPolyfill,
+    installFilePolyfills: () => installFilePolyfills
+  });
+  var import_xmldom, import_headers, import_response, import_fetch, installTextEncoder, installTextDecoder;
+  var init_src = __esm({
+    "src/index.ts"() {
+      import_xmldom = __toModule(require_lib());
+      init_globals();
+      init_encoding();
+      init_all_settled();
+      init_btoa();
+      import_headers = __toModule(require_headers());
+      import_response = __toModule(require_response());
+      import_fetch = __toModule(require_fetch());
+      init_encode_image();
+      init_parse_image();
+      init_readable_stream();
+      init_blob();
+      init_file_reader();
+      init_file();
+      init_install_file_polyfills();
+      installTextEncoder = !isBrowser || !("TextEncoder" in global_);
+      if (installTextEncoder) {
+        global_["TextEncoder"] = TextEncoder;
+      }
+      installTextDecoder = !isBrowser || !("TextDecoder" in global_);
+      if (installTextDecoder) {
+        global_["TextDecoder"] = TextDecoder;
+      }
+      if (!isBrowser && !("atob" in global_) && base64.atob) {
+        global_["atob"] = base64.atob;
+      }
+      if (!isBrowser && !("btoa" in global_) && base64.btoa) {
+        global_["btoa"] = base64.btoa;
+      }
+      if (!isBrowser && !("Headers" in global_) && import_headers.default) {
+        global_["Headers"] = import_headers.default;
+      }
+      if (!isBrowser && !("Response" in global_) && import_response.default) {
+        global_["Response"] = import_response.default;
+      }
+      if (!isBrowser && !("fetch" in global_) && import_fetch.default) {
+        global_["fetch"] = import_fetch.default;
+      }
+      if (!isBrowser && !("DOMParser" in global_) && import_xmldom.DOMParser) {
+        global_["DOMParser"] = import_xmldom.DOMParser;
+      }
+      if (!isBrowser && !("_encodeImageNode" in global_) && import_encode_image.encodeImageNode) {
+        global_["_encodeImageNode"] = import_encode_image.encodeImageNode;
+      }
+      if (!isBrowser && !("_parseImageNode" in global_) && import_parse_image.parseImageNode) {
+        global_["_parseImageNode"] = import_parse_image.parseImageNode;
+      }
+      if (!("allSettled" in Promise)) {
+        Promise.allSettled = allSettled;
+      }
+    }
+  });
+
+  // src/bundle.ts
+  var require_bundle = __commonJS({
+    "src/bundle.ts"(exports, module) {
+      var moduleExports = (init_src(), src_exports);
+      globalThis.loaders = globalThis.loaders || {};
+      module.exports = Object.assign(globalThis.loaders, moduleExports);
+    }
+  });
+  require_bundle();
+})();