cdk-ecr-deployment 3.1.8 → 3.1.10

package/node_modules/@types/keyv/node_modules/@types/node/test.d.ts

@@ -564,6 +564,23 @@ declare module "node:test" {
         /**
          * An object containing assertion methods bound to the test context.
          * The top-level functions from the `node:assert` module are exposed here for the purpose of creating test plans.
+         *
+         * **Note:** Some of the functions from `node:assert` contain type assertions. If these are called via the
+         * TestContext `assert` object, then the context parameter in the test's function signature **must be explicitly typed**
+         * (ie. the parameter must have a type annotation), otherwise an error will be raised by the TypeScript compiler:
+         * ```ts
+         * import { test, type TestContext } from 'node:test';
+         *
+         * // The test function's context parameter must have a type annotation.
+         * test('example', (t: TestContext) => {
+         *   t.assert.deepStrictEqual(actual, expected);
+         * });
+         *
+         * // Omitting the type annotation will result in a compilation error.
+         * test('example', t => {
+         *   t.assert.deepStrictEqual(actual, expected); // Error: 't' needs an explicit type annotation.
+         * });
+         * ```
          * @since v22.2.0, v20.15.0
          */
         readonly assert: TestContextAssert;
@@ -741,139 +758,29 @@ declare module "node:test" {
          */
         readonly mock: MockTracker;
     }
-    interface TestContextAssert {
-        /**
-         * Identical to the `deepEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        deepEqual: typeof import("node:assert").deepEqual;
-        /**
-         * Identical to the `deepStrictEqual` function from the `node:assert` module, but bound to the test context.
-         *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
-         *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.deepStrictEqual(actual, expected);
-         * });
-         *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.deepStrictEqual(actual, expected); // Error: 't' needs an explicit type annotation.
-         * });
-         * ```
-         */
-        deepStrictEqual: typeof import("node:assert").deepStrictEqual;
-        /**
-         * Identical to the `doesNotMatch` function from the `node:assert` module, but bound to the test context.
-         */
-        doesNotMatch: typeof import("node:assert").doesNotMatch;
-        /**
-         * Identical to the `doesNotReject` function from the `node:assert` module, but bound to the test context.
-         */
-        doesNotReject: typeof import("node:assert").doesNotReject;
-        /**
-         * Identical to the `doesNotThrow` function from the `node:assert` module, but bound to the test context.
-         */
-        doesNotThrow: typeof import("node:assert").doesNotThrow;
-        /**
-         * Identical to the `equal` function from the `node:assert` module, but bound to the test context.
-         */
-        equal: typeof import("node:assert").equal;
-        /**
-         * Identical to the `fail` function from the `node:assert` module, but bound to the test context.
-         */
-        fail: typeof import("node:assert").fail;
-        /**
-         * Identical to the `ifError` function from the `node:assert` module, but bound to the test context.
-         *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
-         *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.ifError(err);
-         * });
-         *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.ifError(err); // Error: 't' needs an explicit type annotation.
-         * });
-         * ```
-         */
-        ifError: typeof import("node:assert").ifError;
-        /**
-         * Identical to the `match` function from the `node:assert` module, but bound to the test context.
-         */
-        match: typeof import("node:assert").match;
-        /**
-         * Identical to the `notDeepEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notDeepEqual: typeof import("node:assert").notDeepEqual;
-        /**
-         * Identical to the `notDeepStrictEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notDeepStrictEqual: typeof import("node:assert").notDeepStrictEqual;
-        /**
-         * Identical to the `notEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notEqual: typeof import("node:assert").notEqual;
-        /**
-         * Identical to the `notStrictEqual` function from the `node:assert` module, but bound to the test context.
-         */
-        notStrictEqual: typeof import("node:assert").notStrictEqual;
-        /**
-         * Identical to the `ok` function from the `node:assert` module, but bound to the test context.
-         *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
-         *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.ok(condition);
-         * });
-         *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.ok(condition)); // Error: 't' needs an explicit type annotation.
-         * });
-         * ```
-         */
-        ok: typeof import("node:assert").ok;
-        /**
-         * Identical to the `rejects` function from the `node:assert` module, but bound to the test context.
-         */
-        rejects: typeof import("node:assert").rejects;
-        /**
-         * Identical to the `strictEqual` function from the `node:assert` module, but bound to the test context.
-         *
-         * **Note:** as this method returns a type assertion, the context parameter in the callback signature must have a
-         * type annotation, otherwise an error will be raised by the TypeScript compiler:
-         * ```ts
-         * import { test, type TestContext } from 'node:test';
-         *
-         * // The test function's context parameter must have a type annotation.
-         * test('example', (t: TestContext) => {
-         *   t.assert.strictEqual(actual, expected);
-         * });
-         *
-         * // Omitting the type annotation will result in a compilation error.
-         * test('example', t => {
-         *   t.assert.strictEqual(actual, expected); // Error: 't' needs an explicit type annotation.
-         * });
-         * ```
-         */
-        strictEqual: typeof import("node:assert").strictEqual;
-        /**
-         * Identical to the `throws` function from the `node:assert` module, but bound to the test context.
-         */
-        throws: typeof import("node:assert").throws;
+    interface TestContextAssert extends
+        Pick<
+            typeof import("assert"),
+            | "deepEqual"
+            | "deepStrictEqual"
+            | "doesNotMatch"
+            | "doesNotReject"
+            | "doesNotThrow"
+            | "equal"
+            | "fail"
+            | "ifError"
+            | "match"
+            | "notDeepEqual"
+            | "notDeepStrictEqual"
+            | "notEqual"
+            | "notStrictEqual"
+            | "ok"
+            | "partialDeepStrictEqual"
+            | "rejects"
+            | "strictEqual"
+            | "throws"
+        >
+    {
         /**
          * This function implements assertions for snapshot testing.
          * ```js
@@ -887,10 +794,7 @@ declare module "node:test" {
          *   });
          * });
          * ```
-         *
-         * Only available through the [--experimental-test-snapshots](https://nodejs.org/api/cli.html#--experimental-test-snapshots) flag.
          * @since v22.3.0
-         * @experimental
          */
         snapshot(value: any, options?: AssertSnapshotOptions): void;
     }
@@ -1691,9 +1595,7 @@ declare module "node:test" {
         [Symbol.dispose](): void;
     }
     /**
-     * Only available through the [--experimental-test-snapshots](https://nodejs.org/api/cli.html#--experimental-test-snapshots) flag.
      * @since v22.3.0
-     * @experimental
      */
     namespace snapshot {
         /**

package/node_modules/@types/keyv/node_modules/@types/node/ts5.6/buffer.buffer.d.ts

@@ -24,7 +24,7 @@ declare module "buffer" {
              * @param array The octets to store.
              * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
              */
-            new(array: Uint8Array): Buffer;
+            new(array: ArrayLike<number>): Buffer;
             /**
              * Produces a Buffer backed by the same allocated memory as
              * the given {ArrayBuffer}/{SharedArrayBuffer}.
@@ -33,20 +33,6 @@ declare module "buffer" {
              * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
              */
             new(arrayBuffer: ArrayBuffer | SharedArrayBuffer): Buffer;
-            /**
-             * Allocates a new buffer containing the given {array} of octets.
-             *
-             * @param array The octets to store.
-             * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
-             */
-            new(array: readonly any[]): Buffer;
-            /**
-             * Copies the passed {buffer} data onto a new {Buffer} instance.
-             *
-             * @param buffer The buffer to copy.
-             * @deprecated since v10.0.0 - Use `Buffer.from(buffer)` instead.
-             */
-            new(buffer: Buffer): Buffer;
             /**
              * Allocates a new `Buffer` using an `array` of bytes in the range `0` – `255`.
              * Array entries outside that range will be truncated to fit into it.
@@ -58,40 +44,120 @@ declare module "buffer" {
              * const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
              * ```
              *
-             * If `array` is an `Array`\-like object (that is, one with a `length` property of
+             * If `array` is an `Array`-like object (that is, one with a `length` property of
              * type `number`), it is treated as if it is an array, unless it is a `Buffer` or
-             * a `Uint8Array`. This means all other `TypedArray` variants get treated as an `Array`. To create a `Buffer` from the bytes backing a `TypedArray`, use `Buffer.copyBytesFrom()`.
+             * a `Uint8Array`. This means all other `TypedArray` variants get treated as an
+             * `Array`. To create a `Buffer` from the bytes backing a `TypedArray`, use
+             * `Buffer.copyBytesFrom()`.
              *
              * A `TypeError` will be thrown if `array` is not an `Array` or another type
              * appropriate for `Buffer.from()` variants.
              *
-             * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal `Buffer` pool like `Buffer.allocUnsafe()` does.
+             * `Buffer.from(array)` and `Buffer.from(string)` may also use the internal
+             * `Buffer` pool like `Buffer.allocUnsafe()` does.
              * @since v5.10.0
              */
+            from(array: WithImplicitCoercion<ArrayLike<number>>): Buffer;
+            /**
+             * This creates a view of the `ArrayBuffer` without copying the underlying
+             * memory. For example, when passed a reference to the `.buffer` property of a
+             * `TypedArray` instance, the newly created `Buffer` will share the same
+             * allocated memory as the `TypedArray`'s underlying `ArrayBuffer`.
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const arr = new Uint16Array(2);
+             *
+             * arr[0] = 5000;
+             * arr[1] = 4000;
+             *
+             * // Shares memory with `arr`.
+             * const buf = Buffer.from(arr.buffer);
+             *
+             * console.log(buf);
+             * // Prints: <Buffer 88 13 a0 0f>
+             *
+             * // Changing the original Uint16Array changes the Buffer also.
+             * arr[1] = 6000;
+             *
+             * console.log(buf);
+             * // Prints: <Buffer 88 13 70 17>
+             * ```
+             *
+             * The optional `byteOffset` and `length` arguments specify a memory range within
+             * the `arrayBuffer` that will be shared by the `Buffer`.
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const ab = new ArrayBuffer(10);
+             * const buf = Buffer.from(ab, 0, 2);
+             *
+             * console.log(buf.length);
+             * // Prints: 2
+             * ```
+             *
+             * A `TypeError` will be thrown if `arrayBuffer` is not an `ArrayBuffer` or a
+             * `SharedArrayBuffer` or another type appropriate for `Buffer.from()`
+             * variants.
+             *
+             * It is important to remember that a backing `ArrayBuffer` can cover a range
+             * of memory that extends beyond the bounds of a `TypedArray` view. A new
+             * `Buffer` created using the `buffer` property of a `TypedArray` may extend
+             * beyond the range of the `TypedArray`:
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements
+             * const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
+             * console.log(arrA.buffer === arrB.buffer); // true
+             *
+             * const buf = Buffer.from(arrB.buffer);
+             * console.log(buf);
+             * // Prints: <Buffer 63 64 65 66>
+             * ```
+             * @since v5.10.0
+             * @param arrayBuffer An `ArrayBuffer`, `SharedArrayBuffer`, for example the
+             * `.buffer` property of a `TypedArray`.
+             * @param byteOffset Index of first byte to expose. **Default:** `0`.
+             * @param length Number of bytes to expose. **Default:**
+             * `arrayBuffer.byteLength - byteOffset`.
+             */
             from(
                 arrayBuffer: WithImplicitCoercion<ArrayBuffer | SharedArrayBuffer>,
                 byteOffset?: number,
                 length?: number,
             ): Buffer;
             /**
-             * Creates a new Buffer using the passed {data}
-             * @param data data to create a new Buffer
-             */
-            from(data: Uint8Array | readonly number[]): Buffer;
-            from(data: WithImplicitCoercion<Uint8Array | readonly number[] | string>): Buffer;
-            /**
-             * Creates a new Buffer containing the given JavaScript string {str}.
-             * If provided, the {encoding} parameter identifies the character encoding.
-             * If not provided, {encoding} defaults to 'utf8'.
+             * Creates a new `Buffer` containing `string`. The `encoding` parameter identifies
+             * the character encoding to be used when converting `string` into bytes.
+             *
+             * ```js
+             * import { Buffer } from 'node:buffer';
+             *
+             * const buf1 = Buffer.from('this is a tést');
+             * const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');
+             *
+             * console.log(buf1.toString());
+             * // Prints: this is a tést
+             * console.log(buf2.toString());
+             * // Prints: this is a tést
+             * console.log(buf1.toString('latin1'));
+             * // Prints: this is a tést
+             * ```
+             *
+             * A `TypeError` will be thrown if `string` is not a string or another type
+             * appropriate for `Buffer.from()` variants.
+             *
+             * `Buffer.from(string)` may also use the internal `Buffer` pool like
+             * `Buffer.allocUnsafe()` does.
+             * @since v5.10.0
+             * @param string A string to encode.
+             * @param encoding The encoding of `string`. **Default:** `'utf8'`.
              */
-            from(
-                str:
-                    | WithImplicitCoercion<string>
-                    | {
-                        [Symbol.toPrimitive](hint: "string"): string;
-                    },
-                encoding?: BufferEncoding,
-            ): Buffer;
+            from(string: WithImplicitCoercion<string>, encoding?: BufferEncoding): Buffer;
             /**
              * Creates a new Buffer using the passed {data}
              * @param values to create a new Buffer
@@ -382,4 +448,10 @@ declare module "buffer" {
             subarray(start?: number, end?: number): Buffer;
         }
     }
+    /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+    var SlowBuffer: {
+        /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+        new(size: number): Buffer;
+        prototype: Buffer;
+    };
 }

package/node_modules/@types/keyv/node_modules/@types/node/util.d.ts

@@ -185,6 +185,13 @@ declare module "util" {
      * @since v10.0.0
      */
     export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
+    interface GetCallSitesOptions {
+        /**
+         * Reconstruct the original location in the stacktrace from the source-map.
+         * Enabled by default with the flag `--enable-source-maps`.
+         */
+        sourceMap?: boolean | undefined;
+    }
     /**
      * Returns an array of call site objects containing the stack of
      * the caller function.
@@ -225,12 +232,40 @@ declare module "util" {
      *
      * anotherFunction();
      * ```
+     *
+     * It is possible to reconstruct the original locations by setting the option `sourceMap` to `true`.
+     * If the source map is not available, the original location will be the same as the current location.
+     * When the `--enable-source-maps` flag is enabled, for example when using `--experimental-transform-types`,
+     * `sourceMap` will be true by default.
+     *
+     * ```ts
+     * import util from 'node:util';
+     *
+     * interface Foo {
+     *   foo: string;
+     * }
+     *
+     * const callSites = util.getCallSites({ sourceMap: true });
+     *
+     * // With sourceMap:
+     * // Function Name: ''
+     * // Script Name: example.js
+     * // Line Number: 7
+     * // Column Number: 26
+     *
+     * // Without sourceMap:
+     * // Function Name: ''
+     * // Script Name: example.js
+     * // Line Number: 2
+     * // Column Number: 26
+     * ```
      * @param frameCount Number of frames to capture as call site objects.
      * **Default:** `10`. Allowable range is between 1 and 200.
      * @return An array of call site objects
      * @since v22.9.0
      */
-    export function getCallSites(frameCount?: number): CallSiteObject[];
+    export function getCallSites(frameCount?: number, options?: GetCallSitesOptions): CallSiteObject[];
+    export function getCallSites(options: GetCallSitesOptions): CallSiteObject[];
     /**
      * Returns the string name for a numeric error code that comes from a Node.js API.
      * The mapping between error codes and error names is platform-dependent.
@@ -317,27 +352,36 @@ declare module "util" {
      */
     export function transferableAbortSignal(signal: AbortSignal): AbortSignal;
     /**
-     * Listens to abort event on the provided `signal` and
-     * returns a promise that is fulfilled when the `signal` is
-     * aborted. If the passed `resource` is garbage collected before the `signal` is
-     * aborted, the returned promise shall remain pending indefinitely.
+     * Listens to abort event on the provided `signal` and returns a promise that resolves when the `signal` is aborted.
+     * If `resource` is provided, it weakly references the operation's associated object,
+     * so if `resource` is garbage collected before the `signal` aborts,
+     * then returned promise shall remain pending.
+     * This prevents memory leaks in long-running or non-cancelable operations.
      *
      * ```js
      * import { aborted } from 'node:util';
      *
+     * // Obtain an object with an abortable signal, like a custom resource or operation.
      * const dependent = obtainSomethingAbortable();
      *
+     * // Pass `dependent` as the resource, indicating the promise should only resolve
+     * // if `dependent` is still in memory when the signal is aborted.
      * aborted(dependent.signal, dependent).then(() => {
-     *   // Do something when dependent is aborted.
+     *   // This code runs when `dependent` is aborted.
+     *   console.log('Dependent resource was aborted.');
      * });
      *
+     * // Simulate an event that triggers the abort.
      * dependent.on('event', () => {
-     *   dependent.abort();
+     *   dependent.abort(); // This will cause the `aborted` promise to resolve.
      * });
      * ```
      * @since v19.7.0
      * @experimental
-     * @param resource Any non-null entity, reference to which is held weakly.
+     * @param resource Any non-null object tied to the abortable operation and held weakly.
+     * If `resource` is garbage collected before the `signal` aborts, the promise remains pending,
+     * allowing Node.js to stop tracking it.
+     * This helps prevent memory leaks in long-running or non-cancelable operations.
      */
     export function aborted(signal: AbortSignal, resource: any): Promise<void>;
     /**
@@ -1321,8 +1365,6 @@ declare module "util" {
         | "strikethrough"
         | "underline";
     /**
-     * Stability: 1.1 - Active development
-     *
      * This function returns a formatted text considering the `format` passed.
      *
      * ```js

package/node_modules/@types/keyv/node_modules/@types/node/vm.d.ts

@@ -69,7 +69,7 @@ declare module "vm" {
          * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v22.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          */
         importModuleDynamically?:
-            | ((specifier: string, script: Script, importAttributes: ImportAttributes) => Module)
+            | ((specifier: string, script: Script, importAttributes: ImportAttributes) => Module | Promise<Module>)
             | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER
             | undefined;
     }

package/node_modules/@types/responselike/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Tue, 28 Jan 2025 02:01:18 GMT
+ * Last updated: Sat, 01 Mar 2025 06:37:25 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/responselike/node_modules/@types/node/assert.d.ts

@@ -956,6 +956,59 @@ declare module "assert" {
          * @since v13.6.0, v12.16.0
          */
         function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
+        /**
+         * `assert.partialDeepStrictEqual()` Asserts the equivalence between the `actual` and `expected` parameters through a
+         * deep comparison, ensuring that all properties in the `expected` parameter are
+         * present in the `actual` parameter with equivalent values, not allowing type coercion.
+         * The main difference with `assert.deepStrictEqual()` is that `assert.partialDeepStrictEqual()` does not require
+         * all properties in the `actual` parameter to be present in the `expected` parameter.
+         * This method should always pass the same test cases as `assert.deepStrictEqual()`, behaving as a super set of it.
+         *
+         * ```js
+         * import assert from 'node:assert';
+         *
+         * assert.partialDeepStrictEqual({ a: 1, b: 2 }, { a: 1, b: 2 });
+         * // OK
+         *
+         * assert.partialDeepStrictEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } });
+         * // OK
+         *
+         * assert.partialDeepStrictEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 });
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(new Set(['value1', 'value2']), new Set(['value1', 'value2']));
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(new Map([['key1', 'value1']]), new Map([['key1', 'value1']]));
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]));
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(/abc/, /abc/);
+         * // OK
+         *
+         * assert.partialDeepStrictEqual([{ a: 5 }, { b: 5 }], [{ a: 5 }]);
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(new Set([{ a: 1 }, { b: 1 }]), new Set([{ a: 1 }]));
+         * // OK
+         *
+         * assert.partialDeepStrictEqual(new Date(0), new Date(0));
+         * // OK
+         *
+         * assert.partialDeepStrictEqual({ a: 1 }, { a: 1, b: 2 });
+         * // AssertionError
+         *
+         * assert.partialDeepStrictEqual({ a: 1, b: '2' }, { a: 1, b: 2 });
+         * // AssertionError
+         *
+         * assert.partialDeepStrictEqual({ a: { b: 2 } }, { a: { b: '2' } });
+         * // AssertionError
+         * ```
+         * @since v22.13.0
+         */
+        function partialDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
         /**
          * In strict assertion mode, non-strict methods behave like their corresponding strict methods. For example,
          * {@link deepEqual} will behave like {@link deepStrictEqual}.
@@ -1015,6 +1068,7 @@ declare module "assert" {
                 | "deepStrictEqual"
                 | "ifError"
                 | "strict"
+                | "AssertionError"
             >
             & {
                 (value: unknown, message?: string | Error): asserts value;
@@ -1030,6 +1084,7 @@ declare module "assert" {
                 deepStrictEqual: typeof deepStrictEqual;
                 ifError: typeof ifError;
                 strict: typeof strict;
+                AssertionError: typeof AssertionError;
             };
     }
     export = assert;