@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/options.js

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2021-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.
+ */
+import { extend } from "./util.js";
+import { defaultPort, getResolveFn } from "./transport.js";
+import { createInbox, DEFAULT_HOST } from "./core.js";
+import { multiAuthenticator, noAuthFn, tokenAuthenticator, usernamePasswordAuthenticator, } from "./authenticator.js";
+import { errors, InvalidArgumentError } from "./errors.js";
+export const DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+export const DEFAULT_JITTER = 100;
+export const DEFAULT_JITTER_TLS = 1000;
+// Ping interval
+export const DEFAULT_PING_INTERVAL = 2 * 60 * 1000; // 2 minutes
+export const DEFAULT_MAX_PING_OUT = 2;
+// DISCONNECT Parameters, 2 sec wait, 10 tries
+export const DEFAULT_RECONNECT_TIME_WAIT = 2 * 1000;
+export function defaultOptions() {
+    return {
+        maxPingOut: DEFAULT_MAX_PING_OUT,
+        maxReconnectAttempts: DEFAULT_MAX_RECONNECT_ATTEMPTS,
+        noRandomize: false,
+        pedantic: false,
+        pingInterval: DEFAULT_PING_INTERVAL,
+        reconnect: true,
+        reconnectJitter: DEFAULT_JITTER,
+        reconnectJitterTLS: DEFAULT_JITTER_TLS,
+        reconnectTimeWait: DEFAULT_RECONNECT_TIME_WAIT,
+        tls: undefined,
+        verbose: false,
+        waitOnFirstConnect: false,
+        ignoreAuthErrorAbort: false,
+    };
+}
+export function hasWsProtocol(opts) {
+    if (opts) {
+        let { servers } = opts;
+        if (typeof servers === "string") {
+            servers = [servers];
+        }
+        if (servers) {
+            for (let i = 0; i < servers.length; i++) {
+                const s = servers[i].toLowerCase();
+                if (s.startsWith("ws://") || s.startsWith("wss://")) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+export function buildAuthenticator(opts) {
+    const buf = [];
+    // jwtAuthenticator is created by the user, since it
+    // will require possibly reading files which
+    // some of the clients are simply unable to do
+    if (typeof opts.authenticator === "function") {
+        buf.push(opts.authenticator);
+    }
+    if (Array.isArray(opts.authenticator)) {
+        buf.push(...opts.authenticator);
+    }
+    if (opts.token) {
+        buf.push(tokenAuthenticator(opts.token));
+    }
+    if (opts.user) {
+        buf.push(usernamePasswordAuthenticator(opts.user, opts.pass));
+    }
+    return buf.length === 0 ? noAuthFn() : multiAuthenticator(buf);
+}
+export function parseOptions(opts) {
+    const dhp = `${DEFAULT_HOST}:${defaultPort()}`;
+    opts = opts || { servers: [dhp] };
+    opts.servers = opts.servers || [];
+    if (typeof opts.servers === "string") {
+        opts.servers = [opts.servers];
+    }
+    if (opts.servers.length > 0 && opts.port) {
+        throw InvalidArgumentError.format(["servers", "port"], "are mutually exclusive");
+    }
+    if (opts.servers.length === 0 && opts.port) {
+        opts.servers = [`${DEFAULT_HOST}:${opts.port}`];
+    }
+    if (opts.servers && opts.servers.length === 0) {
+        opts.servers = [dhp];
+    }
+    const options = extend(defaultOptions(), opts);
+    options.authenticator = buildAuthenticator(options);
+    ["reconnectDelayHandler", "authenticator"].forEach((n) => {
+        if (options[n] && typeof options[n] !== "function") {
+            throw TypeError(`'${n}' must be a function`);
+        }
+    });
+    if (!options.reconnectDelayHandler) {
+        options.reconnectDelayHandler = () => {
+            let extra = options.tls
+                ? options.reconnectJitterTLS
+                : options.reconnectJitter;
+            if (extra) {
+                extra++;
+                extra = Math.floor(Math.random() * extra);
+            }
+            return options.reconnectTimeWait + extra;
+        };
+    }
+    if (options.inboxPrefix) {
+        createInbox(options.inboxPrefix);
+    }
+    // if not set - we set it
+    if (options.resolve === undefined) {
+        // set a default based on whether the client can resolve or not
+        options.resolve = typeof getResolveFn() === "function";
+    }
+    if (options.resolve) {
+        if (typeof getResolveFn() !== "function") {
+            throw InvalidArgumentError.format("resolve", "is not supported in the current runtime");
+        }
+    }
+    return options;
+}
+export function checkOptions(info, options) {
+    const { proto, tls_required: tlsRequired, tls_available: tlsAvailable } = info;
+    if ((proto === undefined || proto < 1) && options.noEcho) {
+        throw new errors.ConnectionError(`server does not support 'noEcho'`);
+    }
+    const tls = tlsRequired || tlsAvailable || false;
+    if (options.tls && !tls) {
+        throw new errors.ConnectionError(`server does not support 'tls'`);
+    }
+}
+export function checkUnsupportedOption(prop, v) {
+    if (v) {
+        throw InvalidArgumentError.format(prop, "is not supported");
+    }
+}

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

@@ -0,0 +1,109 @@
+import { DenoBuffer } from "./denobuffer.js";
+import type { Dispatcher } from "./core.js";
+export declare const Kind: {
+    readonly OK: 0;
+    readonly ERR: 1;
+    readonly MSG: 2;
+    readonly INFO: 3;
+    readonly PING: 4;
+    readonly PONG: 5;
+};
+export type Kind = typeof Kind[keyof typeof Kind];
+export interface ParserEvent {
+    kind: Kind;
+    msg?: MsgArg;
+    data?: Uint8Array;
+}
+export declare function describe(e: ParserEvent): string;
+export interface MsgArg {
+    subject: Uint8Array;
+    reply?: Uint8Array;
+    sid: number;
+    hdr: number;
+    size: number;
+}
+export declare class Parser {
+    dispatcher: Dispatcher<ParserEvent>;
+    state: State;
+    as: number;
+    drop: number;
+    hdr: number;
+    ma: MsgArg;
+    argBuf?: DenoBuffer;
+    msgBuf?: DenoBuffer;
+    constructor(dispatcher: Dispatcher<ParserEvent>);
+    parse(buf: Uint8Array): void;
+    cloneMsgArg(): void;
+    processMsgArgs(arg: Uint8Array): void;
+    fail(data: Uint8Array, label?: string): Error;
+    processHeaderMsgArgs(arg: Uint8Array): void;
+    protoParseInt(a: Uint8Array): number;
+}
+export declare const State: {
+    readonly OP_START: 0;
+    readonly OP_PLUS: 1;
+    readonly OP_PLUS_O: 2;
+    readonly OP_PLUS_OK: 3;
+    readonly OP_MINUS: 4;
+    readonly OP_MINUS_E: 5;
+    readonly OP_MINUS_ER: 6;
+    readonly OP_MINUS_ERR: 7;
+    readonly OP_MINUS_ERR_SPC: 8;
+    readonly MINUS_ERR_ARG: 9;
+    readonly OP_M: 10;
+    readonly OP_MS: 11;
+    readonly OP_MSG: 12;
+    readonly OP_MSG_SPC: 13;
+    readonly MSG_ARG: 14;
+    readonly MSG_PAYLOAD: 15;
+    readonly MSG_END: 16;
+    readonly OP_H: 17;
+    readonly OP_P: 18;
+    readonly OP_PI: 19;
+    readonly OP_PIN: 20;
+    readonly OP_PING: 21;
+    readonly OP_PO: 22;
+    readonly OP_PON: 23;
+    readonly OP_PONG: 24;
+    readonly OP_I: 25;
+    readonly OP_IN: 26;
+    readonly OP_INF: 27;
+    readonly OP_INFO: 28;
+    readonly OP_INFO_SPC: 29;
+    readonly INFO_ARG: 30;
+};
+export type State = typeof State[keyof typeof State];
+export declare const cc: {
+    readonly CR: number;
+    readonly E: number;
+    readonly e: number;
+    readonly F: number;
+    readonly f: number;
+    readonly G: number;
+    readonly g: number;
+    readonly H: number;
+    readonly h: number;
+    readonly I: number;
+    readonly i: number;
+    readonly K: number;
+    readonly k: number;
+    readonly M: number;
+    readonly m: number;
+    readonly MINUS: number;
+    readonly N: number;
+    readonly n: number;
+    readonly NL: number;
+    readonly O: number;
+    readonly o: number;
+    readonly P: number;
+    readonly p: number;
+    readonly PLUS: number;
+    readonly R: number;
+    readonly r: number;
+    readonly S: number;
+    readonly s: number;
+    readonly SPACE: number;
+    readonly TAB: number;
+};
+export type cc = typeof cc[keyof typeof cc];
+//# sourceMappingURL=parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nats-core/3.0.2/src/parser.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,eAAO,MAAM,IAAI;;;;;;;CAOP,CAAC;AAEX,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,MAAM,OAAO,IAAI,CAAC,CAAC;AAElD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,IAAI,CAAC;IACX,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CA0B/C;AAED,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,UAAU,CAAC;IACpB,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAgBD,qBAAa,MAAM;IACjB,UAAU,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;IACpC,KAAK,EAAE,KAAK,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAG,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,MAAM,CAAC,EAAE,UAAU,CAAC;gBAER,UAAU,EAAE,UAAU,CAAC,WAAW,CAAC;IAQ/C,KAAK,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI;IA4a5B,WAAW;IAeX,cAAc,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI;IAsDrC,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,SAAK,GAAG,KAAK;IAUzC,oBAAoB,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI;IA0D3C,aAAa,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;CAarC;AAED,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCR,CAAC;AAEX,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,MAAM,OAAO,KAAK,CAAC,CAAC;AAErD,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BL,CAAC;AAEX,MAAM,MAAM,EAAE,GAAG,OAAO,EAAE,CAAC,MAAM,OAAO,EAAE,CAAC,CAAC"}