cdk-common 2.0.1351 → 2.0.1353

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

@@ -4,9 +4,9 @@
  * ```js
  * import v8 from 'node:v8';
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/v8.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/v8.js)
  */
-declare module "v8" {
+declare module "node:v8" {
     import { NonSharedBuffer } from "node:buffer";
     import { Readable } from "node:stream";
     interface HeapSpaceInfo {
@@ -401,6 +401,21 @@ declare module "v8" {
      * @since v12.8.0
      */
     function getHeapCodeStatistics(): HeapCodeStatistics;
+    /**
+     * @since v25.0.0
+     */
+    interface SyncCPUProfileHandle {
+        /**
+         * Stopping collecting the profile and return the profile data.
+         * @since v25.0.0
+         */
+        stop(): string;
+        /**
+         * Stopping collecting the profile and the profile will be discarded.
+         * @since v25.0.0
+         */
+        [Symbol.dispose](): void;
+    }
     /**
      * @since v24.8.0
      */
@@ -433,6 +448,18 @@ declare module "v8" {
          */
         [Symbol.asyncDispose](): Promise<void>;
     }
+    /**
+     * Starting a CPU profile then return a `SyncCPUProfileHandle` object.
+     * This API supports `using` syntax.
+     *
+     * ```js
+     * const handle = v8.startCpuProfile();
+     * const profile = handle.stop();
+     * console.log(profile);
+     * ```
+     * @since v25.0.0
+     */
+    function startCPUProfile(): SyncCPUProfileHandle;
     /**
      * V8 only supports `Latin-1/ISO-8859-1` and `UTF16` as the underlying representation of a string.
      * If the `content` uses `Latin-1/ISO-8859-1` as the underlying representation, this function will return true;
@@ -613,7 +640,7 @@ declare module "v8" {
     function stopCoverage(): void;
     /**
      * The API is a no-op if `--heapsnapshot-near-heap-limit` is already set from the command line or the API is called more than once.
-     * `limit` must be a positive integer. See [`--heapsnapshot-near-heap-limit`](https://nodejs.org/docs/latest-v24.x/api/cli.html#--heapsnapshot-near-heap-limitmax_count) for more information.
+     * `limit` must be a positive integer. See [`--heapsnapshot-near-heap-limit`](https://nodejs.org/docs/latest-v25.x/api/cli.html#--heapsnapshot-near-heap-limitmax_count) for more information.
      * @since v18.10.0, v16.18.0
      */
     function setHeapSnapshotNearHeapLimit(limit: number): void;
@@ -947,6 +974,6 @@ declare module "v8" {
         function isBuildingSnapshot(): boolean;
     }
 }
-declare module "node:v8" {
-    export * from "v8";
+declare module "v8" {
+    export * from "node:v8";
 }

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

@@ -34,9 +34,9 @@
  *
  * console.log(x); // 1; y is not defined.
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/vm.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/vm.js)
  */
-declare module "vm" {
+declare module "node:vm" {
     import { NonSharedBuffer } from "node:buffer";
     import { ImportAttributes, ImportPhase } from "node:module";
     interface Context extends NodeJS.Dict<any> {}
@@ -73,7 +73,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?:
@@ -119,7 +119,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?:
@@ -133,7 +133,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?:
@@ -153,7 +153,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?:
@@ -197,7 +197,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?:
@@ -400,9 +400,9 @@ declare module "vm" {
     }
     /**
      * If the given `contextObject` is an object, the `vm.createContext()` method will
-     * [prepare that object](https://nodejs.org/docs/latest-v24.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
+     * [prepare that object](https://nodejs.org/docs/latest-v25.x/api/vm.html#what-does-it-mean-to-contextify-an-object)
      * and return a reference to it so that it can be used in calls to {@link runInContext} or
-     * [`script.runInContext()`](https://nodejs.org/docs/latest-v24.x/api/vm.html#scriptrunincontextcontextifiedobject-options).
+     * [`script.runInContext()`](https://nodejs.org/docs/latest-v25.x/api/vm.html#scriptrunincontextcontextifiedobject-options).
      * Inside such scripts, the global object will be wrapped by the `contextObject`, retaining all of its
      * existing properties but also having the built-in objects and functions any standard
      * [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global
@@ -887,7 +887,7 @@ declare module "vm" {
         /**
          * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is
          * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see
-         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @experimental
          */
         importModuleDynamically?: DynamicModuleLoader<SourceTextModule> | undefined;
@@ -1156,7 +1156,7 @@ declare module "vm" {
          * and `vm.compileFunction()` so that Node.js uses the default ESM loader from the main
          * context to load the requested module.
          *
-         * For detailed information, see [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v24.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
+         * For detailed information, see [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v25.x/api/vm.html#support-of-dynamic-import-in-compilation-apis).
          * @since v21.7.0, v20.12.0
          */
         const USE_MAIN_CONTEXT_DEFAULT_LOADER: number;
@@ -1175,6 +1175,6 @@ declare module "vm" {
         const DONT_CONTEXTIFY: number;
     }
 }
-declare module "node:vm" {
-    export * from "vm";
+declare module "vm" {
+    export * from "node:vm";
 }

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

@@ -67,9 +67,9 @@
  * wat2wasm demo.wat
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/wasi.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/wasi.js)
  */
-declare module "wasi" {
+declare module "node:wasi" {
     interface WASIOptions {
         /**
          * An array of strings that the WebAssembly application will
@@ -197,6 +197,6 @@ declare module "wasi" {
         readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
     }
 }
-declare module "node:wasi" {
-    export * from "wasi";
+declare module "wasi" {
+    export * from "node:wasi";
 }

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/abortcontroller.d.ts

@@ -1,17 +1,42 @@
 export {};
 
+import { InternalEventTargetEventProperties } from "node:events";
+
 type _AbortController = typeof globalThis extends { onmessage: any } ? {} : AbortController;
 interface AbortController {
     readonly signal: AbortSignal;
     abort(reason?: any): void;
 }
 
+interface AbortSignalEventMap {
+    "abort": Event;
+}
+
 type _AbortSignal = typeof globalThis extends { onmessage: any } ? {} : AbortSignal;
-interface AbortSignal extends EventTarget {
+interface AbortSignal extends EventTarget, InternalEventTargetEventProperties<AbortSignalEventMap> {
     readonly aborted: boolean;
-    onabort: ((this: AbortSignal, ev: Event) => any) | null;
     readonly reason: any;
     throwIfAborted(): void;
+    addEventListener<K extends keyof AbortSignalEventMap>(
+        type: K,
+        listener: (ev: AbortSignalEventMap[K]) => void,
+        options?: AddEventListenerOptions | boolean,
+    ): void;
+    addEventListener(
+        type: string,
+        listener: EventListener | EventListenerObject,
+        options?: AddEventListenerOptions | boolean,
+    ): void;
+    removeEventListener<K extends keyof AbortSignalEventMap>(
+        type: K,
+        listener: (ev: AbortSignalEventMap[K]) => void,
+        options?: EventListenerOptions | boolean,
+    ): void;
+    removeEventListener(
+        type: string,
+        listener: EventListener | EventListenerObject,
+        options?: EventListenerOptions | boolean,
+    ): void;
 }
 
 declare global {

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/blob.d.ts

@@ -0,0 +1,23 @@
+export {};
+
+import * as buffer from "node:buffer";
+
+type _Blob = typeof globalThis extends { onmessage: any } ? {} : buffer.Blob;
+type _BlobPropertyBag = typeof globalThis extends { onmessage: any } ? {} : buffer.BlobPropertyBag;
+type _File = typeof globalThis extends { onmessage: any } ? {} : buffer.File;
+type _FilePropertyBag = typeof globalThis extends { onmessage: any } ? {} : buffer.FilePropertyBag;
+
+declare global {
+    interface Blob extends _Blob {}
+    var Blob: typeof globalThis extends { onmessage: any; Blob: infer T } ? T : typeof buffer.Blob;
+
+    interface BlobPropertyBag extends _BlobPropertyBag {}
+
+    interface File extends _File {}
+    var File: typeof globalThis extends { onmessage: any; File: infer T } ? T : typeof buffer.File;
+
+    interface FilePropertyBag extends _FilePropertyBag {}
+
+    function atob(data: string): string;
+    function btoa(data: string): string;
+}

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/console.d.ts

@@ -0,0 +1,9 @@
+export {};
+
+import * as console from "node:console";
+
+declare global {
+    interface Console extends console.Console {}
+
+    var console: Console;
+}

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/crypto.d.ts

@@ -2,17 +2,24 @@ export {};
 
 import { webcrypto } from "crypto";
 
+type _Crypto = typeof globalThis extends { onmessage: any } ? {} : webcrypto.Crypto;
+type _CryptoKey = typeof globalThis extends { onmessage: any } ? {} : webcrypto.CryptoKey;
+type _SubtleCrypto = typeof globalThis extends { onmessage: any } ? {} : webcrypto.SubtleCrypto;
+
 declare global {
+    interface Crypto extends _Crypto {}
     var Crypto: typeof globalThis extends { onmessage: any; Crypto: infer T } ? T : {
         prototype: webcrypto.Crypto;
         new(): webcrypto.Crypto;
     };
 
+    interface CryptoKey extends _CryptoKey {}
     var CryptoKey: typeof globalThis extends { onmessage: any; CryptoKey: infer T } ? T : {
         prototype: webcrypto.CryptoKey;
         new(): webcrypto.CryptoKey;
     };
 
+    interface SubtleCrypto extends _SubtleCrypto {}
     var SubtleCrypto: typeof globalThis extends { onmessage: any; SubtleCrypto: infer T } ? T : {
         prototype: webcrypto.SubtleCrypto;
         new(): webcrypto.SubtleCrypto;

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/encoding.d.ts

@@ -0,0 +1,11 @@
+export {};
+
+import * as util from "node:util";
+
+declare global {
+    interface TextDecoder extends util.TextDecoder {}
+    var TextDecoder: typeof globalThis extends { onmessage: any; TextDecoder: infer T } ? T : typeof util.TextDecoder;
+
+    interface TextEncoder extends util.TextEncoder {}
+    var TextEncoder: typeof globalThis extends { onmessage: any; TextEncoder: infer T } ? T : typeof util.TextEncoder;
+}

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

@@ -1,5 +1,6 @@
 export {};
 
+type _AddEventListenerOptions = typeof globalThis extends { onmessage: any } ? {} : AddEventListenerOptions;
 interface AddEventListenerOptions extends EventListenerOptions {
     once?: boolean;
     passive?: boolean;
@@ -43,10 +44,12 @@ interface EventInit {
     composed?: boolean;
 }
 
+type _EventListener = typeof globalThis extends { onmessage: any } ? {} : EventListener;
 interface EventListener {
     (evt: Event): void;
 }
 
+type _EventListenerObject = typeof globalThis extends { onmessage: any } ? {} : EventListenerObject;
 interface EventListenerObject {
     handleEvent(object: Event): void;
 }
@@ -72,6 +75,8 @@ interface EventTarget {
 }
 
 declare global {
+    interface AddEventListenerOptions extends _AddEventListenerOptions {}
+
     interface CustomEvent<T = any> extends _CustomEvent<T> {}
     var CustomEvent: typeof globalThis extends { onmessage: any; CustomEvent: infer T } ? T
         : {
@@ -86,6 +91,10 @@ declare global {
             new(type: string, eventInitDict?: EventInit): Event;
         };
 
+    interface EventListener extends _EventListener {}
+
+    interface EventListenerObject extends _EventListenerObject {}
+
     interface EventListenerOptions extends _EventListenerOptions {}
 
     interface EventTarget extends _EventTarget {}

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/fetch.d.ts

@@ -3,6 +3,7 @@ export {};
 import * as undici from "undici-types";
 
 type _CloseEvent = typeof globalThis extends { onmessage: any } ? {} : undici.CloseEvent;
+type _ErrorEvent = typeof globalThis extends { onmessage: any } ? {} : undici.ErrorEvent;
 type _EventSource = typeof globalThis extends { onmessage: any } ? {} : undici.EventSource;
 type _FormData = typeof globalThis extends { onmessage: any } ? {} : undici.FormData;
 type _Headers = typeof globalThis extends { onmessage: any } ? {} : undici.Headers;
@@ -22,6 +23,9 @@ declare global {
     interface CloseEvent extends _CloseEvent {}
     var CloseEvent: typeof globalThis extends { onmessage: any; CloseEvent: infer T } ? T : typeof undici.CloseEvent;
 
+    interface ErrorEvent extends _ErrorEvent {}
+    var ErrorEvent: typeof globalThis extends { onmessage: any; ErrorEvent: infer T } ? T : typeof undici.ErrorEvent;
+
     interface EventSource extends _EventSource {}
     var EventSource: typeof globalThis extends { onmessage: any; EventSource: infer T } ? T : typeof undici.EventSource;
 

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/importmeta.d.ts

@@ -0,0 +1,13 @@
+export {};
+
+import { URL } from "node:url";
+
+declare global {
+    interface ImportMeta {
+        dirname: string;
+        filename: string;
+        main: boolean;
+        url: string;
+        resolve(specifier: string, parent?: string | URL): string;
+    }
+}

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/messaging.d.ts

@@ -0,0 +1,23 @@
+export {};
+
+import * as worker_threads from "node:worker_threads";
+
+type _BroadcastChannel = typeof globalThis extends { onmessage: any } ? {} : worker_threads.BroadcastChannel;
+type _MessageChannel = typeof globalThis extends { onmessage: any } ? {} : worker_threads.MessageChannel;
+type _MessagePort = typeof globalThis extends { onmessage: any } ? {} : worker_threads.MessagePort;
+
+declare global {
+    function structuredClone<T = any>(value: T, options?: worker_threads.StructuredSerializeOptions): T;
+
+    interface BroadcastChannel extends _BroadcastChannel {}
+    var BroadcastChannel: typeof globalThis extends { onmessage: any; BroadcastChannel: infer T } ? T
+        : typeof worker_threads.BroadcastChannel;
+
+    interface MessageChannel extends _MessageChannel {}
+    var MessageChannel: typeof globalThis extends { onmessage: any; MessageChannel: infer T } ? T
+        : typeof worker_threads.MessageChannel;
+
+    interface MessagePort extends _MessagePort {}
+    var MessagePort: typeof globalThis extends { onmessage: any; MessagePort: infer T } ? T
+        : typeof worker_threads.MessagePort;
+}

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/performance.d.ts

@@ -0,0 +1,45 @@
+export {};
+
+import * as perf_hooks from "node:perf_hooks";
+
+type _Performance = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.Performance;
+type _PerformanceEntry = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceEntry;
+type _PerformanceMark = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceMark;
+type _PerformanceMeasure = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceMeasure;
+type _PerformanceObserver = typeof globalThis extends { onmessage: any } ? {} : perf_hooks.PerformanceObserver;
+type _PerformanceObserverEntryList = typeof globalThis extends { onmessage: any } ? {}
+    : perf_hooks.PerformanceObserverEntryList;
+type _PerformanceResourceTiming = typeof globalThis extends { onmessage: any } ? {}
+    : perf_hooks.PerformanceResourceTiming;
+
+declare global {
+    interface Performance extends _Performance {}
+    var Performance: typeof globalThis extends { onmessage: any; Performance: infer T } ? T
+        : typeof perf_hooks.Performance;
+
+    interface PerformanceEntry extends _PerformanceEntry {}
+    var PerformanceEntry: typeof globalThis extends { onmessage: any; PerformanceEntry: infer T } ? T
+        : typeof perf_hooks.PerformanceEntry;
+
+    interface PerformanceMark extends _PerformanceMark {}
+    var PerformanceMark: typeof globalThis extends { onmessage: any; PerformanceMark: infer T } ? T
+        : typeof perf_hooks.PerformanceMark;
+
+    interface PerformanceMeasure extends _PerformanceMeasure {}
+    var PerformanceMeasure: typeof globalThis extends { onmessage: any; PerformanceMeasure: infer T } ? T
+        : typeof perf_hooks.PerformanceMeasure;
+
+    interface PerformanceObserver extends _PerformanceObserver {}
+    var PerformanceObserver: typeof globalThis extends { onmessage: any; PerformanceObserver: infer T } ? T
+        : typeof perf_hooks.PerformanceObserver;
+
+    interface PerformanceObserverEntryList extends _PerformanceObserverEntryList {}
+    var PerformanceObserverEntryList: typeof globalThis extends
+        { onmessage: any; PerformanceObserverEntryList: infer T } ? T : typeof perf_hooks.PerformanceObserverEntryList;
+
+    interface PerformanceResourceTiming extends _PerformanceResourceTiming {}
+    var PerformanceResourceTiming: typeof globalThis extends { onmessage: any; PerformanceResourceTiming: infer T } ? T
+        : typeof perf_hooks.PerformanceResourceTiming;
+
+    var performance: typeof globalThis extends { onmessage: any; performance: infer T } ? T : perf_hooks.Performance;
+}

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/streams.d.ts

@@ -2,10 +2,40 @@ export {};
 
 import * as webstreams from "stream/web";
 
+type _ByteLengthQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ByteLengthQueuingStrategy;
 type _CompressionStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.CompressionStream;
+type _CountQueuingStrategy = typeof globalThis extends { onmessage: any } ? {} : webstreams.CountQueuingStrategy;
 type _DecompressionStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.DecompressionStream;
+type _QueuingStrategy<T = any> = typeof globalThis extends { onmessage: any } ? {} : webstreams.QueuingStrategy<T>;
+type _ReadableByteStreamController = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableByteStreamController;
+type _ReadableStream<R = any> = typeof globalThis extends { onmessage: any } ? {} : webstreams.ReadableStream<R>;
+type _ReadableStreamBYOBReader = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableStreamBYOBReader;
+type _ReadableStreamBYOBRequest = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableStreamBYOBRequest;
+type _ReadableStreamDefaultController<R = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableStreamDefaultController<R>;
+type _ReadableStreamDefaultReader<R = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableStreamDefaultReader<R>;
+type _TextDecoderStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.TextDecoderStream;
+type _TextEncoderStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.TextEncoderStream;
+type _TransformStream<I = any, O = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.TransformStream<I, O>;
+type _TransformStreamDefaultController<O = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.TransformStreamDefaultController<O>;
+type _WritableStream<W = any> = typeof globalThis extends { onmessage: any } ? {} : webstreams.WritableStream<W>;
+type _WritableStreamDefaultController = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.WritableStreamDefaultController;
+type _WritableStreamDefaultWriter<W = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.WritableStreamDefaultWriter<W>;
 
 declare global {
+    interface ByteLengthQueuingStrategy extends _ByteLengthQueuingStrategy {}
+    var ByteLengthQueuingStrategy: typeof globalThis extends { onmessage: any; ByteLengthQueuingStrategy: infer T } ? T
+        : typeof webstreams.ByteLengthQueuingStrategy;
+
     interface CompressionStream extends _CompressionStream {}
     var CompressionStream: typeof globalThis extends {
         onmessage: any;
@@ -13,10 +43,73 @@ declare global {
     } ? T
         : typeof webstreams.CompressionStream;
 
+    interface CountQueuingStrategy extends _CountQueuingStrategy {}
+    var CountQueuingStrategy: typeof globalThis extends { onmessage: any; CountQueuingStrategy: infer T } ? T
+        : typeof webstreams.CountQueuingStrategy;
+
     interface DecompressionStream extends _DecompressionStream {}
     var DecompressionStream: typeof globalThis extends {
         onmessage: any;
         DecompressionStream: infer T;
     } ? T
         : typeof webstreams.DecompressionStream;
+
+    interface QueuingStrategy<T = any> extends _QueuingStrategy<T> {}
+
+    interface ReadableByteStreamController extends _ReadableByteStreamController {}
+    var ReadableByteStreamController: typeof globalThis extends
+        { onmessage: any; ReadableByteStreamController: infer T } ? T : typeof webstreams.ReadableByteStreamController;
+
+    interface ReadableStream<R = any> extends _ReadableStream<R> {}
+    var ReadableStream: typeof globalThis extends { onmessage: any; ReadableStream: infer T } ? T
+        : typeof webstreams.ReadableStream;
+
+    interface ReadableStreamBYOBReader extends _ReadableStreamBYOBReader {}
+    var ReadableStreamBYOBReader: typeof globalThis extends { onmessage: any; ReadableStreamBYOBReader: infer T } ? T
+        : typeof webstreams.ReadableStreamBYOBReader;
+
+    interface ReadableStreamBYOBRequest extends _ReadableStreamBYOBRequest {}
+    var ReadableStreamBYOBRequest: typeof globalThis extends { onmessage: any; ReadableStreamBYOBRequest: infer T } ? T
+        : typeof webstreams.ReadableStreamBYOBRequest;
+
+    interface ReadableStreamDefaultController<R = any> extends _ReadableStreamDefaultController<R> {}
+    var ReadableStreamDefaultController: typeof globalThis extends
+        { onmessage: any; ReadableStreamDefaultController: infer T } ? T
+        : typeof webstreams.ReadableStreamDefaultController;
+
+    interface ReadableStreamDefaultReader<R = any> extends _ReadableStreamDefaultReader<R> {}
+    var ReadableStreamDefaultReader: typeof globalThis extends { onmessage: any; ReadableStreamDefaultReader: infer T }
+        ? T
+        : typeof webstreams.ReadableStreamDefaultReader;
+
+    interface TextDecoderStream extends _TextDecoderStream {}
+    var TextDecoderStream: typeof globalThis extends { onmessage: any; TextDecoderStream: infer T } ? T
+        : typeof webstreams.TextDecoderStream;
+
+    interface TextEncoderStream extends _TextEncoderStream {}
+    var TextEncoderStream: typeof globalThis extends { onmessage: any; TextEncoderStream: infer T } ? T
+        : typeof webstreams.TextEncoderStream;
+
+    interface TransformStream<I = any, O = any> extends _TransformStream<I, O> {}
+    var TransformStream: typeof globalThis extends { onmessage: any; TransformStream: infer T } ? T
+        : typeof webstreams.TransformStream;
+
+    interface TransformStreamDefaultController<O = any> extends _TransformStreamDefaultController<O> {}
+    var TransformStreamDefaultController: typeof globalThis extends
+        { onmessage: any; TransformStreamDefaultController: infer T } ? T
+        : typeof webstreams.TransformStreamDefaultController;
+
+    interface WritableStream<W = any> extends _WritableStream<W> {}
+    var WritableStream: typeof globalThis extends { onmessage: any; WritableStream: infer T } ? T
+        : typeof webstreams.WritableStream;
+
+    interface WritableStreamDefaultController extends _WritableStreamDefaultController {}
+    var WritableStreamDefaultController: typeof globalThis extends
+        { onmessage: any; WritableStreamDefaultController: infer T } ? T
+        : typeof webstreams.WritableStreamDefaultController;
+
+    interface WritableStreamDefaultWriter<W = any> extends _WritableStreamDefaultWriter<W> {}
+    var WritableStreamDefaultWriter: typeof globalThis extends { onmessage: any; WritableStreamDefaultWriter: infer T }
+        ? T
+        : typeof webstreams.WritableStreamDefaultWriter;
 }

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/timers.d.ts

@@ -0,0 +1,44 @@
+export {};
+
+import * as promises from "node:timers/promises";
+
+// Note: The timer function definitions allow a single void-accepting argument
+// to be optional in arguments lists. This allows usage such as
+// `new Promise(resolve => setTimeout(resolve, ms))` (#54258)
+// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+type MakeVoidParameterOptional<TArgs extends any[]> = [void] extends TArgs ? Partial<TArgs> : TArgs;
+
+declare global {
+    function setImmediate<TArgs extends any[]>(
+        callback: (...args: TArgs) => void,
+        ...args: MakeVoidParameterOptional<TArgs>
+    ): NodeJS.Immediate;
+    namespace setImmediate {
+        import __promisify__ = promises.setImmediate;
+        export { __promisify__ };
+    }
+
+    function setInterval<TArgs extends any[]>(
+        callback: (...args: TArgs) => void,
+        delay?: number,
+        ...args: MakeVoidParameterOptional<TArgs>
+    ): NodeJS.Timeout;
+
+    function setTimeout<TArgs extends any[]>(
+        callback: (...args: TArgs) => void,
+        delay?: number,
+        ...args: MakeVoidParameterOptional<TArgs>
+    ): NodeJS.Timeout;
+    namespace setTimeout {
+        import __promisify__ = promises.setTimeout;
+        export { __promisify__ };
+    }
+
+    function clearImmediate(immediate: NodeJS.Immediate | undefined): void;
+
+    function clearInterval(timeout: NodeJS.Timeout | string | number | undefined): void;
+
+    function clearTimeout(timeout: NodeJS.Timeout | string | number | undefined): void;
+
+    function queueMicrotask(callback: () => void): void;
+}

package/node_modules/@types/form-data/node_modules/@types/node/web-globals/url.d.ts

@@ -0,0 +1,24 @@
+export {};
+
+import * as url from "node:url";
+
+declare global {
+    interface URL extends url.URL {}
+    var URL: typeof globalThis extends { onmessage: any; URL: infer T } ? T : typeof url.URL;
+
+    interface URLPattern extends url.URLPattern {}
+    var URLPattern: typeof globalThis extends {
+        onmessage: any;
+        scheduler: any; // Must be a var introduced at the same time as URLPattern.
+        URLPattern: infer T;
+    } ? T
+        : typeof url.URLPattern;
+
+    interface URLPatternInit extends url.URLPatternInit {}
+
+    interface URLPatternResult extends url.URLPatternResult {}
+
+    interface URLSearchParams extends url.URLSearchParams {}
+    var URLSearchParams: typeof globalThis extends { onmessage: any; URLSearchParams: infer T } ? T
+        : typeof url.URLSearchParams;
+}