@silurus/ooxml 0.75.5 → 0.76.1

package/README.md

@@ -79,12 +79,12 @@ pnpm add @silurus/ooxml
 
 ```typescript
 import { DocxViewer } from '@silurus/ooxml/docx';
-import { XlsxViewer } from '@silurus/ooxml/xlsx';
+import { XlsxSheetViewer, XlsxViewer, XlsxWorkbook } from '@silurus/ooxml/xlsx';
 import { PptxViewer } from '@silurus/ooxml/pptx';
 
 // DOCX — caller provides the <canvas>
-const canvas = document.getElementById('docx-canvas') as HTMLCanvasElement;
-const docx = new DocxViewer(canvas);
+const docxCanvas = document.getElementById('docx-canvas') as HTMLCanvasElement;
+const docx = new DocxViewer(docxCanvas);
 await docx.load('/document.docx');
 docx.nextPage();
 
@@ -93,9 +93,32 @@ const container = document.getElementById('xlsx-container') as HTMLElement;
 const xlsx = new XlsxViewer(container);
 await xlsx.load('/workbook.xlsx');
 
+// XLSX active-sheet surface only — caller provides the <canvas>
+const sheetCanvas = document.getElementById('xlsx-canvas') as HTMLCanvasElement;
+const sheet = new XlsxSheetViewer(sheetCanvas);
+await sheet.load('/workbook.xlsx');
+await sheet.goToSheet(1);
+
+// Share one parsed workbook across independently scrollable sheet canvases,
+// including canvases created in same-origin popup windows.
+const workbook = await XlsxWorkbook.load('/workbook.xlsx');
+const firstCanvas = document.getElementById('xlsx-first-canvas') as HTMLCanvasElement;
+const secondCanvas = document.getElementById('xlsx-second-canvas') as HTMLCanvasElement;
+const firstSheet = XlsxSheetViewer.fromWorkbook(firstCanvas, workbook);
+const secondSheet = XlsxSheetViewer.fromWorkbook(secondCanvas, workbook);
+await Promise.all([
+  firstSheet.goToSheet(0),
+  secondSheet.goToSheet(1),
+]);
+
+// Each viewer borrows the workbook; the caller closes it after the viewers.
+firstSheet.destroy();
+secondSheet.destroy();
+workbook.destroy();
+
 // PPTX — caller provides the <canvas>
-const canvas = document.getElementById('pptx-canvas') as HTMLCanvasElement;
-const pptx = new PptxViewer(canvas);
+const pptxCanvas = document.getElementById('pptx-canvas') as HTMLCanvasElement;
+const pptx = new PptxViewer(pptxCanvas);
 await pptx.load('/deck.pptx');
 pptx.nextSlide();
 ```
@@ -203,7 +226,7 @@ The container must have a bounded height (e.g. `height: 100vh` or a flex child)
 so the viewer can size its scroll host to it. Base zoom fits the first page/slide
 width to the container width and re-fits on resize; a `0`-width container defers
 layout until it has width. Call `destroy()` to tear down (a self-loaded engine is
-destroyed with it; an injected one is not — see below).
+destroyed with it; a borrowed one is not — see below).
 
 Pass `refitOnResize: false` when the viewport must not determine the document's
 physical display size. An explicit pre-load `setScale(1)` then keeps the same
