cloudstructs 0.5.3 → 0.5.6

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

@@ -24,7 +24,7 @@
  * made available to developers as a convenience. Fixes or other modifications to
  * the module must be directed to the [Punycode.js](https://github.com/bestiejs/punycode.js) project.
  * @deprecated Since v7.0.0 - Deprecated
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/punycode.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/punycode.js)
  */
 declare module 'punycode' {
     /**

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

@@ -9,7 +9,7 @@
  * The `querystring` API is considered Legacy. While it is still maintained,
  * new code should use the `URLSearchParams` API instead.
  * @deprecated Legacy
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/querystring.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/querystring.js)
  */
 declare module 'querystring' {
     interface StringifyOptions {

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

@@ -17,7 +17,7 @@
  *
  * ```js
  * import * as readline from 'node:readline/promises';
- * import { stdin as input, stdout as output } from 'process';
+ * import { stdin as input, stdout as output } from 'node:process';
  *
  * const rl = readline.createInterface({ input, output });
  *
@@ -30,7 +30,7 @@
  *
  * Once this code is invoked, the Node.js application will not terminate until the`readline.Interface` is closed because the interface waits for data to be
  * received on the `input` stream.
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/readline.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/readline.js)
  */
 declare module 'readline' {
     import { Abortable, EventEmitter } from 'node:events';

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

@@ -6,7 +6,7 @@
  * ```js
  * const repl = require('repl');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/repl.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/repl.js)
  */
 declare module 'repl' {
     import { Interface, Completer, AsyncCompleter } from 'node:readline';
@@ -277,7 +277,7 @@ declare module 'repl' {
          * Goodbye!
          * ```
          * @since v0.3.0
-         * @param keyword The command keyword (*without* a leading `.` character).
+         * @param keyword The command keyword (_without_ a leading `.` character).
          * @param cmd The function to invoke when the command is processed.
          */
         defineCommand(keyword: string, cmd: REPLCommandAction | REPLCommand): void;

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

@@ -14,12 +14,13 @@
  *
  * The `stream` module is useful for creating new types of stream instances. It is
  * usually not necessary to use the `stream` module to consume streams.
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/stream.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/stream.js)
  */
 declare module 'stream' {
     import { EventEmitter, Abortable } from 'node:events';
     import * as streamPromises from 'node:stream/promises';
     import * as streamConsumers from 'node:stream/consumers';
+    import * as streamWeb from 'node:stream/web';
     class internal extends EventEmitter {
         pipe<T extends NodeJS.WritableStream>(
             destination: T,
@@ -52,11 +53,23 @@ declare module 'stream' {
              * A utility method for creating Readable Streams out of iterators.
              */
             static from(iterable: Iterable<any> | AsyncIterable<any>, options?: ReadableOptions): Readable;
+            /**
+             * A utility method for creating a `Readable` from a web `ReadableStream`.
+             * @since v17.0.0
+             * @experimental
+             */
+            static fromWeb(readableStream: streamWeb.ReadableStream, options?: Pick<ReadableOptions, 'encoding' | 'highWaterMark' | 'objectMode' | 'signal'>): Readable;
             /**
              * Returns whether the stream has been read from or cancelled.
              * @since v16.8.0
              */
             static isDisturbed(stream: Readable | NodeJS.ReadableStream): boolean;
+            /**
+             * A utility method for creating a web `ReadableStream` from a `Readable`.
+             * @since v17.0.0
+             * @experimental
+             */
+            static toWeb(streamReadable: Readable): streamWeb.ReadableStream;
             /**
              * Returns whether the stream was destroyed or errored before emitting `'end'`.
              * @since v16.8.0
@@ -110,16 +123,26 @@ declare module 'stream' {
             readonly readableObjectMode: boolean;
             /**
              * Is `true` after `readable.destroy()` has been called.
-             * @since v8.0.0
+             * @since v18.0.0
              */
             destroyed: boolean;
+            /**
+             * Is true after 'close' has been emitted.
+             * @since v8.0.0
+             */
+            readonly closed: boolean;
+            /**
+             * Returns error if the stream has been destroyed with an error.
+             * @since v18.0.0
+             */
+            readonly errored: Error | null;
             constructor(opts?: ReadableOptions);
             _construct?(callback: (error?: Error | null) => void): void;
             _read(size: number): void;
             /**
-             * The `readable.read()` method pulls some data out of the internal buffer and
-             * returns it. If no data available to be read, `null` is returned. By default,
-             * the data will be returned as a `Buffer` object unless an encoding has been
+             * The `readable.read()` method reads data out of the internal buffer and
+             * returns it. If no data is available to be read, `null` is returned. By default,
+             * the data is returned as a `Buffer` object unless an encoding has been
              * specified using the `readable.setEncoding()` method or the stream is operating
              * in object mode.
              *
@@ -334,7 +357,7 @@ declare module 'stream' {
              *     let chunk;
              *     while (null !== (chunk = stream.read())) {
              *       const str = decoder.write(chunk);
-             *       if (str.match(/\n\n/)) {
+             *       if (str.includes('\n\n')) {
              *         // Found the header boundary.
              *         const split = str.split(/\n\n/);
              *         header += split.shift();
@@ -347,10 +370,10 @@ declare module 'stream' {
              *           stream.unshift(buf);
              *         // Now the body of the message can be read from the stream.
              *         callback(null, header, stream);
-             *       } else {
-             *         // Still reading the header.
-             *         header += str;
+             *         return;
              *       }
+             *       // Still reading the header.
+             *       header += str;
              *     }
              *   }
              * }
@@ -541,6 +564,21 @@ declare module 'stream' {
              * @since v8.0.0
              */
             destroyed: boolean;
+            /**
+             * Is true after 'close' has been emitted.
+             * @since v8.0.0
+             */
+            readonly closed: boolean;
+            /**
+             * Returns error if the stream has been destroyed with an error.
+             * @since v18.0.0
+             */
+            readonly errored: Error | null;
+            /**
+             * Is `true` if the stream's buffer has been full and stream will emit 'drain'.
+             * @since v15.2.0, v14.17.0
+             */
+            readonly writableNeedDrain: boolean;
             constructor(opts?: WritableOptions);
             _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
             _writev?(
@@ -567,7 +605,7 @@ declare module 'stream' {
              * While a stream is not draining, calls to `write()` will buffer `chunk`, and
              * return false. Once all currently buffered chunks are drained (accepted for
              * delivery by the operating system), the `'drain'` event will be emitted.
-             * It is recommended that once `write()` returns false, no more chunks be written
+             * Once `write()` returns false, do not write more chunks
              * until the `'drain'` event is emitted. While calling `write()` on a stream that
              * is not draining is allowed, Node.js will buffer all written chunks until
              * maximum memory usage occurs, at which point it will abort unconditionally.
@@ -661,8 +699,8 @@ declare module 'stream' {
              * The `writable.uncork()` method flushes all data buffered since {@link cork} was called.
              *
              * When using `writable.cork()` and `writable.uncork()` to manage the buffering
-             * of writes to a stream, it is recommended that calls to `writable.uncork()` be
-             * deferred using `process.nextTick()`. Doing so allows batching of all`writable.write()` calls that occur within a given Node.js event loop phase.
+             * of writes to a stream, defer calls to `writable.uncork()` using`process.nextTick()`. Doing so allows batching of all`writable.write()` calls that occur within a given Node.js event
+             * loop phase.
              *
              * ```js
              * stream.cork();
@@ -807,6 +845,9 @@ declare module 'stream' {
             readonly writableLength: number;
             readonly writableObjectMode: boolean;
             readonly writableCorked: number;
+            readonly writableNeedDrain: boolean;
+            readonly closed: boolean;
+            readonly errored: Error | null;
             /**
              * If `false` then the stream will automatically end the writable side when the
              * readable side ends. Set initially by the `allowHalfOpen` constructor option,
@@ -1106,7 +1147,7 @@ declare module 'stream' {
          * async function run() {
          *   await pipeline(
          *     fs.createReadStream('lowercase.txt'),
-         *     async function* (source, signal) {
+         *     async function* (source, { signal }) {
          *       source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.
          *       for await (const chunk of source) {
          *         yield await processChunk(chunk, { signal });
@@ -1130,7 +1171,7 @@ declare module 'stream' {
          *
          * async function run() {
          *   await pipeline(
-         *     async function * (signal) {
+         *     async function* ({ signal }) {
          *       await someLongRunningfn({ signal });
          *       yield 'asd';
          *     },
@@ -1149,7 +1190,31 @@ declare module 'stream' {
          *
          * `stream.pipeline()` leaves dangling event listeners on the streams
          * after the `callback` has been invoked. In the case of reuse of streams after
-         * failure, this can cause event listener leaks and swallowed errors.
+         * failure, this can cause event listener leaks and swallowed errors. If the last
+         * stream is readable, dangling event listeners will be removed so that the last
+         * stream can be consumed later.
+         *
+         * `stream.pipeline()` closes all the streams when an error is raised.
+         * The `IncomingRequest` usage with `pipeline` could lead to an unexpected behavior
+         * once it would destroy the socket without sending the expected response.
+         * See the example below:
+         *
+         * ```js
+         * const fs = require('fs');
+         * const http = require('http');
+         * const { pipeline } = require('stream');
+         *
+         * const server = http.createServer((req, res) => {
+         *   const fileStream = fs.createReadStream('./fileNotExist.txt');
+         *   pipeline(fileStream, res, (err) => {
+         *     if (err) {
+         *       console.log(err); // No such file
+         *       // this message can't be sent once `pipeline` already destroyed the socket
+         *       return res.end('error!!!');
+         *     }
+         *   });
+         * });
+         * ```
          * @since v10.0.0
          * @param callback Called when the pipeline is fully done.
          */

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

@@ -36,7 +36,7 @@
  * decoder.write(Buffer.from([0x82]));
  * console.log(decoder.end(Buffer.from([0xAC])));
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/string_decoder.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/string_decoder.js)
  */
 declare module 'string_decoder' {
     class StringDecoder {

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

@@ -0,0 +1,142 @@
+/**
+ * The `node:test` module provides a standalone testing module.
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/test.js)
+ */
+declare module 'node:test' {
+  /**
+   * The `test()` function is the value imported from the test module. Each invocation of this
+   * function results in the creation of a test point in the TAP output.
+   *
+   * The {@link TestContext} object passed to the fn argument can be used to perform actions
+   * related to the current test. Examples include skipping the test, adding additional TAP
+   * diagnostic information, or creating subtests.
+   *
+   * `test()` returns a {@link Promise} that resolves once the test completes. The return value
+   * can usually be discarded for top level tests. However, the return value from subtests should
+   * be used to prevent the parent test from finishing first and cancelling the subtest as shown
+   * in the following example.
+   *
+   * ```js
+   * test('top level test', async (t) => {
+   *   // The setTimeout() in the following subtest would cause it to outlive its
+   *   // parent test if 'await' is removed on the next line. Once the parent test
+   *   // completes, it will cancel any outstanding subtests.
+   *   await t.test('longer running subtest', async (t) => {
+   *     return new Promise((resolve, reject) => {
+   *       setTimeout(resolve, 1000);
+   *     });
+   *   });
+   * });
+   * ```
+   * @since v18.0.0
+   * @param name The name of the test, which is displayed when reporting test results.
+   *    Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
+   * @param options Configuration options for the test
+   * @param fn The function under test. This first argument to this function is a
+   *    {@link TestContext} object. If the test uses callbacks, the callback function is
+   *    passed as the second argument. Default: A no-op function.
+   * @returns A {@link Promise} resolved with `undefined` once the test completes.
+   */
+  function test(name?: string, fn?: TestFn): Promise<void>;
+  function test(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
+  function test(options?: TestOptions, fn?: TestFn): Promise<void>;
+  function test(fn?: TestFn): Promise<void>;
+
+  /**
+   * The type of a function under test. This first argument to this function is a
+   * {@link TestContext} object. If the test uses callbacks, the callback function is passed as
+   * the second argument.
+   */
+  type TestFn = ((t: TestContext, done: (result?: any) => void) => any);
+
+  /**
+   * An instance of `TestContext` is passed to each test function in order to interact with the
+   * test runner. However, the `TestContext` constructor is not exposed as part of the API.
+   * @since v18.0.0
+   */
+  interface TestContext {
+    /**
+     * This function is used to write TAP diagnostics to the output. Any diagnostic information is
+     * included at the end of the test's results. This function does not return a value.
+     * @param message Message to be displayed as a TAP diagnostic.
+     * @since v18.0.0
+     */
+    diagnostic(message: string): void;
+
+    /**
+     * If `shouldRunOnlyTests` is truthy, the test context will only run tests that have the `only`
+     * option set. Otherwise, all tests are run. If Node.js was not started with the `--test-only`
+     * command-line option, this function is a no-op.
+     * @param shouldRunOnlyTests Whether or not to run `only` tests.
+     * @since v18.0.0
+     */
+    runOnly(shouldRunOnlyTests: boolean): void;
+
+    /**
+     * This function causes the test's output to indicate the test as skipped. If `message` is
+     * provided, it is included in the TAP output. Calling `skip()` does not terminate execution of
+     * the test function. This function does not return a value.
+     * @param message Optional skip message to be displayed in TAP output.
+     * @since v18.0.0
+     */
+    skip(message?: string): void;
+
+    /**
+     * This function adds a `TODO` directive to the test's output. If `message` is provided, it is
+     * included in the TAP output. Calling `todo()` does not terminate execution of the test
+     * function. This function does not return a value.
+     * @param message Optional `TODO` message to be displayed in TAP output.
+     * @since v18.0.0
+     */
+    todo(message?: string): void;
+
+    /**
+     * This function is used to create subtests under the current test. This function behaves in
+     * the same fashion as the top level {@link test} function.
+     * @since v18.0.0
+     * @param name The name of the test, which is displayed when reporting test results.
+     *    Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
+     * @param options Configuration options for the test
+     * @param fn The function under test. This first argument to this function is a
+     *    {@link TestContext} object. If the test uses callbacks, the callback function is
+     *    passed as the second argument. Default: A no-op function.
+     * @returns A {@link Promise} resolved with `undefined` once the test completes.
+     */
+    test: typeof test;
+  }
+
+  interface TestOptions {
+    /**
+     * The number of tests that can be run at the same time. If unspecified, subtests inherit this
+     * value from their parent.
+     * @default 1
+     */
+    concurrency?: number;
+
+    /**
+     * If truthy, and the test context is configured to run `only` tests, then this test will be
+     * run. Otherwise, the test is skipped.
+     * @default false
+     */
+    only?: boolean;
+
+    /**
+     * If truthy, the test is skipped. If a string is provided, that string is displayed in the
+     * test results as the reason for skipping the test.
+     * @default false
+     */
+    skip?: boolean | string;
+
+    /**
+     * If truthy, the test marked as `TODO`. If a string is provided, that string is displayed in
+     * the test results as the reason why the test is `TODO`.
+     * @default false
+     */
+    todo?: boolean | string;
+  }
+
+  export {
+    test as default,
+    test,
+  };
+}

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

@@ -6,7 +6,7 @@
  * The timer functions within Node.js implement a similar API as the timers API
  * provided by Web Browsers but use a different internal implementation that is
  * built around the Node.js [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout).
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/timers.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/timers.js)
  */
 declare module 'timers' {
     import { Abortable } from 'node:events';
@@ -69,7 +69,7 @@ declare module 'timers' {
         namespace setTimeout {
             const __promisify__: typeof setTimeoutPromise;
         }
-        function clearTimeout(timeoutId: NodeJS.Timeout | undefined): void;
+        function clearTimeout(timeoutId: NodeJS.Timeout | string | number | undefined): void;
         function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timer;
         // util.promisify no rest args compability
         // tslint:disable-next-line void-return
@@ -77,7 +77,7 @@ declare module 'timers' {
         namespace setInterval {
             const __promisify__: typeof setIntervalPromise;
         }
-        function clearInterval(intervalId: NodeJS.Timeout | undefined): void;
+        function clearInterval(intervalId: NodeJS.Timeout | string | number | undefined): void;
         function setImmediate<TArgs extends any[]>(callback: (...args: TArgs) => void, ...args: TArgs): NodeJS.Immediate;
         // util.promisify no rest args compability
         // tslint:disable-next-line void-return

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

@@ -6,7 +6,7 @@
  * ```js
  * const tls = require('tls');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/tls.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/tls.js)
  */
 declare module 'tls' {
     import { X509Certificate } from 'node:crypto';
@@ -143,8 +143,8 @@ declare module 'tls' {
          */
         constructor(socket: net.Socket, options?: TLSSocketOptions);
         /**
-         * Returns `true` if the peer certificate was signed by one of the CAs specified
-         * when creating the `tls.TLSSocket` instance, otherwise `false`.
+         * This property is `true` if the peer certificate was signed by one of the CAs
+         * specified when creating the `tls.TLSSocket` instance, otherwise `false`.
          * @since v0.11.4
          */
         authorized: boolean;
@@ -158,7 +158,7 @@ declare module 'tls' {
          * Always returns `true`. This may be used to distinguish TLS sockets from regular`net.Socket` instances.
          * @since v0.11.4
          */
-        encrypted: boolean;
+        encrypted: true;
         /**
          * String containing the selected ALPN protocol.
          * Before a handshake has completed, this value is always null.
@@ -343,9 +343,9 @@ declare module 'tls' {
          * When enabled, TLS packet trace information is written to `stderr`. This can be
          * used to debug TLS connection problems.
          *
-         * Note: The format of the output is identical to the output of `openssl s_client -trace` or `openssl s_server -trace`. While it is produced by OpenSSL's`SSL_trace()` function, the format is
-         * undocumented, can change without notice,
-         * and should not be relied on.
+         * The format of the output is identical to the output of`openssl s_client -trace` or `openssl s_server -trace`. While it is produced by
+         * OpenSSL's `SSL_trace()` function, the format is undocumented, can change
+         * without notice, and should not be relied on.
          * @since v12.2.0
          */
         enableTrace(): void;
@@ -374,7 +374,7 @@ declare module 'tls' {
          *   128,
          *   'client finished');
          *
-         *
+         * /*
          *  Example return value of keyingMaterial:
          *  <Buffer 76 26 af 99 c5 56 8e 42 09 91 ef 9f 93 cb ad 6c 7b 65 f8 53 f1 d8 d9
          *     12 5a 33 b8 b5 25 df 7b 37 9f e0 e2 4f b8 67 83 a3 2f cd 5d 41 42 4c 91
@@ -814,13 +814,19 @@ declare module 'tls' {
      * Returns [Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) object, populating it with `reason`, `host`, and `cert` on
      * failure. On success, returns [undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type).
      *
-     * This function can be overwritten by providing alternative function as part of
-     * the `options.checkServerIdentity` option passed to `tls.connect()`. The
+     * This function is intended to be used in combination with the`checkServerIdentity` option that can be passed to {@link connect} and as
+     * such operates on a `certificate object`. For other purposes, consider using `x509.checkHost()` instead.
+     *
+     * This function can be overwritten by providing an alternative function as the`options.checkServerIdentity` option that is passed to `tls.connect()`. The
      * overwriting function can call `tls.checkServerIdentity()` of course, to augment
      * the checks done with additional verification.
      *
      * This function is only called if the certificate passed all other checks, such as
      * being issued by trusted CA (`options.ca`).
+     *
+     * Earlier versions of Node.js incorrectly accepted certificates for a given`hostname` if a matching `uniformResourceIdentifier` subject alternative name
+     * was present (see [CVE-2021-44531](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44531)). Applications that wish to accept`uniformResourceIdentifier` subject alternative names can use
+     * a custom`options.checkServerIdentity` function that implements the desired behavior.
      * @since v0.8.4
      * @param hostname The host name or IP address to verify the certificate against.
      * @param cert A `certificate object` representing the peer's certificate.
@@ -973,6 +979,8 @@ declare module 'tls' {
      * lower-case for historical reasons, but must be uppercased to be used in
      * the `ciphers` option of {@link createSecureContext}.
      *
+     * Not all supported ciphers are enabled by default. See `Modifying the default TLS cipher suite`.
+     *
      * Cipher names that start with `'tls_'` are for TLSv1.3, all the others are for
      * TLSv1.2 and below.
      *

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

@@ -66,6 +66,16 @@
  * node --trace-event-categories v8 --trace-event-file-pattern '${pid}-${rotation}.log' server.js
  * ```
  *
+ * To guarantee that the log file is properly generated after signal events like`SIGINT`, `SIGTERM`, or `SIGBREAK`, make sure to have the appropriate handlers
+ * in your code, such as:
+ *
+ * ```js
+ * process.on('SIGINT', function onSigint() {
+ *   console.info('Received SIGINT.');
+ *   process.exit(130);  // Or applicable exit code depending on OS and signal
+ * });
+ * ```
+ *
  * The tracing system uses the same time source
  * as the one used by `process.hrtime()`.
  * However the trace-event timestamps are expressed in microseconds,
@@ -73,7 +83,7 @@
  *
  * The features from this module are not available in `Worker` threads.
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/trace_events.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/trace_events.js)
  */
 declare module 'trace_events' {
     /**

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

@@ -22,7 +22,7 @@
  *
  * In most cases, there should be little to no reason for an application to
  * manually create instances of the `tty.ReadStream` and `tty.WriteStream`classes.
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/tty.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/tty.js)
  */
 declare module 'tty' {
     import * as net from 'node:net';
@@ -52,7 +52,9 @@ declare module 'tty' {
          *
          * When in raw mode, input is always available character-by-character, not
          * including modifiers. Additionally, all special processing of characters by the
-         * terminal is disabled, including echoing input characters.Ctrl+C will no longer cause a `SIGINT` when in this mode.
+         * terminal is disabled, including echoing input
+         * characters. Ctrl+C will no longer cause a `SIGINT` when
+         * in this mode.
          * @since v0.7.7
          * @param mode If `true`, configures the `tty.ReadStream` to operate as a raw device. If `false`, configures the `tty.ReadStream` to operate in its default mode. The `readStream.isRaw`
          * property will be set to the resulting mode.