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

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

@@ -0,0 +1,372 @@
+/*
+ * 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 { deferred, delay, render } from "./util.js";
+import { extractProtocolMessage, setTransportFactory } from "./transport.js";
+import { checkOptions } from "./options.js";
+import { DataBuffer } from "./databuffer.js";
+import { INFO } from "./protocol.js";
+import { NatsConnectionImpl } from "./nats.js";
+import { version } from "./version.js";
+import { errors, InvalidArgumentError } from "./errors.js";
+const VERSION = version;
+const LANG = "nats.ws";
+export class WsTransport {
+    constructor() {
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lang", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closeError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "done", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // @ts-ignore: expecting global WebSocket
+        Object.defineProperty(this, "socket", {
+            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, "socketClosed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "encrypted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "peeked", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "yields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "signal", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closedNotification", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.version = VERSION;
+        this.lang = LANG;
+        this.connected = false;
+        this.done = false;
+        this.socketClosed = false;
+        this.encrypted = false;
+        this.peeked = false;
+        this.yields = [];
+        this.signal = deferred();
+        this.closedNotification = deferred();
+    }
+    async connect(server, options) {
+        const connected = false;
+        const ok = deferred();
+        this.options = options;
+        const u = server.src;
+        if (options.wsFactory) {
+            const { socket, encrypted } = await options.wsFactory(server.src, options);
+            this.socket = socket;
+            this.encrypted = encrypted;
+        }
+        else {
+            this.encrypted = u.indexOf("wss://") === 0;
+            this.socket = new WebSocket(u);
+        }
+        this.socket.binaryType = "arraybuffer";
+        this.socket.onopen = () => {
+            if (this.done) {
+                this._closed(new Error("aborted"));
+            }
+            // we don't do anything here...
+        };
+        this.socket.onmessage = (me) => {
+            if (this.done) {
+                return;
+            }
+            this.yields.push(new Uint8Array(me.data));
+            if (this.peeked) {
+                this.signal.resolve();
+                return;
+            }
+            const t = DataBuffer.concat(...this.yields);
+            const pm = extractProtocolMessage(t);
+            if (pm !== "") {
+                const m = INFO.exec(pm);
+                if (!m) {
+                    if (options.debug) {
+                        console.error("!!!", render(t));
+                    }
+                    ok.reject(new Error("unexpected response from server"));
+                    return;
+                }
+                try {
+                    const info = JSON.parse(m[1]);
+                    checkOptions(info, this.options);
+                    this.peeked = true;
+                    this.connected = true;
+                    this.signal.resolve();
+                    ok.resolve();
+                }
+                catch (err) {
+                    ok.reject(err);
+                    return;
+                }
+            }
+        };
+        // @ts-ignore: CloseEvent is provided in browsers
+        this.socket.onclose = (evt) => {
+            let reason;
+            if (!evt.wasClean && evt.reason !== "") {
+                reason = new Error(evt.reason);
+            }
+            this._closed(reason);
+            this._cleanup();
+        };
+        // @ts-ignore: signature can be any
+        this.socket.onerror = (e) => {
+            if (this.done) {
+                return;
+            }
+            const evt = e;
+            const err = new errors.ConnectionError(evt.message);
+            if (!connected) {
+                ok.reject(err);
+            }
+            else {
+                this._closed(err);
+            }
+            this._cleanup();
+        };
+        return ok;
+    }
+    _cleanup() {
+        if (this.socketClosed === false) {
+            // node seems to not emit closed if there's an error
+            // all other runtimes do.
+            this.socketClosed = true;
+            this.socket.onopen = null;
+            this.socket.onmessage = null;
+            this.socket.onerror = null;
+            this.socket.onclose = null;
+            this.closedNotification.resolve(this.closeError);
+        }
+    }
+    disconnect() {
+        this._closed(undefined, true);
+    }
+    async _closed(err, _internal = true) {
+        if (this.done) {
+            try {
+                this.socket.close();
+            }
+            catch (_) {
+                // nothing
+            }
+            return;
+        }
+        this.closeError = err;
+        if (!err) {
+            while (!this.socketClosed && this.socket.bufferedAmount > 0) {
+                await delay(100);
+            }
+        }
+        this.done = true;
+        try {
+            this.socket.close();
+        }
+        catch (_) {
+            // ignore this
+        }
+        return this.closedNotification;
+    }
+    get isClosed() {
+        return this.done;
+    }
+    [Symbol.asyncIterator]() {
+        return this.iterate();
+    }
+    async *iterate() {
+        while (true) {
+            if (this.done) {
+                return;
+            }
+            if (this.yields.length === 0) {
+                await this.signal;
+            }
+            const yields = this.yields;
+            this.yields = [];
+            for (let i = 0; i < yields.length; i++) {
+                if (this.options.debug) {
+                    console.info(`> ${render(yields[i])}`);
+                }
+                yield yields[i];
+            }
+            // yielding could have paused and microtask
+            // could have added messages. Prevent allocations
+            // if possible
+            if (this.done) {
+                break;
+            }
+            else if (this.yields.length === 0) {
+                yields.length = 0;
+                this.yields = yields;
+                this.signal = deferred();
+            }
+        }
+    }
+    isEncrypted() {
+        return this.connected && this.encrypted;
+    }
+    send(frame) {
+        if (this.done) {
+            return;
+        }
+        try {
+            this.socket.send(frame.buffer);
+            if (this.options.debug) {
+                console.info(`< ${render(frame)}`);
+            }
+            return;
+        }
+        catch (err) {
+            // we ignore write errors because client will
+            // fail on a read or when the heartbeat timer
+            // detects a stale connection
+            if (this.options.debug) {
+                console.error(`!!! ${render(frame)}: ${err}`);
+            }
+        }
+    }
+    close(err) {
+        return this._closed(err, false);
+    }
+    closed() {
+        return this.closedNotification;
+    }
+    // this is to allow a force discard on a connection
+    // if the connection fails during the handshake protocol.
+    // Firefox for example, will keep connections going,
+    // so eventually if it succeeds, the client will have
+    // an additional transport running. With this
+    discard() {
+        this.socket?.close();
+    }
+}
+export function wsUrlParseFn(u, encrypted) {
+    const ut = /^(.*:\/\/)(.*)/;
+    if (!ut.test(u)) {
+        // if we have no hint to encrypted and no protocol, assume encrypted
+        // else we fix the url from the update to match
+        if (typeof encrypted === "boolean") {
+            u = `${encrypted === true ? "https" : "http"}://${u}`;
+        }
+        else {
+            u = `https://${u}`;
+        }
+    }
+    let url = new URL(u);
+    const srcProto = url.protocol.toLowerCase();
+    if (srcProto === "ws:") {
+        encrypted = false;
+    }
+    if (srcProto === "wss:") {
+        encrypted = true;
+    }
+    if (srcProto !== "https:" && srcProto !== "http") {
+        u = u.replace(/^(.*:\/\/)(.*)/gm, "$2");
+        url = new URL(`http://${u}`);
+    }
+    let protocol;
+    let port;
+    const host = url.hostname;
+    const path = url.pathname;
+    const search = url.search || "";
+    switch (srcProto) {
+        case "http:":
+        case "ws:":
+        case "nats:":
+            port = url.port || "80";
+            protocol = "ws:";
+            break;
+        case "https:":
+        case "wss:":
+        case "tls:":
+            port = url.port || "443";
+            protocol = "wss:";
+            break;
+        default:
+            port = url.port || encrypted === true ? "443" : "80";
+            protocol = encrypted === true ? "wss:" : "ws:";
+            break;
+    }
+    return `${protocol}//${host}:${port}${path}${search}`;
+}
+export function wsconnect(opts = {}) {
+    setTransportFactory({
+        defaultPort: 443,
+        urlParseFn: wsUrlParseFn,
+        factory: () => {
+            if (opts.tls) {
+                throw InvalidArgumentError.format("tls", "is not configurable on w3c websocket connections");
+            }
+            return new WsTransport();
+        },
+    });
+    return NatsConnectionImpl.connect(opts);
+}

package/esm/deps/jsr.io/@nats-io/nkeys/2.0.3/src/base32.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @ignore
+ */
+export declare class base32 {
+    static encode(src: Uint8Array): Uint8Array;
+    static decode(src: Uint8Array): Uint8Array;
+}
+//# sourceMappingURL=base32.d.ts.map

