shogun-core 6.2.4 → 6.3.0

package/dist/src/crypto/file-encryption.js

@@ -0,0 +1,352 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { deriveKeyFromPassword } from "./symmetric.js";
+import { arrayBufferToBase64, base64ToArrayBuffer } from "./hashing.js";
+export var encryptFile = function (fileContent_1, password_1) {
+    var args_1 = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args_1[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([fileContent_1, password_1], __read(args_1), false), void 0, function (fileContent, password, fileName) {
+        var _a, key, salt, iv, dataToEncrypt, encryptedData, error_1;
+        if (fileName === void 0) { fileName = ""; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 8, , 9]);
+                    return [4 /*yield*/, deriveKeyFromPassword(password)];
+                case 1:
+                    _a = _b.sent(), key = _a.key, salt = _a.salt;
+                    iv = crypto.getRandomValues(new Uint8Array(12));
+                    dataToEncrypt = void 0;
+                    if (!(typeof fileContent === "string")) return [3 /*break*/, 2];
+                    dataToEncrypt = new TextEncoder().encode(fileContent).buffer;
+                    return [3 /*break*/, 6];
+                case 2:
+                    if (!(fileContent instanceof ArrayBuffer)) return [3 /*break*/, 3];
+                    dataToEncrypt = fileContent;
+                    return [3 /*break*/, 6];
+                case 3:
+                    if (!(fileContent instanceof File)) return [3 /*break*/, 5];
+                    return [4 /*yield*/, fileContent.arrayBuffer()];
+                case 4:
+                    dataToEncrypt = _b.sent();
+                    return [3 /*break*/, 6];
+                case 5: throw new Error("Unsupported file content type");
+                case 6: return [4 /*yield*/, crypto.subtle.encrypt({
+                        name: "AES-GCM",
+                        iv: iv,
+                    }, key, dataToEncrypt)];
+                case 7:
+                    encryptedData = _b.sent();
+                    // Return encrypted package
+                    return [2 /*return*/, {
+                            encryptedData: arrayBufferToBase64(encryptedData),
+                            iv: arrayBufferToBase64(iv.buffer),
+                            salt: arrayBufferToBase64(salt),
+                            fileName: fileName,
+                            timestamp: new Date().toISOString(),
+                            originalSize: dataToEncrypt.byteLength,
+                        }];
+                case 8:
+                    error_1 = _b.sent();
+                    console.error("Error encrypting file:", error_1);
+                    throw error_1 instanceof Error ? error_1 : new Error("Unknown error occurred");
+                case 9: return [2 /*return*/];
+            }
+        });
+    });
+};
+export var decryptFile = function (encryptedPackage, password) { return __awaiter(void 0, void 0, void 0, function () {
+    var encryptedData, iv, salt, fileName, originalSize, saltBuffer, ivBuffer, dataBuffer, key, decryptedData, error_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 3, , 4]);
+                encryptedData = encryptedPackage.encryptedData, iv = encryptedPackage.iv, salt = encryptedPackage.salt, fileName = encryptedPackage.fileName, originalSize = encryptedPackage.originalSize;
+                saltBuffer = base64ToArrayBuffer(salt);
+                ivBuffer = base64ToArrayBuffer(iv);
+                dataBuffer = base64ToArrayBuffer(encryptedData);
+                return [4 /*yield*/, deriveKeyFromPassword(password, saltBuffer)];
+            case 1:
+                key = (_a.sent()).key;
+                return [4 /*yield*/, crypto.subtle.decrypt({
+                        name: "AES-GCM",
+                        iv: ivBuffer,
+                    }, key, dataBuffer)];
+            case 2:
+                decryptedData = _a.sent();
+                return [2 /*return*/, {
+                        data: decryptedData,
+                        fileName: fileName,
+                        originalSize: originalSize,
+                        decryptedSize: decryptedData.byteLength,
+                    }];
+            case 3:
+                error_2 = _a.sent();
+                console.error("Error decrypting file:", error_2);
+                throw new Error("Failed to decrypt file. Check password and try again.");
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+export var encryptTextFile = function (textContent_1, password_1) {
+    var args_1 = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args_1[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([textContent_1, password_1], __read(args_1), false), void 0, function (textContent, password, fileName) {
+        if (fileName === void 0) { fileName = "encrypted.txt"; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, encryptFile(textContent, password, fileName)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+};
+export var decryptTextFile = function (encryptedPackage, password) { return __awaiter(void 0, void 0, void 0, function () {
+    var result, textContent;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, decryptFile(encryptedPackage, password)];
+            case 1:
+                result = _a.sent();
+                textContent = new TextDecoder().decode(result.data);
+                return [2 /*return*/, __assign(__assign({}, result), { textContent: textContent })];
+        }
+    });
+}); };
+export var encryptBinaryFile = function (file, password) { return __awaiter(void 0, void 0, void 0, function () {
+    var encryptedPackage;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!(file instanceof File)) {
+                    throw new Error("Expected File object for binary encryption");
+                }
+                return [4 /*yield*/, encryptFile(file, password, file.name)];
+            case 1:
+                encryptedPackage = _a.sent();
+                return [2 /*return*/, __assign(__assign({}, encryptedPackage), { mimeType: file.type, fileSize: file.size })];
+        }
+    });
+}); };
+export var decryptBinaryFile = function (encryptedPackage, password) { return __awaiter(void 0, void 0, void 0, function () {
+    var result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, decryptFile(encryptedPackage, password)];
+            case 1:
+                result = _a.sent();
+                return [2 /*return*/, __assign(__assign({}, result), { blob: new Blob([result.data], {
+                            type: encryptedPackage.mimeType || "application/octet-stream",
+                        }), mimeType: encryptedPackage.mimeType })];
+        }
+    });
+}); };
+export var createSecureFileDownload = function (data, fileName, mimeType) {
+    if (mimeType === void 0) { mimeType = "application/octet-stream"; }
+    var blob;
+    if (data instanceof ArrayBuffer) {
+        blob = new Blob([data], { type: mimeType });
+    }
+    else if (typeof data === "string") {
+        blob = new Blob([data], { type: "text/plain" });
+    }
+    else {
+        blob = data; // Assume it's already a Blob
+    }
+    var url = URL.createObjectURL(blob);
+    var a = document.createElement("a");
+    a.href = url;
+    a.download = fileName;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+};
+export var parseEncryptedFilePackage = function (file) { return __awaiter(void 0, void 0, void 0, function () {
+    var content, parsed, requiredProperties, requiredProperties_1, requiredProperties_1_1, prop, error_3;
+    var e_1, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _b.trys.push([0, 2, , 3]);
+                return [4 /*yield*/, file.text()];
+            case 1:
+                content = _b.sent();
+                parsed = JSON.parse(content);
+                requiredProperties = [
+                    "encryptedData",
+                    "iv",
+                    "salt",
+                    "fileName",
+                    "timestamp",
+                    "originalSize",
+                ];
+                try {
+                    for (requiredProperties_1 = __values(requiredProperties), requiredProperties_1_1 = requiredProperties_1.next(); !requiredProperties_1_1.done; requiredProperties_1_1 = requiredProperties_1.next()) {
+                        prop = requiredProperties_1_1.value;
+                        if (!parsed.hasOwnProperty(prop)) {
+                            throw new Error("Missing required property: ".concat(prop));
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (requiredProperties_1_1 && !requiredProperties_1_1.done && (_a = requiredProperties_1.return)) _a.call(requiredProperties_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                // Validate data types
+                if (typeof parsed.encryptedData !== "string") {
+                    throw new Error("encryptedData must be a base64 string");
+                }
+                if (typeof parsed.iv !== "string") {
+                    throw new Error("iv must be a base64 string");
+                }
+                if (typeof parsed.salt !== "string") {
+                    throw new Error("salt must be a base64 string");
+                }
+                if (typeof parsed.fileName !== "string") {
+                    throw new Error("fileName must be a string");
+                }
+                if (typeof parsed.originalSize !== "number") {
+                    throw new Error("originalSize must be a number");
+                }
+                return [2 /*return*/, {
+                        isValid: true,
+                        package: parsed,
+                        metadata: {
+                            fileName: parsed.fileName,
+                            originalSize: parsed.originalSize,
+                            timestamp: parsed.timestamp,
+                            type: parsed.type || "unknown",
+                            mimeType: parsed.mimeType || null,
+                        },
+                    }];
+            case 2:
+                error_3 = _b.sent();
+                return [2 /*return*/, {
+                        isValid: false,
+                        error: error_3 instanceof Error ? error_3.message : "Unknown error occurred",
+                        package: undefined,
+                        metadata: undefined,
+                    }];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+export var decryptUploadedFile = function (encryptedFilePackage, password) { return __awaiter(void 0, void 0, void 0, function () {
+    var validation, pkg, metadata, decryptedResult, error_4, errorMessage;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _b.trys.push([0, 3, , 4]);
+                return [4 /*yield*/, parseEncryptedFilePackage(encryptedFilePackage)];
+            case 1:
+                validation = _b.sent();
+                if (!validation.isValid) {
+                    throw new Error("Invalid encrypted file package: ".concat(validation.error));
+                }
+                pkg = validation.package, metadata = validation.metadata;
+                return [4 /*yield*/, decryptFile(pkg, password)];
+            case 2:
+                decryptedResult = _b.sent();
+                // Return enhanced result with metadata
+                return [2 /*return*/, __assign(__assign({}, decryptedResult), { isTextFile: (metadata === null || metadata === void 0 ? void 0 : metadata.type) === "text" || ((_a = metadata === null || metadata === void 0 ? void 0 : metadata.mimeType) === null || _a === void 0 ? void 0 : _a.startsWith("text/")), textContent: (metadata === null || metadata === void 0 ? void 0 : metadata.type) === "text"
+                            ? new TextDecoder().decode(decryptedResult.data)
+                            : undefined })];
+            case 3:
+                error_4 = _b.sent();
+                console.error("Error decrypting uploaded file:", error_4);
+                errorMessage = error_4 instanceof Error ? error_4.message : "Unknown error occurred";
+                throw new Error("Failed to decrypt uploaded file: ".concat(errorMessage));
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };

package/dist/src/crypto/hashing.js

@@ -0,0 +1,160 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+// Cryptographically Random String Generator
+export var randomString = function (additionalSalt) {
+    if (additionalSalt === void 0) { additionalSalt = ""; }
+    var randomStringLength = 16;
+    var randomValues = crypto.getRandomValues(new Uint8Array(randomStringLength));
+    var randomHex = Array.from(randomValues)
+        .map(function (byte) { return byte.toString(16).padStart(2, "0"); })
+        .join("");
+    return additionalSalt ? additionalSalt + randomHex : randomHex;
+};
+// Hashing Methods
+export var sha256Hash = function (input) { return __awaiter(void 0, void 0, void 0, function () {
+    var inputString, encoder, data, hashBuffer, hashArray;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                inputString = JSON.stringify(input);
+                encoder = new TextEncoder();
+                data = encoder.encode(inputString);
+                return [4 /*yield*/, crypto.subtle.digest("SHA-256", data)];
+            case 1:
+                hashBuffer = _a.sent();
+                hashArray = Array.from(new Uint8Array(hashBuffer));
+                return [2 /*return*/, hashArray.map(function (byte) { return byte.toString(16).padStart(2, "0"); }).join("")];
+        }
+    });
+}); };
+export var sha512Hash = function (input) { return __awaiter(void 0, void 0, void 0, function () {
+    var inputString, encoder, data, hashBuffer, hashArray;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                inputString = JSON.stringify(input);
+                encoder = new TextEncoder();
+                data = encoder.encode(inputString);
+                return [4 /*yield*/, crypto.subtle.digest("SHA-512", data)];
+            case 1:
+                hashBuffer = _a.sent();
+                hashArray = Array.from(new Uint8Array(hashBuffer));
+                return [2 /*return*/, hashArray.map(function (byte) { return byte.toString(16).padStart(2, "0"); }).join("")];
+        }
+    });
+}); };
+export var sha3_512Hash = function (input) { return __awaiter(void 0, void 0, void 0, function () {
+    var inputString, encoder, data, hashBuffer, hashArray;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                inputString = JSON.stringify(input);
+                encoder = new TextEncoder();
+                data = encoder.encode(inputString);
+                return [4 /*yield*/, crypto.subtle.digest("SHA-512", data)];
+            case 1:
+                hashBuffer = _a.sent();
+                hashArray = Array.from(new Uint8Array(hashBuffer));
+                return [2 /*return*/, hashArray.map(function (byte) { return byte.toString(16).padStart(2, "0"); }).join("")];
+        }
+    });
+}); };
+// Utility functions for crypto operations
+export var bufferToHex = function (buffer) {
+    return Array.from(new Uint8Array(buffer))
+        .map(function (b) { return b.toString(16).padStart(2, "0"); })
+        .join("");
+};
+export var hexToBuffer = function (hex) {
+    var bytes = new Uint8Array(hex.length / 2);
+    for (var i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+    }
+    return bytes.buffer;
+};
+export var concatArrayBuffers = function () {
+    var e_1, _a;
+    var buffers = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        buffers[_i] = arguments[_i];
+    }
+    var totalLength = buffers.reduce(function (sum, buf) { return sum + buf.byteLength; }, 0);
+    var result = new Uint8Array(totalLength);
+    var offset = 0;
+    try {
+        for (var buffers_1 = __values(buffers), buffers_1_1 = buffers_1.next(); !buffers_1_1.done; buffers_1_1 = buffers_1.next()) {
+            var buffer = buffers_1_1.value;
+            result.set(new Uint8Array(buffer), offset);
+            offset += buffer.byteLength;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (buffers_1_1 && !buffers_1_1.done && (_a = buffers_1.return)) _a.call(buffers_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return result.buffer;
+};
+export var base64ToArrayBuffer = function (base64) {
+    var binaryString = atob(base64);
+    var bytes = new Uint8Array(binaryString.length);
+    for (var i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes.buffer;
+};
+export var arrayBufferToBase64 = function (buffer) {
+    var bytes = new Uint8Array(buffer);
+    var binary = "";
+    for (var i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+};

package/dist/src/crypto/index.js

@@ -0,0 +1,18 @@
+// Crypto module exports for shogun-core
+export * from "./symmetric.js";
+export * from "./asymmetric.js";
+export * from "./hashing.js";
+export * from "./file-encryption.js";
+export * from "./signal-protocol.js";
+export * from "./double-ratchet.js";
+export * from "./random-generation.js";
+// RFC-compliant MLS and SFrame implementations
+export * from "./mls.js";
+export * from "./mls-codec.js";
+export * from "./sframe.js";
+// PGP/OpenPGP implementation
+export * from "./pgp.js";
+export * from "./types.js";
+export * from "./utils.js";
+// Main crypto provider (only for React apps)
+// export { CryptoProvider, useCrypto } from './provider.js';

package/dist/{crypto → src/crypto}/mls-codec.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * MLS Message encoding/decoding utilities
  *
@@ -6,15 +5,6 @@
  * we'll use JSON serialization with Uint8Array and BigInt conversion for transmission.
  * This works for KeyPackage, Welcome, Commit, and other MLS messages.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeKeyPackage = encodeKeyPackage;
-exports.decodeKeyPackage = decodeKeyPackage;
-exports.encodeWelcome = encodeWelcome;
-exports.decodeWelcome = decodeWelcome;
-exports.encodeCommit = encodeCommit;
-exports.decodeCommit = decodeCommit;
-exports.encodeRatchetTree = encodeRatchetTree;
-exports.decodeRatchetTree = decodeRatchetTree;
 /**
  * Convert Uint8Array and BigInt to regular array/string recursively
  */
@@ -33,8 +23,8 @@ function uint8ArrayToArray(obj) {
         return obj.map(uint8ArrayToArray);
     }
     if (typeof obj === "object") {
-        const result = {};
-        for (const key in obj) {
+        var result = {};
+        for (var key in obj) {
             if (obj.hasOwnProperty(key)) {
                 result[key] = uint8ArrayToArray(obj[key]);
             }
@@ -65,15 +55,15 @@ function arrayToUint8Array(obj) {
     }
     if (typeof obj === "object") {
         // Check if this is an array-like object with sequential numeric keys
-        const keys = Object.keys(obj);
-        const isArrayLike = keys.length > 0 && keys.every((key, index) => key === String(index));
+        var keys = Object.keys(obj);
+        var isArrayLike = keys.length > 0 && keys.every(function (key, index) { return key === String(index); });
         if (isArrayLike) {
             // Convert object with numeric keys back to array
             console.log("🔧 [mlsCodec] Converting array-like object to array, length:", keys.length);
-            return keys.map((key) => arrayToUint8Array(obj[key]));
+            return keys.map(function (key) { return arrayToUint8Array(obj[key]); });
         }
-        const result = {};
-        for (const key in obj) {
+        var result = {};
+        for (var key in obj) {
             if (obj.hasOwnProperty(key)) {
                 result[key] = arrayToUint8Array(obj[key]);
             }
@@ -85,59 +75,59 @@ function arrayToUint8Array(obj) {
 /**
  * Encode a KeyPackage to JSON string for transmission
  */
-function encodeKeyPackage(keyPackage) {
+export function encodeKeyPackage(keyPackage) {
     // Convert Uint8Arrays to regular arrays so they can be JSON serialized
-    const serializable = uint8ArrayToArray(keyPackage);
+    var serializable = uint8ArrayToArray(keyPackage);
     return JSON.stringify(serializable);
 }
 /**
  * Decode JSON string back to a KeyPackage object
  */
-function decodeKeyPackage(encoded) {
-    const parsed = JSON.parse(encoded);
+export function decodeKeyPackage(encoded) {
+    var parsed = JSON.parse(encoded);
     // Convert arrays back to Uint8Arrays
     return arrayToUint8Array(parsed);
 }
 /**
  * Encode a Welcome message to JSON string for transmission
  */
-function encodeWelcome(welcome) {
-    const serializable = uint8ArrayToArray(welcome);
+export function encodeWelcome(welcome) {
+    var serializable = uint8ArrayToArray(welcome);
     return JSON.stringify(serializable);
 }
 /**
  * Decode JSON string back to a Welcome object
  */
-function decodeWelcome(encoded) {
-    const parsed = JSON.parse(encoded);
+export function decodeWelcome(encoded) {
+    var parsed = JSON.parse(encoded);
     return arrayToUint8Array(parsed);
 }
 /**
  * Encode a Commit message to JSON string for transmission
  */
-function encodeCommit(commit) {
-    const serializable = uint8ArrayToArray(commit);
+export function encodeCommit(commit) {
+    var serializable = uint8ArrayToArray(commit);
     return JSON.stringify(serializable);
 }
 /**
  * Decode JSON string back to a Commit object
  */
-function decodeCommit(encoded) {
-    const parsed = JSON.parse(encoded);
+export function decodeCommit(encoded) {
+    var parsed = JSON.parse(encoded);
     return arrayToUint8Array(parsed);
 }
 /**
  * Encode a RatchetTree to JSON string for transmission
  */
-function encodeRatchetTree(ratchetTree) {
-    const serializable = uint8ArrayToArray(ratchetTree);
+export function encodeRatchetTree(ratchetTree) {
+    var serializable = uint8ArrayToArray(ratchetTree);
     return JSON.stringify(serializable);
 }
 /**
  * Decode JSON string back to a RatchetTree
  */
-function decodeRatchetTree(encoded) {
-    const parsed = JSON.parse(encoded);
+export function decodeRatchetTree(encoded) {
+    var parsed = JSON.parse(encoded);
     console.log("========================================");
     console.log("🔍 [mlsCodec] AFTER JSON.PARSE:");
     console.log("  Type:", typeof parsed);
@@ -166,7 +156,7 @@ function decodeRatchetTree(encoded) {
         console.log("    - Keys:", Object.keys(parsed[2]).slice(0, 10));
         console.log("    - Has nodeType:", "nodeType" in parsed[2]);
     }
-    const result = arrayToUint8Array(parsed);
+    var result = arrayToUint8Array(parsed);
     console.log("----------------------------------------");
     console.log("🔍 [mlsCodec] AFTER ARRAY_TO_UINT8ARRAY:");
     console.log("  Type:", typeof result);