@futdevpro/fsm-dynamo 1.11.21 → 1.11.23

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

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_2_non_stable_util_1 = require("./crypto-2-non-stable.util");
+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_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, testKey);
+            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\-_]+$/);
@@ -14,13 +14,13 @@ describe('| DyFM_Crypto', () => {
         it('| should encrypt different data with different results', () => {
             const data1 = { id: 1 };
             const data2 = { id: 2 };
-            const encrypted1 = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(data1, testKey);
-            const encrypted2 = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(data2, testKey);
+            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_2_non_stable_util_1.DyFM_Crypto.encrypt(undefined, testKey)).toThrow();
+            expect(() => crypto_util_1.DyFM_Crypto.encrypt(undefined, testKey)).toThrow();
         });
         it('| should handle complex objects', () => {
             const complexData = {
@@ -31,8 +31,8 @@ describe('| DyFM_Crypto', () => {
                     array: [1, 2, 3]
                 }
             };
-            const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(complexData, testKey);
-            const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+            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', () => {
@@ -45,8 +45,8 @@ describe('| DyFM_Crypto', () => {
                 }
             };
             const expectedResult = JSON.stringify(complexData);
-            const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(complexData, testKey);
-            const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+            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);
         });
@@ -57,81 +57,264 @@ describe('| DyFM_Crypto', () => {
                 nested: { value: 'nested-value', array: [1, 2, 3] }
             };
             const originalData = JSON.stringify(complexData);
-            const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(complexData, testKey);
-            const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+            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_2_non_stable_util_1.DyFM_Crypto.encrypt(arrayData, testKey);
-            const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+            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_2_non_stable_util_1.DyFM_Crypto.encrypt(stringData, testKey);
-            const encryptedNumber = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(numberData, testKey);
-            const encryptedBoolean = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(booleanData, testKey);
-            expect(crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encryptedString, testKey)).toBe(stringData);
-            expect(crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encryptedNumber, testKey)).toBe(numberData);
-            expect(crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encryptedBoolean, testKey)).toBe(booleanData);
+            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_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, testKey);
-            const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+            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_2_non_stable_util_1.DyFM_Crypto.decrypt('invalid-encrypted-data', testKey)).toThrow();
+            expect(() => crypto_util_1.DyFM_Crypto.decrypt('invalid-encrypted-data', testKey)).toThrow();
         });
         it('| should throw DyFM_Error when using wrong key', () => {
-            const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, testKey);
-            expect(() => crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, 'wrong-key')).toThrow();
+            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_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, testKey);
+            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
             const modified = encrypted.slice(0, -1) + 'A';
-            expect(() => crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(modified, testKey)).toThrow();
+            expect(() => crypto_util_1.DyFM_Crypto.decrypt(modified, testKey)).toThrow();
         });
     });
     describe('| URL-safe encryption', () => {
         it('| should produce URL-safe strings', () => {
-            const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, testKey);
+            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_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, testKey);
+            const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
             const header = `Bearer ${encrypted}`;
             const extracted = header.split(' ')[1];
-            const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(extracted, testKey);
+            const decrypted = crypto_util_1.DyFM_Crypto.decrypt(extracted, testKey);
             expect(decrypted).toEqual(testData);
         });
         it('| should work in URLs', () => {
-            const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, testKey);
+            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_2_non_stable_util_1.DyFM_Crypto.decrypt(extracted, testKey);
+            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: '', key: 'empty-string-key' },
+                    { data: 0, key: 'zero-number-key' },
+                    { data: false, key: 'false-boolean-key' },
+                    { data: { a: 0, b: false, c: '' }, 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_2_non_stable_util_1.DyFM_Crypto.encrypt(emptyObj, testKey);
-                const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+                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_2_non_stable_util_1.DyFM_Crypto.encrypt(emptyArr, testKey);
-                const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+                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', () => {
@@ -140,8 +323,8 @@ describe('| DyFM_Crypto', () => {
                     name: null,
                     nested: { value: null }
                 };
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(dataWithNull, testKey);
-                const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+                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', () => {
@@ -150,41 +333,41 @@ describe('| DyFM_Crypto', () => {
                     name: undefined,
                     nested: { value: undefined }
                 };
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(dataWithUndefined, testKey);
-                const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+                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_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, longKey);
-                const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, longKey);
+                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_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, '')).toThrow();
+                expect(() => crypto_util_1.DyFM_Crypto.encrypt(testData, '')).toThrow();
             });
             it('| should handle whitespace-only keys', () => {
-                expect(() => crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, '   ')).toThrow();
+                expect(() => crypto_util_1.DyFM_Crypto.encrypt(testData, '   ')).toThrow();
             });
         });
         describe('| encrypted data manipulation', () => {
             it('| should detect when encrypted data is truncated', () => {
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, testKey);
+                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
                 const truncated = encrypted.slice(0, -10);
-                expect(() => crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(truncated, testKey)).toThrow();
+                expect(() => crypto_util_1.DyFM_Crypto.decrypt(truncated, testKey)).toThrow();
             });
             it('| should detect when encrypted data is extended', () => {
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, testKey);
+                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(testData, testKey);
                 const extended = encrypted + 'A'.repeat(10);
-                expect(() => crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(extended, testKey)).toThrow();
+                expect(() => crypto_util_1.DyFM_Crypto.decrypt(extended, testKey)).toThrow();
             });
             it('| should detect when encrypted data is modified in the middle', () => {
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, testKey);
+                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_2_non_stable_util_1.DyFM_Crypto.decrypt(modified, testKey)).toThrow();
+                expect(() => crypto_util_1.DyFM_Crypto.decrypt(modified, testKey)).toThrow();
             });
         });
         describe('| JSON handling edge cases', () => {
@@ -200,8 +383,8 @@ describe('| DyFM_Crypto', () => {
                 };
                 // Simulate double stringification
                 const doubleStringified = JSON.stringify(JSON.stringify(testData));
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(doubleStringified, testKey);
-                const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(doubleStringified, testKey);
+                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
                 // Should be able to parse the decrypted data back to the original object
                 const parsed = JSON.parse(decrypted);
                 expect(parsed).toEqual(testData);
@@ -451,8 +634,8 @@ describe('| DyFM_Crypto', () => {
                     '239': '}',
                     '240': '}'
                 };
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(charByCharData, testKey);
-                const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+                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);
             });
@@ -466,11 +649,11 @@ describe('| DyFM_Crypto', () => {
                 };
                 const key = 'test-secret-key-123';
                 // Simulate different environments by creating new instances
-                const encrypted1 = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, key);
-                const encrypted2 = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(testData, key);
+                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_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted1, key)).toEqual(testData);
-                expect(crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted2, key)).toEqual(testData);
+                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 = [
@@ -480,8 +663,8 @@ describe('| DyFM_Crypto', () => {
                     { data: { nested: { value: true } }, key: 'key4' }
                 ];
                 testCases.forEach(({ data, key }) => {
-                    const encrypted1 = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(data, key);
-                    const encrypted2 = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(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);
                 });
             });
