@bantis/local-cipher 2.0.0 → 2.1.0

package/dist/react.js

@@ -0,0 +1,1440 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * Configuration types for @bantis/local-cipher
+ */
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG = {
+    encryption: {
+        iterations: 100000,
+        saltLength: 16,
+        ivLength: 12,
+        appIdentifier: 'bantis-local-cipher-v2',
+        keyLength: 256,
+    },
+    storage: {
+        compression: true,
+        compressionThreshold: 1024,
+        autoCleanup: true,
+        cleanupInterval: 60000,
+    },
+    debug: {
+        enabled: false,
+        logLevel: 'info',
+        prefix: 'SecureStorage',
+    },
+};
+/**
+ * Current library version
+ */
+const LIBRARY_VERSION = '2.0.0';
+/**
+ * Storage data version
+ */
+const STORAGE_VERSION = 2;
+
+/**
+ * EncryptionHelper - Clase responsable de todas las operaciones criptográficas
+ * Implementa AES-256-GCM con derivación de claves PBKDF2 y fingerprinting del navegador
+ */
+class EncryptionHelper {
+    constructor(config) {
+        // Propiedades privadas
+        this.key = null;
+        this.baseKey = '';
+        this.baseKeyPromise = null;
+        this.keyVersion = 1;
+        this.config = { ...DEFAULT_CONFIG.encryption, ...config };
+        // Load key version from storage
+        const storedVersion = localStorage.getItem(EncryptionHelper.KEY_VERSION_KEY);
+        if (storedVersion) {
+            this.keyVersion = parseInt(storedVersion, 10);
+        }
+    }
+    /**
+     * Get current key version
+     */
+    getKeyVersion() {
+        return this.keyVersion;
+    }
+    /**
+     * Genera un fingerprint único del navegador
+     * Combina múltiples características del navegador para crear una huella digital
+     */
+    async generateBaseKey() {
+        if (this.baseKeyPromise) {
+            return this.baseKeyPromise;
+        }
+        this.baseKeyPromise = (async () => {
+            const components = [
+                navigator.userAgent,
+                navigator.language,
+                screen.width.toString(),
+                screen.height.toString(),
+                screen.colorDepth.toString(),
+                new Intl.DateTimeFormat().resolvedOptions().timeZone,
+                this.config.appIdentifier,
+            ];
+            const fingerprint = components.join('|');
+            this.baseKey = await this.hashString(fingerprint);
+            return this.baseKey;
+        })();
+        return this.baseKeyPromise;
+    }
+    /**
+     * Hashea un string usando SHA-256
+     * @param str - String a hashear
+     * @returns Hash hexadecimal
+     */
+    async hashString(str) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(str);
+        const hashBuffer = await crypto.subtle.digest(EncryptionHelper.HASH_ALGORITHM, data);
+        return this.arrayBufferToHex(hashBuffer);
+    }
+    /**
+     * Deriva una clave criptográfica usando PBKDF2
+     * @param password - Password base (fingerprint)
+     * @param salt - Salt aleatorio
+     * @returns CryptoKey para AES-GCM
+     */
+    async deriveKey(password, salt) {
+        const encoder = new TextEncoder();
+        const passwordBuffer = encoder.encode(password);
+        // Importar el password como material de clave
+        const keyMaterial = await crypto.subtle.importKey('raw', passwordBuffer, 'PBKDF2', false, ['deriveBits', 'deriveKey']);
+        // Derivar la clave AES-GCM
+        return crypto.subtle.deriveKey({
+            name: 'PBKDF2',
+            salt,
+            iterations: this.config.iterations,
+            hash: EncryptionHelper.HASH_ALGORITHM,
+        }, keyMaterial, {
+            name: EncryptionHelper.ALGORITHM,
+            length: this.config.keyLength,
+        }, false, ['encrypt', 'decrypt']);
+    }
+    /**
+     * Inicializa el sistema de encriptación generando un nuevo salt
+     */
+    async initialize() {
+        // Generar salt aleatorio
+        const salt = crypto.getRandomValues(new Uint8Array(this.config.saltLength));
+        // Obtener y hashear el baseKey
+        const baseKey = await this.generateBaseKey();
+        // Derivar la clave
+        this.key = await this.deriveKey(baseKey, salt);
+        // Increment key version
+        this.keyVersion++;
+        localStorage.setItem(EncryptionHelper.KEY_VERSION_KEY, this.keyVersion.toString());
+        // Guardar el salt en localStorage
+        localStorage.setItem(EncryptionHelper.SALT_STORAGE_KEY, this.arrayBufferToBase64(salt.buffer));
+    }
+    /**
+     * Inicializa desde un salt almacenado previamente
+     */
+    async initializeFromStored() {
+        const storedSalt = localStorage.getItem(EncryptionHelper.SALT_STORAGE_KEY);
+        if (!storedSalt) {
+            // Si no hay salt almacenado, inicializar uno nuevo
+            await this.initialize();
+            return;
+        }
+        // Recuperar el salt
+        const salt = new Uint8Array(this.base64ToArrayBuffer(storedSalt));
+        // Obtener el baseKey
+        const baseKey = await this.generateBaseKey();
+        // Derivar la misma clave
+        this.key = await this.deriveKey(baseKey, salt);
+    }
+    /**
+     * Encripta un texto plano usando AES-256-GCM
+     * @param plaintext - Texto a encriptar
+     * @returns Texto encriptado en Base64 (IV + datos encriptados)
+     */
+    async encrypt(plaintext) {
+        if (!this.key) {
+            await this.initializeFromStored();
+        }
+        if (!this.key) {
+            throw new Error('No se pudo inicializar la clave de encriptación');
+        }
+        // Convertir texto a bytes
+        const encoder = new TextEncoder();
+        const data = encoder.encode(plaintext);
+        // Generar IV aleatorio
+        const iv = crypto.getRandomValues(new Uint8Array(this.config.ivLength));
+        // Encriptar
+        const encryptedBuffer = await crypto.subtle.encrypt({
+            name: EncryptionHelper.ALGORITHM,
+            iv,
+        }, this.key, data);
+        // Combinar IV + datos encriptados
+        const combined = new Uint8Array(iv.length + encryptedBuffer.byteLength);
+        combined.set(iv, 0);
+        combined.set(new Uint8Array(encryptedBuffer), iv.length);
+        // Retornar en Base64
+        return this.arrayBufferToBase64(combined.buffer);
+    }
+    /**
+     * Desencripta un texto encriptado
+     * @param ciphertext - Texto encriptado en Base64
+     * @returns Texto plano
+     */
+    async decrypt(ciphertext) {
+        if (!this.key) {
+            await this.initializeFromStored();
+        }
+        if (!this.key) {
+            throw new Error('No se pudo inicializar la clave de encriptación');
+        }
+        try {
+            // Decodificar de Base64
+            const combined = new Uint8Array(this.base64ToArrayBuffer(ciphertext));
+            // Extraer IV y datos encriptados
+            const iv = combined.slice(0, this.config.ivLength);
+            const encryptedData = combined.slice(this.config.ivLength);
+            // Desencriptar
+            const decryptedBuffer = await crypto.subtle.decrypt({
+                name: EncryptionHelper.ALGORITHM,
+                iv,
+            }, this.key, encryptedData);
+            // Convertir bytes a texto
+            const decoder = new TextDecoder();
+            return decoder.decode(decryptedBuffer);
+        }
+        catch (error) {
+            throw new Error(`Error al desencriptar: ${error instanceof Error ? error.message : 'Error desconocido'}`);
+        }
+    }
+    /**
+     * Encripta el nombre de una clave para ofuscar nombres en localStorage
+     * @param keyName - Nombre original de la clave
+     * @returns Nombre encriptado con prefijo __enc_
+     */
+    async encryptKey(keyName) {
+        const baseKey = await this.generateBaseKey();
+        const combined = keyName + baseKey;
+        const hash = await this.hashString(combined);
+        return `__enc_${hash.substring(0, 16)}`;
+    }
+    /**
+     * Limpia todos los datos encriptados del localStorage
+     */
+    clearEncryptedData() {
+        const keysToRemove = [];
+        // Identificar todas las claves encriptadas
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key && key.startsWith('__enc_')) {
+                keysToRemove.push(key);
+            }
+        }
+        // Eliminar claves encriptadas
+        keysToRemove.forEach(key => localStorage.removeItem(key));
+        // Eliminar salt
+        localStorage.removeItem(EncryptionHelper.SALT_STORAGE_KEY);
+        // Resetear clave en memoria
+        this.key = null;
+        this.baseKey = '';
+        this.baseKeyPromise = null;
+    }
+    /**
+     * Verifica si el navegador soporta Web Crypto API
+     */
+    static isSupported() {
+        return !!(typeof crypto !== 'undefined' &&
+            crypto.subtle &&
+            crypto.getRandomValues);
+    }
+    // Métodos auxiliares para conversión de datos
+    arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    base64ToArrayBuffer(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    arrayBufferToHex(buffer) {
+        const bytes = new Uint8Array(buffer);
+        return Array.from(bytes)
+            .map(b => b.toString(16).padStart(2, '0'))
+            .join('');
+    }
+}
+// Constantes criptográficas (ahora configurables)
+EncryptionHelper.ALGORITHM = 'AES-GCM';
+EncryptionHelper.HASH_ALGORITHM = 'SHA-256';
+EncryptionHelper.SALT_STORAGE_KEY = '__app_salt';
+EncryptionHelper.KEY_VERSION_KEY = '__key_version';
+
+/**
+ * Simple event emitter for storage events
+ */
+class EventEmitter {
+    constructor() {
+        this.listeners = new Map();
+        this.onceListeners = new Map();
+    }
+    /**
+     * Register an event listener
+     */
+    on(event, listener) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(listener);
+    }
+    /**
+     * Register a one-time event listener
+     */
+    once(event, listener) {
+        if (!this.onceListeners.has(event)) {
+            this.onceListeners.set(event, new Set());
+        }
+        this.onceListeners.get(event).add(listener);
+    }
+    /**
+     * Remove an event listener
+     */
+    off(event, listener) {
+        this.listeners.get(event)?.delete(listener);
+        this.onceListeners.get(event)?.delete(listener);
+    }
+    /**
+     * Remove all listeners for an event
+     */
+    removeAllListeners(event) {
+        if (event) {
+            this.listeners.delete(event);
+            this.onceListeners.delete(event);
+        }
+        else {
+            this.listeners.clear();
+            this.onceListeners.clear();
+        }
+    }
+    /**
+     * Emit an event
+     */
+    emit(event, data) {
+        const eventData = {
+            type: event,
+            timestamp: Date.now(),
+            ...data,
+        };
+        // Call regular listeners
+        this.listeners.get(event)?.forEach(listener => {
+            try {
+                listener(eventData);
+            }
+            catch (error) {
+                console.error(`Error in event listener for ${event}:`, error);
+            }
+        });
+        // Call and remove once listeners
+        const onceSet = this.onceListeners.get(event);
+        if (onceSet) {
+            onceSet.forEach(listener => {
+                try {
+                    listener(eventData);
+                }
+                catch (error) {
+                    console.error(`Error in once listener for ${event}:`, error);
+                }
+            });
+            this.onceListeners.delete(event);
+        }
+    }
+    /**
+     * Get listener count for an event
+     */
+    listenerCount(event) {
+        const regularCount = this.listeners.get(event)?.size ?? 0;
+        const onceCount = this.onceListeners.get(event)?.size ?? 0;
+        return regularCount + onceCount;
+    }
+    /**
+     * Get all event types with listeners
+     */
+    eventNames() {
+        const events = new Set();
+        this.listeners.forEach((_, event) => events.add(event));
+        this.onceListeners.forEach((_, event) => events.add(event));
+        return Array.from(events);
+    }
+}
+
+/**
+ * Logger utility for debug mode
+ */
+class Logger {
+    constructor(config = {}) {
+        this.enabled = config.enabled ?? false;
+        this.logLevel = config.logLevel ?? 'info';
+        this.prefix = config.prefix ?? 'SecureStorage';
+    }
+    shouldLog(level) {
+        if (!this.enabled)
+            return false;
+        return Logger.LOG_LEVELS[level] <= Logger.LOG_LEVELS[this.logLevel];
+    }
+    formatMessage(level, message, ...args) {
+        const timestamp = new Date().toISOString();
+        return `[${this.prefix}] [${level.toUpperCase()}] ${timestamp} - ${message}`;
+    }
+    error(message, ...args) {
+        if (this.shouldLog('error')) {
+            console.error(this.formatMessage('error', message), ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.shouldLog('warn')) {
+            console.warn(this.formatMessage('warn', message), ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.shouldLog('info')) {
+            console.info(this.formatMessage('info', message), ...args);
+        }
+    }
+    debug(message, ...args) {
+        if (this.shouldLog('debug')) {
+            console.debug(this.formatMessage('debug', message), ...args);
+        }
+    }
+    verbose(message, ...args) {
+        if (this.shouldLog('verbose')) {
+            console.log(this.formatMessage('verbose', message), ...args);
+        }
+    }
+    time(label) {
+        if (this.enabled && this.shouldLog('debug')) {
+            console.time(`[${this.prefix}] ${label}`);
+        }
+    }
+    timeEnd(label) {
+        if (this.enabled && this.shouldLog('debug')) {
+            console.timeEnd(`[${this.prefix}] ${label}`);
+        }
+    }
+    group(label) {
+        if (this.enabled && this.shouldLog('debug')) {
+            console.group(`[${this.prefix}] ${label}`);
+        }
+    }
+    groupEnd() {
+        if (this.enabled && this.shouldLog('debug')) {
+            console.groupEnd();
+        }
+    }
+}
+Logger.LOG_LEVELS = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+    verbose: 5,
+};
+
+/**
+ * Key rotation utilities
+ */
+class KeyRotation {
+    constructor(encryptionHelper, logger) {
+        this.encryptionHelper = encryptionHelper;
+        this.logger = logger ?? new Logger();
+    }
+    /**
+     * Rotate all encryption keys
+     * Re-encrypts all data with a new salt
+     */
+    async rotateKeys() {
+        this.logger.info('Starting key rotation...');
+        // 1. Export all current data
+        const backup = await this.exportEncryptedData();
+        // 2. Clear old encryption
+        this.encryptionHelper.clearEncryptedData();
+        // 3. Initialize new encryption
+        await this.encryptionHelper.initialize();
+        // 4. Re-encrypt all data
+        for (const [key, value] of Object.entries(backup.data)) {
+            const encryptedKey = await this.encryptionHelper.encryptKey(key);
+            const encryptedValue = await this.encryptionHelper.encrypt(value);
+            localStorage.setItem(encryptedKey, encryptedValue);
+        }
+        this.logger.info(`Key rotation completed. Re-encrypted ${backup.metadata.itemCount} items`);
+    }
+    /**
+     * Export all encrypted data as backup
+     */
+    async exportEncryptedData() {
+        this.logger.info('Exporting encrypted data...');
+        const data = {};
+        let itemCount = 0;
+        for (let i = 0; i < localStorage.length; i++) {
+            const encryptedKey = localStorage.key(i);
+            if (encryptedKey && encryptedKey.startsWith('__enc_')) {
+                const encryptedValue = localStorage.getItem(encryptedKey);
+                if (encryptedValue) {
+                    try {
+                        // Decrypt to get original key and value
+                        const decryptedValue = await this.encryptionHelper.decrypt(encryptedValue);
+                        // Store with encrypted key as identifier
+                        data[encryptedKey] = decryptedValue;
+                        itemCount++;
+                    }
+                    catch (error) {
+                        this.logger.warn(`Failed to decrypt key ${encryptedKey}:`, error);
+                    }
+                }
+            }
+        }
+        const backup = {
+            version: '2.0.0',
+            timestamp: Date.now(),
+            data,
+            metadata: {
+                keyVersion: this.encryptionHelper.getKeyVersion(),
+                algorithm: 'AES-256-GCM',
+                itemCount,
+            },
+        };
+        this.logger.info(`Exported ${itemCount} items`);
+        return backup;
+    }
+    /**
+     * Import encrypted data from backup
+     */
+    async importEncryptedData(backup) {
+        this.logger.info(`Importing backup from ${new Date(backup.timestamp).toISOString()}...`);
+        let imported = 0;
+        for (const [encryptedKey, value] of Object.entries(backup.data)) {
+            try {
+                const encryptedValue = await this.encryptionHelper.encrypt(value);
+                localStorage.setItem(encryptedKey, encryptedValue);
+                imported++;
+            }
+            catch (error) {
+                this.logger.error(`Failed to import key ${encryptedKey}:`, error);
+            }
+        }
+        this.logger.info(`Imported ${imported}/${backup.metadata.itemCount} items`);
+    }
+}
+
+/**
+ * Namespaced storage for organizing data
+ */
+class NamespacedStorage {
+    constructor(storage, namespace) {
+        this.storage = storage;
+        this.prefix = `__ns_${namespace}__`;
+    }
+    /**
+     * Set item in this namespace
+     */
+    async setItem(key, value) {
+        return this.storage.setItem(`${this.prefix}${key}`, value);
+    }
+    /**
+     * Set item with expiry in this namespace
+     */
+    async setItemWithExpiry(key, value, options) {
+        return this.storage.setItemWithExpiry(`${this.prefix}${key}`, value, options);
+    }
+    /**
+     * Get item from this namespace
+     */
+    async getItem(key) {
+        return this.storage.getItem(`${this.prefix}${key}`);
+    }
+    /**
+     * Remove item from this namespace
+     */
+    async removeItem(key) {
+        return this.storage.removeItem(`${this.prefix}${key}`);
+    }
+    /**
+     * Check if item exists in this namespace
+     */
+    async hasItem(key) {
+        return this.storage.hasItem(`${this.prefix}${key}`);
+    }
+    /**
+     * Clear all items in this namespace
+     */
+    async clearNamespace() {
+        const keysToRemove = [];
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key && key.includes(this.prefix)) {
+                keysToRemove.push(key.replace(this.prefix, ''));
+            }
+        }
+        for (const key of keysToRemove) {
+            await this.removeItem(key);
+        }
+    }
+    /**
+     * Get all keys in this namespace
+     */
+    async keys() {
+        const keys = [];
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key && key.includes(this.prefix)) {
+                keys.push(key.replace(this.prefix, ''));
+            }
+        }
+        return keys;
+    }
+}
+
+/**
+ * Compression utilities using CompressionStream API
+ */
+/**
+ * Check if compression is supported
+ */
+function isCompressionSupported() {
+    return typeof CompressionStream !== 'undefined' && typeof DecompressionStream !== 'undefined';
+}
+/**
+ * Compress a string using gzip
+ */
+async function compress(data) {
+    if (!isCompressionSupported()) {
+        // Fallback: return uncompressed data with marker
+        const encoder = new TextEncoder();
+        return encoder.encode(data);
+    }
+    try {
+        const encoder = new TextEncoder();
+        const stream = new Blob([data]).stream();
+        const compressedStream = stream.pipeThrough(new CompressionStream('gzip'));
+        const compressedBlob = await new Response(compressedStream).blob();
+        const buffer = await compressedBlob.arrayBuffer();
+        return new Uint8Array(buffer);
+    }
+    catch (error) {
+        console.warn('Compression failed, returning uncompressed data:', error);
+        const encoder = new TextEncoder();
+        return encoder.encode(data);
+    }
+}
+/**
+ * Decompress gzip data to string
+ */
+async function decompress(data) {
+    if (!isCompressionSupported()) {
+        // Fallback: assume uncompressed
+        const decoder = new TextDecoder();
+        return decoder.decode(data);
+    }
+    try {
+        const stream = new Blob([data]).stream();
+        const decompressedStream = stream.pipeThrough(new DecompressionStream('gzip'));
+        const decompressedBlob = await new Response(decompressedStream).blob();
+        return await decompressedBlob.text();
+    }
+    catch (error) {
+        // If decompression fails, try to decode as plain text
+        console.warn('Decompression failed, trying plain text:', error);
+        const decoder = new TextDecoder();
+        return decoder.decode(data);
+    }
+}
+/**
+ * Check if data should be compressed based on size
+ */
+function shouldCompress(data, threshold = 1024) {
+    return data.length >= threshold;
+}
+
+/**
+ * SecureStorage v2 - API de alto nivel que imita localStorage con cifrado automático
+ * Incluye: configuración personalizable, eventos, compresión, expiración, namespaces, rotación de claves
+ */
+class SecureStorage {
+    constructor(config) {
+        this.cleanupInterval = null;
+        // Merge config with defaults
+        this.config = {
+            encryption: { ...DEFAULT_CONFIG.encryption, ...config?.encryption },
+            storage: { ...DEFAULT_CONFIG.storage, ...config?.storage },
+            debug: { ...DEFAULT_CONFIG.debug, ...config?.debug },
+        };
+        // Initialize components
+        this.logger = new Logger(this.config.debug);
+        this.encryptionHelper = new EncryptionHelper(this.config.encryption);
+        this.eventEmitter = new EventEmitter();
+        this.keyRotation = new KeyRotation(this.encryptionHelper, this.logger);
+        this.logger.info('SecureStorage v2 initialized', this.config);
+        // Setup auto-cleanup if enabled
+        if (this.config.storage.autoCleanup) {
+            this.setupAutoCleanup();
+        }
+    }
+    /**
+     * Obtiene la instancia singleton de SecureStorage
+     */
+    static getInstance(config) {
+        if (!SecureStorage.instance) {
+            SecureStorage.instance = new SecureStorage(config);
+        }
+        return SecureStorage.instance;
+    }
+    /**
+     * Setup automatic cleanup of expired items
+     */
+    setupAutoCleanup() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+        this.cleanupInterval = setInterval(() => {
+            this.cleanExpired().catch(err => {
+                this.logger.error('Auto-cleanup failed:', err);
+            });
+        }, this.config.storage.cleanupInterval);
+        this.logger.debug(`Auto-cleanup enabled with interval: ${this.config.storage.cleanupInterval}ms`);
+    }
+    /**
+     * Guarda un valor encriptado en localStorage
+     */
+    async setItem(key, value) {
+        this.logger.time(`setItem:${key}`);
+        if (!EncryptionHelper.isSupported()) {
+            this.logger.warn('Web Crypto API no soportada, usando localStorage sin encriptar');
+            localStorage.setItem(key, value);
+            return;
+        }
+        try {
+            // Check if compression should be applied
+            const shouldCompressData = this.config.storage.compression &&
+                shouldCompress(value, this.config.storage.compressionThreshold);
+            let processedValue = value;
+            let compressed = false;
+            if (shouldCompressData) {
+                this.logger.debug(`Compressing value for key: ${key}`);
+                const compressedData = await compress(value);
+                processedValue = this.encryptionHelper['arrayBufferToBase64'](compressedData.buffer);
+                compressed = true;
+                this.eventEmitter.emit('compressed', { key });
+            }
+            // Create StoredValue wrapper
+            const now = Date.now();
+            const storedValue = {
+                value: processedValue,
+                createdAt: now,
+                modifiedAt: now,
+                version: STORAGE_VERSION,
+                compressed,
+            };
+            // Calculate checksum for integrity
+            const checksum = await this.calculateChecksum(processedValue);
+            storedValue.checksum = checksum;
+            // Serialize StoredValue
+            const serialized = JSON.stringify(storedValue);
+            // Encrypt the key
+            const encryptedKey = await this.encryptionHelper.encryptKey(key);
+            // Encrypt the value
+            const encryptedValue = await this.encryptionHelper.encrypt(serialized);
+            // Store in localStorage
+            localStorage.setItem(encryptedKey, encryptedValue);
+            this.logger.verbose(`Stored key: ${key}, compressed: ${compressed}, size: ${encryptedValue.length}`);
+            this.eventEmitter.emit('encrypted', { key, metadata: { compressed, size: encryptedValue.length } });
+            this.logger.timeEnd(`setItem:${key}`);
+        }
+        catch (error) {
+            this.logger.error(`Error al guardar dato encriptado para ${key}:`, error);
+            this.eventEmitter.emit('error', { key, error: error });
+            localStorage.setItem(key, value);
+        }
+    }
+    /**
+     * Guarda un valor con tiempo de expiración
+     */
+    async setItemWithExpiry(key, value, options) {
+        this.logger.time(`setItemWithExpiry:${key}`);
+        if (!EncryptionHelper.isSupported()) {
+            this.logger.warn('Web Crypto API no soportada, usando localStorage sin encriptar');
+            localStorage.setItem(key, value);
+            return;
+        }
+        try {
+            // Check if compression should be applied
+            const shouldCompressData = this.config.storage.compression &&
+                shouldCompress(value, this.config.storage.compressionThreshold);
+            let processedValue = value;
+            let compressed = false;
+            if (shouldCompressData) {
+                this.logger.debug(`Compressing value for key: ${key}`);
+                const compressedData = await compress(value);
+                processedValue = this.encryptionHelper['arrayBufferToBase64'](compressedData.buffer);
+                compressed = true;
+                this.eventEmitter.emit('compressed', { key });
+            }
+            // Calculate expiration timestamp
+            let expiresAt;
+            if (options.expiresIn) {
+                expiresAt = Date.now() + options.expiresIn;
+            }
+            else if (options.expiresAt) {
+                expiresAt = options.expiresAt.getTime();
+            }
+            // Create StoredValue wrapper
+            const now = Date.now();
+            const storedValue = {
+                value: processedValue,
+                createdAt: now,
+                modifiedAt: now,
+                version: STORAGE_VERSION,
+                compressed,
+                expiresAt,
+            };
+            // Calculate checksum for integrity
+            const checksum = await this.calculateChecksum(processedValue);
+            storedValue.checksum = checksum;
+            // Serialize StoredValue
+            const serialized = JSON.stringify(storedValue);
+            // Encrypt the key
+            const encryptedKey = await this.encryptionHelper.encryptKey(key);
+            // Encrypt the value
+            const encryptedValue = await this.encryptionHelper.encrypt(serialized);
+            // Store in localStorage
+            localStorage.setItem(encryptedKey, encryptedValue);
+            this.logger.verbose(`Stored key with expiry: ${key}, expiresAt: ${expiresAt}`);
+            this.eventEmitter.emit('encrypted', { key, metadata: { compressed, expiresAt } });
+            this.logger.timeEnd(`setItemWithExpiry:${key}`);
+        }
+        catch (error) {
+            this.logger.error(`Error al guardar dato con expiración para ${key}:`, error);
+            this.eventEmitter.emit('error', { key, error: error });
+            throw error;
+        }
+    }
+    /**
+     * Recupera y desencripta un valor de localStorage
+     */
+    async getItem(key) {
+        this.logger.time(`getItem:${key}`);
+        if (!EncryptionHelper.isSupported()) {
+            return localStorage.getItem(key);
+        }
+        try {
+            // Encrypt the key
+            const encryptedKey = await this.encryptionHelper.encryptKey(key);
+            // Get encrypted value
+            let encryptedValue = localStorage.getItem(encryptedKey);
+            // Backward compatibility: try with plain key
+            if (!encryptedValue) {
+                encryptedValue = localStorage.getItem(key);
+                if (!encryptedValue) {
+                    this.logger.timeEnd(`getItem:${key}`);
+                    return null;
+                }
+            }
+            // Decrypt the value
+            const decrypted = await this.encryptionHelper.decrypt(encryptedValue);
+            // Try to parse as StoredValue (v2 format)
+            let storedValue;
+            try {
+                storedValue = JSON.parse(decrypted);
+                // Validate it's a StoredValue object
+                if (!storedValue.value || !storedValue.version) {
+                    // It's v1 format (plain string), auto-migrate
+                    this.logger.info(`Auto-migrating v1 data for key: ${key}`);
+                    await this.setItem(key, decrypted);
+                    this.logger.timeEnd(`getItem:${key}`);
+                    return decrypted;
+                }
+            }
+            catch {
+                // Not JSON, it's v1 format (plain string), auto-migrate
+                this.logger.info(`Auto-migrating v1 data for key: ${key}`);
+                await this.setItem(key, decrypted);
+                this.logger.timeEnd(`getItem:${key}`);
+                return decrypted;
+            }
+            // Check expiration
+            if (storedValue.expiresAt && storedValue.expiresAt < Date.now()) {
+                this.logger.info(`Key expired: ${key}`);
+                await this.removeItem(key);
+                this.eventEmitter.emit('expired', { key });
+                this.logger.timeEnd(`getItem:${key}`);
+                return null;
+            }
+            // Verify integrity if checksum exists
+            if (storedValue.checksum) {
+                const calculatedChecksum = await this.calculateChecksum(storedValue.value);
+                if (calculatedChecksum !== storedValue.checksum) {
+                    this.logger.warn(`Integrity check failed for key: ${key}`);
+                    this.eventEmitter.emit('error', {
+                        key,
+                        error: new Error('Integrity verification failed')
+                    });
+                }
+            }
+            // Decompress if needed
+            let finalValue = storedValue.value;
+            if (storedValue.compressed) {
+                this.logger.debug(`Decompressing value for key: ${key}`);
+                const compressedData = this.encryptionHelper['base64ToArrayBuffer'](storedValue.value);
+                finalValue = await decompress(new Uint8Array(compressedData));
+                this.eventEmitter.emit('decompressed', { key });
+            }
+            this.eventEmitter.emit('decrypted', { key });
+            this.logger.timeEnd(`getItem:${key}`);
+            return finalValue;
+        }
+        catch (error) {
+            this.logger.error(`Error al recuperar dato encriptado para ${key}:`, error);
+            this.eventEmitter.emit('error', { key, error: error });
+            // Fallback: try plain key
+            const fallback = localStorage.getItem(key);
+            this.logger.timeEnd(`getItem:${key}`);
+            return fallback;
+        }
+    }
+    /**
+     * Elimina un valor de localStorage
+     */
+    async removeItem(key) {
+        if (!EncryptionHelper.isSupported()) {
+            localStorage.removeItem(key);
+            return;
+        }
+        try {
+            const encryptedKey = await this.encryptionHelper.encryptKey(key);
+            localStorage.removeItem(encryptedKey);
+            localStorage.removeItem(key); // Remove both versions
+            this.eventEmitter.emit('deleted', { key });
+            this.logger.info(`Removed key: ${key}`);
+        }
+        catch (error) {
+            this.logger.error(`Error al eliminar dato para ${key}:`, error);
+            localStorage.removeItem(key);
+        }
+    }
+    /**
+     * Verifica si existe un valor para la clave dada
+     */
+    async hasItem(key) {
+        const value = await this.getItem(key);
+        return value !== null;
+    }
+    /**
+     * Limpia todos los datos encriptados
+     */
+    clear() {
+        this.encryptionHelper.clearEncryptedData();
+        this.eventEmitter.emit('cleared', {});
+        this.logger.info('All encrypted data cleared');
+    }
+    /**
+     * Limpia todos los items expirados
+     */
+    async cleanExpired() {
+        this.logger.info('Starting cleanup of expired items...');
+        let cleanedCount = 0;
+        const keysToCheck = [];
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key && key.startsWith('__enc_')) {
+                keysToCheck.push(key);
+            }
+        }
+        for (const encryptedKey of keysToCheck) {
+            try {
+                const encryptedValue = localStorage.getItem(encryptedKey);
+                if (!encryptedValue)
+                    continue;
+                const decrypted = await this.encryptionHelper.decrypt(encryptedValue);
+                const storedValue = JSON.parse(decrypted);
+                if (storedValue.expiresAt && storedValue.expiresAt < Date.now()) {
+                    localStorage.removeItem(encryptedKey);
+                    cleanedCount++;
+                    this.eventEmitter.emit('expired', { key: encryptedKey });
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Failed to check expiration for ${encryptedKey}:`, error);
+            }
+        }
+        this.logger.info(`Cleanup completed. Removed ${cleanedCount} expired items`);
+        return cleanedCount;
+    }
+    /**
+     * Verifica la integridad de un valor almacenado
+     */
+    async verifyIntegrity(key) {
+        try {
+            const encryptedKey = await this.encryptionHelper.encryptKey(key);
+            const encryptedValue = localStorage.getItem(encryptedKey);
+            if (!encryptedValue)
+                return false;
+            const decrypted = await this.encryptionHelper.decrypt(encryptedValue);
+            const storedValue = JSON.parse(decrypted);
+            if (!storedValue.checksum) {
+                this.logger.warn(`No checksum found for key: ${key}`);
+                return true; // No checksum to verify
+            }
+            const calculatedChecksum = await this.calculateChecksum(storedValue.value);
+            return calculatedChecksum === storedValue.checksum;
+        }
+        catch (error) {
+            this.logger.error(`Error verifying integrity for ${key}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Obtiene información de integridad de un valor
+     */
+    async getIntegrityInfo(key) {
+        try {
+            const encryptedKey = await this.encryptionHelper.encryptKey(key);
+            const encryptedValue = localStorage.getItem(encryptedKey);
+            if (!encryptedValue)
+                return null;
+            const decrypted = await this.encryptionHelper.decrypt(encryptedValue);
+            const storedValue = JSON.parse(decrypted);
+            const valid = storedValue.checksum
+                ? await this.calculateChecksum(storedValue.value) === storedValue.checksum
+                : true;
+            return {
+                valid,
+                lastModified: storedValue.modifiedAt,
+                checksum: storedValue.checksum || '',
+                version: storedValue.version,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Error getting integrity info for ${key}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Crea un namespace para organizar datos
+     */
+    namespace(name) {
+        this.logger.debug(`Creating namespace: ${name}`);
+        return new NamespacedStorage(this, name);
+    }
+    /**
+     * Rota todas las claves de encriptación
+     */
+    async rotateKeys() {
+        this.logger.info('Starting key rotation...');
+        await this.keyRotation.rotateKeys();
+        this.eventEmitter.emit('keyRotated', {});
+        this.logger.info('Key rotation completed');
+    }
+    /**
+     * Exporta todos los datos encriptados como backup
+     */
+    async exportEncryptedData() {
+        return this.keyRotation.exportEncryptedData();
+    }
+    /**
+     * Importa datos desde un backup
+     */
+    async importEncryptedData(backup) {
+        return this.keyRotation.importEncryptedData(backup);
+    }
+    /**
+     * Registra un listener de eventos
+     */
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+    }
+    /**
+     * Registra un listener de un solo uso
+     */
+    once(event, listener) {
+        this.eventEmitter.once(event, listener);
+    }
+    /**
+     * Elimina un listener de eventos
+     */
+    off(event, listener) {
+        this.eventEmitter.off(event, listener);
+    }
+    /**
+     * Elimina todos los listeners de un evento
+     */
+    removeAllListeners(event) {
+        this.eventEmitter.removeAllListeners(event);
+    }
+    /**
+     * Migra datos existentes no encriptados a formato encriptado
+     */
+    async migrateExistingData(keys) {
+        if (!EncryptionHelper.isSupported()) {
+            this.logger.warn('Web Crypto API no soportada, no se puede migrar');
+            return;
+        }
+        this.logger.info(`Iniciando migración de ${keys.length} claves...`);
+        for (const key of keys) {
+            try {
+                const value = localStorage.getItem(key);
+                if (value === null)
+                    continue;
+                // Try to decrypt to check if already encrypted
+                try {
+                    await this.encryptionHelper.decrypt(value);
+                    this.logger.info(`✓ ${key} ya está encriptado, saltando`);
+                    continue;
+                }
+                catch {
+                    // Not encrypted, proceed with migration
+                }
+                await this.setItem(key, value);
+                localStorage.removeItem(key);
+                this.logger.info(`✓ ${key} migrado exitosamente`);
+            }
+            catch (error) {
+                this.logger.error(`✗ Error al migrar ${key}:`, error);
+            }
+        }
+        this.logger.info('✅ Migración completada');
+    }
+    /**
+     * Obtiene información de debug sobre el estado del almacenamiento
+     */
+    getDebugInfo() {
+        const allKeys = [];
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key)
+                allKeys.push(key);
+        }
+        const encryptedKeys = allKeys.filter(key => key.startsWith('__enc_'));
+        const unencryptedKeys = allKeys.filter(key => !key.startsWith('__enc_') && key !== '__app_salt' && key !== '__key_version');
+        return {
+            cryptoSupported: EncryptionHelper.isSupported(),
+            encryptedKeys,
+            unencryptedKeys,
+            totalKeys: allKeys.length,
+            config: this.config,
+        };
+    }
+    /**
+     * Calcula el checksum SHA-256 de un valor
+     */
+    async calculateChecksum(value) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(value);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    /**
+     * Cleanup on destroy
+     */
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.removeAllListeners();
+        this.logger.info('SecureStorage destroyed');
+    }
+}
+SecureStorage.instance = null;
+
+const secureStorage$2 = SecureStorage.getInstance();
+/**
+ * Función de debug para verificar el estado del sistema de encriptación
+ * Muestra información detallada en la consola
+ */
+async function debugEncryptionState() {
+    console.group('🔐 Estado del Sistema de Encriptación');
+    console.log('Soporte Crypto API:', EncryptionHelper.isSupported());
+    // Obtener información de debug
+    const debugInfo = secureStorage$2.getDebugInfo();
+    console.log('Claves encriptadas:', debugInfo.encryptedKeys.length);
+    console.log('Claves sin encriptar:', debugInfo.unencryptedKeys);
+    console.log('Total de claves:', debugInfo.totalKeys);
+    if (debugInfo.encryptedKeys.length > 0) {
+        console.log('✅ Datos encriptados encontrados:');
+        debugInfo.encryptedKeys.forEach(key => {
+            const value = localStorage.getItem(key);
+            console.log(`  ${key}: ${value?.substring(0, 30)}...`);
+        });
+    }
+    else {
+        console.log('⚠️ No se encontraron datos encriptados');
+    }
+    if (debugInfo.unencryptedKeys.length > 0) {
+        console.log('⚠️ Claves sin encriptar encontradas:');
+        debugInfo.unencryptedKeys.forEach(key => {
+            console.log(`  ${key}`);
+        });
+    }
+    console.groupEnd();
+}
+/**
+ * Fuerza la migración de claves comunes a formato encriptado
+ * Útil para desarrollo y testing
+ */
+async function forceMigration(customKeys) {
+    const defaultKeys = [
+        'accessToken',
+        'refreshToken',
+        'user',
+        'sessionId',
+        'authToken',
+        'userData',
+    ];
+    const keysToMigrate = customKeys || defaultKeys;
+    console.log(`🔄 Iniciando migración forzada de ${keysToMigrate.length} claves...`);
+    await secureStorage$2.migrateExistingData(keysToMigrate);
+    console.log('✅ Migración forzada completada');
+    // Mostrar estado después de la migración
+    await debugEncryptionState();
+}
+
+/**
+ * @bantis/local-cipher - Core Module
+ * Framework-agnostic client-side encryption for browser storage
+ *
+ * @version 2.1.0
+ * @license MIT
+ */
+// Core classes
+const secureStorage$1 = SecureStorage.getInstance();
+// Version
+const VERSION = '2.1.0';
+
+/**
+ * React Hooks for @bantis/local-cipher
+ * Provides reactive hooks for encrypted browser storage
+ */
+// Allow custom storage instance or use default
+let defaultStorage = null;
+function getDefaultStorage() {
+    if (!defaultStorage) {
+        defaultStorage = SecureStorage.getInstance();
+    }
+    return defaultStorage;
+}
+/**
+ * Initialize SecureStorage with custom configuration
+ */
+function initializeSecureStorage(config) {
+    defaultStorage = SecureStorage.getInstance(config);
+    return defaultStorage;
+}
+/**
+ * Hook de React para usar SecureStorage de forma reactiva
+ * Similar a useState pero con persistencia encriptada
+ */
+function useSecureStorage(key, initialValue, storage) {
+    const secureStorage = storage || getDefaultStorage();
+    const [storedValue, setStoredValue] = react.useState(initialValue);
+    const [loading, setLoading] = react.useState(true);
+    const [error, setError] = react.useState(null);
+    react.useEffect(() => {
+        const loadValue = async () => {
+            try {
+                setLoading(true);
+                setError(null);
+                const item = await secureStorage.getItem(key);
+                if (item !== null) {
+                    if (typeof initialValue === 'object') {
+                        setStoredValue(JSON.parse(item));
+                    }
+                    else {
+                        setStoredValue(item);
+                    }
+                }
+                else {
+                    setStoredValue(initialValue);
+                }
+            }
+            catch (err) {
+                setError(err instanceof Error ? err : new Error('Error al cargar valor'));
+                setStoredValue(initialValue);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        loadValue();
+    }, [key]);
+    const setValue = react.useCallback(async (value) => {
+        try {
+            setError(null);
+            setStoredValue(value);
+            const valueToStore = typeof value === 'object'
+                ? JSON.stringify(value)
+                : String(value);
+            await secureStorage.setItem(key, valueToStore);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Error al guardar valor'));
+            throw err;
+        }
+    }, [key, secureStorage]);
+    return [storedValue, setValue, loading, error];
+}
+/**
+ * Hook para usar SecureStorage con expiración
+ */
+function useSecureStorageWithExpiry(key, initialValue, expiryOptions, storage) {
+    const secureStorage = storage || getDefaultStorage();
+    const [storedValue, setStoredValue] = react.useState(initialValue);
+    const [loading, setLoading] = react.useState(true);
+    const [error, setError] = react.useState(null);
+    react.useEffect(() => {
+        const loadValue = async () => {
+            try {
+                setLoading(true);
+                setError(null);
+                const item = await secureStorage.getItem(key);
+                if (item !== null) {
+                    if (typeof initialValue === 'object') {
+                        setStoredValue(JSON.parse(item));
+                    }
+                    else {
+                        setStoredValue(item);
+                    }
+                }
+                else {
+                    setStoredValue(initialValue);
+                }
+            }
+            catch (err) {
+                setError(err instanceof Error ? err : new Error('Error al cargar valor'));
+                setStoredValue(initialValue);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        loadValue();
+    }, [key]);
+    const setValue = react.useCallback(async (value) => {
+        try {
+            setError(null);
+            setStoredValue(value);
+            const valueToStore = typeof value === 'object'
+                ? JSON.stringify(value)
+                : String(value);
+            await secureStorage.setItemWithExpiry(key, valueToStore, expiryOptions);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Error al guardar valor'));
+            throw err;
+        }
+    }, [key, secureStorage, expiryOptions]);
+    return [storedValue, setValue, loading, error];
+}
+/**
+ * Hook para verificar si una clave existe en SecureStorage
+ */
+function useSecureStorageItem(key, storage) {
+    const secureStorage = storage || getDefaultStorage();
+    const [exists, setExists] = react.useState(false);
+    const [loading, setLoading] = react.useState(true);
+    const [error, setError] = react.useState(null);
+    react.useEffect(() => {
+        const checkExists = async () => {
+            try {
+                setLoading(true);
+                setError(null);
+                const hasItem = await secureStorage.hasItem(key);
+                setExists(hasItem);
+            }
+            catch (err) {
+                setError(err instanceof Error ? err : new Error('Error al verificar clave'));
+                setExists(false);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        checkExists();
+    }, [key, secureStorage]);
+    return [exists, loading, error];
+}
+/**
+ * Hook para escuchar eventos de SecureStorage
+ */
+function useSecureStorageEvents(event, handler, storage) {
+    const secureStorage = storage || getDefaultStorage();
+    react.useEffect(() => {
+        secureStorage.on(event, handler);
+        return () => {
+            secureStorage.off(event, handler);
+        };
+    }, [event, handler, secureStorage]);
+}
+/**
+ * Hook para obtener información de debug del almacenamiento
+ */
+function useSecureStorageDebug(storage) {
+    const secureStorage = storage || getDefaultStorage();
+    const [debugInfo, setDebugInfo] = react.useState(secureStorage.getDebugInfo());
+    react.useEffect(() => {
+        const interval = setInterval(() => {
+            setDebugInfo(secureStorage.getDebugInfo());
+        }, 1000);
+        return () => clearInterval(interval);
+    }, [secureStorage]);
+    return debugInfo;
+}
+/**
+ * Hook para usar un namespace de SecureStorage
+ */
+function useNamespace(namespace, storage) {
+    const secureStorage = storage || getDefaultStorage();
+    const [namespacedStorage] = react.useState(() => secureStorage.namespace(namespace));
+    return namespacedStorage;
+}
+/**
+ * Exportar la instancia de SecureStorage para uso directo
+ */
+const secureStorage = getDefaultStorage();
+
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+exports.EncryptionHelper = EncryptionHelper;
+exports.EventEmitter = EventEmitter;
+exports.KeyRotation = KeyRotation;
+exports.LIBRARY_VERSION = LIBRARY_VERSION;
+exports.Logger = Logger;
+exports.NamespacedStorage = NamespacedStorage;
+exports.STORAGE_VERSION = STORAGE_VERSION;
+exports.SecureStorage = SecureStorage;
+exports.VERSION = VERSION;
+exports.compress = compress;
+exports.debugEncryptionState = debugEncryptionState;
+exports.decompress = decompress;
+exports.forceMigration = forceMigration;
+exports.initializeSecureStorage = initializeSecureStorage;
+exports.isCompressionSupported = isCompressionSupported;
+exports.reactSecureStorage = secureStorage;
+exports.secureStorage = secureStorage$1;
+exports.shouldCompress = shouldCompress;
+exports.useNamespace = useNamespace;
+exports.useSecureStorage = useSecureStorage;
+exports.useSecureStorageDebug = useSecureStorageDebug;
+exports.useSecureStorageEvents = useSecureStorageEvents;
+exports.useSecureStorageItem = useSecureStorageItem;
+exports.useSecureStorageWithExpiry = useSecureStorageWithExpiry;
+//# sourceMappingURL=react.js.map