@versori/run 0.1.0-alpha.8 → 0.1.0-alpha.9

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

@@ -0,0 +1,294 @@
+"use strict";
+/*
+ * Copyright 2020-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.MsgHdrsImpl = void 0;
+exports.canonicalMIMEHeaderKey = canonicalMIMEHeaderKey;
+exports.headers = headers;
+// Heavily inspired by Golang's https://golang.org/src/net/http/header.go
+const encoders_js_1 = require("./encoders.js");
+const core_js_1 = require("./core.js");
+const errors_js_1 = require("./errors.js");
+// https://www.ietf.org/rfc/rfc822.txt
+// 3.1.2.  STRUCTURE OF HEADER FIELDS
+//
+// Once a field has been unfolded, it may be viewed as being com-
+// posed of a field-name followed by a colon (":"), followed by a
+// field-body, and  terminated  by  a  carriage-return/line-feed.
+// The  field-name must be composed of printable ASCII characters
+// (i.e., characters that  have  values  between  33.  and  126.,
+// decimal, except colon).  The field-body may be composed of any
+// ASCII characters, except CR or LF.  (While CR and/or LF may be
+// present  in the actual text, they are removed by the action of
+// unfolding the field.)
+function canonicalMIMEHeaderKey(k) {
+    const a = 97;
+    const A = 65;
+    const Z = 90;
+    const z = 122;
+    const dash = 45;
+    const colon = 58;
+    const start = 33;
+    const end = 126;
+    const toLower = a - A;
+    let upper = true;
+    const buf = new Array(k.length);
+    for (let i = 0; i < k.length; i++) {
+        let c = k.charCodeAt(i);
+        if (c === colon || c < start || c > end) {
+            throw errors_js_1.InvalidArgumentError.format("header", `'${k[i]}' is not a valid character in a header name`);
+        }
+        if (upper && a <= c && c <= z) {
+            c -= toLower;
+        }
+        else if (!upper && A <= c && c <= Z) {
+            c += toLower;
+        }
+        buf[i] = c;
+        upper = c == dash;
+    }
+    return String.fromCharCode(...buf);
+}
+function headers(code = 0, description = "") {
+    if ((code === 0 && description !== "") || (code > 0 && description === "")) {
+        throw errors_js_1.InvalidArgumentError.format("description", "is required");
+    }
+    return new MsgHdrsImpl(code, description);
+}
+const HEADER = "NATS/1.0";
+class MsgHdrsImpl {
+    constructor(code = 0, description = "") {
+        Object.defineProperty(this, "_code", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "headers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._code = code;
+        this._description = description;
+        this.headers = new Map();
+    }
+    [Symbol.iterator]() {
+        return this.headers.entries();
+    }
+    size() {
+        return this.headers.size;
+    }
+    equals(mh) {
+        if (mh && this.headers.size === mh.headers.size &&
+            this._code === mh._code) {
+            for (const [k, v] of this.headers) {
+                const a = mh.values(k);
+                if (v.length !== a.length) {
+                    return false;
+                }
+                const vv = [...v].sort();
+                const aa = [...a].sort();
+                for (let i = 0; i < vv.length; i++) {
+                    if (vv[i] !== aa[i]) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    static decode(a) {
+        const mh = new MsgHdrsImpl();
+        const s = encoders_js_1.TD.decode(a);
+        const lines = s.split("\r\n");
+        const h = lines[0];
+        if (h !== HEADER) {
+            // malformed headers could add extra space without adding a code or description
+            let str = h.replace(HEADER, "").trim();
+            if (str.length > 0) {
+                mh._code = parseInt(str, 10);
+                if (isNaN(mh._code)) {
+                    mh._code = 0;
+                }
+                const scode = mh._code.toString();
+                str = str.replace(scode, "");
+                mh._description = str.trim();
+            }
+        }
+        if (lines.length >= 1) {
+            lines.slice(1).map((s) => {
+                if (s) {
+                    const idx = s.indexOf(":");
+                    if (idx > -1) {
+                        const k = s.slice(0, idx);
+                        const v = s.slice(idx + 1).trim();
+                        mh.append(k, v);
+                    }
+                }
+            });
+        }
+        return mh;
+    }
+    toString() {
+        if (this.headers.size === 0 && this._code === 0) {
+            return "";
+        }
+        let s = HEADER;
+        if (this._code > 0 && this._description !== "") {
+            s += ` ${this._code} ${this._description}`;
+        }
+        for (const [k, v] of this.headers) {
+            for (let i = 0; i < v.length; i++) {
+                s = `${s}\r\n${k}: ${v[i]}`;
+            }
+        }
+        return `${s}\r\n\r\n`;
+    }
+    encode() {
+        return encoders_js_1.TE.encode(this.toString());
+    }
+    static validHeaderValue(k) {
+        const inv = /[\r\n]/;
+        if (inv.test(k)) {
+            throw errors_js_1.InvalidArgumentError.format("header", "values cannot contain \\r or \\n");
+        }
+        return k.trim();
+    }
+    keys() {
+        const keys = [];
+        for (const sk of this.headers.keys()) {
+            keys.push(sk);
+        }
+        return keys;
+    }
+    findKeys(k, match = core_js_1.Match.Exact) {
+        const keys = this.keys();
+        switch (match) {
+            case core_js_1.Match.Exact:
+                return keys.filter((v) => {
+                    return v === k;
+                });
+            case core_js_1.Match.CanonicalMIME:
+                k = canonicalMIMEHeaderKey(k);
+                return keys.filter((v) => {
+                    return v === k;
+                });
+            default: {
+                const lci = k.toLowerCase();
+                return keys.filter((v) => {
+                    return lci === v.toLowerCase();
+                });
+            }
+        }
+    }
+    get(k, match = core_js_1.Match.Exact) {
+        const keys = this.findKeys(k, match);
+        if (keys.length) {
+            const v = this.headers.get(keys[0]);
+            if (v) {
+                return Array.isArray(v) ? v[0] : v;
+            }
+        }
+        return "";
+    }
+    last(k, match = core_js_1.Match.Exact) {
+        const keys = this.findKeys(k, match);
+        if (keys.length) {
+            const v = this.headers.get(keys[0]);
+            if (v) {
+                return Array.isArray(v) ? v[v.length - 1] : v;
+            }
+        }
+        return "";
+    }
+    has(k, match = core_js_1.Match.Exact) {
+        return this.findKeys(k, match).length > 0;
+    }
+    set(k, v, match = core_js_1.Match.Exact) {
+        this.delete(k, match);
+        this.append(k, v, match);
+    }
+    append(k, v, match = core_js_1.Match.Exact) {
+        // validate the key
+        const ck = canonicalMIMEHeaderKey(k);
+        if (match === core_js_1.Match.CanonicalMIME) {
+            k = ck;
+        }
+        // if we get non-sensical ignores/etc, we should try
+        // to do the right thing and use the first key that matches
+        const keys = this.findKeys(k, match);
+        k = keys.length > 0 ? keys[0] : k;
+        const value = MsgHdrsImpl.validHeaderValue(v);
+        let a = this.headers.get(k);
+        if (!a) {
+            a = [];
+            this.headers.set(k, a);
+        }
+        a.push(value);
+    }
+    values(k, match = core_js_1.Match.Exact) {
+        const buf = [];
+        const keys = this.findKeys(k, match);
+        keys.forEach((v) => {
+            const values = this.headers.get(v);
+            if (values) {
+                buf.push(...values);
+            }
+        });
+        return buf;
+    }
+    delete(k, match = core_js_1.Match.Exact) {
+        const keys = this.findKeys(k, match);
+        keys.forEach((v) => {
+            this.headers.delete(v);
+        });
+    }
+    get hasError() {
+        return this._code >= 300;
+    }
+    get status() {
+        return `${this._code} ${this._description}`.trim();
+    }
+    toRecord() {
+        const data = {};
+        this.keys().forEach((v) => {
+            data[v] = this.values(v);
+        });
+        return data;
+    }
+    get code() {
+        return this._code;
+    }
+    get description() {
+        return this._description;
+    }
+    static fromRecord(r) {
+        const h = new MsgHdrsImpl();
+        for (const k in r) {
+            h.headers.set(k, r[k]);
+        }
+        return h;
+    }
+}
+exports.MsgHdrsImpl = MsgHdrsImpl;

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

@@ -0,0 +1,20 @@
+import type { Deferred } from "./util.js";
+import type { Status } from "./core.js";
+export interface PH {
+    flush(p?: Deferred<void>): Promise<void>;
+    disconnect(): void;
+    dispatchStatus(status: Status): void;
+}
+export declare class Heartbeat {
+    ph: PH;
+    interval: number;
+    maxOut: number;
+    timer?: number;
+    pendings: Promise<void>[];
+    constructor(ph: PH, interval: number, maxOut: number);
+    start(): void;
+    cancel(stale?: boolean): void;
+    _schedule(): void;
+    _reset(): void;
+}
+//# sourceMappingURL=heartbeats.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"heartbeats.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nats-core/3.0.2/src/heartbeats.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,MAAM,WAAW,EAAE;IACjB,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,UAAU,IAAI,IAAI,CAAC;IACnB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAED,qBAAa,SAAS;IACpB,EAAE,EAAE,EAAE,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;gBAEd,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAUpD,KAAK;IAOL,MAAM,CAAC,KAAK,CAAC,EAAE,OAAO;IAWtB,SAAS;IAwBT,MAAM;CAQP"}

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

@@ -0,0 +1,105 @@
+"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.Heartbeat = void 0;
+const util_js_1 = require("./util.js");
+class Heartbeat {
+    constructor(ph, interval, maxOut) {
+        Object.defineProperty(this, "ph", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "interval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxOut", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "timer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pendings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.ph = ph;
+        this.interval = interval;
+        this.maxOut = maxOut;
+        this.pendings = [];
+    }
+    // api to start the heartbeats, since this can be
+    // spuriously called from dial, ensure we don't
+    // leak timers
+    start() {
+        this.cancel();
+        this._schedule();
+    }
+    // api for canceling the heartbeats, if stale is
+    // true it will initiate a client disconnect
+    cancel(stale) {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        this._reset();
+        if (stale) {
+            this.ph.disconnect();
+        }
+    }
+    _schedule() {
+        // @ts-ignore: node is not a number - we treat this opaquely
+        this.timer = setTimeout(() => {
+            this.ph.dispatchStatus({ type: "ping", pendingPings: this.pendings.length + 1 });
+            if (this.pendings.length === this.maxOut) {
+                this.cancel(true);
+                return;
+            }
+            const ping = (0, util_js_1.deferred)();
+            this.ph.flush(ping)
+                .then(() => {
+                this._reset();
+            })
+                .catch(() => {
+                // we disconnected - pongs were rejected
+                this.cancel();
+            });
+            this.pendings.push(ping);
+            this._schedule();
+        }, this.interval);
+    }
+    _reset() {
+        // clear pendings after resolving them
+        this.pendings = this.pendings.filter((p) => {
+            const d = p;
+            d.resolve();
+            return false;
+        });
+    }
+}
+exports.Heartbeat = Heartbeat;

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

@@ -0,0 +1,60 @@
+/**
+ * Called with the number of missed heartbeats.
+ * If the function returns true, the monitor will cancel monitoring.
+ */
+export type IdleHeartbeatFn = (n: number) => boolean;
+/**
+ * IdleHeartbeatOptions
+ */
+export type IdleHeartbeatOptions = {
+    /**
+     * @field maxOut - optional maximum number of missed heartbeats before notifying (default is 2)
+     */
+    maxOut: number;
+    /**
+     * @field cancelAfter - optional timer to auto cancel monitoring in millis
+     */
+    cancelAfter: number;
+};
+export declare class IdleHeartbeatMonitor {
+    interval: number;
+    maxOut: number;
+    cancelAfter: number;
+    timer?: number;
+    autoCancelTimer?: number;
+    last: number;
+    missed: number;
+    count: number;
+    callback: IdleHeartbeatFn;
+    /**
+     * Constructor
+     * @param interval in millis to check
+     * @param cb a callback to report when heartbeats are missed
+     * @param opts monitor options @see IdleHeartbeatOptions
+     */
+    constructor(interval: number, cb: IdleHeartbeatFn, opts?: Partial<IdleHeartbeatOptions>);
+    /**
+     * cancel monitoring
+     */
+    cancel(): void;
+    /**
+     * work signals that there was work performed
+     */
+    work(): void;
+    /**
+     * internal api to change the interval, cancelAfter and maxOut
+     * @param interval
+     * @param cancelAfter
+     * @param maxOut
+     */
+    _change(interval: number, cancelAfter?: number, maxOut?: number): void;
+    /**
+     * cancels and restarts the monitoring
+     */
+    restart(): void;
+    /**
+     * internal api called to start monitoring
+     */
+    _schedule(): void;
+}
+//# sourceMappingURL=idleheartbeat_monitor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"idleheartbeat_monitor.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nats-core/3.0.2/src/idleheartbeat_monitor.ts"],"names":[],"mappings":"AAeA;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,qBAAa,oBAAoB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,IAAI,EAAG,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,eAAe,CAAC;IAE1B;;;;;OAKG;gBAED,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,eAAe,EACnB,IAAI,GAAE,OAAO,CAAC,oBAAoB,CAAiB;IAarD;;OAEG;IACH,MAAM;IAYN;;OAEG;IACH,IAAI;IAKJ;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,SAAI,EAAE,MAAM,SAAI;IAOrD;;OAEG;IACH,OAAO;IAKP;;OAEG;IACH,SAAS;CAwBV"}

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

