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

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

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2022-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.
+ */
+export function parseSemVer(s = "") {
+    const m = s.match(/(\d+).(\d+).(\d+)/);
+    if (m) {
+        return {
+            major: parseInt(m[1]),
+            minor: parseInt(m[2]),
+            micro: parseInt(m[3]),
+        };
+    }
+    throw new Error(`'${s}' is not a semver value`);
+}
+export function compare(a, b) {
+    if (a.major < b.major)
+        return -1;
+    if (a.major > b.major)
+        return 1;
+    if (a.minor < b.minor)
+        return -1;
+    if (a.minor > b.minor)
+        return 1;
+    if (a.micro < b.micro)
+        return -1;
+    if (a.micro > b.micro)
+        return 1;
+    return 0;
+}
+export const Feature = {
+    JS_KV: "js_kv",
+    JS_OBJECTSTORE: "js_objectstore",
+    JS_PULL_MAX_BYTES: "js_pull_max_bytes",
+    JS_NEW_CONSUMER_CREATE_API: "js_new_consumer_create",
+    JS_ALLOW_DIRECT: "js_allow_direct",
+    JS_MULTIPLE_CONSUMER_FILTER: "js_multiple_consumer_filter",
+    JS_SIMPLIFICATION: "js_simplification",
+    JS_STREAM_CONSUMER_METADATA: "js_stream_consumer_metadata",
+    JS_CONSUMER_FILTER_SUBJECTS: "js_consumer_filter_subjects",
+    JS_STREAM_FIRST_SEQ: "js_stream_first_seq",
+    JS_STREAM_SUBJECT_TRANSFORM: "js_stream_subject_transform",
+    JS_STREAM_SOURCE_SUBJECT_TRANSFORM: "js_stream_source_subject_transform",
+    JS_STREAM_COMPRESSION: "js_stream_compression",
+    JS_DEFAULT_CONSUMER_LIMITS: "js_default_consumer_limits",
+    JS_BATCH_DIRECT_GET: "js_batch_direct_get",
+    JS_PRIORITY_GROUPS: "js_priority_groups",
+};
+export class Features {
+    constructor(v) {
+        Object.defineProperty(this, "server", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "features", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "disabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.features = new Map();
+        this.disabled = [];
+        this.update(v);
+    }
+    /**
+     * Removes all disabled entries
+     */
+    resetDisabled() {
+        this.disabled.length = 0;
+        this.update(this.server);
+    }
+    /**
+     * Disables a particular feature.
+     * @param f
+     */
+    disable(f) {
+        this.disabled.push(f);
+        this.update(this.server);
+    }
+    isDisabled(f) {
+        return this.disabled.indexOf(f) !== -1;
+    }
+    update(v) {
+        if (typeof v === "string") {
+            v = parseSemVer(v);
+        }
+        this.server = v;
+        this.set(Feature.JS_KV, "2.6.2");
+        this.set(Feature.JS_OBJECTSTORE, "2.6.3");
+        this.set(Feature.JS_PULL_MAX_BYTES, "2.8.3");
+        this.set(Feature.JS_NEW_CONSUMER_CREATE_API, "2.9.0");
+        this.set(Feature.JS_ALLOW_DIRECT, "2.9.0");
+        this.set(Feature.JS_MULTIPLE_CONSUMER_FILTER, "2.10.0");
+        this.set(Feature.JS_SIMPLIFICATION, "2.9.4");
+        this.set(Feature.JS_STREAM_CONSUMER_METADATA, "2.10.0");
+        this.set(Feature.JS_CONSUMER_FILTER_SUBJECTS, "2.10.0");
+        this.set(Feature.JS_STREAM_FIRST_SEQ, "2.10.0");
+        this.set(Feature.JS_STREAM_SUBJECT_TRANSFORM, "2.10.0");
+        this.set(Feature.JS_STREAM_SOURCE_SUBJECT_TRANSFORM, "2.10.0");
+        this.set(Feature.JS_STREAM_COMPRESSION, "2.10.0");
+        this.set(Feature.JS_DEFAULT_CONSUMER_LIMITS, "2.10.0");
+        this.set(Feature.JS_BATCH_DIRECT_GET, "2.11.0");
+        this.set(Feature.JS_PRIORITY_GROUPS, "2.11.0");
+        this.disabled.forEach((f) => {
+            this.features.delete(f);
+        });
+    }
+    /**
+     * Register a feature that requires a particular server version.
+     * @param f
+     * @param requires
+     */
+    set(f, requires) {
+        this.features.set(f, {
+            min: requires,
+            ok: compare(this.server, parseSemVer(requires)) >= 0,
+        });
+    }
+    /**
+     * Returns whether the feature is available and the min server
+     * version that supports it.
+     * @param f
+     */
+    get(f) {
+        return this.features.get(f) || { min: "unknown", ok: false };
+    }
+    /**
+     * Returns true if the feature is supported
+     * @param f
+     */
+    supports(f) {
+        return this.get(f)?.ok || false;
+    }
+    /**
+     * Returns true if the server is at least the specified version
+     * @param v
+     */
+    require(v) {
+        if (typeof v === "string") {
+            v = parseSemVer(v);
+        }
+        return compare(this.server, v) >= 0;
+    }
+}

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

@@ -0,0 +1,55 @@
+import type { DnsResolveFn, Server, ServerInfo, ServersChanged } from "./core.js";
+export declare function isIPV4OrHostname(hp: string): boolean;
+export declare function hostPort(u: string): {
+    listen: string;
+    hostname: string;
+    port: number;
+};
+/**
+ * @hidden
+ */
+export declare class ServerImpl implements Server {
+    src: string;
+    listen: string;
+    hostname: string;
+    port: number;
+    didConnect: boolean;
+    reconnects: number;
+    lastConnect: number;
+    gossiped: boolean;
+    tlsName: string;
+    resolves?: Server[];
+    constructor(u: string, gossiped?: boolean);
+    toString(): string;
+    resolve(opts: Partial<{
+        fn: DnsResolveFn;
+        randomize: boolean;
+        resolve: boolean;
+        debug: boolean;
+    }>): Promise<Server[]>;
+}
+/**
+ * @hidden
+ */
+export declare class Servers {
+    private firstSelect;
+    private readonly servers;
+    private currentServer;
+    private tlsName;
+    private randomize;
+    constructor(listens?: string[], opts?: Partial<{
+        randomize: boolean;
+    }>);
+    clear(): void;
+    updateTLSName(): void;
+    getCurrentServer(): ServerImpl;
+    addServer(u: string, implicit?: boolean): void;
+    selectServer(): ServerImpl | undefined;
+    removeCurrentServer(): void;
+    removeServer(server: ServerImpl | undefined): void;
+    length(): number;
+    next(): ServerImpl | undefined;
+    getServers(): ServerImpl[];
+    update(info: ServerInfo, encrypted?: boolean): ServersChanged;
+}
+//# sourceMappingURL=servers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"servers.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nats-core/3.0.2/src/servers.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EACV,YAAY,EACZ,MAAM,EACN,UAAU,EACV,cAAc,EACf,MAAM,WAAW,CAAC;AAGnB,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAepD;AAmBD,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,GACR;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAyCpD;AAED;;GAEG;AACH,qBAAa,UAAW,YAAW,MAAM;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;gBAER,CAAC,EAAE,MAAM,EAAE,QAAQ,UAAQ;IAavC,QAAQ,IAAI,MAAM;IAIZ,OAAO,CACX,IAAI,EAAE,OAAO,CACX;QACE,EAAE,EAAE,YAAY,CAAC;QACjB,SAAS,EAAE,OAAO,CAAC;QACnB,OAAO,EAAE,OAAO,CAAC;QACjB,KAAK,EAAE,OAAO,CAAC;KAChB,CACF,GACA,OAAO,CAAC,MAAM,EAAE,CAAC;CAsCrB;AAED;;GAEG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,WAAW,CAAU;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAU;gBAGzB,OAAO,GAAE,MAAM,EAAO,EACtB,IAAI,GAAE,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAM;IAuB5C,KAAK,IAAI,IAAI;IAIb,aAAa,IAAI,IAAI;IAYrB,gBAAgB,IAAI,UAAU;IAI9B,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,UAAQ,GAAG,IAAI;IAU5C,YAAY,IAAI,UAAU,GAAG,SAAS;IActC,mBAAmB,IAAI,IAAI;IAI3B,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI;IAOlD,MAAM,IAAI,MAAM;IAIhB,IAAI,IAAI,UAAU,GAAG,SAAS;IAI9B,UAAU,IAAI,UAAU,EAAE;IAI1B,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,cAAc;CA2C9D"}

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

@@ -0,0 +1,351 @@
+/*
+ * Copyright 2018-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.
+ */
+import { defaultPort, getUrlParseFn } from "./transport.js";
+import { shuffle } from "./util.js";
+import { isIP } from "./ipparser.js";
+import { DEFAULT_HOST, DEFAULT_PORT } from "./core.js";
+export function isIPV4OrHostname(hp) {
+    // in the wild seeing IPv4s as IPv6s
+    // ::ffff:35.234.43.228 which incorrectly get mapped to IPv4 unless
+    // we add this test first
+    if (hp.indexOf("[") !== -1 || hp.indexOf("::") !== -1) {
+        return false;
+    }
+    if (hp.indexOf(".") !== -1) {
+        return true;
+    }
+    // if we have a plain hostname or host:port
+    if (hp.split(":").length <= 2) {
+        return true;
+    }
+    return false;
+}
+function isIPV6(hp) {
+    return !isIPV4OrHostname(hp);
+}
+function filterIpv6MappedToIpv4(hp) {
+    const prefix = "::FFFF:";
+    const idx = hp.toUpperCase().indexOf(prefix);
+    if (idx !== -1 && hp.indexOf(".") !== -1) {
+        // we have something like: ::FFFF:127.0.0.1 or [::FFFF:127.0.0.1]:4222
+        let ip = hp.substring(idx + prefix.length);
+        ip = ip.replace("[", "");
+        return ip.replace("]", "");
+    }
+    return hp;
+}
+export function hostPort(u) {
+    u = u.trim();
+    // remove any protocol that may have been provided
+    if (u.match(/^(.*:\/\/)(.*)/m)) {
+        u = u.replace(/^(.*:\/\/)(.*)/gm, "$2");
+    }
+    // in web environments, URL may not be a living standard
+    // that means that protocols other than HTTP/S are not
+    // parsable correctly.
+    // the third complication is that we may have been given
+    // an IPv6 or worse IPv6 mapping an Ipv4
+    u = filterIpv6MappedToIpv4(u);
+    // we only wrap cases where they gave us a plain ipv6
+    // and we are not already bracketed
+    if (isIPV6(u) && u.indexOf("[") === -1) {
+        u = `[${u}]`;
+    }
+    // if we have ipv6, we expect port after ']:' otherwise after ':'
+    const op = isIPV6(u) ? u.match(/(]:)(\d+)/) : u.match(/(:)(\d+)/);
+    const port = op && op.length === 3 && op[1] && op[2]
+        ? parseInt(op[2])
+        : DEFAULT_PORT;
+    // the next complication is that new URL() may
+    // eat ports which match the protocol - so for example
+    // port 80 may be eliminated - so we flip the protocol
+    // so that it always yields a value
+    const protocol = port === 80 ? "https" : "http";
+    const url = new URL(`${protocol}://${u}`);
+    url.port = `${port}`;
+    let hostname = url.hostname;
+    // if we are bracketed, we need to rip it out
+    if (hostname.charAt(0) === "[") {
+        hostname = hostname.substring(1, hostname.length - 1);
+    }
+    const listen = url.host;
+    return { listen, hostname, port };
+}
+/**
+ * @hidden
+ */
+export class ServerImpl {
+    constructor(u, gossiped = false) {
+        Object.defineProperty(this, "src", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "listen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "hostname", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "port", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "didConnect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reconnects", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lastConnect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gossiped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tlsName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "resolves", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.src = u;
+        this.tlsName = "";
+        const v = hostPort(u);
+        this.listen = v.listen;
+        this.hostname = v.hostname;
+        this.port = v.port;
+        this.didConnect = false;
+        this.reconnects = 0;
+        this.lastConnect = 0;
+        this.gossiped = gossiped;
+    }
+    toString() {
+        return this.listen;
+    }
+    async resolve(opts) {
+        if (!opts.fn || opts.resolve === false) {
+            // we cannot resolve - transport doesn't support it
+            // or user opted out
+            // don't add - to resolves or we get a circ reference
+            return [this];
+        }
+        const buf = [];
+        if (isIP(this.hostname)) {
+            // don't add - to resolves or we get a circ reference
+            return [this];
+        }
+        else {
+            // resolve the hostname to ips
+            const ips = await opts.fn(this.hostname);
+            if (opts.debug) {
+                console.log(`resolve ${this.hostname} = ${ips.join(",")}`);
+            }
+            for (const ip of ips) {
+                // letting URL handle the details of representing IPV6 ip with a port, etc
+                // careful to make sure the protocol doesn't line with standard ports or they
+                // get swallowed
+                const proto = this.port === 80 ? "https" : "http";
+                // ipv6 won't be bracketed here, because it came from resolve
+                const url = new URL(`${proto}://${isIPV6(ip) ? "[" + ip + "]" : ip}`);
+                url.port = `${this.port}`;
+                const ss = new ServerImpl(url.host, false);
+                ss.tlsName = this.hostname;
+                buf.push(ss);
+            }
+        }
+        if (opts.randomize) {
+            shuffle(buf);
+        }
+        this.resolves = buf;
+        return buf;
+    }
+}
+/**
+ * @hidden
+ */
+export class Servers {
+    constructor(listens = [], opts = {}) {
+        Object.defineProperty(this, "firstSelect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "servers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "currentServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tlsName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "randomize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.firstSelect = true;
+        this.servers = [];
+        this.tlsName = "";
+        this.randomize = opts.randomize || false;
+        const urlParseFn = getUrlParseFn();
+        if (listens) {
+            listens.forEach((hp) => {
+                hp = urlParseFn ? urlParseFn(hp) : hp;
+                this.servers.push(new ServerImpl(hp));
+            });
+            if (this.randomize) {
+                this.servers = shuffle(this.servers);
+            }
+        }
+        if (this.servers.length === 0) {
+            this.addServer(`${DEFAULT_HOST}:${defaultPort()}`, false);
+        }
+        this.currentServer = this.servers[0];
+    }
+    clear() {
+        this.servers.length = 0;
+    }
+    updateTLSName() {
+        const cs = this.getCurrentServer();
+        if (!isIP(cs.hostname)) {
+            this.tlsName = cs.hostname;
+            this.servers.forEach((s) => {
+                if (s.gossiped) {
+                    s.tlsName = this.tlsName;
+                }
+            });
+        }
+    }
+    getCurrentServer() {
+        return this.currentServer;
+    }
+    addServer(u, implicit = false) {
+        const urlParseFn = getUrlParseFn();
+        u = urlParseFn ? urlParseFn(u) : u;
+        const s = new ServerImpl(u, implicit);
+        if (isIP(s.hostname)) {
+            s.tlsName = this.tlsName;
+        }
+        this.servers.push(s);
+    }
+    selectServer() {
+        // allow using select without breaking the order of the servers
+        if (this.firstSelect) {
+            this.firstSelect = false;
+            return this.currentServer;
+        }
+        const t = this.servers.shift();
+        if (t) {
+            this.servers.push(t);
+            this.currentServer = t;
+        }
+        return t;
+    }
+    removeCurrentServer() {
+        this.removeServer(this.currentServer);
+    }
+    removeServer(server) {
+        if (server) {
+            const index = this.servers.indexOf(server);
+            this.servers.splice(index, 1);
+        }
+    }
+    length() {
+        return this.servers.length;
+    }
+    next() {
+        return this.servers.length ? this.servers[0] : undefined;
+    }
+    getServers() {
+        return this.servers;
+    }
+    update(info, encrypted) {
+        const added = [];
+        let deleted = [];
+        const urlParseFn = getUrlParseFn();
+        const discovered = new Map();
+        if (info.connect_urls && info.connect_urls.length > 0) {
+            info.connect_urls.forEach((hp) => {
+                hp = urlParseFn ? urlParseFn(hp, encrypted) : hp;
+                const s = new ServerImpl(hp, true);
+                discovered.set(hp, s);
+            });
+        }
+        // remove gossiped servers that are no longer reported
+        const toDelete = [];
+        this.servers.forEach((s, index) => {
+            const u = s.listen;
+            if (s.gossiped && this.currentServer.listen !== u &&
+                discovered.get(u) === undefined) {
+                // server was removed
+                toDelete.push(index);
+            }
+            // remove this entry from reported
+            discovered.delete(u);
+        });
+        // perform the deletion
+        toDelete.reverse();
+        toDelete.forEach((index) => {
+            const removed = this.servers.splice(index, 1);
+            deleted = deleted.concat(removed[0].listen);
+        });
+        // remaining servers are new
+        discovered.forEach((v, k) => {
+            this.servers.push(v);
+            added.push(k);
+        });
+        return { added, deleted };
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { ConnectionOptions, DnsResolveFn, Server, URLParseFn } from "./core.js";
+export declare function setTransportFactory(config: TransportFactory): void;
+export declare function defaultPort(): number;
+export declare function getUrlParseFn(): URLParseFn | undefined;
+export declare function newTransport(): Transport;
+export declare function getResolveFn(): DnsResolveFn | undefined;
+export interface TransportFactory {
+    factory?: () => Transport;
+    defaultPort?: number;
+    urlParseFn?: URLParseFn;
+    dnsResolveFn?: DnsResolveFn;
+}
+export interface Transport extends AsyncIterable<Uint8Array> {
+    readonly isClosed: boolean;
+    readonly lang: string;
+    readonly version: string;
+    readonly closeError?: Error;
+    connect(server: Server, opts: ConnectionOptions): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Uint8Array>;
+    isEncrypted(): boolean;
+    send(frame: Uint8Array): void;
+    close(err?: Error): Promise<void>;
+    disconnect(): void;
+    closed(): Promise<void | Error>;
+    discard(): void;
+}
+export declare const CR_LF = "\r\n";
+export declare const CR_LF_LEN: number;
+export declare const CRLF: Uint8Array;
+export declare const CR: number;
+export declare const LF: number;
+export declare function protoLen(ba: Uint8Array): number;
+export declare function extractProtocolMessage(a: Uint8Array): string;
+//# sourceMappingURL=transport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nats-core/3.0.2/src/transport.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,iBAAiB,EACjB,YAAY,EACZ,MAAM,EACN,UAAU,EACX,MAAM,WAAW,CAAC;AAMnB,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAElE;AAED,wBAAgB,WAAW,IAAI,MAAM,CAKpC;AAED,wBAAgB,aAAa,IAAI,UAAU,GAAG,SAAS,CAItD;AAED,wBAAgB,YAAY,IAAI,SAAS,CAKxC;AAED,wBAAgB,YAAY,IAAI,YAAY,GAAG,SAAS,CAIvD;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,MAAM,SAAS,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,MAAM,WAAW,SAAU,SAAQ,aAAa,CAAC,UAAU,CAAC;IAC1D,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC;IAE5B,OAAO,CACL,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAE5D,WAAW,IAAI,OAAO,CAAC;IAEvB,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IAE9B,KAAK,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElC,UAAU,IAAI,IAAI,CAAC;IAEnB,MAAM,IAAI,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC;IAIhC,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,eAAO,MAAM,KAAK,SAAS,CAAC;AAC5B,eAAO,MAAM,SAAS,QAAe,CAAC;AACtC,eAAO,MAAM,IAAI,YAA8B,CAAC;AAChD,eAAO,MAAM,EAAE,QAA0B,CAAC;AAC1C,eAAO,MAAM,EAAE,QAA0B,CAAC;AAC1C,wBAAgB,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,MAAM,CAQ/C;AAED,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,CAS5D"}

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

@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+import { TD } from "./encoders.js";
+import { DEFAULT_PORT } from "./core.js";
+import { DataBuffer } from "./databuffer.js";
+let transportConfig;
+export function setTransportFactory(config) {
+    transportConfig = config;
+}
+export function defaultPort() {
+    return transportConfig !== undefined &&
+        transportConfig.defaultPort !== undefined
+        ? transportConfig.defaultPort
+        : DEFAULT_PORT;
+}
+export function getUrlParseFn() {
+    return transportConfig !== undefined && transportConfig.urlParseFn
+        ? transportConfig.urlParseFn
+        : undefined;
+}
+export function newTransport() {
+    if (!transportConfig || typeof transportConfig.factory !== "function") {
+        throw new Error("transport fn is not set");
+    }
+    return transportConfig.factory();
+}
+export function getResolveFn() {
+    return transportConfig !== undefined && transportConfig.dnsResolveFn
+        ? transportConfig.dnsResolveFn
+        : undefined;
+}
+export const CR_LF = "\r\n";
+export const CR_LF_LEN = CR_LF.length;
+export const CRLF = DataBuffer.fromAscii(CR_LF);
+export const CR = new Uint8Array(CRLF)[0]; // 13
+export const LF = new Uint8Array(CRLF)[1]; // 10
+export function protoLen(ba) {
+    for (let i = 0; i < ba.length; i++) {
+        const n = i + 1;
+        if (ba.byteLength > n && ba[i] === CR && ba[n] === LF) {
+            return n + 1;
+        }
+    }
+    return 0;
+}
+export function extractProtocolMessage(a) {
+    // protocol messages are ascii, so Uint8Array
+    const len = protoLen(a);
+    if (len > 0) {
+        const ba = new Uint8Array(a);
+        const out = ba.slice(0, len);
+        return TD.decode(out);
+    }
+    return "";
+}

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

@@ -0,0 +1,3 @@
+export type { Dispatcher, MsgHdrs, QueuedIterator } from "./core.js";
+export { Empty } from "./encoders.js";
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nats-core/3.0.2/src/types.ts"],"names":[],"mappings":"AAcA,YAAY,EAAE,UAAU,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAErE,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC"}

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

@@ -0,0 +1 @@
+export { Empty } from "./encoders.js";