@cdk8s/awscdk-resolver 0.0.510 → 0.0.511

package/.jsii

@@ -7,7 +7,7 @@
     "url": "https://aws.amazon.com"
   },
   "bundled": {
-    "@aws-sdk/client-cloudformation": "^3.1006.0"
+    "@aws-sdk/client-cloudformation": "^3.1007.0"
   },
   "dependencies": {
     "aws-cdk-lib": "^2.195.0",
@@ -4082,6 +4082,6 @@
       "symbolId": "src/resolve:AwsCdkResolver"
     }
   },
-  "version": "0.0.510",
-  "fingerprint": "r1SARvKtJZ2c79HtNn9cY18J9frtvN4QoZ+h7ytxVZ4="
+  "version": "0.0.511",
+  "fingerprint": "QHoVdVCKoozRaal/LJeMeNK582+yRvP46gko8aVA8sQ="
 }

package/lib/resolve.js

@@ -61,5 +61,5 @@ class AwsCdkResolver {
 }
 exports.AwsCdkResolver = AwsCdkResolver;
 _a = JSII_RTTI_SYMBOL_1;
-AwsCdkResolver[_a] = { fqn: "@cdk8s/awscdk-resolver.AwsCdkResolver", version: "0.0.510" };
+AwsCdkResolver[_a] = { fqn: "@cdk8s/awscdk-resolver.AwsCdkResolver", version: "0.0.511" };
 //# sourceMappingURL=data:application/json;base64,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

package/node_modules/@aws-sdk/client-cloudformation/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-cloudformation",
   "description": "AWS SDK for JavaScript Cloudformation Client for Node.js, Browser and React Native",
-  "version": "3.1006.0",
+  "version": "3.1007.0",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
     "build:cjs": "node ../../scripts/compilation/inline client-cloudformation",

package/node_modules/fast-xml-builder/CHANGELOG.md

@@ -0,0 +1,13 @@
+
+
+
+**1.1.2** (2026-03-11)
+- fix typings
+
+**1.1.1** (2026-03-11)
+- upgrade path-expression-matcher to 1.1.3
+
+**1.1.0** (2026-03-10)
+
+- Integrate [path-expression-matcher](https://github.com/NaturalIntelligence/path-expression-matcher)
+

package/node_modules/fast-xml-builder/lib/fxb.d.cts

@@ -157,16 +157,15 @@ type XmlBuilderOptions = {
   oneListGroup?: boolean;
 };
 
-declare class XMLBuilder {
-  constructor(options?: XmlBuilderOptions);
+interface XMLBuilder {
   build(jObj: any): string;
 }
 
-declare namespace fxpBuilder {
-  export {
-    XMLBuilder,
-    XmlBuilderOptions,
-  }
+interface XMLBuilderConstructor {
+  new(options?: XmlBuilderOptions): XMLBuilder;
+  (options?: XmlBuilderOptions): XMLBuilder;
 }
 
-export = fxpBuilder;
+declare const Builder: XMLBuilderConstructor;
+
+export = Builder;

package/node_modules/fast-xml-builder/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-xml-builder",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Build XML from JSON without C/C++ based libraries",
   "main": "./lib/fxb.cjs",
   "type": "module",
@@ -75,6 +75,6 @@
     }
   ],
   "dependencies": {
-    "path-expression-matcher": "^1.1.2"
+    "path-expression-matcher": "^1.1.3"
   }
 }

package/node_modules/fast-xml-builder/src/fxb.d.ts

@@ -156,7 +156,15 @@ export type XmlBuilderOptions = {
   oneListGroup?: boolean;
 };
 
-export class XMLBuilder {
-  constructor(options?: XmlBuilderOptions);
+export interface XMLBuilder {
   build(jObj: any): string;
-}
+}
+
+export interface XMLBuilderConstructor {
+  new(options?: XmlBuilderOptions): XMLBuilder;
+  (options?: XmlBuilderOptions): XMLBuilder;
+}
+
+declare const Builder: XMLBuilderConstructor;
+
+export default Builder;

package/node_modules/path-expression-matcher/lib/pem.cjs

