@bantis/local-cipher 2.0.1 → 2.1.0

package/dist/angular.js

@@ -0,0 +1,1535 @@
+'use strict';
+
+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(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$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();
+}
+
+/**
+ * @bantis/local-cipher - Core Module
+ * Framework-agnostic client-side encryption for browser storage
+ *
+ * @version 2.1.0
+ * @license MIT
+ */
+// Core classes
+const secureStorage = SecureStorage.getInstance();
+// Version
+const VERSION = '2.1.0';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+}
+function __runInitializers(thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+}
+function __setFunctionName(f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Servicio de Angular para SecureStorage v2
+ * Proporciona una API reactiva usando RxJS Observables
+ *
+ * @example
+ * constructor(private secureStorage: SecureStorageService) {}
+ *
+ * // Guardar
+ * this.secureStorage.setItem('token', 'abc123').subscribe();
+ *
+ * // 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({
+            providedIn: 'root'
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    _classThis = class {
+        constructor(config) {
+            this.debugInfo$ = new rxjs.BehaviorSubject(this.getDebugInfo());
+            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());
+            }, 1000);
+        }
+        /**
+         * Guarda un valor encriptado
+         * @param key - Clave
+         * @param value - Valor a guardar
+         * @returns Observable que completa cuando se guarda
+         */
+        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
+         * @returns Observable con el valor o null
+         */
+        getItem(key) {
+            return rxjs.from(this.storage.getItem(key));
+        }
+        /**
+         * Elimina un valor
+         * @param key - Clave a eliminar
+         * @returns Observable que completa cuando se elimina
+         */
+        removeItem(key) {
+            return rxjs.from(this.storage.removeItem(key));
+        }
+        /**
+         * Verifica si existe una clave
+         * @param key - Clave a verificar
+         * @returns Observable con true/false
+         */
+        hasItem(key) {
+            return rxjs.from(this.storage.hasItem(key));
+        }
+        /**
+         * Limpia todos los datos encriptados
+         */
+        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
+         * @returns Observable que completa cuando termina la migración
+         */
+        migrateExistingData(keys) {
+            return rxjs.from(this.storage.migrateExistingData(keys));
+        }
+        /**
+         * Obtiene información de debug como Observable
+         * @returns Observable con información de debug que se actualiza automáticamente
+         */
+        getDebugInfo$() {
+            return this.debugInfo$.asObservable();
+        }
+        /**
+         * Obtiene información de debug de forma síncrona
+         */
+        getDebugInfo() {
+            return this.storage.getDebugInfo();
+        }
+        /**
+         * Helper para guardar objetos JSON
+         * @param key - Clave
+         * @param value - Objeto a guardar
+         */
+        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
+         * @returns Observable con el objeto parseado o null
+         */
+        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");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return _classThis;
+})();
+
+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.isCompressionSupported = isCompressionSupported;
+exports.secureStorage = secureStorage;
+exports.shouldCompress = shouldCompress;
+//# sourceMappingURL=angular.js.map