package/esm/deps/jsr.io/@nats-io/nkeys/2.0.3/src/base32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base32.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nkeys/2.0.3/src/base32.ts"],"names":[],"mappings":"AAuBA;;GAEG;AACH,qBAAa,MAAM;IACjB,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU;IAsB1C,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU;CAqB3C"}

package/esm/deps/jsr.io/@nats-io/nkeys/2.0.3/src/base32.js

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2018-2021 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.
+ */
+// Fork of https://github.com/LinusU/base32-encode
+// and https://github.com/LinusU/base32-decode to support returning
+// buffers without padding.
+/**
+ * @ignore
+ */
+const b32Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+/**
+ * @ignore
+ */
+export class base32 {
+    static encode(src) {
+        let bits = 0;
+        let value = 0;
+        const a = new Uint8Array(src);
+        const buf = new Uint8Array(src.byteLength * 2);
+        let j = 0;
+        for (let i = 0; i < a.byteLength; i++) {
+            value = (value << 8) | a[i];
+            bits += 8;
+            while (bits >= 5) {
+                const index = (value >>> (bits - 5)) & 31;
+                buf[j++] = b32Alphabet.charAt(index).charCodeAt(0);
+                bits -= 5;
+            }
+        }
+        if (bits > 0) {
+            const index = (value << (5 - bits)) & 31;
+            buf[j++] = b32Alphabet.charAt(index).charCodeAt(0);
+        }
+        return buf.slice(0, j);
+    }
+    static decode(src) {
+        let bits = 0;
+        let byte = 0;
+        let j = 0;
+        const a = new Uint8Array(src);
+        const out = new Uint8Array(a.byteLength * 5 / 8 | 0);
+        for (let i = 0; i < a.byteLength; i++) {
+            const v = String.fromCharCode(a[i]);
+            const vv = b32Alphabet.indexOf(v);
+            if (vv === -1) {
+                throw new Error("Illegal Base32 character: " + a[i]);
+            }
+            byte = (byte << 5) | vv;
+            bits += 5;
+            if (bits >= 8) {
+                out[j++] = (byte >>> (bits - 8)) & 255;
+                bits -= 8;
+            }
+        }
+        return out.slice(0, j);
+    }
+}

