xypriss 9.0.13 → 9.1.1

package/dist/esm/mods/security/src/index.js

@@ -1,340 +0,0 @@
-import { XyPrissSecurity } from './core/crypto.js';
-import 'crypto';
-import './types/secure-memory.js';
-import './utils/memory/index.js';
-import { Hash } from './core/hash/hash-core.js';
-export { HashStrength } from './core/hash/hash-types.js';
-export { HashSecurity } from './core/hash/hash-security.js';
-export { HashAdvanced } from './core/hash/hash-advanced.js';
-export { HashAlgorithms } from './algorithms/hash-algorithms.js';
-import { SecureRandom } from './core/random/random-core.js';
-export { EntropyQuality, RNGState } from './core/random/random-types.js';
-export { RandomSources } from './core/random/random-sources.js';
-import 'strulink';
-export { EntropySource, HashAlgorithm, KeyDerivationAlgorithm, SecurityLevel, TokenType } from './types.js';
-import './components/secure-string/advanced/entropy-analyzer.js';
-import './components/secure-string/advanced/quantum-safe.js';
-import './components/secure-string/advanced/performance-monitor.js';
-import 'nehoid';
-import './components/secure-array/utils/id-generator.js';
-export { PasswordAlgorithm, PasswordSecurityLevel } from './core/password/password-types.js';
-import './core/keys/keys-types.js';
-import './core/keys/keys-logger.js';
-import './core/keys/keys-utils.js';
-import './core/keys/algorithms/mods/PBKDF2Algo.js';
-export { getDefaultPasswordPolicy, getRecommendedConfig } from './core/password/index.js';
-import 'argon2';
-import 'child_process';
-import 'https';
-export { SecurityIssueType, verifyRuntimeSecurity } from './components/runtime-verification.js';
-export { LogLevel, TamperEvidentLogger } from './components/tamper-evident-logging.js';
-import './components/fortified-function/core/fortified-function-core.js';
-import './components/fortified-function/core/fortified-config.js';
-import './components/fortified-function/core/fortified-logger.js';
-import 'events';
-import './components/fortified-function/serializer/safe-serializer.js';
-import '../../../shared/logger/Logger.js';
-import './components/fortified-function/UFA/ultra-fast-allocator.js';
-export { Cache, createOptimalCache, generateFilePath } from './components/cache/index.js';
-import { PasswordManager } from './core/password/password-core.js';
-
-/***************************************************************************
- * XyPrissSecurity - Ex fortify2-js is an Advanced JavaScript Security Library designed for XyPriss
- *
- * This file contains the main entry point for the XyPrissSecurity library.
- *
- * @author Nehonix
- * @license MIT
- *
- * Copyright (c) 2025 Nehonix. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- ***************************************************************************** */
-/**
- * # XyPrissSecurity - Advanced JavaScript Security Library
- *
- * **The most comprehensive cryptographic security library for JavaScript applications**
- *
- * XyPrissSecurity provides enterprise-grade security features including military-grade encryption,
- * secure data structures, advanced password management, and real-time security monitoring.
- * Built with TypeScript for maximum type safety and developer experience.
- *
- * ## Core Features
- *
- * ### Secure Data Structures
- * - **SecureArray**: Military-grade encrypted arrays with AES-256-CTR-HMAC
- * - **SecureString**: Protected string handling with automatic memory cleanup
- * - **SecureObject**: Encrypted object storage with metadata management
- * - **SecureBuffer**: Protected memory allocation with secure wiping
- *
- * ### Cryptographic Operations
- * - **Token Generation**: Secure random tokens with configurable entropy
- * - **Password Management**: Argon2ID hashing with pepper support
- * - **Hash Functions**: SHA-256/512, BLAKE3, with timing-safe operations
- * - **Key Derivation**: PBKDF2, Argon2, scrypt with memory-hard algorithms
- *
- * ### Performance & Security
- * - **FortifiedFunction**: Ultra-fast function execution with security monitoring
- * - **Cache System**: High-performance caching with encryption support
- * - **Memory Management**: Automatic cleanup and leak detection
- * - **Side-Channel Protection**: Constant-time operations and fault resistance
- *
- * ### Advanced Security
- * - **Post-Quantum Cryptography**: Lamport signatures and Ring-LWE
- * - **Canary Tokens**: Intrusion detection and monitoring
- * - **Attestation**: Code integrity verification
- * - **Entropy Augmentation**: Enhanced randomness sources
- *
- * ## Quick Start Examples
- *
- * ### Basic Token Generation
- * ```typescript
- * import { XyPrissSecurity, generateSecureToken } from "xypriss-security";
- *
- * // Generate a secure API key
- * const apiKey = XyPrissSecurity.generateSecureToken({
- *     length: 32,
- *     entropy: "maximum",
- *     includeSymbols: false
- * });
- * console.log(apiKey); // "aK7mN9pQ2rS8tU3vW6xY1zB4cD5eF7gH"
- *
- * // Quick token generation
- * const sessionToken = generateSecureToken({
-    length: 32,
-    entropy: "maximum",
-
-});
- * ```
- *
- * ### Secure Data Structures
- * ```typescript
- * import { fArray, fString, fObject } from "xypriss-security";
- *
- * // Secure array with encryption
- * const sensitiveData = fArray(["api-key-1", "secret-token", "user-data"]);
- * sensitiveData.setEncryptionKey("your-encryption-key-2025");
- * sensitiveData.encryptAll();
- *
- * // Secure string with automatic cleanup
- * const password = fString("user-password-123", {
- *     protectionLevel: "maximum",
- *     enableEncryption: true
- * });
- *
- * // Secure object with metadata
- * const userCredentials = fObject({
- *     username: "john_doe",
- *     apiKey: "secret-key-value"
- * });
- * ```
- *
- * ### Password Management
- * ```typescript
- * import { PasswordManager, encryptSecurePass, verifyEncryptedPassword } from "xypriss-security";
- *
- * // Advanced password hashing with pepper
- * const pepper = process.env.PASSWORD_PEPPER;
- * const hashedPassword = await encryptSecurePass("userPassword123", pepper);
- *
- * // Verify password with timing-safe comparison
- * const isValid = await verifyEncryptedPassword("userPassword123", hashedPassword, pepper);
- *
- * // Password manager with custom configuration
- * const pm = PasswordManager.create({
- *     algorithm: "argon2id",
- *     memoryCost: 65536,
- *     timeCost: 3
- * });
- * ```
- *
- * ### High-Performance Functions
- * ```typescript
- * import { func, createFortifiedFunction } from "xypriss-security";
- *
- * // Ultra-fast function with security monitoring
- * const optimizedFunction = func(async (data: string) => {
- *     return data.toUpperCase();
- * }, {
- *     ultraFast: "maximum",
- *     smartCaching: true,
- *     autoEncrypt: true
- * });
- *
- * const result = await optimizedFunction.execute("hello world");
- * const analytics = optimizedFunction.getAnalyticsData();
- * ```
- *
- * ## Security Best Practices
- *
- * 1. **Always use environment variables for sensitive keys**
- * 2. **Enable encryption for sensitive data structures**
- * 3. **Use timing-safe operations for authentication**
- * 4. **Implement proper memory cleanup with destroy() methods**
- * 5. **Monitor security status with built-in analytics**
- *
- * @author Nehonix
- * @version 4.2.0
- * @license MIT
- * @see {@link https://lab.nehonix.com/nehonix_viewer/_doc/Nehonix%20XyPrissSecurity} Official Documentation
- * @see {@link https://github.com/Nehonix-Team/XyPriss} GitHub Repository
- * @see {@link https://nodejs.org/api/crypto.html} Node.js Crypto Module
- * @see {@link https://github.com/ranisalt/node-argon2} Argon2 Implementation
- * @see {@link https://github.com/paulmillr/noble-hashes} Noble Hashes Library
- * @see {@link https://libsodium.gitbook.io/doc/} Libsodium Documentation
- * @see {@link https://github.com/jedisct1/libsodium.js} Libsodium.js
- * @see {@link https://www.npmjs.com/package/bcryptjs} BCrypt.js Package
- *
- * @example
- * ```typescript
- * // Complete security setup example
- * import { XyPrissSecurity, fArray, PasswordManager } from "xypriss-security";
- *
- * // 1. Generate secure tokens
- * const apiKey = XyPrissSecurity.generateAPIKey(32, "api");
- * const sessionToken = XyPrissSecurity.generateSessionToken();
- *
- * // 2. Secure data storage
- * const userData = fArray([]);
- * userData.setEncryptionKey(process.env.ENCRYPTION_KEY);
- * userData.push("sensitive-user-data");
- *
- * // 3. Password management
- * const pm = PasswordManager.getInstance();
- * const hashedPassword = await pm.hash("userPassword");
- *
- * // 4. Security monitoring
- * const stats = XyPrissSecurity.getStats();
- * const securityStatus = XyPrissSecurity.verifyRuntimeSecurity();
- *
- * console.log("Security Status:", securityStatus.isSecure);
- * console.log("Operations:", stats.totalOperations);
- * ```
- */
-XyPrissSecurity.generateSecureToken;
-/**
- * ### Random Data Generation
- *
- * High-entropy random data generation for cryptographic operations.
- *
- * @example
- * ```typescript
- * import { getRandomBytes, generateSecureUUID } from "xypriss-security";
- *
- * // Generate random bytes
- * const randomData = getRandomBytes(32);
- *
- * // Generate secure UUID
- * const uuid = generateSecureUUID();
- * ```
- */
-/** Generate cryptographically secure random bytes */
-SecureRandom.getRandomBytes;
-/** Generate secure UUID with high entropy */
-SecureRandom.generateSecureUUID;
-/**
- * ### Hash Operations
- *
- * Military-grade hashing functions with timing-safe operations and
- * automatic salt generation for maximum security.
- *
- * @example
- * ```typescript
- * import { createSecureHash, createSecureHMAC, verifyHash } from "xypriss-security";
- *
- * // Create secure hash with automatic salt
- * const hash = createSecureHash("data to hash");
- *
- * // Create HMAC with secret key
- * const hmac = createSecureHMAC("sha256", "secret-key", "data");
- *
- * // Verify hash with timing-safe comparison
- * const isValid = verifyHash("original-data", hash);
- * ```
- *
- * @see {@link https://github.com/paulmillr/noble-hashes} Noble Hashes - Modern Crypto Library
- * @see {@link https://nodejs.org/api/crypto.html#cryptocreatehashstring-options} Node.js Hash Functions
- * @see {@link https://tools.ietf.org/html/rfc2104} RFC 2104 - HMAC Specification
- * @see {@link https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf} NIST SHA Standards
- */
-/** Create secure hash with automatic salt generation */
-Hash.createSecureHash;
-/** Create secure HMAC with timing-safe operations */
-Hash.createSecureHMAC;
-/** Verify hash with constant-time comparison */
-Hash.verifyHash;
-/**
- * ### Password Manager Quick Access
- *
- * Convenient alias for password manager with default configuration.
- * For production use with custom configuration, use PasswordManager.create()
- * or PasswordManager.getInstance() with specific options.
- *
- * @example
- * ```typescript
- * import { pm } from "xypriss-security";
- *
- * // Quick password operations with default config
- * const hash = await pm.hash("userPassword");
- * const result = await pm.verify("userPassword", hash);
- *
- * // For custom configuration:
- * // const customPM = PasswordManager.create({ memoryCost: 131072 });
- * ```
- *
- * @deprecated Consider using PasswordManager.getInstance() for explicit configuration
- */
-PasswordManager.getInstance();
-/**
- * Securely encrypts data using the CryptoUtils class.
- *
- * @public
- * @param {string} text - The plaintext string to encrypt
- * @param {...ConstructorParameters<typeof CryptoUtils>} args - Arguments to pass to the CryptoUtils constructor
- *
- * @returns {string} The encrypted string in format "IV:ENCRYPTED_DATA"
- *
- * @throws {Error} If validation fails or encryption operation encounters an error
- *
- * @example
- * ```typescript
- * const encrypted = encrypt('my-plaintext-data', 'my-32-character-key-here!!!!');
- * ```
- */
-XyPrissSecurity.encrypt;
-/**
- * Securely decrypts data using the CryptoUtils class.
- *
- * @public
- * @param {string} encryptedText - The encrypted string in format "IV:ENCRYPTED_DATA"
- * @param {...ConstructorParameters<typeof CryptoUtils>} args - Arguments to pass to the CryptoUtils constructor
- *
- * @returns {string} The decrypted string
- *
- * @throws {Error} If validation fails or decryption operation encounters an error
- *
- * @example
- * ```typescript
- * const decrypted = decrypt('IV:my-encrypted-data', 'my-32-character-key-here!!!!');
- * ```
- */
-XyPrissSecurity.decrypt;
-
-export { Hash, PasswordManager, SecureRandom as Random, SecureRandom, XyPrissSecurity as XyPriss, XyPrissSecurity };
-//# sourceMappingURL=index.js.map

