cdk-ecr-deployment 3.1.8 → 3.1.10

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

@@ -1,4 +1,6 @@
 declare module "buffer" {
+    type ImplicitArrayBuffer<T extends WithImplicitCoercion<ArrayBufferLike>> = T extends
+        { valueOf(): infer V extends ArrayBufferLike } ? V : T;
     global {
         interface BufferConstructor {
             // see buffer.d.ts for implementation shared with all TypeScript versions
@@ -24,7 +26,7 @@ declare module "buffer" {
              * @param array The octets to store.
              * @deprecated since v10.0.0 - Use `Buffer.from(array)` instead.
              */
-            new(array: Uint8Array): Buffer<ArrayBuffer>;
+            new(array: ArrayLike<number>): Buffer<ArrayBuffer>;
             /**
              * Produces a Buffer backed by the same allocated memory as
              * the given {ArrayBuffer}/{SharedArrayBuffer}.
@@ -33,20 +35,6 @@ declare module "buffer" {
              * @deprecated since v10.0.0 - Use `Buffer.from(arrayBuffer[, byteOffset[, length]])` instead.
              */
             new<TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(arrayBuffer: TArrayBuffer): Buffer<TArrayBuffer>;
-            /**
-             * 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<ArrayBuffer>;
-            /**
-             * 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<ArrayBuffer>;
             /**
              * 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 +46,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<TArrayBuffer extends ArrayBufferLike>(
-                arrayBuffer: WithImplicitCoercion<TArrayBuffer>,
-                byteOffset?: number,
-                length?: number,
-            ): Buffer<TArrayBuffer>;
+            from(array: WithImplicitCoercion<ArrayLike<number>>): Buffer<ArrayBuffer>;
             /**
-             * Creates a new Buffer using the passed {data}
-             * @param data data to create a new 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(data: Uint8Array | readonly number[]): Buffer<ArrayBuffer>;
-            from(data: WithImplicitCoercion<Uint8Array | readonly number[] | string>): Buffer<ArrayBuffer>;
+            from<TArrayBuffer extends WithImplicitCoercion<ArrayBufferLike>>(
+                arrayBuffer: TArrayBuffer,
+                byteOffset?: number,
+                length?: number,
+            ): Buffer<ImplicitArrayBuffer<TArrayBuffer>>;
             /**
-             * 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<ArrayBuffer>;
+            from(string: WithImplicitCoercion<string>, encoding?: BufferEncoding): Buffer<ArrayBuffer>;
             /**
              * Creates a new Buffer using the passed {data}
              * @param values to create a new Buffer
@@ -107,7 +175,8 @@ declare module "buffer" {
              *
              * If `totalLength` is provided, it is coerced to an unsigned integer. If the
              * combined length of the `Buffer`s in `list` exceeds `totalLength`, the result is
-             * truncated to `totalLength`.
+             * truncated to `totalLength`. If the combined length of the `Buffer`s in `list` is
+             * less than `totalLength`, the remaining space is filled with zeros.
              *
              * ```js
              * import { Buffer } from 'node:buffer';
@@ -382,4 +451,10 @@ declare module "buffer" {
             subarray(start?: number, end?: number): Buffer<TArrayBuffer>;
         }
     }
+    /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+    var SlowBuffer: {
+        /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+        new(size: number): Buffer<ArrayBuffer>;
+        prototype: Buffer;
+    };
 }

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

@@ -114,11 +114,6 @@ declare module "buffer" {
      * @param toEnc To target encoding.
      */
     export function transcode(source: Uint8Array, fromEnc: TranscodeEncoding, toEnc: TranscodeEncoding): Buffer;
-    export const SlowBuffer: {
-        /** @deprecated since v6.0.0, use `Buffer.allocUnsafeSlow()` */
-        new(size: number): Buffer;
-        prototype: Buffer;
-    };
     /**
      * Resolves a `'blob:nodedata:...'` an associated `Blob` object registered using
      * a prior call to `URL.createObjectURL()`.
@@ -237,7 +232,10 @@ declare module "buffer" {
     }
     export import atob = globalThis.atob;
     export import btoa = globalThis.btoa;
-
+    export type WithImplicitCoercion<T> =
+        | T
+        | { valueOf(): T }
+        | (T extends string ? { [Symbol.toPrimitive](hint: "string"): T } : never);
     global {
         namespace NodeJS {
             export { BufferEncoding };
@@ -256,11 +254,6 @@ declare module "buffer" {
             | "latin1"
             | "binary"
             | "hex";
-        type WithImplicitCoercion<T> =
-            | T
-            | {
-                valueOf(): T;
-            };
         /**
          * Raw data is stored in instances of the Buffer class.
          * A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap.  A Buffer cannot be resized.

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

@@ -26,7 +26,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/dgram.js)
  */
 declare module "dgram" {
-    import { AddressInfo } from "node:net";
+    import { AddressInfo, BlockList } from "node:net";
     import * as dns from "node:dns";
     import { Abortable, EventEmitter } from "node:events";
     interface RemoteInfo {
@@ -59,6 +59,8 @@ declare module "dgram" {
                 callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
             ) => void)
             | undefined;
+        receiveBlockList?: BlockList | undefined;
+        sendBlockList?: BlockList | undefined;
     }
     /**
      * Creates a `dgram.Socket` object. Once the socket is created, calling `socket.bind()` will instruct the socket to begin listening for datagram

package/node_modules/@types/responselike/node_modules/@types/node/fs/promises.d.ts

@@ -112,7 +112,7 @@ declare module "fs/promises" {
         appendFile(
             data: string | Uint8Array,
             options?:
-                | (ObjectEncodingOptions & FlagAndOpenMode & { flush?: boolean | undefined })
+                | (ObjectEncodingOptions & Abortable)
                 | BufferEncoding
                 | null,
         ): Promise<void>;
@@ -402,7 +402,7 @@ declare module "fs/promises" {
         writeFile(
             data: string | Uint8Array,
             options?:
-                | (ObjectEncodingOptions & FlagAndOpenMode & Abortable & { flush?: boolean | undefined })
+                | (ObjectEncodingOptions & Abortable)
                 | BufferEncoding
                 | null,
         ): Promise<void>;

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

@@ -223,6 +223,7 @@ declare module "http" {
         path?: string | null | undefined;
         port?: number | string | null | undefined;
         protocol?: string | null | undefined;
+        setDefaultHeaders?: boolean | undefined;
         setHost?: boolean | undefined;
         signal?: AbortSignal | undefined;
         socketPath?: string | undefined;

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

@@ -127,6 +127,13 @@ declare module "module" {
          * directory if it is enabled, or `undefined` otherwise.
          */
         function getCompileCacheDir(): string | undefined;
+        /**
+         * @since v23.2.0, v22.14.0
+         */
+        function findPackageJSON(
+            specifier: string | URL,
+            base?: string | URL,
+        ): undefined | string;
         /**
          * @since v18.6.0, v16.17.0
          */
@@ -168,6 +175,80 @@ declare module "module" {
             options?: RegisterOptions<Data>,
         ): void;
         function register<Data = any>(specifier: string | URL, options?: RegisterOptions<Data>): void;
+        interface StripTypeScriptTypesOptions {
+            /**
+             * Possible values are:
+             * * `'strip'` Only strip type annotations without performing the transformation of TypeScript features.
+             * * `'transform'` Strip type annotations and transform TypeScript features to JavaScript.
+             * @default 'strip'
+             */
+            mode?: "strip" | "transform" | undefined;
+            /**
+             * Only when `mode` is `'transform'`, if `true`, a source map
+             * will be generated for the transformed code.
+             * @default false
+             */
+            sourceMap?: boolean | undefined;
+            /**
+             * Specifies the source url used in the source map.
+             */
+            sourceUrl?: string | undefined;
+        }
+        /**
+         * `module.stripTypeScriptTypes()` removes type annotations from TypeScript code. It
+         * can be used to strip type annotations from TypeScript code before running it
+         * with `vm.runInContext()` or `vm.compileFunction()`.
+         * By default, it will throw an error if the code contains TypeScript features
+         * that require transformation such as `Enums`,
+         * see [type-stripping](https://nodejs.org/docs/latest-v22.x/api/typescript.md#type-stripping) for more information.
+         * When mode is `'transform'`, it also transforms TypeScript features to JavaScript,
+         * see [transform TypeScript features](https://nodejs.org/docs/latest-v22.x/api/typescript.md#typescript-features) for more information.
+         * When mode is `'strip'`, source maps are not generated, because locations are preserved.
+         * If `sourceMap` is provided, when mode is `'strip'`, an error will be thrown.
+         *
+         * _WARNING_: The output of this function should not be considered stable across Node.js versions,
+         * due to changes in the TypeScript parser.
+         *
+         * ```js
+         * import { stripTypeScriptTypes } from 'node:module';
+         * const code = 'const a: number = 1;';
+         * const strippedCode = stripTypeScriptTypes(code);
+         * console.log(strippedCode);
+         * // Prints: const a         = 1;
+         * ```
+         *
+         * If `sourceUrl` is provided, it will be used appended as a comment at the end of the output:
+         *
+         * ```js
+         * import { stripTypeScriptTypes } from 'node:module';
+         * const code = 'const a: number = 1;';
+         * const strippedCode = stripTypeScriptTypes(code, { mode: 'strip', sourceUrl: 'source.ts' });
+         * console.log(strippedCode);
+         * // Prints: const a         = 1\n\n//# sourceURL=source.ts;
+         * ```
+         *
+         * When `mode` is `'transform'`, the code is transformed to JavaScript:
+         *
+         * ```js
+         * import { stripTypeScriptTypes } from 'node:module';
+         * const code = `
+         *   namespace MathUtil {
+         *     export const add = (a: number, b: number) => a + b;
+         *   }`;
+         * const strippedCode = stripTypeScriptTypes(code, { mode: 'transform', sourceMap: true });
+         * console.log(strippedCode);
+         * // Prints:
+         * // var MathUtil;
+         * // (function(MathUtil) {
+         * //     MathUtil.add = (a, b)=>a + b;
+         * // })(MathUtil || (MathUtil = {}));
+         * // # sourceMappingURL=data:application/json;base64, ...
+         * ```
+         * @since v22.13.0
+         * @param code The code to strip type annotations from.
+         * @returns The code with type annotations stripped.
+         */
+        function stripTypeScriptTypes(code: string, options?: StripTypeScriptTypesOptions): string;
         /* eslint-enable @definitelytyped/no-unnecessary-generics */
         /**
          * The `module.syncBuiltinESMExports()` method updates all the live bindings for

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

@@ -65,6 +65,7 @@ declare module "net" {
          * @since v18.13.0
          */
         autoSelectFamilyAttemptTimeout?: number | undefined;
+        blockList?: BlockList | undefined;
     }
     interface IpcSocketConnectOpts {
         path: string;
@@ -535,6 +536,15 @@ declare module "net" {
          * @since v18.17.0, v20.1.0
          */
         highWaterMark?: number | undefined;
+        /**
+         * `blockList` can be used for disabling inbound
+         * access to specific IP addresses, IP ranges, or IP subnets. This does not
+         * work if the server is behind a reverse proxy, NAT, etc. because the address
+         * checked against the block list is the address of the proxy, or the one
+         * specified by the NAT.
+         * @since v22.13.0
+         */
+        blockList?: BlockList | undefined;
     }
     interface DropArgument {
         localAddress?: string;
@@ -786,6 +796,12 @@ declare module "net" {
          * @since v15.0.0, v14.18.0
          */
         rules: readonly string[];
+        /**
+         * Returns `true` if the `value` is a `net.BlockList`.
+         * @since v22.13.0
+         * @param value Any JS value
+         */
+        static isBlockList(value: unknown): value is BlockList;
     }
     interface TcpNetConnectOpts extends TcpSocketConnectOpts, SocketConstructorOpts {
         timeout?: number | undefined;
@@ -998,6 +1014,14 @@ declare module "net" {
          * @since v15.14.0, v14.18.0
          */
         readonly flowlabel: number;
+        /**
+         * @since v22.13.0
+         * @param input An input string containing an IP address and optional port,
+         * e.g. `123.1.2.3:1234` or `[1::1]:1234`.
+         * @returns Returns a `SocketAddress` if parsing was successful.
+         * Otherwise returns `undefined`.
+         */
+        static parse(input: string): SocketAddress | undefined;
     }
 }
 declare module "node:net" {

package/node_modules/@types/responselike/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "22.12.0",
+    "version": "22.13.8",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -215,6 +215,6 @@
         "undici-types": "~6.20.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "d4bd811572964de73064ee6d85299d0dff56616e67d674f2ccdc3c824a4288b7",
+    "typesPublisherContentHash": "5bedf97bc7316e968d26ed4056ab5980a72db818c2493f707d9cc1f728b11c88",
     "typeScriptVersion": "5.0"
 }

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

@@ -594,6 +594,11 @@ declare module "perf_hooks" {
                     buffered?: boolean | undefined;
                 },
         ): void;
+        /**
+         * @since v16.0.0
+         * @returns Current list of entries stored in the performance observer, emptying it out.
+         */
+        takeRecords(): PerformanceEntry[];
     }
     /**
      * Provides detailed network timing data regarding the loading of an application's resources.

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

@@ -186,7 +186,10 @@ declare module "process" {
                 readonly inspector: boolean;
                 /**
                  * A boolean value that is `true` if the current Node.js build includes support for IPv6.
+                 *
+                 * Since all Node.js builds have IPv6 support, this value is always `true`.
                  * @since v0.5.3
+                 * @deprecated This property is always true, and any checks based on it are redundant.
                  */
                 readonly ipv6: boolean;
                 /**
@@ -202,17 +205,29 @@ declare module "process" {
                 readonly tls: boolean;
                 /**
                  * A boolean value that is `true` if the current Node.js build includes support for ALPN in TLS.
+                 *
+                 * In Node.js 11.0.0 and later versions, the OpenSSL dependencies feature unconditional ALPN support.
+                 * This value is therefore identical to that of `process.features.tls`.
                  * @since v4.8.0
+                 * @deprecated Use `process.features.tls` instead.
                  */
                 readonly tls_alpn: boolean;
                 /**
                  * A boolean value that is `true` if the current Node.js build includes support for OCSP in TLS.
+                 *
+                 * In Node.js 11.0.0 and later versions, the OpenSSL dependencies feature unconditional OCSP support.
+                 * This value is therefore identical to that of `process.features.tls`.
                  * @since v0.11.13
+                 * @deprecated Use `process.features.tls` instead.
                  */
                 readonly tls_ocsp: boolean;
                 /**
                  * A boolean value that is `true` if the current Node.js build includes support for SNI in TLS.
+                 *
+                 * In Node.js 11.0.0 and later versions, the OpenSSL dependencies feature unconditional SNI support.
+                 * This value is therefore identical to that of `process.features.tls`.
                  * @since v0.5.3
+                 * @deprecated Use `process.features.tls` instead.
                  */
                 readonly tls_sni: boolean;
                 /**
@@ -223,8 +238,10 @@ declare module "process" {
                 readonly typescript: "strip" | "transform" | false;
                 /**
                  * A boolean value that is `true` if the current Node.js build includes support for libuv.
-                 * Since it's currently not possible to build Node.js without libuv, this value is always `true`.
+                 *
+                 * Since it's not possible to build Node.js without libuv, this value is always `true`.
                  * @since v0.5.3
+                 * @deprecated This property is always true, and any checks based on it are redundant.
                  */
                 readonly uv: boolean;
             }
@@ -1676,7 +1693,7 @@ declare module "process" {
                  */
                 nextTick(callback: Function, ...args: any[]): void;
                 /**
-                 * This API is available through the [--experimental-permission](https://nodejs.org/api/cli.html#--experimental-permission) flag.
+                 * This API is available through the [--permission](https://nodejs.org/api/cli.html#--permission) flag.
                  *
                  * `process.permission` is an object whose methods are used to manage permissions for the current process.
                  * Additional documentation is available in the [Permission Model](https://nodejs.org/api/permissions.html#permission-model).

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

@@ -149,5 +149,5 @@ declare module "node:sea" {
      * writes to the returned array buffer is likely to result in a crash.
      * @since v20.12.0
      */
-    function getRawAsset(key: AssetKey): string | ArrayBuffer;
+    function getRawAsset(key: AssetKey): ArrayBuffer;
 }