@b9g/cache 0.1.0

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@b9g/cache",
+  "version": "0.1.0",
+  "description": "Universal Cache API implementation",
+  "keywords": [
+    "cache",
+    "storage",
+    "web-standards",
+    "universal"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "@b9g/libuild": "^0.1.10",
+    "bun-types": "latest"
+  },
+  "type": "module",
+  "types": "src/index.d.ts",
+  "module": "src/index.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./cache": {
+      "types": "./src/cache.d.ts",
+      "import": "./src/cache.js"
+    },
+    "./memory": {
+      "types": "./src/memory.d.ts",
+      "import": "./src/memory.js"
+    },
+    "./postmessage": {
+      "types": "./src/postmessage.d.ts",
+      "import": "./src/postmessage.js"
+    },
+    "./package.json": "./package.json",
+    "./cache.js": {
+      "types": "./src/cache.d.ts",
+      "import": "./src/cache.js"
+    },
+    "./cache-storage": {
+      "types": "./src/cache-storage.d.ts",
+      "import": "./src/cache-storage.js"
+    },
+    "./cache-storage.js": {
+      "types": "./src/cache-storage.d.ts",
+      "import": "./src/cache-storage.js"
+    },
+    "./index": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./index.js": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./memory.js": {
+      "types": "./src/memory.d.ts",
+      "import": "./src/memory.js"
+    },
+    "./postmessage.js": {
+      "types": "./src/postmessage.d.ts",
+      "import": "./src/postmessage.js"
+    }
+  }
+}

package/src/cache-storage.d.ts

@@ -0,0 +1,44 @@
+import type { Cache } from "./cache.js";
+/**
+ * Factory function for creating Cache instances based on cache name
+ */
+export type CacheFactory = (name: string) => Cache | Promise<Cache>;
+/**
+ * CustomCacheStorage implements CacheStorage interface with a configurable factory
+ * The factory function receives the cache name and can return different cache types
+ */
+export declare class CustomCacheStorage {
+    private factory;
+    private instances;
+    constructor(factory: CacheFactory);
+    /**
+     * Opens a cache with the given name
+     * Returns existing instance if already opened, otherwise creates a new one
+     */
+    open(name: string): Promise<Cache>;
+    /**
+     * Returns true if a cache with the given name exists (has been opened)
+     */
+    has(name: string): Promise<boolean>;
+    /**
+     * Deletes a cache with the given name
+     * Disposes of the instance if it exists
+     */
+    delete(name: string): Promise<boolean>;
+    /**
+     * Returns a list of all opened cache names
+     */
+    keys(): Promise<string[]>;
+    /**
+     * Get statistics about the cache storage
+     */
+    getStats(): {
+        openInstances: number;
+        cacheNames: string[];
+    };
+    /**
+     * Dispose of all open cache instances
+     * Useful for cleanup during shutdown
+     */
+    dispose(): Promise<void>;
+}

package/src/cache-storage.js