package/dist/esm/mods/security/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../mods/security/src/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BiF;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgKG;AAyVgC,eAAe,CAAC,oBAAoB;AA2KvE;;;;;;;;;;;;;;;AAeG;AAEH;AAC8B,YAAY,CAAC,eAAe;AAE1D;AACkC,YAAY,CAAC,mBAAmB;AAmBlE;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AAEH;AACgC,IAAI,CAAC,iBAAiB;AAEtD;AACgC,IAAI,CAAC,iBAAiB;AAEtD;AAC0B,IAAI,CAAC,WAAW;AAyL1C;;;;;;;;;;;;;;;;;;;;AAoBG;AACe,eAAe,CAAC,WAAW,GAAG;AA0rB5C;;;;;;;;;;;;;;;AAeG;AACgB,eAAe,CAAC,QAAQ;AAE/C;;;;;;;;;;;;;;;AAeG;AACoB,eAAe,CAAC;;;;"}

package/dist/esm/mods/security/src/types/global.js

@@ -1,49 +0,0 @@
-/**
- * Global type definitions for XyPrissSecurity
- *
- * This file contains polyfills and type definitions for modern JavaScript features
- * that may not be available in all environments.
- */
-/**
- * Runtime polyfills for WeakRef and FinalizationRegistry
- */
-function initializePolyfills() {
-    // Check if WeakRef is available
-    if (typeof globalThis.WeakRef === "undefined") {
-        // Simple polyfill for WeakRef
-        globalThis.WeakRef = class WeakRef {
-            constructor(target) {
-                this.target = target;
-            }
-            deref() {
-                return this.target;
-            }
-        };
-    }
-    // Check if FinalizationRegistry is available
-    if (typeof globalThis.FinalizationRegistry === "undefined") {
-        // Simple polyfill for FinalizationRegistry
-        globalThis.FinalizationRegistry = class FinalizationRegistry {
-            constructor(cleanupCallback) {
-                this.registrations = new Map();
-                this.cleanupCallback = cleanupCallback;
-            }
-            register(target, heldValue, unregisterToken) {
-                this.registrations.set(target, heldValue);
-                // Simple timeout-based cleanup (not perfect but better than nothing)
-                setTimeout(() => {
-                    if (this.registrations.has(target)) {
-                        this.cleanupCallback(heldValue);
-                        this.registrations.delete(target);
-                    }
-                }, 30000); // 30 seconds
-            }
-            unregister(unregisterToken) {
-                return this.registrations.delete(unregisterToken);
-            }
-        };
-    }
-}
-
-export { initializePolyfills };
-//# sourceMappingURL=global.js.map

