@versori/run 0.1.0-alpha.11 → 0.1.0-alpha.13

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/mod.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = void 0;
+var connect_js_1 = require("./connect.js");
+Object.defineProperty(exports, "connect", { enumerable: true, get: function () { return connect_js_1.connect; } });
+__exportStar(require("../../../nats-core/3.0.2/src/mod.js"), exports);

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/version.d.ts

@@ -0,0 +1,2 @@
+export declare const version = "3.0.2";
+//# sourceMappingURL=version.d.ts.map

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/version.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/script/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+// This file is generated - do not edit
+exports.version = "3.0.2";

package/script/deps/jsr.io/@std/bytes/1.0.5/_types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Proxy type of {@code Uint8Array<ArrayBuffer} or {@code Uint8Array} in TypeScript 5.7 or below respectively.
+ *
+ * This type is internal utility type and should not be used directly.
+ *
+ * @internal @private
+ */
+export type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
+//# sourceMappingURL=_types.d.ts.map

package/script/deps/jsr.io/@std/bytes/1.0.5/_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.5/_types.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC"}

package/script/deps/jsr.io/@std/bytes/1.0.5/_types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/deps/jsr.io/@std/bytes/1.0.5/concat.d.ts

@@ -0,0 +1,21 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+/**
+ * Concatenate an array of byte slices into a single slice.
+ *
+ * @param buffers Array of byte slices to concatenate.
+ * @returns A new byte slice containing all the input slices concatenated.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { concat } from "@std/bytes/concat";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = new Uint8Array([0, 1, 2]);
+ * const b = new Uint8Array([3, 4, 5]);
+ *
+ * assertEquals(concat([a, b]), new Uint8Array([0, 1, 2, 3, 4, 5]));
+ * ```
+ */
+export declare function concat(buffers: Uint8Array[]): Uint8Array_;
+//# sourceMappingURL=concat.d.ts.map

package/script/deps/jsr.io/@std/bytes/1.0.5/concat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.5/concat.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,WAAW,CAazD"}

package/script/deps/jsr.io/@std/bytes/1.0.5/concat.js

@@ -0,0 +1,35 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concat = concat;
+/**
+ * Concatenate an array of byte slices into a single slice.
+ *
+ * @param buffers Array of byte slices to concatenate.
+ * @returns A new byte slice containing all the input slices concatenated.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { concat } from "@std/bytes/concat";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = new Uint8Array([0, 1, 2]);
+ * const b = new Uint8Array([3, 4, 5]);
+ *
+ * assertEquals(concat([a, b]), new Uint8Array([0, 1, 2, 3, 4, 5]));
+ * ```
+ */
+function concat(buffers) {
+    let length = 0;
+    for (const buffer of buffers) {
+        length += buffer.length;
+    }
+    const output = new Uint8Array(length);
+    let index = 0;
+    for (const buffer of buffers) {
+        output.set(buffer, index);
+        index += buffer.length;
+    }
+    return output;
+}

