@futdevpro/fsm-dynamo 1.14.19 → 1.14.21

package/build/_modules/crypto/_collections/crypto.util.spec.js

@@ -1,1180 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_util_1 = require("./crypto.util");
-describe('| DyFM_Crypto', () => {
-    const testKey = 'test-secret-key-123';
-    const testData = { id: 1, name: 'test' };
-    describe('| encrypt', () => {
-        it('| should successfully encrypt data', () => {
-            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-            expect(encrypted).toBeDefined();
-            expect(typeof encrypted).toBe('string');
-            expect(encrypted).toMatch(/^[A-Za-z0-9\-_]+$/);
-        });
-        it('| should encrypt different data with different results', () => {
-            const data1 = { id: 1 };
-            const data2 = { id: 2 };
-            const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(data1, testKey);
-            const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(data2, testKey);
-            expect(encrypted1).not.toEqual(encrypted2);
-        });
-        it('| should throw DyFM_Error when encryption fails', () => {
-            // @ts-ignore - Testing invalid input
-            expect(() => crypto_util_1.DyFM_Crypto.encrypt(undefined, testKey)).toThrow();
-        });
-        it('| should handle complex objects', () => {
-            const complexData = {
-                id: 1,
-                name: 'test',
-                nested: {
-                    value: 'nested-value',
-                    array: [1, 2, 3]
-                }
-            };
-            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(complexData, testKey);
-            const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-            expect(decrypted).toEqual(complexData);
-        });
-        it('| should get the same result with the same input', () => {
-            const complexData = {
-                id: 2,
-                name: 'test',
-                nested: {
-                    value: 'nested-value',
-                    array: [1, 2, 3]
-                }
-            };
-            const expectedResult = JSON.stringify(complexData);
-            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(complexData, testKey);
-            const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-            const result = JSON.stringify(decrypted);
-            expect(result).toBe(expectedResult);
-        });
-        it('| should not effect the original object', () => {
-            const complexData = {
-                id: 1,
-                name: 'test',
-                nested: { value: 'nested-value', array: [1, 2, 3] }
-            };
-            const originalData = JSON.stringify(complexData);
-            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(complexData, testKey);
-            const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-            const result = JSON.stringify(decrypted);
-            expect(result).toBe(originalData);
-        });
-        it('| should handle arrays', () => {
-            const arrayData = [1, 'test', { nested: true }];
-            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(arrayData, testKey);
-            const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-            expect(decrypted).toEqual(arrayData);
-        });
-        it('| should handle primitive values', () => {
-            const stringData = 'test string';
-            const numberData = 42;
-            const booleanData = true;
-            const encryptedString = crypto_util_1.DyFM_Crypto.encrypt(stringData, testKey);
-            const encryptedNumber = crypto_util_1.DyFM_Crypto.encrypt(numberData, testKey);
-            const encryptedBoolean = crypto_util_1.DyFM_Crypto.encrypt(booleanData, testKey);
-            expect(crypto_util_1.DyFM_Crypto.decrypt(encryptedString, testKey)).toBe(stringData);
-            expect(crypto_util_1.DyFM_Crypto.decrypt(encryptedNumber, testKey)).toBe(numberData);
-            expect(crypto_util_1.DyFM_Crypto.decrypt(encryptedBoolean, testKey)).toBe(booleanData);
-        });
-    });
-    describe('| decrypt', () => {
-        it('| should successfully decrypt encrypted data', () => {
-            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-            const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-            expect(decrypted).toEqual(testData);
-        });
-        it('| should throw DyFM_Error when decryption fails', () => {
-            expect(() => crypto_util_1.DyFM_Crypto.decrypt('invalid-encrypted-data', testKey)).toThrow();
-        });
-        it('| should throw DyFM_Error when using wrong key', () => {
-            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-            expect(() => crypto_util_1.DyFM_Crypto.decrypt(encrypted, 'wrong-key')).toThrow();
-        });
-        it('| should throw DyFM_Error when encrypted data is modified', () => {
-            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-            const modified = encrypted.slice(0, -1) + 'A';
-            expect(() => crypto_util_1.DyFM_Crypto.decrypt(modified, testKey)).toThrow();
-        });
-    });
-    describe('| URL-safe encryption', () => {
-        it('| should produce URL-safe strings', () => {
-            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-            expect(encrypted).toMatch(/^[A-Za-z0-9\-_]+$/);
-        });
-        it('| should work in HTTP headers', () => {
-            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-            const header = `Bearer ${encrypted}`;
-            const extracted = header.split(' ')[1];
-            const decrypted = crypto_util_1.DyFM_Crypto.decrypt(extracted, testKey);
-            expect(decrypted).toEqual(testData);
-        });
-        it('| should work in URLs', () => {
-            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-            const url = `https://example.com/api?token=${encrypted}`;
-            const params = new URLSearchParams(url.split('?')[1]);
-            const extracted = params.get('token');
-            const decrypted = crypto_util_1.DyFM_Crypto.decrypt(extracted, testKey);
-            expect(decrypted).toEqual(testData);
-        });
-    });
-    describe('| LONG-TERM STABILITY TESTS - Cross-platform compatibility', () => {
-        describe('| Deterministic encryption consistency', () => {
-            it('| should produce identical encrypted output for identical input across multiple calls', () => {
-                const testData = { id: 1, name: 'test', timestamp: '2024-01-01T00:00:00Z' };
-                const key = 'stable-test-key-123';
-                // Multiple encryption calls should produce identical results
-                const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(testData, key);
-                const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(testData, key);
-                const encrypted3 = crypto_util_1.DyFM_Crypto.encrypt(testData, key);
-                expect(encrypted1).toBe(encrypted2);
-                expect(encrypted2).toBe(encrypted3);
-                expect(encrypted1).toBe(encrypted3);
-                // All should decrypt to the same data
-                const decrypted1 = crypto_util_1.DyFM_Crypto.decrypt(encrypted1, key);
-                const decrypted2 = crypto_util_1.DyFM_Crypto.decrypt(encrypted2, key);
-                const decrypted3 = crypto_util_1.DyFM_Crypto.decrypt(encrypted3, key);
-                expect(decrypted1).toEqual(decrypted2);
-                expect(decrypted2).toEqual(decrypted3);
-                expect(decrypted1).toEqual(testData);
-            });
-            it('| should maintain consistency with different data types and structures', () => {
-                const testCases = [
-                    { data: { id: 1, name: 'simple' }, key: 'key1' },
-                    { data: 'plain string', key: 'key2' },
-                    { data: [1, 2, 3, 'array'], key: 'key3' },
-                    { data: { nested: { deep: { value: true } } }, key: 'key4' },
-                    { data: { empty: {}, null: null }, key: 'key5' } // Removed undefined as it gets filtered out
-                ];
-                testCases.forEach(({ data, key }) => {
-                    const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(data, key);
-                    const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(data, key);
-                    expect(encrypted1).toBe(encrypted2);
-                    const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted1, key);
-                    expect(decrypted).toEqual(data);
-                });
-            });
-            it('| should handle edge cases consistently', () => {
-                const edgeCases = [
-                    { data: 'non-empty', key: 'non-empty-string-key' },
-                    { data: 0, key: 'zero-number-key' },
-                    { data: false, key: 'false-boolean-key' },
-                    { data: { a: 0, b: false, c: 'non-empty' }, key: 'mixed-edge-key' }
-                ];
-                edgeCases.forEach(({ data, key }) => {
-                    const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(data, key);
-                    const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(data, key);
-                    expect(encrypted1).toBe(encrypted2);
-                    const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted1, key);
-                    expect(decrypted).toEqual(data);
-                });
-            });
-        });
-        describe('| Cross-version compatibility simulation', () => {
-            it('| should handle data encrypted with different configurations consistently', () => {
-                const testData = { id: 1, name: 'config-test' };
-                const key = 'config-test-key';
-                // Test with default config
-                const defaultEncrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, key);
-                const defaultDecrypted = crypto_util_1.DyFM_Crypto.decrypt(defaultEncrypted, key);
-                expect(defaultDecrypted).toEqual(testData);
-                // Test with custom config
-                const customConfig = { keyIterations: 500, keySize: 6 };
-                const customEncrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, key, customConfig);
-                const customDecrypted = crypto_util_1.DyFM_Crypto.decrypt(customEncrypted, key, customConfig);
-                expect(customDecrypted).toEqual(testData);
-                // Test that different configs produce different encrypted results
-                expect(defaultEncrypted).not.toBe(customEncrypted);
-            });
-            it('| should maintain backward compatibility with existing encrypted data', () => {
-                // Simulate data that was encrypted with previous version
-                const legacyData = { id: 1, name: 'legacy-test', version: '1.0' };
-                const key = 'legacy-key';
-                // Encrypt with current implementation
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(legacyData, key);
-                // Simulate system restart/reload
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, key);
-                expect(decrypted).toEqual(legacyData);
-                // Re-encrypt should produce same result
-                const reEncrypted = crypto_util_1.DyFM_Crypto.encrypt(decrypted, key);
-                expect(reEncrypted).toBe(encrypted);
-            });
-        });
-        describe('| Platform independence tests', () => {
-            it('| should handle different character encodings consistently', () => {
-                const unicodeData = {
-                    hungarian: 'árvíztűrő tükörfúrógép',
-                    chinese: '你好世界',
-                    emoji: '🚀💻🔒',
-                    special: '!@#$%^&*()_+-=[]{}|;:,.<>?'
-                };
-                const key = 'unicode-test-key';
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(unicodeData, key);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, key);
-                expect(decrypted).toEqual(unicodeData);
-                // Multiple encryptions should be identical
-                const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(unicodeData, key);
-                expect(encrypted).toBe(encrypted2);
-            });
-            it('| should handle large data objects consistently', () => {
-                // Create a large object with many properties
-                const largeData = { id: 1 };
-                for (let i = 0; i < 100; i++) {
-                    largeData[`prop${i}`] = `value${i}`;
-                }
-                const key = 'large-data-key';
-                const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(largeData, key);
-                const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(largeData, key);
-                expect(encrypted1).toBe(encrypted2);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted1, key);
-                expect(decrypted).toEqual(largeData);
-            });
-            it('| should handle nested circular references gracefully', () => {
-                const circularData = { id: 1, name: 'circular' };
-                circularData.self = circularData;
-                const key = 'circular-key';
-                // Should handle circular references without crashing
-                expect(() => {
-                    const encrypted = crypto_util_1.DyFM_Crypto.encrypt(circularData, key);
-                    // Note: JSON.stringify will fail on circular refs, so this test ensures graceful handling
-                }).toThrow(); // Expected to throw due to circular reference
-            });
-        });
-        describe('| Time-based stability tests', () => {
-            it('| should maintain consistency across time-based operations', () => {
-                const timeData = {
-                    timestamp: new Date().toISOString(),
-                    id: 1,
-                    name: 'time-test'
-                };
-                const key = 'time-test-key';
-                // Encrypt same data multiple times
-                const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(timeData, key);
-                // Simulate time passing
-                setTimeout(() => {
-                    const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(timeData, key);
-                    expect(encrypted1).toBe(encrypted2);
-                }, 100);
-            });
-            it('| should handle date objects consistently', () => {
-                const dateData = {
-                    created: new Date('2024-01-01T00:00:00Z'),
-                    updated: new Date('2024-12-31T23:59:59Z'),
-                    id: 1
-                };
-                const key = 'date-test-key';
-                const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(dateData, key);
-                const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(dateData, key);
-                expect(encrypted1).toBe(encrypted2);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted1, key);
-                // Compare ISO strings since JSON serialization converts dates to strings
-                expect(decrypted.created).toEqual(dateData.created.toISOString());
-                expect(decrypted.updated).toEqual(dateData.updated.toISOString());
-                expect(decrypted.id).toBe(dateData.id);
-            });
-        });
-        describe('| Memory and performance stability', () => {
-            it('| should handle multiple encryption/decryption cycles without memory leaks', () => {
-                const testData = { id: 1, name: 'memory-test' };
-                const key = 'memory-test-key';
-                // Perform many encryption/decryption cycles
-                for (let i = 0; i < 1000; i++) {
-                    const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, key);
-                    const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, key);
-                    expect(decrypted).toEqual(testData);
-                }
-            });
-            it('| should maintain consistent performance across multiple operations', () => {
-                const testData = { id: 1, name: 'performance-test' };
-                const key = 'performance-test-key';
-                const startTime = Date.now();
-                // Perform multiple operations
-                for (let i = 0; i < 100; i++) {
-                    const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, key);
-                    const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, key);
-                    expect(decrypted).toEqual(testData);
-                }
-                const endTime = Date.now();
-                const duration = endTime - startTime;
-                // Should complete within reasonable time (adjust threshold as needed)
-                expect(duration).toBeLessThan(5000); // 5 seconds max
-            });
-        });
-    });
-    describe('| edge cases', () => {
-        describe('| empty and null values', () => {
-            it('| should handle empty objects', () => {
-                const emptyObj = {};
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(emptyObj, testKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-                expect(decrypted).toEqual(emptyObj);
-            });
-            it('| should handle empty arrays', () => {
-                const emptyArr = [];
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(emptyArr, testKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-                expect(decrypted).toEqual(emptyArr);
-            });
-            it('| should handle null values in objects', () => {
-                const dataWithNull = {
-                    id: 1,
-                    name: null,
-                    nested: { value: null }
-                };
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(dataWithNull, testKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-                expect(decrypted).toEqual(dataWithNull);
-            });
-            it('| should handle undefined values in objects', () => {
-                const dataWithUndefined = {
-                    id: 1,
-                    name: undefined,
-                    nested: { value: undefined }
-                };
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(dataWithUndefined, testKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-                expect(decrypted).toEqual({ id: 1, nested: {} });
-            });
-        });
-        describe('| key edge cases', () => {
-            it('| should handle very long keys', () => {
-                const longKey = 'a'.repeat(1000);
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, longKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, longKey);
-                expect(decrypted).toEqual(testData);
-            });
-            it('| should handle empty key', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt(testData, '')).toThrow();
-            });
-            it('| should handle whitespace-only keys', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt(testData, '   ')).toThrow();
-            });
-        });
-        describe('| encrypted data manipulation', () => {
-            it('| should detect when encrypted data is truncated', () => {
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-                const truncated = encrypted.slice(0, -10);
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(truncated, testKey)).toThrow();
-            });
-            it('| should detect when encrypted data is extended', () => {
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-                const extended = encrypted + 'A'.repeat(10);
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(extended, testKey)).toThrow();
-            });
-            it('| should detect when encrypted data is modified in the middle', () => {
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-                const midPoint = Math.floor(encrypted.length / 2);
-                const modified = encrypted.slice(0, midPoint) + 'X' + encrypted.slice(midPoint + 1);
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(modified, testKey)).toThrow();
-            });
-        });
-        describe('| JSON handling edge cases', () => {
-            it('| should handle double-stringified JSON data correctly', () => {
-                const testData = {
-                    username: 'Itharen',
-                    password: 'asdasd',
-                    roles: [],
-                    permissions: [],
-                    activeSubscriptions: [],
-                    clientUserIds: {},
-                    oauth2Data: {}
-                };
-                // Simulate double stringification
-                const doubleStringified = JSON.stringify(JSON.stringify(testData));
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(doubleStringified, testKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-                // The crypto utility should automatically handle double-stringified JSON
-                // and return the original object directly
-                expect(decrypted).toEqual(testData);
-            });
-            it('| should handle character-by-character JSON data correctly', () => {
-                // Create a character-by-character object like in the example
-                const charByCharData = {
-                    '0': '{',
-                    '1': '"',
-                    '2': '_',
-                    '3': '_',
-                    '4': 'c',
-                    '5': 'r',
-                    '6': 'e',
-                    '7': 'a',
-                    '8': 't',
-                    '9': 'e',
-                    '10': 'd',
-                    '11': '"',
-                    '12': ':',
-                    '13': '"',
-                    '14': '2',
-                    '15': '0',
-                    '16': '2',
-                    '17': '5',
-                    '18': '-',
-                    '19': '0',
-                    '20': '5',
-                    '21': '-',
-                    '22': '1',
-                    '23': '3',
-                    '24': 'T',
-                    '25': '1',
-                    '26': '0',
-                    '27': ':',
-                    '28': '4',
-                    '29': '0',
-                    '30': ':',
-                    '31': '4',
-                    '32': '4',
-                    '33': '.',
-                    '34': '7',
-                    '35': '6',
-                    '36': '0',
-                    '37': 'Z',
-                    '38': '"',
-                    '39': ',',
-                    '40': '"',
-                    '41': '_',
-                    '42': '_',
-                    '43': 'l',
-                    '44': 'a',
-                    '45': 's',
-                    '46': 't',
-                    '47': 'M',
-                    '48': 'o',
-                    '49': 'd',
-                    '50': 'i',
-                    '51': 'f',
-                    '52': 'i',
-                    '53': 'e',
-                    '54': 'd',
-                    '55': '"',
-                    '56': ':',
-                    '57': '"',
-                    '58': '2',
-                    '59': '0',
-                    '60': '2',
-                    '61': '5',
-                    '62': '-',
-                    '63': '0',
-                    '64': '5',
-                    '65': '-',
-                    '66': '1',
-                    '67': '3',
-                    '68': 'T',
-                    '69': '1',
-                    '70': '0',
-                    '71': ':',
-                    '72': '4',
-                    '73': '0',
-                    '74': ':',
-                    '75': '4',
-                    '76': '4',
-                    '77': '.',
-                    '78': '7',
-                    '79': '6',
-                    '80': '0',
-                    '81': 'Z',
-                    '82': '"',
-                    '83': ',',
-                    '84': '"',
-                    '85': '_',
-                    '86': '_',
-                    '87': 'v',
-                    '88': '"',
-                    '89': ':',
-                    '90': '0',
-                    '91': ',',
-                    '92': '"',
-                    '93': 'u',
-                    '94': 's',
-                    '95': 'e',
-                    '96': 'r',
-                    '97': 'n',
-                    '98': 'a',
-                    '99': 'm',
-                    '100': 'e',
-                    '101': '"',
-                    '102': ':',
-                    '103': '"',
-                    '104': 'I',
-                    '105': 't',
-                    '106': 'h',
-                    '107': 'a',
-                    '108': 'r',
-                    '109': 'e',
-                    '110': 'n',
-                    '111': '"',
-                    '112': ',',
-                    '113': '"',
-                    '114': 'p',
-                    '115': 'r',
-                    '116': 'e',
-                    '117': 'v',
-                    '118': 'i',
-                    '119': 'o',
-                    '120': 'u',
-                    '121': 's',
-                    '122': 'E',
-                    '123': 'm',
-                    '124': 'a',
-                    '125': 'i',
-                    '126': 'l',
-                    '127': 's',
-                    '128': '"',
-                    '129': ':',
-                    '130': '[',
-                    '131': ']',
-                    '132': ',',
-                    '133': '"',
-                    '134': 'p',
-                    '135': 'a',
-                    '136': 's',
-                    '137': 's',
-                    '138': 'w',
-                    '139': 'o',
-                    '140': 'r',
-                    '141': 'd',
-                    '142': '"',
-                    '143': ':',
-                    '144': '"',
-                    '145': 'a',
-                    '146': 's',
-                    '147': 'd',
-                    '148': 'a',
-                    '149': 's',
-                    '150': 'd',
-                    '151': '"',
-                    '152': ',',
-                    '153': '"',
-                    '154': 'r',
-                    '155': 'o',
-                    '156': 'l',
-                    '157': 'e',
-                    '158': 's',
-                    '159': '"',
-                    '160': ':',
-                    '161': '[',
-                    '162': ']',
-                    '163': ',',
-                    '164': '"',
-                    '165': 'p',
-                    '166': 'e',
-                    '167': 'r',
-                    '168': 'm',
-                    '169': 'i',
-                    '170': 's',
-                    '171': 's',
-                    '172': 'i',
-                    '173': 'o',
-                    '174': 'n',
-                    '175': 's',
-                    '176': '"',
-                    '177': ':',
-                    '178': '[',
-                    '179': ']',
-                    '180': ',',
-                    '181': '"',
-                    '182': 'a',
-                    '183': 'c',
-                    '184': 't',
-                    '185': 'i',
-                    '186': 'v',
-                    '187': 'e',
-                    '188': 'S',
-                    '189': 'u',
-                    '190': 'b',
-                    '191': 's',
-                    '192': 'c',
-                    '193': 'r',
-                    '194': 'i',
-                    '195': 'p',
-                    '196': 't',
-                    '197': 'i',
-                    '198': 'o',
-                    '199': 'n',
-                    '200': 's',
-                    '201': '"',
-                    '202': ':',
-                    '203': '[',
-                    '204': ']',
-                    '205': ',',
-                    '206': '"',
-                    '207': 'c',
-                    '208': 'l',
-                    '209': 'i',
-                    '210': 'e',
-                    '211': 'n',
-                    '212': 't',
-                    '213': 'U',
-                    '214': 's',
-                    '215': 'e',
-                    '216': 'r',
-                    '217': 'I',
-                    '218': 'd',
-                    '219': 's',
-                    '220': '"',
-                    '221': ':',
-                    '222': '{',
-                    '223': '}',
-                    '224': ',',
-                    '225': '"',
-                    '226': 'o',
-                    '227': 'a',
-                    '228': 'u',
-                    '229': 't',
-                    '230': 'h',
-                    '231': '2',
-                    '232': 'D',
-                    '233': 'a',
-                    '234': 't',
-                    '235': 'a',
-                    '236': '"',
-                    '237': ':',
-                    '238': '{',
-                    '239': '}',
-                    '240': '}'
-                };
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(charByCharData, testKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-                // Should be able to parse the decrypted data back to the original object
-                expect(decrypted).toEqual(charByCharData);
-            });
-        });
-        describe('| cross-environment consistency', () => {
-            it('| should produce same encrypted output for same input across different environments', () => {
-                const testData = {
-                    id: 1,
-                    name: 'test',
-                    timestamp: '2024-03-20T10:00:00Z'
-                };
-                const key = 'test-secret-key-123';
-                // Simulate different environments by creating new instances
-                const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(testData, key);
-                const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(testData, key);
-                expect(encrypted1).toBe(encrypted2);
-                expect(crypto_util_1.DyFM_Crypto.decrypt(encrypted1, key)).toEqual(testData);
-                expect(crypto_util_1.DyFM_Crypto.decrypt(encrypted2, key)).toEqual(testData);
-            });
-            it('| should maintain encryption consistency with different data types', () => {
-                const testCases = [
-                    { data: { id: 1 }, key: 'key1' },
-                    { data: 'string data', key: 'key2' },
-                    { data: [1, 2, 3], key: 'key3' },
-                    { data: { nested: { value: true } }, key: 'key4' }
-                ];
-                testCases.forEach(({ data, key }) => {
-                    const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(data, key);
-                    const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(data, key);
-                    expect(encrypted1).toBe(encrypted2);
-                });
-            });
-        });
-        describe('| database persistence', () => {
-            it('| should successfully encrypt and decrypt data after database storage simulation', () => {
-                const originalData = {
-                    id: 1,
-                    name: 'test user',
-                    email: 'test@example.com',
-                    settings: {
-                        theme: 'dark',
-                        notifications: true
-                    }
-                };
-                const key = 'db-storage-key';
-                // Simulate database storage and retrieval
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(originalData, key);
-                const storedData = encrypted; // Simulating database storage
-                const retrievedData = storedData; // Simulating database retrieval
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(retrievedData, key);
-                expect(decrypted).toEqual(originalData);
-            });
-            it('| should handle multiple encryption/decryption cycles for database operations', () => {
-                const userData = {
-                    id: 1,
-                    name: 'test user',
-                    lastLogin: '2024-01-01T10:00:00.000Z',
-                    preferences: {
-                        language: 'en',
-                        timezone: 'UTC'
-                    }
-                };
-                const key = 'persistent-key';
-                // Simulate multiple database operations
-                const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(userData, key);
-                const decrypted1 = crypto_util_1.DyFM_Crypto.decrypt(encrypted1, key);
-                // Simulate data update with a different timestamp
-                const updatedData = {
-                    ...decrypted1,
-                    lastLogin: '2024-01-02T15:30:00.000Z'
-                };
-                const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(updatedData, key);
-                const decrypted2 = crypto_util_1.DyFM_Crypto.decrypt(encrypted2, key);
-                expect(decrypted1).toEqual(userData);
-                expect(decrypted2).toEqual(updatedData);
-                expect(decrypted2.lastLogin).not.toBe(userData.lastLogin);
-            });
-            it('| should maintain data integrity through multiple database operations', () => {
-                const sensitiveData = {
-                    id: 1,
-                    password: 'hashed-password-123',
-                    securityQuestions: [
-                        { question: 'What is your pet name?', answer: 'Fluffy' },
-                        { question: 'Where were you born?', answer: 'New York' }
-                    ]
-                };
-                const key = 'sensitive-data-key';
-                // Simulate multiple database operations with the same data
-                const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(sensitiveData, key);
-                const decrypted1 = crypto_util_1.DyFM_Crypto.decrypt(encrypted1, key);
-                const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(decrypted1, key);
-                const decrypted2 = crypto_util_1.DyFM_Crypto.decrypt(encrypted2, key);
-                expect(decrypted1).toEqual(sensitiveData);
-                expect(decrypted2).toEqual(sensitiveData);
-                expect(encrypted1).toBe(encrypted2); // Different encryption instances
-            });
-        });
-        describe('| special characters', () => {
-            it('| should handle Unicode characters', () => {
-                const unicodeData = {
-                    text: 'Hello 世界! 🌍',
-                    emoji: '👋',
-                    special: '!!!@@@###$$$%%%^^^&&&***((()))___+++---===[[[]]]{{{}}}|||;;;:::,,,...<<<>>>' +
-                        'ĐĐĐđđđßßߤ¤¤×××÷÷÷¨¨¨¨~~~ˇˇˇ^^^˘˘˘°°°˛˛˛```˙˙˙´´´˝˝˝˝¸¸¸§§§' +
-                        '???ééééáááűűűúúúőőőóóóüüüöööíííÉÉÉÁÁÁŰŰŰÚÚÚŐŐŐÓÓÓÜÖÖÖÍÍÍ'
-                };
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(unicodeData, testKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-                expect(decrypted).toEqual(unicodeData);
-            });
-            it('| should handle special characters in object keys', () => {
-                const specialKeyData = {
-                    'key-with-spaces': 'value',
-                    'key.with.dots': 'value',
-                    'key-with-special-chars!@#': 'value',
-                    'key-with-unicode-世界': 'value'
-                };
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(specialKeyData, testKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-                expect(decrypted).toEqual(specialKeyData);
-            });
-            it('| should handle special characters in nested objects', () => {
-                const nestedData = {
-                    level1: {
-                        'special-key!@#': {
-                            'nested-key-世界': 'value with special chars!@#'
-                        }
-                    }
-                };
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(nestedData, testKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-                expect(decrypted).toEqual(nestedData);
-            });
-            it('| should handle special characters in arrays', () => {
-                const arrayData = [
-                    'Hello 世界!',
-                    { 'special-key': 'value with !@#' },
-                    ['nested', 'array', 'with', 'special', 'chars!@#']
-                ];
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(arrayData, testKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
-                expect(decrypted).toEqual(arrayData);
-            });
-        });
-    });
-    describe('| TIME MANIPULATION TESTS - Cross-temporal consistency', () => {
-        const testKey = 'time-test-key-456';
-        const testData = {
-            id: 123,
-            name: 'time-test',
-            timestamp: new Date().toISOString(),
-            nested: { value: 'time-dependent-test' }
-        };
-        let originalDateNow;
-        let originalDateConstructor;
-        beforeEach(() => {
-            // Store original Date functions
-            originalDateNow = Date.now;
-            originalDateConstructor = Date;
-        });
-        afterEach(() => {
-            // Restore original Date functions
-            Date.now = originalDateNow;
-            global.Date = originalDateConstructor;
-        });
-        it('| should produce identical encrypted output regardless of system time', () => {
-            const baseTime = 1609459200000; // 2021-01-01 00:00:00 UTC
-            // Mock Date.now to return fixed time
-            Date.now = jasmine.createSpy('Date.now').and.returnValue(baseTime);
-            // Mock Date constructor to return fixed date
-            global.Date = jasmine.createSpy('Date').and.callFake((args) => {
-                if (!args) {
-                    return new originalDateConstructor(baseTime);
-                }
-                return new originalDateConstructor(args);
-            });
-            const encrypted1 = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-            const encrypted2 = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-            expect(encrypted1).toEqual(encrypted2);
-            expect(encrypted1).toBeDefined();
-        });
-        it('| should maintain consistency across different time zones', () => {
-            const timeZones = [
-                0, // UTC
-                -5, // EST
-                1, // CET
-                9, // JST
-                -8, // PST
-                5.5 // IST
-            ];
-            const results = [];
-            timeZones.forEach(offset => {
-                const baseTime = 1609459200000 + (offset * 3600000); // Adjust for timezone
-                Date.now = jasmine.createSpy('Date.now').and.returnValue(baseTime);
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-                results.push(encrypted);
-            });
-            // All results should be identical regardless of timezone
-            const firstResult = results[0];
-            results.forEach(result => {
-                expect(result).toEqual(firstResult);
-            });
-        });
-        it('| should handle time-based data consistently', () => {
-            const timeBasedData = {
-                createdAt: new Date('2023-01-01T00:00:00Z'),
-                updatedAt: new Date('2023-12-31T23:59:59Z'),
-                timestamp: Date.now(),
-                timeString: new Date().toISOString()
-            };
-            // Test with different system times
-            const times = [
-                1609459200000, // 2021-01-01
-                1640995200000, // 2022-01-01
-                1672531200000, // 2023-01-01
-                1704067200000 // 2024-01-01
-            ];
-            const results = [];
-            times.forEach(time => {
-                Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(timeBasedData, testKey);
-                results.push(encrypted);
-            });
-            // All results should be identical
-            const firstResult = results[0];
-            results.forEach(result => {
-                expect(result).toEqual(firstResult);
-            });
-        });
-        it('| should maintain consistency across date boundaries', () => {
-            const boundaryTimes = [
-                1609459200000, // 2021-01-01 00:00:00
-                1609459259999, // 2021-01-01 00:00:59
-                1609459260000, // 2021-01-01 00:01:00
-                1609545600000, // 2021-01-02 00:00:00
-                1609632000000, // 2021-01-03 00:00:00
-                1640995200000, // 2022-01-01 00:00:00
-                1672531200000 // 2023-01-01 00:00:00
-            ];
-            const results = [];
-            boundaryTimes.forEach(time => {
-                Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-                results.push(encrypted);
-            });
-            // All results should be identical
-            const firstResult = results[0];
-            results.forEach(result => {
-                expect(result).toEqual(firstResult);
-            });
-        });
-        it('| should handle leap year transitions consistently', () => {
-            const leapYearTimes = [
-                1609459200000, // 2021-01-01 (not leap year)
-                1640995200000, // 2022-01-01 (not leap year)
-                1672531200000, // 2023-01-01 (not leap year)
-                1704067200000, // 2024-01-01 (leap year)
-                1735689600000, // 2025-01-01 (not leap year)
-                1735689600000 + (365 * 24 * 60 * 60 * 1000), // 2025-12-31
-                1735689600000 + (366 * 24 * 60 * 60 * 1000) // 2026-01-01
-            ];
-            const results = [];
-            leapYearTimes.forEach(time => {
-                Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-                results.push(encrypted);
-            });
-            // All results should be identical
-            const firstResult = results[0];
-            results.forEach(result => {
-                expect(result).toEqual(firstResult);
-            });
-        });
-        it('| should maintain consistency across daylight saving time transitions', () => {
-            // DST transition times (approximate)
-            const dstTimes = [
-                1615708800000, // 2021-03-14 (DST start)
-                1615712400000, // 2021-03-14 01:00 (DST start + 1 hour)
-                1636243200000, // 2021-11-07 (DST end)
-                1636246800000, // 2021-11-07 01:00 (DST end + 1 hour)
-                1648339200000, // 2022-03-13 (DST start)
-                1648342800000, // 2022-03-13 01:00 (DST start + 1 hour)
-                1668816000000, // 2022-11-06 (DST end)
-                1668819600000 // 2022-11-06 01:00 (DST end + 1 hour)
-            ];
-            const results = [];
-            dstTimes.forEach(time => {
-                Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-                results.push(encrypted);
-            });
-            // All results should be identical
-            const firstResult = results[0];
-            results.forEach(result => {
-                expect(result).toEqual(firstResult);
-            });
-        });
-        it('| should handle microsecond precision consistently', () => {
-            const baseTime = 1609459200000;
-            const microsecondOffsets = [
-                0,
-                1,
-                10,
-                100,
-                1000,
-                10000,
-                100000,
-                999999
-            ];
-            const results = [];
-            microsecondOffsets.forEach(offset => {
-                const time = baseTime + offset;
-                Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-                results.push(encrypted);
-            });
-            // All results should be identical
-            const firstResult = results[0];
-            results.forEach(result => {
-                expect(result).toEqual(firstResult);
-            });
-        });
-        it('| should maintain consistency across different Date object states', () => {
-            const testDataWithDates = {
-                date1: new Date('2023-01-01'),
-                date2: new Date('2023-12-31'),
-                date3: new Date(),
-                date4: new Date(0), // Unix epoch
-                date5: new Date(8640000000000000), // Max safe date
-                date6: new Date(-8640000000000000) // Min safe date
-            };
-            const results = [];
-            // Test with different system times
-            const systemTimes = [1609459200000, 1640995200000, 1672531200000];
-            systemTimes.forEach(systemTime => {
-                Date.now = jasmine.createSpy('Date.now').and.returnValue(systemTime);
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testDataWithDates, testKey);
-                results.push(encrypted);
-            });
-            // All results should be identical
-            const firstResult = results[0];
-            results.forEach(result => {
-                expect(result).toEqual(firstResult);
-            });
-        });
-        it('| should handle time-based encryption/decryption cycles consistently', () => {
-            const cycles = 10;
-            const results = [];
-            for (let i = 0; i < cycles; i++) {
-                // Simulate different system times
-                const time = 1609459200000 + (i * 86400000); // Add 1 day each cycle
-                Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-                results.push(encrypted);
-            }
-            // All results should be identical
-            const firstResult = results[0];
-            results.forEach(result => {
-                expect(result).toEqual(firstResult);
-            });
-        });
-        it('| should maintain consistency with real-world time scenarios', () => {
-            const realWorldScenarios = [
-                { name: 'New Year 2021', time: 1609459200000 },
-                { name: 'Leap Day 2020', time: 1583020800000 },
-                { name: 'DST Start 2021', time: 1615708800000 },
-                { name: 'DST End 2021', time: 1636243200000 },
-                { name: 'Midnight UTC', time: 1609459200000 },
-                { name: 'Noon UTC', time: 1609459200000 + (12 * 3600000) },
-                { name: 'End of Day', time: 1609459200000 + (23 * 3600000) + (59 * 60000) + (59 * 1000) }
-            ];
-            const results = [];
-            realWorldScenarios.forEach(scenario => {
-                Date.now = jasmine.createSpy('Date.now').and.returnValue(scenario.time);
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
-                results.push(encrypted);
-            });
-            // All results should be identical
-            const firstResult = results[0];
-            results.forEach((result, index) => {
-                expect(result).toEqual(firstResult);
-            });
-        });
-    });
-    describe('| ERROR HANDLING TESTS - Comprehensive validation', () => {
-        const validKey = 'valid-test-key-123';
-        const validData = { id: 1, name: 'test' };
-        describe('| Encryption Error Cases', () => {
-            it('| should throw descriptive error when encrypting undefined data', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt(undefined, validKey)).toThrow();
-            });
-            it('| should throw descriptive error when encrypting null data', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt(null, validKey)).toThrow();
-            });
-            it('| should throw descriptive error when encrypting empty string', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt('', validKey)).toThrow();
-            });
-            it('| should allow empty object for backward compatibility', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt({}, validKey)).not.toThrow();
-            });
-            it('| should allow empty array for backward compatibility', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt([], validKey)).not.toThrow();
-            });
-            it('| should throw descriptive error when key is missing', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt(validData, undefined)).toThrow();
-            });
-            it('| should throw descriptive error when key is null', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt(validData, null)).toThrow();
-            });
-            it('| should throw descriptive error when key is not a string', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt(validData, 123)).toThrow();
-            });
-            it('| should throw descriptive error when key is empty string', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt(validData, '')).toThrow();
-            });
-            it('| should throw descriptive error when key is only whitespace', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt(validData, '   ')).toThrow();
-            });
-            it('| should warn about short keys but still work', () => {
-                // This test just ensures encryption works with short keys
-                // Note: Warning is shown in console but spy might not catch it in test environment
-                expect(() => crypto_util_1.DyFM_Crypto.encrypt(validData, 'short')).not.toThrow();
-            });
-        });
-        describe('| Decryption Error Cases', () => {
-            it('| should throw descriptive error when decrypting undefined data', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(undefined, validKey)).toThrow();
-            });
-            it('| should throw descriptive error when decrypting null data', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(null, validKey)).toThrow();
-            });
-            it('| should throw descriptive error when decrypting non-string data', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(123, validKey)).toThrow();
-            });
-            it('| should throw descriptive error when decrypting empty string', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt('', validKey)).toThrow();
-            });
-            it('| should throw descriptive error when decrypting too short data', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt('short', validKey)).toThrow();
-            });
-            it('| should throw descriptive error when decrypting invalid format', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt('invalid!@#format', validKey)).toThrow();
-            });
-            it('| should throw descriptive error when key is missing for decryption', () => {
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(validData, validKey);
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(encrypted, undefined)).toThrow();
-            });
-            it('| should throw descriptive error when key is wrong type for decryption', () => {
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(validData, validKey);
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(encrypted, 123)).toThrow();
-            });
-            it('| should throw descriptive error when key is empty for decryption', () => {
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(validData, validKey);
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(encrypted, '')).toThrow();
-            });
-            it('| should handle decryption with proper key validation', () => {
-                // Test that decryption works with valid key
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(validData, validKey);
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(encrypted, validKey)).not.toThrow();
-            });
-        });
-        describe('| Decryption Failure Scenarios', () => {
-            it('| should throw descriptive error when decrypting with wrong key', () => {
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(validData, validKey);
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(encrypted, 'wrong-key-123')).toThrow();
-            });
-            it('| should throw descriptive error when decrypting corrupted data', () => {
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(validData, validKey);
-                const corrupted = encrypted.substring(0, encrypted.length - 10); // Remove last 10 characters
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt(corrupted, validKey)).toThrow();
-            });
-            it('| should throw descriptive error when decrypting invalid base64', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt('invalid-base64!@#', validKey)).toThrow();
-            });
-            it('| should throw descriptive error when decrypting completely wrong data', () => {
-                expect(() => crypto_util_1.DyFM_Crypto.decrypt('this-is-not-encrypted-data', validKey)).toThrow();
-            });
-        });
-        describe('| Edge Case Validations', () => {
-            it('| should allow valid data with minimum key length', () => {
-                const shortKey = '12345678'; // 8 characters minimum
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(validData, shortKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, shortKey);
-                expect(decrypted).toEqual(validData);
-            });
-            it('| should allow valid data with whitespace in key', () => {
-                const keyWithSpaces = '  valid-key-123  ';
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(validData, keyWithSpaces);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, keyWithSpaces);
-                expect(decrypted).toEqual(validData);
-            });
-            it('| should handle special characters in data', () => {
-                const specialData = {
-                    special: '!@#$%^&*()_+-=[]{}|;:,.<>?',
-                    unicode: '世界你好',
-                    emoji: '🚀💻🔐'
-                };
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(specialData, validKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, validKey);
-                expect(decrypted).toEqual(specialData);
-            });
-            it('| should handle very long data', () => {
-                const longData = {
-                    text: 'A'.repeat(10000),
-                    array: Array(1000).fill(0).map((_, i) => i),
-                    nested: {
-                        level1: { level2: { level3: { data: 'deep nested data' } } }
-                    }
-                };
-                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(longData, validKey);
-                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, validKey);
-                expect(decrypted).toEqual(longData);
-            });
-        });
-        describe('| Error Code Validation', () => {
-            it('| should have specific error codes for different failure types', () => {
-                try {
-                    crypto_util_1.DyFM_Crypto.encrypt(undefined, validKey);
-                    fail('Should have thrown an error');
-                }
-                catch (error) {
-                    expect(error._errorCode).toBe('DyFM-CRY-DATA-UNDEFINED');
-                }
-                try {
-                    crypto_util_1.DyFM_Crypto.encrypt(validData, '');
-                    fail('Should have thrown an error');
-                }
-                catch (error) {
-                    expect(error._errorCode).toBe('DyFM-CRY-KEY-MISSING');
-                }
-                try {
-                    crypto_util_1.DyFM_Crypto.decrypt('', validKey);
-                    fail('Should have thrown an error');
-                }
-                catch (error) {
-                    expect(error._errorCode).toBe('DyFM-CRY-ENCRYPTED-EMPTY');
-                }
-            });
-        });
-    });
-});
-//# sourceMappingURL=crypto.util.spec.js.map