package/dist/esm/mods/security/src/types/global.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"global.js","sources":["../../../../../../mods/security/src/types/global.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;AAKG;AAwBH;;AAEG;SACa,mBAAmB,GAAA;;AAE/B,IAAA,IAAI,OAAQ,UAAkB,CAAC,OAAO,KAAK,WAAW,EAAE;;AAEnD,QAAA,UAAkB,CAAC,OAAO,GAAG,MAAM,OAAO,CAAA;AAGvC,YAAA,WAAA,CAAY,MAAS,EAAA;AACjB,gBAAA,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;aACxB;YAED,KAAK,GAAA;gBACD,OAAO,IAAI,CAAC,MAAM,CAAC;aACtB;SACJ,CAAC;KACL;;AAGD,IAAA,IAAI,OAAQ,UAAkB,CAAC,oBAAoB,KAAK,WAAW,EAAE;;AAEhE,QAAA,UAAkB,CAAC,oBAAoB,GAAG,MAAM,oBAAoB,CAAA;AAMjE,YAAA,WAAA,CAAY,eAAuC,EAAA;AAF3C,gBAAA,IAAA,CAAA,aAAa,GAAG,IAAI,GAAG,EAAa,CAAC;AAGzC,gBAAA,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;aAC1C;AAED,YAAA,QAAQ,CACJ,MAAc,EACd,SAAY,EACZ,eAAwB,EAAA;gBAExB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;;gBAG1C,UAAU,CAAC,MAAK;oBACZ,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;AAChC,wBAAA,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;AAChC,wBAAA,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;qBACrC;AACL,iBAAC,EAAE,KAAK,CAAC,CAAC;aACb;AAED,YAAA,UAAU,CAAC,eAAuB,EAAA;gBAC9B,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;aACrD;SACJ,CAAC;KACL;AACL;;;;"}

