cloudstructs 0.6.27 → 0.6.29

package/node_modules/@slack/web-api/node_modules/@types/node/vm.d.ts

@@ -56,11 +56,17 @@ declare module 'vm' {
         columnOffset?: number | undefined;
     }
     interface ScriptOptions extends BaseOptions {
-        displayErrors?: boolean | undefined;
-        timeout?: number | undefined;
-        cachedData?: Buffer | undefined;
+        /**
+         * V8's code cache data for the supplied source.
+         */
+        cachedData?: Buffer | NodeJS.ArrayBufferView | undefined;
         /** @deprecated in favor of `script.createCachedData()` */
         produceCachedData?: boolean | undefined;
+        /**
+         * Called during evaluation of this module when `import()` is called.
+         * If this option is not specified, calls to `import()` will reject with `ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`.
+         */
+        importModuleDynamically?: ((specifier: string, script: Script, importAssertions: Object) => Module) | undefined;
     }
     interface RunningScriptOptions extends BaseOptions {
         /**
@@ -80,10 +86,31 @@ declare module 'vm' {
          * Default: `false`.
          */
         breakOnSigint?: boolean | undefined;
+    }
+    interface RunningScriptInNewContextOptions extends RunningScriptOptions {
+        /**
+         * Human-readable name of the newly created context.
+         */
+        contextName?: CreateContextOptions['name'];
+        /**
+         * Origin corresponding to the newly created context for display purposes. The origin should be formatted like a URL,
+         * but with only the scheme, host, and port (if necessary), like the value of the `url.origin` property of a `URL` object.
+         * Most notably, this string should omit the trailing slash, as that denotes a path.
+         */
+        contextOrigin?: CreateContextOptions['origin'];
+        contextCodeGeneration?: CreateContextOptions['codeGeneration'];
         /**
          * If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
          */
-        microtaskMode?: 'afterEvaluate' | undefined;
+        microtaskMode?: CreateContextOptions['microtaskMode'];
+    }
+    interface RunningCodeOptions extends RunningScriptOptions {
+        cachedData?: ScriptOptions['cachedData'];
+        importModuleDynamically?: ScriptOptions['importModuleDynamically'];
+    }
+    interface RunningCodeInNewContextOptions extends RunningScriptInNewContextOptions {
+        cachedData?: ScriptOptions['cachedData'];
+        importModuleDynamically?: ScriptOptions['importModuleDynamically'];
     }
     interface CompileFunctionOptions extends BaseOptions {
         /**
@@ -144,7 +171,10 @@ declare module 'vm' {
          * @default 'summary'
          */
         mode?: MeasureMemoryMode | undefined;
-        context?: Context | undefined;
+        /**
+         * @default 'default'
+         */
+        execution?: 'default' | 'eager' | undefined;
     }
     interface MemoryMeasurement {
         total: {
@@ -158,7 +188,7 @@ declare module 'vm' {
      * @since v0.3.1
      */
     class Script {
-        constructor(code: string, options?: ScriptOptions);
+        constructor(code: string, options?: ScriptOptions | string);
         /**
          * Runs the compiled code contained by the `vm.Script` object within the given`contextifiedObject` and returns the result. Running code does not have access
          * to local scope.
@@ -220,7 +250,7 @@ declare module 'vm' {
          * @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
          * @return the result of the very last statement executed in the script.
          */
-        runInNewContext(contextObject?: Context, options?: RunningScriptOptions): any;
+        runInNewContext(contextObject?: Context, 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.
@@ -273,6 +303,10 @@ declare module 'vm' {
         cachedDataProduced?: boolean | undefined;
         cachedDataRejected?: boolean | undefined;
         cachedData?: Buffer | undefined;
+        /**
+         * When the script is compiled from a source that contains a source map magic comment, this property will be set to the URL of the source map.
+         */
+        sourceMapURL?: string | undefined;
     }
     /**
      * If given a `contextObject`, the `vm.createContext()` method will `prepare
@@ -345,7 +379,7 @@ declare module 'vm' {
      * @param contextifiedObject The `contextified` object that will be used as the `global` when the `code` is compiled and run.
      * @return the result of the very last statement executed in the script.
      */
-    function runInContext(code: string, contextifiedObject: Context, options?: RunningScriptOptions | string): any;
+    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`,
@@ -374,7 +408,7 @@ declare module 'vm' {
      * @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
      * @return the result of the very last statement executed in the script.
      */
-    function runInNewContext(code: string, contextObject?: Context, options?: RunningScriptOptions | string): any;
+    function runInNewContext(code: string, contextObject?: Context, options?: RunningCodeInNewContextOptions | string): any;
     /**
      * `vm.runInThisContext()` compiles `code`, runs it within the context of the
      * current `global` and returns the result. Running code does not have access to
@@ -437,7 +471,7 @@ declare module 'vm' {
      * @param code The JavaScript code to compile and run.
      * @return the result of the very last statement executed in the script.
      */
-    function runInThisContext(code: string, options?: RunningScriptOptions | string): any;
+    function runInThisContext(code: string, options?: RunningCodeOptions | string): any;
     /**
      * Compiles the given code into the provided context (if no context is
      * supplied, the current context is used), and returns it wrapped inside a
@@ -446,7 +480,11 @@ declare module 'vm' {
      * @param code The body of the function to compile.
      * @param params An array of strings containing all parameters for the function.
      */
-    function compileFunction(code: string, params?: ReadonlyArray<string>, options?: CompileFunctionOptions): Function;
+    function compileFunction(code: string, params?: ReadonlyArray<string>, options?: CompileFunctionOptions): Function & {
+        cachedData?: Script['cachedData'] | undefined;
+        cachedDataProduced?: Script['cachedDataProduced'] | undefined;
+        cachedDataRejected?: Script['cachedDataRejected'] | undefined;
+    };
     /**
      * Measure the memory known to V8 and used by all contexts known to the
      * current V8 isolate, or the main context.
@@ -503,6 +541,103 @@ declare module 'vm' {
      * @experimental
      */
     function measureMemory(options?: MeasureMemoryOptions): Promise<MemoryMeasurement>;
+
+    interface ModuleEvaluateOptions {
+        timeout?: RunningScriptOptions['timeout'] | undefined;
+        breakOnSigint?: RunningScriptOptions['breakOnSigint'] | undefined;
+    }
+    type ModuleLinker = (specifier: string, referencingModule: Module, extra: { assert: Object }) => Module | Promise<Module>;
+    type ModuleStatus = 'unlinked' | 'linking' | 'linked' | 'evaluating' | 'evaluated' | 'errored';
+    class Module {
+        /**
+         * The specifiers of all dependencies of this module.
+         */
+        dependencySpecifiers: readonly string[];
+        /**
+         * If the `module.status` is `'errored'`, this property contains the exception thrown by the module during evaluation.
+         * If the status is anything else, accessing this property will result in a thrown exception.
+         */
+        error: any;
+        /**
+         * The identifier of the current module, as set in the constructor.
+         */
+        identifier: string;
+        context: Context;
+        /**
+         * The namespace object of the module. This is only available after linking (`module.link()`) has completed.
+         */
+        namespace: Object;
+        /**
+         * The current status of the module.
+         */
+        status: ModuleStatus;
+        /**
+         * Evaluate the module.
+         *
+         * This must be called after the module has been linked; otherwise it will reject
+         * It could be called also when the module has already been evaluated, in which case it will either do nothing
+         * if the initial evaluation ended in success (`module.status` is `'evaluated'`) or it will re-throw the exception
+         * that the initial evaluation resulted in (`module.status` is `'errored'`).
+         *
+         * This method cannot be called while the module is being evaluated (`module.status` is `'evaluating'`).
+         */
+        evaluate(options?: ModuleEvaluateOptions): Promise<void>;
+        /**
+         * Link module dependencies. This method must be called before evaluation, and can only be called once per module.
+         */
+        link(linker: ModuleLinker): Promise<void>;
+    }
+
+    interface SourceTextModuleOptions {
+        /**
+         * String used in stack traces.
+         * @default 'vm:module(i)' where i is a context-specific ascending index.
+         */
+        identifier?: string | undefined;
+        cachedData?: ScriptOptions['cachedData'] | undefined;
+        context?: Context | undefined;
+        lineOffset?: BaseOptions['lineOffset'] | undefined;
+        columnOffset?: BaseOptions['columnOffset'] | undefined;
+        /**
+         * Called during evaluation of this module to initialize the `import.meta`.
+         */
+        initializeImportMeta?: ((meta: ImportMeta, module: SourceTextModule) => void) | undefined;
+        importModuleDynamically?: ScriptOptions['importModuleDynamically'] | undefined;
+    }
+    class SourceTextModule extends Module {
+        /**
+         * Creates a new `SourceTextModule` instance.
+         * @param code JavaScript Module code to parse
+         */
+        constructor(code: string, options?: SourceTextModuleOptions);
+    }
+
+    interface SyntheticModuleOptions {
+        /**
+         * String used in stack traces.
+         * @default 'vm:module(i)' where i is a context-specific ascending index.
+         */
+        identifier?: string | undefined;
+        /**
+         * The contextified object as returned by the `vm.createContext()` method, to compile and evaluate this module in.
+         */
+        context?: Context | undefined;
+    }
+    class SyntheticModule extends Module {
+        /**
+         * Creates a new `SyntheticModule` instance.
+         * @param exportNames Array of names that will be exported from the module.
+         * @param evaluateCallback Called when the module is evaluated.
+         */
+        constructor(exportNames: string[], evaluateCallback: (this: SyntheticModule) => void, options?: SyntheticModuleOptions);
+        /**
+         * This method is used after the module is linked to set the values of exports.
+         * If it is called before the module is linked, an `ERR_VM_MODULE_STATUS` error will be thrown.
+         * @param name
+         * @param value
+         */
+        setExport(name: string, value: any): void;
+    }
 }
 declare module 'node:vm' {
     export * from 'vm';

package/node_modules/@types/cacheable-request/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Tue, 14 Mar 2023 06:02:37 GMT
+ * Last updated: Tue, 28 Mar 2023 21:33:10 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`, `structuredClone`
 

package/node_modules/@types/cacheable-request/node_modules/@types/node/crypto.d.ts

@@ -3129,12 +3129,13 @@ declare module 'crypto' {
          */
         disableEntropyCache?: boolean | undefined;
     }
+    type UUID = `${string}-${string}-${string}-${string}-${string}`;
     /**
      * Generates a random [RFC 4122](https://www.rfc-editor.org/rfc/rfc4122.txt) version 4 UUID. The UUID is generated using a
      * cryptographic pseudorandom number generator.
      * @since v15.6.0, v14.17.0
      */
-    function randomUUID(options?: RandomUUIDOptions): string;
+    function randomUUID(options?: RandomUUIDOptions): UUID;
     interface X509CheckOptions {
         /**
          * @default 'always'
@@ -3646,7 +3647,7 @@ declare module 'crypto' {
              * The UUID is generated using a cryptographic pseudorandom number generator.
              * @since v16.7.0
              */
-            randomUUID(): string;
+            randomUUID(): UUID;
             CryptoKey: CryptoKeyConstructor;
         }
         // This constructor throws ILLEGAL_CONSTRUCTOR so it should not be newable.

package/node_modules/@types/cacheable-request/node_modules/@types/node/diagnostics_channel.d.ts

@@ -58,6 +58,45 @@ declare module 'diagnostics_channel' {
      */
     function channel(name: string | symbol): Channel;
     type ChannelListener = (message: unknown, name: string | symbol) => void;
+    /**
+     * Register a message handler to subscribe to this channel. This message handler will be run synchronously
+     * whenever a message is published to the channel. Any errors thrown in the message handler will
+     * trigger an 'uncaughtException'.
+     *
+     * ```js
+     * import diagnostics_channel from 'diagnostics_channel';
+     *
+     * diagnostics_channel.subscribe('my-channel', (message, name) => {
+     *   // Received data
+     * });
+     * ```
+     *
+     * @since v18.7.0, v16.17.0
+     * @param name The channel name
+     * @param onMessage The handler to receive channel messages
+     */
+    function subscribe(name: string | symbol, onMessage: ChannelListener): void;
+    /**
+     * Remove a message handler previously registered to this channel with diagnostics_channel.subscribe(name, onMessage).
+     *
+     * ```js
+     * import diagnostics_channel from 'diagnostics_channel';
+     *
+     * function onMessage(message, name) {
+     *  // Received data
+     * }
+     *
+     * diagnostics_channel.subscribe('my-channel', onMessage);
+     *
+     * diagnostics_channel.unsubscribe('my-channel', onMessage);
+     * ```
+     *
+     * @since v18.7.0, v16.17.0
+     * @param name The channel name
+     * @param onMessage The previous subscribed handler to remove
+     * @returns `true` if the handler was found, `false` otherwise
+     */
+    function unsubscribe(name: string | symbol, onMessage: ChannelListener): boolean;
     /**
      * The class `Channel` represents an individual named channel within the data
      * pipeline. It is use to track subscribers and to publish messages when there

package/node_modules/@types/cacheable-request/node_modules/@types/node/dns.d.ts

@@ -174,7 +174,7 @@ declare module 'dns' {
         type: 'AAAA';
     }
     export interface CaaRecord {
-        critial: number;
+        critical: number;
         issue?: string | undefined;
         issuewild?: string | undefined;
         iodef?: string | undefined;

package/node_modules/@types/cacheable-request/node_modules/@types/node/globals.d.ts

@@ -62,6 +62,7 @@ interface AbortSignal extends EventTarget {
      * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
      */
     readonly aborted: boolean;
+    readonly reason: any;
 }
 
 declare var AbortController: typeof globalThis extends {onmessage: any; AbortController: infer T}

package/node_modules/@types/cacheable-request/node_modules/@types/node/http.d.ts

@@ -144,6 +144,7 @@ declare module 'http' {
         socketPath?: string | undefined;
         timeout?: number | undefined;
         uniqueHeaders?: Array<string | string[]> | undefined;
+        joinDuplicateHeaders?: boolean;
     }
     interface ServerOptions<
         Request extends typeof IncomingMessage = typeof IncomingMessage,
@@ -164,6 +165,12 @@ declare module 'http' {
          * @since v18.0.0
          */
         requestTimeout?: number | undefined;
+        /**
+         * It joins the field line values of multiple headers in a request with `, ` instead of discarding the duplicates.
+         * @default false
+         * @since v18.14.0
+         */
+        joinDuplicateHeaders?: boolean;
         /**
          * The number of milliseconds of inactivity a server needs to wait for additional incoming data,
          * after it has finished writing the last response, before a socket will be destroyed.

package/node_modules/@types/cacheable-request/node_modules/@types/node/http2.d.ts

@@ -1053,7 +1053,6 @@ declare module 'http2' {
          */
         unknownProtocolTimeout?: number | undefined;
         selectPadding?(frameLen: number, maxFrameLen: number): number;
-        createConnection?(authority: url.URL, option: SessionOptions): stream.Duplex;
     }
     export interface ClientSessionOptions extends SessionOptions {
         maxReservedRemoteStreams?: number | undefined;

package/node_modules/@types/cacheable-request/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "18.15.3",
+    "version": "18.15.11",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -232,6 +232,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "2b0bdc90cf6594c1dad97a20429a1c7b90e2dc449ce05846f01e2ecc1f0c0467",
-    "typeScriptVersion": "4.2"
+    "typesPublisherContentHash": "0b569b41848800d78adc39868da768013835b59322022dd1bb40be639e885045",
+    "typeScriptVersion": "4.3"
 }

package/node_modules/@types/cacheable-request/node_modules/@types/node/process.d.ts

@@ -1089,6 +1089,12 @@ declare module 'process' {
                  */
                 mainModule?: Module | undefined;
                 memoryUsage: MemoryUsageFn;
+                /**
+                 * Gets the amount of memory available to the process (in bytes) based on
+                 * limits imposed by the OS. If there is no such constraint, or the constraint
+                 * is unknown, `undefined` is returned.
+                 */
+                constrainedMemory(): number | undefined;
                 /**
                  * The `process.cpuUsage()` method returns the user and system CPU time usage of
                  * the current process, in an object with properties `user` and `system`, whose

package/node_modules/@types/cacheable-request/node_modules/@types/node/stream.d.ts

@@ -912,6 +912,105 @@ declare module 'stream' {
             end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this;
             cork(): void;
             uncork(): void;
+            /**
+             * Event emitter
+             * The defined events on documents including:
+             * 1.  close
+             * 2.  data
+             * 3.  drain
+             * 4.  end
+             * 5.  error
+             * 6.  finish
+             * 7.  pause
+             * 8.  pipe
+             * 9.  readable
+             * 10. resume
+             * 11. unpipe
+             */
+            addListener(event: 'close', listener: () => void): this;
+            addListener(event: 'data', listener: (chunk: any) => void): this;
+            addListener(event: 'drain', listener: () => void): this;
+            addListener(event: 'end', listener: () => void): this;
+            addListener(event: 'error', listener: (err: Error) => void): this;
+            addListener(event: 'finish', listener: () => void): this;
+            addListener(event: 'pause', listener: () => void): this;
+            addListener(event: 'pipe', listener: (src: Readable) => void): this;
+            addListener(event: 'readable', listener: () => void): this;
+            addListener(event: 'resume', listener: () => void): this;
+            addListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            emit(event: 'close'): boolean;
+            emit(event: 'data', chunk: any): boolean;
+            emit(event: 'drain'): boolean;
+            emit(event: 'end'): boolean;
+            emit(event: 'error', err: Error): boolean;
+            emit(event: 'finish'): boolean;
+            emit(event: 'pause'): boolean;
+            emit(event: 'pipe', src: Readable): boolean;
+            emit(event: 'readable'): boolean;
+            emit(event: 'resume'): boolean;
+            emit(event: 'unpipe', src: Readable): boolean;
+            emit(event: string | symbol, ...args: any[]): boolean;
+            on(event: 'close', listener: () => void): this;
+            on(event: 'data', listener: (chunk: any) => void): this;
+            on(event: 'drain', listener: () => void): this;
+            on(event: 'end', listener: () => void): this;
+            on(event: 'error', listener: (err: Error) => void): this;
+            on(event: 'finish', listener: () => void): this;
+            on(event: 'pause', listener: () => void): this;
+            on(event: 'pipe', listener: (src: Readable) => void): this;
+            on(event: 'readable', listener: () => void): this;
+            on(event: 'resume', listener: () => void): this;
+            on(event: 'unpipe', listener: (src: Readable) => void): this;
+            on(event: string | symbol, listener: (...args: any[]) => void): this;
+            once(event: 'close', listener: () => void): this;
+            once(event: 'data', listener: (chunk: any) => void): this;
+            once(event: 'drain', listener: () => void): this;
+            once(event: 'end', listener: () => void): this;
+            once(event: 'error', listener: (err: Error) => void): this;
+            once(event: 'finish', listener: () => void): this;
+            once(event: 'pause', listener: () => void): this;
+            once(event: 'pipe', listener: (src: Readable) => void): this;
+            once(event: 'readable', listener: () => void): this;
+            once(event: 'resume', listener: () => void): this;
+            once(event: 'unpipe', listener: (src: Readable) => void): this;
+            once(event: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener(event: 'close', listener: () => void): this;
+            prependListener(event: 'data', listener: (chunk: any) => void): this;
+            prependListener(event: 'drain', listener: () => void): this;
+            prependListener(event: 'end', listener: () => void): this;
+            prependListener(event: 'error', listener: (err: Error) => void): this;
+            prependListener(event: 'finish', listener: () => void): this;
+            prependListener(event: 'pause', listener: () => void): this;
+            prependListener(event: 'pipe', listener: (src: Readable) => void): this;
+            prependListener(event: 'readable', listener: () => void): this;
+            prependListener(event: 'resume', listener: () => void): this;
+            prependListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener(event: 'close', listener: () => void): this;
+            prependOnceListener(event: 'data', listener: (chunk: any) => void): this;
+            prependOnceListener(event: 'drain', listener: () => void): this;
+            prependOnceListener(event: 'end', listener: () => void): this;
+            prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+            prependOnceListener(event: 'finish', listener: () => void): this;
+            prependOnceListener(event: 'pause', listener: () => void): this;
+            prependOnceListener(event: 'pipe', listener: (src: Readable) => void): this;
+            prependOnceListener(event: 'readable', listener: () => void): this;
+            prependOnceListener(event: 'resume', listener: () => void): this;
+            prependOnceListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            removeListener(event: 'close', listener: () => void): this;
+            removeListener(event: 'data', listener: (chunk: any) => void): this;
+            removeListener(event: 'drain', listener: () => void): this;
+            removeListener(event: 'end', listener: () => void): this;
+            removeListener(event: 'error', listener: (err: Error) => void): this;
+            removeListener(event: 'finish', listener: () => void): this;
+            removeListener(event: 'pause', listener: () => void): this;
+            removeListener(event: 'pipe', listener: (src: Readable) => void): this;
+            removeListener(event: 'readable', listener: () => void): this;
+            removeListener(event: 'resume', listener: () => void): this;
+            removeListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
         }
         type TransformCallback = (error?: Error | null, data?: any) => void;
         interface TransformOptions extends DuplexOptions {