cdk-common 2.0.221 → 2.0.224

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

@@ -0,0 +1,413 @@
+declare module 'process' {
+    import * as tty from 'tty';
+
+    global {
+        var process: NodeJS.Process;
+
+        namespace NodeJS {
+            // this namespace merge is here because these are specifically used
+            // as the type for process.stdin, process.stdout, and process.stderr.
+            // they can't live in tty.d.ts because we need to disambiguate the imported name.
+            interface ReadStream extends tty.ReadStream {}
+            interface WriteStream extends tty.WriteStream {}
+
+            interface MemoryUsage {
+                rss: number;
+                heapTotal: number;
+                heapUsed: number;
+                external: number;
+                arrayBuffers: number;
+            }
+
+            interface CpuUsage {
+                user: number;
+                system: number;
+            }
+
+            interface ProcessRelease {
+                name: string;
+                sourceUrl?: string | undefined;
+                headersUrl?: string | undefined;
+                libUrl?: string | undefined;
+                lts?: string | undefined;
+            }
+
+            interface ProcessVersions extends Dict<string> {
+                http_parser: string;
+                node: string;
+                v8: string;
+                ares: string;
+                uv: string;
+                zlib: string;
+                modules: string;
+                openssl: string;
+            }
+
+            type Platform = 'aix'
+                | 'android'
+                | 'darwin'
+                | 'freebsd'
+                | 'linux'
+                | 'openbsd'
+                | 'sunos'
+                | 'win32'
+                | 'cygwin'
+                | 'netbsd';
+
+            type Signals =
+                "SIGABRT" | "SIGALRM" | "SIGBUS" | "SIGCHLD" | "SIGCONT" | "SIGFPE" | "SIGHUP" | "SIGILL" | "SIGINT" | "SIGIO" |
+                "SIGIOT" | "SIGKILL" | "SIGPIPE" | "SIGPOLL" | "SIGPROF" | "SIGPWR" | "SIGQUIT" | "SIGSEGV" | "SIGSTKFLT" |
+                "SIGSTOP" | "SIGSYS" | "SIGTERM" | "SIGTRAP" | "SIGTSTP" | "SIGTTIN" | "SIGTTOU" | "SIGUNUSED" | "SIGURG" |
+                "SIGUSR1" | "SIGUSR2" | "SIGVTALRM" | "SIGWINCH" | "SIGXCPU" | "SIGXFSZ" | "SIGBREAK" | "SIGLOST" | "SIGINFO";
+
+            type UncaughtExceptionOrigin = 'uncaughtException' | 'unhandledRejection';
+            type MultipleResolveType = 'resolve' | 'reject';
+
+            type BeforeExitListener = (code: number) => void;
+            type DisconnectListener = () => void;
+            type ExitListener = (code: number) => void;
+            type RejectionHandledListener = (promise: Promise<any>) => void;
+            type UncaughtExceptionListener = (error: Error, origin: UncaughtExceptionOrigin) => void;
+            type UnhandledRejectionListener = (reason: {} | null | undefined, promise: Promise<any>) => void;
+            type WarningListener = (warning: Error) => void;
+            type MessageListener = (message: any, sendHandle: any) => void;
+            type SignalsListener = (signal: Signals) => void;
+            type NewListenerListener = (type: string | symbol, listener: (...args: any[]) => void) => void;
+            type RemoveListenerListener = (type: string | symbol, listener: (...args: any[]) => void) => void;
+            type MultipleResolveListener = (type: MultipleResolveType, promise: Promise<any>, value: any) => void;
+
+            interface Socket extends ReadWriteStream {
+                isTTY?: true | undefined;
+            }
+
+            // Alias for compatibility
+            interface ProcessEnv extends Dict<string> {}
+
+            interface HRTime {
+                (time?: [number, number]): [number, number];
+                bigint(): bigint;
+            }
+
+            interface ProcessReport {
+                /**
+                 * Directory where the report is written.
+                 * working directory of the Node.js process.
+                 * @default '' indicating that reports are written to the current
+                 */
+                directory: string;
+
+                /**
+                 * Filename where the report is written.
+                 * The default value is the empty string.
+                 * @default '' the output filename will be comprised of a timestamp,
+                 * PID, and sequence number.
+                 */
+                filename: string;
+
+                /**
+                 * Returns a JSON-formatted diagnostic report for the running process.
+                 * The report's JavaScript stack trace is taken from err, if present.
+                 */
+                getReport(err?: Error): string;
+
+                /**
+                 * If true, a diagnostic report is generated on fatal errors,
+                 * such as out of memory errors or failed C++ assertions.
+                 * @default false
+                 */
+                reportOnFatalError: boolean;
+
+                /**
+                 * If true, a diagnostic report is generated when the process
+                 * receives the signal specified by process.report.signal.
+                 * @default false
+                 */
+                reportOnSignal: boolean;
+
+                /**
+                 * If true, a diagnostic report is generated on uncaught exception.
+                 * @default false
+                 */
+                reportOnUncaughtException: boolean;
+
+                /**
+                 * The signal used to trigger the creation of a diagnostic report.
+                 * @default 'SIGUSR2'
+                 */
+                signal: Signals;
+
+                /**
+                 * Writes a diagnostic report to a file. If filename is not provided, the default filename
+                 * includes the date, time, PID, and a sequence number.
+                 * The report's JavaScript stack trace is taken from err, if present.
+                 *
+                 * @param fileName Name of the file where the report is written.
+                 * This should be a relative path, that will be appended to the directory specified in
+                 * `process.report.directory`, or the current working directory of the Node.js process,
+                 * if unspecified.
+                 * @param error A custom error used for reporting the JavaScript stack.
+                 * @return Filename of the generated report.
+                 */
+                writeReport(fileName?: string): string;
+                writeReport(error?: Error): string;
+                writeReport(fileName?: string, err?: Error): string;
+            }
+
+            interface ResourceUsage {
+                fsRead: number;
+                fsWrite: number;
+                involuntaryContextSwitches: number;
+                ipcReceived: number;
+                ipcSent: number;
+                majorPageFault: number;
+                maxRSS: number;
+                minorPageFault: number;
+                sharedMemorySize: number;
+                signalsCount: number;
+                swappedOut: number;
+                systemCPUTime: number;
+                unsharedDataSize: number;
+                unsharedStackSize: number;
+                userCPUTime: number;
+                voluntaryContextSwitches: number;
+            }
+
+            interface Process extends EventEmitter {
+                /**
+                 * Can also be a tty.WriteStream, not typed due to limitations.
+                 */
+                stdout: WriteStream & {
+                    fd: 1;
+                };
+                /**
+                 * Can also be a tty.WriteStream, not typed due to limitations.
+                 */
+                stderr: WriteStream & {
+                    fd: 2;
+                };
+                stdin: ReadStream & {
+                    fd: 0;
+                };
+                openStdin(): Socket;
+                argv: string[];
+                argv0: string;
+                execArgv: string[];
+                execPath: string;
+                abort(): never;
+                chdir(directory: string): void;
+                cwd(): string;
+                debugPort: number;
+                emitWarning(warning: string | Error, name?: string, ctor?: Function): void;
+                env: ProcessEnv;
+                exit(code?: number): never;
+                exitCode?: number | undefined;
+                getgid(): number;
+                setgid(id: number | string): void;
+                getuid(): number;
+                setuid(id: number | string): void;
+                geteuid(): number;
+                seteuid(id: number | string): void;
+                getegid(): number;
+                setegid(id: number | string): void;
+                getgroups(): number[];
+                setgroups(groups: ReadonlyArray<string | number>): void;
+                setUncaughtExceptionCaptureCallback(cb: ((err: Error) => void) | null): void;
+                hasUncaughtExceptionCaptureCallback(): boolean;
+                version: string;
+                versions: ProcessVersions;
+                config: {
+                    target_defaults: {
+                        cflags: any[];
+                        default_configuration: string;
+                        defines: string[];
+                        include_dirs: string[];
+                        libraries: string[];
+                    };
+                    variables: {
+                        clang: number;
+                        host_arch: string;
+                        node_install_npm: boolean;
+                        node_install_waf: boolean;
+                        node_prefix: string;
+                        node_shared_openssl: boolean;
+                        node_shared_v8: boolean;
+                        node_shared_zlib: boolean;
+                        node_use_dtrace: boolean;
+                        node_use_etw: boolean;
+                        node_use_openssl: boolean;
+                        target_arch: string;
+                        v8_no_strict_aliasing: number;
+                        v8_use_snapshot: boolean;
+                        visibility: string;
+                    };
+                };
+                kill(pid: number, signal?: string | number): true;
+                pid: number;
+                ppid: number;
+                title: string;
+                arch: string;
+                platform: Platform;
+                /** @deprecated since v14.0.0 - use `require.main` instead. */
+                mainModule?: Module | undefined;
+                memoryUsage(): MemoryUsage;
+                cpuUsage(previousValue?: CpuUsage): CpuUsage;
+                nextTick(callback: Function, ...args: any[]): void;
+                release: ProcessRelease;
+                features: {
+                    inspector: boolean;
+                    debug: boolean;
+                    uv: boolean;
+                    ipv6: boolean;
+                    tls_alpn: boolean;
+                    tls_sni: boolean;
+                    tls_ocsp: boolean;
+                    tls: boolean;
+                };
+                /**
+                 * @deprecated since v14.0.0 - Calling process.umask() with no argument causes
+                 * the process-wide umask to be written twice. This introduces a race condition between threads,
+                 * and is a potential security vulnerability. There is no safe, cross-platform alternative API.
+                 */
+                umask(): number;
+                /**
+                 * Can only be set if not in worker thread.
+                 */
+                umask(mask: string | number): number;
+                uptime(): number;
+                hrtime: HRTime;
+                domain: Domain;
+
+                // Worker
+                send?(message: any, sendHandle?: any, options?: { swallowErrors?: boolean | undefined}, callback?: (error: Error | null) => void): boolean;
+                disconnect(): void;
+                connected: boolean;
+
+                /**
+                 * The `process.allowedNodeEnvironmentFlags` property is a special,
+                 * read-only `Set` of flags allowable within the [`NODE_OPTIONS`][]
+                 * environment variable.
+                 */
+                allowedNodeEnvironmentFlags: ReadonlySet<string>;
+
+                /**
+                 * Only available with `--experimental-report`
+                 */
+                report?: ProcessReport | undefined;
+
+                resourceUsage(): ResourceUsage;
+
+                traceDeprecation: boolean;
+
+                /* EventEmitter */
+                addListener(event: "beforeExit", listener: BeforeExitListener): this;
+                addListener(event: "disconnect", listener: DisconnectListener): this;
+                addListener(event: "exit", listener: ExitListener): this;
+                addListener(event: "rejectionHandled", listener: RejectionHandledListener): this;
+                addListener(event: "uncaughtException", listener: UncaughtExceptionListener): this;
+                addListener(event: "uncaughtExceptionMonitor", listener: UncaughtExceptionListener): this;
+                addListener(event: "unhandledRejection", listener: UnhandledRejectionListener): this;
+                addListener(event: "warning", listener: WarningListener): this;
+                addListener(event: "message", listener: MessageListener): this;
+                addListener(event: Signals, listener: SignalsListener): this;
+                addListener(event: "newListener", listener: NewListenerListener): this;
+                addListener(event: "removeListener", listener: RemoveListenerListener): this;
+                addListener(event: "multipleResolves", listener: MultipleResolveListener): this;
+
+                emit(event: "beforeExit", code: number): boolean;
+                emit(event: "disconnect"): boolean;
+                emit(event: "exit", code: number): boolean;
+                emit(event: "rejectionHandled", promise: Promise<any>): boolean;
+                emit(event: "uncaughtException", error: Error): boolean;
+                emit(event: "uncaughtExceptionMonitor", error: Error): boolean;
+                emit(event: "unhandledRejection", reason: any, promise: Promise<any>): boolean;
+                emit(event: "warning", warning: Error): boolean;
+                emit(event: "message", message: any, sendHandle: any): this;
+                emit(event: Signals, signal: Signals): boolean;
+                emit(event: "newListener", eventName: string | symbol, listener: (...args: any[]) => void): this;
+                emit(event: "removeListener", eventName: string, listener: (...args: any[]) => void): this;
+                emit(event: "multipleResolves", listener: MultipleResolveListener): this;
+
+                on(event: "beforeExit", listener: BeforeExitListener): this;
+                on(event: "disconnect", listener: DisconnectListener): this;
+                on(event: "exit", listener: ExitListener): this;
+                on(event: "rejectionHandled", listener: RejectionHandledListener): this;
+                on(event: "uncaughtException", listener: UncaughtExceptionListener): this;
+                on(event: "uncaughtExceptionMonitor", listener: UncaughtExceptionListener): this;
+                on(event: "unhandledRejection", listener: UnhandledRejectionListener): this;
+                on(event: "warning", listener: WarningListener): this;
+                on(event: "message", listener: MessageListener): this;
+                on(event: Signals, listener: SignalsListener): this;
+                on(event: "newListener", listener: NewListenerListener): this;
+                on(event: "removeListener", listener: RemoveListenerListener): this;
+                on(event: "multipleResolves", listener: MultipleResolveListener): this;
+                on(event: string | symbol, listener: (...args: any[]) => void): this;
+
+                once(event: "beforeExit", listener: BeforeExitListener): this;
+                once(event: "disconnect", listener: DisconnectListener): this;
+                once(event: "exit", listener: ExitListener): this;
+                once(event: "rejectionHandled", listener: RejectionHandledListener): this;
+                once(event: "uncaughtException", listener: UncaughtExceptionListener): this;
+                once(event: "uncaughtExceptionMonitor", listener: UncaughtExceptionListener): this;
+                once(event: "unhandledRejection", listener: UnhandledRejectionListener): this;
+                once(event: "warning", listener: WarningListener): this;
+                once(event: "message", listener: MessageListener): this;
+                once(event: Signals, listener: SignalsListener): this;
+                once(event: "newListener", listener: NewListenerListener): this;
+                once(event: "removeListener", listener: RemoveListenerListener): this;
+                once(event: "multipleResolves", listener: MultipleResolveListener): this;
+
+                prependListener(event: "beforeExit", listener: BeforeExitListener): this;
+                prependListener(event: "disconnect", listener: DisconnectListener): this;
+                prependListener(event: "exit", listener: ExitListener): this;
+                prependListener(event: "rejectionHandled", listener: RejectionHandledListener): this;
+                prependListener(event: "uncaughtException", listener: UncaughtExceptionListener): this;
+                prependListener(event: "uncaughtExceptionMonitor", listener: UncaughtExceptionListener): this;
+                prependListener(event: "unhandledRejection", listener: UnhandledRejectionListener): this;
+                prependListener(event: "warning", listener: WarningListener): this;
+                prependListener(event: "message", listener: MessageListener): this;
+                prependListener(event: Signals, listener: SignalsListener): this;
+                prependListener(event: "newListener", listener: NewListenerListener): this;
+                prependListener(event: "removeListener", listener: RemoveListenerListener): this;
+                prependListener(event: "multipleResolves", listener: MultipleResolveListener): this;
+
+                prependOnceListener(event: "beforeExit", listener: BeforeExitListener): this;
+                prependOnceListener(event: "disconnect", listener: DisconnectListener): this;
+                prependOnceListener(event: "exit", listener: ExitListener): this;
+                prependOnceListener(event: "rejectionHandled", listener: RejectionHandledListener): this;
+                prependOnceListener(event: "uncaughtException", listener: UncaughtExceptionListener): this;
+                prependOnceListener(event: "uncaughtExceptionMonitor", listener: UncaughtExceptionListener): this;
+                prependOnceListener(event: "unhandledRejection", listener: UnhandledRejectionListener): this;
+                prependOnceListener(event: "warning", listener: WarningListener): this;
+                prependOnceListener(event: "message", listener: MessageListener): this;
+                prependOnceListener(event: Signals, listener: SignalsListener): this;
+                prependOnceListener(event: "newListener", listener: NewListenerListener): this;
+                prependOnceListener(event: "removeListener", listener: RemoveListenerListener): this;
+                prependOnceListener(event: "multipleResolves", listener: MultipleResolveListener): this;
+
+                listeners(event: "beforeExit"): BeforeExitListener[];
+                listeners(event: "disconnect"): DisconnectListener[];
+                listeners(event: "exit"): ExitListener[];
+                listeners(event: "rejectionHandled"): RejectionHandledListener[];
+                listeners(event: "uncaughtException"): UncaughtExceptionListener[];
+                listeners(event: "uncaughtExceptionMonitor"): UncaughtExceptionListener[];
+                listeners(event: "unhandledRejection"): UnhandledRejectionListener[];
+                listeners(event: "warning"): WarningListener[];
+                listeners(event: "message"): MessageListener[];
+                listeners(event: Signals): SignalsListener[];
+                listeners(event: "newListener"): NewListenerListener[];
+                listeners(event: "removeListener"): RemoveListenerListener[];
+                listeners(event: "multipleResolves"): MultipleResolveListener[];
+            }
+
+            interface Global {
+                process: Process;
+            }
+        }
+    }
+
+    export = process;
+}
+declare module 'node:process' {
+    import process = require('process');
+    export = process;
+}

