@silurus/ooxml 0.74.6 → 0.75.0

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

@@ -0,0 +1,1248 @@
+import { f as e } from "./svg-image-by-path-C1M3N2pT.js";
+//#region packages/core/src/errors/ooxml-error.ts
+var t = class e extends Error {
+	code;
+	constructor(t, n) {
+		super(n), this.name = "OoxmlError", this.code = t, Object.setPrototypeOf(this, e.prototype);
+	}
+}, n = class e extends Error {
+	code = "ooxml-resource-limit";
+	details;
+	constructor(t, n) {
+		super(t), this.name = "OoxmlResourceLimitError";
+		let r = n.violation, i = Object.freeze({
+			format: r.format,
+			operation: r.operation,
+			resource: r.resource,
+			metric: r.metric,
+			...r.part === void 0 ? {} : { part: r.part },
+			limit: r.limit,
+			observed: r.observed,
+			configurable: r.configurable,
+			usage: Object.freeze({
+				archiveEntryCount: r.usage.archiveEntryCount,
+				declaredInflatedBytes: r.usage.declaredInflatedBytes,
+				...r.usage.largestInflatedEntryBytes === void 0 ? {} : { largestInflatedEntryBytes: r.usage.largestInflatedEntryBytes },
+				distinctInflatedBytes: r.usage.distinctInflatedBytes,
+				operationInflatedBytes: r.usage.operationInflatedBytes
+			})
+		});
+		this.details = Object.freeze({
+			stage: n.stage,
+			violation: i
+		}), Object.setPrototypeOf(this, e.prototype);
+	}
+}, r = "https://fonts.googleapis.com/css2?family=Noto+Naskh+Arabic:wght@400;700&display=swap", i = "https://fonts.googleapis.com/css2?family=Noto+Sans+Arabic:wght@400;700&display=swap", a = {
+	calibri: {
+		url: "https://fonts.googleapis.com/css2?family=Carlito:ital,wght@0,400;0,700;1,400;1,700&display=swap",
+		loadFamily: "Carlito"
+	},
+	"calibri light": {
+		url: "https://fonts.googleapis.com/css2?family=Carlito:ital,wght@0,400;0,700;1,400;1,700&display=swap",
+		loadFamily: "Carlito"
+	},
+	cambria: {
+		url: "https://fonts.googleapis.com/css2?family=Caladea:ital,wght@0,400;0,700;1,400;1,700&display=swap",
+		loadFamily: "Caladea"
+	},
+	"cambria math": {
+		url: "https://fonts.googleapis.com/css2?family=Caladea:ital,wght@0,400;0,700;1,400;1,700&display=swap",
+		loadFamily: "Caladea"
+	},
+	"nunito sans": { url: "https://fonts.googleapis.com/css2?family=Nunito+Sans:ital,wght@0,400;0,700;1,400;1,700&display=swap" },
+	nunito: { url: "https://fonts.googleapis.com/css2?family=Nunito:ital,wght@0,400;0,700;1,400;1,700&display=swap" },
+	"open sans": { url: "https://fonts.googleapis.com/css2?family=Open+Sans:ital,wght@0,400;0,700;1,400;1,700&display=swap" },
+	roboto: { url: "https://fonts.googleapis.com/css2?family=Roboto:ital,wght@0,400;0,700;1,400;1,700&display=swap" },
+	lato: { url: "https://fonts.googleapis.com/css2?family=Lato:ital,wght@0,400;0,700;1,400;1,700&display=swap" },
+	montserrat: { url: "https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,400;0,700;1,400;1,700&display=swap" },
+	poppins: { url: "https://fonts.googleapis.com/css2?family=Poppins:ital,wght@0,400;0,700;1,400;1,700&display=swap" },
+	raleway: { url: "https://fonts.googleapis.com/css2?family=Raleway:ital,wght@0,400;0,700;1,400;1,700&display=swap" },
+	"playfair display": { url: "https://fonts.googleapis.com/css2?family=Playfair+Display:ital,wght@0,400;0,700;1,400;1,700&display=swap" },
+	ubuntu: { url: "https://fonts.googleapis.com/css2?family=Ubuntu:ital,wght@0,400;0,700;1,400;1,700&display=swap" },
+	"sakkal majalla": {
+		url: r,
+		loadFamily: "Noto Naskh Arabic"
+	},
+	"traditional arabic": {
+		url: r,
+		loadFamily: "Noto Naskh Arabic"
+	},
+	"simplified arabic": {
+		url: r,
+		loadFamily: "Noto Naskh Arabic"
+	},
+	"arabic typesetting": {
+		url: r,
+		loadFamily: "Noto Naskh Arabic"
+	},
+	"univers next arabic": {
+		url: i,
+		loadFamily: "Noto Sans Arabic"
+	},
+	"noto naskh arabic": {
+		url: r,
+		loadFamily: "Noto Naskh Arabic"
+	},
+	"noto sans arabic": {
+		url: i,
+		loadFamily: "Noto Sans Arabic"
+	}
+}, o = class e extends Error {
+	code = "parser-crashed";
+	constructor(t) {
+		super(t), this.name = "WasmTrapError", Object.setPrototypeOf(this, e.prototype);
+	}
+}, s = "ooxml-insufficient-credit", c = "OOXML_INSUFFICIENT_CREDIT:";
+function l(e) {
+	return typeof e == "number" && Number.isSafeInteger(e) && e > 0;
+}
+function u(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return !1;
+	let t = e;
+	return l(t.requiredBytes) && l(t.offeredBytes) && t.requiredBytes > t.offeredBytes;
+}
+var d = class e extends RangeError {
+	code = s;
+	requiredBytes;
+	offeredBytes;
+	constructor(t) {
+		super(`Pull unit requires ${t.requiredBytes} bytes but credit is ${t.offeredBytes}`), this.name = "PullSessionInsufficientCreditError", this.requiredBytes = t.requiredBytes, this.offeredBytes = t.offeredBytes, Object.setPrototypeOf(this, e.prototype);
+	}
+};
+function f(e) {
+	if (e instanceof d) return e;
+	let t = e instanceof Error ? e.message : String(e);
+	if (!t.startsWith(c)) return;
+	let n;
+	try {
+		n = JSON.parse(t.slice(26));
+	} catch {
+		return;
+	}
+	if (!n || typeof n != "object" || Array.isArray(n)) return;
+	let r = n;
+	if (!(r.code !== "ooxml-insufficient-credit" || !u(r))) return new d(r);
+}
+function ee(e, t, n) {
+	let r = f(e);
+	if (!(!r || r.offeredBytes !== t || r.requiredBytes > n)) return r;
+}
+function te(e, t, n) {
+	if (p(e)) return e.offeredBytes === t && e.requiredBytes <= n ? e.requiredBytes : void 0;
+}
+function p(e) {
+	return e instanceof d || !!e && typeof e == "object" && e.code === "ooxml-insufficient-credit" && u(e);
+}
+//#endregion
+//#region packages/core/src/worker/error-wire.ts
+var m = "OOXML_RESOURCE_LIMIT:", h = 128, ne = 256, re = 4096;
+function g(e) {
+	return typeof e == "number" && Number.isSafeInteger(e) && e >= 0;
+}
+function _(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return !1;
+	let t = e;
+	return g(t.archiveEntryCount) && g(t.declaredInflatedBytes) && (t.largestInflatedEntryBytes === void 0 || g(t.largestInflatedEntryBytes)) && g(t.distinctInflatedBytes) && g(t.operationInflatedBytes);
+}
+function ie(e) {
+	let t;
+	try {
+		t = JSON.parse(new TextDecoder().decode(e));
+	} catch {
+		throw TypeError("OOXML resource usage checkpoint is not valid JSON");
+	}
+	if (!_(t)) throw TypeError("OOXML resource usage checkpoint is invalid");
+	return t;
+}
+function ae(e) {
+	return e === "docx" || e === "xlsx" || e === "pptx";
+}
+function oe(e) {
+	return e === "container" || e === "decompression" || e === "parsing" || e === "serialization" || e === "layout" || e === "rendering" || e === "worker";
+}
+function v(e, t) {
+	return typeof e == "string" && e.length > 0 && e.length <= t && !/[\u0000-\u001f\u007f]/u.test(e);
+}
+function y(e) {
+	return v(e, h) && /^[a-z0-9][a-z0-9-]*$/u.test(e);
+}
+function se(e) {
+	return !v(e, re) || e.startsWith("/") || e.startsWith("\\") || e.includes("\\") || e.includes("?") || e.includes("#") || e.includes("://") || /^[a-z]:/iu.test(e) ? !1 : e.split("/").every((e) => e !== "" && e !== "." && e !== "..");
+}
+var b = new Map([
+	["archive-entry:declared-inflated-bytes", {
+		stage: "container",
+		part: "required"
+	}],
+	["archive-entry:actual-inflated-bytes", {
+		stage: "decompression",
+		part: "required"
+	}],
+	["archive:entry-count", {
+		stage: "container",
+		part: "forbidden",
+		configurable: !1
+	}],
+	["archive:central-directory-bytes", {
+		stage: "container",
+		part: "forbidden",
+		configurable: !1
+	}],
+	["archive:distinct-inflated-bytes", {
+		stage: "decompression",
+		part: "required"
+	}],
+	["xml-event:bytes", {
+		stage: "parsing",
+		part: "optional",
+		configurable: !1
+	}],
+	["xml-context:bytes", {
+		stage: "parsing",
+		part: "optional",
+		configurable: !1
+	}],
+	["xml-tree:depth", {
+		stage: "parsing",
+		part: "optional",
+		configurable: !1
+	}],
+	["worksheet-row:projected-bytes", {
+		stage: "parsing",
+		part: "optional",
+		configurable: !1
+	}],
+	["worksheet-shell:projected-bytes", {
+		stage: "parsing",
+		part: "optional",
+		configurable: !1
+	}]
+]), ce = new Set([...b.keys()].map((e) => e.slice(0, e.indexOf(":")))), le = new Set([...b.keys()].map((e) => e.slice(e.indexOf(":") + 1)));
+function ue(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return !1;
+	let t = e;
+	return !ae(t.format) || !v(t.operation, ne) || !y(t.resource) || !y(t.metric) || !g(t.limit) || !g(t.observed) || typeof t.configurable != "boolean" || !_(t.usage) ? !1 : !("part" in t) || se(t.part);
+}
+function x(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return !1;
+	let t = e;
+	if (!oe(t.stage) || !ue(t.violation)) return !1;
+	let n = t.violation, r = b.get(`${n.resource}:${n.metric}`);
+	return r ? t.stage !== r.stage || r.configurable === !1 && n.configurable !== !1 ? !1 : r.part === "required" ? n.part !== void 0 : r.part === "forbidden" ? n.part === void 0 : !0 : !(ce.has(n.resource) && le.has(n.metric));
+}
+function de(e) {
+	return {
+		archiveEntryCount: e.archiveEntryCount,
+		declaredInflatedBytes: e.declaredInflatedBytes,
+		...e.largestInflatedEntryBytes === void 0 ? {} : { largestInflatedEntryBytes: e.largestInflatedEntryBytes },
+		distinctInflatedBytes: e.distinctInflatedBytes,
+		operationInflatedBytes: e.operationInflatedBytes
+	};
+}
+function fe(e) {
+	if (!x(e)) return;
+	let t = e.violation, n = {
+		stage: e.stage,
+		violation: {
+			format: t.format,
+			operation: t.operation,
+			resource: t.resource,
+			metric: t.metric,
+			...t.part === void 0 ? {} : { part: t.part },
+			limit: t.limit,
+			observed: t.observed,
+			configurable: t.configurable,
+			usage: de(t.usage)
+		}
+	};
+	return x(n) ? n : void 0;
+}
+function S(e) {
+	let t = e.violation;
+	return `OOXML resource limit exceeded${t.part ? ` for ${t.part}` : ""}: ${t.metric} ${t.observed} > ${t.limit}`;
+}
+function C(e) {
+	let t = e instanceof Error ? e.message : String(e);
+	if (!t.startsWith(m)) return;
+	let r;
+	try {
+		r = JSON.parse(t.slice(21));
+	} catch {
+		return;
+	}
+	if (!r || typeof r != "object") return;
+	let i = r;
+	if (!(i.code !== "ooxml-resource-limit" || !x(i.details))) return new n(S(i.details), i.details);
+}
+function pe(r) {
+	if (r instanceof e) return {
+		message: r.message,
+		errorName: r.name,
+		code: r.code,
+		decodedImage: {
+			metric: r.metric,
+			limit: r.limit,
+			observed: r.observed
+		}
+	};
+	let i = f(r);
+	if (i) return {
+		message: i.message,
+		errorName: i.name,
+		code: i.code,
+		insufficientCredit: {
+			requiredBytes: i.requiredBytes,
+			offeredBytes: i.offeredBytes
+		}
+	};
+	let a = r instanceof t || r instanceof n ? r : C(r);
+	if (a instanceof n) {
+		let e = fe(a.details);
+		return e ? {
+			message: typeof a.message == "string" ? a.message : S(e),
+			errorName: "OoxmlResourceLimitError",
+			code: "ooxml-resource-limit",
+			resourceLimit: e
+		} : {
+			message: "Invalid OOXML resource-limit error payload",
+			errorName: "Error"
+		};
+	}
+	if (a instanceof t) return {
+		message: typeof a.message == "string" ? a.message : String(a.message),
+		errorName: v(a.name, h) ? a.name : "OoxmlError",
+		...y(a.code) ? { code: a.code } : {}
+	};
+	let o = r instanceof Error ? r.message : String(r);
+	if (typeof o == "string" && o.startsWith(m)) return {
+		message: "Invalid OOXML resource-limit payload",
+		errorName: "Error"
+	};
+	let s = r instanceof Error ? r : Error(o), c = s;
+	return {
+		message: typeof s.message == "string" ? s.message : String(s.message),
+		errorName: v(s.name, h) ? s.name : "Error",
+		...typeof c.code == "string" ? { code: c.code } : {}
+	};
+}
+function w(e) {
+	try {
+		return pe(e);
+	} catch {
+		return {
+			message: "Worker operation failed with an unreadable error",
+			errorName: "Error"
+		};
+	}
+}
+var me = new Set([
+	"encrypted",
+	"invalid-password",
+	"unsupported-encryption",
+	"legacy-binary-format",
+	"not-ooxml"
+]);
+function T(r) {
+	if (r.code === "ooxml-decoded-image-limit" && r.decodedImage && (r.decodedImage.metric === "image-pixels" || r.decodedImage.metric === "active-decoded-bytes") && g(r.decodedImage.limit) && g(r.decodedImage.observed) && r.decodedImage.observed > r.decodedImage.limit) return new e(r.decodedImage.metric, r.decodedImage.limit, r.decodedImage.observed);
+	if (r.code === "ooxml-insufficient-credit" && u(r.insufficientCredit)) return new d(r.insufficientCredit);
+	if (r.code === "ooxml-resource-limit" && x(r.resourceLimit)) return new n(r.message, r.resourceLimit);
+	if (r.code && me.has(r.code)) return new t(r.code, r.message);
+	let i = r.errorName === "TypeError" ? TypeError(r.message) : r.errorName === "RangeError" ? RangeError(r.message) : Error(r.message);
+	return r.errorName && (i.name = r.errorName), r.code !== void 0 && Object.assign(i, { code: r.code }), i;
+}
+//#endregion
+//#region packages/core/src/worker/resource-policy.generated.ts
+var he = 134217728, ge = 268435456, _e = 67108864, ve = 67108864, ye = 67108864, E = 134217728, D = 134217728, O = 1e5, k = 25e4, A = 33554432, j = 67108864, M = 2e5, N = 5e5, P = 25e4, F = Object.freeze({
+	maxArchiveEntryBytes: he,
+	maxTotalInflatedBytes: ge
+});
+function I(e, t, n) {
+	if (t === void 0) return n;
+	if (t === null) return null;
+	if (!Number.isSafeInteger(t) || t <= 0) throw RangeError(`resourceLimits.${e} must be null or a positive safe integer number of bytes`);
+	return t;
+}
+function be(e) {
+	if (!(e === void 0 || !(e > 0))) {
+		if (!Number.isSafeInteger(e)) throw RangeError("maxZipEntryBytes must be a positive safe integer number of bytes");
+		return e;
+	}
+}
+function L(e) {
+	let t = e.resourceLimits;
+	if (t !== void 0 && (typeof t != "object" || !t || Array.isArray(t))) throw TypeError("resourceLimits must be an object when provided");
+	let n = be(e.maxZipEntryBytes), r = t?.maxArchiveEntryBytes;
+	if (n !== void 0 && r !== void 0 && n !== r) throw RangeError("maxZipEntryBytes conflicts with resourceLimits.maxArchiveEntryBytes");
+	return Object.freeze({
+		maxArchiveEntryBytes: I("maxArchiveEntryBytes", r === void 0 ? n : r, F.maxArchiveEntryBytes),
+		maxTotalInflatedBytes: I("maxTotalInflatedBytes", t?.maxTotalInflatedBytes, F.maxTotalInflatedBytes)
+	});
+}
+function xe(e) {
+	if (e.debug !== void 0 && typeof e.debug != "boolean") throw TypeError("debug must be a boolean when provided");
+	if (e.onResourceMetrics !== void 0 && typeof e.onResourceMetrics != "function") throw TypeError("onResourceMetrics must be a function when provided");
+	return Object.freeze({
+		policy: L(e),
+		debug: e.debug ?? !1,
+		...e.onResourceMetrics ? { onResourceMetrics: e.onResourceMetrics } : {}
+	});
+}
+function Se(e) {
+	return [e.maxArchiveEntryBytes === null ? 0n : BigInt(e.maxArchiveEntryBytes), e.maxTotalInflatedBytes === null ? 0n : BigInt(e.maxTotalInflatedBytes)];
+}
+//#endregion
+//#region packages/core/src/internal/console-tui.ts
+var Ce = [
+	"font-family: \"SFMono-Regular\", Menlo, Monaco, Consolas, monospace",
+	"font-size: 12px",
+	"line-height: 1.35",
+	"font-variant-ligatures: none",
+	"letter-spacing: 0",
+	"white-space: pre"
+].join(";");
+function we(e) {
+	if (Te()) {
+		console.log(`%c${e}`, Ce);
+		return;
+	}
+	console.log(e);
+}
+function Te() {
+	return typeof window < "u" && globalThis.process?.release?.name !== "node";
+}
+//#endregion
+//#region packages/core/src/worker/resource-debug-view.ts
+function Ee(e) {
+	let t = e.scope === "session" ? "SESSION" : "LOAD", n = e.status === "ok" ? e.scope === "session" ? "COMPLETE" : "READY" : "FAILED", r = [Oe(` OOXML ${t}  ${e.format.toUpperCase()}  ${n} `, 68)];
+	if (r.push(H(`mode ${e.mode.padEnd(8)}  elapsed ${z(e.elapsedMs)}`, 68)), e.sourceBytes !== void 0 && r.push(H(`source ${R(e.sourceBytes)}`, 68)), r.push(V(" admission ", 68)), r.push(U("largest entry", e.usage?.largestInflatedEntryBytes, e.policy.maxArchiveEntryBytes, 68)), r.push(U("total inflated", e.usage?.distinctInflatedBytes, e.policy.maxTotalInflatedBytes, 68)), e.usage ? r.push(H(`entries ${B(e.usage.archiveEntryCount)}  declared ${R(e.usage.declaredInflatedBytes)}`, 68)) : r.push(H("usage unavailable for this report", 68)), e.checkpoints.length > 0) {
+		r.push(V(" checkpoints ", 68));
+		for (let t of e.checkpoints) {
+			let e = t.usage ? R(t.usage.distinctInflatedBytes) : "—";
+			r.push(H(`${z(t.elapsedMs).padStart(8)}  ${t.name.padEnd(25)} ${e.padStart(12)}`, 68));
+		}
+	}
+	if (e.outcome && Object.keys(e.outcome).length > 0 && (r.push(V(" result ", 68)), r.push(H(Object.entries(e.outcome).map(([e, t]) => `${e} ${B(t)}`).join("  "), 68))), e.error) {
+		r.push(V(" failure ", 68));
+		let t = [
+			e.error.code,
+			e.error.stage,
+			e.error.resource,
+			e.error.metric
+		].filter((e) => !!e).join(" · ");
+		r.push(H(t || "unclassified error", 68));
+	}
+	return r.push(`└${"─".repeat(68)}┘`), r.join("\n");
+}
+function De(e) {
+	we(Ee(e));
+}
+function R(e) {
+	if (!Number.isFinite(e) || e < 0) return "—";
+	let t = [
+		"B",
+		"KiB",
+		"MiB",
+		"GiB",
+		"TiB"
+	], n = e, r = 0;
+	for (; n >= 1024 && r < t.length - 1;) n /= 1024, r += 1;
+	let i = r === 0 || n >= 100 ? 0 : n >= 10 ? 1 : 2;
+	return `${n.toFixed(i)} ${t[r]}`;
+}
+function z(e) {
+	return e < 1e3 ? `${Math.round(e)} ms` : `${(e / 1e3).toFixed(2)} s`;
+}
+function B(e) {
+	return Number.isSafeInteger(e) ? e.toLocaleString("en-US") : "—";
+}
+function Oe(e, t) {
+	let n = e.slice(0, t);
+	return `┌${n}${"─".repeat(t - n.length)}┐`;
+}
+function V(e, t) {
+	let n = e.slice(0, t);
+	return `├${n}${"─".repeat(t - n.length)}┤`;
+}
+function H(e, t) {
+	let n = e.slice(0, t - 2);
+	return `│ ${n}${" ".repeat(t - n.length - 2)} │`;
+}
+function U(e, t, n, r) {
+	let i = t === void 0 || n === null || n <= 0 ? 0 : Math.min(1, t / n), a = Math.round(i * 16), o = `${"█".repeat(a)}${"░".repeat(16 - a)}`, s = `${t === void 0 ? "—" : R(t)} / ${n === null ? "public off" : R(n)}`;
+	return H(`${e.padEnd(14)} ${o}  ${s}`, r);
+}
+//#endregion
+//#region packages/core/src/worker/resource-debug.ts
+var W = 1e3;
+async function ke(e, t) {
+	e.observeUsage(await t(W));
+	let n = e.current();
+	if (!n) throw Error("OOXML resource metrics are not ready");
+	return n;
+}
+var Ae = class {
+	now;
+	startedAt;
+	policy;
+	checkpoints = [];
+	sourceBytes;
+	lastUsage;
+	mode;
+	finished = !1;
+	terminalStatus;
+	terminalError;
+	terminalOutcome;
+	terminalElapsedMs;
+	constructor(e) {
+		this.options = e, this.now = e.now ?? Me, this.startedAt = this.now(), this.policy = Object.freeze({
+			maxArchiveEntryBytes: e.policy.maxArchiveEntryBytes,
+			maxTotalInflatedBytes: e.policy.maxTotalInflatedBytes
+		}), this.mode = e.mode;
+	}
+	setMode(e) {
+		!this.options.enabled || this.finished || (this.mode = e);
+	}
+	setSourceBytes(e) {
+		this.options.enabled && (!Number.isSafeInteger(e) || e < 0 || (this.sourceBytes = e));
+	}
+	checkpoint(e, t) {
+		if (!this.options.enabled || this.finished) return;
+		t && (this.lastUsage = K(t));
+		let n = this.lastUsage;
+		this.checkpoints.push(Object.freeze({
+			name: Pe(e),
+			elapsedMs: q(this.startedAt, this.now()),
+			...n ? { usage: n } : {}
+		}));
+	}
+	observeUsage(e) {
+		!this.options.enabled || !e || (this.lastUsage = K(e));
+	}
+	current() {
+		if (!(!this.options.enabled || !this.terminalStatus)) return this.report(this.terminalStatus, this.terminalError, this.terminalOutcome);
+	}
+	succeed(e) {
+		return this.finish("ok", void 0, e);
+	}
+	fail(e) {
+		return this.finish("error", e);
+	}
+	finish(e, t, n) {
+		if (!this.options.enabled || this.finished) return;
+		this.finished = !0, this.terminalStatus = e, this.terminalError = t, this.terminalOutcome = n, this.terminalElapsedMs = q(this.startedAt, this.now());
+		let r = this.report(e, t, n);
+		return this.options.onMetrics && G(this.options.onMetrics, r), (this.options.emitToConsole ?? this.options.onMetrics === void 0) && G(De, r), r;
+	}
+	report(e, t, n) {
+		let r = Ne(t) ?? this.lastUsage;
+		return Object.freeze({
+			schemaVersion: 1,
+			scope: this.options.scope ?? "load",
+			format: this.options.format,
+			mode: this.mode,
+			status: e,
+			...this.sourceBytes === void 0 ? {} : { sourceBytes: this.sourceBytes },
+			elapsedMs: this.terminalElapsedMs ?? q(this.startedAt, this.now()),
+			policy: this.policy,
+			...r ? { usage: r } : {},
+			checkpoints: Object.freeze([...this.checkpoints]),
+			...n ? { outcome: Fe(n) } : {},
+			...e === "error" ? { error: J(t) } : {}
+		});
+	}
+};
+function G(e, t) {
+	try {
+		let n = e(t);
+		je(n) && Promise.resolve(n).catch(() => void 0);
+	} catch {}
+}
+function je(e) {
+	return (typeof e == "object" && !!e || typeof e == "function") && typeof e.then == "function";
+}
+function Me() {
+	return typeof performance > "u" ? Date.now() : performance.now();
+}
+function K(e) {
+	return Object.freeze({
+		archiveEntryCount: e.archiveEntryCount,
+		declaredInflatedBytes: e.declaredInflatedBytes,
+		...e.largestInflatedEntryBytes === void 0 ? {} : { largestInflatedEntryBytes: e.largestInflatedEntryBytes },
+		distinctInflatedBytes: e.distinctInflatedBytes,
+		operationInflatedBytes: e.operationInflatedBytes
+	});
+}
+function Ne(e) {
+	try {
+		return e instanceof n ? K(e.details.violation.usage) : void 0;
+	} catch {
+		return;
+	}
+}
+function q(e, t) {
+	return Math.max(0, Math.round((t - e) * 10) / 10);
+}
+function Pe(e) {
+	return e.replace(/[^a-z0-9 -]/giu, "").trim().slice(0, 32) || "checkpoint";
+}
+function Fe(e) {
+	return Object.freeze(Object.fromEntries(Object.entries(e).filter(([e, t]) => /^[a-z][a-z0-9-]{0,31}$/u.test(e) && Number.isSafeInteger(t) && t >= 0)));
+}
+function J(r) {
+	try {
+		if (r instanceof n) {
+			let e = r.details.violation;
+			return Object.freeze({
+				code: r.code,
+				stage: r.details.stage,
+				resource: e.resource,
+				metric: e.metric
+			});
+		}
+		if (r instanceof t || r instanceof e) return Object.freeze({ code: r.code });
+		if (r instanceof o || typeof r == "object" && r && r.code === "parser-crashed") return Object.freeze({ code: "parser-crashed" });
+	} catch {}
+	return Object.freeze({});
+}
+var Y = "ooxml-pull-v1";
+function X(e, t) {
+	if (!Number.isSafeInteger(e) || e <= 0) throw RangeError(`${t} must be a positive safe integer`);
+}
+function Z(e) {
+	if (!(typeof e == "string" && e.length > 0 || typeof e == "number" && Number.isSafeInteger(e) && e > 0)) throw RangeError("session id must be a non-empty string or positive safe integer");
+}
+var Ie = class {
+	bridge;
+	options;
+	sequence = 0;
+	pulling = !1;
+	outstanding = !1;
+	ending = !1;
+	completed = !1;
+	lifecyclePromise;
+	usage;
+	orphanedRequestIds = /* @__PURE__ */ new Set();
+	transferDisposers = /* @__PURE__ */ new Set();
+	constructor(e, t) {
+		Z(t.sessionId), X(t.operationId, "operation id"), X(t.generation, "generation"), X(t.maxByteCredit, "max byte credit"), t.cancelGraceMs !== void 0 && X(t.cancelGraceMs, "cancel grace"), this.bridge = e, this.options = t;
+	}
+	async pull(e, t) {
+		if (this.validateCredit(e), this.ending || this.completed) throw Error("pull session is closed");
+		if (this.pulling) throw Error("a pull request is already in flight");
+		if (this.outstanding) throw Error("acknowledge the current chunk before the next pull");
+		this.pulling = !0;
+		let n = this.sequence;
+		try {
+			let r = await this.request((t) => ({
+				protocol: Y,
+				kind: "pull",
+				...this.identity(),
+				requestId: t,
+				sequence: n,
+				byteCredit: e
+			}), t);
+			if (this.validateResponseIdentity(r), r.usage && (this.usage = r.usage), r.kind === "error") throw T(r.error);
+			if (r.kind !== "chunk") throw Error(`expected chunk response, received ${r.kind}`);
+			if (this.ending) throw this.disposePayload(r.payload), Error("pull session is closed");
+			try {
+				this.validateChunk(r, n, e);
+			} catch (e) {
+				throw this.disposePayload(r.payload), e;
+			}
+			return this.outstanding = !0, this.makeChunk(r);
+		} catch (e) {
+			throw !p(e) && !this.ending && !this.completed && this.cancel("protocol-error").catch(() => void 0), e;
+		} finally {
+			this.pulling = !1;
+		}
+	}
+	cancel(e = "closed", t) {
+		return this.lifecyclePromise ? this.lifecyclePromise : (this.ending = !0, this.disposeAllTransferred(), this.lifecyclePromise = this.lifecycleControl(this.control("cancel", t, (t) => ({
+			protocol: Y,
+			kind: "cancel",
+			...this.identity(),
+			requestId: t,
+			reason: e
+		}))), this.lifecyclePromise);
+	}
+	close(e) {
+		return this.lifecyclePromise ? this.lifecyclePromise : (this.ending = !0, this.disposeAllTransferred(), this.lifecyclePromise = this.lifecycleControl(this.control("close", e, (e) => ({
+			protocol: Y,
+			kind: "close",
+			...this.identity(),
+			requestId: e
+		}))), this.lifecyclePromise);
+	}
+	get usageCheckpoint() {
+		return this.usage;
+	}
+	makeChunk(e) {
+		let t = !1, n, r, i = () => {
+			t || (t = !0, this.transferDisposers.delete(i), this.disposePayload(e.payload));
+		};
+		return this.transferDisposers.add(i), {
+			done: e.done,
+			sequence: e.sequence,
+			byteLength: e.byteLength,
+			payload: e.payload,
+			leaseId: e.leaseId,
+			usage: e.usage,
+			disposeTransferred: i,
+			ack: (t) => n || (this.ending ? Promise.resolve() : (n = this.control("ack", t, (t) => ({
+				protocol: Y,
+				kind: "ack",
+				...this.identity(),
+				requestId: t,
+				sequence: e.sequence
+			})).then(() => {
+				this.outstanding = !1, this.sequence++, e.done && (this.completed = !0);
+			}).catch((e) => {
+				throw this.ending || this.cancel("request-error").catch(() => void 0), e;
+			}), n)),
+			release: (t) => r || (e.leaseId === void 0 || this.ending ? Promise.resolve() : (r = this.control("release", t, (t) => ({
+				protocol: Y,
+				kind: "release",
+				...this.identity(),
+				requestId: t,
+				leaseId: e.leaseId
+			})).catch((e) => {
+				throw this.ending || this.cancel("request-error").catch(() => void 0), e;
+			}), r))
+		};
+	}
+	async control(e, t, n) {
+		let r = await this.request(n, t, e !== "cancel" && e !== "close");
+		if (this.validateResponseIdentity(r), r.usage && (this.usage = r.usage), r.kind === "error") {
+			if (r.error.code === "ooxml-stale-lifecycle" && (e === "cancel" || e === "close")) {
+				this.forgetLifecycleOrphans();
+				return;
+			}
+			throw T(r.error);
+		}
+		if (r.kind !== "accepted" || r.command !== e) throw Error(`expected ${e} acceptance`);
+		(e === "cancel" || e === "close") && this.forgetLifecycleOrphans();
+	}
+	request(e, t, n = !0) {
+		return this.bridge.request(e, void 0, {
+			timeoutMs: n ? t?.timeoutMs ?? this.options.timeoutMs : !1,
+			signal: t?.signal,
+			onOrphanedResponse: (e) => {
+				e.kind === "chunk" && this.disposePayload(e.payload);
+			},
+			onCancel: (e, n) => {
+				this.orphanedRequestIds.add(e);
+				try {
+					t?.onCancel?.(e, n);
+				} finally {
+					!this.ending && !this.completed && this.cancel(n).catch(() => void 0);
+				}
+			}
+		});
+	}
+	identity() {
+		return {
+			sessionId: this.options.sessionId,
+			operationId: this.options.operationId,
+			generation: this.options.generation
+		};
+	}
+	validateResponseIdentity(e) {
+		if (e.protocol !== "ooxml-pull-v1" || e.sessionId !== this.options.sessionId || e.operationId !== this.options.operationId || e.generation !== this.options.generation) throw e.kind === "chunk" && this.disposePayload(e.payload), Error("stale or mismatched pull session response");
+	}
+	validateCredit(e) {
+		if (X(e, "byte credit"), e > this.options.maxByteCredit) throw RangeError(`byte credit exceeds session maximum ${this.options.maxByteCredit}`);
+	}
+	validateChunk(e, t, n) {
+		if (e.sequence !== t) throw Error("pull response sequence mismatch");
+		if (!Number.isSafeInteger(e.byteLength) || e.byteLength < 0) throw RangeError("chunk byte length must be a non-negative safe integer");
+		if (e.byteLength > n) throw RangeError("chunk exceeds byte credit");
+		e.leaseId !== void 0 && X(e.leaseId, "lease id");
+	}
+	disposeAllTransferred() {
+		for (let e of [...this.transferDisposers]) e();
+	}
+	lifecycleControl(e) {
+		let t = this.options.cancelGraceMs ?? 1e3, n, r = new Promise((e, r) => {
+			n = setTimeout(() => {
+				this.bridge.terminate(), r(/* @__PURE__ */ Error(`worker did not accept lifecycle command within ${t}ms`));
+			}, t);
+		});
+		return Promise.race([e, r]).catch((e) => {
+			throw this.bridge.terminate(), e;
+		}).finally(() => {
+			n !== void 0 && clearTimeout(n);
+		});
+	}
+	forgetLifecycleOrphans() {
+		this.bridge.forgetOrphaned(this.orphanedRequestIds), this.orphanedRequestIds.clear();
+	}
+	disposePayload(e) {
+		try {
+			this.options.disposeTransferred?.(e);
+		} catch {}
+	}
+}, Le = class {
+	owner;
+	queue = Promise.resolve();
+	leases = /* @__PURE__ */ new Map();
+	retainedBytes = 0;
+	retainedCount = 0;
+	maxRetainedBytes;
+	maxRetainedCount;
+	cleanups = /* @__PURE__ */ new Set();
+	pendingFatalCleanups = [];
+	poisonRunning = !1;
+	fatal;
+	constructor(e) {
+		this.maxRetainedBytes = e?.maxRetainedBytes ?? 64 * 1024 * 1024, this.maxRetainedCount = e?.maxRetainedCount ?? 256, X(this.maxRetainedBytes, "max retained lease bytes"), X(this.maxRetainedCount, "max retained lease count");
+	}
+	enqueue(e) {
+		let t = this.queue.then(e, e);
+		return this.queue = t.then(() => void 0, () => void 0), t;
+	}
+	acquire(e) {
+		return this.owner === void 0 ? (this.owner = e, !0) : this.owner === e;
+	}
+	release(e) {
+		this.owner === e && (this.owner = void 0);
+	}
+	retainLease(e, t, n) {
+		if (!Number.isSafeInteger(n) || n < 0) throw RangeError("retained lease bytes are invalid");
+		let r = this.leases.get(e) ?? /* @__PURE__ */ new Map();
+		if (r.has(t)) throw Error("driver returned a duplicate lease id");
+		if (this.retainedCount + 1 > this.maxRetainedCount) throw RangeError("retained lease count exceeds limit");
+		if (this.retainedBytes + n > this.maxRetainedBytes) throw RangeError("retained lease bytes exceed limit");
+		r.set(t, n), this.leases.set(e, r), this.retainedCount++, this.retainedBytes += n;
+	}
+	releaseLease(e, t) {
+		let n = this.leases.get(e), r = n?.get(t);
+		r !== void 0 && (n?.delete(t), n?.size === 0 && this.leases.delete(e), this.retainedCount--, this.retainedBytes -= r);
+	}
+	registerCleanup(e) {
+		return this.fatal ? (this.poisonRunning ? this.pendingFatalCleanups.push(e) : this.enqueue(e).catch(() => void 0), () => void 0) : (this.cleanups.add(e), () => this.cleanups.delete(e));
+	}
+	get fatalError() {
+		return this.fatal;
+	}
+	get registeredHostCount() {
+		return this.cleanups.size;
+	}
+	async poison(e) {
+		if (this.fatal ??= e, this.poisonRunning) return this.fatal;
+		this.poisonRunning = !0, this.pendingFatalCleanups.push(...this.cleanups);
+		try {
+			let e;
+			for (; (e = this.pendingFatalCleanups.shift()) !== void 0;) await e().catch(() => void 0);
+		} finally {
+			this.poisonRunning = !1;
+		}
+		return this.fatal;
+	}
+}, Re = class {
+	options;
+	coordinator;
+	coordinatorOwner = Symbol("pull-session-host");
+	unregisterCleanup;
+	sequence = 0;
+	unacked;
+	leases = /* @__PURE__ */ new Map();
+	activeDriverLeases = /* @__PURE__ */ new Set();
+	nextWireLeaseId;
+	cancelRequested = !1;
+	cancelComplete = !1;
+	closeRequested = !1;
+	closeComplete = !1;
+	driverCancelComplete = !1;
+	driverCloseComplete = !1;
+	completed = !1;
+	constructor(e) {
+		Z(e.sessionId), X(e.operationId, "operation id"), X(e.generation, "generation"), X(e.maxByteCredit, "max byte credit"), e.wireLeaseIdStart !== void 0 && X(e.wireLeaseIdStart, "wire lease id start"), this.options = e, this.coordinator = e.coordinator, this.nextWireLeaseId = e.wireLeaseIdStart ?? 1, this.unregisterCleanup = this.coordinator.registerCleanup(() => this.forceFatalCleanup());
+	}
+	dispatch(e, t) {
+		return this.coordinator.enqueue(async () => {
+			let n = await this.execute(e);
+			try {
+				t(n.response, n.transfer);
+			} catch (e) {
+				throw await this.rollbackFailedPost(n), e;
+			}
+		});
+	}
+	async rollbackFailedPost(e) {
+		let t = e.response;
+		if (t.kind === "chunk") {
+			let n = t.leaseId === void 0 ? void 0 : this.leases.get(t.leaseId);
+			try {
+				await this.options.driver.disposeInvalidChunk?.({
+					payload: t.payload,
+					byteLength: t.byteLength,
+					done: t.done,
+					leaseId: n?.driverLeaseId,
+					retainedBytes: n?.retainedBytes,
+					transfer: e.transfer
+				});
+			} catch {}
+		}
+		this.unacked = void 0, this.coordinator.release(this.coordinatorOwner);
+		for (let [e, t] of [...this.leases]) try {
+			await this.options.driver.releaseLease?.(t.driverLeaseId);
+		} catch {} finally {
+			this.leases.delete(e), this.activeDriverLeases.delete(t.driverLeaseId), this.coordinator.releaseLease(this.coordinatorOwner, e);
+		}
+		if (this.cancelRequested = !0, !this.driverCancelComplete) try {
+			await this.options.driver.cancel?.(), this.driverCancelComplete = !0;
+		} catch {}
+		this.unregisterCleanup();
+	}
+	async execute(e) {
+		try {
+			if (this.isStaleLifecycle(e)) {
+				let t = e.kind === "cancel" ? "cancel" : "close";
+				return this.sameOperationIdentity(e) ? { response: this.accepted(e, t, !0) } : { response: this.errorResponse(e, {
+					message: "stale lifecycle targets another session or operation",
+					errorName: "PullSessionProtocolError",
+					code: "ooxml-stale-lifecycle"
+				}) };
+			}
+			this.validateCommandIdentity(e);
+			let t = this.coordinator.fatalError;
+			if (t) return e.kind === "pull" ? { response: this.errorResponse(e, t) } : (e.kind === "cancel" ? await this.cancel() : e.kind === "close" ? await this.close() : e.kind === "release" && await this.release(e.leaseId), { response: this.accepted(e, e.kind) });
+			switch (e.kind) {
+				case "pull": return await this.pull(e);
+				case "ack": return await this.ack(e.sequence), { response: this.accepted(e, "ack") };
+				case "release": return await this.release(e.leaseId), { response: this.accepted(e, "release") };
+				case "cancel": return await this.cancel(), { response: this.accepted(e, "cancel") };
+				case "close": return await this.close(), { response: this.accepted(e, "close") };
+			}
+		} catch (t) {
+			let n = w(t);
+			return n.code === "ooxml-resource-limit" && (n = await this.coordinator.poison(n)), { response: this.errorResponse(e, n) };
+		}
+	}
+	async pull(e) {
+		if (this.closeRequested || this.cancelRequested || this.completed) throw Error("pull session is closed");
+		if (this.unacked) throw Error("previous chunk is not acknowledged");
+		if (!Number.isSafeInteger(e.sequence) || e.sequence < 0 || e.sequence !== this.sequence) throw Error("pull command sequence mismatch");
+		if (this.validateHostCredit(e.byteCredit), !this.coordinator.acquire(this.coordinatorOwner)) throw Error("another operation has an unacknowledged package chunk");
+		let t;
+		try {
+			t = await this.options.driver.pull(e.byteCredit);
+		} catch (e) {
+			throw this.coordinator.release(this.coordinatorOwner), e;
+		}
+		let n = !1, r = !1, i, a;
+		try {
+			let o = this.options.driver.measureChunk(t), s = this.arrayBufferTransferBytes(t.transfer);
+			if (o < s) throw RangeError("measured chunk bytes are below ArrayBuffer transfer bytes");
+			if (a = Math.max(o, s), t.leaseId !== void 0) {
+				if (X(t.leaseId, "lease id"), t.retainedBytes === void 0) throw Error("retained lease bytes are required");
+				if (this.activeDriverLeases.has(t.leaseId)) throw r = !0, Error("driver returned an active duplicate lease id");
+				i = this.allocateWireLeaseId(), this.coordinator.retainLease(this.coordinatorOwner, i, t.retainedBytes), this.leases.set(i, {
+					driverLeaseId: t.leaseId,
+					retainedBytes: t.retainedBytes
+				}), this.activeDriverLeases.add(t.leaseId), n = !0;
+			} else if (t.retainedBytes !== void 0) throw Error("retained lease bytes require a lease id");
+			if (!Number.isSafeInteger(a) || a < 0) throw RangeError("host chunk byte length must be a non-negative safe integer");
+			if (a > e.byteCredit) throw RangeError("host chunk exceeds byte credit");
+		} catch (e) {
+			let a;
+			try {
+				await this.options.driver.disposeInvalidChunk?.(t);
+			} catch (e) {
+				a = e;
+			}
+			if (n && i !== void 0) try {
+				await this.release(i);
+			} catch (e) {
+				a ??= e;
+			}
+			else if (t.leaseId !== void 0 && !r) try {
+				await this.options.driver.releaseLease?.(t.leaseId);
+			} catch (e) {
+				a ??= e;
+			}
+			if (r) try {
+				await this.cancel();
+			} catch (e) {
+				a ??= e;
+			}
+			throw this.coordinator.release(this.coordinatorOwner), a || e;
+		}
+		return this.unacked = {
+			sequence: this.sequence,
+			done: t.done
+		}, {
+			response: {
+				kind: "chunk",
+				protocol: Y,
+				...this.identity(),
+				requestId: e.requestId,
+				sequence: this.sequence,
+				byteLength: a,
+				done: t.done,
+				payload: t.payload,
+				leaseId: i,
+				usage: this.resourceUsage()
+			},
+			transfer: t.transfer
+		};
+	}
+	async ack(e) {
+		if (!Number.isSafeInteger(e) || e < 0) throw RangeError("invalid ack sequence");
+		if (e < this.sequence) return;
+		if (!this.unacked || e !== this.sequence) throw Error("ack sequence mismatch");
+		let t = this.unacked.done;
+		await this.options.driver.acknowledge?.(e), this.unacked = void 0, this.coordinator.release(this.coordinatorOwner), this.sequence++, t && (this.completed = !0, this.maybeUnregisterCompleted());
+	}
+	async release(e) {
+		X(e, "wire lease id");
+		let t = this.leases.get(e);
+		t && (await this.options.driver.releaseLease?.(t.driverLeaseId), this.leases.delete(e), this.activeDriverLeases.delete(t.driverLeaseId), this.coordinator.releaseLease(this.coordinatorOwner, e), this.maybeUnregisterCompleted());
+	}
+	async cancel() {
+		if (this.cancelComplete) return;
+		this.cancelRequested = !0, this.unacked = void 0, this.coordinator.release(this.coordinatorOwner);
+		let e;
+		try {
+			await this.releaseAllLeases();
+		} catch (t) {
+			e = t;
+		}
+		if (!this.driverCancelComplete) try {
+			await this.options.driver.cancel?.(), this.driverCancelComplete = !0;
+		} catch (t) {
+			e ??= t;
+		}
+		if (e) throw e;
+		this.cancelComplete = !0, this.unregisterCleanup();
+	}
+	async close() {
+		if (this.closeComplete) return;
+		this.closeRequested = !0, this.unacked = void 0, this.coordinator.release(this.coordinatorOwner);
+		let e;
+		try {
+			await this.releaseAllLeases();
+		} catch (t) {
+			e = t;
+		}
+		if (!this.driverCloseComplete) try {
+			await this.options.driver.close?.(), this.driverCloseComplete = !0;
+		} catch (t) {
+			e ??= t;
+		}
+		if (e) throw e;
+		this.closeComplete = !0, this.unregisterCleanup();
+	}
+	async releaseAllLeases() {
+		let e;
+		for (let t of [...this.leases.keys()]) try {
+			await this.release(t);
+		} catch (t) {
+			e ??= t;
+		}
+		if (e) throw e;
+	}
+	validateCommandIdentity(e) {
+		if (e.protocol !== "ooxml-pull-v1" || e.sessionId !== this.options.sessionId || e.operationId !== this.options.operationId || e.generation !== this.options.generation || !Number.isSafeInteger(e.requestId) || e.requestId <= 0) throw Error("stale or mismatched pull session command");
+	}
+	validateHostCredit(e) {
+		if (X(e, "byte credit"), e > this.options.maxByteCredit) throw RangeError("byte credit exceeds host maximum");
+	}
+	accepted(e, t, n = !1) {
+		return {
+			kind: "accepted",
+			protocol: Y,
+			...n ? {
+				sessionId: e.sessionId,
+				operationId: e.operationId,
+				generation: e.generation
+			} : this.identity(),
+			requestId: e.requestId,
+			command: t,
+			usage: this.resourceUsage()
+		};
+	}
+	identity() {
+		return {
+			sessionId: this.options.sessionId,
+			operationId: this.options.operationId,
+			generation: this.options.generation
+		};
+	}
+	isStaleLifecycle(e) {
+		return (e.kind === "cancel" || e.kind === "close") && e.protocol === "ooxml-pull-v1" && Number.isSafeInteger(e.requestId) && e.requestId > 0 && Number.isSafeInteger(e.generation) && e.generation > 0 && e.generation < this.options.generation;
+	}
+	sameOperationIdentity(e) {
+		return e.sessionId === this.options.sessionId && e.operationId === this.options.operationId;
+	}
+	errorResponse(e, t) {
+		return {
+			kind: "error",
+			protocol: Y,
+			sessionId: e.sessionId,
+			operationId: e.operationId,
+			generation: e.generation,
+			requestId: e.requestId,
+			error: t,
+			usage: this.errorResourceUsage()
+		};
+	}
+	async forceFatalCleanup() {
+		this.cancelRequested = !0, this.unacked = void 0, this.coordinator.release(this.coordinatorOwner);
+		let e;
+		for (let t of [...this.leases.keys()]) try {
+			await this.release(t);
+		} catch (t) {
+			e ??= t;
+		}
+		if (!this.driverCancelComplete) try {
+			await this.options.driver.cancel?.(), this.driverCancelComplete = !0;
+		} catch (t) {
+			e ??= t;
+		}
+		if (e) throw e;
+		this.unregisterCleanup();
+	}
+	allocateWireLeaseId() {
+		if (!Number.isSafeInteger(this.nextWireLeaseId) || this.nextWireLeaseId <= 0) throw RangeError("wire lease id space exhausted");
+		return this.nextWireLeaseId++;
+	}
+	arrayBufferTransferBytes(e) {
+		let t = 0;
+		for (let n of e ?? []) if (n instanceof ArrayBuffer && (t += n.byteLength, !Number.isSafeInteger(t))) throw RangeError("ArrayBuffer transfer bytes overflow");
+		return t;
+	}
+	maybeUnregisterCompleted() {
+		this.completed && this.leases.size === 0 && this.unregisterCleanup();
+	}
+	resourceUsage() {
+		return this.options.driver.resourceUsage?.();
+	}
+	errorResourceUsage() {
+		try {
+			return this.resourceUsage();
+		} catch {
+			return;
+		}
+	}
+};
+//#endregion
+//#region packages/core/src/internal/bounded-async-lru-cache.ts
+function Q(e, t) {
+	if (!Number.isSafeInteger(e) || e <= 0) throw TypeError(`${t} must be a positive safe integer`);
+}
+function ze(e) {
+	if (!Number.isSafeInteger(e) || e < 0) throw TypeError("cache entry weight must be a non-negative safe integer");
+}
+var $ = class {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i = /* @__PURE__ */ new Map();
+	#a = /* @__PURE__ */ new Map();
+	#o = 0;
+	constructor(e) {
+		Q(e.maxEntries, "maxEntries"), Q(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), ze(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 {}
+	}
+}, Be = class {
+	#e;
+	constructor(e) {
+		this.#e = new $({
+			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 { te as A, j as C, C as D, T as E, t as M, n as N, w as O, A as S, ie as T, D as _, Re as a, M as b, Ae as c, L as d, Se as f, ye as g, E as h, Y as i, a as j, ee as k, ke as l, ve as m, $ as n, Le as o, _e as p, Ie as r, W as s, Be as t, xe as u, P as v, O as w, k as x, N as y };