@freesignal/protocol 0.1.7 → 0.2.0

package/crypto.js

@@ -1,156 +0,0 @@
-"use strict";
-/**
- * FreeSignal Protocol
- *
- * Copyright (C) 2025  Christian Braghette
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const js_sha3_1 = require("js-sha3");
-const tweetnacl_1 = __importDefault(require("tweetnacl"));
-const uuid_1 = require("uuid");
-const utils_1 = require("./utils");
-class CryptoConstructor {
-    constructor() {
-        this.KeyPair = {
-            isKeyPair(obj) {
-                if (typeof obj === 'object' && obj.publicKey && obj.secretKey)
-                    return true;
-                return false;
-            }
-        };
-        this.box = new CryptoConstructor.box();
-        this.ECDH = new CryptoConstructor.ECDH();
-        this.EdDSA = new CryptoConstructor.EdDSA();
-        this.UUID = new CryptoConstructor.UUID();
-        this.randomBytes = tweetnacl_1.default.randomBytes;
-    }
-    hash(message, algorithm = 'sha256') {
-        switch (algorithm) {
-            case 'sha224':
-                return new Uint8Array(js_sha3_1.sha3_224.digest(message));
-            case 'sha256':
-                return new Uint8Array(js_sha3_1.sha3_256.digest(message));
-            case 'sha384':
-                return new Uint8Array(js_sha3_1.sha3_384.digest(message));
-            case 'sha512':
-                return new Uint8Array(js_sha3_1.sha3_512.digest(message));
-            default:
-                throw new Error("Error hashing");
-        }
-    }
-    hmac(key, message, length = 32, algorithm = 'kmac256') {
-        length *= 8;
-        switch (algorithm) {
-            case 'kmac128':
-                return new Uint8Array(js_sha3_1.kmac128.digest(key, message, length, new Uint8Array()));
-            case 'kmac256':
-                return new Uint8Array(js_sha3_1.kmac256.digest(key, message, length, new Uint8Array()));
-            default:
-                throw new Error("Error hashing");
-        }
-    }
-    hkdf(key, salt, info, length = 32) {
-        return new Uint8Array(js_sha3_1.kmac256.digest(key, salt, length * 8, info !== null && info !== void 0 ? info : new Uint8Array()));
-    }
-    scalarMult(n, p) {
-        return tweetnacl_1.default.scalarMult(n, p);
-    }
-}
-(function (CryptoConstructor) {
-    class box {
-        constructor() {
-            this.keyLength = tweetnacl_1.default.secretbox.keyLength;
-            this.nonceLength = tweetnacl_1.default.secretbox.nonceLength;
-        }
-        encrypt(msg, nonce, key) {
-            return tweetnacl_1.default.secretbox(msg, nonce, key);
-        }
-        decrypt(msg, nonce, key) {
-            var _a;
-            return (_a = tweetnacl_1.default.secretbox.open(msg, nonce, key)) !== null && _a !== void 0 ? _a : undefined;
-        }
-    }
-    CryptoConstructor.box = box;
-    class ECDH {
-        constructor() {
-            this.publicKeyLength = tweetnacl_1.default.box.publicKeyLength;
-            this.secretKeyLength = tweetnacl_1.default.box.secretKeyLength;
-        }
-        keyPair(secretKey) {
-            if (secretKey)
-                return tweetnacl_1.default.box.keyPair.fromSecretKey(secretKey);
-            return tweetnacl_1.default.box.keyPair();
-        }
-        sharedKey(publicKey, secretKey) {
-            return tweetnacl_1.default.scalarMult(publicKey, secretKey);
-        }
-    }
-    CryptoConstructor.ECDH = ECDH;
-    class EdDSA {
-        constructor() {
-            this.publicKeyLength = tweetnacl_1.default.sign.publicKeyLength;
-            this.secretKeyLength = tweetnacl_1.default.sign.secretKeyLength;
-            this.signatureLength = tweetnacl_1.default.sign.signatureLength;
-            this.seedLength = tweetnacl_1.default.sign.seedLength;
-        }
-        keyPair(secretKey) {
-            if (secretKey)
-                return tweetnacl_1.default.sign.keyPair.fromSecretKey(secretKey);
-            return tweetnacl_1.default.sign.keyPair();
-        }
-        keyPairFromSeed(seed) {
-            return tweetnacl_1.default.sign.keyPair.fromSeed(seed);
-        }
-        sign(msg, secretKey) {
-            return tweetnacl_1.default.sign.detached(msg, secretKey);
-        }
-        verify(msg, sig, publicKey) {
-            return tweetnacl_1.default.sign.detached.verify(msg, sig, publicKey);
-        }
-    }
-    CryptoConstructor.EdDSA = EdDSA;
-    class UUID {
-        generate() {
-            return new UUIDv4();
-        }
-        stringify(arr, offset) {
-            return (0, uuid_1.stringify)(arr, offset);
-        }
-        parse(uuid) {
-            return (0, uuid_1.parse)(uuid);
-        }
-    }
-    CryptoConstructor.UUID = UUID;
-    class UUIDv4 {
-        constructor() {
-            this.value = (0, uuid_1.v4)();
-        }
-        toString() {
-            return this.value;
-        }
-        toJSON() {
-            return this.value;
-        }
-        toBuffer() {
-            return (0, utils_1.decodeUTF8)(this.value);
-        }
-    }
-})(CryptoConstructor || (CryptoConstructor = {}));
-const crypto = new CryptoConstructor();
-exports.default = crypto;

package/data.d.ts

@@ -1,67 +0,0 @@
-/**
- * FreeSignal Protocol
- *
- * Copyright (C) 2025  Christian Braghette
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>
- */
-import { Encodable } from "./types";
-export declare enum Protocols {
-    NULL = "",
-    MESSAGE = "/freesignal/message/1.0.0",
-    RELAY = "/freesignal/relay/1.0.0"
-}
-export declare namespace Protocols {
-    function isProtocol(protocol: any): boolean;
-    function fromCode(code: number): Protocols;
-    function toCode(protocol: Protocols): number;
-    function encode(protocol: Protocols, length?: number): Uint8Array;
-    function decode(array: Uint8Array): Protocols;
-}
-export interface Datagram {
-    readonly id: string;
-    readonly version: number;
-    readonly senderKey: string;
-    readonly senderRelay?: string;
-    readonly receiverKey: string;
-    readonly receiverRelay?: string;
-    readonly protocol: Protocols;
-    readonly createdAt: number;
-    payload?: Uint8Array;
-}
-export declare namespace Datagram {
-    const version = 1;
-    function create(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable): DatagramConstructor;
-    function isDatagram(obj: any): boolean;
-    function from(data: Uint8Array | Datagram | string): DatagramConstructor;
-}
-declare class DatagramConstructor implements Encodable, Datagram {
-    readonly id: string;
-    readonly version: number;
-    readonly senderKey: string;
-    readonly senderRelay?: string;
-    readonly receiverKey: string;
-    readonly receiverRelay?: string;
-    readonly protocol: Protocols;
-    readonly createdAt: number;
-    payload?: Uint8Array;
-    private static headerOffset;
-    constructor(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable);
-    constructor(data: Uint8Array | Datagram);
-    encode(compression?: boolean): Uint8Array;
-    encodeSigned(secretKey: Uint8Array, compression?: boolean): Uint8Array;
-    toString(): string;
-    toJSON(): string;
-}
-export {};

