cdk-common 2.1.11 → 2.1.13

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

@@ -1,57 +1,3 @@
-/**
- * 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`](https://nodejs.org/docs/latest-v25.x/api/worker_threads.html)
- * 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 'node:cluster';
- * import http from 'node:http';
- * import { availableParallelism } from 'node:os';
- * import process from 'node:process';
- *
- * const numCPUs = availableParallelism();
- *
- * if (cluster.isPrimary) {
- *   console.log(`Primary ${process.pid} is running`);
- *
- *   // Fork workers.
- *   for (let i = 0; i < numCPUs; i++) {
- *     cluster.fork();
- *   }
- *
- *   cluster.on('exit', (worker, code, signal) => {
- *     console.log(`worker ${worker.process.pid} died`);
- *   });
- * } else {
- *   // Workers can share any TCP connection
- *   // In this case it is an HTTP server
- *   http.createServer((req, res) => {
- *     res.writeHead(200);
- *     res.end('hello world\n');
- *   }).listen(8000);
- *
- *   console.log(`Worker ${process.pid} started`);
- * }
- * ```
- *
- * Running Node.js will now share port 8000 between the workers:
- *
- * ```console
- * $ node server.js
- * Primary 3596 is running
- * Worker 4324 started
- * Worker 4520 started
- * Worker 6056 started
- * Worker 5644 started
- * ```
- *
- * 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/v25.x/lib/cluster.js)
- */
 declare module "node:cluster" {
     import * as child_process from "node:child_process";
     import { EventEmitter, InternalEventEmitter } from "node:events";

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

@@ -1,61 +1,3 @@
-/**
- * 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`](https://nodejs.org/docs/latest-v25.x/api/process.html#processstdout) and
- * [`process.stderr`](https://nodejs.org/docs/latest-v25.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
- *
- * _**Warning**_: The global console object's methods are neither consistently
- * synchronous like the browser APIs they resemble, nor are they consistently
- * asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v25.x/api/process.html#a-note-on-process-io) for
- * more information.
- *
- * Example using the global `console`:
- *
- * ```js
- * console.log('hello world');
- * // Prints: hello world, to stdout
- * console.log('hello %s', 'world');
- * // Prints: hello world, to stdout
- * console.error(new Error('Whoops, something bad happened'));
- * // Prints error message and stack trace to stderr:
- * //   Error: Whoops, something bad happened
- * //     at [eval]:5:15
- * //     at Script.runInThisContext (node:vm:132:18)
- * //     at Object.runInThisContext (node:vm:309:38)
- * //     at node:internal/process/execution:77:19
- * //     at [eval]-wrapper:6:22
- * //     at evalScript (node:internal/process/execution:76:60)
- * //     at node:internal/main/eval_string:23:3
- *
- * const name = 'Will Robinson';
- * console.warn(`Danger ${name}! Danger!`);
- * // Prints: Danger Will Robinson! Danger!, to stderr
- * ```
- *
- * Example using the `Console` class:
- *
- * ```js
- * const out = getStreamSomehow();
- * const err = getStreamSomehow();
- * const myConsole = new console.Console(out, err);
- *
- * myConsole.log('hello world');
- * // Prints: hello world, to out
- * myConsole.log('hello %s', 'world');
- * // Prints: hello world, to out
- * myConsole.error(new Error('Whoops, something bad happened'));
- * // Prints: [Error: Whoops, something bad happened], to err
- *
- * const name = 'Will Robinson';
- * myConsole.warn(`Danger ${name}! Danger!`);
- * // Prints: Danger Will Robinson! Danger!, to err
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/console.js)
- */
 declare module "node:console" {
     import { InspectOptions } from "node:util";
     namespace console {

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

@@ -1,9 +1,3 @@
-/**
- * @deprecated The `node:constants` module is deprecated. When requiring access to constants
- * relevant to specific Node.js builtin modules, developers should instead refer
- * to the `constants` property exposed by the relevant module. For instance,
- * `require('node:fs').constants` and `require('node:os').constants`.
- */
 declare module "node:constants" {
     const constants:
         & typeof import("node:os").constants.dlopen

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

@@ -1,21 +1,3 @@
-/**
- * The `node:crypto` module provides cryptographic functionality that includes a
- * set of wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify
- * functions.
- *
- * ```js
- * const { createHmac } = await import('node:crypto');
- *
- * const secret = 'abcdefg';
- * const hash = createHmac('sha256', secret)
- *                .update('I love cupcakes')
- *                .digest('hex');
- * console.log(hash);
- * // Prints:
- * //   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/crypto.js)
- */
 declare module "node:crypto" {
     import { NonSharedBuffer } from "node:buffer";
     import * as stream from "node:stream";

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

@@ -1,30 +1,3 @@
-/**
- * The `node:dgram` module provides an implementation of UDP datagram sockets.
- *
- * ```js
- * import dgram from 'node:dgram';
- *
- * const server = dgram.createSocket('udp4');
- *
- * server.on('error', (err) => {
- *   console.error(`server error:\n${err.stack}`);
- *   server.close();
- * });
- *
- * server.on('message', (msg, rinfo) => {
- *   console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
- * });
- *
- * server.on('listening', () => {
- *   const address = server.address();
- *   console.log(`server listening ${address.address}:${address.port}`);
- * });
- *
- * server.bind(41234);
- * // Prints: server listening 0.0.0.0:41234
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/dgram.js)
- */
 declare module "node:dgram" {
     import { NonSharedBuffer } from "node:buffer";
     import * as dns from "node:dns";

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

@@ -1,27 +1,3 @@
-/**
- * The `node:diagnostics_channel` module provides an API to create named channels
- * to report arbitrary message data for diagnostics purposes.
- *
- * It can be accessed using:
- *
- * ```js
- * import diagnostics_channel from 'node:diagnostics_channel';
- * ```
- *
- * It is intended that a module writer wanting to report diagnostics messages
- * will create one or many top-level channels to report messages through.
- * Channels may also be acquired at runtime but it is not encouraged
- * due to the additional overhead of doing so. Channels may be exported for
- * convenience, but as long as the name is known it can be acquired anywhere.
- *
- * If you intend for your module to produce diagnostics data for others to
- * consume it is recommended that you include documentation of what named
- * channels are used along with the shape of the message data. Channel names
- * should generally include the module name to avoid collisions with data from
- * other modules.
- * @since v15.1.0, v14.17.0
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/diagnostics_channel.js)
- */
 declare module "node:diagnostics_channel" {
     import { AsyncLocalStorage } from "node:async_hooks";
     /**

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

@@ -1,9 +1,3 @@
-/**
- * The `dns.promises` API provides an alternative set of asynchronous DNS methods
- * that return `Promise` objects rather than using callbacks. The API is accessible
- * via `import { promises as dnsPromises } from 'node:dns'` or `import dnsPromises from 'node:dns/promises'`.
- * @since v10.6.0
- */
 declare module "node:dns/promises" {
     import {
         AnyRecord,

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

@@ -1,49 +1,3 @@
-/**
- * The `node:dns` module enables name resolution. For example, use it to look up IP
- * addresses of host names.
- *
- * Although named for the [Domain Name System (DNS)](https://en.wikipedia.org/wiki/Domain_Name_System), it does not always use the
- * DNS protocol for lookups. {@link lookup} uses the operating system
- * facilities to perform name resolution. It may not need to perform any network
- * communication. To perform name resolution the way other applications on the same
- * system do, use {@link lookup}.
- *
- * ```js
- * import dns from 'node:dns';
- *
- * dns.lookup('example.org', (err, address, family) => {
- *   console.log('address: %j family: IPv%s', address, family);
- * });
- * // address: "93.184.216.34" family: IPv4
- * ```
- *
- * All other functions in the `node:dns` module connect to an actual DNS server to
- * perform name resolution. They will always use the network to perform DNS
- * queries. These functions do not use the same set of configuration files used by {@link lookup} (e.g. `/etc/hosts`). Use these functions to always perform
- * DNS queries, bypassing other name-resolution facilities.
- *
- * ```js
- * import dns from 'node:dns';
- *
- * dns.resolve4('archive.org', (err, addresses) => {
- *   if (err) throw err;
- *
- *   console.log(`addresses: ${JSON.stringify(addresses)}`);
- *
- *   addresses.forEach((a) => {
- *     dns.reverse(a, (err, hostnames) => {
- *       if (err) {
- *         throw err;
- *       }
- *       console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`);
- *     });
- *   });
- * });
- * ```
- *
- * See the [Implementation considerations section](https://nodejs.org/docs/latest-v25.x/api/dns.html#implementation-considerations) for more information.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/dns.js)
- */
 declare module "node:dns" {
     // Supported getaddrinfo flags.
     /**

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

@@ -1,19 +1,3 @@
-/**
- * **This module is pending deprecation.** Once a replacement API has been
- * finalized, this module will be fully deprecated. Most developers should
- * **not** have cause to use this module. Users who absolutely must have
- * the functionality that domains provide may rely on it for the time being
- * but should expect to have to migrate to a different solution
- * in the future.
- *
- * Domains provide a way to handle multiple different IO operations as a
- * single group. If any of the event emitters or callbacks registered to a
- * domain emit an `'error'` event, or throw an error, then the domain object
- * will be notified, rather than losing the context of the error in the `process.on('uncaughtException')` handler, or causing the program to
- * exit immediately with an error code.
- * @deprecated Since v1.4.2 - Deprecated
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/domain.js)
- */
 declare module "node:domain" {
     import { EventEmitter } from "node:events";
     /**

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

@@ -1,39 +1,3 @@
-/**
- * Much of the Node.js core API is built around an idiomatic asynchronous
- * event-driven architecture in which certain kinds of objects (called "emitters")
- * emit named events that cause `Function` objects ("listeners") to be called.
- *
- * For instance: a `net.Server` object emits an event each time a peer
- * connects to it; a `fs.ReadStream` emits an event when the file is opened;
- * a `stream` emits an event whenever data is available to be read.
- *
- * All objects that emit events are instances of the `EventEmitter` class. These
- * objects expose an `eventEmitter.on()` function that allows one or more
- * functions to be attached to named events emitted by the object. Typically,
- * event names are camel-cased strings but any valid JavaScript property key
- * can be used.
- *
- * When the `EventEmitter` object emits an event, all of the functions attached
- * to that specific event are called _synchronously_. Any values returned by the
- * called listeners are _ignored_ and discarded.
- *
- * The following example shows a simple `EventEmitter` instance with a single
- * listener. The `eventEmitter.on()` method is used to register listeners, while
- * the `eventEmitter.emit()` method is used to trigger the event.
- *
- * ```js
- * import { EventEmitter } from 'node:events';
- *
- * class MyEmitter extends EventEmitter {}
- *
- * const myEmitter = new MyEmitter();
- * myEmitter.on('event', () => {
- *   console.log('an event occurred!');
- * });
- * myEmitter.emit('event');
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/events.js)
- */
 declare module "node:events" {
     import { AsyncResource, AsyncResourceOptions } from "node:async_hooks";
     // #region Event map helpers

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

@@ -1,13 +1,3 @@
-/**
- * The `fs/promises` API provides asynchronous file system methods that return
- * promises.
- *
- * The promise APIs use the underlying Node.js threadpool to perform file
- * system operations off the event loop thread. These operations are not
- * synchronized or threadsafe. Care must be taken when performing multiple
- * concurrent modifications on the same file or data corruption may occur.
- * @since v10.0.0
- */
 declare module "node:fs/promises" {
     import { NonSharedBuffer } from "node:buffer";
     import { Abortable } from "node:events";

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

@@ -1,23 +1,3 @@
-/**
- * The `node:fs` module enables interacting with the file system in a
- * way modeled on standard POSIX functions.
- *
- * To use the promise-based APIs:
- *
- * ```js
- * import * as fs from 'node:fs/promises';
- * ```
- *
- * To use the callback and sync APIs:
- *
- * ```js
- * import * as fs from 'node:fs';
- * ```
- *
- * All file system operations have synchronous, callback, and promise-based
- * forms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/fs.js)
- */
 declare module "node:fs" {
     import { NonSharedBuffer } from "node:buffer";
     import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";

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

@@ -1,44 +1,3 @@
-/**
- * To use the HTTP server and client one must import the `node:http` module.
- *
- * The HTTP interfaces in Node.js are designed to support many features
- * of the protocol which have been traditionally difficult to use.
- * In particular, large, possibly chunk-encoded, messages. The interface is
- * careful to never buffer entire requests or responses, so the
- * user is able to stream data.
- *
- * HTTP message headers are represented by an object like this:
- *
- * ```json
- * { "content-length": "123",
- *   "content-type": "text/plain",
- *   "connection": "keep-alive",
- *   "host": "example.com",
- *   "accept": "*" }
- * ```
- *
- * Keys are lowercased. Values are not modified.
- *
- * In order to support the full spectrum of possible HTTP applications, the Node.js
- * HTTP API is very low-level. It deals with stream handling and message
- * parsing only. It parses a message into headers and body but it does not
- * parse the actual headers or the body.
- *
- * See `message.headers` for details on how duplicate headers are handled.
- *
- * The raw headers as they were received are retained in the `rawHeaders` property, which is an array of `[key, value, key2, value2, ...]`. For
- * example, the previous message header object might have a `rawHeaders` list like the following:
- *
- * ```js
- * [ 'ConTent-Length', '123456',
- *   'content-LENGTH', '123',
- *   'content-type', 'text/plain',
- *   'CONNECTION', 'keep-alive',
- *   'Host', 'example.com',
- *   'accepT', '*' ]
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/http.js)
- */
 declare module "node:http" {
     import { NonSharedBuffer } from "node:buffer";
     import { LookupOptions } from "node:dns";

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

@@ -1,13 +1,3 @@
-/**
- * The `node:http2` module provides an implementation of the [HTTP/2](https://tools.ietf.org/html/rfc7540) protocol.
- * It can be accessed using:
- *
- * ```js
- * import http2 from 'node:http2';
- * ```
- * @since v8.4.0
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/http2.js)
- */
 declare module "node:http2" {
     import { NonSharedBuffer } from "node:buffer";
     import { InternalEventEmitter } from "node:events";

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

@@ -1,8 +1,3 @@
-/**
- * HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
- * separate module.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/https.js)
- */
 declare module "node:https" {
     import * as http from "node:http";
     import { Duplex } from "node:stream";

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

@@ -1,9 +1,3 @@
-/**
- * The `node:inspector/promises` module provides an API for interacting with the V8
- * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/inspector/promises.js)
- * @since v19.0.0
- */
 declare module "node:inspector/promises" {
     import { EventEmitter } from "node:events";
     export { close, console, NetworkResources, open, url, waitForDebugger } from "node:inspector";

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

@@ -1,8 +1,3 @@
-/**
- * The `node:inspector` module provides an API for interacting with the V8
- * inspector.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/inspector.js)
- */
 declare module "node:inspector" {
     import { EventEmitter } from "node:events";
     /**

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

@@ -1,6 +1,3 @@
-/**
- * @since v0.3.7
- */
 declare module "node:module" {
     import { URL } from "node:url";
     class Module {

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

@@ -1,17 +1,3 @@
-/**
- * > Stability: 2 - Stable
- *
- * The `node:net` module provides an asynchronous network API for creating stream-based
- * TCP or `IPC` servers ({@link createServer}) and clients
- * ({@link createConnection}).
- *
- * It can be accessed using:
- *
- * ```js
- * import net from 'node:net';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/net.js)
- */
 declare module "node:net" {
     import { NonSharedBuffer } from "node:buffer";
     import * as dns from "node:dns";
@@ -38,6 +24,7 @@ declare module "node:net" {
         keepAlive?: boolean | undefined;
         keepAliveInitialDelay?: number | undefined;
         blockList?: BlockList | undefined;
+        typeOfService?: number | undefined;
     }
     interface OnReadOpts {
         buffer: Uint8Array | (() => Uint8Array);
@@ -116,9 +103,14 @@ declare module "node:net" {
          * See `Writable` stream `write()` method for more
          * information.
          * @since v0.1.90
-         * @param [encoding='utf8'] Only used when data is `string`.
          */
         write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+        /**
+         * Sends data on the socket, with an explicit encoding for string data.
+         * @see {@link Socket.write} for full details.
+         * @since v0.1.90
+         * @param [encoding='utf8'] Only used when data is `string`.
+         */
         write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
         /**
          * Initiate a connection on a given socket.
@@ -226,6 +218,37 @@ declare module "node:net" {
          * @return The socket itself.
          */
         setKeepAlive(enable?: boolean, initialDelay?: number): this;
+        /**
+         * Returns the current Type of Service (TOS) field for IPv4 packets or Traffic
+         * Class for IPv6 packets for this socket.
+         *
+         * `setTypeOfService()` may be called before the socket is connected; the value
+         * will be cached and applied when the socket establishes a connection.
+         * `getTypeOfService()` will return the currently set value even before connection.
+         *
+         * On some platforms (e.g., Linux), certain TOS/ECN bits may be masked or ignored,
+         * and behavior can differ between IPv4 and IPv6 or dual-stack sockets. Callers
+         * should verify platform-specific semantics.
+         * @since v25.6.0
+         * @returns The current TOS value.
+         */
+        getTypeOfService(): number;
+        /**
+         * Sets the Type of Service (TOS) field for IPv4 packets or Traffic Class for IPv6
+         * Packets sent from this socket. This can be used to prioritize network traffic.
+         *
+         * `setTypeOfService()` may be called before the socket is connected; the value
+         * will be cached and applied when the socket establishes a connection.
+         * `getTypeOfService()` will return the currently set value even before connection.
+         *
+         * On some platforms (e.g., Linux), certain TOS/ECN bits may be masked or ignored,
+         * and behavior can differ between IPv4 and IPv6 or dual-stack sockets. Callers
+         * should verify platform-specific semantics.
+         * @since v25.6.0
+         * @param tos The TOS value to set (0-255).
+         * @returns The socket itself.
+         */
+        setTypeOfService(tos: number): this;
         /**
          * Returns the bound `address`, the address `family` name and `port` of the
          * socket as reported by the operating system:`{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`
@@ -358,12 +381,26 @@ declare module "node:net" {
          *
          * See `writable.end()` for further details.
          * @since v0.1.90
-         * @param [encoding='utf8'] Only used when data is `string`.
          * @param callback Optional callback for when the socket is finished.
          * @return The socket itself.
          */
         end(callback?: () => void): this;
+        /**
+         * Half-closes the socket, with one final chunk of data.
+         * @see {@link Socket.end} for full details.
+         * @since v0.1.90
+         * @param callback Optional callback for when the socket is finished.
+         * @return The socket itself.
+         */
         end(buffer: Uint8Array | string, callback?: () => void): this;
+        /**
+         * Half-closes the socket, with one final chunk of data.
+         * @see {@link Socket.end} for full details.
+         * @since v0.1.90
+         * @param [encoding='utf8'] Only used when data is `string`.
+         * @param callback Optional callback for when the socket is finished.
+         * @return The socket itself.
+         */
         end(str: Uint8Array | string, encoding?: BufferEncoding, callback?: () => void): this;
         // #region InternalEventEmitter
         addListener<E extends keyof SocketEventMap>(eventName: E, listener: (...args: SocketEventMap[E]) => void): this;

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

@@ -1,12 +1,3 @@
-/**
- * The `node:os` module provides operating system-related utility methods and
- * properties. It can be accessed using:
- *
- * ```js
- * import os from 'node:os';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/os.js)
- */
 declare module "node:os" {
     import { NonSharedBuffer } from "buffer";
     interface CpuInfo {

package/node_modules/@types/form-data/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "25.5.0",
+    "version": "25.6.0",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -147,9 +147,9 @@
     },
     "scripts": {},
     "dependencies": {
-        "undici-types": "~7.18.0"
+        "undici-types": "~7.19.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "4b6968335abe1dc64bd6086fd546d6e9c50f986c37d49de8073f4ed1c900057c",
-    "typeScriptVersion": "5.2"
+    "typesPublisherContentHash": "753bd9272f1c86686cc2d1bb435a7f033157f700201f64f0319742347e1ca060",
+    "typeScriptVersion": "5.3"
 }

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

@@ -1,12 +1,3 @@
-/**
- * The `node:path` module provides utilities for working with file and directory
- * paths. It can be accessed using:
- *
- * ```js
- * import path from 'node:path';
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/path.js)
- */
 declare module "node:path" {
     namespace path {
         /**

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

@@ -1,34 +1,3 @@
-/**
- * This module provides an implementation of a subset of the W3C [Web Performance APIs](https://w3c.github.io/perf-timing-primer/) as well as additional APIs for
- * Node.js-specific performance measurements.
- *
- * Node.js supports the following [Web Performance APIs](https://w3c.github.io/perf-timing-primer/):
- *
- * * [High Resolution Time](https://www.w3.org/TR/hr-time-2)
- * * [Performance Timeline](https://w3c.github.io/performance-timeline/)
- * * [User Timing](https://www.w3.org/TR/user-timing/)
- * * [Resource Timing](https://www.w3.org/TR/resource-timing-2/)
- *
- * ```js
- * import { PerformanceObserver, performance } from 'node:perf_hooks';
- *
- * const obs = new PerformanceObserver((items) => {
- *   console.log(items.getEntries()[0].duration);
- *   performance.clearMarks();
- * });
- * obs.observe({ type: 'measure' });
- * performance.measure('Start to Now');
- *
- * performance.mark('A');
- * doSomeLongRunningProcess(() => {
- *   performance.measure('A to Now', 'A');
- *
- *   performance.mark('B');
- *   performance.measure('A to B', 'A', 'B');
- * });
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/perf_hooks.js)
- */
 declare module "node:perf_hooks" {
     import { InternalEventTargetEventProperties } from "node:events";
     // #region web types