satoru-render 1.0.11 → 1.0.13

package/dist/core.js

@@ -1,4 +1,12 @@
 import { LogLevel } from "./log-level.js";
+export const DIAGNOSTIC_CODES = {
+    LIMIT_TIMEOUT: "LIMIT_TIMEOUT",
+    LIMIT_RESOURCE_SIZE: "LIMIT_RESOURCE_SIZE",
+    LIMIT_TOTAL_SIZE: "LIMIT_TOTAL_SIZE",
+    LIMIT_RESOURCE_COUNT: "LIMIT_RESOURCE_COUNT",
+    LIMIT_PROTOCOL_BLOCKED: "LIMIT_PROTOCOL_BLOCKED",
+    LIMIT_HOST_BLOCKED: "LIMIT_HOST_BLOCKED",
+};
 const emojiUrl = "https://cdn.jsdelivr.net/npm/@fontsource/noto-color-emoji/files/noto-color-emoji-emoji-400-normal.woff2";
 export const DEFAULT_FONT_MAP = {
     "sans-serif": "https://fonts.googleapis.com/css2?family=Noto+Sans+JP",
@@ -312,40 +320,32 @@ export class SatoruBase {
     }
     async render(options) {
         let { format = "svg", value, url, baseUrl } = options;
-        const profileEnabled = options.profile === true;
+        const profileEnabled = options.profile === true || options.diagnostics === true;
         const profile = {};
         const now = () => typeof performance !== "undefined" && performance.now
             ? performance.now()
             : Date.now();
+        const startTime = now();
+        const limits = options.limits ?? {};
+        let totalResourceBytes = 0;
+        let resourceCount = 0;
         const addProfile = (name, elapsed) => {
             if (!profileEnabled)
                 return;
             profile[name] = (profile[name] ?? 0) + elapsed;
         };
-        if (format === "pdf" && Array.isArray(value) && value.length > 1) {
-            const pagePdfs = [];
-            const SatoruClass = this.constructor;
-            for (const html of value) {
-                const engine = await SatoruClass.create();
-                const pagePdf = await engine.render({
-                    ...options,
-                    value: html,
-                    format: "pdf",
-                });
-                pagePdfs.push(pagePdf);
-            }
-            const mod = await this.getModule();
-            const instancePtr = mod.create_instance();
-            try {
-                const result = mod.merge_pdfs(instancePtr, pagePdfs);
-                if (!result)
-                    return new Uint8Array();
-                return new Uint8Array(result);
-            }
-            finally {
-                mod.destroy_instance(instancePtr);
-            }
-        }
+        const diagnosticsReport = options.diagnostics ? {
+            version: 1,
+            format: format,
+            width: options.width,
+            height: options.height,
+            mediaType: options.mediaType ?? "screen",
+            timings: profile,
+            resources: [],
+            fonts: [],
+            warnings: [],
+            errors: [],
+        } : null;
         let mod = await this.getModule();
         const { width, height = 0, fonts, images, css, logLevel, onLog } = options;
         if (!options.userAgent) {
@@ -370,6 +370,7 @@ export class SatoruBase {
         this.currentFontMap = options.fontMap ?? DEFAULT_FONT_MAP;
         const instancePtr = mod.create_instance();
         mod.set_font_map(instancePtr, this.currentFontMap);
+        mod.set_collect_profile_enabled(instancePtr, profileEnabled);
         try {
             const defaultResolver = (r) => this.resolveDefaultResource(r, baseUrl, options.userAgent);
             const resolver = options.resolveResource
@@ -380,12 +381,107 @@ export class SatoruBase {
             const cachedResolver = async (r) => {
                 const cacheKey = `${r.type}:${r.url}:${r.characters ?? ""}`;
                 const cached = this.resourceCache.get(cacheKey);
+                let resourceDiag;
+                if (diagnosticsReport) {
+                    resourceDiag = {
+                        type: r.type,
+                        url: r.url,
+                        name: r.name,
+                        status: "pending",
+                    };
+                    diagnosticsReport.resources.push(resourceDiag);
+                }
                 if (cached) {
                     addProfile("resourceCacheHitsCount", 1);
+                    if (resourceDiag) {
+                        resourceDiag.status = "loaded";
+                        if (cached instanceof Uint8Array) {
+                            resourceDiag.bytes = cached.byteLength;
+                        }
+                    }
                     return cached;
                 }
+                // Apply Limits
+                if (limits.maxResourceCount && resourceCount >= limits.maxResourceCount) {
+                    const msg = `Maximum resource count (${limits.maxResourceCount}) exceeded`;
+                    if (resourceDiag) {
+                        resourceDiag.status = "skipped";
+                        resourceDiag.reason = msg;
+                        diagnosticsReport?.errors.push({ code: DIAGNOSTIC_CODES.LIMIT_RESOURCE_COUNT, message: msg, source: r.url });
+                    }
+                    return null;
+                }
+                if (limits.allowedProtocols || limits.allowedHosts || limits.blockedHosts) {
+                    try {
+                        const urlObj = new URL(r.url);
+                        if (limits.allowedProtocols && !limits.allowedProtocols.includes(urlObj.protocol)) {
+                            const msg = `Protocol ${urlObj.protocol} is blocked`;
+                            if (resourceDiag) {
+                                resourceDiag.status = "skipped";
+                                resourceDiag.reason = msg;
+                                diagnosticsReport?.errors.push({ code: DIAGNOSTIC_CODES.LIMIT_PROTOCOL_BLOCKED, message: msg, source: r.url });
+                            }
+                            return null;
+                        }
+                        if (limits.allowedHosts && !limits.allowedHosts.includes(urlObj.hostname)) {
+                            const msg = `Host ${urlObj.hostname} is not in allowed list`;
+                            if (resourceDiag) {
+                                resourceDiag.status = "skipped";
+                                resourceDiag.reason = msg;
+                                diagnosticsReport?.errors.push({ code: DIAGNOSTIC_CODES.LIMIT_HOST_BLOCKED, message: msg, source: r.url });
+                            }
+                            return null;
+                        }
+                        if (limits.blockedHosts && limits.blockedHosts.includes(urlObj.hostname)) {
+                            const msg = `Host ${urlObj.hostname} is blocked`;
+                            if (resourceDiag) {
+                                resourceDiag.status = "skipped";
+                                resourceDiag.reason = msg;
+                                diagnosticsReport?.errors.push({ code: DIAGNOSTIC_CODES.LIMIT_HOST_BLOCKED, message: msg, source: r.url });
+                            }
+                            return null;
+                        }
+                    }
+                    catch (e) {
+                        // Invalid URL - skip protocol/host checks for local/relative paths
+                    }
+                }
                 const resolveStart = now();
-                const result = await resolver(r);
+                let result = null;
+                try {
+                    result = await resolver(r);
+                    if (resourceDiag) {
+                        resourceDiag.status = result ? "loaded" : "failed";
+                        if (result) {
+                            const bytes = result instanceof Uint8Array ? result.byteLength :
+                                result.buffer ? result.byteLength :
+                                    ("css" in result) ? result.css.byteLength + result.fonts.reduce((acc, f) => acc + f.data.byteLength, 0) : 0;
+                            resourceDiag.bytes = bytes;
+                            if (limits.maxResourceBytes && bytes > limits.maxResourceBytes) {
+                                const msg = `Resource size (${bytes} bytes) exceeds limit (${limits.maxResourceBytes})`;
+                                resourceDiag.status = "skipped";
+                                resourceDiag.reason = msg;
+                                diagnosticsReport?.errors.push({ code: DIAGNOSTIC_CODES.LIMIT_RESOURCE_SIZE, message: msg, source: r.url });
+                                return null;
+                            }
+                            if (limits.maxTotalResourceBytes && totalResourceBytes + bytes > limits.maxTotalResourceBytes) {
+                                const msg = `Total resource size exceeds limit (${limits.maxTotalResourceBytes})`;
+                                resourceDiag.status = "skipped";
+                                resourceDiag.reason = msg;
+                                diagnosticsReport?.errors.push({ code: DIAGNOSTIC_CODES.LIMIT_TOTAL_SIZE, message: msg, source: r.url });
+                                return null;
+                            }
+                            totalResourceBytes += bytes;
+                            resourceCount++;
+                        }
+                    }
+                }
+                catch (e) {
+                    if (resourceDiag) {
+                        resourceDiag.status = "failed";
+                        resourceDiag.reason = e.message || String(e);
+                    }
+                }
                 addProfile("resolveResources", now() - resolveStart);
                 if (result) {
                     if (result instanceof Uint8Array) {
@@ -441,14 +537,36 @@ export class SatoruBase {
             };
             const inputHtmls = Array.isArray(value) ? value : [value];
             const processedHtmls = [];
+            const utf8Decoder = new TextDecoder();
+            const utf8Encoder = new TextEncoder();
             const resolvedResources = new Set();
             for (const rawHtml of inputHtmls) {
                 let processedHtml = rawHtml;
                 for (let i = 0; i < 10; i++) {
+                    if (options.signal?.aborted) {
+                        throw new Error("Render aborted");
+                    }
+                    if (typeof limits.timeoutMs !== "undefined" && now() - startTime >= limits.timeoutMs) {
+                        const msg = `Render timed out after ${limits.timeoutMs}ms`;
+                        diagnosticsReport?.errors.push({ code: DIAGNOSTIC_CODES.LIMIT_TIMEOUT, message: msg });
+                        throw new Error(msg);
+                    }
                     addProfile("collectResourcesCount", 1);
                     const collectStart = now();
                     mod.collect_resources(instancePtr, processedHtml, width, height, options.mediaType === "print" ? 1 : 0);
-                    addProfile("collectResources", now() - collectStart);
+                    const collectElapsed = now() - collectStart;
+                    addProfile("collectResources", collectElapsed);
+                    addProfile(`collectResourcesRound${i + 1}`, collectElapsed);
+                    if (profileEnabled) {
+                        try {
+                            const collectProfile = JSON.parse(mod.get_collect_profile(instancePtr));
+                            for (const [key, value] of Object.entries(collectProfile)) {
+                                addProfile(key, value);
+                                addProfile(`${key}Round${i + 1}`, value);
+                            }
+                        }
+                        catch { }
+                    }
                     const pendingStart = now();
                     const binary = mod.get_pending_resources(instancePtr);
                     addProfile("getPendingResources", now() - pendingStart);
@@ -465,15 +583,15 @@ export class SatoruBase {
                         const redraw_on_ready = view.getUint8(offset++) !== 0;
                         const urlLen = view.getUint32(offset, true);
                         offset += 4;
-                        const url = new TextDecoder().decode(new Uint8Array(binary.buffer, binary.byteOffset + offset, urlLen));
+                        const url = utf8Decoder.decode(new Uint8Array(binary.buffer, binary.byteOffset + offset, urlLen));
                         offset += urlLen;
                         const nameLen = view.getUint32(offset, true);
                         offset += 4;
-                        const name = new TextDecoder().decode(new Uint8Array(binary.buffer, binary.byteOffset + offset, nameLen));
+                        const name = utf8Decoder.decode(new Uint8Array(binary.buffer, binary.byteOffset + offset, nameLen));
                         offset += nameLen;
                         const charsLen = view.getUint32(offset, true);
                         offset += 4;
-                        const characters = new TextDecoder().decode(new Uint8Array(binary.buffer, binary.byteOffset + offset, charsLen));
+                        const characters = utf8Decoder.decode(new Uint8Array(binary.buffer, binary.byteOffset + offset, charsLen));
                         offset += charsLen;
                         let type = "font";
                         if (typeInt === 2)
@@ -484,11 +602,31 @@ export class SatoruBase {
                     }
                     const pending = resources.filter((r) => {
                         const key = `${r.type}:${r.url}:${r.characters ?? ""}`;
+                        if (r.type === "font" && resolvedResources.has(`font:${r.url}:`)) {
+                            return false;
+                        }
                         return !resolvedResources.has(key);
                     });
+                    addProfile("pendingResourcesCount", pending.length);
+                    addProfile(`pendingResourcesRound${i + 1}Count`, pending.length);
+                    for (const r of pending) {
+                        if (r.type === "font") {
+                            addProfile("pendingFontResourcesCount", 1);
+                            addProfile(`pendingFontResourcesRound${i + 1}Count`, 1);
+                        }
+                        else if (r.type === "css") {
+                            addProfile("pendingCssResourcesCount", 1);
+                            addProfile(`pendingCssResourcesRound${i + 1}Count`, 1);
+                        }
+                        else if (r.type === "image") {
+                            addProfile("pendingImageResourcesCount", 1);
+                            addProfile(`pendingImageResourcesRound${i + 1}Count`, 1);
+                        }
+                    }
                     addProfile("parsePendingResources", now() - parseStart);
                     if (pending.length === 0)
                         break;
+                    addProfile("pendingResourceRoundsCount", 1);
                     const loadStart = now();
                     await Promise.all(pending.map(async (r) => {
                         try {
@@ -497,6 +635,9 @@ export class SatoruBase {
                             }
                             const key = `${r.type}:${r.url}:${r.characters ?? ""}`;
                             resolvedResources.add(key);
+                            if (r.type === "font") {
+                                resolvedResources.add(`font:${r.url}:`);
+                            }
                             const data = await cachedResolver({ ...r });
                             if (!data)
                                 return;
@@ -523,7 +664,7 @@ export class SatoruBase {
                                     ? data
                                     : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
                                 if (r.type === "css") {
-                                    const cssText = new TextDecoder().decode(finalUint8);
+                                    const cssText = utf8Decoder.decode(finalUint8);
                                     const isAbsolute = /^[a-z][a-z0-9+.-]*:/i.test(r.url) ||
                                         r.url.startsWith("data:");
                                     let cssBaseUrl = r.url;
@@ -551,7 +692,7 @@ export class SatoruBase {
                                                 return match;
                                             }
                                         });
-                                        finalUint8 = new TextEncoder().encode(rewrittenCss);
+                                        finalUint8 = utf8Encoder.encode(rewrittenCss);
                                     }
                                 }
                                 await loadResourceData(r, finalUint8);
@@ -586,6 +727,14 @@ export class SatoruBase {
                 pdf: 3,
             };
             const renderStart = now();
+            if (options.signal?.aborted) {
+                throw new Error("Render aborted");
+            }
+            if (typeof limits.timeoutMs !== "undefined" && now() - startTime >= limits.timeoutMs) {
+                const msg = `Render timed out after ${limits.timeoutMs}ms`;
+                diagnosticsReport?.errors.push({ code: DIAGNOSTIC_CODES.LIMIT_TIMEOUT, message: msg });
+                throw new Error(msg);
+            }
             const result = (processedHtmls.length === 1)
                 ? mod.render_from_state(instancePtr, width, height, formatMap[format] ?? 0, {
                     svgTextToPaths: options.textToPaths ?? true,
@@ -600,6 +749,18 @@ export class SatoruBase {
                     fitPositionY: options.fitPosition?.y ?? 0.5,
                     backgroundColor: this.parseColor(options.backgroundColor),
                     mediaType: options.mediaType === "print" ? 1 : 0,
+                    pdfTitle: options.pdfTitle ?? "",
+                    pdfAuthor: options.pdfAuthor ?? "",
+                    pdfSubject: options.pdfSubject ?? "",
+                    pdfKeywords: options.pdfKeywords ?? "",
+                    pdfCreator: options.pdfCreator ?? "",
+                    pdfProducer: options.pdfProducer ?? "",
+                    pdfMarginTop: options.pdfMargin?.top ?? 0,
+                    pdfMarginRight: options.pdfMargin?.right ?? 0,
+                    pdfMarginBottom: options.pdfMargin?.bottom ?? 0,
+                    pdfMarginLeft: options.pdfMargin?.left ?? 0,
+                    pdfHeader: options.pdfHeader ?? "",
+                    pdfFooter: options.pdfFooter ?? "",
                 })
                 : mod.render(instancePtr, processedHtmls, width, height, formatMap[format] ?? 0, {
                     svgTextToPaths: options.textToPaths ?? true,
@@ -614,25 +775,58 @@ export class SatoruBase {
                     fitPositionY: options.fitPosition?.y ?? 0.5,
                     backgroundColor: this.parseColor(options.backgroundColor),
                     mediaType: options.mediaType === "print" ? 1 : 0,
+                    pdfTitle: options.pdfTitle ?? "",
+                    pdfAuthor: options.pdfAuthor ?? "",
+                    pdfSubject: options.pdfSubject ?? "",
+                    pdfKeywords: options.pdfKeywords ?? "",
+                    pdfCreator: options.pdfCreator ?? "",
+                    pdfProducer: options.pdfProducer ?? "",
+                    pdfMarginTop: options.pdfMargin?.top ?? 0,
+                    pdfMarginRight: options.pdfMargin?.right ?? 0,
+                    pdfMarginBottom: options.pdfMargin?.bottom ?? 0,
+                    pdfMarginLeft: options.pdfMargin?.left ?? 0,
+                    pdfHeader: options.pdfHeader ?? "",
+                    pdfFooter: options.pdfFooter ?? "",
                 });
             addProfile("wasmRender", now() - renderStart);
             if (!result) {
                 options.onProfile?.(profile);
+                if (diagnosticsReport) {
+                    try {
+                        diagnosticsReport.fonts = JSON.parse(mod.get_font_diagnostics(instancePtr));
+                    }
+                    catch { }
+                    options.onDiagnostics?.(diagnosticsReport);
+                }
                 if (format === "svg")
                     return "";
                 return new Uint8Array();
             }
             if (format === "svg") {
                 const decodeStart = now();
-                const svg = new TextDecoder().decode(result);
+                const svg = utf8Decoder.decode(result);
                 addProfile("decodeResult", now() - decodeStart);
                 options.onProfile?.(profile);
+                if (diagnosticsReport) {
+                    try {
+                        diagnosticsReport.fonts = JSON.parse(mod.get_font_diagnostics(instancePtr));
+                    }
+                    catch { }
+                    options.onDiagnostics?.(diagnosticsReport);
+                }
                 return svg;
             }
             const copyStart = now();
             const bytes = new Uint8Array(result);
             addProfile("copyResult", now() - copyStart);
             options.onProfile?.(profile);
+            if (diagnosticsReport) {
+                try {
+                    diagnosticsReport.fonts = JSON.parse(mod.get_font_diagnostics(instancePtr));
+                }
+                catch { }
+                options.onDiagnostics?.(diagnosticsReport);
+            }
             return bytes;
         }
         finally {

package/dist/resources.d.ts

@@ -0,0 +1,60 @@
+import { ResourceResolver, ResolvedFontResult } from "./core.js";
+export interface ResourceCacheEntry {
+    data: Uint8Array | ResolvedFontResult;
+    bytes: number;
+    created: number;
+    lastHit: number;
+}
+export interface ResourceCacheOptions {
+    /** Maximum number of entries to keep in cache. Default: 100 */
+    maxEntries?: number;
+    /** Maximum total bytes to keep in cache. Default: 64MB */
+    maxBytes?: number;
+    /** Time to live in milliseconds. Default: 0 (no TTL) */
+    ttl?: number;
+}
+/**
+ * In-memory resource cache that works in all environments.
+ */
+export declare class MemoryResourceCache {
+    private cache;
+    private totalBytes;
+    private options;
+    constructor(options?: ResourceCacheOptions);
+    get(url: string): Promise<Uint8Array | ResolvedFontResult | null>;
+    set(url: string, data: Uint8Array | ResolvedFontResult): Promise<void>;
+    private delete;
+    private evict;
+    private calculateBytes;
+    /**
+     * Returns a ResourceResolver that wraps another resolver (or the default one) with this cache.
+     */
+    wrap(resolver?: ResourceResolver): ResourceResolver;
+    /**
+     * Clear the cache.
+     */
+    clear(): void;
+    /**
+     * Get cache statistics.
+     */
+    getStats(): {
+        entries: number;
+        totalBytes: number;
+    };
+}
+/**
+ * Composes multiple resource resolvers into a single one.
+ * They are executed in order; each one can choose to call the next one in the chain.
+ */
+export declare function composeResourceResolvers(...resolvers: ResourceResolver[]): ResourceResolver;
+/**
+ * CacheStorage adapter for browser and Cloudflare Workers.
+ */
+export declare class CacheStorageResourceCache {
+    private cacheName;
+    constructor(cacheName?: string);
+    private getCache;
+    get(url: string): Promise<Uint8Array | null>;
+    set(url: string, data: Uint8Array): Promise<void>;
+    wrap(resolver?: ResourceResolver): ResourceResolver;
+}

package/dist/resources.js

@@ -0,0 +1,175 @@
+/**
+ * In-memory resource cache that works in all environments.
+ */
+export class MemoryResourceCache {
+    cache = new Map();
+    totalBytes = 0;
+    options;
+    constructor(options = {}) {
+        this.options = {
+            maxEntries: options.maxEntries ?? 100,
+            maxBytes: options.maxBytes ?? 64 * 1024 * 1024,
+            ttl: options.ttl ?? 0,
+        };
+    }
+    async get(url) {
+        const entry = this.cache.get(url);
+        if (!entry)
+            return null;
+        if (this.options.ttl && Date.now() - entry.created > this.options.ttl) {
+            this.delete(url);
+            return null;
+        }
+        entry.lastHit = Date.now();
+        return entry.data;
+    }
+    async set(url, data) {
+        const bytes = this.calculateBytes(data);
+        if (this.options.maxBytes && bytes > this.options.maxBytes)
+            return;
+        this.evict(bytes);
+        this.cache.set(url, {
+            data,
+            bytes,
+            created: Date.now(),
+            lastHit: Date.now(),
+        });
+        this.totalBytes += bytes;
+    }
+    delete(url) {
+        const entry = this.cache.get(url);
+        if (entry) {
+            this.totalBytes -= entry.bytes;
+            this.cache.delete(url);
+        }
+    }
+    evict(incomingBytes) {
+        if (this.cache.size >= this.options.maxEntries || (this.options.maxBytes && this.totalBytes + incomingBytes > this.options.maxBytes)) {
+            const sorted = Array.from(this.cache.entries()).sort((a, b) => a[1].lastHit - b[1].lastHit);
+            for (const [url, entry] of sorted) {
+                this.delete(url);
+                if (this.cache.size < this.options.maxEntries && (!this.options.maxBytes || this.totalBytes + incomingBytes <= this.options.maxBytes)) {
+                    break;
+                }
+            }
+        }
+    }
+    calculateBytes(data) {
+        if (data instanceof Uint8Array)
+            return data.byteLength;
+        let sum = data.css.byteLength;
+        for (const f of data.fonts)
+            sum += f.data.byteLength;
+        return sum;
+    }
+    /**
+     * Returns a ResourceResolver that wraps another resolver (or the default one) with this cache.
+     */
+    wrap(resolver) {
+        return async (resource, defaultResolver) => {
+            const cached = await this.get(resource.url);
+            if (cached)
+                return cached;
+            const result = await (resolver ? resolver(resource, defaultResolver) : defaultResolver(resource));
+            if (result) {
+                // Normalize to Uint8Array if it's an ArrayBufferView but not ResolvedFontResult
+                let dataToCache;
+                if (typeof result.css !== 'undefined') {
+                    dataToCache = result;
+                }
+                else {
+                    const view = result;
+                    dataToCache = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+                }
+                await this.set(resource.url, dataToCache);
+            }
+            return result;
+        };
+    }
+    /**
+     * Clear the cache.
+     */
+    clear() {
+        this.cache.clear();
+        this.totalBytes = 0;
+    }
+    /**
+     * Get cache statistics.
+     */
+    getStats() {
+        return {
+            entries: this.cache.size,
+            totalBytes: this.totalBytes,
+        };
+    }
+}
+/**
+ * Composes multiple resource resolvers into a single one.
+ * They are executed in order; each one can choose to call the next one in the chain.
+ */
+export function composeResourceResolvers(...resolvers) {
+    return (resource, defaultResolver) => {
+        const run = (i) => {
+            const resolver = resolvers[i];
+            if (resolver) {
+                return resolver(resource, (r) => run(i + 1));
+            }
+            return defaultResolver(resource);
+        };
+        return run(0);
+    };
+}
+/**
+ * CacheStorage adapter for browser and Cloudflare Workers.
+ */
+export class CacheStorageResourceCache {
+    cacheName;
+    constructor(cacheName = "satoru-resources") {
+        this.cacheName = cacheName;
+    }
+    async getCache() {
+        return await caches.open(this.cacheName);
+    }
+    async get(url) {
+        try {
+            const cache = await this.getCache();
+            const response = await cache.match(url);
+            if (response) {
+                return new Uint8Array(await response.arrayBuffer());
+            }
+        }
+        catch (e) {
+            console.warn("CacheStorage error:", e);
+        }
+        return null;
+    }
+    async set(url, data) {
+        try {
+            const cache = await this.getCache();
+            await cache.put(url, new Response(data, {
+                headers: { "Content-Type": "application/octet-stream" }
+            }));
+        }
+        catch (e) {
+            console.warn("CacheStorage error:", e);
+        }
+    }
+    wrap(resolver) {
+        return async (resource, defaultResolver) => {
+            // Note: CacheStorage only supports Uint8Array easily, not ResolvedFontResult
+            if (resource.type === "font") {
+                // Fonts are complex because they might return multiple files. 
+                // For now we don't cache ResolvedFontResult in CacheStorage.
+                return resolver ? resolver(resource, defaultResolver) : defaultResolver(resource);
+            }
+            const cached = await this.get(resource.url);
+            if (cached)
+                return cached;
+            const result = await (resolver ? resolver(resource, defaultResolver) : defaultResolver(resource));
+            if (result && result instanceof Uint8Array) {
+                await this.set(resource.url, result);
+            }
+            return result;
+        };
+    }
+}