@@ -0,0 +1,158 @@
+"use strict";
+/*
+ * Copyright 2022 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.IdleHeartbeatMonitor = void 0;
+class IdleHeartbeatMonitor {
+    /**
+     * Constructor
+     * @param interval in millis to check
+     * @param cb a callback to report when heartbeats are missed
+     * @param opts monitor options @see IdleHeartbeatOptions
+     */
+    constructor(interval, cb, opts = { maxOut: 2 }) {
+        Object.defineProperty(this, "interval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxOut", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cancelAfter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "timer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "autoCancelTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "last", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "missed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "callback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.interval = interval;
+        this.maxOut = opts?.maxOut || 2;
+        this.cancelAfter = opts?.cancelAfter || 0;
+        this.last = Date.now();
+        this.missed = 0;
+        this.count = 0;
+        this.callback = cb;
+        this._schedule();
+    }
+    /**
+     * cancel monitoring
+     */
+    cancel() {
+        if (this.autoCancelTimer) {
+            clearTimeout(this.autoCancelTimer);
+        }
+        if (this.timer) {
+            clearInterval(this.timer);
+        }
+        this.timer = 0;
+        this.autoCancelTimer = 0;
+        this.missed = 0;
+    }
+    /**
+     * work signals that there was work performed
+     */
+    work() {
+        this.last = Date.now();
+        this.missed = 0;
+    }
+    /**
+     * internal api to change the interval, cancelAfter and maxOut
+     * @param interval
+     * @param cancelAfter
+     * @param maxOut
+     */
+    _change(interval, cancelAfter = 0, maxOut = 2) {
+        this.interval = interval;
+        this.maxOut = maxOut;
+        this.cancelAfter = cancelAfter;
+        this.restart();
+    }
+    /**
+     * cancels and restarts the monitoring
+     */
+    restart() {
+        this.cancel();
+        this._schedule();
+    }
+    /**
+     * internal api called to start monitoring
+     */
+    _schedule() {
+        if (this.cancelAfter > 0) {
+            // @ts-ignore: in node is not a number - we treat this opaquely
+            this.autoCancelTimer = setTimeout(() => {
+                this.cancel();
+            }, this.cancelAfter);
+        }
+        // @ts-ignore: in node is not a number - we treat this opaquely
+        this.timer = setInterval(() => {
+            this.count++;
+            if ((Date.now() - this.last) > this.interval) {
+                this.missed++;
+            }
+            if (this.missed >= this.maxOut) {
+                try {
+                    if (this.callback(this.missed) === true) {
+                        this.cancel();
+                    }
+                }
+                catch (err) {
+                    console.log(err);
+                }
+            }
+        }, this.interval);
+    }
+}
+exports.IdleHeartbeatMonitor = IdleHeartbeatMonitor;

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