package/esm/deps/jsr.io/@nats-io/nkeys/2.0.3/src/codec.d.ts

@@ -0,0 +1,22 @@
+import { Prefix } from "./nkeys.js";
+/**
+ * @ignore
+ */
+export interface SeedDecode {
+    prefix: Prefix;
+    buf: Uint8Array;
+}
+/**
+ * @ignore
+ */
+export declare class Codec {
+    static encode(prefix: Prefix, src: Uint8Array): Uint8Array;
+    static encodeSeed(role: Prefix, src: Uint8Array): Uint8Array;
+    static decode(expected: Prefix, src: Uint8Array): Uint8Array;
+    static decodeSeed(src: Uint8Array): SeedDecode;
+    static _encode(seed: boolean, role: Prefix, payload: Uint8Array): Uint8Array;
+    static _decode(src: Uint8Array): Uint8Array;
+    static _encodePrefix(kind: Prefix, role: Prefix): Uint8Array;
+    static _decodePrefix(raw: Uint8Array): Uint8Array;
+}
+//# sourceMappingURL=codec.d.ts.map

package/esm/deps/jsr.io/@nats-io/nkeys/2.0.3/src/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nkeys/2.0.3/src/codec.ts"],"names":[],"mappings":"AAgBA,OAAO,EAA8B,MAAM,EAAY,MAAM,YAAY,CAAC;AAG1E;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,UAAU,CAAC;CACjB;AACD;;GAEG;AACH,qBAAa,KAAK;IAChB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,UAAU;IAY1D,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,UAAU;IAe5D,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,UAAU;IAW5D,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU;IAa9C,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,UAAU;IA2B5E,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU;IAsB3C,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU;IAQ5D,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU;CAOlD"}

