@versori/run 0.0.1-alpha.7 → 0.1.0-alpha.10

package/esm/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/esm/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/esm/deps/jsr.io/@std/bytes/1.0.5/copy.js

@@ -0,0 +1,50 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * 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 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/{script/deps/jsr.io/@std/fs/1.0.15 → esm/deps/jsr.io/@std/fs/1.0.16}/exists.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.15/exists.ts"],"names":[],"mappings":"AAKA,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.16/exists.ts"],"names":[],"mappings":"AAKA,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/esm/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/esm/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/esm/deps/jsr.io/@std/io/0.225.2/_common.js

@@ -0,0 +1,8 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+export 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/esm/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/esm/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/esm/deps/jsr.io/@std/io/0.225.2/_constants.js

@@ -0,0 +1,4 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+export const DEFAULT_CHUNK_SIZE = 16_640;
+export const DEFAULT_BUFFER_SIZE = 32 * 1024;

package/esm/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/esm/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"}