package/dist/esm/mods/security/src/types/secure-mem.type.js

@@ -1,102 +0,0 @@
-// Safe library instances
-let sodium = null;
-let nobleHashes = null;
-let nobleCiphers = null;
-// Library status tracking
-const libraryStatus = {
-    sodium: false,
-    nobleHashes: false,
-    nobleCiphers: false,
-};
-// Safe library initialization with proper error handling
-async function initializeSecurityLibraries() {
-    // Initialize libsodium with proper async handling
-    try {
-        const sodiumLib = await import('libsodium-wrappers');
-        if (sodiumLib.default) {
-            // Wait for sodium to be ready if it has a ready promise
-            if (sodiumLib.default.ready &&
-                typeof sodiumLib.default.ready.then === "function") {
-                await sodiumLib.default.ready;
-            }
-            // Verify required methods exist
-            if (typeof sodiumLib.default.randombytes_buf === "function") {
-                sodium = sodiumLib.default;
-                libraryStatus.sodium = true;
-                // console.log(
-                //     "✔ libsodium-wrappers loaded successfully for SecureBuffer"
-                // );
-            }
-        }
-    }
-    catch (e) {
-        // console.warn(
-        //     "⚠️ libsodium-wrappers not available for SecureBuffer:",
-        //     (e as Error).message
-        // );
-    }
-    // Initialize @noble/hashes using require for compatibility
-    try {
-        const nobleHashesLib = require("@noble/hashes/sha256");
-        const nobleHashesLib512 = require("@noble/hashes/sha512");
-        if (nobleHashesLib &&
-            nobleHashesLib.sha256 &&
-            nobleHashesLib512 &&
-            nobleHashesLib512.sha512) {
-            nobleHashes = {
-                sha256: nobleHashesLib.sha256,
-                sha512: nobleHashesLib512.sha512,
-            };
-            libraryStatus.nobleHashes = true;
-            // console.log(
-            //     "✔ @noble/hashes loaded successfully for SecureBuffer"
-            // );
-        }
-    }
-    catch (e) {
-        // console.warn(
-        //     "⚠️ @noble/hashes not available for SecureBuffer:",
-        //     (e as Error).message
-        // );
-    }
-    // Initialize @noble/ciphers using require for compatibility
-    try {
-        // Try importing specific submodules instead of root module
-        const chachaLib = require("@noble/ciphers/chacha");
-        const aesLib = require("@noble/ciphers/aes");
-        if (chachaLib && aesLib) {
-            nobleCiphers = {
-                chacha20poly1305: chachaLib.chacha20poly1305,
-                aes: aesLib,
-            };
-            libraryStatus.nobleCiphers = true;
-            // console.log(
-            //     "✔ @noble/ciphers loaded successfully for SecureBuffer"
-            // );
-        }
-    }
-    catch (e) {
-        // Silently fail - this is optional
-        // console.warn(
-        //     "⚠️ @noble/ciphers not available for SecureBuffer:",
-        //     (e as Error).message
-        // );
-    }
-}
-// Initialize libraries asynchronously and non-blocking
-let initializationPromise = null;
-function ensureLibrariesInitialized() {
-    if (!initializationPromise) {
-        initializationPromise = initializeSecurityLibraries().catch((_error) => {
-            // Silently handle initialization errors - libraries are optional
-            // console.error(
-            //     "Failed to initialize security libraries for SecureBuffer:",
-            //     error
-            // );
-        });
-    }
-    return initializationPromise;
-}
-
-export { ensureLibrariesInitialized, initializeSecurityLibraries, libraryStatus, nobleCiphers, nobleHashes, sodium };
-//# sourceMappingURL=secure-mem.type.js.map

