@versori/run 0.1.0-alpha.8 → 0.2.0-alpha.1

package/script/deps/jsr.io/@nats-io/nuid/2.0.3/src/nuid.js

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2016-2024 The NATS Authors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nuid = exports.Nuid = void 0;
+const digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const base = 36;
+const preLen = 12;
+const seqLen = 10;
+const maxSeq = 3656158440062976; // base^seqLen == 36^10
+const minInc = 33;
+const maxInc = 333;
+const totalLen = preLen + seqLen;
+function _getRandomValues(a) {
+    for (let i = 0; i < a.length; i++) {
+        a[i] = Math.floor(Math.random() * 255);
+    }
+}
+function fillRandom(a) {
+    if (globalThis?.crypto?.getRandomValues) {
+        globalThis.crypto.getRandomValues(a);
+    }
+    else {
+        _getRandomValues(a);
+    }
+}
+/**
+ * Nuid is a class that generates unique identifiers.
+ */
+class Nuid {
+    constructor() {
+        /**
+         *   @hidden
+         */
+        Object.defineProperty(this, "buf", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         *   @hidden
+         */
+        Object.defineProperty(this, "seq", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * @hidden
+         */
+        Object.defineProperty(this, "inc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * @hidden
+         */
+        Object.defineProperty(this, "inited", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.buf = new Uint8Array(totalLen);
+        this.inited = false;
+    }
+    /**
+     * Initializes a nuid with a crypto random prefix,
+     * and pseudo-random sequence and increment. This function
+     * is only called if any api on a nuid is called.
+     *
+     * @ignore
+     */
+    init() {
+        this.inited = true;
+        this.setPre();
+        this.initSeqAndInc();
+        this.fillSeq();
+    }
+    /**
+     * Initializes the pseudo random sequence number and the increment range.
+     * @ignore
+     */
+    initSeqAndInc() {
+        this.seq = Math.floor(Math.random() * maxSeq);
+        this.inc = Math.floor(Math.random() * (maxInc - minInc) + minInc);
+    }
+    /**
+     * Sets the prefix from crypto random bytes. Converts them to base36.
+     *
+     * @ignore
+     */
+    setPre() {
+        const cbuf = new Uint8Array(preLen);
+        fillRandom(cbuf);
+        for (let i = 0; i < preLen; i++) {
+            const di = cbuf[i] % base;
+            this.buf[i] = digits.charCodeAt(di);
+        }
+    }
+    /**
+     * Fills the sequence part of the nuid as base36 from this.seq.
+     * @ignore
+     */
+    fillSeq() {
+        let n = this.seq;
+        for (let i = totalLen - 1; i >= preLen; i--) {
+            this.buf[i] = digits.charCodeAt(n % base);
+            n = Math.floor(n / base);
+        }
+    }
+    /**
+     * Returns the next nuid.
+     */
+    next() {
+        if (!this.inited) {
+            this.init();
+        }
+        this.seq += this.inc;
+        if (this.seq > maxSeq) {
+            this.setPre();
+            this.initSeqAndInc();
+        }
+        this.fillSeq();
+        // @ts-ignore - Uint8Arrays can be an argument
+        return String.fromCharCode.apply(String, this.buf);
+    }
+    /**
+     * Resets the prefix and counter for the nuid. This is typically
+     * called automatically from within next() if the current sequence
+     * exceeds the resolution of the nuid.
+     */
+    reset() {
+        this.init();
+    }
+}
+exports.Nuid = Nuid;
+/**
+ * A nuid instance you can use by simply calling `next()` on it.
+ */
+exports.nuid = new Nuid();

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

@@ -0,0 +1,3 @@
+import type { ConnectionOptions, NatsConnection } from "../../../nats-core/3.0.2/src/internal_mod.js";
+export declare function connect(opts?: ConnectionOptions): Promise<NatsConnection>;
+//# sourceMappingURL=connect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/connect.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EAGf,MAAM,8CAA8C,CAAC;AAStD,wBAAgB,OAAO,CAAC,IAAI,GAAE,iBAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAiB7E"}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = connect;
+/*
+ * Copyright 2020-2024 The NATS Authors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const deno_transport_js_1 = require("./deno_transport.js");
+const internal_mod_js_1 = require("../../../nats-core/3.0.2/src/internal_mod.js");
+function connect(opts = {}) {
+    if ((0, internal_mod_js_1.hasWsProtocol)(opts)) {
+        return Promise.reject(internal_mod_js_1.errors.InvalidArgumentError.format(`servers`, `deno client doesn't support websockets, use the 'wsconnect' function instead`));
+    }
+    (0, internal_mod_js_1.setTransportFactory)({
+        factory: () => {
+            return new deno_transport_js_1.DenoTransport();
+        },
+        dnsResolveFn: deno_transport_js_1.denoResolveHost,
+    });
+    return internal_mod_js_1.NatsConnectionImpl.connect(opts);
+}

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

@@ -0,0 +1,35 @@
+import type { ConnectionOptions, ServerInfo, Transport } from "../../../nats-core/3.0.2/src/internal_mod.js";
+export declare class DenoTransport implements Transport {
+    version: string;
+    lang: string;
+    closeError?: Error;
+    private options;
+    private buf;
+    private encrypted;
+    private done;
+    private closedNotification;
+    private conn;
+    private frames;
+    private pendingWrite;
+    constructor();
+    connect(hp: {
+        hostname: string;
+        port: number;
+        tlsName: string;
+    }, options: ConnectionOptions): Promise<void>;
+    get isClosed(): boolean;
+    peekInfo(): Promise<ServerInfo>;
+    loadTlsOptions(hostname: string): Promise<Deno.StartTlsOptions>;
+    startTLS(hostname: string): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Uint8Array>;
+    maybeWriteFrame(): void;
+    send(frame: Uint8Array): void;
+    isEncrypted(): boolean;
+    close(err?: Error): Promise<void>;
+    disconnect(): void;
+    _closed(err?: Error, internal?: boolean): Promise<void>;
+    closed(): Promise<void | Error>;
+    discard(): void;
+}
+export declare function denoResolveHost(s: string): Promise<string[]>;
+//# sourceMappingURL=deno_transport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deno_transport.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/deno_transport.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EACV,iBAAiB,EAEjB,UAAU,EAEV,SAAS,EACV,MAAM,8CAA8C,CAAC;AAUtD,qBAAa,aAAc,YAAW,SAAS;IAC7C,OAAO,EAAE,MAAM,CAAW;IAC1B,IAAI,EAAE,MAAM,CAAQ;IACpB,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,kBAAkB,CAAsC;IAChE,OAAO,CAAC,IAAI,CAA+B;IAC3C,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,YAAY,CAAuB;;IAQrC,OAAO,CACX,EAAE,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EACvD,OAAO,EAAE,iBAAiB;IA4C5B,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAEK,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;IAgC/B,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC;IAoB/D,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,qBAAqB,CAAC,UAAU,CAAC;IA2BlE,eAAe,IAAI,IAAI;IAuBvB,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAU7B,WAAW,IAAI,OAAO;IAItB,KAAK,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjC,UAAU;IAKJ,OAAO,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,QAAQ,UAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAyC1D,MAAM,IAAI,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC;IAI/B,OAAO;CAGR;AAED,wBAAsB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAelE"}

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

@@ -0,0 +1,333 @@
+"use strict";
+/*
+ * Copyright 2020-2024 The NATS Authors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DenoTransport = void 0;
+exports.denoResolveHost = denoResolveHost;
+const internal_mod_js_1 = require("../../../nats-core/3.0.2/src/internal_mod.js");
+const mod_js_1 = require("../../../../@std/io/0.225.2/mod.js");
+const version_js_1 = require("./version.js");
+const VERSION = version_js_1.version;
+const LANG = "nats.deno";
+const ReadBufferSize = 1024 * 256;
+class DenoTransport {
+    constructor() {
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: VERSION
+        });
+        Object.defineProperty(this, "lang", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: LANG
+        });
+        Object.defineProperty(this, "closeError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "buf", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "encrypted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "done", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "closedNotification", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (0, internal_mod_js_1.deferred)()
+        });
+        Object.defineProperty(this, "conn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "frames", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pendingWrite", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.buf = new Uint8Array(ReadBufferSize);
+        this.frames = [];
+        this.pendingWrite = null;
+    }
+    async connect(hp, options) {
+        this.options = options;
+        const { tls } = this.options;
+        const { handshakeFirst } = tls || {};
+        try {
+            if (handshakeFirst === true) {
+                const opts = await this.loadTlsOptions(hp.hostname);
+                const ctls = {
+                    caCerts: opts.caCerts,
+                    hostname: hp.hostname,
+                    port: hp.port,
+                };
+                this.conn = await Deno.connectTls(ctls);
+                this.encrypted = true;
+                // do nothing yet.
+            }
+            else {
+                this.conn = await Deno.connect(hp);
+            }
+            if (this.done) {
+                this.conn.close();
+            }
+            const info = await this.peekInfo();
+            (0, internal_mod_js_1.checkOptions)(info, this.options);
+            const { tls_required: tlsRequired, tls_available: tlsAvailable } = info;
+            const desired = tlsAvailable === true && options.tls !== null;
+            if (!handshakeFirst && (tlsRequired || desired)) {
+                const tlsn = hp.tlsName ? hp.tlsName : hp.hostname;
+                await this.startTLS(tlsn);
+            }
+            if (this.done) {
+                this.conn.close();
+            }
+        }
+        catch (err) {
+            this.conn?.close();
+            const _err = err;
+            throw new internal_mod_js_1.errors.ConnectionError(_err.message.toLowerCase(), {
+                cause: err,
+            });
+        }
+    }
+    get isClosed() {
+        return this.done;
+    }
+    async peekInfo() {
+        const inbound = new internal_mod_js_1.DataBuffer();
+        let pm;
+        while (true) {
+            const c = await this.conn.read(this.buf);
+            if (c === null) {
+                // EOF
+                throw new Error("socket closed while expecting INFO");
+            }
+            else if (c) {
+                const frame = this.buf.subarray(0, c);
+                if (this.options.debug) {
+                    console.info(`> ${(0, internal_mod_js_1.render)(frame)}`);
+                }
+                inbound.fill(frame);
+                const raw = inbound.peek();
+                pm = (0, internal_mod_js_1.extractProtocolMessage)(raw);
+                if (pm !== "") {
+                    break;
+                }
+            }
+        }
+        // reset the buffer to previously read, so the client
+        // can validate the info matches the connection
+        this.buf = new Uint8Array(inbound.drain());
+        // expecting the info protocol
+        const m = internal_mod_js_1.INFO.exec(pm);
+        if (!m) {
+            throw new Error("unexpected response from server");
+        }
+        return JSON.parse(m[1]);
+    }
+    async loadTlsOptions(hostname) {
+        const tls = this.options && this.options.tls
+            ? this.options.tls
+            : {};
+        // these options are not available in Deno
+        (0, internal_mod_js_1.checkUnsupportedOption)("tls.ca", tls.ca);
+        (0, internal_mod_js_1.checkUnsupportedOption)("tls.cert", tls.cert);
+        (0, internal_mod_js_1.checkUnsupportedOption)("tls.certFile", tls.certFile);
+        (0, internal_mod_js_1.checkUnsupportedOption)("tls.key", tls.key);
+        (0, internal_mod_js_1.checkUnsupportedOption)("tls.keyFile", tls.keyFile);
+        const sto = { hostname };
+        if (tls.caFile) {
+            const ca = await Deno.readTextFile(tls.caFile);
+            sto.caCerts = [ca];
+        }
+        return sto;
+    }
+    async startTLS(hostname) {
+        const sto = await (this.loadTlsOptions(hostname));
+        this.conn = await Deno.startTls(
+        //@ts-ignore: just the conn
+        this.conn, sto);
+        // this is necessary because the startTls process doesn't
+        // reject a bad certificate, however the next write will.
+        // to identify this as the error, we force it
+        await this.conn.write(internal_mod_js_1.Empty);
+        this.encrypted = true;
+    }
+    async *[Symbol.asyncIterator]() {
+        let reason;
+        // yield what we initially read
+        yield this.buf;
+        while (!this.done) {
+            try {
+                this.buf = new Uint8Array(ReadBufferSize);
+                const c = await this.conn.read(this.buf);
+                if (c === null) {
+                    break;
+                }
+                if (c) {
+                    const frame = this.buf.subarray(0, c);
+                    if (this.options.debug) {
+                        console.info(`> ${(0, internal_mod_js_1.render)(frame)}`);
+                    }
+                    yield frame;
+                }
+            }
+            catch (err) {
+                reason = err;
+                break;
+            }
+        }
+        this._closed(reason).then().catch();
+    }
+    maybeWriteFrame() {
+        if (this.pendingWrite) {
+            return;
+        }
+        const frame = this.frames.shift();
+        if (!frame) {
+            return;
+        }
+        this.pendingWrite = (0, mod_js_1.writeAll)(this.conn, frame).then(() => {
+            this.pendingWrite = null;
+            this.maybeWriteFrame();
+        }).then(() => {
+            if (this.options.debug) {
+                console.info(`< ${(0, internal_mod_js_1.render)(frame)}`);
+            }
+        }).catch((err) => {
+            if (this.options.debug) {
+                console.error(`!!! ${(0, internal_mod_js_1.render)(frame)}: ${err}`);
+            }
+        });
+    }
+    send(frame) {
+        // if we are closed, don't do anything
+        if (this.done) {
+            return;
+        }
+        // push the frame
+        this.frames.push(frame);
+        this.maybeWriteFrame();
+    }
+    isEncrypted() {
+        return this.encrypted;
+    }
+    close(err) {
+        return this._closed(err, false);
+    }
+    disconnect() {
+        this._closed(undefined, true)
+            .then().catch();
+    }
+    async _closed(err, internal = true) {
+        if (this.done) {
+            // it is possible for close to be called before the connection
+            // ever happens or after the protocol requested a close (async connection/upgrade)
+            // so even if we already cleaned up, attempt to close the connection
+            try {
+                this.conn?.close();
+            }
+            catch (_err) {
+                // ignored
+            }
+            return;
+        }
+        this.done = true;
+        this.closeError = err;
+        if (!err && internal) {
+            try {
+                // this is a noop but gives us a place to hang
+                // a close and ensure that we sent all before closing
+                // we wait for the operation to fail or succeed
+                this.frames.push(internal_mod_js_1.Empty);
+                this.maybeWriteFrame();
+                if (this.pendingWrite) {
+                    await this.pendingWrite;
+                }
+            }
+            catch (err) {
+                if (this.options.debug) {
+                    console.log("transport close terminated with an error", err);
+                }
+            }
+        }
+        try {
+            this.conn?.close();
+        }
+        catch (_err) {
+            // ignored
+        }
+        if (internal) {
+            this.closedNotification.resolve(err);
+        }
+    }
+    closed() {
+        return this.closedNotification;
+    }
+    discard() {
+        // ignored - this is not required, as there's no throttling
+    }
+}
+exports.DenoTransport = DenoTransport;
+async function denoResolveHost(s) {
+    const a = Deno.resolveDns(s, "A");
+    const aaaa = Deno.resolveDns(s, "AAAA");
+    const ips = [];
+    const w = await Promise.allSettled([a, aaaa]);
+    if (w[0].status === "fulfilled") {
+        ips.push(...w[0].value);
+    }
+    if (w[1].status === "fulfilled") {
+        ips.push(...w[1].value);
+    }
+    if (ips.length === 0) {
+        ips.push(s);
+    }
+    return ips;
+}

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

@@ -0,0 +1,3 @@
+export { connect } from "./connect.js";
+export * from "../../../nats-core/3.0.2/src/mod.js";
+//# sourceMappingURL=mod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/transport-deno/3.0.2/src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,cAAc,qCAAqC,CAAC"}

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"}