@cdklabs/cdk-ssm-documents 0.0.55 → 0.0.56

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

@@ -189,169 +189,81 @@ export interface MatcherSnapshot {
 }
 
 /**
- * ReadOnlyMatcher - A safe, read-only view over a {@link Matcher} instance.
+ * MatcherView - A lightweight read-only view over a {@link Matcher} instance.
  *
- * Returned by {@link Matcher.readOnly}. Exposes all query and inspection
- * methods but **throws a `TypeError`** if any state-mutating method is called
- * (`push`, `pop`, `reset`, `updateCurrent`, `restore`).  Direct property
- * writes are also blocked.
+ * Created once by {@link Matcher} and reused across all callbacks — no allocation
+ * on every invocation. Holds a direct reference to the parent Matcher's internal
+ * state so it always reflects the current parser position with zero copying or
+ * freezing overhead.
  *
- * Pass this to consumers that only need to inspect or match the current path
- * so they cannot accidentally corrupt the parser state.
+ * Mutation methods (`push`, `pop`, `reset`, `updateCurrent`, `restore`) are simply
+ * absent from this class, so misuse is caught at compile time by TypeScript rather
+ * than at runtime.
+ *
+ * Obtain via {@link Matcher#readOnly} — the same instance is returned every time.
  *
  * @example
  * ```typescript
  * const matcher = new Matcher();
+ * const view: MatcherView = matcher.readOnly();
+ *
  * matcher.push("root", {});
  * matcher.push("users", {});
  * matcher.push("user", { id: "123" });
  *
- * const ro: ReadOnlyMatcher = matcher.readOnly();
- *
- * ro.matches(expr);      // ✓ works
- * ro.getCurrentTag();    // ✓ "user"
- * ro.getDepth();         // ✓ 3
- * ro.push("child", {}); // ✗ TypeError: Cannot call 'push' on a read-only Matcher
- * ro.reset();            // ✗ TypeError: Cannot call 'reset' on a read-only Matcher
+ * view.matches(expr);      // ✓ true
+ * view.getCurrentTag();    // ✓ "user"
+ * view.getDepth();         // ✓ 3
+ * // view.push(...)        // ✗ Property 'push' does not exist on type 'MatcherView'
  * ```
  */