package/script/deps/jsr.io/@std/bytes/1.0.5/copy.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Copy bytes from the source array to the destination array and returns the
+ * number of bytes copied.
+ *
+ * If the source array is larger than what the `dst` array can hold, only the
+ * amount of bytes that fit in the `dst` array are copied.
+ *
+ * @param src Source array to copy from.
+ * @param dst Destination array to copy to.
+ * @param offset Offset in the destination array to start copying to. Defaults
+ * to 0.
+ * @returns Number of bytes copied.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { copy } from "@std/bytes/copy";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const src = new Uint8Array([9, 8, 7]);
+ * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]);
+ *
+ * assertEquals(copy(src, dst), 3);
+ * assertEquals(dst, new Uint8Array([9, 8, 7, 3, 4, 5]));
+ * ```
+ *
+ * @example Copy with offset
+ * ```ts
+ * import { copy } from "@std/bytes/copy";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const src = new Uint8Array([1, 1, 1, 1]);
+ * const dst = new Uint8Array([0, 0, 0, 0]);
+ *
+ * assertEquals(copy(src, dst, 1), 3);
+ * assertEquals(dst, new Uint8Array([0, 1, 1, 1]));
+ * ```
+ * Defining an offset will start copying at the specified index in the
+ * destination array.
+ */
+export declare function copy(src: Uint8Array, dst: Uint8Array, offset?: number): number;
+//# sourceMappingURL=copy.d.ts.map

package/script/deps/jsr.io/@std/bytes/1.0.5/copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.5/copy.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,SAAI,GAAG,MAAM,CAQzE"}

package/script/deps/jsr.io/@std/bytes/1.0.5/copy.js

@@ -0,0 +1,53 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copy = copy;
+/**
+ * Copy bytes from the source array to the destination array and returns the
+ * number of bytes copied.
+ *
+ * If the source array is larger than what the `dst` array can hold, only the
+ * amount of bytes that fit in the `dst` array are copied.
+ *
+ * @param src Source array to copy from.
+ * @param dst Destination array to copy to.
+ * @param offset Offset in the destination array to start copying to. Defaults
+ * to 0.
+ * @returns Number of bytes copied.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { copy } from "@std/bytes/copy";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const src = new Uint8Array([9, 8, 7]);
+ * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]);
+ *
+ * assertEquals(copy(src, dst), 3);
+ * assertEquals(dst, new Uint8Array([9, 8, 7, 3, 4, 5]));
+ * ```
+ *
+ * @example Copy with offset
+ * ```ts
+ * import { copy } from "@std/bytes/copy";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const src = new Uint8Array([1, 1, 1, 1]);
+ * const dst = new Uint8Array([0, 0, 0, 0]);
+ *
+ * assertEquals(copy(src, dst, 1), 3);
+ * assertEquals(dst, new Uint8Array([0, 1, 1, 1]));
+ * ```
+ * Defining an offset will start copying at the specified index in the
+ * destination array.
+ */
+function copy(src, dst, offset = 0) {
+    offset = Math.max(0, Math.min(offset, dst.byteLength));
+    const dstBytesAvailable = dst.byteLength - offset;
+    if (src.byteLength > dstBytesAvailable) {
+        src = src.subarray(0, dstBytesAvailable);
+    }
+    dst.set(src, offset);
+    return src.byteLength;
+}

package/{esm/deps/jsr.io/@std/fmt/1.0.6 → script/deps/jsr.io/@std/fmt/1.0.5}/colors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fmt/1.0.6/colors.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fmt/1.0.5/colors.ts"],"names":[],"mappings":"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"}