@@ -255,26 +278,38 @@ Pass `enableHyperlinks: false` to disable hyperlink interactivity entirely — n
 hit-testing, no pointer cursor over links, no default navigation, and
 `onHyperlinkClick` is never called; links still render as authored but are inert.
 This applies to every viewer that supports hyperlinks (`DocxViewer`,
-`DocxScrollViewer`, `PptxViewer`, `PptxScrollViewer`, `XlsxViewer`).
-
-**Master–detail / shared engine.** Inject an already-loaded headless engine so a
-paged viewer and a scroll viewer (or several panes) share **one** parse. When you
-inject, `load()` is unsupported (the engine is already loaded), the engine's own
-`mode` wins, and `destroy()` leaves the injected engine intact — the caller owns
-its lifecycle:
+`DocxScrollViewer`, `PptxViewer`, `PptxScrollViewer`, `XlsxViewer`,
+`XlsxSheetViewer`).
+
+**Choose one loading mode.** For the normal one-view case, construct a Viewer and
+call `viewer.load(source)`: the Viewer owns the parsed engine, may replace it on a
+later load, and destroys it during teardown. For master–detail, multi-pane, or
+multi-window UIs, create the Viewer from an already-loaded headless engine so
+every view shares **one** parse. The two modes are mutually exclusive: on a
+Viewer returned by a `from*()` factory, `load()` is unsupported, the engine's
+own `mode` wins, and `destroy()` leaves the borrowed engine intact — the caller
+owns its lifecycle.
+
+| Use case | Acquisition | Engine owner |
+| --- | --- | --- |
+| One Viewer | `new Viewer(target)` then `viewer.load(source)` | Viewer |
+| Shared parse | `Engine.load(source)` then `Viewer.fromDocument / fromPresentation / fromWorkbook(...)` | Caller |
 
 ```typescript
-import { DocxDocument, DocxScrollViewer } from '@silurus/ooxml/docx';
-
-const doc = await DocxDocument.load('/document.docx'); // parse once
-const scroll = new DocxScrollViewer(container, { document: doc });
-// ...also drive a thumbnail grid, a paged view, etc. from the same `doc`.
-scroll.destroy(); // the injected `doc` is NOT destroyed — you own it
-doc.destroy();    // release it yourself when every pane is gone
+import { DocxDocument, DocxScrollViewer, DocxViewer } from '@silurus/ooxml/docx';
+
+const document = await DocxDocument.load('/document.docx'); // parse once
+const scroll = DocxScrollViewer.fromDocument(container, document);
+const page = DocxViewer.fromDocument(canvas, document);
+await page.goToPage(0);
+// ...also drive a thumbnail grid or more panes from the same document.
+page.destroy();
+scroll.destroy();  // the borrowed document is NOT destroyed — you own it
+document.destroy(); // release it yourself when every pane is gone
 ```
 
-`PptxScrollViewer` takes the same shape with `{ presentation: pres }`
-(`await PptxPresentation.load(...)`).
+`PptxViewer` and `PptxScrollViewer` use `fromPresentation(...)`; `XlsxViewer`
+and `XlsxSheetViewer` use `fromWorkbook(...)`.
 
 For presentations, `enableMediaPlayback: true` makes embedded audio and video
 interactive inside the real viewport plus `mediaOverscan` slides. Other mounted
@@ -463,7 +498,7 @@ file without uploading it.
 | | In-document find (`findText` / `findNext` / `findPrev` / `clearFind` — full-text search, all hits highlighted, each match tagged with its page) | ✅ |
 | | Runtime zoom (`getScale` / `setScale` / `fitWidth` / `fitPage`) | ✅ |
 | | Clickable hyperlinks (overlay hit-test, `onHyperlinkClick`; internal bookmark / anchor navigation) | ✅ |
-| | Continuous scroll viewer (`DocxScrollViewer` — virtualized page list, desk background / shadow, Ctrl/⌘+wheel zoom, engine injection) | ✅ |
+| | Continuous scroll viewer (`DocxScrollViewer` — virtualized page list, desk background / shadow, Ctrl/⌘+wheel zoom, borrowed-engine factory) | ✅ |
 | **Loading** | Password-protected files ([MS-OFFCRYPTO] Agile Encryption — `load(bytes, { password })`, decrypted client-side via WebCrypto; legacy Standard / Extensible encryption → typed `unsupported-encryption`) | ✅ |
 
 ---
@@ -624,7 +659,7 @@ file without uploading it.
 | | In-document find (`findText` / `findNext` / `findPrev` / `clearFind` — matches tagged with slide) | ✅ |
 | | Runtime zoom (`getScale` / `setScale` / `fitWidth` / `fitPage`) | ✅ |
 | | Clickable hyperlinks (`onHyperlinkClick`; internal slide-jump navigation) | ✅ |
