cdk-ecr-deployment 2.5.29 → 2.5.31

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

@@ -11,8 +11,8 @@
  * ```
  * @since v15.0.0
  */
-declare module 'timers/promises' {
-    import { TimerOptions } from 'node:timers';
+declare module "timers/promises" {
+    import { TimerOptions } from "node:timers";
     /**
      * ```js
      * import {
@@ -88,6 +88,6 @@ declare module 'timers/promises' {
     }
     const scheduler: Scheduler;
 }
-declare module 'node:timers/promises' {
-    export * from 'timers/promises';
+declare module "node:timers/promises" {
+    export * from "timers/promises";
 }

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

@@ -8,9 +8,13 @@
  * 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/v20.2.0/lib/timers.js)
  */
-declare module 'timers' {
-    import { Abortable } from 'node:events';
-    import { setTimeout as setTimeoutPromise, setImmediate as setImmediatePromise, setInterval as setIntervalPromise } from 'node:timers/promises';
+declare module "timers" {
+    import { Abortable } from "node:events";
+    import {
+        setImmediate as setImmediatePromise,
+        setInterval as setIntervalPromise,
+        setTimeout as setTimeoutPromise,
+    } from "node:timers/promises";
     interface TimerOptions extends Abortable {
         /**
          * Set to `false` to indicate that the scheduled `Timeout`
@@ -68,6 +72,11 @@ declare module 'timers' {
                  */
                 hasRef(): boolean;
                 _onImmediate: Function; // to distinguish it from the Timeout class
+                /**
+                 * Cancels the immediate. This is similar to calling `clearImmediate()`.
+                 * @since v20.5.0
+                 */
+                [Symbol.dispose](): void;
             }
             /**
              * This object is created internally and is returned from `setTimeout()` and `setInterval()`. It can be passed to either `clearTimeout()` or `clearInterval()` in order to cancel the
@@ -114,6 +123,11 @@ declare module 'timers' {
                  */
                 refresh(): this;
                 [Symbol.toPrimitive](): number;
+                /**
+                 * Cancels the timeout.
+                 * @since v20.5.0
+                 */
+                [Symbol.dispose](): void;
             }
         }
         /**
@@ -135,7 +149,11 @@ declare module 'timers' {
          * @param args Optional arguments to pass when the `callback` is called.
          * @return for use with {@link clearTimeout}
          */
-        function setTimeout<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timeout;
+        function setTimeout<TArgs extends any[]>(
+            callback: (...args: TArgs) => void,
+            ms?: number,
+            ...args: TArgs
+        ): NodeJS.Timeout;
         // util.promisify no rest args compability
         // tslint:disable-next-line void-return
         function setTimeout(callback: (args: void) => void, ms?: number): NodeJS.Timeout;
