omegon 0.8.4 → 0.9.1

package/node_modules/@types/node/buffer.d.ts

@@ -1,3 +1,8 @@
+// If lib.dom.d.ts or lib.webworker.d.ts is loaded, then use the global types.
+// Otherwise, use the types from node.
+type _Blob = typeof globalThis extends { onmessage: any; Blob: any } ? {} : import("buffer").Blob;
+type _File = typeof globalThis extends { onmessage: any; File: any } ? {} : import("buffer").File;
+
 /**
  * `Buffer` objects are used to represent a fixed-length sequence of bytes. Many
  * Node.js APIs support `Buffer`s.
@@ -41,10 +46,11 @@
  * // Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].
  * const buf7 = Buffer.from('tést', 'latin1');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/buffer.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/buffer.js)
  */
-declare module "node:buffer" {
-    import { ReadableStream } from "node:stream/web";
+declare module "buffer" {
+    import { BinaryLike } from "node:crypto";
+    import { ReadableStream as WebReadableStream } from "node:stream/web";
     /**
      * This function returns `true` if `input` contains only valid UTF-8-encoded data,
      * including the case in which `input` is empty.
@@ -120,11 +126,115 @@ declare module "node:buffer" {
      */
     export function resolveObjectURL(id: string): Blob | undefined;
     export { type AllowSharedBuffer, Buffer, type NonSharedBuffer };
-    /** @deprecated This alias will be removed in a future version. Use the canonical `BlobPropertyBag` instead. */
-    // TODO: remove in future major
-    export interface BlobOptions extends BlobPropertyBag {}
-    /** @deprecated This alias will be removed in a future version. Use the canonical `FilePropertyBag` instead. */
-    export interface FileOptions extends FilePropertyBag {}
+    /**
+     * @experimental
+     */
+    export interface BlobOptions {
+        /**
+         * One of either `'transparent'` or `'native'`. When set to `'native'`, line endings in string source parts
+         * will be converted to the platform native line-ending as specified by `import { EOL } from 'node:os'`.
+         */
+        endings?: "transparent" | "native";
+        /**
+         * The Blob content-type. The intent is for `type` to convey
+         * the MIME media type of the data, however no validation of the type format
+         * is performed.
+         */
+        type?: string | undefined;
+    }
+    /**
+     * A `Blob` encapsulates immutable, raw data that can be safely shared across
+     * multiple worker threads.
+     * @since v15.7.0, v14.18.0
+     */
+    export class Blob {
+        /**
+         * The total size of the `Blob` in bytes.
+         * @since v15.7.0, v14.18.0
+         */
+        readonly size: number;
+        /**
+         * The content-type of the `Blob`.
+         * @since v15.7.0, v14.18.0
+         */
+        readonly type: string;
+        /**
+         * Creates a new `Blob` object containing a concatenation of the given sources.
+         *
+         * {ArrayBuffer}, {TypedArray}, {DataView}, and {Buffer} sources are copied into
+         * the 'Blob' and can therefore be safely modified after the 'Blob' is created.
+         *
+         * String sources are also copied into the `Blob`.
+         */
+        constructor(sources: Array<ArrayBuffer | BinaryLike | Blob>, options?: BlobOptions);
+        /**
+         * Returns a promise that fulfills with an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) containing a copy of
+         * the `Blob` data.
+         * @since v15.7.0, v14.18.0
+         */
+        arrayBuffer(): Promise<ArrayBuffer>;
+        /**
+         * The `blob.bytes()` method returns the byte of the `Blob` object as a `Promise<Uint8Array>`.
+         *
+         * ```js
+         * const blob = new Blob(['hello']);
+         * blob.bytes().then((bytes) => {
+         *   console.log(bytes); // Outputs: Uint8Array(5) [ 104, 101, 108, 108, 111 ]
+         * });
+         * ```
+         */
+        bytes(): Promise<Uint8Array>;
+        /**
+         * Creates and returns a new `Blob` containing a subset of this `Blob` objects
+         * data. The original `Blob` is not altered.
+         * @since v15.7.0, v14.18.0
+         * @param start The starting index.
+         * @param end The ending index.
+         * @param type The content-type for the new `Blob`
+         */
+        slice(start?: number, end?: number, type?: string): Blob;
+        /**
+         * Returns a promise that fulfills with the contents of the `Blob` decoded as a
+         * UTF-8 string.
+         * @since v15.7.0, v14.18.0
+         */
+        text(): Promise<string>;
+        /**
+         * Returns a new `ReadableStream` that allows the content of the `Blob` to be read.
+         * @since v16.7.0
+         */
+        stream(): WebReadableStream;
+    }
+    export interface FileOptions {
+        /**
+         * One of either `'transparent'` or `'native'`. When set to `'native'`, line endings in string source parts will be
+         * converted to the platform native line-ending as specified by `import { EOL } from 'node:os'`.
+         */
+        endings?: "native" | "transparent";
+        /** The File content-type. */
+        type?: string;
+        /** The last modified date of the file. `Default`: Date.now(). */
+        lastModified?: number;
+    }
+    /**
+     * A [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) provides information about files.
+     * @since v19.2.0, v18.13.0
+     */
+    export class File extends Blob {
+        constructor(sources: Array<BinaryLike | Blob>, fileName: string, options?: FileOptions);
+        /**
+         * The name of the `File`.
+         * @since v19.2.0, v18.13.0
+         */
+        readonly name: string;
+        /**
+         * The last modified date of the `File`.
+         * @since v19.2.0, v18.13.0
+         */
+        readonly lastModified: number;
+    }
+    export import atob = globalThis.atob;
+    export import btoa = globalThis.btoa;
     export type WithImplicitCoercion<T> =
         | T
         | { valueOf(): T }
@@ -1769,42 +1879,56 @@ declare module "node:buffer" {
             includes(value: string | number | Buffer, encoding: BufferEncoding): boolean;
         }
         var Buffer: BufferConstructor;
+        /**
+         * Decodes a string of Base64-encoded data into bytes, and encodes those bytes
+         * into a string using Latin-1 (ISO-8859-1).
+         *
+         * The `data` may be any JavaScript-value that can be coerced into a string.
+         *
+         * **This function is only provided for compatibility with legacy web platform APIs**
+         * **and should never be used in new code, because they use strings to represent**
+         * **binary data and predate the introduction of typed arrays in JavaScript.**
+         * **For code running using Node.js APIs, converting between base64-encoded strings**
+         * **and binary data should be performed using `Buffer.from(str, 'base64')` and `buf.toString('base64')`.**
+         * @since v15.13.0, v14.17.0
+         * @legacy Use `Buffer.from(data, 'base64')` instead.
+         * @param data The Base64-encoded input string.
+         */
+        function atob(data: string): string;
+        /**
+         * Decodes a string into bytes using Latin-1 (ISO-8859), and encodes those bytes
+         * into a string using Base64.
+         *
+         * The `data` may be any JavaScript-value that can be coerced into a string.
+         *
+         * **This function is only provided for compatibility with legacy web platform APIs**
+         * **and should never be used in new code, because they use strings to represent**
+         * **binary data and predate the introduction of typed arrays in JavaScript.**
+         * **For code running using Node.js APIs, converting between base64-encoded strings**
+         * **and binary data should be performed using `Buffer.from(str, 'base64')` and `buf.toString('base64')`.**
+         * @since v15.13.0, v14.17.0
+         * @legacy Use `buf.toString('base64')` instead.
+         * @param data An ASCII (Latin1) string.
+         */
+        function btoa(data: string): string;
+        interface Blob extends _Blob {}
+        /**
+         * `Blob` class is a global reference for `import { Blob } from 'node:buffer'`
+         * https://nodejs.org/api/buffer.html#class-blob
+         * @since v18.0.0
+         */
+        var Blob: typeof globalThis extends { onmessage: any; Blob: infer T } ? T
+            : typeof import("buffer").Blob;
+        interface File extends _File {}
+        /**
+         * `File` class is a global reference for `import { File } from 'node:buffer'`
+         * https://nodejs.org/api/buffer.html#class-file
+         * @since v20.0.0
+         */
+        var File: typeof globalThis extends { onmessage: any; File: infer T } ? T
+            : typeof import("buffer").File;
     }
-    // #region web types
-    export type BlobPart = NodeJS.BufferSource | Blob | string;
-    export interface BlobPropertyBag {
-        endings?: "native" | "transparent";
-        type?: string;
-    }
-    export interface FilePropertyBag extends BlobPropertyBag {
-        lastModified?: number;
-    }
-    export interface Blob {
-        readonly size: number;
-        readonly type: string;
-        arrayBuffer(): Promise<ArrayBuffer>;
-        bytes(): Promise<NodeJS.NonSharedUint8Array>;
-        slice(start?: number, end?: number, contentType?: string): Blob;
-        stream(): ReadableStream<NodeJS.NonSharedUint8Array>;
-        text(): Promise<string>;
-    }
-    export var Blob: {
-        prototype: Blob;
-        new(blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
-    };
-    export interface File extends Blob {
-        readonly lastModified: number;
-        readonly name: string;
-        readonly webkitRelativePath: string;
-    }
-    export var File: {
-        prototype: File;
-        new(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
-    };
-    export import atob = globalThis.atob;
-    export import btoa = globalThis.btoa;
-    // #endregion
 }
-declare module "buffer" {
-    export * from "node:buffer";
+declare module "node:buffer" {
+    export * from "buffer";
 }

package/node_modules/@types/node/child_process.d.ts

@@ -5,7 +5,6 @@
  *
  * ```js
  * import { spawn } from 'node:child_process';
- * import { once } from 'node:events';
  * const ls = spawn('ls', ['-lh', '/usr']);
  *
  * ls.stdout.on('data', (data) => {
@@ -16,8 +15,9 @@
  *   console.error(`stderr: ${data}`);
  * });
  *
- * const [code] = await once(ls, 'close');
- * console.log(`child process exited with code ${code}`);
+ * ls.on('close', (code) => {
+ *   console.log(`child process exited with code ${code}`);
+ * });
  * ```
  *
  * By default, pipes for `stdin`, `stdout`, and `stderr` are established between
@@ -63,25 +63,17 @@
  * For certain use cases, such as automating shell scripts, the `synchronous counterparts` may be more convenient. In many cases, however,
  * the synchronous methods can have significant impact on performance due to
  * stalling the event loop while spawned processes complete.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/child_process.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/child_process.js)
  */
-declare module "node:child_process" {
+declare module "child_process" {
     import { NonSharedBuffer } from "node:buffer";
+    import { Abortable, EventEmitter } from "node:events";
     import * as dgram from "node:dgram";
-    import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
     import * as net from "node:net";
     import { Readable, Stream, Writable } from "node:stream";
     import { URL } from "node:url";
     type Serializable = string | object | number | boolean | bigint;
     type SendHandle = net.Socket | net.Server | dgram.Socket | undefined;
-    interface ChildProcessEventMap {
-        "close": [code: number | null, signal: NodeJS.Signals | null];
-        "disconnect": [];
-        "error": [err: Error];
-        "exit": [code: number | null, signal: NodeJS.Signals | null];
-        "message": [message: Serializable, sendHandle: SendHandle];
-        "spawn": [];
-    }
     /**
      * Instances of the `ChildProcess` represent spawned child processes.
      *
@@ -90,7 +82,7 @@ declare module "node:child_process" {
      * instances of `ChildProcess`.
      * @since v2.2.0
      */
-    class ChildProcess implements EventEmitter {
+    class ChildProcess extends EventEmitter {
         /**
          * A `Writable Stream` that represents the child process's `stdin`.
          *
@@ -228,11 +220,6 @@ declare module "node:child_process" {
         /**
          * The `subprocess.exitCode` property indicates the exit code of the child process.
          * If the child process is still running, the field will be `null`.
-         *
-         * When the child process is terminated by a signal, `subprocess.exitCode` will be
-         * `null` and `subprocess.signalCode` will be set. To get the corresponding
-         * POSIX exit code, use
-         * `util.convertProcessSignalToExitCode(subprocess.signalCode)`.
          */
         readonly exitCode: number | null;
         /**
@@ -471,7 +458,7 @@ declare module "node:child_process" {
          * as the connection may have been closed during the time it takes to send the
          * connection to the child.
          * @since v0.5.9
-         * @param sendHandle `undefined`, or a [`net.Socket`](https://nodejs.org/docs/latest-v25.x/api/net.html#class-netsocket), [`net.Server`](https://nodejs.org/docs/latest-v25.x/api/net.html#class-netserver), or [`dgram.Socket`](https://nodejs.org/docs/latest-v25.x/api/dgram.html#class-dgramsocket) object.
+         * @param sendHandle `undefined`, or a [`net.Socket`](https://nodejs.org/docs/latest-v22.x/api/net.html#class-netsocket), [`net.Server`](https://nodejs.org/docs/latest-v22.x/api/net.html#class-netserver), or [`dgram.Socket`](https://nodejs.org/docs/latest-v22.x/api/dgram.html#class-dgramsocket) object.
          * @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles. `options` supports the following properties:
          */
         send(message: Serializable, callback?: (error: Error | null) => void): boolean;
@@ -537,8 +524,64 @@ declare module "node:child_process" {
          * @since v0.7.10
          */
         ref(): void;
+        /**
+         * events.EventEmitter
+         * 1. close
+         * 2. disconnect
+         * 3. error
+         * 4. exit
+         * 5. message
+         * 6. spawn
+         */
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+        addListener(event: "disconnect", listener: () => void): this;
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+        addListener(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
+        addListener(event: "spawn", listener: () => void): this;
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "close", code: number | null, signal: NodeJS.Signals | null): boolean;
+        emit(event: "disconnect"): boolean;
+        emit(event: "error", err: Error): boolean;
+        emit(event: "exit", code: number | null, signal: NodeJS.Signals | null): boolean;
+        emit(event: "message", message: Serializable, sendHandle: SendHandle): boolean;
+        emit(event: "spawn", listener: () => void): boolean;
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+        on(event: "disconnect", listener: () => void): this;
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+        on(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
+        on(event: "spawn", listener: () => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+        once(event: "disconnect", listener: () => void): this;
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+        once(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
+        once(event: "spawn", listener: () => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+        prependListener(event: "disconnect", listener: () => void): this;
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+        prependListener(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
+        prependListener(event: "spawn", listener: () => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(
+            event: "close",
+            listener: (code: number | null, signal: NodeJS.Signals | null) => void,
+        ): this;
+        prependOnceListener(event: "disconnect", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(
+            event: "exit",
+            listener: (code: number | null, signal: NodeJS.Signals | null) => void,
+        ): this;
+        prependOnceListener(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
+        prependOnceListener(event: "spawn", listener: () => void): this;
     }
-    interface ChildProcess extends InternalEventEmitter<ChildProcessEventMap> {}
     // return this object when stdio option is undefined or not specified
     interface ChildProcessWithoutNullStreams extends ChildProcess {
         stdin: Writable;
@@ -676,7 +719,6 @@ declare module "node:child_process" {
      *
      * ```js
      * import { spawn } from 'node:child_process';
-     * import { once } from 'node:events';
      * const ls = spawn('ls', ['-lh', '/usr']);
      *
      * ls.stdout.on('data', (data) => {
@@ -687,8 +729,9 @@ declare module "node:child_process" {
      *   console.error(`stderr: ${data}`);
      * });
      *
-     * const [code] = await once(ls, 'close');
-     * console.log(`child process exited with code ${code}`);
+     * ls.on('close', (code) => {
+     *   console.log(`child process exited with code ${code}`);
+     * });
      * ```
      *
      * Example: A very elaborate way to run `ps ax | grep ssh`
@@ -1428,6 +1471,6 @@ declare module "node:child_process" {
         options?: ExecFileSyncOptions,
     ): string | NonSharedBuffer;
 }
-declare module "child_process" {
-    export * from "node:child_process";
+declare module "node:child_process" {
+    export * from "child_process";
 }