package/data.js

@@ -1,181 +0,0 @@
-"use strict";
-/**
- * FreeSignal Protocol
- *
- * Copyright (C) 2025  Christian Braghette
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Datagram = exports.Protocols = void 0;
-const utils_1 = require("./utils");
-const crypto_1 = __importDefault(require("./crypto"));
-const fflate_1 = __importDefault(require("fflate"));
-var Protocols;
-(function (Protocols) {
-    Protocols["NULL"] = "";
-    Protocols["MESSAGE"] = "/freesignal/message/1.0.0";
-    Protocols["RELAY"] = "/freesignal/relay/1.0.0";
-})(Protocols || (exports.Protocols = Protocols = {}));
-(function (Protocols) {
-    function isProtocol(protocol) {
-        return Object.values(Protocols).includes(protocol);
-    }
-    Protocols.isProtocol = isProtocol;
-    function fromCode(code) {
-        return Object.values(Protocols)[code];
-    }
-    Protocols.fromCode = fromCode;
-    function toCode(protocol) {
-        return Object.values(Protocols).indexOf(protocol);
-    }
-    Protocols.toCode = toCode;
-    function encode(protocol, length) {
-        /*const raw = numberToUint8Array(Protocols.toCode(protocol), length).reverse();
-        raw[0] |= (raw.length - 1) << 6;
-        return raw;*/
-        return (0, utils_1.numberToUint8Array)(Protocols.toCode(protocol), length !== null && length !== void 0 ? length : 4, 'big');
-    }
-    Protocols.encode = encode;
-    function decode(array) {
-        array[0] &= 63;
-        array = array.reverse();
-        return Protocols.fromCode((0, utils_1.numberFromUint8Array)(array));
-    }
-    Protocols.decode = decode;
-})(Protocols || (exports.Protocols = Protocols = {}));
-var Datagram;
-(function (Datagram) {
-    Datagram.version = 1;
-    function create(sender, receiver, protocol, payload) {
-        return new DatagramConstructor(sender, receiver, protocol, payload);
-    }
-    Datagram.create = create;
-    function isDatagram(obj) {
-        return obj instanceof DatagramConstructor || (obj && typeof obj === 'object' && 'id' in obj && 'version' in obj && 'sender' in obj && 'receiver' in obj && 'protocol' in obj && 'createdAt' in obj);
-    }
-    Datagram.isDatagram = isDatagram;
-    function from(data) {
-        if (typeof data === 'string') {
-            const decoded = (0, utils_1.decodeBase64)(data);
-            return new DatagramConstructor(decoded);
-        }
-        else
-            return new DatagramConstructor(data);
-    }
-    Datagram.from = from;
-})(Datagram || (exports.Datagram = Datagram = {}));
-class DatagramConstructor {
-    constructor(data, receiver, protocol, payload) {
-        if (!receiver && !protocol && !payload) {
-            if (data instanceof Uint8Array) {
-                this.version = data[0] & 63;
-                this.protocol = Protocols.decode(data.subarray(1, 4));
-                this.id = crypto_1.default.UUID.stringify(data.subarray(4, 20));
-                this.createdAt = (0, utils_1.numberFromUint8Array)(data.subarray(20, 28));
-                this.senderKey = (0, utils_1.encodeBase64)(data.subarray(28, 28 + crypto_1.default.EdDSA.publicKeyLength));
-                this.receiverKey = (0, utils_1.encodeBase64)(data.subarray(28 + crypto_1.default.EdDSA.publicKeyLength, DatagramConstructor.headerOffset));
-                const senderRelayOffset = data.indexOf(255, DatagramConstructor.headerOffset);
-                const receiverRelayOffset = data.indexOf(255, senderRelayOffset + 1);
-                this.senderRelay = (0, utils_1.encodeUTF8)(data.subarray(DatagramConstructor.headerOffset, senderRelayOffset)) ? "" : undefined;
-                this.receiverRelay = (0, utils_1.encodeUTF8)(data.subarray(senderRelayOffset + 1, receiverRelayOffset)) ? "" : undefined;
-                if (data[0] & 128) {
-                    const signature = data.subarray(data.length - crypto_1.default.EdDSA.signatureLength);
-                    if (!crypto_1.default.EdDSA.verify(data.subarray(0, data.length - crypto_1.default.EdDSA.signatureLength), signature, data.subarray(28, 28 + crypto_1.default.EdDSA.publicKeyLength)))
-                        throw new Error('Invalid signature for Datagram');
-                }
-                if (data[0] & 64)
-                    this.payload = fflate_1.default.inflateSync(data.subarray(receiverRelayOffset + 1, data.length));
-                else
-                    this.payload = data.subarray(receiverRelayOffset + 1, data.length);
-            }
-            else if (Datagram.isDatagram(data)) {
-                const datagram = data;
-                this.id = datagram.id;
-                this.version = datagram.version;
-                this.senderKey = datagram.senderKey;
-                this.receiverKey = datagram.receiverKey;
-                this.protocol = datagram.protocol;
-                this.createdAt = datagram.createdAt;
-                this.senderRelay = datagram.senderRelay;
-                this.receiverRelay = datagram.receiverRelay;
-                this.payload = datagram.payload;
-            }
-            else
-                throw new Error('Invalid constructor arguments for Datagram');
-        }
-        else if (typeof data === 'string' || data instanceof Uint8Array) {
-            this.id = crypto_1.default.UUID.generate().toString();
-            this.version = Datagram.version;
-            if (typeof data === 'string') {
-                const address = data.split('@');
-                this.senderKey = address[0];
-                this.senderRelay = address[1];
-            }
-            else
-                this.senderKey = (0, utils_1.encodeBase64)(data);
-            if (typeof receiver === 'string') {
-                const address = receiver.split('@');
-                this.receiverKey = address[0];
-                this.receiverRelay = address[1];
-            }
-            else
-                this.receiverKey = (0, utils_1.encodeBase64)(receiver);
-            this.protocol = protocol;
-            this.createdAt = Date.now();
-            this.payload = payload instanceof Uint8Array ? payload : payload === null || payload === void 0 ? void 0 : payload.encode();
-        }
-        else
-            throw new Error('Invalid constructor arguments for Datagram');
-    }
-    encode(compression = true) {
-        var _a;
-        compression = compression && this.payload != undefined && this.payload.length > 1024;
-        return (0, utils_1.concatUint8Array)(new Uint8Array(1).fill(this.version | (compression ? 64 : 0)), //1
-        Protocols.encode(this.protocol, 3), //3
-        (_a = crypto_1.default.UUID.parse(this.id)) !== null && _a !== void 0 ? _a : [], //16
-        (0, utils_1.numberToUint8Array)(this.createdAt, 8), //8
-        (0, utils_1.decodeBase64)(this.senderKey), //32
-        (0, utils_1.decodeBase64)(this.receiverKey), //32
-        ...(this.senderRelay ? [(0, utils_1.decodeUTF8)(this.senderRelay)] : []), new Uint8Array(1).fill(255), ...(this.receiverRelay ? [(0, utils_1.decodeUTF8)(this.receiverRelay)] : []), new Uint8Array(1).fill(255), ...(this.payload ? [compression ? fflate_1.default.deflateSync(this.payload) : this.payload] : []));
-    }
-    encodeSigned(secretKey, compression) {
-        //if (!this.payload) throw new Error('Cannot sign a datagram without payload');
-        const header = this.encode(compression);
-        header[0] |= 128; // Set the sign bit
-        const signature = crypto_1.default.EdDSA.sign(header, secretKey);
-        return (0, utils_1.concatUint8Array)(header, signature);
-    }
-    toString() {
-        return (0, utils_1.encodeBase64)(this.encode());
-    }
-    toJSON() {
-        /*return JSON.stringify({
-            id: this.id,
-            version: this.version,
-            senderKey: this.senderKey,
-            senderRelay: this.senderRelay,
-            receiverKey: this.receiverKey,
-            receiverRelay: this.receiverRelay,
-            protocol: this.protocol,
-            createdAt: this.createdAt,
-            payload: this.payload ? encodeBase64(this.payload) : undefined
-        });*/
-        return this.toString();
-    }
-}
-DatagramConstructor.headerOffset = 28 + crypto_1.default.EdDSA.publicKeyLength * 2;

