cachimbo 0.0.3 → 0.0.5

package/README.md

@@ -4,7 +4,10 @@
 
 <h1 align="center">Cachimbo</h1>
 
-Cachimbo is an advanced caching library that allows you to layer different strategies in order to maximize the performance.
+Cachimbo is a composable caching library that allows layering different strategies in order to maximize the performance.
+
+[![NPM](https://img.shields.io/npm/v/cachimbo)](https://www.npmjs.com/package/cachimbo)
+[![Coverage](https://img.shields.io/codecov/c/github/Guichaguri/cachimbo)](https://app.codecov.io/gh/Guichaguri/cachimbo)
 
 ## Features
 
@@ -18,7 +21,8 @@ Cachimbo is an advanced caching library that allows you to layer different strat
   - Least Recently Used (LRU) eviction
   - Time-based (TTL) eviction
   - FIFO eviction
-- Supports intermediary cache strategies
+  - Weak References (garbage collectable cached items)
+- Supports composable cache strategies
   - Request coalescing (deduplication)
   - Multi-layer caching (tiered cache)
   - Stale-While-Revalidate
@@ -78,7 +82,9 @@ External caches (like Redis, Memcached, etc) provide fast, scalable, shared stor
 
 ## Cache Layers
 
-These layers work just like "middlewares" but for caches, they customize how a cache is handled.
+Cache layers are composable components that sit between your code and the cache store. While cache stores define *where* data is stored, cache layers define *how* the cache is accessed.
+
+Each layer intercepts cache operations to add behavior. Layers can be stacked to form a pipeline, allowing advanced caching strategies to be reused across different cache backends.
 
 - [Request Coalescing](/docs/layers/request-coalescing.md) (deduplication)
 - [Tiered Caching](/docs/layers/tiered.md) (multi-layer caching)
@@ -89,6 +95,9 @@ These layers work just like "middlewares" but for caches, they customize how a c
 - [Metrics Collection](/docs/layers/metrics-collection.md)
 
 ## Guides
+- [Getting Started](/docs/guides/getting-started.md)
 - [Choosing the right combination of layers](/docs/guides/choosing-layers.md)
 - [Disabling cache](/docs/guides/disabling.md)
+- [Testing](/docs/guides/testing.md)
 - [Extending](/docs/guides/extending.md)
+- [Samples](/samples)

package/dist/index.cjs

@@ -46,21 +46,18 @@ var BaseLocalCache = class extends BaseCache {
 	disposeListeners = [];
 	/**
 	* Reads cached resources by their keys. (synchronous version)
-	* @protected
 	*/
 	_getMany(keys) {
 		return Object.fromEntries(keys.map((key) => [key, this._get(key)]));
 	}
 	/**
 	* Writes resources into cache. (synchronous version)
-	* @protected
 	*/
 	_setMany(data, options) {
 		for (const [key, value] of Object.entries(data)) this._set(key, value, options);
 	}
 	/**
 	* Deletes many cached resources by their keys. (synchronous version)
-	* @protected
 	*/
 	_deleteMany(keys) {
 		for (const key of keys) this._delete(key);
@@ -69,29 +66,41 @@ var BaseLocalCache = class extends BaseCache {
 	* Adds a listener that will be called when a cached item is disposed.
 	*
 	* @param listener The listener function to add.
-	* @protected
 	*/
 	_addDisposeListener(listener) {
 		this.disposeListeners.push(listener);
 	}
+	/**
+	* Gets access to the internal synchronous methods.
+	* @experimental
+	*/
+	get internal() {
+		return this;
+	}
+	/** @sealed **/
 	get(key) {
 		return Promise.resolve(this._get(key));
 	}
+	/** @sealed **/
 	set(key, value, options) {
 		this._set(key, value, options);
 		return Promise.resolve();
 	}
+	/** @sealed **/
 	delete(key) {
 		this._delete(key);
 		return Promise.resolve();
 	}
+	/** @sealed **/
 	getMany(keys) {
 		return Promise.resolve(this._getMany(keys));
 	}
+	/** @sealed **/
 	setMany(data, options) {
 		this._setMany(data, options);
 		return Promise.resolve();
 	}
+	/** @sealed **/
 	deleteMany(keys) {
 		this._deleteMany(keys);
 		return Promise.resolve();
@@ -205,66 +214,229 @@ var LocalTTLCache = class extends BaseLocalCache {
 * Once the limit of items is reached, the first inserted keys will be purged.
 */
 var LocalMapCache = class extends BaseLocalCache {
-	cache;
+	map;
 	max;
 	constructor(options = {}) {
 		super(options);
-		this.cache = options.cache ?? /* @__PURE__ */ new Map();
+		this.map = options.map ?? /* @__PURE__ */ new Map();
 		this.max = options.max ?? Infinity;
 	}
 	/** @internal */
 	_get(key) {
 		this.logger?.debug(this.name, "[get]", "key =", key);
-		const data = this.cache.get(key);
+		const data = this.map.get(key);
 		return data === void 0 ? null : data;
 	}
 	/** @internal */
 	_set(key, value, options) {
 		this.logger?.debug(this.name, "[set]", "key =", key);
-		const previousValue = this.cache.get(key);
-		if (this.cache.size >= this.max && previousValue === void 0) this.evict(1);
-		this.cache.set(key, value);
+		const previousValue = this.map.get(key);
+		if (this.map.size >= this.max && previousValue === void 0) this.evict(1);
+		this.map.set(key, value);
 		this.onDispose(key, previousValue, "set");
 	}
 	/** @internal */
 	_delete(key) {
 		this.logger?.debug(this.name, "[delete]", "key =", key);
-		const previousValue = this.cache.get(key);
-		this.cache.delete(key);
+		const previousValue = this.map.get(key);
+		this.map.delete(key);
 		this.onDispose(key, previousValue, "delete");
 	}
 	async setMany(data, options) {
 		this.logger?.debug(this.name, "[setMany]", "data =", data);
 		const entries = Object.entries(data);
-		const newEntries = entries.filter(([key]) => !this.cache.has(key)).length;
-		if (this.cache.size + newEntries > this.max) this.evict(this.cache.size + newEntries - this.max);
+		const newEntries = entries.filter(([key]) => !this.map.has(key)).length;
+		if (this.map.size + newEntries > this.max) this.evict(this.map.size + newEntries - this.max);
 		for (const [key, value] of entries) {
-			const previousValue = this.cache.get(key);
-			this.cache.set(key, value);
+			const previousValue = this.map.get(key);
+			this.map.set(key, value);
 			this.onDispose(key, previousValue, "set");
 		}
 	}
 	clear() {
 		this.logger?.debug(this.name, "[clear]");
-		for (const key of this.cache.keys()) this.onDispose(key, this.cache.get(key), "delete");
-		this.cache.clear();
+		for (const key of this.map.keys()) this.onDispose(key, this.map.get(key), "delete");
+		this.map.clear();
 	}
 	onDispose(key, value, reason) {
 		if (value !== void 0) super.onDispose(key, value, reason);
 	}
 	evict(length) {
-		const keys = this.cache.keys();
+		const keys = this.map.keys();
 		for (let i = 0; i < length; i++) {
 			const key = keys.next();
 			if (key.done) break;
 			this.logger?.debug(this.name, "[evict]", "key = ", key);
-			const previousValue = this.cache.get(key.value);
-			this.cache.delete(key.value);
+			const previousValue = this.map.get(key.value);
+			this.map.delete(key.value);
 			this.onDispose(key.value, previousValue, "evict");
 		}
 	}
 };
 
+//#endregion
+//#region src/local/weak/index.ts
+/**
+* A cache layer that stores objects as weak references.
+*
+* When an object is garbage collected, its entry is automatically removed from the underlying cache.
+*
+* This implementation requires support for both `WeakRef` and `FinalizationRegistry`.
+*
+* @see https://caniuse.com/mdn-javascript_builtins_finalizationregistry
+* @see https://caniuse.com/mdn-javascript_builtins_weakref
+*/
+var WeakCache = class extends BaseLocalCache {
+	cache;
+	cacheInternal;
+	registry;
+	constructor(options) {
+		super(options);
+		this.cache = options.cache;
+		this.cacheInternal = options.cache.internal;
+		this.cacheInternal._addDisposeListener(this.onCacheDispose);
+		this.registry = new FinalizationRegistry(this.onGarbageCollect);
+	}
+	onGarbageCollect = (key) => this.cacheInternal._delete(key);
+	onCacheDispose = (key, value, reason) => {
+		this.unregister(value);
+		this.onDispose(key, this.unwrap(value), reason);
+	};
+	/** @internal */
+	_get(key) {
+		return this.unwrap(this.cacheInternal._get(key));
+	}
+	/** @internal */
+	_set(key, value, options) {
+		this.cacheInternal._set(key, this.wrapAndRegister(key, value), options);
+	}
+	/** @internal */
+	_delete(key) {
+		this.unregisterByKey(key);
+		this.cacheInternal._delete(key);
+	}
+	/** @internal */
+	_getMany(keys) {
+		const data = this.cacheInternal._getMany(keys);
+		for (const key of keys) data[key] = this.unwrap(data[key]);
+		return data;
+	}
+	/** @internal */
+	_setMany(data, options) {
+		Object.keys(data).forEach((key) => this.unregisterByKey(key));
+		const wrappedData = {};
+		for (const [key, value] of Object.entries(data)) wrappedData[key] = this.wrapAndRegister(key, value);
+		this.cacheInternal._setMany(wrappedData, options);
+	}
+	/** @internal */
+	_deleteMany(keys) {
+		keys.forEach((key) => this.unregisterByKey(key));
+		this.cacheInternal._deleteMany(keys);
+	}
+	async getOrLoad(key, load, options) {
+		const wrappedLoad = async () => this.wrapAndRegister(key, await load());
+		return this.unwrap(await this.cache.getOrLoad(key, wrappedLoad, options));
+	}
+	/**
+	* Wraps the value in a WeakRef and registers it in the FinalizationRegistry if it's an object.
+	*
+	* @param key The key to reference the value in the FinalizationRegistry
+	* @param value The value to wrap
+	* @returns The wrapped value
+	*/
+	wrapAndRegister(key, value) {
+		this.unregisterByKey(key);
+		if (value !== null && typeof value === "object") {
+			this.registry.register(value, key);
+			return {
+				v: new WeakRef(value),
+				w: true
+			};
+		}
+		return {
+			v: value,
+			w: false
+		};
+	}
+	/**
+	* Unwraps the value from a WeakRef if it's an object.
+	*
+	* @param data The data to unwrap
+	* @returns The unwrapped value
+	*/
+	unwrap(data) {
+		if (data === null) return null;
+		if (data.w) return data.v.deref() ?? null;
+		return data.v;
+	}
+	/**
+	* Unregisters the value from the FinalizationRegistry if it's an object.
+	*
+	* @param value The value to unregister
+	*/
+	unregister(value) {
+		if (value && value.w) this.registry.unregister(value.v);
+	}
+	/**
+	* Unregisters the value associated with the given key from the FinalizationRegistry.
+	*
+	* @param key The key
+	*/
+	unregisterByKey(key) {
+		this.unregister(this.cacheInternal._get(key));
+	}
+};
+
+//#endregion
+//#region src/local/cloning/index.ts
+/**
+* A cache layer that deep clones data when reading and writing.
+*
+* This is useful when you mutate the objects retrieved from cache,
+* and you don't want them to also change in cache.
+*
+* Do not use this layer if you do not intend to mutate cached objects,
+* as the cloning process adds unnecessary overhead.
+*/
+var DeepCloningCache = class extends BaseLocalCache {
+	cache;
+	cacheInternal;
+	deepClone;
+	constructor(options) {
+		super(options);
+		this.cache = options.cache;
+		this.cacheInternal = options.cache.internal;
+		if (options.deepClone) this.deepClone = options.deepClone;
+		else if (typeof structuredClone === "function") this.deepClone = structuredClone;
+		else this.deepClone = (data) => JSON.parse(JSON.stringify(data));
+	}
+	_get(key) {
+		return this.deepClone(this.cacheInternal._get(key));
+	}
+	_set(key, value, options) {
+		this.cacheInternal._set(key, this.deepClone(value), options);
+	}
+	_delete(key) {
+		this.cacheInternal._delete(key);
+	}
+	_getMany(keys) {
+		return this.deepClone(this.cacheInternal._getMany(keys));
+	}
+	_setMany(data, options) {
+		this.cacheInternal._setMany(this.deepClone(data), options);
+	}
+	_deleteMany(keys) {
+		this.cacheInternal._deleteMany(keys);
+	}
+	_addDisposeListener(listener) {
+		this.cacheInternal._addDisposeListener(listener);
+	}
+	async getOrLoad(key, load, options) {
+		const loadWrapped = async () => this.deepClone(await load());
+		return this.deepClone(await this.cache.getOrLoad(key, loadWrapped, options));
+	}
+};
+
 //#endregion
 //#region src/local/noop/index.ts
 /**
@@ -568,7 +740,10 @@ var WorkersKVCache = class extends BaseCache {
 		return this.kv.delete(key);
 	}
 	async getMany(keys) {
-		const data = await this.kv.get(keys, { type: "json" });
+		const data = await this.kv.get(keys, {
+			type: "json",
+			cacheTtl: this.edgeCacheTTL
+		});
 		return Object.fromEntries(data);
 	}
 };
@@ -862,7 +1037,7 @@ var KeyTransformingCache = class {
 	transform;
 	constructor(options) {
 		this.cache = options.cache;
-		if ("transform" in options) this.transform = options.transform;
+		if ("transform" in options && typeof options.transform === "function") this.transform = options.transform;
 		else {
 			const prefix = options.prefix || "";
 			const suffix = options.suffix || "";
@@ -1217,7 +1392,9 @@ var MetricsCollectingCache = class {
 //#endregion
 exports.AsyncLazyCache = AsyncLazyCache;
 exports.BaseCache = BaseCache;
+exports.BaseLocalCache = BaseLocalCache;
 exports.CoalescingCache = CoalescingCache;
+exports.DeepCloningCache = DeepCloningCache;
 exports.IORedisCache = IORedisCache;
 exports.JitteringCache = JitteringCache;
 exports.KeyTransformingCache = KeyTransformingCache;
@@ -1233,4 +1410,5 @@ exports.RedisCache = RedisCache;
 exports.SWRCache = SWRCache;
 exports.TieredCache = TieredCache;
 exports.ValkeyGlideCache = ValkeyGlideCache;
+exports.WeakCache = WeakCache;
 exports.WorkersKVCache = WorkersKVCache;

package/dist/index.d.cts

@@ -121,50 +121,67 @@ declare abstract class BaseCache implements ICache {
 //#endregion
 //#region src/base/local.d.ts
 type LocalCacheDisposeListener<T = any> = (key: string, value: T, reason?: string) => void;
+/**
+ * Internal methods for synchronous cache operations.
+ * @experimental
+ */
+interface LocalCacheInternal {
+  _get<T>(key: string): T | null;
+  _set<T>(key: string, value: T, options?: SetCacheOptions): void;
+  _delete(key: string): void;
+  _getMany<T>(keys: string[]): Record<string, T | null>;
+  _setMany<T>(data: Record<string, T>, options?: SetCacheOptions): void;
+  _deleteMany(keys: string[]): void;
+  _addDisposeListener(listener: LocalCacheDisposeListener): void;
+}
 declare abstract class BaseLocalCache extends BaseCache {
   protected disposeListeners: LocalCacheDisposeListener[];
   /**
    * Reads the cached resource from a key (synchronous version)
-   * @protected
    */
-  abstract _get<T>(key: string): T | null;
+  protected abstract _get<T>(key: string): T | null;
   /**
    * Writes a resource into cache (synchronous version)
-   * @protected
    */
-  abstract _set<T>(key: string, value: T, options?: SetCacheOptions): void;
+  protected abstract _set<T>(key: string, value: T, options?: SetCacheOptions): void;
   /**
    * Deletes a cached resource by a key. (synchronous version)
-   * @protected
    */
-  abstract _delete(key: string): void;
+  protected abstract _delete(key: string): void;
   /**
    * Reads cached resources by their keys. (synchronous version)
-   * @protected
    */
-  _getMany<T>(keys: string[]): Record<string, T | null>;
+  protected _getMany<T>(keys: string[]): Record<string, T | null>;
   /**
    * Writes resources into cache. (synchronous version)
-   * @protected
    */
-  _setMany<T>(data: Record<string, T>, options?: SetCacheOptions): void;
+  protected _setMany<T>(data: Record<string, T>, options?: SetCacheOptions): void;
   /**
    * Deletes many cached resources by their keys. (synchronous version)
-   * @protected
    */
-  _deleteMany(keys: string[]): void;
+  protected _deleteMany(keys: string[]): void;
   /**
    * Adds a listener that will be called when a cached item is disposed.
    *
    * @param listener The listener function to add.
-   * @protected
    */
-  _addDisposeListener(listener: LocalCacheDisposeListener): void;
+  protected _addDisposeListener(listener: LocalCacheDisposeListener): void;
+  /**
+   * Gets access to the internal synchronous methods.
+   * @experimental
+   */
+  get internal(): LocalCacheInternal;
+  /** @sealed **/
   get<T>(key: string): Promise<T | null>;
+  /** @sealed **/
   set<T>(key: string, value: T, options?: SetCacheOptions): Promise<void>;
+  /** @sealed **/
   delete(key: string): Promise<void>;
+  /** @sealed **/
   getMany<T>(keys: string[]): Promise<Record<string, T | null>>;
+  /** @sealed **/
   setMany<T>(data: Record<string, T>, options?: SetCacheOptions): Promise<void>;
+  /** @sealed **/
   deleteMany(keys: string[]): Promise<void>;
   protected onDispose(key: string, value: any, reason?: string): void;
 }
@@ -243,7 +260,7 @@ interface LocalMapCacheOptions extends BaseCacheOptions {
   /**
    * The underlying map.
    */
-  cache?: MapLike<string, any>;
+  map?: MapLike<string, any>;
   /**
    * The maximum size of the cache.
    * When not set, the cache can grow indefinitely.
@@ -268,7 +285,7 @@ interface MapLike<K, V> {
  * Once the limit of items is reached, the first inserted keys will be purged.
  */
 declare class LocalMapCache extends BaseLocalCache {
-  protected readonly cache: MapLike<string, any>;
+  protected readonly map: MapLike<string, any>;
   protected max: number;
   constructor(options?: LocalMapCacheOptions);
   setMany(data: Record<string, any>, options?: SetCacheOptions): Promise<void>;
@@ -277,6 +294,108 @@ declare class LocalMapCache extends BaseLocalCache {
   protected evict(length: number): void;
 }
 //#endregion
+//#region src/local/weak/index.d.ts
+interface WeakCacheOptions extends BaseCacheOptions {
+  /**
+   * The underlying cache. This must be an in-memory cache.
+   */
+  cache: BaseLocalCache;
+}
+type WeakValue = {
+  v: WeakRef<any>;
+  w: true;
+} | {
+  v: any;
+  w: false;
+};
+/**
+ * A cache layer that stores objects as weak references.
+ *
+ * When an object is garbage collected, its entry is automatically removed from the underlying cache.
+ *
+ * This implementation requires support for both `WeakRef` and `FinalizationRegistry`.
+ *
+ * @see https://caniuse.com/mdn-javascript_builtins_finalizationregistry
+ * @see https://caniuse.com/mdn-javascript_builtins_weakref
+ */
+declare class WeakCache extends BaseLocalCache {
+  protected readonly cache: BaseLocalCache;
+  protected readonly cacheInternal: LocalCacheInternal;
+  protected readonly registry: FinalizationRegistry<string>;
+  constructor(options: WeakCacheOptions);
+  protected onGarbageCollect: (key: string) => void;
+  protected onCacheDispose: (key: string, value: any, reason?: string) => void;
+  getOrLoad<T>(key: string, load: () => Promise<T>, options?: SetCacheOptions): Promise<T>;
+  /**
+   * Wraps the value in a WeakRef and registers it in the FinalizationRegistry if it's an object.
+   *
+   * @param key The key to reference the value in the FinalizationRegistry
+   * @param value The value to wrap
+   * @returns The wrapped value
+   */
+  protected wrapAndRegister(key: string, value: any): WeakValue;
+  /**
+   * Unwraps the value from a WeakRef if it's an object.
+   *
+   * @param data The data to unwrap
+   * @returns The unwrapped value
+   */
+  protected unwrap<T>(data: WeakValue | null): T | null;
+  /**
+   * Unregisters the value from the FinalizationRegistry if it's an object.
+   *
+   * @param value The value to unregister
+   */
+  protected unregister(value: WeakValue | null): void;
+  /**
+   * Unregisters the value associated with the given key from the FinalizationRegistry.
+   *
+   * @param key The key
+   */
+  protected unregisterByKey(key: string): void;
+}
+//#endregion
+//#region src/local/cloning/index.d.ts
+interface DeepCloningCacheOptions extends BaseCacheOptions {
+  /**
+   * The underlying cache. This must be an in-memory cache.
+   */
+  cache: BaseLocalCache;
+  /**
+   * The deep clone function to use.
+   *
+   * By default, it will try to use `structuredClone()` if available,
+   * otherwise it will use a JSON.parse/stringify-based implementation.
+   *
+   * @param data The data to deep clone
+   * @returns The cloned data
+   */
+  deepClone?: <T>(data: T) => T;
+}
+/**
+ * A cache layer that deep clones data when reading and writing.
+ *
+ * This is useful when you mutate the objects retrieved from cache,
+ * and you don't want them to also change in cache.
+ *
+ * Do not use this layer if you do not intend to mutate cached objects,
+ * as the cloning process adds unnecessary overhead.
+ */
+declare class DeepCloningCache extends BaseLocalCache {
+  protected readonly cache: BaseLocalCache;
+  protected readonly cacheInternal: LocalCacheInternal;
+  protected deepClone: <T>(data: T) => T;
+  constructor(options: DeepCloningCacheOptions);
+  protected _get<T>(key: string): T | null;
+  protected _set<T>(key: string, value: T, options?: SetCacheOptions): void;
+  protected _delete(key: string): void;
+  protected _getMany<T>(keys: string[]): Record<string, T | null>;
+  protected _setMany<T>(data: Record<string, T>, options?: SetCacheOptions): void;
+  protected _deleteMany(keys: string[]): void;
+  protected _addDisposeListener(listener: any): void;
+  getOrLoad<T>(key: string, load: () => Promise<T>, options?: SetCacheOptions): Promise<T>;
+}
+//#endregion
 //#region src/local/noop/index.d.ts
 /**
  * A cache implementation that does nothing.
@@ -830,5 +949,5 @@ declare class MetricsCollectingCache implements ICache {
   resetMetrics(): void;
 }
 //#endregion
-export { AsyncLazyCache, AsyncLazyCacheOptions, BaseCache, BaseCacheOptions, CacheMetrics, CacheTier, CoalescingCache, CoalescingCacheOptions, ExistingLRUCacheOptions, ExistingTTLCacheOptions, ICache, IORedisCache, IORedisCacheOptions, JitteringCache, JitteringCacheOptions, KeyTransformingCache, KeyTransformingCacheOptions, KeyvCache, KeyvCacheOptions, LocalLRUCache, LocalLRUCacheOptions, LocalMapCache, LocalMapCacheOptions, LocalTTLCache, LocalTTLCacheOptions, Logger, MapLike, MemJSCache, MemJSCacheOptions, MemcacheCache, MemcacheCacheOptions, MetricsCollectingCache, MetricsCollectingCacheOptions, NoOpCache, RedisCache, RedisCacheOptions, SWRCache, SWRCacheOptions, SetCacheOptions, TieredCache, TieredCacheOptions, ValkeyGlideCache, ValkeyGlideCacheOptions, WorkersKVCache, WorkersKVCacheOptions };
+export { AsyncLazyCache, AsyncLazyCacheOptions, BaseCache, BaseCacheOptions, BaseLocalCache, CacheMetrics, CacheTier, CoalescingCache, CoalescingCacheOptions, DeepCloningCache, DeepCloningCacheOptions, ExistingLRUCacheOptions, ExistingTTLCacheOptions, ICache, IORedisCache, IORedisCacheOptions, JitteringCache, JitteringCacheOptions, KeyTransformingCache, KeyTransformingCacheOptions, KeyvCache, KeyvCacheOptions, LocalCacheInternal, LocalLRUCache, LocalLRUCacheOptions, LocalMapCache, LocalMapCacheOptions, LocalTTLCache, LocalTTLCacheOptions, Logger, MapLike, MemJSCache, MemJSCacheOptions, MemcacheCache, MemcacheCacheOptions, MetricsCollectingCache, MetricsCollectingCacheOptions, NoOpCache, RedisCache, RedisCacheOptions, SWRCache, SWRCacheOptions, SetCacheOptions, TieredCache, TieredCacheOptions, ValkeyGlideCache, ValkeyGlideCacheOptions, WeakCache, WeakCacheOptions, WorkersKVCache, WorkersKVCacheOptions };
 //# sourceMappingURL=index.d.cts.map