cdk-ecr-deployment 2.5.6 → 2.5.22

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

@@ -1,10 +1,10 @@
 /**
- * The `child_process` module provides the ability to spawn subprocesses in
+ * The `node:child_process` module provides the ability to spawn subprocesses in
  * a manner that is similar, but not identical, to [`popen(3)`](http://man7.org/linux/man-pages/man3/popen.3.html). This capability
  * is primarily provided by the {@link spawn} function:
  *
  * ```js
- * const { spawn } = require('child_process');
+ * const { spawn } = require('node:child_process');
  * const ls = spawn('ls', ['-lh', '/usr']);
  *
  * ls.stdout.on('data', (data) => {
@@ -28,8 +28,11 @@
  * identical to the behavior of pipes in the shell. Use the `{ stdio: 'ignore' }`option if the output will not be consumed.
  *
  * The command lookup is performed using the `options.env.PATH` environment
- * variable if it is in the `options` object. Otherwise, `process.env.PATH` is
- * used.
+ * variable if `env` is in the `options` object. Otherwise, `process.env.PATH` is
+ * used. If `options.env` is set without `PATH`, lookup on Unix is performed
+ * on a default search path search of `/usr/bin:/bin` (see your operating system's
+ * manual for execvpe/execvp), on Windows the current processes environment
+ * variable `PATH` is used.
  *
  * On Windows, environment variables are case-insensitive. Node.js
  * lexicographically sorts the `env` keys and uses the first one that
@@ -41,8 +44,8 @@
  * without blocking the Node.js event loop. The {@link spawnSync} function provides equivalent functionality in a synchronous manner that blocks
  * the event loop until the spawned process either exits or is terminated.
  *
- * For convenience, the `child_process` module provides a handful of synchronous
- * and asynchronous alternatives to {@link spawn} and {@link spawnSync}. Each of these alternatives are implemented on
+ * For convenience, the `node:child_process` module provides a handful of
+ * synchronous and asynchronous alternatives to {@link spawn} and {@link spawnSync}. Each of these alternatives are implemented on
  * top of {@link spawn} or {@link spawnSync}.
  *
  * * {@link exec}: spawns a shell and runs a command within that
@@ -60,7 +63,7 @@
  * For certain use cases, such as automating shell scripts, the `synchronous counterparts` may be more convenient. In many cases, however,
  * the synchronous methods can have significant impact on performance due to
  * stalling the event loop while spawned processes complete.
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/child_process.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/child_process.js)
  */
 declare module 'child_process' {
     import { ObjectEncodingOptions } from 'node:fs';
@@ -91,8 +94,7 @@ declare module 'child_process' {
          * `subprocess.stdin` is an alias for `subprocess.stdio[0]`. Both properties will
          * refer to the same value.
          *
-         * The `subprocess.stdin` property can be `undefined` if the child process could
-         * not be successfully spawned.
+         * The `subprocess.stdin` property can be `null` or `undefined`if the child process could not be successfully spawned.
          * @since v0.1.90
          */
         stdin: Writable | null;
@@ -106,7 +108,7 @@ declare module 'child_process' {
          * refer to the same value.
          *
          * ```js
-         * const { spawn } = require('child_process');
+         * const { spawn } = require('node:child_process');
          *
          * const subprocess = spawn('ls');
          *
@@ -115,8 +117,7 @@ declare module 'child_process' {
          * });
          * ```
          *
-         * The `subprocess.stdout` property can be `null` if the child process could
-         * not be successfully spawned.
+         * The `subprocess.stdout` property can be `null` or `undefined`if the child process could not be successfully spawned.
          * @since v0.1.90
          */
         stdout: Readable | null;
@@ -129,14 +130,13 @@ declare module 'child_process' {
          * `subprocess.stderr` is an alias for `subprocess.stdio[2]`. Both properties will
          * refer to the same value.
          *
-         * The `subprocess.stderr` property can be `null` if the child process could
-         * not be successfully spawned.
+         * The `subprocess.stderr` property can be `null` or `undefined`if the child process could not be successfully spawned.
          * @since v0.1.90
          */
         stderr: Readable | null;
         /**
          * The `subprocess.channel` property is a reference to the child's IPC channel. If
-         * no IPC channel currently exists, this property is `undefined`.
+         * no IPC channel exists, this property is `undefined`.
          * @since v7.1.0
          */
         readonly channel?: Pipe | null | undefined;
@@ -151,16 +151,16 @@ declare module 'child_process' {
          * in the array are `null`.
          *
          * ```js
-         * const assert = require('assert');
-         * const fs = require('fs');
-         * const child_process = require('child_process');
+         * const assert = require('node:assert');
+         * const fs = require('node:fs');
+         * const child_process = require('node:child_process');
          *
          * const subprocess = child_process.spawn('ls', {
          *   stdio: [
          *     0, // Use parent's stdin for child.
          *     'pipe', // Pipe child's stdout to parent.
          *     fs.openSync('err.out', 'w'), // Direct child's stderr to a file.
-         *   ]
+         *   ],
          * });
          *
          * assert.strictEqual(subprocess.stdio[0], null);
@@ -201,7 +201,7 @@ declare module 'child_process' {
          * emitted.
          *
          * ```js
-         * const { spawn } = require('child_process');
+         * const { spawn } = require('node:child_process');
          * const grep = spawn('grep', ['ssh']);
          *
          * console.log(`Spawned child pid: ${grep.pid}`);
@@ -248,7 +248,7 @@ declare module 'child_process' {
          * returns `true` if [`kill(2)`](http://man7.org/linux/man-pages/man2/kill.2.html) succeeds, and `false` otherwise.
          *
          * ```js
-         * const { spawn } = require('child_process');
+         * const { spawn } = require('node:child_process');
          * const grep = spawn('grep', ['ssh']);
          *
          * grep.on('close', (code, signal) => {
@@ -281,7 +281,7 @@ declare module 'child_process' {
          *
          * ```js
          * 'use strict';
-         * const { spawn } = require('child_process');
+         * const { spawn } = require('node:child_process');
          *
          * const subprocess = spawn(
          *   'sh',
@@ -291,8 +291,8 @@ declare module 'child_process' {
          *       console.log(process.pid, 'is alive')
          *     }, 500);"`,
          *   ], {
-         *     stdio: ['inherit', 'inherit', 'inherit']
-         *   }
+         *     stdio: ['inherit', 'inherit', 'inherit'],
+         *   },
          * );
          *
          * setTimeout(() => {
@@ -314,7 +314,7 @@ declare module 'child_process' {
          * For example, in the parent script:
          *
          * ```js
-         * const cp = require('child_process');
+         * const cp = require('node:child_process');
          * const n = cp.fork(`${__dirname}/sub.js`);
          *
          * n.on('message', (m) => {
@@ -368,10 +368,10 @@ declare module 'child_process' {
          * a TCP server object to the child process as illustrated in the example below:
          *
          * ```js
-         * const subprocess = require('child_process').fork('subprocess.js');
+         * const subprocess = require('node:child_process').fork('subprocess.js');
          *
          * // Open up the server object and send the handle.
-         * const server = require('net').createServer();
+         * const server = require('node:net').createServer();
          * server.on('connection', (socket) => {
          *   socket.end('handled by parent');
          * });
@@ -395,10 +395,9 @@ declare module 'child_process' {
          * Once the server is now shared between the parent and child, some connections
          * can be handled by the parent and some by the child.
          *
-         * While the example above uses a server created using the `net` module, `dgram`module servers use exactly the same workflow with the exceptions of listening on
-         * a `'message'` event instead of `'connection'` and using `server.bind()` instead
-         * of `server.listen()`. This is, however, currently only supported on Unix
-         * platforms.
+         * While the example above uses a server created using the `node:net` module,`node:dgram` module servers use exactly the same workflow with the exceptions of
+         * listening on a `'message'` event instead of `'connection'` and using`server.bind()` instead of `server.listen()`. This is, however, only
+         * supported on Unix platforms.
          *
          * #### Example: sending a socket object
          *
@@ -407,13 +406,13 @@ declare module 'child_process' {
          * handle connections with "normal" or "special" priority:
          *
          * ```js
-         * const { fork } = require('child_process');
+         * const { fork } = require('node:child_process');
          * const normal = fork('subprocess.js', ['normal']);
          * const special = fork('subprocess.js', ['special']);
          *
          * // Open up the server and send sockets to child. Use pauseOnConnect to prevent
          * // the sockets from being read before they are sent to the child process.
-         * const server = require('net').createServer({ pauseOnConnect: true });
+         * const server = require('node:net').createServer({ pauseOnConnect: true });
          * server.on('connection', (socket) => {
          *
          *   // If this is special priority...
@@ -479,11 +478,11 @@ declare module 'child_process' {
          * the child and the parent.
          *
          * ```js
-         * const { spawn } = require('child_process');
+         * const { spawn } = require('node:child_process');
          *
          * const subprocess = spawn(process.argv[0], ['child_program.js'], {
          *   detached: true,
-         *   stdio: 'ignore'
+         *   stdio: 'ignore',
          * });
          *
          * subprocess.unref();
@@ -497,11 +496,11 @@ declare module 'child_process' {
          * to wait for the child to exit before exiting itself.
          *
          * ```js
-         * const { spawn } = require('child_process');
+         * const { spawn } = require('node:child_process');
          *
          * const subprocess = spawn(process.argv[0], ['child_program.js'], {
          *   detached: true,
-         *   stdio: 'ignore'
+         *   stdio: 'ignore',
          * });
          *
          * subprocess.unref();
@@ -621,7 +620,7 @@ declare module 'child_process' {
     }
     interface CommonOptions extends ProcessEnvOptions {
         /**
-         * @default true
+         * @default false
          */
         windowsHide?: boolean | undefined;
         /**
@@ -631,6 +630,15 @@ declare module 'child_process' {
     }
     interface CommonSpawnOptions extends CommonOptions, MessagingOptions, Abortable {
         argv0?: string | undefined;
+        /**
+         * Can be set to 'pipe', 'inherit', 'overlapped', or 'ignore', or an array of these strings.
+         * If passed as an array, the first element is used for `stdin`, the second for
+         * `stdout`, and the third for `stderr`. A fourth element can be used to
+         * specify the `stdio` behavior beyond the standard streams. See
+         * {@link ChildProcess.stdio} for more information.
+         *
+         * @default 'pipe'
+         */
         stdio?: StdioOptions | undefined;
         shell?: boolean | string | undefined;
         windowsVerbatimArguments?: boolean | undefined;
@@ -660,7 +668,7 @@ declare module 'child_process' {
      * ```js
      * const defaults = {
      *   cwd: undefined,
-     *   env: process.env
+     *   env: process.env,
      * };
      * ```
      *
@@ -679,7 +687,7 @@ declare module 'child_process' {
      * exit code:
      *
      * ```js
-     * const { spawn } = require('child_process');
+     * const { spawn } = require('node:child_process');
      * const ls = spawn('ls', ['-lh', '/usr']);
      *
      * ls.stdout.on('data', (data) => {
@@ -698,7 +706,7 @@ declare module 'child_process' {
      * Example: A very elaborate way to run `ps ax | grep ssh`
      *
      * ```js
-     * const { spawn } = require('child_process');
+     * const { spawn } = require('node:child_process');
      * const ps = spawn('ps', ['ax']);
      * const grep = spawn('grep', ['ssh']);
      *
@@ -735,7 +743,7 @@ declare module 'child_process' {
      * Example of checking for failed `spawn`:
      *
      * ```js
-     * const { spawn } = require('child_process');
+     * const { spawn } = require('node:child_process');
      * const subprocess = spawn('bad_command');
      *
      * subprocess.on('error', (err) => {
@@ -746,14 +754,14 @@ declare module 'child_process' {
      * Certain platforms (macOS, Linux) will use the value of `argv[0]` for the process
      * title while others (Windows, SunOS) will use `command`.
      *
-     * Node.js currently overwrites `argv[0]` with `process.execPath` on startup, so`process.argv[0]` in a Node.js child process will not match the `argv0`parameter passed to `spawn` from the parent,
-     * retrieve it with the`process.argv0` property instead.
+     * Node.js overwrites `argv[0]` with `process.execPath` on startup, so`process.argv[0]` in a Node.js child process will not match the `argv0`parameter passed to `spawn` from the parent. Retrieve
+     * it with the`process.argv0` property instead.
      *
      * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.kill()` on the child process except
      * the error passed to the callback will be an `AbortError`:
      *
      * ```js
-     * const { spawn } = require('child_process');
+     * const { spawn } = require('node:child_process');
      * const controller = new AbortController();
      * const { signal } = controller;
      * const grep = spawn('grep', ['ssh'], { signal });
@@ -812,7 +820,7 @@ declare module 'child_process' {
      * need to be dealt with accordingly:
      *
      * ```js
-     * const { exec } = require('child_process');
+     * const { exec } = require('node:child_process');
      *
      * exec('"/path/to/test file/test.sh" arg1 arg2');
      * // Double quotes are used so that the space in the path is not interpreted as
@@ -838,7 +846,7 @@ declare module 'child_process' {
      * encoding, `Buffer` objects will be passed to the callback instead.
      *
      * ```js
-     * const { exec } = require('child_process');
+     * const { exec } = require('node:child_process');
      * exec('cat *.js missing_file | wc -l', (error, stdout, stderr) => {
      *   if (error) {
      *     console.error(`exec error: ${error}`);
@@ -863,8 +871,8 @@ declare module 'child_process' {
      * callback, but with two additional properties `stdout` and `stderr`.
      *
      * ```js
-     * const util = require('util');
-     * const exec = util.promisify(require('child_process').exec);
+     * const util = require('node:util');
+     * const exec = util.promisify(require('node:child_process').exec);
      *
      * async function lsExample() {
      *   const { stdout, stderr } = await exec('ls');
@@ -878,11 +886,11 @@ declare module 'child_process' {
      * the error passed to the callback will be an `AbortError`:
      *
      * ```js
-     * const { exec } = require('child_process');
+     * const { exec } = require('node:child_process');
      * const controller = new AbortController();
      * const { signal } = controller;
      * const child = exec('grep ssh', { signal }, (error) => {
-     *   console.log(error); // an AbortError
+     *   console.error(error); // an AbortError
      * });
      * controller.abort();
      * ```
@@ -981,7 +989,10 @@ declare module 'child_process' {
     interface ExecFileOptionsWithOtherEncoding extends ExecFileOptions {
         encoding: BufferEncoding;
     }
-    type ExecFileException = ExecException & NodeJS.ErrnoException;
+    type ExecFileException =
+        & Omit<ExecException, 'code'>
+        & Omit<NodeJS.ErrnoException, 'code'>
+        & { code?: string | number | undefined | null };
     /**
      * The `child_process.execFile()` function is similar to {@link exec} except that it does not spawn a shell by default. Rather, the specified
      * executable `file` is spawned directly as a new process making it slightly more
@@ -992,7 +1003,7 @@ declare module 'child_process' {
      * supported.
      *
      * ```js
-     * const { execFile } = require('child_process');
+     * const { execFile } = require('node:child_process');
      * const child = execFile('node', ['--version'], (error, stdout, stderr) => {
      *   if (error) {
      *     throw error;
@@ -1015,8 +1026,8 @@ declare module 'child_process' {
      * callback, but with two additional properties `stdout` and `stderr`.
      *
      * ```js
-     * const util = require('util');
-     * const execFile = util.promisify(require('child_process').execFile);
+     * const util = require('node:util');
+     * const execFile = util.promisify(require('node:child_process').execFile);
      * async function getVersion() {
      *   const { stdout } = await execFile('node', ['--version']);
      *   console.log(stdout);
@@ -1032,11 +1043,11 @@ declare module 'child_process' {
      * the error passed to the callback will be an `AbortError`:
      *
      * ```js
-     * const { execFile } = require('child_process');
+     * const { execFile } = require('node:child_process');
      * const controller = new AbortController();
      * const { signal } = controller;
      * const child = execFile('node', ['--version'], { signal }, (error) => {
-     *   console.log(error); // an AbortError
+     *   console.error(error); // an AbortError
      * });
      * controller.abort();
      * ```
@@ -1189,6 +1200,15 @@ declare module 'child_process' {
         execPath?: string | undefined;
         execArgv?: string[] | undefined;
         silent?: boolean | undefined;
+        /**
+         * Can be set to 'pipe', 'inherit', 'overlapped', or 'ignore', or an array of these strings.
+         * If passed as an array, the first element is used for `stdin`, the second for
+         * `stdout`, and the third for `stderr`. A fourth element can be used to
+         * specify the `stdio` behavior beyond the standard streams. See
+         * {@link ChildProcess.stdio} for more information.
+         *
+         * @default 'pipe'
+         */
         stdio?: StdioOptions | undefined;
         detached?: boolean | undefined;
         windowsVerbatimArguments?: boolean | undefined;
@@ -1228,7 +1248,7 @@ declare module 'child_process' {
      *     console.log(`Hello from ${process.argv[2]}!`);
      *   }, 1_000);
      * } else {
-     *   const { fork } = require('child_process');
+     *   const { fork } = require('node:child_process');
      *   const controller = new AbortController();
      *   const { signal } = controller;
      *   const child = fork(__filename, ['child'], { signal });
@@ -1289,6 +1309,15 @@ declare module 'child_process' {
     function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
     interface CommonExecOptions extends CommonOptions {
         input?: string | NodeJS.ArrayBufferView | undefined;
+        /**
+         * Can be set to 'pipe', 'inherit, or 'ignore', or an array of these strings.
+         * If passed as an array, the first element is used for `stdin`, the second for
+         * `stdout`, and the third for `stderr`. A fourth element can be used to
+         * specify the `stdio` behavior beyond the standard streams. See
+         * {@link ChildProcess.stdio} for more information.
+         *
+         * @default 'pipe'
+         */
         stdio?: StdioOptions | undefined;
         killSignal?: NodeJS.Signals | number | undefined;
         maxBuffer?: number | undefined;

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

@@ -1,18 +1,19 @@
 /**
- * A single instance of Node.js runs in a single thread. To take advantage of
- * multi-core systems, the user will sometimes want to launch a cluster of Node.js
- * processes to handle the load.
+ * Clusters of Node.js processes can be used to run multiple instances of Node.js
+ * that can distribute workloads among their application threads. When process
+ * isolation is not needed, use the `worker_threads` module instead, which
+ * allows running multiple application threads within a single Node.js instance.
  *
  * The cluster module allows easy creation of child processes that all share
  * server ports.
  *
  * ```js
- * import cluster from 'cluster';
- * import http from 'http';
- * import { cpus } from 'os';
- * import process from 'process';
+ * import cluster from 'node:cluster';
+ * import http from 'node:http';
+ * import { availableParallelism } from 'node:os';
+ * import process from 'node:process';
  *
- * const numCPUs = cpus().length;
+ * const numCPUs = availableParallelism();
  *
  * if (cluster.isPrimary) {
  *   console.log(`Primary ${process.pid} is running`);
@@ -49,12 +50,13 @@
  * ```
  *
  * On Windows, it is not yet possible to set up a named pipe server in a worker.
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/cluster.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/cluster.js)
  */
 declare module 'cluster' {
     import * as child from 'node:child_process';
     import EventEmitter = require('node:events');
     import * as net from 'node:net';
+    type SerializationType = 'json' | 'advanced';
     export interface ClusterSettings {
         execArgv?: string[] | undefined; // default: process.execArgv
         exec?: string | undefined;
@@ -64,6 +66,9 @@ declare module 'cluster' {
         uid?: number | undefined;
         gid?: number | undefined;
         inspectPort?: number | (() => number) | undefined;
+        serialization?: SerializationType | undefined;
+        cwd?: string | undefined;
+        windowsHide?: boolean | undefined;
     }
     export interface Address {
         address: string;
@@ -99,9 +104,9 @@ declare module 'cluster' {
         /**
          * Send a message to a worker or primary, optionally with a handle.
          *
-         * In the primary this sends a message to a specific worker. It is identical to `ChildProcess.send()`.
+         * In the primary, this sends a message to a specific worker. It is identical to `ChildProcess.send()`.
          *
-         * In a worker this sends a message to the primary. It is identical to`process.send()`.
+         * In a worker, this sends a message to the primary. It is identical to`process.send()`.
          *
          * This example will echo back all messages from the primary:
          *
@@ -123,19 +128,13 @@ declare module 'cluster' {
         send(message: child.Serializable, sendHandle: child.SendHandle, callback?: (error: Error | null) => void): boolean;
         send(message: child.Serializable, sendHandle: child.SendHandle, options?: child.MessageOptions, callback?: (error: Error | null) => void): boolean;
         /**
-         * This function will kill the worker. In the primary, it does this
-         * by disconnecting the `worker.process`, and once disconnected, killing
-         * with `signal`. In the worker, it does it by disconnecting the channel,
-         * and then exiting with code `0`.
+         * This function will kill the worker. In the primary worker, it does this by
+         * disconnecting the `worker.process`, and once disconnected, killing with`signal`. In the worker, it does it by killing the process with `signal`.
          *
-         * Because `kill()` attempts to gracefully disconnect the worker process, it is
-         * susceptible to waiting indefinitely for the disconnect to complete. For example,
-         * if the worker enters an infinite loop, a graceful disconnect will never occur.
-         * If the graceful disconnect behavior is not needed, use `worker.process.kill()`.
+         * The `kill()` function kills the worker process without waiting for a graceful
+         * disconnect, it has the same behavior as `worker.process.kill()`.
          *
-         * Causes `.exitedAfterDisconnect` to be set.
-         *
-         * This method is aliased as `worker.destroy()` for backward compatibility.
+         * This method is aliased as `worker.destroy()` for backwards compatibility.
          *
          * In a worker, `process.kill()` exists, but it is not this function;
          * it is `kill()`.
@@ -188,7 +187,7 @@ declare module 'cluster' {
          *   });
          *
          * } else if (cluster.isWorker) {
-         *   const net = require('net');
+         *   const net = require('node:net');
          *   const server = net.createServer((socket) => {
          *     // Connections never end
          *   });
@@ -218,12 +217,12 @@ declare module 'cluster' {
          * because of exiting or being signaled). Otherwise, it returns `false`.
          *
          * ```js
-         * import cluster from 'cluster';
-         * import http from 'http';
-         * import { cpus } from 'os';
-         * import process from 'process';
+         * import cluster from 'node:cluster';
+         * import http from 'node:http';
+         * import { availableParallelism } from 'node:os';
+         * import process from 'node:process';
          *
-         * const numCPUs = cpus().length;
+         * const numCPUs = availableParallelism();
          *
          * if (cluster.isPrimary) {
          *   console.log(`Primary ${process.pid} is running`);
@@ -253,7 +252,8 @@ declare module 'cluster' {
          */
         isDead(): boolean;
         /**
-         * This property is `true` if the worker exited due to `.kill()` or`.disconnect()`. If the worker exited any other way, it is `false`. If the
+         * This property is `true` if the worker exited due to `.disconnect()`.
+         * If the worker exited any other way, it is `false`. If the
          * worker has not exited, it is `undefined`.
          *
          * The boolean `worker.exitedAfterDisconnect` allows distinguishing between

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

@@ -1,11 +1,11 @@
 /**
- * The `console` module provides a simple debugging console that is similar to the
- * JavaScript console mechanism provided by web browsers.
+ * The `node:console` module provides a simple debugging console that is similar to
+ * the JavaScript console mechanism provided by web browsers.
  *
  * The module exports two specific components:
  *
- * * A `Console` class with methods such as `console.log()`, `console.error()` and`console.warn()` that can be used to write to any Node.js stream.
- * * A global `console` instance configured to write to `process.stdout` and `process.stderr`. The global `console` can be used without calling`require('console')`.
+ * * A `Console` class with methods such as `console.log()`, `console.error()`, and`console.warn()` that can be used to write to any Node.js stream.
+ * * A global `console` instance configured to write to `process.stdout` and `process.stderr`. The global `console` can be used without calling`require('node:console')`.
  *
  * _**Warning**_: The global console object's methods are neither consistently
  * synchronous like the browser APIs they resemble, nor are they consistently
@@ -53,7 +53,7 @@
  * myConsole.warn(`Danger ${name}! Danger!`);
  * // Prints: Danger Will Robinson! Danger!, to err
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/console.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/console.js)
  */
 declare module 'console' {
     import console = require('node:console');