package/utils.d.ts

@@ -1,78 +0,0 @@
-/**
- * FreeSignal Protocol
- *
- * Copyright (C) 2025  Christian Braghette
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>
- */
-/**
- * Decodes a Uint8Array into a UTF-8 string.
- *
- * @param array - The input byte array.
- * @returns The UTF-8 encoded string.
- */
-export declare function encodeUTF8(array?: Uint8Array): string;
-/**
- * Encodes a UTF-8 string into a Uint8Array.
- *
- * @param string - The input string.
- * @returns The resulting Uint8Array.
- */
-export declare function decodeUTF8(string?: string): Uint8Array;
-/**
- * Encodes a Uint8Array into a Base64 string.
- *
- * @param array - The input byte array.
- * @returns The Base64 encoded string.
- */
-export declare function encodeBase64(array?: Uint8Array): string;
-/**
- * Decodes a Base64 string into a Uint8Array.
- *
- * @param string - The Base64 string.
- * @returns The decoded Uint8Array.
- */
-export declare function decodeBase64(string?: string): Uint8Array;
-export declare function encodeHex(array?: Uint8Array): string;
-export declare function decodeHex(string?: string): Uint8Array;
-/**
- * Converts a Uint8Array into a number.
- *
- * @param array - The input byte array.
- * @returns The resulting number.
- */
-export declare function numberFromUint8Array(array?: Uint8Array, endian?: 'big' | 'little'): number;
-/**
- * Converts a number into a Uint8Array of specified length.
- *
- * @param number - The number to convert.
- * @param length - The desired output length.
- * @returns A Uint8Array representing the number.
- */
-export declare function numberToUint8Array(number?: number, length?: number, endian?: 'big' | 'little'): Uint8Array;
-/**
- * Compare Uint8Arrays.
- *
- * @param a - First Uint8Array to compare to.
- * @param b - Arrays to compare to the first one.
- * @returns A boolean value.
- */
-export declare function verifyUint8Array(a?: Uint8Array, ...b: (Uint8Array | undefined)[]): boolean;
-/**
- * Concat Uint8Arrays.
- *
- * @param arrays - Uint8Array to concat.
- * @returns A Uint8Array
- */
-export declare function concatUint8Array(...arrays: Uint8Array[]): Uint8Array;

