xypriss 9.0.13 → 9.1.1

package/dist/cjs/mods/security/src/core/random/random-core.js

@@ -1,962 +0,0 @@
-'use strict';
-
-var constants = require('../../utils/constants.js');
-var stats = require('../../utils/stats.js');
-var randomTypes = require('./random-types.js');
-var randomSources = require('./random-sources.js');
-var randomEntropy = require('./random-entropy.js');
-var randomGenerators = require('./random-generators.js');
-var randomTokens = require('./random-tokens.js');
-var Uint8Array = require('../../helpers/Uint8Array.js');
-var types = require('../../types.js');
-
-/**
- * Random core - Main SecureRandom class with modular architecture
- */
-/**
- * ## Core Cryptographic Exports
- *
- * Primary cryptographic classes and utilities for secure random generation,
- * key management, validation, and buffer operations.
- */
-/**
- * ### Secure Random Generation
- *
- * High-entropy random number and data generation with multiple entropy sources.
- * Provides cryptographically secure random values for all security operations.
- *
- * @example
- * ```typescript
- * import { Random } from "xypriss-security";
- *
- * // Generate secure random bytes
- * const randomBytes = Random.getRandomBytes(32);
- *
- * // Generate secure UUID
- * const uuid = Random.generateSecureUUID();
- *
- * // Generate random integers
- * const randomInt = Random.getSecureRandomInt(1, 100);
- * ```
- */
-class SecureRandom {
-    constructor() {
-        this.stats = stats.StatsTracker.getInstance();
-        this.state = {
-            entropyPool: Buffer.alloc(constants.SECURITY_CONSTANTS.ENTROPY_POOL_SIZE),
-            lastReseed: Date.now(),
-            state: randomTypes.RNGState.UNINITIALIZED,
-            bytesGenerated: 0,
-            entropyQuality: randomTypes.EntropyQuality.POOR,
-            securityLevel: types.SecurityLevel.HIGH,
-            quantumSafeMode: false,
-            reseedCounter: 0,
-            hardwareEntropyAvailable: this.detectHardwareEntropy(),
-            sidechannelProtection: true,
-            entropyAugmentation: true,
-            realTimeMonitoring: true,
-            lastEntropyTest: Date.now(),
-            entropyTestResults: new Map(),
-            securityAlerts: [],
-            additionalEntropySources: new Map(),
-        };
-        this.setupAdditionalEntropySources();
-        this.initializeEntropyPool();
-    }
-    /**
-     * Get singleton instance
-     */
-    static getInstance() {
-        if (!SecureRandom.instance) {
-            SecureRandom.instance = new SecureRandom();
-        }
-        return SecureRandom.instance;
-    }
-    /**
-     * Initialize entropy pool
-     */
-    async initializeEntropyPool() {
-        this.state.state = randomTypes.RNGState.INITIALIZING;
-        try {
-            this.state.entropyPool = await randomEntropy.RandomEntropy.initializeEntropyPool(constants.SECURITY_CONSTANTS.ENTROPY_POOL_SIZE);
-            this.state.entropyQuality = randomEntropy.RandomEntropy.assessEntropyQuality(this.state.entropyPool);
-            this.state.state = randomTypes.RNGState.READY;
-            this.state.lastReseed = Date.now();
-        }
-        catch (error) {
-            this.state.state = randomTypes.RNGState.ERROR;
-            throw new Error(`Failed to initialize entropy pool: ${error}`);
-        }
-    }
-    /**
-     * Setup additional entropy sources
-     */
-    setupAdditionalEntropySources() {
-        // High-resolution timing entropy
-        this.state.additionalEntropySources.set("timing", () => randomEntropy.RandomEntropy.getTimingEntropy());
-        // Memory usage entropy
-        this.state.additionalEntropySources.set("memory", () => randomEntropy.RandomEntropy.getMemoryEntropy());
-        // Process entropy
-        this.state.additionalEntropySources.set("process", () => randomEntropy.RandomEntropy.getProcessEntropy());
-    }
-    /**
-     * Detect hardware entropy availability
-     */
-    detectHardwareEntropy() {
-        try {
-            // Check for hardware random number generator
-            if (typeof crypto !== "undefined" &&
-                typeof crypto.getRandomValues === "function") {
-                return true;
-            }
-            if (typeof window !== "undefined" &&
-                window.crypto &&
-                typeof window.crypto.getRandomValues === "function") {
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    // ============================================================================
-    // PUBLIC API - CORE RANDOM GENERATION
-    // ============================================================================
-    /**
-     * Generate ultra-secure random bytes with enhanced entropy
-     * @param length - Number of bytes to generate
-     * @param options - Generation options
-     * @returns Enhanced random bytes
-     */
-    static getRandomBytes(length, options = {}) {
-        const instance = SecureRandom.getInstance();
-        // Check if we need to reseed
-        const reseedThreshold = options.reseedThreshold || constants.SECURITY_CONSTANTS.RESEED_THRESHOLD;
-        if (instance.state.bytesGenerated > reseedThreshold) {
-            instance.reseedEntropyPool();
-        }
-        // Generate bytes using the generators module
-        const bytes = randomGenerators.RandomGenerators.getRandomBytes(length, options);
-        // Update statistics
-        instance.state.bytesGenerated += length;
-        // instance.stats.recordRandomGeneration(length); // TODO: Implement this method
-        // Return enhanced array
-        return new Uint8Array.EnhancedUint8Array(bytes);
-    }
-    /**
-     * Get system random bytes (fallback method)
-     */
-    static getSystemRandomBytes(length) {
-        return randomGenerators.RandomGenerators.getSystemRandomBytes(length);
-    }
-    /**
-     * Generate secure random integer
-     */
-    static getSecureRandomInt(min, max, options = {}) {
-        return randomGenerators.RandomGenerators.getSecureRandomInt(min, max, options);
-    }
-    /**
-     * Generate secure UUID v4
-     */
-    static generateSecureUUID(options = {}) {
-        return randomGenerators.RandomGenerators.generateSecureUUID(options);
-    }
-    /**
-     * Generate secure random float
-     */
-    static getSecureRandomFloat(options = {}) {
-        return randomGenerators.RandomGenerators.getSecureRandomFloat(options);
-    }
-    /**
-     * Generate secure random boolean
-     */
-    static getSecureRandomBoolean(options = {}) {
-        return randomGenerators.RandomGenerators.getSecureRandomBoolean(options);
-    }
-    /**
-     * Generate salt
-     */
-    static generateSalt(length = 32, options = {}) {
-        return randomGenerators.RandomGenerators.generateSalt(length, options);
-    }
-    // ============================================================================
-    // ENTROPY MANAGEMENT
-    // ============================================================================
-    /**
-     * Reseed entropy pool
-     */
-    reseedEntropyPool() {
-        this.state.state = randomTypes.RNGState.RESEEDING;
-        try {
-            randomEntropy.RandomEntropy.reseedEntropyPool(this.state.entropyPool).then((newPool) => {
-                this.state.entropyPool = newPool;
-                this.state.lastReseed = Date.now();
-                this.state.reseedCounter++;
-                this.state.state = randomTypes.RNGState.READY;
-                this.state.entropyQuality =
-                    randomEntropy.RandomEntropy.assessEntropyQuality(newPool);
-            });
-        }
-        catch (error) {
-            this.state.state = randomTypes.RNGState.ERROR;
-            console.error("Failed to reseed entropy pool:", error);
-        }
-    }
-    /**
-     * Get entropy analysis
-     */
-    static getEntropyAnalysis(data) {
-        const instance = SecureRandom.getInstance();
-        const analysisData = data || instance.state.entropyPool;
-        return randomEntropy.RandomEntropy.analyzeEntropy(analysisData);
-    }
-    /**
-     * Assess entropy quality
-     */
-    static assessEntropyQuality(data) {
-        return randomEntropy.RandomEntropy.assessEntropyQuality(data);
-    }
-    // ============================================================================
-    // MONITORING AND STATUS
-    // ============================================================================
-    /**
-     * Get security monitoring result
-     */
-    static getSecurityStatus() {
-        const instance = SecureRandom.getInstance();
-        const libraryStatus = randomSources.RandomSources.getLibraryStatus();
-        // Assess threats
-        const threats = [];
-        if (instance.state.entropyQuality === randomTypes.EntropyQuality.POOR) {
-            threats.push("Low entropy quality detected");
-        }
-        if (instance.state.bytesGenerated >
-            constants.SECURITY_CONSTANTS.RESEED_THRESHOLD * 2) {
-            threats.push("Entropy pool needs reseeding");
-        }
-        if (!libraryStatus.sodium && !libraryStatus.secureRandom) {
-            threats.push("No enhanced entropy sources available");
-        }
-        // Generate recommendations
-        const recommendations = [];
-        if (threats.length > 0) {
-            recommendations.push("Consider reseeding entropy pool");
-        }
-        if (instance.state.entropyQuality !== randomTypes.EntropyQuality.MILITARY) {
-            recommendations.push("Enable quantum-safe mode for maximum security");
-        }
-        return {
-            entropyQuality: instance.state.entropyQuality,
-            securityLevel: instance.state.securityLevel,
-            threats,
-            recommendations,
-            timestamp: Date.now(),
-            bytesGenerated: instance.state.bytesGenerated,
-            reseedCount: instance.state.reseedCounter,
-            libraryStatus,
-        };
-    }
-    /**
-     * Get library status
-     */
-    static getLibraryStatus() {
-        return randomSources.RandomSources.getLibraryStatus();
-    }
-    /**
-     * Check if secure random is available
-     */
-    static isSecureRandomAvailable() {
-        return ((typeof crypto !== "undefined" &&
-            typeof crypto.getRandomValues === "function") ||
-            (typeof window !== "undefined" &&
-                typeof window.crypto !== "undefined" &&
-                typeof window.crypto.getRandomValues === "function") ||
-            typeof require === "function");
-    }
-    /**
-     * Get current state
-     */
-    getState() {
-        return { ...this.state };
-    }
-    /**
-     * Get statistics
-     */
-    static getStatistics() {
-        const instance = SecureRandom.getInstance();
-        return {
-            bytesGenerated: instance.state.bytesGenerated,
-            reseedCount: instance.state.reseedCounter,
-            lastReseed: instance.state.lastReseed,
-            entropyQuality: instance.state.entropyQuality,
-            state: instance.state.state,
-        };
-    }
-    // ============================================================================
-    // UTILITY METHODS
-    // ============================================================================
-    /**
-     * Reset instance (for testing)
-     */
-    static resetInstance() {
-        SecureRandom.instance = new SecureRandom();
-    }
-    /**
-     * Enable quantum-safe mode
-     */
-    static enableQuantumSafeMode() {
-        const instance = SecureRandom.getInstance();
-        instance.state.quantumSafeMode = true;
-    }
-    /**
-     * Disable quantum-safe mode
-     */
-    static disableQuantumSafeMode() {
-        const instance = SecureRandom.getInstance();
-        instance.state.quantumSafeMode = false;
-    }
-    /**
-     * Set security level
-     */
-    static setSecurityLevel(level) {
-        const instance = SecureRandom.getInstance();
-        instance.state.securityLevel = level;
-    }
-    // ============================================================================
-    // TOKEN GENERATION APIS
-    // ============================================================================
-    /**
-     * ### Generate Secure Password
-     *
-     * Creates a cryptographically secure password with enforced complexity requirements.
-     * Ensures the password contains at least one character from each required character set
-     * and shuffles the result to prevent predictable patterns.
-     *
-     * @param {number} [length=16] - Desired password length (minimum 8 characters)
-     * @param {import('./random-types').TokenGenerationOptions} [options] - Password generation options
-     * @param {boolean} [options.includeUppercase=true] - Include uppercase letters (A-Z)
-     * @param {boolean} [options.includeLowercase=true] - Include lowercase letters (a-z)
-     * @param {boolean} [options.includeNumbers=true] - Include numeric digits (0-9)
-     * @param {boolean} [options.includeSymbols=true] - Include special symbols (!@#$%^&*)
-     * @param {boolean} [options.excludeSimilarCharacters=true] - Exclude visually similar characters (0O1lI|)
-     * @param {import('./random-types').SecurityLevel} [options.entropyLevel='high'] - Security level for entropy
-     * @returns {string} A cryptographically secure password meeting all complexity requirements
-     *
-     * @example
-     * ```typescript
-     * // Generate a 16-character password with all character types
-     * const password = SecureRandom.generateSecurePassword(16);
-     * // Output: "Tr7$Kp9#mN2&vL4!"
-     *
-     * // Generate a simpler password without symbols
-     * const simple = SecureRandom.generateSecurePassword(12, {
-     *   includeSymbols: false
-     * });
-     * ```
-     *
-     * @security This method uses cryptographically secure random generation
-     * @throws {Error} If password length is less than 8 characters
-     */
-    static generateSecurePassword(...params) {
-        return randomTokens.RandomTokens.generateSecurePassword(...params);
-    }
-    /**
-     * ### Generate Session Token
-     *
-     * Creates a secure session token encoded in the specified format.
-     * Uses high-entropy random bytes for maximum security.
-     *
-     * @param {number} [length=32] - Token length in bytes before encoding
-     * @param {"hex"|"base64"|"base64url"} [encoding="base64url"] - Output encoding format
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {string} Secure session token in the specified encoding
-     *
-     * @example
-     * ```typescript
-     * // Generate a base64url session token
-     * const token = SecureRandom.generateSessionToken(32, 'base64url');
-     *
-     * // Generate a hex token for database storage
-     * const hexToken = SecureRandom.generateSessionToken(32, 'hex');
-     * ```
-     */
-    static generateSessionToken(...params) {
-        return randomTokens.RandomTokens.generateSessionToken(...params);
-    }
-    /**
-     * ### Generate API Key
-     *
-     * Creates a secure API key with optional prefix for easy identification.
-     * Uses a combination of random characters for maximum security.
-     *
-     * @param {number} [length=32] - Length of the random part of the API key
-     * @param {string} [prefix] - Optional prefix (e.g., "sk_", "pk_") followed by underscore
-     * @param {import('./random-types').TokenGenerationOptions} [options] - Generation options
-     * @returns {string} Secure API key with optional prefix
-     *
-     * @example
-     * ```typescript
-     * // Generate API key with prefix
-     * const key = SecureRandom.generateAPIKey(32, 'sk_live_');
-     * // Output: "**************************"
-     *
-     * // Generate API key without prefix
-     * const key = SecureRandom.generateAPIKey(24);
-     * ```
-     */
-    static generateAPIKey(...params) {
-        return randomTokens.RandomTokens.generateAPIKey(...params);
-    }
-    /**
-     * ### Generate Secure PIN
-     *
-     * Creates a numeric PIN code for authentication purposes.
-     * Uses cryptographically secure random digits.
-     *
-     * @param {number} [length=6] - PIN length (minimum 4 digits)
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {string} Numeric PIN as a string
-     *
-     * @example
-     * ```typescript
-     * // Generate a 6-digit PIN
-     * const pin = SecureRandom.generateSecurePIN(6);
-     * // Output: "482739"
-     *
-     * // Generate a longer PIN
-     * const longPin = SecureRandom.generateSecurePIN(8);
-     * ```
-     *
-     * @throws {Error} If PIN length is less than 4 digits
-     */
-    static generateSecurePIN(...params) {
-        return randomTokens.RandomTokens.generateSecurePIN(...params);
-    }
-    /**
-     * ### Generate Secure OTP
-     *
-     * Creates a one-time password (OTP) for two-factor authentication.
-     * Uses alphanumeric characters with excluded similar-looking characters.
-     *
-     * @param {number} [length=6] - OTP length
-     * @param {import('./random-types').TokenGenerationOptions} [options] - Generation options
-     * @returns {string} Secure OTP string
-     *
-     * @example
-     * ```typescript
-     * // Generate a 6-character OTP
-     * const otp = SecureRandom.generateSecureOTP(6);
-     * // Output: "A8B3K9"
-     * ```
-     */
-    static generateSecureOTP(...params) {
-        return randomTokens.RandomTokens.generateSecureOTP(...params);
-    }
-    /**
-     * ### Generate Recovery Codes
-     *
-     * Creates an array of recovery codes for account recovery purposes.
-     * Each code is cryptographically secure and suitable for backup authentication.
-     *
-     * @param {number} [count=10] - Number of recovery codes to generate (1-100)
-     * @param {number} [codeLength=8] - Length of each individual code
-     * @param {import('./random-types').TokenGenerationOptions} [options] - Generation options
-     * @returns {string[]} Array of recovery codes
-     *
-     * @example
-     * ```typescript
-     * // Generate 10 recovery codes
-     * const codes = SecureRandom.generateRecoveryCodes(10, 8);
-     * // Output: ["A1B2C3D4", "E5F6G7H8", "I9J0K1L2", ...]
-     * ```
-     *
-     * @throws {Error} If count is not between 1 and 100
-     */
-    static generateRecoveryCodes(...params) {
-        return randomTokens.RandomTokens.generateRecoveryCodes(...params);
-    }
-    /**
-     * ### Validate Token Strength
-     *
-     * Analyzes a token/password for strength and provides detailed feedback.
-     * Evaluates length, character variety, entropy, and common patterns.
-     *
-     * @param {string} token - The token to analyze
-     * @returns {Object} Strength analysis results
-     * @returns {number} returns.score - Strength score (0-100)
-     * @returns {"weak"|"fair"|"good"|"strong"|"excellent"} returns.strength - Qualitative strength rating
-     * @returns {string[]} returns.issues - Array of improvement suggestions
-     *
-     * @example
-     * ```typescript
-     * const analysis = SecureRandom.validateTokenStrength("MySecureP@ss123");
-     * console.log(analysis);
-     * // Output: {
-     * //   score: 85,
-     * //   strength: "strong",
-     * //   issues: ["Consider adding more special characters"]
-     * // }
-     * ```
-     */
-    static validateTokenStrength(...params) {
-        return randomTokens.RandomTokens.validateTokenStrength(...params);
-    }
-    // ============================================================================
-    // ADVANCED GENERATION APIS
-    // ============================================================================
-    /**
-     * ### Generate Secure UUID Batch
-     *
-     * Efficiently generates multiple UUID v4 strings in a single operation.
-     * More performant than generating UUIDs individually when you need many.
-     *
-     * @param {number} count - Number of UUIDs to generate (1-1000)
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {string[]} Array of RFC 4122 compliant UUID v4 strings
-     *
-     * @example
-     * ```typescript
-     * // Generate 100 UUIDs efficiently
-     * const uuids = SecureRandom.generateSecureUUIDBatch(100);
-     *
-     * // Generate UUIDs with quantum-safe entropy
-     * const secureUuids = SecureRandom.generateSecureUUIDBatch(50, {
-     *   quantumSafe: true
-     * });
-     * ```
-     *
-     * @throws {Error} If count is not between 1 and 1000
-     * @performance Significantly faster than individual UUID generation for large batches
-     */
-    static generateSecureUUIDBatch(...params) {
-        return randomGenerators.RandomGenerators.generateSecureUUIDBatch(...params);
-    }
-    /**
-     * ### Get Secure Random Choice
-     *
-     * Selects a random element from an array using cryptographically secure randomness.
-     * Provides uniform distribution across all array elements.
-     *
-     * @template T - The type of elements in the array
-     * @param {T[]} array - Array to select from (must not be empty)
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {T} Randomly selected element from the array
-     *
-     * @example
-     * ```typescript
-     * const fruits = ['apple', 'banana', 'cherry', 'date'];
-     * const randomFruit = SecureRandom.getSecureRandomChoice(fruits);
-     * // Output: randomly one of: "apple", "banana", "cherry", or "date"
-     *
-     * // With custom options
-     * const choice = SecureRandom.getSecureRandomChoice(numbers, {
-     *   quantumSafe: true
-     * });
-     * ```
-     *
-     * @throws {Error} If the array is empty
-     * @security Uses cryptographically secure random selection
-     */
-    static getSecureRandomChoice(array, options) {
-        return randomGenerators.RandomGenerators.getSecureRandomChoice(array, options);
-    }
-    /**
-     * ### Secure Array Shuffle
-     *
-     * Shuffles an array using the Fisher-Yates algorithm with cryptographically secure randomness.
-     * Returns a new array, leaving the original unchanged.
-     *
-     * @template T - The type of elements in the array
-     * @param {T[]} array - Array to shuffle
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {T[]} New shuffled array (original remains unchanged)
-     *
-     * @example
-     * ```typescript
-     * const deck = ['A♠', '2♠', '3♠', '4♠', '5♠'];
-     * const shuffled = SecureRandom.secureArrayShuffle(deck);
-     * // Output: ['3♠', 'A♠', '5♠', '2♠', '4♠'] (randomly shuffled)
-     *
-     * console.log(deck); // ['A♠', '2♠', '3♠', '4♠', '5♠'] (unchanged)
-     * ```
-     *
-     * @algorithm Uses Fisher-Yates shuffle with cryptographic randomness
-     * @security Provides uniform distribution and unpredictability
-     */
-    static secureArrayShuffle(array, options) {
-        return randomGenerators.RandomGenerators.secureArrayShuffle(array, options);
-    }
-    /**
-     * ### Generate Nonce
-     *
-     * Creates a cryptographic nonce (number used once) for preventing replay attacks.
-     * Returns an EnhancedUint8Array for secure memory handling.
-     *
-     * @param {number} [length=12] - Nonce length in bytes
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {import('../../helpers/Uint8Array').EnhancedUint8Array} Secure nonce bytes
-     *
-     * @example
-     * ```typescript
-     * // Generate a 12-byte nonce
-     * const nonce = SecureRandom.generateNonce(12);
-     *
-     * // Use in cryptographic operations
-     * const encrypted = cipher.encrypt(data, key, nonce);
-     * ```
-     *
-     * @security Nonce values are cryptographically secure and unique
-     * @memory Returns EnhancedUint8Array for automatic secure wiping
-     */
-    static generateNonce(...params) {
-        return randomGenerators.RandomGenerators.generateNonce(...params);
-    }
-    // ============================================================================
-    // EXISTING ALIASES (LEGACY COMPATIBILITY)
-    // ============================================================================
-    /**
-     * ### Int (Alias)
-     *
-     * Short alias for {@link SecureRandom.getSecureRandomInt}
-     * Generates a cryptographically secure random integer within a specified range.
-     *
-     * @param {number} min - Minimum value (inclusive)
-     * @param {number} max - Maximum value (inclusive)
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {number} Random integer between min and max
-     *
-     * @example
-     * ```typescript
-     * const diceRoll = SecureRandom.Int(1, 6);
-     * // Same as: SecureRandom.getSecureRandomInt(1, 6)
-     * ```
-     *
-     * @see {@link SecureRandom.getSecureRandomInt} for full documentation
-     */
-    static Int(...params) {
-        return this.getSecureRandomInt(...params);
-    }
-    /**
-     * ### Float (Alias)
-     *
-     * Short alias for {@link SecureRandom.getSecureRandomFloat}
-     * Generates a cryptographically secure random float between 0 and 1.
-     *
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {number} Random float between 0 and 1
-     *
-     * @example
-     * ```typescript
-     * const randomValue = SecureRandom.Float();
-     * // Same as: SecureRandom.getSecureRandomFloat()
-     * ```
-     *
-     * @see {@link SecureRandom.getSecureRandomFloat} for full documentation
-     */
-    static Float(...params) {
-        return this.getSecureRandomFloat(...params);
-    }
-    /**
-     * ### Bool (Alias)
-     *
-     * Short alias for {@link SecureRandom.getSecureRandomBoolean}
-     * Generates a cryptographically secure random boolean value.
-     *
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {boolean} Random boolean (true or false)
-     *
-     * @example
-     * ```typescript
-     * const coinFlip = SecureRandom.Bool();
-     * // Same as: SecureRandom.getSecureRandomBoolean()
-     * ```
-     *
-     * @see {@link SecureRandom.getSecureRandomBoolean} for full documentation
-     */
-    static Bool(...params) {
-        return this.getSecureRandomBoolean(...params);
-    }
-    /**
-     * ### UUID (Alias)
-     *
-     * Short alias for {@link SecureRandom.generateSecureUUID}
-     * Generates a cryptographically secure RFC 4122 compliant UUID v4 string.
-     *
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {string} RFC 4122 compliant UUID v4 string
-     *
-     * @example
-     * ```typescript
-     * const id = SecureRandom.UUID();
-     * // Same as: SecureRandom.generateSecureUUID()
-     * ```
-     *
-     * @see {@link SecureRandom.generateSecureUUID} for full documentation
-     */
-    static UUID(...params) {
-        return this.generateSecureUUID(...params);
-    }
-    /**
-     * ### Bytes (Alias)
-     *
-     * Short alias for {@link SecureRandom.getRandomBytes}
-     * Generates cryptographically secure random bytes.
-     *
-     * @param {number} length - Number of bytes to generate
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {Uint8Array} Array of random bytes
-     *
-     * @example
-     * ```typescript
-     * const key = SecureRandom.Bytes(32);
-     * // Same as: SecureRandom.getRandomBytes(32)
-     * ```
-     *
-     * @see {@link SecureRandom.getRandomBytes} for full documentation
-     */
-    static Bytes(...params) {
-        return this.getRandomBytes(...params);
-    }
-    // ============================================================================
-    // SHORT ALIASES FOR CONVENIENCE
-    // ============================================================================
-    /**
-     * ### Password (Alias)
-     *
-     * Short alias for {@link SecureRandom.generateSecurePassword}
-     * Creates a cryptographically secure password with enforced complexity requirements.
-     *
-     * @param {number} [length=16] - Desired password length (minimum 8 characters)
-     * @param {import('./random-types').TokenGenerationOptions} [options] - Password generation options
-     * @returns {string} A cryptographically secure password
-     *
-     * @example
-     * ```typescript
-     * const password = SecureRandom.Password(16);
-     * // Same as: SecureRandom.generateSecurePassword(16)
-     * ```
-     *
-     * @see {@link SecureRandom.generateSecurePassword} for full documentation
-     */
-    static Password(...params) {
-        return this.generateSecurePassword(...params);
-    }
-    /**
-     * ### SessionToken (Alias)
-     *
-     * Short alias for {@link SecureRandom.generateSessionToken}
-     * Creates a secure session token encoded in the specified format.
-     *
-     * @param {number} [length=32] - Token length in bytes before encoding
-     * @param {"hex"|"base64"|"base64url"} [encoding="base64url"] - Output encoding format
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {string} Secure session token
-     *
-     * @example
-     * ```typescript
-     * const token = SecureRandom.SessionToken(32, 'base64url');
-     * // Same as: SecureRandom.generateSessionToken(32, 'base64url')
-     * ```
-     *
-     * @see {@link SecureRandom.generateSessionToken} for full documentation
-     */
-    static SessionToken(...params) {
-        return this.generateSessionToken(...params);
-    }
-    /**
-     * ### APIKey (Alias)
-     *
-     * Short alias for {@link SecureRandom.generateAPIKey}
-     * Creates a secure API key with optional prefix for easy identification.
-     *
-     * @param {number} [length=32] - Length of the random part of the API key
-     * @param {string} [prefix] - Optional prefix (e.g., "sk_", "pk_")
-     * @param {import('./random-types').TokenGenerationOptions} [options] - Generation options
-     * @returns {string} Secure API key with optional prefix
-     *
-     * @example
-     * ```typescript
-     * const apiKey = SecureRandom.APIKey(32, 'sk_live_');
-     * // Same as: SecureRandom.generateAPIKey(32, 'sk_live_')
-     * ```
-     *
-     * @see {@link SecureRandom.generateAPIKey} for full documentation
-     */
-    static APIKey(...params) {
-        return this.generateAPIKey(...params);
-    }
-    /**
-     * ### PIN (Alias)
-     *
-     * Short alias for {@link SecureRandom.generateSecurePIN}
-     * Creates a numeric PIN code for authentication purposes.
-     *
-     * @param {number} [length=6] - PIN length (minimum 4 digits)
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {string} Numeric PIN as a string
-     *
-     * @example
-     * ```typescript
-     * const pin = SecureRandom.PIN(6);
-     * // Same as: SecureRandom.generateSecurePIN(6)
-     * ```
-     *
-     * @see {@link SecureRandom.generateSecurePIN} for full documentation
-     */
-    static PIN(...params) {
-        return this.generateSecurePIN(...params);
-    }
-    /**
-     * ### OTP (Alias)
-     *
-     * Short alias for {@link SecureRandom.generateSecureOTP}
-     * Creates a one-time password (OTP) for two-factor authentication.
-     *
-     * @param {number} [length=6] - OTP length
-     * @param {import('./random-types').TokenGenerationOptions} [options] - Generation options
-     * @returns {string} Secure OTP string
-     *
-     * @example
-     * ```typescript
-     * const otp = SecureRandom.OTP(6);
-     * // Same as: SecureRandom.generateSecureOTP(6)
-     * ```
-     *
-     * @see {@link SecureRandom.generateSecureOTP} for full documentation
-     */
-    static OTP(...params) {
-        return this.generateSecureOTP(...params);
-    }
-    /**
-     * ### RecoveryCodes (Alias)
-     *
-     * Short alias for {@link SecureRandom.generateRecoveryCodes}
-     * Creates an array of recovery codes for account recovery purposes.
-     *
-     * @param {number} [count=10] - Number of recovery codes to generate (1-100)
-     * @param {number} [codeLength=8] - Length of each individual code
-     * @param {import('./random-types').TokenGenerationOptions} [options] - Generation options
-     * @returns {string[]} Array of recovery codes
-     *
-     * @example
-     * ```typescript
-     * const codes = SecureRandom.RecoveryCodes(10, 8);
-     * // Same as: SecureRandom.generateRecoveryCodes(10, 8)
-     * ```
-     *
-     * @see {@link SecureRandom.generateRecoveryCodes} for full documentation
-     */
-    static RecoveryCodes(...params) {
-        return this.generateRecoveryCodes(...params);
-    }
-    /**
-     * ### ValidateToken (Alias)
-     *
-     * Short alias for {@link SecureRandom.validateTokenStrength}
-     * Analyzes a token/password for strength and provides detailed feedback.
-     *
-     * @param {string} token - The token to analyze
-     * @returns {Object} Strength analysis results
-     *
-     * @example
-     * ```typescript
-     * const analysis = SecureRandom.ValidateToken("password123");
-     * // Same as: SecureRandom.validateTokenStrength("password123")
-     * ```
-     *
-     * @see {@link SecureRandom.validateTokenStrength} for full documentation
-     */
-    static ValidateToken(...params) {
-        return this.validateTokenStrength(...params);
-    }
-    /**
-     * ### UUIDBatch (Alias)
-     *
-     * Short alias for {@link SecureRandom.generateSecureUUIDBatch}
-     * Efficiently generates multiple UUID v4 strings in a single operation.
-     *
-     * @param {number} count - Number of UUIDs to generate (1-1000)
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {string[]} Array of RFC 4122 compliant UUID v4 strings
-     *
-     * @example
-     * ```typescript
-     * const uuids = SecureRandom.UUIDBatch(100);
-     * // Same as: SecureRandom.generateSecureUUIDBatch(100)
-     * ```
-     *
-     * @see {@link SecureRandom.generateSecureUUIDBatch} for full documentation
-     */
-    static UUIDBatch(...params) {
-        return this.generateSecureUUIDBatch(...params);
-    }
-    /**
-     * ### Choice (Alias)
-     *
-     * Short alias for {@link SecureRandom.getSecureRandomChoice}
-     * Selects a random element from an array using cryptographically secure randomness.
-     *
-     * @template T - The type of elements in the array
-     * @param {T[]} array - Array to select from (must not be empty)
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {T} Randomly selected element from the array
-     *
-     * @example
-     * ```typescript
-     * const winner = SecureRandom.Choice(['Alice', 'Bob', 'Charlie']);
-     * // Same as: SecureRandom.getSecureRandomChoice(['Alice', 'Bob', 'Charlie'])
-     * ```
-     *
-     * @see {@link SecureRandom.getSecureRandomChoice} for full documentation
-     */
-    static Choice(...params) {
-        return this.getSecureRandomChoice(...params);
-    }
-    /**
-     * ### Shuffle (Alias)
-     *
-     * Short alias for {@link SecureRandom.secureArrayShuffle}
-     * Shuffles an array using the Fisher-Yates algorithm with cryptographically secure randomness.
-     *
-     * @template T - The type of elements in the array
-     * @param {T[]} array - Array to shuffle
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {T[]} New shuffled array (original remains unchanged)
-     *
-     * @example
-     * ```typescript
-     * const shuffled = SecureRandom.Shuffle([1, 2, 3, 4, 5]);
-     * // Same as: SecureRandom.secureArrayShuffle([1, 2, 3, 4, 5])
-     * ```
-     *
-     * @see {@link SecureRandom.secureArrayShuffle} for full documentation
-     */
-    static Shuffle(...params) {
-        return this.secureArrayShuffle(...params);
-    }
-    /**
-     * ### Nonce (Alias)
-     *
-     * Short alias for {@link SecureRandom.generateNonce}
-     * Creates a cryptographic nonce (number used once) for preventing replay attacks.
-     *
-     * @param {number} [length=12] - Nonce length in bytes
-     * @param {import('./random-types').RandomGenerationOptions} [options] - Generation options
-     * @returns {import('../../helpers/Uint8Array').EnhancedUint8Array} Secure nonce bytes
-     *
-     * @example
-     * ```typescript
-     * const nonce = SecureRandom.nonce(12);
-     * // Same as: SecureRandom.generateNonce(12)
-     * ```
-     *
-     * @see {@link SecureRandom.generateNonce} for full documentation
-     */
-    static Nonce(...params) {
-        return this.generateNonce(...params);
-    }
-}
-
-exports.SecureRandom = SecureRandom;
-//# sourceMappingURL=random-core.js.map