@caspian2026/agent-sdk 0.0.19 → 0.0.20

package/dist/{chunk-fajg8x36.js → chunk-qbbf7rr5.js}

@@ -1,9 +1,9 @@
 // @bun
 import {
   __commonJS
-} from "./chunk-qp2qdcda.js";
+} from "./chunk-eta5aekm.js";
 
-// node_modules/.bun/@xmldom+xmldom@0.8.12/node_modules/@xmldom/xmldom/lib/conventions.js
+// node_modules/.bun/@xmldom+xmldom@0.9.10/node_modules/@xmldom/xmldom/lib/conventions.js
 var require_conventions = __commonJS((exports) => {
   function find(list, predicate, ac) {
     if (ac === undefined) {
@@ -13,7 +13,7 @@ var require_conventions = __commonJS((exports) => {
       return ac.find.call(list, predicate);
     }
     for (var i = 0;i < list.length; i++) {
-      if (Object.prototype.hasOwnProperty.call(list, i)) {
+      if (hasOwn(list, i)) {
         var item = list[i];
         if (predicate.call(undefined, item, i, list)) {
           return item;
@@ -25,34 +25,108 @@ var require_conventions = __commonJS((exports) => {
     if (oc === undefined) {
       oc = Object;
     }
+    if (oc && typeof oc.getOwnPropertyDescriptors === "function") {
+      object = oc.create(null, oc.getOwnPropertyDescriptors(object));
+    }
     return oc && typeof oc.freeze === "function" ? oc.freeze(object) : object;
   }
+  function hasOwn(object, key) {
+    return Object.prototype.hasOwnProperty.call(object, key);
+  }
   function assign(target, source) {
     if (target === null || typeof target !== "object") {
       throw new TypeError("target is not an object");
     }
     for (var key in source) {
-      if (Object.prototype.hasOwnProperty.call(source, key)) {
+      if (hasOwn(source, key)) {
         target[key] = source[key];
       }
     }
     return target;
   }
+  var HTML_BOOLEAN_ATTRIBUTES = freeze({
+    allowfullscreen: true,
+    async: true,
+    autofocus: true,
+    autoplay: true,
+    checked: true,
+    controls: true,
+    default: true,
+    defer: true,
+    disabled: true,
+    formnovalidate: true,
+    hidden: true,
+    ismap: true,
+    itemscope: true,
+    loop: true,
+    multiple: true,
+    muted: true,
+    nomodule: true,
+    novalidate: true,
+    open: true,
+    playsinline: true,
+    readonly: true,
+    required: true,
+    reversed: true,
+    selected: true
+  });
+  function isHTMLBooleanAttribute(name) {
+    return hasOwn(HTML_BOOLEAN_ATTRIBUTES, name.toLowerCase());
+  }
+  var HTML_VOID_ELEMENTS = freeze({
+    area: true,
+    base: true,
+    br: true,
+    col: true,
+    embed: true,
+    hr: true,
+    img: true,
+    input: true,
+    link: true,
+    meta: true,
+    param: true,
+    source: true,
+    track: true,
+    wbr: true
+  });
+  function isHTMLVoidElement(tagName) {
+    return hasOwn(HTML_VOID_ELEMENTS, tagName.toLowerCase());
+  }
+  var HTML_RAW_TEXT_ELEMENTS = freeze({
+    script: false,
+    style: false,
+    textarea: true,
+    title: true
+  });
+  function isHTMLRawTextElement(tagName) {
+    var key = tagName.toLowerCase();
+    return hasOwn(HTML_RAW_TEXT_ELEMENTS, key) && !HTML_RAW_TEXT_ELEMENTS[key];
+  }
+  function isHTMLEscapableRawTextElement(tagName) {
+    var key = tagName.toLowerCase();
+    return hasOwn(HTML_RAW_TEXT_ELEMENTS, key) && HTML_RAW_TEXT_ELEMENTS[key];
+  }
+  function isHTMLMimeType(mimeType) {
+    return mimeType === MIME_TYPE.HTML;
+  }
+  function hasDefaultHTMLNamespace(mimeType) {
+    return isHTMLMimeType(mimeType) || mimeType === MIME_TYPE.XML_XHTML_APPLICATION;
+  }
   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 _MIME_TYPES = Object.keys(MIME_TYPE).map(function(key) {
+    return MIME_TYPE[key];
+  });
+  function isValidMimeType(mimeType) {
+    return _MIME_TYPES.indexOf(mimeType) > -1;
+  }
   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/"
@@ -60,15 +134,344 @@ var require_conventions = __commonJS((exports) => {
   exports.assign = assign;
   exports.find = find;
   exports.freeze = freeze;
+  exports.HTML_BOOLEAN_ATTRIBUTES = HTML_BOOLEAN_ATTRIBUTES;
+  exports.HTML_RAW_TEXT_ELEMENTS = HTML_RAW_TEXT_ELEMENTS;
+  exports.HTML_VOID_ELEMENTS = HTML_VOID_ELEMENTS;
+  exports.hasDefaultHTMLNamespace = hasDefaultHTMLNamespace;
+  exports.hasOwn = hasOwn;
+  exports.isHTMLBooleanAttribute = isHTMLBooleanAttribute;
+  exports.isHTMLRawTextElement = isHTMLRawTextElement;
+  exports.isHTMLEscapableRawTextElement = isHTMLEscapableRawTextElement;
+  exports.isHTMLMimeType = isHTMLMimeType;
+  exports.isHTMLVoidElement = isHTMLVoidElement;
+  exports.isValidMimeType = isValidMimeType;
   exports.MIME_TYPE = MIME_TYPE;
   exports.NAMESPACE = NAMESPACE;
 });
 
-// node_modules/.bun/@xmldom+xmldom@0.8.12/node_modules/@xmldom/xmldom/lib/dom.js
+// node_modules/.bun/@xmldom+xmldom@0.9.10/node_modules/@xmldom/xmldom/lib/errors.js
+var require_errors = __commonJS((exports) => {
+  var conventions = require_conventions();
+  function extendError(constructor, writableName) {
+    constructor.prototype = Object.create(Error.prototype, {
+      constructor: { value: constructor },
+      name: { value: constructor.name, enumerable: true, writable: writableName }
+    });
+  }
+  var DOMExceptionName = conventions.freeze({
+    Error: "Error",
+    IndexSizeError: "IndexSizeError",
+    DomstringSizeError: "DomstringSizeError",
+    HierarchyRequestError: "HierarchyRequestError",
+    WrongDocumentError: "WrongDocumentError",
+    InvalidCharacterError: "InvalidCharacterError",
+    NoDataAllowedError: "NoDataAllowedError",
+    NoModificationAllowedError: "NoModificationAllowedError",
+    NotFoundError: "NotFoundError",
+    NotSupportedError: "NotSupportedError",
+    InUseAttributeError: "InUseAttributeError",
+    InvalidStateError: "InvalidStateError",
+    SyntaxError: "SyntaxError",
+    InvalidModificationError: "InvalidModificationError",
+    NamespaceError: "NamespaceError",
+    InvalidAccessError: "InvalidAccessError",
+    ValidationError: "ValidationError",
+    TypeMismatchError: "TypeMismatchError",
+    SecurityError: "SecurityError",
+    NetworkError: "NetworkError",
+    AbortError: "AbortError",
+    URLMismatchError: "URLMismatchError",
+    QuotaExceededError: "QuotaExceededError",
+    TimeoutError: "TimeoutError",
+    InvalidNodeTypeError: "InvalidNodeTypeError",
+    DataCloneError: "DataCloneError",
+    EncodingError: "EncodingError",
+    NotReadableError: "NotReadableError",
+    UnknownError: "UnknownError",
+    ConstraintError: "ConstraintError",
+    DataError: "DataError",
+    TransactionInactiveError: "TransactionInactiveError",
+    ReadOnlyError: "ReadOnlyError",
+    VersionError: "VersionError",
+    OperationError: "OperationError",
+    NotAllowedError: "NotAllowedError",
+    OptOutError: "OptOutError"
+  });
+  var DOMExceptionNames = Object.keys(DOMExceptionName);
+  function isValidDomExceptionCode(value) {
+    return typeof value === "number" && value >= 1 && value <= 25;
+  }
+  function endsWithError(value) {
+    return typeof value === "string" && value.substring(value.length - DOMExceptionName.Error.length) === DOMExceptionName.Error;
+  }
+  function DOMException(messageOrCode, nameOrMessage) {
+    if (isValidDomExceptionCode(messageOrCode)) {
+      this.name = DOMExceptionNames[messageOrCode];
+      this.message = nameOrMessage || "";
+    } else {
+      this.message = messageOrCode;
+      this.name = endsWithError(nameOrMessage) ? nameOrMessage : DOMExceptionName.Error;
+    }
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, DOMException);
+  }
+  extendError(DOMException, true);
+  Object.defineProperties(DOMException.prototype, {
+    code: {
+      enumerable: true,
+      get: function() {
+        var code = DOMExceptionNames.indexOf(this.name);
+        if (isValidDomExceptionCode(code))
+          return code;
+        return 0;
+      }
+    }
+  });
+  var ExceptionCode = {
+    INDEX_SIZE_ERR: 1,
+    DOMSTRING_SIZE_ERR: 2,
+    HIERARCHY_REQUEST_ERR: 3,
+    WRONG_DOCUMENT_ERR: 4,
+    INVALID_CHARACTER_ERR: 5,
+    NO_DATA_ALLOWED_ERR: 6,
+    NO_MODIFICATION_ALLOWED_ERR: 7,
+    NOT_FOUND_ERR: 8,
+    NOT_SUPPORTED_ERR: 9,
+    INUSE_ATTRIBUTE_ERR: 10,
+    INVALID_STATE_ERR: 11,
+    SYNTAX_ERR: 12,
+    INVALID_MODIFICATION_ERR: 13,
+    NAMESPACE_ERR: 14,
+    INVALID_ACCESS_ERR: 15,
+    VALIDATION_ERR: 16,
+    TYPE_MISMATCH_ERR: 17,
+    SECURITY_ERR: 18,
+    NETWORK_ERR: 19,
+    ABORT_ERR: 20,
+    URL_MISMATCH_ERR: 21,
+    QUOTA_EXCEEDED_ERR: 22,
+    TIMEOUT_ERR: 23,
+    INVALID_NODE_TYPE_ERR: 24,
+    DATA_CLONE_ERR: 25
+  };
+  var entries = Object.entries(ExceptionCode);
+  for (i = 0;i < entries.length; i++) {
+    key = entries[i][0];
+    DOMException[key] = entries[i][1];
+  }
+  var key;
+  var i;
+  function ParseError(message, locator) {
+    this.message = message;
+    this.locator = locator;
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, ParseError);
+  }
+  extendError(ParseError);
+  exports.DOMException = DOMException;
+  exports.DOMExceptionName = DOMExceptionName;
+  exports.ExceptionCode = ExceptionCode;
+  exports.ParseError = ParseError;
+});
+
+// node_modules/.bun/@xmldom+xmldom@0.9.10/node_modules/@xmldom/xmldom/lib/grammar.js
+var require_grammar = __commonJS((exports) => {
+  function detectUnicodeSupport(RegExpImpl) {
+    try {
+      if (typeof RegExpImpl !== "function") {
+        RegExpImpl = RegExp;
+      }
+      var match = new RegExpImpl("\uD834\uDF06", "u").exec("\uD834\uDF06");
+      return !!match && match[0].length === 2;
+    } catch (error) {}
+    return false;
+  }
+  var UNICODE_SUPPORT = detectUnicodeSupport();
+  function chars(regexp) {
+    if (regexp.source[0] !== "[") {
+      throw new Error(regexp + " can not be used with chars");
+    }
+    return regexp.source.slice(1, regexp.source.lastIndexOf("]"));
+  }
+  function chars_without(regexp, search) {
+    if (regexp.source[0] !== "[") {
+      throw new Error("/" + regexp.source + "/ can not be used with chars_without");
+    }
+    if (!search || typeof search !== "string") {
+      throw new Error(JSON.stringify(search) + " is not a valid search");
+    }
+    if (regexp.source.indexOf(search) === -1) {
+      throw new Error('"' + search + '" is not is /' + regexp.source + "/");
+    }
+    if (search === "-" && regexp.source.indexOf(search) !== 1) {
+      throw new Error('"' + search + '" is not at the first postion of /' + regexp.source + "/");
+    }
+    return new RegExp(regexp.source.replace(search, ""), UNICODE_SUPPORT ? "u" : "");
+  }
+  function reg(args) {
+    var self = this;
+    return new RegExp(Array.prototype.slice.call(arguments).map(function(part) {
+      var isStr = typeof part === "string";
+      if (isStr && self === undefined && part === "|") {
+        throw new Error("use regg instead of reg to wrap expressions with `|`!");
+      }
+      return isStr ? part : part.source;
+    }).join(""), UNICODE_SUPPORT ? "mu" : "m");
+  }
+  function regg(args) {
+    if (arguments.length === 0) {
+      throw new Error("no parameters provided");
+    }
+    return reg.apply(regg, ["(?:"].concat(Array.prototype.slice.call(arguments), [")"]));
+  }
+  var UNICODE_REPLACEMENT_CHARACTER = "\uFFFD";
+  var Char = /[-\x09\x0A\x0D\x20-\x2C\x2E-\uD7FF\uE000-\uFFFD]/;
+  if (UNICODE_SUPPORT) {
+    Char = reg("[", chars(Char), "\\u{10000}-\\u{10FFFF}", "]");
+  }
+  var InvalidChar = new RegExp("[^" + chars(Char) + "]", UNICODE_SUPPORT ? "u" : "");
+  var _SChar = /[\x20\x09\x0D\x0A]/;
+  var SChar_s = chars(_SChar);
+  var S = reg(_SChar, "+");
+  var S_OPT = reg(_SChar, "*");
+  var NameStartChar = /[:_a-zA-Z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
+  if (UNICODE_SUPPORT) {
+    NameStartChar = reg("[", chars(NameStartChar), "\\u{10000}-\\u{10FFFF}", "]");
+  }
+  var NameStartChar_s = chars(NameStartChar);
+  var NameChar = reg("[", NameStartChar_s, chars(/[-.0-9\xB7]/), chars(/[\u0300-\u036F\u203F-\u2040]/), "]");
+  var Name = reg(NameStartChar, NameChar, "*");
+  var Nmtoken = reg(NameChar, "+");
+  var EntityRef = reg("&", Name, ";");
+  var CharRef = regg(/&#[0-9]+;|&#x[0-9a-fA-F]+;/);
+  var Reference = regg(EntityRef, "|", CharRef);
+  var PEReference = reg("%", Name, ";");
+  var EntityValue = regg(reg('"', regg(/[^%&"]/, "|", PEReference, "|", Reference), "*", '"'), "|", reg("'", regg(/[^%&']/, "|", PEReference, "|", Reference), "*", "'"));
+  var AttValue = regg('"', regg(/[^<&"]/, "|", Reference), "*", '"', "|", "'", regg(/[^<&']/, "|", Reference), "*", "'");
+  var NCNameStartChar = chars_without(NameStartChar, ":");
+  var NCNameChar = chars_without(NameChar, ":");
+  var NCName = reg(NCNameStartChar, NCNameChar, "*");
+  var QName = reg(NCName, regg(":", NCName), "?");
+  var QName_exact = reg("^", QName, "$");
+  var QName_group = reg("(", QName, ")");
+  var SystemLiteral = regg(/"[^"]*"|'[^']*'/);
+  var PI = reg(/^<\?/, "(", Name, ")", regg(S, "(", Char, "*?)"), "?", /\?>/);
+  var PubidChar = /[\x20\x0D\x0Aa-zA-Z0-9-'()+,./:=?;!*#@$_%]/;
+  var PubidLiteral = regg('"', PubidChar, '*"', "|", "'", chars_without(PubidChar, "'"), "*'");
+  var COMMENT_START = "<!--";
+  var COMMENT_END = "-->";
+  var Comment = reg(COMMENT_START, regg(chars_without(Char, "-"), "|", reg("-", chars_without(Char, "-"))), "*", COMMENT_END);
+  var PCDATA = "#PCDATA";
+  var Mixed = regg(reg(/\(/, S_OPT, PCDATA, regg(S_OPT, /\|/, S_OPT, QName), "*", S_OPT, /\)\*/), "|", reg(/\(/, S_OPT, PCDATA, S_OPT, /\)/));
+  var _children_quantity = /[?*+]?/;
+  var children2 = reg(/\([^>]+\)/, _children_quantity);
+  var contentspec = regg("EMPTY", "|", "ANY", "|", Mixed, "|", children2);
+  var ELEMENTDECL_START = "<!ELEMENT";
+  var elementdecl = reg(ELEMENTDECL_START, S, regg(QName, "|", PEReference), S, regg(contentspec, "|", PEReference), S_OPT, ">");
+  var NotationType = reg("NOTATION", S, /\(/, S_OPT, Name, regg(S_OPT, /\|/, S_OPT, Name), "*", S_OPT, /\)/);
+  var Enumeration = reg(/\(/, S_OPT, Nmtoken, regg(S_OPT, /\|/, S_OPT, Nmtoken), "*", S_OPT, /\)/);
+  var EnumeratedType = regg(NotationType, "|", Enumeration);
+  var AttType = regg(/CDATA|ID|IDREF|IDREFS|ENTITY|ENTITIES|NMTOKEN|NMTOKENS/, "|", EnumeratedType);
+  var DefaultDecl = regg(/#REQUIRED|#IMPLIED/, "|", regg(regg("#FIXED", S), "?", AttValue));
+  var AttDef = regg(S, Name, S, AttType, S, DefaultDecl);
+  var ATTLIST_DECL_START = "<!ATTLIST";
+  var AttlistDecl = reg(ATTLIST_DECL_START, S, Name, AttDef, "*", S_OPT, ">");
+  var ABOUT_LEGACY_COMPAT = "about:legacy-compat";
+  var ABOUT_LEGACY_COMPAT_SystemLiteral = regg('"' + ABOUT_LEGACY_COMPAT + '"', "|", "'" + ABOUT_LEGACY_COMPAT + "'");
+  var SYSTEM = "SYSTEM";
+  var PUBLIC = "PUBLIC";
+  var ExternalID = regg(regg(SYSTEM, S, SystemLiteral), "|", regg(PUBLIC, S, PubidLiteral, S, SystemLiteral));
+  var ExternalID_match = reg("^", regg(regg(SYSTEM, S, "(?<SystemLiteralOnly>", SystemLiteral, ")"), "|", regg(PUBLIC, S, "(?<PubidLiteral>", PubidLiteral, ")", S, "(?<SystemLiteral>", SystemLiteral, ")")));
+  var PubidLiteral_match = reg("^", PubidLiteral, "$");
+  var SystemLiteral_match = reg("^", SystemLiteral, "$");
+  var NDataDecl = regg(S, "NDATA", S, Name);
+  var EntityDef = regg(EntityValue, "|", regg(ExternalID, NDataDecl, "?"));
+  var ENTITY_DECL_START = "<!ENTITY";
+  var GEDecl = reg(ENTITY_DECL_START, S, Name, S, EntityDef, S_OPT, ">");
+  var PEDef = regg(EntityValue, "|", ExternalID);
+  var PEDecl = reg(ENTITY_DECL_START, S, "%", S, Name, S, PEDef, S_OPT, ">");
+  var EntityDecl = regg(GEDecl, "|", PEDecl);
+  var PublicID = reg(PUBLIC, S, PubidLiteral);
+  var NotationDecl = reg("<!NOTATION", S, Name, S, regg(ExternalID, "|", PublicID), S_OPT, ">");
+  var Eq = reg(S_OPT, "=", S_OPT);
+  var VersionNum = /1[.]\d+/;
+  var VersionInfo = reg(S, "version", Eq, regg("'", VersionNum, "'", "|", '"', VersionNum, '"'));
+  var EncName = /[A-Za-z][-A-Za-z0-9._]*/;
+  var EncodingDecl = regg(S, "encoding", Eq, regg('"', EncName, '"', "|", "'", EncName, "'"));
+  var SDDecl = regg(S, "standalone", Eq, regg("'", regg("yes", "|", "no"), "'", "|", '"', regg("yes", "|", "no"), '"'));
+  var XMLDecl = reg(/^<\?xml/, VersionInfo, EncodingDecl, "?", SDDecl, "?", S_OPT, /\?>/);
+  var DOCTYPE_DECL_START = "<!DOCTYPE";
+  var CDATA_START = "<![CDATA[";
+  var CDATA_END = "]]>";
+  var CDStart = /<!\[CDATA\[/;
+  var CDEnd = /\]\]>/;
+  var CData = reg(Char, "*?", CDEnd);
+  var CDSect = reg(CDStart, CData);
+  exports.chars = chars;
+  exports.chars_without = chars_without;
+  exports.detectUnicodeSupport = detectUnicodeSupport;
+  exports.reg = reg;
+  exports.regg = regg;
+  exports.ABOUT_LEGACY_COMPAT = ABOUT_LEGACY_COMPAT;
+  exports.ABOUT_LEGACY_COMPAT_SystemLiteral = ABOUT_LEGACY_COMPAT_SystemLiteral;
+  exports.AttlistDecl = AttlistDecl;
+  exports.CDATA_START = CDATA_START;
+  exports.CDATA_END = CDATA_END;
+  exports.CDSect = CDSect;
+  exports.Char = Char;
+  exports.Comment = Comment;
+  exports.COMMENT_START = COMMENT_START;
+  exports.COMMENT_END = COMMENT_END;
+  exports.DOCTYPE_DECL_START = DOCTYPE_DECL_START;
+  exports.elementdecl = elementdecl;
+  exports.EntityDecl = EntityDecl;
+  exports.EntityValue = EntityValue;
+  exports.ExternalID = ExternalID;
+  exports.ExternalID_match = ExternalID_match;
+  exports.Name = Name;
+  exports.NotationDecl = NotationDecl;
+  exports.Reference = Reference;
+  exports.PEReference = PEReference;
+  exports.PI = PI;
+  exports.PUBLIC = PUBLIC;
+  exports.PubidLiteral = PubidLiteral;
+  exports.PubidLiteral_match = PubidLiteral_match;
+  exports.QName = QName;
+  exports.QName_exact = QName_exact;
+  exports.QName_group = QName_group;
+  exports.S = S;
+  exports.SChar_s = SChar_s;
+  exports.S_OPT = S_OPT;
+  exports.SYSTEM = SYSTEM;
+  exports.SystemLiteral = SystemLiteral;
+  exports.SystemLiteral_match = SystemLiteral_match;
+  exports.InvalidChar = InvalidChar;
+  exports.UNICODE_REPLACEMENT_CHARACTER = UNICODE_REPLACEMENT_CHARACTER;
+  exports.UNICODE_SUPPORT = UNICODE_SUPPORT;
+  exports.XMLDecl = XMLDecl;
+});
+
+// node_modules/.bun/@xmldom+xmldom@0.9.10/node_modules/@xmldom/xmldom/lib/dom.js
 var require_dom = __commonJS((exports) => {
   var conventions = require_conventions();
   var find = conventions.find;
+  var hasDefaultHTMLNamespace = conventions.hasDefaultHTMLNamespace;
+  var hasOwn = conventions.hasOwn;
+  var isHTMLMimeType = conventions.isHTMLMimeType;
+  var isHTMLRawTextElement = conventions.isHTMLRawTextElement;
+  var isHTMLVoidElement = conventions.isHTMLVoidElement;
+  var MIME_TYPE = conventions.MIME_TYPE;
   var NAMESPACE = conventions.NAMESPACE;
+  var PDC = Symbol();
+  var errors = require_errors();
+  var DOMException = errors.DOMException;
+  var DOMExceptionName = errors.DOMExceptionName;
+  var g = require_grammar();
+  function checkSymbol(symbol) {
+    if (symbol !== PDC) {
+      throw new TypeError("Illegal constructor");
+    }
+  }
   function notEmptyString(input) {
     return input !== "";
   }
@@ -76,7 +479,7 @@ var require_dom = __commonJS((exports) => {
     return input ? input.split(/[\t\n\f\r ]+/).filter(notEmptyString) : [];
   }
   function orderedSetReducer(current, element) {
-    if (!current.hasOwnProperty(element)) {
+    if (!hasOwn(current, element)) {
       current[element] = true;
     }
     return current;
@@ -92,9 +495,38 @@ var require_dom = __commonJS((exports) => {
       return list && list.indexOf(element) !== -1;
     };
   }
+  function validateQualifiedName(qualifiedName) {
+    if (!g.QName_exact.test(qualifiedName)) {
+      throw new DOMException(DOMException.INVALID_CHARACTER_ERR, 'invalid character in qualified name "' + qualifiedName + '"');
+    }
+  }
+  function validateAndExtract(namespace, qualifiedName) {
+    validateQualifiedName(qualifiedName);
+    namespace = namespace || null;
+    var prefix = null;
+    var localName = qualifiedName;
+    if (qualifiedName.indexOf(":") >= 0) {
+      var splitResult = qualifiedName.split(":");
+      prefix = splitResult[0];
+      localName = splitResult[1];
+    }
+    if (prefix !== null && namespace === null) {
+      throw new DOMException(DOMException.NAMESPACE_ERR, "prefix is non-null and namespace is null");
+    }
+    if (prefix === "xml" && namespace !== conventions.NAMESPACE.XML) {
+      throw new DOMException(DOMException.NAMESPACE_ERR, 'prefix is "xml" and namespace is not the XML namespace');
+    }
+    if ((prefix === "xmlns" || qualifiedName === "xmlns") && namespace !== conventions.NAMESPACE.XMLNS) {
+      throw new DOMException(DOMException.NAMESPACE_ERR, 'either qualifiedName or prefix is "xmlns" and namespace is not the XMLNS namespace');
+    }
+    if (namespace === conventions.NAMESPACE.XMLNS && prefix !== "xmlns" && qualifiedName !== "xmlns") {
+      throw new DOMException(DOMException.NAMESPACE_ERR, 'namespace is the XMLNS namespace and neither qualifiedName nor prefix is "xmlns"');
+    }
+    return [namespace, prefix, localName];
+  }
   function copy(src, dest) {
     for (var p in src) {
-      if (Object.prototype.hasOwnProperty.call(src, p)) {
+      if (hasOwn(src, p)) {
         dest[p] = src[p];
       }
     }
@@ -102,12 +534,11 @@ var require_dom = __commonJS((exports) => {
   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;
+      let t = function() {};
+      t.prototype = Super.prototype;
+      t = new t;
+      copy(pt, t);
+      Class.prototype = pt = t;
     }
     if (pt.constructor != Class) {
       if (typeof Class != "function") {
@@ -129,49 +560,51 @@ var require_dom = __commonJS((exports) => {
   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);
+  var DocumentPosition = conventions.freeze({
+    DOCUMENT_POSITION_DISCONNECTED: 1,
+    DOCUMENT_POSITION_PRECEDING: 2,
+    DOCUMENT_POSITION_FOLLOWING: 4,
+    DOCUMENT_POSITION_CONTAINS: 8,
+    DOCUMENT_POSITION_CONTAINED_BY: 16,
+    DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32
+  });
+  function commonAncestor(a, b) {
+    if (b.length < a.length)
+      return commonAncestor(b, a);
+    var c = null;
+    for (var n in a) {
+      if (a[n] !== b[n])
+        return c;
+      c = a[n];
     }
-    error.code = code;
-    if (message)
-      this.message = this.message + ": " + message;
-    return error;
+    return c;
+  }
+  function docGUID(doc) {
+    if (!doc.guid)
+      doc.guid = Math.random();
+    return doc.guid;
   }
-  DOMException.prototype = Error.prototype;
-  copy(ExceptionCode, DOMException);
   function NodeList() {}
   NodeList.prototype = {
     length: 0,
     item: function(index) {
       return index >= 0 && index < this.length ? this[index] : null;
     },
-    toString: function(isHTML, nodeFilter) {
+    toString: function(options) {
+      var opts;
+      if (typeof options === "function") {
+        opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: options };
+      } else if (!!options) {
+        opts = {
+          requireWellFormed: !!options.requireWellFormed,
+          splitCDATASections: options.splitCDATASections !== false,
+          nodeFilter: options.nodeFilter || null
+        };
+      } else {
+        opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: null };
+      }
       for (var buf = [], i = 0;i < this.length; i++) {
-        serializeToString(this[i], buf, isHTML, nodeFilter);
+        serializeToString(this[i], buf, null, opts);
       }
       return buf.join("");
     },
@@ -182,6 +615,29 @@ var require_dom = __commonJS((exports) => {
       return Array.prototype.indexOf.call(this, item);
     }
   };
+  NodeList.prototype[Symbol.iterator] = function() {
+    var me = this;
+    var index = 0;
+    return {
+      next: function() {
+        if (index < me.length) {
+          return {
+            value: me[index++],
+            done: false
+          };
+        } else {
+          return {
+            done: true
+          };
+        }
+      },
+      return: function() {
+        return {
+          done: true
+        };
+      }
+    };
+  };
   function LiveNodeList(node, refresh) {
     this._node = node;
     this._refresh = refresh;
@@ -194,7 +650,7 @@ var require_dom = __commonJS((exports) => {
       __set__(list, "length", ls.length);
       if (!list.$$length || ls.length < list.$$length) {
         for (var i = ls.length;i in list; i++) {
-          if (Object.prototype.hasOwnProperty.call(list, i)) {
+          if (hasOwn(list, i)) {
             delete list[i];
           }
         }
@@ -210,18 +666,20 @@ var require_dom = __commonJS((exports) => {
   _extends(LiveNodeList, NodeList);
   function NamedNodeMap() {}
   function _findNodeIndex(list, node) {
-    var i = list.length;
-    while (i--) {
+    var i = 0;
+    while (i < list.length) {
       if (list[i] === node) {
         return i;
       }
+      i++;
     }
   }
   function _addNamedNode(el, list, newAttr, oldAttr) {
     if (oldAttr) {
       list[_findNodeIndex(list, oldAttr)] = newAttr;
     } else {
-      list[list.length++] = newAttr;
+      list[list.length] = newAttr;
+      list.length++;
     }
     if (el) {
       newAttr.ownerElement = el;
@@ -236,7 +694,7 @@ var require_dom = __commonJS((exports) => {
     var i = _findNodeIndex(list, attr);
     if (i >= 0) {
       var lastIndex = list.length - 1;
-      while (i < lastIndex) {
+      while (i <= lastIndex) {
         list[i] = list[++i];
       }
       list.length = lastIndex;
@@ -244,71 +702,110 @@ var require_dom = __commonJS((exports) => {
         var doc = el.ownerDocument;
         if (doc) {
           _onRemoveAttribute(doc, el, attr);
-          attr.ownerElement = null;
         }
+        attr.ownerElement = null;
       }
-    } else {
-      throw new 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--) {
+    getNamedItem: function(localName) {
+      if (this._ownerElement && this._ownerElement._isInHTMLDocumentAndNamespace()) {
+        localName = localName.toLowerCase();
+      }
+      var i = 0;
+      while (i < this.length) {
         var attr = this[i];
-        if (attr.nodeName == key) {
+        if (attr.nodeName === localName) {
           return attr;
         }
+        i++;
       }
+      return null;
     },
     setNamedItem: function(attr) {
       var el = attr.ownerElement;
-      if (el && el != this._ownerElement) {
-        throw new DOMException(INUSE_ATTRIBUTE_ERR);
+      if (el && el !== this._ownerElement) {
+        throw new DOMException(DOMException.INUSE_ATTRIBUTE_ERR);
+      }
+      var oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);
+      if (oldAttr === attr) {
+        return attr;
       }
-      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;
+      return this.setNamedItem(attr);
     },
-    removeNamedItem: function(key) {
-      var attr = this.getNamedItem(key);
+    removeNamedItem: function(localName) {
+      var attr = this.getNamedItem(localName);
+      if (!attr) {
+        throw new DOMException(DOMException.NOT_FOUND_ERR, localName);
+      }
       _removeNamedNode(this._ownerElement, this, attr);
       return attr;
     },
     removeNamedItemNS: function(namespaceURI, localName) {
       var attr = this.getNamedItemNS(namespaceURI, localName);
+      if (!attr) {
+        throw new DOMException(DOMException.NOT_FOUND_ERR, namespaceURI ? namespaceURI + " : " + localName : localName);
+      }
       _removeNamedNode(this._ownerElement, this, attr);
       return attr;
     },
     getNamedItemNS: function(namespaceURI, localName) {
-      var i = this.length;
-      while (i--) {
+      if (!namespaceURI) {
+        namespaceURI = null;
+      }
+      var i = 0;
+      while (i < this.length) {
         var node = this[i];
-        if (node.localName == localName && node.namespaceURI == namespaceURI) {
+        if (node.localName === localName && node.namespaceURI === namespaceURI) {
           return node;
         }
+        i++;
       }
       return null;
     }
   };
+  NamedNodeMap.prototype[Symbol.iterator] = function() {
+    var me = this;
+    var index = 0;
+    return {
+      next: function() {
+        if (index < me.length) {
+          return {
+            value: me[index++],
+            done: false
+          };
+        } else {
+          return {
+            done: true
+          };
+        }
+      },
+      return: function() {
+        return {
+          done: true
+        };
+      }
+    };
+  };
   function DOMImplementation() {}
   DOMImplementation.prototype = {
     hasFeature: function(feature, version) {
       return true;
     },
     createDocument: function(namespaceURI, qualifiedName, doctype) {
-      var doc = new Document;
+      var contentType = MIME_TYPE.XML_APPLICATION;
+      if (namespaceURI === NAMESPACE.HTML) {
+        contentType = MIME_TYPE.XML_XHTML_APPLICATION;
+      } else if (namespaceURI === NAMESPACE.SVG) {
+        contentType = MIME_TYPE.XML_SVG_IMAGE;
+      }
+      var doc = new Document(PDC, { contentType });
       doc.implementation = this;
       doc.childNodes = new NodeList;
       doc.doctype = doctype || null;
@@ -321,29 +818,148 @@ var require_dom = __commonJS((exports) => {
       }
       return doc;
     },
-    createDocumentType: function(qualifiedName, publicId, systemId) {
-      var node = new DocumentType;
+    createDocumentType: function(qualifiedName, publicId, systemId, internalSubset) {
+      validateQualifiedName(qualifiedName);
+      var node = new DocumentType(PDC);
       node.name = qualifiedName;
       node.nodeName = qualifiedName;
       node.publicId = publicId || "";
       node.systemId = systemId || "";
+      node.internalSubset = internalSubset || "";
+      node.childNodes = new NodeList;
       return node;
+    },
+    createHTMLDocument: function(title) {
+      var doc = new Document(PDC, { contentType: MIME_TYPE.HTML });
+      doc.implementation = this;
+      doc.childNodes = new NodeList;
+      if (title !== false) {
+        doc.doctype = this.createDocumentType("html");
+        doc.doctype.ownerDocument = doc;
+        doc.appendChild(doc.doctype);
+        var htmlNode = doc.createElement("html");
+        doc.appendChild(htmlNode);
+        var headNode = doc.createElement("head");
+        htmlNode.appendChild(headNode);
+        if (typeof title === "string") {
+          var titleNode = doc.createElement("title");
+          titleNode.appendChild(doc.createTextNode(title));
+          headNode.appendChild(titleNode);
+        }
+        htmlNode.appendChild(doc.createElement("body"));
+      }
+      return doc;
     }
   };
-  function Node() {}
+  function Node(symbol) {
+    checkSymbol(symbol);
+  }
   Node.prototype = {
     firstChild: null,
     lastChild: null,
     previousSibling: null,
     nextSibling: null,
-    attributes: null,
     parentNode: null,
+    get parentElement() {
+      return this.parentNode && this.parentNode.nodeType === this.ELEMENT_NODE ? this.parentNode : null;
+    },
     childNodes: null,
     ownerDocument: null,
     nodeValue: null,
     namespaceURI: null,
     prefix: null,
     localName: null,
+    baseURI: "about:blank",
+    get isConnected() {
+      var rootNode = this.getRootNode();
+      return rootNode && rootNode.nodeType === rootNode.DOCUMENT_NODE;
+    },
+    contains: function(other) {
+      if (!other)
+        return false;
+      var parent = other;
+      do {
+        if (this === parent)
+          return true;
+        parent = parent.parentNode;
+      } while (parent);
+      return false;
+    },
+    getRootNode: function(options) {
+      var parent = this;
+      do {
+        if (!parent.parentNode) {
+          return parent;
+        }
+        parent = parent.parentNode;
+      } while (parent);
+    },
+    isEqualNode: function(otherNode) {
+      if (!otherNode)
+        return false;
+      var stack = [{ node: this, other: otherNode }];
+      while (stack.length > 0) {
+        var pair = stack.pop();
+        var node = pair.node;
+        var other = pair.other;
+        if (node.nodeType !== other.nodeType)
+          return false;
+        switch (node.nodeType) {
+          case node.DOCUMENT_TYPE_NODE:
+            if (node.name !== other.name)
+              return false;
+            if (node.publicId !== other.publicId)
+              return false;
+            if (node.systemId !== other.systemId)
+              return false;
+            break;
+          case node.ELEMENT_NODE:
+            if (node.namespaceURI !== other.namespaceURI)
+              return false;
+            if (node.prefix !== other.prefix)
+              return false;
+            if (node.localName !== other.localName)
+              return false;
+            if (node.attributes.length !== other.attributes.length)
+              return false;
+            for (var i = 0;i < node.attributes.length; i++) {
+              var attr = node.attributes.item(i);
+              var otherAttr = other.getAttributeNodeNS(attr.namespaceURI, attr.localName);
+              if (!otherAttr)
+                return false;
+              stack.push({ node: attr, other: otherAttr });
+            }
+            break;
+          case node.ATTRIBUTE_NODE:
+            if (node.namespaceURI !== other.namespaceURI)
+              return false;
+            if (node.localName !== other.localName)
+              return false;
+            if (node.value !== other.value)
+              return false;
+            break;
+          case node.PROCESSING_INSTRUCTION_NODE:
+            if (node.target !== other.target || node.data !== other.data)
+              return false;
+            break;
+          case node.TEXT_NODE:
+          case node.CDATA_SECTION_NODE:
+          case node.COMMENT_NODE:
+            if (node.data !== other.data)
+              return false;
+            break;
+        }
+        if (node.childNodes.length !== other.childNodes.length)
+          return false;
+        for (var i = node.childNodes.length - 1;i >= 0; i--) {
+          stack.push({ node: node.childNodes[i], other: other.childNodes[i] });
+        }
+      }
+      return true;
+    },
+    isSameNode: function(otherNode) {
+      return this === otherNode;
+    },
     insertBefore: function(newChild, refChild) {
       return _insertBefore(this, newChild, refChild);
     },
@@ -366,31 +982,32 @@ var require_dom = __commonJS((exports) => {
       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;
+      walkDOM(this, null, {
+        enter: function(node) {
+          var child = node.firstChild;
+          while (child) {
+            var next = child.nextSibling;
+            if (next !== null && next.nodeType === TEXT_NODE && child.nodeType === TEXT_NODE) {
+              node.removeChild(next);
+              child.appendData(next.data);
+            } else {
+              child = next;
+            }
+          }
+          return true;
         }
-      }
+      });
     },
     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 (Object.prototype.hasOwnProperty.call(map, n) && map[n] === namespaceURI) {
+            if (hasOwn(map, n) && map[n] === namespaceURI) {
               return n;
             }
           }
@@ -404,7 +1021,7 @@ var require_dom = __commonJS((exports) => {
       while (el) {
         var map = el._nsMap;
         if (map) {
-          if (Object.prototype.hasOwnProperty.call(map, prefix)) {
+          if (hasOwn(map, prefix)) {
             return map[prefix];
           }
         }
@@ -415,6 +1032,72 @@ var require_dom = __commonJS((exports) => {
     isDefaultNamespace: function(namespaceURI) {
       var prefix = this.lookupPrefix(namespaceURI);
       return prefix == null;
+    },
+    compareDocumentPosition: function(other) {
+      if (this === other)
+        return 0;
+      var node1 = other;
+      var node2 = this;
+      var attr1 = null;
+      var attr2 = null;
+      if (node1 instanceof Attr) {
+        attr1 = node1;
+        node1 = attr1.ownerElement;
+      }
+      if (node2 instanceof Attr) {
+        attr2 = node2;
+        node2 = attr2.ownerElement;
+        if (attr1 && node1 && node2 === node1) {
+          for (var i = 0, attr;attr = node2.attributes[i]; i++) {
+            if (attr === attr1)
+              return DocumentPosition.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC + DocumentPosition.DOCUMENT_POSITION_PRECEDING;
+            if (attr === attr2)
+              return DocumentPosition.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC + DocumentPosition.DOCUMENT_POSITION_FOLLOWING;
+          }
+        }
+      }
+      if (!node1 || !node2 || node2.ownerDocument !== node1.ownerDocument) {
+        return DocumentPosition.DOCUMENT_POSITION_DISCONNECTED + DocumentPosition.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC + (docGUID(node2.ownerDocument) > docGUID(node1.ownerDocument) ? DocumentPosition.DOCUMENT_POSITION_FOLLOWING : DocumentPosition.DOCUMENT_POSITION_PRECEDING);
+      }
+      if (attr2 && node1 === node2) {
+        return DocumentPosition.DOCUMENT_POSITION_CONTAINS + DocumentPosition.DOCUMENT_POSITION_PRECEDING;
+      }
+      if (attr1 && node1 === node2) {
+        return DocumentPosition.DOCUMENT_POSITION_CONTAINED_BY + DocumentPosition.DOCUMENT_POSITION_FOLLOWING;
+      }
+      var chain1 = [];
+      var ancestor1 = node1.parentNode;
+      while (ancestor1) {
+        if (!attr2 && ancestor1 === node2) {
+          return DocumentPosition.DOCUMENT_POSITION_CONTAINED_BY + DocumentPosition.DOCUMENT_POSITION_FOLLOWING;
+        }
+        chain1.push(ancestor1);
+        ancestor1 = ancestor1.parentNode;
+      }
+      chain1.reverse();
+      var chain2 = [];
+      var ancestor2 = node2.parentNode;
+      while (ancestor2) {
+        if (!attr1 && ancestor2 === node1) {
+          return DocumentPosition.DOCUMENT_POSITION_CONTAINS + DocumentPosition.DOCUMENT_POSITION_PRECEDING;
+        }
+        chain2.push(ancestor2);
+        ancestor2 = ancestor2.parentNode;
+      }
+      chain2.reverse();
+      var ca = commonAncestor(chain1, chain2);
+      for (var n in ca.childNodes) {
+        var child = ca.childNodes[n];
+        if (child === node2)
+          return DocumentPosition.DOCUMENT_POSITION_FOLLOWING;
+        if (child === node1)
+          return DocumentPosition.DOCUMENT_POSITION_PRECEDING;
+        if (chain2.indexOf(child) >= 0)
+          return DocumentPosition.DOCUMENT_POSITION_FOLLOWING;
+        if (chain1.indexOf(child) >= 0)
+          return DocumentPosition.DOCUMENT_POSITION_PRECEDING;
+      }
+      return 0;
     }
   };
   function _xmlEncoder(c) {
@@ -422,20 +1105,49 @@ var require_dom = __commonJS((exports) => {
   }
   copy(NodeType, Node);
   copy(NodeType, Node.prototype);
+  copy(DocumentPosition, Node);
+  copy(DocumentPosition, Node.prototype);
   function _visitNode(node, callback) {
-    if (callback(node)) {
-      return true;
-    }
-    if (node = node.firstChild) {
-      do {
-        if (_visitNode(node, callback)) {
-          return true;
+    walkDOM(node, null, {
+      enter: function(n) {
+        return callback(n) ? walkDOM.STOP : true;
+      }
+    });
+  }
+  function walkDOM(node, context, callbacks) {
+    var stack = [{ node, context, phase: walkDOM.ENTER }];
+    while (stack.length > 0) {
+      var frame = stack.pop();
+      if (frame.phase === walkDOM.ENTER) {
+        var childContext = callbacks.enter(frame.node, frame.context);
+        if (childContext === walkDOM.STOP) {
+          return walkDOM.STOP;
+        }
+        stack.push({ node: frame.node, context: childContext, phase: walkDOM.EXIT });
+        if (childContext === null || childContext === undefined) {
+          continue;
         }
-      } while (node = node.nextSibling);
+        var child = frame.node.lastChild;
+        while (child) {
+          stack.push({ node: child, context: childContext, phase: walkDOM.ENTER });
+          child = child.previousSibling;
+        }
+      } else {
+        if (callbacks.exit) {
+          callbacks.exit(frame.node, frame.context);
+        }
+      }
     }
   }
-  function Document() {
+  walkDOM.STOP = Symbol("walkDOM.STOP");
+  walkDOM.ENTER = 0;
+  walkDOM.EXIT = 1;
+  function Document(symbol, options) {
+    checkSymbol(symbol);
+    var opt = options || {};
     this.ownerDocument = this;
+    this.contentType = opt.contentType || MIME_TYPE.XML_APPLICATION;
+    this.type = isHTMLMimeType(this.contentType) ? "html" : "xml";
   }
   function _onAddAttribute(doc, el, newAttr) {
     doc && doc._inc++;
@@ -451,48 +1163,51 @@ var require_dom = __commonJS((exports) => {
       delete el._nsMap[newAttr.prefix ? newAttr.localName : ""];
     }
   }
-  function _onUpdateChild(doc, el, newChild) {
+  function _onUpdateChild(doc, parent, newChild) {
     if (doc && doc._inc) {
       doc._inc++;
-      var cs = el.childNodes;
-      if (newChild) {
-        cs[cs.length++] = newChild;
+      var childNodes = parent.childNodes;
+      if (newChild && !newChild.nextSibling) {
+        childNodes[childNodes.length++] = newChild;
       } else {
-        var child = el.firstChild;
+        var child = parent.firstChild;
         var i = 0;
         while (child) {
-          cs[i++] = child;
+          childNodes[i++] = child;
           child = child.nextSibling;
         }
-        cs.length = i;
-        delete cs[cs.length];
+        childNodes.length = i;
+        delete childNodes[childNodes.length];
       }
     }
   }
   function _removeChild(parentNode, child) {
-    var previous = child.previousSibling;
-    var next = child.nextSibling;
-    if (previous) {
-      previous.nextSibling = next;
+    if (parentNode !== child.parentNode) {
+      throw new DOMException(DOMException.NOT_FOUND_ERR, "child's parent is not parent");
+    }
+    var oldPreviousSibling = child.previousSibling;
+    var oldNextSibling = child.nextSibling;
+    if (oldPreviousSibling) {
+      oldPreviousSibling.nextSibling = oldNextSibling;
     } else {
-      parentNode.firstChild = next;
+      parentNode.firstChild = oldNextSibling;
     }
-    if (next) {
-      next.previousSibling = previous;
+    if (oldNextSibling) {
+      oldNextSibling.previousSibling = oldPreviousSibling;
     } else {
-      parentNode.lastChild = previous;
+      parentNode.lastChild = oldPreviousSibling;
     }
+    _onUpdateChild(parentNode.ownerDocument, parentNode);
     child.parentNode = null;
     child.previousSibling = null;
     child.nextSibling = null;
-    _onUpdateChild(parentNode.ownerDocument, parentNode);
     return child;
   }
   function hasValidParentNodeType(node) {
     return node && (node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.ELEMENT_NODE);
   }
   function hasInsertableNodeType(node) {
-    return node && (isElementNode(node) || isTextNode(node) || isDocTypeNode(node) || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.COMMENT_NODE || node.nodeType === Node.PROCESSING_INSTRUCTION_NODE);
+    return node && (node.nodeType === Node.CDATA_SECTION_NODE || node.nodeType === Node.COMMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.DOCUMENT_TYPE_NODE || node.nodeType === Node.ELEMENT_NODE || node.nodeType === Node.PROCESSING_INSTRUCTION_NODE || node.nodeType === Node.TEXT_NODE);
   }
   function isDocTypeNode(node) {
     return node && node.nodeType === Node.DOCUMENT_TYPE_NODE;
@@ -524,13 +1239,13 @@ var require_dom = __commonJS((exports) => {
   }
   function assertPreInsertionValidity1to5(parent, node, child) {
     if (!hasValidParentNodeType(parent)) {
-      throw new DOMException(HIERARCHY_REQUEST_ERR, "Unexpected parent node type " + parent.nodeType);
+      throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Unexpected parent node type " + parent.nodeType);
     }
     if (child && child.parentNode !== parent) {
-      throw new DOMException(NOT_FOUND_ERR, "child not in parent");
+      throw new DOMException(DOMException.NOT_FOUND_ERR, "child not in parent");
     }
     if (!hasInsertableNodeType(node) || isDocTypeNode(node) && parent.nodeType !== Node.DOCUMENT_NODE) {
-      throw new DOMException(HIERARCHY_REQUEST_ERR, "Unexpected node type " + node.nodeType + " for parent node type " + parent.nodeType);
+      throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Unexpected node type " + node.nodeType + " for parent node type " + parent.nodeType);
     }
   }
   function assertPreInsertionValidityInDocument(parent, node, child) {
@@ -539,27 +1254,27 @@ var require_dom = __commonJS((exports) => {
     if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
       var nodeChildElements = nodeChildNodes.filter(isElementNode);
       if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {
-        throw new DOMException(HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
+        throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
       }
       if (nodeChildElements.length === 1 && !isElementInsertionPossible(parent, child)) {
-        throw new DOMException(HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
+        throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
       }
     }
     if (isElementNode(node)) {
       if (!isElementInsertionPossible(parent, child)) {
-        throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
+        throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
       }
     }
     if (isDocTypeNode(node)) {
       if (find(parentChildNodes, isDocTypeNode)) {
-        throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
+        throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
       }
       var parentElementChild = find(parentChildNodes, isElementNode);
       if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {
-        throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
+        throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
       }
       if (!child && parentElementChild) {
-        throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can not be appended since element is present");
+        throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Doctype can not be appended since element is present");
       }
     }
   }
@@ -569,28 +1284,27 @@ var require_dom = __commonJS((exports) => {
     if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
       var nodeChildElements = nodeChildNodes.filter(isElementNode);
       if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {
-        throw new DOMException(HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
+        throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
       }
       if (nodeChildElements.length === 1 && !isElementReplacementPossible(parent, child)) {
-        throw new DOMException(HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
+        throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
       }
     }
     if (isElementNode(node)) {
       if (!isElementReplacementPossible(parent, child)) {
-        throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
+        throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
       }
     }
     if (isDocTypeNode(node)) {
-      let hasDoctypeChildThatIsNotChild2 = function(node2) {
+      let hasDoctypeChildThatIsNotChild = function(node2) {
         return isDocTypeNode(node2) && node2 !== child;
       };
-      var hasDoctypeChildThatIsNotChild = hasDoctypeChildThatIsNotChild2;
-      if (find(parentChildNodes, hasDoctypeChildThatIsNotChild2)) {
-        throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
+      if (find(parentChildNodes, hasDoctypeChildThatIsNotChild)) {
+        throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
       }
       var parentElementChild = find(parentChildNodes, isElementNode);
       if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {
-        throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
+        throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
       }
     }
   }
@@ -627,60 +1341,22 @@ var require_dom = __commonJS((exports) => {
     }
     do {
       newFirst.parentNode = parent;
-      var targetDoc = parent.ownerDocument || parent;
-      _updateOwnerDocument(newFirst, targetDoc);
     } while (newFirst !== newLast && (newFirst = newFirst.nextSibling));
-    _onUpdateChild(parent.ownerDocument || parent, parent);
+    _onUpdateChild(parent.ownerDocument || parent, parent, node);
     if (node.nodeType == DOCUMENT_FRAGMENT_NODE) {
       node.firstChild = node.lastChild = null;
     }
     return node;
   }
-  function _updateOwnerDocument(node, newOwnerDocument) {
-    if (node.ownerDocument === newOwnerDocument) {
-      return;
-    }
-    node.ownerDocument = newOwnerDocument;
-    if (node.nodeType === ELEMENT_NODE && node.attributes) {
-      for (var i = 0;i < node.attributes.length; i++) {
-        var attr = node.attributes.item(i);
-        if (attr) {
-          attr.ownerDocument = newOwnerDocument;
-        }
-      }
-    }
-    var child = node.firstChild;
-    while (child) {
-      _updateOwnerDocument(child, newOwnerDocument);
-      child = child.nextSibling;
-    }
-  }
-  function _appendSingleChild(parentNode, newChild) {
-    if (newChild.parentNode) {
-      newChild.parentNode.removeChild(newChild);
-    }
-    newChild.parentNode = parentNode;
-    newChild.previousSibling = parentNode.lastChild;
-    newChild.nextSibling = null;
-    if (newChild.previousSibling) {
-      newChild.previousSibling.nextSibling = newChild;
-    } else {
-      parentNode.firstChild = newChild;
-    }
-    parentNode.lastChild = newChild;
-    _onUpdateChild(parentNode.ownerDocument, parentNode, newChild);
-    var targetDoc = parentNode.ownerDocument || parentNode;
-    _updateOwnerDocument(newChild, targetDoc);
-    return newChild;
-  }
   Document.prototype = {
+    implementation: null,
     nodeName: "#document",
     nodeType: DOCUMENT_NODE,
     doctype: null,
     documentElement: null,
     _inc: 1,
     insertBefore: function(newChild, refChild) {
-      if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
+      if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {
         var child = newChild.firstChild;
         while (child) {
           var next = child.nextSibling;
@@ -690,21 +1366,22 @@ var require_dom = __commonJS((exports) => {
         return newChild;
       }
       _insertBefore(this, newChild, refChild);
-      _updateOwnerDocument(newChild, this);
+      newChild.ownerDocument = this;
       if (this.documentElement === null && newChild.nodeType === ELEMENT_NODE) {
         this.documentElement = newChild;
       }
       return newChild;
     },
     removeChild: function(oldChild) {
-      if (this.documentElement == oldChild) {
+      var removed = _removeChild(this, oldChild);
+      if (removed === this.documentElement) {
         this.documentElement = null;
       }
-      return _removeChild(this, oldChild);
+      return removed;
     },
     replaceChild: function(newChild, oldChild) {
       _insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
-      _updateOwnerDocument(newChild, this);
+      newChild.ownerDocument = this;
       if (oldChild) {
         this.removeChild(oldChild);
       }
@@ -727,33 +1404,15 @@ var require_dom = __commonJS((exports) => {
       });
       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;
+      var node = new Element(PDC);
       node.ownerDocument = this;
+      if (this.type === "html") {
+        tagName = tagName.toLowerCase();
+      }
+      if (hasDefaultHTMLNamespace(this.contentType)) {
+        node.namespaceURI = NAMESPACE.HTML;
+      }
       node.nodeName = tagName;
       node.tagName = tagName;
       node.localName = tagName;
@@ -763,42 +1422,56 @@ var require_dom = __commonJS((exports) => {
       return node;
     },
     createDocumentFragment: function() {
-      var node = new DocumentFragment;
+      var node = new DocumentFragment(PDC);
       node.ownerDocument = this;
       node.childNodes = new NodeList;
       return node;
     },
     createTextNode: function(data) {
-      var node = new Text;
+      var node = new Text(PDC);
       node.ownerDocument = this;
+      node.childNodes = new NodeList;
       node.appendData(data);
       return node;
     },
     createComment: function(data) {
-      var node = new Comment;
+      var node = new Comment(PDC);
       node.ownerDocument = this;
+      node.childNodes = new NodeList;
       node.appendData(data);
       return node;
     },
     createCDATASection: function(data) {
       if (data.indexOf("]]>") !== -1) {
-        throw new DOMException(INVALID_CHARACTER_ERR, 'data contains "]]>"');
+        throw new DOMException(DOMException.INVALID_CHARACTER_ERR, 'data contains "]]>"');
       }
-      var node = new CDATASection;
+      var node = new CDATASection(PDC);
       node.ownerDocument = this;
+      node.childNodes = new NodeList;
       node.appendData(data);
       return node;
     },
     createProcessingInstruction: function(target, data) {
-      var node = new ProcessingInstruction;
+      var node = new ProcessingInstruction(PDC);
       node.ownerDocument = this;
-      node.tagName = node.nodeName = node.target = target;
+      node.childNodes = new NodeList;
+      node.nodeName = node.target = target;
       node.nodeValue = node.data = data;
       return node;
     },
     createAttribute: function(name) {
-      var node = new Attr;
+      if (!g.QName_exact.test(name)) {
+        throw new DOMException(DOMException.INVALID_CHARACTER_ERR, 'invalid character in name "' + name + '"');
+      }
+      if (this.type === "html") {
+        name = name.toLowerCase();
+      }
+      return this._createAttribute(name);
+    },
+    _createAttribute: function(name) {
+      var node = new Attr(PDC);
       node.ownerDocument = this;
+      node.childNodes = new NodeList;
       node.name = name;
       node.nodeName = name;
       node.localName = name;
@@ -806,78 +1479,93 @@ var require_dom = __commonJS((exports) => {
       return node;
     },
     createEntityReference: function(name) {
-      var node = new EntityReference;
+      if (!g.Name.test(name)) {
+        throw new DOMException(DOMException.INVALID_CHARACTER_ERR, 'not a valid xml name "' + name + '"');
+      }
+      if (this.type === "html") {
+        throw new DOMException("document is an html document", DOMExceptionName.NotSupportedError);
+      }
+      var node = new EntityReference(PDC);
       node.ownerDocument = this;
+      node.childNodes = new NodeList;
       node.nodeName = name;
       return node;
     },
     createElementNS: function(namespaceURI, qualifiedName) {
-      var node = new Element;
-      var pl = qualifiedName.split(":");
+      var validated = validateAndExtract(namespaceURI, qualifiedName);
+      var node = new Element(PDC);
       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;
-      }
+      node.namespaceURI = validated[0];
+      node.prefix = validated[1];
+      node.localName = validated[2];
       attrs._ownerElement = node;
       return node;
     },
     createAttributeNS: function(namespaceURI, qualifiedName) {
-      var node = new Attr;
-      var pl = qualifiedName.split(":");
+      var validated = validateAndExtract(namespaceURI, qualifiedName);
+      var node = new Attr(PDC);
       node.ownerDocument = this;
+      node.childNodes = new NodeList;
       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;
-      }
+      node.namespaceURI = validated[0];
+      node.prefix = validated[1];
+      node.localName = validated[2];
       return node;
     }
   };
   _extends(Document, Node);
-  function Element() {
-    this._nsMap = {};
+  function Element(symbol) {
+    checkSymbol(symbol);
+    this._nsMap = Object.create(null);
   }
   Element.prototype = {
     nodeType: ELEMENT_NODE,
+    attributes: null,
+    getQualifiedName: function() {
+      return this.prefix ? this.prefix + ":" + this.localName : this.localName;
+    },
+    _isInHTMLDocumentAndNamespace: function() {
+      return this.ownerDocument.type === "html" && this.namespaceURI === NAMESPACE.HTML;
+    },
+    hasAttributes: function() {
+      return !!(this.attributes && this.attributes.length);
+    },
     hasAttribute: function(name) {
-      return this.getAttributeNode(name) != null;
+      return !!this.getAttributeNode(name);
     },
     getAttribute: function(name) {
       var attr = this.getAttributeNode(name);
-      return attr && attr.value || "";
+      return attr ? attr.value : null;
     },
     getAttributeNode: function(name) {
+      if (this._isInHTMLDocumentAndNamespace()) {
+        name = name.toLowerCase();
+      }
       return this.attributes.getNamedItem(name);
     },
     setAttribute: function(name, value) {
-      var attr = this.ownerDocument.createAttribute(name);
-      attr.value = attr.nodeValue = "" + value;
-      this.setAttributeNode(attr);
+      if (this._isInHTMLDocumentAndNamespace()) {
+        name = name.toLowerCase();
+      }
+      var attr = this.getAttributeNode(name);
+      if (attr) {
+        attr.value = attr.nodeValue = "" + value;
+      } else {
+        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);
     },
@@ -896,22 +1584,64 @@ var require_dom = __commonJS((exports) => {
     },
     getAttributeNS: function(namespaceURI, localName) {
       var attr = this.getAttributeNodeNS(namespaceURI, localName);
-      return attr && attr.value || "";
+      return attr ? attr.value : null;
     },
     setAttributeNS: function(namespaceURI, qualifiedName, value) {
-      var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
-      attr.value = attr.nodeValue = "" + value;
-      this.setAttributeNode(attr);
+      var validated = validateAndExtract(namespaceURI, qualifiedName);
+      var localName = validated[2];
+      var attr = this.getAttributeNodeNS(namespaceURI, localName);
+      if (attr) {
+        attr.value = attr.nodeValue = "" + value;
+      } else {
+        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) {
+    getElementsByClassName: function(classNames) {
+      var classNamesSet = toOrderedSet(classNames);
+      return new LiveNodeList(this, function(base) {
+        var ls = [];
+        if (classNamesSet.length > 0) {
+          _visitNode(base, 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;
+      });
+    },
+    getElementsByTagName: function(qualifiedName) {
+      var isHTMLDocument = (this.nodeType === DOCUMENT_NODE ? this : this.ownerDocument).type === "html";
+      var lowerQualifiedName = qualifiedName.toLowerCase();
       return new LiveNodeList(this, function(base) {
         var ls = [];
         _visitNode(base, function(node) {
-          if (node !== base && node.nodeType == ELEMENT_NODE && (tagName === "*" || node.tagName == tagName)) {
+          if (node === base || node.nodeType !== ELEMENT_NODE) {
+            return;
+          }
+          if (qualifiedName === "*") {
             ls.push(node);
+          } else {
+            var nodeQualifiedName = node.getQualifiedName();
+            var matchingQName = isHTMLDocument && node.namespaceURI === NAMESPACE.HTML ? lowerQualifiedName : qualifiedName;
+            if (nodeQualifiedName === matchingQName) {
+              ls.push(node);
+            }
           }
         });
         return ls;
@@ -929,13 +1659,21 @@ var require_dom = __commonJS((exports) => {
       });
     }
   };
+  Document.prototype.getElementsByClassName = Element.prototype.getElementsByClassName;
   Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;
   Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
   _extends(Element, Node);
-  function Attr() {}
+  function Attr(symbol) {
+    checkSymbol(symbol);
+    this.namespaceURI = null;
+    this.prefix = null;
+    this.ownerElement = null;
+  }
   Attr.prototype.nodeType = ATTRIBUTE_NODE;
   _extends(Attr, Node);
-  function CharacterData() {}
+  function CharacterData(symbol) {
+    checkSymbol(symbol);
+  }
   CharacterData.prototype = {
     data: "",
     substringData: function(offset, count) {
@@ -949,9 +1687,6 @@ var require_dom = __commonJS((exports) => {
     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, "");
     },
@@ -964,7 +1699,9 @@ var require_dom = __commonJS((exports) => {
     }
   };
   _extends(CharacterData, Node);
-  function Text() {}
+  function Text(symbol) {
+    checkSymbol(symbol);
+  }
   Text.prototype = {
     nodeName: "#text",
     nodeType: TEXT_NODE,
@@ -982,45 +1719,73 @@ var require_dom = __commonJS((exports) => {
     }
   };
   _extends(Text, CharacterData);
-  function Comment() {}
+  function Comment(symbol) {
+    checkSymbol(symbol);
+  }
   Comment.prototype = {
     nodeName: "#comment",
     nodeType: COMMENT_NODE
   };
   _extends(Comment, CharacterData);
-  function CDATASection() {}
+  function CDATASection(symbol) {
+    checkSymbol(symbol);
+  }
   CDATASection.prototype = {
     nodeName: "#cdata-section",
     nodeType: CDATA_SECTION_NODE
   };
-  _extends(CDATASection, CharacterData);
-  function DocumentType() {}
+  _extends(CDATASection, Text);
+  function DocumentType(symbol) {
+    checkSymbol(symbol);
+  }
   DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
   _extends(DocumentType, Node);
-  function Notation() {}
+  function Notation(symbol) {
+    checkSymbol(symbol);
+  }
   Notation.prototype.nodeType = NOTATION_NODE;
   _extends(Notation, Node);
-  function Entity() {}
+  function Entity(symbol) {
+    checkSymbol(symbol);
+  }
   Entity.prototype.nodeType = ENTITY_NODE;
   _extends(Entity, Node);
-  function EntityReference() {}
+  function EntityReference(symbol) {
+    checkSymbol(symbol);
+  }
   EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
   _extends(EntityReference, Node);
-  function DocumentFragment() {}
+  function DocumentFragment(symbol) {
+    checkSymbol(symbol);
+  }
   DocumentFragment.prototype.nodeName = "#document-fragment";
   DocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;
   _extends(DocumentFragment, Node);
-  function ProcessingInstruction() {}
+  function ProcessingInstruction(symbol) {
+    checkSymbol(symbol);
+  }
   ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
-  _extends(ProcessingInstruction, Node);
+  _extends(ProcessingInstruction, CharacterData);
   function XMLSerializer() {}
-  XMLSerializer.prototype.serializeToString = function(node, isHtml, nodeFilter) {
-    return nodeSerializeToString.call(node, isHtml, nodeFilter);
+  XMLSerializer.prototype.serializeToString = function(node, options) {
+    return nodeSerializeToString.call(node, options);
   };
   Node.prototype.toString = nodeSerializeToString;
-  function nodeSerializeToString(isHtml, nodeFilter) {
+  function nodeSerializeToString(options) {
+    var opts;
+    if (typeof options === "function") {
+      opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: options };
+    } else if (options != null) {
+      opts = {
+        requireWellFormed: !!options.requireWellFormed,
+        splitCDATASections: options.splitCDATASections !== false,
+        nodeFilter: options.nodeFilter || null
+      };
+    } else {
+      opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: null };
+    }
     var buf = [];
-    var refNode = this.nodeType == 9 && this.documentElement || this;
+    var refNode = this.nodeType === DOCUMENT_NODE && this.documentElement || this;
     var prefix = refNode.prefix;
     var uri = refNode.namespaceURI;
     if (uri && prefix == null) {
@@ -1031,7 +1796,7 @@ var require_dom = __commonJS((exports) => {
         ];
       }
     }
-    serializeToString(this, buf, isHtml, nodeFilter, visibleNamespaces);
+    serializeToString(this, buf, visibleNamespaces, opts);
     return buf.join("");
   }
   function needNamespaceDefine(node, isHTML, visibleNamespaces) {
@@ -1055,237 +1820,293 @@ var require_dom = __commonJS((exports) => {
   function addSerializedAttribute(buf, qualifiedName, value) {
     buf.push(" ", qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
   }
-  function serializeToString(node, buf, isHTML, nodeFilter, visibleNamespaces) {
+  function serializeToString(node, buf, visibleNamespaces, opts) {
     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;
+    var nodeFilter = opts.nodeFilter;
+    var requireWellFormed = opts.requireWellFormed;
+    var splitCDATASections = opts.splitCDATASections;
+    var doc = node.nodeType === DOCUMENT_NODE ? node : node.ownerDocument;
+    var isHTML = doc.type === "html";
+    walkDOM(node, { ns: visibleNamespaces }, {
+      enter: function(n, ctx) {
+        var namespaces = ctx.ns;
+        if (nodeFilter) {
+          n = nodeFilter(n);
+          if (n) {
+            if (typeof n == "string") {
+              buf.push(n);
+              return null;
             }
+          } else {
+            return null;
           }
-          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;
+        }
+        switch (n.nodeType) {
+          case ELEMENT_NODE:
+            var attrs = n.attributes;
+            var len = attrs.length;
+            var nodeName = n.tagName;
+            var prefixedNodeName = nodeName;
+            if (!isHTML && !n.prefix && n.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 = namespaces.length - 1;nsi >= 0; nsi--) {
+                  var nsEntry = namespaces[nsi];
+                  if (nsEntry.prefix === "" && nsEntry.namespace === n.namespaceURI) {
+                    defaultNS = nsEntry.namespace;
+                    break;
+                  }
+                }
+              }
+              if (defaultNS !== n.namespaceURI) {
+                for (var nsi = namespaces.length - 1;nsi >= 0; nsi--) {
+                  var nsEntry = namespaces[nsi];
+                  if (nsEntry.namespace === n.namespaceURI) {
+                    if (nsEntry.prefix) {
+                      prefixedNodeName = nsEntry.prefix + ":" + nodeName;
+                    }
+                    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;
+            buf.push("<", prefixedNodeName);
+            var childNamespaces = namespaces.slice();
+            for (var i = 0;i < len; i++) {
+              var attr = attrs.item(i);
+              if (attr.prefix == "xmlns") {
+                childNamespaces.push({
+                  prefix: attr.localName,
+                  namespace: attr.value
+                });
+              } else if (attr.nodeName == "xmlns") {
+                childNamespaces.push({ prefix: "", namespace: attr.value });
+              }
+            }
+            for (var i = 0;i < len; i++) {
+              var attr = attrs.item(i);
+              if (needNamespaceDefine(attr, isHTML, childNamespaces)) {
+                var attrPrefix = attr.prefix || "";
+                var uri = attr.namespaceURI;
+                addSerializedAttribute(buf, attrPrefix ? "xmlns:" + attrPrefix : "xmlns", uri);
+                childNamespaces.push({ prefix: attrPrefix, namespace: uri });
+              }
+              var filteredAttr = nodeFilter ? nodeFilter(attr) : attr;
+              if (filteredAttr) {
+                if (typeof filteredAttr === "string") {
+                  buf.push(filteredAttr);
+                } else {
+                  addSerializedAttribute(buf, filteredAttr.name, filteredAttr.value);
                 }
-                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());
+            if (nodeName === prefixedNodeName && needNamespaceDefine(n, isHTML, childNamespaces)) {
+              var nodePrefix = n.prefix || "";
+              var uri = n.namespaceURI;
+              addSerializedAttribute(buf, nodePrefix ? "xmlns:" + nodePrefix : "xmlns", uri);
+              childNamespaces.push({ prefix: nodePrefix, namespace: uri });
+            }
+            var canCloseTag = !n.firstChild;
+            if (canCloseTag && (isHTML || n.namespaceURI === NAMESPACE.HTML)) {
+              canCloseTag = isHTMLVoidElement(nodeName);
+            }
+            if (canCloseTag) {
+              buf.push("/>");
+              return null;
+            }
+            buf.push(">");
+            if (isHTML && isHTMLRawTextElement(nodeName)) {
+              var child = n.firstChild;
+              while (child) {
+                if (child.data) {
+                  buf.push(child.data);
+                } else {
+                  serializeToString(child, buf, childNamespaces.slice(), opts);
+                }
+                child = child.nextSibling;
               }
-              child = child.nextSibling;
+              buf.push("</", prefixedNodeName, ">");
+              return null;
             }
-          } else {
-            while (child) {
-              serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
-              child = child.nextSibling;
+            return { ns: childNamespaces, tag: prefixedNodeName };
+          case DOCUMENT_NODE:
+          case DOCUMENT_FRAGMENT_NODE:
+            if (requireWellFormed && n.nodeType === DOCUMENT_NODE && n.documentElement == null) {
+              throw new DOMException("The Document has no documentElement", DOMExceptionName.InvalidStateError);
             }
-          }
-          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 { ns: namespaces };
+          case ATTRIBUTE_NODE:
+            addSerializedAttribute(buf, n.name, n.value);
+            return null;
+          case TEXT_NODE:
+            if (requireWellFormed && g.InvalidChar.test(n.data)) {
+              throw new DOMException("The Text node data contains characters outside the XML Char production", DOMExceptionName.InvalidStateError);
+            }
+            buf.push(n.data.replace(/[<&>]/g, _xmlEncoder));
+            return null;
+          case CDATA_SECTION_NODE:
+            if (requireWellFormed && n.data.indexOf("]]>") !== -1) {
+              throw new DOMException('The CDATASection data contains "]]>"', DOMExceptionName.InvalidStateError);
+            }
+            if (splitCDATASections) {
+              buf.push(g.CDATA_START, n.data.replace(/]]>/g, "]]]]><![CDATA[>"), g.CDATA_END);
+            } else {
+              buf.push(g.CDATA_START, n.data, g.CDATA_END);
+            }
+            return null;
+          case COMMENT_NODE:
+            if (requireWellFormed) {
+              if (g.InvalidChar.test(n.data)) {
+                throw new DOMException("The comment node data contains characters outside the XML Char production", DOMExceptionName.InvalidStateError);
+              }
+              if (n.data.indexOf("--") !== -1 || n.data[n.data.length - 1] === "-") {
+                throw new DOMException('The comment node data contains "--" or ends with "-"', DOMExceptionName.InvalidStateError);
+              }
+            }
+            buf.push(g.COMMENT_START, n.data, g.COMMENT_END);
+            return null;
+          case DOCUMENT_TYPE_NODE:
+            var pubid = n.publicId;
+            var sysid = n.systemId;
+            if (requireWellFormed) {
+              if (pubid && !g.PubidLiteral_match.test(pubid)) {
+                throw new DOMException("DocumentType publicId is not a valid PubidLiteral", DOMExceptionName.InvalidStateError);
+              }
+              if (sysid && sysid !== "." && !g.SystemLiteral_match.test(sysid)) {
+                throw new DOMException("DocumentType systemId is not a valid SystemLiteral", DOMExceptionName.InvalidStateError);
+              }
+              if (n.internalSubset && n.internalSubset.indexOf("]>") !== -1) {
+                throw new DOMException('DocumentType internalSubset contains "]>"', DOMExceptionName.InvalidStateError);
+              }
+            }
+            buf.push(g.DOCTYPE_DECL_START, " ", n.name);
+            if (pubid) {
+              buf.push(" ", g.PUBLIC, " ", pubid);
+              if (sysid && sysid !== ".") {
+                buf.push(" ", sysid);
+              }
+            } else if (sysid && sysid !== ".") {
+              buf.push(" ", g.SYSTEM, " ", sysid);
+            }
+            if (n.internalSubset) {
+              buf.push(" [", n.internalSubset, "]");
+            }
+            buf.push(">");
+            return null;
+          case PROCESSING_INSTRUCTION_NODE:
+            if (requireWellFormed) {
+              if (n.target.indexOf(":") !== -1 || n.target.toLowerCase() === "xml") {
+                throw new DOMException("The ProcessingInstruction target is not well-formed", DOMExceptionName.InvalidStateError);
+              }
+              if (g.InvalidChar.test(n.data)) {
+                throw new DOMException("The ProcessingInstruction data contains characters outside the XML Char production", DOMExceptionName.InvalidStateError);
+              }
+              if (n.data.indexOf("?>") !== -1) {
+                throw new DOMException('The ProcessingInstruction data contains "?>"', DOMExceptionName.InvalidStateError);
+              }
+            }
+            buf.push("<?", n.target, " ", n.data, "?>");
+            return null;
+          case ENTITY_REFERENCE_NODE:
+            buf.push("&", n.nodeName, ";");
+            return null;
+          default:
+            buf.push("??", n.nodeName);
+            return null;
         }
-        return;
-      case ATTRIBUTE_NODE:
-        return addSerializedAttribute(buf, node.name, node.value);
-      case TEXT_NODE:
-        return buf.push(node.data.replace(/[<&>]/g, _xmlEncoder));
-      case CDATA_SECTION_NODE:
-        return buf.push("<![CDATA[", node.data.replace(/]]>/g, "]]]]><![CDATA[>"), "]]>");
-      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(">");
+      },
+      exit: function(n, childCtx) {
+        if (childCtx && childCtx.tag) {
+          buf.push("</", childCtx.tag, ">");
         }
-        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;
+    var destRoot;
+    walkDOM(node, null, {
+      enter: function(srcNode, destParent) {
+        var destNode = srcNode.cloneNode(false);
+        destNode.ownerDocument = doc;
+        destNode.parentNode = null;
+        if (destParent === null) {
+          destRoot = destNode;
+        } else {
+          destParent.appendChild(destNode);
+        }
+        var shouldDeep = srcNode.nodeType === ATTRIBUTE_NODE || deep;
+        return shouldDeep ? destNode : null;
       }
-    }
-    return node2;
+    });
+    return destRoot;
   }
   function cloneNode(doc, node, deep) {
-    var node2 = new node.constructor;
-    for (var n in node) {
-      if (Object.prototype.hasOwnProperty.call(node, n)) {
-        var v = node[n];
-        if (typeof v != "object") {
-          if (v != node2[n]) {
-            node2[n] = v;
+    var destRoot;
+    walkDOM(node, null, {
+      enter: function(srcNode, destParent) {
+        var destNode = new srcNode.constructor(PDC);
+        for (var n in srcNode) {
+          if (hasOwn(srcNode, n)) {
+            var v = srcNode[n];
+            if (typeof v != "object") {
+              if (v != destNode[n]) {
+                destNode[n] = v;
+              }
+            }
           }
         }
+        if (srcNode.childNodes) {
+          destNode.childNodes = new NodeList;
+        }
+        destNode.ownerDocument = doc;
+        var shouldDeep = deep;
+        switch (destNode.nodeType) {
+          case ELEMENT_NODE:
+            var attrs = srcNode.attributes;
+            var attrs2 = destNode.attributes = new NamedNodeMap;
+            var len = attrs.length;
+            attrs2._ownerElement = destNode;
+            for (var i = 0;i < len; i++) {
+              destNode.setAttributeNode(cloneNode(doc, attrs.item(i), true));
+            }
+            break;
+          case ATTRIBUTE_NODE:
+            shouldDeep = true;
+        }
+        if (destParent !== null) {
+          destParent.appendChild(destNode);
+        } else {
+          destRoot = destNode;
+        }
+        return shouldDeep ? destNode : null;
       }
-    }
-    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;
+    });
+    return destRoot;
   }
   function __set__(object, key, value) {
     object[key] = value;
   }
+  function childrenRefresh(node) {
+    var ls = [];
+    var child = node.firstChild;
+    while (child) {
+      if (child.nodeType === ELEMENT_NODE) {
+        ls.push(child);
+      }
+      child = child.nextSibling;
+    }
+    return ls;
+  }
   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);
@@ -1294,7 +2115,22 @@ var require_dom = __commonJS((exports) => {
       });
       Object.defineProperty(Node.prototype, "textContent", {
         get: function() {
-          return getTextContent2(this);
+          if (this.nodeType === ELEMENT_NODE || this.nodeType === DOCUMENT_FRAGMENT_NODE) {
+            var buf = [];
+            walkDOM(this, null, {
+              enter: function(n) {
+                if (n.nodeType === ELEMENT_NODE || n.nodeType === DOCUMENT_FRAGMENT_NODE) {
+                  return true;
+                }
+                if (n.nodeType === PROCESSING_INSTRUCTION_NODE || n.nodeType === COMMENT_NODE) {
+                  return null;
+                }
+                buf.push(n.nodeValue);
+              }
+            });
+            return buf.join("");
+          }
+          return this.nodeValue;
         },
         set: function(data) {
           switch (this.nodeType) {
@@ -1314,22 +2150,50 @@ var require_dom = __commonJS((exports) => {
           }
         }
       });
+      Object.defineProperty(Element.prototype, "children", {
+        get: function() {
+          return new LiveNodeList(this, childrenRefresh);
+        }
+      });
+      Object.defineProperty(Document.prototype, "children", {
+        get: function() {
+          return new LiveNodeList(this, childrenRefresh);
+        }
+      });
+      Object.defineProperty(DocumentFragment.prototype, "children", {
+        get: function() {
+          return new LiveNodeList(this, childrenRefresh);
+        }
+      });
       __set__ = function(object, key, value) {
         object["$$" + key] = value;
       };
     }
   } catch (e) {}
-  var getTextContent;
+  exports._updateLiveList = _updateLiveList;
+  exports.Attr = Attr;
+  exports.CDATASection = CDATASection;
+  exports.CharacterData = CharacterData;
+  exports.Comment = Comment;
+  exports.Document = Document;
+  exports.DocumentFragment = DocumentFragment;
   exports.DocumentType = DocumentType;
-  exports.DOMException = DOMException;
   exports.DOMImplementation = DOMImplementation;
   exports.Element = Element;
+  exports.Entity = Entity;
+  exports.EntityReference = EntityReference;
+  exports.LiveNodeList = LiveNodeList;
+  exports.NamedNodeMap = NamedNodeMap;
   exports.Node = Node;
   exports.NodeList = NodeList;
+  exports.Notation = Notation;
+  exports.Text = Text;
+  exports.ProcessingInstruction = ProcessingInstruction;
+  exports.walkDOM = walkDOM;
   exports.XMLSerializer = XMLSerializer;
 });
 
-// node_modules/.bun/@xmldom+xmldom@0.8.12/node_modules/@xmldom/xmldom/lib/entities.js
+// node_modules/.bun/@xmldom+xmldom@0.9.10/node_modules/@xmldom/xmldom/lib/entities.js
 var require_entities = __commonJS((exports) => {
   var freeze = require_conventions().freeze;
   exports.XML_ENTITIES = freeze({
@@ -3470,12 +4334,18 @@ var require_entities = __commonJS((exports) => {
   exports.entityMap = exports.HTML_ENTITIES;
 });
 
-// node_modules/.bun/@xmldom+xmldom@0.8.12/node_modules/@xmldom/xmldom/lib/sax.js
+// node_modules/.bun/@xmldom+xmldom@0.9.10/node_modules/@xmldom/xmldom/lib/sax.js
 var require_sax = __commonJS((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 conventions = require_conventions();
+  var g = require_grammar();
+  var errors = require_errors();
+  var isHTMLEscapableRawTextElement = conventions.isHTMLEscapableRawTextElement;
+  var isHTMLMimeType = conventions.isHTMLMimeType;
+  var isHTMLRawTextElement = conventions.isHTMLRawTextElement;
+  var hasOwn = conventions.hasOwn;
+  var NAMESPACE = conventions.NAMESPACE;
+  var ParseError = errors.ParseError;
+  var DOMException = errors.DOMException;
   var S_TAG = 0;
   var S_ATTR = 1;
   var S_ATTR_SPACE = 2;
@@ -3484,25 +4354,22 @@ var require_sax = __commonJS((exports) => {
   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 = {});
+      _copy(defaultNSMap, defaultNSMap = Object.create(null));
       parse(source, defaultNSMap, entityMap, domBuilder, this.errorHandler);
       domBuilder.endDocument();
     }
   };
+  var ENTITY_REG = /&#?\w+;?/g;
   function parse(source, defaultNSMapCopy, entityMap, domBuilder, errorHandler) {
+    var isHTML = isHTMLMimeType(domBuilder.mimeType);
+    if (source.indexOf(g.UNICODE_REPLACEMENT_CHARACTER) >= 0) {
+      errorHandler.warning("Unicode replacement character detected, source encoding issues?");
+    }
     function fixedFromCharCode(code) {
       if (code > 65535) {
         code -= 65536;
@@ -3513,11 +4380,21 @@ var require_sax = __commonJS((exports) => {
       }
     }
     function entityReplacer(a2) {
-      var k = a2.slice(1, -1);
-      if (Object.hasOwnProperty.call(entityMap, k)) {
+      var complete = a2[a2.length - 1] === ";" ? a2 : a2 + ";";
+      if (!isHTML && complete !== a2) {
+        errorHandler.error("EntityRef: expecting ;");
+        return a2;
+      }
+      var match = g.Reference.exec(complete);
+      if (!match || match[0].length !== complete.length) {
+        errorHandler.error("entity not matching Reference production: " + a2);
+        return a2;
+      }
+      var k = complete.slice(1, -1);
+      if (hasOwn(entityMap, k)) {
         return entityMap[k];
       } else if (k.charAt(0) === "#") {
-        return fixedFromCharCode(parseInt(k.substr(1).replace("x", "0x")));
+        return fixedFromCharCode(parseInt(k.substring(1).replace("x", "0x")));
       } else {
         errorHandler.error("entity not found:" + a2);
         return a2;
@@ -3525,94 +4402,106 @@ var require_sax = __commonJS((exports) => {
     }
     function appendText(end2) {
       if (end2 > start) {
-        var xt = source.substring(start, end2).replace(/&#?\w+;/g, entityReplacer);
+        var xt = source.substring(start, end2).replace(ENTITY_REG, entityReplacer);
         locator && position(start);
         domBuilder.characters(xt, 0, end2 - start);
         start = end2;
       }
     }
+    var lineStart = 0;
+    var lineEnd = 0;
+    var linePattern = /\r\n?|\n|$/g;
+    var locator = domBuilder.locator;
     function position(p, m) {
       while (p >= lineEnd && (m = linePattern.exec(source))) {
-        lineStart = m.index;
-        lineEnd = lineStart + m[0].length;
+        lineStart = lineEnd;
+        lineEnd = m.index + 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 unclosedTags = [];
     var start = 0;
     while (true) {
       try {
         var tagStart = source.indexOf("<", start);
         if (tagStart < 0) {
-          if (!source.substr(start).match(/^\s*$/)) {
+          if (!isHTML && unclosedTags.length > 0) {
+            return errorHandler.fatalError("unclosed xml tag(s): " + unclosedTags.join(", "));
+          }
+          if (!source.substring(start).match(/^\s*$/)) {
             var doc = domBuilder.doc;
-            var text = doc.createTextNode(source.substr(start));
+            var text = doc.createTextNode(source.substring(start));
+            if (doc.documentElement) {
+              return errorHandler.error("Extra content at the end of the document");
+            }
             doc.appendChild(text);
             domBuilder.currentElement = text;
           }
           return;
         }
         if (tagStart > start) {
+          var fromSource = source.substring(start, tagStart);
+          if (!isHTML && unclosedTags.length === 0) {
+            fromSource = fromSource.replace(new RegExp(g.S_OPT.source, "g"), "");
+            fromSource && errorHandler.error("Unexpected content outside root element: '" + fromSource + "'");
+          }
           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 end = source.indexOf(">", tagStart + 2);
+            var tagNameRaw = source.substring(tagStart + 2, end > 0 ? end : undefined);
+            if (!tagNameRaw) {
+              return errorHandler.fatalError("end tag name missing");
+            }
+            var tagNameMatch = end > 0 && g.reg("^", g.QName_group, g.S_OPT, "$").exec(tagNameRaw);
+            if (!tagNameMatch) {
+              return errorHandler.fatalError('end tag name contains invalid characters: "' + tagNameRaw + '"');
+            }
+            if (!domBuilder.currentElement && !domBuilder.doc.documentElement) {
+              return;
             }
+            var currentTagName = unclosedTags[unclosedTags.length - 1] || domBuilder.currentElement.tagName || domBuilder.doc.documentElement.tagName || "";
+            if (currentTagName !== tagNameMatch[1]) {
+              var tagNameLower = tagNameMatch[1].toLowerCase();
+              if (!isHTML || currentTagName.toLowerCase() !== tagNameLower) {
+                return errorHandler.fatalError('Opening and ending tag mismatch: "' + currentTagName + '" != "' + tagNameRaw + '"');
+              }
+            }
+            var config = parseStack.pop();
+            unclosedTags.pop();
             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) {
-                  if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) {
-                    domBuilder.endPrefixMapping(prefix);
-                  }
+            domBuilder.endElement(config.uri, config.localName, currentTagName);
+            if (localNSMap) {
+              for (var prefix in localNSMap) {
+                if (hasOwn(localNSMap, prefix)) {
+                  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);
+            end = parseProcessingInstruction(source, tagStart, domBuilder, errorHandler);
             break;
           case "!":
             locator && position(tagStart);
-            end = parseDCC(source, tagStart, domBuilder, errorHandler);
+            end = parseDoctypeCommentOrCData(source, tagStart, domBuilder, errorHandler, isHTML);
             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 end = parseElementStartPart(source, tagStart, el, currentNSMap, entityReplacer, errorHandler, isHTML);
             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 (!el.closed) {
+              if (isHTML && conventions.isHTMLVoidElement(el.tagName)) {
+                el.closed = true;
+              } else {
+                unclosedTags.push(el.tagName);
               }
             }
             if (locator && len) {
@@ -3632,7 +4521,7 @@ var require_sax = __commonJS((exports) => {
                 parseStack.push(el);
               }
             }
-            if (NAMESPACE.isHTML(el.uri) && !el.closed) {
+            if (isHTML && !el.closed) {
               end = parseHtmlSpecialContent(source, end, el.tagName, entityReplacer, domBuilder);
             } else {
               end++;
@@ -3641,6 +4530,8 @@ var require_sax = __commonJS((exports) => {
       } catch (e) {
         if (e instanceof ParseError) {
           throw e;
+        } else if (e instanceof DOMException) {
+          throw new ParseError(e.name + ": " + e.message, domBuilder.locator, e);
         }
         errorHandler.error("element parse error: " + e);
         end = -1;
@@ -3657,12 +4548,15 @@ var require_sax = __commonJS((exports) => {
     t.columnNumber = f.columnNumber;
     return t;
   }
-  function parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler) {
+  function parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler, isHTML) {
     function addAttribute(qname, value2, startIndex) {
-      if (el.attributeNames.hasOwnProperty(qname)) {
-        errorHandler.fatalError("Attribute " + qname + " redefined");
+      if (hasOwn(el.attributeNames, qname)) {
+        return errorHandler.fatalError("Attribute " + qname + " redefined");
+      }
+      if (!isHTML && value2.indexOf("<") >= 0) {
+        return errorHandler.fatalError("Unescaped '<' not allowed in attributes values");
       }
-      el.addValue(qname, value2.replace(/[\t\n\r]/g, " ").replace(/&#?\w+;/g, entityReplacer), startIndex);
+      el.addValue(qname, value2.replace(/[\t\n\r]/g, " ").replace(ENTITY_REG, entityReplacer), startIndex);
     }
     var attrName;
     var value;
@@ -3755,14 +4649,16 @@ var require_sax = __commonJS((exports) => {
                 errorHandler.warning('attribute "' + value + '" missed quot(")!');
                 addAttribute(attrName, value, start);
               } else {
-                if (!NAMESPACE.isHTML(currentNSMap[""]) || !value.match(/^(?:disabled|checked|selected)$/i)) {
+                if (!isHTML) {
                   errorHandler.warning('attribute "' + value + '" missed value!! "' + value + '" instead!!');
                 }
                 addAttribute(value, value, start);
               }
               break;
             case S_EQ:
-              throw new Error("attribute value missed!!");
+              if (!isHTML) {
+                return errorHandler.fatalError(`AttValue: ' or " expected`);
+              }
           }
           return p;
         case "\x80":
@@ -3789,8 +4685,7 @@ var require_sax = __commonJS((exports) => {
           } else {
             switch (s) {
               case S_ATTR_SPACE:
-                var tagName = el.tagName;
-                if (!NAMESPACE.isHTML(currentNSMap[""]) || !attrName.match(/^(?:disabled|checked|selected)$/i)) {
+                if (!isHTML) {
                   errorHandler.warning('attribute "' + attrName + '" missed value!! "' + attrName + '" instead2!!');
                 }
                 addAttribute(attrName, attrName, start);
@@ -3836,8 +4731,8 @@ var require_sax = __commonJS((exports) => {
       a.localName = localName;
       if (nsPrefix !== false) {
         if (localNSMap == null) {
-          localNSMap = {};
-          _copy(currentNSMap, currentNSMap = {});
+          localNSMap = Object.create(null);
+          _copy(currentNSMap, currentNSMap = Object.create(null));
         }
         currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
         a.uri = NAMESPACE.XMLNS;
@@ -3847,13 +4742,12 @@ var require_sax = __commonJS((exports) => {
     var i = el.length;
     while (i--) {
       a = el[i];
-      var prefix = a.prefix;
-      if (prefix) {
-        if (prefix === "xml") {
+      if (a.prefix) {
+        if (a.prefix === "xml") {
           a.uri = NAMESPACE.XML;
         }
-        if (prefix !== "xmlns") {
-          a.uri = currentNSMap[prefix || ""];
+        if (a.prefix !== "xmlns") {
+          a.uri = currentNSMap[a.prefix];
         }
       }
     }
@@ -3871,7 +4765,7 @@ var require_sax = __commonJS((exports) => {
       domBuilder.endElement(ns, localName, tagName);
       if (localNSMap) {
         for (prefix in localNSMap) {
-          if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) {
+          if (hasOwn(localNSMap, prefix)) {
             domBuilder.endPrefixMapping(prefix);
           }
         }
@@ -3883,111 +4777,257 @@ var require_sax = __commonJS((exports) => {
     }
   }
   function parseHtmlSpecialContent(source, elStartEnd, tagName, entityReplacer, domBuilder) {
-    if (/^(?:script|textarea)$/i.test(tagName)) {
+    var isEscapableRaw = isHTMLEscapableRawTextElement(tagName);
+    if (isEscapableRaw || isHTMLRawTextElement(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;
+      if (isEscapableRaw) {
+        text = text.replace(ENTITY_REG, 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) {
-      if (Object.prototype.hasOwnProperty.call(source, n)) {
+      if (hasOwn(source, n)) {
         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;
+  function parseUtils(source, start) {
+    var index = start;
+    function char(n) {
+      n = n || 0;
+      return source.charAt(index + n);
+    }
+    function skip(n) {
+      n = n || 1;
+      index += n;
+    }
+    function skipBlanks() {
+      var blanks = 0;
+      while (index < source.length) {
+        var c = char();
+        if (c !== " " && c !== `
+` && c !== "\t" && c !== "\r") {
+          return blanks;
+        }
+        blanks++;
+        skip();
+      }
+      return -1;
+    }
+    function substringFromIndex() {
+      return source.substring(index);
+    }
+    function substringStartsWith(text) {
+      return source.substring(index, index + text.length) === text;
+    }
+    function substringStartsWithCaseInsensitive(text) {
+      return source.substring(index, index + text.length).toUpperCase() === text.toUpperCase();
+    }
+    function getMatch(args) {
+      var expr = g.reg("^", args);
+      var match = expr.exec(substringFromIndex());
+      if (match) {
+        skip(match[0].length);
+        return match[0];
+      }
+      return null;
+    }
+    return {
+      char,
+      getIndex: function() {
+        return index;
+      },
+      getMatch,
+      getSource: function() {
+        return source;
+      },
+      skip,
+      skipBlanks,
+      substringFromIndex,
+      substringStartsWith,
+      substringStartsWithCaseInsensitive
+    };
+  }
+  function parseDoctypeInternalSubset(p, errorHandler) {
+    function parsePI(p2, errorHandler2) {
+      var match = g.PI.exec(p2.substringFromIndex());
+      if (!match) {
+        return errorHandler2.fatalError("processing instruction is not well-formed at position " + p2.getIndex());
+      }
+      if (match[1].toLowerCase() === "xml") {
+        return errorHandler2.fatalError("xml declaration is only allowed at the start of the document, but found at position " + p2.getIndex());
+      }
+      p2.skip(match[0].length);
+      return match[0];
+    }
+    var source = p.getSource();
+    if (p.char() === "[") {
+      p.skip(1);
+      var intSubsetStart = p.getIndex();
+      while (p.getIndex() < source.length) {
+        p.skipBlanks();
+        if (p.char() === "]") {
+          var internalSubset = source.substring(intSubsetStart, p.getIndex());
+          p.skip(1);
+          return internalSubset;
+        }
+        var current = null;
+        if (p.char() === "<" && p.char(1) === "!") {
+          switch (p.char(2)) {
+            case "E":
+              if (p.char(3) === "L") {
+                current = p.getMatch(g.elementdecl);
+              } else if (p.char(3) === "N") {
+                current = p.getMatch(g.EntityDecl);
+              }
+              break;
+            case "A":
+              current = p.getMatch(g.AttlistDecl);
+              break;
+            case "N":
+              current = p.getMatch(g.NotationDecl);
+              break;
+            case "-":
+              current = p.getMatch(g.Comment);
+              break;
           }
+        } else if (p.char() === "<" && p.char(1) === "?") {
+          current = parsePI(p, errorHandler);
+        } else if (p.char() === "%") {
+          current = p.getMatch(g.PEReference);
         } else {
-          return -1;
+          return errorHandler.fatalError("Error detected in Markup declaration");
         }
-      default:
-        if (source.substr(start + 3, 6) == "CDATA[") {
-          var end = source.indexOf("]]>", start + 9);
+        if (!current) {
+          return errorHandler.fatalError("Error in internal subset at position " + p.getIndex());
+        }
+      }
+      return errorHandler.fatalError("doctype internal subset is not well-formed, missing ]");
+    }
+  }
+  function parseDoctypeCommentOrCData(source, start, domBuilder, errorHandler, isHTML) {
+    var p = parseUtils(source, start);
+    switch (isHTML ? p.char(2).toUpperCase() : p.char(2)) {
+      case "-":
+        var comment = p.getMatch(g.Comment);
+        if (comment) {
+          domBuilder.comment(comment, g.COMMENT_START.length, comment.length - g.COMMENT_START.length - g.COMMENT_END.length);
+          return p.getIndex();
+        } else {
+          return errorHandler.fatalError("comment is not well-formed at position " + p.getIndex());
+        }
+      case "[":
+        var cdata = p.getMatch(g.CDSect);
+        if (cdata) {
+          if (!isHTML && !domBuilder.currentElement) {
+            return errorHandler.fatalError("CDATA outside of element");
+          }
           domBuilder.startCDATA();
-          domBuilder.characters(source, start + 9, end - start - 9);
+          domBuilder.characters(cdata, g.CDATA_START.length, cdata.length - g.CDATA_START.length - g.CDATA_END.length);
           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];
-            }
+          return p.getIndex();
+        } else {
+          return errorHandler.fatalError("Invalid CDATA starting at position " + start);
+        }
+      case "D": {
+        if (domBuilder.doc && domBuilder.doc.documentElement) {
+          return errorHandler.fatalError("Doctype not allowed inside or after documentElement at position " + p.getIndex());
+        }
+        if (isHTML ? !p.substringStartsWithCaseInsensitive(g.DOCTYPE_DECL_START) : !p.substringStartsWith(g.DOCTYPE_DECL_START)) {
+          return errorHandler.fatalError("Expected " + g.DOCTYPE_DECL_START + " at position " + p.getIndex());
+        }
+        p.skip(g.DOCTYPE_DECL_START.length);
+        if (p.skipBlanks() < 1) {
+          return errorHandler.fatalError("Expected whitespace after " + g.DOCTYPE_DECL_START + " at position " + p.getIndex());
+        }
+        var doctype = {
+          name: undefined,
+          publicId: undefined,
+          systemId: undefined,
+          internalSubset: undefined
+        };
+        doctype.name = p.getMatch(g.Name);
+        if (!doctype.name)
+          return errorHandler.fatalError("doctype name missing or contains unexpected characters at position " + p.getIndex());
+        if (isHTML && doctype.name.toLowerCase() !== "html") {
+          errorHandler.warning("Unexpected DOCTYPE in HTML document at position " + p.getIndex());
+        }
+        p.skipBlanks();
+        if (p.substringStartsWith(g.PUBLIC) || p.substringStartsWith(g.SYSTEM)) {
+          var match = g.ExternalID_match.exec(p.substringFromIndex());
+          if (!match) {
+            return errorHandler.fatalError("doctype external id is not well-formed at position " + p.getIndex());
+          }
+          if (match.groups.SystemLiteralOnly !== undefined) {
+            doctype.systemId = match.groups.SystemLiteralOnly;
+          } else {
+            doctype.systemId = match.groups.SystemLiteral;
+            doctype.publicId = match.groups.PubidLiteral;
+          }
+          p.skip(match[0].length);
+        } else if (isHTML && p.substringStartsWithCaseInsensitive(g.SYSTEM)) {
+          p.skip(g.SYSTEM.length);
+          if (p.skipBlanks() < 1) {
+            return errorHandler.fatalError("Expected whitespace after " + g.SYSTEM + " at position " + p.getIndex());
+          }
+          doctype.systemId = p.getMatch(g.ABOUT_LEGACY_COMPAT_SystemLiteral);
+          if (!doctype.systemId) {
+            return errorHandler.fatalError("Expected " + g.ABOUT_LEGACY_COMPAT + " in single or double quotes after " + g.SYSTEM + " at position " + p.getIndex());
           }
-          var lastMatch = matchs[len - 1];
-          domBuilder.startDTD(name, pubid, sysid);
-          domBuilder.endDTD();
-          return lastMatch.index + lastMatch[0].length;
         }
+        if (isHTML && doctype.systemId && !g.ABOUT_LEGACY_COMPAT_SystemLiteral.test(doctype.systemId)) {
+          errorHandler.warning("Unexpected doctype.systemId in HTML document at position " + p.getIndex());
+        }
+        if (!isHTML) {
+          p.skipBlanks();
+          doctype.internalSubset = parseDoctypeInternalSubset(p, errorHandler);
+        }
+        p.skipBlanks();
+        if (p.char() !== ">") {
+          return errorHandler.fatalError("doctype not terminated with > at position " + p.getIndex());
+        }
+        p.skip(1);
+        domBuilder.startDTD(doctype.name, doctype.publicId, doctype.systemId, doctype.internalSubset);
+        domBuilder.endDTD();
+        return p.getIndex();
+      }
+      default:
+        return errorHandler.fatalError('Not well-formed XML starting with "<!" at position ' + start);
     }
-    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]*?)$/);
-      if (match) {
-        var len = match[0].length;
-        domBuilder.processingInstruction(match[1], match[2]);
-        return end + 2;
-      } else {
-        return -1;
+  function parseProcessingInstruction(source, start, domBuilder, errorHandler) {
+    var match = source.substring(start).match(g.PI);
+    if (!match) {
+      return errorHandler.fatalError("Invalid processing instruction starting at position " + start);
+    }
+    if (match[1].toLowerCase() === "xml") {
+      if (start > 0) {
+        return errorHandler.fatalError("processing instruction at position " + start + " is an xml declaration which is only at the start of the document");
+      }
+      if (!g.XMLDecl.test(source.substring(start))) {
+        return errorHandler.fatalError("xml declaration is not well-formed");
       }
     }
-    return -1;
+    domBuilder.processingInstruction(match[1], match[2]);
+    return start + match[0].length;
   }
   function ElementAttributes() {
-    this.attributeNames = {};
+    this.attributeNames = Object.create(null);
   }
   ElementAttributes.prototype = {
     setTagName: function(tagName) {
-      if (!tagNamePattern.test(tagName)) {
+      if (!g.QName_exact.test(tagName)) {
         throw new Error("invalid tagName:" + tagName);
       }
       this.tagName = tagName;
     },
     addValue: function(qName, value, offset) {
-      if (!tagNamePattern.test(qName)) {
+      if (!g.QName_exact.test(qName)) {
         throw new Error("invalid attribute:" + qName);
       }
       this.attributeNames[qName] = this.length;
@@ -4010,94 +5050,94 @@ var require_sax = __commonJS((exports) => {
       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;
+  exports.parseUtils = parseUtils;
+  exports.parseDoctypeCommentOrCData = parseDoctypeCommentOrCData;
 });
 
-// node_modules/.bun/@xmldom+xmldom@0.8.12/node_modules/@xmldom/xmldom/lib/dom-parser.js
+// node_modules/.bun/@xmldom+xmldom@0.9.10/node_modules/@xmldom/xmldom/lib/dom-parser.js
 var require_dom_parser = __commonJS((exports) => {
   var conventions = require_conventions();
   var dom = require_dom();
+  var errors = require_errors();
   var entities = require_entities();
   var sax = require_sax();
   var DOMImplementation = dom.DOMImplementation;
+  var hasDefaultHTMLNamespace = conventions.hasDefaultHTMLNamespace;
+  var isHTMLMimeType = conventions.isHTMLMimeType;
+  var isValidMimeType = conventions.isValidMimeType;
+  var MIME_TYPE = conventions.MIME_TYPE;
   var NAMESPACE = conventions.NAMESPACE;
-  var ParseError = sax.ParseError;
+  var ParseError = errors.ParseError;
   var XMLReader = sax.XMLReader;
   function normalizeLineEndings(input) {
     return input.replace(/\r[\n\u0085]/g, `
-`).replace(/[\r\u0085\u2028]/g, `
+`).replace(/[\r\u0085\u2028\u2029]/g, `
 `);
   }
   function DOMParser(options) {
-    this.options = options || { locator: {} };
+    options = options || {};
+    if (options.locator === undefined) {
+      options.locator = true;
+    }
+    this.assign = options.assign || conventions.assign;
+    this.domHandler = options.domHandler || DOMHandler;
+    this.onError = options.onError || options.errorHandler;
+    if (options.errorHandler && typeof options.errorHandler !== "function") {
+      throw new TypeError("errorHandler object is no longer supported, switch to onError!");
+    } else if (options.errorHandler) {
+      options.errorHandler("warning", "The `errorHandler` option has been deprecated, use `onError` instead!", this);
+    }
+    this.normalizeLineEndings = options.normalizeLineEndings || normalizeLineEndings;
+    this.locator = !!options.locator;
+    this.xmlns = this.assign(Object.create(null), options.xmlns);
   }
   DOMParser.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);
+    if (!isValidMimeType(mimeType)) {
+      throw new TypeError('DOMParser.parseFromString: the provided mimeType "' + mimeType + '" is not valid.');
     }
-    sax2.errorHandler = buildErrorHandler(errorHandler, domBuilder, locator);
-    sax2.domBuilder = options.domBuilder || domBuilder;
-    if (isHTML) {
-      defaultNSMap[""] = NAMESPACE.HTML;
+    var defaultNSMap = this.assign(Object.create(null), this.xmlns);
+    var entityMap = entities.XML_ENTITIES;
+    var defaultNamespace = defaultNSMap[""] || null;
+    if (hasDefaultHTMLNamespace(mimeType)) {
+      entityMap = entities.HTML_ENTITIES;
+      defaultNamespace = NAMESPACE.HTML;
+    } else if (mimeType === MIME_TYPE.XML_SVG_IMAGE) {
+      defaultNamespace = NAMESPACE.SVG;
     }
+    defaultNSMap[""] = defaultNamespace;
     defaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;
-    var normalize = options.normalizeLineEndings || normalizeLineEndings;
-    if (source && typeof source === "string") {
-      sax2.parse(normalize(source), defaultNSMap, entityMap);
-    } else {
-      sax2.errorHandler.error("invalid doc source");
+    var domBuilder = new this.domHandler({
+      mimeType,
+      defaultNamespace,
+      onError: this.onError
+    });
+    var locator = this.locator ? {} : undefined;
+    if (this.locator) {
+      domBuilder.setDocumentLocator(locator);
     }
-    return domBuilder.doc;
-  };
-  function buildErrorHandler(errorImpl, domBuilder, locator) {
-    if (!errorImpl) {
-      if (domBuilder instanceof DOMHandler) {
-        return domBuilder;
-      }
-      errorImpl = domBuilder;
+    var sax2 = new XMLReader;
+    sax2.errorHandler = domBuilder;
+    sax2.domBuilder = domBuilder;
+    var isXml = !conventions.isHTMLMimeType(mimeType);
+    if (isXml && typeof source !== "string") {
+      sax2.errorHandler.fatalError("source is not a string");
     }
-    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 + "]\t" + msg + _locator(locator));
-      } || function() {};
+    sax2.parse(this.normalizeLineEndings(String(source)), defaultNSMap, entityMap);
+    if (!domBuilder.doc.documentElement) {
+      sax2.errorHandler.fatalError("missing root element");
     }
-    build("warning");
-    build("error");
-    build("fatalError");
-    return errorHandler;
-  }
-  function DOMHandler() {
+    return domBuilder.doc;
+  };
+  function DOMHandler(options) {
+    var opt = options || {};
+    this.mimeType = opt.mimeType || MIME_TYPE.XML_APPLICATION;
+    this.defaultNamespace = opt.defaultNamespace || null;
     this.cdata = false;
+    this.currentElement = undefined;
+    this.doc = undefined;
+    this.locator = undefined;
+    this.onError = opt.onError;
   }
   function position(locator, node) {
     node.lineNumber = locator.lineNumber;
@@ -4105,10 +5145,8 @@ var require_dom_parser = __commonJS((exports) => {
   }
   DOMHandler.prototype = {
     startDocument: function() {
-      this.doc = new DOMImplementation().createDocument(null, null, null);
-      if (this.locator) {
-        this.doc.documentURI = this.locator.systemId;
-      }
+      var impl = new DOMImplementation;
+      this.doc = isHTMLMimeType(this.mimeType) ? impl.createHTMLDocument(false) : impl.createDocument(this.defaultNamespace, "");
     },
     startElement: function(namespaceURI, localName, qName, attrs) {
       var doc = this.doc;
@@ -4128,9 +5166,7 @@ var require_dom_parser = __commonJS((exports) => {
       }
     },
     endElement: function(namespaceURI, localName, qName) {
-      var current = this.currentElement;
-      var tagName = current.tagName;
-      this.currentElement = current.parentNode;
+      this.currentElement = this.currentElement.parentNode;
     },
     startPrefixMapping: function(prefix, uri) {},
     endPrefixMapping: function(prefix) {},
@@ -4161,9 +5197,10 @@ var require_dom_parser = __commonJS((exports) => {
       this.doc.normalize();
     },
     setDocumentLocator: function(locator) {
-      if (this.locator = locator) {
+      if (locator) {
         locator.lineNumber = 0;
       }
+      this.locator = locator;
     },
     comment: function(chars, start, length) {
       chars = _toString.apply(this, arguments);
@@ -4177,29 +5214,41 @@ var require_dom_parser = __commonJS((exports) => {
     endCDATA: function() {
       this.cdata = false;
     },
-    startDTD: function(name, publicId, systemId) {
+    startDTD: function(name, publicId, systemId, internalSubset) {
       var impl = this.doc.implementation;
       if (impl && impl.createDocumentType) {
-        var dt = impl.createDocumentType(name, publicId, systemId);
+        var dt = impl.createDocumentType(name, publicId, systemId, internalSubset);
         this.locator && position(this.locator, dt);
         appendElement(this, dt);
         this.doc.doctype = dt;
       }
     },
-    warning: function(error) {
-      console.warn("[xmldom warning]\t" + error, _locator(this.locator));
+    reportError: function(level, message) {
+      if (typeof this.onError === "function") {
+        try {
+          this.onError(level, message, this);
+        } catch (e) {
+          throw new ParseError("Reporting " + level + ' "' + message + '" caused ' + e, this.locator);
+        }
+      } else {
+        console.error("[xmldom " + level + "]\t" + message, _locator(this.locator));
+      }
+    },
+    warning: function(message) {
+      this.reportError("warning", message);
     },
-    error: function(error) {
-      console.error("[xmldom error]\t" + error, _locator(this.locator));
+    error: function(message) {
+      this.reportError("error", message);
     },
-    fatalError: function(error) {
-      throw new ParseError(error, this.locator);
+    fatalError: function(message) {
+      this.reportError("fatalError", message);
+      throw new ParseError(message, this.locator);
     }
   };
   function _locator(l) {
     if (l) {
       return `
-@` + (l.systemId || "") + "#[line:" + l.lineNumber + ",col:" + l.columnNumber + "]";
+@#[line:` + l.lineNumber + ",col:" + l.columnNumber + "]";
     }
   }
   function _toString(chars, start, length) {
@@ -4217,27 +5266,69 @@ var require_dom_parser = __commonJS((exports) => {
       return null;
     };
   });
-  function appendElement(hander, node) {
-    if (!hander.currentElement) {
-      hander.doc.appendChild(node);
+  function appendElement(handler, node) {
+    if (!handler.currentElement) {
+      handler.doc.appendChild(node);
     } else {
-      hander.currentElement.appendChild(node);
+      handler.currentElement.appendChild(node);
     }
   }
+  function onErrorStopParsing(level) {
+    if (level === "error")
+      throw "onErrorStopParsing";
+  }
+  function onWarningStopParsing() {
+    throw "onWarningStopParsing";
+  }
   exports.__DOMHandler = DOMHandler;
-  exports.normalizeLineEndings = normalizeLineEndings;
   exports.DOMParser = DOMParser;
+  exports.normalizeLineEndings = normalizeLineEndings;
+  exports.onErrorStopParsing = onErrorStopParsing;
+  exports.onWarningStopParsing = onWarningStopParsing;
 });
 
-// node_modules/.bun/@xmldom+xmldom@0.8.12/node_modules/@xmldom/xmldom/lib/index.js
+// node_modules/.bun/@xmldom+xmldom@0.9.10/node_modules/@xmldom/xmldom/lib/index.js
 var require_lib = __commonJS((exports) => {
+  var conventions = require_conventions();
+  exports.assign = conventions.assign;
+  exports.hasDefaultHTMLNamespace = conventions.hasDefaultHTMLNamespace;
+  exports.isHTMLMimeType = conventions.isHTMLMimeType;
+  exports.isValidMimeType = conventions.isValidMimeType;
+  exports.MIME_TYPE = conventions.MIME_TYPE;
+  exports.NAMESPACE = conventions.NAMESPACE;
+  var errors = require_errors();
+  exports.DOMException = errors.DOMException;
+  exports.DOMExceptionName = errors.DOMExceptionName;
+  exports.ExceptionCode = errors.ExceptionCode;
+  exports.ParseError = errors.ParseError;
   var dom = require_dom();
+  exports.Attr = dom.Attr;
+  exports.CDATASection = dom.CDATASection;
+  exports.CharacterData = dom.CharacterData;
+  exports.Comment = dom.Comment;
+  exports.Document = dom.Document;
+  exports.DocumentFragment = dom.DocumentFragment;
+  exports.DocumentType = dom.DocumentType;
   exports.DOMImplementation = dom.DOMImplementation;
+  exports.Element = dom.Element;
+  exports.Entity = dom.Entity;
+  exports.EntityReference = dom.EntityReference;
+  exports.LiveNodeList = dom.LiveNodeList;
+  exports.NamedNodeMap = dom.NamedNodeMap;
+  exports.Node = dom.Node;
+  exports.NodeList = dom.NodeList;
+  exports.Notation = dom.Notation;
+  exports.ProcessingInstruction = dom.ProcessingInstruction;
+  exports.Text = dom.Text;
   exports.XMLSerializer = dom.XMLSerializer;
-  exports.DOMParser = require_dom_parser().DOMParser;
+  var domParser = require_dom_parser();
+  exports.DOMParser = domParser.DOMParser;
+  exports.normalizeLineEndings = domParser.normalizeLineEndings;
+  exports.onErrorStopParsing = domParser.onErrorStopParsing;
+  exports.onWarningStopParsing = domParser.onWarningStopParsing;
 });
 
-// node_modules/.bun/plist@3.1.0/node_modules/plist/lib/parse.js
+// node_modules/.bun/plist@3.1.1/node_modules/plist/lib/parse.js
 var require_parse = __commonJS((exports) => {
   var { DOMParser } = require_lib();
   exports.parse = parse;
@@ -4260,7 +5351,7 @@ var require_parse = __commonJS((exports) => {
     }
   }
   function parse(xml) {
-    var doc = new DOMParser().parseFromString(xml);
+    var doc = new DOMParser().parseFromString(xml, "text/xml");
     invariant(doc.documentElement.nodeName === "plist", "malformed document. First element should be <plist>");
     var plist = parsePlistXML(doc.documentElement);
     if (plist.length == 1)
@@ -8068,7 +9159,7 @@ var require_lib2 = __commonJS((exports, module) => {
   }).call(exports);
 });
 
-// node_modules/.bun/plist@3.1.0/node_modules/plist/lib/build.js
+// node_modules/.bun/plist@3.1.1/node_modules/plist/lib/build.js
 var require_build = __commonJS((exports) => {
   var base64 = require_base64_js();
   var xmlbuilder = require_lib2();
@@ -8144,7 +9235,7 @@ var require_build = __commonJS((exports) => {
   }
 });
 
-// node_modules/.bun/plist@3.1.0/node_modules/plist/index.js
+// node_modules/.bun/plist@3.1.1/node_modules/plist/index.js
 var require_plist = __commonJS((exports) => {
   var parserFunctions = require_parse();
   Object.keys(parserFunctions).forEach(function(k) {