package/utils.js

@@ -1,146 +0,0 @@
-"use strict";
-/**
- * FreeSignal Protocol
- *
- * Copyright (C) 2025  Christian Braghette
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeUTF8 = encodeUTF8;
-exports.decodeUTF8 = decodeUTF8;
-exports.encodeBase64 = encodeBase64;
-exports.decodeBase64 = decodeBase64;
-exports.encodeHex = encodeHex;
-exports.decodeHex = decodeHex;
-exports.numberFromUint8Array = numberFromUint8Array;
-exports.numberToUint8Array = numberToUint8Array;
-exports.verifyUint8Array = verifyUint8Array;
-exports.concatUint8Array = concatUint8Array;
-const base64_js_1 = require("base64-js");
-const tweetnacl_1 = require("tweetnacl");
-/**
- * Decodes a Uint8Array into a UTF-8 string.
- *
- * @param array - The input byte array.
- * @returns The UTF-8 encoded string.
- */
-function encodeUTF8(array) {
-    return new TextDecoder().decode(array);
-}
-/**
- * Encodes a UTF-8 string into a Uint8Array.
- *
- * @param string - The input string.
- * @returns The resulting Uint8Array.
- */
-function decodeUTF8(string) {
-    return new TextEncoder().encode(string);
-}
-/**
- * Encodes a Uint8Array into a Base64 string.
- *
- * @param array - The input byte array.
- * @returns The Base64 encoded string.
- */
-function encodeBase64(array) {
-    return (0, base64_js_1.fromByteArray)(array !== null && array !== void 0 ? array : new Uint8Array());
-}
-/**
- * Decodes a Base64 string into a Uint8Array.
- *
- * @param string - The Base64 string.
- * @returns The decoded Uint8Array.
- */
-function decodeBase64(string) {
-    return (0, base64_js_1.toByteArray)(string !== null && string !== void 0 ? string : "");
-}
-function encodeHex(array) {
-    var _a;
-    return Array.from((_a = array === null || array === void 0 ? void 0 : array.values()) !== null && _a !== void 0 ? _a : []).map(value => value.toString(16).padStart(2, '0')).join('');
-}
-function decodeHex(string) {
-    return new Uint8Array(!string ? [] :
-        Array.from(string).reduce((prev, curr, index) => {
-            if (index % 2 === 0)
-                prev.push(curr);
-            else
-                prev[prev.length - 1] += curr;
-            return prev;
-        }, []).map(value => Number.parseInt(value, 16)));
-}
-/**
- * Converts a Uint8Array into a number.
- *
- * @param array - The input byte array.
- * @returns The resulting number.
- */
-function numberFromUint8Array(array, endian = 'little') {
-    let total = 0;
-    if (array) {
-        if (endian === 'big')
-            array = array.reverse();
-        for (let c = 0; c < array.length; c++)
-            total += array[c] << (c * 8);
-    }
-    return total;
-}
-/**
- * Converts a number into a Uint8Array of specified length.
- *
- * @param number - The number to convert.
- * @param length - The desired output length.
- * @returns A Uint8Array representing the number.
- */
-function numberToUint8Array(number, length, endian = 'little') {
-    if (!number)
-        return new Uint8Array(length !== null && length !== void 0 ? length : 0).fill(0);
-    const arr = [];
-    while (number > 0) {
-        arr.push(number & 255);
-        number = number >>> 8;
-    }
-    const out = new Uint8Array(length !== null && length !== void 0 ? length : arr.length);
-    out.set(arr);
-    return endian === 'little' ? out : out.reverse();
-}
-/**
- * Compare Uint8Arrays.
- *
- * @param a - First Uint8Array to compare to.
- * @param b - Arrays to compare to the first one.
- * @returns A boolean value.
- */
-function verifyUint8Array(a, ...b) {
-    b = b.filter(value => value !== undefined);
-    if (!a || b.length === 0)
-        return false;
-    return b.every(b => (0, tweetnacl_1.verify)(a, b));
-}
-/**
- * Concat Uint8Arrays.
- *
- * @param arrays - Uint8Array to concat.
- * @returns A Uint8Array
- */
-function concatUint8Array(...arrays) {
-    //arrays = arrays.filter(array => array != undefined);
-    const out = new Uint8Array(arrays.map(value => value.length).reduce((prev, curr) => prev + curr));
-    let offset = 0;
-    arrays.forEach(array => {
-        out.set(array, offset);
-        offset += array.length;
-    });
-    return out;
-}