@@ -0,0 +1,74 @@
+/// <reference types="./cache-storage.d.ts" />
+// src/cache-storage.ts
+var CustomCacheStorage = class {
+  constructor(factory) {
+    this.factory = factory;
+  }
+  instances = /* @__PURE__ */ new Map();
+  /**
+   * Opens a cache with the given name
+   * Returns existing instance if already opened, otherwise creates a new one
+   */
+  async open(name) {
+    const existingInstance = this.instances.get(name);
+    if (existingInstance) {
+      return existingInstance;
+    }
+    const cache = await this.factory(name);
+    this.instances.set(name, cache);
+    return cache;
+  }
+  /**
+   * Returns true if a cache with the given name exists (has been opened)
+   */
+  async has(name) {
+    return this.instances.has(name);
+  }
+  /**
+   * Deletes a cache with the given name
+   * Disposes of the instance if it exists
+   */
+  async delete(name) {
+    const instance = this.instances.get(name);
+    if (instance) {
+      if (instance.dispose) {
+        await instance.dispose();
+      }
+      this.instances.delete(name);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Returns a list of all opened cache names
+   */
+  async keys() {
+    return Array.from(this.instances.keys());
+  }
+  /**
+   * Get statistics about the cache storage
+   */
+  getStats() {
+    return {
+      openInstances: this.instances.size,
+      cacheNames: Array.from(this.instances.keys())
+    };
+  }
+  /**
+   * Dispose of all open cache instances
+   * Useful for cleanup during shutdown
+   */
+  async dispose() {
+    const disposePromises = [];
+    for (const [_name, instance] of this.instances) {
+      if (instance.dispose) {
+        disposePromises.push(instance.dispose());
+      }
+    }
+    await Promise.all(disposePromises);
+    this.instances.clear();
+  }
+};
+export {
+  CustomCacheStorage
+};

package/src/cache.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Cache query options for matching requests
+ * Based on the Cache API specification
+ */
+export interface CacheQueryOptions {
+    /** Ignore the search portion of the request URL */
+    ignoreSearch?: boolean;
+    /** Ignore the request method */
+    ignoreMethod?: boolean;
+    /** Ignore the Vary header */
+    ignoreVary?: boolean;
+    /** Custom cache name for scoped operations */
+    cacheName?: string;
+}
+/**
+ * Abstract Cache class implementing the Cache API interface
+ * Provides shared implementations for add() and addAll() while requiring
+ * concrete implementations to handle the core storage operations
+ */
+export declare abstract class Cache {
+    /**
+     * Returns a Promise that resolves to the response associated with the first matching request
+     */
+    abstract match(request: Request, options?: CacheQueryOptions): Promise<Response | undefined>;
+    /**
+     * Puts a request/response pair into the cache
+     */
+    abstract put(request: Request, response: Response): Promise<void>;
+    /**
+     * Finds the cache entry whose key is the request, and if found, deletes it and returns true
+     */
+    abstract delete(request: Request, options?: CacheQueryOptions): Promise<boolean>;
+    /**
+     * Returns a Promise that resolves to an array of cache keys (Request objects)
+     */
+    abstract keys(request?: Request, options?: CacheQueryOptions): Promise<Request[]>;
+    /**
+     * Takes a URL, retrieves it and adds the resulting response object to the cache
+     * Shared implementation using fetch() and put()
+     */
+    add(request: Request): Promise<void>;
+    /**
+     * Takes an array of URLs, retrieves them, and adds the resulting response objects to the cache
+     * Shared implementation using add()
+     */
+    addAll(requests: Request[]): Promise<void>;
+    /**
+     * Returns a Promise that resolves to an array of all matching responses
+     * Default implementation using keys() and match() - can be overridden for efficiency
+     */
+    matchAll(request?: Request, options?: CacheQueryOptions): Promise<Response[]>;
+    /**
+     * Optional cleanup method for implementations that need resource disposal
+     */
+    dispose?(): Promise<void>;
+}
+/**
+ * Generate a cache key from a Request object
+ * Normalizes the request for consistent cache key generation
+ */
+export declare function generateCacheKey(request: Request, options?: CacheQueryOptions): string;
+/**
+ * Clone a Response object for storage
+ * Responses can only be consumed once, so we need to clone them for caching
+ */
+export declare function cloneResponse(response: Response): Promise<Response>;

package/src/cache.js

@@ -0,0 +1,55 @@
+/// <reference types="./cache.d.ts" />
+// src/cache.ts
+var Cache = class {
+  /**
+   * Takes a URL, retrieves it and adds the resulting response object to the cache
+   * Shared implementation using fetch() and put()
+   */
+  async add(request) {
+    const response = await fetch(request);
+    if (!response.ok) {
+      throw new TypeError(
+        `Failed to fetch ${request.url}: ${response.status} ${response.statusText}`
+      );
+    }
+    await this.put(request, response);
+  }
+  /**
+   * Takes an array of URLs, retrieves them, and adds the resulting response objects to the cache
+   * Shared implementation using add()
+   */
+  async addAll(requests) {
+    await Promise.all(requests.map((request) => this.add(request)));
+  }
+  /**
+   * Returns a Promise that resolves to an array of all matching responses
+   * Default implementation using keys() and match() - can be overridden for efficiency
+   */
+  async matchAll(request, options) {
+    const keys = await this.keys(request, options);
+    const responses = [];
+    for (const key of keys) {
+      const response = await this.match(key, options);
+      if (response) {
+        responses.push(response);
+      }
+    }
+    return responses;
+  }
+};
+function generateCacheKey(request, options) {
+  const url = new URL(request.url);
+  if (options?.ignoreSearch) {
+    url.search = "";
+  }
+  const method = options?.ignoreMethod ? "GET" : request.method;
+  return `${method}:${url.href}`;
+}
+async function cloneResponse(response) {
+  return response.clone();
+}
+export {
+  Cache,
+  cloneResponse,
+  generateCacheKey
+};

package/src/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @b9g/cache - Universal Cache API implementation
+ *
+ * Provides HTTP-aware caching with PostMessage coordination for worker environments
+ */
+export { Cache, type CacheQueryOptions, generateCacheKey, cloneResponse } from "./cache.js";
+export { CustomCacheStorage, type CacheFactory } from "./cache-storage.js";
+export { MemoryCache, MemoryCacheManager, type MemoryCacheOptions } from "./memory.js";
+export { PostMessageCache, type PostMessageCacheOptions } from "./postmessage.js";

package/src/index.js

@@ -0,0 +1,15 @@
+/// <reference types="./index.d.ts" />
+// src/index.ts
+import { Cache, generateCacheKey, cloneResponse } from "./cache.js";
+import { CustomCacheStorage } from "./cache-storage.js";
+import { MemoryCache, MemoryCacheManager } from "./memory.js";
+import { PostMessageCache } from "./postmessage.js";
+export {
+  Cache,
+  CustomCacheStorage,
+  MemoryCache,
+  MemoryCacheManager,
+  PostMessageCache,
+  cloneResponse,
+  generateCacheKey
+};

package/src/memory.d.ts

@@ -0,0 +1,119 @@
+import { Cache, type CacheQueryOptions } from "./cache.js";
+/**
+ * Configuration options for MemoryCache
+ */
+export interface MemoryCacheOptions {
+    /** Maximum number of entries to store */
+    maxEntries?: number;
+    /** Maximum age of entries in milliseconds */
+    maxAge?: number;
+}
+/**
+ * In-memory cache implementation using Map for storage
+ * Supports LRU eviction and TTL expiration
+ */
+export declare class MemoryCache extends Cache {
+    private name;
+    private options;
+    private storage;
+    private accessOrder;
+    private accessCounter;
+    constructor(name: string, options?: MemoryCacheOptions);
+    /**
+     * Find a cached response for the given request
+     */
+    match(request: Request, options?: CacheQueryOptions): Promise<Response | undefined>;
+    /**
+     * Store a request/response pair in the cache
+     */
+    put(request: Request, response: Response): Promise<void>;
+    /**
+     * Delete matching entries from the cache
+     */
+    delete(request: Request, options?: CacheQueryOptions): Promise<boolean>;
+    /**
+     * Get all stored requests, optionally filtered by a request pattern
+     */
+    keys(request?: Request, options?: CacheQueryOptions): Promise<Request[]>;
+    /**
+     * Clear all entries from the cache
+     */
+    clear(): Promise<void>;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        name: string;
+        size: number;
+        maxEntries: number;
+        maxAge: number;
+        hitRate: number;
+    };
+    /**
+     * Dispose of the cache and clean up resources
+     */
+    dispose(): Promise<void>;
+    /**
+     * Check if a cache entry has expired
+     */
+    private isExpired;
+    /**
+     * Check if a response should be cached
+     */
+    private isCacheable;
+    /**
+     * Enforce maximum entry limits using LRU eviction
+     */
+    private enforceMaxEntries;
+}
+/**
+ * Memory Cache Manager for Main Thread
+ *
+ * Coordinates MemoryCache operations across Worker threads by managing
+ * shared MemoryCache instances and handling postMessage requests.
+ *
+ * Only MemoryCache needs coordination since it stores data in process memory.
+ * Other cache types can be used directly by workers without coordination.
+ */
+import type { Worker } from "worker_threads";
+interface CacheMessage {
+    type: string;
+    requestId: string;
+    cacheName: string;
+    request?: SerializedRequest;
+    response?: SerializedResponse;
+    options?: any;
+}
+interface SerializedRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+}
+interface SerializedResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+}
+export declare class MemoryCacheManager {
+    private memoryCaches;
+    /**
+     * Handle memory cache-related message from a Worker
+     */
+    handleMessage(worker: Worker, message: CacheMessage): Promise<void>;
+    /**
+     * Get or create a MemoryCache instance
+     */
+    private getMemoryCache;
+    private handleMatch;
+    private handlePut;
+    private handleDelete;
+    private handleKeys;
+    private handleClear;
+    /**
+     * Dispose of all memory caches
+     */
+    dispose(): Promise<void>;
+}
+export {};