package/dist/esm/mods/security/src/types/secure-mem.type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"secure-mem.type.js","sources":["../../../../../../mods/security/src/types/secure-mem.type.ts"],"sourcesContent":[null],"names":[],"mappings":"AA8BA;AACI,IAAA,MAAM,GAA2B,KAAK;AACtC,IAAA,WAAW,GAAgC,KAAK;AAChD,IAAA,YAAY,GAAiC,KAAK;AAEtD;AACA,MAAM,aAAa,GAAG;AAClB,IAAA,MAAM,EAAE,KAAK;AACb,IAAA,WAAW,EAAE,KAAK;AAClB,IAAA,YAAY,EAAE,KAAK;EACrB;AAEF;AACO,eAAe,2BAA2B,GAAA;;AAE7C,IAAA,IAAI;AACA,QAAA,MAAM,SAAS,GAAG,MAAM,OAAO,oBAAoB,CAAC,CAAC;AACrD,QAAA,IAAI,SAAS,CAAC,OAAO,EAAE;;AAEnB,YAAA,IACI,SAAS,CAAC,OAAO,CAAC,KAAK;gBACvB,OAAO,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,EACpD;AACE,gBAAA,MAAM,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;aACjC;;YAGD,IAAI,OAAO,SAAS,CAAC,OAAO,CAAC,eAAe,KAAK,UAAU,EAAE;AACzD,gBAAA,MAAM,GAAG,SAAS,CAAC,OAA0B,CAAC;AAC9C,gBAAA,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC;;;;aAI/B;SACJ;KACJ;IAAC,OAAO,CAAC,EAAE;;;;;KAKX;;AAGD,IAAA,IAAI;AACA,QAAA,MAAM,cAAc,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;AACvD,QAAA,MAAM,iBAAiB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;AAC1D,QAAA,IACI,cAAc;AACd,YAAA,cAAc,CAAC,MAAM;YACrB,iBAAiB;YACjB,iBAAiB,CAAC,MAAM,EAC1B;AACE,YAAA,WAAW,GAAG;gBACV,MAAM,EAAE,cAAc,CAAC,MAAM;gBAC7B,MAAM,EAAE,iBAAiB,CAAC,MAAM;aACX,CAAC;AAC1B,YAAA,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC;;;;SAIpC;KACJ;IAAC,OAAO,CAAC,EAAE;;;;;KAKX;;AAGD,IAAA,IAAI;;AAEA,QAAA,MAAM,SAAS,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;AACnD,QAAA,MAAM,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAC7C,QAAA,IAAI,SAAS,IAAI,MAAM,EAAE;AACrB,YAAA,YAAY,GAAG;gBACX,gBAAgB,EAAE,SAAS,CAAC,gBAAgB;AAC5C,gBAAA,GAAG,EAAE,MAAM;aACW,CAAC;AAC3B,YAAA,aAAa,CAAC,YAAY,GAAG,IAAI,CAAC;;;;SAIrC;KACJ;IAAC,OAAO,CAAC,EAAE;;;;;;KAMX;AACL,CAAC;AAED;AACA,IAAI,qBAAqB,GAAyB,IAAI,CAAC;SAEvC,0BAA0B,GAAA;IACtC,IAAI,CAAC,qBAAqB,EAAE;QACxB,qBAAqB,GAAG,2BAA2B,EAAE,CAAC,KAAK,CACvD,CAAC,MAAM,KAAI;;;;;;AAMX,SAAC,CACJ,CAAC;KACL;AACD,IAAA,OAAO,qBAAqB,CAAC;AACjC;;;;"}

