cloudstructs 0.9.19 → 0.9.21

package/node_modules/@types/keyv/node_modules/@types/node/stream/web.d.ts

@@ -166,6 +166,9 @@ declare module "stream/web" {
     interface ReadableStreamErrorCallback {
         (reason: any): void | PromiseLike<void>;
     }
+    interface ReadableStreamAsyncIterator<T> extends NodeJS.AsyncIterator<T, NodeJS.BuiltinIteratorReturn, unknown> {
+        [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;
+    }
     /** This Streams API interface represents a readable stream of byte data. */
     interface ReadableStream<R = any> {
         readonly locked: boolean;
@@ -176,8 +179,8 @@ declare module "stream/web" {
         pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
         pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
         tee(): [ReadableStream<R>, ReadableStream<R>];
-        values(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
-        [Symbol.asyncIterator](): AsyncIterableIterator<R>;
+        values(options?: { preventCancel?: boolean }): ReadableStreamAsyncIterator<R>;
+        [Symbol.asyncIterator](): ReadableStreamAsyncIterator<R>;
     }
     const ReadableStream: {
         prototype: ReadableStream;

package/node_modules/@types/keyv/node_modules/@types/node/stream.d.ts

@@ -422,7 +422,7 @@ declare module "stream" {
          * or exiting a `for await...of` iteration using a `break`, `return`, or `throw` will not destroy the stream.
          * **Default: `true`**.
          */
-        iterator(options?: { destroyOnReturn?: boolean }): AsyncIterableIterator<any>;
+        iterator(options?: { destroyOnReturn?: boolean }): NodeJS.AsyncIterator<any>;
         /**
          * This method allows mapping over the stream. The *fn* function will be called for every chunk in the stream.
          * If the *fn* function returns a promise - that promise will be `await`ed before being passed to the result stream.
@@ -651,7 +651,7 @@ declare module "stream" {
         removeListener(event: "readable", listener: () => void): this;
         removeListener(event: "resume", listener: () => void): this;
         removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+        [Symbol.asyncIterator](): NodeJS.AsyncIterator<any>;
         /**
          * Calls `readable.destroy()` with an `AbortError` and returns a promise that fulfills when the stream is finished.
          * @since v20.4.0

package/node_modules/@types/keyv/node_modules/@types/node/test.d.ts

@@ -340,11 +340,22 @@ declare module "node:test" {
         globPatterns?: readonly string[] | undefined;
         /**
          * Sets inspector port of test child process.
-         * If a nullish value is provided, each process gets its own port,
-         * incremented from the primary's `process.debugPort`.
+         * This can be a number, or a function that takes no arguments and returns a
+         * number. If a nullish value is provided, each process gets its own port,
+         * incremented from the primary's `process.debugPort`. This option is ignored
+         * if the `isolation` option is set to `'none'` as no child processes are
+         * spawned.
          * @default undefined
          */
         inspectPort?: number | (() => number) | undefined;
+        /**
+         * Configures the type of test isolation. If set to
+         * `'process'`, each test file is run in a separate child process. If set to
+         * `'none'`, all test files run in the current process.
+         * @default 'process'
+         * @since v22.8.0
+         */
+        isolation?: "process" | "none" | undefined;
         /**
          * If truthy, the test context will only run tests that have the `only` option set
          */
@@ -1635,9 +1646,10 @@ declare module "node:test" {
          * This function is used to set a custom resolver for the location of the snapshot file used for snapshot testing.
          * By default, the snapshot filename is the same as the entry point filename with `.snapshot` appended.
          * @since v22.3.0
-         * @param fn A function which returns a string specifying the location of the snapshot file.
-         * The function receives the path of the test file as its only argument.
-         * If `process.argv[1]` is not associated with a file (for example in the REPL), the input is undefined.
+         * @param fn A function used to compute the location of the snapshot file.
+         * The function receives the path of the test file as its only argument. If the
+         * test is not associated with a file (for example in the REPL), the input is
+         * undefined. `fn()` must return a string specifying the location of the snapshot file.
          */
         function setResolveSnapshotPath(fn: (path: string | undefined) => string): void;
     }
@@ -1784,6 +1796,25 @@ interface TestCoverage {
                 count: number;
             }>;
         }>;
+        /**
+         * An object containing whether or not the coverage for
+         * each coverage type.
+         * @since v22.9.0
+         */
+        thresholds: {
+            /**
+             * The function coverage threshold.
+             */
+            function: number;
+            /**
+             * The branch coverage threshold.
+             */
+            branch: number;
+            /**
+             * The line coverage threshold.
+             */
+            line: number;
+        };
         /**
          * An object containing a summary of coverage for all files.
          */

package/node_modules/@types/keyv/node_modules/@types/node/timers/promises.d.ts

@@ -80,7 +80,7 @@ declare module "timers/promises" {
          * @experimental
          * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.
          */
-        wait: (delay?: number, options?: Pick<TimerOptions, "signal">) => Promise<void>;
+        wait: (delay?: number, options?: TimerOptions) => Promise<void>;
         /**
          * An experimental API defined by the [Scheduling APIs](https://nodejs.org/docs/latest-v20.x/api/async_hooks.html#promise-execution-tracking) draft specification
          * being developed as a standard Web Platform API.

package/node_modules/@types/keyv/node_modules/@types/node/tls.d.ts

@@ -809,6 +809,12 @@ declare module "tls" {
          * This option cannot be used with the `ALPNProtocols` option, and setting both options will throw an error.
          */
         ALPNCallback?: ((arg: { servername: string; protocols: string[] }) => string | undefined) | undefined;
+        /**
+         * Treat intermediate (non-self-signed)
+         * certificates in the trust CA certificate list as trusted.
+         * @since v22.9.0, v20.18.0
+         */
+        allowPartialTrustChain?: boolean | undefined;
         /**
          * Optionally override the trusted CA certificates. Default is to trust
          * the well-known CAs curated by Mozilla. Mozilla's CAs are completely

package/node_modules/@types/keyv/node_modules/@types/node/ts5.6/index.d.ts

@@ -22,22 +22,22 @@
  * IN THE SOFTWARE.
  */
 
-// NOTE: These definitions support NodeJS and TypeScript 4.9 through 5.6.
+// NOTE: These definitions support Node.js and TypeScript 4.9 through 5.6.
 
-// Reference required types from the default lib:
+// Reference required TypeScript libs:
 /// <reference lib="es2020" />
-/// <reference lib="esnext.asynciterable" />
-/// <reference lib="esnext.intl" />
-/// <reference lib="esnext.bigint" />
 
-// Definitions specific to TypeScript 4.9 through 5.6
+// TypeScript backwards-compatibility definitions:
+/// <reference path="../compatibility/index.d.ts" />
+
+// Definitions specific to TypeScript 4.9 through 5.6:
 /// <reference path="./globals.typedarray.d.ts" />
 /// <reference path="./buffer.buffer.d.ts" />
 
-// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
+// Definitions for Node.js modules that are not specific to any version of TypeScript:
+/// <reference path="../globals.d.ts" />
 /// <reference path="../assert.d.ts" />
 /// <reference path="../assert/strict.d.ts" />
-/// <reference path="../globals.d.ts" />
 /// <reference path="../async_hooks.d.ts" />
 /// <reference path="../buffer.d.ts" />
 /// <reference path="../child_process.d.ts" />
@@ -90,5 +90,3 @@
 /// <reference path="../wasi.d.ts" />
 /// <reference path="../worker_threads.d.ts" />
 /// <reference path="../zlib.d.ts" />
-
-/// <reference path="../globals.global.d.ts" />

package/node_modules/@types/keyv/node_modules/@types/node/url.d.ts

@@ -757,6 +757,9 @@ declare module "url" {
          */
         toJSON(): string;
     }
+    interface URLSearchParamsIterator<T> extends NodeJS.Iterator<T, NodeJS.BuiltinIteratorReturn, unknown> {
+        [Symbol.iterator](): URLSearchParamsIterator<T>;
+    }
     /**
      * The `URLSearchParams` API provides read and write access to the query of a `URL`. The `URLSearchParams` class can also be used standalone with one of the
      * four following constructors.
@@ -827,7 +830,7 @@ declare module "url" {
          *
          * Alias for `urlSearchParams[@@iterator]()`.
          */
-        entries(): IterableIterator<[string, string]>;
+        entries(): URLSearchParamsIterator<[string, string]>;
         /**
          * Iterates over each name-value pair in the query and invokes the given function.
          *
@@ -881,7 +884,7 @@ declare module "url" {
          * //   foo
          * ```
          */
-        keys(): IterableIterator<string>;
+        keys(): URLSearchParamsIterator<string>;
         /**
          * Sets the value in the `URLSearchParams` object associated with `name` to `value`. If there are any pre-existing name-value pairs whose names are `name`,
          * set the first such pair's value to `value` and remove all others. If not,
@@ -931,8 +934,8 @@ declare module "url" {
         /**
          * Returns an ES6 `Iterator` over the values of each name-value pair.
          */
-        values(): IterableIterator<string>;
-        [Symbol.iterator](): IterableIterator<[string, string]>;
+        values(): URLSearchParamsIterator<string>;
+        [Symbol.iterator](): URLSearchParamsIterator<[string, string]>;
     }
     import { URL as _URL, URLSearchParams as _URLSearchParams } from "url";
     global {

package/node_modules/@types/keyv/node_modules/@types/node/util.d.ts

@@ -108,6 +108,25 @@ declare module "util" {
     export interface InspectOptionsStylized extends InspectOptions {
         stylize(text: string, styleType: Style): string;
     }
+    export interface StacktraceObject {
+        /**
+         * Returns the name of the function associated with this stack frame.
+         */
+        functionName: string;
+        /**
+         * Returns the name of the resource that contains the script for the
+         * function for this StackFrame.
+         */
+        scriptName: string;
+        /**
+         * Returns the number, 1-based, of the line for the associate function call.
+         */
+        lineNumber: number;
+        /**
+         * Returns the 1-based column offset on the line for the associated function call.
+         */
+        column: number;
+    }
     /**
      * The `util.format()` method returns a formatted string using the first argument
      * as a `printf`-like format string which can contain zero or more format
@@ -166,6 +185,52 @@ declare module "util" {
      * @since v10.0.0
      */
     export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
+    /**
+     * Returns an array of stacktrace objects containing the stack of
+     * the caller function.
+     *
+     * ```js
+     * const util = require('node:util');
+     *
+     * function exampleFunction() {
+     *   const callSites = util.getCallSite();
+     *
+     *   console.log('Call Sites:');
+     *   callSites.forEach((callSite, index) => {
+     *     console.log(`CallSite ${index + 1}:`);
+     *     console.log(`Function Name: ${callSite.functionName}`);
+     *     console.log(`Script Name: ${callSite.scriptName}`);
+     *     console.log(`Line Number: ${callSite.lineNumber}`);
+     *     console.log(`Column Number: ${callSite.column}`);
+     *   });
+     *   // CallSite 1:
+     *   // Function Name: exampleFunction
+     *   // Script Name: /home/example.js
+     *   // Line Number: 5
+     *   // Column Number: 26
+     *
+     *   // CallSite 2:
+     *   // Function Name: anotherFunction
+     *   // Script Name: /home/example.js
+     *   // Line Number: 22
+     *   // Column Number: 3
+     *
+     *   // ...
+     * }
+     *
+     * // A function to simulate another stack layer
+     * function anotherFunction() {
+     *   exampleFunction();
+     * }
+     *
+     * anotherFunction();
+     * ```
+     * @param frames Number of frames returned in the stacktrace.
+     * **Default:** `10`. Allowable range is between 1 and 200.
+     * @return An array of stacktrace objects
+     * @since v22.9.0
+     */
+    export function getCallSite(frames?: number): StacktraceObject[];
     /**
      * Returns the string name for a numeric error code that comes from a Node.js API.
      * The mapping between error codes and error names is platform-dependent.
@@ -1517,18 +1582,23 @@ declare module "util" {
         string | boolean
     >;
 
+    type ApplyOptionalModifiers<O extends ParseArgsOptionsConfig, V extends Record<keyof O, unknown>> = (
+        & { -readonly [LongOption in keyof O]?: V[LongOption] }
+        & { [LongOption in keyof O as O[LongOption]["default"] extends {} ? LongOption : never]: V[LongOption] }
+    ) extends infer P ? { [K in keyof P]: P[K] } : never; // resolve intersection to object
+
     type ParsedValues<T extends ParseArgsConfig> =
         & IfDefaultsTrue<T["strict"], unknown, { [longOption: string]: undefined | string | boolean }>
-        & (T["options"] extends ParseArgsOptionsConfig ? {
-                -readonly [LongOption in keyof T["options"]]:
-                    // when "default" is not undefined, the value will be present
-                    | (T["options"][LongOption]["default"] extends {} ? never : undefined)
-                    | IfDefaultsFalse<
+        & (T["options"] extends ParseArgsOptionsConfig ? ApplyOptionalModifiers<
+                T["options"],
+                {
+                    [LongOption in keyof T["options"]]: IfDefaultsFalse<
                         T["options"][LongOption]["multiple"],
                         Array<ExtractOptionValue<T, T["options"][LongOption]>>,
                         ExtractOptionValue<T, T["options"][LongOption]>
                     >;
-            }
+                }
+            >
             : {});
 
     type ParsedPositionals<T extends ParseArgsConfig> = IfDefaultsTrue<
@@ -1720,7 +1790,7 @@ declare module "util" {
          * Each item of the iterator is a JavaScript `Array`. The first item of the array
          * is the `name`, the second item of the array is the `value`.
          */
-        entries(): IterableIterator<[name: string, value: string]>;
+        entries(): NodeJS.Iterator<[name: string, value: string]>;
         /**
          * Returns the value of the first name-value pair whose name is `name`. If there
          * are no such pairs, `null` is returned.
@@ -1746,7 +1816,7 @@ declare module "util" {
          * //   bar
          * ```
          */
-        keys(): IterableIterator<string>;
+        keys(): NodeJS.Iterator<string>;
         /**
          * Sets the value in the `MIMEParams` object associated with `name` to `value`. If there are any pre-existing name-value pairs whose names are `name`,
          * set the first such pair's value to `value`.
@@ -1765,11 +1835,11 @@ declare module "util" {
         /**
          * Returns an iterator over the values of each name-value pair.
          */
-        values(): IterableIterator<string>;
+        values(): NodeJS.Iterator<string>;
         /**
          * Returns an iterator over each of the name-value pairs in the parameters.
          */
-        [Symbol.iterator]: typeof MIMEParams.prototype.entries;
+        [Symbol.iterator](): NodeJS.Iterator<[name: string, value: string]>;
     }
 }
 declare module "util/types" {

package/node_modules/@types/keyv/node_modules/@types/node/vm.d.ts

@@ -230,16 +230,23 @@ declare module "vm" {
          */
         runInContext(contextifiedObject: Context, options?: RunningScriptOptions): any;
         /**
-         * First contextifies the given `contextObject`, runs the compiled code contained
-         * by the `vm.Script` object within the created context, and returns the result.
-         * Running code does not have access to local scope.
+         * This method is a shortcut to `script.runInContext(vm.createContext(options), options)`.
+         * It does several things at once:
+         *
+         * 1. Creates a new context.
+         * 2. If `contextObject` is an object, contextifies it with the new context.
+         *    If  `contextObject` is undefined, creates a new object and contextifies it.
+         *    If `contextObject` is `vm.constants.DONT_CONTEXTIFY`, don't contextify anything.
+         * 3. Runs the compiled code contained by the `vm.Script` object within the created context. The code
+         *    does not have access to the scope in which this method is called.
+         * 4. Returns the result.
          *
          * The following example compiles code that sets a global variable, then executes
          * the code multiple times in different contexts. The globals are set on and
          * contained within each individual `context`.
          *
          * ```js
-         * import vm from 'node:vm';
+         * const vm = require('node:vm');
          *
          * const script = new vm.Script('globalVar = "set"');
          *
@@ -250,12 +257,22 @@ declare module "vm" {
          *
          * console.log(contexts);
          * // Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }]
+         *
+         * // This would throw if the context is created from a contextified object.
+         * // vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary
+         * // global objects that can be frozen.
+         * const freezeScript = new vm.Script('Object.freeze(globalThis); globalThis;');
+         * const frozenContext = freezeScript.runInNewContext(vm.constants.DONT_CONTEXTIFY);
          * ```
          * @since v0.3.1
-         * @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
+         * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
+         * If `undefined`, an empty contextified object will be created for backwards compatibility.
          * @return the result of the very last statement executed in the script.
          */
-        runInNewContext(contextObject?: Context, options?: RunningScriptInNewContextOptions): any;
+        runInNewContext(
+            contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
+            options?: RunningScriptInNewContextOptions,
+        ): any;
         /**
          * Runs the compiled code contained by the `vm.Script` within the context of the
          * current `global` object. Running code does not have access to local scope, but _does_ have access to the current `global` object.
@@ -347,17 +364,17 @@ declare module "vm" {
         sourceMapURL?: string | undefined;
     }
     /**
-     * If given a `contextObject`, the `vm.createContext()` method will
+     * If the given `contextObject` is an object, the `vm.createContext()` method will
      * [prepare that object](https://nodejs.org/docs/latest-v22.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 `{@link runInContext}` or
-     * [`script.runInContext()`](https://nodejs.org/docs/latest-v22.x/api/vm.html#scriptrunincontextcontextifiedobject-options). Inside such
-     * scripts, the `contextObject` will be the global object, 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
+     * 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-v22.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
      * variables will remain unchanged.
      *
      * ```js
-     * import vm from 'node:vm';
+     * const vm = require('node:vm');
      *
      * global.globalVar = 3;
      *
@@ -374,7 +391,12 @@ declare module "vm" {
      * ```
      *
      * If `contextObject` is omitted (or passed explicitly as `undefined`), a new,
-     * empty `contextified` object will be returned.
+     * empty contextified object will be returned.
+     *
+     * When the global object in the newly created context is contextified, it has some quirks
+     * compared to ordinary global objects. For example, it cannot be frozen. To create a context
+     * without the contextifying quirks, pass `vm.constants.DONT_CONTEXTIFY` as the `contextObject`
+     * argument. See the documentation of `vm.constants.DONT_CONTEXTIFY` for details.
      *
      * The `vm.createContext()` method is primarily useful for creating a single
      * context that can be used to run multiple scripts. For instance, if emulating a
@@ -385,11 +407,17 @@ declare module "vm" {
      * The provided `name` and `origin` of the context are made visible through the
      * Inspector API.
      * @since v0.3.1
+     * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
+     * If `undefined`, an empty contextified object will be created for backwards compatibility.
      * @return contextified object.
      */
-    function createContext(sandbox?: Context, options?: CreateContextOptions): Context;
+    function createContext(
+        contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
+        options?: CreateContextOptions,
+    ): Context;
     /**
-     * Returns `true` if the given `object` object has been `contextified` using {@link createContext}.
+     * Returns `true` if the given `object` object has been contextified using {@link createContext},
+     * or if it's the global object of a context created using `vm.constants.DONT_CONTEXTIFY`.
      * @since v0.11.7
      */
     function isContext(sandbox: Context): boolean;
@@ -422,18 +450,26 @@ declare module "vm" {
      */
     function runInContext(code: string, contextifiedObject: Context, options?: RunningCodeOptions | string): any;
     /**
-     * The `vm.runInNewContext()` first contextifies the given `contextObject` (or
-     * creates a new `contextObject` if passed as `undefined`), compiles the `code`,
-     * runs it within the created context, then returns the result. Running code
-     * does not have access to the local scope.
-     *
+     * This method is a shortcut to
+     * `(new vm.Script(code, options)).runInContext(vm.createContext(options), options)`.
      * If `options` is a string, then it specifies the filename.
      *
+     * It does several things at once:
+     *
+     * 1. Creates a new context.
+     * 2. If `contextObject` is an object, contextifies it with the new context.
+     *    If  `contextObject` is undefined, creates a new object and contextifies it.
+     *    If `contextObject` is `vm.constants.DONT_CONTEXTIFY`, don't contextify anything.
+     * 3. Compiles the code as a`vm.Script`
+     * 4. Runs the compield code within the created context. The code does not have access to the scope in
+     *    which this method is called.
+     * 5. Returns the result.
+     *
      * The following example compiles and executes code that increments a global
      * variable and sets a new one. These globals are contained in the `contextObject`.
      *
      * ```js
-     * import vm from 'node:vm';
+     * const vm = require('node:vm');
      *
      * const contextObject = {
      *   animal: 'cat',
@@ -443,15 +479,21 @@ declare module "vm" {
      * vm.runInNewContext('count += 1; name = "kitty"', contextObject);
      * console.log(contextObject);
      * // Prints: { animal: 'cat', count: 3, name: 'kitty' }
+     *
+     * // This would throw if the context is created from a contextified object.
+     * // vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary global objects that
+     * // can be frozen.
+     * const frozenContext = vm.runInNewContext('Object.freeze(globalThis); globalThis;', vm.constants.DONT_CONTEXTIFY);
      * ```
      * @since v0.3.1
      * @param code The JavaScript code to compile and run.
-     * @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
+     * @param contextObject Either `vm.constants.DONT_CONTEXTIFY` or an object that will be contextified.
+     * If `undefined`, an empty contextified object will be created for backwards compatibility.
      * @return the result of the very last statement executed in the script.
      */
     function runInNewContext(
         code: string,
-        contextObject?: Context,
+        contextObject?: Context | typeof constants.DONT_CONTEXTIFY,
         options?: RunningCodeInNewContextOptions | string,
     ): any;
     /**
@@ -902,19 +944,31 @@ declare module "vm" {
     }
     /**
      * Returns an object containing commonly used constants for VM operations.
-     * @since v20.12.0
+     * @since v21.7.0, v20.12.0
      */
     namespace constants {
         /**
-         * Stability: 1.1 - Active development
-         *
          * A constant that can be used as the `importModuleDynamically` option to `vm.Script`
          * 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-v22.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;
+        /**
+         * This constant, when used as the `contextObject` argument in vm APIs, instructs Node.js to create
+         * a context without wrapping its global object with another object in a Node.js-specific manner.
+         * As a result, the `globalThis` value inside the new context would behave more closely to an ordinary
+         * one.
+         *
+         * When `vm.constants.DONT_CONTEXTIFY` is used as the `contextObject` argument to {@link createContext},
+         * the returned object is a proxy-like object to the global object in the newly created context with
+         * fewer Node.js-specific quirks. It is reference equal to the `globalThis` value in the new context,
+         * can be modified from outside the context, and can be used to access built-ins in the new context directly.
+         * @since v22.8.0
+         */
+        const DONT_CONTEXTIFY: number;
     }
 }
 declare module "node:vm" {

package/node_modules/@types/keyv/node_modules/@types/node/worker_threads.d.ts

@@ -267,7 +267,7 @@ declare module "worker_threads" {
         trackUnmanagedFds?: boolean | undefined;
         /**
          * An optional `name` to be appended to the worker title
-         * for debuggin/identification purposes, making the final title as
+         * for debugging/identification purposes, making the final title as
          * `[worker ${id}] ${name}`.
          */
         name?: string | undefined;

package/node_modules/@types/responselike/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: Mon, 07 Oct 2024 22:07:58 GMT
+ * Last updated: Tue, 05 Nov 2024 01:29:26 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

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

@@ -45,7 +45,7 @@ declare module "assert" {
                 /** The `operator` property on the error instance. */
                 operator?: string | undefined;
                 /** If provided, the generated stack trace omits frames before this function. */
-                // eslint-disable-next-line @typescript-eslint/ban-types
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
                 stackStartFn?: Function | undefined;
             });
         }
@@ -226,7 +226,7 @@ declare module "assert" {
             expected: unknown,
             message?: string | Error,
             operator?: string,
-            // eslint-disable-next-line @typescript-eslint/ban-types
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
             stackStartFn?: Function,
         ): never;
         /**

package/node_modules/@types/responselike/node_modules/@types/node/compatibility/disposable.d.ts

@@ -0,0 +1,16 @@
+// Polyfills for the explicit resource management types added in TypeScript 5.2.
+// TODO: remove once this package no longer supports TS 5.1, and replace with a
+// <reference> to TypeScript's disposable library in index.d.ts.
+
+interface SymbolConstructor {
+    readonly dispose: unique symbol;
+    readonly asyncDispose: unique symbol;
+}
+
+interface Disposable {
+    [Symbol.dispose](): void;
+}
+
+interface AsyncDisposable {
+    [Symbol.asyncDispose](): PromiseLike<void>;
+}

package/node_modules/@types/responselike/node_modules/@types/node/compatibility/index.d.ts

@@ -0,0 +1,9 @@
+// Declaration files in this directory contain types relating to TypeScript library features
+// that are not included in all TypeScript versions supported by DefinitelyTyped, but
+// which can be made backwards-compatible without needing `typesVersions`.
+// If adding declarations to this directory, please specify which versions of TypeScript require them,
+// so that they can be removed when no longer needed.
+
+/// <reference path="disposable.d.ts" />
+/// <reference path="indexable.d.ts" />
+/// <reference path="iterators.d.ts" />

package/node_modules/@types/responselike/node_modules/@types/node/compatibility/indexable.d.ts

@@ -0,0 +1,23 @@
+// Polyfill for ES2022's .at() method on string/array prototypes, added to TypeScript in 4.6.
+// TODO: these methods are not used within @types/node, and should be removed at the next
+// major @types/node version; users should include the es2022 TypeScript libraries
+// if they need these features.
+
+interface RelativeIndexable<T> {
+    at(index: number): T | undefined;
+}
+
+interface String extends RelativeIndexable<string> {}
+interface Array<T> extends RelativeIndexable<T> {}
+interface ReadonlyArray<T> extends RelativeIndexable<T> {}
+interface Int8Array extends RelativeIndexable<number> {}
+interface Uint8Array extends RelativeIndexable<number> {}
+interface Uint8ClampedArray extends RelativeIndexable<number> {}
+interface Int16Array extends RelativeIndexable<number> {}
+interface Uint16Array extends RelativeIndexable<number> {}
+interface Int32Array extends RelativeIndexable<number> {}
+interface Uint32Array extends RelativeIndexable<number> {}
+interface Float32Array extends RelativeIndexable<number> {}
+interface Float64Array extends RelativeIndexable<number> {}
+interface BigInt64Array extends RelativeIndexable<bigint> {}
+interface BigUint64Array extends RelativeIndexable<bigint> {}