xypriss 1.1.0 → 1.1.2

package/dist/cjs/mods/toolkit/src/index.js

@@ -1,417 +0,0 @@
-'use strict';
-
-var types = require('./types.js');
-var hashCore = require('./core/hash/hash-core.js');
-require('./core/hash/hash-types.js');
-require('crypto');
-require('./core/hash/hash-security.js');
-require('./core/hash/hash-advanced.js');
-require('./algorithms/hash-algorithms.js');
-require('./core/keys/keys-types.js');
-require('./core/keys/keys-logger.js');
-require('./core/keys/keys-utils.js');
-require('./core/keys/algorithms/mods/PBKDF2Algo.js');
-var randomCore = require('./core/random/random-core.js');
-require('./core/random/random-types.js');
-require('./core/random/random-sources.js');
-require('nehonix-uri-processor');
-require('./utils/memory/index.js');
-require('argon2');
-require('child_process');
-require('./types/secure-memory.js');
-require('https');
-var runtimeVerification = require('./components/runtime-verification.js');
-var tamperEvidentLogging = require('./components/tamper-evident-logging.js');
-require('./components/secure-string/advanced/entropy-analyzer.js');
-require('./components/secure-string/advanced/quantum-safe.js');
-require('./components/secure-string/advanced/performance-monitor.js');
-var index$1 = require('./components/secure-object/index.js');
-require('./components/secure-array/utils/id-generator.js');
-var passwordTypes = require('./core/password/password-types.js');
-require('./core/password/index.js');
-require('./components/fortified-function/core/fortified-function-core.js');
-require('./components/fortified-function/core/fortified-config.js');
-require('./components/fortified-function/core/fortified-logger.js');
-require('events');
-require('./components/fortified-function/serializer/safe-serializer.js');
-require('nehoid');
-require('./components/fortified-function/UFA/ultra-fast-allocator.js');
-var passwordCore = require('./core/password/password-core.js');
-
-/***************************************************************************
- * XyPrissSecurity - Ex xypriss2-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(64, "base64url");
- * ```
- *
- * ### 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.space/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);
- * ```
- */
-/**
- * ### 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 */
-randomCore.SecureRandom.getRandomBytes;
-/** Generate secure UUID with high entropy */
-randomCore.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 */
-hashCore.Hash.createSecureHash;
-/** Create secure HMAC with timing-safe operations */
-hashCore.Hash.createSecureHMAC;
-/** Verify hash with constant-time comparison */
-hashCore.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
- */
-passwordCore.PasswordManager.getInstance();
-/**
- * ### Create Secure Object
- *
- * Creates a secure object instance with encryption, metadata management,
- * and comprehensive security features for sensitive data storage.
- *
- * **Key Features:**
- * - Automatic encryption for sensitive values
- * - Metadata tracking and management
- * - Event-driven architecture
- * - Secure serialization and deserialization
- * - Memory protection and cleanup
- *
- * @param initialData - The initial data to store in the secure object
- * @param options - Configuration options for encryption and security
- * @returns A new SecureObject instance with enhanced protection
- *
- * @example Basic Usage
- * ```typescript
- * import { fObject } from "xypriss-security";
- *
- * // Create secure object with initial data
- * const userCredentials = fObject({
- *     username: "john_doe",
- *     apiKey: "secret-api-key-12345",
- *     sessionToken: "session-token-abcdef"
- * });
- *
- * // Access and modify data
- * userCredentials.set("lastLogin", new Date().toISOString());
- * const apiKey = userCredentials.get("apiKey");
- *
- * // Secure cleanup
- * userCredentials.destroy();
- * ```
- *
- * @example Advanced Configuration
- * ```typescript
- * import { fObject } from "xypriss-security";
- *
- * // Create with encryption and metadata tracking
- * const secureConfig = fObject({
- *     databaseUrl: "postgresql://user:pass@localhost/db",
- *     encryptionKey: "master-encryption-key-2025",
- *     apiSecrets: {
- *         stripe: "sk_live_...",
- *         aws: "AKIA..."
- *     }
- * }, {
- *     encryptionKey: process.env.OBJECT_ENCRYPTION_KEY,
- *     enableMetadata: true,
- *     autoCleanup: true
- * });
- *
- * // Mark sensitive keys for special handling
- * secureConfig.markSensitive("databaseUrl");
- * secureConfig.markSensitive("encryptionKey");
- * secureConfig.markSensitive("apiSecrets");
- *
- * // Export with encryption
- * const encrypted = secureConfig.serialize({ encrypt: true });
- *
- * // Event handling
- * secureConfig.on("accessed", (key) => {
- *     console.log(`Sensitive key accessed: ${key}`);
- * });
- * ```
- *
- * @author Seth Eleazar
- * @since 1.0.0
- */
-function fObject(...args) {
-    return index$1.createSecureObject(...args);
-}
-
-Object.defineProperty(exports, 'EntropySource', {
-    enumerable: true,
-    get: function () { return types.EntropySource; }
-});
-Object.defineProperty(exports, 'HashAlgorithm', {
-    enumerable: true,
-    get: function () { return types.HashAlgorithm; }
-});
-Object.defineProperty(exports, 'KeyDerivationAlgorithm', {
-    enumerable: true,
-    get: function () { return types.KeyDerivationAlgorithm; }
-});
-Object.defineProperty(exports, 'SecurityLevel', {
-    enumerable: true,
-    get: function () { return types.SecurityLevel; }
-});
-Object.defineProperty(exports, 'TokenType', {
-    enumerable: true,
-    get: function () { return types.TokenType; }
-});
-exports.Hash = hashCore.Hash;
-exports.Random = randomCore.SecureRandom;
-Object.defineProperty(exports, 'SecurityIssueType', {
-    enumerable: true,
-    get: function () { return runtimeVerification.SecurityIssueType; }
-});
-exports.verifyRuntimeSecurity = runtimeVerification.verifyRuntimeSecurity;
-Object.defineProperty(exports, 'LogLevel', {
-    enumerable: true,
-    get: function () { return tamperEvidentLogging.LogLevel; }
-});
-exports.TamperEvidentLogger = tamperEvidentLogging.TamperEvidentLogger;
-exports.createSecureObject = index$1.createSecureObject;
-Object.defineProperty(exports, 'PasswordAlgorithm', {
-    enumerable: true,
-    get: function () { return passwordTypes.PasswordAlgorithm; }
-});
-Object.defineProperty(exports, 'PasswordSecurityLevel', {
-    enumerable: true,
-    get: function () { return passwordTypes.PasswordSecurityLevel; }
-});
-exports.PasswordManager = passwordCore.PasswordManager;
-exports.fObject = fObject;
-//# sourceMappingURL=index.js.map