package/dist/esm/mods/security/src/types/secure-memory.js

@@ -1,20 +0,0 @@
-// Memory protection levels
-var MemoryProtectionLevel;
-(function (MemoryProtectionLevel) {
-    MemoryProtectionLevel["BASIC"] = "basic";
-    MemoryProtectionLevel["ENHANCED"] = "enhanced";
-    MemoryProtectionLevel["MILITARY"] = "military";
-    MemoryProtectionLevel["QUANTUM_SAFE"] = "quantum_safe";
-})(MemoryProtectionLevel || (MemoryProtectionLevel = {}));
-// Buffer state tracking
-var BufferState;
-(function (BufferState) {
-    BufferState["UNINITIALIZED"] = "uninitialized";
-    BufferState["ACTIVE"] = "active";
-    BufferState["LOCKED"] = "locked";
-    BufferState["DESTROYED"] = "destroyed";
-    BufferState["CORRUPTED"] = "corrupted";
-})(BufferState || (BufferState = {}));
-
-export { BufferState, MemoryProtectionLevel };
-//# sourceMappingURL=secure-memory.js.map

package/dist/esm/mods/security/src/types/secure-memory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"secure-memory.js","sources":["../../../../../../mods/security/src/types/secure-memory.ts"],"sourcesContent":[null],"names":[],"mappings":"AACA;IACY,sBAKX;AALD,CAAA,UAAY,qBAAqB,EAAA;AAC7B,IAAA,qBAAA,CAAA,OAAA,CAAA,GAAA,OAAe,CAAA;AACf,IAAA,qBAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,qBAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,qBAAA,CAAA,cAAA,CAAA,GAAA,cAA6B,CAAA;AACjC,CAAC,EALW,qBAAqB,KAArB,qBAAqB,GAKhC,EAAA,CAAA,CAAA,CAAA;AAED;IACY,YAMX;AAND,CAAA,UAAY,WAAW,EAAA;AACnB,IAAA,WAAA,CAAA,eAAA,CAAA,GAAA,eAA+B,CAAA;AAC/B,IAAA,WAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,WAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,WAAA,CAAA,WAAA,CAAA,GAAA,WAAuB,CAAA;AACvB,IAAA,WAAA,CAAA,WAAA,CAAA,GAAA,WAAuB,CAAA;AAC3B,CAAC,EANW,WAAW,KAAX,WAAW,GAMtB,EAAA,CAAA,CAAA;;;;"}