@@ -0,0 +1,39 @@
+export { NatsConnectionImpl } from "./nats.js";
+export { Nuid, nuid } from "./nuid.js";
+export { MsgImpl } from "./msg.js";
+export { getResolveFn, setTransportFactory } from "./transport.js";
+export type { Transport, TransportFactory } from "./transport.js";
+export { Connect, INFO, ProtocolHandler } from "./protocol.js";
+export type { Backoff, Deferred, Delay, ErrorResult, Perf, Prettify, Result, Timeout, ValueResult, WithRequired, } from "./util.js";
+export { backoff, collect, deadline, deferred, delay, extend, millis, nanos, render, SimpleMutex, timeout, } from "./util.js";
+export { canonicalMIMEHeaderKey, headers, MsgHdrsImpl } from "./headers.js";
+export { Heartbeat } from "./heartbeats.js";
+export type { PH } from "./heartbeats.js";
+export { MuxSubscription } from "./muxsubscription.js";
+export { DataBuffer } from "./databuffer.js";
+export { buildAuthenticator, checkOptions, checkUnsupportedOption, DEFAULT_MAX_RECONNECT_ATTEMPTS, defaultOptions, hasWsProtocol, parseOptions, } from "./options.js";
+export { RequestOne } from "./request.js";
+export { credsAuthenticator, jwtAuthenticator, nkeyAuthenticator, tokenAuthenticator, usernamePasswordAuthenticator, } from "./authenticator.js";
+export type { Codec } from "./codec.js";
+export * from "./nkeys.js";
+export { QueuedIteratorImpl } from "./queued_iterator.js";
+export type { MsgArg, ParserEvent } from "./parser.js";
+export { Kind, Parser, State } from "./parser.js";
+export { DenoBuffer, MAX_SIZE, readAll, writeAll } from "./denobuffer.js";
+export { Bench, Metric } from "./bench.js";
+export type { BenchOpts } from "./bench.js";
+export { TD, TE } from "./encoders.js";
+export { ipV4, isIP, parseIP } from "./ipparser.js";
+export type { SemVer } from "./semver.js";
+export { compare, Feature, Features, parseSemVer } from "./semver.js";
+export { Empty } from "./types.js";
+export { extractProtocolMessage, protoLen } from "./transport.js";
+export type { Auth, Authenticator, CallbackFn, CallbackOptionalErrorFn, ClientPingStatus, ClusterUpdateStatus, ConnectionClosedListener, ConnectionOptions, DisconnectStatus, Dispatcher, ForceReconnectStatus, JwtAuth, LDMStatus, Msg, MsgCallback, MsgHdrs, Nanos, NatsConnection, NKeyAuth, NoAuth, Payload, Publisher, PublishOptions, QueuedIterator, ReconnectingStatus, ReconnectStatus, Request, RequestManyOptions, RequestOptions, RequestStrategy, ReviverFn, Server, ServerErrorStatus, ServerInfo, ServersChanged, SlowConsumerStatus, StaleConnectionStatus, Stats, Status, SubOpts, Subscription, SubscriptionOptions, SyncIterator, TlsOptions, TokenAuth, UserPass, } from "./core.js";
+export { createInbox, Match, syncIterator } from "./core.js";
+export { SubscriptionImpl, Subscriptions } from "./protocol.js";
+export type { IdleHeartbeatFn, IdleHeartbeatOptions, } from "./idleheartbeat_monitor.js";
+export { IdleHeartbeatMonitor } from "./idleheartbeat_monitor.js";
+export { isIPV4OrHostname, Servers } from "./servers.js";
+export { wsconnect, wsUrlParseFn } from "./ws_transport.js";
+export { AuthorizationError, ClosedConnectionError, ConnectionError, DrainingConnectionError, errors, InvalidArgumentError, InvalidOperationError, InvalidSubjectError, NoRespondersError, PermissionViolationError, ProtocolError, RequestError, TimeoutError, UserAuthenticationExpiredError, } from "./errors.js";
+//# sourceMappingURL=internal_mod.d.ts.map