@@ -0,0 +1 @@
+(()=>{"use strict";var t={d:(e,s)=>{for(var i in s)t.o(s,i)&&!t.o(e,i)&&Object.defineProperty(e,i,{enumerable:!0,get:s[i]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r:t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})}},e={};t.r(e),t.d(e,{Expression:()=>s,Matcher:()=>i,default:()=>n});class s{constructor(t,e={}){this.pattern=t,this.separator=e.separator||".",this.segments=this._parse(t),this._hasDeepWildcard=this.segments.some(t=>"deep-wildcard"===t.type),this._hasAttributeCondition=this.segments.some(t=>void 0!==t.attrName),this._hasPositionSelector=this.segments.some(t=>void 0!==t.position)}_parse(t){const e=[];let s=0,i="";for(;s<t.length;)t[s]===this.separator?s+1<t.length&&t[s+1]===this.separator?(i.trim()&&(e.push(this._parseSegment(i.trim())),i=""),e.push({type:"deep-wildcard"}),s+=2):(i.trim()&&e.push(this._parseSegment(i.trim())),i="",s++):(i+=t[s],s++);return i.trim()&&e.push(this._parseSegment(i.trim())),e}_parseSegment(t){const e={type:"tag"};let s=null,i=t;const n=t.match(/^([^\[]+)(\[[^\]]*\])(.*)$/);if(n&&(i=n[1]+n[3],n[2])){const t=n[2].slice(1,-1);t&&(s=t)}let r,a,h=i;if(i.includes("::")){const e=i.indexOf("::");if(r=i.substring(0,e).trim(),h=i.substring(e+2).trim(),!r)throw new Error(`Invalid namespace in pattern: ${t}`)}let o=null;if(h.includes(":")){const t=h.lastIndexOf(":"),e=h.substring(0,t).trim(),s=h.substring(t+1).trim();["first","last","odd","even"].includes(s)||/^nth\(\d+\)$/.test(s)?(a=e,o=s):a=h}else a=h;if(!a)throw new Error(`Invalid segment pattern: ${t}`);if(e.tag=a,r&&(e.namespace=r),s)if(s.includes("=")){const t=s.indexOf("=");e.attrName=s.substring(0,t).trim(),e.attrValue=s.substring(t+1).trim()}else e.attrName=s.trim();if(o){const t=o.match(/^nth\((\d+)\)$/);t?(e.position="nth",e.positionValue=parseInt(t[1],10)):e.position=o}return e}get length(){return this.segments.length}hasDeepWildcard(){return this._hasDeepWildcard}hasAttributeCondition(){return this._hasAttributeCondition}hasPositionSelector(){return this._hasPositionSelector}toString(){return this.pattern}}class i{constructor(t={}){this.separator=t.separator||".",this.path=[],this.siblingStacks=[]}push(t,e=null,s=null){this.path.length>0&&(this.path[this.path.length-1].values=void 0);const i=this.path.length;this.siblingStacks[i]||(this.siblingStacks[i]=new Map);const n=this.siblingStacks[i],r=s?`${s}:${t}`:t,a=n.get(r)||0;let h=0;for(const t of n.values())h+=t;n.set(r,a+1);const o={tag:t,position:h,counter:a};null!=s&&(o.namespace=s),null!=e&&(o.values=e),this.path.push(o)}pop(){if(0===this.path.length)return;const t=this.path.pop();return this.siblingStacks.length>this.path.length+1&&(this.siblingStacks.length=this.path.length+1),t}updateCurrent(t){if(this.path.length>0){const e=this.path[this.path.length-1];null!=t&&(e.values=t)}}getCurrentTag(){return this.path.length>0?this.path[this.path.length-1].tag:void 0}getCurrentNamespace(){return this.path.length>0?this.path[this.path.length-1].namespace:void 0}getAttrValue(t){if(0===this.path.length)return;const e=this.path[this.path.length-1];return e.values?.[t]}hasAttr(t){if(0===this.path.length)return!1;const e=this.path[this.path.length-1];return void 0!==e.values&&t in e.values}getPosition(){return 0===this.path.length?-1:this.path[this.path.length-1].position??0}getCounter(){return 0===this.path.length?-1:this.path[this.path.length-1].counter??0}getIndex(){return this.getPosition()}getDepth(){return this.path.length}toString(t,e=!0){const s=t||this.separator;return this.path.map(t=>e&&t.namespace?`${t.namespace}:${t.tag}`:t.tag).join(s)}toArray(){return this.path.map(t=>t.tag)}reset(){this.path=[],this.siblingStacks=[]}matches(t){const e=t.segments;return 0!==e.length&&(t.hasDeepWildcard()?this._matchWithDeepWildcard(e):this._matchSimple(e))}_matchSimple(t){if(this.path.length!==t.length)return!1;for(let e=0;e<t.length;e++){const s=t[e],i=this.path[e],n=e===this.path.length-1;if(!this._matchSegment(s,i,n))return!1}return!0}_matchWithDeepWildcard(t){let e=this.path.length-1,s=t.length-1;for(;s>=0&&e>=0;){const i=t[s];if("deep-wildcard"===i.type){if(s--,s<0)return!0;const i=t[s];let n=!1;for(let t=e;t>=0;t--){const r=t===this.path.length-1;if(this._matchSegment(i,this.path[t],r)){e=t-1,s--,n=!0;break}}if(!n)return!1}else{const t=e===this.path.length-1;if(!this._matchSegment(i,this.path[e],t))return!1;e--,s--}}return s<0}_matchSegment(t,e,s){if("*"!==t.tag&&t.tag!==e.tag)return!1;if(void 0!==t.namespace&&"*"!==t.namespace&&t.namespace!==e.namespace)return!1;if(void 0!==t.attrName){if(!s)return!1;if(!e.values||!(t.attrName in e.values))return!1;if(void 0!==t.attrValue){const s=e.values[t.attrName];if(String(s)!==String(t.attrValue))return!1}}if(void 0!==t.position){if(!s)return!1;const i=e.counter??0;if("first"===t.position&&0!==i)return!1;if("odd"===t.position&&i%2!=1)return!1;if("even"===t.position&&i%2!=0)return!1;if("nth"===t.position&&i!==t.positionValue)return!1}return!0}snapshot(){return{path:this.path.map(t=>({...t})),siblingStacks:this.siblingStacks.map(t=>new Map(t))}}restore(t){this.path=t.path.map(t=>({...t})),this.siblingStacks=t.siblingStacks.map(t=>new Map(t))}}const n={Expression:s,Matcher:i};module.exports=e})();

