cdk-common 2.0.1410 → 2.0.1412

package/node_modules/@types/concat-stream/node_modules/@types/node/util.d.ts

@@ -308,6 +308,9 @@ declare module "node:util" {
      * Returns an array of call site objects containing the stack of
      * the caller function.
      *
+     * Unlike accessing an `error.stack`, the result returned from this API is not
+     * interfered with `Error.prepareStackTrace`.
+     *
      * ```js
      * import { getCallSites } from 'node:util';
      *
@@ -320,7 +323,7 @@ declare module "node:util" {
      *     console.log(`Function Name: ${callSite.functionName}`);
      *     console.log(`Script Name: ${callSite.scriptName}`);
      *     console.log(`Line Number: ${callSite.lineNumber}`);
-     *     console.log(`Column Number: ${callSite.column}`);
+     *     console.log(`Column Number: ${callSite.columnNumber}`);
      *   });
      *   // CallSite 1:
      *   // Function Name: exampleFunction
@@ -750,6 +753,28 @@ declare module "node:util" {
      * @legacy Use ES2015 class syntax and `extends` keyword instead.
      */
     export function inherits(constructor: unknown, superConstructor: unknown): void;
+    /**
+     * The `util.convertProcessSignalToExitCode()` method converts a signal name to its
+     * corresponding POSIX exit code. Following the POSIX standard, the exit code
+     * for a process terminated by a signal is calculated as `128 + signal number`.
+     *
+     * If `signal` is not a valid signal name, then an error will be thrown. See
+     * [`signal(7)`](https://man7.org/linux/man-pages/man7/signal.7.html) for a list of valid signals.
+     *
+     * ```js
+     * import { convertProcessSignalToExitCode } from 'node:util';
+     *
+     * console.log(convertProcessSignalToExitCode('SIGTERM')); // 143 (128 + 15)
+     * console.log(convertProcessSignalToExitCode('SIGKILL')); // 137 (128 + 9)
+     * ```
+     *
+     * This is particularly useful when working with processes to determine
+     * the exit code based on the signal that terminated the process.
+     * @since v25.4.0
+     * @param signal A signal name (e.g. `'SIGTERM'`)
+     * @returns The exit code corresponding to `signal`
+     */
+    export function convertProcessSignalToExitCode(signal: NodeJS.Signals): number;
     export type DebugLoggerFunction = (msg: string, ...param: unknown[]) => void;
     export interface DebugLogger extends DebugLoggerFunction {
         /**
@@ -804,7 +829,7 @@ declare module "node:util" {
      *
      * ```js
      * import { debuglog } from 'node:util';
-     * const log = debuglog('foo');
+     * const log = debuglog('foo-bar');
      *
      * log('hi there, it\'s foo-bar [%d]', 2333);
      * ```

package/node_modules/@types/concat-stream/node_modules/@types/node/v8.d.ts

@@ -308,7 +308,6 @@ declare module "node:v8" {
      * ```
      * @param ctor The constructor that can be used to search on the prototype chain in order to filter target objects in the heap.
      * @since v20.13.0
-     * @experimental
      */
     function queryObjects(ctor: Function): number | string[];
     function queryObjects(ctor: Function, options: { format: "count" }): number;

package/node_modules/@types/concat-stream/node_modules/@types/node/worker_threads.d.ts

@@ -33,8 +33,8 @@
  *       workerData: script,
  *     });
  *     worker.on('message', resolve);
