@versori/run 0.1.0-alpha.8 → 0.2.0-alpha.1

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

@@ -0,0 +1,171 @@
+/**
+ * @ignore
+ */
+export declare function createPair(prefix: Prefix): KeyPair;
+/**
+ * Creates a KeyPair with an operator prefix
+ * @returns {KeyPair} Returns the created KeyPair.
+ */
+export declare function createOperator(): KeyPair;
+/**
+ * Creates a KeyPair with an account prefix
+ * @returns {KeyPair} Returns the created KeyPair.
+ */
+export declare function createAccount(): KeyPair;
+/**
+ * Creates a KeyPair with a user prefix
+ * @returns {KeyPair} Returns the created KeyPair.
+ */
+export declare function createUser(): KeyPair;
+/**
+ * @ignore
+ */
+export declare function createCluster(): KeyPair;
+/**
+ * @ignore
+ */
+export declare function createServer(): KeyPair;
+/**
+ * Generates and returns a KeyPair object using the Curve prefix.
+ * Curve KeyPairs can seal/open (encrypt/decrypt) payloads.
+ *
+ * @return {KeyPair} The generated KeyPair object with Curve prefix.
+ */
+export declare function createCurve(): KeyPair;
+/**
+ * Creates a KeyPair from a specified public key
+ * @param {string} src of the public key in string format.
+ * @returns {KeyPair} Returns the created KeyPair.
+ * @see KeyPair#getPublicKey
+ */
+export declare function fromPublic(src: string): KeyPair;
+/**
+ * Creates a KeyPair from a Curve seed. Curve keys can encrypt and decrypt payloads.
+ *
+ * @param {Uint8Array} src - The seed representing the Curve key in encoded format.
+ * @return {KeyPair} The resulting KeyPair generated from the Curve seed.
+ * @throws {NKeysError} If the seed's prefix is not a Curve prefix or if the seed length is invalid.
+ */
+export declare function fromCurveSeed(src: Uint8Array): KeyPair;
+/**
+ * Creates a KeyPair from a specified seed.
+ * @param {Uint8Array} src of the seed key as Uint8Array
+ * @returns {KeyPair} Returns the created KeyPair.
+ * @see KeyPair#getSeed
+ */
+export declare function fromSeed(src: Uint8Array): KeyPair;
+export interface KeyPair {
+    /**
+     * Returns the public key associated with the KeyPair
+     * @returns {string}
+     * @throws NKeysError
+     */
+    getPublicKey(): string;
+    /**
+     * Returns the private key associated with the KeyPair
+     * @returns Uint8Array
+     * @throws NKeysError
+     */
+    getPrivateKey(): Uint8Array;
+    /**
+     * Returns the PrivateKey's seed.
+     * @returns Uint8Array
+     * @throws NKeysError
+     */
+    getSeed(): Uint8Array;
+    /**
+     * Returns the digital signature of signing the input with the
+     * the KeyPair's private key. Note that only non-curve keys can sign.
+     * @param {Uint8Array} input
+     * @returns Uint8Array
+     * @throws NKeysError if a curve key
+     */
+    sign(input: Uint8Array): Uint8Array;
+    /**
+     * Returns true if the signature can be verified with the KeyPair
+     * Note that only non-curve keys can verify.
+     *
+     * @param {Uint8Array} input
+     * @param {Uint8Array} sig
+     * @returns {boolean}
+     * @throws NKeysError if a curve key
+     */
+    verify(input: Uint8Array, sig: Uint8Array): boolean;
+    /**
+     * Clears the secret stored in the keypair. After clearing
+     * a keypair cannot be used or recovered.
+     */
+    clear(): void;
+    /**
+     * Seals (encrypts) the provided input data with the recipient's public key
+     * and an optional nonce. Note that only curve keys can seal a payload.
+     *
+     * @param {Uint8Array} input - The data to be encrypted.
+     * @param {string} recipient - The recipient's identifier or public key.
+     * @param {Uint8Array} [nonce] - An optional nonce to use in the encryption process.
+     * @return {Uint8Array} The encrypted data.
+     * @throws {NKeysError} if not a curve key
+     */
+    seal(input: Uint8Array, recipient: string, nonce?: Uint8Array): Uint8Array;
+    /**
+     * Opens (decrypts) and processes a given message from a specified sender.
+     * Note that only curve keys can open a payload.
+     *
+     * @param {Uint8Array} message - The message to be opened and processed.
+     * @param {string} sender - The sender of the message.
+     * @return {Uint8Array | null} Returns the processed message as a Uint8Array if successful, or null if the operation fails.
+     * @throws {NKeysError} if not a curve key
+     */
+    open(message: Uint8Array, sender: string): Uint8Array | null;
+}
+/**
+ * @ignore
+ */
+export declare enum Prefix {
+    Unknown = -1,
+    Seed = 144,// Base32-encodes to 'S...'
+    Private = 120,// Base32-encodes to 'P...'
+    Operator = 112,// Base32-encodes to 'O...'
+    Server = 104,// Base32-encodes to 'N...'
+    Cluster = 16,// Base32-encodes to 'C...'
+    Account = 0,// Base32-encodes to 'A...'
+    User = 160,// Base32-encodes to 'U...'
+    Curve = 184
+}
+/**
+ * @private
+ */
+export declare class Prefixes {
+    static isValidPublicPrefix(prefix: Prefix): boolean;
+    static startsWithValidPrefix(s: string): boolean;
+    static isValidPrefix(prefix: Prefix): boolean;
+    static parsePrefix(v: number): Prefix;
+}
+/**
+ * Possible error codes on exceptions thrown by the library.
+ */
+export declare enum NKeysErrorCode {
+    InvalidPrefixByte = "nkeys: invalid prefix byte",
+    InvalidKey = "nkeys: invalid key",
+    InvalidPublicKey = "nkeys: invalid public key",
+    InvalidSeedLen = "nkeys: invalid seed length",
+    InvalidSeed = "nkeys: invalid seed",
+    InvalidCurveSeed = "nkeys: invalid curve seed",
+    InvalidCurveKey = "nkeys: not a valid curve key",
+    InvalidCurveOperation = "nkeys: curve key is not valid for sign/verify",
+    InvalidNKeyOperation = "keys: only curve key can seal/open",
+    InvalidEncoding = "nkeys: invalid encoded key",
+    InvalidRecipient = "nkeys: not a valid recipient public curve key",
+    InvalidEncrypted = "nkeys: encrypted input is not valid",
+    CannotSign = "nkeys: cannot sign, no private key available",
+    PublicKeyOnly = "nkeys: no seed or private key available",
+    InvalidChecksum = "nkeys: invalid checksum",
+    SerializationError = "nkeys: serialization error",
+    ApiError = "nkeys: api error",
+    ClearedPair = "nkeys: pair is cleared"
+}
+export declare class NKeysError extends Error {
+    code: string;
+    constructor(code: NKeysErrorCode, options?: ErrorOptions);
+}
+//# sourceMappingURL=nkeys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nkeys.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nkeys/2.0.3/src/nkeys.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,238 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NKeysError = exports.NKeysErrorCode = exports.Prefixes = exports.Prefix = void 0;
+exports.createPair = createPair;
+exports.createOperator = createOperator;
+exports.createAccount = createAccount;
+exports.createUser = createUser;
+exports.createCluster = createCluster;
+exports.createServer = createServer;
+exports.createCurve = createCurve;
+exports.fromPublic = fromPublic;
+exports.fromCurveSeed = fromCurveSeed;
+exports.fromSeed = fromSeed;
+/*
+ * 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.
+ */
+const kp_js_1 = require("./kp.js");
+const public_js_1 = require("./public.js");
+const codec_js_1 = require("./codec.js");
+const curve_js_1 = require("./curve.js");
+const nacl_js_1 = __importDefault(require("./nacl.js"));
+/**
+ * @ignore
+ */
+function createPair(prefix) {
+    const len = prefix === Prefix.Curve ? curve_js_1.curveKeyLen : 32;
+    const rawSeed = nacl_js_1.default.randomBytes(len);
+    const str = codec_js_1.Codec.encodeSeed(prefix, new Uint8Array(rawSeed));
+    return prefix === Prefix.Curve
+        ? new curve_js_1.CurveKP(new Uint8Array(rawSeed))
+        : new kp_js_1.KP(str);
+}
+/**
+ * Creates a KeyPair with an operator prefix
+ * @returns {KeyPair} Returns the created KeyPair.
+ */
+function createOperator() {
+    return createPair(Prefix.Operator);
+}
+/**
+ * Creates a KeyPair with an account prefix
+ * @returns {KeyPair} Returns the created KeyPair.
+ */
+function createAccount() {
+    return createPair(Prefix.Account);
+}
+/**
+ * Creates a KeyPair with a user prefix
+ * @returns {KeyPair} Returns the created KeyPair.
+ */
+function createUser() {
+    return createPair(Prefix.User);
+}
+/**
+ * @ignore
+ */
+function createCluster() {
+    return createPair(Prefix.Cluster);
+}
+/**
+ * @ignore
+ */
+function createServer() {
+    return createPair(Prefix.Server);
+}
+/**
+ * Generates and returns a KeyPair object using the Curve prefix.
+ * Curve KeyPairs can seal/open (encrypt/decrypt) payloads.
+ *
+ * @return {KeyPair} The generated KeyPair object with Curve prefix.
+ */
+function createCurve() {
+    return createPair(Prefix.Curve);
+}
+/**
+ * Creates a KeyPair from a specified public key
+ * @param {string} src of the public key in string format.
+ * @returns {KeyPair} Returns the created KeyPair.
+ * @see KeyPair#getPublicKey
+ */
+function fromPublic(src) {
+    const ba = new TextEncoder().encode(src);
+    const raw = codec_js_1.Codec._decode(ba);
+    const prefix = Prefixes.parsePrefix(raw[0]);
+    if (Prefixes.isValidPublicPrefix(prefix)) {
+        return new public_js_1.PublicKey(ba);
+    }
+    throw new NKeysError(NKeysErrorCode.InvalidPublicKey);
+}
+/**
+ * Creates a KeyPair from a Curve seed. Curve keys can encrypt and decrypt payloads.
+ *
+ * @param {Uint8Array} src - The seed representing the Curve key in encoded format.
+ * @return {KeyPair} The resulting KeyPair generated from the Curve seed.
+ * @throws {NKeysError} If the seed's prefix is not a Curve prefix or if the seed length is invalid.
+ */
+function fromCurveSeed(src) {
+    const sd = codec_js_1.Codec.decodeSeed(src);
+    if (sd.prefix !== Prefix.Curve) {
+        throw new NKeysError(NKeysErrorCode.InvalidCurveSeed);
+    }
+    if (sd.buf.byteLength !== curve_js_1.curveKeyLen) {
+        throw new NKeysError(NKeysErrorCode.InvalidSeedLen);
+    }
+    return new curve_js_1.CurveKP(sd.buf);
+}
+/**
+ * Creates a KeyPair from a specified seed.
+ * @param {Uint8Array} src of the seed key as Uint8Array
+ * @returns {KeyPair} Returns the created KeyPair.
+ * @see KeyPair#getSeed
+ */
+function fromSeed(src) {
+    const sd = codec_js_1.Codec.decodeSeed(src);
+    // if we are here it decoded properly
+    if (sd.prefix === Prefix.Curve) {
+        return fromCurveSeed(src);
+    }
+    return new kp_js_1.KP(src);
+}
+/**
+ * @ignore
+ */
+var Prefix;
+(function (Prefix) {
+    Prefix[Prefix["Unknown"] = -1] = "Unknown";
+    //Seed is the version byte used for encoded NATS Seeds
+    Prefix[Prefix["Seed"] = 144] = "Seed";
+    //PrefixBytePrivate is the version byte used for encoded NATS Private keys
+    Prefix[Prefix["Private"] = 120] = "Private";
+    //PrefixByteOperator is the version byte used for encoded NATS Operators
+    Prefix[Prefix["Operator"] = 112] = "Operator";
+    //PrefixByteServer is the version byte used for encoded NATS Servers
+    Prefix[Prefix["Server"] = 104] = "Server";
+    //PrefixByteCluster is the version byte used for encoded NATS Clusters
+    Prefix[Prefix["Cluster"] = 16] = "Cluster";
+    //PrefixByteAccount is the version byte used for encoded NATS Accounts
+    Prefix[Prefix["Account"] = 0] = "Account";
+    //PrefixByteUser is the version byte used for encoded NATS Users
+    Prefix[Prefix["User"] = 160] = "User";
+    Prefix[Prefix["Curve"] = 184] = "Curve";
+})(Prefix || (exports.Prefix = Prefix = {}));
+/**
+ * @private
+ */
+class Prefixes {
+    static isValidPublicPrefix(prefix) {
+        return prefix == Prefix.Server ||
+            prefix == Prefix.Operator ||
+            prefix == Prefix.Cluster ||
+            prefix == Prefix.Account ||
+            prefix == Prefix.User ||
+            prefix == Prefix.Curve;
+    }
+    static startsWithValidPrefix(s) {
+        const c = s[0];
+        return c == "S" || c == "P" || c == "O" || c == "N" || c == "C" ||
+            c == "A" || c == "U" || c == "X";
+    }
+    static isValidPrefix(prefix) {
+        const v = this.parsePrefix(prefix);
+        return v !== Prefix.Unknown;
+    }
+    static parsePrefix(v) {
+        switch (v) {
+            case Prefix.Seed:
+                return Prefix.Seed;
+            case Prefix.Private:
+                return Prefix.Private;
+            case Prefix.Operator:
+                return Prefix.Operator;
+            case Prefix.Server:
+                return Prefix.Server;
+            case Prefix.Cluster:
+                return Prefix.Cluster;
+            case Prefix.Account:
+                return Prefix.Account;
+            case Prefix.User:
+                return Prefix.User;
+            case Prefix.Curve:
+                return Prefix.Curve;
+            default:
+                return Prefix.Unknown;
+        }
+    }
+}
+exports.Prefixes = Prefixes;
+/**
+ * Possible error codes on exceptions thrown by the library.
+ */
+var NKeysErrorCode;
+(function (NKeysErrorCode) {
+    NKeysErrorCode["InvalidPrefixByte"] = "nkeys: invalid prefix byte";
+    NKeysErrorCode["InvalidKey"] = "nkeys: invalid key";
+    NKeysErrorCode["InvalidPublicKey"] = "nkeys: invalid public key";
+    NKeysErrorCode["InvalidSeedLen"] = "nkeys: invalid seed length";
+    NKeysErrorCode["InvalidSeed"] = "nkeys: invalid seed";
+    NKeysErrorCode["InvalidCurveSeed"] = "nkeys: invalid curve seed";
+    NKeysErrorCode["InvalidCurveKey"] = "nkeys: not a valid curve key";
+    NKeysErrorCode["InvalidCurveOperation"] = "nkeys: curve key is not valid for sign/verify";
+    NKeysErrorCode["InvalidNKeyOperation"] = "keys: only curve key can seal/open";
+    NKeysErrorCode["InvalidEncoding"] = "nkeys: invalid encoded key";
+    NKeysErrorCode["InvalidRecipient"] = "nkeys: not a valid recipient public curve key";
+    NKeysErrorCode["InvalidEncrypted"] = "nkeys: encrypted input is not valid";
+    NKeysErrorCode["CannotSign"] = "nkeys: cannot sign, no private key available";
+    NKeysErrorCode["PublicKeyOnly"] = "nkeys: no seed or private key available";
+    NKeysErrorCode["InvalidChecksum"] = "nkeys: invalid checksum";
+    NKeysErrorCode["SerializationError"] = "nkeys: serialization error";
+    NKeysErrorCode["ApiError"] = "nkeys: api error";
+    NKeysErrorCode["ClearedPair"] = "nkeys: pair is cleared";
+})(NKeysErrorCode || (exports.NKeysErrorCode = NKeysErrorCode = {}));
+class NKeysError extends Error {
+    constructor(code, options) {
+        super(code, options);
+        Object.defineProperty(this, "code", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.code = code;
+    }
+}
+exports.NKeysError = NKeysError;

package/script/deps/jsr.io/@nats-io/nkeys/2.0.3/src/public.d.ts

@@ -0,0 +1,17 @@
+import { type KeyPair } from "./nkeys.js";
+/**
+ * @ignore
+ */
+export declare class PublicKey implements KeyPair {
+    publicKey?: Uint8Array;
+    constructor(publicKey: Uint8Array);
+    getPublicKey(): string;
+    getPrivateKey(): Uint8Array;
+    getSeed(): Uint8Array;
+    sign(_: Uint8Array): Uint8Array;
+    verify(input: Uint8Array, sig: Uint8Array): boolean;
+    clear(): void;
+    seal(_: Uint8Array, _recipient: string, _nonce?: Uint8Array): Uint8Array;
+    open(_: Uint8Array, _sender: string): Uint8Array | null;
+}
+//# sourceMappingURL=public.d.ts.map

package/script/deps/jsr.io/@nats-io/nkeys/2.0.3/src/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nkeys/2.0.3/src/public.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,KAAK,OAAO,EAA8B,MAAM,YAAY,CAAC;AAGtE;;GAEG;AACH,qBAAa,SAAU,YAAW,OAAO;IACvC,SAAS,CAAC,EAAE,UAAU,CAAC;gBAEX,SAAS,EAAE,UAAU;IAIjC,YAAY,IAAI,MAAM;IAOtB,aAAa,IAAI,UAAU;IAO3B,OAAO,IAAI,UAAU;IAOrB,IAAI,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU;IAO/B,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO;IAQnD,KAAK,IAAI,IAAI;IAQb,IAAI,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,UAAU,GAAG,UAAU;IAIxE,IAAI,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;CAGxD"}

package/script/deps/jsr.io/@nats-io/nkeys/2.0.3/src/public.js

@@ -0,0 +1,82 @@
+"use strict";
+/*
+ * 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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicKey = void 0;
+const codec_js_1 = require("./codec.js");
+const nkeys_js_1 = require("./nkeys.js");
+const nacl_js_1 = __importDefault(require("./nacl.js"));
+/**
+ * @ignore
+ */
+class PublicKey {
+    constructor(publicKey) {
+        Object.defineProperty(this, "publicKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.publicKey = publicKey;
+    }
+    getPublicKey() {
+        if (!this.publicKey) {
+            throw new nkeys_js_1.NKeysError(nkeys_js_1.NKeysErrorCode.ClearedPair);
+        }
+        return new TextDecoder().decode(this.publicKey);
+    }
+    getPrivateKey() {
+        if (!this.publicKey) {
+            throw new nkeys_js_1.NKeysError(nkeys_js_1.NKeysErrorCode.ClearedPair);
+        }
+        throw new nkeys_js_1.NKeysError(nkeys_js_1.NKeysErrorCode.PublicKeyOnly);
+    }
+    getSeed() {
+        if (!this.publicKey) {
+            throw new nkeys_js_1.NKeysError(nkeys_js_1.NKeysErrorCode.ClearedPair);
+        }
+        throw new nkeys_js_1.NKeysError(nkeys_js_1.NKeysErrorCode.PublicKeyOnly);
+    }
+    sign(_) {
+        if (!this.publicKey) {
+            throw new nkeys_js_1.NKeysError(nkeys_js_1.NKeysErrorCode.ClearedPair);
+        }
+        throw new nkeys_js_1.NKeysError(nkeys_js_1.NKeysErrorCode.CannotSign);
+    }
+    verify(input, sig) {
+        if (!this.publicKey) {
+            throw new nkeys_js_1.NKeysError(nkeys_js_1.NKeysErrorCode.ClearedPair);
+        }
+        const buf = codec_js_1.Codec._decode(this.publicKey);
+        return nacl_js_1.default.sign.detached.verify(input, sig, buf.slice(1));
+    }
+    clear() {
+        if (!this.publicKey) {
+            return;
+        }
+        this.publicKey.fill(0);
+        this.publicKey = undefined;
+    }
+    seal(_, _recipient, _nonce) {
+        throw new nkeys_js_1.NKeysError(nkeys_js_1.NKeysErrorCode.InvalidNKeyOperation);
+    }
+    open(_, _sender) {
+        throw new nkeys_js_1.NKeysError(nkeys_js_1.NKeysErrorCode.InvalidNKeyOperation);
+    }
+}
+exports.PublicKey = PublicKey;

package/script/deps/jsr.io/@nats-io/nkeys/2.0.3/src/util.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Encode binary data to a base64 string
+ * @param {Uint8Array} bytes to encode to base64
+ */
+export declare function encode(bytes: Uint8Array): string;
+/**
+ * Decode a base64 encoded string to a binary Uint8Array
+ * @param {string} b64str encoded string
+ */
+export declare function decode(b64str: string): Uint8Array;
+/**
+ * @ignore
+ */
+export declare function dump(buf: Uint8Array, msg?: string): void;
+//# sourceMappingURL=util.d.ts.map

package/script/deps/jsr.io/@nats-io/nkeys/2.0.3/src/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nkeys/2.0.3/src/util.ts"],"names":[],"mappings":"AAcA;;;GAGG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEhD;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAOjD;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAgBxD"}

package/script/deps/jsr.io/@nats-io/nkeys/2.0.3/src/util.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = encode;
+exports.decode = decode;
+exports.dump = dump;
+/*
+ * 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.
+ */
+/**
+ * Encode binary data to a base64 string
+ * @param {Uint8Array} bytes to encode to base64
+ */
+function encode(bytes) {
+    return btoa(String.fromCharCode(...bytes));
+}
+/**
+ * Decode a base64 encoded string to a binary Uint8Array
+ * @param {string} b64str encoded string
+ */
+function decode(b64str) {
+    const bin = atob(b64str);
+    const bytes = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) {
+        bytes[i] = bin.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * @ignore
+ */
+function dump(buf, msg) {
+    if (msg) {
+        console.log(msg);
+    }
+    const a = [];
+    for (let i = 0; i < buf.byteLength; i++) {
+        if (i % 8 === 0) {
+            a.push("\n");
+        }
+        let v = buf[i].toString(16);
+        if (v.length === 1) {
+            v = "0" + v;
+        }
+        a.push(v);
+    }
+    console.log(a.join("  "));
+}

package/script/deps/jsr.io/@nats-io/nkeys/2.0.3/src/version.d.ts

@@ -0,0 +1,2 @@
+export declare const version = "2.0.3";
+//# sourceMappingURL=version.d.ts.map

package/script/deps/jsr.io/@nats-io/nkeys/2.0.3/src/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nkeys/2.0.3/src/version.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/script/deps/jsr.io/@nats-io/nkeys/2.0.3/src/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+// this file is autogenerated - do not edit
+exports.version = "2.0.3";

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

@@ -0,0 +1,61 @@
+/**
+ * Nuid is a class that generates unique identifiers.
+ */
+export declare class Nuid {
+    /**
+     *   @hidden
+     */
+    buf: Uint8Array;
+    /**
+     *   @hidden
+     */
+    seq: number;
+    /**
+     * @hidden
+     */
+    inc: number;
+    /**
+     * @hidden
+     */
+    inited: boolean;
+    constructor();
+    /**
+     * Initializes a nuid with a crypto random prefix,
+     * and pseudo-random sequence and increment. This function
+     * is only called if any api on a nuid is called.
+     *
+     * @ignore
+     */
+    private init;
+    /**
+     * Initializes the pseudo random sequence number and the increment range.
+     * @ignore
+     */
+    private initSeqAndInc;
+    /**
+     * Sets the prefix from crypto random bytes. Converts them to base36.
+     *
+     * @ignore
+     */
+    private setPre;
+    /**
+     * Fills the sequence part of the nuid as base36 from this.seq.
+     * @ignore
+     */
+    private fillSeq;
+    /**
+     * Returns the next nuid.
+     */
+    next(): string;
+    /**
+     * Resets the prefix and counter for the nuid. This is typically
+     * called automatically from within next() if the current sequence
+     * exceeds the resolution of the nuid.
+     */
+    reset(): void;
+}
+/**
+ * A nuid instance you can use by simply calling `next()` on it.
+ */
+export declare const nuid: Nuid;
+//# sourceMappingURL=nuid.d.ts.map

package/script/deps/jsr.io/@nats-io/nuid/2.0.3/src/nuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nuid.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nats-io/nuid/2.0.3/src/nuid.ts"],"names":[],"mappings":"AAwCA;;GAEG;AACH,qBAAa,IAAI;IACf;;OAEG;IACH,GAAG,EAAE,UAAU,CAAC;IAChB;;OAEG;IACH,GAAG,EAAG,MAAM,CAAC;IACb;;OAEG;IACH,GAAG,EAAG,MAAM,CAAC;IACb;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;;IAOhB;;;;;;OAMG;IACH,OAAO,CAAC,IAAI;IAOZ;;;OAGG;IACH,OAAO,CAAC,aAAa;IAKrB;;;;OAIG;IACH,OAAO,CAAC,MAAM;IASd;;;OAGG;IACH,OAAO,CAAC,OAAO;IAQf;;OAEG;IACH,IAAI,IAAI,MAAM;IAcd;;;;OAIG;IACH,KAAK;CAGN;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,IAAiB,CAAC"}