cloudstructs 0.9.18 → 0.9.20

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

@@ -156,6 +156,8 @@ declare global {
     interface RequireResolve extends NodeJS.RequireResolve {}
     interface NodeModule extends NodeJS.Module {}
 
+    var global: typeof globalThis;
+
     var process: NodeJS.Process;
     var console: Console;
 
@@ -168,10 +170,26 @@ declare global {
     // Same as module.exports
     var exports: any;
 
+    interface GCFunction {
+        (options: {
+            execution?: "sync";
+            flavor?: "regular" | "last-resort";
+            type?: "major-snapshot" | "major" | "minor";
+            filename?: string;
+        }): void;
+        (options: {
+            execution: "async";
+            flavor?: "regular" | "last-resort";
+            type?: "major-snapshot" | "major" | "minor";
+            filename?: string;
+        }): Promise<void>;
+        (options?: boolean): void;
+    }
+
     /**
      * Only available if `--expose-gc` is passed to the process.
      */
-    var gc: undefined | (() => void);
+    var gc: undefined | GCFunction;
 
     // #region borrowed
     // from https://github.com/microsoft/TypeScript/blob/38da7c600c83e7b31193a62495239a0fe478cb67/lib/lib.webworker.d.ts#L633 until moved to separate lib
@@ -249,53 +267,6 @@ declare global {
     var sessionStorage: Storage;
     // #endregion Storage
 
-    // #region Disposable
-    interface SymbolConstructor {
-        /**
-         * A method that is used to release resources held by an object. Called by the semantics of the `using` statement.
-         */
-        readonly dispose: unique symbol;
-
-        /**
-         * A method that is used to asynchronously release resources held by an object. Called by the semantics of the `await using` statement.
-         */
-        readonly asyncDispose: unique symbol;
-    }
-
-    interface Disposable {
-        [Symbol.dispose](): void;
-    }
-
-    interface AsyncDisposable {
-        [Symbol.asyncDispose](): PromiseLike<void>;
-    }
-    // #endregion Disposable
-
-    // #region ArrayLike.at()
-    interface RelativeIndexable<T> {
-        /**
-         * Takes an integer value and returns the item at that index,
-         * allowing for positive and negative integers.
-         * Negative integers count back from the last item in the array.
-         */
-        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> {}
-    // #endregion ArrayLike.at() end
-
     /**
      * @since v17.0.0
      *
@@ -448,7 +419,7 @@ declare global {
             unpipe(destination?: WritableStream): this;
             unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
             wrap(oldStream: ReadableStream): this;
-            [Symbol.asyncIterator](): AsyncIterableIterator<string | Buffer>;
+            [Symbol.asyncIterator](): NodeJS.AsyncIterator<string | Buffer>;
         }
 
         interface WritableStream extends EventEmitter {
@@ -467,20 +438,6 @@ declare global {
             unref(): this;
         }
 
-        type TypedArray =
-            | Uint8Array
-            | Uint8ClampedArray
-            | Uint16Array
-            | Uint32Array
-            | Int8Array
-            | Int16Array
-            | Int32Array
-            | BigUint64Array
-            | BigInt64Array
-            | Float32Array
-            | Float64Array;
-        type ArrayBufferView = TypedArray | DataView;
-
         interface Require {
             (id: string): any;
             resolve: RequireResolve;
@@ -531,6 +488,20 @@ declare global {
         interface ReadOnlyDict<T> {
             readonly [key: string]: T | undefined;
         }
+
+        /** An iterable iterator returned by the Node.js API. */
+        // Default TReturn/TNext in v22 is `any`, for compatibility with the previously-used IterableIterator.
+        // TODO: In next major @types/node version, change default TReturn to undefined.
+        interface Iterator<T, TReturn = any, TNext = any> extends IteratorObject<T, TReturn, TNext> {
+            [Symbol.iterator](): NodeJS.Iterator<T, TReturn, TNext>;
+        }
+
+        /** An async iterable iterator returned by the Node.js API. */
+        // Default TReturn/TNext in v22 is `any`, for compatibility with the previously-used AsyncIterableIterator.
+        // TODO: In next major @types/node version, change default TReturn to undefined.
+        interface AsyncIterator<T, TReturn = any, TNext = any> extends AsyncIteratorObject<T, TReturn, TNext> {
+            [Symbol.asyncIterator](): NodeJS.AsyncIterator<T, TReturn, TNext>;
+        }
     }
 
     interface RequestInit extends _RequestInit {}

package/node_modules/@types/responselike/node_modules/@types/node/globals.typedarray.d.ts

@@ -0,0 +1,21 @@
+export {}; // Make this a module
+
+declare global {
+    namespace NodeJS {
+        type TypedArray<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> =
+            | Uint8Array<TArrayBuffer>
+            | Uint8ClampedArray<TArrayBuffer>
+            | Uint16Array<TArrayBuffer>
+            | Uint32Array<TArrayBuffer>
+            | Int8Array<TArrayBuffer>
+            | Int16Array<TArrayBuffer>
+            | Int32Array<TArrayBuffer>
+            | BigUint64Array<TArrayBuffer>
+            | BigInt64Array<TArrayBuffer>
+            | Float32Array<TArrayBuffer>
+            | Float64Array<TArrayBuffer>;
+        type ArrayBufferView<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> =
+            | TypedArray<TArrayBuffer>
+            | DataView<TArrayBuffer>;
+    }
+}

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

@@ -1,5 +1,5 @@
 /**
- * To use the HTTP server and client one must `require('node:http')`.
+ * 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.
@@ -141,6 +141,7 @@ declare module "http" {
         "content-range"?: string | undefined;
         "content-security-policy"?: string | undefined;
         "content-security-policy-report-only"?: string | undefined;
+        "content-type"?: string | undefined;
         cookie?: string | string[] | undefined;
         dav?: string | string[] | undefined;
         dnt?: string | undefined;
@@ -231,7 +232,7 @@ declare module "http" {
     }
     interface ServerOptions<
         Request extends typeof IncomingMessage = typeof IncomingMessage,
-        Response extends typeof ServerResponse = typeof ServerResponse,
+        Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse,
     > {
         /**
          * Specifies the `IncomingMessage` class to be used. Useful for extending the original `IncomingMessage`.
@@ -315,14 +316,14 @@ declare module "http" {
     }
     type RequestListener<
         Request extends typeof IncomingMessage = typeof IncomingMessage,
-        Response extends typeof ServerResponse = typeof ServerResponse,
+        Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse,
     > = (req: InstanceType<Request>, res: InstanceType<Response> & { req: InstanceType<Request> }) => void;
     /**
      * @since v0.1.17
      */
     class Server<
         Request extends typeof IncomingMessage = typeof IncomingMessage,
-        Response extends typeof ServerResponse = typeof ServerResponse,
+        Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse,
     > extends NetServer {
         constructor(requestListener?: RequestListener<Request, Response>);
         constructor(options: ServerOptions<Request, Response>, requestListener?: RequestListener<Request, Response>);
@@ -588,6 +589,42 @@ declare module "http" {
          * @param value Header value
          */
         setHeader(name: string, value: number | string | readonly string[]): this;
+        /**
+         * Sets multiple header values for implicit headers. headers must be an instance of
+         * `Headers` or `Map`, if a header already exists in the to-be-sent headers, its
+         * value will be replaced.
+         *
+         * ```js
+         * const headers = new Headers({ foo: 'bar' });
+         * outgoingMessage.setHeaders(headers);
+         * ```
+         *
+         * or
+         *
+         * ```js
+         * const headers = new Map([['foo', 'bar']]);
+         * outgoingMessage.setHeaders(headers);
+         * ```
+         *
+         * When headers have been set with `outgoingMessage.setHeaders()`, they will be
+         * merged with any headers passed to `response.writeHead()`, with the headers passed
+         * to `response.writeHead()` given precedence.
+         *
+         * ```js
+         * // Returns content-type = text/plain
+         * const server = http.createServer((req, res) => {
+         *   const headers = new Headers({ 'Content-Type': 'text/html' });
+         *   res.setHeaders(headers);
+         *   res.writeHead(200, { 'Content-Type': 'text/plain' });
+         *   res.end('ok');
+         * });
+         * ```
+         *
+         * @since v19.6.0, v18.15.0
+         * @param name Header name
+         * @param value Header value
+         */
+        setHeaders(headers: Headers | Map<string, number | string | readonly string[]>): this;
         /**
          * Append a single header value to the header object.
          *
@@ -1447,7 +1484,7 @@ declare module "http" {
      * To configure any of them, a custom {@link Agent} instance must be created.
      *
      * ```js
-     * const http = require('node:http');
+     * import http from 'node:http';
      * const keepAliveAgent = new http.Agent({ keepAlive: true });
      * options.agent = keepAliveAgent;
      * http.request(options, onResponseCallback)
@@ -1553,11 +1590,11 @@ declare module "http" {
      */
     function createServer<
         Request extends typeof IncomingMessage = typeof IncomingMessage,
-        Response extends typeof ServerResponse = typeof ServerResponse,
+        Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse,
     >(requestListener?: RequestListener<Request, Response>): Server<Request, Response>;
     function createServer<
         Request extends typeof IncomingMessage = typeof IncomingMessage,
-        Response extends typeof ServerResponse = typeof ServerResponse,
+        Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse,
     >(
         options: ServerOptions<Request, Response>,
         requestListener?: RequestListener<Request, Response>,