package/node_modules/path-expression-matcher/lib/pem.d.cts

@@ -0,0 +1,335 @@
+/**
+ * TypeScript definitions for path-expression-matcher (CommonJS)
+ */
+
+/**
+ * Options for creating an Expression
+ */
+declare interface ExpressionOptions {
+  /**
+   * Path separator character
+   * @default '.'
+   */
+  separator?: string;
+}
+
+/**
+ * Parsed segment from an expression pattern
+ */
+declare interface Segment {
+  /**
+   * Type of segment
+   */
+  type: 'tag' | 'deep-wildcard';
+
+  /**
+   * Tag name (e.g., "user", "*" for wildcard)
+   * Only present when type is 'tag'
+   */
+  tag?: string;
+
+  /**
+   * Namespace prefix (e.g., "ns" in "ns::user")
+   * Only present when namespace is specified
+   */
+  namespace?: string;
+
+  /**
+   * Attribute name to match (e.g., "id" in "user[id]")
+   * Only present when attribute condition exists
+   */
+  attrName?: string;
+
+  /**
+   * Attribute value to match (e.g., "123" in "user[id=123]")
+   * Only present when attribute value is specified
+   */
+  attrValue?: string;
+
+  /**
+   * Position selector type
+   * Only present when position selector exists
+   */
+  position?: 'first' | 'last' | 'odd' | 'even' | 'nth';
+
+  /**
+   * Numeric value for nth() selector
+   * Only present when position is 'nth'
+   */
+  positionValue?: number;
+}
+
+/**
+ * Expression - Parses and stores a tag pattern expression
+ * 
+ * Patterns are parsed once and stored in an optimized structure for fast matching.
+ * 
+ * @example
+ * ```javascript
+ * const { Expression } = require('path-expression-matcher');
+ * const expr = new Expression("root.users.user");
+ * const expr2 = new Expression("..user[id]:first");
+ * ```
+ */
+declare class Expression {
+  /**
+   * Original pattern string
+   */
+  readonly pattern: string;
+
+  /**
+   * Path separator character
+   */
+  readonly separator: string;
+
+  /**
+   * Parsed segments
+   */
+  readonly segments: Segment[];
+
+  /**
+   * Create a new Expression
+   * @param pattern - Pattern string (e.g., "root.users.user", "..user[id]")
+   * @param options - Configuration options
+   */
+  constructor(pattern: string, options?: ExpressionOptions);
+
+  /**
+   * Get the number of segments
+   */
+  get length(): number;
+
+  /**
+   * Check if expression contains deep wildcard (..)
+   */
+  hasDeepWildcard(): boolean;
+
+  /**
+   * Check if expression has attribute conditions
+   */
+  hasAttributeCondition(): boolean;
+
+  /**
+   * Check if expression has position selectors
+   */
+  hasPositionSelector(): boolean;
+
+  /**
+   * Get string representation
+   */
+  toString(): string;
+}
+
+/**
+ * Options for creating a Matcher
+ */
+declare interface MatcherOptions {
+  /**
+   * Default path separator
+   * @default '.'
+   */
+  separator?: string;
+}
+
+/**
+ * Internal node structure in the path stack
+ */
+declare interface PathNode {
+  /**
+   * Tag name
+   */
+  tag: string;
+
+  /**
+   * Namespace (if present)
+   */
+  namespace?: string;
+
+  /**
+   * Position in sibling list (child index in parent)
+   */
+  position: number;
+
+  /**
+   * Counter (occurrence count of this tag name)
+   */
+  counter: number;
+
+  /**
+   * Attribute key-value pairs
+   * Only present for the current (last) node in path
+   */
+  values?: Record<string, any>;
+}
+
+/**
+ * Snapshot of matcher state
+ */
+declare interface MatcherSnapshot {
+  /**
+   * Copy of the path stack
+   */
+  path: PathNode[];
+
+  /**
+   * Copy of sibling tracking maps
+   */
+  siblingStacks: Map<string, number>[];
+}
+
+/**
+ * Matcher - Tracks current path in XML/JSON tree and matches against Expressions
+ * 
+ * The matcher maintains a stack of nodes representing the current path from root to
+ * current tag. It only stores attribute values for the current (top) node to minimize
+ * memory usage.
+ * 
+ * @example
+ * ```javascript
+ * const { Matcher } = require('path-expression-matcher');
+ * const matcher = new Matcher();
+ * matcher.push("root", {});
+ * matcher.push("users", {});
+ * matcher.push("user", { id: "123", type: "admin" });
+ * ```
+ */
+declare class Matcher {
+  /**
+   * Default path separator
+   */
+  readonly separator: string;
+
+  /**
+   * Current path stack
+   */
+  readonly path: PathNode[];
+
+  /**
+   * Create a new Matcher
+   * @param options - Configuration options
+   */
+  constructor(options?: MatcherOptions);
+
+  /**
+   * Push a new tag onto the path
+   * @param tagName - Name of the tag
+   * @param attrValues - Attribute key-value pairs for current node (optional)
+   * @param namespace - Namespace for the tag (optional)
+   */
+  push(tagName: string, attrValues?: Record<string, any> | null, namespace?: string | null): void;
+
+  /**
+   * Pop the last tag from the path
+   * @returns The popped node or undefined if path is empty
+   */
+  pop(): PathNode | undefined;
+
+  /**
+   * Update current node's attribute values
+   * Useful when attributes are parsed after push
+   * @param attrValues - Attribute values
+   */
+  updateCurrent(attrValues: Record<string, any>): void;
+
+  /**
+   * 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[];
+
+  /**
+   * Reset the path to empty
+   */
+  reset(): void;
+
+  /**
+   * 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;
+
+  /**
+   * Restore state from snapshot
+   * @param snapshot - State snapshot from previous snapshot() call
+   */
+  restore(snapshot: MatcherSnapshot): void;
+}
+
+declare namespace pathExpressionMatcher {
+  export {
+    Expression,
+    Matcher,
+    ExpressionOptions,
+    MatcherOptions,
+    Segment,
+    PathNode,
+    MatcherSnapshot,
+  };
+}
+
+export = pathExpressionMatcher;

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