- *     worker.on('error', reject);
- *     worker.on('exit', (code) => {
+ *     worker.once('error', reject);
+ *     worker.once('exit', (code) => {
  *       if (code !== 0)
  *         reject(new Error(`Worker stopped with exit code ${code}`));
  *     });

package/node_modules/@types/form-data/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Fri, 06 Mar 2026 00:57:44 GMT
+ * Last updated: Mon, 09 Mar 2026 18:46:38 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/form-data/node_modules/@types/node/assert.d.ts

@@ -253,10 +253,10 @@ declare module "node:assert" {
          * import assert from 'node:assert/strict';
          *
          * // Using `assert()` works the same:
-         * assert(0);
+         * assert(2 + 2 > 5);;
          * // AssertionError: The expression evaluated to a falsy value:
          * //
-         * //   assert(0)
+         * //   assert(2 + 2 > 5)
          * ```
          * @since v0.1.21
          */

package/node_modules/@types/form-data/node_modules/@types/node/child_process.d.ts

@@ -228,6 +228,11 @@ declare module "node:child_process" {
         /**
          * The `subprocess.exitCode` property indicates the exit code of the child process.
          * If the child process is still running, the field will be `null`.
+         *
+         * When the child process is terminated by a signal, `subprocess.exitCode` will be
+         * `null` and `subprocess.signalCode` will be set. To get the corresponding
+         * POSIX exit code, use
+         * `util.convertProcessSignalToExitCode(subprocess.signalCode)`.
          */
         readonly exitCode: number | null;
         /**

package/node_modules/@types/form-data/node_modules/@types/node/events.d.ts

@@ -638,24 +638,17 @@ declare module "node:events" {
          */
         function getMaxListeners(emitter: EventEmitter | EventTarget): number;
         /**
-         * A class method that returns the number of listeners for the given `eventName`
-         * registered on the given `emitter`.
+         * Returns the number of registered listeners for the event named `eventName`.
          *
-         * ```js
-         * import { EventEmitter, listenerCount } from 'node:events';
+         * For `EventEmitter`s this behaves exactly the same as calling `.listenerCount`
+         * on the emitter.
          *
-         * const myEmitter = new EventEmitter();
-         * myEmitter.on('event', () => {});
-         * myEmitter.on('event', () => {});
-         * console.log(listenerCount(myEmitter, 'event'));
-         * // Prints: 2
-         * ```
+         * For `EventTarget`s this is the only way to obtain the listener count. This can
+         * be useful for debugging and diagnostic purposes.
          * @since v0.9.12
-         * @deprecated Use `emitter.listenerCount()` instead.
-         * @param emitter The emitter to query
-         * @param eventName The event name
          */
         function listenerCount(emitter: EventEmitter, eventName: string | symbol): number;
+        function listenerCount(emitter: EventTarget, eventName: string): number;
         interface OnOptions extends Abortable {
             /**
              * Names of events that will end the iteration.

package/node_modules/@types/form-data/node_modules/@types/node/http.d.ts

@@ -2136,6 +2136,27 @@ declare module "node:http" {
      * @param [max=1000]
      */
     function setMaxIdleHTTPParsers(max: number): void;
+    /**
+     * Dynamically resets the global configurations to enable built-in proxy support for
+     * `fetch()` and `http.request()`/`https.request()` at runtime, as an alternative
+     * to using the `--use-env-proxy` flag or `NODE_USE_ENV_PROXY` environment variable.
+     * It can also be used to override settings configured from the environment variables.
+     *
+     * As this function resets the global configurations, any previously configured
+     * `http.globalAgent`, `https.globalAgent` or undici global dispatcher would be
+     * overridden after this function is invoked. It's recommended to invoke it before any
+     * requests are made and avoid invoking it in the middle of any requests.
+     *
+     * See [Built-in Proxy Support](https://nodejs.org/docs/latest-v25.x/api/http.html#built-in-proxy-support) for details on proxy URL formats and `NO_PROXY`
+     * syntax.
+     * @since v25.4.0
+     * @param proxyEnv An object containing proxy configuration. This accepts the
+     * same options as the `proxyEnv` option accepted by {@link Agent}. **Default:**
+     * `process.env`.
+     * @returns A function that restores the original agent and dispatcher
+     * settings to the state before this `http.setGlobalProxyFromEnv()` is invoked.
+     */
+    function setGlobalProxyFromEnv(proxyEnv?: ProxyEnv): () => void;
     /**
      * Global instance of `Agent` which is used as the default for all HTTP client
      * requests. Diverges from a default `Agent` configuration by having `keepAlive`