shogun-core 6.2.3 → 6.3.0

package/dist/src/examples/pgp-example.js

@@ -0,0 +1,354 @@
+/**
+ * PGP Example - Simple and Immediate
+ * Demonstrates basic PGP functionality:
+ * - Key generation
+ * - Message encryption/decryption
+ * - Digital signing
+ * - Signature verification
+ */
+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.");
+};
+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;
+};
+import { createPGPManager, generatePGPKeyPair, encryptPGPMessage, decryptPGPMessage, signPGPMessage, verifyPGPSignature, demonstratePGP, } from "../crypto/index.js";
+// Simple PGP usage example
+function simplePGPExample() {
+    return __awaiter(this, void 0, void 0, function () {
+        var aliceKeys, bobKeys, message, encrypted, decrypted, signedMessage, signature, verification, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 7, , 8]);
+                    console.log("🔐 Starting Simple PGP Example");
+                    console.log("=".repeat(40));
+                    // Method 1: Using factory functions (simplest)
+                    console.log("\n📋 Method 1: Factory Functions");
+                    return [4 /*yield*/, generatePGPKeyPair("Alice", "alice@example.com", "alice123")];
+                case 1:
+                    aliceKeys = _a.sent();
+                    return [4 /*yield*/, generatePGPKeyPair("Bob", "bob@example.com", "bob123")];
+                case 2:
+                    bobKeys = _a.sent();
+                    console.log("✅ Key pairs generated");
+                    console.log("Alice Key ID:", aliceKeys.keyId);
+                    console.log("Bob Key ID:", bobKeys.keyId);
+                    message = "Hello Bob! This is a secret message from Alice. 🔐";
+                    return [4 /*yield*/, encryptPGPMessage(message, bobKeys.publicKey)];
+                case 3:
+                    encrypted = _a.sent();
+                    console.log("✅ Message encrypted");
+                    console.log("Encrypted message length:", encrypted.message.length);
+                    return [4 /*yield*/, decryptPGPMessage(encrypted.message, bobKeys.privateKey, "bob123")];
+                case 4:
+                    decrypted = _a.sent();
+                    console.log("✅ Message decrypted");
+                    console.log("Original message:", message);
+                    console.log("Decrypted message:", decrypted);
+                    console.log("Messages match:", message === decrypted);
+                    signedMessage = "This is a signed message from Alice. ✍️";
+                    return [4 /*yield*/, signPGPMessage(signedMessage, aliceKeys.privateKey, "alice123")];
+                case 5:
+                    signature = _a.sent();
+                    console.log("✅ Message signed");
+                    console.log("Signature length:", signature.signature.length);
+                    return [4 /*yield*/, verifyPGPSignature(signedMessage, signature.signature, aliceKeys.publicKey)];
+                case 6:
+                    verification = _a.sent();
+                    console.log("✅ Signature verified");
+                    console.log("Signature valid:", verification.valid);
+                    console.log("\n🎉 Simple PGP Example completed successfully!");
+                    return [2 /*return*/, {
+                            success: true,
+                            messageDecrypted: message === decrypted,
+                            signatureValid: verification.valid,
+                        }];
+                case 7:
+                    error_1 = _a.sent();
+                    console.error("❌ Simple PGP Example failed:", error_1);
+                    return [2 /*return*/, {
+                            success: false,
+                            error: error_1 instanceof Error ? error_1.message : "Unknown error",
+                        }];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}
+// Advanced PGP usage with manager
+function advancedPGPExample() {
+    return __awaiter(this, void 0, void 0, function () {
+        var manager, users, userKeys, users_1, users_1_1, user, keys, e_1_1, groupMessage, encryptedForBob, encryptedForCharlie, bobDecrypted, charlieDecrypted, userKeys_1, userKeys_1_1, _a, name_1, keys, keyInfo, e_2_1, aliceKeyArmored, aliceKeyBinary, importedKey, error_2;
+        var e_1, _b, e_2, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 25, 26, 27]);
+                    console.log("\n🔐 Starting Advanced PGP Example");
+                    console.log("=".repeat(40));
+                    return [4 /*yield*/, createPGPManager()];
+                case 1:
+                    // Method 2: Using PGPManager (more control)
+                    manager = _d.sent();
+                    console.log("✅ PGP Manager created");
+                    users = [
+                        { name: "Alice", email: "alice@example.com", passphrase: "alice123" },
+                        { name: "Bob", email: "bob@example.com", passphrase: "bob123" },
+                        {
+                            name: "Charlie",
+                            email: "charlie@example.com",
+                            passphrase: "charlie123",
+                        },
+                    ];
+                    userKeys = new Map();
+                    _d.label = 2;
+                case 2:
+                    _d.trys.push([2, 7, 8, 9]);
+                    users_1 = __values(users), users_1_1 = users_1.next();
+                    _d.label = 3;
+                case 3:
+                    if (!!users_1_1.done) return [3 /*break*/, 6];
+                    user = users_1_1.value;
+                    return [4 /*yield*/, manager.generateKeyPair(user.name, user.email, user.passphrase)];
+                case 4:
+                    keys = _d.sent();
+                    userKeys.set(user.name, keys);
+                    console.log("\u2705 ".concat(user.name, " key pair generated: ").concat(keys.keyId));
+                    _d.label = 5;
+                case 5:
+                    users_1_1 = users_1.next();
+                    return [3 /*break*/, 3];
+                case 6: return [3 /*break*/, 9];
+                case 7:
+                    e_1_1 = _d.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 9];
+                case 8:
+                    try {
+                        if (users_1_1 && !users_1_1.done && (_b = users_1.return)) _b.call(users_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 9:
+                    // Test group messaging (Alice sends to Bob and Charlie)
+                    console.log("\n📧 Group Messaging Test");
+                    groupMessage = "Hello everyone! This is a group message from Alice. 👥";
+                    return [4 /*yield*/, manager.encryptMessage(groupMessage, userKeys.get("Bob").publicKey, userKeys.get("Alice").privateKey, // Alice signs
+                        "alice123")];
+                case 10:
+                    encryptedForBob = _d.sent();
+                    return [4 /*yield*/, manager.encryptMessage(groupMessage, userKeys.get("Charlie").publicKey, userKeys.get("Alice").privateKey, // Alice signs
+                        "alice123")];
+                case 11:
+                    encryptedForCharlie = _d.sent();
+                    console.log("✅ Messages encrypted for Bob and Charlie");
+                    return [4 /*yield*/, manager.decryptMessage(encryptedForBob.message, userKeys.get("Bob").privateKey, "bob123")];
+                case 12:
+                    bobDecrypted = _d.sent();
+                    return [4 /*yield*/, manager.decryptMessage(encryptedForCharlie.message, userKeys.get("Charlie").privateKey, "charlie123")];
+                case 13:
+                    charlieDecrypted = _d.sent();
+                    console.log("✅ Messages decrypted by Bob and Charlie");
+                    console.log("Bob received:", bobDecrypted);
+                    console.log("Charlie received:", charlieDecrypted);
+                    // Test key information
+                    console.log("\n🔍 Key Information");
+                    _d.label = 14;
+                case 14:
+                    _d.trys.push([14, 19, 20, 21]);
+                    userKeys_1 = __values(userKeys), userKeys_1_1 = userKeys_1.next();
+                    _d.label = 15;
+                case 15:
+                    if (!!userKeys_1_1.done) return [3 /*break*/, 18];
+                    _a = __read(userKeys_1_1.value, 2), name_1 = _a[0], keys = _a[1];
+                    return [4 /*yield*/, manager.getKeyInfo(keys.publicKey)];
+                case 16:
+                    keyInfo = _d.sent();
+                    console.log("".concat(name_1, ":"), {
+                        keyId: keyInfo.keyId,
+                        fingerprint: keyInfo.fingerprint,
+                        algorithm: keyInfo.algorithm,
+                        created: keyInfo.created,
+                        isPrivate: keyInfo.isPrivate,
+                        isPublic: keyInfo.isPublic,
+                    });
+                    _d.label = 17;
+                case 17:
+                    userKeys_1_1 = userKeys_1.next();
+                    return [3 /*break*/, 15];
+                case 18: return [3 /*break*/, 21];
+                case 19:
+                    e_2_1 = _d.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 21];
+                case 20:
+                    try {
+                        if (userKeys_1_1 && !userKeys_1_1.done && (_c = userKeys_1.return)) _c.call(userKeys_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 21:
+                    // Test key export/import
+                    console.log("\n📤 Key Export/Import Test");
+                    return [4 /*yield*/, manager.exportKey(userKeys.get("Alice").publicKey, "armored")];
+                case 22:
+                    aliceKeyArmored = _d.sent();
+                    return [4 /*yield*/, manager.exportKey(userKeys.get("Alice").publicKey, "binary")];
+                case 23:
+                    aliceKeyBinary = _d.sent();
+                    console.log("✅ Alice's key exported in armored and binary formats");
+                    console.log("Armored length:", aliceKeyArmored.length);
+                    console.log("Binary length:", aliceKeyBinary.length);
+                    return [4 /*yield*/, manager.importKey(aliceKeyBinary, "binary")];
+                case 24:
+                    importedKey = _d.sent();
+                    console.log("✅ Key imported from binary format");
+                    console.log("Imported key matches original:", importedKey === userKeys.get("Alice").publicKey);
+                    console.log("\n🎉 Advanced PGP Example completed successfully!");
+                    return [2 /*return*/, {
+                            success: true,
+                            groupMessaging: true,
+                            keyManagement: true,
+                            exportImport: true,
+                        }];
+                case 25:
+                    error_2 = _d.sent();
+                    console.error("❌ Advanced PGP Example failed:", error_2);
+                    return [2 /*return*/, {
+                            success: false,
+                            error: error_2 instanceof Error ? error_2.message : "Unknown error",
+                        }];
+                case 26:
+                    // Clean up
+                    if (typeof manager !== "undefined") {
+                        manager.destroy();
+                    }
+                    return [7 /*endfinally*/];
+                case 27: return [2 /*return*/];
+            }
+        });
+    });
+}
+// Run all examples
+function runAllPGPExamples() {
+    return __awaiter(this, void 0, void 0, function () {
+        var simpleResult, advancedResult, demoResult, allPassed;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    console.log("🚀 Running All PGP Examples");
+                    console.log("=".repeat(50));
+                    // Example 1: Simple usage
+                    console.log("\n=== Example 1: Simple PGP Usage ===");
+                    return [4 /*yield*/, simplePGPExample()];
+                case 1:
+                    simpleResult = _a.sent();
+                    // Example 2: Advanced usage
+                    console.log("\n=== Example 2: Advanced PGP Usage ===");
+                    return [4 /*yield*/, advancedPGPExample()];
+                case 2:
+                    advancedResult = _a.sent();
+                    // Example 3: Full demonstration
+                    console.log("\n=== Example 3: Full PGP Demonstration ===");
+                    return [4 /*yield*/, demonstratePGP()];
+                case 3:
+                    demoResult = _a.sent();
+                    console.log("\n📊 Final Results:");
+                    console.log("Simple PGP:", simpleResult.success ? "✅ PASSED" : "❌ FAILED");
+                    console.log("Advanced PGP:", advancedResult.success ? "✅ PASSED" : "❌ FAILED");
+                    console.log("Full Demo:", demoResult.success ? "✅ PASSED" : "❌ FAILED");
+                    allPassed = simpleResult.success && advancedResult.success && demoResult.success;
+                    if (allPassed) {
+                        console.log("\n🎉 All PGP examples completed successfully!");
+                        console.log("🔐 PGP Features Demonstrated:");
+                        console.log("  ✅ Key generation (RSA 4096-bit)");
+                        console.log("  ✅ Message encryption/decryption");
+                        console.log("  ✅ Digital signing and verification");
+                        console.log("  ✅ Key management and information");
+                        console.log("  ✅ Key export/import (armored/binary)");
+                        console.log("  ✅ Group messaging with signing");
+                        console.log("  ✅ OpenPGP standard compliance");
+                    }
+                    else {
+                        console.log("\n❌ Some PGP examples failed");
+                    }
+                    return [2 /*return*/, {
+                            simple: simpleResult,
+                            advanced: advancedResult,
+                            demo: demoResult,
+                            allPassed: allPassed,
+                        }];
+            }
+        });
+    });
+}
+// Run the examples
+if (require.main === module) {
+    runAllPGPExamples()
+        .then(function (result) {
+        console.log("\n📊 Final Test Summary:");
+        console.log(JSON.stringify(result, null, 2));
+    })
+        .catch(function (error) {
+        console.error("💥 PGP examples execution failed:", error);
+    });
+}
+export { simplePGPExample, advancedPGPExample, runAllPGPExamples };

package/dist/src/examples/random-generation-test.js

@@ -0,0 +1,191 @@
+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 };
+    }
+};
+// Random Generation test
+import { generateRandomString, randomBytes, randomInt, randomFloat, randomBool, randomUUID, createDeterministicRandom, chance, randomChoice, randomShuffle, randomColor, randomPassword, randomSeedPhrase, } from "../crypto/index.js";
+// Test Random Generation
+function testRandomGeneration() {
+    return __awaiter(this, void 0, void 0, function () {
+        var randomStr, bytes, randomNum, randomFloatVal, randomBoolVal, uuid, detRandom, detInt1, detInt2, detFloat, detBool, detString, detGuid, chanceInstance, chanceInt, chanceFloat, chanceBool, testArray, choice, shuffled, color, password, seedPhrase, det1, det2, val1_1, val1_2, val2_1, val2_2;
+        return __generator(this, function (_a) {
+            try {
+                console.log("🎲 Starting Random Generation test...");
+                // Test 1: Basic random string generation
+                console.log("\n1. Testing basic random string generation...");
+                randomStr = generateRandomString(16, "test-");
+                console.log("✅ Random string:", randomStr);
+                // Test 2: Random bytes
+                console.log("\n2. Testing random bytes...");
+                bytes = randomBytes(8);
+                console.log("✅ Random bytes:", Array.from(bytes)
+                    .map(function (b) { return b.toString(16).padStart(2, "0"); })
+                    .join(""));
+                // Test 3: Random integer
+                console.log("\n3. Testing random integer...");
+                randomNum = randomInt(1, 100);
+                console.log("✅ Random integer (1-100):", randomNum);
+                // Test 4: Random float
+                console.log("\n4. Testing random float...");
+                randomFloatVal = randomFloat();
+                console.log("✅ Random float:", randomFloatVal);
+                // Test 5: Random boolean
+                console.log("\n5. Testing random boolean...");
+                randomBoolVal = randomBool();
+                console.log("✅ Random boolean:", randomBoolVal);
+                // Test 6: Random UUID
+                console.log("\n6. Testing random UUID...");
+                uuid = randomUUID();
+                console.log("✅ Random UUID:", uuid);
+                // Test 7: Deterministic random
+                console.log("\n7. Testing deterministic random...");
+                detRandom = createDeterministicRandom("test-seed");
+                detInt1 = detRandom.integer(1, 100);
+                detInt2 = detRandom.integer(1, 100);
+                detFloat = detRandom.floating(0, 1, 4);
+                detBool = detRandom.bool();
+                detString = detRandom.string(10);
+                detGuid = detRandom.guid();
+                console.log("✅ Deterministic integer 1:", detInt1);
+                console.log("✅ Deterministic integer 2:", detInt2);
+                console.log("✅ Deterministic float:", detFloat);
+                console.log("✅ Deterministic boolean:", detBool);
+                console.log("✅ Deterministic string:", detString);
+                console.log("✅ Deterministic GUID:", detGuid);
+                // Test 8: Chance.js compatibility
+                console.log("\n8. Testing Chance.js compatibility...");
+                chanceInstance = chance("chance-seed");
+                chanceInt = chanceInstance.integer(1, 50);
+                chanceFloat = chanceInstance.floating(0, 10, 2);
+                chanceBool = chanceInstance.bool();
+                console.log("✅ Chance integer:", chanceInt);
+                console.log("✅ Chance float:", chanceFloat);
+                console.log("✅ Chance boolean:", chanceBool);
+                // Test 9: Array utilities
+                console.log("\n9. Testing array utilities...");
+                testArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+                choice = randomChoice(testArray);
+                shuffled = randomShuffle(testArray);
+                console.log("✅ Random choice from array:", choice);
+                console.log("✅ Shuffled array:", shuffled);
+                // Test 10: Random color
+                console.log("\n10. Testing random color...");
+                color = randomColor();
+                console.log("✅ Random color:", color);
+                // Test 11: Random password
+                console.log("\n11. Testing random password...");
+                password = randomPassword({
+                    length: 16,
+                    includeUppercase: true,
+                    includeLowercase: true,
+                    includeNumbers: true,
+                    includeSymbols: true,
+                    excludeSimilar: true,
+                });
+                console.log("✅ Random password:", password);
+                // Test 12: Random seed phrase
+                console.log("\n12. Testing random seed phrase...");
+                seedPhrase = randomSeedPhrase(12);
+                console.log("✅ Random seed phrase:", seedPhrase.join(" "));
+                // Test 13: Deterministic consistency
+                console.log("\n13. Testing deterministic consistency...");
+                det1 = createDeterministicRandom("consistency-test");
+                det2 = createDeterministicRandom("consistency-test");
+                val1_1 = det1.integer(1, 100);
+                val1_2 = det1.integer(1, 100);
+                val2_1 = det2.integer(1, 100);
+                val2_2 = det2.integer(1, 100);
+                console.log("✅ Deterministic consistency test:");
+                console.log("  Same seed, first value:", val1_1 === val2_1 ? "✅ MATCH" : "❌ MISMATCH");
+                console.log("  Same seed, second value:", val1_2 === val2_2 ? "✅ MATCH" : "❌ MISMATCH");
+                console.log("\n🎉 All Random Generation tests completed successfully!");
+                return [2 /*return*/, {
+                        success: true,
+                        tests: {
+                            randomString: randomStr,
+                            randomBytes: Array.from(bytes)
+                                .map(function (b) { return b.toString(16).padStart(2, "0"); })
+                                .join(""),
+                            randomInt: randomNum,
+                            randomFloat: randomFloatVal,
+                            randomBool: randomBoolVal,
+                            randomUUID: uuid,
+                            deterministic: {
+                                int1: detInt1,
+                                int2: detInt2,
+                                float: detFloat,
+                                bool: detBool,
+                                string: detString,
+                                guid: detGuid,
+                            },
+                            chance: {
+                                int: chanceInt,
+                                float: chanceFloat,
+                                bool: chanceBool,
+                            },
+                            arrayUtils: {
+                                choice: choice,
+                                shuffledLength: shuffled.length,
+                            },
+                            color: color,
+                            password: password,
+                            seedPhrase: seedPhrase.join(" "),
+                            consistency: {
+                                firstMatch: val1_1 === val2_1,
+                                secondMatch: val1_2 === val2_2,
+                            },
+                        },
+                    }];
+            }
+            catch (error) {
+                console.error("❌ Random Generation test error:", error);
+                return [2 /*return*/, {
+                        success: false,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                    }];
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+// Run the test
+testRandomGeneration()
+    .then(function (result) {
+    console.log("\n📊 Final Result:");
+    console.log(JSON.stringify(result, null, 2));
+})
+    .catch(function (error) {
+    console.error("💥 Test execution failed:", error);
+});