@@ -499,10 +682,10 @@ describe('| DyFM_Crypto', () => {
                 };
                 const key = 'db-storage-key';
                 // Simulate database storage and retrieval
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(originalData, key);
+                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_2_non_stable_util_1.DyFM_Crypto.decrypt(retrievedData, key);
+                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(retrievedData, key);
                 expect(decrypted).toEqual(originalData);
             });
             it('| should handle multiple encryption/decryption cycles for database operations', () => {
@@ -517,15 +700,15 @@ describe('| DyFM_Crypto', () => {
                 };
                 const key = 'persistent-key';
                 // Simulate multiple database operations
-                const encrypted1 = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(userData, key);
-                const decrypted1 = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted1, key);
+                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_2_non_stable_util_1.DyFM_Crypto.encrypt(updatedData, key);
-                const decrypted2 = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted2, key);
+                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);
@@ -541,10 +724,10 @@ describe('| DyFM_Crypto', () => {
                 };
                 const key = 'sensitive-data-key';
                 // Simulate multiple database operations with the same data
-                const encrypted1 = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(sensitiveData, key);
-                const decrypted1 = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted1, key);
-                const encrypted2 = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(decrypted1, key);
-                const decrypted2 = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted2, key);
+                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
@@ -559,8 +742,8 @@ describe('| DyFM_Crypto', () => {
                         'ĐĐĐđđđßßߤ¤¤×××÷÷÷¨¨¨¨~~~ˇˇˇ^^^˘˘˘°°°˛˛˛```˙˙˙´´´˝˝˝˝¸¸¸§§§' +
                         '???ééééáááűűűúúúőőőóóóüüüöööíííÉÉÉÁÁÁŰŰŰÚÚÚŐŐŐÓÓÓÜÖÖÖÍÍÍ'
                 };
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(unicodeData, testKey);
-                const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+                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', () => {
@@ -570,8 +753,8 @@ describe('| DyFM_Crypto', () => {
                     'key-with-special-chars!@#': 'value',
                     'key-with-unicode-世界': 'value'
                 };
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(specialKeyData, testKey);
-                const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+                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', () => {
@@ -582,8 +765,8 @@ describe('| DyFM_Crypto', () => {
                         }
                     }
                 };
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(nestedData, testKey);
-                const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+                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', () => {
@@ -592,8 +775,8 @@ describe('| DyFM_Crypto', () => {
                     { 'special-key': 'value with !@#' },
                     ['nested', 'array', 'with', 'special', 'chars!@#']
                 ];
-                const encrypted = crypto_2_non_stable_util_1.DyFM_Crypto.encrypt(arrayData, testKey);
-                const decrypted = crypto_2_non_stable_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
+                const encrypted = crypto_util_1.DyFM_Crypto.encrypt(arrayData, testKey);
+                const decrypted = crypto_util_1.DyFM_Crypto.decrypt(encrypted, testKey);
                 expect(decrypted).toEqual(arrayData);
             });
         });