npm - lambda-live-debugger - Versions diffs - 1.12.4 → 1.12.6 - Mend

lambda-live-debugger 1.12.4 → 1.12.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4242) hide show

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

	@@ -1 +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/ExpressionSet.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 = {}, data) {\n this.pattern = pattern;\n this.separator = options.separator \|\| '.';\n this.segments = this._parse(pattern);\n this.data = data;\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}","import ExpressionSet from \"./ExpressionSet.js\";\n\n/\n MatcherView - A lightweight read-only view over a Matcher's internal state.\n \n Created once by Matcher and reused across all callbacks. Holds a direct\n * reference to the parent Matcher so it always reflects current parser state\n * with zero copying or freezing overhead.\n \n Users receive this via {@link Matcher#readOnly} or directly from parser\n * callbacks. It exposes all query and matching methods but has no mutation\n * methods — misuse is caught at the TypeScript level rather than at runtime.\n \n @example\n * const matcher = new Matcher();\n * const view = matcher.readOnly();\n \n matcher.push(\"root\", {});\n * view.getCurrentTag(); // \"root\"\n * view.getDepth(); // 1\n /\nexport class MatcherView {\n /\n @param {Matcher} matcher - The parent Matcher instance to read from.\n /\n constructor(matcher) {\n this._matcher = matcher;\n }\n\n /\n Get the path separator used by the parent matcher.\n * @returns {string}\n /\n get separator() {\n return this._matcher.separator;\n }\n\n /\n Get current tag name.\n * @returns {string\|undefined}\n /\n getCurrentTag() {\n const path = this._matcher.path;\n return path.length > 0 ? path[path.length - 1].tag : undefined;\n }\n\n /\n Get current namespace.\n * @returns {string\|undefined}\n /\n getCurrentNamespace() {\n const path = this._matcher.path;\n return path.length > 0 ? path[path.length - 1].namespace : undefined;\n }\n\n /\n Get current node's attribute value.\n * @param {string} attrName\n * @returns {}\n /\n getAttrValue(attrName) {\n const path = this._matcher.path;\n if (path.length === 0) return undefined;\n return path[path.length - 1].values?.[attrName];\n }\n\n /*\n Check if current node has an attribute.\n * @param {string} attrName\n * @returns {boolean}\n /\n hasAttr(attrName) {\n const path = this._matcher.path;\n if (path.length === 0) return false;\n const current = path[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 const path = this._matcher.path;\n if (path.length === 0) return -1;\n return path[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 const path = this._matcher.path;\n if (path.length === 0) return -1;\n return path[path.length - 1].counter ?? 0;\n }\n\n /\n Get current node's sibling index (alias for getPosition).\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._matcher.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=true]\n * @returns {string}\n /\n toString(separator, includeNamespace = true) {\n return this._matcher.toString(separator, includeNamespace);\n }\n\n /\n Get path as array of tag names.\n * @returns {string[]}\n /\n toArray() {\n return this._matcher.path.map(n => n.tag);\n }\n\n /\n Match current path against an Expression.\n * @param {Expression} expression\n * @returns {boolean}\n /\n matches(expression) {\n return this._matcher.matches(expression);\n }\n\n /\n Match any expression in the given set against the current path.\n * @param {ExpressionSet} exprSet\n * @returns {boolean}\n /\n matchesAny(exprSet) {\n return exprSet.matchesAny(this._matcher);\n }\n}\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 Use {@link Matcher#readOnly} to obtain a {@link MatcherView} safe to pass to\n * user callbacks — it always reflects current state with no Proxy overhead.\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={}]\n * @param {string} [options.separator='.'] - Default path separator\n /\n constructor(options = {}) {\n this.separator = options.separator \|\| '.';\n this.path = [];\n this.siblingStacks = [];\n // Each path node: { tag, values, position, counter, namespace? }\n // values only present for current (last) node\n // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level\n this._pathStringCache = null;\n this._view = new MatcherView(this);\n }\n\n /\n Push a new tag onto the path.\n * @param {string} tagName\n * @param {Object\|null} [attrValues=null]\n * @param {string\|null} [namespace=null]\n /\n push(tagName, attrValues = null, namespace = null) {\n this._pathStringCache = null;\n\n // Remove values from previous current node (now becoming ancestor)\n if (this.path.length > 0) {\n this.path[this.path.length - 1].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 if (namespace !== null && namespace !== undefined) {\n node.namespace = namespace;\n }\n\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) return undefined;\n this._pathStringCache = null;\n\n const node = this.path.pop();\n\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\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\n * @returns {}\n /\n getAttrValue(attrName) {\n if (this.path.length === 0) return undefined;\n return this.path[this.path.length - 1].values?.[attrName];\n }\n\n /*\n Check if current node has an attribute.\n * @param {string} attrName\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).\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=true]\n * @returns {string}\n /\n toString(separator, includeNamespace = true) {\n const sep = separator \|\| this.separator;\n const isDefault = (sep === this.separator && includeNamespace === true);\n\n if (isDefault) {\n if (this._pathStringCache !== null) {\n return this._pathStringCache;\n }\n const result = this.path.map(n =>\n (n.namespace) ? `${n.namespace}:${n.tag}` : n.tag\n ).join(sep);\n this._pathStringCache = result;\n return result;\n }\n\n return this.path.map(n =>\n (includeNamespace && n.namespace) ? `${n.namespace}:${n.tag}` : 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._pathStringCache = null;\n this.path = [];\n this.siblingStacks = [];\n }\n\n /\n Match current path against an Expression.\n * @param {Expression} expression\n * @returns {boolean}\n /\n matches(expression) {\n const segments = expression.segments;\n\n if (segments.length === 0) {\n return false;\n }\n\n if (expression.hasDeepWildcard()) {\n return this._matchWithDeepWildcard(segments);\n }\n\n return this._matchSimple(segments);\n }\n\n /\n @private\n /\n _matchSimple(segments) {\n if (this.path.length !== segments.length) {\n return false;\n }\n\n for (let i = 0; i < segments.length; i++) {\n if (!this._matchSegment(segments[i], this.path[i], i === this.path.length - 1)) {\n return false;\n }\n }\n\n return true;\n }\n\n /\n @private\n /\n _matchWithDeepWildcard(segments) {\n let pathIdx = this.path.length - 1;\n let segIdx = segments.length - 1;\n\n while (segIdx >= 0 && pathIdx >= 0) {\n const segment = segments[segIdx];\n\n if (segment.type === 'deep-wildcard') {\n segIdx--;\n\n if (segIdx < 0) {\n return true;\n }\n\n const nextSeg = segments[segIdx];\n let found = false;\n\n for (let i = pathIdx; i >= 0; i--) {\n if (this._matchSegment(nextSeg, this.path[i], i === this.path.length - 1)) {\n pathIdx = i - 1;\n segIdx--;\n found = true;\n break;\n }\n }\n\n if (!found) {\n return false;\n }\n } else {\n if (!this._matchSegment(segment, this.path[pathIdx], pathIdx === this.path.length - 1)) {\n return false;\n }\n pathIdx--;\n segIdx--;\n }\n }\n\n return segIdx < 0;\n }\n\n /\n @private\n /\n _matchSegment(segment, node, isCurrentNode) {\n if (segment.tag !== '' && segment.tag !== node.tag) {\n return false;\n }\n\n if (segment.namespace !== undefined) {\n if (segment.namespace !== '' && segment.namespace !== node.namespace) {\n return false;\n }\n }\n\n if (segment.attrName !== undefined) {\n if (!isCurrentNode) {\n return false;\n }\n\n if (!node.values \|\| !(segment.attrName in node.values)) {\n return false;\n }\n\n if (segment.attrValue !== undefined) {\n if (String(node.values[segment.attrName]) !== String(segment.attrValue)) {\n return false;\n }\n }\n }\n\n if (segment.position !== undefined) {\n if (!isCurrentNode) {\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' && counter !== segment.positionValue) {\n return false;\n }\n }\n\n return true;\n }\n\n /\n Match any expression in the given set against the current path.\n * @param {ExpressionSet} exprSet\n * @returns {boolean}\n /\n matchesAny(exprSet) {\n return exprSet.matchesAny(this);\n }\n\n /\n Create a snapshot of current state.\n * @returns {Object}\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\n /\n restore(snapshot) {\n this._pathStringCache = null;\n this.path = snapshot.path.map(node => ({ ...node }));\n this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));\n }\n\n /\n Return the read-only {@link MatcherView} for this matcher.\n \n The same instance is returned on every call — no allocation occurs.\n * It always reflects the current parser state and is safe to pass to\n * user callbacks without risk of accidental mutation.\n \n @returns {MatcherView}\n \n @example\n * const view = matcher.readOnly();\n * // pass view to callbacks — it stays in sync automatically\n * view.matches(expr); // ✓\n * view.getCurrentTag(); // ✓\n * // view.push(...) // ✗ method does not exist — caught by TypeScript\n /\n readOnly() {\n return this._view;\n }\n}","/\n ExpressionSet - An indexed collection of Expressions for efficient bulk matching\n \n Instead of iterating all expressions on every tag, ExpressionSet pre-indexes\n * them at insertion time by depth and terminal tag name. At match time, only\n * the relevant bucket is evaluated — typically reducing checks from O(E) to O(1)\n * lookup plus O(small bucket) matches.\n \n Three buckets are maintained:\n * - `_byDepthAndTag` — exact depth + exact tag name (tightest, used first)\n * - `_wildcardByDepth` — exact depth + wildcard tag `` (depth-matched only)\n - `_deepWildcards` — expressions containing `..` (cannot be depth-indexed)\n \n @example\n * import { Expression, ExpressionSet } from 'fast-xml-tagger';\n \n // Build once at config time\n * const stopNodes = new ExpressionSet();\n * stopNodes.add(new Expression('root.users.user'));\n * stopNodes.add(new Expression('root.config.setting'));\n * stopNodes.add(new Expression('..script'));\n \n // Query on every tag — hot path\n * if (stopNodes.matchesAny(matcher)) { ... }\n /\nexport default class ExpressionSet {\n constructor() {\n /* @type {Map<string, import('./Expression.js').default[]>} depth:tag → expressions /\n this._byDepthAndTag = new Map();\n\n /* @type {Map<number, import('./Expression.js').default[]>} depth → wildcard-tag expressions /\n this._wildcardByDepth = new Map();\n\n /* @type {import('./Expression.js').default[]} expressions containing deep wildcard (..) /\n this._deepWildcards = [];\n\n /* @type {Set<string>} pattern strings already added — used for deduplication /\n this._patterns = new Set();\n\n /* @type {boolean} whether the set is sealed against further additions /\n this._sealed = false;\n }\n\n /\n Add an Expression to the set.\n * Duplicate patterns (same pattern string) are silently ignored.\n \n @param {import('./Expression.js').default} expression - A pre-constructed Expression instance\n * @returns {this} for chaining\n * @throws {TypeError} if called after seal()\n \n @example\n * set.add(new Expression('root.users.user'));\n * set.add(new Expression('..script'));\n /\n add(expression) {\n if (this._sealed) {\n throw new TypeError(\n 'ExpressionSet is sealed. Create a new ExpressionSet to add more expressions.'\n );\n }\n\n // Deduplicate by pattern string\n if (this._patterns.has(expression.pattern)) return this;\n this._patterns.add(expression.pattern);\n\n if (expression.hasDeepWildcard()) {\n this._deepWildcards.push(expression);\n return this;\n }\n\n const depth = expression.length;\n const lastSeg = expression.segments[expression.segments.length - 1];\n const tag = lastSeg?.tag;\n\n if (!tag \|\| tag === '') {\n // Can index by depth but not by tag\n if (!this._wildcardByDepth.has(depth)) this._wildcardByDepth.set(depth, []);\n this._wildcardByDepth.get(depth).push(expression);\n } else {\n // Tightest bucket: depth + tag\n const key = `${depth}:${tag}`;\n if (!this._byDepthAndTag.has(key)) this._byDepthAndTag.set(key, []);\n this._byDepthAndTag.get(key).push(expression);\n }\n\n return this;\n }\n\n /*\n Add multiple expressions at once.\n \n @param {import('./Expression.js').default[]} expressions - Array of Expression instances\n * @returns {this} for chaining\n \n @example\n * set.addAll([\n * new Expression('root.users.user'),\n * new Expression('root.config.setting'),\n * ]);\n /\n addAll(expressions) {\n for (const expr of expressions) this.add(expr);\n return this;\n }\n\n /\n Check whether a pattern string is already present in the set.\n \n @param {import('./Expression.js').default} expression\n * @returns {boolean}\n /\n has(expression) {\n return this._patterns.has(expression.pattern);\n }\n\n /\n Number of expressions in the set.\n * @type {number}\n /\n get size() {\n return this._patterns.size;\n }\n\n /\n Seal the set against further modifications.\n * Useful to prevent accidental mutations after config is built.\n * Calling add() or addAll() on a sealed set throws a TypeError.\n \n @returns {this}\n /\n seal() {\n this._sealed = true;\n return this;\n }\n\n /\n Whether the set has been sealed.\n * @type {boolean}\n /\n get isSealed() {\n return this._sealed;\n }\n\n /\n Test whether the matcher's current path matches any expression in the set.\n \n Evaluation order (cheapest → most expensive):\n * 1. Exact depth + tag bucket — O(1) lookup, typically 0–2 expressions\n * 2. Depth-only wildcard bucket — O(1) lookup, rare\n * 3. Deep-wildcard list — always checked, but usually small\n \n @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)\n * @returns {boolean} true if any expression matches the current path\n \n @example\n * if (stopNodes.matchesAny(matcher)) {\n * // handle stop node\n * }\n /\n matchesAny(matcher) {\n return this.findMatch(matcher) !== null;\n }\n /\n Find and return the first Expression that matches the matcher's current path.\n \n Uses the same evaluation order as matchesAny (cheapest → most expensive):\n * 1. Exact depth + tag bucket\n * 2. Depth-only wildcard bucket\n * 3. Deep-wildcard list\n \n @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)\n * @returns {import('./Expression.js').default \| null} the first matching Expression, or null\n \n @example\n * const expr = stopNodes.findMatch(matcher);\n * if (expr) {\n * // access expr.config, expr.pattern, etc.\n * }\n /\n findMatch(matcher) {\n const depth = matcher.getDepth();\n const tag = matcher.getCurrentTag();\n\n // 1. Tightest bucket — most expressions live here\n const exactKey = `${depth}:${tag}`;\n const exactBucket = this._byDepthAndTag.get(exactKey);\n if (exactBucket) {\n for (let i = 0; i < exactBucket.length; i++) {\n if (matcher.matches(exactBucket[i])) return exactBucket[i];\n }\n }\n\n // 2. Depth-matched wildcard-tag expressions\n const wildcardBucket = this._wildcardByDepth.get(depth);\n if (wildcardBucket) {\n for (let i = 0; i < wildcardBucket.length; i++) {\n if (matcher.matches(wildcardBucket[i])) return wildcardBucket[i];\n }\n }\n\n // 3. Deep wildcards — cannot be pre-filtered by depth or tag\n for (let i = 0; i < this._deepWildcards.length; i++) {\n if (matcher.matches(this._deepWildcards[i])) return this._deepWildcards[i];\n }\n\n return null;\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';\nimport ExpressionSet from './ExpressionSet.js';\n\nexport { Expression, Matcher, ExpressionSet };\nexport default { Expression, Matcher, ExpressionSet };\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","data","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","MatcherView","matcher","_matcher","getCurrentTag","path","getCurrentNamespace","getAttrValue","values","hasAttr","current","getPosition","getCounter","counter","getIndex","getDepth","includeNamespace","toArray","map","n","matches","expression","matchesAny","exprSet","Matcher","siblingStacks","_pathStringCache","_view","tagName","attrValues","currentLevel","Map","siblings","siblingKey","count","set","node","pop","updateCurrent","sep","result","join","reset","_matchWithDeepWildcard","_matchSimple","_matchSegment","pathIdx","segIdx","nextSeg","found","isCurrentNode","String","snapshot","restore","readOnly","ExpressionSet","_byDepthAndTag","_wildcardByDepth","_deepWildcards","_patterns","Set","_sealed","add","TypeError","has","depth","lastSeg","addAll","expressions","expr","size","seal","isSealed","findMatch","exactKey","exactBucket","wildcardBucket"],"sourceRoot":""}
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/ExpressionSet.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 = {}, data) {\n this.pattern = pattern;\n this.separator = options.separator \|\| '.';\n this.segments = this._parse(pattern);\n this.data = data;\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}","import ExpressionSet from \"./ExpressionSet.js\";\n\n/\n MatcherView - A lightweight read-only view over a Matcher's internal state.\n \n Created once by Matcher and reused across all callbacks. Holds a direct\n * reference to the parent Matcher so it always reflects current parser state\n * with zero copying or freezing overhead.\n \n Users receive this via {@link Matcher#readOnly} or directly from parser\n * callbacks. It exposes all query and matching methods but has no mutation\n * methods — misuse is caught at the TypeScript level rather than at runtime.\n \n @example\n * const matcher = new Matcher();\n * const view = matcher.readOnly();\n \n matcher.push(\"root\", {});\n * view.getCurrentTag(); // \"root\"\n * view.getDepth(); // 1\n /\nexport class MatcherView {\n /\n @param {Matcher} matcher - The parent Matcher instance to read from.\n /\n constructor(matcher) {\n this._matcher = matcher;\n }\n\n /\n Get the path separator used by the parent matcher.\n * @returns {string}\n /\n get separator() {\n return this._matcher.separator;\n }\n\n /\n Get current tag name.\n * @returns {string\|undefined}\n /\n getCurrentTag() {\n const path = this._matcher.path;\n return path.length > 0 ? path[path.length - 1].tag : undefined;\n }\n\n /\n Get current namespace.\n * @returns {string\|undefined}\n /\n getCurrentNamespace() {\n const path = this._matcher.path;\n return path.length > 0 ? path[path.length - 1].namespace : undefined;\n }\n\n /\n Get current node's attribute value.\n * @param {string} attrName\n * @returns {}\n /\n getAttrValue(attrName) {\n const path = this._matcher.path;\n if (path.length === 0) return undefined;\n return path[path.length - 1].values?.[attrName];\n }\n\n /*\n Check if current node has an attribute.\n * @param {string} attrName\n * @returns {boolean}\n /\n hasAttr(attrName) {\n const path = this._matcher.path;\n if (path.length === 0) return false;\n const current = path[path.length - 1];\n return current.values !== undefined && attrName in current.values;\n }\n\n /\n Get the value of a \"kept\" attribute from the nearest ancestor (or\n * current node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.\n * @param {string} attrName\n * @returns {}\n /\n getAnyParentAttr(attrName) {\n return this._matcher.getAnyParentAttr(attrName);\n }\n\n /*\n Check whether any ancestor (or the current node) kept the given\n * attribute via `push(tag, attrs, ns, { keep: [...] })`.\n * @param {string} attrName\n * @returns {boolean}\n /\n hasAnyParentAttr(attrName) {\n return this._matcher.hasAnyParentAttr(attrName);\n }\n\n /\n Get current node's sibling position (child index in parent).\n * @returns {number}\n /\n getPosition() {\n const path = this._matcher.path;\n if (path.length === 0) return -1;\n return path[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 const path = this._matcher.path;\n if (path.length === 0) return -1;\n return path[path.length - 1].counter ?? 0;\n }\n\n /\n Get current node's sibling index (alias for getPosition).\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._matcher.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=true]\n * @returns {string}\n /\n toString(separator, includeNamespace = true) {\n return this._matcher.toString(separator, includeNamespace);\n }\n\n /\n Get path as array of tag names.\n * @returns {string[]}\n /\n toArray() {\n return this._matcher.path.map(n => n.tag);\n }\n\n /\n Match current path against an Expression.\n * @param {Expression} expression\n * @returns {boolean}\n /\n matches(expression) {\n return this._matcher.matches(expression);\n }\n\n /\n Match any expression in the given set against the current path.\n * @param {ExpressionSet} exprSet\n * @returns {boolean}\n /\n matchesAny(exprSet) {\n return exprSet.matchesAny(this._matcher);\n }\n}\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 Use {@link Matcher#readOnly} to obtain a {@link MatcherView} safe to pass to\n * user callbacks — it always reflects current state with no Proxy overhead.\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={}]\n * @param {string} [options.separator='.'] - Default path separator\n /\n constructor(options = {}) {\n this.separator = options.separator \|\| '.';\n this.path = [];\n this.siblingStacks = [];\n // Each path node: { tag, values, position, counter, namespace? }\n // values only present for current (last) node\n // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level\n this._pathStringCache = null;\n this._view = new MatcherView(this);\n\n // Kept-attribute stack: only populated when push() is called with options.keep.\n this._keptAttrs = [];\n }\n\n /\n Push a new tag onto the path.\n * @param {string} tagName\n * @param {Object\|null} [attrValues=null]\n * @param {string\|null} [namespace=null]\n * @param {Object\|null} [options=null]\n * @param {string[]} [options.keep] - Names of attributes (from attrValues)\n /\n push(tagName, attrValues = null, namespace = null, options = null) {\n this._pathStringCache = null;\n\n // Remove values from previous current node (now becoming ancestor)\n if (this.path.length > 0) {\n this.path[this.path.length - 1].values = undefined;\n }\n\n // Get or create sibling tracking for current level\n const currentLevel = this.path.length;\n let level = this.siblingStacks[currentLevel];\n if (!level) {\n // `counts` tells same-name siblings apart (the \"counter\" — nth <item>\n // among other <item>s). `total` is every child seen at this level so\n // far, kept as a running number instead of re-added from `counts` on\n // every push — a parent with many differently-named children would\n // otherwise cost more per child the more distinct names it has.\n level = { counts: new Map(), total: 0 };\n this.siblingStacks[currentLevel] = level;\n }\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 = level.counts.get(siblingKey) \|\| 0;\n\n // Position = total children at this level seen before this one.\n const position = level.total;\n\n // Update sibling count for this tag, and the level's running total.\n level.counts.set(siblingKey, counter + 1);\n level.total++;\n\n // Create new node\n const node = {\n tag: tagName,\n position: position,\n counter: counter\n };\n\n if (namespace !== null && namespace !== undefined) {\n node.namespace = namespace;\n }\n\n if (attrValues !== null && attrValues !== undefined) {\n node.values = attrValues;\n }\n\n this.path.push(node);\n\n // Depth of the node we just pushed (1-based, matches this.path.length)\n const depth = this.path.length;\n\n // Copy only the requested attributes into the kept-attrs stack. This is\n // the one part of push() whose cost scales with input (O(keep.length))\n // rather than being O(1) — by design, since the caller is explicitly\n // opting in for specific attribute names. No options/keep => zero added\n // cost beyond the two property reads below.\n const keep = options !== null ? options.keep : null;\n if (keep !== null && keep !== undefined && keep.length > 0 && attrValues) {\n for (let i = 0; i < keep.length; i++) {\n const name = keep[i];\n if (attrValues[name] !== undefined) {\n this._keptAttrs.push({ depth, name, value: attrValues[name] });\n }\n }\n }\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) return undefined;\n this._pathStringCache = null;\n\n const node = this.path.pop();\n\n if (this.siblingStacks.length > this.path.length + 1) {\n this.siblingStacks.length = this.path.length + 1;\n }\n\n // Drop any kept attributes that belonged to the popped node (or deeper).\n // _keptAttrs is depth-ordered (push only ever appends increasing depths),\n // so this is a backward scan that stops at the first surviving entry —\n // typically O(1) since kept attrs are rare by design.\n const poppedDepth = this.path.length + 1;\n while (\n this._keptAttrs.length > 0 &&\n this._keptAttrs[this._keptAttrs.length - 1].depth >= poppedDepth\n ) {\n this._keptAttrs.pop();\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\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\n * @returns {}\n /\n getAttrValue(attrName) {\n if (this.path.length === 0) return undefined;\n return this.path[this.path.length - 1].values?.[attrName];\n }\n\n /*\n Check if current node has an attribute.\n * @param {string} attrName\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 the value of a \"kept\" attribute from the nearest ancestor (or\n * current node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.\n * Unlike getAttrValue(), this works regardless of how deep the path has\n * gone since the attribute was pushed — but only for attribute names that\n * were explicitly marked with `keep` at push time. Cost is proportional to\n * the number of currently-kept attributes (typically 0-3), not path depth.\n * @param {string} attrName\n * @returns {} the value, or undefined if no ancestor kept this attribute\n /\n getAnyParentAttr(attrName) {\n const kept = this._keptAttrs;\n for (let i = kept.length - 1; i >= 0; i--) {\n if (kept[i].name === attrName) return kept[i].value;\n }\n return undefined;\n }\n\n /*\n Check whether any ancestor (or the current node) kept the given\n * attribute via `push(tag, attrs, ns, { keep: [...] })`.\n * @param {string} attrName\n * @returns {boolean}\n /\n hasAnyParentAttr(attrName) {\n const kept = this._keptAttrs;\n for (let i = kept.length - 1; i >= 0; i--) {\n if (kept[i].name === attrName) return true;\n }\n return false;\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).\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=true]\n * @returns {string}\n /\n toString(separator, includeNamespace = true) {\n const sep = separator \|\| this.separator;\n const isDefault = (sep === this.separator && includeNamespace === true);\n\n if (isDefault) {\n if (this._pathStringCache !== null) {\n return this._pathStringCache;\n }\n const result = this.path.map(n =>\n (n.namespace) ? `${n.namespace}:${n.tag}` : n.tag\n ).join(sep);\n this._pathStringCache = result;\n return result;\n }\n\n return this.path.map(n =>\n (includeNamespace && n.namespace) ? `${n.namespace}:${n.tag}` : 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._pathStringCache = null;\n this.path = [];\n this.siblingStacks = [];\n this._keptAttrs = [];\n }\n\n /\n Match current path against an Expression.\n * @param {Expression} expression\n * @returns {boolean}\n /\n matches(expression) {\n const segments = expression.segments;\n\n if (segments.length === 0) {\n return false;\n }\n\n if (expression.hasDeepWildcard()) {\n return this._matchWithDeepWildcard(segments);\n }\n\n return this._matchSimple(segments);\n }\n\n /\n @private\n /\n _matchSimple(segments) {\n if (this.path.length !== segments.length) {\n return false;\n }\n\n for (let i = 0; i < segments.length; i++) {\n if (!this._matchSegment(segments[i], this.path[i], i === this.path.length - 1)) {\n return false;\n }\n }\n\n return true;\n }\n\n /\n @private\n /\n _matchWithDeepWildcard(segments) {\n let pathIdx = this.path.length - 1;\n let segIdx = segments.length - 1;\n\n while (segIdx >= 0 && pathIdx >= 0) {\n const segment = segments[segIdx];\n\n if (segment.type === 'deep-wildcard') {\n segIdx--;\n\n if (segIdx < 0) {\n return true;\n }\n\n const nextSeg = segments[segIdx];\n let found = false;\n\n for (let i = pathIdx; i >= 0; i--) {\n if (this._matchSegment(nextSeg, this.path[i], i === this.path.length - 1)) {\n pathIdx = i - 1;\n segIdx--;\n found = true;\n break;\n }\n }\n\n if (!found) {\n return false;\n }\n } else {\n if (!this._matchSegment(segment, this.path[pathIdx], pathIdx === this.path.length - 1)) {\n return false;\n }\n pathIdx--;\n segIdx--;\n }\n }\n\n return segIdx < 0;\n }\n\n /\n @private\n /\n _matchSegment(segment, node, isCurrentNode) {\n if (segment.tag !== '' && segment.tag !== node.tag) {\n return false;\n }\n\n if (segment.namespace !== undefined) {\n if (segment.namespace !== '' && segment.namespace !== node.namespace) {\n return false;\n }\n }\n\n if (segment.attrName !== undefined) {\n if (!isCurrentNode) {\n return false;\n }\n\n if (!node.values \|\| !(segment.attrName in node.values)) {\n return false;\n }\n\n if (segment.attrValue !== undefined) {\n if (String(node.values[segment.attrName]) !== String(segment.attrValue)) {\n return false;\n }\n }\n }\n\n if (segment.position !== undefined) {\n if (!isCurrentNode) {\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' && counter !== segment.positionValue) {\n return false;\n }\n }\n\n return true;\n }\n\n /\n Match any expression in the given set against the current path.\n * @param {ExpressionSet} exprSet\n * @returns {boolean}\n /\n matchesAny(exprSet) {\n return exprSet.matchesAny(this);\n }\n\n /\n Create a snapshot of current state.\n * @returns {Object}\n /\n snapshot() {\n return {\n path: this.path.map(node => ({ ...node })),\n siblingStacks: this.siblingStacks.map(level => level ? { counts: new Map(level.counts), total: level.total } : level),\n keptAttrs: this._keptAttrs.map(entry => ({ ...entry }))\n };\n }\n\n /\n Restore state from snapshot.\n * @param {Object} snapshot\n /\n restore(snapshot) {\n this._pathStringCache = null;\n this.path = snapshot.path.map(node => ({ ...node }));\n this.siblingStacks = snapshot.siblingStacks.map(level => level ? { counts: new Map(level.counts), total: level.total } : level);\n this._keptAttrs = (snapshot.keptAttrs \|\| []).map(entry => ({ ...entry }));\n }\n\n /\n Return the read-only {@link MatcherView} for this matcher.\n \n The same instance is returned on every call — no allocation occurs.\n * It always reflects the current parser state and is safe to pass to\n * user callbacks without risk of accidental mutation.\n \n @returns {MatcherView}\n \n @example\n * const view = matcher.readOnly();\n * // pass view to callbacks — it stays in sync automatically\n * view.matches(expr); // ✓\n * view.getCurrentTag(); // ✓\n * // view.push(...) // ✗ method does not exist — caught by TypeScript\n /\n readOnly() {\n return this._view;\n }\n}\n","/\n ExpressionSet - An indexed collection of Expressions for efficient bulk matching\n \n Instead of iterating all expressions on every tag, ExpressionSet pre-indexes\n * them at insertion time by depth and terminal tag name. At match time, only\n * the relevant bucket is evaluated — typically reducing checks from O(E) to O(1)\n * lookup plus O(small bucket) matches.\n \n Three buckets are maintained:\n * - `_byDepthAndTag` — exact depth + exact tag name (tightest, used first)\n * - `_wildcardByDepth` — exact depth + wildcard tag `` (depth-matched only)\n - `_deepWildcards` — expressions containing `..` (cannot be depth-indexed)\n \n @example\n * import { Expression, ExpressionSet } from 'fast-xml-tagger';\n \n // Build once at config time\n * const stopNodes = new ExpressionSet();\n * stopNodes.add(new Expression('root.users.user'));\n * stopNodes.add(new Expression('root.config.setting'));\n * stopNodes.add(new Expression('..script'));\n \n // Query on every tag — hot path\n * if (stopNodes.matchesAny(matcher)) { ... }\n /\nexport default class ExpressionSet {\n constructor() {\n /* @type {Map<string, import('./Expression.js').default[]>} depth:tag → expressions /\n this._byDepthAndTag = new Map();\n\n /* @type {Map<number, import('./Expression.js').default[]>} depth → wildcard-tag expressions /\n this._wildcardByDepth = new Map();\n\n /* @type {import('./Expression.js').default[]} expressions containing deep wildcard (..) /\n this._deepWildcards = [];\n\n /* @type {Map<string, import('./Expression.js').default[]>} terminalTag → deep wildcard expressions /\n this._deepByTerminalTag = new Map();\n\n /* @type {Set<string>} pattern strings already added — used for deduplication /\n this._patterns = new Set();\n\n /* @type {boolean} whether the set is sealed against further additions /\n this._sealed = false;\n }\n\n /\n Add an Expression to the set.\n * Duplicate patterns (same pattern string) are silently ignored.\n \n @param {import('./Expression.js').default} expression - A pre-constructed Expression instance\n * @returns {this} for chaining\n * @throws {TypeError} if called after seal()\n \n @example\n * set.add(new Expression('root.users.user'));\n * set.add(new Expression('..script'));\n /\n add(expression) {\n if (this._sealed) {\n throw new TypeError(\n 'ExpressionSet is sealed. Create a new ExpressionSet to add more expressions.'\n );\n }\n\n // Deduplicate by pattern string\n if (this._patterns.has(expression.pattern)) return this;\n this._patterns.add(expression.pattern);\n\n if (expression.hasDeepWildcard()) {\n const lastSeg = expression.segments[expression.segments.length - 1];\n if (lastSeg && lastSeg.type !== 'deep-wildcard' && lastSeg.tag !== '') {\n const tag = lastSeg.tag;\n if (!this._deepByTerminalTag.has(tag)) this._deepByTerminalTag.set(tag, []);\n this._deepByTerminalTag.get(tag).push(expression);\n } else {\n this._deepWildcards.push(expression);\n }\n return this;\n }\n\n const depth = expression.length;\n const lastSeg = expression.segments[expression.segments.length - 1];\n const tag = lastSeg?.tag;\n\n if (!tag \|\| tag === '') {\n // Can index by depth but not by tag\n if (!this._wildcardByDepth.has(depth)) this._wildcardByDepth.set(depth, []);\n this._wildcardByDepth.get(depth).push(expression);\n } else {\n // Tightest bucket: depth + tag\n const key = `${depth}:${tag}`;\n if (!this._byDepthAndTag.has(key)) this._byDepthAndTag.set(key, []);\n this._byDepthAndTag.get(key).push(expression);\n }\n\n return this;\n }\n\n /\n Add multiple expressions at once.\n \n @param {import('./Expression.js').default[]} expressions - Array of Expression instances\n * @returns {this} for chaining\n \n @example\n * set.addAll([\n * new Expression('root.users.user'),\n * new Expression('root.config.setting'),\n * ]);\n /\n addAll(expressions) {\n for (const expr of expressions) this.add(expr);\n return this;\n }\n\n /\n Check whether a pattern string is already present in the set.\n \n @param {import('./Expression.js').default} expression\n * @returns {boolean}\n /\n has(expression) {\n return this._patterns.has(expression.pattern);\n }\n\n /\n Number of expressions in the set.\n * @type {number}\n /\n get size() {\n return this._patterns.size;\n }\n\n /\n Seal the set against further modifications.\n * Useful to prevent accidental mutations after config is built.\n * Calling add() or addAll() on a sealed set throws a TypeError.\n \n @returns {this}\n /\n seal() {\n this._sealed = true;\n return this;\n }\n\n /\n Whether the set has been sealed.\n * @type {boolean}\n /\n get isSealed() {\n return this._sealed;\n }\n\n /\n Test whether the matcher's current path matches any expression in the set.\n \n Evaluation order (cheapest → most expensive):\n * 1. Exact depth + tag bucket — O(1) lookup, typically 0–2 expressions\n * 2. Depth-only wildcard bucket — O(1) lookup, rare\n * 3. Deep-wildcard list — always checked, but usually small\n \n @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)\n * @returns {boolean} true if any expression matches the current path\n \n @example\n * if (stopNodes.matchesAny(matcher)) {\n * // handle stop node\n * }\n /\n matchesAny(matcher) {\n return this.findMatch(matcher) !== null;\n }\n /\n Find and return the first Expression that matches the matcher's current path.\n \n Uses the same evaluation order as matchesAny (cheapest → most expensive):\n * 1. Exact depth + tag bucket\n * 2. Depth-only wildcard bucket\n * 3. Deep-wildcard list\n \n @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)\n * @returns {import('./Expression.js').default \| null} the first matching Expression, or null\n \n @example\n * const expr = stopNodes.findMatch(matcher);\n * if (expr) {\n * // access expr.config, expr.pattern, etc.\n * }\n /\n findMatch(matcher) {\n const depth = matcher.getDepth();\n const tag = matcher.getCurrentTag();\n\n // 1. Tightest bucket — most expressions live here\n const exactKey = `${depth}:${tag}`;\n const exactBucket = this._byDepthAndTag.get(exactKey);\n if (exactBucket) {\n for (let i = 0; i < exactBucket.length; i++) {\n if (matcher.matches(exactBucket[i])) return exactBucket[i];\n }\n }\n\n // 2. Depth-matched wildcard-tag expressions\n const wildcardBucket = this._wildcardByDepth.get(depth);\n if (wildcardBucket) {\n for (let i = 0; i < wildcardBucket.length; i++) {\n if (matcher.matches(wildcardBucket[i])) return wildcardBucket[i];\n }\n }\n\n // 3. Deep wildcards — indexed by terminal tag, then unindexed fallback\n const deepBucket = this._deepByTerminalTag.get(tag);\n if (deepBucket) {\n for (let i = 0; i < deepBucket.length; i++) {\n if (matcher.matches(deepBucket[i])) return deepBucket[i];\n }\n }\n for (let i = 0; i < this._deepWildcards.length; i++) {\n if (matcher.matches(this._deepWildcards[i])) return this._deepWildcards[i];\n }\n\n return null;\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';\nimport { MatcherView } from './Matcher.js';\nimport ExpressionSet from './ExpressionSet.js';\n\nexport { Expression, Matcher, MatcherView, ExpressionSet };\nexport default { Expression, Matcher, MatcherView, ExpressionSet };\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","data","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","MatcherView","matcher","_matcher","getCurrentTag","path","getCurrentNamespace","getAttrValue","values","hasAttr","current","getAnyParentAttr","hasAnyParentAttr","getPosition","getCounter","counter","getIndex","getDepth","includeNamespace","toArray","map","n","matches","expression","matchesAny","exprSet","Matcher","siblingStacks","_pathStringCache","_view","_keptAttrs","tagName","attrValues","currentLevel","level","counts","Map","total","siblingKey","set","node","depth","keep","name","pop","poppedDepth","updateCurrent","kept","sep","result","join","reset","_matchWithDeepWildcard","_matchSimple","_matchSegment","pathIdx","segIdx","nextSeg","found","isCurrentNode","String","snapshot","keptAttrs","entry","restore","readOnly","ExpressionSet","_byDepthAndTag","_wildcardByDepth","_deepWildcards","_deepByTerminalTag","_patterns","Set","_sealed","add","TypeError","has","lastSeg","addAll","expressions","expr","size","seal","isSealed","findMatch","exactKey","exactBucket","wildcardBucket","deepBucket"],"sourceRoot":""}

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

