@geekmidas/cache 0.0.3 → 0.0.5

package/dist/__tests__/integration.spec.cjs

@@ -1,30 +1,30 @@
 const require_memory = require('../memory-n6Iosq6J.cjs');
-const require_vi_DgezovHB = require('../vi.DgezovHB-NqP74KGR.cjs');
+const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-CKSnd2bq.cjs');
 
 //#region src/__tests__/integration.spec.ts
-require_vi_DgezovHB.describe("Cache Integration Tests", () => {
+require_vi_bdSIJ99Y.describe("Cache Integration Tests", () => {
 	let memoryCache;
-	require_vi_DgezovHB.beforeEach(() => {
+	require_vi_bdSIJ99Y.beforeEach(() => {
 		memoryCache = new require_memory.InMemoryCache();
 	});
-	require_vi_DgezovHB.describe("cross-cache behavior consistency", () => {
+	require_vi_bdSIJ99Y.describe("cross-cache behavior consistency", () => {
 		const testCases = [{
 			name: "InMemoryCache",
 			cache: () => new require_memory.InMemoryCache()
 		}];
 		testCases.forEach(({ name, cache }) => {
-			require_vi_DgezovHB.describe(name, () => {
+			require_vi_bdSIJ99Y.describe(name, () => {
 				let cacheInstance;
-				require_vi_DgezovHB.beforeEach(() => {
+				require_vi_bdSIJ99Y.beforeEach(() => {
 					cacheInstance = cache();
 				});
-				require_vi_DgezovHB.it("should handle basic CRUD operations", async () => {
+				require_vi_bdSIJ99Y.it("should handle basic CRUD operations", async () => {
 					await cacheInstance.set("user:1", {
 						id: 1,
 						name: "John"
 					});
 					const user = await cacheInstance.get("user:1");
-					require_vi_DgezovHB.globalExpect(user).toEqual({
+					require_vi_bdSIJ99Y.globalExpect(user).toEqual({
 						id: 1,
 						name: "John"
 					});
@@ -33,15 +33,15 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 						name: "Jane"
 					});
 					const updatedUser = await cacheInstance.get("user:1");
-					require_vi_DgezovHB.globalExpect(updatedUser).toEqual({
+					require_vi_bdSIJ99Y.globalExpect(updatedUser).toEqual({
 						id: 1,
 						name: "Jane"
 					});
 					await cacheInstance.delete("user:1");
 					const deletedUser = await cacheInstance.get("user:1");
-					require_vi_DgezovHB.globalExpect(deletedUser).toBeUndefined();
+					require_vi_bdSIJ99Y.globalExpect(deletedUser).toBeUndefined();
 				});
-				require_vi_DgezovHB.it("should handle concurrent operations", async () => {
+				require_vi_bdSIJ99Y.it("should handle concurrent operations", async () => {
 					const operations = [
 						cacheInstance.set("key1", "value1"),
 						cacheInstance.set("key2", "value2"),
@@ -53,13 +53,13 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 						cacheInstance.get("key2"),
 						cacheInstance.get("key3")
 					]);
-					require_vi_DgezovHB.globalExpect(results).toEqual([
+					require_vi_bdSIJ99Y.globalExpect(results).toEqual([
 						"value1",
 						"value2",
 						"value3"
 					]);
 				});
-				require_vi_DgezovHB.it("should handle data type preservation", async () => {
+				require_vi_bdSIJ99Y.it("should handle data type preservation", async () => {
 					const testData = {
 						string: "hello",
 						number: 42,
@@ -74,31 +74,31 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 					};
 					await Promise.all(Object.entries(testData).map(([key, value]) => cacheInstance.set(key, value)));
 					const results = await Promise.all(Object.keys(testData).map((key) => cacheInstance.get(key)));
-					require_vi_DgezovHB.globalExpect(results[0]).toBe("hello");
-					require_vi_DgezovHB.globalExpect(results[1]).toBe(42);
-					require_vi_DgezovHB.globalExpect(results[2]).toBe(true);
-					require_vi_DgezovHB.globalExpect(results[3]).toEqual({ nested: true });
-					require_vi_DgezovHB.globalExpect(results[4]).toEqual([
+					require_vi_bdSIJ99Y.globalExpect(results[0]).toBe("hello");
+					require_vi_bdSIJ99Y.globalExpect(results[1]).toBe(42);
+					require_vi_bdSIJ99Y.globalExpect(results[2]).toBe(true);
+					require_vi_bdSIJ99Y.globalExpect(results[3]).toEqual({ nested: true });
+					require_vi_bdSIJ99Y.globalExpect(results[4]).toEqual([
 						1,
 						2,
 						3
 					]);
-					require_vi_DgezovHB.globalExpect(results[5]).toBeNull();
+					require_vi_bdSIJ99Y.globalExpect(results[5]).toBeNull();
 				});
-				require_vi_DgezovHB.it("should handle key isolation", async () => {
+				require_vi_bdSIJ99Y.it("should handle key isolation", async () => {
 					await cacheInstance.set("user:1", "User One");
 					await cacheInstance.set("user:2", "User Two");
 					await cacheInstance.set("session:1", "Session One");
 					await cacheInstance.delete("user:1");
-					require_vi_DgezovHB.globalExpect(await cacheInstance.get("user:1")).toBeUndefined();
-					require_vi_DgezovHB.globalExpect(await cacheInstance.get("user:2")).toBe("User Two");
-					require_vi_DgezovHB.globalExpect(await cacheInstance.get("session:1")).toBe("Session One");
+					require_vi_bdSIJ99Y.globalExpect(await cacheInstance.get("user:1")).toBeUndefined();
+					require_vi_bdSIJ99Y.globalExpect(await cacheInstance.get("user:2")).toBe("User Two");
+					require_vi_bdSIJ99Y.globalExpect(await cacheInstance.get("session:1")).toBe("Session One");
 				});
 			});
 		});
 	});
-	require_vi_DgezovHB.describe("cache migration scenarios", () => {
-		require_vi_DgezovHB.it("should support migrating data between cache implementations", async () => {
+	require_vi_bdSIJ99Y.describe("cache migration scenarios", () => {
+		require_vi_bdSIJ99Y.it("should support migrating data between cache implementations", async () => {
 			const sourceCache = new require_memory.InMemoryCache();
 			const targetCache = new require_memory.InMemoryCache();
 			const testData = {
@@ -123,12 +123,12 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 			}
 			for (const [key, expectedValue] of Object.entries(testData)) {
 				const migratedValue = await targetCache.get(key);
-				require_vi_DgezovHB.globalExpect(migratedValue).toEqual(expectedValue);
+				require_vi_bdSIJ99Y.globalExpect(migratedValue).toEqual(expectedValue);
 			}
 		});
 	});
-	require_vi_DgezovHB.describe("cache abstraction patterns", () => {
-		require_vi_DgezovHB.it("should support cache factory pattern", async () => {
+	require_vi_bdSIJ99Y.describe("cache abstraction patterns", () => {
+		require_vi_bdSIJ99Y.it("should support cache factory pattern", async () => {
 			const createCache = (type) => {
 				switch (type) {
 					case "memory": return new require_memory.InMemoryCache();
@@ -142,13 +142,13 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 				name: "John"
 			});
 			await sessionCache.set("session:abc", "active");
-			require_vi_DgezovHB.globalExpect(await userCache.get("user:1")).toEqual({
+			require_vi_bdSIJ99Y.globalExpect(await userCache.get("user:1")).toEqual({
 				id: 1,
 				name: "John"
 			});
-			require_vi_DgezovHB.globalExpect(await sessionCache.get("session:abc")).toBe("active");
+			require_vi_bdSIJ99Y.globalExpect(await sessionCache.get("session:abc")).toBe("active");
 		});
-		require_vi_DgezovHB.it("should support cache wrapper pattern", async () => {
+		require_vi_bdSIJ99Y.it("should support cache wrapper pattern", async () => {
 			class LoggingCache {
 				logs = [];
 				constructor(underlying) {
@@ -176,28 +176,28 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 			await loggingCache.get("test");
 			await loggingCache.delete("test");
 			const logs = loggingCache.getLogs();
-			require_vi_DgezovHB.globalExpect(logs).toEqual([
+			require_vi_bdSIJ99Y.globalExpect(logs).toEqual([
 				"SET test",
 				"GET test",
 				"DELETE test"
 			]);
 		});
 	});
-	require_vi_DgezovHB.describe("performance and stress tests", () => {
-		require_vi_DgezovHB.it("should handle large number of operations", async () => {
+	require_vi_bdSIJ99Y.describe("performance and stress tests", () => {
+		require_vi_bdSIJ99Y.it("should handle large number of operations", async () => {
 			const cache = new require_memory.InMemoryCache();
 			const operationCount = 1e3;
 			const insertPromises = Array.from({ length: operationCount }, (_, i) => cache.set(`key:${i}`, i));
 			await Promise.all(insertPromises);
 			const readPromises = Array.from({ length: operationCount }, (_, i) => cache.get(`key:${i}`));
 			const results = await Promise.all(readPromises);
-			for (let i = 0; i < operationCount; i++) require_vi_DgezovHB.globalExpect(results[i]).toBe(i);
+			for (let i = 0; i < operationCount; i++) require_vi_bdSIJ99Y.globalExpect(results[i]).toBe(i);
 			const deletePromises = Array.from({ length: operationCount }, (_, i) => cache.delete(`key:${i}`));
 			await Promise.all(deletePromises);
 			const postDeleteRead = await cache.get("key:0");
-			require_vi_DgezovHB.globalExpect(postDeleteRead).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(postDeleteRead).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should handle large objects efficiently", async () => {
+		require_vi_bdSIJ99Y.it("should handle large objects efficiently", async () => {
 			const cache = new require_memory.InMemoryCache();
 			const largeObject = {
 				id: 1,
@@ -214,19 +214,19 @@ require_vi_DgezovHB.describe("Cache Integration Tests", () => {
 			await cache.set("large-object", largeObject);
 			const result = await cache.get("large-object");
 			const endTime = Date.now();
-			require_vi_DgezovHB.globalExpect(result).toEqual(largeObject);
-			require_vi_DgezovHB.globalExpect(endTime - startTime).toBeLessThan(100);
+			require_vi_bdSIJ99Y.globalExpect(result).toEqual(largeObject);
+			require_vi_bdSIJ99Y.globalExpect(endTime - startTime).toBeLessThan(100);
 		});
 	});
-	require_vi_DgezovHB.describe("error scenarios", () => {
-		require_vi_DgezovHB.it("should handle operations after errors gracefully", async () => {
+	require_vi_bdSIJ99Y.describe("error scenarios", () => {
+		require_vi_bdSIJ99Y.it("should handle operations after errors gracefully", async () => {
 			const cache = new require_memory.InMemoryCache();
 			await cache.set("valid-key", "valid-value");
-			require_vi_DgezovHB.globalExpect(await cache.get("valid-key")).toBe("valid-value");
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("valid-key")).toBe("valid-value");
 			await cache.set("another-key", "another-value");
-			require_vi_DgezovHB.globalExpect(await cache.get("another-key")).toBe("another-value");
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("another-key")).toBe("another-value");
 			await cache.delete("valid-key");
-			require_vi_DgezovHB.globalExpect(await cache.get("valid-key")).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("valid-key")).toBeUndefined();
 		});
 	});
 });

package/dist/__tests__/integration.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/integration.spec.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/integration.spec.mjs

@@ -1,4 +1,4 @@
-import { beforeEach, describe, globalExpect, it } from "../vi.DgezovHB-McgltIC5.mjs";
+import { beforeEach, describe, globalExpect, it } from "../vi.bdSIJ99Y-DffpE2Zw.mjs";
 import { InMemoryCache } from "../memory-YteQXj7m.mjs";
 
 //#region src/__tests__/integration.spec.ts

package/dist/__tests__/memory.spec.cjs

@@ -1,23 +1,23 @@
 const require_memory = require('../memory-n6Iosq6J.cjs');
-const require_vi_DgezovHB = require('../vi.DgezovHB-NqP74KGR.cjs');
+const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-CKSnd2bq.cjs');
 
 //#region src/__tests__/memory.spec.ts
-require_vi_DgezovHB.describe("InMemoryCache", () => {
+require_vi_bdSIJ99Y.describe("InMemoryCache", () => {
 	let cache;
-	require_vi_DgezovHB.beforeEach(() => {
+	require_vi_bdSIJ99Y.beforeEach(() => {
 		cache = new require_memory.InMemoryCache();
 	});
-	require_vi_DgezovHB.describe("get", () => {
-		require_vi_DgezovHB.it("should return undefined for non-existent key", async () => {
+	require_vi_bdSIJ99Y.describe("get", () => {
+		require_vi_bdSIJ99Y.it("should return undefined for non-existent key", async () => {
 			const result = await cache.get("non-existent");
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(result).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should return value for existing key", async () => {
+		require_vi_bdSIJ99Y.it("should return value for existing key", async () => {
 			await cache.set("test-key", "test-value");
 			const result = await cache.get("test-key");
-			require_vi_DgezovHB.globalExpect(result).toBe("test-value");
+			require_vi_bdSIJ99Y.globalExpect(result).toBe("test-value");
 		});
-		require_vi_DgezovHB.it("should handle different data types", async () => {
+		require_vi_bdSIJ99Y.it("should handle different data types", async () => {
 			const objectValue = {
 				id: 1,
 				name: "test"
@@ -33,91 +33,91 @@ require_vi_DgezovHB.describe("InMemoryCache", () => {
 			await cache.set("array", arrayValue);
 			await cache.set("number", numberValue);
 			await cache.set("boolean", booleanValue);
-			require_vi_DgezovHB.globalExpect(await cache.get("object")).toEqual(objectValue);
-			require_vi_DgezovHB.globalExpect(await cache.get("array")).toEqual(arrayValue);
-			require_vi_DgezovHB.globalExpect(await cache.get("number")).toBe(numberValue);
-			require_vi_DgezovHB.globalExpect(await cache.get("boolean")).toBe(booleanValue);
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("object")).toEqual(objectValue);
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("array")).toEqual(arrayValue);
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("number")).toBe(numberValue);
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("boolean")).toBe(booleanValue);
 		});
 	});
-	require_vi_DgezovHB.describe("set", () => {
-		require_vi_DgezovHB.it("should store string value", async () => {
+	require_vi_bdSIJ99Y.describe("set", () => {
+		require_vi_bdSIJ99Y.it("should store string value", async () => {
 			await cache.set("string-key", "string-value");
 			const result = await cache.get("string-key");
-			require_vi_DgezovHB.globalExpect(result).toBe("string-value");
+			require_vi_bdSIJ99Y.globalExpect(result).toBe("string-value");
 		});
-		require_vi_DgezovHB.it("should store object value", async () => {
+		require_vi_bdSIJ99Y.it("should store object value", async () => {
 			const value = {
 				id: 1,
 				data: "test"
 			};
 			await cache.set("object-key", value);
 			const result = await cache.get("object-key");
-			require_vi_DgezovHB.globalExpect(result).toEqual(value);
+			require_vi_bdSIJ99Y.globalExpect(result).toEqual(value);
 		});
-		require_vi_DgezovHB.it("should overwrite existing value", async () => {
+		require_vi_bdSIJ99Y.it("should overwrite existing value", async () => {
 			await cache.set("key", "initial-value");
 			await cache.set("key", "updated-value");
 			const result = await cache.get("key");
-			require_vi_DgezovHB.globalExpect(result).toBe("updated-value");
+			require_vi_bdSIJ99Y.globalExpect(result).toBe("updated-value");
 		});
-		require_vi_DgezovHB.it("should handle null values", async () => {
+		require_vi_bdSIJ99Y.it("should handle null values", async () => {
 			await cache.set("null-key", null);
 			const result = await cache.get("null-key");
-			require_vi_DgezovHB.globalExpect(result).toBeNull();
+			require_vi_bdSIJ99Y.globalExpect(result).toBeNull();
 		});
 	});
-	require_vi_DgezovHB.describe("delete", () => {
-		require_vi_DgezovHB.it("should remove existing key", async () => {
+	require_vi_bdSIJ99Y.describe("delete", () => {
+		require_vi_bdSIJ99Y.it("should remove existing key", async () => {
 			await cache.set("to-delete", "value");
 			await cache.delete("to-delete");
 			const result = await cache.get("to-delete");
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(result).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should not throw error for non-existent key", async () => {
-			await require_vi_DgezovHB.globalExpect(cache.delete("non-existent")).resolves.not.toThrow();
+		require_vi_bdSIJ99Y.it("should not throw error for non-existent key", async () => {
+			await require_vi_bdSIJ99Y.globalExpect(cache.delete("non-existent")).resolves.not.toThrow();
 		});
-		require_vi_DgezovHB.it("should only delete specified key", async () => {
+		require_vi_bdSIJ99Y.it("should only delete specified key", async () => {
 			await cache.set("key1", "value1");
 			await cache.set("key2", "value2");
 			await cache.delete("key1");
-			require_vi_DgezovHB.globalExpect(await cache.get("key1")).toBeUndefined();
-			require_vi_DgezovHB.globalExpect(await cache.get("key2")).toBe("value2");
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("key1")).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("key2")).toBe("value2");
 		});
 	});
-	require_vi_DgezovHB.describe("multiple operations", () => {
-		require_vi_DgezovHB.it("should handle multiple keys independently", async () => {
+	require_vi_bdSIJ99Y.describe("multiple operations", () => {
+		require_vi_bdSIJ99Y.it("should handle multiple keys independently", async () => {
 			await cache.set("key1", "value1");
 			await cache.set("key2", "value2");
 			await cache.set("key3", "value3");
-			require_vi_DgezovHB.globalExpect(await cache.get("key1")).toBe("value1");
-			require_vi_DgezovHB.globalExpect(await cache.get("key2")).toBe("value2");
-			require_vi_DgezovHB.globalExpect(await cache.get("key3")).toBe("value3");
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("key1")).toBe("value1");
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("key2")).toBe("value2");
+			require_vi_bdSIJ99Y.globalExpect(await cache.get("key3")).toBe("value3");
 		});
-		require_vi_DgezovHB.it("should maintain data integrity across operations", async () => {
+		require_vi_bdSIJ99Y.it("should maintain data integrity across operations", async () => {
 			const data = { count: 0 };
 			await cache.set("counter", data);
 			const retrieved = await cache.get("counter");
 			retrieved.count = 5;
 			const original = await cache.get("counter");
-			require_vi_DgezovHB.globalExpect(original.count).toBe(5);
+			require_vi_bdSIJ99Y.globalExpect(original.count).toBe(5);
 		});
 	});
-	require_vi_DgezovHB.describe("edge cases", () => {
-		require_vi_DgezovHB.it("should handle empty string as key", async () => {
+	require_vi_bdSIJ99Y.describe("edge cases", () => {
+		require_vi_bdSIJ99Y.it("should handle empty string as key", async () => {
 			await cache.set("", "empty-key-value");
 			const result = await cache.get("");
-			require_vi_DgezovHB.globalExpect(result).toBe("empty-key-value");
+			require_vi_bdSIJ99Y.globalExpect(result).toBe("empty-key-value");
 		});
-		require_vi_DgezovHB.it("should handle special characters in keys", async () => {
+		require_vi_bdSIJ99Y.it("should handle special characters in keys", async () => {
 			const specialKey = "key!@#$%^&*()_+{}|:\"<>?[]\\;',./?`~";
 			await cache.set(specialKey, "special-value");
 			const result = await cache.get(specialKey);
-			require_vi_DgezovHB.globalExpect(result).toBe("special-value");
+			require_vi_bdSIJ99Y.globalExpect(result).toBe("special-value");
 		});
-		require_vi_DgezovHB.it("should handle undefined values", async () => {
+		require_vi_bdSIJ99Y.it("should handle undefined values", async () => {
 			await cache.set("undefined-key", void 0);
 			const result = await cache.get("undefined-key");
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(result).toBeUndefined();
 		});
 	});
 });

package/dist/__tests__/memory.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/memory.spec.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/memory.spec.mjs

@@ -1,4 +1,4 @@
-import { beforeEach, describe, globalExpect, it } from "../vi.DgezovHB-McgltIC5.mjs";
+import { beforeEach, describe, globalExpect, it } from "../vi.bdSIJ99Y-DffpE2Zw.mjs";
 import { InMemoryCache } from "../memory-YteQXj7m.mjs";
 
 //#region src/__tests__/memory.spec.ts

package/dist/__tests__/upstash.spec.cjs

@@ -1,16 +1,16 @@
-const require_upstash = require('../upstash-0RolGx7m.cjs');
-const require_vi_DgezovHB = require('../vi.DgezovHB-NqP74KGR.cjs');
+const require_upstash = require('../upstash-DiFDpOHy.cjs');
+const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-CKSnd2bq.cjs');
 
 //#region src/__tests__/upstash.spec.ts
-require_vi_DgezovHB.describe("UpstashCache", () => {
+require_vi_bdSIJ99Y.describe("UpstashCache", () => {
 	let cache;
 	const testKeyPrefix = `test:${Date.now()}:`;
 	let testKeys = [];
-	require_vi_DgezovHB.beforeEach(() => {
+	require_vi_bdSIJ99Y.beforeEach(() => {
 		cache = new require_upstash.UpstashCache("http://localhost:8079", "example_token");
 		testKeys = [];
 	});
-	require_vi_DgezovHB.afterEach(async () => {
+	require_vi_bdSIJ99Y.afterEach(async () => {
 		for (const key of testKeys) try {
 			await cache.delete(key);
 		} catch (error) {}
@@ -20,13 +20,13 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 		testKeys.push(key);
 		return key;
 	};
-	require_vi_DgezovHB.describe("get", () => {
-		require_vi_DgezovHB.it("should return undefined for non-existent key", async () => {
+	require_vi_bdSIJ99Y.describe("get", () => {
+		require_vi_bdSIJ99Y.it("should return undefined for non-existent key", async () => {
 			const key = getTestKey("non-existent");
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(result).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should parse and return JSON value", async () => {
+		require_vi_bdSIJ99Y.it("should parse and return JSON value", async () => {
 			const key = getTestKey("object");
 			const testValue = {
 				id: 1,
@@ -34,30 +34,30 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			};
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(testValue);
+			require_vi_bdSIJ99Y.globalExpect(result).toEqual(testValue);
 		});
-		require_vi_DgezovHB.it("should handle string values", async () => {
+		require_vi_bdSIJ99Y.it("should handle string values", async () => {
 			const key = getTestKey("string");
 			const testValue = "simple string";
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			require_vi_bdSIJ99Y.globalExpect(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should handle number values", async () => {
+		require_vi_bdSIJ99Y.it("should handle number values", async () => {
 			const key = getTestKey("number");
 			const testValue = 42;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			require_vi_bdSIJ99Y.globalExpect(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should handle boolean values", async () => {
+		require_vi_bdSIJ99Y.it("should handle boolean values", async () => {
 			const key = getTestKey("boolean");
 			const testValue = true;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			require_vi_bdSIJ99Y.globalExpect(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should handle array values", async () => {
+		require_vi_bdSIJ99Y.it("should handle array values", async () => {
 			const key = getTestKey("array");
 			const testArray = [
 				1,
@@ -67,17 +67,17 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			];
 			await cache.set(key, testArray);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(testArray);
+			require_vi_bdSIJ99Y.globalExpect(result).toEqual(testArray);
 		});
-		require_vi_DgezovHB.it("should handle null values as undefined", async () => {
+		require_vi_bdSIJ99Y.it("should handle null values as undefined", async () => {
 			const key = getTestKey("null");
 			await cache.set(key, null);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(result).toBeUndefined();
 		});
 	});
-	require_vi_DgezovHB.describe("set", () => {
-		require_vi_DgezovHB.it("should store and retrieve object value", async () => {
+	require_vi_bdSIJ99Y.describe("set", () => {
+		require_vi_bdSIJ99Y.it("should store and retrieve object value", async () => {
 			const key = getTestKey("set-object");
 			const testValue = {
 				id: 1,
@@ -85,30 +85,30 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			};
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(testValue);
+			require_vi_bdSIJ99Y.globalExpect(result).toEqual(testValue);
 		});
-		require_vi_DgezovHB.it("should store and retrieve string values", async () => {
+		require_vi_bdSIJ99Y.it("should store and retrieve string values", async () => {
 			const key = getTestKey("set-string");
 			const testValue = "test string";
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			require_vi_bdSIJ99Y.globalExpect(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should store and retrieve number values", async () => {
+		require_vi_bdSIJ99Y.it("should store and retrieve number values", async () => {
 			const key = getTestKey("set-number");
 			const testValue = 42;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			require_vi_bdSIJ99Y.globalExpect(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should store and retrieve boolean values", async () => {
+		require_vi_bdSIJ99Y.it("should store and retrieve boolean values", async () => {
 			const key = getTestKey("set-boolean");
 			const testValue = true;
 			await cache.set(key, testValue);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe(testValue);
+			require_vi_bdSIJ99Y.globalExpect(result).toBe(testValue);
 		});
-		require_vi_DgezovHB.it("should store and retrieve array values", async () => {
+		require_vi_bdSIJ99Y.it("should store and retrieve array values", async () => {
 			const key = getTestKey("set-array");
 			const testArray = [
 				1,
@@ -117,46 +117,46 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			];
 			await cache.set(key, testArray);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(testArray);
+			require_vi_bdSIJ99Y.globalExpect(result).toEqual(testArray);
 		});
-		require_vi_DgezovHB.it("should not store and retrieve null values", async () => {
+		require_vi_bdSIJ99Y.it("should not store and retrieve null values", async () => {
 			const key = getTestKey("set-null");
 			await cache.set(key, null);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(result).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should overwrite existing values", async () => {
+		require_vi_bdSIJ99Y.it("should overwrite existing values", async () => {
 			const key = getTestKey("overwrite");
 			await cache.set(key, "initial");
 			await cache.set(key, "updated");
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBe("updated");
+			require_vi_bdSIJ99Y.globalExpect(result).toBe("updated");
 		});
 	});
-	require_vi_DgezovHB.describe("delete", () => {
-		require_vi_DgezovHB.it("should delete existing key", async () => {
+	require_vi_bdSIJ99Y.describe("delete", () => {
+		require_vi_bdSIJ99Y.it("should delete existing key", async () => {
 			const key = getTestKey("delete-test");
 			await cache.set(key, "value-to-delete");
 			await cache.delete(key);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(result).toBeUndefined();
 		});
-		require_vi_DgezovHB.it("should handle deletion of non-existent key", async () => {
+		require_vi_bdSIJ99Y.it("should handle deletion of non-existent key", async () => {
 			const key = getTestKey("non-existent-delete");
-			await require_vi_DgezovHB.globalExpect(cache.delete(key)).resolves.not.toThrow();
+			await require_vi_bdSIJ99Y.globalExpect(cache.delete(key)).resolves.not.toThrow();
 		});
-		require_vi_DgezovHB.it("should only delete specified key", async () => {
+		require_vi_bdSIJ99Y.it("should only delete specified key", async () => {
 			const key1 = getTestKey("delete-key1");
 			const key2 = getTestKey("delete-key2");
 			await cache.set(key1, "value1");
 			await cache.set(key2, "value2");
 			await cache.delete(key1);
-			require_vi_DgezovHB.globalExpect(await cache.get(key1)).toBeUndefined();
-			require_vi_DgezovHB.globalExpect(await cache.get(key2)).toBe("value2");
+			require_vi_bdSIJ99Y.globalExpect(await cache.get(key1)).toBeUndefined();
+			require_vi_bdSIJ99Y.globalExpect(await cache.get(key2)).toBe("value2");
 		});
 	});
-	require_vi_DgezovHB.describe("integration scenarios", () => {
-		require_vi_DgezovHB.it("should handle round-trip operations", async () => {
+	require_vi_bdSIJ99Y.describe("integration scenarios", () => {
+		require_vi_bdSIJ99Y.it("should handle round-trip operations", async () => {
 			const key = getTestKey("user-session");
 			const testData = {
 				user: {
@@ -168,9 +168,9 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			};
 			await cache.set(key, testData);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(testData);
+			require_vi_bdSIJ99Y.globalExpect(result).toEqual(testData);
 		});
-		require_vi_DgezovHB.it("should handle complex nested objects", async () => {
+		require_vi_bdSIJ99Y.it("should handle complex nested objects", async () => {
 			const key = getTestKey("complex");
 			const complexObject = { level1: { level2: { level3: {
 				data: "deep nested value",
@@ -178,9 +178,9 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			} } } };
 			await cache.set(key, complexObject);
 			const result = await cache.get(key);
-			require_vi_DgezovHB.globalExpect(result).toEqual(complexObject);
+			require_vi_bdSIJ99Y.globalExpect(result).toEqual(complexObject);
 		});
-		require_vi_DgezovHB.it("should handle concurrent operations", async () => {
+		require_vi_bdSIJ99Y.it("should handle concurrent operations", async () => {
 			const keys = [
 				"concurrent1",
 				"concurrent2",
@@ -193,7 +193,7 @@ require_vi_DgezovHB.describe("UpstashCache", () => {
 			];
 			await Promise.all(keys.map((key, i) => cache.set(key, values[i])));
 			const results = await Promise.all(keys.map((key) => cache.get(key)));
-			require_vi_DgezovHB.globalExpect(results).toEqual(values);
+			require_vi_bdSIJ99Y.globalExpect(results).toEqual(values);
 		});
 	});
 });

package/dist/__tests__/upstash.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/upstash.spec.d.mts

@@ -0,0 +1 @@
+export { };