@@ -0,0 +1,2 @@
+!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.pem=e():t.pem=e()}(this,()=>(()=>{"use strict";var t={d:(e,s)=>{for(var i in s)t.o(s,i)&&!t.o(e,i)&&Object.defineProperty(e,i,{enumerable:!0,get:s[i]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r:t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})}},e={};t.r(e),t.d(e,{Expression:()=>s,Matcher:()=>i,default:()=>n});class s{constructor(t,e={}){this.pattern=t,this.separator=e.separator||".",this.segments=this._parse(t),this._hasDeepWildcard=this.segments.some(t=>"deep-wildcard"===t.type),this._hasAttributeCondition=this.segments.some(t=>void 0!==t.attrName),this._hasPositionSelector=this.segments.some(t=>void 0!==t.position)}_parse(t){const e=[];let s=0,i="";for(;s<t.length;)t[s]===this.separator?s+1<t.length&&t[s+1]===this.separator?(i.trim()&&(e.push(this._parseSegment(i.trim())),i=""),e.push({type:"deep-wildcard"}),s+=2):(i.trim()&&e.push(this._parseSegment(i.trim())),i="",s++):(i+=t[s],s++);return i.trim()&&e.push(this._parseSegment(i.trim())),e}_parseSegment(t){const e={type:"tag"};let s=null,i=t;const n=t.match(/^([^\[]+)(\[[^\]]*\])(.*)$/);if(n&&(i=n[1]+n[3],n[2])){const t=n[2].slice(1,-1);t&&(s=t)}let r,a,h=i;if(i.includes("::")){const e=i.indexOf("::");if(r=i.substring(0,e).trim(),h=i.substring(e+2).trim(),!r)throw new Error(`Invalid namespace in pattern: ${t}`)}let o=null;if(h.includes(":")){const t=h.lastIndexOf(":"),e=h.substring(0,t).trim(),s=h.substring(t+1).trim();["first","last","odd","even"].includes(s)||/^nth\(\d+\)$/.test(s)?(a=e,o=s):a=h}else a=h;if(!a)throw new Error(`Invalid segment pattern: ${t}`);if(e.tag=a,r&&(e.namespace=r),s)if(s.includes("=")){const t=s.indexOf("=");e.attrName=s.substring(0,t).trim(),e.attrValue=s.substring(t+1).trim()}else e.attrName=s.trim();if(o){const t=o.match(/^nth\((\d+)\)$/);t?(e.position="nth",e.positionValue=parseInt(t[1],10)):e.position=o}return e}get length(){return this.segments.length}hasDeepWildcard(){return this._hasDeepWildcard}hasAttributeCondition(){return this._hasAttributeCondition}hasPositionSelector(){return this._hasPositionSelector}toString(){return this.pattern}}class i{constructor(t={}){this.separator=t.separator||".",this.path=[],this.siblingStacks=[]}push(t,e=null,s=null){this.path.length>0&&(this.path[this.path.length-1].values=void 0);const i=this.path.length;this.siblingStacks[i]||(this.siblingStacks[i]=new Map);const n=this.siblingStacks[i],r=s?`${s}:${t}`:t,a=n.get(r)||0;let h=0;for(const t of n.values())h+=t;n.set(r,a+1);const o={tag:t,position:h,counter:a};null!=s&&(o.namespace=s),null!=e&&(o.values=e),this.path.push(o)}pop(){if(0===this.path.length)return;const t=this.path.pop();return this.siblingStacks.length>this.path.length+1&&(this.siblingStacks.length=this.path.length+1),t}updateCurrent(t){if(this.path.length>0){const e=this.path[this.path.length-1];null!=t&&(e.values=t)}}getCurrentTag(){return this.path.length>0?this.path[this.path.length-1].tag:void 0}getCurrentNamespace(){return this.path.length>0?this.path[this.path.length-1].namespace:void 0}getAttrValue(t){if(0===this.path.length)return;const e=this.path[this.path.length-1];return e.values?.[t]}hasAttr(t){if(0===this.path.length)return!1;const e=this.path[this.path.length-1];return void 0!==e.values&&t in e.values}getPosition(){return 0===this.path.length?-1:this.path[this.path.length-1].position??0}getCounter(){return 0===this.path.length?-1:this.path[this.path.length-1].counter??0}getIndex(){return this.getPosition()}getDepth(){return this.path.length}toString(t,e=!0){const s=t||this.separator;return this.path.map(t=>e&&t.namespace?`${t.namespace}:${t.tag}`:t.tag).join(s)}toArray(){return this.path.map(t=>t.tag)}reset(){this.path=[],this.siblingStacks=[]}matches(t){const e=t.segments;return 0!==e.length&&(t.hasDeepWildcard()?this._matchWithDeepWildcard(e):this._matchSimple(e))}_matchSimple(t){if(this.path.length!==t.length)return!1;for(let e=0;e<t.length;e++){const s=t[e],i=this.path[e],n=e===this.path.length-1;if(!this._matchSegment(s,i,n))return!1}return!0}_matchWithDeepWildcard(t){let e=this.path.length-1,s=t.length-1;for(;s>=0&&e>=0;){const i=t[s];if("deep-wildcard"===i.type){if(s--,s<0)return!0;const i=t[s];let n=!1;for(let t=e;t>=0;t--){const r=t===this.path.length-1;if(this._matchSegment(i,this.path[t],r)){e=t-1,s--,n=!0;break}}if(!n)return!1}else{const t=e===this.path.length-1;if(!this._matchSegment(i,this.path[e],t))return!1;e--,s--}}return s<0}_matchSegment(t,e,s){if("*"!==t.tag&&t.tag!==e.tag)return!1;if(void 0!==t.namespace&&"*"!==t.namespace&&t.namespace!==e.namespace)return!1;if(void 0!==t.attrName){if(!s)return!1;if(!e.values||!(t.attrName in e.values))return!1;if(void 0!==t.attrValue){const s=e.values[t.attrName];if(String(s)!==String(t.attrValue))return!1}}if(void 0!==t.position){if(!s)return!1;const i=e.counter??0;if("first"===t.position&&0!==i)return!1;if("odd"===t.position&&i%2!=1)return!1;if("even"===t.position&&i%2!=0)return!1;if("nth"===t.position&&i!==t.positionValue)return!1}return!0}snapshot(){return{path:this.path.map(t=>({...t})),siblingStacks:this.siblingStacks.map(t=>new Map(t))}}restore(t){this.path=t.path.map(t=>({...t})),this.siblingStacks=t.siblingStacks.map(t=>new Map(t))}}const n={Expression:s,Matcher:i};return e})());
+//# sourceMappingURL=pem.min.js.map

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

