@bantis/local-cipher 1.0.1 → 2.0.1

package/dist/index.js

@@ -5,16 +5,64 @@ var core = require('@angular/core');
 var rxjs = require('rxjs');
 var operators = require('rxjs/operators');
 
+/**
+ * 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() {
+    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
@@ -32,7 +80,7 @@ class EncryptionHelper {
                 screen.height.toString(),
                 screen.colorDepth.toString(),
                 new Intl.DateTimeFormat().resolvedOptions().timeZone,
-                EncryptionHelper.APP_IDENTIFIER,
+                this.config.appIdentifier,
             ];
             const fingerprint = components.join('|');
             this.baseKey = await this.hashString(fingerprint);
@@ -66,11 +114,11 @@ class EncryptionHelper {
         return crypto.subtle.deriveKey({
             name: 'PBKDF2',
             salt,
-            iterations: EncryptionHelper.ITERATIONS,
+            iterations: this.config.iterations,
             hash: EncryptionHelper.HASH_ALGORITHM,
         }, keyMaterial, {
             name: EncryptionHelper.ALGORITHM,
-            length: EncryptionHelper.KEY_LENGTH,
+            length: this.config.keyLength,
         }, false, ['encrypt', 'decrypt']);
     }
     /**
@@ -78,11 +126,14 @@ class EncryptionHelper {
      */
     async initialize() {
         // Generar salt aleatorio
-        const salt = crypto.getRandomValues(new Uint8Array(EncryptionHelper.SALT_LENGTH));
+        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));
     }