-| | Continuous scroll viewer (`PptxScrollViewer` — virtualized slide list, desk background / shadow, Ctrl/⌘+wheel zoom, engine injection) | ✅ |
+| | Continuous scroll viewer (`PptxScrollViewer` — virtualized slide list, desk background / shadow, Ctrl/⌘+wheel zoom, borrowed-engine factory) | ✅ |
 | **Loading** | Password-protected files ([MS-OFFCRYPTO] Agile Encryption — `load(bytes, { password })`, decrypted client-side via WebCrypto; legacy Standard / Extensible encryption → typed `unsupported-encryption`) | ✅ |
 
 ---
@@ -636,7 +671,8 @@ file without uploading it.
 ## Companion packages
 
 - **[`packages/markdown/`](packages/markdown/)** — `@silurus/ooxml-markdown` and the `ooxml-md` CLI convert `.pptx` / `.docx` / `.xlsx` to GitHub-flavoured markdown via the workspace WASM parsers. Same projection used by the MCP server (~21× smaller than the raw XML on the demo deck, ~8% bigger than a flat-text extractor). Includes a node20-based GitHub Action for bulk repo-wide conversion.
-- **[`packages/node/`](packages/node/)** — the implementation behind the public Node-only `@silurus/ooxml/node` subpath. It exposes materializing `parsePptx` / `parseDocx` / `parseXlsx` / `parseXlsxAllSheets` helpers plus uniformly owned, bounded `openPptxPresentation`, `openDocxDocument`, and `openXlsxWorkbook` sessions, with no DOM or Web Worker dependency. Each `open*` call returns an explicit `close()`-able session; PPTX streams `slides()` and can render each yielded slide through the same bounded archive, DOCX completes format-required sequential pagination before streaming `pages()`, and XLSX parses its workbook index once before sequential `worksheetRows(sheetIndex)` streams reuse the retained archive. Useful for CI checks and headless rendering pipelines; canvas rendering accepts a user-supplied backend such as `skia-canvas` without making it a runtime dependency.
+- **[`packages/node/`](packages/node/)** — the implementation behind the public Node-only `@silurus/ooxml/node` subpath. Its canonical APIs are the explicitly owned, bounded `openPptxPresentation`, `openDocxDocument`, and `openXlsxWorkbook` sessions. Async `materializePptxPresentation`, `materializeDocxDocument`, `materializeXlsxWorkbookIndex`, `materializeXlsxWorksheet`, and `materializeXlsxWorkbook` are provided when a complete caller-owned graph is actually needed. Each `open*` call returns an explicit, idempotent `close()`-able session; PPTX streams `slides()`, DOCX completes format-required sequential pagination before streaming `pages()`, and XLSX parses its workbook index once before sequential `worksheetRows(sheetIndex)` streams reuse the retained archive. Useful for CI checks and headless rendering pipelines; canvas rendering accepts a user-supplied backend such as `skia-canvas` without making it a runtime dependency.
+  See the [0.75 to 0.76 migration guide](docs/migration-0.76.md) for every removed synchronous helper and its replacement.
 - **[`packages/vscode-extension/`](packages/vscode-extension/)** — VS Code extension (`ooxml-viewer`) that registers `CustomEditorProvider`s for `.docx`, `.xlsx`, and `.pptx`, and (opt-in) auto-installs and registers the `ooxml-mcp-server` so AI coding agents in the same window (Copilot Agent mode, Claude, …) can read those files via dedicated tools. The preview is offline by default; an opt-in `ooxmlViewer.useGoogleFonts` setting (off, and force-disabled in untrusted workspaces) surfaces the library's metric-compatible font substitution, widening the webview CSP to the Google Fonts CDN only while enabled.
 - **[`packages/mcp-server/`](packages/mcp-server/)** — Rust MCP server (`ooxml-mcp-server`) exposing the parsers as tools for AI agents (Claude, Copilot, Codex, etc.). Provides structured queries (`docx_get_structure`, `xlsx_get_cell_range`, `pptx_get_slide_structure`, …) so agents can inspect OOXML files without shelling out to `unzip`. Prebuilt binaries are attached to each [GitHub Release](https://github.com/yukiyokotani/office-open-xml-viewer/releases) for macOS / Linux / Windows; the VS Code extension downloads them on demand.
 
@@ -738,16 +774,17 @@ await viewer.load(file);
 ## Security & Privacy
 
 - **Canvas-only rendering.** Documents are decoded and drawn to an `HTMLCanvasElement`. No script, link, form, or other active content from the source file is executed or injected into the DOM.
-- **Bounded OOXML package expansion.** DOCX, XLSX, and PPTX use the same resource policy. By default, one archive entry may inflate to at most 128 MiB and the distinct entries visited during one package session may inflate to at most 256 MiB. Override either budget with a plain `resourceLimits` object on a viewer or `load(...)` call:
+- **Bounded OOXML package expansion.** DOCX, XLSX, and PPTX use the same resource policy. By default, one archive entry may inflate to at most 128 MiB, the distinct entries visited during one package session may inflate to at most 256 MiB, and an archive may contain at most 4,096 entries. Override these budgets with a plain `resourceLimits` object on a viewer or `load(...)` call:
   ```ts
   new XlsxViewer(container, {
     resourceLimits: {
       maxArchiveEntryBytes: 64 * 1024 * 1024,
       maxTotalInflatedBytes: 192 * 1024 * 1024,
+      maxArchiveEntries: 2048,
     },
   });
   ```
-  `maxArchiveEntryBytes` applies to every XML, text, image, media, and other package part that the parser reads. `maxTotalInflatedBytes` counts the largest amount actually read from each distinct part during the lifetime of the loaded package; reading the same part again does not consume that budget twice. Set an individual field to `null` to disable that configurable budget. Internal hard safety ceilings still apply, so disabling a budget does not make arbitrary archives acceptable. Values other than `null` must be positive safe-integer byte counts.
+  `maxArchiveEntryBytes` applies to every XML, text, image, media, and other package part that the parser reads. `maxTotalInflatedBytes` counts the largest amount actually read from each distinct part during the lifetime of the loaded package; reading the same part again does not consume that budget twice. `maxArchiveEntries` bounds central-directory entries before the ZIP library allocates its owned index. Set an individual field to `null` to disable that configurable budget. Internal hard safety ceilings still apply, so disabling a budget does not make arbitrary archives acceptable. Values other than `null` must be positive safe integers; byte fields are expressed in bytes and the entry field is a count.
 
   A violation rejects with `OoxmlResourceLimitError` (`code === 'ooxml-resource-limit'`). Its structured `details.violation` reports the resource, metric, limit, observed value, usage snapshot, and part name when a particular part caused the failure. The deprecated `maxZipEntryBytes` option remains as a compatibility alias for `resourceLimits.maxArchiveEntryBytes`, but is scheduled for removal in a future breaking release; new code should use `resourceLimits`.
 
@@ -769,6 +806,7 @@ await viewer.load(file);
     resourceLimits: {
       maxArchiveEntryBytes: 128 * 1024 * 1024,
       maxTotalInflatedBytes: 256 * 1024 * 1024,
+      maxArchiveEntries: 4096,
     },
   });
   ```
@@ -781,7 +819,7 @@ await viewer.load(file);
   The package counters and raster-image guards are deterministic admission limits, not exact JavaScript/WASM process-memory accounting. XML trees, document models, canvas backing stores, browser decoder overhead, renderer state, and browser-managed SVG/vector parse or decoded storage can still require several times the measured input. SVG has no portable decoded-byte measure or explicit browser release primitive; the library count-bounds its cache and revokes owned object URLs, but cannot charge it as RGBA bytes. The defaults therefore reduce risk but cannot promise that an OOM is impossible on every device. Running parse and render work in `mode: 'worker'` can contain many failures away from the main UI thread, but a Worker is not a separate operating-system process or a strict memory sandbox.
 
   A measured limit crossing is reported as `OoxmlResourceLimitError`. A residual WASM failure that reaches a recognized trap-shaped boundary is reported conservatively as `parser-crashed`, not `parser-oom`: with the current aborting Rust/WASM boundary, panic, allocation failure, explicit `unreachable`, and stack overflow can lose their distinct causes and converge on the same generic runtime error. Inferring OOM from an exception class or message would misclassify some parser defects as large-file failures. Reliable OOM classification would require preserving a structured cause before the trap across every relevant allocation path; it cannot be recovered from the generic trap afterward. The WebAssembly JavaScript embedding also permits implementation-defined stack/OOM failures, including an indistinguishable plain `Error` or process termination, so converting and poisoning every engine-level failure cannot be guaranteed.
-- **No network by default.** The library does not send telemetry or analytics, and does not contact third-party services unless you ask it to. In particular, theme webfonts, Office font metric substitutes (Carlito/Caladea), and the script fallback fonts are **not** loaded from Google Fonts unless you pass `useGoogleFonts: true` to the relevant `Viewer` / `load(...)` options — supported uniformly by `DocxViewer`, `PptxViewer`, and `XlsxViewer`. When enabled, fonts for non-Latin scripts are supplied on demand from Noto families so text does not fall back to tofu: Arabic (Noto Naskh/Sans Arabic), CJK (Noto Sans/Serif KR · SC · TC · JP, picked per document language so shared Han glyphs take the right shapes), Cyrillic (Noto Sans/Serif), Hebrew (Noto Sans/Serif Hebrew, RTL), Thai (Noto Sans Thai) and Devanagari (Noto Sans Devanagari). No font binaries ship in the bundle. Enabling this option causes the end-user's browser to send an HTTP request (IP and User-Agent) to `fonts.googleapis.com`, which may have GDPR implications for your application — consider self-hosting the required fonts via `@font-face` instead.
+- **No network by default.** The library does not send telemetry or analytics, and does not contact third-party services unless you ask it to. In particular, theme webfonts, Office font metric substitutes (Carlito/Caladea), and the script fallback fonts are **not** loaded from Google Fonts unless you pass `useGoogleFonts: true` to the relevant `Viewer` / `load(...)` options — supported uniformly by `DocxViewer`, `PptxViewer`, `XlsxViewer`, and `XlsxSheetViewer`. When enabled, fonts for non-Latin scripts are supplied on demand from Noto families so text does not fall back to tofu: Arabic (Noto Naskh/Sans Arabic), CJK (Noto Sans/Serif KR · SC · TC · JP, picked per document language so shared Han glyphs take the right shapes), Cyrillic (Noto Sans/Serif), Hebrew (Noto Sans/Serif Hebrew, RTL), Thai (Noto Sans Thai) and Devanagari (Noto Sans Devanagari). No font binaries ship in the bundle. Enabling this option causes the end-user's browser to send an HTTP request (IP and User-Agent) to `fonts.googleapis.com`, which may have GDPR implications for your application — consider self-hosting the required fonts via `@font-face` instead.
 - **XML parsing.** Uses `roxmltree`, which does not resolve external entities (XXE-safe by default).
 - **Encrypted OOXML ([MS-OFFCRYPTO] Agile Encryption).** Password-protected `.docx` / `.xlsx` / `.pptx` files are OLE2/CFB containers, not ZIPs. Pass `password` to `load(...)` and the file is decrypted **client-side** via WebCrypto — no bytes and no password leave the browser:
   ```ts

