@senpiper/sp-agent 0.1.6 → 0.1.9

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

@@ -1,5 +1,56 @@
-declare module "node:buffer" {
-    import { ReadableStream } from "node:stream/web";
+// 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.
+ *
+ * The `Buffer` class is a subclass of JavaScript's [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) class and
+ * extends it with methods that cover additional use cases. Node.js APIs accept
+ * plain [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) s wherever `Buffer`s are supported as well.
+ *
+ * While the `Buffer` class is available within the global scope, it is still
+ * recommended to explicitly reference it via an import or require statement.
+ *
+ * ```js
+ * import { Buffer } from 'node:buffer';
+ *
+ * // Creates a zero-filled Buffer of length 10.
+ * const buf1 = Buffer.alloc(10);
+ *
+ * // Creates a Buffer of length 10,
+ * // filled with bytes which all have the value `1`.
+ * const buf2 = Buffer.alloc(10, 1);
+ *
+ * // Creates an uninitialized buffer of length 10.
+ * // This is faster than calling Buffer.alloc() but the returned
+ * // Buffer instance might contain old data that needs to be
+ * // overwritten using fill(), write(), or other functions that fill the Buffer's
+ * // contents.
+ * const buf3 = Buffer.allocUnsafe(10);
+ *
+ * // Creates a Buffer containing the bytes [1, 2, 3].
+ * const buf4 = Buffer.from([1, 2, 3]);
+ *
+ * // Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries
+ * // are all truncated using `(value & 255)` to fit into the range 0–255.
+ * const buf5 = Buffer.from([257, 257.5, -255, '1']);
+ *
+ * // Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':
+ * // [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)
+ * // [116, 195, 169, 115, 116] (in decimal notation)
+ * const buf6 = Buffer.from('tést');
+ *
+ * // 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/v22.x/lib/buffer.js)
+ */
+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.
@@ -75,6 +126,115 @@ declare module "node:buffer" {
      */
     export function resolveObjectURL(id: string): Blob | undefined;
     export { type AllowSharedBuffer, Buffer, type NonSharedBuffer };
+    /**
+     * @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 }
@@ -1550,12 +1710,11 @@ declare module "node:buffer" {
             /**
              * If `value` is:
              *
-             * * a string, `value` is interpreted according to the character encoding in
-             *   `encoding`.
-             * * a `Buffer` or `Uint8Array`, `value` will be used in its entirety.
-             *   To compare a partial `Buffer`, use `buf.subarray`.
+             * * a string, `value` is interpreted according to the character encoding in `encoding`.
+             * * a `Buffer` or [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), `value` will be used in its entirety.
+             * To compare a partial `Buffer`, use `buf.subarray`.
              * * a number, `value` will be interpreted as an unsigned 8-bit integer
-             *   value between `0` and `255`.
+             * value between `0` and `255`.
              *
              * ```js
              * import { Buffer } from 'node:buffer';
@@ -1583,13 +1742,12 @@ declare module "node:buffer" {
              * // Prints: 6
              * ```
              *
-             * If `value` is not a string, number, or `Buffer`, this method will throw a
-             * `TypeError`. If `value` is a number, it will be coerced to a valid byte value,
+             * If `value` is not a string, number, or `Buffer`, this method will throw a `TypeError`. If `value` is a number, it will be coerced to a valid byte value,
              * an integer between 0 and 255.
              *
              * If `byteOffset` is not a number, it will be coerced to a number. If the result
              * of coercion is `NaN` or `0`, then the entire buffer will be searched. This
-             * behavior matches `String.prototype.indexOf()`.
+             * behavior matches [`String.prototype.indexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf).
              *
              * ```js
              * import { Buffer } from 'node:buffer';
@@ -1610,27 +1768,14 @@ declare module "node:buffer" {
              * ```
              *
              * If `value` is an empty string or empty `Buffer` and `byteOffset` is less
-             * than `buf.length`, `byteOffset` will be returned. If `value` is empty and
-             * `byteOffset` is at least `buf.length`, `buf.length` will be returned.
+             * than `buf.length`, `byteOffset` will be returned. If `value` is empty and`byteOffset` is at least `buf.length`, `buf.length` will be returned.
              * @since v1.5.0
              * @param value What to search for.
-             * @param start Where to begin searching in `buf`. If negative, then
-             * offset is calculated from the end of `buf`. **Default:** `0`.
-             * @param end Where to stop searching in `buf` (exclusive). **Default:**
-             * `buf.length`.
-             * @param encoding If `value` is a string, this is the encoding used to
-             * determine the binary representation of the string that will be searched for in
-             * `buf`. **Default:** `'utf8'`.
-             * @returns The index of the first occurrence of `value` in `buf`, or
-             * `-1` if `buf` does not contain `value`.
-             */
-            indexOf(
-                value: string | number | Uint8Array,
-                start?: number,
-                end?: number,
-                encoding?: BufferEncoding,
-            ): number;
-            indexOf(value: string | number | Uint8Array, start: number, encoding: BufferEncoding): number;
+             * @param [byteOffset=0] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`.
+             * @param [encoding='utf8'] If `value` is a string, this is the encoding used to determine the binary representation of the string that will be searched for in `buf`.
+             * @return The index of the first occurrence of `value` in `buf`, or `-1` if `buf` does not contain `value`.
+             */
+            indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
             indexOf(value: string | number | Uint8Array, encoding: BufferEncoding): number;
             /**
              * Identical to `buf.indexOf()`, except the last occurrence of `value` is found
@@ -1664,13 +1809,12 @@ declare module "node:buffer" {
              * // Prints: 4
              * ```
              *
-             * If `value` is not a string, number, or `Buffer`, this method will throw a
-             * `TypeError`. If `value` is a number, it will be coerced to a valid byte value,
+             * If `value` is not a string, number, or `Buffer`, this method will throw a `TypeError`. If `value` is a number, it will be coerced to a valid byte value,
              * an integer between 0 and 255.
              *
              * If `byteOffset` is not a number, it will be coerced to a number. Any arguments
              * that coerce to `NaN`, like `{}` or `undefined`, will search the whole buffer.
-             * This behavior matches `String.prototype.lastIndexOf()`.
+             * This behavior matches [`String.prototype.lastIndexOf()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf).
              *
              * ```js
              * import { Buffer } from 'node:buffer';
@@ -1696,24 +1840,11 @@ declare module "node:buffer" {
              * If `value` is an empty string or empty `Buffer`, `byteOffset` will be returned.
              * @since v6.0.0
              * @param value What to search for.
-             * @param start Where to begin searching in `buf`. If negative, then
-             * offset is calculated from the end of `buf`. **Default:**
-             * `buf.length - 1`.
-             * @param end Where to stop searching in `buf` (exclusive). **Default:**
-             * `buf.length`.
-             * @param encoding If `value` is a string, this is the encoding used to
-             * determine the binary representation of the string that will be searched for in
-             * `buf`. **Default:** `'utf8'`.
-             * @returns The index of the last occurrence of `value` in `buf`, or
-             * `-1` if `buf` does not contain `value`.
-             */
-            lastIndexOf(
-                value: string | number | Uint8Array,
-                start?: number,
-                end?: number,
-                encoding?: BufferEncoding,
-            ): number;
-            lastIndexOf(value: string | number | Uint8Array, start: number, encoding: BufferEncoding): number;
+             * @param [byteOffset=buf.length - 1] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`.
+             * @param [encoding='utf8'] If `value` is a string, this is the encoding used to determine the binary representation of the string that will be searched for in `buf`.
+             * @return The index of the last occurrence of `value` in `buf`, or `-1` if `buf` does not contain `value`.
+             */
+            lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
             lastIndexOf(value: string | number | Uint8Array, encoding: BufferEncoding): number;
             /**
              * Equivalent to `buf.indexOf() !== -1`.
@@ -1740,60 +1871,64 @@ declare module "node:buffer" {
              * ```
              * @since v5.3.0
              * @param value What to search for.
-             * @param start Where to begin searching in `buf`. If negative, then
-             * offset is calculated from the end of `buf`. **Default:** `0`.
-             * @param end Where to stop searching in `buf` (exclusive). **Default:**
-             * `buf.length`.
-             * @param encoding If `value` is a string, this is its encoding.
-             * **Default:** `'utf8'`.
-             * @returns `true` if `value` was found in `buf`, `false` otherwise.
-             */
-            includes(
-                value: string | number | Uint8Array,
-                start?: number,
-                end?: number,
-                encoding?: BufferEncoding,
-            ): boolean;
-            includes(value: string | number | Uint8Array, start: number, encoding: BufferEncoding): boolean;
-            includes(value: string | number | Uint8Array, encoding: BufferEncoding): boolean;
+             * @param [byteOffset=0] Where to begin searching in `buf`. If negative, then offset is calculated from the end of `buf`.
+             * @param [encoding='utf8'] If `value` is a string, this is its encoding.
+             * @return `true` if `value` was found in `buf`, `false` otherwise.
+             */
+            includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean;
+            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";
 }