package/src/memory.js

@@ -0,0 +1,294 @@
+/// <reference types="./memory.d.ts" />
+// src/memory.ts
+import {
+  Cache,
+  generateCacheKey,
+  cloneResponse
+} from "./cache.js";
+var MemoryCache = class extends Cache {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.options = options;
+  }
+  storage = /* @__PURE__ */ new Map();
+  accessOrder = /* @__PURE__ */ new Map();
+  // For LRU tracking
+  accessCounter = 0;
+  /**
+   * Find a cached response for the given request
+   */
+  async match(request, options) {
+    const key = generateCacheKey(request, options);
+    const entry = this.storage.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    if (this.isExpired(entry)) {
+      this.storage.delete(key);
+      this.accessOrder.delete(key);
+      return void 0;
+    }
+    this.accessOrder.set(key, ++this.accessCounter);
+    return cloneResponse(entry.response);
+  }
+  /**
+   * Store a request/response pair in the cache
+   */
+  async put(request, response) {
+    const key = generateCacheKey(request);
+    if (!this.isCacheable(response)) {
+      return;
+    }
+    const clonedRequest = request.clone();
+    const clonedResponse = cloneResponse(response);
+    const entry = {
+      request: clonedRequest,
+      response: clonedResponse,
+      timestamp: Date.now()
+    };
+    this.storage.set(key, entry);
+    this.accessOrder.set(key, ++this.accessCounter);
+    this.enforceMaxEntries();
+  }
+  /**
+   * Delete matching entries from the cache
+   */
+  async delete(request, options) {
+    const key = generateCacheKey(request, options);
+    const deleted = this.storage.delete(key);
+    if (deleted) {
+      this.accessOrder.delete(key);
+    }
+    return deleted;
+  }
+  /**
+   * Get all stored requests, optionally filtered by a request pattern
+   */
+  async keys(request, options) {
+    const keys = [];
+    for (const [_, entry] of this.storage) {
+      if (this.isExpired(entry)) {
+        continue;
+      }
+      if (!request) {
+        keys.push(entry.request.clone());
+        continue;
+      }
+      const entryKey = generateCacheKey(entry.request, options);
+      const filterKey = generateCacheKey(request, options);
+      if (entryKey === filterKey) {
+        keys.push(entry.request.clone());
+      }
+    }
+    return keys;
+  }
+  /**
+   * Clear all entries from the cache
+   */
+  async clear() {
+    this.storage.clear();
+    this.accessOrder.clear();
+    this.accessCounter = 0;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return {
+      name: this.name,
+      size: this.storage.size,
+      maxEntries: this.options.maxEntries,
+      maxAge: this.options.maxAge,
+      hitRate: 0
+      // Could be implemented with additional tracking
+    };
+  }
+  /**
+   * Dispose of the cache and clean up resources
+   */
+  async dispose() {
+    await this.clear();
+  }
+  /**
+   * Check if a cache entry has expired
+   */
+  isExpired(entry) {
+    if (!this.options.maxAge) {
+      return false;
+    }
+    return Date.now() - entry.timestamp > this.options.maxAge;
+  }
+  /**
+   * Check if a response should be cached
+   */
+  isCacheable(response) {
+    if (!response.ok) {
+      return false;
+    }
+    const cacheControl = response.headers.get("cache-control");
+    if (cacheControl) {
+      if (cacheControl.includes("no-cache") || cacheControl.includes("no-store")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Enforce maximum entry limits using LRU eviction
+   */
+  enforceMaxEntries() {
+    if (!this.options.maxEntries || this.storage.size <= this.options.maxEntries) {
+      return;
+    }
+    const entries = Array.from(this.accessOrder.entries()).sort((a, b) => a[1] - b[1]);
+    const toRemove = this.storage.size - this.options.maxEntries;
+    for (let i = 0; i < toRemove; i++) {
+      const [key] = entries[i];
+      this.storage.delete(key);
+      this.accessOrder.delete(key);
+    }
+  }
+};
+var MemoryCacheManager = class {
+  memoryCaches = /* @__PURE__ */ new Map();
+  /**
+   * Handle memory cache-related message from a Worker
+   */
+  async handleMessage(worker, message) {
+    const { type, requestId } = message;
+    try {
+      let result;
+      switch (type) {
+        case "cache:match":
+          result = await this.handleMatch(message);
+          break;
+        case "cache:put":
+          result = await this.handlePut(message);
+          break;
+        case "cache:delete":
+          result = await this.handleDelete(message);
+          break;
+        case "cache:keys":
+          result = await this.handleKeys(message);
+          break;
+        case "cache:clear":
+          result = await this.handleClear(message);
+          break;
+        default:
+          throw new Error(`Unknown cache operation: ${type}`);
+      }
+      worker.postMessage({
+        type: "cache:response",
+        requestId,
+        result
+      });
+    } catch (error) {
+      worker.postMessage({
+        type: "cache:error",
+        requestId,
+        error: error.message
+      });
+    }
+  }
+  /**
+   * Get or create a MemoryCache instance
+   */
+  getMemoryCache(name, options) {
+    if (!this.memoryCaches.has(name)) {
+      this.memoryCaches.set(name, new MemoryCache(name, options));
+    }
+    return this.memoryCaches.get(name);
+  }
+  async handleMatch(message) {
+    const { cacheName, request, options } = message;
+    if (!request)
+      throw new Error("Request is required for match operation");
+    const cache = this.getMemoryCache(cacheName);
+    const req = new Request(request.url, {
+      method: request.method,
+      headers: request.headers,
+      body: request.body
+    });
+    const response = await cache.match(req, options);
+    if (!response) {
+      return void 0;
+    }
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+      body: await response.text()
+    };
+  }
+  async handlePut(message) {
+    const { cacheName, request, response } = message;
+    if (!request || !response)
+      throw new Error("Request and response are required for put operation");
+    const cache = this.getMemoryCache(cacheName);
+    const req = new Request(request.url, {
+      method: request.method,
+      headers: request.headers,
+      body: request.body
+    });
+    const res = new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    await cache.put(req, res);
+    return true;
+  }
+  async handleDelete(message) {
+    const { cacheName, request, options } = message;
+    if (!request)
+      throw new Error("Request is required for delete operation");
+    const cache = this.getMemoryCache(cacheName);
+    const req = new Request(request.url, {
+      method: request.method,
+      headers: request.headers,
+      body: request.body
+    });
+    return await cache.delete(req, options);
+  }
+  async handleKeys(message) {
+    const { cacheName, request, options } = message;
+    const cache = this.getMemoryCache(cacheName);
+    let req;
+    if (request) {
+      req = new Request(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body
+      });
+    }
+    const keys = await cache.keys(req, options);
+    return keys.map((r) => ({
+      url: r.url,
+      method: r.method,
+      headers: Object.fromEntries(r.headers.entries()),
+      body: void 0
+      // Keys typically don't need body
+    }));
+  }
+  async handleClear(message) {
+    const { cacheName } = message;
+    const cache = this.getMemoryCache(cacheName);
+    await cache.clear();
+    return true;
+  }
+  /**
+   * Dispose of all memory caches
+   */
+  async dispose() {
+    const disposePromises = Array.from(this.memoryCaches.values()).map(
+      (cache) => cache.dispose()
+    );
+    await Promise.all(disposePromises);
+    this.memoryCaches.clear();
+  }
+};
+export {
+  MemoryCache,
+  MemoryCacheManager
+};

