@tothalex/cloud 0.0.40

package/src/stream.d.ts

@@ -0,0 +1,366 @@
+declare module "stream" {
+  import { EventEmitter } from "events";
+  import { Buffer } from "buffer";
+
+  class ReadableStreamInner
+    extends EventEmitter
+    implements QuickJS.ReadableStream
+  {
+    /**
+     * 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.
+     *
+     * The optional `size` argument specifies a specific number of bytes to read. If
+     * `size` bytes are not available to be read, `null` will be returned _unless_ the
+     * stream has ended, in which case all of the data remaining in the internal buffer
+     * will be returned.
+     *
+     * If the `size` argument is not specified, all of the data contained in the
+     * internal buffer will be returned.
+     *
+     * The `size` argument must be less than or equal to 1 GiB.
+     *
+     * The `readable.read()` method should only be called on `Readable` streams
+     * operating in paused mode. In flowing mode, `readable.read()` is called
+     * automatically until the internal buffer is fully drained.
+     *
+     * ```js
+     * const readable = getReadableStreamSomehow();
+     *
+     * // 'readable' may be triggered multiple times as data is buffered in
+     * readable.on('readable', () => {
+     *   let chunk;
+     *   console.log('Stream is readable (new data received in buffer)');
+     *   // Use a loop to make sure we read all currently available data
+     *   while (null !== (chunk = readable.read())) {
+     *     console.log(`Read ${chunk.length} bytes of data...`);
+     *   }
+     * });
+     *
+     * // 'end' will be triggered once when there is no more data available
+     * readable.on('end', () => {
+     *   console.log('Reached end of stream.');
+     * });
+     * ```
+     *
+     * Each call to `readable.read()` returns a chunk of data, or `null`. The chunks
+     * are not concatenated. A `while` loop is necessary to consume all data
+     * currently in the buffer. When reading a large file `.read()` may return `null`,
+     * having consumed all buffered content so far, but there is still more data to
+     * come not yet buffered. In this case a new `'readable'` event will be emitted
+     * when there is more data in the buffer. Finally the `'end'` event will be
+     * emitted when there is no more data to come.
+     *
+     * Therefore to read a file's whole contents from a `readable`, it is necessary
+     * to collect chunks across multiple `'readable'` events:
+     *
+     * ```js
+     * const chunks = [];
+     *
+     * readable.on('readable', () => {
+     *   let chunk;
+     *   while (null !== (chunk = readable.read())) {
+     *     chunks.push(chunk);
+     *   }
+     * });
+     *
+     * readable.on('end', () => {
+     *   const content = chunks.join('');
+     * });
+     * ```
+     *
+     * A `Readable` stream in object mode will always return a single item from
+     * a call to `readable.read(size)`, regardless of the value of the `size` argument.
+     *
+     * If the `readable.read()` method returns a chunk of data, a `'data'` event will
+     * also be emitted.
+     *
+     * Calling {@link read} after the `'end'` event has
+     * been emitted will return `null`. No runtime error will be raised.
+     * @param size Optional argument to specify how much data to read.
+     */
+    read(size?: number): Buffer | null;
+
+    /**
+     * Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'` event. After this call, the readable
+     * stream will release any internal resources and subsequent calls to `push()` will be ignored.
+     *
+     * Once `destroy()` has been called any further calls will be a no-op and no
+     * further errors except from `_destroy()` may be emitted as `'error'`.
+     *
+     * Implementors should not override this method, but instead implement `readable._destroy()`.
+     * @param error Error which will be passed as payload in `'error'` event
+     */
+    destroy(error?: Error): this;
+
+    /**
+     * Event emitter
+     * The defined events on documents including:
+     * 1. close
+     * 2. data
+     * 3. end
+     * 4. error
+     * 5. readable
+     */
+    addListener(event: EventKey, listener: (...args: any[]) => void): this;
+    addListener(event: "close", listener: () => void): this;
+    addListener(event: "data", listener: (chunk: Buffer) => void): this;
+    addListener(event: "end", listener: () => void): this;
+    addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "readable", listener: () => void): this;
+    emit(event: EventKey, ...args: any[]): boolean;
+    emit(event: "close"): boolean;
+    emit(event: "data", chunk: Buffer): boolean;
+    emit(event: "end"): boolean;
+    emit(event: "error", err: Error): boolean;
+    emit(event: "readable"): boolean;
+    on(event: EventKey, listener: (...args: any[]) => void): this;
+    on(event: "close", listener: () => void): this;
+    on(event: "data", listener: (chunk: Buffer) => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: "readable", listener: () => void): this;
+    once(event: EventKey, listener: (...args: any[]) => void): this;
+    once(event: "close", listener: () => void): this;
+    once(event: "data", listener: (chunk: Buffer) => void): this;
+    once(event: "end", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: "readable", listener: () => void): this;
+    prependListener(event: EventKey, listener: (...args: any[]) => void): this;
+    prependListener(event: "close", listener: () => void): this;
+    prependListener(event: "data", listener: (chunk: Buffer) => void): this;
+    prependListener(event: "end", listener: () => void): this;
+    prependListener(event: "error", listener: (err: Error) => void): this;
+    prependListener(event: "readable", listener: () => void): this;
+    prependOnceListener(
+      event: EventKey,
+      listener: (...args: any[]) => void
+    ): this;
+    prependOnceListener(event: "close", listener: () => void): this;
+    prependOnceListener(event: "data", listener: (chunk: Buffer) => void): this;
+    prependOnceListener(event: "end", listener: () => void): this;
+    prependOnceListener(event: "error", listener: (err: Error) => void): this;
+    prependOnceListener(event: "readable", listener: () => void): this;
+    removeListener(event: EventKey, listener: (...args: any[]) => void): this;
+    removeListener(event: "close", listener: () => void): this;
+    removeListener(event: "data", listener: (chunk: Buffer) => void): this;
+    removeListener(event: "end", listener: () => void): this;
+    removeListener(event: "error", listener: (err: Error) => void): this;
+    removeListener(event: "readable", listener: () => void): this;
+
+    /**
+     * Calls `readable.destroy()`.
+     */
+    [Symbol.dispose](): void;
+  }
+
+  class WritableStreamInner
+    extends EventEmitter
+    implements QuickJS.WritableStream
+  {
+    /**
+     * The `writable.write()` method writes some data to the stream, and calls the
+     * supplied `callback` once the data has been fully handled. If an error
+     * occurs, the `callback` will be called with the error as its
+     * first argument. The `callback` is usually called asynchronously and before `'error'`
+     * is emitted.
+     *
+     * ```js
+     * function write(data, cb) {
+     *   if (!stream.write(data)) {
+     *     stream.once('drain', cb);
+     *   } else {
+     *     process.nextTick(cb);
+     *   }
+     * }
+     *
+     * // Wait for cb to be called before doing any other write.
+     * write('hello', () => {
+     *   console.log('Write completed, do more writes now.');
+     * });
+     * ```
+     *
+     * A `Writable` stream in object mode will always ignore the `encoding` argument.
+     * @since v0.9.4
+     * @param chunk Optional data to write. `chunk` must be a {string}, {Buffer}, {TypedArray} or {DataView}.
+     * @param [encoding='utf8'] The encoding, if `chunk` is a string.
+     * @param callback Callback for when this chunk of data is flushed.
+     * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
+     */
+    write(
+      chunk:
+        | string
+        | Buffer
+        | QuickJS.ArrayBufferView
+        | ArrayBuffer
+        | SharedArrayBuffer,
+      callback?: (error?: Error | null) => void
+    ): void;
+
+    /**
+     * Calling the `writable.end()` method signals that no more data will be written
+     * to the `Writable`.
+     *
+     * Calling the {@link write} method after calling {@link end} will raise an error.
+     */
+    end(): this;
+
+    /**
+     * Event emitter
+     * The defined events on documents including:
+     * 1. close
+     * 2. error
+     * 3. finish
+     */
+    addListener(event: EventKey, listener: (...args: any[]) => void): this;
+    addListener(event: "close", listener: () => void): this;
+    addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "finish", listener: () => void): this;
+    emit(event: EventKey, ...args: any[]): boolean;
+    emit(event: "close"): boolean;
+    emit(event: "error", err: Error): boolean;
+    emit(event: "finish"): boolean;
+    on(event: EventKey, listener: (...args: any[]) => void): this;
+    on(event: "close", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: "finish", listener: () => void): this;
+    once(event: EventKey, listener: (...args: any[]) => void): this;
+    once(event: "close", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: "finish", listener: () => void): this;
+    prependListener(event: EventKey, listener: (...args: any[]) => void): this;
+    prependListener(event: "close", listener: () => void): this;
+    prependListener(event: "error", listener: (err: Error) => void): this;
+    prependListener(event: "finish", listener: () => void): this;
+    prependOnceListener(
+      event: EventKey,
+      listener: (...args: any[]) => void
+    ): this;
+    prependOnceListener(event: "close", listener: () => void): this;
+    prependOnceListener(event: "error", listener: (err: Error) => void): this;
+    prependOnceListener(event: "finish", listener: () => void): this;
+    removeListener(event: EventKey, listener: (...args: any[]) => void): this;
+    removeListener(event: "close", listener: () => void): this;
+    removeListener(event: "error", listener: (err: Error) => void): this;
+    removeListener(event: "finish", listener: () => void): this;
+  }
+
+  class DefaultReadableStream extends ReadableStreamInner {}
+
+  class DefaultWritableStream extends WritableStreamInner {}
+
+  class DefaultDuplexStream
+    extends DefaultReadableStream
+    implements DefaultWritableStream
+  {
+    /**
+     * The `writable.write()` method writes some data to the stream, and calls the
+     * supplied `callback` once the data has been fully handled. If an error
+     * occurs, the `callback` will be called with the error as its
+     * first argument. The `callback` is usually called asynchronously and before `'error'`
+     * is emitted.
+     *
+     * ```js
+     * function write(data, cb) {
+     *   if (!stream.write(data)) {
+     *     stream.once('drain', cb);
+     *   } else {
+     *     process.nextTick(cb);
+     *   }
+     * }
+     *
+     * // Wait for cb to be called before doing any other write.
+     * write('hello', () => {
+     *   console.log('Write completed, do more writes now.');
+     * });
+     * ```
+     *
+     * A `Writable` stream in object mode will always ignore the `encoding` argument.
+     * @since v0.9.4
+     * @param chunk Optional data to write. `chunk` must be a {string}, {Buffer}, {TypedArray} or {DataView}.
+     * @param [encoding='utf8'] The encoding, if `chunk` is a string.
+     * @param callback Callback for when this chunk of data is flushed.
+     * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
+     */
+    write(
+      chunk:
+        | string
+        | Buffer
+        | QuickJS.ArrayBufferView
+        | ArrayBuffer
+        | SharedArrayBuffer,
+      callback?: (error?: Error | null) => void
+    ): void;
+
+    /**
+     * Calling the `writable.end()` method signals that no more data will be written
+     * to the `Writable`.
+     *
+     * Calling the {@link write} method after calling {@link end} will raise an error.
+     */
+    end(): this;
+
+    /**
+     * Event emitter
+     * The defined events on documents including:
+     * 1. close
+     * 2. error
+     * 3. finish
+     */
+    addListener(event: EventKey, listener: (...args: any[]) => void): this;
+    addListener(event: "close", listener: () => void): this;
+    addListener(event: "error", listener: (err: Error) => void): this;
+    addListener(event: "finish", listener: () => void): this;
+    emit(event: EventKey, ...args: any[]): boolean;
+    emit(event: "close"): boolean;
+    emit(event: "error", err: Error): boolean;
+    emit(event: "finish"): boolean;
+    on(event: EventKey, listener: (...args: any[]) => void): this;
+    on(event: "close", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: "finish", listener: () => void): this;
+    once(event: EventKey, listener: (...args: any[]) => void): this;
+    once(event: "close", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: "finish", listener: () => void): this;
+    prependListener(event: EventKey, listener: (...args: any[]) => void): this;
+    prependListener(event: "close", listener: () => void): this;
+    prependListener(event: "error", listener: (err: Error) => void): this;
+    prependListener(event: "finish", listener: () => void): this;
+    prependOnceListener(
+      event: EventKey,
+      listener: (...args: any[]) => void
+    ): this;
+    prependOnceListener(event: "close", listener: () => void): this;
+    prependOnceListener(event: "error", listener: (err: Error) => void): this;
+    prependOnceListener(event: "finish", listener: () => void): this;
+    removeListener(event: EventKey, listener: (...args: any[]) => void): this;
+    removeListener(event: "close", listener: () => void): this;
+    removeListener(event: "error", listener: (err: Error) => void): this;
+    removeListener(event: "finish", listener: () => void): this;
+  }
+
+  global {
+    namespace QuickJS {
+      interface ReadableStream extends EventEmitter {
+        read(size?: number): Buffer | null;
+      }
+
+      interface WritableStream extends EventEmitter {
+        write(
+          chunk:
+            | string
+            | Buffer
+            | QuickJS.ArrayBufferView
+            | ArrayBuffer
+            | SharedArrayBuffer,
+          callback?: (err?: Error | null) => void
+        ): void;
+        end(): this;
+      }
+    }
+  }
+}

