@bantis/local-cipher 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,767 @@
+import { useState, useEffect, useCallback } from 'react';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, from } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+
+/**
+ * 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() {
+        // Propiedades privadas
+        this.key = null;
+        this.baseKey = '';
+        this.baseKeyPromise = null;
+    }
+    /**
+     * 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,
+                EncryptionHelper.APP_IDENTIFIER,
+            ];
+            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: EncryptionHelper.ITERATIONS,
+            hash: EncryptionHelper.HASH_ALGORITHM,
+        }, keyMaterial, {
+            name: EncryptionHelper.ALGORITHM,
+            length: EncryptionHelper.KEY_LENGTH,
+        }, false, ['encrypt', 'decrypt']);
+    }
+    /**
+     * Inicializa el sistema de encriptación generando un nuevo salt
+     */
+    async initialize() {
+        // Generar salt aleatorio
+        const salt = crypto.getRandomValues(new Uint8Array(EncryptionHelper.SALT_LENGTH));
+        // Obtener y hashear el baseKey
+        const baseKey = await this.generateBaseKey();
+        // Derivar la clave
+        this.key = await this.deriveKey(baseKey, salt);
+        // 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(EncryptionHelper.IV_LENGTH));
+        // 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, EncryptionHelper.IV_LENGTH);
+            const encryptedData = combined.slice(EncryptionHelper.IV_LENGTH);
+            // 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
+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
+
+/**
+ * SecureStorage - API de alto nivel que imita localStorage con cifrado automático
+ * Implementa el patrón Singleton
+ */
+class SecureStorage {
+    constructor() {
+        this.encryptionHelper = new EncryptionHelper();
+    }
+    /**
+     * Obtiene la instancia singleton de SecureStorage
+     */
+    static getInstance() {
+        if (!SecureStorage.instance) {
+            SecureStorage.instance = new SecureStorage();
+        }
+        return SecureStorage.instance;
+    }
+    /**
+     * Guarda un valor encriptado en localStorage
+     * @param key - Clave para almacenar
+     * @param value - Valor a encriptar y almacenar
+     */
+    async setItem(key, value) {
+        if (!EncryptionHelper.isSupported()) {
+            console.warn('Web Crypto API no soportada, usando localStorage sin encriptar');
+            localStorage.setItem(key, value);
+            return;
+        }
+        try {
+            // Encriptar el nombre de la clave
+            const encryptedKey = await this.encryptionHelper.encryptKey(key);
+            // Encriptar el valor
+            const encryptedValue = await this.encryptionHelper.encrypt(value);
+            // Guardar en localStorage
+            localStorage.setItem(encryptedKey, encryptedValue);
+        }
+        catch (error) {
+            console.error('Error al guardar dato encriptado, usando fallback:', error);
+            localStorage.setItem(key, value);
+        }
+    }
+    /**
+     * Recupera y desencripta un valor de localStorage
+     * @param key - Clave a buscar
+     * @returns Valor desencriptado o null si no existe
+     */
+    async getItem(key) {
+        if (!EncryptionHelper.isSupported()) {
+            return localStorage.getItem(key);
+        }
+        try {
+            // Encriptar el nombre de la clave
+            const encryptedKey = await this.encryptionHelper.encryptKey(key);
+            // Buscar el valor encriptado
+            let encryptedValue = localStorage.getItem(encryptedKey);
+            // Retrocompatibilidad: si no existe con clave encriptada, buscar con clave normal
+            if (!encryptedValue) {
+                encryptedValue = localStorage.getItem(key);
+                if (!encryptedValue) {
+                    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);
+        }
+        catch (error) {
+            console.error('Error al recuperar dato encriptado:', error);
+            // Fallback: intentar leer directamente
+            return localStorage.getItem(key);
+        }
+    }
+    /**
+     * Elimina un valor de localStorage
+     * @param key - Clave a eliminar
+     */
+    async removeItem(key) {
+        if (!EncryptionHelper.isSupported()) {
+            localStorage.removeItem(key);
+            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);
+        }
+        catch (error) {
+            console.error('Error al eliminar dato encriptado:', 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);
+        return value !== null;
+    }
+    /**
+     * Limpia todos los datos encriptados
+     */
+    clear() {
+        this.encryptionHelper.clearEncryptedData();
+    }
+    /**
+     * 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');
+            return;
+        }
+        console.log(`🔄 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
+                try {
+                    await this.encryptionHelper.decrypt(value);
+                    console.log(`✓ ${key} ya está encriptado, saltando`);
+                    continue;
+                }
+                catch {
+                    // No está encriptado, proceder con la migración
+                }
+                // 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`);
+            }
+            catch (error) {
+                console.error(`✗ Error al migrar ${key}:`, error);
+            }
+        }
+        console.log('✅ 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');
+        return {
+            cryptoSupported: EncryptionHelper.isSupported(),
+            encryptedKeys,
+            unencryptedKeys,
+            totalKeys: allKeys.length,
+        };
+    }
+}
+SecureStorage.instance = null;
+
+const secureStorage$2 = SecureStorage.getInstance();
+/**
+ * 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
+ * @returns [value, setValue, loading, error]
+ *
+ * @example
+ * const [token, setToken, loading] = useSecureStorage('accessToken', '');
+ */
+function useSecureStorage(key, initialValue) {
+    const [storedValue, setStoredValue] = useState(initialValue);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    // Cargar valor inicial
+    useEffect(() => {
+        const loadValue = async () => {
+            try {
+                setLoading(true);
+                setError(null);
+                const item = await secureStorage$2.getItem(key);
+                if (item !== null) {
+                    // Si T es un objeto, parsear JSON
+                    if (typeof initialValue === 'object') {
+                        setStoredValue(JSON.parse(item));
+                    }
+                    else {
+                        setStoredValue(item);
+                    }
+                }
+                else {
+                    setStoredValue(initialValue);
+                }
+            }
+            catch (err) {
+                setError(err instanceof Error ? err : new Error('Error al cargar valor'));
+                setStoredValue(initialValue);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        loadValue();
+    }, [key]); // Solo recargar si cambia la clave
+    // Función para actualizar el valor
+    const setValue = useCallback(async (value) => {
+        try {
+            setError(null);
+            setStoredValue(value);
+            // Si T es un objeto, convertir a JSON
+            const valueToStore = typeof value === 'object'
+                ? JSON.stringify(value)
+                : String(value);
+            await secureStorage$2.setItem(key, valueToStore);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Error al guardar valor'));
+            throw err;
+        }
+    }, [key]);
+    return [storedValue, setValue, loading, error];
+}
+/**
+ * Hook para verificar si una clave existe en SecureStorage
+ *
+ * @param key - Clave a verificar
+ * @returns [exists, loading, error]
+ *
+ * @example
+ * const [hasToken, loading] = useSecureStorageItem('accessToken');
+ */
+function useSecureStorageItem(key) {
+    const [exists, setExists] = useState(false);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        const checkExists = async () => {
+            try {
+                setLoading(true);
+                setError(null);
+                const hasItem = await secureStorage$2.hasItem(key);
+                setExists(hasItem);
+            }
+            catch (err) {
+                setError(err instanceof Error ? err : new Error('Error al verificar clave'));
+                setExists(false);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        checkExists();
+    }, [key]);
+    return [exists, loading, error];
+}
+/**
+ * Hook para obtener información de debug del almacenamiento
+ *
+ * @returns Información de debug
+ *
+ * @example
+ * const debugInfo = useSecureStorageDebug();
+ * console.log(`Claves encriptadas: ${debugInfo.encryptedKeys.length}`);
+ */
+function useSecureStorageDebug() {
+    const [debugInfo, setDebugInfo] = useState(secureStorage$2.getDebugInfo());
+    useEffect(() => {
+        // Actualizar cada segundo
+        const interval = setInterval(() => {
+            setDebugInfo(secureStorage$2.getDebugInfo());
+        }, 1000);
+        return () => clearInterval(interval);
+    }, []);
+    return debugInfo;
+}
+
+/******************************************************************************
+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
+ * 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));
+ */
+let SecureStorageService = (() => {
+    let _classDecorators = [Injectable({
+            providedIn: 'root'
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    _classThis = class {
+        constructor() {
+            this.debugInfo$ = new BehaviorSubject(this.getDebugInfo());
+            this.storage = SecureStorage.getInstance();
+            // 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 from(this.storage.setItem(key, value));
+        }
+        /**
+         * Recupera un valor desencriptado
+         * @param key - Clave
+         * @returns Observable con el valor o null
+         */
+        getItem(key) {
+            return from(this.storage.getItem(key));
+        }
+        /**
+         * Elimina un valor
+         * @param key - Clave a eliminar
+         * @returns Observable que completa cuando se elimina
+         */
+        removeItem(key) {
+            return from(this.storage.removeItem(key));
+        }
+        /**
+         * Verifica si existe una clave
+         * @param key - Clave a verificar
+         * @returns Observable con true/false
+         */
+        hasItem(key) {
+            return from(this.storage.hasItem(key));
+        }
+        /**
+         * Limpia todos los datos encriptados
+         */
+        clear() {
+            this.storage.clear();
+        }
+        /**
+         * 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 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 recuperar objetos JSON
+         * @param key - Clave
+         * @returns Observable con el objeto parseado o null
+         */
+        getObject(key) {
+            return this.getItem(key).pipe(map(value => value ? JSON.parse(value) : null), catchError(() => from([null])));
+        }
+    };
+    __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;
+})();
+
+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
+ * Librería de cifrado local AES-256-GCM para Angular, React y JavaScript
+ *
+ * @author MTT
+ * @license MIT
+ */
+// Core exports
+const secureStorage = SecureStorage.getInstance();
+// Version
+const VERSION = '1.0.0';
+
+export { EncryptionHelper, SecureStorage, SecureStorageService, VERSION, debugEncryptionState, forceMigration, secureStorage$2 as reactSecureStorage, secureStorage, useSecureStorage, useSecureStorageDebug, useSecureStorageItem };
+//# sourceMappingURL=index.esm.js.map