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

package/script/deps/jsr.io/@nats-io/nats-core/3.0.2/src/muxsubscription.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MuxSubscription = void 0;
+const core_js_1 = require("./core.js");
+const errors_js_1 = require("./errors.js");
+class MuxSubscription {
+    constructor() {
+        Object.defineProperty(this, "baseInbox", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reqs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.reqs = new Map();
+    }
+    size() {
+        return this.reqs.size;
+    }
+    init(prefix) {
+        this.baseInbox = `${(0, core_js_1.createInbox)(prefix)}.`;
+        return this.baseInbox;
+    }
+    add(r) {
+        if (!isNaN(r.received)) {
+            r.received = 0;
+        }
+        this.reqs.set(r.token, r);
+    }
+    get(token) {
+        return this.reqs.get(token);
+    }
+    cancel(r) {
+        this.reqs.delete(r.token);
+    }
+    getToken(m) {
+        const s = m.subject || "";
+        if (s.indexOf(this.baseInbox) === 0) {
+            return s.substring(this.baseInbox.length);
+        }
+        return null;
+    }
+    all() {
+        return Array.from(this.reqs.values());
+    }
+    handleError(isMuxPermissionError, err) {
+        if (isMuxPermissionError) {
+            // one or more requests queued but mux cannot process them
+            this.all().forEach((r) => {
+                r.resolver(err, {});
+            });
+            return true;
+        }
+        if (err.operation === "publish") {
+            const req = this.all().find((s) => {
+                return s.requestSubject === err.subject;
+            });
+            if (req) {
+                req.resolver(err, {});
+                return true;
+            }
+        }
+        return false;
+    }
+    dispatcher() {
+        return (err, m) => {
+            const token = this.getToken(m);
+            if (token) {
+                const r = this.get(token);
+                if (r) {
+                    if (err === null) {
+                        err = (m?.data?.length === 0 && m.headers?.code === 503)
+                            ? new errors_js_1.NoRespondersError(r.requestSubject)
+                            : null;
+                    }
+                    r.resolver(err, m);
+                }
+            }
+        };
+    }
+    close() {
+        const err = new errors_js_1.RequestError("connection closed");
+        this.reqs.forEach((req) => {
+            req.resolver(err, {});
+        });
+    }
+}
+exports.MuxSubscription = MuxSubscription;

package/script/deps/jsr.io/@nats-io/nats-core/3.0.2/src/nats.d.ts

@@ -0,0 +1,49 @@
+import { ProtocolHandler } from "./protocol.js";
+import type { Features, SemVer } from "./semver.js";
+import type { ConnectionClosedListener, ConnectionOptions, Context, Msg, NatsConnection, Payload, PublishOptions, QueuedIterator, RequestManyOptions, RequestOptions, ServerInfo, Stats, Status, Subscription, SubscriptionOptions } from "./core.js";
+export declare class NatsConnectionImpl implements NatsConnection {
+    options: ConnectionOptions;
+    protocol: ProtocolHandler;
+    draining: boolean;
+    closeListeners?: CloseListeners;
+    private constructor();
+    static connect(opts?: ConnectionOptions): Promise<NatsConnection>;
+    closed(): Promise<void | Error>;
+    close(): Promise<void>;
+    _check(subject: string, sub: boolean, pub: boolean): void;
+    publish(subject: string, data?: Payload, options?: PublishOptions): void;
+    publishMessage(msg: Msg): void;
+    respondMessage(msg: Msg): boolean;
+    subscribe(subject: string, opts?: SubscriptionOptions): Subscription;
+    _resub(s: Subscription, subject: string, max?: number): void;
+    requestMany(subject: string, data?: Payload, opts?: Partial<RequestManyOptions>): Promise<QueuedIterator<Msg>>;
+    request(subject: string, data?: Payload, opts?: RequestOptions): Promise<Msg>;
+    /** *
+     * Flushes to the server. Promise resolves when round-trip completes.
+     * @returns {Promise<void>}
+     */
+    flush(): Promise<void>;
+    drain(): Promise<void>;
+    isClosed(): boolean;
+    isDraining(): boolean;
+    getServer(): string;
+    status(): AsyncIterable<Status>;
+    get info(): ServerInfo | undefined;
+    context(): Promise<Context>;
+    stats(): Stats;
+    getServerVersion(): SemVer | undefined;
+    rtt(): Promise<number>;
+    get features(): Features;
+    reconnect(): Promise<void>;
+    addCloseListener(listener: ConnectionClosedListener): void;
+    removeCloseListener(listener: ConnectionClosedListener): void;
+}
+declare class CloseListeners {
+    listeners: ConnectionClosedListener[];
+    constructor(closed: Promise<void | Error>);
+    add(listener: ConnectionClosedListener): void;
+    remove(listener: ConnectionClosedListener): void;
+    notify(err: void | Error): void;
+}
+export {};
+//# sourceMappingURL=nats.d.ts.map

package/script/deps/jsr.io/@nats-io/nats-core/3.0.2/src/nats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nats.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nats-core/3.0.2/src/nats.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,eAAe,EAAoB,MAAM,eAAe,CAAC;AAGlE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAQpD,OAAO,KAAK,EACV,wBAAwB,EACxB,iBAAiB,EACjB,OAAO,EACP,GAAG,EACH,cAAc,EACd,OAAO,EACP,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,UAAU,EACV,KAAK,EACL,MAAM,EACN,YAAY,EACZ,mBAAmB,EACpB,MAAM,WAAW,CAAC;AAInB,qBAAa,kBAAmB,YAAW,cAAc;IACvD,OAAO,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,EAAG,eAAe,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,cAAc,CAAC;IAEhC,OAAO;WAKO,OAAO,CAAC,IAAI,GAAE,iBAAsB,GAAG,OAAO,CAAC,cAAc,CAAC;IAc5E,MAAM,IAAI,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC;IAIzB,KAAK;IAIX,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO;IAgBlD,OAAO,CACL,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,cAAc,GACvB,IAAI;IAQP,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI;IAO9B,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO;IAWjC,SAAS,CACP,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,mBAAwB,GAC7B,YAAY;IAiBf,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IA2BrD,WAAW,CACT,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,OAAe,EACrB,IAAI,GAAE,OAAO,CAAC,kBAAkB,CAAsC,GACrE,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;IAoK/B,OAAO,CACL,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,OAAO,EACd,IAAI,GAAE,cAAgD,GACrD,OAAO,CAAC,GAAG,CAAC;IA6Ff;;;OAGG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAWtB,QAAQ,IAAI,OAAO;IAInB,UAAU,IAAI,OAAO;IAIrB,SAAS,IAAI,MAAM;IAKnB,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC;IAY/B,IAAI,IAAI,IAAI,UAAU,GAAG,SAAS,CAEjC;IAEK,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAUjC,KAAK,IAAI,KAAK;IASd,gBAAgB,IAAI,MAAM,GAAG,SAAS;IAKhC,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC;IAY5B,IAAI,QAAQ,IAAI,QAAQ,CAEvB;IAED,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAW1B,gBAAgB,CAAC,QAAQ,EAAE,wBAAwB;IAOnD,mBAAmB,CAAC,QAAQ,EAAE,wBAAwB;CAKvD;AAED,cAAM,cAAc;IAClB,SAAS,EAAE,wBAAwB,EAAE,CAAC;gBAE1B,MAAM,EAAE,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC;IAOzC,GAAG,CAAC,QAAQ,EAAE,wBAAwB;IAItC,MAAM,CAAC,QAAQ,EAAE,wBAAwB;IAIzC,MAAM,CAAC,GAAG,EAAE,IAAI,GAAG,KAAK;CAYzB"}

package/script/deps/jsr.io/@nats-io/nats-core/3.0.2/src/nats.js

@@ -0,0 +1,508 @@
+"use strict";
+/*
+ * Copyright 2018-2023 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.NatsConnectionImpl = void 0;
+const util_js_1 = require("./util.js");
+const protocol_js_1 = require("./protocol.js");
+const encoders_js_1 = require("./encoders.js");
+const semver_js_1 = require("./semver.js");
+const options_js_1 = require("./options.js");
+const queued_iterator_js_1 = require("./queued_iterator.js");
+const request_js_1 = require("./request.js");
+const core_js_1 = require("./core.js");
+const errors_js_1 = require("./errors.js");
+class NatsConnectionImpl {
+    constructor(opts) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "protocol", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "draining", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closeListeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.draining = false;
+        this.options = (0, options_js_1.parseOptions)(opts);
+    }
+    static connect(opts = {}) {
+        return new Promise((resolve, reject) => {
+            const nc = new NatsConnectionImpl(opts);
+            protocol_js_1.ProtocolHandler.connect(nc.options, nc)
+                .then((ph) => {
+                nc.protocol = ph;
+                resolve(nc);
+            })
+                .catch((err) => {
+                reject(err);
+            });
+        });
+    }
+    closed() {
+        return this.protocol.closed;
+    }
+    async close() {
+        await this.protocol.close();
+    }
+    _check(subject, sub, pub) {
+        if (this.isClosed()) {
+            throw new errors_js_1.errors.ClosedConnectionError();
+        }
+        if (sub && this.isDraining()) {
+            throw new errors_js_1.errors.DrainingConnectionError();
+        }
+        if (pub && this.protocol.noMorePublishing) {
+            throw new errors_js_1.errors.DrainingConnectionError();
+        }
+        subject = subject || "";
+        if (subject.length === 0) {
+            throw new errors_js_1.errors.InvalidSubjectError(subject);
+        }
+    }
+    publish(subject, data, options) {
+        this._check(subject, false, true);
+        if (options?.reply) {
+            this._check(options.reply, false, true);
+        }
+        this.protocol.publish(subject, data, options);
+    }
+    publishMessage(msg) {
+        return this.publish(msg.subject, msg.data, {
+            reply: msg.reply,
+            headers: msg.headers,
+        });
+    }
+    respondMessage(msg) {
+        if (msg.reply) {
+            this.publish(msg.reply, msg.data, {
+                reply: msg.reply,
+                headers: msg.headers,
+            });
+            return true;
+        }
+        return false;
+    }
+    subscribe(subject, opts = {}) {
+        this._check(subject, true, false);
+        const sub = new protocol_js_1.SubscriptionImpl(this.protocol, subject, opts);
+        if (typeof opts.callback !== "function" && typeof opts.slow === "number") {
+            sub.setSlowNotificationFn(opts.slow, (pending) => {
+                this.protocol.dispatchStatus({
+                    type: "slowConsumer",
+                    sub,
+                    pending,
+                });
+            });
+        }
+        this.protocol.subscribe(sub);
+        return sub;
+    }
+    _resub(s, subject, max) {
+        this._check(subject, true, false);
+        const si = s;
+        // FIXME: need way of understanding a callbacks processed
+        //   count without it, we cannot really do much - ie
+        //   for rejected messages, the count would be lower, etc.
+        //   To handle cases were for example KV is building a map
+        //   the consumer would say how many messages we need to do
+        //   a proper build before we can handle updates.
+        si.max = max; // this might clear it
+        if (max) {
+            // we cannot auto-unsub, because we don't know the
+            // number of messages we processed vs received
+            // allow the auto-unsub on processMsg to work if they
+            // we were called with a new max
+            si.max = max + si.received;
+        }
+        this.protocol.resub(si, subject);
+    }
+    // possibilities are:
+    // stop on error or any non-100 status
+    // AND:
+    // - wait for timer
+    // - wait for n messages or timer
+    // - wait for unknown messages, done when empty or reset timer expires (with possible alt wait)
+    // - wait for unknown messages, done when an empty payload is received or timer expires (with possible alt wait)
+    requestMany(subject, data = encoders_js_1.Empty, opts = { maxWait: 1000, maxMessages: -1 }) {
+        const asyncTraces = !(this.protocol.options.noAsyncTraces || false);
+        try {
+            this._check(subject, true, true);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+        opts.strategy = opts.strategy || "timer";
+        opts.maxWait = opts.maxWait || 1000;
+        if (opts.maxWait < 1) {
+            return Promise.reject(errors_js_1.InvalidArgumentError.format("timeout", "must be greater than 0"));
+        }
+        // the iterator for user results
+        const qi = new queued_iterator_js_1.QueuedIteratorImpl();
+        function stop(err) {
+            qi.push(() => {
+                qi.stop(err);
+            });
+        }
+        // callback for the subscription or the mux handler
+        // simply pushes errors and messages into the iterator
+        function callback(err, msg) {
+            if (err || msg === null) {
+                stop(err === null ? undefined : err);
+            }
+            else {
+                qi.push(msg);
+            }
+        }
+        if (opts.noMux) {
+            // we setup a subscription and manage it
+            const stack = asyncTraces ? new Error().stack : null;
+            let max = typeof opts.maxMessages === "number" && opts.maxMessages > 0
+                ? opts.maxMessages
+                : -1;
+            const sub = this.subscribe((0, core_js_1.createInbox)(this.options.inboxPrefix), {
+                callback: (err, msg) => {
+                    // we only expect runtime errors or a no responders
+                    if (msg?.data?.length === 0 &&
+                        msg?.headers?.status === "503") {
+                        err = new errors_js_1.errors.NoRespondersError(subject);
+                    }
+                    // augment any error with the current stack to provide context
+                    // for the error on the suer code
+                    if (err) {
+                        if (stack) {
+                            err.stack += `\n\n${stack}`;
+                        }
+                        cancel(err);
+                        return;
+                    }
+                    // push the message
+                    callback(null, msg);
+                    // see if the m request is completed
+                    if (opts.strategy === "count") {
+                        max--;
+                        if (max === 0) {
+                            cancel();
+                        }
+                    }
+                    if (opts.strategy === "stall") {
+                        clearTimers();
+                        timer = setTimeout(() => {
+                            cancel();
+                        }, 300);
+                    }
+                    if (opts.strategy === "sentinel") {
+                        if (msg && msg.data.length === 0) {
+                            cancel();
+                        }
+                    }
+                },
+            });
+            sub.requestSubject = subject;
+            sub.closed
+                .then(() => {
+                stop();
+            })
+                .catch((err) => {
+                qi.stop(err);
+            });
+            const cancel = (err) => {
+                if (err) {
+                    qi.push(() => {
+                        throw err;
+                    });
+                }
+                clearTimers();
+                sub.drain()
+                    .then(() => {
+                    stop();
+                })
+                    .catch((_err) => {
+                    stop();
+                });
+            };
+            qi.iterClosed
+                .then(() => {
+                clearTimers();
+                sub?.unsubscribe();
+            })
+                .catch((_err) => {
+                clearTimers();
+                sub?.unsubscribe();
+            });
+            try {
+                this.publish(subject, data, { reply: sub.getSubject() });
+            }
+            catch (err) {
+                cancel(err);
+            }
+            let timer = setTimeout(() => {
+                cancel();
+            }, opts.maxWait);
+            const clearTimers = () => {
+                if (timer) {
+                    clearTimeout(timer);
+                }
+            };
+        }
+        else {
+            // the ingestion is the RequestMany
+            const rmo = opts;
+            rmo.callback = callback;
+            qi.iterClosed.then(() => {
+                r.cancel();
+            }).catch((err) => {
+                r.cancel(err);
+            });
+            const r = new request_js_1.RequestMany(this.protocol.muxSubscriptions, subject, rmo);
+            this.protocol.request(r);
+            try {
+                this.publish(subject, data, {
+                    reply: `${this.protocol.muxSubscriptions.baseInbox}${r.token}`,
+                    headers: opts.headers,
+                });
+            }
+            catch (err) {
+                r.cancel(err);
+            }
+        }
+        return Promise.resolve(qi);
+    }
+    request(subject, data, opts = { timeout: 1000, noMux: false }) {
+        try {
+            this._check(subject, true, true);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+        const asyncTraces = !(this.protocol.options.noAsyncTraces || false);
+        opts.timeout = opts.timeout || 1000;
+        if (opts.timeout < 1) {
+            return Promise.reject(errors_js_1.InvalidArgumentError.format("timeout", `must be greater than 0`));
+        }
+        if (!opts.noMux && opts.reply) {
+            return Promise.reject(errors_js_1.InvalidArgumentError.format(["reply", "noMux"], "are mutually exclusive"));
+        }
+        if (opts.noMux) {
+            const inbox = opts.reply
+                ? opts.reply
+                : (0, core_js_1.createInbox)(this.options.inboxPrefix);
+            const d = (0, util_js_1.deferred)();
+            const errCtx = asyncTraces ? new errors_js_1.errors.RequestError("") : null;
+            const sub = this.subscribe(inbox, {
+                max: 1,
+                timeout: opts.timeout,
+                callback: (err, msg) => {
+                    // check for no responders status
+                    if (msg && msg.data?.length === 0 && msg.headers?.code === 503) {
+                        err = new errors_js_1.errors.NoRespondersError(subject);
+                    }
+                    if (err) {
+                        // we have a proper stack on timeout
+                        if (!(err instanceof errors_js_1.TimeoutError)) {
+                            if (errCtx) {
+                                errCtx.message = err.message;
+                                errCtx.cause = err;
+                                err = errCtx;
+                            }
+                            else {
+                                err = new errors_js_1.errors.RequestError(err.message, { cause: err });
+                            }
+                        }
+                        d.reject(err);
+                        sub.unsubscribe();
+                    }
+                    else {
+                        d.resolve(msg);
+                    }
+                },
+            });
+            sub.requestSubject = subject;
+            this.protocol.publish(subject, data, {
+                reply: inbox,
+                headers: opts.headers,
+            });
+            return d;
+        }
+        else {
+            const r = new request_js_1.RequestOne(this.protocol.muxSubscriptions, subject, opts, asyncTraces);
+            this.protocol.request(r);
+            try {
+                this.publish(subject, data, {
+                    reply: `${this.protocol.muxSubscriptions.baseInbox}${r.token}`,
+                    headers: opts.headers,
+                });
+            }
+            catch (err) {
+                r.cancel(err);
+            }
+            const p = Promise.race([r.timer, r.deferred]);
+            p.catch(() => {
+                r.cancel();
+            });
+            return p;
+        }
+    }
+    /** *
+     * Flushes to the server. Promise resolves when round-trip completes.
+     * @returns {Promise<void>}
+     */
+    flush() {
+        if (this.isClosed()) {
+            return Promise.reject(new errors_js_1.errors.ClosedConnectionError());
+        }
+        return this.protocol.flush();
+    }
+    drain() {
+        if (this.isClosed()) {
+            return Promise.reject(new errors_js_1.errors.ClosedConnectionError());
+        }
+        if (this.isDraining()) {
+            return Promise.reject(new errors_js_1.errors.DrainingConnectionError());
+        }
+        this.draining = true;
+        return this.protocol.drain();
+    }
+    isClosed() {
+        return this.protocol.isClosed();
+    }
+    isDraining() {
+        return this.draining;
+    }
+    getServer() {
+        const srv = this.protocol.getServer();
+        return srv ? srv.listen : "";
+    }
+    status() {
+        const iter = new queued_iterator_js_1.QueuedIteratorImpl();
+        iter.iterClosed.then(() => {
+            const idx = this.protocol.listeners.indexOf(iter);
+            if (idx > -1) {
+                this.protocol.listeners.splice(idx, 1);
+            }
+        });
+        this.protocol.listeners.push(iter);
+        return iter;
+    }
+    get info() {
+        return this.protocol.isClosed() ? undefined : this.protocol.info;
+    }
+    async context() {
+        const r = await this.request(`$SYS.REQ.USER.INFO`);
+        return r.json((key, value) => {
+            if (key === "time") {
+                return new Date(Date.parse(value));
+            }
+            return value;
+        });
+    }
+    stats() {
+        return {
+            inBytes: this.protocol.inBytes,
+            outBytes: this.protocol.outBytes,
+            inMsgs: this.protocol.inMsgs,
+            outMsgs: this.protocol.outMsgs,
+        };
+    }
+    getServerVersion() {
+        const info = this.info;
+        return info ? (0, semver_js_1.parseSemVer)(info.version) : undefined;
+    }
+    async rtt() {
+        if (this.isClosed()) {
+            throw new errors_js_1.errors.ClosedConnectionError();
+        }
+        if (!this.protocol.connected) {
+            throw new errors_js_1.errors.RequestError("connection disconnected");
+        }
+        const start = Date.now();
+        await this.flush();
+        return Date.now() - start;
+    }
+    get features() {
+        return this.protocol.features;
+    }
+    reconnect() {
+        if (this.isClosed()) {
+            return Promise.reject(new errors_js_1.errors.ClosedConnectionError());
+        }
+        if (this.isDraining()) {
+            return Promise.reject(new errors_js_1.errors.DrainingConnectionError());
+        }
+        return this.protocol.reconnect();
+    }
+    // internal
+    addCloseListener(listener) {
+        if (this.closeListeners === undefined) {
+            this.closeListeners = new CloseListeners(this.closed());
+        }
+        this.closeListeners.add(listener);
+    }
+    // internal
+    removeCloseListener(listener) {
+        if (this.closeListeners) {
+            this.closeListeners.remove(listener);
+        }
+    }
+}
+exports.NatsConnectionImpl = NatsConnectionImpl;
+class CloseListeners {
+    constructor(closed) {
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.listeners = [];
+        closed.then((err) => {
+            this.notify(err);
+        });
+    }
+    add(listener) {
+        this.listeners.push(listener);
+    }
+    remove(listener) {
+        this.listeners = this.listeners.filter((l) => l !== listener);
+    }
+    notify(err) {
+        this.listeners.forEach((l) => {
+            if (typeof l.connectionClosedCallback === "function") {
+                try {
+                    l.connectionClosedCallback(err);
+                }
+                catch (_) {
+                    // ignored
+                }
+            }
+        });
+        this.listeners = [];
+    }
+}

package/script/deps/jsr.io/@nats-io/nats-core/3.0.2/src/nkeys.d.ts

@@ -0,0 +1,2 @@
+export * as nkeys from "../../../nkeys/2.0.3/src/mod.js";
+//# sourceMappingURL=nkeys.d.ts.map

package/script/deps/jsr.io/@nats-io/nats-core/3.0.2/src/nkeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nkeys.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nats-core/3.0.2/src/nkeys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,iCAAiC,CAAC"}

package/script/deps/jsr.io/@nats-io/nats-core/3.0.2/src/nkeys.js

@@ -0,0 +1,27 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nkeys = void 0;
+exports.nkeys = __importStar(require("../../../nkeys/2.0.3/src/mod.js"));

package/script/deps/jsr.io/@nats-io/nats-core/3.0.2/src/nuid.d.ts

@@ -0,0 +1,2 @@
+export { Nuid, nuid } from "../../../nuid/2.0.3/src/nuid.js";
+//# sourceMappingURL=nuid.d.ts.map