cdk-ecr-deployment 2.0.1 → 2.0.5

package/node_modules/@types/cacheable-request/node_modules/@types/node/perf_hooks.d.ts

@@ -26,7 +26,7 @@
  *   performance.measure('A to B', 'A', 'B');
  * });
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/perf_hooks.js)
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/perf_hooks.js)
  */
 declare module 'perf_hooks' {
     import { AsyncResource } from 'node:async_hooks';
@@ -485,7 +485,7 @@ declare module 'perf_hooks' {
     }
     interface RecordableHistogram extends Histogram {
         /**
-         * @since v15.9.0
+         * @since v15.9.0, v14.18.0
          * @param val The amount to record in the histogram.
          */
         record(val: number | bigint): void;
@@ -494,7 +494,7 @@ declare module 'perf_hooks' {
          * previous call to `recordDelta()` and records that amount in the histogram.
          *
          * ## Examples
-         * @since v15.9.0
+         * @since v15.9.0, v14.18.0
          */
         recordDelta(): void;
     }
@@ -546,7 +546,7 @@ declare module 'perf_hooks' {
     }
     /**
      * Returns a `RecordableHistogram`.
-     * @since v15.9.0
+     * @since v15.9.0, v14.18.0
      */
     function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
 }

package/node_modules/@types/cacheable-request/node_modules/@types/node/punycode.d.ts

@@ -24,7 +24,7 @@
  * made available to developers as a convenience. Fixes or other modifications to
  * the module must be directed to the [Punycode.js](https://github.com/bestiejs/punycode.js) project.
  * @deprecated Since v7.0.0 - Deprecated
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/punycode.js)
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/punycode.js)
  */
 declare module 'punycode' {
     /**

package/node_modules/@types/cacheable-request/node_modules/@types/node/querystring.d.ts

@@ -9,7 +9,7 @@
  * The `querystring` API is considered Legacy. While it is still maintained,
  * new code should use the `URLSearchParams` API instead.
  * @deprecated Legacy
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/querystring.js)
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/querystring.js)
  */
 declare module 'querystring' {
     interface StringifyOptions {

package/node_modules/@types/cacheable-request/node_modules/@types/node/readline.d.ts

@@ -1,32 +1,36 @@
 /**
- * The `readline` module provides an interface for reading data from a `Readable` stream (such as `process.stdin`) one line at a time. It can be accessed
- * using:
+ * The `readline` module provides an interface for reading data from a `Readable` stream (such as `process.stdin`) one line at a time.
+ *
+ * To use the promise-based APIs:
  *
  * ```js
- * const readline = require('readline');
+ * import * as readline from 'node:readline/promises';
+ * ```
+ *
+ * To use the callback and sync APIs:
+ *
+ * ```js
+ * import * as readline from 'node:readline';
  * ```
  *
  * The following simple example illustrates the basic use of the `readline` module.
  *
  * ```js
- * const readline = require('readline');
+ * import * as readline from 'node:readline/promises';
+ * import { stdin as input, stdout as output } from 'process';
+ *
+ * const rl = readline.createInterface({ input, output });
  *
- * const rl = readline.createInterface({
- *   input: process.stdin,
- *   output: process.stdout
- * });
+ * const answer = await rl.question('What do you think of Node.js? ');
  *
- * rl.question('What do you think of Node.js? ', (answer) => {
- *   // TODO: Log the answer in a database
- *   console.log(`Thank you for your valuable feedback: ${answer}`);
+ * console.log(`Thank you for your valuable feedback: ${answer}`);
  *
- *   rl.close();
- * });
+ * rl.close();
  * ```
  *
  * Once this code is invoked, the Node.js application will not terminate until the`readline.Interface` is closed because the interface waits for data to be
  * received on the `input` stream.
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/readline.js)
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/readline.js)
  */
 declare module 'readline' {
     import { Abortable, EventEmitter } from 'node:events';
@@ -394,6 +398,109 @@ declare module 'readline' {
      * if (process.stdin.isTTY)
      *   process.stdin.setRawMode(true);
      * ```
+     *
+     * ## Example: Tiny CLI
+     *
+     * The following example illustrates the use of `readline.Interface` class to
+     * implement a small command-line interface:
+     *
+     * ```js
+     * const readline = require('readline');
+     * const rl = readline.createInterface({
+     *   input: process.stdin,
+     *   output: process.stdout,
+     *   prompt: 'OHAI> '
+     * });
+     *
+     * rl.prompt();
+     *
+     * rl.on('line', (line) => {
+     *   switch (line.trim()) {
+     *     case 'hello':
+     *       console.log('world!');
+     *       break;
+     *     default:
+     *       console.log(`Say what? I might have heard '${line.trim()}'`);
+     *       break;
+     *   }
+     *   rl.prompt();
+     * }).on('close', () => {
+     *   console.log('Have a great day!');
+     *   process.exit(0);
+     * });
+     * ```
+     *
+     * ## Example: Read file stream line-by-Line
+     *
+     * A common use case for `readline` is to consume an input file one line at a
+     * time. The easiest way to do so is leveraging the `fs.ReadStream` API as
+     * well as a `for await...of` loop:
+     *
+     * ```js
+     * const fs = require('fs');
+     * const readline = require('readline');
+     *
+     * async function processLineByLine() {
+     *   const fileStream = fs.createReadStream('input.txt');
+     *
+     *   const rl = readline.createInterface({
+     *     input: fileStream,
+     *     crlfDelay: Infinity
+     *   });
+     *   // Note: we use the crlfDelay option to recognize all instances of CR LF
+     *   // ('\r\n') in input.txt as a single line break.
+     *
+     *   for await (const line of rl) {
+     *     // Each line in input.txt will be successively available here as `line`.
+     *     console.log(`Line from file: ${line}`);
+     *   }
+     * }
+     *
+     * processLineByLine();
+     * ```
+     *
+     * Alternatively, one could use the `'line'` event:
+     *
+     * ```js
+     * const fs = require('fs');
+     * const readline = require('readline');
+     *
+     * const rl = readline.createInterface({
+     *   input: fs.createReadStream('sample.txt'),
+     *   crlfDelay: Infinity
+     * });
+     *
+     * rl.on('line', (line) => {
+     *   console.log(`Line from file: ${line}`);
+     * });
+     * ```
+     *
+     * Currently, `for await...of` loop can be a bit slower. If `async` / `await`flow and speed are both essential, a mixed approach can be applied:
+     *
+     * ```js
+     * const { once } = require('events');
+     * const { createReadStream } = require('fs');
+     * const { createInterface } = require('readline');
+     *
+     * (async function processLineByLine() {
+     *   try {
+     *     const rl = createInterface({
+     *       input: createReadStream('big-file.txt'),
+     *       crlfDelay: Infinity
+     *     });
+     *
+     *     rl.on('line', (line) => {
+     *       // Process the line.
+     *     });
+     *
+     *     await once(rl, 'close');
+     *
+     *     console.log('File processed.');
+     *   } catch (err) {
+     *     console.error(err);
+     *   }
+     * })();
+     * ```
      * @since v0.7.7
      */
     function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;

package/node_modules/@types/cacheable-request/node_modules/@types/node/repl.d.ts

@@ -6,7 +6,7 @@
  * ```js
  * const repl = require('repl');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/repl.js)
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/repl.js)
  */
 declare module 'repl' {
     import { Interface, Completer, AsyncCompleter } from 'node:readline';

package/node_modules/@types/cacheable-request/node_modules/@types/node/stream/web.d.ts

@@ -1,7 +1,6 @@
 declare module 'stream/web' {
     // stub module, pending copy&paste from .d.ts or manual impl
     // copy from lib.dom.d.ts
-
     interface ReadableWritablePair<R = any, W = any> {
         readable: ReadableStream<R>;
         /**
@@ -15,7 +14,6 @@ declare module 'stream/web' {
          */
         writable: WritableStream<W>;
     }
-
     interface StreamPipeOptions {
         preventAbort?: boolean;
         preventCancel?: boolean;
@@ -63,70 +61,53 @@ declare module 'stream/web' {
         preventClose?: boolean;
         signal?: AbortSignal;
     }
-
     interface ReadableStreamGenericReader {
         readonly closed: Promise<undefined>;
         cancel(reason?: any): Promise<void>;
     }
-
     interface ReadableStreamDefaultReadValueResult<T> {
         done: false;
         value: T;
     }
-
     interface ReadableStreamDefaultReadDoneResult {
         done: true;
         value?: undefined;
     }
     type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
-    type ReadableStreamDefaultReadResult<T> =
-        | ReadableStreamDefaultReadValueResult<T>
-        | ReadableStreamDefaultReadDoneResult;
-
+    type ReadableStreamDefaultReadResult<T> = ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult;
     interface ReadableByteStreamControllerCallback {
         (controller: ReadableByteStreamController): void | PromiseLike<void>;
     }
-
     interface UnderlyingSinkAbortCallback {
         (reason?: any): void | PromiseLike<void>;
     }
-
     interface UnderlyingSinkCloseCallback {
         (): void | PromiseLike<void>;
     }
-
     interface UnderlyingSinkStartCallback {
         (controller: WritableStreamDefaultController): any;
     }
-
     interface UnderlyingSinkWriteCallback<W> {
         (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
     }
-
     interface UnderlyingSourceCancelCallback {
         (reason?: any): void | PromiseLike<void>;
     }
-
     interface UnderlyingSourcePullCallback<R> {
         (controller: ReadableStreamController<R>): void | PromiseLike<void>;
     }
-
     interface UnderlyingSourceStartCallback<R> {
         (controller: ReadableStreamController<R>): any;
     }
-
     interface TransformerFlushCallback<O> {
         (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
     }
-
     interface TransformerStartCallback<O> {
         (controller: TransformStreamDefaultController<O>): any;
     }
-
     interface TransformerTransformCallback<I, O> {
         (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
     }
-
     interface UnderlyingByteSource {
         autoAllocateChunkSize?: number;
         cancel?: ReadableStreamErrorCallback;
@@ -134,14 +115,12 @@ declare module 'stream/web' {
         start?: ReadableByteStreamControllerCallback;
         type: 'bytes';
     }
-
     interface UnderlyingSource<R = any> {
         cancel?: UnderlyingSourceCancelCallback;
         pull?: UnderlyingSourcePullCallback<R>;
         start?: UnderlyingSourceStartCallback<R>;
         type?: undefined;
     }
-
     interface UnderlyingSink<W = any> {
         abort?: UnderlyingSinkAbortCallback;
         close?: UnderlyingSinkCloseCallback;
@@ -149,11 +128,9 @@ declare module 'stream/web' {
         type?: undefined;
         write?: UnderlyingSinkWriteCallback<W>;
     }
-
     interface ReadableStreamErrorCallback {
         (reason: any): void | PromiseLike<void>;
     }
-
     /** This Streams API interface represents a readable stream of byte data. */
     interface ReadableStream<R = any> {
         readonly locked: boolean;
@@ -164,29 +141,21 @@ declare module 'stream/web' {
         tee(): [ReadableStream<R>, ReadableStream<R>];
         [Symbol.asyncIterator](options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
     }
-
     const ReadableStream: {
         prototype: ReadableStream;
-        new (
-            underlyingSource: UnderlyingByteSource,
-            strategy?: QueuingStrategy<Uint8Array>,
-        ): ReadableStream<Uint8Array>;
+        new (underlyingSource: UnderlyingByteSource, strategy?: QueuingStrategy<Uint8Array>): ReadableStream<Uint8Array>;
         new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
     };
-
     interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
         read(): Promise<ReadableStreamDefaultReadResult<R>>;
         releaseLock(): void;
     }
-
     const ReadableStreamDefaultReader: {
         prototype: ReadableStreamDefaultReader;
         new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
     };
-
     const ReadableStreamBYOBReader: any;
     const ReadableStreamBYOBRequest: any;
-
     interface ReadableByteStreamController {
         readonly byobRequest: undefined;
         readonly desiredSize: number | null;
@@ -194,24 +163,20 @@ declare module 'stream/web' {
         enqueue(chunk: ArrayBufferView): void;
         error(error?: any): void;
     }
-
     const ReadableByteStreamController: {
         prototype: ReadableByteStreamController;
         new (): ReadableByteStreamController;
     };
-
     interface ReadableStreamDefaultController<R = any> {
         readonly desiredSize: number | null;
         close(): void;
         enqueue(chunk?: R): void;
         error(e?: any): void;
     }
-
     const ReadableStreamDefaultController: {
         prototype: ReadableStreamDefaultController;
         new (): ReadableStreamDefaultController;
     };
-
     interface Transformer<I = any, O = any> {
         flush?: TransformerFlushCallback<O>;
         readableType?: undefined;
@@ -219,33 +184,24 @@ declare module 'stream/web' {
         transform?: TransformerTransformCallback<I, O>;
         writableType?: undefined;
     }
-
     interface TransformStream<I = any, O = any> {
         readonly readable: ReadableStream<O>;
         readonly writable: WritableStream<I>;
     }
-
     const TransformStream: {
         prototype: TransformStream;
-        new <I = any, O = any>(
-            transformer?: Transformer<I, O>,
-            writableStrategy?: QueuingStrategy<I>,
-            readableStrategy?: QueuingStrategy<O>,
-        ): TransformStream<I, O>;
+        new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
     };
-
     interface TransformStreamDefaultController<O = any> {
         readonly desiredSize: number | null;
         enqueue(chunk?: O): void;
         error(reason?: any): void;
         terminate(): void;
     }
-
     const TransformStreamDefaultController: {
         prototype: TransformStreamDefaultController;
         new (): TransformStreamDefaultController;
     };
-
     /**
      * This Streams API interface provides a standard abstraction for writing
      * streaming data to a destination, known as a sink. This object comes with
@@ -257,12 +213,10 @@ declare module 'stream/web' {
         close(): Promise<void>;
         getWriter(): WritableStreamDefaultWriter<W>;
     }
-
     const WritableStream: {
         prototype: WritableStream;
         new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
     };
-
     /**
      * This Streams API interface is the object returned by
      * WritableStream.getWriter() and once created locks the < writer to the
@@ -278,12 +232,10 @@ declare module 'stream/web' {
         releaseLock(): void;
         write(chunk?: W): Promise<void>;
     }
-
     const WritableStreamDefaultWriter: {
         prototype: WritableStreamDefaultWriter;
         new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
     };
-
     /**
      * This Streams API interface represents a controller allowing control of a
      * WritableStream's state. When constructing a WritableStream, the
@@ -293,21 +245,17 @@ declare module 'stream/web' {
     interface WritableStreamDefaultController {
         error(e?: any): void;
     }
-
     const WritableStreamDefaultController: {
         prototype: WritableStreamDefaultController;
         new (): WritableStreamDefaultController;
     };
-
     interface QueuingStrategy<T = any> {
         highWaterMark?: number;
         size?: QueuingStrategySize<T>;
     }
-
     interface QueuingStrategySize<T = any> {
         (chunk?: T): number;
     }
-
     interface QueuingStrategyInit {
         /**
          * Creates a new ByteLengthQueuingStrategy with the provided high water
@@ -320,7 +268,6 @@ declare module 'stream/web' {
          */
         highWaterMark: number;
     }
-
     /**
      * This Streams API interface provides a built-in byte length queuing
      * strategy that can be used when constructing streams.
@@ -329,12 +276,10 @@ declare module 'stream/web' {
         readonly highWaterMark: number;
         readonly size: QueuingStrategySize<ArrayBufferView>;
     }
-
     const ByteLengthQueuingStrategy: {
         prototype: ByteLengthQueuingStrategy;
         new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
     };
-
     /**
      * This Streams API interface provides a built-in byte length queuing
      * strategy that can be used when constructing streams.
@@ -343,12 +288,10 @@ declare module 'stream/web' {
         readonly highWaterMark: number;
         readonly size: QueuingStrategySize;
     }
-
     const CountQueuingStrategy: {
         prototype: CountQueuingStrategy;
         new (init: QueuingStrategyInit): CountQueuingStrategy;
     };
-
     interface TextEncoderStream {
         /** Returns "utf-8". */
         readonly encoding: 'utf-8';
@@ -356,19 +299,15 @@ declare module 'stream/web' {
         readonly writable: WritableStream<string>;
         readonly [Symbol.toStringTag]: string;
     }
-
     const TextEncoderStream: {
         prototype: TextEncoderStream;
         new (): TextEncoderStream;
     };
-
     interface TextDecoderOptions {
         fatal?: boolean;
         ignoreBOM?: boolean;
     }
-
     type BufferSource = ArrayBufferView | ArrayBuffer;
-
     interface TextDecoderStream {
         /** Returns encoding's name, lower cased. */
         readonly encoding: string;
@@ -380,7 +319,6 @@ declare module 'stream/web' {
         readonly writable: WritableStream<BufferSource>;
         readonly [Symbol.toStringTag]: string;
     }
-
     const TextDecoderStream: {
         prototype: TextDecoderStream;
         new (label?: string, options?: TextDecoderOptions): TextDecoderStream;

package/node_modules/@types/cacheable-request/node_modules/@types/node/stream.d.ts

@@ -14,7 +14,7 @@
  *
  * The `stream` module is useful for creating new types of stream instances. It is
  * usually not necessary to use the `stream` module to consume streams.
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/stream.js)
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/stream.js)
  */
 declare module 'stream' {
     import { EventEmitter, Abortable } from 'node:events';
@@ -71,7 +71,7 @@ declare module 'stream' {
             readable: boolean;
             /**
              * Returns whether `'data'` has been emitted.
-             * @since v16.7.0
+             * @since v16.7.0, v14.18.0
              * @experimental
              */
             readonly readableDidRead: boolean;

package/node_modules/@types/cacheable-request/node_modules/@types/node/string_decoder.d.ts

@@ -36,7 +36,7 @@
  * decoder.write(Buffer.from([0x82]));
  * console.log(decoder.end(Buffer.from([0xAC])));
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/string_decoder.js)
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/string_decoder.js)
  */
 declare module 'string_decoder' {
     class StringDecoder {

package/node_modules/@types/cacheable-request/node_modules/@types/node/timers.d.ts

@@ -6,7 +6,7 @@
  * The timer functions within Node.js implement a similar API as the timers API
  * provided by Web Browsers but use a different internal implementation that is
  * built around the Node.js [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout).
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/timers.js)
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/timers.js)
  */
 declare module 'timers' {
     import { Abortable } from 'node:events';

package/node_modules/@types/cacheable-request/node_modules/@types/node/tls.d.ts

@@ -6,7 +6,7 @@
  * ```js
  * const tls = require('tls');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/tls.js)
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/tls.js)
  */
 declare module 'tls' {
     import { X509Certificate } from 'node:crypto';

package/node_modules/@types/cacheable-request/node_modules/@types/node/trace_events.d.ts

@@ -73,7 +73,7 @@
  *
  * The features from this module are not available in `Worker` threads.
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/trace_events.js)
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/trace_events.js)
  */
 declare module 'trace_events' {
     /**

package/node_modules/@types/cacheable-request/node_modules/@types/node/tty.d.ts

@@ -22,7 +22,7 @@
  *
  * In most cases, there should be little to no reason for an application to
  * manually create instances of the `tty.ReadStream` and `tty.WriteStream`classes.
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/tty.js)
+ * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/tty.js)
  */
 declare module 'tty' {
     import * as net from 'node:net';