projen 0.99.73 → 0.99.75

package/node_modules/dax/esm/deps/jsr.io/@std/internal/1.0.14/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.14/diff.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD,2DAA2D;AAC3D,MAAM,WAAW,aAAa;IAC5B,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B;IAC3B,EAAE,EAAE,MAAM,CAAC;CACZ;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAanD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,aAAa,CAWvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,CAAC,EAAE,EACN,CAAC,EAAE,CAAC,EAAE,EACN,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,GACzB,KAAK,CAAC;IACP,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAiCD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,aAAa,EACrB,IAAI,CAAC,EAAE,aAAa,GACnB,aAAa,CAsBf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAwEvD"}

package/node_modules/dax/esm/deps/jsr.io/@std/internal/1.0.14/diff_str.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff_str.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.14/diff_str.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,YAAY,CAAC;AAGhE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAY/C;AAKD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,UAAQ,GAAG,MAAM,EAAE,CAiBnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,EACxB,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,GAC3B,UAAU,CAAC,MAAM,CAAC,EAAE,CAetB;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,EAAE,CAkDlE"}

package/node_modules/dax/esm/deps/jsr.io/@std/internal/1.0.14/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.14/format.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,SAAS,GAAG,CACtB,CAAC,EAAE,OAAO,EACV,OAAO,EAAE;IACP,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,KACE,MAAM,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAmBzC"}

package/node_modules/dax/esm/deps/jsr.io/@std/internal/1.0.14/os.d.ts

@@ -0,0 +1,3 @@
+/** Whether the current platform is Windows */
+export declare const isWindows: boolean;
+//# sourceMappingURL=os.d.ts.map

package/node_modules/dax/esm/deps/jsr.io/@std/internal/1.0.14/os.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"os.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.14/os.ts"],"names":[],"mappings":"AAKA,8CAA8C;AAC9C,eAAO,MAAM,SAAS,EAAE,OAAwB,CAAC"}

package/node_modules/dax/esm/deps/jsr.io/@std/internal/1.0.14/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.14/styles.ts"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE3C;AAWD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/node_modules/dax/esm/deps/jsr.io/@std/internal/1.0.14/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.14/types.ts"],"names":[],"mappings":"AAGA,kDAAkD;AAClD,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnD;;;GAGG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,iBAAiB,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAEvE;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IAChC,IAAI,EAAE,QAAQ,GAAG,YAAY,CAAC;IAC9B,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IACjC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;IAC1B,KAAK,EAAE,CAAC,CAAC;IACT,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;CAC3B,CAAC"}

package/node_modules/dax/esm/deps/jsr.io/@std/io/0.225.3/_common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_common.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.3/_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/node_modules/dax/esm/deps/jsr.io/@std/io/0.225.3/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/node_modules/dax/esm/deps/jsr.io/@std/io/0.225.3/buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.3/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"}

package/node_modules/dax/esm/deps/jsr.io/@std/io/0.225.3/reader_from_stream_reader.d.ts

@@ -0,0 +1,21 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+import type { Reader } from "./types.js";
+/**
+ * Create a {@linkcode Reader} from a {@linkcode ReadableStreamDefaultReader}.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { copy } from "@std/io/copy";
+ * import { readerFromStreamReader } from "@std/io/reader-from-stream-reader";
+ *
+ * const res = await fetch("https://deno.land");
+ *
+ * const reader = readerFromStreamReader(res.body!.getReader());
+ * await copy(reader, Deno.stdout);
+ * ```
+ *
+ * @param streamReader The stream reader to read from
+ * @returns The reader
+ */
+export declare function readerFromStreamReader(streamReader: dntShim.ReadableStreamDefaultReader<Uint8Array>): Reader;
+//# sourceMappingURL=reader_from_stream_reader.d.ts.map

package/node_modules/dax/esm/deps/jsr.io/@std/io/0.225.3/reader_from_stream_reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader_from_stream_reader.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.3/reader_from_stream_reader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAKxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,OAAO,CAAC,2BAA2B,CAAC,UAAU,CAAC,GAC5D,MAAM,CAiBR"}

package/node_modules/dax/esm/deps/jsr.io/@std/io/0.225.3/to_writable_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_writable_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.3/to_writable_stream.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,OAAO,MAAM,mCAAmC,CAAC;AAI7D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGzC,gDAAgD;AAEhD,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAyBpC"}