package/src/string_decoder.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The `string_decoder` module provides an API for decoding `Buffer` objects
+ * into strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16
+ * characters. It can be accessed using:
+ *
+ * ```js
+ * const { StringDecoder } = require('string_decoder');
+ * ```
+ *
+ * The following example shows the basic use of the `StringDecoder` class.
+ *
+ * ```js
+ * const { StringDecoder } = require('string_decoder');
+ * const decoder = new StringDecoder('utf8');
+ *
+ * const cent = Buffer.from([0xC2, 0xA2]);
+ * console.log(decoder.write(cent)); // Prints: ¢
+ *
+ * const euro = Buffer.from([0xE2, 0x82, 0xAC]);
+ * console.log(decoder.write(euro)); // Prints: €
+ * ```
+ *
+ * When a `Buffer` instance is written to the `StringDecoder` instance, an
+ * internal buffer is used to ensure that the decoded string does not contain
+ * any incomplete multibyte characters. These are held in the buffer until the
+ * next call to `stringDecoder.write()` or until `stringDecoder.end()` is called.
+ *
+ * In the following example, the three UTF-8 encoded bytes of the European Euro
+ * symbol (`€`) are written over three separate operations:
+ *
+ * ```js
+ * const { StringDecoder } = require('string_decoder');
+ * const decoder = new StringDecoder('utf8');
+ *
+ * decoder.write(Buffer.from([0xE2]));
+ * decoder.write(Buffer.from([0x82]));
+ * console.log(decoder.end(Buffer.from([0xAC]))); // Prints: €
+ * ```
+ */
+declare module "string_decoder" {
+  import { Buffer, BufferEncoding } from "buffer";
+
+  class StringDecoder {
+    constructor(encoding?: BufferEncoding);
+    /**
+     * Returns a decoded string, ensuring that any incomplete multibyte characters at
+     * the end of the `Buffer`, or `TypedArray`, or `DataView` are omitted from the
+     * returned string and stored in an internal buffer for the next call to `stringDecoder.write()` or `stringDecoder.end()`.
+     * @param buffer The bytes to decode.
+     */
+    write(buffer: string | Buffer | QuickJS.ArrayBufferView): string;
+    /**
+     * Returns any remaining input stored in the internal buffer as a string. Bytes
+     * representing incomplete UTF-8 and UTF-16 characters will be replaced with
+     * substitution characters appropriate for the character encoding.
+     *
+     * If the `buffer` argument is provided, one final call to `stringDecoder.write()` is performed before returning the remaining input.
+     * After `end()` is called, the `stringDecoder` object can be reused for new input.
+     * @param buffer The bytes to decode.
+     */
+    end(buffer?: string | Buffer | QuickJS.ArrayBufferView): string;
+  }
+}

