@jjrawlins/cdk-diff-pr-github-action 1.9.14 → 1.9.16

package/node_modules/path-expression-matcher/lib/pem.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"./lib/pem.min.js","mappings":"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","sources":["webpack://pem/webpack/universalModuleDefinition","webpack://pem/webpack/bootstrap","webpack://pem/webpack/runtime/define property getters","webpack://pem/webpack/runtime/hasOwnProperty shorthand","webpack://pem/webpack/runtime/make namespace object","webpack://pem/./src/Expression.js","webpack://pem/./src/Matcher.js","webpack://pem/./src/index.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"pem\"] = factory();\n\telse\n\t\troot[\"pem\"] = factory();\n})(this, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/**\n * Expression - Parses and stores a tag pattern expression\n * \n * Patterns are parsed once and stored in an optimized structure for fast matching.\n * \n * @example\n * const expr = new Expression(\"root.users.user\");\n * const expr2 = new Expression(\"..user[id]:first\");\n * const expr3 = new Expression(\"root/users/user\", { separator: '/' });\n */\nexport default class Expression {\n  /**\n   * Create a new Expression\n   * @param {string} pattern - Pattern string (e.g., \"root.users.user\", \"..user[id]\")\n   * @param {Object} options - Configuration options\n   * @param {string} options.separator - Path separator (default: '.')\n   */\n  constructor(pattern, options = {}) {\n    this.pattern = pattern;\n    this.separator = options.separator || '.';\n    this.segments = this._parse(pattern);\n\n    // Cache expensive checks for performance (O(1) instead of O(n))\n    this._hasDeepWildcard = this.segments.some(seg => seg.type === 'deep-wildcard');\n    this._hasAttributeCondition = this.segments.some(seg => seg.attrName !== undefined);\n    this._hasPositionSelector = this.segments.some(seg => seg.position !== undefined);\n  }\n\n  /**\n   * Parse pattern string into segments\n   * @private\n   * @param {string} pattern - Pattern to parse\n   * @returns {Array} Array of segment objects\n   */\n  _parse(pattern) {\n    const segments = [];\n\n    // Split by separator but handle \"..\" specially\n    let i = 0;\n    let currentPart = '';\n\n    while (i < pattern.length) {\n      if (pattern[i] === this.separator) {\n        // Check if next char is also separator (deep wildcard)\n        if (i + 1 < pattern.length && pattern[i + 1] === this.separator) {\n          // Flush current part if any\n          if (currentPart.trim()) {\n            segments.push(this._parseSegment(currentPart.trim()));\n            currentPart = '';\n          }\n          // Add deep wildcard\n          segments.push({ type: 'deep-wildcard' });\n          i += 2; // Skip both separators\n        } else {\n          // Regular separator\n          if (currentPart.trim()) {\n            segments.push(this._parseSegment(currentPart.trim()));\n          }\n          currentPart = '';\n          i++;\n        }\n      } else {\n        currentPart += pattern[i];\n        i++;\n      }\n    }\n\n    // Flush remaining part\n    if (currentPart.trim()) {\n      segments.push(this._parseSegment(currentPart.trim()));\n    }\n\n    return segments;\n  }\n\n  /**\n   * Parse a single segment\n   * @private\n   * @param {string} part - Segment string (e.g., \"user\", \"ns::user\", \"user[id]\", \"ns::user:first\")\n   * @returns {Object} Segment object\n   */\n  _parseSegment(part) {\n    const segment = { type: 'tag' };\n\n    // NEW NAMESPACE SYNTAX (v2.0):\n    // ============================\n    // Namespace uses DOUBLE colon (::)\n    // Position uses SINGLE colon (:)\n    // \n    // Examples:\n    //   \"user\"              → tag\n    //   \"user:first\"        → tag + position\n    //   \"user[id]\"          → tag + attribute\n    //   \"user[id]:first\"    → tag + attribute + position\n    //   \"ns::user\"          → namespace + tag\n    //   \"ns::user:first\"    → namespace + tag + position\n    //   \"ns::user[id]\"      → namespace + tag + attribute\n    //   \"ns::user[id]:first\" → namespace + tag + attribute + position\n    //   \"ns::first\"         → namespace + tag named \"first\" (NO ambiguity!)\n    //\n    // This eliminates all ambiguity:\n    //   :: = namespace separator\n    //   :  = position selector\n    //   [] = attributes\n\n    // Step 1: Extract brackets [attr] or [attr=value]\n    let bracketContent = null;\n    let withoutBrackets = part;\n\n    const bracketMatch = part.match(/^([^\\[]+)(\\[[^\\]]*\\])(.*)$/);\n    if (bracketMatch) {\n      withoutBrackets = bracketMatch[1] + bracketMatch[3];\n      if (bracketMatch[2]) {\n        const content = bracketMatch[2].slice(1, -1);\n        if (content) {\n          bracketContent = content;\n        }\n      }\n    }\n\n    // Step 2: Check for namespace (double colon ::)\n    let namespace = undefined;\n    let tagAndPosition = withoutBrackets;\n\n    if (withoutBrackets.includes('::')) {\n      const nsIndex = withoutBrackets.indexOf('::');\n      namespace = withoutBrackets.substring(0, nsIndex).trim();\n      tagAndPosition = withoutBrackets.substring(nsIndex + 2).trim(); // Skip ::\n\n      if (!namespace) {\n        throw new Error(`Invalid namespace in pattern: ${part}`);\n      }\n    }\n\n    // Step 3: Parse tag and position (single colon :)\n    let tag = undefined;\n    let positionMatch = null;\n\n    if (tagAndPosition.includes(':')) {\n      const colonIndex = tagAndPosition.lastIndexOf(':'); // Use last colon for position\n      const tagPart = tagAndPosition.substring(0, colonIndex).trim();\n      const posPart = tagAndPosition.substring(colonIndex + 1).trim();\n\n      // Verify position is a valid keyword\n      const isPositionKeyword = ['first', 'last', 'odd', 'even'].includes(posPart) ||\n        /^nth\\(\\d+\\)$/.test(posPart);\n\n      if (isPositionKeyword) {\n        tag = tagPart;\n        positionMatch = posPart;\n      } else {\n        // Not a valid position keyword, treat whole thing as tag\n        tag = tagAndPosition;\n      }\n    } else {\n      tag = tagAndPosition;\n    }\n\n    if (!tag) {\n      throw new Error(`Invalid segment pattern: ${part}`);\n    }\n\n    segment.tag = tag;\n    if (namespace) {\n      segment.namespace = namespace;\n    }\n\n    // Step 4: Parse attributes\n    if (bracketContent) {\n      if (bracketContent.includes('=')) {\n        const eqIndex = bracketContent.indexOf('=');\n        segment.attrName = bracketContent.substring(0, eqIndex).trim();\n        segment.attrValue = bracketContent.substring(eqIndex + 1).trim();\n      } else {\n        segment.attrName = bracketContent.trim();\n      }\n    }\n\n    // Step 5: Parse position selector\n    if (positionMatch) {\n      const nthMatch = positionMatch.match(/^nth\\((\\d+)\\)$/);\n      if (nthMatch) {\n        segment.position = 'nth';\n        segment.positionValue = parseInt(nthMatch[1], 10);\n      } else {\n        segment.position = positionMatch;\n      }\n    }\n\n    return segment;\n  }\n\n  /**\n   * Get the number of segments\n   * @returns {number}\n   */\n  get length() {\n    return this.segments.length;\n  }\n\n  /**\n   * Check if expression contains deep wildcard\n   * @returns {boolean}\n   */\n  hasDeepWildcard() {\n    return this._hasDeepWildcard;\n  }\n\n  /**\n   * Check if expression has attribute conditions\n   * @returns {boolean}\n   */\n  hasAttributeCondition() {\n    return this._hasAttributeCondition;\n  }\n\n  /**\n   * Check if expression has position selectors\n   * @returns {boolean}\n   */\n  hasPositionSelector() {\n    return this._hasPositionSelector;\n  }\n\n  /**\n   * Get string representation\n   * @returns {string}\n   */\n  toString() {\n    return this.pattern;\n  }\n}","/**\n * Matcher - Tracks current path in XML/JSON tree and matches against Expressions\n * \n * The matcher maintains a stack of nodes representing the current path from root to\n * current tag. It only stores attribute values for the current (top) node to minimize\n * memory usage. Sibling tracking is used to auto-calculate position and counter.\n * \n * @example\n * const matcher = new Matcher();\n * matcher.push(\"root\", {});\n * matcher.push(\"users\", {});\n * matcher.push(\"user\", { id: \"123\", type: \"admin\" });\n * \n * const expr = new Expression(\"root.users.user\");\n * matcher.matches(expr); // true\n */\nexport default class Matcher {\n  /**\n   * Create a new Matcher\n   * @param {Object} options - Configuration options\n   * @param {string} options.separator - Default path separator (default: '.')\n   */\n  constructor(options = {}) {\n    this.separator = options.separator || '.';\n    this.path = [];\n    this.siblingStacks = [];\n    // Each path node: { tag: string, values: object, position: number, counter: number }\n    // values only present for current (last) node\n    // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level\n  }\n\n  /**\n   * Push a new tag onto the path\n   * @param {string} tagName - Name of the tag\n   * @param {Object} attrValues - Attribute key-value pairs for current node (optional)\n   * @param {string} namespace - Namespace for the tag (optional)\n   */\n  push(tagName, attrValues = null, namespace = null) {\n    // Remove values from previous current node (now becoming ancestor)\n    if (this.path.length > 0) {\n      const prev = this.path[this.path.length - 1];\n      prev.values = undefined;\n    }\n\n    // Get or create sibling tracking for current level\n    const currentLevel = this.path.length;\n    if (!this.siblingStacks[currentLevel]) {\n      this.siblingStacks[currentLevel] = new Map();\n    }\n\n    const siblings = this.siblingStacks[currentLevel];\n\n    // Create a unique key for sibling tracking that includes namespace\n    const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;\n\n    // Calculate counter (how many times this tag appeared at this level)\n    const counter = siblings.get(siblingKey) || 0;\n\n    // Calculate position (total children at this level so far)\n    let position = 0;\n    for (const count of siblings.values()) {\n      position += count;\n    }\n\n    // Update sibling count for this tag\n    siblings.set(siblingKey, counter + 1);\n\n    // Create new node\n    const node = {\n      tag: tagName,\n      position: position,\n      counter: counter\n    };\n\n    // Store namespace if provided\n    if (namespace !== null && namespace !== undefined) {\n      node.namespace = namespace;\n    }\n\n    // Store values only for current node\n    if (attrValues !== null && attrValues !== undefined) {\n      node.values = attrValues;\n    }\n\n    this.path.push(node);\n  }\n\n  /**\n   * Pop the last tag from the path\n   * @returns {Object|undefined} The popped node\n   */\n  pop() {\n    if (this.path.length === 0) {\n      return undefined;\n    }\n\n    const node = this.path.pop();\n\n    // Clean up sibling tracking for levels deeper than current\n    // After pop, path.length is the new depth\n    // We need to clean up siblingStacks[path.length + 1] and beyond\n    if (this.siblingStacks.length > this.path.length + 1) {\n      this.siblingStacks.length = this.path.length + 1;\n    }\n\n    return node;\n  }\n\n  /**\n   * Update current node's attribute values\n   * Useful when attributes are parsed after push\n   * @param {Object} attrValues - Attribute values\n   */\n  updateCurrent(attrValues) {\n    if (this.path.length > 0) {\n      const current = this.path[this.path.length - 1];\n      if (attrValues !== null && attrValues !== undefined) {\n        current.values = attrValues;\n      }\n    }\n  }\n\n  /**\n   * Get current tag name\n   * @returns {string|undefined}\n   */\n  getCurrentTag() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].tag : undefined;\n  }\n\n  /**\n   * Get current namespace\n   * @returns {string|undefined}\n   */\n  getCurrentNamespace() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].namespace : undefined;\n  }\n\n  /**\n   * Get current node's attribute value\n   * @param {string} attrName - Attribute name\n   * @returns {*} Attribute value or undefined\n   */\n  getAttrValue(attrName) {\n    if (this.path.length === 0) return undefined;\n    const current = this.path[this.path.length - 1];\n    return current.values?.[attrName];\n  }\n\n  /**\n   * Check if current node has an attribute\n   * @param {string} attrName - Attribute name\n   * @returns {boolean}\n   */\n  hasAttr(attrName) {\n    if (this.path.length === 0) return false;\n    const current = this.path[this.path.length - 1];\n    return current.values !== undefined && attrName in current.values;\n  }\n\n  /**\n   * Get current node's sibling position (child index in parent)\n   * @returns {number}\n   */\n  getPosition() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].position ?? 0;\n  }\n\n  /**\n   * Get current node's repeat counter (occurrence count of this tag name)\n   * @returns {number}\n   */\n  getCounter() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].counter ?? 0;\n  }\n\n  /**\n   * Get current node's sibling index (alias for getPosition for backward compatibility)\n   * @returns {number}\n   * @deprecated Use getPosition() or getCounter() instead\n   */\n  getIndex() {\n    return this.getPosition();\n  }\n\n  /**\n   * Get current path depth\n   * @returns {number}\n   */\n  getDepth() {\n    return this.path.length;\n  }\n\n  /**\n   * Get path as string\n   * @param {string} separator - Optional separator (uses default if not provided)\n   * @param {boolean} includeNamespace - Whether to include namespace in output (default: true)\n   * @returns {string}\n   */\n  toString(separator, includeNamespace = true) {\n    const sep = separator || this.separator;\n    return this.path.map(n => {\n      if (includeNamespace && n.namespace) {\n        return `${n.namespace}:${n.tag}`;\n      }\n      return n.tag;\n    }).join(sep);\n  }\n\n  /**\n   * Get path as array of tag names\n   * @returns {string[]}\n   */\n  toArray() {\n    return this.path.map(n => n.tag);\n  }\n\n  /**\n   * Reset the path to empty\n   */\n  reset() {\n    this.path = [];\n    this.siblingStacks = [];\n  }\n\n  /**\n   * Match current path against an Expression\n   * @param {Expression} expression - The expression to match against\n   * @returns {boolean} True if current path matches the expression\n   */\n  matches(expression) {\n    const segments = expression.segments;\n\n    if (segments.length === 0) {\n      return false;\n    }\n\n    // Handle deep wildcard patterns\n    if (expression.hasDeepWildcard()) {\n      return this._matchWithDeepWildcard(segments);\n    }\n\n    // Simple path matching (no deep wildcards)\n    return this._matchSimple(segments);\n  }\n\n  /**\n   * Match simple path (no deep wildcards)\n   * @private\n   */\n  _matchSimple(segments) {\n    // Path must be same length as segments\n    if (this.path.length !== segments.length) {\n      return false;\n    }\n\n    // Match each segment bottom-to-top\n    for (let i = 0; i < segments.length; i++) {\n      const segment = segments[i];\n      const node = this.path[i];\n      const isCurrentNode = (i === this.path.length - 1);\n\n      if (!this._matchSegment(segment, node, isCurrentNode)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Match path with deep wildcards\n   * @private\n   */\n  _matchWithDeepWildcard(segments) {\n    let pathIdx = this.path.length - 1;  // Start from current node (bottom)\n    let segIdx = segments.length - 1;     // Start from last segment\n\n    while (segIdx >= 0 && pathIdx >= 0) {\n      const segment = segments[segIdx];\n\n      if (segment.type === 'deep-wildcard') {\n        // \"..\" matches zero or more levels\n        segIdx--;\n\n        if (segIdx < 0) {\n          // Pattern ends with \"..\", always matches\n          return true;\n        }\n\n        // Find where next segment matches in the path\n        const nextSeg = segments[segIdx];\n        let found = false;\n\n        for (let i = pathIdx; i >= 0; i--) {\n          const isCurrentNode = (i === this.path.length - 1);\n          if (this._matchSegment(nextSeg, this.path[i], isCurrentNode)) {\n            pathIdx = i - 1;\n            segIdx--;\n            found = true;\n            break;\n          }\n        }\n\n        if (!found) {\n          return false;\n        }\n      } else {\n        // Regular segment\n        const isCurrentNode = (pathIdx === this.path.length - 1);\n        if (!this._matchSegment(segment, this.path[pathIdx], isCurrentNode)) {\n          return false;\n        }\n        pathIdx--;\n        segIdx--;\n      }\n    }\n\n    // All segments must be consumed\n    return segIdx < 0;\n  }\n\n  /**\n   * Match a single segment against a node\n   * @private\n   * @param {Object} segment - Segment from Expression\n   * @param {Object} node - Node from path\n   * @param {boolean} isCurrentNode - Whether this is the current (last) node\n   * @returns {boolean}\n   */\n  _matchSegment(segment, node, isCurrentNode) {\n    // Match tag name (* is wildcard)\n    if (segment.tag !== '*' && segment.tag !== node.tag) {\n      return false;\n    }\n\n    // Match namespace if specified in segment\n    if (segment.namespace !== undefined) {\n      // Segment has namespace - node must match it\n      if (segment.namespace !== '*' && segment.namespace !== node.namespace) {\n        return false;\n      }\n    }\n    // If segment has no namespace, it matches nodes with or without namespace\n\n    // Match attribute name (check if node has this attribute)\n    // Can only check for current node since ancestors don't have values\n    if (segment.attrName !== undefined) {\n      if (!isCurrentNode) {\n        // Can't check attributes for ancestor nodes (values not stored)\n        return false;\n      }\n\n      if (!node.values || !(segment.attrName in node.values)) {\n        return false;\n      }\n\n      // Match attribute value (only possible for current node)\n      if (segment.attrValue !== undefined) {\n        const actualValue = node.values[segment.attrName];\n        // Both should be strings\n        if (String(actualValue) !== String(segment.attrValue)) {\n          return false;\n        }\n      }\n    }\n\n    // Match position (only for current node)\n    if (segment.position !== undefined) {\n      if (!isCurrentNode) {\n        // Can't check position for ancestor nodes\n        return false;\n      }\n\n      const counter = node.counter ?? 0;\n\n      if (segment.position === 'first' && counter !== 0) {\n        return false;\n      } else if (segment.position === 'odd' && counter % 2 !== 1) {\n        return false;\n      } else if (segment.position === 'even' && counter % 2 !== 0) {\n        return false;\n      } else if (segment.position === 'nth') {\n        if (counter !== segment.positionValue) {\n          return false;\n        }\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Create a snapshot of current state\n   * @returns {Object} State snapshot\n   */\n  snapshot() {\n    return {\n      path: this.path.map(node => ({ ...node })),\n      siblingStacks: this.siblingStacks.map(map => new Map(map))\n    };\n  }\n\n  /**\n   * Restore state from snapshot\n   * @param {Object} snapshot - State snapshot\n   */\n  restore(snapshot) {\n    this.path = snapshot.path.map(node => ({ ...node }));\n    this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));\n  }\n}","/**\n * fast-xml-tagger - XML/JSON path matching library\n * \n * Provides efficient path tracking and pattern matching for XML/JSON parsers.\n * \n * @example\n * import { Expression, Matcher } from 'fast-xml-tagger';\n * \n * // Create expression (parse once)\n * const expr = new Expression(\"root.users.user[id]\");\n * \n * // Create matcher (track path)\n * const matcher = new Matcher();\n * matcher.push(\"root\", [], {}, 0);\n * matcher.push(\"users\", [], {}, 0);\n * matcher.push(\"user\", [\"id\", \"type\"], { id: \"123\", type: \"admin\" }, 0);\n * \n * // Match\n * if (matcher.matches(expr)) {\n *   console.log(\"Match found!\");\n * }\n */\n\nimport Expression from './Expression.js';\nimport Matcher from './Matcher.js';\n\nexport { Expression, Matcher };\nexport default { Expression, Matcher };\n"],"names":["root","factory","exports","module","define","amd","this","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","value","Expression","constructor","pattern","options","separator","segments","_parse","_hasDeepWildcard","some","seg","type","_hasAttributeCondition","undefined","attrName","_hasPositionSelector","position","i","currentPart","length","trim","push","_parseSegment","part","segment","bracketContent","withoutBrackets","bracketMatch","match","content","slice","namespace","tag","tagAndPosition","includes","nsIndex","indexOf","substring","Error","positionMatch","colonIndex","lastIndexOf","tagPart","posPart","test","eqIndex","attrValue","nthMatch","positionValue","parseInt","hasDeepWildcard","hasAttributeCondition","hasPositionSelector","toString","Matcher","path","siblingStacks","tagName","attrValues","values","currentLevel","Map","siblings","siblingKey","counter","count","set","node","pop","updateCurrent","current","getCurrentTag","getCurrentNamespace","getAttrValue","hasAttr","getPosition","getCounter","getIndex","getDepth","includeNamespace","sep","map","n","join","toArray","reset","matches","expression","_matchWithDeepWildcard","_matchSimple","isCurrentNode","_matchSegment","pathIdx","segIdx","nextSeg","found","actualValue","String","snapshot","restore"],"sourceRoot":""}
+{"version":3,"file":"./lib/pem.min.js","mappings":"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","sources":["webpack://pem/webpack/universalModuleDefinition","webpack://pem/webpack/bootstrap","webpack://pem/webpack/runtime/define property getters","webpack://pem/webpack/runtime/hasOwnProperty shorthand","webpack://pem/webpack/runtime/make namespace object","webpack://pem/./src/Expression.js","webpack://pem/./src/Matcher.js","webpack://pem/./src/index.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"pem\"] = factory();\n\telse\n\t\troot[\"pem\"] = factory();\n})(this, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/**\n * Expression - Parses and stores a tag pattern expression\n * \n * Patterns are parsed once and stored in an optimized structure for fast matching.\n * \n * @example\n * const expr = new Expression(\"root.users.user\");\n * const expr2 = new Expression(\"..user[id]:first\");\n * const expr3 = new Expression(\"root/users/user\", { separator: '/' });\n */\nexport default class Expression {\n  /**\n   * Create a new Expression\n   * @param {string} pattern - Pattern string (e.g., \"root.users.user\", \"..user[id]\")\n   * @param {Object} options - Configuration options\n   * @param {string} options.separator - Path separator (default: '.')\n   */\n  constructor(pattern, options = {}) {\n    this.pattern = pattern;\n    this.separator = options.separator || '.';\n    this.segments = this._parse(pattern);\n\n    // Cache expensive checks for performance (O(1) instead of O(n))\n    this._hasDeepWildcard = this.segments.some(seg => seg.type === 'deep-wildcard');\n    this._hasAttributeCondition = this.segments.some(seg => seg.attrName !== undefined);\n    this._hasPositionSelector = this.segments.some(seg => seg.position !== undefined);\n  }\n\n  /**\n   * Parse pattern string into segments\n   * @private\n   * @param {string} pattern - Pattern to parse\n   * @returns {Array} Array of segment objects\n   */\n  _parse(pattern) {\n    const segments = [];\n\n    // Split by separator but handle \"..\" specially\n    let i = 0;\n    let currentPart = '';\n\n    while (i < pattern.length) {\n      if (pattern[i] === this.separator) {\n        // Check if next char is also separator (deep wildcard)\n        if (i + 1 < pattern.length && pattern[i + 1] === this.separator) {\n          // Flush current part if any\n          if (currentPart.trim()) {\n            segments.push(this._parseSegment(currentPart.trim()));\n            currentPart = '';\n          }\n          // Add deep wildcard\n          segments.push({ type: 'deep-wildcard' });\n          i += 2; // Skip both separators\n        } else {\n          // Regular separator\n          if (currentPart.trim()) {\n            segments.push(this._parseSegment(currentPart.trim()));\n          }\n          currentPart = '';\n          i++;\n        }\n      } else {\n        currentPart += pattern[i];\n        i++;\n      }\n    }\n\n    // Flush remaining part\n    if (currentPart.trim()) {\n      segments.push(this._parseSegment(currentPart.trim()));\n    }\n\n    return segments;\n  }\n\n  /**\n   * Parse a single segment\n   * @private\n   * @param {string} part - Segment string (e.g., \"user\", \"ns::user\", \"user[id]\", \"ns::user:first\")\n   * @returns {Object} Segment object\n   */\n  _parseSegment(part) {\n    const segment = { type: 'tag' };\n\n    // NEW NAMESPACE SYNTAX (v2.0):\n    // ============================\n    // Namespace uses DOUBLE colon (::)\n    // Position uses SINGLE colon (:)\n    // \n    // Examples:\n    //   \"user\"              → tag\n    //   \"user:first\"        → tag + position\n    //   \"user[id]\"          → tag + attribute\n    //   \"user[id]:first\"    → tag + attribute + position\n    //   \"ns::user\"          → namespace + tag\n    //   \"ns::user:first\"    → namespace + tag + position\n    //   \"ns::user[id]\"      → namespace + tag + attribute\n    //   \"ns::user[id]:first\" → namespace + tag + attribute + position\n    //   \"ns::first\"         → namespace + tag named \"first\" (NO ambiguity!)\n    //\n    // This eliminates all ambiguity:\n    //   :: = namespace separator\n    //   :  = position selector\n    //   [] = attributes\n\n    // Step 1: Extract brackets [attr] or [attr=value]\n    let bracketContent = null;\n    let withoutBrackets = part;\n\n    const bracketMatch = part.match(/^([^\\[]+)(\\[[^\\]]*\\])(.*)$/);\n    if (bracketMatch) {\n      withoutBrackets = bracketMatch[1] + bracketMatch[3];\n      if (bracketMatch[2]) {\n        const content = bracketMatch[2].slice(1, -1);\n        if (content) {\n          bracketContent = content;\n        }\n      }\n    }\n\n    // Step 2: Check for namespace (double colon ::)\n    let namespace = undefined;\n    let tagAndPosition = withoutBrackets;\n\n    if (withoutBrackets.includes('::')) {\n      const nsIndex = withoutBrackets.indexOf('::');\n      namespace = withoutBrackets.substring(0, nsIndex).trim();\n      tagAndPosition = withoutBrackets.substring(nsIndex + 2).trim(); // Skip ::\n\n      if (!namespace) {\n        throw new Error(`Invalid namespace in pattern: ${part}`);\n      }\n    }\n\n    // Step 3: Parse tag and position (single colon :)\n    let tag = undefined;\n    let positionMatch = null;\n\n    if (tagAndPosition.includes(':')) {\n      const colonIndex = tagAndPosition.lastIndexOf(':'); // Use last colon for position\n      const tagPart = tagAndPosition.substring(0, colonIndex).trim();\n      const posPart = tagAndPosition.substring(colonIndex + 1).trim();\n\n      // Verify position is a valid keyword\n      const isPositionKeyword = ['first', 'last', 'odd', 'even'].includes(posPart) ||\n        /^nth\\(\\d+\\)$/.test(posPart);\n\n      if (isPositionKeyword) {\n        tag = tagPart;\n        positionMatch = posPart;\n      } else {\n        // Not a valid position keyword, treat whole thing as tag\n        tag = tagAndPosition;\n      }\n    } else {\n      tag = tagAndPosition;\n    }\n\n    if (!tag) {\n      throw new Error(`Invalid segment pattern: ${part}`);\n    }\n\n    segment.tag = tag;\n    if (namespace) {\n      segment.namespace = namespace;\n    }\n\n    // Step 4: Parse attributes\n    if (bracketContent) {\n      if (bracketContent.includes('=')) {\n        const eqIndex = bracketContent.indexOf('=');\n        segment.attrName = bracketContent.substring(0, eqIndex).trim();\n        segment.attrValue = bracketContent.substring(eqIndex + 1).trim();\n      } else {\n        segment.attrName = bracketContent.trim();\n      }\n    }\n\n    // Step 5: Parse position selector\n    if (positionMatch) {\n      const nthMatch = positionMatch.match(/^nth\\((\\d+)\\)$/);\n      if (nthMatch) {\n        segment.position = 'nth';\n        segment.positionValue = parseInt(nthMatch[1], 10);\n      } else {\n        segment.position = positionMatch;\n      }\n    }\n\n    return segment;\n  }\n\n  /**\n   * Get the number of segments\n   * @returns {number}\n   */\n  get length() {\n    return this.segments.length;\n  }\n\n  /**\n   * Check if expression contains deep wildcard\n   * @returns {boolean}\n   */\n  hasDeepWildcard() {\n    return this._hasDeepWildcard;\n  }\n\n  /**\n   * Check if expression has attribute conditions\n   * @returns {boolean}\n   */\n  hasAttributeCondition() {\n    return this._hasAttributeCondition;\n  }\n\n  /**\n   * Check if expression has position selectors\n   * @returns {boolean}\n   */\n  hasPositionSelector() {\n    return this._hasPositionSelector;\n  }\n\n  /**\n   * Get string representation\n   * @returns {string}\n   */\n  toString() {\n    return this.pattern;\n  }\n}","/**\n * Matcher - Tracks current path in XML/JSON tree and matches against Expressions\n * \n * The matcher maintains a stack of nodes representing the current path from root to\n * current tag. It only stores attribute values for the current (top) node to minimize\n * memory usage. Sibling tracking is used to auto-calculate position and counter.\n * \n * @example\n * const matcher = new Matcher();\n * matcher.push(\"root\", {});\n * matcher.push(\"users\", {});\n * matcher.push(\"user\", { id: \"123\", type: \"admin\" });\n * \n * const expr = new Expression(\"root.users.user\");\n * matcher.matches(expr); // true\n */\n\n/**\n * Names of methods that mutate Matcher state.\n * Any attempt to call these on a read-only view throws a TypeError.\n * @type {Set<string>}\n */\nconst MUTATING_METHODS = new Set(['push', 'pop', 'reset', 'updateCurrent', 'restore']);\n\nexport default class Matcher {\n  /**\n   * Create a new Matcher\n   * @param {Object} options - Configuration options\n   * @param {string} options.separator - Default path separator (default: '.')\n   */\n  constructor(options = {}) {\n    this.separator = options.separator || '.';\n    this.path = [];\n    this.siblingStacks = [];\n    // Each path node: { tag: string, values: object, position: number, counter: number }\n    // values only present for current (last) node\n    // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level\n  }\n\n  /**\n   * Push a new tag onto the path\n   * @param {string} tagName - Name of the tag\n   * @param {Object} attrValues - Attribute key-value pairs for current node (optional)\n   * @param {string} namespace - Namespace for the tag (optional)\n   */\n  push(tagName, attrValues = null, namespace = null) {\n    // Remove values from previous current node (now becoming ancestor)\n    if (this.path.length > 0) {\n      const prev = this.path[this.path.length - 1];\n      prev.values = undefined;\n    }\n\n    // Get or create sibling tracking for current level\n    const currentLevel = this.path.length;\n    if (!this.siblingStacks[currentLevel]) {\n      this.siblingStacks[currentLevel] = new Map();\n    }\n\n    const siblings = this.siblingStacks[currentLevel];\n\n    // Create a unique key for sibling tracking that includes namespace\n    const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;\n\n    // Calculate counter (how many times this tag appeared at this level)\n    const counter = siblings.get(siblingKey) || 0;\n\n    // Calculate position (total children at this level so far)\n    let position = 0;\n    for (const count of siblings.values()) {\n      position += count;\n    }\n\n    // Update sibling count for this tag\n    siblings.set(siblingKey, counter + 1);\n\n    // Create new node\n    const node = {\n      tag: tagName,\n      position: position,\n      counter: counter\n    };\n\n    // Store namespace if provided\n    if (namespace !== null && namespace !== undefined) {\n      node.namespace = namespace;\n    }\n\n    // Store values only for current node\n    if (attrValues !== null && attrValues !== undefined) {\n      node.values = attrValues;\n    }\n\n    this.path.push(node);\n  }\n\n  /**\n   * Pop the last tag from the path\n   * @returns {Object|undefined} The popped node\n   */\n  pop() {\n    if (this.path.length === 0) {\n      return undefined;\n    }\n\n    const node = this.path.pop();\n\n    // Clean up sibling tracking for levels deeper than current\n    // After pop, path.length is the new depth\n    // We need to clean up siblingStacks[path.length + 1] and beyond\n    if (this.siblingStacks.length > this.path.length + 1) {\n      this.siblingStacks.length = this.path.length + 1;\n    }\n\n    return node;\n  }\n\n  /**\n   * Update current node's attribute values\n   * Useful when attributes are parsed after push\n   * @param {Object} attrValues - Attribute values\n   */\n  updateCurrent(attrValues) {\n    if (this.path.length > 0) {\n      const current = this.path[this.path.length - 1];\n      if (attrValues !== null && attrValues !== undefined) {\n        current.values = attrValues;\n      }\n    }\n  }\n\n  /**\n   * Get current tag name\n   * @returns {string|undefined}\n   */\n  getCurrentTag() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].tag : undefined;\n  }\n\n  /**\n   * Get current namespace\n   * @returns {string|undefined}\n   */\n  getCurrentNamespace() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].namespace : undefined;\n  }\n\n  /**\n   * Get current node's attribute value\n   * @param {string} attrName - Attribute name\n   * @returns {*} Attribute value or undefined\n   */\n  getAttrValue(attrName) {\n    if (this.path.length === 0) return undefined;\n    const current = this.path[this.path.length - 1];\n    return current.values?.[attrName];\n  }\n\n  /**\n   * Check if current node has an attribute\n   * @param {string} attrName - Attribute name\n   * @returns {boolean}\n   */\n  hasAttr(attrName) {\n    if (this.path.length === 0) return false;\n    const current = this.path[this.path.length - 1];\n    return current.values !== undefined && attrName in current.values;\n  }\n\n  /**\n   * Get current node's sibling position (child index in parent)\n   * @returns {number}\n   */\n  getPosition() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].position ?? 0;\n  }\n\n  /**\n   * Get current node's repeat counter (occurrence count of this tag name)\n   * @returns {number}\n   */\n  getCounter() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].counter ?? 0;\n  }\n\n  /**\n   * Get current node's sibling index (alias for getPosition for backward compatibility)\n   * @returns {number}\n   * @deprecated Use getPosition() or getCounter() instead\n   */\n  getIndex() {\n    return this.getPosition();\n  }\n\n  /**\n   * Get current path depth\n   * @returns {number}\n   */\n  getDepth() {\n    return this.path.length;\n  }\n\n  /**\n   * Get path as string\n   * @param {string} separator - Optional separator (uses default if not provided)\n   * @param {boolean} includeNamespace - Whether to include namespace in output (default: true)\n   * @returns {string}\n   */\n  toString(separator, includeNamespace = true) {\n    const sep = separator || this.separator;\n    return this.path.map(n => {\n      if (includeNamespace && n.namespace) {\n        return `${n.namespace}:${n.tag}`;\n      }\n      return n.tag;\n    }).join(sep);\n  }\n\n  /**\n   * Get path as array of tag names\n   * @returns {string[]}\n   */\n  toArray() {\n    return this.path.map(n => n.tag);\n  }\n\n  /**\n   * Reset the path to empty\n   */\n  reset() {\n    this.path = [];\n    this.siblingStacks = [];\n  }\n\n  /**\n   * Match current path against an Expression\n   * @param {Expression} expression - The expression to match against\n   * @returns {boolean} True if current path matches the expression\n   */\n  matches(expression) {\n    const segments = expression.segments;\n\n    if (segments.length === 0) {\n      return false;\n    }\n\n    // Handle deep wildcard patterns\n    if (expression.hasDeepWildcard()) {\n      return this._matchWithDeepWildcard(segments);\n    }\n\n    // Simple path matching (no deep wildcards)\n    return this._matchSimple(segments);\n  }\n\n  /**\n   * Match simple path (no deep wildcards)\n   * @private\n   */\n  _matchSimple(segments) {\n    // Path must be same length as segments\n    if (this.path.length !== segments.length) {\n      return false;\n    }\n\n    // Match each segment bottom-to-top\n    for (let i = 0; i < segments.length; i++) {\n      const segment = segments[i];\n      const node = this.path[i];\n      const isCurrentNode = (i === this.path.length - 1);\n\n      if (!this._matchSegment(segment, node, isCurrentNode)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Match path with deep wildcards\n   * @private\n   */\n  _matchWithDeepWildcard(segments) {\n    let pathIdx = this.path.length - 1;  // Start from current node (bottom)\n    let segIdx = segments.length - 1;     // Start from last segment\n\n    while (segIdx >= 0 && pathIdx >= 0) {\n      const segment = segments[segIdx];\n\n      if (segment.type === 'deep-wildcard') {\n        // \"..\" matches zero or more levels\n        segIdx--;\n\n        if (segIdx < 0) {\n          // Pattern ends with \"..\", always matches\n          return true;\n        }\n\n        // Find where next segment matches in the path\n        const nextSeg = segments[segIdx];\n        let found = false;\n\n        for (let i = pathIdx; i >= 0; i--) {\n          const isCurrentNode = (i === this.path.length - 1);\n          if (this._matchSegment(nextSeg, this.path[i], isCurrentNode)) {\n            pathIdx = i - 1;\n            segIdx--;\n            found = true;\n            break;\n          }\n        }\n\n        if (!found) {\n          return false;\n        }\n      } else {\n        // Regular segment\n        const isCurrentNode = (pathIdx === this.path.length - 1);\n        if (!this._matchSegment(segment, this.path[pathIdx], isCurrentNode)) {\n          return false;\n        }\n        pathIdx--;\n        segIdx--;\n      }\n    }\n\n    // All segments must be consumed\n    return segIdx < 0;\n  }\n\n  /**\n   * Match a single segment against a node\n   * @private\n   * @param {Object} segment - Segment from Expression\n   * @param {Object} node - Node from path\n   * @param {boolean} isCurrentNode - Whether this is the current (last) node\n   * @returns {boolean}\n   */\n  _matchSegment(segment, node, isCurrentNode) {\n    // Match tag name (* is wildcard)\n    if (segment.tag !== '*' && segment.tag !== node.tag) {\n      return false;\n    }\n\n    // Match namespace if specified in segment\n    if (segment.namespace !== undefined) {\n      // Segment has namespace - node must match it\n      if (segment.namespace !== '*' && segment.namespace !== node.namespace) {\n        return false;\n      }\n    }\n    // If segment has no namespace, it matches nodes with or without namespace\n\n    // Match attribute name (check if node has this attribute)\n    // Can only check for current node since ancestors don't have values\n    if (segment.attrName !== undefined) {\n      if (!isCurrentNode) {\n        // Can't check attributes for ancestor nodes (values not stored)\n        return false;\n      }\n\n      if (!node.values || !(segment.attrName in node.values)) {\n        return false;\n      }\n\n      // Match attribute value (only possible for current node)\n      if (segment.attrValue !== undefined) {\n        const actualValue = node.values[segment.attrName];\n        // Both should be strings\n        if (String(actualValue) !== String(segment.attrValue)) {\n          return false;\n        }\n      }\n    }\n\n    // Match position (only for current node)\n    if (segment.position !== undefined) {\n      if (!isCurrentNode) {\n        // Can't check position for ancestor nodes\n        return false;\n      }\n\n      const counter = node.counter ?? 0;\n\n      if (segment.position === 'first' && counter !== 0) {\n        return false;\n      } else if (segment.position === 'odd' && counter % 2 !== 1) {\n        return false;\n      } else if (segment.position === 'even' && counter % 2 !== 0) {\n        return false;\n      } else if (segment.position === 'nth') {\n        if (counter !== segment.positionValue) {\n          return false;\n        }\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Create a snapshot of current state\n   * @returns {Object} State snapshot\n   */\n  snapshot() {\n    return {\n      path: this.path.map(node => ({ ...node })),\n      siblingStacks: this.siblingStacks.map(map => new Map(map))\n    };\n  }\n\n  /**\n   * Restore state from snapshot\n   * @param {Object} snapshot - State snapshot\n   */\n  restore(snapshot) {\n    this.path = snapshot.path.map(node => ({ ...node }));\n    this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));\n  }\n\n  /**\n   * Return a read-only view of this matcher.\n   *\n   * The returned object exposes all query/inspection methods but throws a\n   * TypeError if any state-mutating method is called (`push`, `pop`, `reset`,\n   * `updateCurrent`, `restore`).  Property reads (e.g. `.path`, `.separator`)\n   * are allowed but the returned arrays/objects are frozen so callers cannot\n   * mutate internal state through them either.\n   *\n   * @returns {ReadOnlyMatcher} A proxy that forwards read operations and blocks writes.\n   *\n   * @example\n   * const matcher = new Matcher();\n   * matcher.push(\"root\", {});\n   *\n   * const ro = matcher.readOnly();\n   * ro.matches(expr);      // ✓ works\n   * ro.getCurrentTag();    // ✓ works\n   * ro.push(\"child\", {}); // ✗ throws TypeError\n   * ro.reset();            // ✗ throws TypeError\n   */\n  readOnly() {\n    const self = this;\n\n    return new Proxy(self, {\n      get(target, prop, receiver) {\n        // Block mutating methods\n        if (MUTATING_METHODS.has(prop)) {\n          return () => {\n            throw new TypeError(\n              `Cannot call '${prop}' on a read-only Matcher. ` +\n              `Obtain a writable instance to mutate state.`\n            );\n          };\n        }\n\n        const value = Reflect.get(target, prop, receiver);\n\n        // Freeze array/object properties so callers can't mutate internal\n        // state through direct property access (e.g. matcher.path.push(...))\n        if (prop === 'path' || prop === 'siblingStacks') {\n          return Object.freeze(\n            Array.isArray(value)\n              ? value.map(item =>\n                item instanceof Map\n                  ? Object.freeze(new Map(item))   // freeze a copy of each Map\n                  : Object.freeze({ ...item })      // freeze a copy of each node\n              )\n              : value\n          );\n        }\n\n        // Bind methods so `this` inside them still refers to the real Matcher\n        if (typeof value === 'function') {\n          return value.bind(target);\n        }\n\n        return value;\n      },\n\n      // Prevent any property assignment on the read-only view\n      set(_target, prop) {\n        throw new TypeError(\n          `Cannot set property '${String(prop)}' on a read-only Matcher.`\n        );\n      },\n\n      // Prevent property deletion\n      deleteProperty(_target, prop) {\n        throw new TypeError(\n          `Cannot delete property '${String(prop)}' from a read-only Matcher.`\n        );\n      }\n    });\n  }\n}","/**\n * fast-xml-tagger - XML/JSON path matching library\n * \n * Provides efficient path tracking and pattern matching for XML/JSON parsers.\n * \n * @example\n * import { Expression, Matcher } from 'fast-xml-tagger';\n * \n * // Create expression (parse once)\n * const expr = new Expression(\"root.users.user[id]\");\n * \n * // Create matcher (track path)\n * const matcher = new Matcher();\n * matcher.push(\"root\", [], {}, 0);\n * matcher.push(\"users\", [], {}, 0);\n * matcher.push(\"user\", [\"id\", \"type\"], { id: \"123\", type: \"admin\" }, 0);\n * \n * // Match\n * if (matcher.matches(expr)) {\n *   console.log(\"Match found!\");\n * }\n */\n\nimport Expression from './Expression.js';\nimport Matcher from './Matcher.js';\n\nexport { Expression, Matcher };\nexport default { Expression, Matcher };\n"],"names":["root","factory","exports","module","define","amd","this","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","value","Expression","constructor","pattern","options","separator","segments","_parse","_hasDeepWildcard","some","seg","type","_hasAttributeCondition","undefined","attrName","_hasPositionSelector","position","i","currentPart","length","trim","push","_parseSegment","part","segment","bracketContent","withoutBrackets","bracketMatch","match","content","slice","namespace","tag","tagAndPosition","includes","nsIndex","indexOf","substring","Error","positionMatch","colonIndex","lastIndexOf","tagPart","posPart","test","eqIndex","attrValue","nthMatch","positionValue","parseInt","hasDeepWildcard","hasAttributeCondition","hasPositionSelector","toString","MUTATING_METHODS","Set","Matcher","path","siblingStacks","tagName","attrValues","values","currentLevel","Map","siblings","siblingKey","counter","count","set","node","pop","updateCurrent","current","getCurrentTag","getCurrentNamespace","getAttrValue","hasAttr","getPosition","getCounter","getIndex","getDepth","includeNamespace","sep","map","n","join","toArray","reset","matches","expression","_matchWithDeepWildcard","_matchSimple","isCurrentNode","_matchSegment","pathIdx","segIdx","nextSeg","found","actualValue","String","snapshot","restore","readOnly","Proxy","target","receiver","has","TypeError","Reflect","freeze","Array","isArray","item","bind","_target","deleteProperty"],"sourceRoot":""}