package/node_modules/dax/esm/deps/jsr.io/@std/io/0.225.3/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * An abstract interface which when implemented provides an interface to read
+ * bytes into an array buffer asynchronously.
+ */
+export interface Reader {
+    /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number of
+     * bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
+     * encountered. Even if `read()` resolves to `n` < `p.byteLength`, it may
+     * use all of `p` as scratch space during the call. If some data is
+     * available but not `p.byteLength` bytes, `read()` conventionally resolves
+     * to what is available instead of waiting for more.
+     *
+     * When `read()` encounters end-of-file condition, it resolves to EOF
+     * (`null`).
+     *
+     * When `read()` encounters an error, it rejects with an error.
+     *
+     * Callers should always process the `n` > `0` bytes returned before
+     * considering the EOF (`null`). Doing so correctly handles I/O errors that
+     * happen after reading some bytes and also both of the allowed EOF
+     * behaviors.
+     *
+     * Implementations should not retain a reference to `p`.
+     *
+     * Use
+     * {@linkcode @std/io/to-iterator.ts?s=toIterator}
+     * to turn a {@linkcode Reader} into an {@linkcode AsyncIterableIterator}.
+     */
+    read(p: Uint8Array): Promise<number | null>;
+}
+/**
+ * An abstract interface which when implemented provides an interface to read
+ * bytes into an array buffer synchronously.
+ */
+export interface ReaderSync {
+    /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number
+     * of bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
+     * encountered. Even if `read()` returns `n` < `p.byteLength`, it may use
+     * all of `p` as scratch space during the call. If some data is available
+     * but not `p.byteLength` bytes, `read()` conventionally returns what is
+     * available instead of waiting for more.
+     *
+     * When `readSync()` encounters end-of-file condition, it returns EOF
+     * (`null`).
+     *
+     * When `readSync()` encounters an error, it throws with an error.
+     *
+     * Callers should always process the `n` > `0` bytes returned before
+     * considering the EOF (`null`). Doing so correctly handles I/O errors that happen
+     * after reading some bytes and also both of the allowed EOF behaviors.
+     *
+     * Implementations should not retain a reference to `p`.
+     *
+     * Use
+     * {@linkcode @std/io/to-iterator.ts?s=toIteratorSync}
+     * to turn a {@linkcode ReaderSync} into an {@linkcode IterableIterator}.
+     */
+    readSync(p: Uint8Array): number | null;
+}
+/**
+ * An abstract interface which when implemented provides an interface to write
+ * bytes from an array buffer to a file/resource asynchronously.
+ */
+export interface Writer {
+    /** Writes `p.byteLength` bytes from `p` to the underlying data stream. It
+     * resolves to the number of bytes written from `p` (`0` <= `n` <=
+     * `p.byteLength`) or reject with the error encountered that caused the
+     * write to stop early. `write()` must reject with a non-null error if
+     * would resolve to `n` < `p.byteLength`. `write()` must not modify the
+     * slice data, even temporarily.
+     *
+     * Implementations should not retain a reference to `p`.
+     */
+    write(p: Uint8Array): Promise<number>;
+}
+/**
+ * An abstract interface which when implemented provides an interface to write
+ * bytes from an array buffer to a file/resource synchronously.
+ */
+export interface WriterSync {
+    /** Writes `p.byteLength` bytes from `p` to the underlying data
+     * stream. It returns the number of bytes written from `p` (`0` <= `n`
+     * <= `p.byteLength`) and any error encountered that caused the write to
+     * stop early. `writeSync()` must throw a non-null error if it returns `n` <
+     * `p.byteLength`. `writeSync()` must not modify the slice data, even
+     * temporarily.
+     *
+     * Implementations should not retain a reference to `p`.
+     */
+    writeSync(p: Uint8Array): number;
+}
+/**
+ * An abstract interface which when implemented provides an interface to close
+ * files/resources that were previously opened.
+ */
+export interface Closer {
+    /** Closes the resource, "freeing" the backing file/resource. */
+    close(): void;
+}
+/**
+ * A enum which defines the seek mode for IO related APIs that support
+ * seeking.
+ */
+export declare enum SeekMode {
+    Start = 0,
+    Current = 1,
+    End = 2
+}
+/**
+ * An abstract interface which when implemented provides an interface to seek
+ * within an open file/resource asynchronously.
+ */
+export interface Seeker {
+    /** Seek sets the offset for the next `read()` or `write()` to offset,
+     * interpreted according to `whence`: `Start` means relative to the
+     * start of the file, `Current` means relative to the current offset,
+     * and `End` means relative to the end. Seek resolves to the new offset
+     * relative to the start of the file.
+     *
+     * Seeking to an offset before the start of the file is an error. Seeking to
+     * any positive offset is legal, but the behavior of subsequent I/O
+     * operations on the underlying object is implementation-dependent.
+     *
+     * It resolves with the updated offset.
+     */
+    seek(offset: number | bigint, whence: SeekMode): Promise<number>;
+}
+/**
+ * An abstract interface which when implemented provides an interface to seek
+ * within an open file/resource synchronously.
+ */
+export interface SeekerSync {
+    /** Seek sets the offset for the next `readSync()` or `writeSync()` to
+     * offset, interpreted according to `whence`: `Start` means relative
+     * to the start of the file, `Current` means relative to the current
+     * offset, and `End` means relative to the end.
+     *
+     * Seeking to an offset before the start of the file is an error. Seeking to
+     * any positive offset is legal, but the behavior of subsequent I/O
+     * operations on the underlying object is implementation-dependent.
+     *
+     * It returns the updated offset.
+     */
+    seekSync(offset: number | bigint, whence: SeekMode): number;
+}
+//# sourceMappingURL=types.d.ts.map