package/dist/esm/mods/security/src/types.js

@@ -1,63 +0,0 @@
-/**
- * Type definitions for the XyPrissSecurity library
- */
-/**
- * Security level enum
- */
-var SecurityLevel;
-(function (SecurityLevel) {
-    SecurityLevel["STANDARD"] = "standard";
-    SecurityLevel["HIGH"] = "high";
-    SecurityLevel["MAXIMUM"] = "maximum";
-})(SecurityLevel || (SecurityLevel = {}));
-/**
- * Token type enum
- */
-var TokenType;
-(function (TokenType) {
-    TokenType["GENERAL"] = "general";
-    TokenType["API_KEY"] = "api_key";
-    TokenType["SESSION"] = "session";
-    TokenType["JWT"] = "jwt";
-    TokenType["TOTP"] = "totp";
-})(TokenType || (TokenType = {}));
-/**
- * Hash algorithm enum - can be used as values
- */
-var HashAlgorithm;
-(function (HashAlgorithm) {
-    HashAlgorithm["SHA256"] = "sha256";
-    HashAlgorithm["SHA512"] = "sha512";
-    HashAlgorithm["SHA3_256"] = "sha3-256";
-    HashAlgorithm["SHA3_512"] = "sha3-512";
-    HashAlgorithm["BLAKE3"] = "blake3";
-    HashAlgorithm["BLAKE2B"] = "blake2b";
-    HashAlgorithm["BLAKE2S"] = "blake2s";
-    HashAlgorithm["PBKDF2"] = "pbkdf2";
-})(HashAlgorithm || (HashAlgorithm = {}));
-/**
- * Key derivation algorithm enum
- */
-var KeyDerivationAlgorithm;
-(function (KeyDerivationAlgorithm) {
-    KeyDerivationAlgorithm["PBKDF2"] = "pbkdf2";
-    KeyDerivationAlgorithm["ARGON2"] = "argon2";
-    KeyDerivationAlgorithm["BALLOON"] = "balloon";
-})(KeyDerivationAlgorithm || (KeyDerivationAlgorithm = {}));
-/**
- * Entropy source enum
- */
-var EntropySource;
-(function (EntropySource) {
-    EntropySource["SYSTEM"] = "system";
-    EntropySource["BROWSER"] = "browser";
-    EntropySource["USER"] = "user";
-    EntropySource["NETWORK"] = "network";
-    EntropySource["COMBINED"] = "combined";
-    EntropySource["CSPRNG"] = "csprng";
-    EntropySource["MATH_RANDOM"] = "math_random";
-    EntropySource["CUSTOM"] = "custom";
-})(EntropySource || (EntropySource = {}));
-
-export { EntropySource, HashAlgorithm, KeyDerivationAlgorithm, SecurityLevel, TokenType };
-//# sourceMappingURL=types.js.map