@@ -163,10 +181,14 @@ declare module 'timers' {
          * @param args Optional arguments to pass when the `callback` is called.
          * @return for use with {@link clearInterval}
          */
-        function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timer;
+        function setInterval<TArgs extends any[]>(
+            callback: (...args: TArgs) => void,
+            ms?: number,
+            ...args: TArgs
+        ): NodeJS.Timeout;
         // util.promisify no rest args compability
         // tslint:disable-next-line void-return
-        function setInterval(callback: (args: void) => void, ms?: number): NodeJS.Timer;
+        function setInterval(callback: (args: void) => void, ms?: number): NodeJS.Timeout;
         namespace setInterval {
             const __promisify__: typeof setIntervalPromise;
         }
@@ -194,7 +216,10 @@ declare module 'timers' {
          * @param args Optional arguments to pass when the `callback` is called.
          * @return for use with {@link clearImmediate}
          */
-        function setImmediate<TArgs extends any[]>(callback: (...args: TArgs) => void, ...args: TArgs): NodeJS.Immediate;
+        function setImmediate<TArgs extends any[]>(
+            callback: (...args: TArgs) => void,
+            ...args: TArgs
+        ): NodeJS.Immediate;
         // util.promisify no rest args compability
         // tslint:disable-next-line void-return
         function setImmediate(callback: (args: void) => void): NodeJS.Immediate;
@@ -210,6 +235,6 @@ declare module 'timers' {
         function queueMicrotask(callback: () => void): void;
     }
 }
-declare module 'node:timers' {
-    export * from 'timers';
+declare module "node:timers" {
+    export * from "timers";
 }

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

@@ -8,10 +8,10 @@
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/tls.js)
  */
-declare module 'tls' {
-    import { X509Certificate } from 'node:crypto';
-    import * as net from 'node:net';
-    import * as stream from 'stream';
+declare module "tls" {
+    import { X509Certificate } from "node:crypto";
+    import * as net from "node:net";
+    import * as stream from "stream";
     const CLIENT_RENEG_LIMIT: number;
     const CLIENT_RENEG_WINDOW: number;
     interface Certificate {
@@ -396,7 +396,7 @@ declare module 'tls' {
                 rejectUnauthorized?: boolean | undefined;
                 requestCert?: boolean | undefined;
             },
-            callback: (err: Error | null) => void
+            callback: (err: Error | null) => void,
         ): undefined | boolean;
         /**
          * The `tlsSocket.setMaxSendFragment()` method sets the maximum TLS fragment size.
@@ -472,35 +472,35 @@ declare module 'tls' {
          */
         exportKeyingMaterial(length: number, label: string, context: Buffer): Buffer;
         addListener(event: string, listener: (...args: any[]) => void): this;
-        addListener(event: 'OCSPResponse', listener: (response: Buffer) => void): this;
-        addListener(event: 'secureConnect', listener: () => void): this;
-        addListener(event: 'session', listener: (session: Buffer) => void): this;
-        addListener(event: 'keylog', listener: (line: Buffer) => void): this;
+        addListener(event: "OCSPResponse", listener: (response: Buffer) => void): this;
+        addListener(event: "secureConnect", listener: () => void): this;
+        addListener(event: "session", listener: (session: Buffer) => void): this;
+        addListener(event: "keylog", listener: (line: Buffer) => void): this;
         emit(event: string | symbol, ...args: any[]): boolean;
-        emit(event: 'OCSPResponse', response: Buffer): boolean;
-        emit(event: 'secureConnect'): boolean;
-        emit(event: 'session', session: Buffer): boolean;
-        emit(event: 'keylog', line: Buffer): boolean;
+        emit(event: "OCSPResponse", response: Buffer): boolean;
+        emit(event: "secureConnect"): boolean;
+        emit(event: "session", session: Buffer): boolean;
+        emit(event: "keylog", line: Buffer): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
-        on(event: 'OCSPResponse', listener: (response: Buffer) => void): this;
-        on(event: 'secureConnect', listener: () => void): this;
-        on(event: 'session', listener: (session: Buffer) => void): this;
-        on(event: 'keylog', listener: (line: Buffer) => void): this;
+        on(event: "OCSPResponse", listener: (response: Buffer) => void): this;
+        on(event: "secureConnect", listener: () => void): this;
+        on(event: "session", listener: (session: Buffer) => void): this;
+        on(event: "keylog", listener: (line: Buffer) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
-        once(event: 'OCSPResponse', listener: (response: Buffer) => void): this;
-        once(event: 'secureConnect', listener: () => void): this;
-        once(event: 'session', listener: (session: Buffer) => void): this;
-        once(event: 'keylog', listener: (line: Buffer) => void): this;
+        once(event: "OCSPResponse", listener: (response: Buffer) => void): this;
+        once(event: "secureConnect", listener: () => void): this;
+        once(event: "session", listener: (session: Buffer) => void): this;
+        once(event: "keylog", listener: (line: Buffer) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: 'OCSPResponse', listener: (response: Buffer) => void): this;
-        prependListener(event: 'secureConnect', listener: () => void): this;
-        prependListener(event: 'session', listener: (session: Buffer) => void): this;
-        prependListener(event: 'keylog', listener: (line: Buffer) => void): this;
+        prependListener(event: "OCSPResponse", listener: (response: Buffer) => void): this;
+        prependListener(event: "secureConnect", listener: () => void): this;
+        prependListener(event: "session", listener: (session: Buffer) => void): this;
+        prependListener(event: "keylog", listener: (line: Buffer) => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: 'OCSPResponse', listener: (response: Buffer) => void): this;
-        prependOnceListener(event: 'secureConnect', listener: () => void): this;
-        prependOnceListener(event: 'session', listener: (session: Buffer) => void): this;
-        prependOnceListener(event: 'keylog', listener: (line: Buffer) => void): this;
+        prependOnceListener(event: "OCSPResponse", listener: (response: Buffer) => void): this;
+        prependOnceListener(event: "secureConnect", listener: () => void): this;
+        prependOnceListener(event: "session", listener: (session: Buffer) => void): this;
+        prependOnceListener(event: "keylog", listener: (line: Buffer) => void): this;
     }
     interface CommonConnectionOptions {
         /**
@@ -561,7 +561,6 @@ declare module 'tls' {
          */
         ticketKeys?: Buffer | undefined;
         /**
-         *
          * @param socket
          * @param identity identity parameter sent from the client.
          * @return pre-shared key that must either be
@@ -677,47 +676,118 @@ declare module 'tls' {
          * 6. keylog
          */
         addListener(event: string, listener: (...args: any[]) => void): this;
-        addListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
-        addListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        addListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
-        addListener(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
-        addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
+        addListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
+        addListener(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void,
+        ): this;
+        addListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        addListener(
+            event: "resumeSession",
+            listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void,
+        ): this;
+        addListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
+        addListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
         emit(event: string | symbol, ...args: any[]): boolean;
-        emit(event: 'tlsClientError', err: Error, tlsSocket: TLSSocket): boolean;
-        emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: () => void): boolean;
-        emit(event: 'OCSPRequest', certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
-        emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void): boolean;
-        emit(event: 'secureConnection', tlsSocket: TLSSocket): boolean;
-        emit(event: 'keylog', line: Buffer, tlsSocket: TLSSocket): boolean;
+        emit(event: "tlsClientError", err: Error, tlsSocket: TLSSocket): boolean;
+        emit(event: "newSession", sessionId: Buffer, sessionData: Buffer, callback: () => void): boolean;
+        emit(
+            event: "OCSPRequest",
+            certificate: Buffer,
+            issuer: Buffer,
+            callback: (err: Error | null, resp: Buffer) => void,
+        ): boolean;
+        emit(
+            event: "resumeSession",
+            sessionId: Buffer,
+            callback: (err: Error | null, sessionData: Buffer | null) => void,
+        ): boolean;
+        emit(event: "secureConnection", tlsSocket: TLSSocket): boolean;
+        emit(event: "keylog", line: Buffer, tlsSocket: TLSSocket): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
-        on(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
-        on(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        on(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
-        on(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
-        on(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
+        on(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
+        on(event: "newSession", listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
+        on(
+            event: "OCSPRequest",
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        on(
+            event: "resumeSession",
+            listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void,
+        ): this;
+        on(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
+        on(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
-        once(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
-        once(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        once(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
-        once(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
-        once(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
+        once(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
+        once(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void,
+        ): this;
+        once(
+            event: "OCSPRequest",
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        once(
+            event: "resumeSession",
+            listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void,
+        ): this;
+        once(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
+        once(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
-        prependListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
-        prependListener(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
-        prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
+        prependListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
+        prependListener(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void,
+        ): this;
+        prependListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        prependListener(
+            event: "resumeSession",
+            listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void,
+        ): this;
+        prependListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
+        prependListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: TLSSocket) => void): this;
-        prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void): this;
-        prependOnceListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependOnceListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void): this;
-        prependOnceListener(event: 'secureConnection', listener: (tlsSocket: TLSSocket) => void): this;
-        prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
+        prependOnceListener(event: "tlsClientError", listener: (err: Error, tlsSocket: TLSSocket) => void): this;
+        prependOnceListener(
+            event: "newSession",
+            listener: (sessionId: Buffer, sessionData: Buffer, callback: () => void) => void,
+        ): this;
+        prependOnceListener(
+            event: "OCSPRequest",
+            listener: (
+                certificate: Buffer,
+                issuer: Buffer,
+                callback: (err: Error | null, resp: Buffer) => void,
+            ) => void,
+        ): this;
+        prependOnceListener(
+            event: "resumeSession",
+            listener: (sessionId: Buffer, callback: (err: Error | null, sessionData: Buffer | null) => void) => void,
+        ): this;
+        prependOnceListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
+        prependOnceListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
     }
     /**
      * @deprecated since v0.11.3 Use `tls.TLSSocket` instead.
@@ -726,8 +796,19 @@ declare module 'tls' {
         encrypted: TLSSocket;
         cleartext: TLSSocket;
     }
-    type SecureVersion = 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
+    type SecureVersion = "TLSv1.3" | "TLSv1.2" | "TLSv1.1" | "TLSv1";
     interface SecureContextOptions {
+        /**
+         * If set, this will be called when a client opens a connection using the ALPN extension.
+         * One argument will be passed to the callback: an object containing `servername` and `protocols` fields,
+         * respectively containing the server name from the SNI extension (if any) and an array of
+         * ALPN protocol name strings. The callback must return either one of the strings listed in `protocols`,
+         * which will be returned to the client as the selected ALPN protocol, or `undefined`,
+         * to reject the connection with a fatal alert. If a string is returned that does not match one of
+         * the client's ALPN protocols, an error will be thrown.
+         * This option cannot be used with the `ALPNProtocols` option, and setting both options will throw an error.
+         */
+        ALPNCallback?: ((arg: { servername: string; protocols: string[] }) => string | undefined) | undefined;
         /**
          * Optionally override the trusted CA certificates. Default is to trust
          * the well-known CAs curated by Mozilla. Mozilla's CAs are completely
@@ -997,7 +1078,12 @@ declare module 'tls' {
      * @since v0.11.3
      */
     function connect(options: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
-    function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
+    function connect(
+        port: number,
+        host?: string,
+        options?: ConnectionOptions,
+        secureConnectListener?: () => void,
+    ): TLSSocket;
     function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
     /**
      * Creates a new secure pair object with two streams, one of which reads and writes
@@ -1032,7 +1118,12 @@ declare module 'tls' {
      * @param requestCert `true` to specify whether a server should request a certificate from a connecting client. Only applies when `isServer` is `true`.
      * @param rejectUnauthorized If not `false` a server automatically reject clients with invalid certificates. Only applies when `isServer` is `true`.
      */
-    function createSecurePair(context?: SecureContext, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
+    function createSecurePair(
+        context?: SecureContext,
+        isServer?: boolean,
+        requestCert?: boolean,
+        rejectUnauthorized?: boolean,
+    ): SecurePair;
     /**
      * {@link createServer} sets the default value of the `honorCipherOrder` option
      * to `true`, other APIs that create secure contexts leave it unset.
@@ -1114,6 +1205,6 @@ declare module 'tls' {
      */
     const rootCertificates: ReadonlyArray<string>;
 }
-declare module 'node:tls' {
-    export * from 'tls';
+declare module "node:tls" {
+    export * from "tls";
 }

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

@@ -96,7 +96,7 @@
  * @experimental
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/trace_events.js)
  */
-declare module 'trace_events' {
+declare module "trace_events" {
     /**
      * The `Tracing` object is used to enable or disable tracing for sets of
      * categories. Instances are created using the
@@ -177,6 +177,6 @@ declare module 'trace_events' {
      */
     function getEnabledCategories(): string | undefined;
 }
-declare module 'node:trace_events' {
-    export * from 'trace_events';
+declare module "node:trace_events" {
+    export * from "trace_events";
 }

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

@@ -23,8 +23,8 @@
  * manually create instances of the `tty.ReadStream` and `tty.WriteStream`classes.
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/tty.js)
  */
-declare module 'tty' {
-    import * as net from 'node:net';
+declare module "tty" {
+    import * as net from "node:net";
     /**
      * The `tty.isatty()` method returns `true` if the given `fd` is associated with
      * a TTY and `false` if it is not, including whenever `fd` is not a non-negative
@@ -83,17 +83,17 @@ declare module 'tty' {
     class WriteStream extends net.Socket {
         constructor(fd: number);
         addListener(event: string, listener: (...args: any[]) => void): this;
-        addListener(event: 'resize', listener: () => void): this;
+        addListener(event: "resize", listener: () => void): this;
         emit(event: string | symbol, ...args: any[]): boolean;
-        emit(event: 'resize'): boolean;
+        emit(event: "resize"): boolean;
         on(event: string, listener: (...args: any[]) => void): this;
-        on(event: 'resize', listener: () => void): this;
+        on(event: "resize", listener: () => void): this;
         once(event: string, listener: (...args: any[]) => void): this;
-        once(event: 'resize', listener: () => void): this;
+        once(event: "resize", listener: () => void): this;
         prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: 'resize', listener: () => void): this;
+        prependListener(event: "resize", listener: () => void): this;
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: 'resize', listener: () => void): this;
+        prependOnceListener(event: "resize", listener: () => void): this;
         /**
          * `writeStream.clearLine()` clears the current line of this `WriteStream` in a
          * direction identified by `dir`.
@@ -203,6 +203,6 @@ declare module 'tty' {
         isTTY: boolean;
     }
 }
-declare module 'node:tty' {
-    export * from 'tty';
+declare module "node:tty" {
+    export * from "tty";
 }

package/node_modules/@types/cacheable-request/node_modules/@types/node/ts4.8/url.d.ts

@@ -7,10 +7,10 @@
  * ```
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/url.js)
  */
-declare module 'url' {
-    import { Blob as NodeBlob } from 'node:buffer';
-    import { ClientRequestArgs } from 'node:http';
-    import { ParsedUrlQuery, ParsedUrlQueryInput } from 'node:querystring';
+declare module "url" {
+    import { Blob as NodeBlob } from "node:buffer";
+    import { ClientRequestArgs } from "node:http";
+    import { ParsedUrlQuery, ParsedUrlQueryInput } from "node:querystring";
     // Input to `url.format`
     interface UrlObject {
         auth?: string | null | undefined;
@@ -66,7 +66,11 @@ declare module 'url' {
      * result would be `{host: 'foo', pathname: '/bar'}` rather than `{pathname: '//foo/bar'}`.
      */
     function parse(urlString: string): UrlWithStringQuery;
-    function parse(urlString: string, parseQueryString: false | undefined, slashesDenoteHost?: boolean): UrlWithStringQuery;
+    function parse(
+        urlString: string,
+        parseQueryString: false | undefined,
+        slashesDenoteHost?: boolean,
+    ): UrlWithStringQuery;
     function parse(urlString: string, parseQueryString: true, slashesDenoteHost?: boolean): UrlWithParsedQuery;
     function parse(urlString: string, parseQueryString: boolean, slashesDenoteHost?: boolean): Url;
     /**
@@ -394,6 +398,20 @@ declare module 'url' {
          * @param id A `'blob:nodedata:...` URL string returned by a prior call to `URL.createObjectURL()`.
          */
         static revokeObjectURL(objectUrl: string): void;
+        /**
+         * Checks if an `input` relative to the `base` can be parsed to a `URL`.
+         *
+         * ```js
+         * const isValid = URL.canParse('/foo', 'https://example.org/'); // true
+         *
+         * const isNotValid = URL.canParse('/foo'); // false
+         * ```
+         * @since v19.9.0
+         * @param input The absolute or relative input URL to parse. If `input` is relative, then `base` is required. If `input` is absolute, the `base` is ignored. If `input` is not a string, it is
+         * `converted to a string` first.
+         * @param base The base URL to resolve against if the `input` is not absolute. If `base` is not a string, it is `converted to a string` first.
+         */
+        static canParse(input: string, base?: string): boolean;
         constructor(input: string, base?: string | URL);
         /**
          * Gets and sets the fragment portion of the URL.
@@ -742,7 +760,14 @@ declare module 'url' {
      * @since v7.5.0, v6.13.0
      */
     class URLSearchParams implements Iterable<[string, string]> {
-        constructor(init?: URLSearchParams | string | Record<string, string | ReadonlyArray<string>> | Iterable<[string, string]> | ReadonlyArray<[string, string]>);
+        constructor(
+            init?:
+                | URLSearchParams
+                | string
+                | Record<string, string | ReadonlyArray<string>>
+                | Iterable<[string, string]>
+                | ReadonlyArray<[string, string]>,
+        );
         /**
          * Append a new name-value pair to the query string.
          */
@@ -776,7 +801,10 @@ declare module 'url' {
          * @param fn Invoked for each name-value pair in the query
          * @param thisArg To be used as `this` value for when `fn` is called
          */
-        forEach<TThis = this>(callback: (this: TThis, value: string, name: string, searchParams: URLSearchParams) => void, thisArg?: TThis): void;
+        forEach<TThis = this>(
+            callback: (this: TThis, value: string, name: string, searchParams: URLSearchParams) => void,
+            thisArg?: TThis,
+        ): void;
         /**
          * Returns the value of the first name-value pair whose name is `name`. If there
          * are no such pairs, `null` is returned.
@@ -864,7 +892,7 @@ declare module 'url' {
         values(): IterableIterator<string>;
         [Symbol.iterator](): IterableIterator<[string, string]>;
     }
-    import { URL as _URL, URLSearchParams as _URLSearchParams } from 'url';
+    import { URL as _URL, URLSearchParams as _URLSearchParams } from "url";
     global {
         interface URLSearchParams extends _URLSearchParams {}
         interface URL extends _URL {}
@@ -880,8 +908,7 @@ declare module 'url' {
         var URL: typeof globalThis extends {
             onmessage: any;
             URL: infer T;
-        }
-            ? T
+        } ? T
             : typeof _URL;
         /**
          * `URLSearchParams` class is a global reference for `require('url').URLSearchParams`
@@ -891,11 +918,10 @@ declare module 'url' {
         var URLSearchParams: typeof globalThis extends {
             onmessage: any;
             URLSearchParams: infer T;
-        }
-            ? T
+        } ? T
             : typeof _URLSearchParams;
     }
 }
-declare module 'node:url' {
-    export * from 'url';
+declare module "node:url" {
+    export * from "url";
 }