@@ -119,7 +170,7 @@ class EncryptionHelper {
         const encoder = new TextEncoder();
         const data = encoder.encode(plaintext);
         // Generar IV aleatorio
-        const iv = crypto.getRandomValues(new Uint8Array(EncryptionHelper.IV_LENGTH));
+        const iv = crypto.getRandomValues(new Uint8Array(this.config.ivLength));
         // Encriptar
         const encryptedBuffer = await crypto.subtle.encrypt({
             name: EncryptionHelper.ALGORITHM,
@@ -148,8 +199,8 @@ class EncryptionHelper {
             // Decodificar de Base64
             const combined = new Uint8Array(this.base64ToArrayBuffer(ciphertext));
             // Extraer IV y datos encriptados
-            const iv = combined.slice(0, EncryptionHelper.IV_LENGTH);
-            const encryptedData = combined.slice(EncryptionHelper.IV_LENGTH);
+            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,
@@ -227,92 +278,644 @@ class EncryptionHelper {
             .join('');
     }
 }
-// Constantes criptográficas
+// Constantes criptográficas (ahora configurables)
 EncryptionHelper.ALGORITHM = 'AES-GCM';
-EncryptionHelper.KEY_LENGTH = 256;
-EncryptionHelper.IV_LENGTH = 12; // 96 bits para GCM
-EncryptionHelper.SALT_LENGTH = 16; // 128 bits
-EncryptionHelper.ITERATIONS = 100000;
 EncryptionHelper.HASH_ALGORITHM = 'SHA-256';
 EncryptionHelper.SALT_STORAGE_KEY = '__app_salt';
-EncryptionHelper.APP_IDENTIFIER = 'mtt-local-cipher-v1'; // Identificador único de la app
+EncryptionHelper.KEY_VERSION_KEY = '__key_version';
 
 /**
- * SecureStorage - API de alto nivel que imita localStorage con cifrado automático
- * Implementa el patrón Singleton
+ * Simple event emitter for storage events
  */
-class SecureStorage {
+class EventEmitter {
     constructor() {
-        this.encryptionHelper = new EncryptionHelper();
+        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() {
+    static getInstance(config) {
         if (!SecureStorage.instance) {
-            SecureStorage.instance = new SecureStorage();
+            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
-     * @param key - Clave para almacenar
-     * @param value - Valor a encriptar y almacenar
      */
     async setItem(key, value) {
+        this.logger.time(`setItem:${key}`);
         if (!EncryptionHelper.isSupported()) {
-            console.warn('Web Crypto API no soportada, usando localStorage sin encriptar');
+            this.logger.warn('Web Crypto API no soportada, usando localStorage sin encriptar');
             localStorage.setItem(key, value);
             return;
         }
         try {
-            // Encriptar el nombre de la clave
+            // 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);
-            // Encriptar el valor
-            const encryptedValue = await this.encryptionHelper.encrypt(value);
-            // Guardar en localStorage
+            // 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) {
-            console.error('Error al guardar dato encriptado, usando fallback:', 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
-     * @param key - Clave a buscar
-     * @returns Valor desencriptado o null si no existe
      */
     async getItem(key) {
+        this.logger.time(`getItem:${key}`);
         if (!EncryptionHelper.isSupported()) {
             return localStorage.getItem(key);
         }
         try {
-            // Encriptar el nombre de la clave
+            // Encrypt the key
             const encryptedKey = await this.encryptionHelper.encryptKey(key);
-            // Buscar el valor encriptado
+            // Get encrypted value
             let encryptedValue = localStorage.getItem(encryptedKey);
-            // Retrocompatibilidad: si no existe con clave encriptada, buscar con clave normal
+            // Backward compatibility: try with plain key
             if (!encryptedValue) {
                 encryptedValue = localStorage.getItem(key);
                 if (!encryptedValue) {
+                    this.logger.timeEnd(`getItem:${key}`);
                     return null;
                 }
-                // Si encontramos un valor con clave normal, intentar desencriptarlo
-                // (podría ser un valor ya encriptado pero con clave antigua)
             }
-            // Desencriptar el valor
-            return await this.encryptionHelper.decrypt(encryptedValue);
+            // 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) {
-            console.error('Error al recuperar dato encriptado:', error);
-            // Fallback: intentar leer directamente
-            return localStorage.getItem(key);
+            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
-     * @param key - Clave a eliminar
      */
     async removeItem(key) {
         if (!EncryptionHelper.isSupported()) {
@@ -320,21 +923,19 @@ class SecureStorage {
             return;
         }
         try {
-            // Encriptar el nombre de la clave
             const encryptedKey = await this.encryptionHelper.encryptKey(key);
-            // Eliminar ambas versiones (encriptada y normal) por seguridad
             localStorage.removeItem(encryptedKey);
-            localStorage.removeItem(key);
+            localStorage.removeItem(key); // Remove both versions
+            this.eventEmitter.emit('deleted', { key });
+            this.logger.info(`Removed key: ${key}`);
         }
         catch (error) {
-            console.error('Error al eliminar dato encriptado:', error);
+            this.logger.error(`Error al eliminar dato para ${key}:`, error);
             localStorage.removeItem(key);
         }
     }
     /**
      * Verifica si existe un valor para la clave dada
-     * @param key - Clave a verificar
-     * @returns true si existe, false si no
      */
     async hasItem(key) {
         const value = await this.getItem(key);
@@ -345,44 +946,175 @@ class SecureStorage {
      */
     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
-     * @param keys - Array de claves a migrar
      */
     async migrateExistingData(keys) {
         if (!EncryptionHelper.isSupported()) {
-            console.warn('Web Crypto API no soportada, no se puede migrar');
+            this.logger.warn('Web Crypto API no soportada, no se puede migrar');
             return;
         }
-        console.log(`🔄 Iniciando migración de ${keys.length} claves...`);
+        this.logger.info(`Iniciando migración de ${keys.length} claves...`);
         for (const key of keys) {
             try {
-                // Leer el valor no encriptado
                 const value = localStorage.getItem(key);
-                if (value === null) {
-                    continue; // La clave no existe, saltar
-                }
-                // Verificar si ya está encriptado intentando desencriptarlo
+                if (value === null)
+                    continue;
+                // Try to decrypt to check if already encrypted
                 try {
                     await this.encryptionHelper.decrypt(value);
-                    console.log(`✓ ${key} ya está encriptado, saltando`);
+                    this.logger.info(`✓ ${key} ya está encriptado, saltando`);
                     continue;
                 }
                 catch {
-                    // No está encriptado, proceder con la migración
+                    // Not encrypted, proceed with migration
                 }
-                // Guardar usando setItem (que encriptará automáticamente)
                 await this.setItem(key, value);
-                // Eliminar la versión no encriptada
                 localStorage.removeItem(key);
-                console.log(`✓ ${key} migrado exitosamente`);
+                this.logger.info(`✓ ${key} migrado exitosamente`);
             }
             catch (error) {
-                console.error(`✗ Error al migrar ${key}:`, error);
+                this.logger.error(`✗ Error al migrar ${key}:`, error);
             }
         }
-        console.log('✅ Migración completada');
+        this.logger.info('✅ Migración completada');
     }
     /**
      * Obtiene información de debug sobre el estado del almacenamiento
@@ -395,30 +1127,113 @@ class SecureStorage {
                 allKeys.push(key);
         }
         const encryptedKeys = allKeys.filter(key => key.startsWith('__enc_'));
-        const unencryptedKeys = allKeys.filter(key => !key.startsWith('__enc_') && key !== '__app_salt');
+        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();
+}
+
+// Allow custom storage instance or use default
+let defaultStorage = null;
+function getDefaultStorage() {
+    if (!defaultStorage) {
+        defaultStorage = SecureStorage.getInstance();
+    }
+    return defaultStorage;
+}
 /**
  * Hook de React para usar SecureStorage de forma reactiva
  * Similar a useState pero con persistencia encriptada
  *
  * @param key - Clave para almacenar en localStorage
  * @param initialValue - Valor inicial si no existe en storage
+ * @param storage - Instancia personalizada de SecureStorage (opcional)
  * @returns [value, setValue, loading, error]
  *
  * @example
  * const [token, setToken, loading] = useSecureStorage('accessToken', '');
  */
-function useSecureStorage(key, initialValue) {
+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);
@@ -428,7 +1243,7 @@ function useSecureStorage(key, initialValue) {
             try {
                 setLoading(true);
                 setError(null);
-                const item = await secureStorage$2.getItem(key);
+                const item = await secureStorage.getItem(key);
                 if (item !== null) {
                     // Si T es un objeto, parsear JSON
                     if (typeof initialValue === 'object') {
@@ -461,25 +1276,27 @@ function useSecureStorage(key, initialValue) {
             const valueToStore = typeof value === 'object'
                 ? JSON.stringify(value)
                 : String(value);
-            await secureStorage$2.setItem(key, valueToStore);
+            await secureStorage.setItem(key, valueToStore);
         }
         catch (err) {
             setError(err instanceof Error ? err : new Error('Error al guardar valor'));
             throw err;
         }
-    }, [key]);
+    }, [key, secureStorage]);
     return [storedValue, setValue, loading, error];
 }
 /**
  * Hook para verificar si una clave existe en SecureStorage
  *
  * @param key - Clave a verificar
+ * @param storage - Instancia personalizada de SecureStorage (opcional)
  * @returns [exists, loading, error]
  *
  * @example
  * const [hasToken, loading] = useSecureStorageItem('accessToken');
  */
-function useSecureStorageItem(key) {
+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);
@@ -488,7 +1305,7 @@ function useSecureStorageItem(key) {
             try {
                 setLoading(true);
                 setError(null);
-                const hasItem = await secureStorage$2.hasItem(key);
+                const hasItem = await secureStorage.hasItem(key);
                 setExists(hasItem);
             }
             catch (err) {
@@ -500,29 +1317,35 @@ function useSecureStorageItem(key) {
             }
         };
         checkExists();
-    }, [key]);
+    }, [key, secureStorage]);
     return [exists, loading, error];
 }
 /**
  * Hook para obtener información de debug del almacenamiento
  *
+ * @param storage - Instancia personalizada de SecureStorage (opcional)
  * @returns Información de debug
  *
  * @example
  * const debugInfo = useSecureStorageDebug();
  * console.log(`Claves encriptadas: ${debugInfo.encryptedKeys.length}`);
  */
-function useSecureStorageDebug() {
-    const [debugInfo, setDebugInfo] = react.useState(secureStorage$2.getDebugInfo());
+function useSecureStorageDebug(storage) {
+    const secureStorage = storage || getDefaultStorage();
+    const [debugInfo, setDebugInfo] = react.useState(secureStorage.getDebugInfo());
     react.useEffect(() => {
         // Actualizar cada segundo
         const interval = setInterval(() => {
-            setDebugInfo(secureStorage$2.getDebugInfo());
+            setDebugInfo(secureStorage.getDebugInfo());
         }, 1000);
         return () => clearInterval(interval);
-    }, []);
+    }, [secureStorage]);
     return debugInfo;
 }
+/**
+ * Exportar la instancia de SecureStorage para uso directo
+ */
+const secureStorage$1 = getDefaultStorage();
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -585,7 +1408,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 /**
- * Servicio de Angular para SecureStorage
+ * Servicio de Angular para SecureStorage v2
  * Proporciona una API reactiva usando RxJS Observables
  *
  * @example
@@ -596,6 +1419,9 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
  *
  * // Leer
  * this.secureStorage.getItem('token').subscribe(token => console.log(token));
+ *
+ * // Escuchar eventos
+ * this.secureStorage.events$.subscribe(event => console.log(event));
  */
 let SecureStorageService = (() => {
     let _classDecorators = [core.Injectable({
@@ -605,9 +1431,24 @@ let SecureStorageService = (() => {
     let _classExtraInitializers = [];
     let _classThis;
     _classThis = class {
-        constructor() {
+        constructor(config) {
             this.debugInfo$ = new rxjs.BehaviorSubject(this.getDebugInfo());
-            this.storage = SecureStorage.getInstance();
+            this.eventsSubject$ = new rxjs.Subject();
+            /**
+             * Observable de eventos de storage
+             */
+            this.events$ = this.eventsSubject$.asObservable();
+            this.storage = SecureStorage.getInstance(config);
+            // Setup event forwarding to Observable
+            this.storage.on('encrypted', (data) => this.eventsSubject$.next(data));
+            this.storage.on('decrypted', (data) => this.eventsSubject$.next(data));
+            this.storage.on('deleted', (data) => this.eventsSubject$.next(data));
+            this.storage.on('cleared', (data) => this.eventsSubject$.next(data));
+            this.storage.on('expired', (data) => this.eventsSubject$.next(data));
+            this.storage.on('error', (data) => this.eventsSubject$.next(data));
+            this.storage.on('keyRotated', (data) => this.eventsSubject$.next(data));
+            this.storage.on('compressed', (data) => this.eventsSubject$.next(data));
+            this.storage.on('decompressed', (data) => this.eventsSubject$.next(data));
             // Actualizar debug info cada segundo
             setInterval(() => {
                 this.debugInfo$.next(this.getDebugInfo());
@@ -622,6 +1463,16 @@ let SecureStorageService = (() => {
         setItem(key, value) {
             return rxjs.from(this.storage.setItem(key, value));
         }
+        /**
+         * Guarda un valor con expiración
+         * @param key - Clave
+         * @param value - Valor a guardar
+         * @param options - Opciones de expiración
+         * @returns Observable que completa cuando se guarda
+         */
+        setItemWithExpiry(key, value, options) {
+            return rxjs.from(this.storage.setItemWithExpiry(key, value, options));
+        }
         /**
          * Recupera un valor desencriptado
          * @param key - Clave
@@ -652,6 +1503,59 @@ let SecureStorageService = (() => {
         clear() {
             this.storage.clear();
         }
+        /**
+         * Limpia todos los items expirados
+         * @returns Observable con el número de items eliminados
+         */
+        cleanExpired() {
+            return rxjs.from(this.storage.cleanExpired());
+        }
+        /**
+         * Verifica la integridad de un valor
+         * @param key - Clave a verificar
+         * @returns Observable con true si es válido
+         */
+        verifyIntegrity(key) {
+            return rxjs.from(this.storage.verifyIntegrity(key));
+        }
+        /**
+         * Obtiene información de integridad de un valor
+         * @param key - Clave
+         * @returns Observable con información de integridad
+         */
+        getIntegrityInfo(key) {
+            return rxjs.from(this.storage.getIntegrityInfo(key));
+        }
+        /**
+         * Crea un namespace para organizar datos
+         * @param name - Nombre del namespace
+         * @returns Instancia de NamespacedStorage
+         */
+        namespace(name) {
+            return this.storage.namespace(name);
+        }
+        /**
+         * Rota todas las claves de encriptación
+         * @returns Observable que completa cuando termina la rotación
+         */
+        rotateKeys() {
+            return rxjs.from(this.storage.rotateKeys());
+        }
+        /**
+         * Exporta todos los datos como backup
+         * @returns Observable con el backup
+         */
+        exportEncryptedData() {
+            return rxjs.from(this.storage.exportEncryptedData());
+        }
+        /**
+         * Importa datos desde un backup
+         * @param backup - Backup a importar
+         * @returns Observable que completa cuando termina la importación
+         */
+        importEncryptedData(backup) {
+            return rxjs.from(this.storage.importEncryptedData(backup));
+        }
         /**
          * Migra datos existentes a formato encriptado
          * @param keys - Array de claves a migrar
@@ -681,6 +1585,15 @@ let SecureStorageService = (() => {
         setObject(key, value) {
             return this.setItem(key, JSON.stringify(value));
         }
+        /**
+         * Helper para guardar objetos JSON con expiración
+         * @param key - Clave
+         * @param value - Objeto a guardar
+         * @param options - Opciones de expiración
+         */
+        setObjectWithExpiry(key, value, options) {
+            return this.setItemWithExpiry(key, JSON.stringify(value), options);
+        }
         /**
          * Helper para recuperar objetos JSON
          * @param key - Clave
@@ -689,6 +1602,30 @@ let SecureStorageService = (() => {
         getObject(key) {
             return this.getItem(key).pipe(operators.map(value => value ? JSON.parse(value) : null), operators.catchError(() => rxjs.from([null])));
         }
+        /**
+         * Registra un listener para un tipo de evento específico
+         * @param event - Tipo de evento
+         * @param handler - Función manejadora
+         */
+        on(event, handler) {
+            this.storage.on(event, handler);
+        }
+        /**
+         * Elimina un listener de evento
+         * @param event - Tipo de evento
+         * @param handler - Función manejadora
+         */
+        off(event, handler) {
+            this.storage.off(event, handler);
+        }
+        /**
+         * Observable filtrado por tipo de evento
+         * @param eventType - Tipo de evento a filtrar
+         * @returns Observable con eventos del tipo especificado
+         */
+        onEvent$(eventType) {
+            return this.events$.pipe(operators.map(event => event.type === eventType ? event : null), operators.map(event => event));
+        }
     };
     __setFunctionName(_classThis, "SecureStorageService");
     (() => {
@@ -701,60 +1638,8 @@ let SecureStorageService = (() => {
     return _classThis;
 })();
 
-const secureStorage$1 = 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$1.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$1.migrateExistingData(keysToMigrate);
-    console.log('✅ Migración forzada completada');
-    // Mostrar estado después de la migración
-    await debugEncryptionState();
-}
-
 /**
- * @mtt/local-cipher
+ * @bantis/local-cipher v2.0.0
  * Librería de cifrado local AES-256-GCM para Angular, React y JavaScript
  *
  * @author MTT
@@ -763,16 +1648,27 @@ async function forceMigration(customKeys) {
 // Core exports
 const secureStorage = SecureStorage.getInstance();
 // Version
-const VERSION = '1.0.0';
+const VERSION = '2.0.0';
 
+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.SecureStorageService = SecureStorageService;
 exports.VERSION = VERSION;
+exports.compress = compress;
 exports.debugEncryptionState = debugEncryptionState;
+exports.decompress = decompress;
 exports.forceMigration = forceMigration;
-exports.reactSecureStorage = secureStorage$2;
+exports.isCompressionSupported = isCompressionSupported;
+exports.reactSecureStorage = secureStorage$1;
 exports.secureStorage = secureStorage;
+exports.shouldCompress = shouldCompress;
 exports.useSecureStorage = useSecureStorage;
 exports.useSecureStorageDebug = useSecureStorageDebug;
 exports.useSecureStorageItem = useSecureStorageItem;