@@ -0,0 +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":""}

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

@@ -1,16 +1,27 @@
 {
   "name": "path-expression-matcher",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Efficient path tracking and pattern matching for XML/JSON parsers",
-  "main": "src/index.js",
+  "main": "./lib/pem.cjs",
   "type": "module",
+  "sideEffects": false,
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
   "exports": {
-    ".": "./src/index.js",
-    "./Expression": "./src/Expression.js",
-    "./Matcher": "./src/Matcher.js"
+    ".": {
+      "import": {
+        "types": "./src/index.d.ts",
+        "default": "./src/index.js"
+      },
+      "require": {
+        "types": "./lib/pem.d.cts",
+        "default": "./lib/pem.cjs"
+      }
+    }
   },
   "scripts": {
-    "test": "node test/namespace_test.js && node test/test.js"
+    "test": "c8 --reporter=lcov --reporter=text node test/namespace_test.js && c8 --reporter=lcov --reporter=text node test/test.js",
+    "bundle": "webpack --config webpack.cjs.config.js"
   },
   "keywords": [
     "xml",
@@ -39,10 +50,25 @@
     "node": ">=14.0.0"
   },
   "files": [
+    "lib",
     "src/",
     "README.md",
     "LICENSE"
   ],
+  "devDependencies": {
+    "@babel/core": "^7.13.10",
+    "@babel/plugin-transform-runtime": "^7.13.10",
+    "@babel/preset-env": "^7.13.10",
+    "@babel/register": "^7.13.8",
+    "@types/node": "20",
+    "babel-loader": "^8.2.2",
+    "c8": "^10.1.3",
+    "eslint": "^8.3.0",
+    "prettier": "^3.5.1",
+    "typescript": "5",
+    "webpack": "^5.64.4",
+    "webpack-cli": "^4.9.1"
+  },
   "funding": [
     {
       "type": "github",

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

@@ -0,0 +1,366 @@
+/**
+ * TypeScript definitions for path-expression-matcher
+ * 
+ * Provides efficient path tracking and pattern matching for XML/JSON parsers.
+ */
+
+/**
+ * Options for creating an Expression
+ */
+export interface ExpressionOptions {
+  /**
+   * Path separator character
+   * @default '.'
+   */
+  separator?: string;
+}
+
+/**
+ * Parsed segment from an expression pattern
+ */
+export interface Segment {
+  /**
+   * Type of segment
+   */
+  type: 'tag' | 'deep-wildcard';
+
+  /**
+   * Tag name (e.g., "user", "*" for wildcard)
+   * Only present when type is 'tag'
+   */
+  tag?: string;
+
+  /**
+   * Namespace prefix (e.g., "ns" in "ns::user")
+   * Only present when namespace is specified
+   */
+  namespace?: string;
+
+  /**
+   * Attribute name to match (e.g., "id" in "user[id]")
+   * Only present when attribute condition exists
+   */
+  attrName?: string;
+
+  /**
+   * Attribute value to match (e.g., "123" in "user[id=123]")
+   * Only present when attribute value is specified
+   */
+  attrValue?: string;
+
+  /**
+   * Position selector type
+   * Only present when position selector exists
+   */
+  position?: 'first' | 'last' | 'odd' | 'even' | 'nth';
+
+  /**
+   * Numeric value for nth() selector
+   * Only present when position is 'nth'
+   */
+  positionValue?: number;
+}
+
+/**
+ * Expression - Parses and stores a tag pattern expression
+ * 
+ * Patterns are parsed once and stored in an optimized structure for fast matching.
+ * 
+ * @example
+ * ```typescript
+ * const expr = new Expression("root.users.user");
+ * const expr2 = new Expression("..user[id]:first");
+ * const expr3 = new Expression("root/users/user", { separator: '/' });
+ * ```
+ * 
+ * Pattern Syntax:
+ * - `root.users.user` - Match exact path
+ * - `..user` - Match "user" at any depth (deep wildcard)
+ * - `user[id]` - Match user tag with "id" attribute
+ * - `user[id=123]` - Match user tag where id="123"
+ * - `user:first` - Match first occurrence of user tag
+ * - `ns::user` - Match user tag with namespace "ns"
+ * - `ns::user[id]:first` - Combine namespace, attribute, and position
+ */
+export class Expression {
+  /**
+   * Original pattern string
+   */
+  readonly pattern: string;
+
+  /**
+   * Path separator character
+   */
+  readonly separator: string;
+
+  /**
+   * Parsed segments
+   */
+  readonly segments: Segment[];
+
+  /**
+   * Create a new Expression
+   * @param pattern - Pattern string (e.g., "root.users.user", "..user[id]")
+   * @param options - Configuration options
+   */
+  constructor(pattern: string, options?: ExpressionOptions);
+
+  /**
+   * Get the number of segments
+   */
+  get length(): number;
+
+  /**
+   * Check if expression contains deep wildcard (..)
+   */
+  hasDeepWildcard(): boolean;
+
+  /**
+   * Check if expression has attribute conditions
+   */
+  hasAttributeCondition(): boolean;
+
+  /**
+   * Check if expression has position selectors
+   */
+  hasPositionSelector(): boolean;
+
+  /**
+   * Get string representation
+   */
+  toString(): string;
+}
+
+/**
+ * Options for creating a Matcher
+ */
+export interface MatcherOptions {
+  /**
+   * Default path separator
+   * @default '.'
+   */
+  separator?: string;
+}
+
+/**
+ * Internal node structure in the path stack
+ */
+export interface PathNode {
+  /**
+   * Tag name
+   */
+  tag: string;
+
+  /**
+   * Namespace (if present)
+   */
+  namespace?: string;
+
+  /**
+   * Position in sibling list (child index in parent)
+   */
+  position: number;
+
+  /**
+   * Counter (occurrence count of this tag name)
+   */
+  counter: number;
+
+  /**
+   * Attribute key-value pairs
+   * Only present for the current (last) node in path
+   */
+  values?: Record<string, any>;
+}
+
+/**
+ * Snapshot of matcher state
+ */
+export interface MatcherSnapshot {
+  /**
+   * Copy of the path stack
+   */
+  path: PathNode[];
+
+  /**
+   * Copy of sibling tracking maps
+   */
+  siblingStacks: Map<string, number>[];
+}
+
+/**
+ * Matcher - Tracks current path in XML/JSON tree and matches against Expressions
+ * 
+ * The matcher maintains a stack of nodes representing the current path from root to
+ * current tag. It only stores attribute values for the current (top) node to minimize
+ * memory usage.
+ * 
+ * @example
+ * ```typescript
+ * const matcher = new Matcher();
+ * matcher.push("root", {});
+ * matcher.push("users", {});
+ * matcher.push("user", { id: "123", type: "admin" });
+ * 
+ * const expr = new Expression("root.users.user");
+ * matcher.matches(expr); // true
+ * 
+ * matcher.pop();
+ * matcher.matches(expr); // false
+ * ```
+ */
+export class Matcher {
+  /**
+   * Default path separator
+   */
+  readonly separator: string;
+
+  /**
+   * Current path stack
+   */
+  readonly path: PathNode[];
+
+  /**
+   * Create a new Matcher
+   * @param options - Configuration options
+   */
+  constructor(options?: MatcherOptions);
+
+  /**
+   * Push a new tag onto the path
+   * @param tagName - Name of the tag
+   * @param attrValues - Attribute key-value pairs for current node (optional)
+   * @param namespace - Namespace for the tag (optional)
+   * 
+   * @example
+   * ```typescript
+   * matcher.push("user", { id: "123", type: "admin" });
+   * matcher.push("user", { id: "456" }, "ns");
+   * matcher.push("container", null);
+   * ```
+   */
+  push(tagName: string, attrValues?: Record<string, any> | null, namespace?: string | null): void;
+
+  /**
+   * Pop the last tag from the path
+   * @returns The popped node or undefined if path is empty
+   */
+  pop(): PathNode | undefined;
+
+  /**
+   * Update current node's attribute values
+   * Useful when attributes are parsed after push
+   * @param attrValues - Attribute values
+   */
+  updateCurrent(attrValues: Record<string, any>): void;
+
+  /**
+   * 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[];
+
+  /**
+   * Reset the path to empty
+   */
+  reset(): void;
+
+  /**
+   * Match current path against an Expression
+   * @param expression - The expression to match against
+   * @returns True if current path matches the expression
+   * 
+   * @example
+   * ```typescript
+   * const expr = new Expression("root.users.user[id]");
+   * const matcher = new Matcher();
+   * 
+   * matcher.push("root");
+   * matcher.push("users");
+   * matcher.push("user", { id: "123" });
+   * 
+   * matcher.matches(expr); // true
+   * ```
+   */
+  matches(expression: Expression): boolean;
+
+  /**
+   * Create a snapshot of current state
+   * @returns State snapshot that can be restored later
+   */
+  snapshot(): MatcherSnapshot;
+
+  /**
+   * Restore state from snapshot
+   * @param snapshot - State snapshot from previous snapshot() call
+   */
+  restore(snapshot: MatcherSnapshot): void;
+}
+
+/**
+ * Default export containing both Expression and Matcher
+ */
+declare const _default: {
+  Expression: typeof Expression;
+  Matcher: typeof Matcher;
+};
+
+export default _default;

package/package.json

@@ -77,7 +77,7 @@
     "constructs": "^10.3.0"
   },
   "dependencies": {
-    "@aws-sdk/client-cloudformation": "^3.1006.0"
+    "@aws-sdk/client-cloudformation": "^3.1007.0"
   },
   "bundledDependencies": [
     "@aws-sdk/client-cloudformation"
@@ -93,7 +93,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.510",
+  "version": "0.0.511",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [