shogun-core 6.2.3 → 6.3.0

package/dist/{crypto → src/crypto}/random-generation.js

@@ -1,16 +1,39 @@
-"use strict";
 // Random Generation Module for shogun-core
 // Provides cryptographically secure and deterministic random generation
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.randomSeedPhrase = exports.randomPassword = exports.randomColor = exports.randomShuffle = exports.randomChoice = exports.chance = exports.createDeterministicRandom = exports.DeterministicRandom = exports.randomUUID = exports.randomBool = exports.randomFloat = exports.randomInt = exports.randomBytes = exports.generateRandomString = void 0;
+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));
+};
 // Cryptographically secure random string generation
-const generateRandomString = (length = 32, additionalSalt) => {
-    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    const randomBytes = new Uint8Array(length);
+export var generateRandomString = function (length, additionalSalt) {
+    if (length === void 0) { length = 32; }
+    var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    var randomBytes = new Uint8Array(length);
     // Use crypto.getRandomValues for cryptographically secure randomness
     crypto.getRandomValues(randomBytes);
-    let result = "";
-    for (let i = 0; i < length; i++) {
+    var result = "";
+    for (var i = 0; i < length; i++) {
         result += chars[randomBytes[i] % chars.length];
     }
     // Add additional salt if provided
@@ -19,57 +42,52 @@ const generateRandomString = (length = 32, additionalSalt) => {
     }
     return result;
 };
-exports.generateRandomString = generateRandomString;
 // Generate random bytes
-const randomBytes = (length) => {
-    const bytes = new Uint8Array(length);
+export var randomBytes = function (length) {
+    var bytes = new Uint8Array(length);
     crypto.getRandomValues(bytes);
     return bytes;
 };
-exports.randomBytes = randomBytes;
 // Generate random integer in range
-const randomInt = (min, max) => {
-    const range = max - min + 1;
-    const randomBytes = new Uint8Array(4);
+export var randomInt = function (min, max) {
+    var range = max - min + 1;
+    var randomBytes = new Uint8Array(4);
     crypto.getRandomValues(randomBytes);
     // Convert bytes to unsigned integer
-    const randomValue = (randomBytes[0] << 24) |
+    var randomValue = (randomBytes[0] << 24) |
         (randomBytes[1] << 16) |
         (randomBytes[2] << 8) |
         randomBytes[3];
     // Ensure positive result and use modulo
     return min + (Math.abs(randomValue) % range);
 };
-exports.randomInt = randomInt;
 // Generate random float in range [0, 1)
-const randomFloat = () => {
-    const randomBytes = new Uint8Array(4);
+export var randomFloat = function () {
+    var randomBytes = new Uint8Array(4);
     crypto.getRandomValues(randomBytes);
     // Convert bytes to float
-    const randomValue = (randomBytes[0] << 24) |
+    var randomValue = (randomBytes[0] << 24) |
         (randomBytes[1] << 16) |
         (randomBytes[2] << 8) |
         randomBytes[3];
     return randomValue / (0xffffffff + 1);
 };
-exports.randomFloat = randomFloat;
 // Generate random boolean
-const randomBool = () => {
-    const randomBytes = new Uint8Array(1);
+export var randomBool = function () {
+    var randomBytes = new Uint8Array(1);
     crypto.getRandomValues(randomBytes);
     return randomBytes[0] % 2 === 0;
 };
-exports.randomBool = randomBool;
 // Generate random UUID v4
-const randomUUID = () => {
-    const randomBytes = new Uint8Array(16);
+export var randomUUID = function () {
+    var randomBytes = new Uint8Array(16);
     crypto.getRandomValues(randomBytes);
     // Set version (4) and variant bits
     randomBytes[6] = (randomBytes[6] & 0x0f) | 0x40; // Version 4
     randomBytes[8] = (randomBytes[8] & 0x3f) | 0x80; // Variant bits
     // Convert to UUID string format
-    const hex = Array.from(randomBytes)
-        .map((b) => b.toString(16).padStart(2, "0"))
+    var hex = Array.from(randomBytes)
+        .map(function (b) { return b.toString(16).padStart(2, "0"); })
         .join("");
     return [
         hex.slice(0, 8),
@@ -79,53 +97,59 @@ const randomUUID = () => {
         hex.slice(20, 32),
     ].join("-");
 };
-exports.randomUUID = randomUUID;
 // Deterministic random generation using seed
-class DeterministicRandom {
-    constructor(seed) {
+var DeterministicRandom = /** @class */ (function () {
+    function DeterministicRandom(seed) {
         this.seed = typeof seed === "string" ? this.hashString(seed) : seed;
     }
     // Simple hash function for string seeds
-    hashString(str) {
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            const char = str.charCodeAt(i);
+    DeterministicRandom.prototype.hashString = function (str) {
+        var hash = 0;
+        for (var i = 0; i < str.length; i++) {
+            var char = str.charCodeAt(i);
             hash = (hash << 5) - hash + char;
             hash = hash & hash; // Convert to 32-bit integer
         }
         return Math.abs(hash);
-    }
+    };
     // Linear Congruential Generator (LCG)
-    lcg() {
+    DeterministicRandom.prototype.lcg = function () {
         this.seed = (this.seed * 1664525 + 1013904223) % Math.pow(2, 32);
         return this.seed / Math.pow(2, 32);
-    }
+    };
     // Generate random integer in range
-    integer(min = 0, max = 100) {
+    DeterministicRandom.prototype.integer = function (min, max) {
+        if (min === void 0) { min = 0; }
+        if (max === void 0) { max = 100; }
         return Math.floor(this.lcg() * (max - min + 1)) + min;
-    }
+    };
     // Generate random float in range
-    floating(min = 0, max = 1, fixed = 4) {
-        const value = this.lcg() * (max - min) + min;
+    DeterministicRandom.prototype.floating = function (min, max, fixed) {
+        if (min === void 0) { min = 0; }
+        if (max === void 0) { max = 1; }
+        if (fixed === void 0) { fixed = 4; }
+        var value = this.lcg() * (max - min) + min;
         return parseFloat(value.toFixed(fixed));
-    }
+    };
     // Generate random boolean
-    bool() {
+    DeterministicRandom.prototype.bool = function () {
         return this.lcg() < 0.5;
-    }
+    };
     // Generate random string
-    string(length = 10, pool = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
-        let result = "";
-        for (let i = 0; i < length; i++) {
+    DeterministicRandom.prototype.string = function (length, pool) {
+        if (length === void 0) { length = 10; }
+        if (pool === void 0) { pool = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; }
+        var result = "";
+        for (var i = 0; i < length; i++) {
             result += pool[this.integer(0, pool.length - 1)];
         }
         return result;
-    }
+    };
     // Generate random GUID (deterministic)
-    guid() {
-        const hex = "0123456789abcdef";
-        let result = "";
-        for (let i = 0; i < 32; i++) {
+    DeterministicRandom.prototype.guid = function () {
+        var hex = "0123456789abcdef";
+        var result = "";
+        for (var i = 0; i < 32; i++) {
             result += hex[this.integer(0, 15)];
         }
         return [
@@ -135,70 +159,69 @@ class DeterministicRandom {
             result.slice(16, 20),
             result.slice(20, 32),
         ].join("-");
-    }
+    };
     // Generate random choice from array
-    choice(array) {
+    DeterministicRandom.prototype.choice = function (array) {
         return array[this.integer(0, array.length - 1)];
-    }
+    };
     // Shuffle array (Fisher-Yates algorithm)
-    shuffle(array) {
-        const shuffled = [...array];
-        for (let i = shuffled.length - 1; i > 0; i--) {
-            const j = this.integer(0, i);
-            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    DeterministicRandom.prototype.shuffle = function (array) {
+        var _a;
+        var shuffled = __spreadArray([], __read(array), false);
+        for (var i = shuffled.length - 1; i > 0; i--) {
+            var j = this.integer(0, i);
+            _a = __read([shuffled[j], shuffled[i]], 2), shuffled[i] = _a[0], shuffled[j] = _a[1];
         }
         return shuffled;
-    }
+    };
     // Generate random color (hex)
-    color() {
+    DeterministicRandom.prototype.color = function () {
         return "#" + this.string(6, "0123456789abcdef");
-    }
+    };
     // Generate random date in range
-    date(start, end) {
-        const startTime = start.getTime();
-        const endTime = end.getTime();
-        const randomTime = this.floating(startTime, endTime);
+    DeterministicRandom.prototype.date = function (start, end) {
+        var startTime = start.getTime();
+        var endTime = end.getTime();
+        var randomTime = this.floating(startTime, endTime);
         return new Date(randomTime);
-    }
-}
-exports.DeterministicRandom = DeterministicRandom;
+    };
+    return DeterministicRandom;
+}());
+export { DeterministicRandom };
 // Factory function for deterministic random
-const createDeterministicRandom = (seed) => {
+export var createDeterministicRandom = function (seed) {
     return new DeterministicRandom(seed);
 };
-exports.createDeterministicRandom = createDeterministicRandom;
 // Chance.js-like interface for compatibility
-const chance = (seed) => {
+export var chance = function (seed) {
     return new DeterministicRandom(seed);
 };
-exports.chance = chance;
 // Utility functions for random generation
-const randomChoice = (array) => {
-    return array[(0, exports.randomInt)(0, array.length - 1)];
+export var randomChoice = function (array) {
+    return array[randomInt(0, array.length - 1)];
 };
-exports.randomChoice = randomChoice;
-const randomShuffle = (array) => {
-    const shuffled = [...array];
-    for (let i = shuffled.length - 1; i > 0; i--) {
-        const j = (0, exports.randomInt)(0, i);
-        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+export var randomShuffle = function (array) {
+    var _a;
+    var shuffled = __spreadArray([], __read(array), false);
+    for (var i = shuffled.length - 1; i > 0; i--) {
+        var j = randomInt(0, i);
+        _a = __read([shuffled[j], shuffled[i]], 2), shuffled[i] = _a[0], shuffled[j] = _a[1];
     }
     return shuffled;
 };
-exports.randomShuffle = randomShuffle;
-const randomColor = () => {
-    const hex = "0123456789abcdef";
-    let color = "#";
-    for (let i = 0; i < 6; i++) {
-        color += hex[(0, exports.randomInt)(0, 15)];
+export var randomColor = function () {
+    var hex = "0123456789abcdef";
+    var color = "#";
+    for (var i = 0; i < 6; i++) {
+        color += hex[randomInt(0, 15)];
     }
     return color;
 };
-exports.randomColor = randomColor;
 // Generate random password with specific requirements
-const randomPassword = (options = {}) => {
-    const { length = 12, includeUppercase = true, includeLowercase = true, includeNumbers = true, includeSymbols = true, excludeSimilar = true, } = options;
-    let charset = "";
+export var randomPassword = function (options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.length, length = _a === void 0 ? 12 : _a, _b = options.includeUppercase, includeUppercase = _b === void 0 ? true : _b, _c = options.includeLowercase, includeLowercase = _c === void 0 ? true : _c, _d = options.includeNumbers, includeNumbers = _d === void 0 ? true : _d, _e = options.includeSymbols, includeSymbols = _e === void 0 ? true : _e, _f = options.excludeSimilar, excludeSimilar = _f === void 0 ? true : _f;
+    var charset = "";
     if (includeUppercase) {
         charset += excludeSimilar
             ? "ABCDEFGHJKLMNPQRSTUVWXYZ"
@@ -218,18 +241,18 @@ const randomPassword = (options = {}) => {
     if (charset === "") {
         throw new Error("At least one character type must be included");
     }
-    let password = "";
-    for (let i = 0; i < length; i++) {
-        const randomIndex = (0, exports.randomInt)(0, charset.length - 1);
+    var password = "";
+    for (var i = 0; i < length; i++) {
+        var randomIndex = randomInt(0, charset.length - 1);
         password += charset[randomIndex];
     }
     return password;
 };
-exports.randomPassword = randomPassword;
 // Generate random seed phrase (for crypto wallets)
-const randomSeedPhrase = (wordCount = 12) => {
+export var randomSeedPhrase = function (wordCount) {
+    if (wordCount === void 0) { wordCount = 12; }
     // Common BIP39 wordlist (first 100 words for demo)
-    const wordlist = [
+    var wordlist = [
         "abandon",
         "ability",
         "able",
@@ -331,11 +354,10 @@ const randomSeedPhrase = (wordCount = 12) => {
         "arrange",
         "arrest",
     ];
-    const phrase = [];
-    for (let i = 0; i < wordCount; i++) {
-        const randomIndex = (0, exports.randomInt)(0, wordlist.length - 1);
+    var phrase = [];
+    for (var i = 0; i < wordCount; i++) {
+        var randomIndex = randomInt(0, wordlist.length - 1);
         phrase.push(wordlist[randomIndex]);
     }
     return phrase;
 };
-exports.randomSeedPhrase = randomSeedPhrase;