package/src/postmessage.d.ts

@@ -0,0 +1,29 @@
+import { Cache, type CacheQueryOptions } from "./cache.js";
+/**
+ * Configuration options for PostMessageCache
+ */
+export interface PostMessageCacheOptions {
+    /** Maximum number of entries to store */
+    maxEntries?: number;
+    /** Maximum age of entries in milliseconds */
+    maxAge?: number;
+}
+/**
+ * Worker-side cache that forwards operations to main thread via postMessage
+ * Only used for MemoryCache in multi-worker environments
+ */
+export declare class PostMessageCache extends Cache {
+    private name;
+    private options;
+    private requestId;
+    private pendingRequests;
+    constructor(name: string, options?: PostMessageCacheOptions);
+    private handleResponse;
+    private sendRequest;
+    match(request: Request, options?: CacheQueryOptions): Promise<Response | undefined>;
+    put(request: Request, response: Response): Promise<void>;
+    delete(request: Request, options?: CacheQueryOptions): Promise<boolean>;
+    keys(request?: Request, options?: CacheQueryOptions): Promise<Request[]>;
+    clear(): Promise<void>;
+    dispose(): Promise<void>;
+}

package/src/postmessage.js

@@ -0,0 +1,141 @@
+/// <reference types="./postmessage.d.ts" />
+// src/postmessage.ts
+import { Cache } from "./cache.js";
+import { parentPort, isMainThread } from "worker_threads";
+var PostMessageCache = class extends Cache {
+  constructor(name, options = {}) {
+    super();
+    this.name = name;
+    this.options = options;
+    if (isMainThread) {
+      throw new Error(
+        "PostMessageCache should only be used in worker threads"
+      );
+    }
+    if (parentPort) {
+      parentPort.on("message", (message) => {
+        if (message.type === "cache:response" || message.type === "cache:error") {
+          this.handleResponse(message);
+        }
+      });
+    }
+  }
+  requestId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  handleResponse(message) {
+    const pending = this.pendingRequests.get(message.requestId);
+    if (pending) {
+      this.pendingRequests.delete(message.requestId);
+      if (message.type === "cache:error") {
+        pending.reject(new Error(message.error));
+      } else {
+        pending.resolve(message.result);
+      }
+    }
+  }
+  async sendRequest(type, data) {
+    if (!parentPort) {
+      throw new Error(
+        "PostMessageCache can only be used in worker threads"
+      );
+    }
+    const requestId = ++this.requestId;
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(requestId, { resolve, reject });
+      parentPort.postMessage({
+        type,
+        requestId,
+        cacheName: this.name,
+        ...data
+      });
+      setTimeout(() => {
+        if (this.pendingRequests.has(requestId)) {
+          this.pendingRequests.delete(requestId);
+          reject(new Error("Cache operation timeout"));
+        }
+      }, 3e4);
+    });
+  }
+  async match(request, options) {
+    const serializedRequest = {
+      url: request.url,
+      method: request.method,
+      headers: Object.fromEntries(request.headers.entries()),
+      body: request.method !== "GET" && request.method !== "HEAD" ? await request.text() : void 0
+    };
+    const response = await this.sendRequest("cache:match", {
+      request: serializedRequest,
+      options
+    });
+    if (!response) {
+      return void 0;
+    }
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  async put(request, response) {
+    const serializedRequest = {
+      url: request.url,
+      method: request.method,
+      headers: Object.fromEntries(request.headers.entries()),
+      body: request.method !== "GET" && request.method !== "HEAD" ? await request.clone().text() : void 0
+    };
+    const serializedResponse = {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+      body: await response.clone().text()
+    };
+    await this.sendRequest("cache:put", {
+      request: serializedRequest,
+      response: serializedResponse
+    });
+  }
+  async delete(request, options) {
+    const serializedRequest = {
+      url: request.url,
+      method: request.method,
+      headers: Object.fromEntries(request.headers.entries()),
+      body: request.method !== "GET" && request.method !== "HEAD" ? await request.text() : void 0
+    };
+    return await this.sendRequest("cache:delete", {
+      request: serializedRequest,
+      options
+    });
+  }
+  async keys(request, options) {
+    let serializedRequest;
+    if (request) {
+      serializedRequest = {
+        url: request.url,
+        method: request.method,
+        headers: Object.fromEntries(request.headers.entries()),
+        body: request.method !== "GET" && request.method !== "HEAD" ? await request.text() : void 0
+      };
+    }
+    const keys = await this.sendRequest("cache:keys", {
+      request: serializedRequest,
+      options
+    });
+    return keys.map(
+      (req) => new Request(req.url, {
+        method: req.method,
+        headers: req.headers,
+        body: req.body
+      })
+    );
+  }
+  async clear() {
+    await this.sendRequest("cache:clear", {});
+  }
+  async dispose() {
+    await this.clear();
+    this.pendingRequests.clear();
+  }
+};
+export {
+  PostMessageCache
+};