@@ -1,6 +1,6 @@
 {
   "name": "path-expression-matcher",
-  "version": "1.5.0",
+  "version": "1.6.2",
   "description": "Efficient path tracking and pattern matching for XML/JSON parsers",
   "main": "./lib/pem.cjs",
   "type": "module",
@@ -25,6 +25,7 @@
   },
   "keywords": [
     "xml",
+    "html",
     "json",
     "yaml",
     "path",

package/node_modules/path-expression-matcher/src/ExpressionSet.js CHANGED Viewed

@@ -34,6 +34,9 @@ export default class ExpressionSet {
     /** @type {import('./Expression.js').default[]} expressions containing deep wildcard (..) */
     this._deepWildcards = [];
+    /** @type {Map<string, import('./Expression.js').default[]>} terminalTag → deep wildcard expressions */
+    this._deepByTerminalTag = new Map();
     /** @type {Set<string>} pattern strings already added — used for deduplication */
     this._patterns = new Set();
@@ -65,7 +68,14 @@ export default class ExpressionSet {
     this._patterns.add(expression.pattern);
     if (expression.hasDeepWildcard()) {
-      this._deepWildcards.push(expression);
+      const lastSeg = expression.segments[expression.segments.length - 1];
+      if (lastSeg && lastSeg.type !== 'deep-wildcard' && lastSeg.tag !== '*') {
+        const tag = lastSeg.tag;
+        if (!this._deepByTerminalTag.has(tag)) this._deepByTerminalTag.set(tag, []);
+        this._deepByTerminalTag.get(tag).push(expression);
+      } else {
+        this._deepWildcards.push(expression);
+      }
       return this;
     }
@@ -199,7 +209,13 @@ export default class ExpressionSet {
       }
     }
-    // 3. Deep wildcards — cannot be pre-filtered by depth or tag
+    // 3. Deep wildcards — indexed by terminal tag, then unindexed fallback
+    const deepBucket = this._deepByTerminalTag.get(tag);
+    if (deepBucket) {
+      for (let i = 0; i < deepBucket.length; i++) {
+        if (matcher.matches(deepBucket[i])) return deepBucket[i];
+      }
+    }
     for (let i = 0; i < this._deepWildcards.length; i++) {
       if (matcher.matches(this._deepWildcards[i])) return this._deepWildcards[i];
     }

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

@@ -76,6 +76,26 @@ export class MatcherView {
     return current.values !== undefined && attrName in current.values;
   }
+  /**
+   * Get the value of a "kept" attribute from the nearest ancestor (or
+   * current node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.
+   * @param {string} attrName
+   * @returns {*}
+   */
+  getAnyParentAttr(attrName) {
+    return this._matcher.getAnyParentAttr(attrName);
+  }
+  /**
+   * Check whether any ancestor (or the current node) kept the given
+   * attribute via `push(tag, attrs, ns, { keep: [...] })`.
+   * @param {string} attrName
+   * @returns {boolean}
+   */
+  hasAnyParentAttr(attrName) {
+    return this._matcher.hasAnyParentAttr(attrName);
+  }
   /**
    * Get current node's sibling position (child index in parent).
    * @returns {number}
@@ -184,6 +204,9 @@ export default class Matcher {
     // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level
     this._pathStringCache = null;
     this._view = new MatcherView(this);
+    // Kept-attribute stack: only populated when push() is called with options.keep.
+    this._keptAttrs = [];
   }
   /**
@@ -191,8 +214,10 @@ export default class Matcher {
    * @param {string} tagName
    * @param {Object|null} [attrValues=null]
    * @param {string|null} [namespace=null]
+   * @param {Object|null} [options=null]
+   * @param {string[]} [options.keep] - Names of attributes (from attrValues)
    */
-  push(tagName, attrValues = null, namespace = null) {
+  push(tagName, attrValues = null, namespace = null, options = null) {
     this._pathStringCache = null;
     // Remove values from previous current node (now becoming ancestor)
@@ -202,26 +227,29 @@ export default class Matcher {
     // Get or create sibling tracking for current level
     const currentLevel = this.path.length;
-    if (!this.siblingStacks[currentLevel]) {
-      this.siblingStacks[currentLevel] = new Map();
+    let level = this.siblingStacks[currentLevel];
+    if (!level) {
+      // `counts` tells same-name siblings apart (the "counter" — nth <item>
+      // among other <item>s). `total` is every child seen at this level so
+      // far, kept as a running number instead of re-added from `counts` on
+      // every push — a parent with many differently-named children would
+      // otherwise cost more per child the more distinct names it has.
+      level = { counts: new Map(), total: 0 };
+      this.siblingStacks[currentLevel] = level;
     }
-    const siblings = this.siblingStacks[currentLevel];
     // Create a unique key for sibling tracking that includes namespace
     const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;
     // Calculate counter (how many times this tag appeared at this level)
-    const counter = siblings.get(siblingKey) || 0;
+    const counter = level.counts.get(siblingKey) || 0;
-    // Calculate position (total children at this level so far)
-    let position = 0;
-    for (const count of siblings.values()) {
-      position += count;
-    }
+    // Position = total children at this level seen before this one.
+    const position = level.total;
-    // Update sibling count for this tag
-    siblings.set(siblingKey, counter + 1);
+    // Update sibling count for this tag, and the level's running total.
+    level.counts.set(siblingKey, counter + 1);
+    level.total++;
     // Create new node
     const node = {
@@ -239,6 +267,24 @@ export default class Matcher {
     }
     this.path.push(node);
+    // Depth of the node we just pushed (1-based, matches this.path.length)
+    const depth = this.path.length;
+    // Copy only the requested attributes into the kept-attrs stack. This is
+    // the one part of push() whose cost scales with input (O(keep.length))
+    // rather than being O(1) — by design, since the caller is explicitly
+    // opting in for specific attribute names. No options/keep => zero added
+    // cost beyond the two property reads below.
+    const keep = options !== null ? options.keep : null;
+    if (keep !== null && keep !== undefined && keep.length > 0 && attrValues) {
+      for (let i = 0; i < keep.length; i++) {
+        const name = keep[i];
+        if (attrValues[name] !== undefined) {
+          this._keptAttrs.push({ depth, name, value: attrValues[name] });
+        }
+      }
+    }
   }
   /**
@@ -255,6 +301,18 @@ export default class Matcher {
       this.siblingStacks.length = this.path.length + 1;
     }
+    // Drop any kept attributes that belonged to the popped node (or deeper).
+    // _keptAttrs is depth-ordered (push only ever appends increasing depths),
+    // so this is a backward scan that stops at the first surviving entry —
+    // typically O(1) since kept attrs are rare by design.
+    const poppedDepth = this.path.length + 1;
+    while (
+      this._keptAttrs.length > 0 &&
+      this._keptAttrs[this._keptAttrs.length - 1].depth >= poppedDepth
+    ) {
+      this._keptAttrs.pop();
+    }
     return node;
   }
@@ -309,6 +367,38 @@ export default class Matcher {
     return current.values !== undefined && attrName in current.values;
   }
+  /**
+   * Get the value of a "kept" attribute from the nearest ancestor (or
+   * current node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.
+   * Unlike getAttrValue(), this works regardless of how deep the path has
+   * gone since the attribute was pushed — but only for attribute names that
+   * were explicitly marked with `keep` at push time. Cost is proportional to
+   * the number of currently-kept attributes (typically 0-3), not path depth.
+   * @param {string} attrName
+   * @returns {*} the value, or undefined if no ancestor kept this attribute
+   */
+  getAnyParentAttr(attrName) {
+    const kept = this._keptAttrs;
+    for (let i = kept.length - 1; i >= 0; i--) {
+      if (kept[i].name === attrName) return kept[i].value;
+    }
+    return undefined;
+  }
+  /**
+   * Check whether any ancestor (or the current node) kept the given
+   * attribute via `push(tag, attrs, ns, { keep: [...] })`.
+   * @param {string} attrName
+   * @returns {boolean}
+   */
+  hasAnyParentAttr(attrName) {
+    const kept = this._keptAttrs;
+    for (let i = kept.length - 1; i >= 0; i--) {
+      if (kept[i].name === attrName) return true;
+    }
+    return false;
+  }
   /**
    * Get current node's sibling position (child index in parent).
    * @returns {number}
@@ -385,6 +475,7 @@ export default class Matcher {
     this._pathStringCache = null;
     this.path = [];
     this.siblingStacks = [];
+    this._keptAttrs = [];
   }
   /**
@@ -534,7 +625,8 @@ export default class Matcher {
   snapshot() {
     return {
       path: this.path.map(node => ({ ...node })),
-      siblingStacks: this.siblingStacks.map(map => new Map(map))
+      siblingStacks: this.siblingStacks.map(level => level ? { counts: new Map(level.counts), total: level.total } : level),
+      keptAttrs: this._keptAttrs.map(entry => ({ ...entry }))
     };
   }
@@ -545,7 +637,8 @@ export default class Matcher {
   restore(snapshot) {
     this._pathStringCache = null;
     this.path = snapshot.path.map(node => ({ ...node }));
-    this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));
+    this.siblingStacks = snapshot.siblingStacks.map(level => level ? { counts: new Map(level.counts), total: level.total } : level);
+    this._keptAttrs = (snapshot.keptAttrs || []).map(entry => ({ ...entry }));
   }
   /**
@@ -567,4 +660,4 @@ export default class Matcher {
   readOnly() {
     return this._view;
   }
-}
+}

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

@@ -186,6 +186,42 @@ export interface MatcherSnapshot {
    * Copy of sibling tracking maps
    */
   siblingStacks: Map<string, number>[];
+  /**
+   * Copy of the kept-attrs stack (see {@link PushOptions.keep})
+   */
+  keptAttrs: KeptAttrEntry[];
+}
+/**
+ * A single entry in the matcher's kept-attrs stack — an attribute value
+ * explicitly retained at push time via `{ keep: [...] }` so it remains
+ * reachable from descendants after the owning node is no longer current.
+ */
+export interface KeptAttrEntry {
+  /** Path depth (1-based) of the node that declared this kept attribute */
+  depth: number;
+  /** Attribute name */
+  name: string;
+  /** Attribute value at push time */
+  value: any;
+}
+/**
+ * Options for {@link Matcher#push}
+ */
+export interface PushOptions {
+  /**
+   * Names of attributes (from `attrValues`) to retain for ancestor lookup
+   * (`getAnyParentAttr` / `hasAnyParentAttr`) even after this node is no
+   * longer the current node.
+   *
+   * Use sparingly — this is for attributes you know you'll need much deeper
+   * in the tree (e.g. `xml:space`, a SOAP envelope's `version`), not a
+   * general substitute for `getAttrValue()`. Cost is proportional to
+   * `keep.length`, independent of path depth.
+   */
+  keep?: string[];
 }
 /**
@@ -227,6 +263,16 @@ export class MatcherView {
   getCurrentNamespace(): string | undefined;
   getAttrValue(attrName: string): any;
   hasAttr(attrName: string): boolean;
+  /**
+   * Get the value of a "kept" attribute from the nearest ancestor (or current
+   * node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.
+   */
+  getAnyParentAttr(attrName: string): any;
+  /**
+   * Check whether any ancestor (or the current node) kept the given
+   * attribute via `push(tag, attrs, ns, { keep: [...] })`.
+   */
+  hasAnyParentAttr(attrName: string): boolean;
   getPosition(): number;
   getCounter(): number;
   /** @deprecated Use getPosition() or getCounter() instead */
@@ -285,15 +331,23 @@ export class Matcher {
    * @param tagName - Name of the tag
    * @param attrValues - Attribute key-value pairs for current node (optional)
    * @param namespace - Namespace for the tag (optional)
+   * @param options - Push options, e.g. `{ keep: ['version'] }` to retain
+   *   specific attributes for ancestor lookup after this node stops being current
    *
    * @example
    * ```typescript
    * matcher.push("user", { id: "123", type: "admin" });
    * matcher.push("user", { id: "456" }, "ns");
    * matcher.push("container", null);
+   * matcher.push("Body", { version: "1.1" }, "soap", { keep: ["version"] });
    * ```
    */
-  push(tagName: string, attrValues?: Record<string, any> | null, namespace?: string | null): void;
+  push(
+    tagName: string,
+    attrValues?: Record<string, any> | null,
+    namespace?: string | null,
+    options?: PushOptions | null
+  ): void;
   /**
    * Pop the last tag from the path.
@@ -329,6 +383,18 @@ export class Matcher {
   getCurrentNamespace(): string | undefined;
   getAttrValue(attrName: string): any;
   hasAttr(attrName: string): boolean;
+  /**
+   * Get the value of a "kept" attribute from the nearest ancestor (or current
+   * node) that declared it via `push(tag, attrs, ns, { keep: [...] })`.
+   * Cost is proportional to the number of currently-kept attributes, not
+   * path depth.
+   */
+  getAnyParentAttr(attrName: string): any;
+  /**
+   * Check whether any ancestor (or the current node) kept the given
+   * attribute via `push(tag, attrs, ns, { keep: [...] })`.
+   */
+  hasAnyParentAttr(attrName: string): boolean;
   getPosition(): number;
   getCounter(): number;
   /** @deprecated Use getPosition() or getCounter() instead */

package/node_modules/path-expression-matcher/src/index.js CHANGED Viewed

@@ -23,7 +23,8 @@
 import Expression from './Expression.js';
 import Matcher from './Matcher.js';
+import { MatcherView } from './Matcher.js';
 import ExpressionSet from './ExpressionSet.js';
-export { Expression, Matcher, ExpressionSet };
-export default { Expression, Matcher, ExpressionSet };
+export { Expression, Matcher, MatcherView, ExpressionSet };
+export default { Expression, Matcher, MatcherView, ExpressionSet };

package/node_modules/strnum/CHANGELOG.md CHANGED Viewed

@@ -1,4 +1,12 @@
+**2.4.0 / 2026-06-09**
+- support unicode numerals using 'anynum'
+**2.3.0 / 2026-05-07**
+- support octal and binary, test with @byspec/numbers
+- test with @byspec/numbers
 **2.2.3 / 2026-04-07**
 - remove unnecessary files from npm package