@deck.gl/geo-layers 9.3.0-beta.1 → 9.3.0

package/dist/dist.dev.js

@@ -8661,6 +8661,19 @@ var __exports__ = (() => {
   function isExist(v2) {
     return typeof v2 !== "undefined";
   }
+  var DANGEROUS_PROPERTY_NAMES = [
+    // '__proto__',
+    // 'constructor',
+    // 'prototype',
+    "hasOwnProperty",
+    "toString",
+    "valueOf",
+    "__defineGetter__",
+    "__defineSetter__",
+    "__lookupGetter__",
+    "__lookupSetter__"
+  ];
+  var criticalProperties = ["__proto__", "constructor", "prototype"];
 
   // ../../node_modules/fast-xml-parser/src/validator.js
   var defaultOptions = {
@@ -8902,7 +8915,7 @@ var __exports__ = (() => {
       if (!validateAttrName(attrName)) {
         return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches3[i]));
       }
-      if (!attrNames.hasOwnProperty(attrName)) {
+      if (!Object.prototype.hasOwnProperty.call(attrNames, attrName)) {
         attrNames[attrName] = 1;
       } else {
         return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches3[i]));
@@ -8971,6 +8984,12 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
+  var defaultOnDangerousProperty = (name12) => {
+    if (DANGEROUS_PROPERTY_NAMES.includes(name12)) {
+      return "__" + name12;
+    }
+    return name12;
+  };
   var defaultOptions2 = {
     preserveOrder: false,
     attributeNamePrefix: "@_",
@@ -9014,8 +9033,29 @@ var __exports__ = (() => {
       return tagName;
     },
     // skipEmptyListItem: false
-    captureMetaData: false
+    captureMetaData: false,
+    maxNestedTags: 100,
+    strictReservedNames: true,
+    jPath: true,
+    // if true, pass jPath string to callbacks; if false, pass matcher instance
+    onDangerousProperty: defaultOnDangerousProperty
   };
+  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 {
@@ -9025,6 +9065,7 @@ var __exports__ = (() => {
         maxExpansionDepth: 10,
         maxTotalExpansions: 1e3,
         maxExpandedLength: 1e5,
+        maxEntityCount: 100,
         allowedTags: null,
         tagFilter: null
       };
@@ -9032,11 +9073,11 @@ var __exports__ = (() => {
     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 ?? 1e4),
+        maxTotalExpansions: Math.max(1, value.maxTotalExpansions ?? Infinity),
+        maxExpandedLength: Math.max(1, value.maxExpandedLength ?? 1e5),
+        maxEntityCount: Math.max(1, value.maxEntityCount ?? 1e3),
         allowedTags: value.allowedTags ?? null,
         tagFilter: value.tagFilter ?? null
       };
@@ -9045,7 +9086,31 @@ var __exports__ = (() => {
   }
   var buildOptions = function(options) {
     const built = Object.assign({}, defaultOptions2, 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: name12 } of propertyNameOptions) {
+      if (value) {
+        validatePropertyName(value, name12);
+      }
+    }
+    if (built.onDangerousProperty === null) {
+      built.onDangerousProperty = defaultOnDangerousProperty;
+    }
     built.processEntities = normalizeProcessEntities(built.processEntities);
+    built.unpairedTagsSet = new Set(built.unpairedTags);
+    if (built.stopNodes && Array.isArray(built.stopNodes)) {
+      built.stopNodes = built.stopNodes.map((node) => {
+        if (typeof node === "string" && node.startsWith("*.")) {
+          return ".." + node.substring(2);
+        }
+        return node;
+      });
+    }
     return built;
   };
 
@@ -9060,7 +9125,7 @@ var __exports__ = (() => {
     constructor(tagname) {
       this.tagname = tagname;
       this.child = [];
-      this[":@"] = {};
+      this[":@"] = /* @__PURE__ */ Object.create(null);
     }
     add(key, val) {
       if (key === "__proto__")
@@ -9092,7 +9157,8 @@ var __exports__ = (() => {
       this.options = options;
     }
     readDocType(xmlData, i) {
-      const entities = {};
+      const entities = /* @__PURE__ */ Object.create(null);
+      let entityCount = 0;
       if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") {
         i = i + 9;
         let angleBracketsCount = 1;
@@ -9105,11 +9171,17 @@ var __exports__ = (() => {
               let entityName, val;
               [entityName, val, i] = this.readEntityExp(xmlData, i + 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", i)) {
               i += 8;
@@ -9155,11 +9227,11 @@ var __exports__ = (() => {
     }
     readEntityExp(xmlData, i) {
       i = skipWhitespace(xmlData, i);
-      let entityName = "";
+      const startIndex = i;
       while (i < xmlData.length && !/\s/.test(xmlData[i]) && xmlData[i] !== '"' && xmlData[i] !== "'") {
-        entityName += xmlData[i];
         i++;
       }
+      let entityName = xmlData.substring(startIndex, i);
       validateEntityName(entityName);
       i = skipWhitespace(xmlData, i);
       if (!this.suppressValidationErr) {
@@ -9171,7 +9243,7 @@ var __exports__ = (() => {
       }
       let entityValue = "";
       [i, entityValue] = this.readIdentifierVal(xmlData, i, "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})`
         );
@@ -9181,11 +9253,11 @@ var __exports__ = (() => {
     }
     readNotationExp(xmlData, i) {
       i = skipWhitespace(xmlData, i);
-      let notationName = "";
+      const startIndex = i;
       while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-        notationName += xmlData[i];
         i++;
       }
+      let notationName = xmlData.substring(startIndex, i);
       !this.suppressValidationErr && validateEntityName(notationName);
       i = skipWhitespace(xmlData, i);
       const identifierType = xmlData.substring(i, i + 6).toUpperCase();
@@ -9217,10 +9289,11 @@ var __exports__ = (() => {
         throw new Error(`Expected quoted string, found "${startChar}"`);
       }
       i++;
+      const startIndex = i;
       while (i < xmlData.length && xmlData[i] !== startChar) {
-        identifierVal += xmlData[i];
         i++;
       }
+      identifierVal = xmlData.substring(startIndex, i);
       if (xmlData[i] !== startChar) {
         throw new Error(`Unterminated ${type} value`);
       }
@@ -9229,11 +9302,11 @@ var __exports__ = (() => {
     }
     readElementExp(xmlData, i) {
       i = skipWhitespace(xmlData, i);
-      let elementName = "";
+      const startIndex = i;
       while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-        elementName += xmlData[i];
         i++;
       }
+      let elementName = xmlData.substring(startIndex, i);
       if (!this.suppressValidationErr && !isName(elementName)) {
         throw new Error(`Invalid element name: "${elementName}"`);
       }
@@ -9245,10 +9318,11 @@ var __exports__ = (() => {
         i += 2;
       else if (xmlData[i] === "(") {
         i++;
+        const startIndex2 = i;
         while (i < xmlData.length && xmlData[i] !== ")") {
-          contentModel += xmlData[i];
           i++;
         }
+        contentModel = xmlData.substring(startIndex2, i);
         if (xmlData[i] !== ")") {
           throw new Error("Unterminated content model");
         }
@@ -9263,18 +9337,18 @@ var __exports__ = (() => {
     }
     readAttlistExp(xmlData, i) {
       i = skipWhitespace(xmlData, i);
-      let elementName = "";
+      let startIndex = i;
       while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-        elementName += xmlData[i];
         i++;
       }
+      let elementName = xmlData.substring(startIndex, i);
       validateEntityName(elementName);
       i = skipWhitespace(xmlData, i);
-      let attributeName = "";
+      startIndex = i;
       while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-        attributeName += xmlData[i];
         i++;
       }
+      let attributeName = xmlData.substring(startIndex, i);
       if (!validateEntityName(attributeName)) {
         throw new Error(`Invalid attribute name: "${attributeName}"`);
       }
@@ -9290,11 +9364,11 @@ var __exports__ = (() => {
         i++;
         let allowedNotations = [];
         while (i < xmlData.length && xmlData[i] !== ")") {
-          let notation = "";
+          const startIndex2 = i;
           while (i < xmlData.length && xmlData[i] !== "|" && xmlData[i] !== ")") {
-            notation += xmlData[i];
             i++;
           }
+          let notation = xmlData.substring(startIndex2, i);
           notation = notation.trim();
           if (!validateEntityName(notation)) {
             throw new Error(`Invalid notation name: "${notation}"`);
@@ -9311,10 +9385,11 @@ var __exports__ = (() => {
         i++;
         attributeType += " (" + allowedNotations.join("|") + ")";
       } else {
+        const startIndex2 = i;
         while (i < xmlData.length && !/\s/.test(xmlData[i])) {
-          attributeType += xmlData[i];
           i++;
         }
+        attributeType += xmlData.substring(startIndex2, i);
         const validTypes = ["CDATA", "ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS"];
         if (!this.suppressValidationErr && !validTypes.includes(attributeType.toUpperCase())) {
           throw new Error(`Invalid attribute type: "${attributeType}"`);
@@ -9368,20 +9443,26 @@ var __exports__ = (() => {
     // oct: false,
     leadingZeros: true,
     decimalPoint: ".",
-    eNotation: true
-    //skipLike: /regex/
+    eNotation: true,
+    //skipLike: /regex/,
+    infinity: "original"
+    // "null", "infinity" (Infinity type), "string" ("Infinity" (the string literal))
   };
   function toNumber(str7, options = {}) {
     options = Object.assign({}, consider, options);
     if (!str7 || typeof str7 !== "string")
       return str7;
     let trimmedStr = str7.trim();
-    if (options.skipLike !== void 0 && options.skipLike.test(trimmedStr))
+    if (trimmedStr.length === 0)
       return str7;
-    else if (str7 === "0")
+    else if (options.skipLike !== void 0 && options.skipLike.test(trimmedStr))
+      return str7;
+    else if (trimmedStr === "0")
       return 0;
     else if (options.hex && hexRegex.test(trimmedStr)) {
       return parse_int(trimmedStr, 16);
+    } else if (!isFinite(trimmedStr)) {
+      return handleInfinity(str7, Number(trimmedStr), options);
     } else if (trimmedStr.includes("e") || trimmedStr.includes("E")) {
       return resolveEnotation(str7, trimmedStr, options);
     } else {
@@ -9445,11 +9526,15 @@ var __exports__ = (() => {
         return str7;
       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 str7;
+      } else {
         return Number(trimmedStr);
-      } else
-        return str7;
+      }
     } else {
       return str7;
     }
@@ -9477,6 +9562,20 @@ var __exports__ = (() => {
     else
       throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
   }
+  function handleInfinity(str7, num, options) {
+    const isPositive2 = num === Infinity;
+    switch (options.infinity.toLowerCase()) {
+      case "null":
+        return null;
+      case "infinity":
+        return num;
+      case "string":
+        return isPositive2 ? "Infinity" : "-Infinity";
+      case "original":
+      default:
+        return str7;
+    }
+  }
 
   // ../../node_modules/fast-xml-parser/src/ignoreAttributes.js
   function getIgnoreAttributesFn(ignoreAttributes) {
@@ -9498,7 +9597,776 @@ var __exports__ = (() => {
     return () => false;
   }
 
+  // ../../node_modules/path-expression-matcher/src/Expression.js
+  var 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 = {}, data) {
+      this.pattern = pattern;
+      this.separator = options.separator || ".";
+      this.segments = this._parse(pattern);
+      this.data = data;
+      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 i = 0;
+      let currentPart = "";
+      while (i < pattern.length) {
+        if (pattern[i] === this.separator) {
+          if (i + 1 < pattern.length && pattern[i + 1] === this.separator) {
+            if (currentPart.trim()) {
+              segments.push(this._parseSegment(currentPart.trim()));
+              currentPart = "";
+            }
+            segments.push({ type: "deep-wildcard" });
+            i += 2;
+          } else {
+            if (currentPart.trim()) {
+              segments.push(this._parseSegment(currentPart.trim()));
+            }
+            currentPart = "";
+            i++;
+          }
+        } else {
+          currentPart += pattern[i];
+          i++;
+        }
+      }
+      if (currentPart.trim()) {
+        segments.push(this._parseSegment(currentPart.trim()));
+      }
+      return segments;
+    }
+    /**
+     * 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 tag = 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) {
+          tag = tagPart;
+          positionMatch = posPart;
+        } else {
+          tag = tagAndPosition;
+        }
+      } else {
+        tag = tagAndPosition;
+      }
+      if (!tag) {
+        throw new Error(`Invalid segment pattern: ${part}`);
+      }
+      segment.tag = tag;
+      if (namespace) {
+        segment.namespace = namespace;
+      }
+      if (bracketContent) {
+        if (bracketContent.includes("=")) {
+          const eqIndex = bracketContent.indexOf("=");
+          segment.attrName = bracketContent.substring(0, eqIndex).trim();
+          segment.attrValue = bracketContent.substring(eqIndex + 1).trim();
+        } else {
+          segment.attrName = bracketContent.trim();
+        }
+      }
+      if (positionMatch) {
+        const nthMatch = positionMatch.match(/^nth\((\d+)\)$/);
+        if (nthMatch) {
+          segment.position = "nth";
+          segment.positionValue = parseInt(nthMatch[1], 10);
+        } else {
+          segment.position = positionMatch;
+        }
+      }
+      return segment;
+    }
+    /**
+     * Get 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/path-expression-matcher/src/ExpressionSet.js
+  var ExpressionSet = class {
+    constructor() {
+      this._byDepthAndTag = /* @__PURE__ */ new Map();
+      this._wildcardByDepth = /* @__PURE__ */ new Map();
+      this._deepWildcards = [];
+      this._patterns = /* @__PURE__ */ new Set();
+      this._sealed = false;
+    }
+    /**
+     * Add an Expression to the set.
+     * Duplicate patterns (same pattern string) are silently ignored.
+     *
+     * @param {import('./Expression.js').default} expression - A pre-constructed Expression instance
+     * @returns {this} for chaining
+     * @throws {TypeError} if called after seal()
+     *
+     * @example
+     * set.add(new Expression('root.users.user'));
+     * set.add(new Expression('..script'));
+     */
+    add(expression) {
+      if (this._sealed) {
+        throw new TypeError(
+          "ExpressionSet is sealed. Create a new ExpressionSet to add more expressions."
+        );
+      }
+      if (this._patterns.has(expression.pattern))
+        return this;
+      this._patterns.add(expression.pattern);
+      if (expression.hasDeepWildcard()) {
+        this._deepWildcards.push(expression);
+        return this;
+      }
+      const depth = expression.length;
+      const lastSeg = expression.segments[expression.segments.length - 1];
+      const tag = lastSeg?.tag;
+      if (!tag || tag === "*") {
+        if (!this._wildcardByDepth.has(depth))
+          this._wildcardByDepth.set(depth, []);
+        this._wildcardByDepth.get(depth).push(expression);
+      } else {
+        const key = `${depth}:${tag}`;
+        if (!this._byDepthAndTag.has(key))
+          this._byDepthAndTag.set(key, []);
+        this._byDepthAndTag.get(key).push(expression);
+      }
+      return this;
+    }
+    /**
+     * Add multiple expressions at once.
+     *
+     * @param {import('./Expression.js').default[]} expressions - Array of Expression instances
+     * @returns {this} for chaining
+     *
+     * @example
+     * set.addAll([
+     *   new Expression('root.users.user'),
+     *   new Expression('root.config.setting'),
+     * ]);
+     */
+    addAll(expressions) {
+      for (const expr of expressions)
+        this.add(expr);
+      return this;
+    }
+    /**
+     * Check whether a pattern string is already present in the set.
+     *
+     * @param {import('./Expression.js').default} expression
+     * @returns {boolean}
+     */
+    has(expression) {
+      return this._patterns.has(expression.pattern);
+    }
+    /**
+     * Number of expressions in the set.
+     * @type {number}
+     */
+    get size() {
+      return this._patterns.size;
+    }
+    /**
+     * Seal the set against further modifications.
+     * Useful to prevent accidental mutations after config is built.
+     * Calling add() or addAll() on a sealed set throws a TypeError.
+     *
+     * @returns {this}
+     */
+    seal() {
+      this._sealed = true;
+      return this;
+    }
+    /**
+     * Whether the set has been sealed.
+     * @type {boolean}
+     */
+    get isSealed() {
+      return this._sealed;
+    }
+    /**
+     * Test whether the matcher's current path matches any expression in the set.
+     *
+     * Evaluation order (cheapest → most expensive):
+     *  1. Exact depth + tag bucket  — O(1) lookup, typically 0–2 expressions
+     *  2. Depth-only wildcard bucket — O(1) lookup, rare
+     *  3. Deep-wildcard list         — always checked, but usually small
+     *
+     * @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)
+     * @returns {boolean} true if any expression matches the current path
+     *
+     * @example
+     * if (stopNodes.matchesAny(matcher)) {
+     *   // handle stop node
+     * }
+     */
+    matchesAny(matcher) {
+      return this.findMatch(matcher) !== null;
+    }
+    /**
+    * Find and return the first Expression that matches the matcher's current path.
+    *
+    * Uses the same evaluation order as matchesAny (cheapest → most expensive):
+    *  1. Exact depth + tag bucket
+    *  2. Depth-only wildcard bucket
+    *  3. Deep-wildcard list
+    *
+    * @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)
+    * @returns {import('./Expression.js').default | null} the first matching Expression, or null
+    *
+    * @example
+    * const expr = stopNodes.findMatch(matcher);
+    * if (expr) {
+    *   // access expr.config, expr.pattern, etc.
+    * }
+    */
+    findMatch(matcher) {
+      const depth = matcher.getDepth();
+      const tag = matcher.getCurrentTag();
+      const exactKey = `${depth}:${tag}`;
+      const exactBucket = this._byDepthAndTag.get(exactKey);
+      if (exactBucket) {
+        for (let i = 0; i < exactBucket.length; i++) {
+          if (matcher.matches(exactBucket[i]))
+            return exactBucket[i];
+        }
+      }
+      const wildcardBucket = this._wildcardByDepth.get(depth);
+      if (wildcardBucket) {
+        for (let i = 0; i < wildcardBucket.length; i++) {
+          if (matcher.matches(wildcardBucket[i]))
+            return wildcardBucket[i];
+        }
+      }
+      for (let i = 0; i < this._deepWildcards.length; i++) {
+        if (matcher.matches(this._deepWildcards[i]))
+          return this._deepWildcards[i];
+      }
+      return null;
+    }
+  };
+
+  // ../../node_modules/path-expression-matcher/src/Matcher.js
+  var MUTATING_METHODS = /* @__PURE__ */ new Set(["push", "pop", "reset", "updateCurrent", "restore"]);
+  var 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 = [];
+      this._pathStringCache = null;
+      this._frozenPathCache = null;
+      this._frozenSiblingsCache = null;
+    }
+    /**
+     * 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) {
+      this._pathStringCache = null;
+      this._frozenPathCache = null;
+      this._frozenSiblingsCache = 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 node = {
+        tag: tagName,
+        position,
+        counter
+      };
+      if (namespace !== null && namespace !== void 0) {
+        node.namespace = namespace;
+      }
+      if (attrValues !== null && attrValues !== void 0) {
+        node.values = attrValues;
+      }
+      this.path.push(node);
+    }
+    /**
+     * Pop the last tag from the path
+     * @returns {Object|undefined} The popped node
+     */
+    pop() {
+      if (this.path.length === 0)
+        return void 0;
+      this._pathStringCache = null;
+      this._frozenPathCache = null;
+      this._frozenSiblingsCache = null;
+      const node = this.path.pop();
+      if (this.siblingStacks.length > this.path.length + 1) {
+        this.siblingStacks.length = this.path.length + 1;
+      }
+      return node;
+    }
+    /**
+     * 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;
+          this._frozenPathCache = null;
+        }
+      }
+    }
+    /**
+     * 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 sep = separator || this.separator;
+      const isDefault = sep === this.separator && includeNamespace === true;
+      if (isDefault) {
+        if (this._pathStringCache !== null && this._pathStringCache !== void 0) {
+          return this._pathStringCache;
+        }
+        const result = this.path.map(
+          (n) => includeNamespace && n.namespace ? `${n.namespace}:${n.tag}` : n.tag
+        ).join(sep);
+        this._pathStringCache = result;
+        return result;
+      }
+      return this.path.map(
+        (n) => includeNamespace && n.namespace ? `${n.namespace}:${n.tag}` : n.tag
+      ).join(sep);
+    }
+    /**
+     * Get path as array of tag names
+     * @returns {string[]}
+     */
+    toArray() {
+      return this.path.map((n) => n.tag);
+    }
+    /**
+     * Reset the path to empty
+     */
+    reset() {
+      this._pathStringCache = null;
+      this._frozenPathCache = null;
+      this._frozenSiblingsCache = null;
+      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 i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const node = this.path[i];
+        const isCurrentNode = i === this.path.length - 1;
+        if (!this._matchSegment(segment, node, isCurrentNode)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    /**
+     * 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 i = pathIdx; i >= 0; i--) {
+            const isCurrentNode = i === this.path.length - 1;
+            if (this._matchSegment(nextSeg, this.path[i], isCurrentNode)) {
+              pathIdx = i - 1;
+              segIdx--;
+              found = true;
+              break;
+            }
+          }
+          if (!found) {
+            return false;
+          }
+        } else {
+          const isCurrentNode = pathIdx === this.path.length - 1;
+          if (!this._matchSegment(segment, this.path[pathIdx], isCurrentNode)) {
+            return false;
+          }
+          pathIdx--;
+          segIdx--;
+        }
+      }
+      return segIdx < 0;
+    }
+    /**
+     * 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, node, isCurrentNode) {
+      if (segment.tag !== "*" && segment.tag !== node.tag) {
+        return false;
+      }
+      if (segment.namespace !== void 0) {
+        if (segment.namespace !== "*" && segment.namespace !== node.namespace) {
+          return false;
+        }
+      }
+      if (segment.attrName !== void 0) {
+        if (!isCurrentNode) {
+          return false;
+        }
+        if (!node.values || !(segment.attrName in node.values)) {
+          return false;
+        }
+        if (segment.attrValue !== void 0) {
+          const actualValue = node.values[segment.attrName];
+          if (String(actualValue) !== String(segment.attrValue)) {
+            return false;
+          }
+        }
+      }
+      if (segment.position !== void 0) {
+        if (!isCurrentNode) {
+          return false;
+        }
+        const counter = node.counter ?? 0;
+        if (segment.position === "first" && counter !== 0) {
+          return false;
+        } else if (segment.position === "odd" && counter % 2 !== 1) {
+          return false;
+        } else if (segment.position === "even" && counter % 2 !== 0) {
+          return false;
+        } else if (segment.position === "nth") {
+          if (counter !== segment.positionValue) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+    /**
+    * Match any expression in the given set against the current path.
+    * @param {ExpressionSet} exprSet - The set of expressions to match against.
+    * @returns {boolean} - True if any expression in the set matches the current path, false otherwise.
+    */
+    matchesAny(exprSet) {
+      return exprSet.matchesAny(this);
+    }
+    /**
+     * Create a snapshot of current state
+     * @returns {Object} State snapshot
+     */
+    snapshot() {
+      return {
+        path: this.path.map((node) => ({ ...node })),
+        siblingStacks: this.siblingStacks.map((map2) => new Map(map2))
+      };
+    }
+    /**
+     * Restore state from snapshot
+     * @param {Object} snapshot - State snapshot
+     */
+    restore(snapshot) {
+      this._pathStringCache = null;
+      this._frozenPathCache = null;
+      this._frozenSiblingsCache = null;
+      this.path = snapshot.path.map((node) => ({ ...node }));
+      this.siblingStacks = snapshot.siblingStacks.map((map2) => new Map(map2));
+    }
+    /**
+     * Return a read-only view of this matcher.
+     *
+     * The returned object exposes all query/inspection methods but throws a
+     * TypeError if any state-mutating method is called (`push`, `pop`, `reset`,
+     * `updateCurrent`, `restore`).  Property reads (e.g. `.path`, `.separator`)
+     * are allowed but the returned arrays/objects are frozen so callers cannot
+     * mutate internal state through them either.
+     *
+     * @returns {ReadOnlyMatcher} A proxy that forwards read operations and blocks writes.
+     *
+     * @example
+     * const matcher = new Matcher();
+     * matcher.push("root", {});
+     *
+     * const ro = matcher.readOnly();
+     * ro.matches(expr);      // ✓ works
+     * ro.getCurrentTag();    // ✓ works
+     * ro.push("child", {}); // ✗ throws TypeError
+     * ro.reset();            // ✗ throws TypeError
+     */
+    readOnly() {
+      const self2 = this;
+      return new Proxy(self2, {
+        get(target, prop, receiver) {
+          if (MUTATING_METHODS.has(prop)) {
+            return () => {
+              throw new TypeError(
+                `Cannot call '${prop}' on a read-only Matcher. Obtain a writable instance to mutate state.`
+              );
+            };
+          }
+          if (prop === "path") {
+            if (target._frozenPathCache === null) {
+              target._frozenPathCache = Object.freeze(
+                target.path.map((node) => Object.freeze({ ...node }))
+              );
+            }
+            return target._frozenPathCache;
+          }
+          if (prop === "siblingStacks") {
+            if (target._frozenSiblingsCache === null) {
+              target._frozenSiblingsCache = Object.freeze(
+                target.siblingStacks.map((map2) => Object.freeze(new Map(map2)))
+              );
+            }
+            return target._frozenSiblingsCache;
+          }
+          const value = Reflect.get(target, prop, receiver);
+          if (typeof value === "function") {
+            return value.bind(target);
+          }
+          return value;
+        },
+        // Prevent any property assignment on the read-only view
+        set(_target, prop) {
+          throw new TypeError(
+            `Cannot set property '${String(prop)}' on a read-only Matcher.`
+          );
+        },
+        // Prevent property deletion
+        deleteProperty(_target, prop) {
+          throw new TypeError(
+            `Cannot delete property '${String(prop)}' from a read-only Matcher.`
+          );
+        }
+      });
+    }
+  };
+
   // ../../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 ns = rawTagName.substring(0, colonIndex);
+      if (ns !== "xmlns") {
+        return ns;
+      }
+    }
+    return void 0;
+  }
   var OrderedObjParser = class {
     constructor(options) {
       this.options = options;
@@ -9542,19 +10410,21 @@ var __exports__ = (() => {
       this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
       this.entityExpansionCount = 0;
       this.currentExpandedLength = 0;
-      if (this.options.stopNodes && this.options.stopNodes.length > 0) {
-        this.stopNodesExact = /* @__PURE__ */ new Set();
-        this.stopNodesWildcard = /* @__PURE__ */ new Set();
-        for (let i = 0; i < this.options.stopNodes.length; i++) {
-          const stopNodeExp = this.options.stopNodes[i];
-          if (typeof stopNodeExp !== "string")
-            continue;
-          if (stopNodeExp.startsWith("*.")) {
-            this.stopNodesWildcard.add(stopNodeExp.substring(2));
-          } else {
-            this.stopNodesExact.add(stopNodeExp);
+      this.matcher = new Matcher();
+      this.readonlyMatcher = this.matcher.readOnly();
+      this.isCurrentNodeStopNode = false;
+      this.stopNodeExpressionsSet = new ExpressionSet();
+      const stopNodesOpts = this.options.stopNodes;
+      if (stopNodesOpts && stopNodesOpts.length > 0) {
+        for (let i = 0; i < stopNodesOpts.length; i++) {
+          const stopNodeExp = stopNodesOpts[i];
+          if (typeof stopNodeExp === "string") {
+            this.stopNodeExpressionsSet.add(new Expression(stopNodeExp));
+          } else if (stopNodeExp instanceof Expression) {
+            this.stopNodeExpressionsSet.add(stopNodeExp);
           }
         }
+        this.stopNodeExpressionsSet.seal();
       }
     }
   };
@@ -9570,24 +10440,26 @@ var __exports__ = (() => {
     }
   }
   function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
+    const options = this.options;
     if (val !== void 0) {
-      if (this.options.trimValues && !dontTrim) {
+      if (options.trimValues && !dontTrim) {
         val = val.trim();
       }
       if (val.length > 0) {
         if (!escapeEntities)
           val = this.replaceEntitiesValue(val, tagName, jPath);
-        const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
+        const jPathOrMatcher = options.jPath ? jPath.toString() : jPath;
+        const newval = options.tagValueProcessor(tagName, val, jPathOrMatcher, hasAttributes, isLeafNode);
         if (newval === null || newval === void 0) {
           return val;
         } else if (typeof newval !== typeof val || newval !== val) {
           return newval;
-        } else if (this.options.trimValues) {
-          return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+        } else if (options.trimValues) {
+          return parseValue(val, options.parseTagValue, options.numberParseOptions);
         } else {
           const trimmedVal = val.trim();
           if (trimmedVal === val) {
-            return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+            return parseValue(val, options.parseTagValue, options.numberParseOptions);
           } else {
             return val;
           }
@@ -9610,51 +10482,64 @@ var __exports__ = (() => {
   }
   var attrsRegx = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
   function buildAttributesMap(attrStr, jPath, tagName) {
-    if (this.options.ignoreAttributes !== true && typeof attrStr === "string") {
+    const options = this.options;
+    if (options.ignoreAttributes !== true && typeof attrStr === "string") {
       const matches3 = getAllMatches(attrStr, attrsRegx);
       const len5 = matches3.length;
       const attrs = {};
+      const processedVals = new Array(len5);
+      let hasRawAttrs = false;
+      const rawAttrsForMatcher = {};
+      for (let i = 0; i < len5; i++) {
+        const attrName = this.resolveNameSpace(matches3[i][1]);
+        const oldVal = matches3[i][4];
+        if (attrName.length && oldVal !== void 0) {
+          let val = oldVal;
+          if (options.trimValues)
+            val = val.trim();
+          val = this.replaceEntitiesValue(val, tagName, this.readonlyMatcher);
+          processedVals[i] = val;
+          rawAttrsForMatcher[attrName] = val;
+          hasRawAttrs = true;
+        }
+      }
+      if (hasRawAttrs && typeof jPath === "object" && jPath.updateCurrent) {
+        jPath.updateCurrent(rawAttrsForMatcher);
+      }
+      const jPathStr = options.jPath ? jPath.toString() : this.readonlyMatcher;
+      let hasAttrs = false;
       for (let i = 0; i < len5; i++) {
         const attrName = this.resolveNameSpace(matches3[i][1]);
-        if (this.ignoreAttributesFn(attrName, jPath)) {
+        if (this.ignoreAttributesFn(attrName, jPathStr))
           continue;
-        }
-        let oldVal = matches3[i][4];
-        let aName = this.options.attributeNamePrefix + attrName;
+        let aName = options.attributeNamePrefix + attrName;
         if (attrName.length) {
-          if (this.options.transformAttributeName) {
-            aName = this.options.transformAttributeName(aName);
+          if (options.transformAttributeName) {
+            aName = options.transformAttributeName(aName);
           }
-          if (aName === "__proto__")
-            aName = "#__proto__";
-          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);
+          aName = sanitizeName(aName, options);
+          if (matches3[i][4] !== void 0) {
+            const oldVal = processedVals[i];
+            const newVal = options.attributeValueProcessor(attrName, oldVal, jPathStr);
             if (newVal === null || newVal === void 0) {
               attrs[aName] = oldVal;
             } else if (typeof newVal !== typeof oldVal || newVal !== oldVal) {
               attrs[aName] = newVal;
             } else {
-              attrs[aName] = parseValue(
-                oldVal,
-                this.options.parseAttributeValue,
-                this.options.numberParseOptions
-              );
+              attrs[aName] = parseValue(oldVal, options.parseAttributeValue, options.numberParseOptions);
             }
-          } else if (this.options.allowBooleanAttributes) {
+            hasAttrs = true;
+          } else if (options.allowBooleanAttributes) {
             attrs[aName] = true;
+            hasAttrs = true;
           }
         }
       }
-      if (!Object.keys(attrs).length) {
+      if (!hasAttrs)
         return;
-      }
-      if (this.options.attributesGroupName) {
+      if (options.attributesGroupName) {
         const attrCollection = {};
-        attrCollection[this.options.attributesGroupName] = attrs;
+        attrCollection[options.attributesGroupName] = attrs;
         return attrCollection;
       }
       return attrs;
@@ -9665,123 +10550,144 @@ var __exports__ = (() => {
     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);
-    for (let i = 0; i < xmlData.length; i++) {
+    this.docTypeEntitiesKeys = [];
+    this.lastEntitiesKeys = Object.keys(this.lastEntities);
+    this.htmlEntitiesKeys = this.options.htmlEntities ? Object.keys(this.htmlEntities) : [];
+    const options = this.options;
+    const docTypeReader = new DocTypeReader(options.processEntities);
+    const xmlLen = xmlData.length;
+    for (let i = 0; i < xmlLen; i++) {
       const ch = xmlData[i];
       if (ch === "<") {
-        if (xmlData[i + 1] === "/") {
+        const c1 = xmlData.charCodeAt(i + 1);
+        if (c1 === 47) {
           const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
           let tagName = xmlData.substring(i + 2, closeIndex).trim();
-          if (this.options.removeNSPrefix) {
+          if (options.removeNSPrefix) {
             const colonIndex = tagName.indexOf(":");
             if (colonIndex !== -1) {
               tagName = tagName.substr(colonIndex + 1);
             }
           }
-          if (this.options.transformTagName) {
-            tagName = this.options.transformTagName(tagName);
-          }
+          tagName = transformTagName(options.transformTagName, tagName, "", options).tagName;
           if (currentNode) {
-            textData = this.saveTextToParentTag(textData, currentNode, jPath);
+            textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
           }
-          const lastTagName = jPath.substring(jPath.lastIndexOf(".") + 1);
-          if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) {
+          const lastTagName = this.matcher.getCurrentTag();
+          if (tagName && options.unpairedTagsSet.has(tagName)) {
             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);
+          if (lastTagName && options.unpairedTagsSet.has(lastTagName)) {
+            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 = "";
           i = closeIndex;
-        } else if (xmlData[i + 1] === "?") {
+        } else if (c1 === 63) {
           let tagData = readTagExp(xmlData, i, false, "?>");
           if (!tagData)
             throw new Error("Pi Tag is not closed.");
-          textData = this.saveTextToParentTag(textData, currentNode, jPath);
-          if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) {
+          textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
+          if (options.ignoreDeclaration && tagData.tagName === "?xml" || options.ignorePiTags) {
           } else {
             const childNode = new XmlNode(tagData.tagName);
-            childNode.add(this.options.textNodeName, "");
+            childNode.add(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, i);
+            this.addChild(currentNode, childNode, this.readonlyMatcher, i);
           }
           i = tagData.closeIndex + 1;
-        } else if (xmlData.substr(i + 1, 3) === "!--") {
+        } else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 45 && xmlData.charCodeAt(i + 3) === 45) {
           const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
-          if (this.options.commentPropName) {
+          if (options.commentPropName) {
             const comment = xmlData.substring(i + 4, endIndex - 2);
-            textData = this.saveTextToParentTag(textData, currentNode, jPath);
-            currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
+            textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);
+            currentNode.add(options.commentPropName, [{ [options.textNodeName]: comment }]);
           }
           i = endIndex;
-        } else if (xmlData.substr(i + 1, 2) === "!D") {
+        } else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 68) {
           const result = docTypeReader.readDocType(xmlData, i);
           this.docTypeEntities = result.entities;
+          this.docTypeEntitiesKeys = Object.keys(this.docTypeEntities) || [];
           i = result.i;
-        } else if (xmlData.substr(i + 1, 2) === "![") {
+        } else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 91) {
           const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
           const tagExp = xmlData.substring(i + 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.readonlyMatcher);
+          let val = this.parseTextData(tagExp, currentNode.tagname, this.readonlyMatcher, true, false, true, true);
           if (val == void 0)
             val = "";
-          if (this.options.cdataPropName) {
-            currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);
+          if (options.cdataPropName) {
+            currentNode.add(options.cdataPropName, [{ [options.textNodeName]: tagExp }]);
           } else {
-            currentNode.add(this.options.textNodeName, val);
+            currentNode.add(options.textNodeName, val);
           }
           i = closeIndex + 2;
         } else {
-          let result = readTagExp(xmlData, i, this.options.removeNSPrefix);
+          let result = readTagExp(xmlData, i, options.removeNSPrefix);
+          if (!result) {
+            const context = xmlData.substring(Math.max(0, i - 50), Math.min(xmlLen, i + 50));
+            throw new Error(`readTagExp returned undefined at position ${i}. Context: "${context}"`);
+          }
           let tagName = result.tagName;
           const rawTagName = result.rawTagName;
           let tagExp = result.tagExp;
           let attrExpPresent = result.attrExpPresent;
           let closeIndex = result.closeIndex;
-          if (this.options.transformTagName) {
-            const newTagName = this.options.transformTagName(tagName);
-            if (tagExp === tagName) {
-              tagExp = newTagName;
-            }
-            tagName = newTagName;
+          ({ tagName, tagExp } = transformTagName(options.transformTagName, tagName, tagExp, options));
+          if (options.strictReservedNames && (tagName === options.commentPropName || tagName === options.cdataPropName || tagName === options.textNodeName || tagName === 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.readonlyMatcher, false);
             }
           }
           const lastTag = currentNode;
-          if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
+          if (lastTag && options.unpairedTagsSet.has(lastTag.tagname)) {
             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) {
-            jPath += jPath ? "." + tagName : tagName;
+            this.matcher.push(tagName, {}, namespace);
+          }
+          if (tagName !== tagExp && attrExpPresent) {
+            prefixedAttrs = this.buildAttributesMap(tagExp, this.matcher, tagName);
+            if (prefixedAttrs) {
+              rawAttrs = extractRawAttributes(prefixedAttrs, options);
+            }
+          }
+          if (tagName !== xmlObj.tagname) {
+            this.isCurrentNodeStopNode = this.isItStopNode();
           }
           const startIndex = i;
-          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) {
               i = result.closeIndex;
-            } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
+            } else if (options.unpairedTagsSet.has(tagName)) {
               i = result.closeIndex;
             } else {
               const result2 = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
@@ -9791,44 +10697,43 @@ var __exports__ = (() => {
               tagContent = result2.tagContent;
             }
             const childNode = new XmlNode(tagName);
-            if (tagName !== tagExp && attrExpPresent) {
-              childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
+            if (prefixedAttrs) {
+              childNode[":@"] = prefixedAttrs;
             }
-            if (tagContent) {
-              tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);
-            }
-            jPath = jPath.substr(0, jPath.lastIndexOf("."));
-            childNode.add(this.options.textNodeName, tagContent);
-            this.addChild(currentNode, childNode, jPath, startIndex);
+            childNode.add(options.textNodeName, tagContent);
+            this.matcher.pop();
+            this.isCurrentNodeStopNode = false;
+            this.addChild(currentNode, childNode, this.readonlyMatcher, 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(options.transformTagName, tagName, tagExp, options));
+              const childNode = new XmlNode(tagName);
+              if (prefixedAttrs) {
+                childNode[":@"] = prefixedAttrs;
               }
+              this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);
+              this.matcher.pop();
+              this.isCurrentNodeStopNode = false;
+            } else if (options.unpairedTagsSet.has(tagName)) {
               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.readonlyMatcher, startIndex);
+              this.matcher.pop();
+              this.isCurrentNodeStopNode = false;
+              i = result.closeIndex;
+              continue;
             } else {
               const childNode = new XmlNode(tagName);
+              if (this.tagsNodeStack.length > 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.readonlyMatcher, startIndex);
               currentNode = childNode;
             }
             textData = "";
@@ -9841,10 +10746,11 @@ var __exports__ = (() => {
     }
     return xmlObj.child;
   };
-  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;
@@ -9853,25 +10759,25 @@ var __exports__ = (() => {
       currentNode.addChild(childNode, startIndex);
     }
   }
-  var replaceEntitiesValue = function(val, tagName, jPath) {
-    if (val.indexOf("&") === -1) {
-      return val;
-    }
+  function replaceEntitiesValue(val, tagName, jPath) {
     const entityConfig = this.options.processEntities;
-    if (!entityConfig.enabled) {
+    if (!entityConfig || !entityConfig.enabled) {
       return val;
     }
     if (entityConfig.allowedTags) {
-      if (!entityConfig.allowedTags.includes(tagName)) {
+      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) {
-      if (!entityConfig.tagFilter(tagName, jPath)) {
+      const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;
+      if (!entityConfig.tagFilter(tagName, jPathOrMatcher)) {
         return val;
       }
     }
-    for (let entityName in this.docTypeEntities) {
+    for (const entityName of this.docTypeEntitiesKeys) {
       const entity = this.docTypeEntities[entityName];
       const matches3 = val.match(entity.regx);
       if (matches3) {
@@ -9895,74 +10801,86 @@ var __exports__ = (() => {
     }
     if (val.indexOf("&") === -1)
       return val;
-    for (let entityName in this.lastEntities) {
+    for (const entityName of this.lastEntitiesKeys) {
       const entity = this.lastEntities[entityName];
+      const matches3 = val.match(entity.regex);
+      if (matches3) {
+        this.entityExpansionCount += matches3.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 (let entityName in this.htmlEntities) {
-        const entity = this.htmlEntities[entityName];
-        val = val.replace(entity.regex, entity.val);
+    for (const entityName of this.htmlEntitiesKeys) {
+      const entity = this.htmlEntities[entityName];
+      const matches3 = val.match(entity.regex);
+      if (matches3) {
+        this.entityExpansionCount += matches3.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, currentNode, jPath, isLeafNode) {
+  }
+  function saveTextToParentTag(textData, parentNode, matcher, isLeafNode) {
     if (textData) {
       if (isLeafNode === void 0)
-        isLeafNode = currentNode.child.length === 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;
-    return false;
+  function isItStopNode() {
+    if (this.stopNodeExpressionsSet.size === 0)
+      return false;
+    return this.matcher.matchesAny(this.stopNodeExpressionsSet);
   }
   function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
-    let attrBoundary;
-    let tagExp = "";
-    for (let index = i; index < xmlData.length; index++) {
-      let ch = xmlData[index];
+    let attrBoundary = 0;
+    const chars = [];
+    const len5 = xmlData.length;
+    const closeCode0 = closingChar.charCodeAt(0);
+    const closeCode1 = closingChar.length > 1 ? closingChar.charCodeAt(1) : -1;
+    for (let index = i; index < len5; index++) {
+      const code = xmlData.charCodeAt(index);
       if (attrBoundary) {
-        if (ch === attrBoundary)
-          attrBoundary = "";
-      } else if (ch === '"' || ch === "'") {
-        attrBoundary = ch;
-      } else if (ch === closingChar[0]) {
-        if (closingChar[1]) {
-          if (xmlData[index + 1] === closingChar[1]) {
-            return {
-              data: tagExp,
-              index
-            };
+        if (code === attrBoundary)
+          attrBoundary = 0;
+      } else if (code === 34 || code === 39) {
+        attrBoundary = code;
+      } else if (code === closeCode0) {
+        if (closeCode1 !== -1) {
+          if (xmlData.charCodeAt(index + 1) === closeCode1) {
+            return { data: String.fromCharCode(...chars), index };
           }
         } else {
-          return {
-            data: tagExp,
-            index
-          };
+          return { data: String.fromCharCode(...chars), index };
         }
-      } else if (ch === "	") {
-        ch = " ";
+      } else if (code === 9) {
+        chars.push(32);
+        continue;
       }
-      tagExp += ch;
+      chars.push(code);
     }
   }
   function findClosingIndex(xmlData, str7, i, errMsg) {
@@ -9973,6 +10891,12 @@ var __exports__ = (() => {
       return closingIndex + str7.length - 1;
     }
   }
+  function findClosingChar(xmlData, char, i, errMsg) {
+    const closingIndex = xmlData.indexOf(char, i);
+    if (closingIndex === -1)
+      throw new Error(errMsg);
+    return closingIndex;
+  }
   function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
     const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
     if (!result)
@@ -10005,10 +10929,12 @@ var __exports__ = (() => {
   function readStopNodeData(xmlData, tagName, i) {
     const startIndex = i;
     let openTagCount = 1;
-    for (; i < xmlData.length; i++) {
+    const xmllen = xmlData.length;
+    for (; i < xmllen; i++) {
       if (xmlData[i] === "<") {
-        if (xmlData[i + 1] === "/") {
-          const closeIndex = findClosingIndex(xmlData, ">", i, `${tagName} is not closed`);
+        const c1 = xmlData.charCodeAt(i + 1);
+        if (c1 === 47) {
+          const closeIndex = findClosingChar(xmlData, ">", i, `${tagName} is not closed`);
           let closeTagName = xmlData.substring(i + 2, closeIndex).trim();
           if (closeTagName === tagName) {
             openTagCount--;
@@ -10020,13 +10946,13 @@ var __exports__ = (() => {
             }
           }
           i = closeIndex;
-        } else if (xmlData[i + 1] === "?") {
+        } else if (c1 === 63) {
           const closeIndex = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed.");
           i = closeIndex;
-        } else if (xmlData.substr(i + 1, 3) === "!--") {
+        } else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 45 && xmlData.charCodeAt(i + 3) === 45) {
           const closeIndex = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed.");
           i = closeIndex;
-        } else if (xmlData.substr(i + 1, 2) === "![") {
+        } else if (c1 === 33 && xmlData.charCodeAt(i + 2) === 91) {
           const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
           i = closeIndex;
         } else {
@@ -10067,23 +10993,60 @@ var __exports__ = (() => {
       return prefix + str7 + ";";
     }
   }
+  function transformTagName(fn, tagName, tagExp, options) {
+    if (fn) {
+      const newTagName = fn(tagName);
+      if (tagExp === tagName) {
+        tagExp = newTagName;
+      }
+      tagName = newTagName;
+    }
+    tagName = sanitizeName(tagName, options);
+    return { tagName, tagExp };
+  }
+  function sanitizeName(name12, options) {
+    if (criticalProperties.includes(name12)) {
+      throw new Error(`[SECURITY] Invalid name: "${name12}" is a reserved JavaScript keyword that could cause prototype pollution`);
+    } else if (DANGEROUS_PROPERTY_NAMES.includes(name12)) {
+      return options.onDangerousProperty(name12);
+    }
+    return name12;
+  }
 
   // ../../node_modules/fast-xml-parser/src/xmlparser/node2json.js
   var METADATA_SYMBOL2 = XmlNode.getMetaDataSymbol();
-  function prettify(node, options) {
-    return compress(node, options);
+  function stripAttributePrefix(attrs, prefix) {
+    if (!attrs || typeof attrs !== "object")
+      return {};
+    if (!prefix)
+      return attrs;
+    const rawAttrs = {};
+    for (const key in attrs) {
+      if (key.startsWith(prefix)) {
+        const rawName = key.substring(prefix.length);
+        rawAttrs[rawName] = attrs[key];
+      } else {
+        rawAttrs[key] = attrs[key];
+      }
+    }
+    return rawAttrs;
+  }
+  function prettify(node, options, matcher, readonlyMatcher) {
+    return compress(node, options, matcher, readonlyMatcher);
   }
-  function compress(arr, options, jPath) {
+  function compress(arr, options, matcher, readonlyMatcher) {
     let text;
     const compressedObj = {};
     for (let i = 0; i < arr.length; i++) {
       const tagObj = arr[i];
       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];
@@ -10092,13 +11055,10 @@ var __exports__ = (() => {
       } else if (property === void 0) {
         continue;
       } else if (tagObj[property]) {
-        let val = compress(tagObj[property], options, newJpath);
+        let val = compress(tagObj[property], options, matcher, readonlyMatcher);
         const isLeaf = isLeafTag(val, options);
-        if (tagObj[METADATA_SYMBOL2] !== void 0) {
-          val[METADATA_SYMBOL2] = tagObj[METADATA_SYMBOL2];
-        }
         if (tagObj[":@"]) {
-          assignAttributes(val, tagObj[":@"], newJpath, options);
+          assignAttributes(val, tagObj[":@"], readonlyMatcher, 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) {
@@ -10107,18 +11067,25 @@ var __exports__ = (() => {
           else
             val = "";
         }
-        if (compressedObj[property] !== void 0 && compressedObj.hasOwnProperty(property)) {
+        if (tagObj[METADATA_SYMBOL2] !== void 0 && typeof val === "object" && val !== null) {
+          val[METADATA_SYMBOL2] = tagObj[METADATA_SYMBOL2];
+        }
+        if (compressedObj[property] !== void 0 && Object.prototype.hasOwnProperty.call(compressedObj, property)) {
           if (!Array.isArray(compressedObj[property])) {
             compressedObj[property] = [compressedObj[property]];
           }
           compressedObj[property].push(val);
         } else {
-          if (options.isArray(property, newJpath, isLeaf)) {
+          const jPathOrMatcher = options.jPath ? readonlyMatcher.toString() : readonlyMatcher;
+          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") {
@@ -10136,13 +11103,15 @@ var __exports__ = (() => {
         return key;
     }
   }
-  function assignAttributes(obj, attrMap, jpath, options) {
+  function assignAttributes(obj, attrMap, readonlyMatcher, options) {
     if (attrMap) {
       const keys = Object.keys(attrMap);
       const len5 = keys.length;
       for (let i = 0; i < len5; i++) {
         const atrrName = keys[i];
-        if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) {
+        const rawAttrName = atrrName.startsWith(options.attributeNamePrefix) ? atrrName.substring(options.attributeNamePrefix.length) : atrrName;
+        const jPathOrMatcher = options.jPath ? readonlyMatcher.toString() + "." + rawAttrName : readonlyMatcher;
+        if (options.isArray(atrrName, jPathOrMatcher, true, true)) {
           obj[atrrName] = [attrMap[atrrName]];
         } else {
           obj[atrrName] = attrMap[atrrName];
@@ -10193,7 +11162,7 @@ var __exports__ = (() => {
       if (this.options.preserveOrder || orderedResult === void 0)
         return orderedResult;
       else
-        return prettify(orderedResult, this.options);
+        return prettify(orderedResult, this.options, orderedObjParser.matcher, orderedObjParser.readonlyMatcher);
     }
     /**
      * Add Entity which is not by default supported by this library