@loaders.gl/xml 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/{dist.min.js → dist.dev.js}

@@ -1,1934 +1,620 @@
-(() => {
+(function webpackUniversalModuleDefinition(root, factory) {
+  if (typeof exports === 'object' && typeof module === 'object')
+    module.exports = factory();
+  else if (typeof define === 'function' && define.amd) define([], factory);
+        else if (typeof exports === 'object') exports['loader'] = factory();
+  else root['loader'] = factory();})(globalThis, function () {
+"use strict";
+var __exports__ = (() => {
   var __create = Object.create;
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
-  };
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __export = (target, all) => {
-    __markAsModule(target);
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
-  var __reExport = (target, module, desc) => {
-    if (module && typeof module === "object" || typeof module === "function") {
-      for (let key of __getOwnPropNames(module))
-        if (!__hasOwnProp.call(target, key) && key !== "default")
-          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
     }
-    return target;
+    return to;
   };
-  var __toModule = (module) => {
-    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
   };
 
-  // src/sax-ts/sax.ts
-  var DEFAULT_SAX_EVENTS, DEFAULT_SAX_PARSER_OPTIONS, EVENTS, BUFFERS, nameStart, nameBody, entityStart, entityBody, ENTITIES, SAX, SAXParser;
-  var init_sax = __esm({
-    "src/sax-ts/sax.ts"() {
-      DEFAULT_SAX_EVENTS = {
-        ontext: () => {
-        },
-        onprocessinginstruction: () => {
-        },
-        onsgmldeclaration: () => {
-        },
-        ondoctype: () => {
-        },
-        oncomment: () => {
-        },
-        onopentagstart: () => {
-        },
-        onattribute: () => {
-        },
-        onopentag: () => {
-        },
-        onclosetag: () => {
-        },
-        onopencdata: () => {
-        },
-        oncdata: () => {
-        },
-        onclosecdata: () => {
-        },
-        onerror: () => {
-        },
-        onend: () => {
-        },
-        onready: () => {
-        },
-        onscript: () => {
-        },
-        onopennamespace: () => {
-        },
-        onclosenamespace: () => {
+  // ../../node_modules/fast-xml-parser/src/util.js
+  var require_util = __commonJS({
+    "../../node_modules/fast-xml-parser/src/util.js"(exports) {
+      "use strict";
+      var nameStartChar = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
+      var nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+      var nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*";
+      var regexName = new RegExp("^" + nameRegexp + "$");
+      var getAllMatches = function(string, regex) {
+        const matches = [];
+        let match = regex.exec(string);
+        while (match) {
+          const allmatches = [];
+          allmatches.startIndex = regex.lastIndex - match[0].length;
+          const len = match.length;
+          for (let index = 0; index < len; index++) {
+            allmatches.push(match[index]);
+          }
+          matches.push(allmatches);
+          match = regex.exec(string);
         }
+        return matches;
       };
-      DEFAULT_SAX_PARSER_OPTIONS = {
-        ...DEFAULT_SAX_EVENTS,
-        strict: false,
-        MAX_BUFFER_LENGTH: 64 * 1024,
-        lowercase: false,
-        lowercasetags: false,
-        noscript: false,
-        strictEntities: false,
-        xmlns: void 0,
-        position: void 0,
-        trim: void 0,
-        normalize: void 0
+      var isName = function(string) {
+        const match = regexName.exec(string);
+        return !(match === null || typeof match === "undefined");
       };
-      EVENTS = [
-        "text",
-        "processinginstruction",
-        "sgmldeclaration",
-        "doctype",
-        "comment",
-        "opentagstart",
-        "attribute",
-        "opentag",
-        "closetag",
-        "opencdata",
-        "cdata",
-        "closecdata",
-        "error",
-        "end",
-        "ready",
-        "script",
-        "opennamespace",
-        "closenamespace"
-      ];
-      BUFFERS = [
-        "comment",
-        "sgmlDecl",
-        "textNode",
-        "tagName",
-        "doctype",
-        "procInstName",
-        "procInstBody",
-        "entity",
-        "attribName",
-        "attribValue",
-        "cdata",
-        "script"
-      ];
-      nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
-      nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
-      entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
-      entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
-      ENTITIES = {
-        amp: "&",
-        gt: ">",
-        lt: "<",
-        quot: '"',
-        apos: "'",
-        AElig: 198,
-        Aacute: 193,
-        Acirc: 194,
-        Agrave: 192,
-        Aring: 197,
-        Atilde: 195,
-        Auml: 196,
-        Ccedil: 199,
-        ETH: 208,
-        Eacute: 201,
-        Ecirc: 202,
-        Egrave: 200,
-        Euml: 203,
-        Iacute: 205,
-        Icirc: 206,
-        Igrave: 204,
-        Iuml: 207,
-        Ntilde: 209,
-        Oacute: 211,
-        Ocirc: 212,
-        Ograve: 210,
-        Oslash: 216,
-        Otilde: 213,
-        Ouml: 214,
-        THORN: 222,
-        Uacute: 218,
-        Ucirc: 219,
-        Ugrave: 217,
-        Uuml: 220,
-        Yacute: 221,
-        aacute: 225,
-        acirc: 226,
-        aelig: 230,
-        agrave: 224,
-        aring: 229,
-        atilde: 227,
-        auml: 228,
-        ccedil: 231,
-        eacute: 233,
-        ecirc: 234,
-        egrave: 232,
-        eth: 240,
-        euml: 235,
-        iacute: 237,
-        icirc: 238,
-        igrave: 236,
-        iuml: 239,
-        ntilde: 241,
-        oacute: 243,
-        ocirc: 244,
-        ograve: 242,
-        oslash: 248,
-        otilde: 245,
-        ouml: 246,
-        szlig: 223,
-        thorn: 254,
-        uacute: 250,
-        ucirc: 251,
-        ugrave: 249,
-        uuml: 252,
-        yacute: 253,
-        yuml: 255,
-        copy: 169,
-        reg: 174,
-        nbsp: 160,
-        iexcl: 161,
-        cent: 162,
-        pound: 163,
-        curren: 164,
-        yen: 165,
-        brvbar: 166,
-        sect: 167,
-        uml: 168,
-        ordf: 170,
-        laquo: 171,
-        not: 172,
-        shy: 173,
-        macr: 175,
-        deg: 176,
-        plusmn: 177,
-        sup1: 185,
-        sup2: 178,
-        sup3: 179,
-        acute: 180,
-        micro: 181,
-        para: 182,
-        middot: 183,
-        cedil: 184,
-        ordm: 186,
-        raquo: 187,
-        frac14: 188,
-        frac12: 189,
-        frac34: 190,
-        iquest: 191,
-        times: 215,
-        divide: 247,
-        OElig: 338,
-        oelig: 339,
-        Scaron: 352,
-        scaron: 353,
-        Yuml: 376,
-        fnof: 402,
-        circ: 710,
-        tilde: 732,
-        Alpha: 913,
-        Beta: 914,
-        Gamma: 915,
-        Delta: 916,
-        Epsilon: 917,
-        Zeta: 918,
-        Eta: 919,
-        Theta: 920,
-        Iota: 921,
-        Kappa: 922,
-        Lambda: 923,
-        Mu: 924,
-        Nu: 925,
-        Xi: 926,
-        Omicron: 927,
-        Pi: 928,
-        Rho: 929,
-        Sigma: 931,
-        Tau: 932,
-        Upsilon: 933,
-        Phi: 934,
-        Chi: 935,
-        Psi: 936,
-        Omega: 937,
-        alpha: 945,
-        beta: 946,
-        gamma: 947,
-        delta: 948,
-        epsilon: 949,
-        zeta: 950,
-        eta: 951,
-        theta: 952,
-        iota: 953,
-        kappa: 954,
-        lambda: 955,
-        mu: 956,
-        nu: 957,
-        xi: 958,
-        omicron: 959,
-        pi: 960,
-        rho: 961,
-        sigmaf: 962,
-        sigma: 963,
-        tau: 964,
-        upsilon: 965,
-        phi: 966,
-        chi: 967,
-        psi: 968,
-        omega: 969,
-        thetasym: 977,
-        upsih: 978,
-        piv: 982,
-        ensp: 8194,
-        emsp: 8195,
-        thinsp: 8201,
-        zwnj: 8204,
-        zwj: 8205,
-        lrm: 8206,
-        rlm: 8207,
-        ndash: 8211,
-        mdash: 8212,
-        lsquo: 8216,
-        rsquo: 8217,
-        sbquo: 8218,
-        ldquo: 8220,
-        rdquo: 8221,
-        bdquo: 8222,
-        dagger: 8224,
-        Dagger: 8225,
-        bull: 8226,
-        hellip: 8230,
-        permil: 8240,
-        prime: 8242,
-        Prime: 8243,
-        lsaquo: 8249,
-        rsaquo: 8250,
-        oline: 8254,
-        frasl: 8260,
-        euro: 8364,
-        image: 8465,
-        weierp: 8472,
-        real: 8476,
-        trade: 8482,
-        alefsym: 8501,
-        larr: 8592,
-        uarr: 8593,
-        rarr: 8594,
-        darr: 8595,
-        harr: 8596,
-        crarr: 8629,
-        lArr: 8656,
-        uArr: 8657,
-        rArr: 8658,
-        dArr: 8659,
-        hArr: 8660,
-        forall: 8704,
-        part: 8706,
-        exist: 8707,
-        empty: 8709,
-        nabla: 8711,
-        isin: 8712,
-        notin: 8713,
-        ni: 8715,
-        prod: 8719,
-        sum: 8721,
-        minus: 8722,
-        lowast: 8727,
-        radic: 8730,
-        prop: 8733,
-        infin: 8734,
-        ang: 8736,
-        and: 8743,
-        or: 8744,
-        cap: 8745,
-        cup: 8746,
-        int: 8747,
-        there4: 8756,
-        sim: 8764,
-        cong: 8773,
-        asymp: 8776,
-        ne: 8800,
-        equiv: 8801,
-        le: 8804,
-        ge: 8805,
-        sub: 8834,
-        sup: 8835,
-        nsub: 8836,
-        sube: 8838,
-        supe: 8839,
-        oplus: 8853,
-        otimes: 8855,
-        perp: 8869,
-        sdot: 8901,
-        lceil: 8968,
-        rceil: 8969,
-        lfloor: 8970,
-        rfloor: 8971,
-        lang: 9001,
-        rang: 9002,
-        loz: 9674,
-        spades: 9824,
-        clubs: 9827,
-        hearts: 9829,
-        diams: 9830
+      exports.isExist = function(v) {
+        return typeof v !== "undefined";
       };
-      Object.keys(ENTITIES).forEach((key) => {
-        const e = ENTITIES[key];
-        ENTITIES[key] = typeof e === "number" ? String.fromCharCode(e) : e;
-      });
-      SAX = class {
-        constructor() {
-          this.EVENTS = EVENTS;
-          this.ENTITIES = {
-            ...ENTITIES
-          };
-          this.XML_ENTITIES = {
-            amp: "&",
-            gt: ">",
-            lt: "<",
-            quot: '"',
-            apos: "'"
-          };
-          this.S = 0;
-          this.trackPosition = false;
-          this.column = 0;
-          this.line = 0;
-          this.c = "";
-          this.q = "";
-          this.closed = false;
-          this.tags = [];
-          this.looseCase = "";
-          this.closedRoot = false;
-          this.sawRoot = false;
-          this.strict = false;
-          this.noscript = false;
-          this.attribList = [];
-          this.position = 0;
-          this.STATE = {
-            BEGIN: this.S++,
-            BEGIN_WHITESPACE: this.S++,
-            TEXT: this.S++,
-            TEXT_ENTITY: this.S++,
-            OPEN_WAKA: this.S++,
-            SGML_DECL: this.S++,
-            SGML_DECL_QUOTED: this.S++,
-            DOCTYPE: this.S++,
-            DOCTYPE_QUOTED: this.S++,
-            DOCTYPE_DTD: this.S++,
-            DOCTYPE_DTD_QUOTED: this.S++,
-            COMMENT_STARTING: this.S++,
-            COMMENT: this.S++,
-            COMMENT_ENDING: this.S++,
-            COMMENT_ENDED: this.S++,
-            CDATA: this.S++,
-            CDATA_ENDING: this.S++,
-            CDATA_ENDING_2: this.S++,
-            PROC_INST: this.S++,
-            PROC_INST_BODY: this.S++,
-            PROC_INST_ENDING: this.S++,
-            OPEN_TAG: this.S++,
-            OPEN_TAG_SLASH: this.S++,
-            ATTRIB: this.S++,
-            ATTRIB_NAME: this.S++,
-            ATTRIB_NAME_SAW_WHITE: this.S++,
-            ATTRIB_VALUE: this.S++,
-            ATTRIB_VALUE_QUOTED: this.S++,
-            ATTRIB_VALUE_CLOSED: this.S++,
-            ATTRIB_VALUE_UNQUOTED: this.S++,
-            ATTRIB_VALUE_ENTITY_Q: this.S++,
-            ATTRIB_VALUE_ENTITY_U: this.S++,
-            CLOSE_TAG: this.S++,
-            CLOSE_TAG_SAW_WHITE: this.S++,
-            SCRIPT: this.S++,
-            SCRIPT_ENDING: this.S++
-          };
-          this.BUFFERS = BUFFERS;
-          this.CDATA = "[CDATA[";
-          this.DOCTYPE = "DOCTYPE";
-          this.XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
-          this.XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
-          this.rootNS = {
-            xml: this.XML_NAMESPACE,
-            xmlns: this.XMLNS_NAMESPACE
-          };
-          this.textNode = "";
-          this.entity = "";
-          this.cdata = "";
-          this.script = "";
-          this.startTagPosition = 0;
-          this.S = 0;
-          for (const s in this.STATE) {
-            if (this.STATE.hasOwnProperty(s)) {
-              this.STATE[this.STATE[s]] = s;
+      exports.isEmptyObject = function(obj) {
+        return Object.keys(obj).length === 0;
+      };
+      exports.merge = function(target, a, arrayMode) {
+        if (a) {
+          const keys = Object.keys(a);
+          const len = keys.length;
+          for (let i = 0; i < len; i++) {
+            if (arrayMode === "strict") {
+              target[keys[i]] = [a[keys[i]]];
+            } else {
+              target[keys[i]] = a[keys[i]];
             }
           }
-          this.S = this.STATE;
-        }
-        static charAt(chunk, i) {
-          let result = "";
-          if (i < chunk.length) {
-            result = chunk.charAt(i);
-          }
-          return result;
         }
-        static isWhitespace(c) {
-          return c === " " || c === "\n" || c === "\r" || c === "	";
-        }
-        static isQuote(c) {
-          return c === '"' || c === "'";
-        }
-        static isAttribEnd(c) {
-          return c === ">" || SAX.isWhitespace(c);
-        }
-        static isMatch(regex, c) {
-          return regex.test(c);
-        }
-        static notMatch(regex, c) {
-          return !SAX.isMatch(regex, c);
+      };
+      exports.getValue = function(v) {
+        if (exports.isExist(v)) {
+          return v;
+        } else {
+          return "";
         }
-        static qname(name, attribute) {
-          const i = name.indexOf(":");
-          const qualName = i < 0 ? ["", name] : name.split(":");
-          let prefix = qualName[0];
-          let local = qualName[1];
-          if (attribute && name === "xmlns") {
-            prefix = "xmlns";
-            local = "";
-          }
-          return { prefix, local };
+      };
+      exports.isName = isName;
+      exports.getAllMatches = getAllMatches;
+      exports.nameRegexp = nameRegexp;
+    }
+  });
+
+  // ../../node_modules/fast-xml-parser/src/validator.js
+  var require_validator = __commonJS({
+    "../../node_modules/fast-xml-parser/src/validator.js"(exports) {
+      "use strict";
+      var util = require_util();
+      var defaultOptions = {
+        allowBooleanAttributes: false,
+        //A tag can have attributes without any value
+        unpairedTags: []
+      };
+      exports.validate = function(xmlData, options) {
+        options = Object.assign({}, defaultOptions, options);
+        const tags = [];
+        let tagFound = false;
+        let reachedRoot = false;
+        if (xmlData[0] === "\uFEFF") {
+          xmlData = xmlData.substr(1);
         }
-        write(chunk) {
-          if (this.error) {
-            throw this.error;
-          }
-          if (this.closed) {
-            return this.errorFunction("Cannot write after close. Assign an onready handler.");
-          }
-          if (chunk === null) {
-            return this.end();
-          }
-          if (typeof chunk === "object") {
-            chunk = chunk.toString();
-          }
-          let i = 0;
-          let c;
-          while (true) {
-            c = SAX.charAt(chunk, i++);
-            this.c = c;
-            if (!c) {
-              break;
-            }
-            if (this.trackPosition) {
-              this.position++;
-              if (c === "\n") {
-                this.line++;
-                this.column = 0;
-              } else {
-                this.column++;
+        for (let i = 0; i < xmlData.length; i++) {
+          if (xmlData[i] === "<" && xmlData[i + 1] === "?") {
+            i += 2;
+            i = readPI(xmlData, i);
+            if (i.err)
+              return i;
+          } else if (xmlData[i] === "<") {
+            let tagStartPos = i;
+            i++;
+            if (xmlData[i] === "!") {
+              i = readCommentAndCDATA(xmlData, i);
+              continue;
+            } else {
+              let closingTag = false;
+              if (xmlData[i] === "/") {
+                closingTag = true;
+                i++;
               }
-            }
-            switch (this.state) {
-              case this.S.BEGIN:
-                this.state = this.S.BEGIN_WHITESPACE;
-                if (c === "\uFEFF") {
-                  continue;
-                }
-                this.beginWhiteSpace(c);
-                continue;
-              case this.S.BEGIN_WHITESPACE:
-                this.beginWhiteSpace(c);
-                continue;
-              case this.S.TEXT:
-                if (this.sawRoot && !this.closedRoot) {
-                  const starti = i - 1;
-                  while (c && c !== "<" && c !== "&") {
-                    c = SAX.charAt(chunk, i++);
-                    if (c && this.trackPosition) {
-                      this.position++;
-                      if (c === "\n") {
-                        this.line++;
-                        this.column = 0;
-                      } else {
-                        this.column++;
-                      }
-                    }
-                  }
-                  this.textNode += chunk.substring(starti, i - 1);
-                }
-                if (c === "<" && !(this.sawRoot && this.closedRoot && !this.strict)) {
-                  this.state = this.S.OPEN_WAKA;
-                  this.startTagPosition = this.position;
-                } else {
-                  if (!SAX.isWhitespace(c) && (!this.sawRoot || this.closedRoot)) {
-                    this.strictFail("Text data outside of root node.");
-                  }
-                  if (c === "&") {
-                    this.state = this.S.TEXT_ENTITY;
-                  } else {
-                    this.textNode += c;
-                  }
-                }
-                continue;
-              case this.S.SCRIPT:
-                if (c === "<") {
-                  this.state = this.S.SCRIPT_ENDING;
-                } else {
-                  this.script += c;
-                }
-                continue;
-              case this.S.SCRIPT_ENDING:
-                if (c === "/") {
-                  this.state = this.S.CLOSE_TAG;
-                } else {
-                  this.script += `<${c}`;
-                  this.state = this.S.SCRIPT;
-                }
-                continue;
-              case this.S.OPEN_WAKA:
-                if (c === "!") {
-                  this.state = this.S.SGML_DECL;
-                  this.sgmlDecl = "";
-                } else if (SAX.isWhitespace(c)) {
-                } else if (SAX.isMatch(nameStart, c)) {
-                  this.state = this.S.OPEN_TAG;
-                  this.tagName = c;
-                } else if (c === "/") {
-                  this.state = this.S.CLOSE_TAG;
-                  this.tagName = "";
-                } else if (c === "?") {
-                  this.state = this.S.PROC_INST;
-                  this.procInstName = this.procInstBody = "";
-                } else {
-                  this.strictFail("Unencoded <");
-                  if (this.startTagPosition + 1 < this.position) {
-                    const pad = this.position - this.startTagPosition;
-                    c = new Array(pad).join(" ") + c;
-                  }
-                  this.textNode += `<${c}`;
-                  this.state = this.S.TEXT;
-                }
-                continue;
-              case this.S.SGML_DECL:
-                if ((this.sgmlDecl + c).toUpperCase() === this.CDATA) {
-                  this.emitNode("onopencdata");
-                  this.state = this.S.CDATA;
-                  this.sgmlDecl = "";
-                  this.cdata = "";
-                } else if (this.sgmlDecl + c === "--") {
-                  this.state = this.S.COMMENT;
-                  this.comment = "";
-                  this.sgmlDecl = "";
-                } else if ((this.sgmlDecl + c).toUpperCase() === this.DOCTYPE) {
-                  this.state = this.S.DOCTYPE;
-                  if (this.doctype || this.sawRoot) {
-                    this.strictFail("Inappropriately located doctype declaration");
-                  }
-                  this.doctype = "";
-                  this.sgmlDecl = "";
-                } else if (c === ">") {
-                  this.emitNode("onsgmldeclaration", this.sgmlDecl);
-                  this.sgmlDecl = "";
-                  this.state = this.S.TEXT;
-                } else if (SAX.isQuote(c)) {
-                  this.state = this.S.SGML_DECL_QUOTED;
-                  this.sgmlDecl += c;
+              let tagName = "";
+              for (; i < xmlData.length && xmlData[i] !== ">" && xmlData[i] !== " " && xmlData[i] !== "	" && xmlData[i] !== "\n" && xmlData[i] !== "\r"; i++) {
+                tagName += xmlData[i];
+              }
+              tagName = tagName.trim();
+              if (tagName[tagName.length - 1] === "/") {
+                tagName = tagName.substring(0, tagName.length - 1);
+                i--;
+              }
+              if (!validateTagName(tagName)) {
+                let msg;
+                if (tagName.trim().length === 0) {
+                  msg = "Invalid space after '<'.";
                 } else {
-                  this.sgmlDecl += c;
-                }
-                continue;
-              case this.S.SGML_DECL_QUOTED:
-                if (c === this.q) {
-                  this.state = this.S.SGML_DECL;
-                  this.q = "";
+                  msg = "Tag '" + tagName + "' is an invalid name.";
                 }
-                this.sgmlDecl += c;
-                continue;
-              case this.S.DOCTYPE:
-                if (c === ">") {
-                  this.state = this.S.TEXT;
-                  this.emitNode("ondoctype", this.doctype);
-                  this.doctype = true;
+                return getErrorObject("InvalidTag", msg, getLineNumberForPosition(xmlData, i));
+              }
+              const result = readAttributeStr(xmlData, i);
+              if (result === false) {
+                return getErrorObject("InvalidAttr", "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i));
+              }
+              let attrStr = result.value;
+              i = result.index;
+              if (attrStr[attrStr.length - 1] === "/") {
+                const attrStrStart = i - attrStr.length;
+                attrStr = attrStr.substring(0, attrStr.length - 1);
+                const isValid = validateAttributeString(attrStr, options);
+                if (isValid === true) {
+                  tagFound = true;
                 } else {
-                  this.doctype += c;
-                  if (c === "[") {
-                    this.state = this.S.DOCTYPE_DTD;
-                  } else if (SAX.isQuote(c)) {
-                    this.state = this.S.DOCTYPE_QUOTED;
-                    this.q = c;
-                  }
-                }
-                continue;
-              case this.S.DOCTYPE_QUOTED:
-                this.doctype += c;
-                if (c === this.q) {
-                  this.q = "";
-                  this.state = this.S.DOCTYPE;
-                }
-                continue;
-              case this.S.DOCTYPE_DTD:
-                this.doctype += c;
-                if (c === "]") {
-                  this.state = this.S.DOCTYPE;
-                } else if (SAX.isQuote(c)) {
-                  this.state = this.S.DOCTYPE_DTD_QUOTED;
-                  this.q = c;
-                }
-                continue;
-              case this.S.DOCTYPE_DTD_QUOTED:
-                this.doctype += c;
-                if (c === this.q) {
-                  this.state = this.S.DOCTYPE_DTD;
-                  this.q = "";
+                  return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));
                 }
-                continue;
-              case this.S.COMMENT:
-                if (c === "-") {
-                  this.state = this.S.COMMENT_ENDING;
+              } else if (closingTag) {
+                if (!result.tagClosed) {
+                  return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
+                } else if (attrStr.trim().length > 0) {
+                  return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
                 } else {
-                  this.comment += c;
-                }
-                continue;
-              case this.S.COMMENT_ENDING:
-                if (c === "-") {
-                  this.state = this.S.COMMENT_ENDED;
-                  this.comment = this.textApplyOptions(this.comment);
-                  if (this.comment) {
-                    this.emitNode("oncomment", this.comment);
+                  const otg = tags.pop();
+                  if (tagName !== otg.tagName) {
+                    let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
+                    return getErrorObject("InvalidTag", "Expected closing tag '" + otg.tagName + "' (opened in line " + openPos.line + ", col " + openPos.col + ") instead of closing tag '" + tagName + "'.", getLineNumberForPosition(xmlData, tagStartPos));
                   }
-                  this.comment = "";
-                } else {
-                  this.comment += `-${c}`;
-                  this.state = this.S.COMMENT;
-                }
-                continue;
-              case this.S.COMMENT_ENDED:
-                if (c !== ">") {
-                  this.strictFail("Malformed comment");
-                  this.comment += `--${c}`;
-                  this.state = this.S.COMMENT;
-                } else {
-                  this.state = this.S.TEXT;
-                }
-                continue;
-              case this.S.CDATA:
-                if (c === "]") {
-                  this.state = this.S.CDATA_ENDING;
-                } else {
-                  this.cdata += c;
-                }
-                continue;
-              case this.S.CDATA_ENDING:
-                if (c === "]") {
-                  this.state = this.S.CDATA_ENDING_2;
-                } else {
-                  this.cdata += `]${c}`;
-                  this.state = this.S.CDATA;
-                }
-                continue;
-              case this.S.CDATA_ENDING_2:
-                if (c === ">") {
-                  if (this.cdata) {
-                    this.emitNode("oncdata", this.cdata);
+                  if (tags.length == 0) {
+                    reachedRoot = true;
                   }
-                  this.emitNode("onclosecdata");
-                  this.cdata = "";
-                  this.state = this.S.TEXT;
-                } else if (c === "]") {
-                  this.cdata += "]";
-                } else {
-                  this.cdata += `]]${c}`;
-                  this.state = this.S.CDATA;
                 }
-                continue;
-              case this.S.PROC_INST:
-                if (c === "?") {
-                  this.state = this.S.PROC_INST_ENDING;
-                } else if (SAX.isWhitespace(c)) {
-                  this.state = this.S.PROC_INST_BODY;
-                } else {
-                  this.procInstName += c;
+              } else {
+                const isValid = validateAttributeString(attrStr, options);
+                if (isValid !== true) {
+                  return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
                 }
-                continue;
-              case this.S.PROC_INST_BODY:
-                if (!this.procInstBody && SAX.isWhitespace(c)) {
-                  continue;
-                } else if (c === "?") {
-                  this.state = this.S.PROC_INST_ENDING;
+                if (reachedRoot === true) {
+                  return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(xmlData, i));
+                } else if (options.unpairedTags.indexOf(tagName) !== -1) {
                 } else {
-                  this.procInstBody += c;
-                }
-                continue;
-              case this.S.PROC_INST_ENDING:
-                if (c === ">") {
-                  this.emitNode("onprocessinginstruction", {
-                    name: this.procInstName,
-                    body: this.procInstBody
+                  tags.push({
+                    tagName,
+                    tagStartPos
                   });
-                  this.procInstName = this.procInstBody = "";
-                  this.state = this.S.TEXT;
-                } else {
-                  this.procInstBody += `?${c}`;
-                  this.state = this.S.PROC_INST_BODY;
                 }
-                continue;
-              case this.S.OPEN_TAG:
-                if (SAX.isMatch(nameBody, c)) {
-                  this.tagName += c;
-                } else {
-                  this.newTag();
-                  if (c === ">") {
-                    this.openTag();
-                  } else if (c === "/") {
-                    this.state = this.S.OPEN_TAG_SLASH;
+                tagFound = true;
+              }
+              for (i++; i < xmlData.length; i++) {
+                if (xmlData[i] === "<") {
+                  if (xmlData[i + 1] === "!") {
+                    i++;
+                    i = readCommentAndCDATA(xmlData, i);
+                    continue;
+                  } else if (xmlData[i + 1] === "?") {
+                    i = readPI(xmlData, ++i);
+                    if (i.err)
+                      return i;
                   } else {
-                    if (!SAX.isWhitespace(c)) {
-                      this.strictFail("Invalid character in tag name");
-                    }
-                    this.state = this.S.ATTRIB;
+                    break;
                   }
-                }
-                continue;
-              case this.S.OPEN_TAG_SLASH:
-                if (c === ">") {
-                  this.openTag(true);
-                  this.closeTag();
-                } else {
-                  this.strictFail("Forward-slash in opening tag not followed by >");
-                  this.state = this.S.ATTRIB;
-                }
-                continue;
-              case this.S.ATTRIB:
-                if (SAX.isWhitespace(c)) {
-                  continue;
-                } else if (c === ">") {
-                  this.openTag();
-                } else if (c === "/") {
-                  this.state = this.S.OPEN_TAG_SLASH;
-                } else if (SAX.isMatch(nameStart, c)) {
-                  this.attribName = c;
-                  this.attribValue = "";
-                  this.state = this.S.ATTRIB_NAME;
+                } else if (xmlData[i] === "&") {
+                  const afterAmp = validateAmpersand(xmlData, i);
+                  if (afterAmp == -1)
+                    return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
+                  i = afterAmp;
                 } else {
-                  this.strictFail("Invalid attribute name");
+                  if (reachedRoot === true && !isWhiteSpace(xmlData[i])) {
+                    return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(xmlData, i));
+                  }
                 }
-                continue;
-              case this.S.ATTRIB_NAME:
-                if (c === "=") {
-                  this.state = this.S.ATTRIB_VALUE;
-                } else if (c === ">") {
-                  this.strictFail("Attribute without value");
-                  this.attribValue = this.attribName;
-                  this.attrib();
-                  this.openTag();
-                } else if (SAX.isWhitespace(c)) {
-                  this.state = this.S.ATTRIB_NAME_SAW_WHITE;
-                } else if (SAX.isMatch(nameBody, c)) {
-                  this.attribName += c;
-                } else {
-                  this.strictFail("Invalid attribute name");
-                }
-                continue;
-              case this.S.ATTRIB_NAME_SAW_WHITE:
-                if (c === "=") {
-                  this.state = this.S.ATTRIB_VALUE;
-                } else if (SAX.isWhitespace(c)) {
-                  continue;
-                } else {
-                  this.strictFail("Attribute without value");
-                  this.tag.attributes[this.attribName] = "";
-                  this.attribValue = "";
-                  this.emitNode("onattribute", {
-                    name: this.attribName,
-                    value: ""
-                  });
-                  this.attribName = "";
-                  if (c === ">") {
-                    this.openTag();
-                  } else if (SAX.isMatch(nameStart, c)) {
-                    this.attribName = c;
-                    this.state = this.S.ATTRIB_NAME;
-                  } else {
-                    this.strictFail("Invalid attribute name");
-                    this.state = this.S.ATTRIB;
-                  }
-                }
-                continue;
-              case this.S.ATTRIB_VALUE:
-                if (SAX.isWhitespace(c)) {
-                  continue;
-                } else if (SAX.isQuote(c)) {
-                  this.q = c;
-                  this.state = this.S.ATTRIB_VALUE_QUOTED;
-                } else {
-                  this.strictFail("Unquoted attribute value");
-                  this.state = this.S.ATTRIB_VALUE_UNQUOTED;
-                  this.attribValue = c;
-                }
-                continue;
-              case this.S.ATTRIB_VALUE_QUOTED:
-                if (c !== this.q) {
-                  if (c === "&") {
-                    this.state = this.S.ATTRIB_VALUE_ENTITY_Q;
-                  } else {
-                    this.attribValue += c;
-                  }
-                  continue;
-                }
-                this.attrib();
-                this.q = "";
-                this.state = this.S.ATTRIB_VALUE_CLOSED;
-                continue;
-              case this.S.ATTRIB_VALUE_CLOSED:
-                if (SAX.isWhitespace(c)) {
-                  this.state = this.S.ATTRIB;
-                } else if (c === ">") {
-                  this.openTag();
-                } else if (c === "/") {
-                  this.state = this.S.OPEN_TAG_SLASH;
-                } else if (SAX.isMatch(nameStart, c)) {
-                  this.strictFail("No whitespace between attributes");
-                  this.attribName = c;
-                  this.attribValue = "";
-                  this.state = this.S.ATTRIB_NAME;
-                } else {
-                  this.strictFail("Invalid attribute name");
-                }
-                continue;
-              case this.S.ATTRIB_VALUE_UNQUOTED:
-                if (!SAX.isAttribEnd(c)) {
-                  if (c === "&") {
-                    this.state = this.S.ATTRIB_VALUE_ENTITY_U;
-                  } else {
-                    this.attribValue += c;
-                  }
-                  continue;
-                }
-                this.attrib();
-                if (c === ">") {
-                  this.openTag();
-                } else {
-                  this.state = this.S.ATTRIB;
-                }
-                continue;
-              case this.S.CLOSE_TAG:
-                if (!this.tagName) {
-                  if (SAX.isWhitespace(c)) {
-                    continue;
-                  } else if (SAX.notMatch(nameStart, c)) {
-                    if (this.script) {
-                      this.script += `</${c}`;
-                      this.state = this.S.SCRIPT;
-                    } else {
-                      this.strictFail("Invalid tagname in closing tag.");
-                    }
-                  } else {
-                    this.tagName = c;
-                  }
-                } else if (c === ">") {
-                  this.closeTag();
-                } else if (SAX.isMatch(nameBody, c)) {
-                  this.tagName += c;
-                } else if (this.script) {
-                  this.script += `</${this.tagName}`;
-                  this.tagName = "";
-                  this.state = this.S.SCRIPT;
-                } else {
-                  if (!SAX.isWhitespace(c)) {
-                    this.strictFail("Invalid tagname in closing tag");
-                  }
-                  this.state = this.S.CLOSE_TAG_SAW_WHITE;
-                }
-                continue;
-              case this.S.CLOSE_TAG_SAW_WHITE:
-                if (SAX.isWhitespace(c)) {
-                  continue;
-                }
-                if (c === ">") {
-                  this.closeTag();
-                } else {
-                  this.strictFail("Invalid characters in closing tag");
-                }
-                continue;
-              case this.S.TEXT_ENTITY:
-              case this.S.ATTRIB_VALUE_ENTITY_Q:
-              case this.S.ATTRIB_VALUE_ENTITY_U:
-                let returnState;
-                let buffer;
-                switch (this.state) {
-                  case this.S.TEXT_ENTITY:
-                    returnState = this.S.TEXT;
-                    buffer = "textNode";
-                    break;
-                  case this.S.ATTRIB_VALUE_ENTITY_Q:
-                    returnState = this.S.ATTRIB_VALUE_QUOTED;
-                    buffer = "attribValue";
-                    break;
-                  case this.S.ATTRIB_VALUE_ENTITY_U:
-                    returnState = this.S.ATTRIB_VALUE_UNQUOTED;
-                    buffer = "attribValue";
-                    break;
-                  default:
-                    throw new Error(`Unknown state: ${this.state}`);
-                }
-                if (c === ";") {
-                  this[buffer] += this.parseEntity();
-                  this.entity = "";
-                  this.state = returnState;
-                } else if (SAX.isMatch(this.entity.length ? entityBody : entityStart, c)) {
-                  this.entity += c;
-                } else {
-                  this.strictFail("Invalid character in entity name");
-                  this[buffer] += `&${this.entity}${c}`;
-                  this.entity = "";
-                  this.state = returnState;
-                }
-                continue;
-              default:
-                throw new Error(`Unknown state: ${this.state}`);
-            }
-          }
-          if (this.position >= this.bufferCheckPosition) {
-            this.checkBufferLength();
-          }
-          return this;
-        }
-        emit(event, data) {
-          if (this.events.hasOwnProperty(event)) {
-            const eventName = event.replace(/^on/, "");
-            this.events[event](data, eventName, this);
-          }
-        }
-        clearBuffers() {
-          for (let i = 0, l = this.BUFFERS.length; i < l; i++) {
-            this[this[i]] = "";
-          }
-        }
-        flushBuffers() {
-          this.closeText();
-          if (this.cdata !== "") {
-            this.emitNode("oncdata", this.cdata);
-            this.cdata = "";
-          }
-          if (this.script !== "") {
-            this.emitNode("onscript", this.script);
-            this.script = "";
-          }
-        }
-        end() {
-          if (this.sawRoot && !this.closedRoot)
-            this.strictFail("Unclosed root tag");
-          if (this.state !== this.S.BEGIN && this.state !== this.S.BEGIN_WHITESPACE && this.state !== this.S.TEXT) {
-            this.errorFunction("Unexpected end");
-          }
-          this.closeText();
-          this.c = "";
-          this.closed = true;
-          this.emit("onend");
-          return new SAXParser(this.opt);
-        }
-        errorFunction(er) {
-          this.closeText();
-          if (this.trackPosition) {
-            er += `
-Line: ${this.line}
-Column: ${this.column}
-Char: ${this.c}`;
-          }
-          const error = new Error(er);
-          this.error = error;
-          this.emit("onerror", error);
-          return this;
-        }
-        attrib() {
-          if (!this.strict) {
-            this.attribName = this.attribName[this.looseCase]();
-          }
-          if (this.attribList.indexOf(this.attribName) !== -1 || this.tag.attributes.hasOwnProperty(this.attribName)) {
-            this.attribName = this.attribValue = "";
-            return;
-          }
-          if (this.opt.xmlns) {
-            const qn = SAX.qname(this.attribName, true);
-            const prefix = qn.prefix;
-            const local = qn.local;
-            if (prefix === "xmlns") {
-              if (local === "xml" && this.attribValue !== this.XML_NAMESPACE) {
-                this.strictFail(`xml: prefix must be bound to ${this.XML_NAMESPACE}
-Actual: ${this.attribValue}`);
-              } else if (local === "xmlns" && this.attribValue !== this.XMLNS_NAMESPACE) {
-                this.strictFail(`xmlns: prefix must be bound to ${this.XMLNS_NAMESPACE}
-Actual: ${this.attribValue}`);
-              } else {
-                const tag = this.tag;
-                const parent = this.tags[this.tags.length - 1] || this;
-                if (tag.ns === parent.ns) {
-                  tag.ns = Object.create(parent.ns);
-                }
-                tag.ns[local] = this.attribValue;
+              }
+              if (xmlData[i] === "<") {
+                i--;
               }
             }
-            this.attribList.push([this.attribName, this.attribValue]);
           } else {
-            this.tag.attributes[this.attribName] = this.attribValue;
-            this.emitNode("onattribute", {
-              name: this.attribName,
-              value: this.attribValue
-            });
-          }
-          this.attribName = this.attribValue = "";
-        }
-        newTag() {
-          if (!this.strict)
-            this.tagName = this.tagName[this.looseCase]();
-          const parent = this.tags[this.tags.length - 1] || this;
-          const tag = this.tag = { name: this.tagName, attributes: {} };
-          if (this.opt.xmlns) {
-            tag.ns = parent.ns;
-          }
-          this.attribList.length = 0;
-          this.emitNode("onopentagstart", tag);
-        }
-        parseEntity() {
-          let entity = this.entity;
-          const entityLC = entity.toLowerCase();
-          let num = NaN;
-          let numStr = "";
-          if (this.ENTITIES[entity]) {
-            return this.ENTITIES[entity];
-          }
-          if (this.ENTITIES[entityLC]) {
-            return this.ENTITIES[entityLC];
-          }
-          entity = entityLC;
-          if (entity.charAt(0) === "#") {
-            if (entity.charAt(1) === "x") {
-              entity = entity.slice(2);
-              num = parseInt(entity, 16);
-              numStr = num.toString(16);
-            } else {
-              entity = entity.slice(1);
-              num = parseInt(entity, 10);
-              numStr = num.toString(10);
+            if (isWhiteSpace(xmlData[i])) {
+              continue;
             }
-          }
-          entity = entity.replace(/^0+/, "");
-          if (isNaN(num) || numStr.toLowerCase() !== entity) {
-            this.strictFail("Invalid character entity");
-            return `&${this.entity};`;
-          }
-          return String.fromCodePoint(num);
-        }
-        beginWhiteSpace(c) {
-          if (c === "<") {
-            this.state = this.S.OPEN_WAKA;
-            this.startTagPosition = this.position;
-          } else if (!SAX.isWhitespace(c)) {
-            this.strictFail("Non-whitespace before first tag.");
-            this.textNode = c;
-            this.state = this.S.TEXT;
-          } else {
+            return getErrorObject("InvalidChar", "char '" + xmlData[i] + "' is not expected.", getLineNumberForPosition(xmlData, i));
           }
         }
-        strictFail(message) {
-          if (typeof this !== "object" || !(this instanceof SAXParser)) {
-            throw new Error("bad call to strictFail");
-          }
-          if (this.strict) {
-            this.errorFunction(message);
-          }
+        if (!tagFound) {
+          return getErrorObject("InvalidXml", "Start tag expected.", 1);
+        } else if (tags.length == 1) {
+          return getErrorObject("InvalidTag", "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
+        } else if (tags.length > 0) {
+          return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t) => t.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", {
+            line: 1,
+            col: 1
+          });
         }
-        textApplyOptions(text) {
-          if (this.opt.trim)
-            text = text.trim();
-          if (this.opt.normalize)
-            text = text.replace(/\s+/g, " ");
-          return text;
-        }
-        emitNode(nodeType, data) {
-          if (this.textNode)
-            this.closeText();
-          this.emit(nodeType, data);
-        }
-        closeText() {
-          this.textNode = this.textApplyOptions(this.textNode);
-          if (this.textNode !== void 0 && this.textNode !== "" && this.textNode !== "undefined") {
-            this.emit("ontext", this.textNode);
-          }
-          this.textNode = "";
-        }
-        checkBufferLength() {
-          const maxAllowed = Math.max(this.opt.MAX_BUFFER_LENGTH, 10);
-          let maxActual = 0;
-          for (let i = 0, l = this.BUFFERS.length; i < l; i++) {
-            const len = this[this.BUFFERS[i]]?.length || 0;
-            if (len > maxAllowed) {
-              switch (this.BUFFERS[i]) {
-                case "textNode":
-                  this.closeText();
-                  break;
-                case "cdata":
-                  this.emitNode("oncdata", this.cdata);
-                  this.cdata = "";
-                  break;
-                case "script":
-                  this.emitNode("onscript", this.script);
-                  this.script = "";
-                  break;
-                default:
-                  this.errorFunction(`Max buffer length exceeded: ${this.BUFFERS[i]}`);
-              }
+        return true;
+      };
+      function isWhiteSpace(char) {
+        return char === " " || char === "	" || char === "\n" || char === "\r";
+      }
+      function readPI(xmlData, i) {
+        const start = i;
+        for (; i < xmlData.length; i++) {
+          if (xmlData[i] == "?" || xmlData[i] == " ") {
+            const tagname = xmlData.substr(start, i - start);
+            if (i > 5 && tagname === "xml") {
+              return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(xmlData, i));
+            } else if (xmlData[i] == "?" && xmlData[i + 1] == ">") {
+              i++;
+              break;
+            } else {
+              continue;
             }
-            maxActual = Math.max(maxActual, len);
           }
-          const m = this.opt.MAX_BUFFER_LENGTH - maxActual;
-          this.bufferCheckPosition = m + this.position;
         }
-        openTag(selfClosing) {
-          if (this.opt.xmlns) {
-            const tag = this.tag;
-            const qn = SAX.qname(this.tagName);
-            tag.prefix = qn.prefix;
-            tag.local = qn.local;
-            tag.uri = tag.ns[qn.prefix] || "";
-            if (tag.prefix && !tag.uri) {
-              this.strictFail(`Unbound namespace prefix: ${JSON.stringify(this.tagName)}`);
-              tag.uri = qn.prefix;
-            }
-            const parent = this.tags[this.tags.length - 1] || this;
-            if (tag.ns && parent.ns !== tag.ns) {
-              const that = this;
-              Object.keys(tag.ns).forEach((p) => {
-                that.emitNode("onopennamespace", {
-                  prefix: p,
-                  uri: tag.ns[p]
-                });
-              });
-            }
-            for (let i = 0, l = this.attribList.length; i < l; i++) {
-              const nv = this.attribList[i];
-              const name = nv[0];
-              const value = nv[1];
-              const qualName = SAX.qname(name, true);
-              const prefix = qualName.prefix;
-              const local = qualName.local;
-              const uri = prefix === "" ? "" : tag.ns[prefix] || "";
-              const a = {
-                name,
-                value,
-                prefix,
-                local,
-                uri
-              };
-              if (prefix && prefix !== "xmlns" && !uri) {
-                this.strictFail(`Unbound namespace prefix: ${JSON.stringify(prefix)}`);
-                a.uri = prefix;
-              }
-              this.tag.attributes[name] = a;
-              this.emitNode("onattribute", a);
-            }
-            this.attribList.length = 0;
-          }
-          this.tag.isSelfClosing = Boolean(selfClosing);
-          this.sawRoot = true;
-          this.tags.push(this.tag);
-          this.emitNode("onopentag", this.tag);
-          if (!selfClosing) {
-            if (!this.noscript && this.tagName.toLowerCase() === "script") {
-              this.state = this.S.SCRIPT;
-            } else {
-              this.state = this.S.TEXT;
+        return i;
+      }
+      function readCommentAndCDATA(xmlData, i) {
+        if (xmlData.length > i + 5 && xmlData[i + 1] === "-" && xmlData[i + 2] === "-") {
+          for (i += 3; i < xmlData.length; i++) {
+            if (xmlData[i] === "-" && xmlData[i + 1] === "-" && xmlData[i + 2] === ">") {
+              i += 2;
+              break;
             }
-            this.tag = null;
-            this.tagName = "";
           }
-          this.attribName = this.attribValue = "";
-          this.attribList.length = 0;
-        }
-        closeTag() {
-          if (!this.tagName) {
-            this.strictFail("Weird empty close tag.");
-            this.textNode += "</>";
-            this.state = this.S.TEXT;
-            return;
-          }
-          if (this.script) {
-            if (this.tagName !== "script") {
-              this.script += `</${this.tagName}>`;
-              this.tagName = "";
-              this.state = this.S.SCRIPT;
-              return;
+        } else if (xmlData.length > i + 8 && xmlData[i + 1] === "D" && xmlData[i + 2] === "O" && xmlData[i + 3] === "C" && xmlData[i + 4] === "T" && xmlData[i + 5] === "Y" && xmlData[i + 6] === "P" && xmlData[i + 7] === "E") {
+          let angleBracketsCount = 1;
+          for (i += 8; i < xmlData.length; i++) {
+            if (xmlData[i] === "<") {
+              angleBracketsCount++;
+            } else if (xmlData[i] === ">") {
+              angleBracketsCount--;
+              if (angleBracketsCount === 0) {
+                break;
+              }
             }
-            this.emitNode("onscript", this.script);
-            this.script = "";
           }
-          let t = this.tags.length;
-          let tagName = this.tagName;
-          if (!this.strict) {
-            tagName = tagName[this.looseCase]();
-          }
-          while (t--) {
-            const close = this.tags[t];
-            if (close.name !== tagName) {
-              this.strictFail("Unexpected close tag");
-            } else {
+        } else if (xmlData.length > i + 9 && xmlData[i + 1] === "[" && xmlData[i + 2] === "C" && xmlData[i + 3] === "D" && xmlData[i + 4] === "A" && xmlData[i + 5] === "T" && xmlData[i + 6] === "A" && xmlData[i + 7] === "[") {
+          for (i += 8; i < xmlData.length; i++) {
+            if (xmlData[i] === "]" && xmlData[i + 1] === "]" && xmlData[i + 2] === ">") {
+              i += 2;
               break;
             }
           }
-          if (t < 0) {
-            this.strictFail(`Unmatched closing tag: ${this.tagName}`);
-            this.textNode += `</${this.tagName}>`;
-            this.state = this.S.TEXT;
-            return;
-          }
-          this.tagName = tagName;
-          let s = this.tags.length;
-          while (s-- > t) {
-            const tag = this.tag = this.tags.pop();
-            this.tagName = this.tag.name;
-            this.emitNode("onclosetag", this.tagName);
-            const x = {};
-            for (const i in tag.ns) {
-              if (tag.ns.hasOwnProperty(i)) {
-                x[i] = tag.ns[i];
-              }
+        }
+        return i;
+      }
+      var doubleQuote = '"';
+      var singleQuote = "'";
+      function readAttributeStr(xmlData, i) {
+        let attrStr = "";
+        let startChar = "";
+        let tagClosed = false;
+        for (; i < xmlData.length; i++) {
+          if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {
+            if (startChar === "") {
+              startChar = xmlData[i];
+            } else if (startChar !== xmlData[i]) {
+            } else {
+              startChar = "";
             }
-            const parent = this.tags[this.tags.length - 1] || this;
-            if (this.opt.xmlns && tag.ns !== parent.ns) {
-              const that = this;
-              Object.keys(tag.ns).forEach((p) => {
-                const n = tag.ns[p];
-                that.emitNode("onclosenamespace", { prefix: p, uri: n });
-              });
+          } else if (xmlData[i] === ">") {
+            if (startChar === "") {
+              tagClosed = true;
+              break;
             }
           }
-          if (t === 0)
-            this.closedRoot = true;
-          this.tagName = this.attribValue = this.attribName = "";
-          this.attribList.length = 0;
-          this.state = this.S.TEXT;
+          attrStr += xmlData[i];
         }
-      };
-      SAXParser = class extends SAX {
-        constructor(opt) {
-          super();
-          this.opt = DEFAULT_SAX_PARSER_OPTIONS;
-          this.events = DEFAULT_SAX_EVENTS;
-          this.clearBuffers();
-          this.opt = opt = { ...this.opt, ...opt };
-          this.events = { ...this.events, ...opt };
-          this.q = this.c = "";
-          this.opt.lowercase = this.opt.lowercase || this.opt.lowercasetags;
-          this.bufferCheckPosition = this.opt.MAX_BUFFER_LENGTH;
-          this.looseCase = this.opt.lowercase ? "toLowerCase" : "toUpperCase";
-          this.tags = [];
-          this.closed = this.closedRoot = this.sawRoot = false;
-          this.tag = this.error = null;
-          this.strict = Boolean(this.opt.strict);
-          this.noscript = Boolean(this.opt.strict || this.opt.noscript);
-          this.state = this.S.BEGIN;
-          this.strictEntities = this.opt.strictEntities;
-          this.ENTITIES = this.strictEntities ? Object.create(this.XML_ENTITIES) : Object.create(this.ENTITIES);
-          this.attribList = [];
-          if (this.opt.xmlns) {
-            this.ns = Object.create(this.rootNS);
+        if (startChar !== "") {
+          return false;
+        }
+        return {
+          value: attrStr,
+          index: i,
+          tagClosed
+        };
+      }
+      var validAttrStrRegxp = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g");
+      function validateAttributeString(attrStr, options) {
+        const matches = util.getAllMatches(attrStr, validAttrStrRegxp);
+        const attrNames = {};
+        for (let i = 0; i < matches.length; i++) {
+          if (matches[i][1].length === 0) {
+            return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' has no space in starting.", getPositionFromMatch(matches[i]));
+          } else if (matches[i][3] !== void 0 && matches[i][4] === void 0) {
+            return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' is without value.", getPositionFromMatch(matches[i]));
+          } else if (matches[i][3] === void 0 && !options.allowBooleanAttributes) {
+            return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i][2] + "' is not allowed.", getPositionFromMatch(matches[i]));
           }
-          this.trackPosition = this.opt.position !== false;
-          if (this.trackPosition) {
-            this.position = this.line = this.column = 0;
+          const attrName = matches[i][2];
+          if (!validateAttrName(attrName)) {
+            return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i]));
+          }
+          if (!attrNames.hasOwnProperty(attrName)) {
+            attrNames[attrName] = 1;
+          } else {
+            return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i]));
           }
-          this.emit("onready");
         }
-        resume() {
-          this.error = null;
-          return this;
+        return true;
+      }
+      function validateNumberAmpersand(xmlData, i) {
+        let re = /\d/;
+        if (xmlData[i] === "x") {
+          i++;
+          re = /[\da-fA-F]/;
+        }
+        for (; i < xmlData.length; i++) {
+          if (xmlData[i] === ";")
+            return i;
+          if (!xmlData[i].match(re))
+            break;
         }
-        close() {
-          return this.write(null);
+        return -1;
+      }
+      function validateAmpersand(xmlData, i) {
+        i++;
+        if (xmlData[i] === ";")
+          return -1;
+        if (xmlData[i] === "#") {
+          i++;
+          return validateNumberAmpersand(xmlData, i);
         }
-        flush() {
-          this.flushBuffers();
+        let count = 0;
+        for (; i < xmlData.length; i++, count++) {
+          if (xmlData[i].match(/\w/) && count < 20)
+            continue;
+          if (xmlData[i] === ";")
+            break;
+          return -1;
         }
-      };
-      SAXParser.ENTITIES = ENTITIES;
-    }
-  });
-
-  // src/lib/xml-utils/uncapitalize.ts
-  function uncapitalize(str) {
-    return typeof str === "string" ? str.charAt(0).toLowerCase() + str.slice(1) : str;
-  }
-  function uncapitalizeKeys(object) {
-    if (Array.isArray(object)) {
-      return object.map((element) => uncapitalizeKeys(element));
-    }
-    if (object && typeof object === "object") {
-      const newObject = {};
-      for (const [key, value] of Object.entries(object)) {
-        newObject[uncapitalize(key)] = uncapitalizeKeys(value);
+        return i;
+      }
+      function getErrorObject(code, message, lineNumber) {
+        return {
+          err: {
+            code,
+            msg: message,
+            line: lineNumber.line || lineNumber,
+            col: lineNumber.col
+          }
+        };
+      }
+      function validateAttrName(attrName) {
+        return util.isName(attrName);
+      }
+      function validateTagName(tagname) {
+        return util.isName(tagname);
+      }
+      function getLineNumberForPosition(xmlData, index) {
+        const lines = xmlData.substring(0, index).split(/\r?\n/);
+        return {
+          line: lines.length,
+          // column number is last line's length + 1, because column numbering starts at 1:
+          col: lines[lines.length - 1].length + 1
+        };
+      }
+      function getPositionFromMatch(match) {
+        return match.startIndex + match[1].length;
       }
-      return newObject;
-    }
-    return object;
-  }
-  var init_uncapitalize = __esm({
-    "src/lib/xml-utils/uncapitalize.ts"() {
     }
   });
 
-  // ../../node_modules/fast-xml-parser/src/util.js
-  var require_util = __commonJS({
-    "../../node_modules/fast-xml-parser/src/util.js"(exports) {
-      "use strict";
-      var nameStartChar = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
-      var nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
-      var nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*";
-      var regexName = new RegExp("^" + nameRegexp + "$");
-      var getAllMatches = function(string, regex) {
-        const matches = [];
-        let match = regex.exec(string);
-        while (match) {
-          const allmatches = [];
-          allmatches.startIndex = regex.lastIndex - match[0].length;
-          const len = match.length;
-          for (let index = 0; index < len; index++) {
-            allmatches.push(match[index]);
-          }
-          matches.push(allmatches);
-          match = regex.exec(string);
+  // ../../node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
+  var require_OptionsBuilder = __commonJS({
+    "../../node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js"(exports) {
+      var defaultOptions = {
+        preserveOrder: false,
+        attributeNamePrefix: "@_",
+        attributesGroupName: false,
+        textNodeName: "#text",
+        ignoreAttributes: true,
+        removeNSPrefix: false,
+        // remove NS from tag name or attribute name if true
+        allowBooleanAttributes: false,
+        //a tag can have attributes without any value
+        //ignoreRootElement : false,
+        parseTagValue: true,
+        parseAttributeValue: false,
+        trimValues: true,
+        //Trim string values of tag and attributes
+        cdataPropName: false,
+        numberParseOptions: {
+          hex: true,
+          leadingZeros: true,
+          eNotation: true
+        },
+        tagValueProcessor: function(tagName, val2) {
+          return val2;
+        },
+        attributeValueProcessor: function(attrName, val2) {
+          return val2;
+        },
+        stopNodes: [],
+        //nested tags will not be parsed even for errors
+        alwaysCreateTextNode: false,
+        isArray: () => false,
+        commentPropName: false,
+        unpairedTags: [],
+        processEntities: true,
+        htmlEntities: false,
+        ignoreDeclaration: false,
+        ignorePiTags: false,
+        transformTagName: false,
+        transformAttributeName: false,
+        updateTag: function(tagName, jPath, attrs) {
+          return tagName;
         }
-        return matches;
+        // skipEmptyListItem: false
       };
-      var isName = function(string) {
-        const match = regexName.exec(string);
-        return !(match === null || typeof match === "undefined");
-      };
-      exports.isExist = function(v) {
-        return typeof v !== "undefined";
-      };
-      exports.isEmptyObject = function(obj) {
-        return Object.keys(obj).length === 0;
+      var buildOptions = function(options) {
+        return Object.assign({}, defaultOptions, options);
       };
-      exports.merge = function(target, a, arrayMode) {
-        if (a) {
-          const keys = Object.keys(a);
-          const len = keys.length;
-          for (let i = 0; i < len; i++) {
-            if (arrayMode === "strict") {
-              target[keys[i]] = [a[keys[i]]];
-            } else {
-              target[keys[i]] = a[keys[i]];
-            }
-          }
+      exports.buildOptions = buildOptions;
+      exports.defaultOptions = defaultOptions;
+    }
+  });
+
+  // ../../node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
+  var require_xmlNode = __commonJS({
+    "../../node_modules/fast-xml-parser/src/xmlparser/xmlNode.js"(exports, module) {
+      "use strict";
+      var XmlNode = class {
+        constructor(tagname) {
+          this.tagname = tagname;
+          this.child = [];
+          this[":@"] = {};
         }
-      };
-      exports.getValue = function(v) {
-        if (exports.isExist(v)) {
-          return v;
-        } else {
-          return "";
+        add(key, val2) {
+          if (key === "__proto__")
+            key = "#__proto__";
+          this.child.push({
+            [key]: val2
+          });
+        }
+        addChild(node) {
+          if (node.tagname === "__proto__")
+            node.tagname = "#__proto__";
+          if (node[":@"] && Object.keys(node[":@"]).length > 0) {
+            this.child.push({
+              [node.tagname]: node.child,
+              [":@"]: node[":@"]
+            });
+          } else {
+            this.child.push({
+              [node.tagname]: node.child
+            });
+          }
         }
       };
-      exports.isName = isName;
-      exports.getAllMatches = getAllMatches;
-      exports.nameRegexp = nameRegexp;
+      module.exports = XmlNode;
     }
   });
 
-  // ../../node_modules/fast-xml-parser/src/validator.js
-  var require_validator = __commonJS({
-    "../../node_modules/fast-xml-parser/src/validator.js"(exports) {
-      "use strict";
+  // ../../node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
+  var require_DocTypeReader = __commonJS({
+    "../../node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js"(exports, module) {
       var util = require_util();
-      var defaultOptions = {
-        allowBooleanAttributes: false,
-        unpairedTags: []
-      };
-      exports.validate = function(xmlData, options) {
-        options = Object.assign({}, defaultOptions, options);
-        const tags = [];
-        let tagFound = false;
-        let reachedRoot = false;
-        if (xmlData[0] === "\uFEFF") {
-          xmlData = xmlData.substr(1);
-        }
-        for (let i = 0; i < xmlData.length; i++) {
-          if (xmlData[i] === "<" && xmlData[i + 1] === "?") {
-            i += 2;
-            i = readPI(xmlData, i);
-            if (i.err)
-              return i;
-          } else if (xmlData[i] === "<") {
-            let tagStartPos = i;
-            i++;
-            if (xmlData[i] === "!") {
-              i = readCommentAndCDATA(xmlData, i);
-              continue;
-            } else {
-              let closingTag = false;
-              if (xmlData[i] === "/") {
-                closingTag = true;
-                i++;
-              }
-              let tagName = "";
-              for (; i < xmlData.length && xmlData[i] !== ">" && xmlData[i] !== " " && xmlData[i] !== "	" && xmlData[i] !== "\n" && xmlData[i] !== "\r"; i++) {
-                tagName += xmlData[i];
-              }
-              tagName = tagName.trim();
-              if (tagName[tagName.length - 1] === "/") {
-                tagName = tagName.substring(0, tagName.length - 1);
-                i--;
-              }
-              if (!validateTagName(tagName)) {
-                let msg;
-                if (tagName.trim().length === 0) {
-                  msg = "Invalid space after '<'.";
-                } else {
-                  msg = "Tag '" + tagName + "' is an invalid name.";
+      function readDocType(xmlData, i) {
+        const entities = {};
+        if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") {
+          i = i + 9;
+          let angleBracketsCount = 1;
+          let hasBody = false, comment = false;
+          let exp = "";
+          for (; i < xmlData.length; i++) {
+            if (xmlData[i] === "<" && !comment) {
+              if (hasBody && isEntity(xmlData, i)) {
+                i += 7;
+                [entityName, val, i] = readEntityExp(xmlData, i + 1);
+                if (val.indexOf("&") === -1)
+                  entities[validateEntityName(entityName)] = {
+                    regx: RegExp(`&${entityName};`, "g"),
+                    val
+                  };
+              } else if (hasBody && isElement(xmlData, i))
+                i += 8;
+              else if (hasBody && isAttlist(xmlData, i))
+                i += 8;
+              else if (hasBody && isNotation(xmlData, i))
+                i += 9;
+              else if (isComment)
+                comment = true;
+              else
+                throw new Error("Invalid DOCTYPE");
+              angleBracketsCount++;
+              exp = "";
+            } else if (xmlData[i] === ">") {
+              if (comment) {
+                if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") {
+                  comment = false;
+                  angleBracketsCount--;
                 }
-                return getErrorObject("InvalidTag", msg, getLineNumberForPosition(xmlData, i));
+              } else {
+                angleBracketsCount--;
               }
-              const result = readAttributeStr(xmlData, i);
-              if (result === false) {
-                return getErrorObject("InvalidAttr", "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i));
+              if (angleBracketsCount === 0) {
+                break;
               }
-              let attrStr = result.value;
-              i = result.index;
-              if (attrStr[attrStr.length - 1] === "/") {
-                const attrStrStart = i - attrStr.length;
-                attrStr = attrStr.substring(0, attrStr.length - 1);
-                const isValid = validateAttributeString(attrStr, options);
-                if (isValid === true) {
-                  tagFound = true;
-                } else {
-                  return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));
-                }
-              } else if (closingTag) {
-                if (!result.tagClosed) {
-                  return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
-                } else if (attrStr.trim().length > 0) {
-                  return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
-                } else {
-                  const otg = tags.pop();
-                  if (tagName !== otg.tagName) {
-                    let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
-                    return getErrorObject("InvalidTag", "Expected closing tag '" + otg.tagName + "' (opened in line " + openPos.line + ", col " + openPos.col + ") instead of closing tag '" + tagName + "'.", getLineNumberForPosition(xmlData, tagStartPos));
-                  }
-                  if (tags.length == 0) {
-                    reachedRoot = true;
-                  }
-                }
-              } else {
-                const isValid = validateAttributeString(attrStr, options);
-                if (isValid !== true) {
-                  return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
-                }
-                if (reachedRoot === true) {
-                  return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(xmlData, i));
-                } else if (options.unpairedTags.indexOf(tagName) !== -1) {
-                } else {
-                  tags.push({ tagName, tagStartPos });
-                }
-                tagFound = true;
-              }
-              for (i++; i < xmlData.length; i++) {
-                if (xmlData[i] === "<") {
-                  if (xmlData[i + 1] === "!") {
-                    i++;
-                    i = readCommentAndCDATA(xmlData, i);
-                    continue;
-                  } else if (xmlData[i + 1] === "?") {
-                    i = readPI(xmlData, ++i);
-                    if (i.err)
-                      return i;
-                  } else {
-                    break;
-                  }
-                } else if (xmlData[i] === "&") {
-                  const afterAmp = validateAmpersand(xmlData, i);
-                  if (afterAmp == -1)
-                    return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
-                  i = afterAmp;
-                } else {
-                  if (reachedRoot === true && !isWhiteSpace(xmlData[i])) {
-                    return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(xmlData, i));
-                  }
-                }
-              }
-              if (xmlData[i] === "<") {
-                i--;
-              }
-            }
-          } else {
-            if (isWhiteSpace(xmlData[i])) {
-              continue;
-            }
-            return getErrorObject("InvalidChar", "char '" + xmlData[i] + "' is not expected.", getLineNumberForPosition(xmlData, i));
-          }
-        }
-        if (!tagFound) {
-          return getErrorObject("InvalidXml", "Start tag expected.", 1);
-        } else if (tags.length == 1) {
-          return getErrorObject("InvalidTag", "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
-        } else if (tags.length > 0) {
-          return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t) => t.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 });
-        }
-        return true;
-      };
-      function isWhiteSpace(char) {
-        return char === " " || char === "	" || char === "\n" || char === "\r";
-      }
-      function readPI(xmlData, i) {
-        const start = i;
-        for (; i < xmlData.length; i++) {
-          if (xmlData[i] == "?" || xmlData[i] == " ") {
-            const tagname = xmlData.substr(start, i - start);
-            if (i > 5 && tagname === "xml") {
-              return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(xmlData, i));
-            } else if (xmlData[i] == "?" && xmlData[i + 1] == ">") {
-              i++;
-              break;
+            } else if (xmlData[i] === "[") {
+              hasBody = true;
             } else {
-              continue;
-            }
-          }
-        }
-        return i;
-      }
-      function readCommentAndCDATA(xmlData, i) {
-        if (xmlData.length > i + 5 && xmlData[i + 1] === "-" && xmlData[i + 2] === "-") {
-          for (i += 3; i < xmlData.length; i++) {
-            if (xmlData[i] === "-" && xmlData[i + 1] === "-" && xmlData[i + 2] === ">") {
-              i += 2;
-              break;
-            }
-          }
-        } else if (xmlData.length > i + 8 && xmlData[i + 1] === "D" && xmlData[i + 2] === "O" && xmlData[i + 3] === "C" && xmlData[i + 4] === "T" && xmlData[i + 5] === "Y" && xmlData[i + 6] === "P" && xmlData[i + 7] === "E") {
-          let angleBracketsCount = 1;
-          for (i += 8; i < xmlData.length; i++) {
-            if (xmlData[i] === "<") {
-              angleBracketsCount++;
-            } else if (xmlData[i] === ">") {
-              angleBracketsCount--;
-              if (angleBracketsCount === 0) {
-                break;
-              }
-            }
-          }
-        } else if (xmlData.length > i + 9 && xmlData[i + 1] === "[" && xmlData[i + 2] === "C" && xmlData[i + 3] === "D" && xmlData[i + 4] === "A" && xmlData[i + 5] === "T" && xmlData[i + 6] === "A" && xmlData[i + 7] === "[") {
-          for (i += 8; i < xmlData.length; i++) {
-            if (xmlData[i] === "]" && xmlData[i + 1] === "]" && xmlData[i + 2] === ">") {
-              i += 2;
-              break;
+              exp += xmlData[i];
             }
           }
-        }
-        return i;
-      }
-      var doubleQuote = '"';
-      var singleQuote = "'";
-      function readAttributeStr(xmlData, i) {
-        let attrStr = "";
-        let startChar = "";
-        let tagClosed = false;
-        for (; i < xmlData.length; i++) {
-          if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {
-            if (startChar === "") {
-              startChar = xmlData[i];
-            } else if (startChar !== xmlData[i]) {
-            } else {
-              startChar = "";
-            }
-          } else if (xmlData[i] === ">") {
-            if (startChar === "") {
-              tagClosed = true;
-              break;
-            }
+          if (angleBracketsCount !== 0) {
+            throw new Error(`Unclosed DOCTYPE`);
           }
-          attrStr += xmlData[i];
-        }
-        if (startChar !== "") {
-          return false;
+        } else {
+          throw new Error(`Invalid Tag instead of DOCTYPE`);
         }
         return {
-          value: attrStr,
-          index: i,
-          tagClosed
+          entities,
+          i
         };
       }
-      var validAttrStrRegxp = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g");
-      function validateAttributeString(attrStr, options) {
-        const matches = util.getAllMatches(attrStr, validAttrStrRegxp);
-        const attrNames = {};
-        for (let i = 0; i < matches.length; i++) {
-          if (matches[i][1].length === 0) {
-            return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' has no space in starting.", getPositionFromMatch(matches[i]));
-          } else if (matches[i][3] !== void 0 && matches[i][4] === void 0) {
-            return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' is without value.", getPositionFromMatch(matches[i]));
-          } else if (matches[i][3] === void 0 && !options.allowBooleanAttributes) {
-            return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i][2] + "' is not allowed.", getPositionFromMatch(matches[i]));
-          }
-          const attrName = matches[i][2];
-          if (!validateAttrName(attrName)) {
-            return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i]));
-          }
-          if (!attrNames.hasOwnProperty(attrName)) {
-            attrNames[attrName] = 1;
-          } else {
-            return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i]));
-          }
-        }
-        return true;
-      }
-      function validateNumberAmpersand(xmlData, i) {
-        let re = /\d/;
-        if (xmlData[i] === "x") {
-          i++;
-          re = /[\da-fA-F]/;
+      function readEntityExp(xmlData, i) {
+        let entityName2 = "";
+        for (; i < xmlData.length && xmlData[i] !== "'" && xmlData[i] !== '"'; i++) {
+          entityName2 += xmlData[i];
         }
-        for (; i < xmlData.length; i++) {
-          if (xmlData[i] === ";")
-            return i;
-          if (!xmlData[i].match(re))
-            break;
+        entityName2 = entityName2.trim();
+        if (entityName2.indexOf(" ") !== -1)
+          throw new Error("External entites are not supported");
+        const startChar = xmlData[i++];
+        let val2 = "";
+        for (; i < xmlData.length && xmlData[i] !== startChar; i++) {
+          val2 += xmlData[i];
         }
-        return -1;
+        return [entityName2, val2, i];
       }
-      function validateAmpersand(xmlData, i) {
-        i++;
-        if (xmlData[i] === ";")
-          return -1;
-        if (xmlData[i] === "#") {
-          i++;
-          return validateNumberAmpersand(xmlData, i);
-        }
-        let count = 0;
-        for (; i < xmlData.length; i++, count++) {
-          if (xmlData[i].match(/\w/) && count < 20)
-            continue;
-          if (xmlData[i] === ";")
-            break;
-          return -1;
-        }
-        return i;
+      function isComment(xmlData, i) {
+        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "-" && xmlData[i + 3] === "-")
+          return true;
+        return false;
       }
-      function getErrorObject(code, message, lineNumber) {
-        return {
-          err: {
-            code,
-            msg: message,
-            line: lineNumber.line || lineNumber,
-            col: lineNumber.col
-          }
-        };
+      function isEntity(xmlData, i) {
+        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "N" && xmlData[i + 4] === "T" && xmlData[i + 5] === "I" && xmlData[i + 6] === "T" && xmlData[i + 7] === "Y")
+          return true;
+        return false;
       }
-      function validateAttrName(attrName) {
-        return util.isName(attrName);
+      function isElement(xmlData, i) {
+        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "L" && xmlData[i + 4] === "E" && xmlData[i + 5] === "M" && xmlData[i + 6] === "E" && xmlData[i + 7] === "N" && xmlData[i + 8] === "T")
+          return true;
+        return false;
       }
-      function validateTagName(tagname) {
-        return util.isName(tagname);
+      function isAttlist(xmlData, i) {
+        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "A" && xmlData[i + 3] === "T" && xmlData[i + 4] === "T" && xmlData[i + 5] === "L" && xmlData[i + 6] === "I" && xmlData[i + 7] === "S" && xmlData[i + 8] === "T")
+          return true;
+        return false;
       }
-      function getLineNumberForPosition(xmlData, index) {
-        const lines = xmlData.substring(0, index).split(/\r?\n/);
-        return {
-          line: lines.length,
-          col: lines[lines.length - 1].length + 1
-        };
+      function isNotation(xmlData, i) {
+        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "N" && xmlData[i + 3] === "O" && xmlData[i + 4] === "T" && xmlData[i + 5] === "A" && xmlData[i + 6] === "T" && xmlData[i + 7] === "I" && xmlData[i + 8] === "O" && xmlData[i + 9] === "N")
+          return true;
+        return false;
       }
-      function getPositionFromMatch(match) {
-        return match.startIndex + match[1].length;
+      function validateEntityName(name) {
+        if (util.isName(name))
+          return name;
+        else
+          throw new Error(`Invalid entity name ${name}`);
       }
-    }
-  });
-
-  // ../../node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
-  var require_OptionsBuilder = __commonJS({
-    "../../node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js"(exports) {
-      var defaultOptions = {
-        preserveOrder: false,
-        attributeNamePrefix: "@_",
-        attributesGroupName: false,
-        textNodeName: "#text",
-        ignoreAttributes: true,
-        removeNSPrefix: false,
-        allowBooleanAttributes: false,
-        parseTagValue: true,
-        parseAttributeValue: false,
-        trimValues: true,
-        cdataPropName: false,
-        numberParseOptions: {
-          hex: true,
-          leadingZeros: true,
-          eNotation: true
-        },
-        tagValueProcessor: function(tagName, val2) {
-          return val2;
-        },
-        attributeValueProcessor: function(attrName, val2) {
-          return val2;
-        },
-        stopNodes: [],
-        alwaysCreateTextNode: false,
-        isArray: () => false,
-        commentPropName: false,
-        unpairedTags: [],
-        processEntities: true,
-        htmlEntities: false,
-        ignoreDeclaration: false,
-        ignorePiTags: false,
-        transformTagName: false,
-        transformAttributeName: false,
-        updateTag: function(tagName, jPath, attrs) {
-          return tagName;
-        }
-      };
-      var buildOptions = function(options) {
-        return Object.assign({}, defaultOptions, options);
-      };
-      exports.buildOptions = buildOptions;
-      exports.defaultOptions = defaultOptions;
-    }
-  });
-
-  // ../../node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
-  var require_xmlNode = __commonJS({
-    "../../node_modules/fast-xml-parser/src/xmlparser/xmlNode.js"(exports, module) {
-      "use strict";
-      var XmlNode = class {
-        constructor(tagname) {
-          this.tagname = tagname;
-          this.child = [];
-          this[":@"] = {};
-        }
-        add(key, val2) {
-          if (key === "__proto__")
-            key = "#__proto__";
-          this.child.push({ [key]: val2 });
-        }
-        addChild(node) {
-          if (node.tagname === "__proto__")
-            node.tagname = "#__proto__";
-          if (node[":@"] && Object.keys(node[":@"]).length > 0) {
-            this.child.push({ [node.tagname]: node.child, [":@"]: node[":@"] });
-          } else {
-            this.child.push({ [node.tagname]: node.child });
-          }
-        }
-      };
-      module.exports = XmlNode;
-    }
-  });
-
-  // ../../node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
-  var require_DocTypeReader = __commonJS({
-    "../../node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js"(exports, module) {
-      var util = require_util();
-      function readDocType(xmlData, i) {
-        const entities = {};
-        if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") {
-          i = i + 9;
-          let angleBracketsCount = 1;
-          let hasBody = false, comment = false;
-          let exp = "";
-          for (; i < xmlData.length; i++) {
-            if (xmlData[i] === "<" && !comment) {
-              if (hasBody && isEntity(xmlData, i)) {
-                i += 7;
-                [entityName, val, i] = readEntityExp(xmlData, i + 1);
-                if (val.indexOf("&") === -1)
-                  entities[validateEntityName(entityName)] = {
-                    regx: RegExp(`&${entityName};`, "g"),
-                    val
-                  };
-              } else if (hasBody && isElement(xmlData, i))
-                i += 8;
-              else if (hasBody && isAttlist(xmlData, i))
-                i += 8;
-              else if (hasBody && isNotation(xmlData, i))
-                i += 9;
-              else if (isComment)
-                comment = true;
-              else
-                throw new Error("Invalid DOCTYPE");
-              angleBracketsCount++;
-              exp = "";
-            } else if (xmlData[i] === ">") {
-              if (comment) {
-                if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") {
-                  comment = false;
-                  angleBracketsCount--;
-                }
-              } else {
-                angleBracketsCount--;
-              }
-              if (angleBracketsCount === 0) {
-                break;
-              }
-            } else if (xmlData[i] === "[") {
-              hasBody = true;
-            } else {
-              exp += xmlData[i];
-            }
-          }
-          if (angleBracketsCount !== 0) {
-            throw new Error(`Unclosed DOCTYPE`);
-          }
-        } else {
-          throw new Error(`Invalid Tag instead of DOCTYPE`);
-        }
-        return { entities, i };
-      }
-      function readEntityExp(xmlData, i) {
-        let entityName2 = "";
-        for (; i < xmlData.length && (xmlData[i] !== "'" && xmlData[i] !== '"'); i++) {
-          entityName2 += xmlData[i];
-        }
-        entityName2 = entityName2.trim();
-        if (entityName2.indexOf(" ") !== -1)
-          throw new Error("External entites are not supported");
-        const startChar = xmlData[i++];
-        let val2 = "";
-        for (; i < xmlData.length && xmlData[i] !== startChar; i++) {
-          val2 += xmlData[i];
-        }
-        return [entityName2, val2, i];
-      }
-      function isComment(xmlData, i) {
-        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "-" && xmlData[i + 3] === "-")
-          return true;
-        return false;
-      }
-      function isEntity(xmlData, i) {
-        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "N" && xmlData[i + 4] === "T" && xmlData[i + 5] === "I" && xmlData[i + 6] === "T" && xmlData[i + 7] === "Y")
-          return true;
-        return false;
-      }
-      function isElement(xmlData, i) {
-        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "L" && xmlData[i + 4] === "E" && xmlData[i + 5] === "M" && xmlData[i + 6] === "E" && xmlData[i + 7] === "N" && xmlData[i + 8] === "T")
-          return true;
-        return false;
-      }
-      function isAttlist(xmlData, i) {
-        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "A" && xmlData[i + 3] === "T" && xmlData[i + 4] === "T" && xmlData[i + 5] === "L" && xmlData[i + 6] === "I" && xmlData[i + 7] === "S" && xmlData[i + 8] === "T")
-          return true;
-        return false;
-      }
-      function isNotation(xmlData, i) {
-        if (xmlData[i + 1] === "!" && xmlData[i + 2] === "N" && xmlData[i + 3] === "O" && xmlData[i + 4] === "T" && xmlData[i + 5] === "A" && xmlData[i + 6] === "T" && xmlData[i + 7] === "I" && xmlData[i + 8] === "O" && xmlData[i + 9] === "N")
-          return true;
-        return false;
-      }
-      function validateEntityName(name) {
-        if (util.isName(name))
-          return name;
-        else
-          throw new Error(`Invalid entity name ${name}`);
-      }
-      module.exports = readDocType;
+      module.exports = readDocType;
     }
   });
 
@@ -1948,6 +634,7 @@ Actual: ${this.attribValue}`);
         leadingZeros: true,
         decimalPoint: ".",
         eNotation: true
+        //skipLike: /regex/
       };
       function toNumber(str, options = {}) {
         options = Object.assign({}, consider, options);
@@ -2044,21 +731,65 @@ Actual: ${this.attribValue}`);
           this.tagsNodeStack = [];
           this.docTypeEntities = {};
           this.lastEntities = {
-            "apos": { regex: /&(apos|#39|#x27);/g, val: "'" },
-            "gt": { regex: /&(gt|#62|#x3E);/g, val: ">" },
-            "lt": { regex: /&(lt|#60|#x3C);/g, val: "<" },
-            "quot": { regex: /&(quot|#34|#x22);/g, val: '"' }
+            "apos": {
+              regex: /&(apos|#39|#x27);/g,
+              val: "'"
+            },
+            "gt": {
+              regex: /&(gt|#62|#x3E);/g,
+              val: ">"
+            },
+            "lt": {
+              regex: /&(lt|#60|#x3C);/g,
+              val: "<"
+            },
+            "quot": {
+              regex: /&(quot|#34|#x22);/g,
+              val: '"'
+            }
+          };
+          this.ampEntity = {
+            regex: /&(amp|#38|#x26);/g,
+            val: "&"
           };
-          this.ampEntity = { regex: /&(amp|#38|#x26);/g, val: "&" };
           this.htmlEntities = {
-            "space": { regex: /&(nbsp|#160);/g, val: " " },
-            "cent": { regex: /&(cent|#162);/g, val: "\xA2" },
-            "pound": { regex: /&(pound|#163);/g, val: "\xA3" },
-            "yen": { regex: /&(yen|#165);/g, val: "\xA5" },
-            "euro": { regex: /&(euro|#8364);/g, val: "\u20AC" },
-            "copyright": { regex: /&(copy|#169);/g, val: "\xA9" },
-            "reg": { regex: /&(reg|#174);/g, val: "\xAE" },
-            "inr": { regex: /&(inr|#8377);/g, val: "\u20B9" }
+            "space": {
+              regex: /&(nbsp|#160);/g,
+              val: " "
+            },
+            // "lt" : { regex: /&(lt|#60);/g, val: "<" },
+            // "gt" : { regex: /&(gt|#62);/g, val: ">" },
+            // "amp" : { regex: /&(amp|#38);/g, val: "&" },
+            // "quot" : { regex: /&(quot|#34);/g, val: "\"" },
+            // "apos" : { regex: /&(apos|#39);/g, val: "'" },
+            "cent": {
+              regex: /&(cent|#162);/g,
+              val: "\xA2"
+            },
+            "pound": {
+              regex: /&(pound|#163);/g,
+              val: "\xA3"
+            },
+            "yen": {
+              regex: /&(yen|#165);/g,
+              val: "\xA5"
+            },
+            "euro": {
+              regex: /&(euro|#8364);/g,
+              val: "\u20AC"
+            },
+            "copyright": {
+              regex: /&(copy|#169);/g,
+              val: "\xA9"
+            },
+            "reg": {
+              regex: /&(reg|#174);/g,
+              val: "\xAE"
+            },
+            "inr": {
+              regex: /&(inr|#8377);/g,
+              val: "\u20B9"
+            }
           };
           this.addExternalEntities = addExternalEntities;
           this.parseXml = parseXml;
@@ -2225,7 +956,9 @@ Actual: ${this.attribValue}`);
               if (this.options.commentPropName) {
                 const comment = xmlData.substring(i + 4, endIndex - 2);
                 textData = this.saveTextToParentTag(textData, currentNode, jPath);
-                currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
+                currentNode.add(this.options.commentPropName, [{
+                  [this.options.textNodeName]: comment
+                }]);
               }
               i = endIndex;
             } else if (xmlData.substr(i + 1, 2) === "!D") {
@@ -2237,7 +970,9 @@ Actual: ${this.attribValue}`);
               const tagExp = xmlData.substring(i + 9, closeIndex);
               textData = this.saveTextToParentTag(textData, currentNode, jPath);
               if (this.options.cdataPropName) {
-                currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);
+                currentNode.add(this.options.cdataPropName, [{
+                  [this.options.textNodeName]: tagExp
+                }]);
               } else {
                 let val2 = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true);
                 if (val2 == void 0)
@@ -2584,7 +1319,9 @@ Actual: ${this.attribValue}`);
         }
       }
       function isLeafTag(obj, options) {
-        const { textNodeName } = options;
+        const {
+          textNodeName
+        } = options;
         const propCount = Object.keys(obj).length;
         if (propCount === 0) {
           return true;
@@ -2601,15 +1338,24 @@ Actual: ${this.attribValue}`);
   // ../../node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
   var require_XMLParser = __commonJS({
     "../../node_modules/fast-xml-parser/src/xmlparser/XMLParser.js"(exports, module) {
-      var { buildOptions } = require_OptionsBuilder();
+      var {
+        buildOptions
+      } = require_OptionsBuilder();
       var OrderedObjParser = require_OrderedObjParser();
-      var { prettify } = require_node2json();
+      var {
+        prettify
+      } = require_node2json();
       var validator = require_validator();
       var XMLParser = class {
         constructor(options) {
           this.externalEntities = {};
           this.options = buildOptions(options);
         }
+        /**
+         * Parse XML dats to JS object 
+         * @param {string|Buffer} xmlData 
+         * @param {boolean|Object} validationOption 
+         */
         parse(xmlData, validationOption) {
           if (typeof xmlData === "string") {
           } else if (xmlData.toString) {
@@ -2633,6 +1379,11 @@ Actual: ${this.attribValue}`);
           else
             return prettify(orderedResult, this.options);
         }
+        /**
+         * Add Entity which is not by default supported by this library
+         * @param {string} key 
+         * @param {string} value 
+         */
         addEntity(key, value) {
           if (value.indexOf("&") !== -1) {
             throw new Error("Entity value can't have '&'");
@@ -2803,14 +1554,32 @@ Actual: ${this.attribValue}`);
         commentPropName: false,
         unpairedTags: [],
         entities: [
-          { regex: new RegExp("&", "g"), val: "&amp;" },
-          { regex: new RegExp(">", "g"), val: "&gt;" },
-          { regex: new RegExp("<", "g"), val: "&lt;" },
-          { regex: new RegExp("'", "g"), val: "&apos;" },
-          { regex: new RegExp('"', "g"), val: "&quot;" }
+          {
+            regex: new RegExp("&", "g"),
+            val: "&amp;"
+          },
+          //it must be on top
+          {
+            regex: new RegExp(">", "g"),
+            val: "&gt;"
+          },
+          {
+            regex: new RegExp("<", "g"),
+            val: "&lt;"
+          },
+          {
+            regex: new RegExp("'", "g"),
+            val: "&apos;"
+          },
+          {
+            regex: new RegExp('"', "g"),
+            val: "&quot;"
+          }
         ],
         processEntities: true,
         stopNodes: [],
+        // transformTagName: false,
+        // transformAttributeName: false,
         oneListGroup: false
       };
       function Builder(options) {
@@ -2887,150 +1656,1538 @@ Actual: ${this.attribValue}`);
                 if (this.options.oneListGroup) {
                   listTagVal += this.j2x(item, level + 1).val;
                 } else {
-                  listTagVal += this.processTextOrObjNode(item, key, level);
+                  listTagVal += this.processTextOrObjNode(item, key, level);
+                }
+              } else {
+                listTagVal += this.buildTextValNode(item, key, "", level);
+              }
+            }
+            if (this.options.oneListGroup) {
+              listTagVal = this.buildObjectNode(listTagVal, key, "", level);
+            }
+            val2 += listTagVal;
+          } else {
+            if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
+              const Ks = Object.keys(jObj[key]);
+              const L = Ks.length;
+              for (let j = 0; j < L; j++) {
+                attrStr += this.buildAttrPairStr(Ks[j], "" + jObj[key][Ks[j]]);
+              }
+            } else {
+              val2 += this.processTextOrObjNode(jObj[key], key, level);
+            }
+          }
+        }
+        return {
+          attrStr,
+          val: val2
+        };
+      };
+      Builder.prototype.buildAttrPairStr = function(attrName, val2) {
+        val2 = this.options.attributeValueProcessor(attrName, "" + val2);
+        val2 = this.replaceEntitiesValue(val2);
+        if (this.options.suppressBooleanAttributes && val2 === "true") {
+          return " " + attrName;
+        } else
+          return " " + attrName + '="' + val2 + '"';
+      };
+      function processTextOrObjNode(object, key, level) {
+        const result = this.j2x(object, level + 1);
+        if (object[this.options.textNodeName] !== void 0 && Object.keys(object).length === 1) {
+          return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level);
+        } else {
+          return this.buildObjectNode(result.val, key, result.attrStr, level);
+        }
+      }
+      Builder.prototype.buildObjectNode = function(val2, key, attrStr, level) {
+        if (val2 === "") {
+          if (key[0] === "?")
+            return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
+          else {
+            return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
+          }
+        } else {
+          let tagEndExp = "</" + key + this.tagEndChar;
+          let piClosingChar = "";
+          if (key[0] === "?") {
+            piClosingChar = "?";
+            tagEndExp = "";
+          }
+          if (attrStr && val2.indexOf("<") === -1) {
+            return this.indentate(level) + "<" + key + attrStr + piClosingChar + ">" + val2 + tagEndExp;
+          } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {
+            return this.indentate(level) + `<!--${val2}-->` + this.newLine;
+          } else {
+            return this.indentate(level) + "<" + key + attrStr + piClosingChar + this.tagEndChar + val2 + this.indentate(level) + tagEndExp;
+          }
+        }
+      };
+      Builder.prototype.closeTag = function(key) {
+        let closeTag = "";
+        if (this.options.unpairedTags.indexOf(key) !== -1) {
+          if (!this.options.suppressUnpairedNode)
+            closeTag = "/";
+        } else if (this.options.suppressEmptyNode) {
+          closeTag = "/";
+        } else {
+          closeTag = `></${key}`;
+        }
+        return closeTag;
+      };
+      Builder.prototype.buildTextValNode = function(val2, key, attrStr, level) {
+        if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
+          return this.indentate(level) + `<![CDATA[${val2}]]>` + this.newLine;
+        } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
+          return this.indentate(level) + `<!--${val2}-->` + this.newLine;
+        } else if (key[0] === "?") {
+          return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
+        } else {
+          let textValue = this.options.tagValueProcessor(key, val2);
+          textValue = this.replaceEntitiesValue(textValue);
+          if (textValue === "") {
+            return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
+          } else {
+            return this.indentate(level) + "<" + key + attrStr + ">" + textValue + "</" + key + this.tagEndChar;
+          }
+        }
+      };
+      Builder.prototype.replaceEntitiesValue = function(textValue) {
+        if (textValue && textValue.length > 0 && this.options.processEntities) {
+          for (let i = 0; i < this.options.entities.length; i++) {
+            const entity = this.options.entities[i];
+            textValue = textValue.replace(entity.regex, entity.val);
+          }
+        }
+        return textValue;
+      };
+      function indentate(level) {
+        return this.options.indentBy.repeat(level);
+      }
+      function isAttribute(name) {
+        if (name.startsWith(this.options.attributeNamePrefix)) {
+          return name.substr(this.attrPrefixLen);
+        } else {
+          return false;
+        }
+      }
+      module.exports = Builder;
+    }
+  });
+
+  // ../../node_modules/fast-xml-parser/src/fxp.js
+  var require_fxp = __commonJS({
+    "../../node_modules/fast-xml-parser/src/fxp.js"(exports, module) {
+      "use strict";
+      var validator = require_validator();
+      var XMLParser = require_XMLParser();
+      var XMLBuilder = require_json2xml();
+      module.exports = {
+        XMLParser,
+        XMLValidator: validator,
+        XMLBuilder
+      };
+    }
+  });
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    HTMLLoader: () => HTMLLoader,
+    SAXParser: () => SAXParser,
+    XMLLoader: () => XMLLoader,
+    _uncapitalize: () => uncapitalize,
+    _uncapitalizeKeys: () => uncapitalizeKeys,
+    convertXMLFieldToArrayInPlace: () => convertXMLFieldToArrayInPlace,
+    convertXMLValueToArray: () => convertXMLValueToArray
+  });
+
+  // src/sax-ts/sax.ts
+  var DEFAULT_SAX_EVENTS = {
+    ontext: () => {
+    },
+    onprocessinginstruction: () => {
+    },
+    onsgmldeclaration: () => {
+    },
+    ondoctype: () => {
+    },
+    oncomment: () => {
+    },
+    onopentagstart: () => {
+    },
+    onattribute: () => {
+    },
+    onopentag: () => {
+    },
+    onclosetag: () => {
+    },
+    onopencdata: () => {
+    },
+    oncdata: () => {
+    },
+    onclosecdata: () => {
+    },
+    onerror: () => {
+    },
+    onend: () => {
+    },
+    onready: () => {
+    },
+    onscript: () => {
+    },
+    onopennamespace: () => {
+    },
+    onclosenamespace: () => {
+    }
+  };
+  var DEFAULT_SAX_PARSER_OPTIONS = {
+    ...DEFAULT_SAX_EVENTS,
+    strict: false,
+    MAX_BUFFER_LENGTH: 64 * 1024,
+    lowercase: false,
+    lowercasetags: false,
+    noscript: false,
+    strictEntities: false,
+    xmlns: void 0,
+    position: void 0,
+    trim: void 0,
+    normalize: void 0
+  };
+  var EVENTS = ["text", "processinginstruction", "sgmldeclaration", "doctype", "comment", "opentagstart", "attribute", "opentag", "closetag", "opencdata", "cdata", "closecdata", "error", "end", "ready", "script", "opennamespace", "closenamespace"];
+  var BUFFERS = ["comment", "sgmlDecl", "textNode", "tagName", "doctype", "procInstName", "procInstBody", "entity", "attribName", "attribValue", "cdata", "script"];
+  var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
+  var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
+  var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
+  var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
+  var ENTITIES = {
+    amp: "&",
+    gt: ">",
+    lt: "<",
+    quot: '"',
+    apos: "'",
+    AElig: 198,
+    Aacute: 193,
+    Acirc: 194,
+    Agrave: 192,
+    Aring: 197,
+    Atilde: 195,
+    Auml: 196,
+    Ccedil: 199,
+    ETH: 208,
+    Eacute: 201,
+    Ecirc: 202,
+    Egrave: 200,
+    Euml: 203,
+    Iacute: 205,
+    Icirc: 206,
+    Igrave: 204,
+    Iuml: 207,
+    Ntilde: 209,
+    Oacute: 211,
+    Ocirc: 212,
+    Ograve: 210,
+    Oslash: 216,
+    Otilde: 213,
+    Ouml: 214,
+    THORN: 222,
+    Uacute: 218,
+    Ucirc: 219,
+    Ugrave: 217,
+    Uuml: 220,
+    Yacute: 221,
+    aacute: 225,
+    acirc: 226,
+    aelig: 230,
+    agrave: 224,
+    aring: 229,
+    atilde: 227,
+    auml: 228,
+    ccedil: 231,
+    eacute: 233,
+    ecirc: 234,
+    egrave: 232,
+    eth: 240,
+    euml: 235,
+    iacute: 237,
+    icirc: 238,
+    igrave: 236,
+    iuml: 239,
+    ntilde: 241,
+    oacute: 243,
+    ocirc: 244,
+    ograve: 242,
+    oslash: 248,
+    otilde: 245,
+    ouml: 246,
+    szlig: 223,
+    thorn: 254,
+    uacute: 250,
+    ucirc: 251,
+    ugrave: 249,
+    uuml: 252,
+    yacute: 253,
+    yuml: 255,
+    copy: 169,
+    reg: 174,
+    nbsp: 160,
+    iexcl: 161,
+    cent: 162,
+    pound: 163,
+    curren: 164,
+    yen: 165,
+    brvbar: 166,
+    sect: 167,
+    uml: 168,
+    ordf: 170,
+    laquo: 171,
+    not: 172,
+    shy: 173,
+    macr: 175,
+    deg: 176,
+    plusmn: 177,
+    sup1: 185,
+    sup2: 178,
+    sup3: 179,
+    acute: 180,
+    micro: 181,
+    para: 182,
+    middot: 183,
+    cedil: 184,
+    ordm: 186,
+    raquo: 187,
+    frac14: 188,
+    frac12: 189,
+    frac34: 190,
+    iquest: 191,
+    times: 215,
+    divide: 247,
+    OElig: 338,
+    oelig: 339,
+    Scaron: 352,
+    scaron: 353,
+    Yuml: 376,
+    fnof: 402,
+    circ: 710,
+    tilde: 732,
+    Alpha: 913,
+    Beta: 914,
+    Gamma: 915,
+    Delta: 916,
+    Epsilon: 917,
+    Zeta: 918,
+    Eta: 919,
+    Theta: 920,
+    Iota: 921,
+    Kappa: 922,
+    Lambda: 923,
+    Mu: 924,
+    Nu: 925,
+    Xi: 926,
+    Omicron: 927,
+    Pi: 928,
+    Rho: 929,
+    Sigma: 931,
+    Tau: 932,
+    Upsilon: 933,
+    Phi: 934,
+    Chi: 935,
+    Psi: 936,
+    Omega: 937,
+    alpha: 945,
+    beta: 946,
+    gamma: 947,
+    delta: 948,
+    epsilon: 949,
+    zeta: 950,
+    eta: 951,
+    theta: 952,
+    iota: 953,
+    kappa: 954,
+    lambda: 955,
+    mu: 956,
+    nu: 957,
+    xi: 958,
+    omicron: 959,
+    pi: 960,
+    rho: 961,
+    sigmaf: 962,
+    sigma: 963,
+    tau: 964,
+    upsilon: 965,
+    phi: 966,
+    chi: 967,
+    psi: 968,
+    omega: 969,
+    thetasym: 977,
+    upsih: 978,
+    piv: 982,
+    ensp: 8194,
+    emsp: 8195,
+    thinsp: 8201,
+    zwnj: 8204,
+    zwj: 8205,
+    lrm: 8206,
+    rlm: 8207,
+    ndash: 8211,
+    mdash: 8212,
+    lsquo: 8216,
+    rsquo: 8217,
+    sbquo: 8218,
+    ldquo: 8220,
+    rdquo: 8221,
+    bdquo: 8222,
+    dagger: 8224,
+    Dagger: 8225,
+    bull: 8226,
+    hellip: 8230,
+    permil: 8240,
+    prime: 8242,
+    Prime: 8243,
+    lsaquo: 8249,
+    rsaquo: 8250,
+    oline: 8254,
+    frasl: 8260,
+    euro: 8364,
+    image: 8465,
+    weierp: 8472,
+    real: 8476,
+    trade: 8482,
+    alefsym: 8501,
+    larr: 8592,
+    uarr: 8593,
+    rarr: 8594,
+    darr: 8595,
+    harr: 8596,
+    crarr: 8629,
+    lArr: 8656,
+    uArr: 8657,
+    rArr: 8658,
+    dArr: 8659,
+    hArr: 8660,
+    forall: 8704,
+    part: 8706,
+    exist: 8707,
+    empty: 8709,
+    nabla: 8711,
+    isin: 8712,
+    notin: 8713,
+    ni: 8715,
+    prod: 8719,
+    sum: 8721,
+    minus: 8722,
+    lowast: 8727,
+    radic: 8730,
+    prop: 8733,
+    infin: 8734,
+    ang: 8736,
+    and: 8743,
+    or: 8744,
+    cap: 8745,
+    cup: 8746,
+    int: 8747,
+    there4: 8756,
+    sim: 8764,
+    cong: 8773,
+    asymp: 8776,
+    ne: 8800,
+    equiv: 8801,
+    le: 8804,
+    ge: 8805,
+    sub: 8834,
+    sup: 8835,
+    nsub: 8836,
+    sube: 8838,
+    supe: 8839,
+    oplus: 8853,
+    otimes: 8855,
+    perp: 8869,
+    sdot: 8901,
+    lceil: 8968,
+    rceil: 8969,
+    lfloor: 8970,
+    rfloor: 8971,
+    lang: 9001,
+    rang: 9002,
+    loz: 9674,
+    spades: 9824,
+    clubs: 9827,
+    hearts: 9829,
+    diams: 9830
+  };
+  Object.keys(ENTITIES).forEach((key) => {
+    const e = ENTITIES[key];
+    ENTITIES[key] = typeof e === "number" ? String.fromCharCode(e) : e;
+  });
+  var SAX = class {
+    EVENTS = EVENTS;
+    ENTITIES = {
+      // TODO: make it readonly, needed for entity-mega test
+      // amp, gt, lt, quot and apos are resolved to strings instead of numerical
+      // codes, IDK why
+      ...ENTITIES
+    };
+    XML_ENTITIES = {
+      amp: "&",
+      gt: ">",
+      lt: "<",
+      quot: '"',
+      apos: "'"
+    };
+    S = 0;
+    trackPosition = false;
+    column = 0;
+    line = 0;
+    c = "";
+    q = "";
+    closed = false;
+    tags = [];
+    looseCase = "";
+    closedRoot = false;
+    sawRoot = false;
+    strict = false;
+    noscript = false;
+    attribList = [];
+    position = 0;
+    STATE = {
+      BEGIN: this.S++,
+      // leading byte order mark or whitespace
+      BEGIN_WHITESPACE: this.S++,
+      // leading whitespace
+      TEXT: this.S++,
+      // general stuff
+      TEXT_ENTITY: this.S++,
+      // &amp and such.
+      OPEN_WAKA: this.S++,
+      // <
+      SGML_DECL: this.S++,
+      // <!BLARG
+      SGML_DECL_QUOTED: this.S++,
+      // <!BLARG foo "bar
+      DOCTYPE: this.S++,
+      // <!DOCTYPE
+      DOCTYPE_QUOTED: this.S++,
+      // <!DOCTYPE "//blah
+      DOCTYPE_DTD: this.S++,
+      // <!DOCTYPE "//blah" [ ...
+      DOCTYPE_DTD_QUOTED: this.S++,
+      // <!DOCTYPE "//blah" [ "foo
+      COMMENT_STARTING: this.S++,
+      // <!-
+      COMMENT: this.S++,
+      // <!--
+      COMMENT_ENDING: this.S++,
+      // <!-- blah -
+      COMMENT_ENDED: this.S++,
+      // <!-- blah --
+      CDATA: this.S++,
+      // <![CDATA[ something
+      CDATA_ENDING: this.S++,
+      // ]
+      CDATA_ENDING_2: this.S++,
+      // ]]
+      PROC_INST: this.S++,
+      // <?hi
+      PROC_INST_BODY: this.S++,
+      // <?hi there
+      PROC_INST_ENDING: this.S++,
+      // <?hi "there" ?
+      OPEN_TAG: this.S++,
+      // <strong
+      OPEN_TAG_SLASH: this.S++,
+      // <strong /
+      ATTRIB: this.S++,
+      // <a
+      ATTRIB_NAME: this.S++,
+      // <a foo
+      ATTRIB_NAME_SAW_WHITE: this.S++,
+      // <a foo _
+      ATTRIB_VALUE: this.S++,
+      // <a foo=
+      ATTRIB_VALUE_QUOTED: this.S++,
+      // <a foo="bar
+      ATTRIB_VALUE_CLOSED: this.S++,
+      // <a foo="bar"
+      ATTRIB_VALUE_UNQUOTED: this.S++,
+      // <a foo=bar
+      ATTRIB_VALUE_ENTITY_Q: this.S++,
+      // <foo bar="&quot;"
+      ATTRIB_VALUE_ENTITY_U: this.S++,
+      // <foo bar=&quot
+      CLOSE_TAG: this.S++,
+      // </a
+      CLOSE_TAG_SAW_WHITE: this.S++,
+      // </a   >
+      SCRIPT: this.S++,
+      // <script> ...
+      SCRIPT_ENDING: this.S++
+      // <script> ... <
+    };
+    BUFFERS = BUFFERS;
+    // private parser: (strict: boolean, opt: any) => SAXParser;
+    CDATA = "[CDATA[";
+    DOCTYPE = "DOCTYPE";
+    XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+    XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+    rootNS = {
+      xml: this.XML_NAMESPACE,
+      xmlns: this.XMLNS_NAMESPACE
+    };
+    textNode = "";
+    entity = "";
+    cdata = "";
+    script = "";
+    startTagPosition = 0;
+    constructor() {
+      this.S = 0;
+      for (const s in this.STATE) {
+        if (this.STATE.hasOwnProperty(s)) {
+          this.STATE[this.STATE[s]] = s;
+        }
+      }
+      this.S = this.STATE;
+    }
+    static charAt(chunk, i) {
+      let result = "";
+      if (i < chunk.length) {
+        result = chunk.charAt(i);
+      }
+      return result;
+    }
+    static isWhitespace(c) {
+      return c === " " || c === "\n" || c === "\r" || c === "	";
+    }
+    static isQuote(c) {
+      return c === '"' || c === "'";
+    }
+    static isAttribEnd(c) {
+      return c === ">" || SAX.isWhitespace(c);
+    }
+    static isMatch(regex, c) {
+      return regex.test(c);
+    }
+    static notMatch(regex, c) {
+      return !SAX.isMatch(regex, c);
+    }
+    static qname(name, attribute) {
+      const i = name.indexOf(":");
+      const qualName = i < 0 ? ["", name] : name.split(":");
+      let prefix = qualName[0];
+      let local = qualName[1];
+      if (attribute && name === "xmlns") {
+        prefix = "xmlns";
+        local = "";
+      }
+      return {
+        prefix,
+        local
+      };
+    }
+    write(chunk) {
+      if (this.error) {
+        throw this.error;
+      }
+      if (this.closed) {
+        return this.errorFunction("Cannot write after close. Assign an onready handler.");
+      }
+      if (chunk === null) {
+        return this.end();
+      }
+      if (typeof chunk === "object") {
+        chunk = chunk.toString();
+      }
+      let i = 0;
+      let c;
+      while (true) {
+        c = SAX.charAt(chunk, i++);
+        this.c = c;
+        if (!c) {
+          break;
+        }
+        if (this.trackPosition) {
+          this.position++;
+          if (c === "\n") {
+            this.line++;
+            this.column = 0;
+          } else {
+            this.column++;
+          }
+        }
+        switch (this.state) {
+          case this.S.BEGIN:
+            this.state = this.S.BEGIN_WHITESPACE;
+            if (c === "\uFEFF") {
+              continue;
+            }
+            this.beginWhiteSpace(c);
+            continue;
+          case this.S.BEGIN_WHITESPACE:
+            this.beginWhiteSpace(c);
+            continue;
+          case this.S.TEXT:
+            if (this.sawRoot && !this.closedRoot) {
+              const starti = i - 1;
+              while (c && c !== "<" && c !== "&") {
+                c = SAX.charAt(chunk, i++);
+                if (c && this.trackPosition) {
+                  this.position++;
+                  if (c === "\n") {
+                    this.line++;
+                    this.column = 0;
+                  } else {
+                    this.column++;
+                  }
+                }
+              }
+              this.textNode += chunk.substring(starti, i - 1);
+            }
+            if (c === "<" && !(this.sawRoot && this.closedRoot && !this.strict)) {
+              this.state = this.S.OPEN_WAKA;
+              this.startTagPosition = this.position;
+            } else {
+              if (!SAX.isWhitespace(c) && (!this.sawRoot || this.closedRoot)) {
+                this.strictFail("Text data outside of root node.");
+              }
+              if (c === "&") {
+                this.state = this.S.TEXT_ENTITY;
+              } else {
+                this.textNode += c;
+              }
+            }
+            continue;
+          case this.S.SCRIPT:
+            if (c === "<") {
+              this.state = this.S.SCRIPT_ENDING;
+            } else {
+              this.script += c;
+            }
+            continue;
+          case this.S.SCRIPT_ENDING:
+            if (c === "/") {
+              this.state = this.S.CLOSE_TAG;
+            } else {
+              this.script += `<${c}`;
+              this.state = this.S.SCRIPT;
+            }
+            continue;
+          case this.S.OPEN_WAKA:
+            if (c === "!") {
+              this.state = this.S.SGML_DECL;
+              this.sgmlDecl = "";
+            } else if (SAX.isWhitespace(c)) {
+            } else if (SAX.isMatch(nameStart, c)) {
+              this.state = this.S.OPEN_TAG;
+              this.tagName = c;
+            } else if (c === "/") {
+              this.state = this.S.CLOSE_TAG;
+              this.tagName = "";
+            } else if (c === "?") {
+              this.state = this.S.PROC_INST;
+              this.procInstName = this.procInstBody = "";
+            } else {
+              this.strictFail("Unencoded <");
+              if (this.startTagPosition + 1 < this.position) {
+                const pad = this.position - this.startTagPosition;
+                c = new Array(pad).join(" ") + c;
+              }
+              this.textNode += `<${c}`;
+              this.state = this.S.TEXT;
+            }
+            continue;
+          case this.S.SGML_DECL:
+            if ((this.sgmlDecl + c).toUpperCase() === this.CDATA) {
+              this.emitNode("onopencdata");
+              this.state = this.S.CDATA;
+              this.sgmlDecl = "";
+              this.cdata = "";
+            } else if (this.sgmlDecl + c === "--") {
+              this.state = this.S.COMMENT;
+              this.comment = "";
+              this.sgmlDecl = "";
+            } else if ((this.sgmlDecl + c).toUpperCase() === this.DOCTYPE) {
+              this.state = this.S.DOCTYPE;
+              if (this.doctype || this.sawRoot) {
+                this.strictFail("Inappropriately located doctype declaration");
+              }
+              this.doctype = "";
+              this.sgmlDecl = "";
+            } else if (c === ">") {
+              this.emitNode("onsgmldeclaration", this.sgmlDecl);
+              this.sgmlDecl = "";
+              this.state = this.S.TEXT;
+            } else if (SAX.isQuote(c)) {
+              this.state = this.S.SGML_DECL_QUOTED;
+              this.sgmlDecl += c;
+            } else {
+              this.sgmlDecl += c;
+            }
+            continue;
+          case this.S.SGML_DECL_QUOTED:
+            if (c === this.q) {
+              this.state = this.S.SGML_DECL;
+              this.q = "";
+            }
+            this.sgmlDecl += c;
+            continue;
+          case this.S.DOCTYPE:
+            if (c === ">") {
+              this.state = this.S.TEXT;
+              this.emitNode("ondoctype", this.doctype);
+              this.doctype = true;
+            } else {
+              this.doctype += c;
+              if (c === "[") {
+                this.state = this.S.DOCTYPE_DTD;
+              } else if (SAX.isQuote(c)) {
+                this.state = this.S.DOCTYPE_QUOTED;
+                this.q = c;
+              }
+            }
+            continue;
+          case this.S.DOCTYPE_QUOTED:
+            this.doctype += c;
+            if (c === this.q) {
+              this.q = "";
+              this.state = this.S.DOCTYPE;
+            }
+            continue;
+          case this.S.DOCTYPE_DTD:
+            this.doctype += c;
+            if (c === "]") {
+              this.state = this.S.DOCTYPE;
+            } else if (SAX.isQuote(c)) {
+              this.state = this.S.DOCTYPE_DTD_QUOTED;
+              this.q = c;
+            }
+            continue;
+          case this.S.DOCTYPE_DTD_QUOTED:
+            this.doctype += c;
+            if (c === this.q) {
+              this.state = this.S.DOCTYPE_DTD;
+              this.q = "";
+            }
+            continue;
+          case this.S.COMMENT:
+            if (c === "-") {
+              this.state = this.S.COMMENT_ENDING;
+            } else {
+              this.comment += c;
+            }
+            continue;
+          case this.S.COMMENT_ENDING:
+            if (c === "-") {
+              this.state = this.S.COMMENT_ENDED;
+              this.comment = this.textApplyOptions(this.comment);
+              if (this.comment) {
+                this.emitNode("oncomment", this.comment);
+              }
+              this.comment = "";
+            } else {
+              this.comment += `-${c}`;
+              this.state = this.S.COMMENT;
+            }
+            continue;
+          case this.S.COMMENT_ENDED:
+            if (c !== ">") {
+              this.strictFail("Malformed comment");
+              this.comment += `--${c}`;
+              this.state = this.S.COMMENT;
+            } else {
+              this.state = this.S.TEXT;
+            }
+            continue;
+          case this.S.CDATA:
+            if (c === "]") {
+              this.state = this.S.CDATA_ENDING;
+            } else {
+              this.cdata += c;
+            }
+            continue;
+          case this.S.CDATA_ENDING:
+            if (c === "]") {
+              this.state = this.S.CDATA_ENDING_2;
+            } else {
+              this.cdata += `]${c}`;
+              this.state = this.S.CDATA;
+            }
+            continue;
+          case this.S.CDATA_ENDING_2:
+            if (c === ">") {
+              if (this.cdata) {
+                this.emitNode("oncdata", this.cdata);
+              }
+              this.emitNode("onclosecdata");
+              this.cdata = "";
+              this.state = this.S.TEXT;
+            } else if (c === "]") {
+              this.cdata += "]";
+            } else {
+              this.cdata += `]]${c}`;
+              this.state = this.S.CDATA;
+            }
+            continue;
+          case this.S.PROC_INST:
+            if (c === "?") {
+              this.state = this.S.PROC_INST_ENDING;
+            } else if (SAX.isWhitespace(c)) {
+              this.state = this.S.PROC_INST_BODY;
+            } else {
+              this.procInstName += c;
+            }
+            continue;
+          case this.S.PROC_INST_BODY:
+            if (!this.procInstBody && SAX.isWhitespace(c)) {
+              continue;
+            } else if (c === "?") {
+              this.state = this.S.PROC_INST_ENDING;
+            } else {
+              this.procInstBody += c;
+            }
+            continue;
+          case this.S.PROC_INST_ENDING:
+            if (c === ">") {
+              this.emitNode("onprocessinginstruction", {
+                name: this.procInstName,
+                body: this.procInstBody
+              });
+              this.procInstName = this.procInstBody = "";
+              this.state = this.S.TEXT;
+            } else {
+              this.procInstBody += `?${c}`;
+              this.state = this.S.PROC_INST_BODY;
+            }
+            continue;
+          case this.S.OPEN_TAG:
+            if (SAX.isMatch(nameBody, c)) {
+              this.tagName += c;
+            } else {
+              this.newTag();
+              if (c === ">") {
+                this.openTag();
+              } else if (c === "/") {
+                this.state = this.S.OPEN_TAG_SLASH;
+              } else {
+                if (!SAX.isWhitespace(c)) {
+                  this.strictFail("Invalid character in tag name");
+                }
+                this.state = this.S.ATTRIB;
+              }
+            }
+            continue;
+          case this.S.OPEN_TAG_SLASH:
+            if (c === ">") {
+              this.openTag(true);
+              this.closeTag();
+            } else {
+              this.strictFail("Forward-slash in opening tag not followed by >");
+              this.state = this.S.ATTRIB;
+            }
+            continue;
+          case this.S.ATTRIB:
+            if (SAX.isWhitespace(c)) {
+              continue;
+            } else if (c === ">") {
+              this.openTag();
+            } else if (c === "/") {
+              this.state = this.S.OPEN_TAG_SLASH;
+            } else if (SAX.isMatch(nameStart, c)) {
+              this.attribName = c;
+              this.attribValue = "";
+              this.state = this.S.ATTRIB_NAME;
+            } else {
+              this.strictFail("Invalid attribute name");
+            }
+            continue;
+          case this.S.ATTRIB_NAME:
+            if (c === "=") {
+              this.state = this.S.ATTRIB_VALUE;
+            } else if (c === ">") {
+              this.strictFail("Attribute without value");
+              this.attribValue = this.attribName;
+              this.attrib();
+              this.openTag();
+            } else if (SAX.isWhitespace(c)) {
+              this.state = this.S.ATTRIB_NAME_SAW_WHITE;
+            } else if (SAX.isMatch(nameBody, c)) {
+              this.attribName += c;
+            } else {
+              this.strictFail("Invalid attribute name");
+            }
+            continue;
+          case this.S.ATTRIB_NAME_SAW_WHITE:
+            if (c === "=") {
+              this.state = this.S.ATTRIB_VALUE;
+            } else if (SAX.isWhitespace(c)) {
+              continue;
+            } else {
+              this.strictFail("Attribute without value");
+              this.tag.attributes[this.attribName] = "";
+              this.attribValue = "";
+              this.emitNode("onattribute", {
+                name: this.attribName,
+                value: ""
+              });
+              this.attribName = "";
+              if (c === ">") {
+                this.openTag();
+              } else if (SAX.isMatch(nameStart, c)) {
+                this.attribName = c;
+                this.state = this.S.ATTRIB_NAME;
+              } else {
+                this.strictFail("Invalid attribute name");
+                this.state = this.S.ATTRIB;
+              }
+            }
+            continue;
+          case this.S.ATTRIB_VALUE:
+            if (SAX.isWhitespace(c)) {
+              continue;
+            } else if (SAX.isQuote(c)) {
+              this.q = c;
+              this.state = this.S.ATTRIB_VALUE_QUOTED;
+            } else {
+              this.strictFail("Unquoted attribute value");
+              this.state = this.S.ATTRIB_VALUE_UNQUOTED;
+              this.attribValue = c;
+            }
+            continue;
+          case this.S.ATTRIB_VALUE_QUOTED:
+            if (c !== this.q) {
+              if (c === "&") {
+                this.state = this.S.ATTRIB_VALUE_ENTITY_Q;
+              } else {
+                this.attribValue += c;
+              }
+              continue;
+            }
+            this.attrib();
+            this.q = "";
+            this.state = this.S.ATTRIB_VALUE_CLOSED;
+            continue;
+          case this.S.ATTRIB_VALUE_CLOSED:
+            if (SAX.isWhitespace(c)) {
+              this.state = this.S.ATTRIB;
+            } else if (c === ">") {
+              this.openTag();
+            } else if (c === "/") {
+              this.state = this.S.OPEN_TAG_SLASH;
+            } else if (SAX.isMatch(nameStart, c)) {
+              this.strictFail("No whitespace between attributes");
+              this.attribName = c;
+              this.attribValue = "";
+              this.state = this.S.ATTRIB_NAME;
+            } else {
+              this.strictFail("Invalid attribute name");
+            }
+            continue;
+          case this.S.ATTRIB_VALUE_UNQUOTED:
+            if (!SAX.isAttribEnd(c)) {
+              if (c === "&") {
+                this.state = this.S.ATTRIB_VALUE_ENTITY_U;
+              } else {
+                this.attribValue += c;
+              }
+              continue;
+            }
+            this.attrib();
+            if (c === ">") {
+              this.openTag();
+            } else {
+              this.state = this.S.ATTRIB;
+            }
+            continue;
+          case this.S.CLOSE_TAG:
+            if (!this.tagName) {
+              if (SAX.isWhitespace(c)) {
+                continue;
+              } else if (SAX.notMatch(nameStart, c)) {
+                if (this.script) {
+                  this.script += `</${c}`;
+                  this.state = this.S.SCRIPT;
+                } else {
+                  this.strictFail("Invalid tagname in closing tag.");
                 }
               } else {
-                listTagVal += this.buildTextValNode(item, key, "", level);
+                this.tagName = c;
+              }
+            } else if (c === ">") {
+              this.closeTag();
+            } else if (SAX.isMatch(nameBody, c)) {
+              this.tagName += c;
+            } else if (this.script) {
+              this.script += `</${this.tagName}`;
+              this.tagName = "";
+              this.state = this.S.SCRIPT;
+            } else {
+              if (!SAX.isWhitespace(c)) {
+                this.strictFail("Invalid tagname in closing tag");
               }
+              this.state = this.S.CLOSE_TAG_SAW_WHITE;
             }
-            if (this.options.oneListGroup) {
-              listTagVal = this.buildObjectNode(listTagVal, key, "", level);
+            continue;
+          case this.S.CLOSE_TAG_SAW_WHITE:
+            if (SAX.isWhitespace(c)) {
+              continue;
             }
-            val2 += listTagVal;
-          } else {
-            if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
-              const Ks = Object.keys(jObj[key]);
-              const L = Ks.length;
-              for (let j = 0; j < L; j++) {
-                attrStr += this.buildAttrPairStr(Ks[j], "" + jObj[key][Ks[j]]);
-              }
+            if (c === ">") {
+              this.closeTag();
             } else {
-              val2 += this.processTextOrObjNode(jObj[key], key, level);
+              this.strictFail("Invalid characters in closing tag");
+            }
+            continue;
+          case this.S.TEXT_ENTITY:
+          case this.S.ATTRIB_VALUE_ENTITY_Q:
+          case this.S.ATTRIB_VALUE_ENTITY_U:
+            let returnState;
+            let buffer;
+            switch (this.state) {
+              case this.S.TEXT_ENTITY:
+                returnState = this.S.TEXT;
+                buffer = "textNode";
+                break;
+              case this.S.ATTRIB_VALUE_ENTITY_Q:
+                returnState = this.S.ATTRIB_VALUE_QUOTED;
+                buffer = "attribValue";
+                break;
+              case this.S.ATTRIB_VALUE_ENTITY_U:
+                returnState = this.S.ATTRIB_VALUE_UNQUOTED;
+                buffer = "attribValue";
+                break;
+              default:
+                throw new Error(`Unknown state: ${this.state}`);
+            }
+            if (c === ";") {
+              this[buffer] += this.parseEntity();
+              this.entity = "";
+              this.state = returnState;
+            } else if (SAX.isMatch(this.entity.length ? entityBody : entityStart, c)) {
+              this.entity += c;
+            } else {
+              this.strictFail("Invalid character in entity name");
+              this[buffer] += `&${this.entity}${c}`;
+              this.entity = "";
+              this.state = returnState;
+            }
+            continue;
+          default:
+            throw new Error(`Unknown state: ${this.state}`);
+        }
+      }
+      if (this.position >= this.bufferCheckPosition) {
+        this.checkBufferLength();
+      }
+      return this;
+    }
+    emit(event, data) {
+      if (this.events.hasOwnProperty(event)) {
+        const eventName = event.replace(/^on/, "");
+        this.events[event](data, eventName, this);
+      }
+    }
+    clearBuffers() {
+      for (let i = 0, l = this.BUFFERS.length; i < l; i++) {
+        this[this[i]] = "";
+      }
+    }
+    flushBuffers() {
+      this.closeText();
+      if (this.cdata !== "") {
+        this.emitNode("oncdata", this.cdata);
+        this.cdata = "";
+      }
+      if (this.script !== "") {
+        this.emitNode("onscript", this.script);
+        this.script = "";
+      }
+    }
+    end() {
+      if (this.sawRoot && !this.closedRoot)
+        this.strictFail("Unclosed root tag");
+      if (this.state !== this.S.BEGIN && this.state !== this.S.BEGIN_WHITESPACE && this.state !== this.S.TEXT) {
+        this.errorFunction("Unexpected end");
+      }
+      this.closeText();
+      this.c = "";
+      this.closed = true;
+      this.emit("onend");
+      return new SAXParser(this.opt);
+    }
+    errorFunction(er) {
+      this.closeText();
+      if (this.trackPosition) {
+        er += `
+Line: ${this.line}
+Column: ${this.column}
+Char: ${this.c}`;
+      }
+      const error = new Error(er);
+      this.error = error;
+      this.emit("onerror", error);
+      return this;
+    }
+    attrib() {
+      if (!this.strict) {
+        this.attribName = this.attribName[this.looseCase]();
+      }
+      if (this.attribList.indexOf(this.attribName) !== -1 || this.tag.attributes.hasOwnProperty(this.attribName)) {
+        this.attribName = this.attribValue = "";
+        return;
+      }
+      if (this.opt.xmlns) {
+        const qn = SAX.qname(this.attribName, true);
+        const prefix = qn.prefix;
+        const local = qn.local;
+        if (prefix === "xmlns") {
+          if (local === "xml" && this.attribValue !== this.XML_NAMESPACE) {
+            this.strictFail(`xml: prefix must be bound to ${this.XML_NAMESPACE}
+Actual: ${this.attribValue}`);
+          } else if (local === "xmlns" && this.attribValue !== this.XMLNS_NAMESPACE) {
+            this.strictFail(`xmlns: prefix must be bound to ${this.XMLNS_NAMESPACE}
+Actual: ${this.attribValue}`);
+          } else {
+            const tag = this.tag;
+            const parent = this.tags[this.tags.length - 1] || this;
+            if (tag.ns === parent.ns) {
+              tag.ns = Object.create(parent.ns);
             }
+            tag.ns[local] = this.attribValue;
           }
         }
-        return { attrStr, val: val2 };
-      };
-      Builder.prototype.buildAttrPairStr = function(attrName, val2) {
-        val2 = this.options.attributeValueProcessor(attrName, "" + val2);
-        val2 = this.replaceEntitiesValue(val2);
-        if (this.options.suppressBooleanAttributes && val2 === "true") {
-          return " " + attrName;
-        } else
-          return " " + attrName + '="' + val2 + '"';
+        this.attribList.push([this.attribName, this.attribValue]);
+      } else {
+        this.tag.attributes[this.attribName] = this.attribValue;
+        this.emitNode("onattribute", {
+          name: this.attribName,
+          value: this.attribValue
+        });
+      }
+      this.attribName = this.attribValue = "";
+    }
+    newTag() {
+      if (!this.strict)
+        this.tagName = this.tagName[this.looseCase]();
+      const parent = this.tags[this.tags.length - 1] || this;
+      const tag = this.tag = {
+        name: this.tagName,
+        attributes: {}
       };
-      function processTextOrObjNode(object, key, level) {
-        const result = this.j2x(object, level + 1);
-        if (object[this.options.textNodeName] !== void 0 && Object.keys(object).length === 1) {
-          return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level);
+      if (this.opt.xmlns) {
+        tag.ns = parent.ns;
+      }
+      this.attribList.length = 0;
+      this.emitNode("onopentagstart", tag);
+    }
+    parseEntity() {
+      let entity = this.entity;
+      const entityLC = entity.toLowerCase();
+      let num = NaN;
+      let numStr = "";
+      if (this.ENTITIES[entity]) {
+        return this.ENTITIES[entity];
+      }
+      if (this.ENTITIES[entityLC]) {
+        return this.ENTITIES[entityLC];
+      }
+      entity = entityLC;
+      if (entity.charAt(0) === "#") {
+        if (entity.charAt(1) === "x") {
+          entity = entity.slice(2);
+          num = parseInt(entity, 16);
+          numStr = num.toString(16);
         } else {
-          return this.buildObjectNode(result.val, key, result.attrStr, level);
+          entity = entity.slice(1);
+          num = parseInt(entity, 10);
+          numStr = num.toString(10);
         }
       }
-      Builder.prototype.buildObjectNode = function(val2, key, attrStr, level) {
-        if (val2 === "") {
-          if (key[0] === "?")
-            return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
-          else {
-            return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
-          }
-        } else {
-          let tagEndExp = "</" + key + this.tagEndChar;
-          let piClosingChar = "";
-          if (key[0] === "?") {
-            piClosingChar = "?";
-            tagEndExp = "";
+      entity = entity.replace(/^0+/, "");
+      if (isNaN(num) || numStr.toLowerCase() !== entity) {
+        this.strictFail("Invalid character entity");
+        return `&${this.entity};`;
+      }
+      return String.fromCodePoint(num);
+    }
+    beginWhiteSpace(c) {
+      if (c === "<") {
+        this.state = this.S.OPEN_WAKA;
+        this.startTagPosition = this.position;
+      } else if (!SAX.isWhitespace(c)) {
+        this.strictFail("Non-whitespace before first tag.");
+        this.textNode = c;
+        this.state = this.S.TEXT;
+      } else {
+      }
+    }
+    strictFail(message) {
+      if (typeof this !== "object" || !(this instanceof SAXParser)) {
+        throw new Error("bad call to strictFail");
+      }
+      if (this.strict) {
+        this.errorFunction(message);
+      }
+    }
+    textApplyOptions(text) {
+      if (this.opt.trim)
+        text = text.trim();
+      if (this.opt.normalize)
+        text = text.replace(/\s+/g, " ");
+      return text;
+    }
+    emitNode(nodeType, data) {
+      if (this.textNode)
+        this.closeText();
+      this.emit(nodeType, data);
+    }
+    closeText() {
+      this.textNode = this.textApplyOptions(this.textNode);
+      if (this.textNode !== void 0 && this.textNode !== "" && this.textNode !== "undefined") {
+        this.emit("ontext", this.textNode);
+      }
+      this.textNode = "";
+    }
+    checkBufferLength() {
+      const maxAllowed = Math.max(this.opt.MAX_BUFFER_LENGTH, 10);
+      let maxActual = 0;
+      for (let i = 0, l = this.BUFFERS.length; i < l; i++) {
+        const len = this[this.BUFFERS[i]]?.length || 0;
+        if (len > maxAllowed) {
+          switch (this.BUFFERS[i]) {
+            case "textNode":
+              this.closeText();
+              break;
+            case "cdata":
+              this.emitNode("oncdata", this.cdata);
+              this.cdata = "";
+              break;
+            case "script":
+              this.emitNode("onscript", this.script);
+              this.script = "";
+              break;
+            default:
+              this.errorFunction(`Max buffer length exceeded: ${this.BUFFERS[i]}`);
           }
-          if (attrStr && val2.indexOf("<") === -1) {
-            return this.indentate(level) + "<" + key + attrStr + piClosingChar + ">" + val2 + tagEndExp;
-          } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {
-            return this.indentate(level) + `<!--${val2}-->` + this.newLine;
-          } else {
-            return this.indentate(level) + "<" + key + attrStr + piClosingChar + this.tagEndChar + val2 + this.indentate(level) + tagEndExp;
+        }
+        maxActual = Math.max(maxActual, len);
+      }
+      const m = this.opt.MAX_BUFFER_LENGTH - maxActual;
+      this.bufferCheckPosition = m + this.position;
+    }
+    openTag(selfClosing) {
+      if (this.opt.xmlns) {
+        const tag = this.tag;
+        const qn = SAX.qname(this.tagName);
+        tag.prefix = qn.prefix;
+        tag.local = qn.local;
+        tag.uri = tag.ns[qn.prefix] || "";
+        if (tag.prefix && !tag.uri) {
+          this.strictFail(`Unbound namespace prefix: ${JSON.stringify(this.tagName)}`);
+          tag.uri = qn.prefix;
+        }
+        const parent = this.tags[this.tags.length - 1] || this;
+        if (tag.ns && parent.ns !== tag.ns) {
+          const that = this;
+          Object.keys(tag.ns).forEach((p) => {
+            that.emitNode("onopennamespace", {
+              prefix: p,
+              uri: tag.ns[p]
+            });
+          });
+        }
+        for (let i = 0, l = this.attribList.length; i < l; i++) {
+          const nv = this.attribList[i];
+          const name = nv[0];
+          const value = nv[1];
+          const qualName = SAX.qname(name, true);
+          const prefix = qualName.prefix;
+          const local = qualName.local;
+          const uri = prefix === "" ? "" : tag.ns[prefix] || "";
+          const a = {
+            name,
+            value,
+            prefix,
+            local,
+            uri
+          };
+          if (prefix && prefix !== "xmlns" && !uri) {
+            this.strictFail(`Unbound namespace prefix: ${JSON.stringify(prefix)}`);
+            a.uri = prefix;
           }
+          this.tag.attributes[name] = a;
+          this.emitNode("onattribute", a);
         }
-      };
-      Builder.prototype.closeTag = function(key) {
-        let closeTag = "";
-        if (this.options.unpairedTags.indexOf(key) !== -1) {
-          if (!this.options.suppressUnpairedNode)
-            closeTag = "/";
-        } else if (this.options.suppressEmptyNode) {
-          closeTag = "/";
+        this.attribList.length = 0;
+      }
+      this.tag.isSelfClosing = Boolean(selfClosing);
+      this.sawRoot = true;
+      this.tags.push(this.tag);
+      this.emitNode("onopentag", this.tag);
+      if (!selfClosing) {
+        if (!this.noscript && this.tagName.toLowerCase() === "script") {
+          this.state = this.S.SCRIPT;
         } else {
-          closeTag = `></${key}`;
+          this.state = this.S.TEXT;
         }
-        return closeTag;
-      };
-      Builder.prototype.buildTextValNode = function(val2, key, attrStr, level) {
-        if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
-          return this.indentate(level) + `<![CDATA[${val2}]]>` + this.newLine;
-        } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
-          return this.indentate(level) + `<!--${val2}-->` + this.newLine;
-        } else if (key[0] === "?") {
-          return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
+        this.tag = null;
+        this.tagName = "";
+      }
+      this.attribName = this.attribValue = "";
+      this.attribList.length = 0;
+    }
+    closeTag() {
+      if (!this.tagName) {
+        this.strictFail("Weird empty close tag.");
+        this.textNode += "</>";
+        this.state = this.S.TEXT;
+        return;
+      }
+      if (this.script) {
+        if (this.tagName !== "script") {
+          this.script += `</${this.tagName}>`;
+          this.tagName = "";
+          this.state = this.S.SCRIPT;
+          return;
+        }
+        this.emitNode("onscript", this.script);
+        this.script = "";
+      }
+      let t = this.tags.length;
+      let tagName = this.tagName;
+      if (!this.strict) {
+        tagName = tagName[this.looseCase]();
+      }
+      while (t--) {
+        const close = this.tags[t];
+        if (close.name !== tagName) {
+          this.strictFail("Unexpected close tag");
         } else {
-          let textValue = this.options.tagValueProcessor(key, val2);
-          textValue = this.replaceEntitiesValue(textValue);
-          if (textValue === "") {
-            return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
-          } else {
-            return this.indentate(level) + "<" + key + attrStr + ">" + textValue + "</" + key + this.tagEndChar;
-          }
+          break;
         }
-      };
-      Builder.prototype.replaceEntitiesValue = function(textValue) {
-        if (textValue && textValue.length > 0 && this.options.processEntities) {
-          for (let i = 0; i < this.options.entities.length; i++) {
-            const entity = this.options.entities[i];
-            textValue = textValue.replace(entity.regex, entity.val);
-          }
+      }
+      if (t < 0) {
+        this.strictFail(`Unmatched closing tag: ${this.tagName}`);
+        this.textNode += `</${this.tagName}>`;
+        this.state = this.S.TEXT;
+        return;
+      }
+      this.tagName = tagName;
+      let s = this.tags.length;
+      while (s-- > t) {
+        const tag = this.tag = this.tags.pop();
+        this.tagName = this.tag.name;
+        this.emitNode("onclosetag", this.tagName);
+        const x = {};
+        for (const i in tag.ns) {
+          if (tag.ns.hasOwnProperty(i)) {
+            x[i] = tag.ns[i];
+          }
+        }
+        const parent = this.tags[this.tags.length - 1] || this;
+        if (this.opt.xmlns && tag.ns !== parent.ns) {
+          const that = this;
+          Object.keys(tag.ns).forEach((p) => {
+            const n = tag.ns[p];
+            that.emitNode("onclosenamespace", {
+              prefix: p,
+              uri: n
+            });
+          });
         }
-        return textValue;
+      }
+      if (t === 0)
+        this.closedRoot = true;
+      this.tagName = this.attribValue = this.attribName = "";
+      this.attribList.length = 0;
+      this.state = this.S.TEXT;
+    }
+  };
+  var SAXParser = class extends SAX {
+    opt = DEFAULT_SAX_PARSER_OPTIONS;
+    events = DEFAULT_SAX_EVENTS;
+    constructor(opt) {
+      super();
+      this.clearBuffers();
+      this.opt = opt = {
+        ...this.opt,
+        ...opt
       };
-      function indentate(level) {
-        return this.options.indentBy.repeat(level);
+      this.events = {
+        ...this.events,
+        ...opt
+      };
+      this.q = this.c = "";
+      this.opt.lowercase = this.opt.lowercase || this.opt.lowercasetags;
+      this.bufferCheckPosition = this.opt.MAX_BUFFER_LENGTH;
+      this.looseCase = this.opt.lowercase ? "toLowerCase" : "toUpperCase";
+      this.tags = [];
+      this.closed = this.closedRoot = this.sawRoot = false;
+      this.tag = this.error = null;
+      this.strict = Boolean(this.opt.strict);
+      this.noscript = Boolean(this.opt.strict || this.opt.noscript);
+      this.state = this.S.BEGIN;
+      this.strictEntities = this.opt.strictEntities;
+      this.ENTITIES = this.strictEntities ? Object.create(this.XML_ENTITIES) : Object.create(this.ENTITIES);
+      this.attribList = [];
+      if (this.opt.xmlns) {
+        this.ns = Object.create(this.rootNS);
       }
-      function isAttribute(name) {
-        if (name.startsWith(this.options.attributeNamePrefix)) {
-          return name.substr(this.attrPrefixLen);
-        } else {
-          return false;
-        }
+      this.trackPosition = this.opt.position !== false;
+      if (this.trackPosition) {
+        this.position = this.line = this.column = 0;
       }
-      module.exports = Builder;
+      this.emit("onready");
     }
-  });
+    resume() {
+      this.error = null;
+      return this;
+    }
+    close() {
+      return this.write(null);
+    }
+    flush() {
+      this.flushBuffers();
+    }
+  };
+  __publicField(SAXParser, "ENTITIES", ENTITIES);
 
-  // ../../node_modules/fast-xml-parser/src/fxp.js
-  var require_fxp = __commonJS({
-    "../../node_modules/fast-xml-parser/src/fxp.js"(exports, module) {
-      "use strict";
-      var validator = require_validator();
-      var XMLParser = require_XMLParser();
-      var XMLBuilder = require_json2xml();
-      module.exports = {
-        XMLParser,
-        XMLValidator: validator,
-        XMLBuilder
-      };
+  // src/lib/xml-utils/uncapitalize.ts
+  function uncapitalize(str) {
+    return typeof str === "string" ? str.charAt(0).toLowerCase() + str.slice(1) : str;
+  }
+  function uncapitalizeKeys(object) {
+    if (Array.isArray(object)) {
+      return object.map((element) => uncapitalizeKeys(element));
     }
-  });
+    if (object && typeof object === "object") {
+      const newObject = {};
+      for (const [key, value] of Object.entries(object)) {
+        newObject[uncapitalize(key)] = uncapitalizeKeys(value);
+      }
+      return newObject;
+    }
+    return object;
+  }
 
   // src/lib/parsers/parse-xml.ts
+  var import_fast_xml_parser = __toESM(require_fxp(), 1);
   function parseXMLSync(text, options) {
     if (options?._parser && options._parser !== "fast-xml-parser") {
       throw new Error(options?._parser);
     }
     const fastXMLOptions = {
+      // Default FastXML options
+      // https://github.com/NaturalIntelligence/fast-xml-parser/blob/master/docs/v4/2.XMLparseOptions.md#allowbooleanattributes
       allowBooleanAttributes: true,
+      // https://github.com/NaturalIntelligence/fast-xml-parser/blob/master/docs/v4/2.XMLparseOptions.md#ignoredeclaration
       ignoreDeclaration: true,
+      // https://github.com/NaturalIntelligence/fast-xml-parser/blob/master/docs/v4/2.XMLparseOptions.md#removensprefix
       removeNSPrefix: options?.removeNSPrefix,
+      // https://github.com/NaturalIntelligence/fast-xml-parser/blob/master/docs/v4/2.XMLparseOptions.md#textnodename
       textNodeName: options?.textNodeName,
+      // Let's application specify keys that are always arrays
       isArray: (name, jpath, isLeafNode, isAttribute) => {
         const array = Boolean(options?.arrayPaths?.some((path) => jpath === path));
         return array;
       },
+      // Application overrides
       ...options?._fastXML
     };
     const xml = fastParseXML(text, fastXMLOptions);
@@ -3045,56 +3202,48 @@ Actual: ${this.attribValue}`);
     const parsedXML = parser.parse(text);
     return parsedXML;
   }
-  var import_fast_xml_parser;
-  var init_parse_xml = __esm({
-    "src/lib/parsers/parse-xml.ts"() {
-      init_uncapitalize();
-      import_fast_xml_parser = __toModule(require_fxp());
-    }
-  });
 
   // src/xml-loader.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var XMLLoader = {
+    name: "XML",
+    id: "xml",
+    module: "xml",
+    version: VERSION,
+    worker: false,
+    extensions: ["xml"],
+    mimeTypes: ["application/xml", "text/xml"],
+    testText: testXMLFile,
+    options: {
+      xml: {
+        _parser: "fast-xml-parser",
+        uncapitalizeKeys: false,
+        removeNSPrefix: false,
+        textNodeName: "value",
+        arrayPaths: []
+      }
+    },
+    parse: async (arrayBuffer, options) => parseXMLSync(new TextDecoder().decode(arrayBuffer), {
+      ...XMLLoader.options.xml,
+      ...options?.xml
+    }),
+    parseTextSync: (text, options) => parseXMLSync(text, {
+      ...XMLLoader.options.xml,
+      ...options?.xml
+    })
+  };
   function testXMLFile(text) {
     return text.startsWith("<?xml");
   }
-  var VERSION, XMLLoader;
-  var init_xml_loader = __esm({
-    "src/xml-loader.ts"() {
-      init_parse_xml();
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      XMLLoader = {
-        name: "XML",
-        id: "xml",
-        module: "xml",
-        version: VERSION,
-        worker: false,
-        extensions: ["xml"],
-        mimeTypes: ["application/xml", "text/xml"],
-        testText: testXMLFile,
-        options: {
-          xml: {
-            _parser: "fast-xml-parser",
-            uncapitalizeKeys: false,
-            removeNSPrefix: false,
-            textNodeName: "value",
-            arrayPaths: []
-          }
-        },
-        parse: async (arrayBuffer, options) => parseXMLSync(new TextDecoder().decode(arrayBuffer), {
-          ...XMLLoader.options.xml,
-          ...options?.xml
-        }),
-        parseTextSync: (text, options) => parseXMLSync(text, { ...XMLLoader.options.xml, ...options?.xml })
-      };
-    }
-  });
 
   // ../loader-utils/src/lib/option-utils/merge-loader-options.ts
   function mergeLoaderOptions(baseOptions, newOptions) {
     return mergeOptionsRecursively(baseOptions || {}, newOptions);
   }
   function mergeOptionsRecursively(baseOptions, newOptions) {
-    const options = { ...baseOptions };
+    const options = {
+      ...baseOptions
+    };
     for (const [key, newValue] of Object.entries(newOptions)) {
       if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
         options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key]);
@@ -3104,19 +3253,18 @@ Actual: ${this.attribValue}`);
     }
     return options;
   }
-  var init_merge_loader_options = __esm({
-    "../loader-utils/src/lib/option-utils/merge-loader-options.ts"() {
-    }
-  });
-
-  // ../loader-utils/src/index.ts
-  var init_src = __esm({
-    "../loader-utils/src/index.ts"() {
-      init_merge_loader_options();
-    }
-  });
 
   // src/html-loader.ts
+  var HTMLLoader = {
+    ...XMLLoader,
+    name: "HTML",
+    id: "html",
+    extensions: ["html", "htm"],
+    mimeTypes: ["text/html"],
+    testText: testHTMLFile,
+    parse: async (arrayBuffer, options) => parseTextSync(new TextDecoder().decode(arrayBuffer), options),
+    parseTextSync: (text, options) => parseTextSync(text, options)
+  };
   function testHTMLFile(text) {
     return text.startsWith("<html");
   }
@@ -3131,23 +3279,6 @@ Actual: ${this.attribValue}`);
     });
     return XMLLoader.parseTextSync?.(text, options);
   }
-  var HTMLLoader;
-  var init_html_loader = __esm({
-    "src/html-loader.ts"() {
-      init_src();
-      init_xml_loader();
-      HTMLLoader = {
-        ...XMLLoader,
-        name: "HTML",
-        id: "html",
-        extensions: ["html", "htm"],
-        mimeTypes: ["text/html"],
-        testText: testHTMLFile,
-        parse: async (arrayBuffer, options) => parseTextSync(new TextDecoder().decode(arrayBuffer), options),
-        parseTextSync: (text, options) => parseTextSync(text, options)
-      };
-    }
-  });
 
   // src/lib/xml-utils/xml-utils.ts
   function convertXMLValueToArray(xmlValue) {
@@ -3164,39 +3295,7 @@ Actual: ${this.attribValue}`);
   function convertXMLFieldToArrayInPlace(xml, key) {
     xml[key] = convertXMLValueToArray(xml[key]);
   }
-  var init_xml_utils = __esm({
-    "src/lib/xml-utils/xml-utils.ts"() {
-    }
-  });
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    HTMLLoader: () => HTMLLoader,
-    SAXParser: () => SAXParser,
-    XMLLoader: () => XMLLoader,
-    _uncapitalize: () => uncapitalize,
-    _uncapitalizeKeys: () => uncapitalizeKeys,
-    convertXMLFieldToArrayInPlace: () => convertXMLFieldToArrayInPlace,
-    convertXMLValueToArray: () => convertXMLValueToArray
-  });
-  var init_src2 = __esm({
-    "src/index.ts"() {
-      init_xml_loader();
-      init_html_loader();
-      init_sax();
-      init_xml_utils();
-      init_uncapitalize();
-    }
-  });
-
-  // src/bundle.ts
-  var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src2(), src_exports);
-      globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
-    }
-  });
-  require_bundle();
+  return __toCommonJS(src_exports);
 })();
+      return __exports__;
+      });