package/node_modules/{@aws-cdk/cloudformation-diff/node_modules/@types → @types}/node/punycode.d.ts

@@ -1,4 +1,11 @@
-declare module "punycode" {
+/**
+ * @deprecated since v7.0.0
+ * The version of the punycode module bundled in Node.js is being deprecated.
+ * In a future major version of Node.js this module will be removed.
+ * Users currently depending on the punycode module should switch to using
+ * the userland-provided Punycode.js module instead.
+ */
+declare module 'punycode' {
     /**
      * @deprecated since v7.0.0
      * The version of the punycode module bundled in Node.js is being deprecated.
@@ -66,3 +73,6 @@ declare module "punycode" {
      */
     const version: string;
 }
+declare module 'node:punycode' {
+    export * from 'punycode';
+}

package/node_modules/@types/node/querystring.d.ts

@@ -0,0 +1,31 @@
+declare module 'querystring' {
+    interface StringifyOptions {
+        encodeURIComponent?: ((str: string) => string) | undefined;
+    }
+
+    interface ParseOptions {
+        maxKeys?: number | undefined;
+        decodeURIComponent?: ((str: string) => string) | undefined;
+    }
+
+    interface ParsedUrlQuery extends NodeJS.Dict<string | string[]> { }
+
+    interface ParsedUrlQueryInput extends NodeJS.Dict<string | number | boolean | ReadonlyArray<string> | ReadonlyArray<number> | ReadonlyArray<boolean> | null> {
+    }
+
+    function stringify(obj?: ParsedUrlQueryInput, sep?: string, eq?: string, options?: StringifyOptions): string;
+    function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): ParsedUrlQuery;
+    /**
+     * The querystring.encode() function is an alias for querystring.stringify().
+     */
+    const encode: typeof stringify;
+    /**
+     * The querystring.decode() function is an alias for querystring.parse().
+     */
+    const decode: typeof parse;
+    function escape(str: string): string;
+    function unescape(str: string): string;
+}
+declare module 'node:querystring' {
+    export * from 'querystring';
+}