package/node_modules/path-expression-matcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "path-expression-matcher",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "Efficient path tracking and pattern matching for XML/JSON parsers",
   "main": "./lib/pem.cjs",
   "type": "module",
@@ -20,7 +20,7 @@
     }
   },
   "scripts": {
-    "test": "c8 --reporter=lcov --reporter=text node test/namespace_test.js && c8 --reporter=lcov --reporter=text node test/test.js",
+    "test": "c8 --reporter=lcov --reporter=text node test/*test.js",
     "bundle": "webpack --config webpack.cjs.config.js"
   },
   "keywords": [

package/node_modules/path-expression-matcher/src/Matcher.js

@@ -14,6 +14,14 @@
  * const expr = new Expression("root.users.user");
  * matcher.matches(expr); // true
  */
+
+/**
+ * Names of methods that mutate Matcher state.
+ * Any attempt to call these on a read-only view throws a TypeError.
+ * @type {Set<string>}
+ */
+const MUTATING_METHODS = new Set(['push', 'pop', 'reset', 'updateCurrent', 'restore']);
+
 export default class Matcher {
   /**
    * Create a new Matcher
@@ -411,4 +419,80 @@ export default class Matcher {
     this.path = snapshot.path.map(node => ({ ...node }));
     this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));
   }
+
+  /**
+   * 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 self = this;
+
+    return new Proxy(self, {
+      get(target, prop, receiver) {
+        // Block mutating methods
+        if (MUTATING_METHODS.has(prop)) {
+          return () => {
+            throw new TypeError(
+              `Cannot call '${prop}' on a read-only Matcher. ` +
+              `Obtain a writable instance to mutate state.`
+            );
+          };
+        }
+
+        const value = Reflect.get(target, prop, receiver);
+
+        // Freeze array/object properties so callers can't mutate internal
+        // state through direct property access (e.g. matcher.path.push(...))
+        if (prop === 'path' || prop === 'siblingStacks') {
+          return Object.freeze(
+            Array.isArray(value)
+              ? value.map(item =>
+                item instanceof Map
+                  ? Object.freeze(new Map(item))   // freeze a copy of each Map
+                  : Object.freeze({ ...item })      // freeze a copy of each node
+              )
+              : value
+          );
+        }
+
+        // Bind methods so `this` inside them still refers to the real Matcher
+        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.`
+        );
+      }
+    });
+  }
 }

package/node_modules/path-expression-matcher/src/index.d.ts

@@ -188,6 +188,153 @@ export interface MatcherSnapshot {
   siblingStacks: Map<string, number>[];
 }
 
+/**
+ * ReadOnlyMatcher - A safe, read-only view over a {@link Matcher} instance.
+ *
+ * Returned by {@link Matcher.readOnly}. Exposes all query and inspection
+ * methods but **throws a `TypeError`** if any state-mutating method is called
+ * (`push`, `pop`, `reset`, `updateCurrent`, `restore`).  Direct property
+ * writes are also blocked.
+ *
+ * Pass this to consumers that only need to inspect or match the current path
+ * so they cannot accidentally corrupt the parser state.
+ *
+ * @example
+ * ```typescript
+ * const matcher = new Matcher();
+ * matcher.push("root", {});
+ * matcher.push("users", {});
+ * matcher.push("user", { id: "123" });
+ *
+ * const ro: ReadOnlyMatcher = matcher.readOnly();
+ *
+ * ro.matches(expr);      // ✓ works
+ * ro.getCurrentTag();    // ✓ "user"
+ * ro.getDepth();         // ✓ 3
+ * ro.push("child", {}); // ✗ TypeError: Cannot call 'push' on a read-only Matcher
+ * ro.reset();            // ✗ TypeError: Cannot call 'reset' on a read-only Matcher
+ * ```
+ */
+export interface ReadOnlyMatcher {
+  /**
+   * Default path separator (read-only)
+   */
+  readonly separator: string;
+
+  /**
+   * Current path stack (each node is a frozen copy)
+   */
+  readonly path: ReadonlyArray<Readonly<PathNode>>;
+
+  // ── Query methods ───────────────────────────────────────────────────────────
+
+  /**
+   * Get current tag name
+   * @returns Current tag name or undefined if path is empty
+   */
+  getCurrentTag(): string | undefined;
+
+  /**
+   * Get current namespace
+   * @returns Current namespace or undefined if not present or path is empty
+   */
+  getCurrentNamespace(): string | undefined;
+
+  /**
+   * Get current node's attribute value
+   * @param attrName - Attribute name
+   * @returns Attribute value or undefined
+   */
+  getAttrValue(attrName: string): any;
+
+  /**
+   * Check if current node has an attribute
+   * @param attrName - Attribute name
+   */
+  hasAttr(attrName: string): boolean;
+
+  /**
+   * Get current node's sibling position (child index in parent)
+   * @returns Position index or -1 if path is empty
+   */
+  getPosition(): number;
+
+  /**
+   * Get current node's repeat counter (occurrence count of this tag name)
+   * @returns Counter value or -1 if path is empty
+   */
+  getCounter(): number;
+
+  /**
+   * Get current node's sibling index (alias for getPosition for backward compatibility)
+   * @returns Index or -1 if path is empty
+   * @deprecated Use getPosition() or getCounter() instead
+   */
+  getIndex(): number;
+
+  /**
+   * Get current path depth
+   * @returns Number of nodes in the path
+   */
+  getDepth(): number;
+
+  /**
+   * Get path as string
+   * @param separator - Optional separator (uses default if not provided)
+   * @param includeNamespace - Whether to include namespace in output
+   * @returns Path string (e.g., "root.users.user" or "ns:root.ns:users.user")
+   */
+  toString(separator?: string, includeNamespace?: boolean): string;
+
+  /**
+   * Get path as array of tag names
+   * @returns Array of tag names
+   */
+  toArray(): string[];
+
+  /**
+   * Match current path against an Expression
+   * @param expression - The expression to match against
+   * @returns True if current path matches the expression
+   */
+  matches(expression: Expression): boolean;
+
+  /**
+   * Create a snapshot of current state
+   * @returns State snapshot that can be restored later
+   */
+  snapshot(): MatcherSnapshot;
+
+  // ── Blocked mutating methods ────────────────────────────────────────────────
+  // These are present in the type so callers get a compile-time error with a
+  // helpful message instead of a silent "property does not exist" error.
+
+  /**
+   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
+   */
+  push(tagName: string, attrValues?: Record<string, any> | null, namespace?: string | null): never;
+
+  /**
+   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
+   */
+  pop(): never;
+
+  /**
+   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
+   */
+  updateCurrent(attrValues: Record<string, any>): never;
+
+  /**
+   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
+   */
+  reset(): never;
+
+  /**
+   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
+   */
+  restore(snapshot: MatcherSnapshot): never;
+}
+
 /**
  * Matcher - Tracks current path in XML/JSON tree and matches against Expressions
  * 
@@ -353,6 +500,11 @@ export class Matcher {
    * @param snapshot - State snapshot from previous snapshot() call
    */
   restore(snapshot: MatcherSnapshot): void;
+
+  /**
+   * Return a read-only view of this matcher.
+   */
+  readOnly(): ReadOnlyMatcher;
 }
 
 /**

package/node_modules/strnum/CHANGELOG.md

@@ -1,6 +1,9 @@
 
-**2.1.1 / 2025-05-15**
-- remove unnecessary check to remove lint error
+**2.2.1 / 2026-03-19**
+- fix false positive for eNotation when no leading zeros
+
+**2.2.0 / 2026-02-28**
+- support infinity
 
 **2.1.0 / 2025-05-01**
 - fix e-notation 

package/node_modules/strnum/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strnum",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Parse String to Number based on configuration",
   "type": "module",
   "main": "strnum.js",

package/node_modules/strnum/strnum.js

@@ -97,11 +97,16 @@ function resolveEnotation(str, trimmedStr, options) {
         else if (leadingZeros.length === 1
             && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)) {
             return Number(trimmedStr);
-        } else if (options.leadingZeros && !eAdjacentToLeadingZeros) { //accept with leading zeros
-            //remove leading 0s
-            trimmedStr = (notation[1] || "") + notation[3];
+        } else if (leadingZeros.length > 0) {
+            // Has leading zeros — only accept if leadingZeros option allows it
+            if (options.leadingZeros && !eAdjacentToLeadingZeros) {
+                trimmedStr = (notation[1] || "") + notation[3];
+                return Number(trimmedStr);
+            } else return str;
+        } else {
+            // No leading zeros — always valid e-notation, parse it
             return Number(trimmedStr);
-        } else return str;
+        }
     } else {
         return str;
     }

package/node_modules/strnum/tests/strnum_test.js

@@ -126,6 +126,8 @@ describe("Should convert all the valid numeric strings to number", () => {
         expect(toNumber("1e-2")).toEqual(0.01);
         expect(toNumber("1e+2")).toEqual(100);
         expect(toNumber("1.e+2")).toEqual(100);
+
+        expect(toNumber("1.5e3", { leadingZeros: false })).toEqual(1500);
     });
 
     it("scientific notation with upper E", () => {

package/node_modules/strnum/tests/temp.js

@@ -0,0 +1,8 @@
+import toNumber from "../strnum.js";
+
+console.log(toNumber("1.5e3", {leadingZeros: false}))
+// describe("temp", () = {
+
+//   it("scientific notation", () => {
+//     });
+// })

package/package.json

@@ -69,7 +69,7 @@
     "constructs": ">=10.0.5 <11.0.0"
   },
   "dependencies": {
-    "@aws-sdk/client-cloudformation": "^3.1012.0",
+    "@aws-sdk/client-cloudformation": "^3.1014.0",
     "@types/crypto-js": "^4.2.2",
     "@types/js-yaml": "^4.0.9",
     "crypto-js": "^4.2.0",
@@ -110,7 +110,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.9.14",
+  "version": "1.9.16",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [