@stacksjs/ts-cloud 0.2.1 → 0.2.2

package/dist/index.js

@@ -693,2047 +693,1173 @@ var init_signature = __esm(async () => {
   };
 });
 
-// ../../node_modules/fast-xml-parser/src/util.js
-function getAllMatches(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;
-}
-function isExist(v) {
-  return typeof v !== "undefined";
-}
-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", nameChar, nameRegexp, regexName, isName = function(string) {
-  const match = regexName.exec(string);
-  return !(match === null || typeof match === "undefined");
-};
-var init_util = __esm(() => {
-  nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
-  nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*";
-  regexName = new RegExp("^" + nameRegexp + "$");
-});
-
-// ../../node_modules/fast-xml-parser/src/validator.js
-function validate(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);
+// ../../node_modules/@stacksjs/ts-xml/dist/index.js
+class EntityDecoder {
+  customEntities = {};
+  useHtmlEntities;
+  constructor(useHtmlEntities = false) {
+    this.useHtmlEntities = useHtmlEntities;
+  }
+  addEntity(name, value) {
+    this.customEntities[name] = value;
+  }
+  decodeEntities(text) {
+    let ampIdx = text.indexOf("&");
+    if (ampIdx === -1)
+      return text;
+    const len = text.length;
+    let result = "";
+    let lastPos = 0;
+    while (ampIdx !== -1 && ampIdx < len) {
+      if (ampIdx > lastPos)
+        result += text.substring(lastPos, ampIdx);
+      const semiIdx = text.indexOf(";", ampIdx + 1);
+      if (semiIdx === -1 || semiIdx - ampIdx > 32) {
+        result += "&";
+        lastPos = ampIdx + 1;
+        ampIdx = text.indexOf("&", lastPos);
         continue;
-      } else {
-        let closingTag = false;
-        if (xmlData[i] === "/") {
-          closingTag = true;
-          i++;
-        }
-        let tagName = "";
-        for (;i < xmlData.length && xmlData[i] !== ">" && xmlData[i] !== " " && xmlData[i] !== "\t" && xmlData[i] !== `
-` && 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.";
-          }
-          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 {
-            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 if (tags.length === 0) {
-            return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' has not been opened.", 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;
+      }
+      const entity = text.substring(ampIdx + 1, semiIdx);
+      if (entity.charCodeAt(0) === 35) {
+        const elen = entity.length;
+        let code = 0;
+        let valid = false;
+        if (elen > 2 && (entity.charCodeAt(1) === 120 || entity.charCodeAt(1) === 88)) {
+          valid = true;
+          for (let k = 2;k < elen; k++) {
+            const d = entity.charCodeAt(k);
+            if (d >= 48 && d <= 57)
+              code = code << 4 | d - 48;
+            else if (d >= 65 && d <= 70)
+              code = code << 4 | d - 55;
+            else if (d >= 97 && d <= 102)
+              code = code << 4 | d - 87;
+            else {
+              valid = false;
+              break;
             }
           }
-        } 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 {
+        } else if (elen > 1) {
+          valid = true;
+          for (let k = 1;k < elen; k++) {
+            const d = entity.charCodeAt(k);
+            if (d >= 48 && d <= 57)
+              code = code * 10 + (d - 48);
+            else {
+              valid = false;
               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 === "\t" || char === `
-` || 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;
-      }
-    }
-  }
-  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;
-      }
-    }
-  }
-  return i;
-}
-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;
-      }
-    }
-    attrStr += xmlData[i];
-  }
-  if (startChar !== "") {
-    return false;
-  }
-  return {
-    value: attrStr,
-    index: i,
-    tagClosed
-  };
-}
-function validateAttributeString(attrStr, options) {
-  const matches = 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] !== undefined && matches[i][4] === undefined) {
-      return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' is without value.", getPositionFromMatch(matches[i]));
-    } else if (matches[i][3] === undefined && !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 (!Object.prototype.hasOwnProperty.call(attrNames, 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]/;
-  }
-  for (;i < xmlData.length; i++) {
-    if (xmlData[i] === ";")
-      return i;
-    if (!xmlData[i].match(re))
-      break;
-  }
-  return -1;
-}
-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 getErrorObject(code, message, lineNumber) {
-  return {
-    err: {
-      code,
-      msg: message,
-      line: lineNumber.line || lineNumber,
-      col: lineNumber.col
-    }
-  };
-}
-function validateAttrName(attrName) {
-  return isName(attrName);
-}
-function validateTagName(tagname) {
-  return isName(tagname);
-}
-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 getPositionFromMatch(match) {
-  return match.startIndex + match[1].length;
-}
-var defaultOptions, doubleQuote = '"', singleQuote = "'", validAttrStrRegxp;
-var init_validator = __esm(() => {
-  init_util();
-  defaultOptions = {
-    allowBooleanAttributes: false,
-    unpairedTags: []
-  };
-  validAttrStrRegxp = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g");
-});
-
-// ../../node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
-function normalizeProcessEntities(value) {
-  if (typeof value === "boolean") {
-    return {
-      enabled: value,
-      maxEntitySize: 1e4,
-      maxExpansionDepth: 10,
-      maxTotalExpansions: 1000,
-      maxExpandedLength: 1e5,
-      maxEntityCount: 100,
-      allowedTags: null,
-      tagFilter: null
-    };
-  }
-  if (typeof value === "object" && value !== null) {
-    return {
-      enabled: value.enabled !== false,
-      maxEntitySize: value.maxEntitySize ?? 1e4,
-      maxExpansionDepth: value.maxExpansionDepth ?? 10,
-      maxTotalExpansions: value.maxTotalExpansions ?? 1000,
-      maxExpandedLength: value.maxExpandedLength ?? 1e5,
-      maxEntityCount: value.maxEntityCount ?? 100,
-      allowedTags: value.allowedTags ?? null,
-      tagFilter: value.tagFilter ?? null
-    };
-  }
-  return normalizeProcessEntities(true);
-}
-var defaultOptions2, buildOptions = function(options) {
-  const built = Object.assign({}, defaultOptions2, options);
-  built.processEntities = normalizeProcessEntities(built.processEntities);
-  if (built.stopNodes && Array.isArray(built.stopNodes)) {
-    built.stopNodes = built.stopNodes.map((node) => {
-      if (typeof node === "string" && node.startsWith("*.")) {
-        return ".." + node.substring(2);
-      }
-      return node;
-    });
-  }
-  return built;
-};
-var init_OptionsBuilder = __esm(() => {
-  defaultOptions2 = {
-    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, val) {
-      return val;
-    },
-    attributeValueProcessor: function(attrName, val) {
-      return val;
-    },
-    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;
-    },
-    captureMetaData: false,
-    maxNestedTags: 100,
-    strictReservedNames: true,
-    jPath: true
-  };
-});
-
-// ../../node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
-class XmlNode {
-  constructor(tagname) {
-    this.tagname = tagname;
-    this.child = [];
-    this[":@"] = Object.create(null);
-  }
-  add(key, val) {
-    if (key === "__proto__")
-      key = "#__proto__";
-    this.child.push({ [key]: val });
-  }
-  addChild(node, startIndex) {
-    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 });
-    }
-    if (startIndex !== undefined) {
-      this.child[this.child.length - 1][METADATA_SYMBOL] = { startIndex };
-    }
-  }
-  static getMetaDataSymbol() {
-    return METADATA_SYMBOL;
-  }
-}
-var METADATA_SYMBOL;
-var init_xmlNode = __esm(() => {
-  if (typeof Symbol !== "function") {
-    METADATA_SYMBOL = "@@xmlMetadata";
-  } else {
-    METADATA_SYMBOL = Symbol("XML Node Metadata");
-  }
-});
-
-// ../../node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
-class DocTypeReader {
-  constructor(options) {
-    this.suppressValidationErr = !options;
-    this.options = options;
-  }
-  readDocType(xmlData, i) {
-    const entities = Object.create(null);
-    let entityCount = 0;
-    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 && hasSeq(xmlData, "!ENTITY", i)) {
-            i += 7;
-            let entityName, val;
-            [entityName, val, i] = this.readEntityExp(xmlData, i + 1, this.suppressValidationErr);
-            if (val.indexOf("&") === -1) {
-              if (this.options.enabled !== false && this.options.maxEntityCount && entityCount >= this.options.maxEntityCount) {
-                throw new Error(`Entity count (${entityCount + 1}) exceeds maximum allowed (${this.options.maxEntityCount})`);
-              }
-              const escaped = entityName.replace(/[.\-+*:]/g, "\\.");
-              entities[entityName] = {
-                regx: RegExp(`&${escaped};`, "g"),
-                val
-              };
-              entityCount++;
-            }
-          } else if (hasBody && hasSeq(xmlData, "!ELEMENT", i)) {
-            i += 8;
-            const { index } = this.readElementExp(xmlData, i + 1);
-            i = index;
-          } else if (hasBody && hasSeq(xmlData, "!ATTLIST", i)) {
-            i += 8;
-          } else if (hasBody && hasSeq(xmlData, "!NOTATION", i)) {
-            i += 9;
-            const { index } = this.readNotationExp(xmlData, i + 1, this.suppressValidationErr);
-            i = index;
-          } else if (hasSeq(xmlData, "!--", i))
-            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;
+        if (valid) {
+          result += String.fromCodePoint(code);
         } else {
-          exp += xmlData[i];
-        }
-      }
-      if (angleBracketsCount !== 0) {
-        throw new Error(`Unclosed DOCTYPE`);
-      }
-    } else {
-      throw new Error(`Invalid Tag instead of DOCTYPE`);
-    }
-    return { entities, i };
-  }
-  readEntityExp(xmlData, i) {
-    i = skipWhitespace(xmlData, i);
-    let entityName = "";
-    while (i < xmlData.length && !/\s/.test(xmlData[i]) && xmlData[i] !== '"' && xmlData[i] !== "'") {
-      entityName += xmlData[i];
-      i++;
-    }
-    validateEntityName(entityName);
-    i = skipWhitespace(xmlData, i);
-    if (!this.suppressValidationErr) {
-      if (xmlData.substring(i, i + 6).toUpperCase() === "SYSTEM") {
-        throw new Error("External entities are not supported");
-      } else if (xmlData[i] === "%") {
-        throw new Error("Parameter entities are not supported");
-      }
-    }
-    let entityValue = "";
-    [i, entityValue] = this.readIdentifierVal(xmlData, i, "entity");
-    if (this.options.enabled !== false && this.options.maxEntitySize && entityValue.length > this.options.maxEntitySize) {
-      throw new Error(`Entity "${entityName}" size (${entityValue.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`);
-    }
-    i--;
-    return [entityName, entityValue, i];
-  }
-  readNotationExp(xmlData, i) {
-    i = skipWhitespace(xmlData, i);
-    let notationName = "";
-    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-      notationName += xmlData[i];
-      i++;
-    }
-    !this.suppressValidationErr && validateEntityName(notationName);
-    i = skipWhitespace(xmlData, i);
-    const identifierType = xmlData.substring(i, i + 6).toUpperCase();
-    if (!this.suppressValidationErr && identifierType !== "SYSTEM" && identifierType !== "PUBLIC") {
-      throw new Error(`Expected SYSTEM or PUBLIC, found "${identifierType}"`);
-    }
-    i += identifierType.length;
-    i = skipWhitespace(xmlData, i);
-    let publicIdentifier = null;
-    let systemIdentifier = null;
-    if (identifierType === "PUBLIC") {
-      [i, publicIdentifier] = this.readIdentifierVal(xmlData, i, "publicIdentifier");
-      i = skipWhitespace(xmlData, i);
-      if (xmlData[i] === '"' || xmlData[i] === "'") {
-        [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, "systemIdentifier");
-      }
-    } else if (identifierType === "SYSTEM") {
-      [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, "systemIdentifier");
-      if (!this.suppressValidationErr && !systemIdentifier) {
-        throw new Error("Missing mandatory system identifier for SYSTEM notation");
-      }
-    }
-    return { notationName, publicIdentifier, systemIdentifier, index: --i };
-  }
-  readIdentifierVal(xmlData, i, type) {
-    let identifierVal = "";
-    const startChar = xmlData[i];
-    if (startChar !== '"' && startChar !== "'") {
-      throw new Error(`Expected quoted string, found "${startChar}"`);
-    }
-    i++;
-    while (i < xmlData.length && xmlData[i] !== startChar) {
-      identifierVal += xmlData[i];
-      i++;
-    }
-    if (xmlData[i] !== startChar) {
-      throw new Error(`Unterminated ${type} value`);
-    }
-    i++;
-    return [i, identifierVal];
-  }
-  readElementExp(xmlData, i) {
-    i = skipWhitespace(xmlData, i);
-    let elementName = "";
-    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-      elementName += xmlData[i];
-      i++;
-    }
-    if (!this.suppressValidationErr && !isName(elementName)) {
-      throw new Error(`Invalid element name: "${elementName}"`);
-    }
-    i = skipWhitespace(xmlData, i);
-    let contentModel = "";
-    if (xmlData[i] === "E" && hasSeq(xmlData, "MPTY", i))
-      i += 4;
-    else if (xmlData[i] === "A" && hasSeq(xmlData, "NY", i))
-      i += 2;
-    else if (xmlData[i] === "(") {
-      i++;
-      while (i < xmlData.length && xmlData[i] !== ")") {
-        contentModel += xmlData[i];
-        i++;
-      }
-      if (xmlData[i] !== ")") {
-        throw new Error("Unterminated content model");
-      }
-    } else if (!this.suppressValidationErr) {
-      throw new Error(`Invalid Element Expression, found "${xmlData[i]}"`);
-    }
-    return {
-      elementName,
-      contentModel: contentModel.trim(),
-      index: i
-    };
-  }
-  readAttlistExp(xmlData, i) {
-    i = skipWhitespace(xmlData, i);
-    let elementName = "";
-    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-      elementName += xmlData[i];
-      i++;
-    }
-    validateEntityName(elementName);
-    i = skipWhitespace(xmlData, i);
-    let attributeName = "";
-    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-      attributeName += xmlData[i];
-      i++;
-    }
-    if (!validateEntityName(attributeName)) {
-      throw new Error(`Invalid attribute name: "${attributeName}"`);
-    }
-    i = skipWhitespace(xmlData, i);
-    let attributeType = "";
-    if (xmlData.substring(i, i + 8).toUpperCase() === "NOTATION") {
-      attributeType = "NOTATION";
-      i += 8;
-      i = skipWhitespace(xmlData, i);
-      if (xmlData[i] !== "(") {
-        throw new Error(`Expected '(', found "${xmlData[i]}"`);
-      }
-      i++;
-      let allowedNotations = [];
-      while (i < xmlData.length && xmlData[i] !== ")") {
-        let notation = "";
-        while (i < xmlData.length && xmlData[i] !== "|" && xmlData[i] !== ")") {
-          notation += xmlData[i];
-          i++;
-        }
-        notation = notation.trim();
-        if (!validateEntityName(notation)) {
-          throw new Error(`Invalid notation name: "${notation}"`);
+          result += text.substring(ampIdx, semiIdx + 1);
         }
-        allowedNotations.push(notation);
-        if (xmlData[i] === "|") {
-          i++;
-          i = skipWhitespace(xmlData, i);
-        }
-      }
-      if (xmlData[i] !== ")") {
-        throw new Error("Unterminated list of notations");
-      }
-      i++;
-      attributeType += " (" + allowedNotations.join("|") + ")";
-    } else {
-      while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-        attributeType += xmlData[i];
-        i++;
-      }
-      const validTypes = ["CDATA", "ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS"];
-      if (!this.suppressValidationErr && !validTypes.includes(attributeType.toUpperCase())) {
-        throw new Error(`Invalid attribute type: "${attributeType}"`);
-      }
-    }
-    i = skipWhitespace(xmlData, i);
-    let defaultValue = "";
-    if (xmlData.substring(i, i + 8).toUpperCase() === "#REQUIRED") {
-      defaultValue = "#REQUIRED";
-      i += 8;
-    } else if (xmlData.substring(i, i + 7).toUpperCase() === "#IMPLIED") {
-      defaultValue = "#IMPLIED";
-      i += 7;
-    } else {
-      [i, defaultValue] = this.readIdentifierVal(xmlData, i, "ATTLIST");
-    }
-    return {
-      elementName,
-      attributeName,
-      attributeType,
-      defaultValue,
-      index: i
-    };
-  }
-}
-function hasSeq(data, seq, i) {
-  for (let j = 0;j < seq.length; j++) {
-    if (seq[j] !== data[i + j + 1])
-      return false;
-  }
-  return true;
-}
-function validateEntityName(name) {
-  if (isName(name))
-    return name;
-  else
-    throw new Error(`Invalid entity name ${name}`);
-}
-var skipWhitespace = (data, index) => {
-  while (index < data.length && /\s/.test(data[index])) {
-    index++;
-  }
-  return index;
-};
-var init_DocTypeReader = __esm(() => {
-  init_util();
-});
-
-// ../../node_modules/strnum/strnum.js
-function toNumber(str, options = {}) {
-  options = Object.assign({}, consider, options);
-  if (!str || typeof str !== "string")
-    return str;
-  let trimmedStr = str.trim();
-  if (options.skipLike !== undefined && options.skipLike.test(trimmedStr))
-    return str;
-  else if (str === "0")
-    return 0;
-  else if (options.hex && hexRegex.test(trimmedStr)) {
-    return parse_int(trimmedStr, 16);
-  } else if (!isFinite(trimmedStr)) {
-    return handleInfinity(str, Number(trimmedStr), options);
-  } else if (trimmedStr.includes("e") || trimmedStr.includes("E")) {
-    return resolveEnotation(str, trimmedStr, options);
-  } else {
-    const match = numRegex.exec(trimmedStr);
-    if (match) {
-      const sign = match[1] || "";
-      const leadingZeros = match[2];
-      let numTrimmedByZeros = trimZeros(match[3]);
-      const decimalAdjacentToLeadingZeros = sign ? str[leadingZeros.length + 1] === "." : str[leadingZeros.length] === ".";
-      if (!options.leadingZeros && (leadingZeros.length > 1 || leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros)) {
-        return str;
-      } else {
-        const num = Number(trimmedStr);
-        const parsedStr = String(num);
-        if (num === 0)
-          return num;
-        if (parsedStr.search(/[eE]/) !== -1) {
-          if (options.eNotation)
-            return num;
-          else
-            return str;
-        } else if (trimmedStr.indexOf(".") !== -1) {
-          if (parsedStr === "0")
-            return num;
-          else if (parsedStr === numTrimmedByZeros)
-            return num;
-          else if (parsedStr === `${sign}${numTrimmedByZeros}`)
-            return num;
-          else
-            return str;
-        }
-        let n = leadingZeros ? numTrimmedByZeros : trimmedStr;
-        if (leadingZeros) {
-          return n === parsedStr || sign + n === parsedStr ? num : str;
-        } else {
-          return n === parsedStr || n === sign + parsedStr ? num : str;
-        }
-      }
-    } else {
-      return str;
-    }
-  }
-}
-function resolveEnotation(str, trimmedStr, options) {
-  if (!options.eNotation)
-    return str;
-  const notation = trimmedStr.match(eNotationRegx);
-  if (notation) {
-    let sign = notation[1] || "";
-    const eChar = notation[3].indexOf("e") === -1 ? "E" : "e";
-    const leadingZeros = notation[2];
-    const eAdjacentToLeadingZeros = sign ? str[leadingZeros.length + 1] === eChar : str[leadingZeros.length] === eChar;
-    if (leadingZeros.length > 1 && eAdjacentToLeadingZeros)
-      return str;
-    else if (leadingZeros.length === 1 && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)) {
-      return Number(trimmedStr);
-    } else if (options.leadingZeros && !eAdjacentToLeadingZeros) {
-      trimmedStr = (notation[1] || "") + notation[3];
-      return Number(trimmedStr);
-    } else
-      return str;
-  } else {
-    return str;
-  }
-}
-function trimZeros(numStr) {
-  if (numStr && numStr.indexOf(".") !== -1) {
-    numStr = numStr.replace(/0+$/, "");
-    if (numStr === ".")
-      numStr = "0";
-    else if (numStr[0] === ".")
-      numStr = "0" + numStr;
-    else if (numStr[numStr.length - 1] === ".")
-      numStr = numStr.substring(0, numStr.length - 1);
-    return numStr;
-  }
-  return numStr;
-}
-function parse_int(numStr, base) {
-  if (parseInt)
-    return parseInt(numStr, base);
-  else if (Number.parseInt)
-    return Number.parseInt(numStr, base);
-  else if (window && window.parseInt)
-    return window.parseInt(numStr, base);
-  else
-    throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
-}
-function handleInfinity(str, num, options) {
-  const isPositive = num === Infinity;
-  switch (options.infinity.toLowerCase()) {
-    case "null":
-      return null;
-    case "infinity":
-      return num;
-    case "string":
-      return isPositive ? "Infinity" : "-Infinity";
-    case "original":
-    default:
-      return str;
-  }
-}
-var hexRegex, numRegex, consider, eNotationRegx;
-var init_strnum = __esm(() => {
-  hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
-  numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
-  consider = {
-    hex: true,
-    leadingZeros: true,
-    decimalPoint: ".",
-    eNotation: true,
-    infinity: "original"
-  };
-  eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
-});
-
-// ../../node_modules/fast-xml-parser/src/ignoreAttributes.js
-function getIgnoreAttributesFn(ignoreAttributes) {
-  if (typeof ignoreAttributes === "function") {
-    return ignoreAttributes;
-  }
-  if (Array.isArray(ignoreAttributes)) {
-    return (attrName) => {
-      for (const pattern of ignoreAttributes) {
-        if (typeof pattern === "string" && attrName === pattern) {
-          return true;
-        }
-        if (pattern instanceof RegExp && pattern.test(attrName)) {
-          return true;
-        }
-      }
-    };
-  }
-  return () => false;
-}
-
-// ../../node_modules/path-expression-matcher/src/Expression.js
-class Expression {
-  constructor(pattern, options = {}) {
-    this.pattern = pattern;
-    this.separator = options.separator || ".";
-    this.segments = this._parse(pattern);
-    this._hasDeepWildcard = this.segments.some((seg) => seg.type === "deep-wildcard");
-    this._hasAttributeCondition = this.segments.some((seg) => seg.attrName !== undefined);
-    this._hasPositionSelector = this.segments.some((seg) => seg.position !== undefined);
-  }
-  _parse(pattern) {
-    const segments = [];
-    let i = 0;
-    let currentPart = "";
-    while (i < pattern.length) {
-      if (pattern[i] === this.separator) {
-        if (i + 1 < pattern.length && pattern[i + 1] === this.separator) {
-          if (currentPart.trim()) {
-            segments.push(this._parseSegment(currentPart.trim()));
-            currentPart = "";
-          }
-          segments.push({ type: "deep-wildcard" });
-          i += 2;
-        } else {
-          if (currentPart.trim()) {
-            segments.push(this._parseSegment(currentPart.trim()));
-          }
-          currentPart = "";
-          i++;
-        }
-      } else {
-        currentPart += pattern[i];
-        i++;
-      }
-    }
-    if (currentPart.trim()) {
-      segments.push(this._parseSegment(currentPart.trim()));
-    }
-    return segments;
-  }
-  _parseSegment(part) {
-    const segment = { type: "tag" };
-    let bracketContent = null;
-    let withoutBrackets = part;
-    const bracketMatch = part.match(/^([^\[]+)(\[[^\]]*\])(.*)$/);
-    if (bracketMatch) {
-      withoutBrackets = bracketMatch[1] + bracketMatch[3];
-      if (bracketMatch[2]) {
-        const content = bracketMatch[2].slice(1, -1);
-        if (content) {
-          bracketContent = content;
-        }
-      }
-    }
-    let namespace = undefined;
-    let tagAndPosition = withoutBrackets;
-    if (withoutBrackets.includes("::")) {
-      const nsIndex = withoutBrackets.indexOf("::");
-      namespace = withoutBrackets.substring(0, nsIndex).trim();
-      tagAndPosition = withoutBrackets.substring(nsIndex + 2).trim();
-      if (!namespace) {
-        throw new Error(`Invalid namespace in pattern: ${part}`);
-      }
-    }
-    let tag = undefined;
-    let positionMatch = null;
-    if (tagAndPosition.includes(":")) {
-      const colonIndex = tagAndPosition.lastIndexOf(":");
-      const tagPart = tagAndPosition.substring(0, colonIndex).trim();
-      const posPart = tagAndPosition.substring(colonIndex + 1).trim();
-      const isPositionKeyword = ["first", "last", "odd", "even"].includes(posPart) || /^nth\(\d+\)$/.test(posPart);
-      if (isPositionKeyword) {
-        tag = tagPart;
-        positionMatch = posPart;
-      } else {
-        tag = tagAndPosition;
-      }
-    } else {
-      tag = tagAndPosition;
-    }
-    if (!tag) {
-      throw new Error(`Invalid segment pattern: ${part}`);
-    }
-    segment.tag = tag;
-    if (namespace) {
-      segment.namespace = namespace;
-    }
-    if (bracketContent) {
-      if (bracketContent.includes("=")) {
-        const eqIndex = bracketContent.indexOf("=");
-        segment.attrName = bracketContent.substring(0, eqIndex).trim();
-        segment.attrValue = bracketContent.substring(eqIndex + 1).trim();
-      } else {
-        segment.attrName = bracketContent.trim();
-      }
-    }
-    if (positionMatch) {
-      const nthMatch = positionMatch.match(/^nth\((\d+)\)$/);
-      if (nthMatch) {
-        segment.position = "nth";
-        segment.positionValue = parseInt(nthMatch[1], 10);
-      } else {
-        segment.position = positionMatch;
-      }
-    }
-    return segment;
-  }
-  get length() {
-    return this.segments.length;
-  }
-  hasDeepWildcard() {
-    return this._hasDeepWildcard;
-  }
-  hasAttributeCondition() {
-    return this._hasAttributeCondition;
-  }
-  hasPositionSelector() {
-    return this._hasPositionSelector;
-  }
-  toString() {
-    return this.pattern;
-  }
-}
-
-// ../../node_modules/path-expression-matcher/src/Matcher.js
-class Matcher {
-  constructor(options = {}) {
-    this.separator = options.separator || ".";
-    this.path = [];
-    this.siblingStacks = [];
-  }
-  push(tagName, attrValues = null, namespace = null) {
-    if (this.path.length > 0) {
-      const prev = this.path[this.path.length - 1];
-      prev.values = undefined;
-    }
-    const currentLevel = this.path.length;
-    if (!this.siblingStacks[currentLevel]) {
-      this.siblingStacks[currentLevel] = new Map;
-    }
-    const siblings = this.siblingStacks[currentLevel];
-    const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;
-    const counter = siblings.get(siblingKey) || 0;
-    let position = 0;
-    for (const count of siblings.values()) {
-      position += count;
-    }
-    siblings.set(siblingKey, counter + 1);
-    const node = {
-      tag: tagName,
-      position,
-      counter
-    };
-    if (namespace !== null && namespace !== undefined) {
-      node.namespace = namespace;
-    }
-    if (attrValues !== null && attrValues !== undefined) {
-      node.values = attrValues;
-    }
-    this.path.push(node);
-  }
-  pop() {
-    if (this.path.length === 0) {
-      return;
-    }
-    const node = this.path.pop();
-    if (this.siblingStacks.length > this.path.length + 1) {
-      this.siblingStacks.length = this.path.length + 1;
-    }
-    return node;
-  }
-  updateCurrent(attrValues) {
-    if (this.path.length > 0) {
-      const current = this.path[this.path.length - 1];
-      if (attrValues !== null && attrValues !== undefined) {
-        current.values = attrValues;
-      }
-    }
-  }
-  getCurrentTag() {
-    return this.path.length > 0 ? this.path[this.path.length - 1].tag : undefined;
-  }
-  getCurrentNamespace() {
-    return this.path.length > 0 ? this.path[this.path.length - 1].namespace : undefined;
-  }
-  getAttrValue(attrName) {
-    if (this.path.length === 0)
-      return;
-    const current = this.path[this.path.length - 1];
-    return current.values?.[attrName];
-  }
-  hasAttr(attrName) {
-    if (this.path.length === 0)
-      return false;
-    const current = this.path[this.path.length - 1];
-    return current.values !== undefined && attrName in current.values;
-  }
-  getPosition() {
-    if (this.path.length === 0)
-      return -1;
-    return this.path[this.path.length - 1].position ?? 0;
-  }
-  getCounter() {
-    if (this.path.length === 0)
-      return -1;
-    return this.path[this.path.length - 1].counter ?? 0;
-  }
-  getIndex() {
-    return this.getPosition();
-  }
-  getDepth() {
-    return this.path.length;
-  }
-  toString(separator, includeNamespace = true) {
-    const sep = separator || this.separator;
-    return this.path.map((n) => {
-      if (includeNamespace && n.namespace) {
-        return `${n.namespace}:${n.tag}`;
-      }
-      return n.tag;
-    }).join(sep);
-  }
-  toArray() {
-    return this.path.map((n) => n.tag);
-  }
-  reset() {
-    this.path = [];
-    this.siblingStacks = [];
-  }
-  matches(expression) {
-    const segments = expression.segments;
-    if (segments.length === 0) {
-      return false;
-    }
-    if (expression.hasDeepWildcard()) {
-      return this._matchWithDeepWildcard(segments);
-    }
-    return this._matchSimple(segments);
-  }
-  _matchSimple(segments) {
-    if (this.path.length !== segments.length) {
-      return false;
-    }
-    for (let i = 0;i < segments.length; i++) {
-      const segment = segments[i];
-      const node = this.path[i];
-      const isCurrentNode = i === this.path.length - 1;
-      if (!this._matchSegment(segment, node, isCurrentNode)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  _matchWithDeepWildcard(segments) {
-    let pathIdx = this.path.length - 1;
-    let segIdx = segments.length - 1;
-    while (segIdx >= 0 && pathIdx >= 0) {
-      const segment = segments[segIdx];
-      if (segment.type === "deep-wildcard") {
-        segIdx--;
-        if (segIdx < 0) {
-          return true;
-        }
-        const nextSeg = segments[segIdx];
-        let found = false;
-        for (let i = pathIdx;i >= 0; i--) {
-          const isCurrentNode = i === this.path.length - 1;
-          if (this._matchSegment(nextSeg, this.path[i], isCurrentNode)) {
-            pathIdx = i - 1;
-            segIdx--;
-            found = true;
-            break;
-          }
-        }
-        if (!found) {
-          return false;
-        }
-      } else {
-        const isCurrentNode = pathIdx === this.path.length - 1;
-        if (!this._matchSegment(segment, this.path[pathIdx], isCurrentNode)) {
-          return false;
-        }
-        pathIdx--;
-        segIdx--;
-      }
-    }
-    return segIdx < 0;
-  }
-  _matchSegment(segment, node, isCurrentNode) {
-    if (segment.tag !== "*" && segment.tag !== node.tag) {
-      return false;
-    }
-    if (segment.namespace !== undefined) {
-      if (segment.namespace !== "*" && segment.namespace !== node.namespace) {
-        return false;
-      }
-    }
-    if (segment.attrName !== undefined) {
-      if (!isCurrentNode) {
-        return false;
-      }
-      if (!node.values || !(segment.attrName in node.values)) {
-        return false;
-      }
-      if (segment.attrValue !== undefined) {
-        const actualValue = node.values[segment.attrName];
-        if (String(actualValue) !== String(segment.attrValue)) {
-          return false;
-        }
-      }
-    }
-    if (segment.position !== undefined) {
-      if (!isCurrentNode) {
-        return false;
-      }
-      const counter = node.counter ?? 0;
-      if (segment.position === "first" && counter !== 0) {
-        return false;
-      } else if (segment.position === "odd" && counter % 2 !== 1) {
-        return false;
-      } else if (segment.position === "even" && counter % 2 !== 0) {
-        return false;
-      } else if (segment.position === "nth") {
-        if (counter !== segment.positionValue) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-  snapshot() {
-    return {
-      path: this.path.map((node) => ({ ...node })),
-      siblingStacks: this.siblingStacks.map((map) => new Map(map))
-    };
-  }
-  restore(snapshot) {
-    this.path = snapshot.path.map((node) => ({ ...node }));
-    this.siblingStacks = snapshot.siblingStacks.map((map) => new Map(map));
-  }
-}
-
-// ../../node_modules/path-expression-matcher/src/index.js
-var init_src = () => {};
-
-// ../../node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
-function extractRawAttributes(prefixedAttrs, options) {
-  if (!prefixedAttrs)
-    return {};
-  const attrs = options.attributesGroupName ? prefixedAttrs[options.attributesGroupName] : prefixedAttrs;
-  if (!attrs)
-    return {};
-  const rawAttrs = {};
-  for (const key in attrs) {
-    if (key.startsWith(options.attributeNamePrefix)) {
-      const rawName = key.substring(options.attributeNamePrefix.length);
-      rawAttrs[rawName] = attrs[key];
-    } else {
-      rawAttrs[key] = attrs[key];
-    }
-  }
-  return rawAttrs;
-}
-function extractNamespace(rawTagName) {
-  if (!rawTagName || typeof rawTagName !== "string")
-    return;
-  const colonIndex = rawTagName.indexOf(":");
-  if (colonIndex !== -1 && colonIndex > 0) {
-    const ns = rawTagName.substring(0, colonIndex);
-    if (ns !== "xmlns") {
-      return ns;
-    }
-  }
-  return;
-}
-
-class OrderedObjParser {
-  constructor(options) {
-    this.options = options;
-    this.currentNode = null;
-    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: '"' }
-    };
-    this.ampEntity = { regex: /&(amp|#38|#x26);/g, val: "&" };
-    this.htmlEntities = {
-      space: { regex: /&(nbsp|#160);/g, val: " " },
-      cent: { regex: /&(cent|#162);/g, val: "¢" },
-      pound: { regex: /&(pound|#163);/g, val: "£" },
-      yen: { regex: /&(yen|#165);/g, val: "¥" },
-      euro: { regex: /&(euro|#8364);/g, val: "€" },
-      copyright: { regex: /&(copy|#169);/g, val: "©" },
-      reg: { regex: /&(reg|#174);/g, val: "®" },
-      inr: { regex: /&(inr|#8377);/g, val: "₹" },
-      num_dec: { regex: /&#([0-9]{1,7});/g, val: (_, str) => fromCodePoint(str, 10, "&#") },
-      num_hex: { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (_, str) => fromCodePoint(str, 16, "&#x") }
-    };
-    this.addExternalEntities = addExternalEntities;
-    this.parseXml = parseXml;
-    this.parseTextData = parseTextData;
-    this.resolveNameSpace = resolveNameSpace;
-    this.buildAttributesMap = buildAttributesMap;
-    this.isItStopNode = isItStopNode;
-    this.replaceEntitiesValue = replaceEntitiesValue;
-    this.readStopNodeData = readStopNodeData;
-    this.saveTextToParentTag = saveTextToParentTag;
-    this.addChild = addChild;
-    this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
-    this.entityExpansionCount = 0;
-    this.currentExpandedLength = 0;
-    this.matcher = new Matcher;
-    this.isCurrentNodeStopNode = false;
-    if (this.options.stopNodes && this.options.stopNodes.length > 0) {
-      this.stopNodeExpressions = [];
-      for (let i = 0;i < this.options.stopNodes.length; i++) {
-        const stopNodeExp = this.options.stopNodes[i];
-        if (typeof stopNodeExp === "string") {
-          this.stopNodeExpressions.push(new Expression(stopNodeExp));
-        } else if (stopNodeExp instanceof Expression) {
-          this.stopNodeExpressions.push(stopNodeExp);
-        }
-      }
-    }
-  }
-}
-function addExternalEntities(externalEntities) {
-  const entKeys = Object.keys(externalEntities);
-  for (let i = 0;i < entKeys.length; i++) {
-    const ent = entKeys[i];
-    const escaped = ent.replace(/[.\-+*:]/g, "\\.");
-    this.lastEntities[ent] = {
-      regex: new RegExp("&" + escaped + ";", "g"),
-      val: externalEntities[ent]
-    };
-  }
-}
-function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
-  if (val !== undefined) {
-    if (this.options.trimValues && !dontTrim) {
-      val = val.trim();
-    }
-    if (val.length > 0) {
-      if (!escapeEntities)
-        val = this.replaceEntitiesValue(val, tagName, jPath);
-      const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
-      const newval = this.options.tagValueProcessor(tagName, val, jPathOrMatcher, hasAttributes, isLeafNode);
-      if (newval === null || newval === undefined) {
-        return val;
-      } else if (typeof newval !== typeof val || newval !== val) {
-        return newval;
-      } else if (this.options.trimValues) {
-        return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
-      } else {
-        const trimmedVal = val.trim();
-        if (trimmedVal === val) {
-          return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
-        } else {
-          return val;
-        }
-      }
-    }
-  }
-}
-function resolveNameSpace(tagname) {
-  if (this.options.removeNSPrefix) {
-    const tags = tagname.split(":");
-    const prefix = tagname.charAt(0) === "/" ? "/" : "";
-    if (tags[0] === "xmlns") {
-      return "";
-    }
-    if (tags.length === 2) {
-      tagname = prefix + tags[1];
-    }
-  }
-  return tagname;
-}
-function buildAttributesMap(attrStr, jPath, tagName) {
-  if (this.options.ignoreAttributes !== true && typeof attrStr === "string") {
-    const matches = getAllMatches(attrStr, attrsRegx);
-    const len = matches.length;
-    const attrs = {};
-    const rawAttrsForMatcher = {};
-    for (let i = 0;i < len; i++) {
-      const attrName = this.resolveNameSpace(matches[i][1]);
-      const oldVal = matches[i][4];
-      if (attrName.length && oldVal !== undefined) {
-        let parsedVal = oldVal;
-        if (this.options.trimValues) {
-          parsedVal = parsedVal.trim();
-        }
-        parsedVal = this.replaceEntitiesValue(parsedVal, tagName, jPath);
-        rawAttrsForMatcher[attrName] = parsedVal;
-      }
-    }
-    if (Object.keys(rawAttrsForMatcher).length > 0 && typeof jPath === "object" && jPath.updateCurrent) {
-      jPath.updateCurrent(rawAttrsForMatcher);
-    }
-    for (let i = 0;i < len; i++) {
-      const attrName = this.resolveNameSpace(matches[i][1]);
-      const jPathStr = this.options.jPath ? jPath.toString() : jPath;
-      if (this.ignoreAttributesFn(attrName, jPathStr)) {
-        continue;
-      }
-      let oldVal = matches[i][4];
-      let aName = this.options.attributeNamePrefix + attrName;
-      if (attrName.length) {
-        if (this.options.transformAttributeName) {
-          aName = this.options.transformAttributeName(aName);
-        }
-        if (aName === "__proto__")
-          aName = "#__proto__";
-        if (oldVal !== undefined) {
-          if (this.options.trimValues) {
-            oldVal = oldVal.trim();
-          }
-          oldVal = this.replaceEntitiesValue(oldVal, tagName, jPath);
-          const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
-          const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPathOrMatcher);
-          if (newVal === null || newVal === undefined) {
-            attrs[aName] = oldVal;
-          } else if (typeof newVal !== typeof oldVal || newVal !== oldVal) {
-            attrs[aName] = newVal;
-          } else {
-            attrs[aName] = parseValue(oldVal, this.options.parseAttributeValue, this.options.numberParseOptions);
+      } else {
+        let replacement = this.customEntities[entity];
+        if (replacement === undefined) {
+          const elen = entity.length;
+          if (elen >= 2 && elen <= 4) {
+            const e0 = entity.charCodeAt(0);
+            if (e0 === 108 && elen === 2 && entity.charCodeAt(1) === 116)
+              replacement = "<";
+            else if (e0 === 103 && elen === 2 && entity.charCodeAt(1) === 116)
+              replacement = ">";
+            else if (e0 === 97 && elen === 3 && entity.charCodeAt(1) === 109 && entity.charCodeAt(2) === 112)
+              replacement = "&";
+            else if (e0 === 113 && elen === 4)
+              replacement = entity === "quot" ? '"' : undefined;
+            else if (e0 === 97 && elen === 4)
+              replacement = entity === "apos" ? "'" : undefined;
           }
-        } else if (this.options.allowBooleanAttributes) {
-          attrs[aName] = true;
+          if (replacement === undefined)
+            replacement = xmlEntities[entity] ?? (this.useHtmlEntities ? htmlEntities[entity] : undefined);
+        }
+        if (replacement !== undefined) {
+          result += replacement;
+        } else {
+          result += text.substring(ampIdx, semiIdx + 1);
         }
       }
+      lastPos = semiIdx + 1;
+      ampIdx = text.indexOf("&", lastPos);
     }
-    if (!Object.keys(attrs).length) {
-      return;
-    }
-    if (this.options.attributesGroupName) {
-      const attrCollection = {};
-      attrCollection[this.options.attributesGroupName] = attrs;
-      return attrCollection;
-    }
-    return attrs;
+    if (lastPos < len)
+      result += text.substring(lastPos);
+    return result;
   }
 }
-function addChild(currentNode, childNode, matcher, startIndex) {
-  if (!this.options.captureMetaData)
-    startIndex = undefined;
-  const jPathOrMatcher = this.options.jPath ? matcher.toString() : matcher;
-  const result = this.options.updateTag(childNode.tagname, jPathOrMatcher, childNode[":@"]);
-  if (result === false) {} else if (typeof result === "string") {
-    childNode.tagname = result;
-    currentNode.addChild(childNode, startIndex);
-  } else {
-    currentNode.addChild(childNode, startIndex);
-  }
+function isWhitespace(ch) {
+  return ch === 32 || ch === 9 || ch === 10 || ch === 13;
 }
-function replaceEntitiesValue(val, tagName, jPath) {
-  const entityConfig = this.options.processEntities;
-  if (!entityConfig || !entityConfig.enabled) {
-    return val;
+function isNameStartChar(ch) {
+  return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch === 95 || ch === 58 || ch >= 192 && ch <= 214 || ch >= 216 && ch <= 246 || ch >= 248 && ch <= 767 || ch >= 880 && ch <= 893 || ch >= 895 && ch <= 8191 || ch >= 8204 && ch <= 8205 || ch >= 8304 && ch <= 8591 || ch >= 11264 && ch <= 12271 || ch >= 12289 && ch <= 55295 || ch >= 63744 && ch <= 64975 || ch >= 65008 && ch <= 65533;
+}
+function isNameChar(ch) {
+  return isNameStartChar(ch) || ch === 45 || ch === 46 || ch >= 48 && ch <= 57 || ch === 183 || ch >= 768 && ch <= 879 || ch >= 8255 && ch <= 8256;
+}
+function isCDATA(xml, pos) {
+  return xml.charCodeAt(pos) === 91 && xml.charCodeAt(pos + 1) === 67 && xml.charCodeAt(pos + 2) === 68 && xml.charCodeAt(pos + 3) === 65 && xml.charCodeAt(pos + 4) === 84 && xml.charCodeAt(pos + 5) === 65 && xml.charCodeAt(pos + 6) === 91;
+}
+function isDOCTYPE(xml, pos) {
+  const c0 = xml.charCodeAt(pos);
+  const c1 = xml.charCodeAt(pos + 1);
+  const c2 = xml.charCodeAt(pos + 2);
+  const c3 = xml.charCodeAt(pos + 3);
+  const c4 = xml.charCodeAt(pos + 4);
+  const c5 = xml.charCodeAt(pos + 5);
+  const c6 = xml.charCodeAt(pos + 6);
+  return (c0 === 68 || c0 === 100) && (c1 === 79 || c1 === 111) && (c2 === 67 || c2 === 99) && (c3 === 84 || c3 === 116) && (c4 === 89 || c4 === 121) && (c5 === 80 || c5 === 112) && (c6 === 69 || c6 === 101);
+}
+function readNameEnd(xml, pos, len) {
+  if (pos >= len || !isNameStartChar(xml.charCodeAt(pos)))
+    return pos;
+  pos++;
+  while (pos < len && isNameChar(xml.charCodeAt(pos)))
+    pos++;
+  return pos;
+}
+
+class XMLParser {
+  options;
+  entityDecoder;
+  unpairedSet;
+  exactStopNodes;
+  wildcardStopSuffixes;
+  needsJPath;
+  _ignoreAttributes = true;
+  _textNodeName = "#text";
+  _commentPropName = false;
+  _cdataPropName = false;
+  _piPropName = false;
+  _alwaysCreateTextNode = false;
+  _trimValues = true;
+  _processEntities = true;
+  _parseTagValue = true;
+  _parseAttributeValue = false;
+  _removeNSPrefix = false;
+  _attrPrefix = "@_";
+  _attrsGroupName = false;
+  _ignorePiTags = false;
+  _ignoreDeclaration = false;
+  constructor(options) {
+    this.options = { ...defaultParserOptions, ...options };
+    this.entityDecoder = new EntityDecoder(this.options.htmlEntities);
+    this.unpairedSet = new Set(this.options.unpairedTags);
+    this.exactStopNodes = new Set;
+    this.wildcardStopSuffixes = [];
+    for (const stopNode of this.options.stopNodes) {
+      if (stopNode.startsWith("*.")) {
+        this.wildcardStopSuffixes.push(stopNode.substring(2));
+      } else {
+        this.exactStopNodes.add(stopNode);
+      }
+    }
+    this._ignoreAttributes = this.options.ignoreAttributes;
+    this._textNodeName = this.options.textNodeName;
+    this._commentPropName = this.options.commentPropName;
+    this._cdataPropName = this.options.cdataPropName;
+    this._piPropName = this.options.piPropName;
+    this._alwaysCreateTextNode = this.options.alwaysCreateTextNode;
+    this._trimValues = this.options.trimValues;
+    this._processEntities = this.options.processEntities;
+    this._parseTagValue = this.options.parseTagValue;
+    this._parseAttributeValue = this.options.parseAttributeValue;
+    this._removeNSPrefix = this.options.removeNSPrefix;
+    this._attrPrefix = this.options.attributeNamePrefix;
+    this._attrsGroupName = this.options.attributesGroupName;
+    this._ignorePiTags = this.options.ignorePiTags;
+    this._ignoreDeclaration = this.options.ignoreDeclaration;
+    this.needsJPath = this.options.stopNodes.length > 0 || this.options.isArray !== undefined || this.options.updateTag !== undefined || this.options.tagValueProcessor !== undefined || this.options.attributeValueProcessor !== undefined;
+  }
+  addEntity(name, value) {
+    this.entityDecoder.addEntity(name, value);
+  }
+  parse(xmlData) {
+    if (xmlData instanceof Uint8Array) {
+      xmlData = new TextDecoder().decode(xmlData);
+    }
+    const xml = xmlData;
+    if (this.options.preserveOrder) {
+      return this.parseOrdered(xml);
+    }
+    return this.parseUnordered(xml);
+  }
+  parseUnordered(xml) {
+    const result = {};
+    const len = xml.length;
+    let i = 0;
+    if (len > 0 && xml.charCodeAt(0) === 65279)
+      i = 1;
+    i = this.parseChildren(xml, i, len, result, "", []);
+    return result;
   }
-  if (entityConfig.allowedTags) {
-    const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
-    const allowed = Array.isArray(entityConfig.allowedTags) ? entityConfig.allowedTags.includes(tagName) : entityConfig.allowedTags(tagName, jPathOrMatcher);
-    if (!allowed) {
-      return val;
-    }
+  parseOrdered(xml) {
+    const len = xml.length;
+    let i = 0;
+    if (len > 0 && xml.charCodeAt(0) === 65279)
+      i = 1;
+    const result = [];
+    this.parseChildrenOrdered(xml, i, len, result, "");
+    return result;
   }
-  if (entityConfig.tagFilter) {
-    const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
-    if (!entityConfig.tagFilter(tagName, jPathOrMatcher)) {
-      return val;
+  readTagName(xml, pos, len) {
+    const end = readNameEnd(xml, pos, len);
+    return end;
+  }
+  extractTagName(xml, start, end) {
+    let name = xml.substring(start, end);
+    if (this._removeNSPrefix) {
+      const colonIdx = name.indexOf(":");
+      if (colonIdx !== -1)
+        name = name.substring(colonIdx + 1);
     }
+    if (this.options.transformTagName)
+      name = this.options.transformTagName(name);
+    return name;
   }
-  for (let entityName in this.docTypeEntities) {
-    const entity = this.docTypeEntities[entityName];
-    const matches = val.match(entity.regx);
-    if (matches) {
-      this.entityExpansionCount += matches.length;
-      if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) {
-        throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`);
+  parseAttributes(xml, pos, len, jPath, outAttrs) {
+    let count = 0;
+    const removeNS = this._removeNSPrefix;
+    const transformAttr = this.options.transformAttributeName;
+    const trimVals = this._trimValues;
+    const processEnts = this._processEntities;
+    const attrProcessor = this.options.attributeValueProcessor;
+    while (pos < len) {
+      let ch = xml.charCodeAt(pos);
+      while (ch === 32 || ch === 9 || ch === 10 || ch === 13) {
+        pos++;
+        if (pos >= len)
+          break;
+        ch = xml.charCodeAt(pos);
       }
-      const lengthBefore = val.length;
-      val = val.replace(entity.regx, entity.val);
-      if (entityConfig.maxExpandedLength) {
-        this.currentExpandedLength += val.length - lengthBefore;
-        if (this.currentExpandedLength > entityConfig.maxExpandedLength) {
-          throw new Error(`Total expanded content size exceeded: ${this.currentExpandedLength} > ${entityConfig.maxExpandedLength}`);
+      if (pos >= len)
+        break;
+      if (ch === 62 || ch === 47)
+        break;
+      const attrStart = pos;
+      if (!isNameStartChar(ch))
+        break;
+      pos++;
+      while (pos < len && isNameChar(xml.charCodeAt(pos)))
+        pos++;
+      let attrName = xml.substring(attrStart, pos);
+      if (removeNS) {
+        const colonIdx = attrName.indexOf(":");
+        if (colonIdx !== -1)
+          attrName = attrName.substring(colonIdx + 1);
+      }
+      if (transformAttr)
+        attrName = transformAttr(attrName);
+      while (pos < len && isWhitespace(xml.charCodeAt(pos)))
+        pos++;
+      if (pos < len && xml.charCodeAt(pos) === 61) {
+        pos++;
+        while (pos < len && isWhitespace(xml.charCodeAt(pos)))
+          pos++;
+        if (pos >= len)
+          break;
+        const quoteChar = xml.charCodeAt(pos);
+        if (quoteChar === 34 || quoteChar === 39) {
+          pos++;
+          const valueStart = pos;
+          while (pos < len && xml.charCodeAt(pos) !== quoteChar)
+            pos++;
+          let value = xml.substring(valueStart, pos);
+          if (trimVals && value.length > 0) {
+            const f = value.charCodeAt(0);
+            const l = value.charCodeAt(value.length - 1);
+            if (f <= 32 || l <= 32)
+              value = value.trim();
+          }
+          if (processEnts)
+            value = this.entityDecoder.decodeEntities(value);
+          if (attrProcessor)
+            value = attrProcessor(attrName, value, jPath) ?? value;
+          outAttrs[attrName] = value;
+          count++;
+          if (pos < len)
+            pos++;
         }
+      } else {
+        outAttrs[attrName] = "true";
+        count++;
       }
     }
+    return count > 0 ? -pos - 1 : pos;
   }
-  if (val.indexOf("&") === -1)
-    return val;
-  for (let entityName in this.lastEntities) {
-    const entity = this.lastEntities[entityName];
-    val = val.replace(entity.regex, entity.val);
-  }
-  if (val.indexOf("&") === -1)
-    return val;
-  if (this.options.htmlEntities) {
-    for (let entityName in this.htmlEntities) {
-      const entity = this.htmlEntities[entityName];
-      val = val.replace(entity.regex, entity.val);
+  processTagValue(value, tagName, jPath, hasAttributes, isLeaf) {
+    if (this._trimValues) {
+      const vlen = value.length;
+      if (vlen > 0) {
+        const first = value.charCodeAt(0);
+        const last = value.charCodeAt(vlen - 1);
+        if (first <= 32 || last <= 32)
+          value = value.trim();
+      }
     }
+    if (this._processEntities)
+      value = this.entityDecoder.decodeEntities(value);
+    if (this.options.tagValueProcessor) {
+      const processed = this.options.tagValueProcessor(tagName, value, jPath, hasAttributes, isLeaf);
+      if (processed !== undefined)
+        value = processed;
+    }
+    if (!value)
+      return value;
+    if (this._parseTagValue)
+      return this.parseValue(value);
+    return value;
   }
-  val = val.replace(this.ampEntity.regex, this.ampEntity.val);
-  return val;
-}
-function saveTextToParentTag(textData, parentNode, matcher, isLeafNode) {
-  if (textData) {
-    if (isLeafNode === undefined)
-      isLeafNode = parentNode.child.length === 0;
-    textData = this.parseTextData(textData, parentNode.tagname, matcher, false, parentNode[":@"] ? Object.keys(parentNode[":@"]).length !== 0 : false, isLeafNode);
-    if (textData !== undefined && textData !== "")
-      parentNode.add(this.options.textNodeName, textData);
-    textData = "";
-  }
-  return textData;
-}
-function isItStopNode(stopNodeExpressions, matcher) {
-  if (!stopNodeExpressions || stopNodeExpressions.length === 0)
-    return false;
-  for (let i = 0;i < stopNodeExpressions.length; i++) {
-    if (matcher.matches(stopNodeExpressions[i])) {
+  parseValue(val) {
+    if (val === "true")
       return true;
+    if (val === "false")
+      return false;
+    if (!val)
+      return val;
+    const firstCh = val.charCodeAt(0);
+    const isNumStart = firstCh >= 48 && firstCh <= 57 || firstCh === 43 || firstCh === 45 || firstCh === 46;
+    if (!isNumStart)
+      return val;
+    const opts = this.options.numberParseOptions;
+    if (opts.skipLike?.test(val))
+      return val;
+    if (opts.hex && firstCh === 48 && RE_HEX.test(val))
+      return Number.parseInt(val, 16);
+    if (val.length > 1 && firstCh === 48 && val.charCodeAt(1) !== 46) {
+      if (opts.leadingZeros)
+        return val;
     }
-  }
-  return false;
-}
-function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
-  let attrBoundary;
-  let tagExp = "";
-  for (let index = i;index < xmlData.length; index++) {
-    let ch = xmlData[index];
-    if (attrBoundary) {
-      if (ch === attrBoundary)
-        attrBoundary = "";
-    } else if (ch === '"' || ch === "'") {
-      attrBoundary = ch;
-    } else if (ch === closingChar[0]) {
-      if (closingChar[1]) {
-        if (xmlData[index + 1] === closingChar[1]) {
-          return {
-            data: tagExp,
-            index
-          };
-        }
-      } else {
-        return {
-          data: tagExp,
-          index
-        };
-      }
-    } else if (ch === "\t") {
-      ch = " ";
+    if (opts.scientific && RE_SCIENTIFIC.test(val)) {
+      const num = Number(val);
+      if (!Number.isNaN(num))
+        return num;
+    }
+    if (RE_NUMBER.test(val)) {
+      const num = Number(val);
+      if (!Number.isNaN(num))
+        return num;
     }
-    tagExp += ch;
+    return val;
   }
-}
-function findClosingIndex(xmlData, str, i, errMsg) {
-  const closingIndex = xmlData.indexOf(str, i);
-  if (closingIndex === -1) {
-    throw new Error(errMsg);
-  } else {
-    return closingIndex + str.length - 1;
+  parseAttributeValue(val) {
+    if (!this._parseAttributeValue)
+      return val;
+    return this.parseValue(val);
   }
-}
-function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
-  const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
-  if (!result)
-    return;
-  let tagExp = result.data;
-  const closeIndex = result.index;
-  const separatorIndex = tagExp.search(/\s/);
-  let tagName = tagExp;
-  let attrExpPresent = true;
-  if (separatorIndex !== -1) {
-    tagName = tagExp.substring(0, separatorIndex);
-    tagExp = tagExp.substring(separatorIndex + 1).trimStart();
-  }
-  const rawTagName = tagName;
-  if (removeNSPrefix) {
-    const colonIndex = tagName.indexOf(":");
-    if (colonIndex !== -1) {
-      tagName = tagName.substr(colonIndex + 1);
-      attrExpPresent = tagName !== result.data.substr(colonIndex + 1);
+  isStopNode(jPath) {
+    if (this.exactStopNodes.has(jPath))
+      return true;
+    for (const suffix of this.wildcardStopSuffixes) {
+      if (jPath.endsWith(`.${suffix}`) || jPath === suffix)
+        return true;
     }
+    return false;
   }
-  return {
-    tagName,
-    tagExp,
-    closeIndex,
-    attrExpPresent,
-    rawTagName
-  };
-}
-function readStopNodeData(xmlData, tagName, i) {
-  const startIndex = i;
-  let openTagCount = 1;
-  for (;i < xmlData.length; i++) {
-    if (xmlData[i] === "<") {
-      if (xmlData[i + 1] === "/") {
-        const closeIndex = findClosingIndex(xmlData, ">", i, `${tagName} is not closed`);
-        let closeTagName = xmlData.substring(i + 2, closeIndex).trim();
-        if (closeTagName === tagName) {
-          openTagCount--;
-          if (openTagCount === 0) {
-            return {
-              tagContent: xmlData.substring(startIndex, i),
-              i: closeIndex
-            };
-          }
-        }
-        i = closeIndex;
-      } else if (xmlData[i + 1] === "?") {
-        const closeIndex = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed.");
-        i = closeIndex;
-      } else if (xmlData.substr(i + 1, 3) === "!--") {
-        const closeIndex = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed.");
-        i = closeIndex;
-      } else if (xmlData.substr(i + 1, 2) === "![") {
-        const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
-        i = closeIndex;
+  readStopNodeContent(xml, pos, len, tagName) {
+    const closingTag = `</${tagName}`;
+    const idx = xml.indexOf(closingTag, pos);
+    if (idx === -1) {
+      return { content: xml.substring(pos), pos: len };
+    }
+    const content = xml.substring(pos, idx);
+    let endPos = idx + closingTag.length;
+    while (endPos < len && xml.charCodeAt(endPos) !== 62)
+      endPos++;
+    if (endPos < len)
+      endPos++;
+    return { content, pos: endPos };
+  }
+  addToObj(obj, key, value, jPath, isLeaf, isAttribute) {
+    const existing = obj[key];
+    if (existing !== undefined) {
+      if (!Array.isArray(existing)) {
+        obj[key] = [existing, value];
       } else {
-        const tagData = readTagExp(xmlData, i, ">");
-        if (tagData) {
-          const openTagName = tagData && tagData.tagName;
-          if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== "/") {
-            openTagCount++;
-          }
-          i = tagData.closeIndex;
-        }
+        existing.push(value);
       }
-    }
-  }
-}
-function parseValue(val, shouldParse, options) {
-  if (shouldParse && typeof val === "string") {
-    const newval = val.trim();
-    if (newval === "true")
-      return true;
-    else if (newval === "false")
-      return false;
-    else
-      return toNumber(val, options);
-  } else {
-    if (isExist(val)) {
-      return val;
+    } else if (this.options.isArray?.(key, jPath, isLeaf, isAttribute)) {
+      obj[key] = [value];
     } else {
-      return "";
+      obj[key] = value;
     }
   }
-}
-function fromCodePoint(str, base, prefix) {
-  const codePoint = Number.parseInt(str, base);
-  if (codePoint >= 0 && codePoint <= 1114111) {
-    return String.fromCodePoint(codePoint);
-  } else {
-    return prefix + str + ";";
-  }
-}
-var attrsRegx, parseXml = function(xmlData) {
-  xmlData = xmlData.replace(/\r\n?/g, `
-`);
-  const xmlObj = new XmlNode("!xml");
-  let currentNode = xmlObj;
-  let textData = "";
-  this.matcher.reset();
-  this.entityExpansionCount = 0;
-  this.currentExpandedLength = 0;
-  const docTypeReader = new DocTypeReader(this.options.processEntities);
-  for (let i = 0;i < xmlData.length; i++) {
-    const ch = xmlData[i];
-    if (ch === "<") {
-      if (xmlData[i + 1] === "/") {
-        const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
-        let tagName = xmlData.substring(i + 2, closeIndex).trim();
-        if (this.options.removeNSPrefix) {
-          const colonIndex = tagName.indexOf(":");
-          if (colonIndex !== -1) {
-            tagName = tagName.substr(colonIndex + 1);
-          }
+  flushText(textContent, cdataBuffer, jPath, parent) {
+    if (!textContent && !cdataBuffer)
+      return;
+    const textNodeName = this._textNodeName;
+    if (cdataBuffer) {
+      let decodedText = textContent;
+      if (decodedText && this._processEntities)
+        decodedText = this.entityDecoder.decodeEntities(decodedText);
+      let value = cdataBuffer + decodedText;
+      if (this._trimValues && value.length > 0) {
+        const f = value.charCodeAt(0);
+        const l = value.charCodeAt(value.length - 1);
+        if (f <= 32 || l <= 32)
+          value = value.trim();
+      }
+      if (this.options.tagValueProcessor) {
+        const processed = this.options.tagValueProcessor(textNodeName, value, jPath, false, true);
+        if (processed !== undefined)
+          value = processed;
+      }
+      if (value) {
+        const parsed = this._parseTagValue ? this.parseValue(value) : value;
+        if (parsed !== undefined && parsed !== "")
+          this.addToObj(parent, textNodeName, parsed, jPath, true, false);
+      }
+    } else {
+      const processed = this.processTagValue(textContent, textNodeName, jPath, false, true);
+      if (processed !== undefined && processed !== "")
+        this.addToObj(parent, textNodeName, processed, jPath, true, false);
+    }
+  }
+  parseChildren(xml, pos, len, parent, jPath, unpairedStack) {
+    let textContent = "";
+    let cdataBuffer = "";
+    const needsJPath = this.needsJPath;
+    while (pos < len) {
+      const ch = xml.charCodeAt(pos);
+      if (ch !== 60) {
+        const textStart = pos;
+        pos++;
+        while (pos < len && xml.charCodeAt(pos) !== 60)
+          pos++;
+        if (!textContent)
+          textContent = xml.substring(textStart, pos);
+        else
+          textContent += xml.substring(textStart, pos);
+        continue;
+      }
+      if (pos + 1 >= len)
+        break;
+      const nextCh = xml.charCodeAt(pos + 1);
+      if (nextCh === 33 && pos + 3 < len && xml.charCodeAt(pos + 2) === 45 && xml.charCodeAt(pos + 3) === 45) {
+        if (textContent || cdataBuffer) {
+          this.flushText(textContent, cdataBuffer, jPath, parent);
+          textContent = "";
+          cdataBuffer = "";
+        }
+        pos += 4;
+        const endComment = xml.indexOf("-->", pos);
+        if (endComment === -1) {
+          pos = len;
+          break;
         }
-        if (this.options.transformTagName) {
-          tagName = this.options.transformTagName(tagName);
-        }
-        if (currentNode) {
-          textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
-        }
-        const lastTagName = this.matcher.getCurrentTag();
-        if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) {
-          throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
-        }
-        if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {
-          this.matcher.pop();
-          this.tagsNodeStack.pop();
-        }
-        this.matcher.pop();
-        this.isCurrentNodeStopNode = false;
-        currentNode = this.tagsNodeStack.pop();
-        textData = "";
-        i = closeIndex;
-      } else if (xmlData[i + 1] === "?") {
-        let tagData = readTagExp(xmlData, i, false, "?>");
-        if (!tagData)
-          throw new Error("Pi Tag is not closed.");
-        textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
-        if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) {} else {
-          const childNode = new XmlNode(tagData.tagName);
-          childNode.add(this.options.textNodeName, "");
-          if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {
-            childNode[":@"] = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName);
-          }
-          this.addChild(currentNode, childNode, this.matcher, i);
-        }
-        i = tagData.closeIndex + 1;
-      } else if (xmlData.substr(i + 1, 3) === "!--") {
-        const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
-        if (this.options.commentPropName) {
-          const comment = xmlData.substring(i + 4, endIndex - 2);
-          textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
-          currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
-        }
-        i = endIndex;
-      } else if (xmlData.substr(i + 1, 2) === "!D") {
-        const result = docTypeReader.readDocType(xmlData, i);
-        this.docTypeEntities = result.entities;
-        i = result.i;
-      } else if (xmlData.substr(i + 1, 2) === "![") {
-        const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
-        const tagExp = xmlData.substring(i + 9, closeIndex);
-        textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
-        let val = this.parseTextData(tagExp, currentNode.tagname, this.matcher, true, false, true, true);
-        if (val == undefined)
-          val = "";
-        if (this.options.cdataPropName) {
-          currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);
-        } else {
-          currentNode.add(this.options.textNodeName, val);
+        if (this._commentPropName) {
+          const comment = xml.substring(pos, endComment);
+          this.addToObj(parent, this._commentPropName, comment, jPath, true, false);
         }
-        i = closeIndex + 2;
-      } else {
-        let result = readTagExp(xmlData, i, this.options.removeNSPrefix);
-        if (!result) {
-          const context = xmlData.substring(Math.max(0, i - 50), Math.min(xmlData.length, i + 50));
-          throw new Error(`readTagExp returned undefined at position ${i}. Context: "${context}"`);
-        }
-        let tagName = result.tagName;
-        const rawTagName = result.rawTagName;
-        let tagExp = result.tagExp;
-        let attrExpPresent = result.attrExpPresent;
-        let closeIndex = result.closeIndex;
-        if (this.options.transformTagName) {
-          const newTagName = this.options.transformTagName(tagName);
-          if (tagExp === tagName) {
-            tagExp = newTagName;
+        pos = endComment + 3;
+        continue;
+      }
+      if (nextCh === 33 && pos + 8 < len && isCDATA(xml, pos + 2)) {
+        pos += 9;
+        const endCdata = xml.indexOf("]]>", pos);
+        if (endCdata === -1) {
+          pos = len;
+          break;
+        }
+        const cdataContent = xml.substring(pos, endCdata);
+        if (this._cdataPropName) {
+          this.flushText(textContent, cdataBuffer, jPath, parent);
+          textContent = "";
+          cdataBuffer = "";
+          this.addToObj(parent, this._cdataPropName, cdataContent, jPath, true, false);
+        } else {
+          if (textContent) {
+            let decoded = textContent;
+            if (this._processEntities)
+              decoded = this.entityDecoder.decodeEntities(decoded);
+            cdataBuffer += decoded;
+            textContent = "";
           }
-          tagName = newTagName;
+          cdataBuffer += cdataContent;
+        }
+        pos = endCdata + 3;
+        continue;
+      }
+      if (nextCh === 33 && pos + 9 < len && isDOCTYPE(xml, pos + 2)) {
+        pos += 9;
+        let depth = 1;
+        while (pos < len && depth > 0) {
+          const c = xml.charCodeAt(pos);
+          if (c === 60)
+            depth++;
+          else if (c === 62)
+            depth--;
+          pos++;
         }
-        if (this.options.strictReservedNames && (tagName === this.options.commentPropName || tagName === this.options.cdataPropName)) {
-          throw new Error(`Invalid tag name: ${tagName}`);
+        continue;
+      }
+      if (nextCh === 63) {
+        pos += 2;
+        const piNameStart = pos;
+        while (pos < len && !isWhitespace(xml.charCodeAt(pos)) && xml.charCodeAt(pos) !== 63)
+          pos++;
+        const piTarget = xml.substring(piNameStart, pos);
+        const endPi = xml.indexOf("?>", pos);
+        if (endPi === -1) {
+          pos = len;
+          break;
         }
-        if (currentNode && textData) {
-          if (currentNode.tagname !== "!xml") {
-            textData = this.saveTextToParentTag(textData, currentNode, this.matcher, false);
+        const piContent = xml.substring(pos, endPi).trim();
+        if (piTarget === "xml") {
+          if (!this._ignoreDeclaration && this._piPropName) {
+            const declAttrs = this.parsePiAttributes(piContent);
+            this.addToObj(parent, this._piPropName, { [piTarget]: declAttrs }, jPath, true, false);
           }
+        } else if (!this._ignorePiTags && this._piPropName) {
+          this.addToObj(parent, this._piPropName, { [piTarget]: piContent }, jPath, true, false);
         }
-        const lastTag = currentNode;
-        if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
-          currentNode = this.tagsNodeStack.pop();
-          this.matcher.pop();
-        }
-        let isSelfClosing = false;
-        if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
-          isSelfClosing = true;
-          if (tagName[tagName.length - 1] === "/") {
-            tagName = tagName.substr(0, tagName.length - 1);
-            tagExp = tagName;
-          } else {
-            tagExp = tagExp.substr(0, tagExp.length - 1);
+        pos = endPi + 2;
+        continue;
+      }
+      if (nextCh === 47) {
+        if (textContent || cdataBuffer) {
+          this.flushText(textContent, cdataBuffer, jPath, parent);
+          textContent = "";
+          cdataBuffer = "";
+        }
+        pos += 2;
+        const nameStart2 = pos;
+        const nameEnd2 = this.readTagName(xml, pos, len);
+        const closingName = this.extractTagName(xml, nameStart2, nameEnd2);
+        pos = nameEnd2;
+        while (pos < len && isWhitespace(xml.charCodeAt(pos)))
+          pos++;
+        if (pos < len && xml.charCodeAt(pos) === 62)
+          pos++;
+        if (unpairedStack.length > 0 && unpairedStack[unpairedStack.length - 1] === closingName) {
+          unpairedStack.pop();
+          continue;
+        }
+        return pos;
+      }
+      if (textContent || cdataBuffer) {
+        this.flushText(textContent, cdataBuffer, jPath, parent);
+        textContent = "";
+        cdataBuffer = "";
+      }
+      pos++;
+      const nameStart = pos;
+      const nameEnd = this.readTagName(xml, pos, len);
+      const tagName = this.extractTagName(xml, nameStart, nameEnd);
+      if (!tagName) {
+        pos = nameEnd + 1;
+        continue;
+      }
+      pos = nameEnd;
+      const childJPath = needsJPath ? jPath ? `${jPath}.${tagName}` : tagName : "";
+      let attrs = {};
+      let hasAttrs = false;
+      if (!this._ignoreAttributes) {
+        const attrResult = this.parseAttributes(xml, pos, len, childJPath, attrs);
+        if (attrResult < 0) {
+          pos = -attrResult - 1;
+          hasAttrs = true;
+        } else {
+          pos = attrResult;
+        }
+      } else {
+        while (pos < len) {
+          const c = xml.charCodeAt(pos);
+          if (c === 62 || c === 47)
+            break;
+          if (c === 34 || c === 39) {
+            pos++;
+            while (pos < len && xml.charCodeAt(pos) !== c)
+              pos++;
           }
-          attrExpPresent = tagName !== tagExp;
-        }
-        let prefixedAttrs = null;
-        let rawAttrs = {};
-        let namespace = undefined;
-        namespace = extractNamespace(rawTagName);
-        if (tagName !== xmlObj.tagname) {
-          this.matcher.push(tagName, {}, namespace);
-        }
-        if (tagName !== tagExp && attrExpPresent) {
-          prefixedAttrs = this.buildAttributesMap(tagExp, this.matcher, tagName);
-          if (prefixedAttrs) {
-            rawAttrs = extractRawAttributes(prefixedAttrs, this.options);
+          pos++;
+        }
+      }
+      if (this.options.updateTag) {
+        const newName = this.options.updateTag(tagName, childJPath, attrs);
+        if (newName === false) {
+          while (pos < len && isWhitespace(xml.charCodeAt(pos)))
+            pos++;
+          if (pos < len && xml.charCodeAt(pos) === 47) {
+            pos += 2;
+          } else if (pos < len && xml.charCodeAt(pos) === 62) {
+            pos++;
+            const closingTag = `</${tagName}>`;
+            const closeIdx = xml.indexOf(closingTag, pos);
+            if (closeIdx !== -1)
+              pos = closeIdx + closingTag.length;
           }
+          continue;
         }
-        if (tagName !== xmlObj.tagname) {
-          this.isCurrentNodeStopNode = this.isItStopNode(this.stopNodeExpressions, this.matcher);
+      }
+      while (pos < len && isWhitespace(xml.charCodeAt(pos)))
+        pos++;
+      if (pos < len && xml.charCodeAt(pos) === 47) {
+        pos += 2;
+        if (hasAttrs || this._alwaysCreateTextNode) {
+          const childObj = {};
+          if (hasAttrs)
+            this.applyAttributes(childObj, attrs, childJPath);
+          if (this._alwaysCreateTextNode)
+            childObj[this._textNodeName] = "";
+          this.addToObj(parent, tagName, childObj, childJPath, true, false);
+        } else {
+          this.addToObj(parent, tagName, "", childJPath, true, false);
         }
-        const startIndex = i;
-        if (this.isCurrentNodeStopNode) {
-          let tagContent = "";
-          if (isSelfClosing) {
-            i = result.closeIndex;
-          } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
-            i = result.closeIndex;
+        continue;
+      }
+      if (pos < len && xml.charCodeAt(pos) === 62) {
+        pos++;
+        if (this.unpairedSet.has(tagName)) {
+          if (hasAttrs) {
+            const childObj2 = {};
+            this.applyAttributes(childObj2, attrs, childJPath);
+            this.addToObj(parent, tagName, childObj2, childJPath, true, false);
           } else {
-            const result2 = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
-            if (!result2)
-              throw new Error(`Unexpected end of ${rawTagName}`);
-            i = result2.i;
-            tagContent = result2.tagContent;
+            this.addToObj(parent, tagName, "", childJPath, true, false);
           }
-          const childNode = new XmlNode(tagName);
-          if (prefixedAttrs) {
-            childNode[":@"] = prefixedAttrs;
+          unpairedStack.push(tagName);
+          continue;
+        }
+        if (this.exactStopNodes.size > 0 || this.wildcardStopSuffixes.length > 0) {
+          if (this.isStopNode(childJPath)) {
+            const stopResult = this.readStopNodeContent(xml, pos, len, tagName);
+            const childObj2 = {};
+            if (hasAttrs)
+              this.applyAttributes(childObj2, attrs, childJPath);
+            if (stopResult.content)
+              childObj2[this._textNodeName] = stopResult.content;
+            this.addToObj(parent, tagName, childObj2, childJPath, true, false);
+            pos = stopResult.pos;
+            continue;
           }
-          childNode.add(this.options.textNodeName, tagContent);
-          this.matcher.pop();
-          this.isCurrentNodeStopNode = false;
-          this.addChild(currentNode, childNode, this.matcher, startIndex);
-        } else {
-          if (isSelfClosing) {
-            if (this.options.transformTagName) {
-              const newTagName = this.options.transformTagName(tagName);
-              if (tagExp === tagName) {
-                tagExp = newTagName;
-              }
-              tagName = newTagName;
-            }
-            const childNode = new XmlNode(tagName);
-            if (prefixedAttrs) {
-              childNode[":@"] = prefixedAttrs;
-            }
-            this.addChild(currentNode, childNode, this.matcher, startIndex);
-            this.matcher.pop();
-            this.isCurrentNodeStopNode = false;
-          } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
-            const childNode = new XmlNode(tagName);
-            if (prefixedAttrs) {
-              childNode[":@"] = prefixedAttrs;
+        }
+        const childObj = {};
+        if (hasAttrs)
+          this.applyAttributes(childObj, attrs, childJPath);
+        pos = this.parseChildren(xml, pos, len, childObj, childJPath, unpairedStack);
+        const textNodeName = this._textNodeName;
+        const textValue = childObj[textNodeName];
+        if (!hasAttrs && !this._alwaysCreateTextNode) {
+          let isLeaf = true;
+          for (const k in childObj) {
+            if (k !== textNodeName) {
+              isLeaf = false;
+              break;
             }
-            this.addChild(currentNode, childNode, this.matcher, startIndex);
-            this.matcher.pop();
-            this.isCurrentNodeStopNode = false;
-            i = result.closeIndex;
+          }
+          if (isLeaf) {
+            this.addToObj(parent, tagName, textValue !== undefined ? textValue : "", childJPath, true, false);
             continue;
-          } else {
-            const childNode = new XmlNode(tagName);
-            if (this.tagsNodeStack.length > this.options.maxNestedTags) {
-              throw new Error("Maximum nested tags exceeded");
-            }
-            this.tagsNodeStack.push(currentNode);
-            if (prefixedAttrs) {
-              childNode[":@"] = prefixedAttrs;
-            }
-            this.addChild(currentNode, childNode, this.matcher, startIndex);
-            currentNode = childNode;
           }
-          textData = "";
-          i = closeIndex;
         }
+        this.addToObj(parent, tagName, childObj, childJPath, false, false);
       }
-    } else {
-      textData += xmlData[i];
     }
+    if (textContent || cdataBuffer) {
+      this.flushText(textContent, cdataBuffer, jPath, parent);
+    }
+    return pos;
   }
-  return xmlObj.child;
-};
-var init_OrderedObjParser = __esm(() => {
-  init_util();
-  init_xmlNode();
-  init_DocTypeReader();
-  init_strnum();
-  init_src();
-  attrsRegx = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
-});
-
-// ../../node_modules/fast-xml-parser/src/xmlparser/node2json.js
-function stripAttributePrefix(attrs, prefix) {
-  if (!attrs || typeof attrs !== "object")
-    return {};
-  if (!prefix)
-    return attrs;
-  const rawAttrs = {};
-  for (const key in attrs) {
-    if (key.startsWith(prefix)) {
-      const rawName = key.substring(prefix.length);
-      rawAttrs[rawName] = attrs[key];
-    } else {
-      rawAttrs[key] = attrs[key];
-    }
-  }
-  return rawAttrs;
-}
-function prettify(node, options, matcher) {
-  return compress(node, options, matcher);
-}
-function compress(arr, options, matcher) {
-  let text;
-  const compressedObj = {};
-  for (let i = 0;i < arr.length; i++) {
-    const tagObj = arr[i];
-    const property = propName(tagObj);
-    if (property !== undefined && property !== options.textNodeName) {
-      const rawAttrs = stripAttributePrefix(tagObj[":@"] || {}, options.attributeNamePrefix);
-      matcher.push(property, rawAttrs);
-    }
-    if (property === options.textNodeName) {
-      if (text === undefined)
-        text = tagObj[property];
-      else
-        text += "" + tagObj[property];
-    } else if (property === undefined) {
-      continue;
-    } else if (tagObj[property]) {
-      let val = compress(tagObj[property], options, matcher);
-      const isLeaf = isLeafTag(val, options);
-      if (tagObj[":@"]) {
-        assignAttributes(val, tagObj[":@"], matcher, options);
-      } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode) {
-        val = val[options.textNodeName];
-      } else if (Object.keys(val).length === 0) {
-        if (options.alwaysCreateTextNode)
-          val[options.textNodeName] = "";
+  parseChildrenOrdered(xml, pos, len, parent, jPath) {
+    let textContent = "";
+    const needsJPath = this.needsJPath;
+    while (pos < len) {
+      const ch = xml.charCodeAt(pos);
+      if (ch !== 60) {
+        const textStart = pos;
+        pos++;
+        while (pos < len && xml.charCodeAt(pos) !== 60)
+          pos++;
+        if (!textContent)
+          textContent = xml.substring(textStart, pos);
         else
-          val = "";
+          textContent += xml.substring(textStart, pos);
+        continue;
       }
-      if (tagObj[METADATA_SYMBOL2] !== undefined && typeof val === "object" && val !== null) {
-        val[METADATA_SYMBOL2] = tagObj[METADATA_SYMBOL2];
+      if (pos + 1 >= len)
+        break;
+      const nextCh = xml.charCodeAt(pos + 1);
+      if (nextCh === 33 && pos + 3 < len && xml.charCodeAt(pos + 2) === 45 && xml.charCodeAt(pos + 3) === 45) {
+        if (textContent) {
+          const processed = this.processTagValue(textContent, this._textNodeName, jPath, false, true);
+          if (processed !== undefined && processed !== "")
+            parent.push({ [this._textNodeName]: processed });
+          textContent = "";
+        }
+        pos += 4;
+        const endComment = xml.indexOf("-->", pos);
+        if (endComment === -1) {
+          pos = len;
+          break;
+        }
+        if (this._commentPropName) {
+          parent.push({ [this._commentPropName]: [{ [this._textNodeName]: xml.substring(pos, endComment) }] });
+        }
+        pos = endComment + 3;
+        continue;
       }
-      if (compressedObj[property] !== undefined && Object.prototype.hasOwnProperty.call(compressedObj, property)) {
-        if (!Array.isArray(compressedObj[property])) {
-          compressedObj[property] = [compressedObj[property]];
+      if (nextCh === 33 && pos + 8 < len && isCDATA(xml, pos + 2)) {
+        pos += 9;
+        const endCdata = xml.indexOf("]]>", pos);
+        if (endCdata === -1) {
+          pos = len;
+          break;
         }
-        compressedObj[property].push(val);
-      } else {
-        const jPathOrMatcher = options.jPath ? matcher.toString() : matcher;
-        if (options.isArray(property, jPathOrMatcher, isLeaf)) {
-          compressedObj[property] = [val];
+        const cdataContent = xml.substring(pos, endCdata);
+        if (this._cdataPropName) {
+          if (textContent) {
+            const processed = this.processTagValue(textContent, this._textNodeName, jPath, false, true);
+            if (processed !== undefined && processed !== "")
+              parent.push({ [this._textNodeName]: processed });
+            textContent = "";
+          }
+          parent.push({ [this._cdataPropName]: [{ [this._textNodeName]: cdataContent }] });
         } else {
-          compressedObj[property] = val;
+          textContent += cdataContent;
         }
+        pos = endCdata + 3;
+        continue;
       }
-      if (property !== undefined && property !== options.textNodeName) {
-        matcher.pop();
+      if (nextCh === 33 && pos + 9 < len && isDOCTYPE(xml, pos + 2)) {
+        pos += 9;
+        let depth = 1;
+        while (pos < len && depth > 0) {
+          const c = xml.charCodeAt(pos);
+          if (c === 60)
+            depth++;
+          else if (c === 62)
+            depth--;
+          pos++;
+        }
+        continue;
       }
-    }
-  }
-  if (typeof text === "string") {
-    if (text.length > 0)
-      compressedObj[options.textNodeName] = text;
-  } else if (text !== undefined)
-    compressedObj[options.textNodeName] = text;
-  return compressedObj;
-}
-function propName(obj) {
-  const keys = Object.keys(obj);
-  for (let i = 0;i < keys.length; i++) {
-    const key = keys[i];
-    if (key !== ":@")
-      return key;
-  }
-}
-function assignAttributes(obj, attrMap, matcher, options) {
-  if (attrMap) {
-    const keys = Object.keys(attrMap);
-    const len = keys.length;
-    for (let i = 0;i < len; i++) {
-      const atrrName = keys[i];
-      const rawAttrName = atrrName.startsWith(options.attributeNamePrefix) ? atrrName.substring(options.attributeNamePrefix.length) : atrrName;
-      const jPathOrMatcher = options.jPath ? matcher.toString() + "." + rawAttrName : matcher;
-      if (options.isArray(atrrName, jPathOrMatcher, true, true)) {
-        obj[atrrName] = [attrMap[atrrName]];
+      if (nextCh === 63) {
+        pos += 2;
+        const endPi = xml.indexOf("?>", pos);
+        if (endPi === -1) {
+          pos = len;
+          break;
+        }
+        pos = endPi + 2;
+        continue;
+      }
+      if (nextCh === 47) {
+        if (textContent) {
+          const processed = this.processTagValue(textContent, this._textNodeName, jPath, false, true);
+          if (processed !== undefined && processed !== "")
+            parent.push({ [this._textNodeName]: processed });
+          textContent = "";
+        }
+        pos += 2;
+        const nameEnd2 = this.readTagName(xml, pos, len);
+        pos = nameEnd2;
+        while (pos < len && isWhitespace(xml.charCodeAt(pos)))
+          pos++;
+        if (pos < len && xml.charCodeAt(pos) === 62)
+          pos++;
+        return pos;
+      }
+      if (textContent) {
+        const processed = this.processTagValue(textContent, this._textNodeName, jPath, false, true);
+        if (processed !== undefined && processed !== "")
+          parent.push({ [this._textNodeName]: processed });
+        textContent = "";
+      }
+      pos++;
+      const nameStart = pos;
+      const nameEnd = this.readTagName(xml, pos, len);
+      const tagName = this.extractTagName(xml, nameStart, nameEnd);
+      if (!tagName) {
+        pos = nameEnd + 1;
+        continue;
+      }
+      pos = nameEnd;
+      const childJPath = needsJPath ? jPath ? `${jPath}.${tagName}` : tagName : "";
+      let attrs = {};
+      let hasAttrs = false;
+      if (!this._ignoreAttributes) {
+        const attrResult = this.parseAttributes(xml, pos, len, childJPath, attrs);
+        if (attrResult < 0) {
+          pos = -attrResult - 1;
+          hasAttrs = true;
+        } else {
+          pos = attrResult;
+        }
       } else {
-        obj[atrrName] = attrMap[atrrName];
+        while (pos < len) {
+          const c = xml.charCodeAt(pos);
+          if (c === 62 || c === 47)
+            break;
+          if (c === 34 || c === 39) {
+            pos++;
+            while (pos < len && xml.charCodeAt(pos) !== c)
+              pos++;
+          }
+          pos++;
+        }
+      }
+      while (pos < len && isWhitespace(xml.charCodeAt(pos)))
+        pos++;
+      const orderedNode = { [tagName]: [] };
+      if (hasAttrs) {
+        const attrKey = ":@";
+        orderedNode[attrKey] = {};
+        for (const name in attrs) {
+          orderedNode[attrKey][this._attrPrefix + name] = this.parseAttributeValue(attrs[name]);
+        }
+      }
+      if (pos < len && xml.charCodeAt(pos) === 47) {
+        pos += 2;
+        parent.push(orderedNode);
+        continue;
+      }
+      if (pos < len && xml.charCodeAt(pos) === 62) {
+        pos++;
+        pos = this.parseChildrenOrdered(xml, pos, len, orderedNode[tagName], childJPath);
+        parent.push(orderedNode);
       }
     }
+    if (textContent) {
+      const processed = this.processTagValue(textContent, this._textNodeName, jPath, false, true);
+      if (processed !== undefined && processed !== "")
+        parent.push({ [this._textNodeName]: processed });
+    }
+    return pos;
   }
-}
-function isLeafTag(obj, options) {
-  const { textNodeName } = options;
-  const propCount = Object.keys(obj).length;
-  if (propCount === 0) {
-    return true;
-  }
-  if (propCount === 1 && (obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)) {
-    return true;
-  }
-  return false;
-}
-var METADATA_SYMBOL2;
-var init_node2json = __esm(() => {
-  init_xmlNode();
-  init_src();
-  METADATA_SYMBOL2 = XmlNode.getMetaDataSymbol();
-});
-
-// ../../node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
-class XMLParser {
-  constructor(options) {
-    this.externalEntities = {};
-    this.options = buildOptions(options);
-  }
-  parse(xmlData, validationOption) {
-    if (typeof xmlData !== "string" && xmlData.toString) {
-      xmlData = xmlData.toString();
-    } else if (typeof xmlData !== "string") {
-      throw new Error("XML data is accepted in String or Bytes[] form.");
-    }
-    if (validationOption) {
-      if (validationOption === true)
-        validationOption = {};
-      const result = validate(xmlData, validationOption);
-      if (result !== true) {
-        throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`);
-      }
-    }
-    const orderedObjParser = new OrderedObjParser(this.options);
-    orderedObjParser.addExternalEntities(this.externalEntities);
-    const orderedResult = orderedObjParser.parseXml(xmlData);
-    if (this.options.preserveOrder || orderedResult === undefined)
-      return orderedResult;
-    else
-      return prettify(orderedResult, this.options, orderedObjParser.matcher);
-  }
-  addEntity(key, value) {
-    if (value.indexOf("&") !== -1) {
-      throw new Error("Entity value can't have '&'");
-    } else if (key.indexOf("&") !== -1 || key.indexOf(";") !== -1) {
-      throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
-    } else if (value === "&") {
-      throw new Error("An entity with value '&' is not permitted");
+  applyAttributes(obj, attrs, jPath) {
+    const prefix = this._attrPrefix;
+    if (this._attrsGroupName) {
+      const group = {};
+      for (const name in attrs) {
+        group[prefix + name] = this.parseAttributeValue(attrs[name]);
+      }
+      obj[this._attrsGroupName] = group;
     } else {
-      this.externalEntities[key] = value;
+      for (const name in attrs) {
+        obj[prefix + name] = this.parseAttributeValue(attrs[name]);
+      }
     }
   }
-  static getMetaDataSymbol() {
-    return XmlNode.getMetaDataSymbol();
+  parsePiAttributes(content) {
+    const attrs = {};
+    let i = 0;
+    const len = content.length;
+    while (i < len) {
+      while (i < len && isWhitespace(content.charCodeAt(i)))
+        i++;
+      if (i >= len)
+        break;
+      const nameStart = i;
+      while (i < len && !isWhitespace(content.charCodeAt(i)) && content.charCodeAt(i) !== 61)
+        i++;
+      const name = content.substring(nameStart, i);
+      if (!name)
+        break;
+      while (i < len && isWhitespace(content.charCodeAt(i)))
+        i++;
+      if (i < len && content.charCodeAt(i) === 61) {
+        i++;
+        while (i < len && isWhitespace(content.charCodeAt(i)))
+          i++;
+        if (i < len) {
+          const quote = content.charCodeAt(i);
+          if (quote === 34 || quote === 39) {
+            i++;
+            const valueStart = i;
+            while (i < len && content.charCodeAt(i) !== quote)
+              i++;
+            attrs[name] = content.substring(valueStart, i);
+            if (i < len)
+              i++;
+          }
+        }
+      }
+    }
+    return attrs;
   }
 }
-var init_XMLParser = __esm(() => {
-  init_OptionsBuilder();
-  init_OrderedObjParser();
-  init_node2json();
-  init_validator();
-  init_xmlNode();
-});
-
-// ../../node_modules/fast-xml-parser/src/fxp.js
-var init_fxp = __esm(() => {
-  init_XMLParser();
+var xmlEntities, htmlEntities, _encodeMap, defaultParserOptions, RE_HEX, RE_SCIENTIFIC, RE_NUMBER;
+var init_dist = __esm(() => {
+  xmlEntities = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    apos: "'"
+  };
+  htmlEntities = {
+    nbsp: " ",
+    copy: "©",
+    reg: "®",
+    trade: "™",
+    euro: "€",
+    pound: "£",
+    yen: "¥",
+    cent: "¢",
+    deg: "°",
+    micro: "µ",
+    middot: "·",
+    bull: "•",
+    hellip: "…",
+    prime: "′",
+    Prime: "″",
+    laquo: "«",
+    raquo: "»",
+    lsquo: "‘",
+    rsquo: "’",
+    ldquo: "“",
+    rdquo: "”",
+    ndash: "–",
+    mdash: "—",
+    iexcl: "¡",
+    iquest: "¿",
+    sect: "§",
+    para: "¶",
+    dagger: "†",
+    Dagger: "‡",
+    lsaquo: "‹",
+    rsaquo: "›",
+    oline: "‾",
+    frasl: "⁄",
+    ensp: " ",
+    emsp: " ",
+    thinsp: " ",
+    zwnj: "‌",
+    zwj: "‍",
+    lrm: "‎",
+    rlm: "‏",
+    times: "×",
+    divide: "÷",
+    plusmn: "±",
+    ne: "≠",
+    le: "≤",
+    ge: "≥",
+    infin: "∞",
+    fnof: "ƒ",
+    Alpha: "Α",
+    Beta: "Β",
+    Gamma: "Γ",
+    Delta: "Δ",
+    Epsilon: "Ε",
+    Zeta: "Ζ",
+    Eta: "Η",
+    Theta: "Θ",
+    Iota: "Ι",
+    Kappa: "Κ",
+    Lambda: "Λ",
+    Mu: "Μ",
+    Nu: "Ν",
+    Xi: "Ξ",
+    Omicron: "Ο",
+    Pi: "Π",
+    Rho: "Ρ",
+    Sigma: "Σ",
+    Tau: "Τ",
+    Upsilon: "Υ",
+    Phi: "Φ",
+    Chi: "Χ",
+    Psi: "Ψ",
+    Omega: "Ω",
+    alpha: "α",
+    beta: "β",
+    gamma: "γ",
+    delta: "δ",
+    epsilon: "ε",
+    zeta: "ζ",
+    eta: "η",
+    theta: "θ",
+    iota: "ι",
+    kappa: "κ",
+    lambda: "λ",
+    mu: "μ",
+    nu: "ν",
+    xi: "ξ",
+    omicron: "ο",
+    pi: "π",
+    rho: "ρ",
+    sigmaf: "ς",
+    sigma: "σ",
+    tau: "τ",
+    upsilon: "υ",
+    phi: "φ",
+    chi: "χ",
+    psi: "ψ",
+    omega: "ω",
+    thetasym: "ϑ",
+    upsih: "ϒ",
+    piv: "ϖ",
+    larr: "←",
+    uarr: "↑",
+    rarr: "→",
+    darr: "↓",
+    harr: "↔",
+    crarr: "↵",
+    lArr: "⇐",
+    uArr: "⇑",
+    rArr: "⇒",
+    dArr: "⇓",
+    hArr: "⇔",
+    forall: "∀",
+    part: "∂",
+    exist: "∃",
+    empty: "∅",
+    nabla: "∇",
+    isin: "∈",
+    notin: "∉",
+    ni: "∋",
+    prod: "∏",
+    sum: "∑",
+    minus: "−",
+    lowast: "∗",
+    radic: "√",
+    prop: "∝",
+    ang: "∠",
+    and: "∧",
+    or: "∨",
+    cap: "∩",
+    cup: "∪",
+    int: "∫",
+    there4: "∴",
+    sim: "∼",
+    cong: "≅",
+    asymp: "≈",
+    equiv: "≡",
+    sub: "⊂",
+    sup: "⊃",
+    nsub: "⊄",
+    sube: "⊆",
+    supe: "⊇",
+    oplus: "⊕",
+    otimes: "⊗",
+    perp: "⊥",
+    sdot: "⋅",
+    lceil: "⌈",
+    rceil: "⌉",
+    lfloor: "⌊",
+    rfloor: "⌋",
+    lang: "〈",
+    rang: "〉",
+    loz: "◊",
+    spades: "♠",
+    clubs: "♣",
+    hearts: "♥",
+    diams: "♦",
+    Agrave: "À",
+    Aacute: "Á",
+    Acirc: "Â",
+    Atilde: "Ã",
+    Auml: "Ä",
+    Aring: "Å",
+    AElig: "Æ",
+    Ccedil: "Ç",
+    Egrave: "È",
+    Eacute: "É",
+    Ecirc: "Ê",
+    Euml: "Ë",
+    Igrave: "Ì",
+    Iacute: "Í",
+    Icirc: "Î",
+    Iuml: "Ï",
+    ETH: "Ð",
+    Ntilde: "Ñ",
+    Ograve: "Ò",
+    Oacute: "Ó",
+    Ocirc: "Ô",
+    Otilde: "Õ",
+    Ouml: "Ö",
+    Oslash: "Ø",
+    Ugrave: "Ù",
+    Uacute: "Ú",
+    Ucirc: "Û",
+    Uuml: "Ü",
+    Yacute: "Ý",
+    THORN: "Þ",
+    szlig: "ß",
+    agrave: "à",
+    aacute: "á",
+    acirc: "â",
+    atilde: "ã",
+    auml: "ä",
+    aring: "å",
+    aelig: "æ",
+    ccedil: "ç",
+    egrave: "è",
+    eacute: "é",
+    ecirc: "ê",
+    euml: "ë",
+    igrave: "ì",
+    iacute: "í",
+    icirc: "î",
+    iuml: "ï",
+    eth: "ð",
+    ntilde: "ñ",
+    ograve: "ò",
+    oacute: "ó",
+    ocirc: "ô",
+    otilde: "õ",
+    ouml: "ö",
+    oslash: "ø",
+    ugrave: "ù",
+    uacute: "ú",
+    ucirc: "û",
+    uuml: "ü",
+    yacute: "ý",
+    thorn: "þ",
+    yuml: "ÿ",
+    OElig: "Œ",
+    oelig: "œ",
+    Scaron: "Š",
+    scaron: "š",
+    Yuml: "Ÿ",
+    circ: "ˆ",
+    tilde: "˜"
+  };
+  _encodeMap = [];
+  _encodeMap[38] = "&amp;";
+  _encodeMap[60] = "&lt;";
+  _encodeMap[62] = "&gt;";
+  _encodeMap[34] = "&quot;";
+  _encodeMap[39] = "&apos;";
+  defaultParserOptions = {
+    attributeNamePrefix: "@_",
+    attributesGroupName: false,
+    textNodeName: "#text",
+    ignoreAttributes: true,
+    removeNSPrefix: false,
+    allowBooleanAttributes: false,
+    alwaysCreateTextNode: false,
+    trimValues: true,
+    parseTagValue: true,
+    parseAttributeValue: false,
+    processEntities: true,
+    htmlEntities: false,
+    commentPropName: false,
+    cdataPropName: false,
+    piPropName: false,
+    preserveOrder: false,
+    stopNodes: [],
+    unpairedTags: [],
+    isArray: undefined,
+    tagValueProcessor: undefined,
+    attributeValueProcessor: undefined,
+    updateTag: undefined,
+    numberParseOptions: {
+      hex: true,
+      leadingZeros: true,
+      scientific: true
+    },
+    ignorePiTags: false,
+    transformAttributeName: undefined,
+    transformTagName: undefined,
+    ignoreDeclaration: false
+  };
+  RE_HEX = /^0x[\da-fA-F]+$/;
+  RE_SCIENTIFIC = /^[+-]?\d+(\.\d+)?[eE][+-]?\d+$/;
+  RE_NUMBER = /^[+-]?(\d+\.?\d*|\.\d+)$/;
 });
 
 // src/aws/client.ts
@@ -3268,7 +2394,7 @@ function buildQueryParams(params) {
   return result;
 }
 var init_client = __esm(() => {
-  init_fxp();
+  init_dist();
 });
 
 // src/aws/cloudformation.ts
@@ -8395,7 +7521,7 @@ function createGoDaddyValidator(apiKey, apiSecret, acmRegion, environment) {
 function createRoute53Validator(region, hostedZoneId, acmRegion) {
   return new UnifiedDnsValidator({ provider: "route53", region, hostedZoneId }, acmRegion || region);
 }
-var init_validator2 = __esm(() => {
+var init_validator = __esm(() => {
   init_acm();
   init_dns();
 });
@@ -8514,7 +7640,7 @@ class DnsProviderFactory {
 var dnsProviders;
 var init_dns = __esm(() => {
   init_route53_adapter();
-  init_validator2();
+  init_validator();
   init_route53_adapter();
   dnsProviders = new DnsProviderFactory;
 });
@@ -9673,7 +8799,7 @@ var init_static_site_external_dns = __esm(() => {
   init_cloudfront();
   init_acm();
   init_dns();
-  init_validator2();
+  init_validator();
 });
 
 // src/deploy/static-site.ts