package/dist/cjs/mods/toolkit/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../mods/toolkit/src/index.ts"],"sourcesContent":[null],"names":["SecureRandom","Hash","PasswordManager","fObjectUtils.createSecureObject"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BiF;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4JG;AAkgBH;;;;;;;;;;;;;;;AAeG;AAEH;AAC8BA,uBAAY,CAAC,eAAe;AAE1D;AACkCA,uBAAY,CAAC,mBAAmB;AAmBlE;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AAEH;AACgCC,aAAI,CAAC,iBAAiB;AAEtD;AACgCA,aAAI,CAAC,iBAAiB;AAEtD;AAC0BA,aAAI,CAAC,WAAW;AAyL1C;;;;;;;;;;;;;;;;;;;;AAoBG;AACeC,4BAAe,CAAC,WAAW,GAAG;AA0EhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEG;AACa,SAAA,OAAO,CACnB,GAAG,IAA2D,EAAA;AAE9D,IAAA,OAAOC,0BAA+B,CAAI,GAAG,IAAI,CAAC,CAAC;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/mods/toolkit/src/types/global.js

@@ -1,51 +0,0 @@
-'use strict';
-
-/**
- * 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);
-            }
-        };
-    }
-}
-
-exports.initializePolyfills = initializePolyfills;
-//# sourceMappingURL=global.js.map

package/dist/cjs/mods/toolkit/src/types/global.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"global.js","sources":["../../../../../../mods/toolkit/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/cjs/mods/toolkit/src/types/secure-mem.type.js

@@ -1,100 +0,0 @@
-'use strict';
-
-// Safe library instances
-exports.sodium = null;
-exports.nobleHashes = null;
-exports.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") {
-                exports.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.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) {
-            exports.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.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) {
-            exports.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;
-}
-
-exports.ensureLibrariesInitialized = ensureLibrariesInitialized;
-exports.initializeSecurityLibraries = initializeSecurityLibraries;
-exports.libraryStatus = libraryStatus;
-//# sourceMappingURL=secure-mem.type.js.map

package/dist/cjs/mods/toolkit/src/types/secure-mem.type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"secure-mem.type.js","sources":["../../../../../../mods/toolkit/src/types/secure-mem.type.ts"],"sourcesContent":[null],"names":["sodium","nobleHashes","nobleCiphers"],"mappings":";;AA8BA;AACIA,cAAM,GAA2B,KAAK;AACtCC,mBAAW,GAAgC,KAAK;AAChDC,oBAAY,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,gBAAAF,cAAM,GAAG,SAAS,CAAC,OAA0B,CAAC;AAC9C,gBAAA,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC;;;;aAI/B;SACJ;KACJ;IAAC,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,IAAI,CACR,uDAAuD,EACtD,CAAW,CAAC,OAAO,CACvB,CAAC;KACL;;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,YAAAC,mBAAW,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;QACR,OAAO,CAAC,IAAI,CACR,kDAAkD,EACjD,CAAW,CAAC,OAAO,CACvB,CAAC;KACL;;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,YAAAC,oBAAY,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/cjs/mods/toolkit/src/types/secure-memory.js

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

package/dist/cjs/mods/toolkit/src/types/secure-memory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"secure-memory.js","sources":["../../../../../../mods/toolkit/src/types/secure-memory.ts"],"sourcesContent":[null],"names":["MemoryProtectionLevel","BufferState"],"mappings":";;AACA;AACYA,uCAKX;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,EALWA,6BAAqB,KAArBA,6BAAqB,GAKhC,EAAA,CAAA,CAAA,CAAA;AAED;AACYC,6BAMX;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,EANWA,mBAAW,KAAXA,mBAAW,GAMtB,EAAA,CAAA,CAAA;;"}

package/dist/cjs/mods/toolkit/src/types.js

@@ -1,63 +0,0 @@
-'use strict';
-
-/**
- * Type definitions for the XyPrissSecurity library
- */
-/**
- * Security level enum
- */
-exports.SecurityLevel = void 0;
-(function (SecurityLevel) {
-    SecurityLevel["STANDARD"] = "standard";
-    SecurityLevel["HIGH"] = "high";
-    SecurityLevel["MAXIMUM"] = "maximum";
-})(exports.SecurityLevel || (exports.SecurityLevel = {}));
-/**
- * Token type enum
- */
-exports.TokenType = void 0;
-(function (TokenType) {
-    TokenType["GENERAL"] = "general";
-    TokenType["API_KEY"] = "api_key";
-    TokenType["SESSION"] = "session";
-    TokenType["JWT"] = "jwt";
-    TokenType["TOTP"] = "totp";
-})(exports.TokenType || (exports.TokenType = {}));
-/**
- * Hash algorithm enum - can be used as values
- */
-exports.HashAlgorithm = void 0;
-(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";
-})(exports.HashAlgorithm || (exports.HashAlgorithm = {}));
-/**
- * Key derivation algorithm enum
- */
-exports.KeyDerivationAlgorithm = void 0;
-(function (KeyDerivationAlgorithm) {
-    KeyDerivationAlgorithm["PBKDF2"] = "pbkdf2";
-    KeyDerivationAlgorithm["ARGON2"] = "argon2";
-    KeyDerivationAlgorithm["BALLOON"] = "balloon";
-})(exports.KeyDerivationAlgorithm || (exports.KeyDerivationAlgorithm = {}));
-/**
- * Entropy source enum
- */
-exports.EntropySource = void 0;
-(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";
-})(exports.EntropySource || (exports.EntropySource = {}));
-//# sourceMappingURL=types.js.map

package/dist/cjs/mods/toolkit/src/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sources":["../../../../../mods/toolkit/src/types.ts"],"sourcesContent":[null],"names":["SecurityLevel","TokenType","HashAlgorithm","KeyDerivationAlgorithm","EntropySource"],"mappings":";;AAAA;;AAEG;AAMH;;AAEG;AACSA,+BAIX;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,EAJWA,qBAAa,KAAbA,qBAAa,GAIxB,EAAA,CAAA,CAAA,CAAA;AAED;;AAEG;AACSC,2BAMX;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,EANWA,iBAAS,KAATA,iBAAS,GAMpB,EAAA,CAAA,CAAA,CAAA;AAED;;AAEG;AACSC,+BASX;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,EATWA,qBAAa,KAAbA,qBAAa,GASxB,EAAA,CAAA,CAAA,CAAA;AAoBD;;AAEG;AACSC,wCAIX;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,EAJWA,8BAAsB,KAAtBA,8BAAsB,GAIjC,EAAA,CAAA,CAAA,CAAA;AAED;;AAEG;AACSC,+BASX;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,EATWA,qBAAa,KAAbA,qBAAa,GASxB,EAAA,CAAA,CAAA;;"}