-export interface ReadOnlyMatcher {
+export class MatcherView {
   /**
-   * Default path separator (read-only)
+   * Default path separator (read-only, delegates to parent Matcher)
    */
   readonly separator: string;
 
-  /**
-   * Current path stack (each node is a frozen copy)
-   */
-  readonly path: ReadonlyArray<Readonly<PathNode>>;
-
-  // ── Query methods ───────────────────────────────────────────────────────────
-
-  /**
-   * Get current tag name
-   * @returns Current tag name or undefined if path is empty
-   */
   getCurrentTag(): string | undefined;
-
-  /**
-   * Get current namespace
-   * @returns Current namespace or undefined if not present or path is empty
-   */
   getCurrentNamespace(): string | undefined;
-
-  /**
-   * Get current node's attribute value
-   * @param attrName - Attribute name
-   * @returns Attribute value or undefined
-   */
   getAttrValue(attrName: string): any;
-
-  /**
-   * Check if current node has an attribute
-   * @param attrName - Attribute name
-   */
   hasAttr(attrName: string): boolean;
-
-  /**
-   * Get current node's sibling position (child index in parent)
-   * @returns Position index or -1 if path is empty
-   */
   getPosition(): number;
-
-  /**
-   * Get current node's repeat counter (occurrence count of this tag name)
-   * @returns Counter value or -1 if path is empty
-   */
   getCounter(): number;
-
-  /**
-   * Get current node's sibling index (alias for getPosition for backward compatibility)
-   * @returns Index or -1 if path is empty
-   * @deprecated Use getPosition() or getCounter() instead
-   */
+  /** @deprecated Use getPosition() or getCounter() instead */
   getIndex(): number;
-
-  /**
-   * Get current path depth
-   * @returns Number of nodes in the path
-   */
   getDepth(): number;
-
-  /**
-   * Get path as string
-   * @param separator - Optional separator (uses default if not provided)
-   * @param includeNamespace - Whether to include namespace in output
-   * @returns Path string (e.g., "root.users.user" or "ns:root.ns:users.user")
-   */
   toString(separator?: string, includeNamespace?: boolean): string;
-
-  /**
-   * Get path as array of tag names
-   * @returns Array of tag names
-   */
   toArray(): string[];
-
-  /**
-   * Match current path against an Expression
-   * @param expression - The expression to match against
-   * @returns True if current path matches the expression
-   */
   matches(expression: Expression): boolean;
-
-  /**
-   * Create a snapshot of current state
-   * @returns State snapshot that can be restored later
-   */
-  snapshot(): MatcherSnapshot;
-
-  // ── Blocked mutating methods ────────────────────────────────────────────────
-  // These are present in the type so callers get a compile-time error with a
-  // helpful message instead of a silent "property does not exist" error.
-
-  /**
-   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
-   */
-  push(tagName: string, attrValues?: Record<string, any> | null, namespace?: string | null): never;
-
-  /**
-   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
-   */
-  pop(): never;
-
-  /**
-   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
-   */
-  updateCurrent(attrValues: Record<string, any>): never;
-
-  /**
-   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
-   */
-  reset(): never;
-
-  /**
-   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
-   */
-  restore(snapshot: MatcherSnapshot): never;
+  matchesAny(exprSet: ExpressionSet): boolean;
 }
 
 /**
- * Matcher - Tracks current path in XML/JSON tree and matches against Expressions
- * 
+ * @deprecated Use {@link MatcherView} instead.
+ * Alias kept for backward compatibility with code that references `ReadOnlyMatcher`.
+ */
+export type ReadOnlyMatcher = MatcherView;
+
+/**
+ * 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.
- * 
+ *
+ * Use {@link Matcher#readOnly} to obtain a {@link MatcherView} safe to pass to
+ * user callbacks — the same instance is reused on every call with no allocation overhead.
+ *
  * @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
  * ```
@@ -362,11 +274,6 @@ export class Matcher {
    */
   readonly separator: string;
 
-  /**
-   * Current path stack
-   */
-  readonly path: PathNode[];
-
   /**
    * Create a new Matcher
    * @param options - Configuration options
@@ -374,11 +281,11 @@ export class Matcher {
   constructor(options?: MatcherOptions);
 
   /**
-   * Push a new tag onto the path
+   * 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" });
@@ -389,130 +296,228 @@ export class Matcher {
   push(tagName: string, attrValues?: Record<string, any> | null, namespace?: string | null): void;
 
   /**
-   * Pop the last tag from the path
+   * 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
+   * 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
+   * Reset the path to empty.
    */
-  getCurrentTag(): string | undefined;
+  reset(): void;
 
   /**
-   * Get current namespace
-   * @returns Current namespace or undefined if not present or path is empty
+   * Create a snapshot of current state.
+   * @returns State snapshot that can be restored later
    */
-  getCurrentNamespace(): string | undefined;
+  snapshot(): MatcherSnapshot;
 
   /**
-   * Get current node's attribute value
-   * @param attrName - Attribute name
-   * @returns Attribute value or undefined
+   * Restore state from snapshot.
+   * @param snapshot - State snapshot from previous snapshot() call
    */
-  getAttrValue(attrName: string): any;
+  restore(snapshot: MatcherSnapshot): void;
 
-  /**
-   * Check if current node has an attribute
-   * @param attrName - Attribute name
-   */
+  getCurrentTag(): string | undefined;
+  getCurrentNamespace(): string | undefined;
+  getAttrValue(attrName: string): any;
   hasAttr(attrName: string): boolean;
+  getPosition(): number;
+  getCounter(): number;
+  /** @deprecated Use getPosition() or getCounter() instead */
+  getIndex(): number;
+  getDepth(): number;
+  toString(separator?: string, includeNamespace?: boolean): string;
+  toArray(): string[];
+  matches(expression: Expression): boolean;
+  matchesAny(exprSet: ExpressionSet): boolean;
 
   /**
-   * Get current node's sibling position (child index in parent)
-   * @returns Position index or -1 if path is empty
+   * Return the read-only {@link MatcherView} for this matcher.
+   *
+   * The same instance is returned on every call — no allocation occurs.
+   * Pass this to user callbacks; it always reflects current parser state.
+   *
+   * @example
+   * ```typescript
+   * const view = matcher.readOnly();
+   * // same reference every time — safe to cache
+   * view === matcher.readOnly(); // true
+   * ```
    */
-  getPosition(): number;
+  readOnly(): MatcherView;
+}
 
+/**
+ * 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 {
   /**
-   * Get current node's repeat counter (occurrence count of this tag name)
-   * @returns Counter value or -1 if path is empty
+   * Create an empty ExpressionSet.
    */
-  getCounter(): number;
+  constructor();
 
   /**
-   * 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
+   * Number of expressions currently in the set.
    */