package/script/deps/jsr.io/@std/fs/{1.0.16 → 1.0.11}/exists.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.16/exists.ts"],"names":[],"mappings":"AAEA,iEAAiE;AACjE,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,CAAC,CAsClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAqCT"}
+{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.11/exists.ts"],"names":[],"mappings":"AAEA,iEAAiE;AACjE,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,CAAC,CAsClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAqCT"}

package/script/deps/jsr.io/@std/io/0.225.2/_common.d.ts

@@ -0,0 +1,3 @@
+import type { Closer } from "./types.js";
+export declare function isCloser(value: unknown): value is Closer;
+//# sourceMappingURL=_common.d.ts.map

package/script/deps/jsr.io/@std/io/0.225.2/_common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_common.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.2/_common.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAKxD"}

package/script/deps/jsr.io/@std/io/0.225.2/_common.js

@@ -0,0 +1,11 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCloser = isCloser;
+function isCloser(value) {
+    return typeof value === "object" && value !== null && value !== undefined &&
+        "close" in value &&
+        // deno-lint-ignore no-explicit-any
+        typeof value["close"] === "function";
+}

package/script/deps/jsr.io/@std/io/0.225.2/_constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_CHUNK_SIZE = 16640;
+export declare const DEFAULT_BUFFER_SIZE: number;
+//# sourceMappingURL=_constants.d.ts.map

package/script/deps/jsr.io/@std/io/0.225.2/_constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.2/_constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,eAAO,MAAM,mBAAmB,QAAY,CAAC"}

package/script/deps/jsr.io/@std/io/0.225.2/_constants.js

@@ -0,0 +1,7 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BUFFER_SIZE = exports.DEFAULT_CHUNK_SIZE = void 0;
+exports.DEFAULT_CHUNK_SIZE = 16_640;
+exports.DEFAULT_BUFFER_SIZE = 32 * 1024;

package/script/deps/jsr.io/@std/io/0.225.2/buffer.d.ts

@@ -0,0 +1,321 @@
+import type { Reader, ReaderSync, Writer, WriterSync } from "./types.js";
+/**
+ * A variable-sized buffer of bytes with `read()` and `write()` methods.
+ *
+ * Buffer is almost always used with some I/O like files and sockets. It allows
+ * one to buffer up a download from a socket. Buffer grows and shrinks as
+ * necessary.
+ *
+ * Buffer is NOT the same thing as Node's Buffer. Node's Buffer was created in
+ * 2009 before JavaScript had the concept of ArrayBuffers. It's simply a
+ * non-standard ArrayBuffer.
+ *
+ * ArrayBuffer is a fixed memory allocation. Buffer is implemented on top of
+ * ArrayBuffer.
+ *
+ * Based on {@link https://golang.org/pkg/bytes/#Buffer | Go Buffer}.
+ *
+ * @example Usage
+ * ```ts
+ * import { Buffer } from "@std/io/buffer";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * const buf = new Buffer();
+ * await buf.write(new TextEncoder().encode("Hello, "));
+ * await buf.write(new TextEncoder().encode("world!"));
+ *
+ * const data = new Uint8Array(13);
+ * await buf.read(data);
+ *
+ * assertEquals(new TextDecoder().decode(data), "Hello, world!");
+ * ```
+ */
+export declare class Buffer implements Writer, WriterSync, Reader, ReaderSync {
+    #private;
+    /**
+     * Constructs a new instance with the specified {@linkcode ArrayBuffer} as its
+     * initial contents.
+     *
+     * @param ab The ArrayBuffer to use as the initial contents of the buffer.
+     */
+    constructor(ab?: ArrayBufferLike | ArrayLike<number>);
+    /**
+     * Returns a slice holding the unread portion of the buffer.
+     *
+     * The slice is valid for use only until the next buffer modification (that
+     * is, only until the next call to a method like `read()`, `write()`,
+     * `reset()`, or `truncate()`). If `options.copy` is false the slice aliases the buffer content at
+     * least until the next buffer modification, so immediate changes to the
+     * slice will affect the result of future reads.
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * await buf.write(new TextEncoder().encode("Hello, world!"));
+     *
+     * const slice = buf.bytes();
+     * assertEquals(new TextDecoder().decode(slice), "Hello, world!");
+     * ```
+     *
+     * @param options The options for the slice.
+     * @returns A slice holding the unread portion of the buffer.
+     */
+    bytes(options?: {
+        copy: boolean;
+    }): Uint8Array;
+    /**
+     * Returns whether the unread portion of the buffer is empty.
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * assertEquals(buf.empty(), true);
+     * await buf.write(new TextEncoder().encode("Hello, world!"));
+     * assertEquals(buf.empty(), false);
+     * ```
+     *
+     * @returns `true` if the unread portion of the buffer is empty, `false`
+     *          otherwise.
+     */
+    empty(): boolean;
+    /**
+     * A read only number of bytes of the unread portion of the buffer.
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * await buf.write(new TextEncoder().encode("Hello, world!"));
+     *
+     * assertEquals(buf.length, 13);
+     * ```
+     *
+     * @returns The number of bytes of the unread portion of the buffer.
+     */
+    get length(): number;
+    /**
+     * The read only capacity of the buffer's underlying byte slice, that is,
+     * the total space allocated for the buffer's data.
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * assertEquals(buf.capacity, 0);
+     * await buf.write(new TextEncoder().encode("Hello, world!"));
+     * assertEquals(buf.capacity, 13);
+     * ```
+     *
+     * @returns The capacity of the buffer.
+     */
+    get capacity(): number;
+    /**
+     * Discards all but the first `n` unread bytes from the buffer but
+     * continues to use the same allocated storage. It throws if `n` is
+     * negative or greater than the length of the buffer.
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * await buf.write(new TextEncoder().encode("Hello, world!"));
+     * buf.truncate(6);
+     * assertEquals(buf.length, 6);
+     * ```
+     *
+     * @param n The number of bytes to keep.
+     */
+    truncate(n: number): void;
+    /**
+     * Resets the contents
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * await buf.write(new TextEncoder().encode("Hello, world!"));
+     * buf.reset();
+     * assertEquals(buf.length, 0);
+     * ```
+     */
+    reset(): void;
+    /**
+     * Reads the next `p.length` bytes from the buffer or until the buffer is
+     * drained. Returns the number of bytes read. If the buffer has no data to
+     * return, the return is EOF (`null`).
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * await buf.write(new TextEncoder().encode("Hello, world!"));
+     *
+     * const data = new Uint8Array(5);
+     * const res = await buf.read(data);
+     *
+     * assertEquals(res, 5);
+     * assertEquals(new TextDecoder().decode(data), "Hello");
+     * ```
+     *
+     * @param p The buffer to read data into.
+     * @returns The number of bytes read.
+     */
+    readSync(p: Uint8Array): number | null;
+    /**
+     * Reads the next `p.length` bytes from the buffer or until the buffer is
+     * drained. Resolves to the number of bytes read. If the buffer has no
+     * data to return, resolves to EOF (`null`).
+     *
+     * NOTE: This methods reads bytes synchronously; it's provided for
+     * compatibility with `Reader` interfaces.
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * await buf.write(new TextEncoder().encode("Hello, world!"));
+     *
+     * const data = new Uint8Array(5);
+     * const res = await buf.read(data);
+     *
+     * assertEquals(res, 5);
+     * assertEquals(new TextDecoder().decode(data), "Hello");
+     * ```
+     *
+     * @param p The buffer to read data into.
+     * @returns The number of bytes read.
+     */
+    read(p: Uint8Array): Promise<number | null>;
+    /**
+     * Writes the given data to the buffer.
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * const data = new TextEncoder().encode("Hello, world!");
+     * buf.writeSync(data);
+     *
+     * const slice = buf.bytes();
+     * assertEquals(new TextDecoder().decode(slice), "Hello, world!");
+     * ```
+     *
+     * @param p The data to write to the buffer.
+     * @returns The number of bytes written.
+     */
+    writeSync(p: Uint8Array): number;
+    /**
+     * Writes the given data to the buffer. Resolves to the number of bytes
+     * written.
+     *
+     * > [!NOTE]
+     * > This methods writes bytes synchronously; it's provided for compatibility
+     * > with the {@linkcode Writer} interface.
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * const data = new TextEncoder().encode("Hello, world!");
+     * await buf.write(data);
+     *
+     * const slice = buf.bytes();
+     * assertEquals(new TextDecoder().decode(slice), "Hello, world!");
+     * ```
+     *
+     * @param p The data to write to the buffer.
+     * @returns The number of bytes written.
+     */
+    write(p: Uint8Array): Promise<number>;
+    /** Grows the buffer's capacity, if necessary, to guarantee space for
+     * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to
+     * the buffer without another allocation. If `n` is negative, `.grow()` will
+     * throw. If the buffer can't grow it will throw an error.
+     *
+     * Based on Go Lang's
+     * {@link https://golang.org/pkg/bytes/#Buffer.Grow | Buffer.Grow}.
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * buf.grow(10);
+     * assertEquals(buf.capacity, 10);
+     * ```
+     *
+     * @param n The number of bytes to grow the buffer by.
+     */
+    grow(n: number): void;
+    /**
+     * Reads data from `r` until EOF (`null`) and appends it to the buffer,
+     * growing the buffer as needed. It resolves to the number of bytes read.
+     * If the buffer becomes too large, `.readFrom()` will reject with an error.
+     *
+     * Based on Go Lang's
+     * {@link https://golang.org/pkg/bytes/#Buffer.ReadFrom | Buffer.ReadFrom}.
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * const r = new Buffer(new TextEncoder().encode("Hello, world!"));
+     * const n = await buf.readFrom(r);
+     *
+     * assertEquals(n, 13);
+     * ```
+     *
+     * @param r The reader to read from.
+     * @returns The number of bytes read.
+     */
+    readFrom(r: Reader): Promise<number>;
+    /** Reads data from `r` until EOF (`null`) and appends it to the buffer,
+     * growing the buffer as needed. It returns the number of bytes read. If the
+     * buffer becomes too large, `.readFromSync()` will throw an error.
+     *
+     * Based on Go Lang's
+     * {@link https://golang.org/pkg/bytes/#Buffer.ReadFrom | Buffer.ReadFrom}.
+     *
+     * @example Usage
+     * ```ts
+     * import { Buffer } from "@std/io/buffer";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const buf = new Buffer();
+     * const r = new Buffer(new TextEncoder().encode("Hello, world!"));
+     * const n = buf.readFromSync(r);
+     *
+     * assertEquals(n, 13);
+     * ```
+     *
+     * @param r The reader to read from.
+     * @returns The number of bytes read.
+     */
+    readFromSync(r: ReaderSync): number;
+}
+//# sourceMappingURL=buffer.d.ts.map

package/script/deps/jsr.io/@std/io/0.225.2/buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.2/buffer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AASzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,MAAO,YAAW,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU;;IAInE;;;;;OAKG;gBACS,EAAE,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,MAAM,CAAC;IAWpD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,KAAK,CAAC,OAAO;;KAAiB,GAAG,UAAU;IAK3C;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,IAAI,OAAO;IAIhB;;;;;;;;;;;;;;;OAeG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM;IAWlB;;;;;;;;;;;;;OAaG;IACH,KAAK;IAqBL;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI;IAetC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,IAAI,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAK3C;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAS,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;IAKhC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAuCrC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM;IAQd;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAwB1C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,YAAY,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;CAuBpC"}