package/dist/esm/mods/security/src/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sources":["../../../../../mods/security/src/types.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;AAEG;AAMH;;AAEG;IACS,cAIX;AAJD,CAAA,UAAY,aAAa,EAAA;AACrB,IAAA,aAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,aAAA,CAAA,MAAA,CAAA,GAAA,MAAa,CAAA;AACb,IAAA,aAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACvB,CAAC,EAJW,aAAa,KAAb,aAAa,GAIxB,EAAA,CAAA,CAAA,CAAA;AAED;;AAEG;IACS,UAMX;AAND,CAAA,UAAY,SAAS,EAAA;AACjB,IAAA,SAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,SAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,SAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,SAAA,CAAA,KAAA,CAAA,GAAA,KAAW,CAAA;AACX,IAAA,SAAA,CAAA,MAAA,CAAA,GAAA,MAAa,CAAA;AACjB,CAAC,EANW,SAAS,KAAT,SAAS,GAMpB,EAAA,CAAA,CAAA,CAAA;AAED;;AAEG;IACS,cASX;AATD,CAAA,UAAY,aAAa,EAAA;AACrB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,aAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,aAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,aAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,aAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACrB,CAAC,EATW,aAAa,KAAb,aAAa,GASxB,EAAA,CAAA,CAAA,CAAA;AAoBD;;AAEG;IACS,uBAIX;AAJD,CAAA,UAAY,sBAAsB,EAAA;AAC9B,IAAA,sBAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,sBAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,sBAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACvB,CAAC,EAJW,sBAAsB,KAAtB,sBAAsB,GAIjC,EAAA,CAAA,CAAA,CAAA;AAED;;AAEG;IACS,cASX;AATD,CAAA,UAAY,aAAa,EAAA;AACrB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,aAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,aAAA,CAAA,MAAA,CAAA,GAAA,MAAa,CAAA;AACb,IAAA,aAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,aAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,aAAA,CAAA,aAAA,CAAA,GAAA,aAA2B,CAAA;AAC3B,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACrB,CAAC,EATW,aAAa,KAAb,aAAa,GASxB,EAAA,CAAA,CAAA;;;;"}

package/dist/esm/mods/security/src/utils/CryptoAlgorithmUtils.js

@@ -1,69 +0,0 @@
-import { ALGORITHM_REGISTRY } from '../algorithms/registry.js';
-
-/**
- * Utility class for algorithm validation and information
- */
-class CryptoAlgorithmUtils {
-    /**
-     * Validates if an algorithm is supported
-     */
-    static isSupported(algorithm) {
-        return algorithm in ALGORITHM_REGISTRY;
-    }
-    /**
-     * Gets algorithm information
-     */
-    static getInfo(algorithm) {
-        return ALGORITHM_REGISTRY[algorithm];
-    }
-    /**
-     * Checks if an algorithm is deprecated
-     */
-    static isDeprecated(algorithm) {
-        return ALGORITHM_REGISTRY[algorithm].deprecated;
-    }
-    /**
-     * Gets all algorithms by security level
-     */
-    static getAlgorithmsBySecurityLevel(level) {
-        return Object.entries(ALGORITHM_REGISTRY)
-            .filter(([, info]) => info.securityLevel === level)
-            .map(([algorithm]) => algorithm);
-    }
-    /**
-     * Gets recommended algorithms (non-deprecated, strong or very-strong)
-     */
-    static getRecommendedAlgorithms() {
-        return Object.entries(ALGORITHM_REGISTRY)
-            .filter(([, info]) => !info.deprecated &&
-            (info.securityLevel === "strong" ||
-                info.securityLevel === "very-strong"))
-            .map(([algorithm]) => algorithm);
-    }
-    /**
-     * Validates algorithm and warns about deprecated ones
-     */
-    static validateAlgorithm(algorithm) {
-        if (!this.isSupported(algorithm)) {
-            throw new Error(`Unsupported algorithm: ${algorithm}. Supported: ${Object.keys(ALGORITHM_REGISTRY).join(", ")}`);
-        }
-        const info = this.getInfo(algorithm);
-        if (info.deprecated) {
-            console.warn(`Warning: ${algorithm} is deprecated. ${info.description}`);
-        }
-        // For now, only return hash algorithms for the hash method
-        const hashAlgorithms = [
-            "SHA-1",
-            "SHA-256",
-            "SHA-384",
-            "SHA-512",
-        ];
-        if (!hashAlgorithms.includes(algorithm)) {
-            throw new Error(`Algorithm ${algorithm} is not a hash algorithm`);
-        }
-        return algorithm;
-    }
-}
-
-export { CryptoAlgorithmUtils };
-//# sourceMappingURL=CryptoAlgorithmUtils.js.map