-  getIndex(): number;
+  readonly size: number;
 
   /**
-   * Get current path depth
-   * @returns Number of nodes in the path
+   * Whether the set has been sealed against further modifications.
    */
-  getDepth(): number;
+  readonly isSealed: boolean;
 
   /**
-   * 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")
+   * 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'));
+   * ```
    */
-  toString(separator?: string, includeNamespace?: boolean): string;
+  add(expression: Expression): this;
 
   /**
-   * Get path as array of tag names
-   * @returns Array of tag names
+   * 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'),
+   * ]);
+   * ```
    */
-  toArray(): string[];
+  addAll(expressions: Expression[]): this;
 
   /**
-   * Reset the path to empty
+   * 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
    */
-  reset(): void;
+  has(expression: Expression): boolean;
 
   /**
-   * Match current path against an Expression
-   * @param expression - The expression to match against
-   * @returns True if current path matches the expression
-   * 
+   * 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 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
+   * 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'));
    * ```
    */
-  matches(expression: Expression): boolean;
-
-  /**
-   * Create a snapshot of current state
-   * @returns State snapshot that can be restored later
-   */
-  snapshot(): MatcherSnapshot;
+  seal(): this;
 
   /**
-   * Restore state from snapshot
-   * @param snapshot - State snapshot from previous snapshot() call
+   * 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
+   * }
+   * ```
    */
-  restore(snapshot: MatcherSnapshot): void;
+  matchesAny(matcher: Matcher | MatcherView): boolean;
 
   /**
-   * Return a read-only view of this matcher.
+   * 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);
+   * ```
    */
-  readOnly(): ReadOnlyMatcher;
+  findMatch(matcher: Matcher | MatcherView): Expression;
 }
 
 /**
- * Default export containing both Expression and Matcher
+ * Default export containing Expression, Matcher, and ExpressionSet
  */
 declare const _default: {
   Expression: typeof Expression;
   Matcher: typeof Matcher;
+  MatcherView: typeof MatcherView;
+  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/package.json

@@ -74,15 +74,15 @@
     "constructs": "^10.5.1"
   },
   "dependencies": {
-    "@aws-sdk/client-cloudformation": "^3.1024.0",
-    "@aws-sdk/client-cloudwatch": "^3.1024.0",
-    "@aws-sdk/client-ec2": "^3.1024.0",
-    "@aws-sdk/client-iam": "^3.1024.0",
-    "@aws-sdk/client-lambda": "^3.1024.0",
-    "@aws-sdk/client-s3": "^3.1024.0",
-    "@aws-sdk/client-sns": "^3.1024.0",
-    "@aws-sdk/client-sqs": "^3.1024.0",
-    "@aws-sdk/client-ssm": "^3.1024.0",
+    "@aws-sdk/client-cloudformation": "^3.1029.0",
+    "@aws-sdk/client-cloudwatch": "^3.1029.0",
+    "@aws-sdk/client-ec2": "^3.1029.0",
+    "@aws-sdk/client-iam": "^3.1029.0",
+    "@aws-sdk/client-lambda": "^3.1029.0",
+    "@aws-sdk/client-s3": "^3.1029.0",
+    "@aws-sdk/client-sns": "^3.1029.0",
+    "@aws-sdk/client-sqs": "^3.1029.0",
+    "@aws-sdk/client-ssm": "^3.1029.0",
     "immutable": "^4.3.8",
     "js-yaml": "^4.1.1",
     "jsonpath": "^1.3.0",
@@ -116,7 +116,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.55",
+  "version": "0.0.56",
   "jest": {
     "coverageProvider": "v8",
     "maxWorkers": 4,

package/node_modules/strnum/.github/SECURITY.md

@@ -1,5 +0,0 @@
-If you believe you have found a security vulnerability in this repository which can be potentially harful for the users in anyway, please do not report security vulnerabilities through public GitHub issues. Instead, please report it to us as described below.
-
-## Security contact information
-
-To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.

package/node_modules/strnum/.vscode/launch.json

@@ -1,25 +0,0 @@
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Jasmine Tests",
-            "program": "${workspaceFolder}/node_modules/jasmine/bin/jasmine.js",
-            "args": [
-                "${workspaceFolder}/spec/attr_spec.js"
-            ],
-            "internalConsoleOptions": "openOnSessionStart"
-        },{
-            "type": "node",
-            "request": "launch",
-            "name": "Jasmine Tests current test file",
-            "program": "${workspaceFolder}/node_modules/jasmine/bin/jasmine.js",
-            "args": [
-                "${file}"
-            ],
-            "internalConsoleOptions": "openOnSessionStart"
-        }
-    ]
-   
-}