package/src/timers.d.ts

@@ -0,0 +1,72 @@
+declare module "timers" {
+  export import setTimeout = globalThis.setTimeout;
+  export import clearTimeout = globalThis.clearTimeout;
+  export import setInterval = globalThis.setInterval;
+  export import clearInterval = globalThis.clearInterval;
+  export import setImmediate = globalThis.setImmediate;
+
+  global {
+    /**
+     * This object is created internally and is returned from `setTimeout()` and `setInterval()`. It can be passed to either `clearTimeout()` or `clearInterval()` in order to cancel the
+     * scheduled actions.
+     */
+    class Timeout {}
+
+    /**
+     * Schedules execution of a one-time `callback` after `delay` milliseconds.
+     *
+     * The `callback` will likely not be invoked in precisely `delay` milliseconds.
+     * LLRT makes no guarantees about the exact timing of when callbacks will fire,
+     * nor of their ordering. The callback will be called as close as possible to the
+     * time specified. The precision is limited to 4ms.
+     *
+     * @param callback The function to call when the timer elapses.
+     * @param [delay=4] The number of milliseconds to wait before calling the `callback`.
+     * @return for use with {@link clearTimeout}
+     */
+    function setTimeout<TArgs extends any[]>(
+      callback: (...args: TArgs) => void,
+      ms?: number
+    ): Timeout;
+
+    /**
+     * Cancels a `Timeout` object created by `setTimeout()`.
+     * @param timeout A `Timeout` object as returned by {@link setTimeout}.
+     */
+    function clearTimeout(timeout: Timeout): void;
+
+    /**
+     * Schedules repeated execution of `callback` every `delay` milliseconds.
+     *
+     * The `callback` will likely not be invoked at precisely `delay` milliseconds.
+     * LLRT makes no guarantees about the exact timing of when callbacks will fire,
+     * nor of their ordering. The callback will be called as close as possible to the
+     * time specified. The precision is limited to 4ms.
+     *
+     * @param callback The function to call when the timer elapses.
+     * @param [delay=4] The number of milliseconds to wait before calling the `callback`.
+     * @return for use with {@link clearInterval}
+     */
+    function setInterval<TArgs extends any[]>(
+      callback: (...args: TArgs) => void,
+      ms?: number
+    ): Timeout;
+
+    /**
+     * Cancels a `Timeout` object created by `setInterval()`.
+     * @param timeout A `Timeout` object as returned by {@link setInterval}
+     */
+    function clearInterval(interval: Timeout): void;
+
+    /**
+     * Schedules the "immediate" execution of the `callback` after I/O events'
+     * callbacks.
+     *
+     * @param callback The function to call at the end of this turn of the Node.js `Event Loop`
+     * @return for use with {@link clearImmediate}
+     */
+    function setImmediate<TArgs extends any[]>(
+      callback: (...args: TArgs) => void
+    ): void;
+  }
+}

package/src/tty.d.ts

@@ -0,0 +1,10 @@
+declare module 'tty' {
+  /**
+   * The `tty.isatty()` method returns `true` if the given `fd` is associated with
+   * a TTY and `false` if it is not, including whenever `fd` is not a non-negative
+   * integer.
+   * @since v0.5.8
+   * @param fd A numeric file descriptor
+   */
+  function isatty(fd: number): boolean
+}