@cdk8s/awscdk-resolver 0.0.532 → 0.0.534

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

@@ -15,11 +15,11 @@ export default class Expression {
    * @param {Object} options - Configuration options
    * @param {string} options.separator - Path separator (default: '.')
    */
-  constructor(pattern, options = {}) {
+  constructor(pattern, options = {}, data) {
     this.pattern = pattern;
     this.separator = options.separator || '.';
     this.segments = this._parse(pattern);
-
+    this.data = data;
     // Cache expensive checks for performance (O(1) instead of O(n))
     this._hasDeepWildcard = this.segments.some(seg => seg.type === 'deep-wildcard');
     this._hasAttributeCondition = this.segments.some(seg => seg.attrName !== undefined);

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

@@ -0,0 +1,209 @@
+/**
+ * ExpressionSet - An indexed collection of Expressions for efficient bulk matching
+ *
+ * Instead of iterating all expressions on every tag, ExpressionSet pre-indexes
+ * them at insertion time by depth and terminal tag name. At match time, only
+ * the relevant bucket is evaluated — typically reducing checks from O(E) to O(1)
+ * lookup plus O(small bucket) matches.
+ *
+ * Three buckets are maintained:
+ *  - `_byDepthAndTag`  — exact depth + exact tag name  (tightest, used first)
+ *  - `_wildcardByDepth` — exact depth + wildcard tag `*` (depth-matched only)
+ *  - `_deepWildcards`  — expressions containing `..`  (cannot be depth-indexed)
+ *
+ * @example
+ * import { Expression, ExpressionSet } from 'fast-xml-tagger';
+ *
+ * // Build once at config time
+ * const stopNodes = new ExpressionSet();
+ * stopNodes.add(new Expression('root.users.user'));
+ * stopNodes.add(new Expression('root.config.setting'));
+ * stopNodes.add(new Expression('..script'));
+ *
+ * // Query on every tag — hot path
+ * if (stopNodes.matchesAny(matcher)) { ... }
+ */
+export default class ExpressionSet {
+  constructor() {
+    /** @type {Map<string, import('./Expression.js').default[]>} depth:tag → expressions */
+    this._byDepthAndTag = new Map();
+
+    /** @type {Map<number, import('./Expression.js').default[]>} depth → wildcard-tag expressions */
+    this._wildcardByDepth = new Map();
+
+    /** @type {import('./Expression.js').default[]} expressions containing deep wildcard (..) */
+    this._deepWildcards = [];
+
+    /** @type {Set<string>} pattern strings already added — used for deduplication */
+    this._patterns = new Set();
+
+    /** @type {boolean} whether the set is sealed against further additions */
+    this._sealed = false;
+  }
+
+  /**
+   * Add an Expression to the set.
+   * Duplicate patterns (same pattern string) are silently ignored.
+   *
+   * @param {import('./Expression.js').default} expression - A pre-constructed Expression instance
+   * @returns {this} for chaining
+   * @throws {TypeError} if called after seal()
+   *
+   * @example
+   * set.add(new Expression('root.users.user'));
+   * set.add(new Expression('..script'));
+   */
+  add(expression) {
+    if (this._sealed) {
+      throw new TypeError(
+        'ExpressionSet is sealed. Create a new ExpressionSet to add more expressions.'
+      );
+    }
+
+    // Deduplicate by pattern string
+    if (this._patterns.has(expression.pattern)) return this;
+    this._patterns.add(expression.pattern);
+
+    if (expression.hasDeepWildcard()) {
+      this._deepWildcards.push(expression);
+      return this;
+    }
+
+    const depth = expression.length;
+    const lastSeg = expression.segments[expression.segments.length - 1];
+    const tag = lastSeg?.tag;
+
+    if (!tag || tag === '*') {
+      // Can index by depth but not by tag
+      if (!this._wildcardByDepth.has(depth)) this._wildcardByDepth.set(depth, []);
+      this._wildcardByDepth.get(depth).push(expression);
+    } else {
+      // Tightest bucket: depth + tag
+      const key = `${depth}:${tag}`;
+      if (!this._byDepthAndTag.has(key)) this._byDepthAndTag.set(key, []);
+      this._byDepthAndTag.get(key).push(expression);
+    }
+
+    return this;
+  }
+
+  /**
+   * Add multiple expressions at once.
+   *
+   * @param {import('./Expression.js').default[]} expressions - Array of Expression instances
+   * @returns {this} for chaining
+   *
+   * @example
+   * set.addAll([
+   *   new Expression('root.users.user'),
+   *   new Expression('root.config.setting'),
+   * ]);
+   */
+  addAll(expressions) {
+    for (const expr of expressions) this.add(expr);
+    return this;
+  }
+
+  /**
+   * Check whether a pattern string is already present in the set.
+   *
+   * @param {import('./Expression.js').default} expression
+   * @returns {boolean}
+   */
+  has(expression) {
+    return this._patterns.has(expression.pattern);
+  }
+
+  /**
+   * Number of expressions in the set.
+   * @type {number}
+   */
+  get size() {
+    return this._patterns.size;
+  }
+
+  /**
+   * Seal the set against further modifications.
+   * Useful to prevent accidental mutations after config is built.
+   * Calling add() or addAll() on a sealed set throws a TypeError.
+   *
+   * @returns {this}
+   */
+  seal() {
+    this._sealed = true;
+    return this;
+  }
+
+  /**
+   * Whether the set has been sealed.
+   * @type {boolean}
+   */
+  get isSealed() {
+    return this._sealed;
+  }
+
+  /**
+   * Test whether the matcher's current path matches any expression in the set.
+   *
+   * Evaluation order (cheapest → most expensive):
+   *  1. Exact depth + tag bucket  — O(1) lookup, typically 0–2 expressions
+   *  2. Depth-only wildcard bucket — O(1) lookup, rare
+   *  3. Deep-wildcard list         — always checked, but usually small
+   *
+   * @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)
+   * @returns {boolean} true if any expression matches the current path
+   *
+   * @example
+   * if (stopNodes.matchesAny(matcher)) {
+   *   // handle stop node
+   * }
+   */
+  matchesAny(matcher) {
+    return this.findMatch(matcher) !== null;
+  }
+  /**
+ * Find and return the first Expression that matches the matcher's current path.
+ *
+ * Uses the same evaluation order as matchesAny (cheapest → most expensive):
+ *  1. Exact depth + tag bucket
+ *  2. Depth-only wildcard bucket
+ *  3. Deep-wildcard list
+ *
+ * @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)
+ * @returns {import('./Expression.js').default | null} the first matching Expression, or null
+ *
+ * @example
+ * const expr = stopNodes.findMatch(matcher);
+ * if (expr) {
+ *   // access expr.config, expr.pattern, etc.
+ * }
+ */
+  findMatch(matcher) {
+    const depth = matcher.getDepth();
+    const tag = matcher.getCurrentTag();
+
+    // 1. Tightest bucket — most expressions live here
+    const exactKey = `${depth}:${tag}`;
+    const exactBucket = this._byDepthAndTag.get(exactKey);
+    if (exactBucket) {
+      for (let i = 0; i < exactBucket.length; i++) {
+        if (matcher.matches(exactBucket[i])) return exactBucket[i];
+      }
+    }
+
+    // 2. Depth-matched wildcard-tag expressions
+    const wildcardBucket = this._wildcardByDepth.get(depth);
+    if (wildcardBucket) {
+      for (let i = 0; i < wildcardBucket.length; i++) {
+        if (matcher.matches(wildcardBucket[i])) return wildcardBucket[i];
+      }
+    }
+
+    // 3. Deep wildcards — cannot be pre-filtered by depth or tag
+    for (let i = 0; i < this._deepWildcards.length; i++) {
+      if (matcher.matches(this._deepWildcards[i])) return this._deepWildcards[i];
+    }
+
+    return null;
+  }
+}

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

@@ -1,3 +1,4 @@
+import ExpressionSet from "./ExpressionSet.js";
 /**
  * Matcher - Tracks current path in XML/JSON tree and matches against Expressions
  * 
@@ -35,6 +36,9 @@ export default class Matcher {
     // Each path node: { tag: string, values: object, position: number, counter: number }
     // values only present for current (last) node
     // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level
+    this._pathStringCache = null;
+    this._frozenPathCache = null;        // cache for readOnly().path
+    this._frozenSiblingsCache = null;   // cache for readOnly().siblingStacks
   }
 
   /**
@@ -44,6 +48,10 @@ export default class Matcher {
    * @param {string} namespace - Namespace for the tag (optional)
    */
   push(tagName, attrValues = null, namespace = null) {
+    //invalidate cache
+    this._pathStringCache = null;
+    this._frozenPathCache = null;
+    this._frozenSiblingsCache = null;
     // Remove values from previous current node (now becoming ancestor)
     if (this.path.length > 0) {
       const prev = this.path[this.path.length - 1];
@@ -98,10 +106,11 @@ export default class Matcher {
    * @returns {Object|undefined} The popped node
    */
   pop() {
-    if (this.path.length === 0) {
-      return undefined;
-    }
-
+    if (this.path.length === 0) return undefined;
+    //invalidate cache
+    this._pathStringCache = null;
+    this._frozenPathCache = null;
+    this._frozenSiblingsCache = null;
     const node = this.path.pop();
 
     // Clean up sibling tracking for levels deeper than current
@@ -124,6 +133,7 @@ export default class Matcher {
       const current = this.path[this.path.length - 1];
       if (attrValues !== null && attrValues !== undefined) {
         current.values = attrValues;
+        this._frozenPathCache = null;
       }
     }
   }
@@ -209,12 +219,23 @@ export default class Matcher {
    */
   toString(separator, includeNamespace = true) {
     const sep = separator || this.separator;
-    return this.path.map(n => {
-      if (includeNamespace && n.namespace) {
-        return `${n.namespace}:${n.tag}`;
+    const isDefault = (sep === this.separator && includeNamespace === true);
+
+    if (isDefault) {
+      if (this._pathStringCache !== null && this._pathStringCache !== undefined) {
+        return this._pathStringCache;
       }
-      return n.tag;
-    }).join(sep);
+      const result = this.path.map(n =>
+        (includeNamespace && n.namespace) ? `${n.namespace}:${n.tag}` : n.tag
+      ).join(sep);
+      this._pathStringCache = result;
+      return result;
+    }
+
+    // Non-default separator or includeNamespace=false: don't cache (rare case)
+    return this.path.map(n =>
+      (includeNamespace && n.namespace) ? `${n.namespace}:${n.tag}` : n.tag
+    ).join(sep);
   }
 
   /**
@@ -229,6 +250,10 @@ export default class Matcher {
    * Reset the path to empty
    */
   reset() {
+    //invalidate cache
+    this._pathStringCache = null;
+    this._frozenPathCache = null;
+    this._frozenSiblingsCache = null;
     this.path = [];
     this.siblingStacks = [];
   }
@@ -400,6 +425,15 @@ export default class Matcher {
     return true;
   }
 
+  /**
+ * Match any expression in the given set against the current path.
+ * @param {ExpressionSet} exprSet - The set of expressions to match against.
+ * @returns {boolean} - True if any expression in the set matches the current path, false otherwise.
+ */
+  matchesAny(exprSet) {
+    return exprSet.matchesAny(this);
+  }
+
   /**
    * Create a snapshot of current state
    * @returns {Object} State snapshot
@@ -416,6 +450,10 @@ export default class Matcher {
    * @param {Object} snapshot - State snapshot
    */
   restore(snapshot) {
+    //invalidate cache
+    this._pathStringCache = null;
+    this._frozenPathCache = null;
+    this._frozenSiblingsCache = null;
     this.path = snapshot.path.map(node => ({ ...node }));
     this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));
   }
@@ -456,22 +494,28 @@ export default class Matcher {
           };
         }
 
-        const value = Reflect.get(target, prop, receiver);
+        // Return cached frozen copy of path — rebuilt only after push/pop/updateCurrent/reset/restore
+        if (prop === 'path') {
+          if (target._frozenPathCache === null) {
+            target._frozenPathCache = Object.freeze(
+              target.path.map(node => Object.freeze({ ...node }))
+            );
+          }
+          return target._frozenPathCache;
+        }
 
-        // Freeze array/object properties so callers can't mutate internal
-        // state through direct property access (e.g. matcher.path.push(...))
-        if (prop === 'path' || prop === 'siblingStacks') {
-          return Object.freeze(
-            Array.isArray(value)
-              ? value.map(item =>
-                item instanceof Map
-                  ? Object.freeze(new Map(item))   // freeze a copy of each Map
-                  : Object.freeze({ ...item })      // freeze a copy of each node
-              )
-              : value
-          );
+        // Return cached frozen copy of siblingStacks — rebuilt only after push/pop/reset/restore
+        if (prop === 'siblingStacks') {
+          if (target._frozenSiblingsCache === null) {
+            target._frozenSiblingsCache = Object.freeze(
+              target.siblingStacks.map(map => Object.freeze(new Map(map)))
+            );
+          }
+          return target._frozenSiblingsCache;
         }
 
+        const value = Reflect.get(target, prop, receiver);
+
         // Bind methods so `this` inside them still refers to the real Matcher
         if (typeof value === 'function') {
           return value.bind(target);

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

@@ -299,6 +299,14 @@ export interface ReadOnlyMatcher {
    */
   matches(expression: Expression): boolean;
 
+  /**
+ * Test whether the matcher's current path matches **any** expression in the set.
+ *
+ * @param exprSet - A `ExpressionSet` instance
+ * @returns `true` if at least one expression matches the current path
+ */
+  matchesAny(exprSet: ExpressionSet): boolean;
+
   /**
    * Create a snapshot of current state
    * @returns State snapshot that can be restored later
@@ -489,6 +497,30 @@ export class Matcher {
    */
   matches(expression: Expression): boolean;
 
+  /**
+ * Test whether the matcher's current path matches **any** expression in the set.
+ *
+ * Uses the pre-built index to evaluate only the relevant bucket(s):
+ *  1. Exact depth + tag — O(1) lookup
+ *  2. Depth-matched wildcard tag — O(1) lookup
+ *  3. Deep-wildcard expressions — always scanned (typically a small list)
+ *
+ * @param exprSet - A `ExpressionSet` instance
+ * @returns `true` if at least one expression matches the current path
+ *
+ * @example
+ * ```typescript
+ * // Replaces:
+ * // for (const expr of stopNodeExpressions) {
+ * //   if (matcher.matches(expr)) return true;
+ * // }
+ *
+ * if (matcher.matchesAny(stopNodes)) {
+ *   // current tag is a stop node
+ * }
+ * ```
+ */
+  matchesAny(exprSet: ExpressionSet): boolean;
   /**
    * Create a snapshot of current state
    * @returns State snapshot that can be restored later
@@ -508,11 +540,167 @@ export class Matcher {
 }
 
 /**
- * Default export containing both Expression and Matcher
+ * ExpressionSet - An indexed collection of Expressions for efficient bulk matching
+ *
+ * Pre-indexes expressions at insertion time by depth and terminal tag name so
+ * that `matchesAny()` performs an O(1) bucket lookup rather than a full O(E)
+ * linear scan on every tag.
+ *
+ * Three internal buckets are maintained automatically:
+ *  - **exact** — expressions with a fixed depth and a concrete terminal tag
+ *  - **depth-wildcard** — fixed depth but terminal tag is `*`
+ *  - **deep-wildcard** — expressions containing `..` (cannot be depth-indexed)
+ *
+ * @example
+ * ```typescript
+ * import { Expression, ExpressionSet, Matcher } from 'fast-xml-tagger';
+ *
+ * // Build once at config time
+ * const stopNodes = new ExpressionSet();
+ * stopNodes
+ *   .add(new Expression('root.users.user'))
+ *   .add(new Expression('root.config.*'))
+ *   .add(new Expression('..script'))
+ *   .seal(); // prevent accidental mutation during parsing
+ *
+ * // Query on every tag — hot path
+ * if (stopNodes.matchesAny(matcher)) {
+ *   // handle stop node
+ * }
+ * ```
+ */
+export class ExpressionSet {
+  /**
+   * Create an empty ExpressionSet.
+   */
+  constructor();
+
+  /**
+   * Number of expressions currently in the set.
+   */
+  readonly size: number;
+
+  /**
+   * Whether the set has been sealed against further modifications.
+   */
+  readonly isSealed: boolean;
+
+  /**
+   * Add a single Expression to the set.
+   *
+   * Duplicate patterns (same `expression.pattern` string) are silently ignored.
+   *
+   * @param expression - A pre-constructed Expression instance
+   * @returns `this` — for chaining
+   * @throws {TypeError} if the set has been sealed
+   *
+   * @example
+   * ```typescript
+   * set.add(new Expression('root.users.user'));
+   * set.add(new Expression('..script'));
+   * ```
+   */
+  add(expression: Expression): this;
+
+  /**
+   * Add multiple expressions at once.
+   *
+   * @param expressions - Array of Expression instances
+   * @returns `this` — for chaining
+   * @throws {TypeError} if the set has been sealed
+   *
+   * @example
+   * ```typescript
+   * set.addAll([
+   *   new Expression('root.users.user'),
+   *   new Expression('root.config.setting'),
+   * ]);
+   * ```
+   */
+  addAll(expressions: Expression[]): this;
+
+  /**
+   * Check whether an Expression with the same pattern is already present.
+   *
+   * @param expression - Expression to look up
+   * @returns `true` if the pattern was already added
+   */
+  has(expression: Expression): boolean;
+
+  /**
+   * Seal the set against further modifications.
+   *
+   * After calling `seal()`, any call to `add()` or `addAll()` will throw a
+   * `TypeError`. This is useful to prevent accidental mutation once the config
+   * has been fully built and parsing has started.
+   *
+   * @returns `this` — for chaining
+   *
+   * @example
+   * ```typescript
+   * const stopNodes = new ExpressionSet();
+   * stopNodes.addAll(patterns.map(p => new Expression(p))).seal();
+   *
+   * // Later — safe: reads are still allowed
+   * stopNodes.matchesAny(matcher);
+   *
+   * // Later — throws TypeError: ExpressionSet is sealed
+   * stopNodes.add(new Expression('root.extra'));
+   * ```
+   */
+  seal(): this;
+
+  /**
+   * Test whether the matcher's current path matches **any** expression in the set.
+   *
+   * Uses the pre-built index to evaluate only the relevant bucket(s):
+   *  1. Exact depth + tag — O(1) lookup
+   *  2. Depth-matched wildcard tag — O(1) lookup
+   *  3. Deep-wildcard expressions — always scanned (typically a small list)
+   *
+   * @param matcher - A `Matcher` instance or a `ReadOnlyMatcher` view
+   * @returns `true` if at least one expression matches the current path
+   *
+   * @example
+   * ```typescript
+   * // Replaces:
+   * // for (const expr of stopNodeExpressions) {
+   * //   if (matcher.matches(expr)) return true;
+   * // }
+   *
+   * if (stopNodes.matchesAny(matcher)) {
+   *   // current tag is a stop node
+   * }
+   * ```
+   */
+  matchesAny(matcher: Matcher | ReadOnlyMatcher): boolean;
+
+  /**
+   * Find the first expression in the set that matches the matcher's current path.
+   *
+   * Uses the pre-built index to evaluate only the relevant bucket(s):
+   *  1. Exact depth + tag — O(1) lookup
+   *  2. Depth-matched wildcard tag — O(1) lookup
+   *  3. Deep-wildcard expressions — always scanned (typically a small list)
+   *
+   * @param matcher - A `Matcher` instance or a `ReadOnlyMatcher` view
+   * @returns Expression if at least one expression matches the current path
+   *
+   * @example
+   * ```typescript
+   * const node = stopNodes.findMatch(matcher);
+   * ```
+   */
+  findMatch(matcher: Matcher | ReadOnlyMatcher): Expression;
+}
+
+/**
+ * Default export containing Expression, Matcher, and ExpressionSet
  */
 declare const _default: {
   Expression: typeof Expression;
   Matcher: typeof Matcher;
+  ExpressionSet: typeof ExpressionSet;
 };
 
 export default _default;

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

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

package/node_modules/strnum/package.json

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

package/package.json

@@ -42,17 +42,17 @@
     "organization": false
   },
   "devDependencies": {
-    "@cdk8s/projen-common": "0.0.680",
+    "@cdk8s/projen-common": "0.0.681",
     "@stylistic/eslint-plugin": "^2",
     "@types/fs-extra": "^11.0.4",
     "@types/jest": "^27",
     "@types/node": "16.18.78",
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
-    "aws-cdk": "^2.1116.0",
+    "aws-cdk": "^2.1117.0",
     "aws-cdk-lib": "2.195.0",
     "cdk8s": "2.68.91",
-    "cdk8s-cli": "^2.206.0",
+    "cdk8s-cli": "^2.206.2",
     "commit-and-tag-version": "^12",
     "constructs": "10.3.0",
     "eslint": "^9",
@@ -66,7 +66,7 @@
     "jsii-docgen": "^10.5.0",
     "jsii-pacmak": "^1.127.0",
     "jsii-rosetta": "^5",
-    "projen": "^0.99.27",
+    "projen": "^0.99.36",
     "ts-jest": "^27",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
@@ -77,7 +77,7 @@
     "constructs": "^10.3.0"
   },
   "dependencies": {
-    "@aws-sdk/client-cloudformation": "^3.1022.0"
+    "@aws-sdk/client-cloudformation": "^3.1026.0"
   },
   "bundledDependencies": [
     "@aws-sdk/client-cloudformation"
@@ -93,7 +93,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.532",
+  "version": "0.0.534",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [

package/node_modules/@smithy/config-resolver/dist-types/ts3.4/endpointsConfig/NodeUseDualstackEndpointConfigOptions.d.ts

@@ -1,23 +0,0 @@
-import { LoadedConfigSelectors } from "@smithy/node-config-provider";
-/**
- * @internal
- */
-export declare const ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT";
-/**
- * @internal
- */
-export declare const CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint";
-/**
- * @internal
- */
-export declare const DEFAULT_USE_DUALSTACK_ENDPOINT = false;
-/**
- * Don't delete this, used by older clients.
- * @deprecated replaced by nodeDualstackConfigSelectors in newer clients.
- * @internal
- */
-export declare const NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS: LoadedConfigSelectors<boolean>;
-/**
- * @internal
- */
-export declare const nodeDualstackConfigSelectors: LoadedConfigSelectors<boolean | undefined>;