cloudstructs 0.6.0 → 0.6.3

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

@@ -33,6 +33,7 @@ declare module 'fs/promises' {
         WatchEventType,
         CopyOptions,
         ReadStream,
+        TimeLike,
         WriteStream,
     } from 'node:fs';
     interface FileChangeInfo<T extends string | Buffer> {
@@ -329,7 +330,7 @@ declare module 'fs/promises' {
          * Change the file system timestamps of the object referenced by the `FileHandle` then resolves the promise with no arguments upon success.
          * @since v10.0.0
          */
-        utimes(atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+        utimes(atime: TimeLike, mtime: TimeLike): Promise<void>;
         /**
          * Asynchronously writes data to a file, replacing the file if it already exists.`data` can be a string, a buffer, an
          * [AsyncIterable](https://tc39.github.io/ecma262/#sec-asynciterable-interface) or
@@ -762,7 +763,7 @@ declare module 'fs/promises' {
      * @since v14.5.0, v12.19.0
      * @return Fulfills with `undefined` upon success.
      */
-    function lutimes(path: PathLike, atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+    function lutimes(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
     /**
      * Changes the ownership of a file.
      * @since v10.0.0
@@ -780,7 +781,7 @@ declare module 'fs/promises' {
      * @since v10.0.0
      * @return Fulfills with `undefined` upon success.
      */
-    function utimes(path: PathLike, atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+    function utimes(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
     /**
      * Determines the actual location of `path` using the same semantics as the`fs.realpath.native()` function.
      *

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

@@ -1395,7 +1395,7 @@ declare module 'fs' {
          * Use `fs.rm(path, { recursive: true, force: true })` instead.
          *
          * If `true`, perform a recursive directory removal. In
-         * recursive mode soperations are retried on failure.
+         * recursive mode, operations are retried on failure.
          * @default false
          */
         recursive?: boolean | undefined;
@@ -3791,7 +3791,7 @@ declare module 'fs' {
     export interface StatSyncOptions extends StatOptions {
         throwIfNoEntry?: boolean | undefined;
     }
-    export interface CopyOptions {
+    interface CopyOptionsBase {
         /**
          * Dereference symlinks
          * @default false
@@ -3803,11 +3803,6 @@ declare module 'fs' {
          * @default false
          */
         errorOnExist?: boolean;
-        /**
-         * Function to filter copied files/directories. Return
-         * `true` to copy the item, `false` to ignore it.
-         */
-        filter?(source: string, destination: string): boolean;
         /**
          * Overwrite existing file or directory. _The copy
          * operation will ignore errors if you set this to false and the destination
@@ -3826,6 +3821,25 @@ declare module 'fs' {
          * @default false
          */
         recursive?: boolean;
+        /**
+         * When true, path resolution for symlinks will be skipped
+         * @default false
+         */
+        verbatimSymlinks?: boolean;
+    }
+    export interface CopyOptions extends CopyOptionsBase {
+        /**
+         * Function to filter copied files/directories. Return
+         * `true` to copy the item, `false` to ignore it.
+         */
+        filter?(source: string, destination: string): boolean | Promise<boolean>;
+    }
+    export interface CopySyncOptions extends CopyOptionsBase {
+        /**
+         * Function to filter copied files/directories. Return
+         * `true` to copy the item, `false` to ignore it.
+         */
+        filter?(source: string, destination: string): boolean;
     }
     /**
      * Asynchronously copies the entire directory structure from `src` to `dest`,
@@ -3851,7 +3865,7 @@ declare module 'fs' {
      * @param src source path to copy.
      * @param dest destination path to copy to.
      */
-    export function cpSync(source: string | URL, destination: string | URL, opts?: CopyOptions): void;
+    export function cpSync(source: string | URL, destination: string | URL, opts?: CopySyncOptions): void;
 }
 declare module 'node:fs' {
     export * from 'fs';

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

@@ -1642,7 +1642,7 @@ declare module 'http2' {
          * be called multiple times to provide successive parts of the body.
          *
          * In the `http` module, the response body is omitted when the
-         * request is a HEAD request. Similarly, the `204` and `304` responses_must not_ include a message body.
+         * request is a HEAD request. Similarly, the `204` and `304` responses _must not_ include a message body.
          *
          * `chunk` can be a string or a buffer. If `chunk` is a string,
          * the second parameter specifies how to encode it into a byte stream.

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

@@ -1,4 +1,4 @@
-// Type definitions for non-npm package Node.js 18.6
+// Type definitions for non-npm package Node.js 18.7
 // Project: https://nodejs.org/
 // Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
 //                 DefinitelyTyped <https://github.com/DefinitelyTyped>
@@ -108,6 +108,7 @@
 /// <reference path="punycode.d.ts" />
 /// <reference path="querystring.d.ts" />
 /// <reference path="readline.d.ts" />
+/// <reference path="readline/promises.d.ts" />
 /// <reference path="repl.d.ts" />
 /// <reference path="stream.d.ts" />
 /// <reference path="stream/promises.d.ts" />

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

@@ -205,7 +205,7 @@ declare module 'net' {
          */
         unref(): this;
         /**
-         * Opposite of `unref()`, calling `ref()` on a previously `unref`ed socket will_not_ let the program exit if it's the only socket left (the default behavior).
+         * Opposite of `unref()`, calling `ref()` on a previously `unref`ed socket will _not_ let the program exit if it's the only socket left (the default behavior).
          * If the socket is `ref`ed calling `ref` again will have no effect.
          * @since v0.9.1
          * @return The socket itself.
@@ -504,7 +504,7 @@ declare module 'net' {
          */
         getConnections(cb: (error: Error | null, count: number) => void): void;
         /**
-         * Opposite of `unref()`, calling `ref()` on a previously `unref`ed server will_not_ let the program exit if it's the only server left (the default behavior).
+         * Opposite of `unref()`, calling `ref()` on a previously `unref`ed server will _not_ let the program exit if it's the only server left (the default behavior).
          * If the server is `ref`ed calling `ref()` again will have no effect.
          * @since v0.9.1
          */

package/node_modules/@slack/web-api/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "18.6.1",
+    "version": "18.7.3",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -220,6 +220,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "44e628c188a3b958cbf3478d419ce6106d591da55cf4b80f1d8dffa1caae8bf2",
+    "typesPublisherContentHash": "8dea3d15b6bef937e990a6b11572d052d6b749766317804596d909c7e26211e5",
     "typeScriptVersion": "4.0"
 }

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

@@ -69,18 +69,19 @@ declare module 'path' {
              * Normalize a string path, reducing '..' and '.' parts.
              * When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used.
              *
-             * @param p string path to normalize.
+             * @param path string path to normalize.
+             * @throws {TypeError} if `path` is not a string.
              */
-            normalize(p: string): string;
+            normalize(path: string): string;
             /**
              * Join all arguments together and normalize the resulting path.
-             * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown.
              *
              * @param paths paths to join.
+             * @throws {TypeError} if any of the path segments is not a string.
              */
             join(...paths: string[]): string;
             /**
-             * The right-most parameter is considered {to}.  Other parameters are considered an array of {from}.
+             * The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
              *
              * Starting from leftmost {from} parameter, resolves {to} to an absolute path.
              *
@@ -89,41 +90,50 @@ declare module 'path' {
              * the current working directory is used as well. The resulting path is normalized,
              * and trailing slashes are removed unless the path gets resolved to the root directory.
              *
-             * @param pathSegments string paths to join.  Non-string arguments are ignored.
+             * @param paths A sequence of paths or path segments.
+             * @throws {TypeError} if any of the arguments is not a string.
              */
-            resolve(...pathSegments: string[]): string;
+            resolve(...paths: string[]): string;
             /**
              * Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory.
              *
+             * If the given {path} is a zero-length string, `false` will be returned.
+             *
              * @param path path to test.
+             * @throws {TypeError} if `path` is not a string.
              */
-            isAbsolute(p: string): boolean;
+            isAbsolute(path: string): boolean;
             /**
-             * Solve the relative path from {from} to {to}.
+             * Solve the relative path from {from} to {to} based on the current working directory.
              * At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.
+             *
+             * @throws {TypeError} if either `from` or `to` is not a string.
              */
             relative(from: string, to: string): string;
             /**
              * Return the directory name of a path. Similar to the Unix dirname command.
              *
-             * @param p the path to evaluate.
+             * @param path the path to evaluate.
+             * @throws {TypeError} if `path` is not a string.
              */
-            dirname(p: string): string;
+            dirname(path: string): string;
             /**
              * Return the last portion of a path. Similar to the Unix basename command.
              * Often used to extract the file name from a fully qualified path.
              *
-             * @param p the path to evaluate.
+             * @param path the path to evaluate.
              * @param ext optionally, an extension to remove from the result.
+             * @throws {TypeError} if `path` is not a string or if `ext` is given and is not a string.
              */
-            basename(p: string, ext?: string): string;
+            basename(path: string, ext?: string): string;
             /**
              * Return the extension of the path, from the last '.' to end of string in the last portion of the path.
-             * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string
+             * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string.
              *
-             * @param p the path to evaluate.
+             * @param path the path to evaluate.
+             * @throws {TypeError} if `path` is not a string.
              */
-            extname(p: string): string;
+            extname(path: string): string;
             /**
              * The platform-specific file separator. '\\' or '/'.
              */
@@ -135,15 +145,16 @@ declare module 'path' {
             /**
              * Returns an object from a path string - the opposite of format().
              *
-             * @param pathString path to evaluate.
+             * @param path path to evaluate.
+             * @throws {TypeError} if `path` is not a string.
              */
-            parse(p: string): ParsedPath;
+            parse(path: string): ParsedPath;
             /**
              * Returns a path string from an object - the opposite of parse().
              *
-             * @param pathString path to evaluate.
+             * @param pathObject path to evaluate.
              */
-            format(pP: FormatInputPathObject): string;
+            format(pathObject: FormatInputPathObject): string;
             /**
              * On Windows systems only, returns an equivalent namespace-prefixed path for the given path.
              * If path is not a string, path will be returned without modifications.

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

@@ -191,6 +191,35 @@ declare module 'perf_hooks' {
          * @param name
          */
         clearMarks(name?: string): void;
+        /**
+         * If name is not provided, removes all PerformanceMeasure objects from the Performance Timeline.
+         * If name is provided, removes only the named measure.
+         * @param name
+         * @since v16.7.0
+         */
+        clearMeasures(name?: string): void;
+        /**
+         * Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`.
+         * If you are only interested in performance entries of certain types or that have certain names, see
+         * `performance.getEntriesByType()` and `performance.getEntriesByName()`.
+         * @since v16.7.0
+         */
+        getEntries(): PerformanceEntry[];
+        /**
+         * Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`
+         * whose `performanceEntry.name` is equal to `name`, and optionally, whose `performanceEntry.entryType` is equal to `type`.
+         * @param name
+         * @param type
+         * @since v16.7.0
+         */
+        getEntriesByName(name: string, type?: EntryType): PerformanceEntry[];
+        /**
+         * Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`
+         * whose `performanceEntry.entryType` is equal to `type`.
+         * @param type
+         * @since v16.7.0
+         */
+        getEntriesByType(type: EntryType): PerformanceEntry[];
         /**
          * Creates a new PerformanceMark entry in the Performance Timeline.
          * A PerformanceMark is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'mark',

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

@@ -590,7 +590,7 @@ declare module 'process' {
                  *
                  * The reason this is problematic is because writes to `process.stdout` in Node.js
                  * are sometimes _asynchronous_ and may occur over multiple ticks of the Node.js
-                 * event loop. Calling `process.exit()`, however, forces the process to exit_before_ those additional writes to `stdout` can be performed.
+                 * event loop. Calling `process.exit()`, however, forces the process to exit _before_ those additional writes to `stdout` can be performed.
                  *
                  * Rather than calling `process.exit()` directly, the code _should_ set the`process.exitCode` and allow the process to exit naturally by avoiding
                  * scheduling any additional work for the event loop:

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

@@ -0,0 +1,143 @@
+/**
+ * The `readline/promise` module provides an API for reading lines of input from a Readable stream one line at a time.
+ *
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/readline/promises.js)
+ * @since v17.0.0
+ */
+declare module 'readline/promises' {
+    import { Interface as _Interface, ReadLineOptions, Completer, AsyncCompleter, Direction } from 'node:readline';
+    import { Abortable } from 'node:events';
+
+    class Interface extends _Interface {
+        /**
+         * The rl.question() method displays the query by writing it to the output, waits for user input to be provided on input,
+         * then invokes the callback function passing the provided input as the first argument.
+         *
+         * When called, rl.question() will resume the input stream if it has been paused.
+         *
+         * If the readlinePromises.Interface was created with output set to null or undefined the query is not written.
+         *
+         * If the question is called after rl.close(), it returns a rejected promise.
+         *
+         * Example usage:
+         *
+         * ```js
+         * const answer = await rl.question('What is your favorite food? ');
+         * console.log(`Oh, so your favorite food is ${answer}`);
+         * ```
+         *
+         * Using an AbortSignal to cancel a question.
+         *
+         * ```js
+         * const signal = AbortSignal.timeout(10_000);
+         *
+         * signal.addEventListener('abort', () => {
+         *   console.log('The food question timed out');
+         * }, { once: true });
+         *
+         * const answer = await rl.question('What is your favorite food? ', { signal });
+         * console.log(`Oh, so your favorite food is ${answer}`);
+         * ```
+         *
+         * @since v17.0.0
+         * @param query A statement or query to write to output, prepended to the prompt.
+         */
+        question(query: string): Promise<string>;
+        question(query: string, options: Abortable): Promise<string>;
+    }
+
+    class Readline {
+        /**
+         * @param stream A TTY stream.
+         */
+        constructor(stream: NodeJS.WritableStream, options?: { autoCommit?: boolean });
+        /**
+         * The `rl.clearLine()` method adds to the internal list of pending action an action that clears current line of the associated `stream` in a specified direction identified by `dir`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         */
+        clearLine(dir: Direction): this;
+        /**
+         * The `rl.clearScreenDown()` method adds to the internal list of pending action an action that clears the associated `stream` from the current position of the cursor down.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         */
+        clearScreenDown(): this;
+        /**
+         * The `rl.commit()` method sends all the pending actions to the associated `stream` and clears the internal list of pending actions.
+         */
+        commit(): Promise<void>;
+        /**
+         * The `rl.cursorTo()` method adds to the internal list of pending action an action that moves cursor to the specified position in the associated `stream`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         */
+        cursorTo(x: number, y?: number): this;
+        /**
+         * The `rl.moveCursor()` method adds to the internal list of pending action an action that moves the cursor relative to its current position in the associated `stream`.
+         * Call `rl.commit()` to see the effect of this method, unless autoCommit: true was passed to the constructor.
+         */
+        moveCursor(dx: number, dy: number): this;
+        /**
+         * The `rl.rollback()` method clears the internal list of pending actions without sending it to the associated `stream`.
+         */
+        rollback(): this;
+    }
+
+    /**
+     * The `readlinePromises.createInterface()` method creates a new `readlinePromises.Interface` instance.
+     *
+     * ```js
+     * const readlinePromises = require('node:readline/promises');
+     * const rl = readlinePromises.createInterface({
+     *   input: process.stdin,
+     *   output: process.stdout
+     * });
+     * ```
+     *
+     * Once the `readlinePromises.Interface` instance is created, the most common case is to listen for the `'line'` event:
+     *
+     * ```js
+     * rl.on('line', (line) => {
+     *   console.log(`Received: ${line}`);
+     * });
+     * ```
+     *
+     * If `terminal` is `true` for this instance then the `output` stream will get the best compatibility if it defines an `output.columns` property,
+     * and emits a `'resize'` event on the `output`, if or when the columns ever change (`process.stdout` does this automatically when it is a TTY).
+     *
+     * ## Use of the `completer` function
+     *
+     * The `completer` function takes the current line entered by the user as an argument, and returns an `Array` with 2 entries:
+     *
+     * - An Array with matching entries for the completion.
+     * - The substring that was used for the matching.
+     *
+     * For instance: `[[substr1, substr2, ...], originalsubstring]`.
+     *
+     * ```js
+     * function completer(line) {
+     *   const completions = '.help .error .exit .quit .q'.split(' ');
+     *   const hits = completions.filter((c) => c.startsWith(line));
+     *   // Show all completions if none found
+     *   return [hits.length ? hits : completions, line];
+     * }
+     * ```
+     *
+     * The `completer` function can also returns a `Promise`, or be asynchronous:
+     *
+     * ```js
+     * async function completer(linePartial) {
+     *   await someAsyncWork();
+     *   return [['123'], linePartial];
+     * }
+     * ```
+     */
+    function createInterface(
+        input: NodeJS.ReadableStream,
+        output?: NodeJS.WritableStream,
+        completer?: Completer | AsyncCompleter,
+        terminal?: boolean,
+    ): Interface;
+    function createInterface(options: ReadLineOptions): Interface;
+}
+declare module 'node:readline/promises' {
+    export * from 'readline/promises';
+}

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

@@ -34,7 +34,10 @@
  */
 declare module 'readline' {
     import { Abortable, EventEmitter } from 'node:events';
-    interface Key {
+    import * as promises from 'node:readline/promises';
+
+    export { promises };
+    export interface Key {
         sequence?: string | undefined;
         name?: string | undefined;
         ctrl?: boolean | undefined;
@@ -48,7 +51,7 @@ declare module 'readline' {
      * and is read from, the `input` stream.
      * @since v0.1.104
      */
-    class Interface extends EventEmitter {
+    export class Interface extends EventEmitter {
         readonly terminal: boolean;
         /**
          * The current input data being processed by node.
@@ -315,11 +318,11 @@ declare module 'readline' {
         prependOnceListener(event: 'history', listener: (history: string[]) => void): this;
         [Symbol.asyncIterator](): AsyncIterableIterator<string>;
     }
-    type ReadLine = Interface; // type forwarded for backwards compatibility
-    type Completer = (line: string) => CompleterResult;
-    type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => void;
-    type CompleterResult = [string[], string];
-    interface ReadLineOptions {
+    export type ReadLine = Interface; // type forwarded for backwards compatibility
+    export type Completer = (line: string) => CompleterResult;
+    export type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => void;
+    export type CompleterResult = [string[], string];
+    export interface ReadLineOptions {
         input: NodeJS.ReadableStream;
         output?: NodeJS.WritableStream | undefined;
         completer?: Completer | AsyncCompleter | undefined;
@@ -380,8 +383,8 @@ declare module 'readline' {
      * ```
      * @since v0.1.98
      */
-    function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
-    function createInterface(options: ReadLineOptions): Interface;
+    export function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
+    export function createInterface(options: ReadLineOptions): Interface;
     /**
      * The `readline.emitKeypressEvents()` method causes the given `Readable` stream to begin emitting `'keypress'` events corresponding to received input.
      *
@@ -503,9 +506,9 @@ declare module 'readline' {
      * ```
      * @since v0.7.7
      */
-    function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
-    type Direction = -1 | 0 | 1;
-    interface CursorPos {
+    export function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
+    export type Direction = -1 | 0 | 1;
+    export interface CursorPos {
         rows: number;
         cols: number;
     }
@@ -516,7 +519,7 @@ declare module 'readline' {
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
+    export function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
     /**
      * The `readline.clearScreenDown()` method clears the given `TTY` stream from
      * the current position of the cursor down.
@@ -524,7 +527,7 @@ declare module 'readline' {
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
+    export function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
     /**
      * The `readline.cursorTo()` method moves cursor to the specified position in a
      * given `TTY` `stream`.
@@ -532,7 +535,7 @@ declare module 'readline' {
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
+    export function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
     /**
      * The `readline.moveCursor()` method moves the cursor _relative_ to its current
      * position in a given `TTY` `stream`.
@@ -643,7 +646,7 @@ declare module 'readline' {
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
+    export function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
 }
 declare module 'node:readline' {
     export * from 'readline';