package/dist/bounded-raw-part-cache-C6ro6Ezf.js

@@ -0,0 +1,254 @@
+//#region packages/core/src/fonts/font-registry.ts
+var e = /* @__PURE__ */ new Map();
+function t(t, n, r) {
+	let i = e.get(t), a = i?.get(n);
+	if (a) return a.refs++, {
+		face: a.face,
+		isNew: !1
+	};
+	let o = r(), s = i ?? /* @__PURE__ */ new Map();
+	return s.set(n, {
+		face: o,
+		set: n,
+		refs: 1
+	}), e.set(t, s), {
+		face: o,
+		isNew: !0
+	};
+}
+function n(t) {
+	let n = /* @__PURE__ */ new Set();
+	for (let r of t) if (!n.has(r)) {
+		n.add(r);
+		for (let [t, n] of e) {
+			let i = !1;
+			for (let [a, o] of n) if (o.face === r) {
+				if (i = !0, o.refs--, o.refs <= 0) {
+					try {
+						o.set.delete(r);
+					} catch {}
+					n.delete(a), n.size === 0 && e.delete(t);
+				}
+				break;
+			}
+			if (i) break;
+		}
+	}
+}
+//#endregion
+//#region packages/core/src/fonts/preload.ts
+var r = 15e3;
+function i(e) {
+	return Promise.race([e, new Promise((e) => setTimeout(e, r))]);
+}
+var a = /* @__PURE__ */ new Map();
+function o(e) {
+	let t = [], n = /@font-face\s*\{([^}]*)\}/g, r;
+	for (; r = n.exec(e);) {
+		let e = r[1], n = (t) => e.match(RegExp(`(?:^|;|\\n)\\s*${t}\\s*:\\s*([^;]+)`, "i"))?.[1].trim(), i = n("font-family"), a = n("src");
+		if (!i || !a) continue;
+		let o = {}, s = n("font-style");
+		s && (o.style = s);
+		let c = n("font-weight");
+		c && (o.weight = c);
+		let l = n("font-stretch");
+		l && (o.stretch = l);
+		let u = n("unicode-range");
+		u && (o.unicodeRange = u), t.push({
+			family: i.replace(/^['"]|['"]$/g, ""),
+			src: a,
+			descriptors: o
+		});
+	}
+	return t;
+}
+function s() {
+	return typeof document < "u" && document && document.fonts ? document.fonts : typeof self < "u" && self && "fonts" in self ? self.fonts : null;
+}
+function c(e, t) {
+	let n = t.descriptors;
+	return [
+		"gfonts",
+		e,
+		t.family.toLowerCase(),
+		n.style ?? "",
+		n.weight ?? "",
+		n.stretch ?? "",
+		n.unicodeRange ?? "",
+		t.src
+	].join("|");
+}
+async function l(e, n, r = s()) {
+	let l = r;
+	if (!l || typeof FontFace > "u" || typeof fetch > "u") return [];
+	let u = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Set();
+	for (let t of e) {
+		if (!t) continue;
+		let e = t.toLowerCase();
+		if (u.has(e)) continue;
+		u.add(e);
+		let r = n[e];
+		if (!r) continue;
+		f.add(r.url);
+		let i = (r.loadFamily ?? t).toLowerCase();
+		d.add(i);
+		let a = p.get(r.url);
+		a || (a = /* @__PURE__ */ new Set(), p.set(r.url, a)), a.add(i);
+	}
+	if (d.size === 0) return [];
+	let h = await i(Promise.all([...f].map(async (e) => {
+		let t = a.get(e);
+		if (t) return {
+			url: e,
+			rules: await t
+		};
+		let n = (async () => {
+			try {
+				let t = await fetch(e);
+				if (!t.ok) throw Error(`HTTP ${t.status}`);
+				return o(await t.text());
+			} catch {
+				a.delete(e);
+				for (let t of p.get(e) ?? []) m.add(t);
+				return [];
+			}
+		})();
+		return a.set(e, n), {
+			url: e,
+			rules: await n
+		};
+	}))), g = [], _ = [];
+	for (let e of Array.isArray(h) ? h : []) for (let n of e.rules) {
+		let { face: r, isNew: i } = t(c(e.url, n), l, () => {
+			let e = new FontFace(n.family, n.src, n.descriptors);
+			return l.add(e), e;
+		});
+		g.push(r), i && _.push(r);
+	}
+	return _.length > 0 && await i(Promise.allSettled(_.map((e) => e.load())).then((e) => (e.forEach((e, t) => {
+		e.status === "rejected" && m.add(_[t].family.replace(/['"]/g, "").toLowerCase());
+	}), l.ready))), m.size > 0 && console.warn(`[ooxml] failed to preload web font(s): ${[...m].join(", ")}; falling back to system fonts (text may shift or differ).`), g;
+}
+function u(e) {
+	n(e);
+}
+//#endregion
+//#region packages/core/src/internal/bounded-async-lru-cache.ts
+function d(e, t) {
+	if (!Number.isSafeInteger(e) || e <= 0) throw TypeError(`${t} must be a positive safe integer`);
+}
+function f(e) {
+	if (!Number.isSafeInteger(e) || e < 0) throw TypeError("cache entry weight must be a non-negative safe integer");
+}
+var p = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i = /* @__PURE__ */ new Map();
+	#a = /* @__PURE__ */ new Map();
+	#o = 0;
+	constructor(e) {
+		d(e.maxEntries, "maxEntries"), d(e.maxWeight, "maxWeight"), this.#e = e.maxEntries, this.#t = e.maxWeight, this.#n = e.measure, this.#r = e.onRemove;
+	}
+	get usage() {
+		return {
+			entries: this.#i.size,
+			weight: this.#o,
+			pending: this.#a.size
+		};
+	}
+	has(e) {
+		return this.#i.has(e);
+	}
+	get(e) {
+		let t = this.#i.get(e);
+		if (t !== void 0) return this.#i.delete(e), this.#i.set(e, t), t.value;
+	}
+	getOrLoad(e, t) {
+		let n = this.get(e);
+		if (n !== void 0 || this.#i.has(e)) return Promise.resolve(n);
+		let r = this.#a.get(e);
+		if (r !== void 0) return r.promise;
+		let i = {}, a = Promise.resolve().then(t).then((t) => this.#c(e, i, t), (t) => {
+			throw this.#s(e, i), t;
+		});
+		return this.#a.set(e, {
+			token: i,
+			promise: a
+		}), a;
+	}
+	delete(e) {
+		let t = this.#a.delete(e), n = this.#i.get(e);
+		return n === void 0 ? t : (this.#i.delete(e), this.#o -= n.weight, this.#l(n.value, e, "deleted"), !0);
+	}
+	clear() {
+		this.#a.clear();
+		let e = [...this.#i];
+		this.#i.clear(), this.#o = 0;
+		for (let [t, n] of e) this.#l(n.value, t, "cleared");
+	}
+	#s(e, t) {
+		this.#a.get(e)?.token === t && this.#a.delete(e);
+	}
+	#c(e, t, n) {
+		if (this.#a.get(e)?.token !== t) return n;
+		let r;
+		try {
+			r = this.#n(n), f(r);
+		} catch (n) {
+			throw this.#s(e, t), n;
+		}
+		if (this.#a.get(e)?.token !== t || (this.#a.delete(e), r > this.#t)) return n;
+		let i = [];
+		for (; this.#i.size >= this.#e || r > this.#t - this.#o;) {
+			let e = this.#i.entries().next().value;
+			if (e === void 0) break;
+			let [t, n] = e;
+			this.#i.delete(t), this.#o -= n.weight, i.push([t, n]);
+		}
+		this.#i.set(e, {
+			value: n,
+			weight: r
+		}), this.#o += r;
+		for (let [e, t] of i) this.#l(t.value, e, "evicted");
+		return n;
+	}
+	#l(e, t, n) {
+		try {
+			this.#r?.(e, t, n);
+		} catch {}
+	}
+}, m = class {
+	#e;
+	constructor(e) {
+		this.#e = new p({
+			maxEntries: e.maxEntries,
+			maxWeight: e.maxBytes,
+			measure: (e) => e.size
+		});
+	}
+	get usage() {
+		let e = this.#e.usage;
+		return {
+			entries: e.entries,
+			bytes: e.weight,
+			pending: e.pending
+		};
+	}
+	async get(e, t, n) {
+		if (typeof e != "string" || e.length === 0) throw TypeError("raw package part path must be a non-empty string");
+		if (typeof t != "string") throw TypeError("raw package part MIME type must be a string");
+		let r = await this.#e.getOrLoad(e, async () => {
+			let e = await n();
+			if (!(e instanceof Blob)) throw TypeError("raw package part loader must return a Blob");
+			return e;
+		});
+		return t === "" || r.type === t ? r : r.slice(0, r.size, t);
+	}
+	clear() {
+		this.#e.clear();
+	}
+};
+//#endregion
+export { u as a, t as c, l as i, p as n, i as o, s as r, n as s, m as t };