@sentry/craft 2.24.2 → 2.25.0

package/dist/craft

@@ -104254,7 +104254,7 @@ var init_storage = __esm({
   }
 });
 
-// node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/util.js
+// node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/util.js
 function getAllMatches(string, regex2) {
   const matches = [];
   let match2 = regex2.exec(string);
@@ -104273,9 +104273,9 @@ function getAllMatches(string, regex2) {
 function isExist(v9) {
   return typeof v9 !== "undefined";
 }
-var nameStartChar, nameChar, nameRegexp, regexName, isName;
+var nameStartChar, nameChar, nameRegexp, regexName, isName, DANGEROUS_PROPERTY_NAMES, criticalProperties;
 var init_util5 = __esm({
-  "node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/util.js"() {
+  "node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/util.js"() {
     "use strict";
     init_import_meta_url();
     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";
@@ -104286,10 +104286,23 @@ var init_util5 = __esm({
       const match2 = regexName.exec(string);
       return !(match2 === null || typeof match2 === "undefined");
     };
+    DANGEROUS_PROPERTY_NAMES = [
+      // '__proto__',
+      // 'constructor',
+      // 'prototype',
+      "hasOwnProperty",
+      "toString",
+      "valueOf",
+      "__defineGetter__",
+      "__defineSetter__",
+      "__lookupGetter__",
+      "__lookupSetter__"
+    ];
+    criticalProperties = ["__proto__", "constructor", "prototype"];
   }
 });
 
-// node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/validator.js
+// node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/validator.js
 function validate3(xmlData, options) {
   options = Object.assign({}, defaultOptions2, options);
   const tags = [];
@@ -104588,7 +104601,7 @@ function getPositionFromMatch(match2) {
 }
 var defaultOptions2, doubleQuote, singleQuote, validAttrStrRegxp;
 var init_validator = __esm({
-  "node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/validator.js"() {
+  "node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/validator.js"() {
     "use strict";
     init_import_meta_url();
     init_util5();
@@ -104603,7 +104616,23 @@ var init_validator = __esm({
   }
 });
 
-// node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
+// node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
+function validatePropertyName(propertyName, optionName) {
+  if (typeof propertyName !== "string") {
+    return;
+  }
+  const normalized = propertyName.toLowerCase();
+  if (DANGEROUS_PROPERTY_NAMES.some((dangerous) => normalized === dangerous.toLowerCase())) {
+    throw new Error(
+      `[SECURITY] Invalid ${optionName}: "${propertyName}" is a reserved JavaScript keyword that could cause prototype pollution`
+    );
+  }
+  if (criticalProperties.some((dangerous) => normalized === dangerous.toLowerCase())) {
+    throw new Error(
+      `[SECURITY] Invalid ${optionName}: "${propertyName}" is a reserved JavaScript keyword that could cause prototype pollution`
+    );
+  }
+}
 function normalizeProcessEntities(value) {
   if (typeof value === "boolean") {
     return {
@@ -104613,6 +104642,7 @@ function normalizeProcessEntities(value) {
       maxExpansionDepth: 10,
       maxTotalExpansions: 1e3,
       maxExpandedLength: 1e5,
+      maxEntityCount: 100,
       allowedTags: null,
       tagFilter: null
     };
@@ -104620,21 +104650,28 @@ function normalizeProcessEntities(value) {
   if (typeof value === "object" && value !== null) {
     return {
       enabled: value.enabled !== false,
-      // default true if not specified
-      maxEntitySize: value.maxEntitySize ?? 1e4,
-      maxExpansionDepth: value.maxExpansionDepth ?? 10,
-      maxTotalExpansions: value.maxTotalExpansions ?? 1e3,
-      maxExpandedLength: value.maxExpandedLength ?? 1e5,
+      maxEntitySize: Math.max(1, value.maxEntitySize ?? 1e4),
+      maxExpansionDepth: Math.max(1, value.maxExpansionDepth ?? 10),
+      maxTotalExpansions: Math.max(1, value.maxTotalExpansions ?? 1e3),
+      maxExpandedLength: Math.max(1, value.maxExpandedLength ?? 1e5),
+      maxEntityCount: Math.max(1, value.maxEntityCount ?? 100),
       allowedTags: value.allowedTags ?? null,
       tagFilter: value.tagFilter ?? null
     };
   }
   return normalizeProcessEntities(true);
 }
-var defaultOptions3, buildOptions;
+var defaultOnDangerousProperty, defaultOptions3, buildOptions;
 var init_OptionsBuilder = __esm({
-  "node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js"() {
+  "node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js"() {
     init_import_meta_url();
+    init_util5();
+    defaultOnDangerousProperty = (name) => {
+      if (DANGEROUS_PROPERTY_NAMES.includes(name)) {
+        return "__" + name;
+      }
+      return name;
+    };
     defaultOptions3 = {
       preserveOrder: false,
       attributeNamePrefix: "@_",
@@ -104679,20 +104716,47 @@ var init_OptionsBuilder = __esm({
       },
       // skipEmptyListItem: false
       captureMetaData: false,
-      maxNestedTags: 100
+      maxNestedTags: 100,
+      strictReservedNames: true,
+      jPath: true,
+      // if true, pass jPath string to callbacks; if false, pass matcher instance
+      onDangerousProperty: defaultOnDangerousProperty
     };
     buildOptions = function(options) {
       const built = Object.assign({}, defaultOptions3, options);
+      const propertyNameOptions = [
+        { value: built.attributeNamePrefix, name: "attributeNamePrefix" },
+        { value: built.attributesGroupName, name: "attributesGroupName" },
+        { value: built.textNodeName, name: "textNodeName" },
+        { value: built.cdataPropName, name: "cdataPropName" },
+        { value: built.commentPropName, name: "commentPropName" }
+      ];
+      for (const { value, name } of propertyNameOptions) {
+        if (value) {
+          validatePropertyName(value, name);
+        }
+      }
+      if (built.onDangerousProperty === null) {
+        built.onDangerousProperty = defaultOnDangerousProperty;
+      }
       built.processEntities = normalizeProcessEntities(built.processEntities);
+      if (built.stopNodes && Array.isArray(built.stopNodes)) {
+        built.stopNodes = built.stopNodes.map((node2) => {
+          if (typeof node2 === "string" && node2.startsWith("*.")) {
+            return ".." + node2.substring(2);
+          }
+          return node2;
+        });
+      }
       return built;
     };
   }
 });
 
-// node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
+// node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
 var METADATA_SYMBOL, XmlNode;
 var init_xmlNode = __esm({
-  "node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js"() {
+  "node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js"() {
     "use strict";
     init_import_meta_url();
     if (typeof Symbol !== "function") {
@@ -104729,7 +104793,7 @@ var init_xmlNode = __esm({
   }
 });
 
-// node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
+// node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
 function hasSeq(data2, seq2, i4) {
   for (let j6 = 0; j6 < seq2.length; j6++) {
     if (seq2[j6] !== data2[i4 + j6 + 1]) return false;
@@ -104744,7 +104808,7 @@ function validateEntityName(name) {
 }
 var DocTypeReader, skipWhitespace;
 var init_DocTypeReader = __esm({
-  "node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js"() {
+  "node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js"() {
     init_import_meta_url();
     init_util5();
     DocTypeReader = class {
@@ -104754,6 +104818,7 @@ var init_DocTypeReader = __esm({
       }
       readDocType(xmlData, i4) {
         const entities = /* @__PURE__ */ Object.create(null);
+        let entityCount = 0;
         if (xmlData[i4 + 3] === "O" && xmlData[i4 + 4] === "C" && xmlData[i4 + 5] === "T" && xmlData[i4 + 6] === "Y" && xmlData[i4 + 7] === "P" && xmlData[i4 + 8] === "E") {
           i4 = i4 + 9;
           let angleBracketsCount = 1;
@@ -104766,11 +104831,17 @@ var init_DocTypeReader = __esm({
                 let entityName, val;
                 [entityName, val, i4] = this.readEntityExp(xmlData, i4 + 1, this.suppressValidationErr);
                 if (val.indexOf("&") === -1) {
-                  const escaped = entityName.replace(/[.\-+*:]/g, "\\.");
+                  if (this.options.enabled !== false && this.options.maxEntityCount != null && 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", i4)) {
                 i4 += 8;
@@ -104814,11 +104885,11 @@ var init_DocTypeReader = __esm({
       }
       readEntityExp(xmlData, i4) {
         i4 = skipWhitespace(xmlData, i4);
-        let entityName = "";
+        const startIndex = i4;
         while (i4 < xmlData.length && !/\s/.test(xmlData[i4]) && xmlData[i4] !== '"' && xmlData[i4] !== "'") {
-          entityName += xmlData[i4];
           i4++;
         }
+        let entityName = xmlData.substring(startIndex, i4);
         validateEntityName(entityName);
         i4 = skipWhitespace(xmlData, i4);
         if (!this.suppressValidationErr) {
@@ -104830,7 +104901,7 @@ var init_DocTypeReader = __esm({
         }
         let entityValue = "";
         [i4, entityValue] = this.readIdentifierVal(xmlData, i4, "entity");
-        if (this.options.enabled !== false && this.options.maxEntitySize && entityValue.length > this.options.maxEntitySize) {
+        if (this.options.enabled !== false && this.options.maxEntitySize != null && entityValue.length > this.options.maxEntitySize) {
           throw new Error(
             `Entity "${entityName}" size (${entityValue.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`
           );
@@ -104840,11 +104911,11 @@ var init_DocTypeReader = __esm({
       }
       readNotationExp(xmlData, i4) {
         i4 = skipWhitespace(xmlData, i4);
-        let notationName = "";
+        const startIndex = i4;
         while (i4 < xmlData.length && !/\s/.test(xmlData[i4])) {
-          notationName += xmlData[i4];
           i4++;
         }
+        let notationName = xmlData.substring(startIndex, i4);
         !this.suppressValidationErr && validateEntityName(notationName);
         i4 = skipWhitespace(xmlData, i4);
         const identifierType = xmlData.substring(i4, i4 + 6).toUpperCase();
@@ -104876,10 +104947,11 @@ var init_DocTypeReader = __esm({
           throw new Error(`Expected quoted string, found "${startChar}"`);
         }
         i4++;
+        const startIndex = i4;
         while (i4 < xmlData.length && xmlData[i4] !== startChar) {
-          identifierVal += xmlData[i4];
           i4++;
         }
+        identifierVal = xmlData.substring(startIndex, i4);
         if (xmlData[i4] !== startChar) {
           throw new Error(`Unterminated ${type2} value`);
         }
@@ -104888,11 +104960,11 @@ var init_DocTypeReader = __esm({
       }
       readElementExp(xmlData, i4) {
         i4 = skipWhitespace(xmlData, i4);
-        let elementName = "";
+        const startIndex = i4;
         while (i4 < xmlData.length && !/\s/.test(xmlData[i4])) {
-          elementName += xmlData[i4];
           i4++;
         }
+        let elementName = xmlData.substring(startIndex, i4);
         if (!this.suppressValidationErr && !isName(elementName)) {
           throw new Error(`Invalid element name: "${elementName}"`);
         }
@@ -104902,10 +104974,11 @@ var init_DocTypeReader = __esm({
         else if (xmlData[i4] === "A" && hasSeq(xmlData, "NY", i4)) i4 += 2;
         else if (xmlData[i4] === "(") {
           i4++;
+          const startIndex2 = i4;
           while (i4 < xmlData.length && xmlData[i4] !== ")") {
-            contentModel += xmlData[i4];
             i4++;
           }
+          contentModel = xmlData.substring(startIndex2, i4);
           if (xmlData[i4] !== ")") {
             throw new Error("Unterminated content model");
           }
@@ -104920,18 +104993,18 @@ var init_DocTypeReader = __esm({
       }
       readAttlistExp(xmlData, i4) {
         i4 = skipWhitespace(xmlData, i4);
-        let elementName = "";
+        let startIndex = i4;
         while (i4 < xmlData.length && !/\s/.test(xmlData[i4])) {
-          elementName += xmlData[i4];
           i4++;
         }
+        let elementName = xmlData.substring(startIndex, i4);
         validateEntityName(elementName);
         i4 = skipWhitespace(xmlData, i4);
-        let attributeName = "";
+        startIndex = i4;
         while (i4 < xmlData.length && !/\s/.test(xmlData[i4])) {
-          attributeName += xmlData[i4];
           i4++;
         }
+        let attributeName = xmlData.substring(startIndex, i4);
         if (!validateEntityName(attributeName)) {
           throw new Error(`Invalid attribute name: "${attributeName}"`);
         }
@@ -104947,11 +105020,11 @@ var init_DocTypeReader = __esm({
           i4++;
           let allowedNotations = [];
           while (i4 < xmlData.length && xmlData[i4] !== ")") {
-            let notation = "";
+            const startIndex2 = i4;
             while (i4 < xmlData.length && xmlData[i4] !== "|" && xmlData[i4] !== ")") {
-              notation += xmlData[i4];
               i4++;
             }
+            let notation = xmlData.substring(startIndex2, i4);
             notation = notation.trim();
             if (!validateEntityName(notation)) {
               throw new Error(`Invalid notation name: "${notation}"`);
@@ -104968,10 +105041,11 @@ var init_DocTypeReader = __esm({
           i4++;
           attributeType += " (" + allowedNotations.join("|") + ")";
         } else {
+          const startIndex2 = i4;
           while (i4 < xmlData.length && !/\s/.test(xmlData[i4])) {
-            attributeType += xmlData[i4];
             i4++;
           }
+          attributeType += xmlData.substring(startIndex2, i4);
           const validTypes = ["CDATA", "ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS"];
           if (!this.suppressValidationErr && !validTypes.includes(attributeType.toUpperCase())) {
             throw new Error(`Invalid attribute type: "${attributeType}"`);
@@ -105006,7 +105080,7 @@ var init_DocTypeReader = __esm({
   }
 });
 
-// node_modules/.pnpm/strnum@2.1.2/node_modules/strnum/strnum.js
+// node_modules/.pnpm/strnum@2.2.1/node_modules/strnum/strnum.js
 function toNumber2(str2, options = {}) {
   options = Object.assign({}, consider, options);
   if (!str2 || typeof str2 !== "string") return str2;
@@ -105015,6 +105089,8 @@ function toNumber2(str2, options = {}) {
   else if (str2 === "0") return 0;
   else if (options.hex && hexRegex.test(trimmedStr)) {
     return parse_int(trimmedStr, 16);
+  } else if (!isFinite(trimmedStr)) {
+    return handleInfinity(str2, Number(trimmedStr), options);
   } else if (trimmedStr.includes("e") || trimmedStr.includes("E")) {
     return resolveEnotation(str2, trimmedStr, options);
   } else {
@@ -105068,10 +105144,14 @@ function resolveEnotation(str2, trimmedStr, options) {
     if (leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str2;
     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];
+    } else if (leadingZeros.length > 0) {
+      if (options.leadingZeros && !eAdjacentToLeadingZeros) {
+        trimmedStr = (notation[1] || "") + notation[3];
+        return Number(trimmedStr);
+      } else return str2;
+    } else {
       return Number(trimmedStr);
-    } else return str2;
+    }
   } else {
     return str2;
   }
@@ -105092,9 +105172,24 @@ function parse_int(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(str2, num, options) {
+  const isPositive = num === Infinity;
+  switch (options.infinity.toLowerCase()) {
+    case "null":
+      return null;
+    case "infinity":
+      return num;
+    // Return Infinity or -Infinity
+    case "string":
+      return isPositive ? "Infinity" : "-Infinity";
+    case "original":
+    default:
+      return str2;
+  }
+}
 var hexRegex, numRegex, consider, eNotationRegx;
 var init_strnum = __esm({
-  "node_modules/.pnpm/strnum@2.1.2/node_modules/strnum/strnum.js"() {
+  "node_modules/.pnpm/strnum@2.2.1/node_modules/strnum/strnum.js"() {
     init_import_meta_url();
     hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
     numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
@@ -105103,14 +105198,16 @@ var init_strnum = __esm({
       // oct: false,
       leadingZeros: true,
       decimalPoint: ".",
-      eNotation: true
-      //skipLike: /regex/
+      eNotation: true,
+      //skipLike: /regex/,
+      infinity: "original"
+      // "null", "infinity" (Infinity type), "string" ("Infinity" (the string literal))
     };
     eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
   }
 });
 
-// node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/ignoreAttributes.js
+// node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/ignoreAttributes.js
 function getIgnoreAttributesFn(ignoreAttributes) {
   if (typeof ignoreAttributes === "function") {
     return ignoreAttributes;
@@ -105130,12 +105227,532 @@ function getIgnoreAttributesFn(ignoreAttributes) {
   return () => false;
 }
 var init_ignoreAttributes = __esm({
-  "node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/ignoreAttributes.js"() {
+  "node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/ignoreAttributes.js"() {
+    init_import_meta_url();
+  }
+});
+
+// node_modules/.pnpm/path-expression-matcher@1.1.3/node_modules/path-expression-matcher/src/Expression.js
+var Expression;
+var init_Expression = __esm({
+  "node_modules/.pnpm/path-expression-matcher@1.1.3/node_modules/path-expression-matcher/src/Expression.js"() {
+    init_import_meta_url();
+    Expression = class {
+      /**
+       * Create a new Expression
+       * @param {string} pattern - Pattern string (e.g., "root.users.user", "..user[id]")
+       * @param {Object} options - Configuration options
+       * @param {string} options.separator - Path separator (default: '.')
+       */
+      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 !== void 0);
+        this._hasPositionSelector = this.segments.some((seg) => seg.position !== void 0);
+      }
+      /**
+       * Parse pattern string into segments
+       * @private
+       * @param {string} pattern - Pattern to parse
+       * @returns {Array} Array of segment objects
+       */
+      _parse(pattern) {
+        const segments = [];
+        let i4 = 0;
+        let currentPart = "";
+        while (i4 < pattern.length) {
+          if (pattern[i4] === this.separator) {
+            if (i4 + 1 < pattern.length && pattern[i4 + 1] === this.separator) {
+              if (currentPart.trim()) {
+                segments.push(this._parseSegment(currentPart.trim()));
+                currentPart = "";
+              }
+              segments.push({ type: "deep-wildcard" });
+              i4 += 2;
+            } else {
+              if (currentPart.trim()) {
+                segments.push(this._parseSegment(currentPart.trim()));
+              }
+              currentPart = "";
+              i4++;
+            }
+          } else {
+            currentPart += pattern[i4];
+            i4++;
+          }
+        }
+        if (currentPart.trim()) {
+          segments.push(this._parseSegment(currentPart.trim()));
+        }
+        return segments;
+      }
+      /**
+       * Parse a single segment
+       * @private
+       * @param {string} part - Segment string (e.g., "user", "ns::user", "user[id]", "ns::user:first")
+       * @returns {Object} Segment object
+       */
+      _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 = void 0;
+        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 tag2 = void 0;
+        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) {
+            tag2 = tagPart;
+            positionMatch = posPart;
+          } else {
+            tag2 = tagAndPosition;
+          }
+        } else {
+          tag2 = tagAndPosition;
+        }
+        if (!tag2) {
+          throw new Error(`Invalid segment pattern: ${part}`);
+        }
+        segment.tag = tag2;
+        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 the number of segments
+       * @returns {number}
+       */
+      get length() {
+        return this.segments.length;
+      }
+      /**
+       * Check if expression contains deep wildcard
+       * @returns {boolean}
+       */
+      hasDeepWildcard() {
+        return this._hasDeepWildcard;
+      }
+      /**
+       * Check if expression has attribute conditions
+       * @returns {boolean}
+       */
+      hasAttributeCondition() {
+        return this._hasAttributeCondition;
+      }
+      /**
+       * Check if expression has position selectors
+       * @returns {boolean}
+       */
+      hasPositionSelector() {
+        return this._hasPositionSelector;
+      }
+      /**
+       * Get string representation
+       * @returns {string}
+       */
+      toString() {
+        return this.pattern;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/path-expression-matcher@1.1.3/node_modules/path-expression-matcher/src/Matcher.js
+var Matcher;
+var init_Matcher = __esm({
+  "node_modules/.pnpm/path-expression-matcher@1.1.3/node_modules/path-expression-matcher/src/Matcher.js"() {
+    init_import_meta_url();
+    Matcher = class {
+      /**
+       * Create a new Matcher
+       * @param {Object} options - Configuration options
+       * @param {string} options.separator - Default path separator (default: '.')
+       */
+      constructor(options = {}) {
+        this.separator = options.separator || ".";
+        this.path = [];
+        this.siblingStacks = [];
+      }
+      /**
+       * Push a new tag onto the path
+       * @param {string} tagName - Name of the tag
+       * @param {Object} attrValues - Attribute key-value pairs for current node (optional)
+       * @param {string} namespace - Namespace for the tag (optional)
+       */
+      push(tagName, attrValues = null, namespace = null) {
+        if (this.path.length > 0) {
+          const prev = this.path[this.path.length - 1];
+          prev.values = void 0;
+        }
+        const currentLevel = this.path.length;
+        if (!this.siblingStacks[currentLevel]) {
+          this.siblingStacks[currentLevel] = /* @__PURE__ */ 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 node2 = {
+          tag: tagName,
+          position,
+          counter
+        };
+        if (namespace !== null && namespace !== void 0) {
+          node2.namespace = namespace;
+        }
+        if (attrValues !== null && attrValues !== void 0) {
+          node2.values = attrValues;
+        }
+        this.path.push(node2);
+      }
+      /**
+       * Pop the last tag from the path
+       * @returns {Object|undefined} The popped node
+       */
+      pop() {
+        if (this.path.length === 0) {
+          return void 0;
+        }
+        const node2 = this.path.pop();
+        if (this.siblingStacks.length > this.path.length + 1) {
+          this.siblingStacks.length = this.path.length + 1;
+        }
+        return node2;
+      }
+      /**
+       * Update current node's attribute values
+       * Useful when attributes are parsed after push
+       * @param {Object} attrValues - Attribute values
+       */
+      updateCurrent(attrValues) {
+        if (this.path.length > 0) {
+          const current = this.path[this.path.length - 1];
+          if (attrValues !== null && attrValues !== void 0) {
+            current.values = attrValues;
+          }
+        }
+      }
+      /**
+       * Get current tag name
+       * @returns {string|undefined}
+       */
+      getCurrentTag() {
+        return this.path.length > 0 ? this.path[this.path.length - 1].tag : void 0;
+      }
+      /**
+       * Get current namespace
+       * @returns {string|undefined}
+       */
+      getCurrentNamespace() {
+        return this.path.length > 0 ? this.path[this.path.length - 1].namespace : void 0;
+      }
+      /**
+       * Get current node's attribute value
+       * @param {string} attrName - Attribute name
+       * @returns {*} Attribute value or undefined
+       */
+      getAttrValue(attrName) {
+        if (this.path.length === 0) return void 0;
+        const current = this.path[this.path.length - 1];
+        return current.values?.[attrName];
+      }
+      /**
+       * Check if current node has an attribute
+       * @param {string} attrName - Attribute name
+       * @returns {boolean}
+       */
+      hasAttr(attrName) {
+        if (this.path.length === 0) return false;
+        const current = this.path[this.path.length - 1];
+        return current.values !== void 0 && attrName in current.values;
+      }
+      /**
+       * Get current node's sibling position (child index in parent)
+       * @returns {number}
+       */
+      getPosition() {
+        if (this.path.length === 0) return -1;
+        return this.path[this.path.length - 1].position ?? 0;
+      }
+      /**
+       * Get current node's repeat counter (occurrence count of this tag name)
+       * @returns {number}
+       */
+      getCounter() {
+        if (this.path.length === 0) return -1;
+        return this.path[this.path.length - 1].counter ?? 0;
+      }
+      /**
+       * Get current node's sibling index (alias for getPosition for backward compatibility)
+       * @returns {number}
+       * @deprecated Use getPosition() or getCounter() instead
+       */
+      getIndex() {
+        return this.getPosition();
+      }
+      /**
+       * Get current path depth
+       * @returns {number}
+       */
+      getDepth() {
+        return this.path.length;
+      }
+      /**
+       * Get path as string
+       * @param {string} separator - Optional separator (uses default if not provided)
+       * @param {boolean} includeNamespace - Whether to include namespace in output (default: true)
+       * @returns {string}
+       */
+      toString(separator, includeNamespace = true) {
+        const sep4 = separator || this.separator;
+        return this.path.map((n4) => {
+          if (includeNamespace && n4.namespace) {
+            return `${n4.namespace}:${n4.tag}`;
+          }
+          return n4.tag;
+        }).join(sep4);
+      }
+      /**
+       * Get path as array of tag names
+       * @returns {string[]}
+       */
+      toArray() {
+        return this.path.map((n4) => n4.tag);
+      }
+      /**
+       * Reset the path to empty
+       */
+      reset() {
+        this.path = [];
+        this.siblingStacks = [];
+      }
+      /**
+       * Match current path against an Expression
+       * @param {Expression} expression - The expression to match against
+       * @returns {boolean} True if current path matches the expression
+       */
+      matches(expression) {
+        const segments = expression.segments;
+        if (segments.length === 0) {
+          return false;
+        }
+        if (expression.hasDeepWildcard()) {
+          return this._matchWithDeepWildcard(segments);
+        }
+        return this._matchSimple(segments);
+      }
+      /**
+       * Match simple path (no deep wildcards)
+       * @private
+       */
+      _matchSimple(segments) {
+        if (this.path.length !== segments.length) {
+          return false;
+        }
+        for (let i4 = 0; i4 < segments.length; i4++) {
+          const segment = segments[i4];
+          const node2 = this.path[i4];
+          const isCurrentNode = i4 === this.path.length - 1;
+          if (!this._matchSegment(segment, node2, isCurrentNode)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      /**
+       * Match path with deep wildcards
+       * @private
+       */
+      _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 i4 = pathIdx; i4 >= 0; i4--) {
+              const isCurrentNode = i4 === this.path.length - 1;
+              if (this._matchSegment(nextSeg, this.path[i4], isCurrentNode)) {
+                pathIdx = i4 - 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;
+      }
+      /**
+       * Match a single segment against a node
+       * @private
+       * @param {Object} segment - Segment from Expression
+       * @param {Object} node - Node from path
+       * @param {boolean} isCurrentNode - Whether this is the current (last) node
+       * @returns {boolean}
+       */
+      _matchSegment(segment, node2, isCurrentNode) {
+        if (segment.tag !== "*" && segment.tag !== node2.tag) {
+          return false;
+        }
+        if (segment.namespace !== void 0) {
+          if (segment.namespace !== "*" && segment.namespace !== node2.namespace) {
+            return false;
+          }
+        }
+        if (segment.attrName !== void 0) {
+          if (!isCurrentNode) {
+            return false;
+          }
+          if (!node2.values || !(segment.attrName in node2.values)) {
+            return false;
+          }
+          if (segment.attrValue !== void 0) {
+            const actualValue = node2.values[segment.attrName];
+            if (String(actualValue) !== String(segment.attrValue)) {
+              return false;
+            }
+          }
+        }
+        if (segment.position !== void 0) {
+          if (!isCurrentNode) {
+            return false;
+          }
+          const counter = node2.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;
+      }
+      /**
+       * Create a snapshot of current state
+       * @returns {Object} State snapshot
+       */
+      snapshot() {
+        return {
+          path: this.path.map((node2) => ({ ...node2 })),
+          siblingStacks: this.siblingStacks.map((map3) => new Map(map3))
+        };
+      }
+      /**
+       * Restore state from snapshot
+       * @param {Object} snapshot - State snapshot
+       */
+      restore(snapshot) {
+        this.path = snapshot.path.map((node2) => ({ ...node2 }));
+        this.siblingStacks = snapshot.siblingStacks.map((map3) => new Map(map3));
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/path-expression-matcher@1.1.3/node_modules/path-expression-matcher/src/index.js
+var init_src = __esm({
+  "node_modules/.pnpm/path-expression-matcher@1.1.3/node_modules/path-expression-matcher/src/index.js"() {
     init_import_meta_url();
+    init_Expression();
+    init_Matcher();
   }
 });
 
-// node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
+// node_modules/.pnpm/fast-xml-parser@5.5.7/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 void 0;
+  const colonIndex = rawTagName.indexOf(":");
+  if (colonIndex !== -1 && colonIndex > 0) {
+    const ns2 = rawTagName.substring(0, colonIndex);
+    if (ns2 !== "xmlns") {
+      return ns2;
+    }
+  }
+  return void 0;
+}
 function addExternalEntities(externalEntities) {
   const entKeys = Object.keys(externalEntities);
   for (let i4 = 0; i4 < entKeys.length; i4++) {
@@ -105154,7 +105771,8 @@ function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode,
     }
     if (val.length > 0) {
       if (!escapeEntities) val = this.replaceEntitiesValue(val, tagName, jPath);
-      const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
+      const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
+      const newval = this.options.tagValueProcessor(tagName, val, jPathOrMatcher, hasAttributes, isLeafNode);
       if (newval === null || newval === void 0) {
         return val;
       } else if (typeof newval !== typeof val || newval !== val) {
@@ -105190,9 +105808,26 @@ function buildAttributesMap(attrStr, jPath, tagName) {
     const matches = getAllMatches(attrStr, attrsRegx);
     const len = matches.length;
     const attrs = {};
+    const rawAttrsForMatcher = {};
+    for (let i4 = 0; i4 < len; i4++) {
+      const attrName = this.resolveNameSpace(matches[i4][1]);
+      const oldVal = matches[i4][4];
+      if (attrName.length && oldVal !== void 0) {
+        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 i4 = 0; i4 < len; i4++) {
       const attrName = this.resolveNameSpace(matches[i4][1]);
-      if (this.ignoreAttributesFn(attrName, jPath)) {
+      const jPathStr = this.options.jPath ? jPath.toString() : jPath;
+      if (this.ignoreAttributesFn(attrName, jPathStr)) {
         continue;
       }
       let oldVal = matches[i4][4];
@@ -105201,13 +105836,14 @@ function buildAttributesMap(attrStr, jPath, tagName) {
         if (this.options.transformAttributeName) {
           aName = this.options.transformAttributeName(aName);
         }
-        if (aName === "__proto__") aName = "#__proto__";
+        aName = sanitizeName(aName, this.options);
         if (oldVal !== void 0) {
           if (this.options.trimValues) {
             oldVal = oldVal.trim();
           }
           oldVal = this.replaceEntitiesValue(oldVal, tagName, jPath);
-          const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);
+          const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
+          const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPathOrMatcher);
           if (newVal === null || newVal === void 0) {
             attrs[aName] = oldVal;
           } else if (typeof newVal !== typeof oldVal || newVal !== oldVal) {
@@ -105235,9 +105871,10 @@ function buildAttributesMap(attrStr, jPath, tagName) {
     return attrs;
   }
 }
-function addChild(currentNode, childNode, jPath, startIndex) {
+function addChild(currentNode, childNode, matcher, startIndex) {
   if (!this.options.captureMetaData) startIndex = void 0;
-  const result = this.options.updateTag(childNode.tagname, jPath, childNode[":@"]);
+  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;
@@ -105246,26 +105883,102 @@ function addChild(currentNode, childNode, jPath, startIndex) {
     currentNode.addChild(childNode, startIndex);
   }
 }
-function saveTextToParentTag(textData, currentNode, jPath, isLeafNode) {
+function replaceEntitiesValue(val, tagName, jPath) {
+  const entityConfig = this.options.processEntities;
+  if (!entityConfig || !entityConfig.enabled) {
+    return val;
+  }
+  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;
+    }
+  }
+  if (entityConfig.tagFilter) {
+    const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
+    if (!entityConfig.tagFilter(tagName, jPathOrMatcher)) {
+      return val;
+    }
+  }
+  for (const entityName of Object.keys(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}`
+        );
+      }
+      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}`
+          );
+        }
+      }
+    }
+  }
+  for (const entityName of Object.keys(this.lastEntities)) {
+    const entity = this.lastEntities[entityName];
+    const matches = val.match(entity.regex);
+    if (matches) {
+      this.entityExpansionCount += matches.length;
+      if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) {
+        throw new Error(
+          `Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`
+        );
+      }
+    }
+    val = val.replace(entity.regex, entity.val);
+  }
+  if (val.indexOf("&") === -1) return val;
+  if (this.options.htmlEntities) {
+    for (const entityName of Object.keys(this.htmlEntities)) {
+      const entity = this.htmlEntities[entityName];
+      const matches = val.match(entity.regex);
+      if (matches) {
+        this.entityExpansionCount += matches.length;
+        if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) {
+          throw new Error(
+            `Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`
+          );
+        }
+      }
+      val = val.replace(entity.regex, entity.val);
+    }
+  }
+  val = val.replace(this.ampEntity.regex, this.ampEntity.val);
+  return val;
+}
+function saveTextToParentTag(textData, parentNode, matcher, isLeafNode) {
   if (textData) {
-    if (isLeafNode === void 0) isLeafNode = currentNode.child.length === 0;
+    if (isLeafNode === void 0) isLeafNode = parentNode.child.length === 0;
     textData = this.parseTextData(
       textData,
-      currentNode.tagname,
-      jPath,
+      parentNode.tagname,
+      matcher,
       false,
-      currentNode[":@"] ? Object.keys(currentNode[":@"]).length !== 0 : false,
+      parentNode[":@"] ? Object.keys(parentNode[":@"]).length !== 0 : false,
       isLeafNode
     );
     if (textData !== void 0 && textData !== "")
-      currentNode.add(this.options.textNodeName, textData);
+      parentNode.add(this.options.textNodeName, textData);
     textData = "";
   }
   return textData;
 }
-function isItStopNode(stopNodesExact, stopNodesWildcard, jPath, currentTagName) {
-  if (stopNodesWildcard && stopNodesWildcard.has(currentTagName)) return true;
-  if (stopNodesExact && stopNodesExact.has(jPath)) return true;
+function isItStopNode(stopNodeExpressions, matcher) {
+  if (!stopNodeExpressions || stopNodeExpressions.length === 0) return false;
+  for (let i4 = 0; i4 < stopNodeExpressions.length; i4++) {
+    if (matcher.matches(stopNodeExpressions[i4])) {
+      return true;
+    }
+  }
   return false;
 }
 function tagExpWithClosingIndex(xmlData, i4, closingChar = ">") {
@@ -105395,9 +106108,28 @@ function fromCodePoint2(str2, base, prefix) {
     return prefix + str2 + ";";
   }
 }
-var OrderedObjParser, attrsRegx, parseXml, replaceEntitiesValue;
+function transformTagName(fn2, tagName, tagExp, options) {
+  if (fn2) {
+    const newTagName = fn2(tagName);
+    if (tagExp === tagName) {
+      tagExp = newTagName;
+    }
+    tagName = newTagName;
+  }
+  tagName = sanitizeName(tagName, options);
+  return { tagName, tagExp };
+}
+function sanitizeName(name, options) {
+  if (criticalProperties.includes(name)) {
+    throw new Error(`[SECURITY] Invalid name: "${name}" is a reserved JavaScript keyword that could cause prototype pollution`);
+  } else if (DANGEROUS_PROPERTY_NAMES.includes(name)) {
+    return options.onDangerousProperty(name);
+  }
+  return name;
+}
+var OrderedObjParser, attrsRegx, parseXml;
 var init_OrderedObjParser = __esm({
-  "node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js"() {
+  "node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js"() {
     "use strict";
     init_import_meta_url();
     init_util5();
@@ -105405,6 +106137,7 @@ var init_OrderedObjParser = __esm({
     init_DocTypeReader();
     init_strnum();
     init_ignoreAttributes();
+    init_src();
     OrderedObjParser = class {
       constructor(options) {
         this.options = options;
@@ -105448,16 +106181,16 @@ var init_OrderedObjParser = __esm({
         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.stopNodesExact = /* @__PURE__ */ new Set();
-          this.stopNodesWildcard = /* @__PURE__ */ new Set();
+          this.stopNodeExpressions = [];
           for (let i4 = 0; i4 < this.options.stopNodes.length; i4++) {
             const stopNodeExp = this.options.stopNodes[i4];
-            if (typeof stopNodeExp !== "string") continue;
-            if (stopNodeExp.startsWith("*.")) {
-              this.stopNodesWildcard.add(stopNodeExp.substring(2));
-            } else {
-              this.stopNodesExact.add(stopNodeExp);
+            if (typeof stopNodeExp === "string") {
+              this.stopNodeExpressions.push(new Expression(stopNodeExp));
+            } else if (stopNodeExp instanceof Expression) {
+              this.stopNodeExpressions.push(stopNodeExp);
             }
           }
         }
@@ -105469,7 +106202,7 @@ var init_OrderedObjParser = __esm({
       const xmlObj = new XmlNode("!xml");
       let currentNode = xmlObj;
       let textData = "";
-      let jPath = "";
+      this.matcher.reset();
       this.entityExpansionCount = 0;
       this.currentExpandedLength = 0;
       const docTypeReader = new DocTypeReader(this.options.processEntities);
@@ -105485,46 +106218,42 @@ var init_OrderedObjParser = __esm({
                 tagName = tagName.substr(colonIndex + 1);
               }
             }
-            if (this.options.transformTagName) {
-              tagName = this.options.transformTagName(tagName);
-            }
+            tagName = transformTagName(this.options.transformTagName, tagName, "", this.options).tagName;
             if (currentNode) {
-              textData = this.saveTextToParentTag(textData, currentNode, jPath);
+              textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
             }
-            const lastTagName = jPath.substring(jPath.lastIndexOf(".") + 1);
+            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}>`);
             }
-            let propIndex = 0;
             if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {
-              propIndex = jPath.lastIndexOf(".", jPath.lastIndexOf(".") - 1);
+              this.matcher.pop();
               this.tagsNodeStack.pop();
-            } else {
-              propIndex = jPath.lastIndexOf(".");
             }
-            jPath = jPath.substring(0, propIndex);
+            this.matcher.pop();
+            this.isCurrentNodeStopNode = false;
             currentNode = this.tagsNodeStack.pop();
             textData = "";
             i4 = closeIndex;
           } else if (xmlData[i4 + 1] === "?") {
             let tagData = readTagExp(xmlData, i4, false, "?>");
             if (!tagData) throw new Error("Pi Tag is not closed.");
-            textData = this.saveTextToParentTag(textData, currentNode, jPath);
+            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, jPath, tagData.tagName);
+                childNode[":@"] = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName);
               }
-              this.addChild(currentNode, childNode, jPath, i4);
+              this.addChild(currentNode, childNode, this.matcher, i4);
             }
             i4 = tagData.closeIndex + 1;
           } else if (xmlData.substr(i4 + 1, 3) === "!--") {
             const endIndex = findClosingIndex(xmlData, "-->", i4 + 4, "Comment is not closed.");
             if (this.options.commentPropName) {
               const comment = xmlData.substring(i4 + 4, endIndex - 2);
-              textData = this.saveTextToParentTag(textData, currentNode, jPath);
+              textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
               currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
             }
             i4 = endIndex;
@@ -105535,8 +106264,8 @@ var init_OrderedObjParser = __esm({
           } else if (xmlData.substr(i4 + 1, 2) === "![") {
             const closeIndex = findClosingIndex(xmlData, "]]>", i4, "CDATA is not closed.") - 2;
             const tagExp = xmlData.substring(i4 + 9, closeIndex);
-            textData = this.saveTextToParentTag(textData, currentNode, jPath);
-            let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true, true);
+            textData = this.saveTextToParentTag(textData, currentNode, this.matcher);
+            let val = this.parseTextData(tagExp, currentNode.tagname, this.matcher, true, false, true, true);
             if (val == void 0) val = "";
             if (this.options.cdataPropName) {
               currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);
@@ -105546,42 +106275,60 @@ var init_OrderedObjParser = __esm({
             i4 = closeIndex + 2;
           } else {
             let result = readTagExp(xmlData, i4, this.options.removeNSPrefix);
+            if (!result) {
+              const context2 = xmlData.substring(Math.max(0, i4 - 50), Math.min(xmlData.length, i4 + 50));
+              throw new Error(`readTagExp returned undefined at position ${i4}. Context: "${context2}"`);
+            }
             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;
-              }
-              tagName = newTagName;
+            ({ tagName, tagExp } = transformTagName(this.options.transformTagName, tagName, tagExp, this.options));
+            if (this.options.strictReservedNames && (tagName === this.options.commentPropName || tagName === this.options.cdataPropName || tagName === this.options.textNodeName || tagName === this.options.attributesGroupName)) {
+              throw new Error(`Invalid tag name: ${tagName}`);
             }
             if (currentNode && textData) {
               if (currentNode.tagname !== "!xml") {
-                textData = this.saveTextToParentTag(textData, currentNode, jPath, false);
+                textData = this.saveTextToParentTag(textData, currentNode, this.matcher, false);
               }
             }
             const lastTag = currentNode;
             if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
               currentNode = this.tagsNodeStack.pop();
-              jPath = jPath.substring(0, jPath.lastIndexOf("."));
+              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);
+              }
+              attrExpPresent = tagName !== tagExp;
+            }
+            let prefixedAttrs = null;
+            let rawAttrs = {};
+            let namespace = void 0;
+            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);
+              }
             }
             if (tagName !== xmlObj.tagname) {
-              jPath += jPath ? "." + tagName : tagName;
+              this.isCurrentNodeStopNode = this.isItStopNode(this.stopNodeExpressions, this.matcher);
             }
             const startIndex = i4;
-            if (this.isItStopNode(this.stopNodesExact, this.stopNodesWildcard, jPath, tagName)) {
+            if (this.isCurrentNodeStopNode) {
               let tagContent = "";
-              if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
-                if (tagName[tagName.length - 1] === "/") {
-                  tagName = tagName.substr(0, tagName.length - 1);
-                  jPath = jPath.substr(0, jPath.length - 1);
-                  tagExp = tagName;
-                } else {
-                  tagExp = tagExp.substr(0, tagExp.length - 1);
-                }
+              if (isSelfClosing) {
                 i4 = result.closeIndex;
               } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
                 i4 = result.closeIndex;
@@ -105592,47 +106339,43 @@ var init_OrderedObjParser = __esm({
                 tagContent = result2.tagContent;
               }
               const childNode = new XmlNode(tagName);
-              if (tagName !== tagExp && attrExpPresent) {
-                childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
-              }
-              if (tagContent) {
-                tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);
+              if (prefixedAttrs) {
+                childNode[":@"] = prefixedAttrs;
               }
-              jPath = jPath.substr(0, jPath.lastIndexOf("."));
               childNode.add(this.options.textNodeName, tagContent);
-              this.addChild(currentNode, childNode, jPath, startIndex);
+              this.matcher.pop();
+              this.isCurrentNodeStopNode = false;
+              this.addChild(currentNode, childNode, this.matcher, startIndex);
             } else {
-              if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
-                if (tagName[tagName.length - 1] === "/") {
-                  tagName = tagName.substr(0, tagName.length - 1);
-                  jPath = jPath.substr(0, jPath.length - 1);
-                  tagExp = tagName;
-                } else {
-                  tagExp = tagExp.substr(0, tagExp.length - 1);
-                }
-                if (this.options.transformTagName) {
-                  const newTagName = this.options.transformTagName(tagName);
-                  if (tagExp === tagName) {
-                    tagExp = newTagName;
-                  }
-                  tagName = newTagName;
+              if (isSelfClosing) {
+                ({ tagName, tagExp } = transformTagName(this.options.transformTagName, tagName, tagExp, this.options));
+                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 (tagName !== tagExp && attrExpPresent) {
-                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
+                if (prefixedAttrs) {
+                  childNode[":@"] = prefixedAttrs;
                 }
-                this.addChild(currentNode, childNode, jPath, startIndex);
-                jPath = jPath.substr(0, jPath.lastIndexOf("."));
+                this.addChild(currentNode, childNode, this.matcher, startIndex);
+                this.matcher.pop();
+                this.isCurrentNodeStopNode = false;
+                i4 = result.closeIndex;
+                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 (tagName !== tagExp && attrExpPresent) {
-                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
+                if (prefixedAttrs) {
+                  childNode[":@"] = prefixedAttrs;
                 }
-                this.addChild(currentNode, childNode, jPath, startIndex);
+                this.addChild(currentNode, childNode, this.matcher, startIndex);
                 currentNode = childNode;
               }
               textData = "";
@@ -105645,87 +106388,50 @@ var init_OrderedObjParser = __esm({
       }
       return xmlObj.child;
     };
-    replaceEntitiesValue = function(val, tagName, jPath) {
-      if (val.indexOf("&") === -1) {
-        return val;
-      }
-      const entityConfig = this.options.processEntities;
-      if (!entityConfig.enabled) {
-        return val;
-      }
-      if (entityConfig.allowedTags) {
-        if (!entityConfig.allowedTags.includes(tagName)) {
-          return val;
-        }
-      }
-      if (entityConfig.tagFilter) {
-        if (!entityConfig.tagFilter(tagName, jPath)) {
-          return val;
-        }
-      }
-      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}`
-            );
-          }
-          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 (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);
-        }
-      }
-      val = val.replace(this.ampEntity.regex, this.ampEntity.val);
-      return val;
-    };
   }
 });
 
-// node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/node2json.js
-function prettify(node2, options) {
-  return compress(node2, options);
+// node_modules/.pnpm/fast-xml-parser@5.5.7/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 compress(arr, options, jPath) {
+function prettify(node2, options, matcher) {
+  return compress(node2, options, matcher);
+}
+function compress(arr, options, matcher) {
   let text;
   const compressedObj = {};
   for (let i4 = 0; i4 < arr.length; i4++) {
     const tagObj = arr[i4];
     const property = propName(tagObj);
-    let newJpath = "";
-    if (jPath === void 0) newJpath = property;
-    else newJpath = jPath + "." + property;
+    if (property !== void 0 && property !== options.textNodeName) {
+      const rawAttrs = stripAttributePrefix(
+        tagObj[":@"] || {},
+        options.attributeNamePrefix
+      );
+      matcher.push(property, rawAttrs);
+    }
     if (property === options.textNodeName) {
       if (text === void 0) text = tagObj[property];
       else text += "" + tagObj[property];
     } else if (property === void 0) {
       continue;
     } else if (tagObj[property]) {
-      let val = compress(tagObj[property], options, newJpath);
+      let val = compress(tagObj[property], options, matcher);
       const isLeaf = isLeafTag(val, options);
       if (tagObj[":@"]) {
-        assignAttributes(val, tagObj[":@"], newJpath, options);
+        assignAttributes(val, tagObj[":@"], matcher, options);
       } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== void 0 && !options.alwaysCreateTextNode) {
         val = val[options.textNodeName];
       } else if (Object.keys(val).length === 0) {
@@ -105741,12 +106447,16 @@ function compress(arr, options, jPath) {
         }
         compressedObj[property].push(val);
       } else {
-        if (options.isArray(property, newJpath, isLeaf)) {
+        const jPathOrMatcher = options.jPath ? matcher.toString() : matcher;
+        if (options.isArray(property, jPathOrMatcher, isLeaf)) {
           compressedObj[property] = [val];
         } else {
           compressedObj[property] = val;
         }
       }
+      if (property !== void 0 && property !== options.textNodeName) {
+        matcher.pop();
+      }
     }
   }
   if (typeof text === "string") {
@@ -105761,13 +106471,15 @@ function propName(obj) {
     if (key !== ":@") return key;
   }
 }
-function assignAttributes(obj, attrMap, jpath, options) {
+function assignAttributes(obj, attrMap, matcher, options) {
   if (attrMap) {
     const keys = Object.keys(attrMap);
     const len = keys.length;
     for (let i4 = 0; i4 < len; i4++) {
       const atrrName = keys[i4];
-      if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) {
+      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]];
       } else {
         obj[atrrName] = attrMap[atrrName];
@@ -105788,7 +106500,7 @@ function isLeafTag(obj, options) {
 }
 var METADATA_SYMBOL2;
 var init_node2json = __esm({
-  "node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/node2json.js"() {
+  "node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/xmlparser/node2json.js"() {
     "use strict";
     init_import_meta_url();
     init_xmlNode();
@@ -105796,10 +106508,10 @@ var init_node2json = __esm({
   }
 });
 
-// node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
+// node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
 var XMLParser;
 var init_XMLParser = __esm({
-  "node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js"() {
+  "node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js"() {
     init_import_meta_url();
     init_OptionsBuilder();
     init_OrderedObjParser();
@@ -105833,7 +106545,7 @@ var init_XMLParser = __esm({
         orderedObjParser.addExternalEntities(this.externalEntities);
         const orderedResult = orderedObjParser.parseXml(xmlData);
         if (this.options.preserveOrder || orderedResult === void 0) return orderedResult;
-        else return prettify(orderedResult, this.options);
+        else return prettify(orderedResult, this.options, orderedObjParser.matcher);
       }
       /**
        * Add Entity which is not by default supported by this library
@@ -105868,9 +106580,9 @@ var init_XMLParser = __esm({
   }
 });
 
-// node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/fxp.js
+// node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/fxp.js
 var init_fxp = __esm({
-  "node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/src/fxp.js"() {
+  "node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/src/fxp.js"() {
     "use strict";
     init_import_meta_url();
     init_XMLParser();
@@ -105931,7 +106643,7 @@ var init_transfer_manager = __esm({
 });
 
 // node_modules/.pnpm/@google-cloud+storage@7.18.0/node_modules/@google-cloud/storage/build/esm/src/index.js
-var init_src = __esm({
+var init_src2 = __esm({
   "node_modules/.pnpm/@google-cloud+storage@7.18.0/node_modules/@google-cloud/storage/build/esm/src/index.js"() {
     init_import_meta_url();
     init_nodejs_common();
@@ -105993,7 +106705,7 @@ var init_gcsApi = __esm({
     init_import_meta_url();
     fs8 = __toESM(require("fs"));
     path8 = __toESM(require("path"));
-    init_src();
+    init_src2();
     init_logger2();
     init_errors2();
     init_dryRun();
@@ -113258,20 +113970,20 @@ ${data2}`);
 });
 
 // src/targets/cocoapods.ts
-var fs9, import_path8, import_util23, writeFile2, DEFAULT_COCOAPODS_BIN, COCOAPODS_BIN, CocoapodsTarget;
+var fs9, import_path8, import_util24, writeFile2, DEFAULT_COCOAPODS_BIN, COCOAPODS_BIN, CocoapodsTarget;
 var init_cocoapods = __esm({
   "src/targets/cocoapods.ts"() {
     "use strict";
     init_import_meta_url();
     fs9 = __toESM(require("fs"));
     import_path8 = require("path");
-    import_util23 = require("util");
+    import_util24 = require("util");
     init_errors2();
     init_files();
     init_githubApi();
     init_system();
     init_base5();
-    writeFile2 = (0, import_util23.promisify)(fs9.writeFile);
+    writeFile2 = (0, import_util24.promisify)(fs9.writeFile);
     DEFAULT_COCOAPODS_BIN = "pod";
     COCOAPODS_BIN = process.env.COCOAPODS_BIN || DEFAULT_COCOAPODS_BIN;
     CocoapodsTarget = class extends BaseTarget {
@@ -124698,18 +125410,44 @@ async function getPackageManifest(baseDir, type2, canonicalName, version2, initi
       );
       throw new Error("Unreachable");
     }
+    let effectiveManifestData = initialManifestData;
+    if (!initialManifestData.name) {
+      reportError(
+        `"name" is required for new package "${canonicalName}". Add \`name\` to the registry target config in your .craft.yml.`
+      );
+      throw new Error("Unreachable");
+    }
+    if (!initialManifestData.mainDocsUrl) {
+      logger.warn(
+        `"mainDocsUrl" is not set for "${canonicalName}". Falling back to repo_url ("${initialManifestData.repoUrl}"). Set \`mainDocsUrl\` in the registry target config in .craft.yml to avoid this warning.`
+      );
+      effectiveManifestData = {
+        ...initialManifestData,
+        mainDocsUrl: initialManifestData.repoUrl
+      };
+    }
+    if (initialManifestData.sdkName && !initialManifestData.packageUrl) {
+      reportError(
+        `"packageUrl" is required for new SDK "${canonicalName}". Add \`packageUrl\` to the registry target config in your .craft.yml.`
+      );
+      throw new Error("Unreachable");
+    }
     if (!(0, import_fs18.existsSync)(fullPackageDir)) {
       logger.info(
         `Creating new package directory for "${canonicalName}" at "${packageDirPath}"...`
       );
       (0, import_fs18.mkdirSync)(fullPackageDir, { recursive: true });
     }
-    if (initialManifestData.sdkName) {
-      const sdkSymlinkPath = path15.join(baseDir, "sdks", initialManifestData.sdkName);
+    if (effectiveManifestData.sdkName) {
+      const sdkSymlinkPath = path15.join(
+        baseDir,
+        "sdks",
+        effectiveManifestData.sdkName
+      );
       if (!(0, import_fs18.existsSync)(sdkSymlinkPath)) {
         const relativeTarget = path15.join("..", packageDirPath);
         logger.info(
-          `Creating sdks symlink "${initialManifestData.sdkName}" -> "${relativeTarget}"...`
+          `Creating sdks symlink "${effectiveManifestData.sdkName}" -> "${relativeTarget}"...`
         );
         (0, import_fs18.symlinkSync)(relativeTarget, sdkSymlinkPath);
       }
@@ -124719,10 +125457,13 @@ async function getPackageManifest(baseDir, type2, canonicalName, version2, initi
     );
     return {
       versionFilePath,
-      packageManifest: createInitialManifest(initialManifestData)
+      packageManifest: createInitialManifest(effectiveManifestData)
     };
   }
-  logger.debug("Reading the current configuration from", packageManifestPath);
+  logger.debug(
+    "Reading the already existing configuration from",
+    packageManifestPath
+  );
   return {
     versionFilePath,
     packageManifest: JSON.parse(
@@ -136961,50 +137702,50 @@ var init_awsExpectUnion = __esm({
   }
 });
 
-// node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/lib/fxp.cjs
+// node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/lib/fxp.cjs
 var require_fxp = __commonJS({
-  "node_modules/.pnpm/fast-xml-parser@5.3.8/node_modules/fast-xml-parser/lib/fxp.cjs"(exports2, module2) {
+  "node_modules/.pnpm/fast-xml-parser@5.5.7/node_modules/fast-xml-parser/lib/fxp.cjs"(exports2, module2) {
     init_import_meta_url();
     (() => {
       "use strict";
-      var t4 = { d: (e5, n5) => {
-        for (var i5 in n5) t4.o(n5, i5) && !t4.o(e5, i5) && Object.defineProperty(e5, i5, { enumerable: true, get: n5[i5] });
+      var t4 = { d: (e5, i5) => {
+        for (var n5 in i5) t4.o(i5, n5) && !t4.o(e5, n5) && Object.defineProperty(e5, n5, { enumerable: true, get: i5[n5] });
       }, o: (t5, e5) => Object.prototype.hasOwnProperty.call(t5, e5), r: (t5) => {
         "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(t5, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(t5, "__esModule", { value: true });
       } }, e4 = {};
-      t4.r(e4), t4.d(e4, { XMLBuilder: () => pt2, XMLParser: () => st2, XMLValidator: () => xt2 });
-      const n4 = ":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", i4 = new RegExp("^[" + n4 + "][" + n4 + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$");
+      t4.r(e4), t4.d(e4, { XMLBuilder: () => Ot2, XMLParser: () => ft2, XMLValidator: () => $t2 });
+      const i4 = ":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", n4 = new RegExp("^[" + i4 + "][" + i4 + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$");
       function s6(t5, e5) {
-        const n5 = [];
-        let i5 = e5.exec(t5);
-        for (; i5; ) {
+        const i5 = [];
+        let n5 = e5.exec(t5);
+        for (; n5; ) {
           const s7 = [];
-          s7.startIndex = e5.lastIndex - i5[0].length;
-          const r5 = i5.length;
-          for (let t6 = 0; t6 < r5; t6++) s7.push(i5[t6]);
-          n5.push(s7), i5 = e5.exec(t5);
+          s7.startIndex = e5.lastIndex - n5[0].length;
+          const r5 = n5.length;
+          for (let t6 = 0; t6 < r5; t6++) s7.push(n5[t6]);
+          i5.push(s7), n5 = e5.exec(t5);
         }
-        return n5;
+        return i5;
       }
       const r4 = function(t5) {
-        return !(null == i4.exec(t5));
-      }, o4 = { allowBooleanAttributes: false, unpairedTags: [] };
-      function a4(t5, e5) {
-        e5 = Object.assign({}, o4, e5);
-        const n5 = [];
-        let i5 = false, s7 = false;
+        return !(null == n4.exec(t5));
+      }, o4 = ["hasOwnProperty", "toString", "valueOf", "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__"], a4 = ["__proto__", "constructor", "prototype"], h4 = { allowBooleanAttributes: false, unpairedTags: [] };
+      function l4(t5, e5) {
+        e5 = Object.assign({}, h4, e5);
+        const i5 = [];
+        let n5 = false, s7 = false;
         "\uFEFF" === t5[0] && (t5 = t5.substr(1));
         for (let r5 = 0; r5 < t5.length; r5++) if ("<" === t5[r5] && "?" === t5[r5 + 1]) {
           if (r5 += 2, r5 = u7(t5, r5), r5.err) return r5;
         } else {
           if ("<" !== t5[r5]) {
-            if (l4(t5[r5])) continue;
-            return m6("InvalidChar", "char '" + t5[r5] + "' is not expected.", N2(t5, r5));
+            if (p5(t5[r5])) continue;
+            return b6("InvalidChar", "char '" + t5[r5] + "' is not expected.", w6(t5, r5));
           }
           {
             let o5 = r5;
             if (r5++, "!" === t5[r5]) {
-              r5 = d5(t5, r5);
+              r5 = c4(t5, r5);
               continue;
             }
             {
@@ -137012,63 +137753,63 @@ var require_fxp = __commonJS({
               "/" === t5[r5] && (a5 = true, r5++);
               let h5 = "";
               for (; r5 < t5.length && ">" !== t5[r5] && " " !== t5[r5] && "	" !== t5[r5] && "\n" !== t5[r5] && "\r" !== t5[r5]; r5++) h5 += t5[r5];
-              if (h5 = h5.trim(), "/" === h5[h5.length - 1] && (h5 = h5.substring(0, h5.length - 1), r5--), !b6(h5)) {
+              if (h5 = h5.trim(), "/" === h5[h5.length - 1] && (h5 = h5.substring(0, h5.length - 1), r5--), !y4(h5)) {
                 let e6;
-                return e6 = 0 === h5.trim().length ? "Invalid space after '<'." : "Tag '" + h5 + "' is an invalid name.", m6("InvalidTag", e6, N2(t5, r5));
+                return e6 = 0 === h5.trim().length ? "Invalid space after '<'." : "Tag '" + h5 + "' is an invalid name.", b6("InvalidTag", e6, w6(t5, r5));
               }
-              const p6 = c4(t5, r5);
-              if (false === p6) return m6("InvalidAttr", "Attributes for '" + h5 + "' have open quote.", N2(t5, r5));
-              let f6 = p6.value;
-              if (r5 = p6.index, "/" === f6[f6.length - 1]) {
-                const n6 = r5 - f6.length;
-                f6 = f6.substring(0, f6.length - 1);
-                const s8 = g5(f6, e5);
-                if (true !== s8) return m6(s8.err.code, s8.err.msg, N2(t5, n6 + s8.err.line));
-                i5 = true;
+              const l5 = g5(t5, r5);
+              if (false === l5) return b6("InvalidAttr", "Attributes for '" + h5 + "' have open quote.", w6(t5, r5));
+              let d6 = l5.value;
+              if (r5 = l5.index, "/" === d6[d6.length - 1]) {
+                const i6 = r5 - d6.length;
+                d6 = d6.substring(0, d6.length - 1);
+                const s8 = x5(d6, e5);
+                if (true !== s8) return b6(s8.err.code, s8.err.msg, w6(t5, i6 + s8.err.line));
+                n5 = true;
               } else if (a5) {
-                if (!p6.tagClosed) return m6("InvalidTag", "Closing tag '" + h5 + "' doesn't have proper closing.", N2(t5, r5));
-                if (f6.trim().length > 0) return m6("InvalidTag", "Closing tag '" + h5 + "' can't have attributes or invalid starting.", N2(t5, o5));
-                if (0 === n5.length) return m6("InvalidTag", "Closing tag '" + h5 + "' has not been opened.", N2(t5, o5));
+                if (!l5.tagClosed) return b6("InvalidTag", "Closing tag '" + h5 + "' doesn't have proper closing.", w6(t5, r5));
+                if (d6.trim().length > 0) return b6("InvalidTag", "Closing tag '" + h5 + "' can't have attributes or invalid starting.", w6(t5, o5));
+                if (0 === i5.length) return b6("InvalidTag", "Closing tag '" + h5 + "' has not been opened.", w6(t5, o5));
                 {
-                  const e6 = n5.pop();
+                  const e6 = i5.pop();
                   if (h5 !== e6.tagName) {
-                    let n6 = N2(t5, e6.tagStartPos);
-                    return m6("InvalidTag", "Expected closing tag '" + e6.tagName + "' (opened in line " + n6.line + ", col " + n6.col + ") instead of closing tag '" + h5 + "'.", N2(t5, o5));
+                    let i6 = w6(t5, e6.tagStartPos);
+                    return b6("InvalidTag", "Expected closing tag '" + e6.tagName + "' (opened in line " + i6.line + ", col " + i6.col + ") instead of closing tag '" + h5 + "'.", w6(t5, o5));
                   }
-                  0 == n5.length && (s7 = true);
+                  0 == i5.length && (s7 = true);
                 }
               } else {
-                const a6 = g5(f6, e5);
-                if (true !== a6) return m6(a6.err.code, a6.err.msg, N2(t5, r5 - f6.length + a6.err.line));
-                if (true === s7) return m6("InvalidXml", "Multiple possible root nodes found.", N2(t5, r5));
-                -1 !== e5.unpairedTags.indexOf(h5) || n5.push({ tagName: h5, tagStartPos: o5 }), i5 = true;
+                const a6 = x5(d6, e5);
+                if (true !== a6) return b6(a6.err.code, a6.err.msg, w6(t5, r5 - d6.length + a6.err.line));
+                if (true === s7) return b6("InvalidXml", "Multiple possible root nodes found.", w6(t5, r5));
+                -1 !== e5.unpairedTags.indexOf(h5) || i5.push({ tagName: h5, tagStartPos: o5 }), n5 = true;
               }
               for (r5++; r5 < t5.length; r5++) if ("<" === t5[r5]) {
                 if ("!" === t5[r5 + 1]) {
-                  r5++, r5 = d5(t5, r5);
+                  r5++, r5 = c4(t5, r5);
                   continue;
                 }
                 if ("?" !== t5[r5 + 1]) break;
                 if (r5 = u7(t5, ++r5), r5.err) return r5;
               } else if ("&" === t5[r5]) {
-                const e6 = x5(t5, r5);
-                if (-1 == e6) return m6("InvalidChar", "char '&' is not expected.", N2(t5, r5));
+                const e6 = N2(t5, r5);
+                if (-1 == e6) return b6("InvalidChar", "char '&' is not expected.", w6(t5, r5));
                 r5 = e6;
-              } else if (true === s7 && !l4(t5[r5])) return m6("InvalidXml", "Extra text at the end", N2(t5, r5));
+              } else if (true === s7 && !p5(t5[r5])) return b6("InvalidXml", "Extra text at the end", w6(t5, r5));
               "<" === t5[r5] && r5--;
             }
           }
         }
-        return i5 ? 1 == n5.length ? m6("InvalidTag", "Unclosed tag '" + n5[0].tagName + "'.", N2(t5, n5[0].tagStartPos)) : !(n5.length > 0) || m6("InvalidXml", "Invalid '" + JSON.stringify(n5.map((t6) => t6.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 }) : m6("InvalidXml", "Start tag expected.", 1);
+        return n5 ? 1 == i5.length ? b6("InvalidTag", "Unclosed tag '" + i5[0].tagName + "'.", w6(t5, i5[0].tagStartPos)) : !(i5.length > 0) || b6("InvalidXml", "Invalid '" + JSON.stringify(i5.map((t6) => t6.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 }) : b6("InvalidXml", "Start tag expected.", 1);
       }
-      function l4(t5) {
+      function p5(t5) {
         return " " === t5 || "	" === t5 || "\n" === t5 || "\r" === t5;
       }
       function u7(t5, e5) {
-        const n5 = e5;
+        const i5 = e5;
         for (; e5 < t5.length; e5++) if ("?" == t5[e5] || " " == t5[e5]) {
-          const i5 = t5.substr(n5, e5 - n5);
-          if (e5 > 5 && "xml" === i5) return m6("InvalidXml", "XML declaration allowed only at the start of the document.", N2(t5, e5));
+          const n5 = t5.substr(i5, e5 - i5);
+          if (e5 > 5 && "xml" === n5) return b6("InvalidXml", "XML declaration allowed only at the start of the document.", w6(t5, e5));
           if ("?" == t5[e5] && ">" == t5[e5 + 1]) {
             e5++;
             break;
@@ -137077,16 +137818,16 @@ var require_fxp = __commonJS({
         }
         return e5;
       }
-      function d5(t5, e5) {
+      function c4(t5, e5) {
         if (t5.length > e5 + 5 && "-" === t5[e5 + 1] && "-" === t5[e5 + 2]) {
           for (e5 += 3; e5 < t5.length; e5++) if ("-" === t5[e5] && "-" === t5[e5 + 1] && ">" === t5[e5 + 2]) {
             e5 += 2;
             break;
           }
         } else if (t5.length > e5 + 8 && "D" === t5[e5 + 1] && "O" === t5[e5 + 2] && "C" === t5[e5 + 3] && "T" === t5[e5 + 4] && "Y" === t5[e5 + 5] && "P" === t5[e5 + 6] && "E" === t5[e5 + 7]) {
-          let n5 = 1;
-          for (e5 += 8; e5 < t5.length; e5++) if ("<" === t5[e5]) n5++;
-          else if (">" === t5[e5] && (n5--, 0 === n5)) break;
+          let i5 = 1;
+          for (e5 += 8; e5 < t5.length; e5++) if ("<" === t5[e5]) i5++;
+          else if (">" === t5[e5] && (i5--, 0 === i5)) break;
         } else if (t5.length > e5 + 9 && "[" === t5[e5 + 1] && "C" === t5[e5 + 2] && "D" === t5[e5 + 3] && "A" === t5[e5 + 4] && "T" === t5[e5 + 5] && "A" === t5[e5 + 6] && "[" === t5[e5 + 7]) {
           for (e5 += 8; e5 < t5.length; e5++) if ("]" === t5[e5] && "]" === t5[e5 + 1] && ">" === t5[e5 + 2]) {
             e5 += 2;
@@ -137095,83 +137836,90 @@ var require_fxp = __commonJS({
         }
         return e5;
       }
-      const h4 = '"', p5 = "'";
-      function c4(t5, e5) {
-        let n5 = "", i5 = "", s7 = false;
+      const d5 = '"', f5 = "'";
+      function g5(t5, e5) {
+        let i5 = "", n5 = "", s7 = false;
         for (; e5 < t5.length; e5++) {
-          if (t5[e5] === h4 || t5[e5] === p5) "" === i5 ? i5 = t5[e5] : i5 !== t5[e5] || (i5 = "");
-          else if (">" === t5[e5] && "" === i5) {
+          if (t5[e5] === d5 || t5[e5] === f5) "" === n5 ? n5 = t5[e5] : n5 !== t5[e5] || (n5 = "");
+          else if (">" === t5[e5] && "" === n5) {
             s7 = true;
             break;
           }
-          n5 += t5[e5];
+          i5 += t5[e5];
         }
-        return "" === i5 && { value: n5, index: e5, tagClosed: s7 };
+        return "" === n5 && { value: i5, index: e5, tagClosed: s7 };
       }
-      const f5 = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g");
-      function g5(t5, e5) {
-        const n5 = s6(t5, f5), i5 = {};
-        for (let t6 = 0; t6 < n5.length; t6++) {
-          if (0 === n5[t6][1].length) return m6("InvalidAttr", "Attribute '" + n5[t6][2] + "' has no space in starting.", y4(n5[t6]));
-          if (void 0 !== n5[t6][3] && void 0 === n5[t6][4]) return m6("InvalidAttr", "Attribute '" + n5[t6][2] + "' is without value.", y4(n5[t6]));
-          if (void 0 === n5[t6][3] && !e5.allowBooleanAttributes) return m6("InvalidAttr", "boolean attribute '" + n5[t6][2] + "' is not allowed.", y4(n5[t6]));
-          const s7 = n5[t6][2];
-          if (!E3(s7)) return m6("InvalidAttr", "Attribute '" + s7 + "' is an invalid name.", y4(n5[t6]));
-          if (Object.prototype.hasOwnProperty.call(i5, s7)) return m6("InvalidAttr", "Attribute '" + s7 + "' is repeated.", y4(n5[t6]));
-          i5[s7] = 1;
+      const m6 = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g");
+      function x5(t5, e5) {
+        const i5 = s6(t5, m6), n5 = {};
+        for (let t6 = 0; t6 < i5.length; t6++) {
+          if (0 === i5[t6][1].length) return b6("InvalidAttr", "Attribute '" + i5[t6][2] + "' has no space in starting.", v9(i5[t6]));
+          if (void 0 !== i5[t6][3] && void 0 === i5[t6][4]) return b6("InvalidAttr", "Attribute '" + i5[t6][2] + "' is without value.", v9(i5[t6]));
+          if (void 0 === i5[t6][3] && !e5.allowBooleanAttributes) return b6("InvalidAttr", "boolean attribute '" + i5[t6][2] + "' is not allowed.", v9(i5[t6]));
+          const s7 = i5[t6][2];
+          if (!E3(s7)) return b6("InvalidAttr", "Attribute '" + s7 + "' is an invalid name.", v9(i5[t6]));
+          if (Object.prototype.hasOwnProperty.call(n5, s7)) return b6("InvalidAttr", "Attribute '" + s7 + "' is repeated.", v9(i5[t6]));
+          n5[s7] = 1;
         }
         return true;
       }
-      function x5(t5, e5) {
+      function N2(t5, e5) {
         if (";" === t5[++e5]) return -1;
         if ("#" === t5[e5]) return (function(t6, e6) {
-          let n6 = /\d/;
-          for ("x" === t6[e6] && (e6++, n6 = /[\da-fA-F]/); e6 < t6.length; e6++) {
+          let i6 = /\d/;
+          for ("x" === t6[e6] && (e6++, i6 = /[\da-fA-F]/); e6 < t6.length; e6++) {
             if (";" === t6[e6]) return e6;
-            if (!t6[e6].match(n6)) break;
+            if (!t6[e6].match(i6)) break;
           }
           return -1;
         })(t5, ++e5);
-        let n5 = 0;
-        for (; e5 < t5.length; e5++, n5++) if (!(t5[e5].match(/\w/) && n5 < 20)) {
+        let i5 = 0;
+        for (; e5 < t5.length; e5++, i5++) if (!(t5[e5].match(/\w/) && i5 < 20)) {
           if (";" === t5[e5]) break;
           return -1;
         }
         return e5;
       }
-      function m6(t5, e5, n5) {
-        return { err: { code: t5, msg: e5, line: n5.line || n5, col: n5.col } };
+      function b6(t5, e5, i5) {
+        return { err: { code: t5, msg: e5, line: i5.line || i5, col: i5.col } };
       }
       function E3(t5) {
         return r4(t5);
       }
-      function b6(t5) {
+      function y4(t5) {
         return r4(t5);
       }
-      function N2(t5, e5) {
-        const n5 = t5.substring(0, e5).split(/\r?\n/);
-        return { line: n5.length, col: n5[n5.length - 1].length + 1 };
+      function w6(t5, e5) {
+        const i5 = t5.substring(0, e5).split(/\r?\n/);
+        return { line: i5.length, col: i5[i5.length - 1].length + 1 };
       }
-      function y4(t5) {
+      function v9(t5) {
         return t5.startIndex + t5[1].length;
       }
-      const T2 = { 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(t5, e5) {
+      const T2 = (t5) => o4.includes(t5) ? "__" + t5 : t5, P3 = { 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(t5, e5) {
         return e5;
       }, attributeValueProcessor: function(t5, e5) {
         return e5;
-      }, stopNodes: [], alwaysCreateTextNode: false, isArray: () => false, commentPropName: false, unpairedTags: [], processEntities: true, htmlEntities: false, ignoreDeclaration: false, ignorePiTags: false, transformTagName: false, transformAttributeName: false, updateTag: function(t5, e5, n5) {
+      }, stopNodes: [], alwaysCreateTextNode: false, isArray: () => false, commentPropName: false, unpairedTags: [], processEntities: true, htmlEntities: false, ignoreDeclaration: false, ignorePiTags: false, transformTagName: false, transformAttributeName: false, updateTag: function(t5, e5, i5) {
         return t5;
-      }, captureMetaData: false, maxNestedTags: 100 };
-      function w6(t5) {
-        return "boolean" == typeof t5 ? { enabled: t5, maxEntitySize: 1e4, maxExpansionDepth: 10, maxTotalExpansions: 1e3, maxExpandedLength: 1e5, allowedTags: null, tagFilter: null } : "object" == typeof t5 && null !== t5 ? { enabled: false !== t5.enabled, maxEntitySize: t5.maxEntitySize ?? 1e4, maxExpansionDepth: t5.maxExpansionDepth ?? 10, maxTotalExpansions: t5.maxTotalExpansions ?? 1e3, maxExpandedLength: t5.maxExpandedLength ?? 1e5, allowedTags: t5.allowedTags ?? null, tagFilter: t5.tagFilter ?? null } : w6(true);
+      }, captureMetaData: false, maxNestedTags: 100, strictReservedNames: true, jPath: true, onDangerousProperty: T2 };
+      function S2(t5, e5) {
+        if ("string" != typeof t5) return;
+        const i5 = t5.toLowerCase();
+        if (o4.some((t6) => i5 === t6.toLowerCase())) throw new Error(`[SECURITY] Invalid ${e5}: "${t5}" is a reserved JavaScript keyword that could cause prototype pollution`);
+        if (a4.some((t6) => i5 === t6.toLowerCase())) throw new Error(`[SECURITY] Invalid ${e5}: "${t5}" is a reserved JavaScript keyword that could cause prototype pollution`);
       }
-      const v9 = function(t5) {
-        const e5 = Object.assign({}, T2, t5);
-        return e5.processEntities = w6(e5.processEntities), e5;
+      function A3(t5) {
+        return "boolean" == typeof t5 ? { enabled: t5, maxEntitySize: 1e4, maxExpansionDepth: 10, maxTotalExpansions: 1e3, maxExpandedLength: 1e5, maxEntityCount: 100, allowedTags: null, tagFilter: null } : "object" == typeof t5 && null !== t5 ? { enabled: false !== t5.enabled, maxEntitySize: Math.max(1, t5.maxEntitySize ?? 1e4), maxExpansionDepth: Math.max(1, t5.maxExpansionDepth ?? 10), maxTotalExpansions: Math.max(1, t5.maxTotalExpansions ?? 1e3), maxExpandedLength: Math.max(1, t5.maxExpandedLength ?? 1e5), maxEntityCount: Math.max(1, t5.maxEntityCount ?? 100), allowedTags: t5.allowedTags ?? null, tagFilter: t5.tagFilter ?? null } : A3(true);
+      }
+      const C4 = function(t5) {
+        const e5 = Object.assign({}, P3, t5), i5 = [{ value: e5.attributeNamePrefix, name: "attributeNamePrefix" }, { value: e5.attributesGroupName, name: "attributesGroupName" }, { value: e5.textNodeName, name: "textNodeName" }, { value: e5.cdataPropName, name: "cdataPropName" }, { value: e5.commentPropName, name: "commentPropName" }];
+        for (const { value: t6, name: e6 } of i5) t6 && S2(t6, e6);
+        return null === e5.onDangerousProperty && (e5.onDangerousProperty = T2), e5.processEntities = A3(e5.processEntities), e5.stopNodes && Array.isArray(e5.stopNodes) && (e5.stopNodes = e5.stopNodes.map((t6) => "string" == typeof t6 && t6.startsWith("*.") ? ".." + t6.substring(2) : t6)), e5;
       };
       let O2;
       O2 = "function" != typeof Symbol ? "@@xmlMetadata" : Symbol("XML Node Metadata");
-      class I4 {
+      class $3 {
         constructor(t5) {
           this.tagname = t5, this.child = [], this[":@"] = /* @__PURE__ */ Object.create(null);
         }
@@ -137185,192 +137933,403 @@ var require_fxp = __commonJS({
           return O2;
         }
       }
-      class P3 {
+      class I4 {
         constructor(t5) {
           this.suppressValidationErr = !t5, this.options = t5;
         }
         readDocType(t5, e5) {
-          const n5 = /* @__PURE__ */ Object.create(null);
+          const i5 = /* @__PURE__ */ Object.create(null);
+          let n5 = 0;
           if ("O" !== t5[e5 + 3] || "C" !== t5[e5 + 4] || "T" !== t5[e5 + 5] || "Y" !== t5[e5 + 6] || "P" !== t5[e5 + 7] || "E" !== t5[e5 + 8]) throw new Error("Invalid Tag instead of DOCTYPE");
           {
             e5 += 9;
-            let i5 = 1, s7 = false, r5 = false, o5 = "";
-            for (; e5 < t5.length; e5++) if ("<" !== t5[e5] || r5) if (">" === t5[e5]) {
-              if (r5 ? "-" === t5[e5 - 1] && "-" === t5[e5 - 2] && (r5 = false, i5--) : i5--, 0 === i5) break;
-            } else "[" === t5[e5] ? s7 = true : o5 += t5[e5];
+            let s7 = 1, r5 = false, o5 = false, a5 = "";
+            for (; e5 < t5.length; e5++) if ("<" !== t5[e5] || o5) if (">" === t5[e5]) {
+              if (o5 ? "-" === t5[e5 - 1] && "-" === t5[e5 - 2] && (o5 = false, s7--) : s7--, 0 === s7) break;
+            } else "[" === t5[e5] ? r5 = true : a5 += t5[e5];
             else {
-              if (s7 && S2(t5, "!ENTITY", e5)) {
-                let i6, s8;
-                if (e5 += 7, [i6, s8, e5] = this.readEntityExp(t5, e5 + 1, this.suppressValidationErr), -1 === s8.indexOf("&")) {
-                  const t6 = i6.replace(/[.\-+*:]/g, "\\.");
-                  n5[i6] = { regx: RegExp(`&${t6};`, "g"), val: s8 };
+              if (r5 && _3(t5, "!ENTITY", e5)) {
+                let s8, r6;
+                if (e5 += 7, [s8, r6, e5] = this.readEntityExp(t5, e5 + 1, this.suppressValidationErr), -1 === r6.indexOf("&")) {
+                  if (false !== this.options.enabled && null != this.options.maxEntityCount && n5 >= this.options.maxEntityCount) throw new Error(`Entity count (${n5 + 1}) exceeds maximum allowed (${this.options.maxEntityCount})`);
+                  const t6 = s8.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                  i5[s8] = { regx: RegExp(`&${t6};`, "g"), val: r6 }, n5++;
                 }
-              } else if (s7 && S2(t5, "!ELEMENT", e5)) {
+              } else if (r5 && _3(t5, "!ELEMENT", e5)) {
                 e5 += 8;
-                const { index: n6 } = this.readElementExp(t5, e5 + 1);
-                e5 = n6;
-              } else if (s7 && S2(t5, "!ATTLIST", e5)) e5 += 8;
-              else if (s7 && S2(t5, "!NOTATION", e5)) {
+                const { index: i6 } = this.readElementExp(t5, e5 + 1);
+                e5 = i6;
+              } else if (r5 && _3(t5, "!ATTLIST", e5)) e5 += 8;
+              else if (r5 && _3(t5, "!NOTATION", e5)) {
                 e5 += 9;
-                const { index: n6 } = this.readNotationExp(t5, e5 + 1, this.suppressValidationErr);
-                e5 = n6;
+                const { index: i6 } = this.readNotationExp(t5, e5 + 1, this.suppressValidationErr);
+                e5 = i6;
               } else {
-                if (!S2(t5, "!--", e5)) throw new Error("Invalid DOCTYPE");
-                r5 = true;
+                if (!_3(t5, "!--", e5)) throw new Error("Invalid DOCTYPE");
+                o5 = true;
               }
-              i5++, o5 = "";
+              s7++, a5 = "";
             }
-            if (0 !== i5) throw new Error("Unclosed DOCTYPE");
+            if (0 !== s7) throw new Error("Unclosed DOCTYPE");
           }
-          return { entities: n5, i: e5 };
+          return { entities: i5, i: e5 };
         }
         readEntityExp(t5, e5) {
-          e5 = A3(t5, e5);
-          let n5 = "";
-          for (; e5 < t5.length && !/\s/.test(t5[e5]) && '"' !== t5[e5] && "'" !== t5[e5]; ) n5 += t5[e5], e5++;
-          if (C4(n5), e5 = A3(t5, e5), !this.suppressValidationErr) {
+          const i5 = e5 = j6(t5, e5);
+          for (; e5 < t5.length && !/\s/.test(t5[e5]) && '"' !== t5[e5] && "'" !== t5[e5]; ) e5++;
+          let n5 = t5.substring(i5, e5);
+          if (D4(n5), e5 = j6(t5, e5), !this.suppressValidationErr) {
             if ("SYSTEM" === t5.substring(e5, e5 + 6).toUpperCase()) throw new Error("External entities are not supported");
             if ("%" === t5[e5]) throw new Error("Parameter entities are not supported");
           }
-          let i5 = "";
-          if ([e5, i5] = this.readIdentifierVal(t5, e5, "entity"), false !== this.options.enabled && this.options.maxEntitySize && i5.length > this.options.maxEntitySize) throw new Error(`Entity "${n5}" size (${i5.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`);
-          return [n5, i5, --e5];
+          let s7 = "";
+          if ([e5, s7] = this.readIdentifierVal(t5, e5, "entity"), false !== this.options.enabled && null != this.options.maxEntitySize && s7.length > this.options.maxEntitySize) throw new Error(`Entity "${n5}" size (${s7.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`);
+          return [n5, s7, --e5];
         }
         readNotationExp(t5, e5) {
-          e5 = A3(t5, e5);
+          const i5 = e5 = j6(t5, e5);
+          for (; e5 < t5.length && !/\s/.test(t5[e5]); ) e5++;
+          let n5 = t5.substring(i5, e5);
+          !this.suppressValidationErr && D4(n5), e5 = j6(t5, e5);
+          const s7 = t5.substring(e5, e5 + 6).toUpperCase();
+          if (!this.suppressValidationErr && "SYSTEM" !== s7 && "PUBLIC" !== s7) throw new Error(`Expected SYSTEM or PUBLIC, found "${s7}"`);
+          e5 += s7.length, e5 = j6(t5, e5);
+          let r5 = null, o5 = null;
+          if ("PUBLIC" === s7) [e5, r5] = this.readIdentifierVal(t5, e5, "publicIdentifier"), '"' !== t5[e5 = j6(t5, e5)] && "'" !== t5[e5] || ([e5, o5] = this.readIdentifierVal(t5, e5, "systemIdentifier"));
+          else if ("SYSTEM" === s7 && ([e5, o5] = this.readIdentifierVal(t5, e5, "systemIdentifier"), !this.suppressValidationErr && !o5)) throw new Error("Missing mandatory system identifier for SYSTEM notation");
+          return { notationName: n5, publicIdentifier: r5, systemIdentifier: o5, index: --e5 };
+        }
+        readIdentifierVal(t5, e5, i5) {
           let n5 = "";
-          for (; e5 < t5.length && !/\s/.test(t5[e5]); ) n5 += t5[e5], e5++;
-          !this.suppressValidationErr && C4(n5), e5 = A3(t5, e5);
-          const i5 = t5.substring(e5, e5 + 6).toUpperCase();
-          if (!this.suppressValidationErr && "SYSTEM" !== i5 && "PUBLIC" !== i5) throw new Error(`Expected SYSTEM or PUBLIC, found "${i5}"`);
-          e5 += i5.length, e5 = A3(t5, e5);
-          let s7 = null, r5 = null;
-          if ("PUBLIC" === i5) [e5, s7] = this.readIdentifierVal(t5, e5, "publicIdentifier"), '"' !== t5[e5 = A3(t5, e5)] && "'" !== t5[e5] || ([e5, r5] = this.readIdentifierVal(t5, e5, "systemIdentifier"));
-          else if ("SYSTEM" === i5 && ([e5, r5] = this.readIdentifierVal(t5, e5, "systemIdentifier"), !this.suppressValidationErr && !r5)) throw new Error("Missing mandatory system identifier for SYSTEM notation");
-          return { notationName: n5, publicIdentifier: s7, systemIdentifier: r5, index: --e5 };
-        }
-        readIdentifierVal(t5, e5, n5) {
-          let i5 = "";
           const s7 = t5[e5];
           if ('"' !== s7 && "'" !== s7) throw new Error(`Expected quoted string, found "${s7}"`);
-          for (e5++; e5 < t5.length && t5[e5] !== s7; ) i5 += t5[e5], e5++;
-          if (t5[e5] !== s7) throw new Error(`Unterminated ${n5} value`);
-          return [++e5, i5];
+          const r5 = ++e5;
+          for (; e5 < t5.length && t5[e5] !== s7; ) e5++;
+          if (n5 = t5.substring(r5, e5), t5[e5] !== s7) throw new Error(`Unterminated ${i5} value`);
+          return [++e5, n5];
         }
         readElementExp(t5, e5) {
-          e5 = A3(t5, e5);
-          let n5 = "";
-          for (; e5 < t5.length && !/\s/.test(t5[e5]); ) n5 += t5[e5], e5++;
+          const i5 = e5 = j6(t5, e5);
+          for (; e5 < t5.length && !/\s/.test(t5[e5]); ) e5++;
+          let n5 = t5.substring(i5, e5);
           if (!this.suppressValidationErr && !r4(n5)) throw new Error(`Invalid element name: "${n5}"`);
-          let i5 = "";
-          if ("E" === t5[e5 = A3(t5, e5)] && S2(t5, "MPTY", e5)) e5 += 4;
-          else if ("A" === t5[e5] && S2(t5, "NY", e5)) e5 += 2;
+          let s7 = "";
+          if ("E" === t5[e5 = j6(t5, e5)] && _3(t5, "MPTY", e5)) e5 += 4;
+          else if ("A" === t5[e5] && _3(t5, "NY", e5)) e5 += 2;
           else if ("(" === t5[e5]) {
-            for (e5++; e5 < t5.length && ")" !== t5[e5]; ) i5 += t5[e5], e5++;
-            if (")" !== t5[e5]) throw new Error("Unterminated content model");
+            const i6 = ++e5;
+            for (; e5 < t5.length && ")" !== t5[e5]; ) e5++;
+            if (s7 = t5.substring(i6, e5), ")" !== t5[e5]) throw new Error("Unterminated content model");
           } else if (!this.suppressValidationErr) throw new Error(`Invalid Element Expression, found "${t5[e5]}"`);
-          return { elementName: n5, contentModel: i5.trim(), index: e5 };
+          return { elementName: n5, contentModel: s7.trim(), index: e5 };
         }
         readAttlistExp(t5, e5) {
-          e5 = A3(t5, e5);
-          let n5 = "";
-          for (; e5 < t5.length && !/\s/.test(t5[e5]); ) n5 += t5[e5], e5++;
-          C4(n5), e5 = A3(t5, e5);
-          let i5 = "";
-          for (; e5 < t5.length && !/\s/.test(t5[e5]); ) i5 += t5[e5], e5++;
-          if (!C4(i5)) throw new Error(`Invalid attribute name: "${i5}"`);
-          e5 = A3(t5, e5);
-          let s7 = "";
+          let i5 = e5 = j6(t5, e5);
+          for (; e5 < t5.length && !/\s/.test(t5[e5]); ) e5++;
+          let n5 = t5.substring(i5, e5);
+          for (D4(n5), i5 = e5 = j6(t5, e5); e5 < t5.length && !/\s/.test(t5[e5]); ) e5++;
+          let s7 = t5.substring(i5, e5);
+          if (!D4(s7)) throw new Error(`Invalid attribute name: "${s7}"`);
+          e5 = j6(t5, e5);
+          let r5 = "";
           if ("NOTATION" === t5.substring(e5, e5 + 8).toUpperCase()) {
-            if (s7 = "NOTATION", "(" !== t5[e5 = A3(t5, e5 += 8)]) throw new Error(`Expected '(', found "${t5[e5]}"`);
+            if (r5 = "NOTATION", "(" !== t5[e5 = j6(t5, e5 += 8)]) throw new Error(`Expected '(', found "${t5[e5]}"`);
             e5++;
-            let n6 = [];
+            let i6 = [];
             for (; e5 < t5.length && ")" !== t5[e5]; ) {
-              let i6 = "";
-              for (; e5 < t5.length && "|" !== t5[e5] && ")" !== t5[e5]; ) i6 += t5[e5], e5++;
-              if (i6 = i6.trim(), !C4(i6)) throw new Error(`Invalid notation name: "${i6}"`);
-              n6.push(i6), "|" === t5[e5] && (e5++, e5 = A3(t5, e5));
+              const n6 = e5;
+              for (; e5 < t5.length && "|" !== t5[e5] && ")" !== t5[e5]; ) e5++;
+              let s8 = t5.substring(n6, e5);
+              if (s8 = s8.trim(), !D4(s8)) throw new Error(`Invalid notation name: "${s8}"`);
+              i6.push(s8), "|" === t5[e5] && (e5++, e5 = j6(t5, e5));
             }
             if (")" !== t5[e5]) throw new Error("Unterminated list of notations");
-            e5++, s7 += " (" + n6.join("|") + ")";
+            e5++, r5 += " (" + i6.join("|") + ")";
           } else {
-            for (; e5 < t5.length && !/\s/.test(t5[e5]); ) s7 += t5[e5], e5++;
+            const i6 = e5;
+            for (; e5 < t5.length && !/\s/.test(t5[e5]); ) e5++;
+            r5 += t5.substring(i6, e5);
             const n6 = ["CDATA", "ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS"];
-            if (!this.suppressValidationErr && !n6.includes(s7.toUpperCase())) throw new Error(`Invalid attribute type: "${s7}"`);
+            if (!this.suppressValidationErr && !n6.includes(r5.toUpperCase())) throw new Error(`Invalid attribute type: "${r5}"`);
           }
-          e5 = A3(t5, e5);
-          let r5 = "";
-          return "#REQUIRED" === t5.substring(e5, e5 + 8).toUpperCase() ? (r5 = "#REQUIRED", e5 += 8) : "#IMPLIED" === t5.substring(e5, e5 + 7).toUpperCase() ? (r5 = "#IMPLIED", e5 += 7) : [e5, r5] = this.readIdentifierVal(t5, e5, "ATTLIST"), { elementName: n5, attributeName: i5, attributeType: s7, defaultValue: r5, index: e5 };
+          e5 = j6(t5, e5);
+          let o5 = "";
+          return "#REQUIRED" === t5.substring(e5, e5 + 8).toUpperCase() ? (o5 = "#REQUIRED", e5 += 8) : "#IMPLIED" === t5.substring(e5, e5 + 7).toUpperCase() ? (o5 = "#IMPLIED", e5 += 7) : [e5, o5] = this.readIdentifierVal(t5, e5, "ATTLIST"), { elementName: n5, attributeName: s7, attributeType: r5, defaultValue: o5, index: e5 };
         }
       }
-      const A3 = (t5, e5) => {
+      const j6 = (t5, e5) => {
         for (; e5 < t5.length && /\s/.test(t5[e5]); ) e5++;
         return e5;
       };
-      function S2(t5, e5, n5) {
-        for (let i5 = 0; i5 < e5.length; i5++) if (e5[i5] !== t5[n5 + i5 + 1]) return false;
+      function _3(t5, e5, i5) {
+        for (let n5 = 0; n5 < e5.length; n5++) if (e5[n5] !== t5[i5 + n5 + 1]) return false;
         return true;
       }
-      function C4(t5) {
+      function D4(t5) {
         if (r4(t5)) return t5;
         throw new Error(`Invalid entity name ${t5}`);
       }
-      const $3 = /^[-+]?0x[a-fA-F0-9]+$/, V2 = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/, D4 = { hex: true, leadingZeros: true, decimalPoint: ".", eNotation: true };
-      const j6 = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
-      function L3(t5) {
-        return "function" == typeof t5 ? t5 : Array.isArray(t5) ? (e5) => {
-          for (const n5 of t5) {
-            if ("string" == typeof n5 && e5 === n5) return true;
-            if (n5 instanceof RegExp && n5.test(e5)) return true;
+      const V2 = /^[-+]?0x[a-fA-F0-9]+$/, k6 = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/, M3 = { hex: true, leadingZeros: true, decimalPoint: ".", eNotation: true, infinity: "original" };
+      const F4 = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
+      class L3 {
+        constructor(t5 = {}) {
+          this.separator = t5.separator || ".", this.path = [], this.siblingStacks = [];
+        }
+        push(t5, e5 = null, i5 = null) {
+          this.path.length > 0 && (this.path[this.path.length - 1].values = void 0);
+          const n5 = this.path.length;
+          this.siblingStacks[n5] || (this.siblingStacks[n5] = /* @__PURE__ */ new Map());
+          const s7 = this.siblingStacks[n5], r5 = i5 ? `${i5}:${t5}` : t5, o5 = s7.get(r5) || 0;
+          let a5 = 0;
+          for (const t6 of s7.values()) a5 += t6;
+          s7.set(r5, o5 + 1);
+          const h5 = { tag: t5, position: a5, counter: o5 };
+          null != i5 && (h5.namespace = i5), null != e5 && (h5.values = e5), this.path.push(h5);
+        }
+        pop() {
+          if (0 === this.path.length) return;
+          const t5 = this.path.pop();
+          return this.siblingStacks.length > this.path.length + 1 && (this.siblingStacks.length = this.path.length + 1), t5;
+        }
+        updateCurrent(t5) {
+          if (this.path.length > 0) {
+            const e5 = this.path[this.path.length - 1];
+            null != t5 && (e5.values = t5);
+          }
+        }
+        getCurrentTag() {
+          return this.path.length > 0 ? this.path[this.path.length - 1].tag : void 0;
+        }
+        getCurrentNamespace() {
+          return this.path.length > 0 ? this.path[this.path.length - 1].namespace : void 0;
+        }
+        getAttrValue(t5) {
+          if (0 === this.path.length) return;
+          const e5 = this.path[this.path.length - 1];
+          return e5.values?.[t5];
+        }
+        hasAttr(t5) {
+          if (0 === this.path.length) return false;
+          const e5 = this.path[this.path.length - 1];
+          return void 0 !== e5.values && t5 in e5.values;
+        }
+        getPosition() {
+          return 0 === this.path.length ? -1 : this.path[this.path.length - 1].position ?? 0;
+        }
+        getCounter() {
+          return 0 === this.path.length ? -1 : this.path[this.path.length - 1].counter ?? 0;
+        }
+        getIndex() {
+          return this.getPosition();
+        }
+        getDepth() {
+          return this.path.length;
+        }
+        toString(t5, e5 = true) {
+          const i5 = t5 || this.separator;
+          return this.path.map((t6) => e5 && t6.namespace ? `${t6.namespace}:${t6.tag}` : t6.tag).join(i5);
+        }
+        toArray() {
+          return this.path.map((t5) => t5.tag);
+        }
+        reset() {
+          this.path = [], this.siblingStacks = [];
+        }
+        matches(t5) {
+          const e5 = t5.segments;
+          return 0 !== e5.length && (t5.hasDeepWildcard() ? this._matchWithDeepWildcard(e5) : this._matchSimple(e5));
+        }
+        _matchSimple(t5) {
+          if (this.path.length !== t5.length) return false;
+          for (let e5 = 0; e5 < t5.length; e5++) {
+            const i5 = t5[e5], n5 = this.path[e5], s7 = e5 === this.path.length - 1;
+            if (!this._matchSegment(i5, n5, s7)) return false;
           }
-        } : () => false;
+          return true;
+        }
+        _matchWithDeepWildcard(t5) {
+          let e5 = this.path.length - 1, i5 = t5.length - 1;
+          for (; i5 >= 0 && e5 >= 0; ) {
+            const n5 = t5[i5];
+            if ("deep-wildcard" === n5.type) {
+              if (i5--, i5 < 0) return true;
+              const n6 = t5[i5];
+              let s7 = false;
+              for (let t6 = e5; t6 >= 0; t6--) {
+                const r5 = t6 === this.path.length - 1;
+                if (this._matchSegment(n6, this.path[t6], r5)) {
+                  e5 = t6 - 1, i5--, s7 = true;
+                  break;
+                }
+              }
+              if (!s7) return false;
+            } else {
+              const t6 = e5 === this.path.length - 1;
+              if (!this._matchSegment(n5, this.path[e5], t6)) return false;
+              e5--, i5--;
+            }
+          }
+          return i5 < 0;
+        }
+        _matchSegment(t5, e5, i5) {
+          if ("*" !== t5.tag && t5.tag !== e5.tag) return false;
+          if (void 0 !== t5.namespace && "*" !== t5.namespace && t5.namespace !== e5.namespace) return false;
+          if (void 0 !== t5.attrName) {
+            if (!i5) return false;
+            if (!e5.values || !(t5.attrName in e5.values)) return false;
+            if (void 0 !== t5.attrValue) {
+              const i6 = e5.values[t5.attrName];
+              if (String(i6) !== String(t5.attrValue)) return false;
+            }
+          }
+          if (void 0 !== t5.position) {
+            if (!i5) return false;
+            const n5 = e5.counter ?? 0;
+            if ("first" === t5.position && 0 !== n5) return false;
+            if ("odd" === t5.position && n5 % 2 != 1) return false;
+            if ("even" === t5.position && n5 % 2 != 0) return false;
+            if ("nth" === t5.position && n5 !== t5.positionValue) return false;
+          }
+          return true;
+        }
+        snapshot() {
+          return { path: this.path.map((t5) => ({ ...t5 })), siblingStacks: this.siblingStacks.map((t5) => new Map(t5)) };
+        }
+        restore(t5) {
+          this.path = t5.path.map((t6) => ({ ...t6 })), this.siblingStacks = t5.siblingStacks.map((t6) => new Map(t6));
+        }
+      }
+      class G4 {
+        constructor(t5, e5 = {}) {
+          this.pattern = t5, this.separator = e5.separator || ".", this.segments = this._parse(t5), this._hasDeepWildcard = this.segments.some((t6) => "deep-wildcard" === t6.type), this._hasAttributeCondition = this.segments.some((t6) => void 0 !== t6.attrName), this._hasPositionSelector = this.segments.some((t6) => void 0 !== t6.position);
+        }
+        _parse(t5) {
+          const e5 = [];
+          let i5 = 0, n5 = "";
+          for (; i5 < t5.length; ) t5[i5] === this.separator ? i5 + 1 < t5.length && t5[i5 + 1] === this.separator ? (n5.trim() && (e5.push(this._parseSegment(n5.trim())), n5 = ""), e5.push({ type: "deep-wildcard" }), i5 += 2) : (n5.trim() && e5.push(this._parseSegment(n5.trim())), n5 = "", i5++) : (n5 += t5[i5], i5++);
+          return n5.trim() && e5.push(this._parseSegment(n5.trim())), e5;
+        }
+        _parseSegment(t5) {
+          const e5 = { type: "tag" };
+          let i5 = null, n5 = t5;
+          const s7 = t5.match(/^([^\[]+)(\[[^\]]*\])(.*)$/);
+          if (s7 && (n5 = s7[1] + s7[3], s7[2])) {
+            const t6 = s7[2].slice(1, -1);
+            t6 && (i5 = t6);
+          }
+          let r5, o5, a5 = n5;
+          if (n5.includes("::")) {
+            const e6 = n5.indexOf("::");
+            if (r5 = n5.substring(0, e6).trim(), a5 = n5.substring(e6 + 2).trim(), !r5) throw new Error(`Invalid namespace in pattern: ${t5}`);
+          }
+          let h5 = null;
+          if (a5.includes(":")) {
+            const t6 = a5.lastIndexOf(":"), e6 = a5.substring(0, t6).trim(), i6 = a5.substring(t6 + 1).trim();
+            ["first", "last", "odd", "even"].includes(i6) || /^nth\(\d+\)$/.test(i6) ? (o5 = e6, h5 = i6) : o5 = a5;
+          } else o5 = a5;
+          if (!o5) throw new Error(`Invalid segment pattern: ${t5}`);
+          if (e5.tag = o5, r5 && (e5.namespace = r5), i5) if (i5.includes("=")) {
+            const t6 = i5.indexOf("=");
+            e5.attrName = i5.substring(0, t6).trim(), e5.attrValue = i5.substring(t6 + 1).trim();
+          } else e5.attrName = i5.trim();
+          if (h5) {
+            const t6 = h5.match(/^nth\((\d+)\)$/);
+            t6 ? (e5.position = "nth", e5.positionValue = parseInt(t6[1], 10)) : e5.position = h5;
+          }
+          return e5;
+        }
+        get length() {
+          return this.segments.length;
+        }
+        hasDeepWildcard() {
+          return this._hasDeepWildcard;
+        }
+        hasAttributeCondition() {
+          return this._hasAttributeCondition;
+        }
+        hasPositionSelector() {
+          return this._hasPositionSelector;
+        }
+        toString() {
+          return this.pattern;
+        }
       }
-      class F4 {
+      function R2(t5, e5) {
+        if (!t5) return {};
+        const i5 = e5.attributesGroupName ? t5[e5.attributesGroupName] : t5;
+        if (!i5) return {};
+        const n5 = {};
+        for (const t6 in i5) t6.startsWith(e5.attributeNamePrefix) ? n5[t6.substring(e5.attributeNamePrefix.length)] = i5[t6] : n5[t6] = i5[t6];
+        return n5;
+      }
+      function U3(t5) {
+        if (!t5 || "string" != typeof t5) return;
+        const e5 = t5.indexOf(":");
+        if (-1 !== e5 && e5 > 0) {
+          const i5 = t5.substring(0, e5);
+          if ("xmlns" !== i5) return i5;
+        }
+      }
+      class B4 {
         constructor(t5) {
-          if (this.options = t5, 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: "\xA2" }, pound: { regex: /&(pound|#163);/g, val: "\xA3" }, yen: { regex: /&(yen|#165);/g, val: "\xA5" }, euro: { regex: /&(euro|#8364);/g, val: "\u20AC" }, copyright: { regex: /&(copy|#169);/g, val: "\xA9" }, reg: { regex: /&(reg|#174);/g, val: "\xAE" }, inr: { regex: /&(inr|#8377);/g, val: "\u20B9" }, num_dec: { regex: /&#([0-9]{1,7});/g, val: (t6, e5) => Q3(e5, 10, "&#") }, num_hex: { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (t6, e5) => Q3(e5, 16, "&#x") } }, this.addExternalEntities = M3, this.parseXml = R2, this.parseTextData = k6, this.resolveNameSpace = _3, this.buildAttributesMap = B4, this.isItStopNode = z4, this.replaceEntitiesValue = G4, this.readStopNodeData = Z3, this.saveTextToParentTag = X3, this.addChild = Y2, this.ignoreAttributesFn = L3(this.options.ignoreAttributes), this.entityExpansionCount = 0, this.currentExpandedLength = 0, this.options.stopNodes && this.options.stopNodes.length > 0) {
-            this.stopNodesExact = /* @__PURE__ */ new Set(), this.stopNodesWildcard = /* @__PURE__ */ new Set();
+          var e5;
+          if (this.options = t5, 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: "\xA2" }, pound: { regex: /&(pound|#163);/g, val: "\xA3" }, yen: { regex: /&(yen|#165);/g, val: "\xA5" }, euro: { regex: /&(euro|#8364);/g, val: "\u20AC" }, copyright: { regex: /&(copy|#169);/g, val: "\xA9" }, reg: { regex: /&(reg|#174);/g, val: "\xAE" }, inr: { regex: /&(inr|#8377);/g, val: "\u20B9" }, num_dec: { regex: /&#([0-9]{1,7});/g, val: (t6, e6) => st2(e6, 10, "&#") }, num_hex: { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (t6, e6) => st2(e6, 16, "&#x") } }, this.addExternalEntities = W3, this.parseXml = Z3, this.parseTextData = Y2, this.resolveNameSpace = X3, this.buildAttributesMap = q6, this.isItStopNode = H3, this.replaceEntitiesValue = K3, this.readStopNodeData = it2, this.saveTextToParentTag = Q3, this.addChild = J4, this.ignoreAttributesFn = "function" == typeof (e5 = this.options.ignoreAttributes) ? e5 : Array.isArray(e5) ? (t6) => {
+            for (const i5 of e5) {
+              if ("string" == typeof i5 && t6 === i5) return true;
+              if (i5 instanceof RegExp && i5.test(t6)) return true;
+            }
+          } : () => false, this.entityExpansionCount = 0, this.currentExpandedLength = 0, this.matcher = new L3(), this.isCurrentNodeStopNode = false, this.options.stopNodes && this.options.stopNodes.length > 0) {
+            this.stopNodeExpressions = [];
             for (let t6 = 0; t6 < this.options.stopNodes.length; t6++) {
-              const e5 = this.options.stopNodes[t6];
-              "string" == typeof e5 && (e5.startsWith("*.") ? this.stopNodesWildcard.add(e5.substring(2)) : this.stopNodesExact.add(e5));
+              const e6 = this.options.stopNodes[t6];
+              "string" == typeof e6 ? this.stopNodeExpressions.push(new G4(e6)) : e6 instanceof G4 && this.stopNodeExpressions.push(e6);
             }
           }
         }
       }
-      function M3(t5) {
+      function W3(t5) {
         const e5 = Object.keys(t5);
-        for (let n5 = 0; n5 < e5.length; n5++) {
-          const i5 = e5[n5], s7 = i5.replace(/[.\-+*:]/g, "\\.");
-          this.lastEntities[i5] = { regex: new RegExp("&" + s7 + ";", "g"), val: t5[i5] };
+        for (let i5 = 0; i5 < e5.length; i5++) {
+          const n5 = e5[i5], s7 = n5.replace(/[.\-+*:]/g, "\\.");
+          this.lastEntities[n5] = { regex: new RegExp("&" + s7 + ";", "g"), val: t5[n5] };
         }
       }
-      function k6(t5, e5, n5, i5, s7, r5, o5) {
-        if (void 0 !== t5 && (this.options.trimValues && !i5 && (t5 = t5.trim()), t5.length > 0)) {
-          o5 || (t5 = this.replaceEntitiesValue(t5, e5, n5));
-          const i6 = this.options.tagValueProcessor(e5, t5, n5, s7, r5);
-          return null == i6 ? t5 : typeof i6 != typeof t5 || i6 !== t5 ? i6 : this.options.trimValues || t5.trim() === t5 ? K3(t5, this.options.parseTagValue, this.options.numberParseOptions) : t5;
+      function Y2(t5, e5, i5, n5, s7, r5, o5) {
+        if (void 0 !== t5 && (this.options.trimValues && !n5 && (t5 = t5.trim()), t5.length > 0)) {
+          o5 || (t5 = this.replaceEntitiesValue(t5, e5, i5));
+          const n6 = this.options.jPath ? i5.toString() : i5, a5 = this.options.tagValueProcessor(e5, t5, n6, s7, r5);
+          return null == a5 ? t5 : typeof a5 != typeof t5 || a5 !== t5 ? a5 : this.options.trimValues || t5.trim() === t5 ? nt2(t5, this.options.parseTagValue, this.options.numberParseOptions) : t5;
         }
       }
-      function _3(t5) {
+      function X3(t5) {
         if (this.options.removeNSPrefix) {
-          const e5 = t5.split(":"), n5 = "/" === t5.charAt(0) ? "/" : "";
+          const e5 = t5.split(":"), i5 = "/" === t5.charAt(0) ? "/" : "";
           if ("xmlns" === e5[0]) return "";
-          2 === e5.length && (t5 = n5 + e5[1]);
+          2 === e5.length && (t5 = i5 + e5[1]);
         }
         return t5;
       }
-      const U3 = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
-      function B4(t5, e5, n5) {
+      const z4 = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
+      function q6(t5, e5, i5) {
         if (true !== this.options.ignoreAttributes && "string" == typeof t5) {
-          const i5 = s6(t5, U3), r5 = i5.length, o5 = {};
+          const n5 = s6(t5, z4), r5 = n5.length, o5 = {}, a5 = {};
           for (let t6 = 0; t6 < r5; t6++) {
-            const s7 = this.resolveNameSpace(i5[t6][1]);
-            if (this.ignoreAttributesFn(s7, e5)) continue;
-            let r6 = i5[t6][4], a5 = this.options.attributeNamePrefix + s7;
-            if (s7.length) if (this.options.transformAttributeName && (a5 = this.options.transformAttributeName(a5)), "__proto__" === a5 && (a5 = "#__proto__"), void 0 !== r6) {
-              this.options.trimValues && (r6 = r6.trim()), r6 = this.replaceEntitiesValue(r6, n5, e5);
-              const t7 = this.options.attributeValueProcessor(s7, r6, e5);
-              o5[a5] = null == t7 ? r6 : typeof t7 != typeof r6 || t7 !== r6 ? t7 : K3(r6, this.options.parseAttributeValue, this.options.numberParseOptions);
-            } else this.options.allowBooleanAttributes && (o5[a5] = true);
+            const s7 = this.resolveNameSpace(n5[t6][1]), r6 = n5[t6][4];
+            if (s7.length && void 0 !== r6) {
+              let t7 = r6;
+              this.options.trimValues && (t7 = t7.trim()), t7 = this.replaceEntitiesValue(t7, i5, e5), a5[s7] = t7;
+            }
+          }
+          Object.keys(a5).length > 0 && "object" == typeof e5 && e5.updateCurrent && e5.updateCurrent(a5);
+          for (let t6 = 0; t6 < r5; t6++) {
+            const s7 = this.resolveNameSpace(n5[t6][1]), r6 = this.options.jPath ? e5.toString() : e5;
+            if (this.ignoreAttributesFn(s7, r6)) continue;
+            let a6 = n5[t6][4], h5 = this.options.attributeNamePrefix + s7;
+            if (s7.length) if (this.options.transformAttributeName && (h5 = this.options.transformAttributeName(h5)), h5 = ot2(h5, this.options), void 0 !== a6) {
+              this.options.trimValues && (a6 = a6.trim()), a6 = this.replaceEntitiesValue(a6, i5, e5);
+              const t7 = this.options.jPath ? e5.toString() : e5, n6 = this.options.attributeValueProcessor(s7, a6, t7);
+              o5[h5] = null == n6 ? a6 : typeof n6 != typeof a6 || n6 !== a6 ? n6 : nt2(a6, this.options.parseAttributeValue, this.options.numberParseOptions);
+            } else this.options.allowBooleanAttributes && (o5[h5] = true);
           }
           if (!Object.keys(o5).length) return;
           if (this.options.attributesGroupName) {
@@ -137380,282 +138339,340 @@ var require_fxp = __commonJS({
           return o5;
         }
       }
-      const R2 = function(t5) {
+      const Z3 = function(t5) {
         t5 = t5.replace(/\r\n?/g, "\n");
-        const e5 = new I4("!xml");
-        let n5 = e5, i5 = "", s7 = "";
-        this.entityExpansionCount = 0, this.currentExpandedLength = 0;
-        const r5 = new P3(this.options.processEntities);
-        for (let o5 = 0; o5 < t5.length; o5++) if ("<" === t5[o5]) if ("/" === t5[o5 + 1]) {
-          const e6 = W3(t5, ">", o5, "Closing Tag is not closed.");
-          let r6 = t5.substring(o5 + 2, e6).trim();
+        const e5 = new $3("!xml");
+        let i5 = e5, n5 = "";
+        this.matcher.reset(), this.entityExpansionCount = 0, this.currentExpandedLength = 0;
+        const s7 = new I4(this.options.processEntities);
+        for (let r5 = 0; r5 < t5.length; r5++) if ("<" === t5[r5]) if ("/" === t5[r5 + 1]) {
+          const e6 = tt2(t5, ">", r5, "Closing Tag is not closed.");
+          let s8 = t5.substring(r5 + 2, e6).trim();
           if (this.options.removeNSPrefix) {
-            const t6 = r6.indexOf(":");
-            -1 !== t6 && (r6 = r6.substr(t6 + 1));
-          }
-          this.options.transformTagName && (r6 = this.options.transformTagName(r6)), n5 && (i5 = this.saveTextToParentTag(i5, n5, s7));
-          const a5 = s7.substring(s7.lastIndexOf(".") + 1);
-          if (r6 && -1 !== this.options.unpairedTags.indexOf(r6)) throw new Error(`Unpaired tag can not be used as closing tag: </${r6}>`);
-          let l5 = 0;
-          a5 && -1 !== this.options.unpairedTags.indexOf(a5) ? (l5 = s7.lastIndexOf(".", s7.lastIndexOf(".") - 1), this.tagsNodeStack.pop()) : l5 = s7.lastIndexOf("."), s7 = s7.substring(0, l5), n5 = this.tagsNodeStack.pop(), i5 = "", o5 = e6;
-        } else if ("?" === t5[o5 + 1]) {
-          let e6 = q6(t5, o5, false, "?>");
+            const t6 = s8.indexOf(":");
+            -1 !== t6 && (s8 = s8.substr(t6 + 1));
+          }
+          s8 = rt2(this.options.transformTagName, s8, "", this.options).tagName, i5 && (n5 = this.saveTextToParentTag(n5, i5, this.matcher));
+          const o5 = this.matcher.getCurrentTag();
+          if (s8 && -1 !== this.options.unpairedTags.indexOf(s8)) throw new Error(`Unpaired tag can not be used as closing tag: </${s8}>`);
+          o5 && -1 !== this.options.unpairedTags.indexOf(o5) && (this.matcher.pop(), this.tagsNodeStack.pop()), this.matcher.pop(), this.isCurrentNodeStopNode = false, i5 = this.tagsNodeStack.pop(), n5 = "", r5 = e6;
+        } else if ("?" === t5[r5 + 1]) {
+          let e6 = et2(t5, r5, false, "?>");
           if (!e6) throw new Error("Pi Tag is not closed.");
-          if (i5 = this.saveTextToParentTag(i5, n5, s7), this.options.ignoreDeclaration && "?xml" === e6.tagName || this.options.ignorePiTags) ;
+          if (n5 = this.saveTextToParentTag(n5, i5, this.matcher), this.options.ignoreDeclaration && "?xml" === e6.tagName || this.options.ignorePiTags) ;
           else {
-            const t6 = new I4(e6.tagName);
-            t6.add(this.options.textNodeName, ""), e6.tagName !== e6.tagExp && e6.attrExpPresent && (t6[":@"] = this.buildAttributesMap(e6.tagExp, s7, e6.tagName)), this.addChild(n5, t6, s7, o5);
+            const t6 = new $3(e6.tagName);
+            t6.add(this.options.textNodeName, ""), e6.tagName !== e6.tagExp && e6.attrExpPresent && (t6[":@"] = this.buildAttributesMap(e6.tagExp, this.matcher, e6.tagName)), this.addChild(i5, t6, this.matcher, r5);
           }
-          o5 = e6.closeIndex + 1;
-        } else if ("!--" === t5.substr(o5 + 1, 3)) {
-          const e6 = W3(t5, "-->", o5 + 4, "Comment is not closed.");
+          r5 = e6.closeIndex + 1;
+        } else if ("!--" === t5.substr(r5 + 1, 3)) {
+          const e6 = tt2(t5, "-->", r5 + 4, "Comment is not closed.");
           if (this.options.commentPropName) {
-            const r6 = t5.substring(o5 + 4, e6 - 2);
-            i5 = this.saveTextToParentTag(i5, n5, s7), n5.add(this.options.commentPropName, [{ [this.options.textNodeName]: r6 }]);
-          }
-          o5 = e6;
-        } else if ("!D" === t5.substr(o5 + 1, 2)) {
-          const e6 = r5.readDocType(t5, o5);
-          this.docTypeEntities = e6.entities, o5 = e6.i;
-        } else if ("![" === t5.substr(o5 + 1, 2)) {
-          const e6 = W3(t5, "]]>", o5, "CDATA is not closed.") - 2, r6 = t5.substring(o5 + 9, e6);
-          i5 = this.saveTextToParentTag(i5, n5, s7);
-          let a5 = this.parseTextData(r6, n5.tagname, s7, true, false, true, true);
-          null == a5 && (a5 = ""), this.options.cdataPropName ? n5.add(this.options.cdataPropName, [{ [this.options.textNodeName]: r6 }]) : n5.add(this.options.textNodeName, a5), o5 = e6 + 2;
+            const s8 = t5.substring(r5 + 4, e6 - 2);
+            n5 = this.saveTextToParentTag(n5, i5, this.matcher), i5.add(this.options.commentPropName, [{ [this.options.textNodeName]: s8 }]);
+          }
+          r5 = e6;
+        } else if ("!D" === t5.substr(r5 + 1, 2)) {
+          const e6 = s7.readDocType(t5, r5);
+          this.docTypeEntities = e6.entities, r5 = e6.i;
+        } else if ("![" === t5.substr(r5 + 1, 2)) {
+          const e6 = tt2(t5, "]]>", r5, "CDATA is not closed.") - 2, s8 = t5.substring(r5 + 9, e6);
+          n5 = this.saveTextToParentTag(n5, i5, this.matcher);
+          let o5 = this.parseTextData(s8, i5.tagname, this.matcher, true, false, true, true);
+          null == o5 && (o5 = ""), this.options.cdataPropName ? i5.add(this.options.cdataPropName, [{ [this.options.textNodeName]: s8 }]) : i5.add(this.options.textNodeName, o5), r5 = e6 + 2;
         } else {
-          let r6 = q6(t5, o5, this.options.removeNSPrefix), a5 = r6.tagName;
-          const l5 = r6.rawTagName;
-          let u8 = r6.tagExp, d6 = r6.attrExpPresent, h5 = r6.closeIndex;
-          if (this.options.transformTagName) {
-            const t6 = this.options.transformTagName(a5);
-            u8 === a5 && (u8 = t6), a5 = t6;
-          }
-          n5 && i5 && "!xml" !== n5.tagname && (i5 = this.saveTextToParentTag(i5, n5, s7, false));
-          const p6 = n5;
-          p6 && -1 !== this.options.unpairedTags.indexOf(p6.tagname) && (n5 = this.tagsNodeStack.pop(), s7 = s7.substring(0, s7.lastIndexOf("."))), a5 !== e5.tagname && (s7 += s7 ? "." + a5 : a5);
-          const c5 = o5;
-          if (this.isItStopNode(this.stopNodesExact, this.stopNodesWildcard, s7, a5)) {
+          let s8 = et2(t5, r5, this.options.removeNSPrefix);
+          if (!s8) {
+            const e6 = t5.substring(Math.max(0, r5 - 50), Math.min(t5.length, r5 + 50));
+            throw new Error(`readTagExp returned undefined at position ${r5}. Context: "${e6}"`);
+          }
+          let o5 = s8.tagName;
+          const a5 = s8.rawTagName;
+          let h5 = s8.tagExp, l5 = s8.attrExpPresent, p6 = s8.closeIndex;
+          if ({ tagName: o5, tagExp: h5 } = rt2(this.options.transformTagName, o5, h5, this.options), this.options.strictReservedNames && (o5 === this.options.commentPropName || o5 === this.options.cdataPropName || o5 === this.options.textNodeName || o5 === this.options.attributesGroupName)) throw new Error(`Invalid tag name: ${o5}`);
+          i5 && n5 && "!xml" !== i5.tagname && (n5 = this.saveTextToParentTag(n5, i5, this.matcher, false));
+          const u8 = i5;
+          u8 && -1 !== this.options.unpairedTags.indexOf(u8.tagname) && (i5 = this.tagsNodeStack.pop(), this.matcher.pop());
+          let c5 = false;
+          h5.length > 0 && h5.lastIndexOf("/") === h5.length - 1 && (c5 = true, "/" === o5[o5.length - 1] ? (o5 = o5.substr(0, o5.length - 1), h5 = o5) : h5 = h5.substr(0, h5.length - 1), l5 = o5 !== h5);
+          let d6, f6 = null, g6 = {};
+          d6 = U3(a5), o5 !== e5.tagname && this.matcher.push(o5, {}, d6), o5 !== h5 && l5 && (f6 = this.buildAttributesMap(h5, this.matcher, o5), f6 && (g6 = R2(f6, this.options))), o5 !== e5.tagname && (this.isCurrentNodeStopNode = this.isItStopNode(this.stopNodeExpressions, this.matcher));
+          const m7 = r5;
+          if (this.isCurrentNodeStopNode) {
             let e6 = "";
-            if (u8.length > 0 && u8.lastIndexOf("/") === u8.length - 1) "/" === a5[a5.length - 1] ? (a5 = a5.substr(0, a5.length - 1), s7 = s7.substr(0, s7.length - 1), u8 = a5) : u8 = u8.substr(0, u8.length - 1), o5 = r6.closeIndex;
-            else if (-1 !== this.options.unpairedTags.indexOf(a5)) o5 = r6.closeIndex;
+            if (c5) r5 = s8.closeIndex;
+            else if (-1 !== this.options.unpairedTags.indexOf(o5)) r5 = s8.closeIndex;
             else {
-              const n6 = this.readStopNodeData(t5, l5, h5 + 1);
-              if (!n6) throw new Error(`Unexpected end of ${l5}`);
-              o5 = n6.i, e6 = n6.tagContent;
+              const i6 = this.readStopNodeData(t5, a5, p6 + 1);
+              if (!i6) throw new Error(`Unexpected end of ${a5}`);
+              r5 = i6.i, e6 = i6.tagContent;
             }
-            const i6 = new I4(a5);
-            a5 !== u8 && d6 && (i6[":@"] = this.buildAttributesMap(u8, s7, a5)), e6 && (e6 = this.parseTextData(e6, a5, s7, true, d6, true, true)), s7 = s7.substr(0, s7.lastIndexOf(".")), i6.add(this.options.textNodeName, e6), this.addChild(n5, i6, s7, c5);
+            const n6 = new $3(o5);
+            f6 && (n6[":@"] = f6), n6.add(this.options.textNodeName, e6), this.matcher.pop(), this.isCurrentNodeStopNode = false, this.addChild(i5, n6, this.matcher, m7);
           } else {
-            if (u8.length > 0 && u8.lastIndexOf("/") === u8.length - 1) {
-              if ("/" === a5[a5.length - 1] ? (a5 = a5.substr(0, a5.length - 1), s7 = s7.substr(0, s7.length - 1), u8 = a5) : u8 = u8.substr(0, u8.length - 1), this.options.transformTagName) {
-                const t7 = this.options.transformTagName(a5);
-                u8 === a5 && (u8 = t7), a5 = t7;
-              }
-              const t6 = new I4(a5);
-              a5 !== u8 && d6 && (t6[":@"] = this.buildAttributesMap(u8, s7, a5)), this.addChild(n5, t6, s7, c5), s7 = s7.substr(0, s7.lastIndexOf("."));
+            if (c5) {
+              ({ tagName: o5, tagExp: h5 } = rt2(this.options.transformTagName, o5, h5, this.options));
+              const t6 = new $3(o5);
+              f6 && (t6[":@"] = f6), this.addChild(i5, t6, this.matcher, m7), this.matcher.pop(), this.isCurrentNodeStopNode = false;
             } else {
-              const t6 = new I4(a5);
-              if (this.tagsNodeStack.length > this.options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
-              this.tagsNodeStack.push(n5), a5 !== u8 && d6 && (t6[":@"] = this.buildAttributesMap(u8, s7, a5)), this.addChild(n5, t6, s7, c5), n5 = t6;
+              if (-1 !== this.options.unpairedTags.indexOf(o5)) {
+                const t6 = new $3(o5);
+                f6 && (t6[":@"] = f6), this.addChild(i5, t6, this.matcher, m7), this.matcher.pop(), this.isCurrentNodeStopNode = false, r5 = s8.closeIndex;
+                continue;
+              }
+              {
+                const t6 = new $3(o5);
+                if (this.tagsNodeStack.length > this.options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
+                this.tagsNodeStack.push(i5), f6 && (t6[":@"] = f6), this.addChild(i5, t6, this.matcher, m7), i5 = t6;
+              }
             }
-            i5 = "", o5 = h5;
+            n5 = "", r5 = p6;
           }
         }
-        else i5 += t5[o5];
+        else n5 += t5[r5];
         return e5.child;
       };
-      function Y2(t5, e5, n5, i5) {
-        this.options.captureMetaData || (i5 = void 0);
-        const s7 = this.options.updateTag(e5.tagname, n5, e5[":@"]);
-        false === s7 || ("string" == typeof s7 ? (e5.tagname = s7, t5.addChild(e5, i5)) : t5.addChild(e5, i5));
+      function J4(t5, e5, i5, n5) {
+        this.options.captureMetaData || (n5 = void 0);
+        const s7 = this.options.jPath ? i5.toString() : i5, r5 = this.options.updateTag(e5.tagname, s7, e5[":@"]);
+        false === r5 || ("string" == typeof r5 ? (e5.tagname = r5, t5.addChild(e5, n5)) : t5.addChild(e5, n5));
       }
-      const G4 = function(t5, e5, n5) {
-        if (-1 === t5.indexOf("&")) return t5;
-        const i5 = this.options.processEntities;
-        if (!i5.enabled) return t5;
-        if (i5.allowedTags && !i5.allowedTags.includes(e5)) return t5;
-        if (i5.tagFilter && !i5.tagFilter(e5, n5)) return t5;
-        for (let e6 in this.docTypeEntities) {
-          const n6 = this.docTypeEntities[e6], s7 = t5.match(n6.regx);
+      function K3(t5, e5, i5) {
+        const n5 = this.options.processEntities;
+        if (!n5 || !n5.enabled) return t5;
+        if (n5.allowedTags) {
+          const s7 = this.options.jPath ? i5.toString() : i5;
+          if (!(Array.isArray(n5.allowedTags) ? n5.allowedTags.includes(e5) : n5.allowedTags(e5, s7))) return t5;
+        }
+        if (n5.tagFilter) {
+          const s7 = this.options.jPath ? i5.toString() : i5;
+          if (!n5.tagFilter(e5, s7)) return t5;
+        }
+        for (const e6 of Object.keys(this.docTypeEntities)) {
+          const i6 = this.docTypeEntities[e6], s7 = t5.match(i6.regx);
           if (s7) {
-            if (this.entityExpansionCount += s7.length, i5.maxTotalExpansions && this.entityExpansionCount > i5.maxTotalExpansions) throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${i5.maxTotalExpansions}`);
+            if (this.entityExpansionCount += s7.length, n5.maxTotalExpansions && this.entityExpansionCount > n5.maxTotalExpansions) throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${n5.maxTotalExpansions}`);
             const e7 = t5.length;
-            if (t5 = t5.replace(n6.regx, n6.val), i5.maxExpandedLength && (this.currentExpandedLength += t5.length - e7, this.currentExpandedLength > i5.maxExpandedLength)) throw new Error(`Total expanded content size exceeded: ${this.currentExpandedLength} > ${i5.maxExpandedLength}`);
+            if (t5 = t5.replace(i6.regx, i6.val), n5.maxExpandedLength && (this.currentExpandedLength += t5.length - e7, this.currentExpandedLength > n5.maxExpandedLength)) throw new Error(`Total expanded content size exceeded: ${this.currentExpandedLength} > ${n5.maxExpandedLength}`);
           }
         }
-        if (-1 === t5.indexOf("&")) return t5;
-        for (let e6 in this.lastEntities) {
-          const n6 = this.lastEntities[e6];
-          t5 = t5.replace(n6.regex, n6.val);
+        for (const e6 of Object.keys(this.lastEntities)) {
+          const i6 = this.lastEntities[e6], s7 = t5.match(i6.regex);
+          if (s7 && (this.entityExpansionCount += s7.length, n5.maxTotalExpansions && this.entityExpansionCount > n5.maxTotalExpansions)) throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${n5.maxTotalExpansions}`);
+          t5 = t5.replace(i6.regex, i6.val);
         }
         if (-1 === t5.indexOf("&")) return t5;
-        if (this.options.htmlEntities) for (let e6 in this.htmlEntities) {
-          const n6 = this.htmlEntities[e6];
-          t5 = t5.replace(n6.regex, n6.val);
+        if (this.options.htmlEntities) for (const e6 of Object.keys(this.htmlEntities)) {
+          const i6 = this.htmlEntities[e6], s7 = t5.match(i6.regex);
+          if (s7 && (this.entityExpansionCount += s7.length, n5.maxTotalExpansions && this.entityExpansionCount > n5.maxTotalExpansions)) throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${n5.maxTotalExpansions}`);
+          t5 = t5.replace(i6.regex, i6.val);
         }
         return t5.replace(this.ampEntity.regex, this.ampEntity.val);
-      };
-      function X3(t5, e5, n5, i5) {
-        return t5 && (void 0 === i5 && (i5 = 0 === e5.child.length), void 0 !== (t5 = this.parseTextData(t5, e5.tagname, n5, false, !!e5[":@"] && 0 !== Object.keys(e5[":@"]).length, i5)) && "" !== t5 && e5.add(this.options.textNodeName, t5), t5 = ""), t5;
       }
-      function z4(t5, e5, n5, i5) {
-        return !(!e5 || !e5.has(i5)) || !(!t5 || !t5.has(n5));
+      function Q3(t5, e5, i5, n5) {
+        return t5 && (void 0 === n5 && (n5 = 0 === e5.child.length), void 0 !== (t5 = this.parseTextData(t5, e5.tagname, i5, false, !!e5[":@"] && 0 !== Object.keys(e5[":@"]).length, n5)) && "" !== t5 && e5.add(this.options.textNodeName, t5), t5 = ""), t5;
+      }
+      function H3(t5, e5) {
+        if (!t5 || 0 === t5.length) return false;
+        for (let i5 = 0; i5 < t5.length; i5++) if (e5.matches(t5[i5])) return true;
+        return false;
       }
-      function W3(t5, e5, n5, i5) {
-        const s7 = t5.indexOf(e5, n5);
-        if (-1 === s7) throw new Error(i5);
+      function tt2(t5, e5, i5, n5) {
+        const s7 = t5.indexOf(e5, i5);
+        if (-1 === s7) throw new Error(n5);
         return s7 + e5.length - 1;
       }
-      function q6(t5, e5, n5, i5 = ">") {
-        const s7 = (function(t6, e6, n6 = ">") {
-          let i6, s8 = "";
+      function et2(t5, e5, i5, n5 = ">") {
+        const s7 = (function(t6, e6, i6 = ">") {
+          let n6, s8 = "";
           for (let r6 = e6; r6 < t6.length; r6++) {
             let e7 = t6[r6];
-            if (i6) e7 === i6 && (i6 = "");
-            else if ('"' === e7 || "'" === e7) i6 = e7;
-            else if (e7 === n6[0]) {
-              if (!n6[1]) return { data: s8, index: r6 };
-              if (t6[r6 + 1] === n6[1]) return { data: s8, index: r6 };
+            if (n6) e7 === n6 && (n6 = "");
+            else if ('"' === e7 || "'" === e7) n6 = e7;
+            else if (e7 === i6[0]) {
+              if (!i6[1]) return { data: s8, index: r6 };
+              if (t6[r6 + 1] === i6[1]) return { data: s8, index: r6 };
             } else "	" === e7 && (e7 = " ");
             s8 += e7;
           }
-        })(t5, e5 + 1, i5);
+        })(t5, e5 + 1, n5);
         if (!s7) return;
         let r5 = s7.data;
         const o5 = s7.index, a5 = r5.search(/\s/);
-        let l5 = r5, u8 = true;
-        -1 !== a5 && (l5 = r5.substring(0, a5), r5 = r5.substring(a5 + 1).trimStart());
-        const d6 = l5;
-        if (n5) {
-          const t6 = l5.indexOf(":");
-          -1 !== t6 && (l5 = l5.substr(t6 + 1), u8 = l5 !== s7.data.substr(t6 + 1));
+        let h5 = r5, l5 = true;
+        -1 !== a5 && (h5 = r5.substring(0, a5), r5 = r5.substring(a5 + 1).trimStart());
+        const p6 = h5;
+        if (i5) {
+          const t6 = h5.indexOf(":");
+          -1 !== t6 && (h5 = h5.substr(t6 + 1), l5 = h5 !== s7.data.substr(t6 + 1));
         }
-        return { tagName: l5, tagExp: r5, closeIndex: o5, attrExpPresent: u8, rawTagName: d6 };
+        return { tagName: h5, tagExp: r5, closeIndex: o5, attrExpPresent: l5, rawTagName: p6 };
       }
-      function Z3(t5, e5, n5) {
-        const i5 = n5;
+      function it2(t5, e5, i5) {
+        const n5 = i5;
         let s7 = 1;
-        for (; n5 < t5.length; n5++) if ("<" === t5[n5]) if ("/" === t5[n5 + 1]) {
-          const r5 = W3(t5, ">", n5, `${e5} is not closed`);
-          if (t5.substring(n5 + 2, r5).trim() === e5 && (s7--, 0 === s7)) return { tagContent: t5.substring(i5, n5), i: r5 };
-          n5 = r5;
-        } else if ("?" === t5[n5 + 1]) n5 = W3(t5, "?>", n5 + 1, "StopNode is not closed.");
-        else if ("!--" === t5.substr(n5 + 1, 3)) n5 = W3(t5, "-->", n5 + 3, "StopNode is not closed.");
-        else if ("![" === t5.substr(n5 + 1, 2)) n5 = W3(t5, "]]>", n5, "StopNode is not closed.") - 2;
+        for (; i5 < t5.length; i5++) if ("<" === t5[i5]) if ("/" === t5[i5 + 1]) {
+          const r5 = tt2(t5, ">", i5, `${e5} is not closed`);
+          if (t5.substring(i5 + 2, r5).trim() === e5 && (s7--, 0 === s7)) return { tagContent: t5.substring(n5, i5), i: r5 };
+          i5 = r5;
+        } else if ("?" === t5[i5 + 1]) i5 = tt2(t5, "?>", i5 + 1, "StopNode is not closed.");
+        else if ("!--" === t5.substr(i5 + 1, 3)) i5 = tt2(t5, "-->", i5 + 3, "StopNode is not closed.");
+        else if ("![" === t5.substr(i5 + 1, 2)) i5 = tt2(t5, "]]>", i5, "StopNode is not closed.") - 2;
         else {
-          const i6 = q6(t5, n5, ">");
-          i6 && ((i6 && i6.tagName) === e5 && "/" !== i6.tagExp[i6.tagExp.length - 1] && s7++, n5 = i6.closeIndex);
+          const n6 = et2(t5, i5, ">");
+          n6 && ((n6 && n6.tagName) === e5 && "/" !== n6.tagExp[n6.tagExp.length - 1] && s7++, i5 = n6.closeIndex);
         }
       }
-      function K3(t5, e5, n5) {
+      function nt2(t5, e5, i5) {
         if (e5 && "string" == typeof t5) {
           const e6 = t5.trim();
           return "true" === e6 || "false" !== e6 && (function(t6, e7 = {}) {
-            if (e7 = Object.assign({}, D4, e7), !t6 || "string" != typeof t6) return t6;
-            let n6 = t6.trim();
-            if (void 0 !== e7.skipLike && e7.skipLike.test(n6)) return t6;
+            if (e7 = Object.assign({}, M3, e7), !t6 || "string" != typeof t6) return t6;
+            let i6 = t6.trim();
+            if (void 0 !== e7.skipLike && e7.skipLike.test(i6)) return t6;
             if ("0" === t6) return 0;
-            if (e7.hex && $3.test(n6)) return (function(t7) {
+            if (e7.hex && V2.test(i6)) return (function(t7) {
               if (parseInt) return parseInt(t7, 16);
               if (Number.parseInt) return Number.parseInt(t7, 16);
               if (window && window.parseInt) return window.parseInt(t7, 16);
               throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
-            })(n6);
-            if (n6.includes("e") || n6.includes("E")) return (function(t7, e8, n7) {
-              if (!n7.eNotation) return t7;
-              const i6 = e8.match(j6);
-              if (i6) {
-                let s7 = i6[1] || "";
-                const r5 = -1 === i6[3].indexOf("e") ? "E" : "e", o5 = i6[2], a5 = s7 ? t7[o5.length + 1] === r5 : t7[o5.length] === r5;
-                return o5.length > 1 && a5 ? t7 : 1 !== o5.length || !i6[3].startsWith(`.${r5}`) && i6[3][0] !== r5 ? n7.leadingZeros && !a5 ? (e8 = (i6[1] || "") + i6[3], Number(e8)) : t7 : Number(e8);
-              }
-              return t7;
-            })(t6, n6, e7);
-            {
-              const s7 = V2.exec(n6);
-              if (s7) {
-                const r5 = s7[1] || "", o5 = s7[2];
-                let a5 = (i5 = s7[3]) && -1 !== i5.indexOf(".") ? ("." === (i5 = i5.replace(/0+$/, "")) ? i5 = "0" : "." === i5[0] ? i5 = "0" + i5 : "." === i5[i5.length - 1] && (i5 = i5.substring(0, i5.length - 1)), i5) : i5;
-                const l5 = r5 ? "." === t6[o5.length + 1] : "." === t6[o5.length];
-                if (!e7.leadingZeros && (o5.length > 1 || 1 === o5.length && !l5)) return t6;
-                {
-                  const i6 = Number(n6), s8 = String(i6);
-                  if (0 === i6) return i6;
-                  if (-1 !== s8.search(/[eE]/)) return e7.eNotation ? i6 : t6;
-                  if (-1 !== n6.indexOf(".")) return "0" === s8 || s8 === a5 || s8 === `${r5}${a5}` ? i6 : t6;
-                  let l6 = o5 ? a5 : n6;
-                  return o5 ? l6 === s8 || r5 + l6 === s8 ? i6 : t6 : l6 === s8 || l6 === r5 + s8 ? i6 : t6;
+            })(i6);
+            if (isFinite(i6)) {
+              if (i6.includes("e") || i6.includes("E")) return (function(t7, e8, i7) {
+                if (!i7.eNotation) return t7;
+                const n6 = e8.match(F4);
+                if (n6) {
+                  let s7 = n6[1] || "";
+                  const r5 = -1 === n6[3].indexOf("e") ? "E" : "e", o5 = n6[2], a5 = s7 ? t7[o5.length + 1] === r5 : t7[o5.length] === r5;
+                  return o5.length > 1 && a5 ? t7 : (1 !== o5.length || !n6[3].startsWith(`.${r5}`) && n6[3][0] !== r5) && o5.length > 0 ? i7.leadingZeros && !a5 ? (e8 = (n6[1] || "") + n6[3], Number(e8)) : t7 : Number(e8);
+                }
+                return t7;
+              })(t6, i6, e7);
+              {
+                const s7 = k6.exec(i6);
+                if (s7) {
+                  const r5 = s7[1] || "", o5 = s7[2];
+                  let a5 = (n5 = s7[3]) && -1 !== n5.indexOf(".") ? ("." === (n5 = n5.replace(/0+$/, "")) ? n5 = "0" : "." === n5[0] ? n5 = "0" + n5 : "." === n5[n5.length - 1] && (n5 = n5.substring(0, n5.length - 1)), n5) : n5;
+                  const h5 = r5 ? "." === t6[o5.length + 1] : "." === t6[o5.length];
+                  if (!e7.leadingZeros && (o5.length > 1 || 1 === o5.length && !h5)) return t6;
+                  {
+                    const n6 = Number(i6), s8 = String(n6);
+                    if (0 === n6) return n6;
+                    if (-1 !== s8.search(/[eE]/)) return e7.eNotation ? n6 : t6;
+                    if (-1 !== i6.indexOf(".")) return "0" === s8 || s8 === a5 || s8 === `${r5}${a5}` ? n6 : t6;
+                    let h6 = o5 ? a5 : i6;
+                    return o5 ? h6 === s8 || r5 + h6 === s8 ? n6 : t6 : h6 === s8 || h6 === r5 + s8 ? n6 : t6;
+                  }
                 }
+                return t6;
               }
-              return t6;
             }
-            var i5;
-          })(t5, n5);
+            var n5;
+            return (function(t7, e8, i7) {
+              const n6 = e8 === 1 / 0;
+              switch (i7.infinity.toLowerCase()) {
+                case "null":
+                  return null;
+                case "infinity":
+                  return e8;
+                case "string":
+                  return n6 ? "Infinity" : "-Infinity";
+                default:
+                  return t7;
+              }
+            })(t6, Number(i6), e7);
+          })(t5, i5);
         }
         return void 0 !== t5 ? t5 : "";
       }
-      function Q3(t5, e5, n5) {
-        const i5 = Number.parseInt(t5, e5);
-        return i5 >= 0 && i5 <= 1114111 ? String.fromCodePoint(i5) : n5 + t5 + ";";
+      function st2(t5, e5, i5) {
+        const n5 = Number.parseInt(t5, e5);
+        return n5 >= 0 && n5 <= 1114111 ? String.fromCodePoint(n5) : i5 + t5 + ";";
       }
-      const J4 = I4.getMetaDataSymbol();
-      function H3(t5, e5) {
-        return tt2(t5, e5);
+      function rt2(t5, e5, i5, n5) {
+        if (t5) {
+          const n6 = t5(e5);
+          i5 === e5 && (i5 = n6), e5 = n6;
+        }
+        return { tagName: e5 = ot2(e5, n5), tagExp: i5 };
+      }
+      function ot2(t5, e5) {
+        if (a4.includes(t5)) throw new Error(`[SECURITY] Invalid name: "${t5}" is a reserved JavaScript keyword that could cause prototype pollution`);
+        return o4.includes(t5) ? e5.onDangerousProperty(t5) : t5;
       }
-      function tt2(t5, e5, n5) {
-        let i5;
+      const at2 = $3.getMetaDataSymbol();
+      function ht2(t5, e5) {
+        if (!t5 || "object" != typeof t5) return {};
+        if (!e5) return t5;
+        const i5 = {};
+        for (const n5 in t5) n5.startsWith(e5) ? i5[n5.substring(e5.length)] = t5[n5] : i5[n5] = t5[n5];
+        return i5;
+      }
+      function lt2(t5, e5, i5) {
+        return pt2(t5, e5, i5);
+      }
+      function pt2(t5, e5, i5) {
+        let n5;
         const s7 = {};
         for (let r5 = 0; r5 < t5.length; r5++) {
-          const o5 = t5[r5], a5 = et2(o5);
-          let l5 = "";
-          if (l5 = void 0 === n5 ? a5 : n5 + "." + a5, a5 === e5.textNodeName) void 0 === i5 ? i5 = o5[a5] : i5 += "" + o5[a5];
+          const o5 = t5[r5], a5 = ut2(o5);
+          if (void 0 !== a5 && a5 !== e5.textNodeName) {
+            const t6 = ht2(o5[":@"] || {}, e5.attributeNamePrefix);
+            i5.push(a5, t6);
+          }
+          if (a5 === e5.textNodeName) void 0 === n5 ? n5 = o5[a5] : n5 += "" + o5[a5];
           else {
             if (void 0 === a5) continue;
             if (o5[a5]) {
-              let t6 = tt2(o5[a5], e5, l5);
-              const n6 = it2(t6, e5);
-              o5[":@"] ? nt2(t6, o5[":@"], l5, e5) : 1 !== Object.keys(t6).length || void 0 === t6[e5.textNodeName] || e5.alwaysCreateTextNode ? 0 === Object.keys(t6).length && (e5.alwaysCreateTextNode ? t6[e5.textNodeName] = "" : t6 = "") : t6 = t6[e5.textNodeName], void 0 !== o5[J4] && "object" == typeof t6 && null !== t6 && (t6[J4] = o5[J4]), void 0 !== s7[a5] && Object.prototype.hasOwnProperty.call(s7, a5) ? (Array.isArray(s7[a5]) || (s7[a5] = [s7[a5]]), s7[a5].push(t6)) : e5.isArray(a5, l5, n6) ? s7[a5] = [t6] : s7[a5] = t6;
+              let t6 = pt2(o5[a5], e5, i5);
+              const n6 = dt2(t6, e5);
+              if (o5[":@"] ? ct2(t6, o5[":@"], i5, e5) : 1 !== Object.keys(t6).length || void 0 === t6[e5.textNodeName] || e5.alwaysCreateTextNode ? 0 === Object.keys(t6).length && (e5.alwaysCreateTextNode ? t6[e5.textNodeName] = "" : t6 = "") : t6 = t6[e5.textNodeName], void 0 !== o5[at2] && "object" == typeof t6 && null !== t6 && (t6[at2] = o5[at2]), void 0 !== s7[a5] && Object.prototype.hasOwnProperty.call(s7, a5)) Array.isArray(s7[a5]) || (s7[a5] = [s7[a5]]), s7[a5].push(t6);
+              else {
+                const r6 = e5.jPath ? i5.toString() : i5;
+                e5.isArray(a5, r6, n6) ? s7[a5] = [t6] : s7[a5] = t6;
+              }
+              void 0 !== a5 && a5 !== e5.textNodeName && i5.pop();
             }
           }
         }
-        return "string" == typeof i5 ? i5.length > 0 && (s7[e5.textNodeName] = i5) : void 0 !== i5 && (s7[e5.textNodeName] = i5), s7;
+        return "string" == typeof n5 ? n5.length > 0 && (s7[e5.textNodeName] = n5) : void 0 !== n5 && (s7[e5.textNodeName] = n5), s7;
       }
-      function et2(t5) {
+      function ut2(t5) {
         const e5 = Object.keys(t5);
         for (let t6 = 0; t6 < e5.length; t6++) {
-          const n5 = e5[t6];
-          if (":@" !== n5) return n5;
+          const i5 = e5[t6];
+          if (":@" !== i5) return i5;
         }
       }
-      function nt2(t5, e5, n5, i5) {
+      function ct2(t5, e5, i5, n5) {
         if (e5) {
           const s7 = Object.keys(e5), r5 = s7.length;
           for (let o5 = 0; o5 < r5; o5++) {
-            const r6 = s7[o5];
-            i5.isArray(r6, n5 + "." + r6, true, true) ? t5[r6] = [e5[r6]] : t5[r6] = e5[r6];
+            const r6 = s7[o5], a5 = r6.startsWith(n5.attributeNamePrefix) ? r6.substring(n5.attributeNamePrefix.length) : r6, h5 = n5.jPath ? i5.toString() + "." + a5 : i5;
+            n5.isArray(r6, h5, true, true) ? t5[r6] = [e5[r6]] : t5[r6] = e5[r6];
           }
         }
       }
-      function it2(t5, e5) {
-        const { textNodeName: n5 } = e5, i5 = Object.keys(t5).length;
-        return 0 === i5 || !(1 !== i5 || !t5[n5] && "boolean" != typeof t5[n5] && 0 !== t5[n5]);
+      function dt2(t5, e5) {
+        const { textNodeName: i5 } = e5, n5 = Object.keys(t5).length;
+        return 0 === n5 || !(1 !== n5 || !t5[i5] && "boolean" != typeof t5[i5] && 0 !== t5[i5]);
       }
-      class st2 {
+      class ft2 {
         constructor(t5) {
-          this.externalEntities = {}, this.options = v9(t5);
+          this.externalEntities = {}, this.options = C4(t5);
         }
         parse(t5, e5) {
           if ("string" != typeof t5 && t5.toString) t5 = t5.toString();
           else if ("string" != typeof t5) throw new Error("XML data is accepted in String or Bytes[] form.");
           if (e5) {
             true === e5 && (e5 = {});
-            const n6 = a4(t5, e5);
-            if (true !== n6) throw Error(`${n6.err.msg}:${n6.err.line}:${n6.err.col}`);
+            const i6 = l4(t5, e5);
+            if (true !== i6) throw Error(`${i6.err.msg}:${i6.err.line}:${i6.err.col}`);
           }
-          const n5 = new F4(this.options);
-          n5.addExternalEntities(this.externalEntities);
-          const i5 = n5.parseXml(t5);
-          return this.options.preserveOrder || void 0 === i5 ? i5 : H3(i5, this.options);
+          const i5 = new B4(this.options);
+          i5.addExternalEntities(this.externalEntities);
+          const n5 = i5.parseXml(t5);
+          return this.options.preserveOrder || void 0 === n5 ? n5 : lt2(n5, this.options, i5.matcher);
         }
         addEntity(t5, e5) {
           if (-1 !== e5.indexOf("&")) throw new Error("Entity value can't have '&'");
@@ -137664,166 +138681,305 @@ var require_fxp = __commonJS({
           this.externalEntities[t5] = e5;
         }
         static getMetaDataSymbol() {
-          return I4.getMetaDataSymbol();
+          return $3.getMetaDataSymbol();
         }
       }
-      function rt2(t5, e5) {
-        let n5 = "";
-        return e5.format && e5.indentBy.length > 0 && (n5 = "\n"), ot2(t5, e5, "", n5);
+      function gt2(t5, e5) {
+        let i5 = "";
+        e5.format && e5.indentBy.length > 0 && (i5 = "\n");
+        const n5 = [];
+        if (e5.stopNodes && Array.isArray(e5.stopNodes)) for (let t6 = 0; t6 < e5.stopNodes.length; t6++) {
+          const i6 = e5.stopNodes[t6];
+          "string" == typeof i6 ? n5.push(new G4(i6)) : i6 instanceof G4 && n5.push(i6);
+        }
+        return mt2(t5, e5, i5, new L3(), n5);
       }
-      function ot2(t5, e5, n5, i5) {
-        let s7 = "", r5 = false;
+      function mt2(t5, e5, i5, n5, s7) {
+        let r5 = "", o5 = false;
+        if (e5.maxNestedTags && n5.getDepth() > e5.maxNestedTags) throw new Error("Maximum nested tags exceeded");
         if (!Array.isArray(t5)) {
           if (null != t5) {
-            let n6 = t5.toString();
-            return n6 = dt2(n6, e5), n6;
+            let i6 = t5.toString();
+            return i6 = vt2(i6, e5), i6;
           }
           return "";
         }
-        for (let o5 = 0; o5 < t5.length; o5++) {
-          const a5 = t5[o5], l5 = at2(a5);
+        for (let a5 = 0; a5 < t5.length; a5++) {
+          const h5 = t5[a5], l5 = Et2(h5);
           if (void 0 === l5) continue;
-          let u8 = "";
-          if (u8 = 0 === n5.length ? l5 : `${n5}.${l5}`, l5 === e5.textNodeName) {
-            let t6 = a5[l5];
-            ut2(u8, e5) || (t6 = e5.tagValueProcessor(l5, t6), t6 = dt2(t6, e5)), r5 && (s7 += i5), s7 += t6, r5 = false;
+          const p6 = xt2(h5[":@"], e5);
+          n5.push(l5, p6);
+          const u8 = wt2(n5, s7);
+          if (l5 === e5.textNodeName) {
+            let t6 = h5[l5];
+            u8 || (t6 = e5.tagValueProcessor(l5, t6), t6 = vt2(t6, e5)), o5 && (r5 += i5), r5 += t6, o5 = false, n5.pop();
             continue;
           }
           if (l5 === e5.cdataPropName) {
-            r5 && (s7 += i5), s7 += `<![CDATA[${a5[l5][0][e5.textNodeName]}]]>`, r5 = false;
+            o5 && (r5 += i5), r5 += `<![CDATA[${h5[l5][0][e5.textNodeName]}]]>`, o5 = false, n5.pop();
             continue;
           }
           if (l5 === e5.commentPropName) {
-            s7 += i5 + `<!--${a5[l5][0][e5.textNodeName]}-->`, r5 = true;
+            r5 += i5 + `<!--${h5[l5][0][e5.textNodeName]}-->`, o5 = true, n5.pop();
             continue;
           }
           if ("?" === l5[0]) {
-            const t6 = lt2(a5[":@"], e5), n6 = "?xml" === l5 ? "" : i5;
-            let o6 = a5[l5][0][e5.textNodeName];
-            o6 = 0 !== o6.length ? " " + o6 : "", s7 += n6 + `<${l5}${o6}${t6}?>`, r5 = true;
+            const t6 = yt2(h5[":@"], e5, u8), s8 = "?xml" === l5 ? "" : i5;
+            let a6 = h5[l5][0][e5.textNodeName];
+            a6 = 0 !== a6.length ? " " + a6 : "", r5 += s8 + `<${l5}${a6}${t6}?>`, o5 = true, n5.pop();
             continue;
           }
-          let d6 = i5;
-          "" !== d6 && (d6 += e5.indentBy);
-          const h5 = i5 + `<${l5}${lt2(a5[":@"], e5)}`, p6 = ot2(a5[l5], e5, u8, d6);
-          -1 !== e5.unpairedTags.indexOf(l5) ? e5.suppressUnpairedNode ? s7 += h5 + ">" : s7 += h5 + "/>" : p6 && 0 !== p6.length || !e5.suppressEmptyNode ? p6 && p6.endsWith(">") ? s7 += h5 + `>${p6}${i5}</${l5}>` : (s7 += h5 + ">", p6 && "" !== i5 && (p6.includes("/>") || p6.includes("</")) ? s7 += i5 + e5.indentBy + p6 + i5 : s7 += p6, s7 += `</${l5}>`) : s7 += h5 + "/>", r5 = true;
+          let c5 = i5;
+          "" !== c5 && (c5 += e5.indentBy);
+          const d6 = i5 + `<${l5}${yt2(h5[":@"], e5, u8)}`;
+          let f6;
+          f6 = u8 ? Nt3(h5[l5], e5) : mt2(h5[l5], e5, c5, n5, s7), -1 !== e5.unpairedTags.indexOf(l5) ? e5.suppressUnpairedNode ? r5 += d6 + ">" : r5 += d6 + "/>" : f6 && 0 !== f6.length || !e5.suppressEmptyNode ? f6 && f6.endsWith(">") ? r5 += d6 + `>${f6}${i5}</${l5}>` : (r5 += d6 + ">", f6 && "" !== i5 && (f6.includes("/>") || f6.includes("</")) ? r5 += i5 + e5.indentBy + f6 + i5 : r5 += f6, r5 += `</${l5}>`) : r5 += d6 + "/>", o5 = true, n5.pop();
+        }
+        return r5;
+      }
+      function xt2(t5, e5) {
+        if (!t5 || e5.ignoreAttributes) return null;
+        const i5 = {};
+        let n5 = false;
+        for (let s7 in t5) Object.prototype.hasOwnProperty.call(t5, s7) && (i5[s7.startsWith(e5.attributeNamePrefix) ? s7.substr(e5.attributeNamePrefix.length) : s7] = t5[s7], n5 = true);
+        return n5 ? i5 : null;
+      }
+      function Nt3(t5, e5) {
+        if (!Array.isArray(t5)) return null != t5 ? t5.toString() : "";
+        let i5 = "";
+        for (let n5 = 0; n5 < t5.length; n5++) {
+          const s7 = t5[n5], r5 = Et2(s7);
+          if (r5 === e5.textNodeName) i5 += s7[r5];
+          else if (r5 === e5.cdataPropName) i5 += s7[r5][0][e5.textNodeName];
+          else if (r5 === e5.commentPropName) i5 += s7[r5][0][e5.textNodeName];
+          else {
+            if (r5 && "?" === r5[0]) continue;
+            if (r5) {
+              const t6 = bt2(s7[":@"], e5), n6 = Nt3(s7[r5], e5);
+              n6 && 0 !== n6.length ? i5 += `<${r5}${t6}>${n6}</${r5}>` : i5 += `<${r5}${t6}/>`;
+            }
+          }
+        }
+        return i5;
+      }
+      function bt2(t5, e5) {
+        let i5 = "";
+        if (t5 && !e5.ignoreAttributes) for (let n5 in t5) {
+          if (!Object.prototype.hasOwnProperty.call(t5, n5)) continue;
+          let s7 = t5[n5];
+          true === s7 && e5.suppressBooleanAttributes ? i5 += ` ${n5.substr(e5.attributeNamePrefix.length)}` : i5 += ` ${n5.substr(e5.attributeNamePrefix.length)}="${s7}"`;
         }
-        return s7;
+        return i5;
       }
-      function at2(t5) {
+      function Et2(t5) {
         const e5 = Object.keys(t5);
-        for (let n5 = 0; n5 < e5.length; n5++) {
-          const i5 = e5[n5];
-          if (Object.prototype.hasOwnProperty.call(t5, i5) && ":@" !== i5) return i5;
+        for (let i5 = 0; i5 < e5.length; i5++) {
+          const n5 = e5[i5];
+          if (Object.prototype.hasOwnProperty.call(t5, n5) && ":@" !== n5) return n5;
         }
       }
-      function lt2(t5, e5) {
+      function yt2(t5, e5, i5) {
         let n5 = "";
-        if (t5 && !e5.ignoreAttributes) for (let i5 in t5) {
-          if (!Object.prototype.hasOwnProperty.call(t5, i5)) continue;
-          let s7 = e5.attributeValueProcessor(i5, t5[i5]);
-          s7 = dt2(s7, e5), true === s7 && e5.suppressBooleanAttributes ? n5 += ` ${i5.substr(e5.attributeNamePrefix.length)}` : n5 += ` ${i5.substr(e5.attributeNamePrefix.length)}="${s7}"`;
+        if (t5 && !e5.ignoreAttributes) for (let s7 in t5) {
+          if (!Object.prototype.hasOwnProperty.call(t5, s7)) continue;
+          let r5;
+          i5 ? r5 = t5[s7] : (r5 = e5.attributeValueProcessor(s7, t5[s7]), r5 = vt2(r5, e5)), true === r5 && e5.suppressBooleanAttributes ? n5 += ` ${s7.substr(e5.attributeNamePrefix.length)}` : n5 += ` ${s7.substr(e5.attributeNamePrefix.length)}="${r5}"`;
         }
         return n5;
       }
-      function ut2(t5, e5) {
-        let n5 = (t5 = t5.substr(0, t5.length - e5.textNodeName.length - 1)).substr(t5.lastIndexOf(".") + 1);
-        for (let i5 in e5.stopNodes) if (e5.stopNodes[i5] === t5 || e5.stopNodes[i5] === "*." + n5) return true;
+      function wt2(t5, e5) {
+        if (!e5 || 0 === e5.length) return false;
+        for (let i5 = 0; i5 < e5.length; i5++) if (t5.matches(e5[i5])) return true;
         return false;
       }
-      function dt2(t5, e5) {
-        if (t5 && t5.length > 0 && e5.processEntities) for (let n5 = 0; n5 < e5.entities.length; n5++) {
-          const i5 = e5.entities[n5];
-          t5 = t5.replace(i5.regex, i5.val);
+      function vt2(t5, e5) {
+        if (t5 && t5.length > 0 && e5.processEntities) for (let i5 = 0; i5 < e5.entities.length; i5++) {
+          const n5 = e5.entities[i5];
+          t5 = t5.replace(n5.regex, n5.val);
         }
         return t5;
       }
-      const ht2 = { attributeNamePrefix: "@_", attributesGroupName: false, textNodeName: "#text", ignoreAttributes: true, cdataPropName: false, format: false, indentBy: "  ", suppressEmptyNode: false, suppressUnpairedNode: true, suppressBooleanAttributes: true, tagValueProcessor: function(t5, e5) {
+      const Tt2 = { attributeNamePrefix: "@_", attributesGroupName: false, textNodeName: "#text", ignoreAttributes: true, cdataPropName: false, format: false, indentBy: "  ", suppressEmptyNode: false, suppressUnpairedNode: true, suppressBooleanAttributes: true, tagValueProcessor: function(t5, e5) {
         return e5;
       }, attributeValueProcessor: function(t5, e5) {
         return e5;
-      }, preserveOrder: false, commentPropName: false, unpairedTags: [], entities: [{ regex: new RegExp("&", "g"), val: "&amp;" }, { regex: new RegExp(">", "g"), val: "&gt;" }, { regex: new RegExp("<", "g"), val: "&lt;" }, { regex: new RegExp("'", "g"), val: "&apos;" }, { regex: new RegExp('"', "g"), val: "&quot;" }], processEntities: true, stopNodes: [], oneListGroup: false };
-      function pt2(t5) {
-        this.options = Object.assign({}, ht2, t5), true === this.options.ignoreAttributes || this.options.attributesGroupName ? this.isAttribute = function() {
+      }, preserveOrder: false, commentPropName: false, unpairedTags: [], entities: [{ regex: new RegExp("&", "g"), val: "&amp;" }, { regex: new RegExp(">", "g"), val: "&gt;" }, { regex: new RegExp("<", "g"), val: "&lt;" }, { regex: new RegExp("'", "g"), val: "&apos;" }, { regex: new RegExp('"', "g"), val: "&quot;" }], processEntities: true, stopNodes: [], oneListGroup: false, maxNestedTags: 100, jPath: true };
+      function Pt2(t5) {
+        if (this.options = Object.assign({}, Tt2, t5), this.options.stopNodes && Array.isArray(this.options.stopNodes) && (this.options.stopNodes = this.options.stopNodes.map((t6) => "string" == typeof t6 && t6.startsWith("*.") ? ".." + t6.substring(2) : t6)), this.stopNodeExpressions = [], this.options.stopNodes && Array.isArray(this.options.stopNodes)) for (let t6 = 0; t6 < this.options.stopNodes.length; t6++) {
+          const e6 = this.options.stopNodes[t6];
+          "string" == typeof e6 ? this.stopNodeExpressions.push(new G4(e6)) : e6 instanceof G4 && this.stopNodeExpressions.push(e6);
+        }
+        var e5;
+        true === this.options.ignoreAttributes || this.options.attributesGroupName ? this.isAttribute = function() {
           return false;
-        } : (this.ignoreAttributesFn = L3(this.options.ignoreAttributes), this.attrPrefixLen = this.options.attributeNamePrefix.length, this.isAttribute = gt2), this.processTextOrObjNode = ct2, this.options.format ? (this.indentate = ft2, this.tagEndChar = ">\n", this.newLine = "\n") : (this.indentate = function() {
+        } : (this.ignoreAttributesFn = "function" == typeof (e5 = this.options.ignoreAttributes) ? e5 : Array.isArray(e5) ? (t6) => {
+          for (const i5 of e5) {
+            if ("string" == typeof i5 && t6 === i5) return true;
+            if (i5 instanceof RegExp && i5.test(t6)) return true;
+          }
+        } : () => false, this.attrPrefixLen = this.options.attributeNamePrefix.length, this.isAttribute = Ct2), this.processTextOrObjNode = St2, this.options.format ? (this.indentate = At2, this.tagEndChar = ">\n", this.newLine = "\n") : (this.indentate = function() {
           return "";
         }, this.tagEndChar = ">", this.newLine = "");
       }
-      function ct2(t5, e5, n5, i5) {
-        const s7 = this.j2x(t5, n5 + 1, i5.concat(e5));
-        return void 0 !== t5[this.options.textNodeName] && 1 === Object.keys(t5).length ? this.buildTextValNode(t5[this.options.textNodeName], e5, s7.attrStr, n5) : this.buildObjectNode(s7.val, e5, s7.attrStr, n5);
+      function St2(t5, e5, i5, n5) {
+        const s7 = this.extractAttributes(t5);
+        if (n5.push(e5, s7), this.checkStopNode(n5)) {
+          const s8 = this.buildRawContent(t5), r6 = this.buildAttributesForStopNode(t5);
+          return n5.pop(), this.buildObjectNode(s8, e5, r6, i5);
+        }
+        const r5 = this.j2x(t5, i5 + 1, n5);
+        return n5.pop(), void 0 !== t5[this.options.textNodeName] && 1 === Object.keys(t5).length ? this.buildTextValNode(t5[this.options.textNodeName], e5, r5.attrStr, i5, n5) : this.buildObjectNode(r5.val, e5, r5.attrStr, i5);
       }
-      function ft2(t5) {
+      function At2(t5) {
         return this.options.indentBy.repeat(t5);
       }
-      function gt2(t5) {
+      function Ct2(t5) {
         return !(!t5.startsWith(this.options.attributeNamePrefix) || t5 === this.options.textNodeName) && t5.substr(this.attrPrefixLen);
       }
-      pt2.prototype.build = function(t5) {
-        return this.options.preserveOrder ? rt2(t5, this.options) : (Array.isArray(t5) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1 && (t5 = { [this.options.arrayNodeName]: t5 }), this.j2x(t5, 0, []).val);
-      }, pt2.prototype.j2x = function(t5, e5, n5) {
-        let i5 = "", s7 = "";
-        const r5 = n5.join(".");
-        for (let o5 in t5) if (Object.prototype.hasOwnProperty.call(t5, o5)) if (void 0 === t5[o5]) this.isAttribute(o5) && (s7 += "");
-        else if (null === t5[o5]) this.isAttribute(o5) || o5 === this.options.cdataPropName ? s7 += "" : "?" === o5[0] ? s7 += this.indentate(e5) + "<" + o5 + "?" + this.tagEndChar : s7 += this.indentate(e5) + "<" + o5 + "/" + this.tagEndChar;
-        else if (t5[o5] instanceof Date) s7 += this.buildTextValNode(t5[o5], o5, "", e5);
-        else if ("object" != typeof t5[o5]) {
-          const n6 = this.isAttribute(o5);
-          if (n6 && !this.ignoreAttributesFn(n6, r5)) i5 += this.buildAttrPairStr(n6, "" + t5[o5]);
-          else if (!n6) if (o5 === this.options.textNodeName) {
-            let e6 = this.options.tagValueProcessor(o5, "" + t5[o5]);
+      Pt2.prototype.build = function(t5) {
+        if (this.options.preserveOrder) return gt2(t5, this.options);
+        {
+          Array.isArray(t5) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1 && (t5 = { [this.options.arrayNodeName]: t5 });
+          const e5 = new L3();
+          return this.j2x(t5, 0, e5).val;
+        }
+      }, Pt2.prototype.j2x = function(t5, e5, i5) {
+        let n5 = "", s7 = "";
+        if (this.options.maxNestedTags && i5.getDepth() >= this.options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
+        const r5 = this.options.jPath ? i5.toString() : i5, o5 = this.checkStopNode(i5);
+        for (let a5 in t5) if (Object.prototype.hasOwnProperty.call(t5, a5)) if (void 0 === t5[a5]) this.isAttribute(a5) && (s7 += "");
+        else if (null === t5[a5]) this.isAttribute(a5) || a5 === this.options.cdataPropName ? s7 += "" : "?" === a5[0] ? s7 += this.indentate(e5) + "<" + a5 + "?" + this.tagEndChar : s7 += this.indentate(e5) + "<" + a5 + "/" + this.tagEndChar;
+        else if (t5[a5] instanceof Date) s7 += this.buildTextValNode(t5[a5], a5, "", e5, i5);
+        else if ("object" != typeof t5[a5]) {
+          const h5 = this.isAttribute(a5);
+          if (h5 && !this.ignoreAttributesFn(h5, r5)) n5 += this.buildAttrPairStr(h5, "" + t5[a5], o5);
+          else if (!h5) if (a5 === this.options.textNodeName) {
+            let e6 = this.options.tagValueProcessor(a5, "" + t5[a5]);
             s7 += this.replaceEntitiesValue(e6);
-          } else s7 += this.buildTextValNode(t5[o5], o5, "", e5);
-        } else if (Array.isArray(t5[o5])) {
-          const i6 = t5[o5].length;
-          let r6 = "", a5 = "";
-          for (let l5 = 0; l5 < i6; l5++) {
-            const i7 = t5[o5][l5];
-            if (void 0 === i7) ;
-            else if (null === i7) "?" === o5[0] ? s7 += this.indentate(e5) + "<" + o5 + "?" + this.tagEndChar : s7 += this.indentate(e5) + "<" + o5 + "/" + this.tagEndChar;
-            else if ("object" == typeof i7) if (this.options.oneListGroup) {
-              const t6 = this.j2x(i7, e5 + 1, n5.concat(o5));
-              r6 += t6.val, this.options.attributesGroupName && i7.hasOwnProperty(this.options.attributesGroupName) && (a5 += t6.attrStr);
-            } else r6 += this.processTextOrObjNode(i7, o5, e5, n5);
+          } else {
+            i5.push(a5);
+            const n6 = this.checkStopNode(i5);
+            if (i5.pop(), n6) {
+              const i6 = "" + t5[a5];
+              s7 += "" === i6 ? this.indentate(e5) + "<" + a5 + this.closeTag(a5) + this.tagEndChar : this.indentate(e5) + "<" + a5 + ">" + i6 + "</" + a5 + this.tagEndChar;
+            } else s7 += this.buildTextValNode(t5[a5], a5, "", e5, i5);
+          }
+        } else if (Array.isArray(t5[a5])) {
+          const n6 = t5[a5].length;
+          let r6 = "", o6 = "";
+          for (let h5 = 0; h5 < n6; h5++) {
+            const n7 = t5[a5][h5];
+            if (void 0 === n7) ;
+            else if (null === n7) "?" === a5[0] ? s7 += this.indentate(e5) + "<" + a5 + "?" + this.tagEndChar : s7 += this.indentate(e5) + "<" + a5 + "/" + this.tagEndChar;
+            else if ("object" == typeof n7) if (this.options.oneListGroup) {
+              i5.push(a5);
+              const t6 = this.j2x(n7, e5 + 1, i5);
+              i5.pop(), r6 += t6.val, this.options.attributesGroupName && n7.hasOwnProperty(this.options.attributesGroupName) && (o6 += t6.attrStr);
+            } else r6 += this.processTextOrObjNode(n7, a5, e5, i5);
             else if (this.options.oneListGroup) {
-              let t6 = this.options.tagValueProcessor(o5, i7);
+              let t6 = this.options.tagValueProcessor(a5, n7);
               t6 = this.replaceEntitiesValue(t6), r6 += t6;
-            } else r6 += this.buildTextValNode(i7, o5, "", e5);
-          }
-          this.options.oneListGroup && (r6 = this.buildObjectNode(r6, o5, a5, e5)), s7 += r6;
-        } else if (this.options.attributesGroupName && o5 === this.options.attributesGroupName) {
-          const e6 = Object.keys(t5[o5]), n6 = e6.length;
-          for (let s8 = 0; s8 < n6; s8++) i5 += this.buildAttrPairStr(e6[s8], "" + t5[o5][e6[s8]]);
-        } else s7 += this.processTextOrObjNode(t5[o5], o5, e5, n5);
-        return { attrStr: i5, val: s7 };
-      }, pt2.prototype.buildAttrPairStr = function(t5, e5) {
-        return e5 = this.options.attributeValueProcessor(t5, "" + e5), e5 = this.replaceEntitiesValue(e5), this.options.suppressBooleanAttributes && "true" === e5 ? " " + t5 : " " + t5 + '="' + e5 + '"';
-      }, pt2.prototype.buildObjectNode = function(t5, e5, n5, i5) {
-        if ("" === t5) return "?" === e5[0] ? this.indentate(i5) + "<" + e5 + n5 + "?" + this.tagEndChar : this.indentate(i5) + "<" + e5 + n5 + this.closeTag(e5) + this.tagEndChar;
+            } else {
+              i5.push(a5);
+              const t6 = this.checkStopNode(i5);
+              if (i5.pop(), t6) {
+                const t7 = "" + n7;
+                r6 += "" === t7 ? this.indentate(e5) + "<" + a5 + this.closeTag(a5) + this.tagEndChar : this.indentate(e5) + "<" + a5 + ">" + t7 + "</" + a5 + this.tagEndChar;
+              } else r6 += this.buildTextValNode(n7, a5, "", e5, i5);
+            }
+          }
+          this.options.oneListGroup && (r6 = this.buildObjectNode(r6, a5, o6, e5)), s7 += r6;
+        } else if (this.options.attributesGroupName && a5 === this.options.attributesGroupName) {
+          const e6 = Object.keys(t5[a5]), i6 = e6.length;
+          for (let s8 = 0; s8 < i6; s8++) n5 += this.buildAttrPairStr(e6[s8], "" + t5[a5][e6[s8]], o5);
+        } else s7 += this.processTextOrObjNode(t5[a5], a5, e5, i5);
+        return { attrStr: n5, val: s7 };
+      }, Pt2.prototype.buildAttrPairStr = function(t5, e5, i5) {
+        return i5 || (e5 = this.options.attributeValueProcessor(t5, "" + e5), e5 = this.replaceEntitiesValue(e5)), this.options.suppressBooleanAttributes && "true" === e5 ? " " + t5 : " " + t5 + '="' + e5 + '"';
+      }, Pt2.prototype.extractAttributes = function(t5) {
+        if (!t5 || "object" != typeof t5) return null;
+        const e5 = {};
+        let i5 = false;
+        if (this.options.attributesGroupName && t5[this.options.attributesGroupName]) {
+          const n5 = t5[this.options.attributesGroupName];
+          for (let t6 in n5) Object.prototype.hasOwnProperty.call(n5, t6) && (e5[t6.startsWith(this.options.attributeNamePrefix) ? t6.substring(this.options.attributeNamePrefix.length) : t6] = n5[t6], i5 = true);
+        } else for (let n5 in t5) {
+          if (!Object.prototype.hasOwnProperty.call(t5, n5)) continue;
+          const s7 = this.isAttribute(n5);
+          s7 && (e5[s7] = t5[n5], i5 = true);
+        }
+        return i5 ? e5 : null;
+      }, Pt2.prototype.buildRawContent = function(t5) {
+        if ("string" == typeof t5) return t5;
+        if ("object" != typeof t5 || null === t5) return String(t5);
+        if (void 0 !== t5[this.options.textNodeName]) return t5[this.options.textNodeName];
+        let e5 = "";
+        for (let i5 in t5) {
+          if (!Object.prototype.hasOwnProperty.call(t5, i5)) continue;
+          if (this.isAttribute(i5)) continue;
+          if (this.options.attributesGroupName && i5 === this.options.attributesGroupName) continue;
+          const n5 = t5[i5];
+          if (i5 === this.options.textNodeName) e5 += n5;
+          else if (Array.isArray(n5)) {
+            for (let t6 of n5) if ("string" == typeof t6 || "number" == typeof t6) e5 += `<${i5}>${t6}</${i5}>`;
+            else if ("object" == typeof t6 && null !== t6) {
+              const n6 = this.buildRawContent(t6), s7 = this.buildAttributesForStopNode(t6);
+              e5 += "" === n6 ? `<${i5}${s7}/>` : `<${i5}${s7}>${n6}</${i5}>`;
+            }
+          } else if ("object" == typeof n5 && null !== n5) {
+            const t6 = this.buildRawContent(n5), s7 = this.buildAttributesForStopNode(n5);
+            e5 += "" === t6 ? `<${i5}${s7}/>` : `<${i5}${s7}>${t6}</${i5}>`;
+          } else e5 += `<${i5}>${n5}</${i5}>`;
+        }
+        return e5;
+      }, Pt2.prototype.buildAttributesForStopNode = function(t5) {
+        if (!t5 || "object" != typeof t5) return "";
+        let e5 = "";
+        if (this.options.attributesGroupName && t5[this.options.attributesGroupName]) {
+          const i5 = t5[this.options.attributesGroupName];
+          for (let t6 in i5) {
+            if (!Object.prototype.hasOwnProperty.call(i5, t6)) continue;
+            const n5 = t6.startsWith(this.options.attributeNamePrefix) ? t6.substring(this.options.attributeNamePrefix.length) : t6, s7 = i5[t6];
+            true === s7 && this.options.suppressBooleanAttributes ? e5 += " " + n5 : e5 += " " + n5 + '="' + s7 + '"';
+          }
+        } else for (let i5 in t5) {
+          if (!Object.prototype.hasOwnProperty.call(t5, i5)) continue;
+          const n5 = this.isAttribute(i5);
+          if (n5) {
+            const s7 = t5[i5];
+            true === s7 && this.options.suppressBooleanAttributes ? e5 += " " + n5 : e5 += " " + n5 + '="' + s7 + '"';
+          }
+        }
+        return e5;
+      }, Pt2.prototype.buildObjectNode = function(t5, e5, i5, n5) {
+        if ("" === t5) return "?" === e5[0] ? this.indentate(n5) + "<" + e5 + i5 + "?" + this.tagEndChar : this.indentate(n5) + "<" + e5 + i5 + this.closeTag(e5) + this.tagEndChar;
         {
           let s7 = "</" + e5 + this.tagEndChar, r5 = "";
-          return "?" === e5[0] && (r5 = "?", s7 = ""), !n5 && "" !== n5 || -1 !== t5.indexOf("<") ? false !== this.options.commentPropName && e5 === this.options.commentPropName && 0 === r5.length ? this.indentate(i5) + `<!--${t5}-->` + this.newLine : this.indentate(i5) + "<" + e5 + n5 + r5 + this.tagEndChar + t5 + this.indentate(i5) + s7 : this.indentate(i5) + "<" + e5 + n5 + r5 + ">" + t5 + s7;
+          return "?" === e5[0] && (r5 = "?", s7 = ""), !i5 && "" !== i5 || -1 !== t5.indexOf("<") ? false !== this.options.commentPropName && e5 === this.options.commentPropName && 0 === r5.length ? this.indentate(n5) + `<!--${t5}-->` + this.newLine : this.indentate(n5) + "<" + e5 + i5 + r5 + this.tagEndChar + t5 + this.indentate(n5) + s7 : this.indentate(n5) + "<" + e5 + i5 + r5 + ">" + t5 + s7;
         }
-      }, pt2.prototype.closeTag = function(t5) {
+      }, Pt2.prototype.closeTag = function(t5) {
         let e5 = "";
         return -1 !== this.options.unpairedTags.indexOf(t5) ? this.options.suppressUnpairedNode || (e5 = "/") : e5 = this.options.suppressEmptyNode ? "/" : `></${t5}`, e5;
-      }, pt2.prototype.buildTextValNode = function(t5, e5, n5, i5) {
-        if (false !== this.options.cdataPropName && e5 === this.options.cdataPropName) return this.indentate(i5) + `<![CDATA[${t5}]]>` + this.newLine;
-        if (false !== this.options.commentPropName && e5 === this.options.commentPropName) return this.indentate(i5) + `<!--${t5}-->` + this.newLine;
-        if ("?" === e5[0]) return this.indentate(i5) + "<" + e5 + n5 + "?" + this.tagEndChar;
+      }, Pt2.prototype.checkStopNode = function(t5) {
+        if (!this.stopNodeExpressions || 0 === this.stopNodeExpressions.length) return false;
+        for (let e5 = 0; e5 < this.stopNodeExpressions.length; e5++) if (t5.matches(this.stopNodeExpressions[e5])) return true;
+        return false;
+      }, Pt2.prototype.buildTextValNode = function(t5, e5, i5, n5, s7) {
+        if (false !== this.options.cdataPropName && e5 === this.options.cdataPropName) return this.indentate(n5) + `<![CDATA[${t5}]]>` + this.newLine;
+        if (false !== this.options.commentPropName && e5 === this.options.commentPropName) return this.indentate(n5) + `<!--${t5}-->` + this.newLine;
+        if ("?" === e5[0]) return this.indentate(n5) + "<" + e5 + i5 + "?" + this.tagEndChar;
         {
-          let s7 = this.options.tagValueProcessor(e5, t5);
-          return s7 = this.replaceEntitiesValue(s7), "" === s7 ? this.indentate(i5) + "<" + e5 + n5 + this.closeTag(e5) + this.tagEndChar : this.indentate(i5) + "<" + e5 + n5 + ">" + s7 + "</" + e5 + this.tagEndChar;
+          let s8 = this.options.tagValueProcessor(e5, t5);
+          return s8 = this.replaceEntitiesValue(s8), "" === s8 ? this.indentate(n5) + "<" + e5 + i5 + this.closeTag(e5) + this.tagEndChar : this.indentate(n5) + "<" + e5 + i5 + ">" + s8 + "</" + e5 + this.tagEndChar;
         }
-      }, pt2.prototype.replaceEntitiesValue = function(t5) {
+      }, Pt2.prototype.replaceEntitiesValue = function(t5) {
         if (t5 && t5.length > 0 && this.options.processEntities) for (let e5 = 0; e5 < this.options.entities.length; e5++) {
-          const n5 = this.options.entities[e5];
-          t5 = t5.replace(n5.regex, n5.val);
+          const i5 = this.options.entities[e5];
+          t5 = t5.replace(i5.regex, i5.val);
         }
         return t5;
       };
-      const xt2 = { validate: a4 };
+      const Ot2 = Pt2, $t2 = { validate: l4 };
       module2.exports = e4;
     })();
   }
@@ -157896,7 +159052,7 @@ var require_package6 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sentry/craft",
-      version: "2.24.2",
+      version: "2.25.0",
       description: "The universal sentry workflow CLI",
       main: "dist/craft",
       repository: "https://github.com/getsentry/craft",
@@ -157942,7 +159098,7 @@ var require_package6 = __commonJS({
         "eslint-config-prettier": "^9.1.0",
         "eslint-formatter-github-annotations": "^0.1.0",
         "extract-zip": "^2.0.1",
-        "fast-xml-parser": "^5.3.4",
+        "fast-xml-parser": "^5.5.7",
         "git-url-parse": "^16.1.0",
         glob: "^11.0.0",
         "is-ci": "^2.0.0",
@@ -157997,11 +159153,11 @@ var require_package6 = __commonJS({
       },
       pnpm: {
         overrides: {
-          "fast-xml-parser": "^5.3.4",
+          "fast-xml-parser": "^5.5.7",
           minimatch: "^10.2.1",
           "ajv@<6.14.0": "^6.14.0",
           rollup: "^4.59.0",
-          flatted: "^3.4.0"
+          flatted: "^3.4.2"
         }
       }
     };
@@ -158065,7 +159221,7 @@ function getPackage() {
 }
 function getPackageVersion() {
   const { version: version2 } = getPackage();
-  const buildInfo = "78da70b88de5cf6245d5d7e3263a9e8952667dec";
+  const buildInfo = "f4889d04564e47311038ecb6b910fef6b6cf1363";
   return buildInfo ? `${version2} (${buildInfo})` : version2;
 }
 function semVerToString(s6) {
@@ -161350,12 +162506,12 @@ function sync_default(start, callback) {
 }
 
 // node_modules/.pnpm/yargs@18.0.0/node_modules/yargs/lib/platform-shims/esm.mjs
-var import_util26 = require("util");
+var import_util27 = require("util");
 var import_url4 = require("url");
 
 // node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/index.js
 init_import_meta_url();
-var import_util24 = require("util");
+var import_util25 = require("util");
 var import_path24 = require("path");
 
 // node_modules/.pnpm/yargs-parser@22.0.0/node_modules/yargs-parser/build/lib/string-utils.js
@@ -162320,7 +163476,7 @@ var parser4 = new YargsParser({
   env: () => {
     return env;
   },
-  format: import_util24.format,
+  format: import_util25.format,
   normalize: import_path24.normalize,
   resolve: import_path24.resolve,
   require: (path19) => {
@@ -162371,14 +163527,14 @@ init_import_meta_url();
 // node_modules/.pnpm/y18n@5.0.8/node_modules/y18n/build/lib/platform-shims/node.js
 init_import_meta_url();
 var import_fs28 = require("fs");
-var import_util25 = require("util");
+var import_util26 = require("util");
 var import_path25 = require("path");
 var node_default = {
   fs: {
     readFileSync: import_fs28.readFileSync,
     writeFile: import_fs28.writeFile
   },
-  format: import_util25.format,
+  format: import_util26.format,
   resolve: import_path25.resolve,
   exists: (file) => {
     try {
@@ -162574,7 +163730,7 @@ var esm_default3 = {
   getEnv: (key) => {
     return process.env[key];
   },
-  inspect: import_util26.inspect,
+  inspect: import_util27.inspect,
   getProcessArgvBin,
   mainFilename: mainFilename || process.cwd(),
   Parser: lib_default,
@@ -166131,6 +167287,7 @@ __export(publish_exports, {
   builder: () => builder,
   command: () => command2,
   description: () => description,
+  handleReleaseBranch: () => handleReleaseBranch,
   handler: () => handler2,
   publishMain: () => publishMain,
   runPostReleaseCommand: () => runPostReleaseCommand
@@ -166153,6 +167310,7 @@ init_helpers();
 init_strings();
 init_system();
 init_version9();
+init_esm9();
 init_git();
 init_tracing3();
 var DEFAULT_POST_RELEASE_SCRIPT_PATH = (0, import_path27.join)("scripts", "post-release.sh");
@@ -166370,8 +167528,41 @@ async function handleReleaseBranch(git, remoteName, branch, mergeTarget, keepBra
   }
   logger.debug(`Checking out merge target branch:`, mergeTarget);
   await git.checkout(mergeTarget);
+  logger.debug(`Pulling latest changes from ${remoteName}/${mergeTarget}`);
+  try {
+    await git.pull(remoteName, mergeTarget, ["--rebase"]);
+  } catch (pullError) {
+    try {
+      await git.raw(["rebase", "--abort"]);
+    } catch (_abortError) {
+      logger.trace("git rebase --abort failed (may be no rebase in progress)");
+    }
+    throw pullError;
+  }
   logger.debug(`Merging ${branch} into: ${mergeTarget}`);
-  await git.pull(remoteName, mergeTarget, ["--rebase"]).merge(["--no-ff", "--no-edit", branch]).push(remoteName, mergeTarget);
+  try {
+    await git.merge(["--no-ff", "--no-edit", branch]);
+  } catch (mergeError) {
+    logger.warn(
+      `Merge with default strategy failed (${mergeError instanceof Error ? mergeError.message : mergeError}), retrying with "resolve" strategy...`
+    );
+    try {
+      await git.merge(["--abort"]);
+    } catch (_abortError) {
+      logger.trace("git merge --abort failed (may be no merge in progress)");
+    }
+    try {
+      await git.merge(["-s", "resolve", "--no-ff", "--no-edit", branch]);
+    } catch (resolveError) {
+      try {
+        await git.merge(["--abort"]);
+      } catch (_abortError) {
+        logger.trace("git merge --abort failed after resolve strategy");
+      }
+      throw resolveError;
+    }
+  }
+  await git.push(remoteName, mergeTarget);
   if (keepBranch) {
     logger.info("Not deleting the release branch.");
   } else {
@@ -166561,13 +167752,30 @@ Original error: ${err instanceof Error ? err.message : String(err)}`;
       "Not merging because cannot determine a branch name to merge from."
     );
   } else if (targetsToPublish.has("all" /* All */) || targetsToPublish.has("none" /* None */) || earlierStateExists) {
-    await handleReleaseBranch(
-      git,
-      argv.remote,
-      branchName,
-      argv.mergeTarget,
-      argv.keepBranch
-    );
+    try {
+      await handleReleaseBranch(
+        git,
+        argv.remote,
+        branchName,
+        argv.mergeTarget,
+        argv.keepBranch
+      );
+    } catch (mergeError) {
+      captureException(mergeError);
+      logger.warn(
+        [
+          `Failed to merge release branch "${branchName}" into the target branch.`,
+          `This is likely due to a merge conflict (e.g., in CHANGELOG.md).`,
+          `All publish targets completed successfully \u2014 only the post-publish merge failed.`,
+          ``,
+          `To resolve manually:`,
+          `  1. Merge the release branch into the target branch, resolving conflicts`,
+          `  2. Delete the release branch: git push ${argv.remote} --delete ${branchName}`,
+          ``,
+          `Error: ${mergeError instanceof Error ? mergeError.message : String(mergeError)}`
+        ].join("\n")
+      );
+    }
     safeFs.unlink(publishStateFile).catch(
       (err) => logger.trace("Couldn't remove publish state file: ", err)
     );