package/node_modules/{@aws-cdk/cloudformation-diff/node_modules/@types → @types}/node/readline.d.ts

@@ -1,16 +1,15 @@
-declare module "readline" {
-    import * as events from "events";
-    import * as stream from "stream";
+declare module 'readline' {
+    import EventEmitter = require('events');
 
     interface Key {
-        sequence?: string;
-        name?: string;
-        ctrl?: boolean;
-        meta?: boolean;
-        shift?: boolean;
+        sequence?: string | undefined;
+        name?: string | undefined;
+        ctrl?: boolean | undefined;
+        meta?: boolean | undefined;
+        shift?: boolean | undefined;
     }
 
-    class Interface extends events.EventEmitter {
+    class Interface extends EventEmitter {
         readonly terminal: boolean;
 
         // Need direct access to line/cursor data, for use in external processes
@@ -46,6 +45,14 @@ declare module "readline" {
         resume(): this;
         close(): void;
         write(data: string | Buffer, key?: Key): void;
+        write(data: undefined | null | string | Buffer, key: Key): void;
+
+        /**
+         * Returns the real position of the cursor in relation to the input
+         * prompt + string.  Long input (wrapping) strings, as well as multiple
+         * line prompts are included in the calculations.
+         */
+        getCursorPos(): CursorPos;
 
         /**
          * events.EventEmitter
@@ -111,33 +118,57 @@ declare module "readline" {
         prependOnceListener(event: "SIGCONT", listener: () => void): this;
         prependOnceListener(event: "SIGINT", listener: () => void): this;
         prependOnceListener(event: "SIGTSTP", listener: () => void): this;
+        [Symbol.asyncIterator](): AsyncIterableIterator<string>;
     }
 
-    type ReadLine = Interface; // type forwarded for backwards compatiblity
+    type ReadLine = Interface; // type forwarded for backwards compatibility
 
     type Completer = (line: string) => CompleterResult;
-    type AsyncCompleter = (line: string, callback: (err: any, result: CompleterResult) => void) => any;
+    type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => any;
 
     type CompleterResult = [string[], string];
 
     interface ReadLineOptions {
         input: NodeJS.ReadableStream;
-        output?: NodeJS.WritableStream;
-        completer?: Completer | AsyncCompleter;
-        terminal?: boolean;
-        historySize?: number;
-        prompt?: string;
-        crlfDelay?: number;
-        removeHistoryDuplicates?: boolean;
-        escapeCodeTimeout?: number;
+        output?: NodeJS.WritableStream | undefined;
+        completer?: Completer | AsyncCompleter | undefined;
+        terminal?: boolean | undefined;
+        historySize?: number | undefined;
+        prompt?: string | undefined;
+        crlfDelay?: number | undefined;
+        removeHistoryDuplicates?: boolean | undefined;
+        escapeCodeTimeout?: number | undefined;
+        tabSize?: number | undefined;
     }
 
     function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
     function createInterface(options: ReadLineOptions): Interface;
-
-    function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number): void;
     function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
-    function moveCursor(stream: NodeJS.WritableStream, dx: number | string, dy: number | string): void;
-    function clearLine(stream: NodeJS.WritableStream, dir: number): void;
-    function clearScreenDown(stream: NodeJS.WritableStream): void;
+
+    type Direction = -1 | 0 | 1;
+
+    interface CursorPos {
+        rows: number;
+        cols: number;
+    }
+
+    /**
+     * Clears the current line of this WriteStream in a direction identified by `dir`.
+     */
+    function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
+    /**
+     * Clears this `WriteStream` from the current cursor down.
+     */
+    function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
+    /**
+     * Moves this WriteStream's cursor to the specified position.
+     */
+    function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
+    /**
+     * Moves this WriteStream's cursor relative to its current position.
+     */
+    function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
+}
+declare module 'node:readline' {
+    export * from 'readline';
 }