package/esm/deps/jsr.io/@nats-io/nkeys/2.0.3/src/codec.js

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2018-2020 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 { crc16 } from "./crc16.js";
+import { NKeysError, NKeysErrorCode, Prefix, Prefixes } from "./nkeys.js";
+import { base32 } from "./base32.js";
+/**
+ * @ignore
+ */
+export class Codec {
+    static encode(prefix, src) {
+        if (!src || !(src instanceof Uint8Array)) {
+            throw new NKeysError(NKeysErrorCode.SerializationError);
+        }
+        if (!Prefixes.isValidPrefix(prefix)) {
+            throw new NKeysError(NKeysErrorCode.InvalidPrefixByte);
+        }
+        return Codec._encode(false, prefix, src);
+    }
+    static encodeSeed(role, src) {
+        if (!src) {
+            throw new NKeysError(NKeysErrorCode.ApiError);
+        }
+        if (!Prefixes.isValidPublicPrefix(role)) {
+            throw new NKeysError(NKeysErrorCode.InvalidPrefixByte);
+        }
+        if (src.byteLength !== 32) {
+            throw new NKeysError(NKeysErrorCode.InvalidSeedLen);
+        }
+        return Codec._encode(true, role, src);
+    }
+    static decode(expected, src) {
+        if (!Prefixes.isValidPrefix(expected)) {
+            throw new NKeysError(NKeysErrorCode.InvalidPrefixByte);
+        }
+        const raw = Codec._decode(src);
+        if (raw[0] !== expected) {
+            throw new NKeysError(NKeysErrorCode.InvalidPrefixByte);
+        }
+        return raw.slice(1);
+    }
+    static decodeSeed(src) {
+        const raw = Codec._decode(src);
+        const prefix = Codec._decodePrefix(raw);
+        if (prefix[0] != Prefix.Seed) {
+            throw new NKeysError(NKeysErrorCode.InvalidSeed);
+        }
+        if (!Prefixes.isValidPublicPrefix(prefix[1])) {
+            throw new NKeysError(NKeysErrorCode.InvalidPrefixByte);
+        }
+        return ({ buf: raw.slice(2), prefix: prefix[1] });
+    }
+    // unsafe encode no prefix/role validation
+    static _encode(seed, role, payload) {
+        // offsets for this token
+        const payloadOffset = seed ? 2 : 1;
+        const payloadLen = payload.byteLength;
+        const checkLen = 2;
+        const cap = payloadOffset + payloadLen + checkLen;
+        const checkOffset = payloadOffset + payloadLen;
+        const raw = new Uint8Array(cap);
+        // make the prefixes human readable when encoded
+        if (seed) {
+            const encodedPrefix = Codec._encodePrefix(Prefix.Seed, role);
+            raw.set(encodedPrefix);
+        }
+        else {
+            raw[0] = role;
+        }
+        raw.set(payload, payloadOffset);
+        //calculate the checksum write it LE
+        const checksum = crc16.checksum(raw.slice(0, checkOffset));
+        const dv = new DataView(raw.buffer);
+        dv.setUint16(checkOffset, checksum, true);
+        return base32.encode(raw);
+    }
+    // unsafe decode - no prefix/role validation
+    static _decode(src) {
+        if (src.byteLength < 4) {
+            throw new NKeysError(NKeysErrorCode.InvalidEncoding);
+        }
+        let raw;
+        try {
+            raw = base32.decode(src);
+        }
+        catch (ex) {
+            throw new NKeysError(NKeysErrorCode.InvalidEncoding, { cause: ex });
+        }
+        const checkOffset = raw.byteLength - 2;
+        const dv = new DataView(raw.buffer);
+        const checksum = dv.getUint16(checkOffset, true);
+        const payload = raw.slice(0, checkOffset);
+        if (!crc16.validate(payload, checksum)) {
+            throw new NKeysError(NKeysErrorCode.InvalidChecksum);
+        }
+        return payload;
+    }
+    static _encodePrefix(kind, role) {
+        // In order to make this human printable for both bytes, we need to do a little
+        // bit manipulation to setup for base32 encoding which takes 5 bits at a time.
+        const b1 = kind | (role >> 5);
+        const b2 = (role & 31) << 3; // 31 = 00011111
+        return new Uint8Array([b1, b2]);
+    }
+    static _decodePrefix(raw) {
+        // Need to do the reverse from the printable representation to
+        // get back to internal representation.
+        const b1 = raw[0] & 248; // 248 = 11111000
+        const b2 = (raw[0] & 7) << 5 | ((raw[1] & 248) >> 3); // 7 = 00000111
+        return new Uint8Array([b1, b2]);
+    }
+}

package/esm/deps/jsr.io/@nats-io/nkeys/2.0.3/src/crc16.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @ignore
+ */
+export declare class crc16 {
+    static checksum(data: Uint8Array): number;
+    static validate(data: Uint8Array, expected: number): boolean;
+}
+//# sourceMappingURL=crc16.d.ts.map

package/esm/deps/jsr.io/@nats-io/nkeys/2.0.3/src/crc16.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crc16.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nkeys/2.0.3/src/crc16.ts"],"names":[],"mappings":"AAsRA;;GAEG;AACH,qBAAa,KAAK;IAEhB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAUzC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;CAI7D"}