package/node_modules/dax/esm/deps/jsr.io/@std/io/0.225.3/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.3/types.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,IAAI,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC7C;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAAC;CACxC;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;;;;OAQG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACvC;AACD;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;OAQG;IACH,SAAS,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,gEAAgE;IAChE,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;GAGG;AACH,oBAAY,QAAQ;IAElB,KAAK,IAAI;IAET,OAAO,IAAI;IAEX,GAAG,IAAI;CACR;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAClE;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;CAC7D"}

package/node_modules/dax/esm/deps/jsr.io/@std/io/0.225.3/write_all.d.ts

@@ -0,0 +1,52 @@
+import type { Writer, WriterSync } from "./types.js";
+export type { Writer, WriterSync } from "./types.js";
+/**
+ * Write all the content of the array buffer (`arr`) to the writer (`w`).
+ *
+ * @example Writing to stdout
+ * ```ts no-assert
+ * import { writeAll } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * await writeAll(Deno.stdout, contentBytes);
+ * ```
+ *
+ * @example Writing to file
+ * ```ts ignore no-assert
+ * import { writeAll } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * using file = await Deno.open('test.file', { write: true });
+ * await writeAll(file, contentBytes);
+ * ```
+ *
+ * @param writer The writer to write to
+ * @param data The data to write
+ */
+export declare function writeAll(writer: Writer, data: Uint8Array): Promise<void>;
+/**
+ * Synchronously write all the content of the array buffer (`arr`) to the
+ * writer (`w`).
+ *
+ * @example "riting to stdout
+ * ```ts no-assert
+ * import { writeAllSync } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * writeAllSync(Deno.stdout, contentBytes);
+ * ```
+ *
+ * @example Writing to file
+ * ```ts ignore no-assert
+ * import { writeAllSync } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * using file = Deno.openSync("test.file", { write: true });
+ * writeAllSync(file, contentBytes);
+ * ```
+ *
+ * @param writer The writer to write to
+ * @param data The data to write
+ */
+export declare function writeAllSync(writer: WriterSync, data: Uint8Array): void;
+//# sourceMappingURL=write_all.d.ts.map

package/node_modules/dax/esm/deps/jsr.io/@std/io/0.225.3/write_all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write_all.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.3/write_all.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,iBAK9D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,QAKhE"}

package/node_modules/dax/esm/deps/jsr.io/@std/path/1.1.5/_common/glob_to_reg_exp.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Options for {@linkcode globToRegExp}, {@linkcode joinGlobs},
+ * {@linkcode normalizeGlob} and {@linkcode expandGlob}.
+ */
+export interface GlobOptions {
+    /** Extended glob syntax.
+     * See https://www.linuxjournal.com/content/bash-extended-globbing.
+     *
+     * @default {true}
+     */
+    extended?: boolean;
+    /** Globstar syntax.
+     * See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
+     * If false, `**` is treated like `*`.
+     *
+     * @default {true}
+     */
+    globstar?: boolean;
+    /**
+     * Whether globstar should be case-insensitive.
+     *
+     * @default {false}
+     */
+    caseInsensitive?: boolean;
+}
+export interface GlobConstants {
+    sep: string;
+    sepMaybe: string;
+    seps: string[];
+    globstar: string;
+    wildcard: string;
+    escapePrefix: string;
+}
+export declare function _globToRegExp(c: GlobConstants, glob: string, { extended, globstar: globstarOption, caseInsensitive, }?: GlobOptions): RegExp;
+//# sourceMappingURL=glob_to_reg_exp.d.ts.map

package/node_modules/dax/esm/deps/jsr.io/@std/path/1.1.5/_common/glob_to_reg_exp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob_to_reg_exp.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.5/_common/glob_to_reg_exp.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAwBD,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,aAAa,CAC3B,CAAC,EAAE,aAAa,EAChB,IAAI,EAAE,MAAM,EACZ,EACE,QAAe,EACf,QAAQ,EAAE,cAAqB,EAE/B,eAAuB,GACxB,GAAE,WAAgB,GAClB,MAAM,CAiOR"}